mirror of
https://github.com/RGBCube/serenity
synced 2025-05-14 20:04:59 +00:00
Kernel/Ext2FS: Use TRY() in the Ext2FS
This class was just *full* of great opportunities for TRY(). :^)
This commit is contained in:
Andreas Kling
parent
83fed5b2de
commit
865eb54f75
1 changed files with 58 additions and 125 deletions
|
|
@ -119,8 +119,7 @@ KResult Ext2FS::initialize()
|
|||
set_fragment_size(EXT2_FRAG_SIZE(&super_block));
|
||||
|
||||
// Note: This depends on the block size being available.
|
||||
if (auto result = BlockBasedFileSystem::initialize(); result.is_error())
|
||||
return result;
|
||||
TRY(BlockBasedFileSystem::initialize());
|
||||
|
||||
VERIFY(block_size() <= (int)max_block_size);
|
||||
|
||||
|
|
@ -139,10 +138,7 @@ KResult Ext2FS::initialize()
|
|||
return ENOMEM;
|
||||
}
|
||||
auto buffer = UserOrKernelBuffer::for_kernel_buffer(m_cached_group_descriptor_table->data());
|
||||
if (auto result = read_blocks(first_block_of_bgdt, blocks_to_read, buffer); result.is_error()) {
|
||||
dbgln("Ext2FS: initialize had error: {}", result.error());
|
||||
return result;
|
||||
}
|
||||
TRY(read_blocks(first_block_of_bgdt, blocks_to_read, buffer));
|
||||
|
||||
if constexpr (EXT2_DEBUG) {
|
||||
for (unsigned i = 1; i <= m_block_group_count; ++i) {
|
||||
|
|
@ -250,8 +246,7 @@ KResult Ext2FSInode::grow_doubly_indirect_block(BlockBasedFileSystem::BlockIndex
|
|||
auto buffer = UserOrKernelBuffer::for_kernel_buffer(stream.data());
|
||||
|
||||
if (old_blocks_length > 0) {
|
||||
if (auto result = fs().read_block(block, &buffer, fs().block_size()); result.is_error())
|
||||
return result;
|
||||
TRY(fs().read_block(block, &buffer, fs().block_size()));
|
||||
}
|
||||
|
||||
// Grow the doubly indirect block.
|
||||
|
|
@ -268,8 +263,7 @@ KResult Ext2FSInode::grow_doubly_indirect_block(BlockBasedFileSystem::BlockIndex
|
|||
// Write out the indirect blocks.
|
||||
for (unsigned i = old_blocks_length / entries_per_block; i < new_indirect_blocks_length; i++) {
|
||||
const auto offset_block = i * entries_per_block;
|
||||
if (auto result = write_indirect_block(block_as_pointers[i], blocks_indices.slice(offset_block, min(blocks_indices.size() - offset_block, entries_per_block))); result.is_error())
|
||||
return result;
|
||||
TRY(write_indirect_block(block_as_pointers[i], blocks_indices.slice(offset_block, min(blocks_indices.size() - offset_block, entries_per_block))));
|
||||
}
|
||||
|
||||
// Write out the doubly indirect block.
|
||||
|
|
@ -289,22 +283,19 @@ KResult Ext2FSInode::shrink_doubly_indirect_block(BlockBasedFileSystem::BlockInd
|
|||
auto block_contents = ByteBuffer::create_uninitialized(fs().block_size());
|
||||
auto* block_as_pointers = (unsigned*)block_contents.data();
|
||||
auto buffer = UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<u8*>(block_as_pointers));
|
||||
if (auto result = fs().read_block(block, &buffer, fs().block_size()); result.is_error())
|
||||
return result;
|
||||
TRY(fs().read_block(block, &buffer, fs().block_size()));
|
||||
|
||||
// Free the unused indirect blocks.
|
||||
for (unsigned i = new_indirect_blocks_length; i < old_indirect_blocks_length; i++) {
|
||||
dbgln_if(EXT2_BLOCKLIST_DEBUG, "Ext2FSInode[{}]::shrink_doubly_indirect_block(): Freeing indirect block {} at index {}", identifier(), block_as_pointers[i], i);
|
||||
if (auto result = fs().set_block_allocation_state(block_as_pointers[i], false); result.is_error())
|
||||
return result;
|
||||
TRY(fs().set_block_allocation_state(block_as_pointers[i], false));
|
||||
meta_blocks--;
|
||||
}
|
||||
|
||||
// Free the doubly indirect block if no longer needed.
|
||||
if (new_blocks_length == 0) {
|
||||
dbgln_if(EXT2_BLOCKLIST_DEBUG, "Ext2FSInode[{}]::shrink_doubly_indirect_block(): Freeing doubly indirect block {}", identifier(), block);
|
||||
if (auto result = fs().set_block_allocation_state(block, false); result.is_error())
|
||||
return result;
|
||||
TRY(fs().set_block_allocation_state(block, false));
|
||||
meta_blocks--;
|
||||
}
|
||||
|
||||
|
|
@ -328,8 +319,7 @@ KResult Ext2FSInode::grow_triply_indirect_block(BlockBasedFileSystem::BlockIndex
|
|||
auto buffer = UserOrKernelBuffer::for_kernel_buffer(stream.data());
|
||||
|
||||
if (old_blocks_length > 0) {
|
||||
if (auto result = fs().read_block(block, &buffer, fs().block_size()); result.is_error())
|
||||
return result;
|
||||
TRY(fs().read_block(block, &buffer, fs().block_size()));
|
||||
}
|
||||
|
||||
// Grow the triply indirect block.
|
||||
|
|
@ -348,8 +338,7 @@ KResult Ext2FSInode::grow_triply_indirect_block(BlockBasedFileSystem::BlockIndex
|
|||
const auto processed_blocks = i * entries_per_doubly_indirect_block;
|
||||
const auto old_doubly_indirect_blocks_length = min(old_blocks_length > processed_blocks ? old_blocks_length - processed_blocks : 0, entries_per_doubly_indirect_block);
|
||||
const auto new_doubly_indirect_blocks_length = min(blocks_indices.size() > processed_blocks ? blocks_indices.size() - processed_blocks : 0, entries_per_doubly_indirect_block);
|
||||
if (auto result = grow_doubly_indirect_block(block_as_pointers[i], old_doubly_indirect_blocks_length, blocks_indices.slice(processed_blocks, new_doubly_indirect_blocks_length), new_meta_blocks, meta_blocks); result.is_error())
|
||||
return result;
|
||||
TRY(grow_doubly_indirect_block(block_as_pointers[i], old_doubly_indirect_blocks_length, blocks_indices.slice(processed_blocks, new_doubly_indirect_blocks_length), new_meta_blocks, meta_blocks));
|
||||
}
|
||||
|
||||
// Write out the triply indirect block.
|
||||
|
|
@ -370,8 +359,7 @@ KResult Ext2FSInode::shrink_triply_indirect_block(BlockBasedFileSystem::BlockInd
|
|||
auto block_contents = ByteBuffer::create_uninitialized(fs().block_size());
|
||||
auto* block_as_pointers = (unsigned*)block_contents.data();
|
||||
auto buffer = UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<u8*>(block_as_pointers));
|
||||
if (auto result = fs().read_block(block, &buffer, fs().block_size()); result.is_error())
|
||||
return result;
|
||||
TRY(fs().read_block(block, &buffer, fs().block_size()));
|
||||
|
||||
// Shrink the doubly indirect blocks.
|
||||
for (unsigned i = new_triply_indirect_blocks_length; i < old_triply_indirect_blocks_length; i++) {
|
||||
|
|
@ -379,15 +367,13 @@ KResult Ext2FSInode::shrink_triply_indirect_block(BlockBasedFileSystem::BlockInd
|
|||
const auto old_doubly_indirect_blocks_length = min(old_blocks_length > processed_blocks ? old_blocks_length - processed_blocks : 0, entries_per_doubly_indirect_block);
|
||||
const auto new_doubly_indirect_blocks_length = min(new_blocks_length > processed_blocks ? new_blocks_length - processed_blocks : 0, entries_per_doubly_indirect_block);
|
||||
dbgln_if(EXT2_BLOCKLIST_DEBUG, "Ext2FSInode[{}]::shrink_triply_indirect_block(): Shrinking doubly indirect block {} at index {}", identifier(), block_as_pointers[i], i);
|
||||
if (auto result = shrink_doubly_indirect_block(block_as_pointers[i], old_doubly_indirect_blocks_length, new_doubly_indirect_blocks_length, meta_blocks); result.is_error())
|
||||
return result;
|
||||
TRY(shrink_doubly_indirect_block(block_as_pointers[i], old_doubly_indirect_blocks_length, new_doubly_indirect_blocks_length, meta_blocks));
|
||||
}
|
||||
|
||||
// Free the triply indirect block if no longer needed.
|
||||
if (new_blocks_length == 0) {
|
||||
dbgln_if(EXT2_BLOCKLIST_DEBUG, "Ext2FSInode[{}]::shrink_triply_indirect_block(): Freeing triply indirect block {}", identifier(), block);
|
||||
if (auto result = fs().set_block_allocation_state(block, false); result.is_error())
|
||||
return result;
|
||||
TRY(fs().set_block_allocation_state(block, false));
|
||||
meta_blocks--;
|
||||
}
|
||||
|
||||
|
|
@ -413,10 +399,7 @@ KResult Ext2FSInode::flush_block_list()
|
|||
|
||||
Vector<Ext2FS::BlockIndex> new_meta_blocks;
|
||||
if (new_shape.meta_blocks > old_shape.meta_blocks) {
|
||||
auto blocks_or_error = fs().allocate_blocks(fs().group_index_from_inode(index()), new_shape.meta_blocks - old_shape.meta_blocks);
|
||||
if (blocks_or_error.is_error())
|
||||
return blocks_or_error.error();
|
||||
new_meta_blocks = blocks_or_error.release_value();
|
||||
new_meta_blocks = TRY(fs().allocate_blocks(fs().group_index_from_inode(index()), new_shape.meta_blocks - old_shape.meta_blocks));
|
||||
}
|
||||
|
||||
m_raw_inode.i_blocks = (m_block_list.size() + new_shape.meta_blocks) * (fs().block_size() / 512);
|
||||
|
|
@ -465,12 +448,10 @@ KResult Ext2FSInode::flush_block_list()
|
|||
old_shape.meta_blocks++;
|
||||
}
|
||||
|
||||
if (auto result = write_indirect_block(m_raw_inode.i_block[EXT2_IND_BLOCK], m_block_list.span().slice(output_block_index, new_shape.indirect_blocks)); result.is_error())
|
||||
return result;
|
||||
TRY(write_indirect_block(m_raw_inode.i_block[EXT2_IND_BLOCK], m_block_list.span().slice(output_block_index, new_shape.indirect_blocks)));
|
||||
} else if ((new_shape.indirect_blocks == 0) && (old_shape.indirect_blocks != 0)) {
|
||||
dbgln_if(EXT2_BLOCKLIST_DEBUG, "Ext2FSInode[{}]::flush_block_list(): Freeing indirect block: {}", identifier(), m_raw_inode.i_block[EXT2_IND_BLOCK]);
|
||||
if (auto result = fs().set_block_allocation_state(m_raw_inode.i_block[EXT2_IND_BLOCK], false); result.is_error())
|
||||
return result;
|
||||
TRY(fs().set_block_allocation_state(m_raw_inode.i_block[EXT2_IND_BLOCK], false));
|
||||
old_shape.meta_blocks--;
|
||||
m_raw_inode.i_block[EXT2_IND_BLOCK] = 0;
|
||||
}
|
||||
|
|
@ -489,11 +470,9 @@ KResult Ext2FSInode::flush_block_list()
|
|||
set_metadata_dirty(true);
|
||||
old_shape.meta_blocks++;
|
||||
}
|
||||
if (auto result = grow_doubly_indirect_block(m_raw_inode.i_block[EXT2_DIND_BLOCK], old_shape.doubly_indirect_blocks, m_block_list.span().slice(output_block_index, new_shape.doubly_indirect_blocks), new_meta_blocks, old_shape.meta_blocks); result.is_error())
|
||||
return result;
|
||||
TRY(grow_doubly_indirect_block(m_raw_inode.i_block[EXT2_DIND_BLOCK], old_shape.doubly_indirect_blocks, m_block_list.span().slice(output_block_index, new_shape.doubly_indirect_blocks), new_meta_blocks, old_shape.meta_blocks));
|
||||
} else {
|
||||
if (auto result = shrink_doubly_indirect_block(m_raw_inode.i_block[EXT2_DIND_BLOCK], old_shape.doubly_indirect_blocks, new_shape.doubly_indirect_blocks, old_shape.meta_blocks); result.is_error())
|
||||
return result;
|
||||
TRY(shrink_doubly_indirect_block(m_raw_inode.i_block[EXT2_DIND_BLOCK], old_shape.doubly_indirect_blocks, new_shape.doubly_indirect_blocks, old_shape.meta_blocks));
|
||||
if (new_shape.doubly_indirect_blocks == 0)
|
||||
m_raw_inode.i_block[EXT2_DIND_BLOCK] = 0;
|
||||
}
|
||||
|
|
@ -512,11 +491,9 @@ KResult Ext2FSInode::flush_block_list()
|
|||
set_metadata_dirty(true);
|
||||
old_shape.meta_blocks++;
|
||||
}
|
||||
if (auto result = grow_triply_indirect_block(m_raw_inode.i_block[EXT2_TIND_BLOCK], old_shape.triply_indirect_blocks, m_block_list.span().slice(output_block_index, new_shape.triply_indirect_blocks), new_meta_blocks, old_shape.meta_blocks); result.is_error())
|
||||
return result;
|
||||
TRY(grow_triply_indirect_block(m_raw_inode.i_block[EXT2_TIND_BLOCK], old_shape.triply_indirect_blocks, m_block_list.span().slice(output_block_index, new_shape.triply_indirect_blocks), new_meta_blocks, old_shape.meta_blocks));
|
||||
} else {
|
||||
if (auto result = shrink_triply_indirect_block(m_raw_inode.i_block[EXT2_TIND_BLOCK], old_shape.triply_indirect_blocks, new_shape.triply_indirect_blocks, old_shape.meta_blocks); result.is_error())
|
||||
return result;
|
||||
TRY(shrink_triply_indirect_block(m_raw_inode.i_block[EXT2_TIND_BLOCK], old_shape.triply_indirect_blocks, new_shape.triply_indirect_blocks, old_shape.meta_blocks));
|
||||
if (new_shape.triply_indirect_blocks == 0)
|
||||
m_raw_inode.i_block[EXT2_TIND_BLOCK] = 0;
|
||||
}
|
||||
|
|
@ -933,10 +910,8 @@ KResult Ext2FSInode::resize(u64 new_size)
|
|||
m_block_list = this->compute_block_list();
|
||||
|
||||
if (blocks_needed_after > blocks_needed_before) {
|
||||
auto blocks_or_error = fs().allocate_blocks(fs().group_index_from_inode(index()), blocks_needed_after - blocks_needed_before);
|
||||
if (blocks_or_error.is_error())
|
||||
return blocks_or_error.error();
|
||||
if (!m_block_list.try_extend(blocks_or_error.release_value()))
|
||||
auto blocks = TRY(fs().allocate_blocks(fs().group_index_from_inode(index()), blocks_needed_after - blocks_needed_before));
|
||||
if (!m_block_list.try_extend(move(blocks)))
|
||||
return ENOMEM;
|
||||
} else if (blocks_needed_after < blocks_needed_before) {
|
||||
if constexpr (EXT2_VERY_DEBUG) {
|
||||
|
|
@ -956,8 +931,7 @@ KResult Ext2FSInode::resize(u64 new_size)
|
|||
}
|
||||
}
|
||||
|
||||
if (auto result = flush_block_list(); result.is_error())
|
||||
return result;
|
||||
TRY(flush_block_list());
|
||||
|
||||
m_raw_inode.i_size = new_size;
|
||||
if (Kernel::is_regular_file(m_raw_inode.i_mode))
|
||||
|
|
@ -972,12 +946,10 @@ KResult Ext2FSInode::resize(u64 new_size)
|
|||
auto clear_from = old_size;
|
||||
u8 zero_buffer[PAGE_SIZE] {};
|
||||
while (bytes_to_clear) {
|
||||
auto result = write_bytes(clear_from, min(static_cast<u64>(sizeof(zero_buffer)), bytes_to_clear), UserOrKernelBuffer::for_kernel_buffer(zero_buffer), nullptr);
|
||||
if (result.is_error())
|
||||
return result.error();
|
||||
VERIFY(result.value() != 0);
|
||||
bytes_to_clear -= result.value();
|
||||
clear_from += result.value();
|
||||
auto nwritten = TRY(write_bytes(clear_from, min(static_cast<u64>(sizeof(zero_buffer)), bytes_to_clear), UserOrKernelBuffer::for_kernel_buffer(zero_buffer), nullptr));
|
||||
VERIFY(nwritten != 0);
|
||||
bytes_to_clear -= nwritten;
|
||||
clear_from += nwritten;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -993,8 +965,7 @@ KResultOr<size_t> Ext2FSInode::write_bytes(off_t offset, size_t count, const Use
|
|||
|
||||
MutexLocker inode_locker(m_inode_lock);
|
||||
|
||||
if (auto result = prepare_to_write_data(); result.is_error())
|
||||
return result;
|
||||
TRY(prepare_to_write_data());
|
||||
|
||||
if (is_symlink()) {
|
||||
VERIFY(offset == 0);
|
||||
|
|
@ -1014,8 +985,7 @@ KResultOr<size_t> Ext2FSInode::write_bytes(off_t offset, size_t count, const Use
|
|||
const auto block_size = fs().block_size();
|
||||
auto new_size = max(static_cast<u64>(offset) + count, size());
|
||||
|
||||
if (auto result = resize(new_size); result.is_error())
|
||||
return result;
|
||||
TRY(resize(new_size));
|
||||
|
||||
if (m_block_list.is_empty())
|
||||
m_block_list = compute_block_list();
|
||||
|
|
@ -1098,8 +1068,7 @@ KResult Ext2FSInode::traverse_as_directory(Function<bool(FileSystem::DirectoryEn
|
|||
// so we can iterate over blocks separately.
|
||||
|
||||
for (u64 offset = 0; offset < file_size; offset += block_size) {
|
||||
if (auto result = read_bytes(offset, block_size, buf, nullptr); result.is_error())
|
||||
return result.error();
|
||||
TRY(read_bytes(offset, block_size, buf, nullptr));
|
||||
|
||||
auto* entry = reinterpret_cast<ext2_dir_entry_2*>(buffer);
|
||||
auto* entries_end = reinterpret_cast<ext2_dir_entry_2*>(buffer + block_size);
|
||||
|
|
@ -1163,15 +1132,12 @@ KResult Ext2FSInode::write_directory(Vector<Ext2FSDirectoryEntry>& entries)
|
|||
|
||||
VERIFY(stream.is_end());
|
||||
|
||||
if (auto result = resize(stream.size()); result.is_error())
|
||||
return result;
|
||||
TRY(resize(stream.size()));
|
||||
|
||||
auto buffer = UserOrKernelBuffer::for_kernel_buffer(stream.data());
|
||||
auto result = write_bytes(0, stream.size(), buffer, nullptr);
|
||||
if (result.is_error())
|
||||
return result.error();
|
||||
auto nwritten = TRY(write_bytes(0, stream.size(), buffer, nullptr));
|
||||
set_metadata_dirty(true);
|
||||
if (static_cast<size_t>(result.value()) != directory_data.size())
|
||||
if (nwritten != directory_data.size())
|
||||
return EIO;
|
||||
return KSuccess;
|
||||
}
|
||||
|
|
@ -1212,17 +1178,12 @@ KResult Ext2FSInode::add_child(Inode& child, const StringView& name, mode_t mode
|
|||
return EEXIST;
|
||||
}
|
||||
|
||||
result = child.increment_link_count();
|
||||
if (result.is_error())
|
||||
return result;
|
||||
TRY(child.increment_link_count());
|
||||
|
||||
entries.empend(name, child.index(), to_ext2_file_type(mode));
|
||||
result = write_directory(entries);
|
||||
if (result.is_error())
|
||||
return result;
|
||||
|
||||
if (auto populate_result = populate_lookup_cache(); populate_result.is_error())
|
||||
return populate_result;
|
||||
TRY(write_directory(entries));
|
||||
TRY(populate_lookup_cache());
|
||||
|
||||
m_lookup_cache.set(name, child.index());
|
||||
did_add_child(child.identifier(), name);
|
||||
|
|
@ -1235,8 +1196,7 @@ KResult Ext2FSInode::remove_child(const StringView& name)
|
|||
dbgln_if(EXT2_DEBUG, "Ext2FSInode[{}]::remove_child(): Removing '{}'", identifier(), name);
|
||||
VERIFY(is_directory());
|
||||
|
||||
if (auto populate_result = populate_lookup_cache(); populate_result.is_error())
|
||||
return populate_result;
|
||||
TRY(populate_lookup_cache());
|
||||
|
||||
auto it = m_lookup_cache.find(name);
|
||||
if (it == m_lookup_cache.end())
|
||||
|
|
@ -1254,16 +1214,12 @@ KResult Ext2FSInode::remove_child(const StringView& name)
|
|||
if (result.is_error())
|
||||
return result;
|
||||
|
||||
result = write_directory(entries);
|
||||
if (result.is_error())
|
||||
return result;
|
||||
TRY(write_directory(entries));
|
||||
|
||||
m_lookup_cache.remove(name);
|
||||
|
||||
auto child_inode = fs().get_inode(child_id);
|
||||
result = child_inode->decrement_link_count();
|
||||
if (result.is_error())
|
||||
return result;
|
||||
TRY(child_inode->decrement_link_count());
|
||||
|
||||
did_remove_child(child_id, name);
|
||||
return KSuccess;
|
||||
|
|
@ -1337,13 +1293,10 @@ auto Ext2FS::allocate_blocks(GroupIndex preferred_group_index, size_t count) ->
|
|||
VERIFY(found_a_group);
|
||||
auto& bgd = group_descriptor(group_index);
|
||||
|
||||
auto cached_bitmap_or_error = get_bitmap_block(bgd.bg_block_bitmap);
|
||||
if (cached_bitmap_or_error.is_error())
|
||||
return cached_bitmap_or_error.error();
|
||||
auto& cached_bitmap = *cached_bitmap_or_error.value();
|
||||
auto* cached_bitmap = TRY(get_bitmap_block(bgd.bg_block_bitmap));
|
||||
|
||||
int blocks_in_group = min(blocks_per_group(), super_block().s_blocks_count);
|
||||
auto block_bitmap = cached_bitmap.bitmap(blocks_in_group);
|
||||
auto block_bitmap = cached_bitmap->bitmap(blocks_in_group);
|
||||
|
||||
BlockIndex first_block_in_group = (group_index.value() - 1) * blocks_per_group() + first_block_index().value();
|
||||
size_t free_region_size = 0;
|
||||
|
|
@ -1400,11 +1353,8 @@ KResultOr<InodeIndex> Ext2FS::allocate_inode(GroupIndex preferred_group)
|
|||
unsigned inodes_in_group = min(inodes_per_group(), super_block().s_inodes_count);
|
||||
InodeIndex first_inode_in_group = (group_index.value() - 1) * inodes_per_group() + 1;
|
||||
|
||||
auto cached_bitmap_or_error = get_bitmap_block(bgd.bg_inode_bitmap);
|
||||
if (cached_bitmap_or_error.is_error())
|
||||
return cached_bitmap_or_error.error();
|
||||
auto& cached_bitmap = *cached_bitmap_or_error.value();
|
||||
auto inode_bitmap = cached_bitmap.bitmap(inodes_in_group);
|
||||
auto* cached_bitmap = TRY(get_bitmap_block(bgd.bg_inode_bitmap));
|
||||
auto inode_bitmap = cached_bitmap->bitmap(inodes_in_group);
|
||||
for (size_t i = 0; i < inode_bitmap.size(); ++i) {
|
||||
if (inode_bitmap.get(i))
|
||||
continue;
|
||||
|
|
@ -1412,7 +1362,7 @@ KResultOr<InodeIndex> Ext2FS::allocate_inode(GroupIndex preferred_group)
|
|||
|
||||
auto inode_index = InodeIndex(first_inode_in_group.value() + i);
|
||||
|
||||
cached_bitmap.dirty = true;
|
||||
cached_bitmap->dirty = true;
|
||||
m_super_block.s_free_inodes_count--;
|
||||
m_super_block_dirty = true;
|
||||
const_cast<ext2_group_desc&>(bgd).bg_free_inodes_count--;
|
||||
|
|
@ -1452,25 +1402,20 @@ KResultOr<bool> Ext2FS::get_inode_allocation_state(InodeIndex index) const
|
|||
unsigned index_in_group = index.value() - ((group_index.value() - 1) * inodes_per_group());
|
||||
unsigned bit_index = (index_in_group - 1) % inodes_per_group();
|
||||
|
||||
auto cached_bitmap_or_error = const_cast<Ext2FS&>(*this).get_bitmap_block(bgd.bg_inode_bitmap);
|
||||
if (cached_bitmap_or_error.is_error())
|
||||
return cached_bitmap_or_error.error();
|
||||
return cached_bitmap_or_error.value()->bitmap(inodes_per_group()).get(bit_index);
|
||||
auto* cached_bitmap = TRY(const_cast<Ext2FS&>(*this).get_bitmap_block(bgd.bg_inode_bitmap));
|
||||
return cached_bitmap->bitmap(inodes_per_group()).get(bit_index);
|
||||
}
|
||||
|
||||
KResult Ext2FS::update_bitmap_block(BlockIndex bitmap_block, size_t bit_index, bool new_state, u32& super_block_counter, u16& group_descriptor_counter)
|
||||
{
|
||||
auto cached_bitmap_or_error = get_bitmap_block(bitmap_block);
|
||||
if (cached_bitmap_or_error.is_error())
|
||||
return cached_bitmap_or_error.error();
|
||||
auto& cached_bitmap = *cached_bitmap_or_error.value();
|
||||
bool current_state = cached_bitmap.bitmap(blocks_per_group()).get(bit_index);
|
||||
auto* cached_bitmap = TRY(get_bitmap_block(bitmap_block));
|
||||
bool current_state = cached_bitmap->bitmap(blocks_per_group()).get(bit_index);
|
||||
if (current_state == new_state) {
|
||||
dbgln("Ext2FS: Bit {} in bitmap block {} had unexpected state {}", bit_index, bitmap_block, current_state);
|
||||
return EIO;
|
||||
}
|
||||
cached_bitmap.bitmap(blocks_per_group()).set(bit_index, new_state);
|
||||
cached_bitmap.dirty = true;
|
||||
cached_bitmap->bitmap(blocks_per_group()).set(bit_index, new_state);
|
||||
cached_bitmap->dirty = true;
|
||||
|
||||
if (new_state) {
|
||||
--super_block_counter;
|
||||
|
|
@ -1544,11 +1489,7 @@ KResult Ext2FS::create_directory(Ext2FSInode& parent_inode, StringView name, mod
|
|||
MutexLocker locker(m_lock);
|
||||
VERIFY(is_directory(mode));
|
||||
|
||||
auto inode_or_error = create_inode(parent_inode, name, mode, 0, uid, gid);
|
||||
if (inode_or_error.is_error())
|
||||
return inode_or_error.error();
|
||||
|
||||
auto& inode = inode_or_error.value();
|
||||
auto inode = TRY(create_inode(parent_inode, name, mode, 0, uid, gid));
|
||||
|
||||
dbgln_if(EXT2_DEBUG, "Ext2FS: create_directory: created new directory named '{} with inode {}", name, inode->index());
|
||||
|
||||
|
|
@ -1556,11 +1497,8 @@ KResult Ext2FS::create_directory(Ext2FSInode& parent_inode, StringView name, mod
|
|||
entries.empend(".", inode->index(), static_cast<u8>(EXT2_FT_DIR));
|
||||
entries.empend("..", parent_inode.index(), static_cast<u8>(EXT2_FT_DIR));
|
||||
|
||||
if (auto result = static_cast<Ext2FSInode&>(*inode).write_directory(entries); result.is_error())
|
||||
return result;
|
||||
|
||||
if (auto result = parent_inode.increment_link_count(); result.is_error())
|
||||
return result;
|
||||
TRY(static_cast<Ext2FSInode&>(*inode).write_directory(entries));
|
||||
TRY(parent_inode.increment_link_count());
|
||||
|
||||
auto& bgd = const_cast<ext2_group_desc&>(group_descriptor(group_index_from_inode(inode->identifier().index())));
|
||||
++bgd.bg_used_dirs_count;
|
||||
|
|
@ -1597,20 +1535,17 @@ KResultOr<NonnullRefPtr<Inode>> Ext2FS::create_inode(Ext2FSInode& parent_inode,
|
|||
else if (is_block_device(mode))
|
||||
e2inode.i_block[1] = dev;
|
||||
|
||||
auto inode_id = allocate_inode();
|
||||
if (inode_id.is_error())
|
||||
return inode_id.error();
|
||||
auto inode_id = TRY(allocate_inode());
|
||||
|
||||
dbgln_if(EXT2_DEBUG, "Ext2FS: writing initial metadata for inode {}", inode_id.value());
|
||||
auto success = write_ext2_inode(inode_id.value(), e2inode);
|
||||
auto success = write_ext2_inode(inode_id, e2inode);
|
||||
VERIFY(success);
|
||||
|
||||
auto new_inode = get_inode({ fsid(), inode_id.value() });
|
||||
auto new_inode = get_inode({ fsid(), inode_id });
|
||||
VERIFY(new_inode);
|
||||
|
||||
dbgln_if(EXT2_DEBUG, "Ext2FS: Adding inode '{}' (mode {:o}) to parent directory {}", name, mode, parent_inode.index());
|
||||
if (auto result = parent_inode.add_child(*new_inode, name, mode); result.is_error())
|
||||
return result;
|
||||
TRY(parent_inode.add_child(*new_inode, name, mode));
|
||||
return new_inode.release_nonnull();
|
||||
}
|
||||
|
||||
|
|
@ -1638,8 +1573,7 @@ KResultOr<NonnullRefPtr<Inode>> Ext2FSInode::lookup(StringView name)
|
|||
{
|
||||
VERIFY(is_directory());
|
||||
dbgln_if(EXT2_DEBUG, "Ext2FSInode[{}]:lookup(): Looking up '{}'", identifier(), name);
|
||||
if (auto result = populate_lookup_cache(); result.is_error())
|
||||
return result;
|
||||
TRY(populate_lookup_cache());
|
||||
|
||||
InodeIndex inode_index;
|
||||
{
|
||||
|
|
@ -1756,8 +1690,7 @@ KResult Ext2FSInode::truncate(u64 size)
|
|||
MutexLocker locker(m_inode_lock);
|
||||
if (static_cast<u64>(m_raw_inode.i_size) == size)
|
||||
return KSuccess;
|
||||
if (auto result = resize(size); result.is_error())
|
||||
return result;
|
||||
TRY(resize(size));
|
||||
set_metadata_dirty(true);
|
||||
return KSuccess;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue