RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-31 15:48:12 +00:00
Code Issues Activity Actions

Ext2FS: Use if-with-initializer a lot more

Browse source 
This pattern felt really cluttery:

auto result = something();
if (result.is_error())
    return result;

Since it leaves "result" lying around in the no-error case.
Let's use some C++17 if initializer expressions to improve this:

if (auto result = something(); result.is_error())
    return result;

Now the "result" goes out of scope if we don't need it anymore.
This is doubly nice since we're also free to reuse the "result"
name later in the same function.
This commit is contained in:
Andreas Kling 2021-04-11 00:25:26 +02:00
parent ccd21614a3
commit acebc9beaf
1 changed files with 36 additions and 71 deletions
Download patch file Download diff file Expand all files Collapse all files

107
Kernel/FileSystem/Ext2FileSystem.cpp
View file

@ -150,8 +150,7 @@ bool Ext2FS::initialize()
return false; return false;
} }
auto buffer = UserOrKernelBuffer::for_kernel_buffer(m_cached_group_descriptor_table->data()); auto buffer = UserOrKernelBuffer::for_kernel_buffer(m_cached_group_descriptor_table->data());
auto result = read_blocks(first_block_of_bgdt, blocks_to_read, buffer); if (auto result = read_blocks(first_block_of_bgdt, blocks_to_read, buffer); result.is_error()) {
if (result.is_error()) {
// FIXME: Propagate the error // FIXME: Propagate the error
dbgln("Ext2FS: initialize had error: {}", result.error()); dbgln("Ext2FS: initialize had error: {}", result.error());
return false; return false;
@ -262,8 +261,7 @@ KResult Ext2FSInode::grow_doubly_indirect_block(BlockBasedFS::BlockIndex block,
auto buffer = UserOrKernelBuffer::for_kernel_buffer(stream.data()); auto buffer = UserOrKernelBuffer::for_kernel_buffer(stream.data());
if (old_blocks_length > 0) { if (old_blocks_length > 0) {
auto result = fs().read_block(block, &buffer, fs().block_size()); if (auto result = fs().read_block(block, &buffer, fs().block_size()); result.is_error())
if (result.is_error())
return result; return result;
} }
@ -281,8 +279,7 @@ KResult Ext2FSInode::grow_doubly_indirect_block(BlockBasedFS::BlockIndex block,
// Write out the indirect blocks. // Write out the indirect blocks.
for (unsigned i = old_blocks_length / entries_per_block; i < new_indirect_blocks_length; i++) { for (unsigned i = old_blocks_length / entries_per_block; i < new_indirect_blocks_length; i++) {
const auto offset_block = i * entries_per_block; const auto offset_block = i * entries_per_block;
auto result = write_indirect_block(block_as_pointers[i], blocks_indexes.slice(offset_block, min(blocks_indexes.size() - offset_block, entries_per_block))); if (auto result = write_indirect_block(block_as_pointers[i], blocks_indexes.slice(offset_block, min(blocks_indexes.size() - offset_block, entries_per_block))); result.is_error())
if (result.is_error())
return result; return result;
} }
@ -303,15 +300,13 @@ KResult Ext2FSInode::shrink_doubly_indirect_block(BlockBasedFS::BlockIndex block
auto block_contents = ByteBuffer::create_uninitialized(fs().block_size()); auto block_contents = ByteBuffer::create_uninitialized(fs().block_size());
auto* block_as_pointers = (unsigned*)block_contents.data(); auto* block_as_pointers = (unsigned*)block_contents.data();
auto buffer = UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<u8*>(block_as_pointers)); auto buffer = UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<u8*>(block_as_pointers));
auto result = fs().read_block(block, &buffer, fs().block_size()); if (auto result = fs().read_block(block, &buffer, fs().block_size()); result.is_error())
if (result.is_error())
return result; return result;
// Free the unused indirect blocks. // Free the unused indirect blocks.
for (unsigned i = new_indirect_blocks_length; i < old_indirect_blocks_length; i++) { 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); dbgln_if(EXT2_BLOCKLIST_DEBUG, "Ext2FSInode[{}]::shrink_doubly_indirect_block(): Freeing indirect block {} at index {}", identifier(), block_as_pointers[i], i);
auto result = fs().set_block_allocation_state(block_as_pointers[i], false); if (auto result = fs().set_block_allocation_state(block_as_pointers[i], false); result.is_error())
if (result.is_error())
return result; return result;
meta_blocks--; meta_blocks--;
} }
@ -319,8 +314,7 @@ KResult Ext2FSInode::shrink_doubly_indirect_block(BlockBasedFS::BlockIndex block
// Free the doubly indirect block if no longer needed. // Free the doubly indirect block if no longer needed.
if (new_blocks_length == 0) { if (new_blocks_length == 0) {
dbgln_if(EXT2_BLOCKLIST_DEBUG, "Ext2FSInode[{}]::shrink_doubly_indirect_block(): Freeing doubly indirect block {}", identifier(), block); dbgln_if(EXT2_BLOCKLIST_DEBUG, "Ext2FSInode[{}]::shrink_doubly_indirect_block(): Freeing doubly indirect block {}", identifier(), block);
auto result = fs().set_block_allocation_state(block, false); if (auto result = fs().set_block_allocation_state(block, false); result.is_error())
if (result.is_error())
return result; return result;
meta_blocks--; meta_blocks--;
} }
@ -345,8 +339,7 @@ KResult Ext2FSInode::grow_triply_indirect_block(BlockBasedFS::BlockIndex block,
auto buffer = UserOrKernelBuffer::for_kernel_buffer(stream.data()); auto buffer = UserOrKernelBuffer::for_kernel_buffer(stream.data());
if (old_blocks_length > 0) { if (old_blocks_length > 0) {
auto result = fs().read_block(block, &buffer, fs().block_size()); if (auto result = fs().read_block(block, &buffer, fs().block_size()); result.is_error())
if (result.is_error())
return result; return result;
} }
@ -366,8 +359,7 @@ KResult Ext2FSInode::grow_triply_indirect_block(BlockBasedFS::BlockIndex block,
const auto processed_blocks = i * entries_per_doubly_indirect_block; 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 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_indexes.size() > processed_blocks ? blocks_indexes.size() - processed_blocks : 0, entries_per_doubly_indirect_block); const auto new_doubly_indirect_blocks_length = min(blocks_indexes.size() > processed_blocks ? blocks_indexes.size() - processed_blocks : 0, entries_per_doubly_indirect_block);
auto result = grow_doubly_indirect_block(block_as_pointers[i], old_doubly_indirect_blocks_length, blocks_indexes.slice(processed_blocks, new_doubly_indirect_blocks_length), new_meta_blocks, meta_blocks); if (auto result = grow_doubly_indirect_block(block_as_pointers[i], old_doubly_indirect_blocks_length, blocks_indexes.slice(processed_blocks, new_doubly_indirect_blocks_length), new_meta_blocks, meta_blocks); result.is_error())
if (result.is_error())
return result; return result;
} }
@ -389,8 +381,7 @@ KResult Ext2FSInode::shrink_triply_indirect_block(BlockBasedFS::BlockIndex block
auto block_contents = ByteBuffer::create_uninitialized(fs().block_size()); auto block_contents = ByteBuffer::create_uninitialized(fs().block_size());
auto* block_as_pointers = (unsigned*)block_contents.data(); auto* block_as_pointers = (unsigned*)block_contents.data();
auto buffer = UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<u8*>(block_as_pointers)); auto buffer = UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<u8*>(block_as_pointers));
auto result = fs().read_block(block, &buffer, fs().block_size()); if (auto result = fs().read_block(block, &buffer, fs().block_size()); result.is_error())
if (result.is_error())
return result; return result;
// Shrink the doubly indirect blocks. // Shrink the doubly indirect blocks.
@ -399,16 +390,14 @@ KResult Ext2FSInode::shrink_triply_indirect_block(BlockBasedFS::BlockIndex 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 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); 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); dbgln_if(EXT2_BLOCKLIST_DEBUG, "Ext2FSInode[{}]::shrink_triply_indirect_block(): Shrinking doubly indirect block {} at index {}", identifier(), block_as_pointers[i], i);
auto result = shrink_doubly_indirect_block(block_as_pointers[i], old_doubly_indirect_blocks_length, new_doubly_indirect_blocks_length, meta_blocks); 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())
if (result.is_error())
return result; return result;
} }
// Free the triply indirect block if no longer needed. // Free the triply indirect block if no longer needed.
if (new_blocks_length == 0) { if (new_blocks_length == 0) {
dbgln_if(EXT2_BLOCKLIST_DEBUG, "Ext2FSInode[{}]::shrink_triply_indirect_block(): Freeing triply indirect block {}", identifier(), block); dbgln_if(EXT2_BLOCKLIST_DEBUG, "Ext2FSInode[{}]::shrink_triply_indirect_block(): Freeing triply indirect block {}", identifier(), block);
auto result = fs().set_block_allocation_state(block, false); if (auto result = fs().set_block_allocation_state(block, false); result.is_error())
if (result.is_error())
return result; return result;
meta_blocks--; meta_blocks--;
} }
@ -478,13 +467,11 @@ KResult Ext2FSInode::flush_block_list()
old_shape.meta_blocks++; old_shape.meta_blocks++;
} }
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)); 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())
if (result.is_error())
return result; return result;
} else if ((new_shape.indirect_blocks == 0) && (old_shape.indirect_blocks != 0)) { } 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]); dbgln_if(EXT2_BLOCKLIST_DEBUG, "Ext2FSInode[{}]::flush_block_list(): Freeing indirect block: {}", identifier(), m_raw_inode.i_block[EXT2_IND_BLOCK]);
auto result = fs().set_block_allocation_state(m_raw_inode.i_block[EXT2_IND_BLOCK], false); if (auto result = fs().set_block_allocation_state(m_raw_inode.i_block[EXT2_IND_BLOCK], false); result.is_error())
if (result.is_error())
return result; return result;
old_shape.meta_blocks--; old_shape.meta_blocks--;
} }
@ -503,12 +490,10 @@ KResult Ext2FSInode::flush_block_list()
set_metadata_dirty(true); set_metadata_dirty(true);
old_shape.meta_blocks++; old_shape.meta_blocks++;
} }
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); 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())
if (result.is_error())
return result; return result;
} else { } else {
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); 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())
if (result.is_error())
return result; return result;
} }
} }
@ -526,12 +511,10 @@ KResult Ext2FSInode::flush_block_list()
set_metadata_dirty(true); set_metadata_dirty(true);
old_shape.meta_blocks++; old_shape.meta_blocks++;
} }
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); 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())
if (result.is_error())
return result; return result;
} else { } else {
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); 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())
if (result.is_error())
return result; return result;
} }
} }
@ -628,8 +611,7 @@ Vector<Ext2FS::BlockIndex> Ext2FSInode::compute_block_list_impl_internal(const e
auto array_storage = ByteBuffer::create_uninitialized(read_size); auto array_storage = ByteBuffer::create_uninitialized(read_size);
auto* array = (u32*)array_storage.data(); auto* array = (u32*)array_storage.data();
auto buffer = UserOrKernelBuffer::for_kernel_buffer((u8*)array); auto buffer = UserOrKernelBuffer::for_kernel_buffer((u8*)array);
auto result = fs().read_block(array_block_index, &buffer, read_size, 0); if (auto result = fs().read_block(array_block_index, &buffer, read_size, 0); result.is_error()) {
if (result.is_error()) {
// FIXME: Stop here and propagate this error. // FIXME: Stop here and propagate this error.
dbgln("Ext2FSInode[{}]::compute_block_list_impl_internal(): Error: {}", identifier(), result.error()); dbgln("Ext2FSInode[{}]::compute_block_list_impl_internal(): Error: {}", identifier(), result.error());
} }
@ -674,8 +656,7 @@ void Ext2FS::free_inode(Ext2FSInode& inode)
for (auto block_index : inode.compute_block_list_with_meta_blocks()) { for (auto block_index : inode.compute_block_list_with_meta_blocks()) {
VERIFY(block_index <= super_block().s_blocks_count); VERIFY(block_index <= super_block().s_blocks_count);
if (block_index.value()) { if (block_index.value()) {
auto result = set_block_allocation_state(block_index, false); if (auto result = set_block_allocation_state(block_index, false); result.is_error()) {
if (result.is_error()) {
dbgln("Ext2FS[{}]::free_inode(): Failed to deallocate block {} for inode {}", fsid(), block_index, inode.index()); dbgln("Ext2FS[{}]::free_inode(): Failed to deallocate block {} for inode {}", fsid(), block_index, inode.index());
} }
} }
@ -695,8 +676,7 @@ void Ext2FS::free_inode(Ext2FSInode& inode)
write_ext2_inode(inode.index(), inode.m_raw_inode); write_ext2_inode(inode.index(), inode.m_raw_inode);
// Mark the inode as free. // Mark the inode as free.
auto result = set_inode_allocation_state(inode.index(), false); if (auto result = set_inode_allocation_state(inode.index(), false); result.is_error())
if (result.is_error())
dbgln("Ext2FS[{}]::free_inode(): Failed to free inode {}: {}", fsid(), inode.index(), result.error()); dbgln("Ext2FS[{}]::free_inode(): Failed to free inode {}: {}", fsid(), inode.index(), result.error());
} }
@ -706,8 +686,7 @@ void Ext2FS::flush_block_group_descriptor_table()
unsigned blocks_to_write = ceil_div(m_block_group_count * sizeof(ext2_group_desc), block_size()); unsigned blocks_to_write = ceil_div(m_block_group_count * sizeof(ext2_group_desc), block_size());
unsigned first_block_of_bgdt = block_size() == 1024 ? 2 : 1; unsigned first_block_of_bgdt = block_size() == 1024 ? 2 : 1;
auto buffer = UserOrKernelBuffer::for_kernel_buffer((u8*)block_group_descriptors()); auto buffer = UserOrKernelBuffer::for_kernel_buffer((u8*)block_group_descriptors());
auto result = write_blocks(first_block_of_bgdt, blocks_to_write, buffer); if (auto result = write_blocks(first_block_of_bgdt, blocks_to_write, buffer); result.is_error())
if (result.is_error())
dbgln("Ext2FS[{}]::flush_block_group_descriptor_table(): Failed to write blocks: {}", fsid(), result.error()); dbgln("Ext2FS[{}]::flush_block_group_descriptor_table(): Failed to write blocks: {}", fsid(), result.error());
} }
@ -725,8 +704,7 @@ void Ext2FS::flush_writes()
for (auto& cached_bitmap : m_cached_bitmaps) { for (auto& cached_bitmap : m_cached_bitmaps) {
if (cached_bitmap->dirty) { if (cached_bitmap->dirty) {
auto buffer = UserOrKernelBuffer::for_kernel_buffer(cached_bitmap->buffer.data()); auto buffer = UserOrKernelBuffer::for_kernel_buffer(cached_bitmap->buffer.data());
auto result = write_block(cached_bitmap->bitmap_block_index, buffer, block_size()); if (auto result = write_block(cached_bitmap->bitmap_block_index, buffer, block_size()); result.is_error()) {
if (result.is_error()) {
dbgln("Ext2FS[{}]::flush_writes(): Failed to write blocks: {}", fsid(), result.error()); dbgln("Ext2FS[{}]::flush_writes(): Failed to write blocks: {}", fsid(), result.error());
} }
cached_bitmap->dirty = false; cached_bitmap->dirty = false;
@ -841,8 +819,7 @@ RefPtr<Inode> Ext2FS::get_inode(InodeIdentifier inode) const
auto new_inode = adopt(*new Ext2FSInode(const_cast<Ext2FS&>(*this), inode.index())); auto new_inode = adopt(*new Ext2FSInode(const_cast<Ext2FS&>(*this), inode.index()));
auto buffer = UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<u8*>(&new_inode->m_raw_inode)); auto buffer = UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<u8*>(&new_inode->m_raw_inode));
auto result = read_block(block_index, &buffer, sizeof(ext2_inode), offset); if (auto result = read_block(block_index, &buffer, sizeof(ext2_inode), offset); result.is_error()) {
if (result.is_error()) {
// FIXME: Propagate the actual error. // FIXME: Propagate the actual error.
return nullptr; return nullptr;
} }
@ -904,8 +881,7 @@ ssize_t Ext2FSInode::read_bytes(off_t offset, ssize_t count, UserOrKernelBuffer&
if (!buffer_offset.memset(0, num_bytes_to_copy)) if (!buffer_offset.memset(0, num_bytes_to_copy))
return -EFAULT; return -EFAULT;
} else { } else {
auto result = fs().read_block(block_index, &buffer_offset, num_bytes_to_copy, offset_into_block, allow_cache); if (auto result = fs().read_block(block_index, &buffer_offset, num_bytes_to_copy, offset_into_block, allow_cache); result.is_error()) {
if (result.is_error()) {
dmesgln("Ext2FSInode[{}]::read_bytes(): Failed to read block {} (index {})", identifier(), block_index.value(), bi); dmesgln("Ext2FSInode[{}]::read_bytes(): Failed to read block {} (index {})", identifier(), block_index.value(), bi);
return result.error(); return result.error();
} }
@ -959,8 +935,7 @@ KResult Ext2FSInode::resize(u64 new_size)
while (m_block_list.size() != blocks_needed_after) { while (m_block_list.size() != blocks_needed_after) {
auto block_index = m_block_list.take_last(); auto block_index = m_block_list.take_last();
if (block_index.value()) { if (block_index.value()) {
auto result = fs().set_block_allocation_state(block_index, false); if (auto result = fs().set_block_allocation_state(block_index, false); result.is_error()) {
if (result.is_error()) {
dbgln("Ext2FSInode[{}]::resize(): Failed to free block {}: {}", identifier(), block_index, result.error()); dbgln("Ext2FSInode[{}]::resize(): Failed to free block {}: {}", identifier(), block_index, result.error());
return result; return result;
} }
@ -968,8 +943,7 @@ KResult Ext2FSInode::resize(u64 new_size)
} }
} }
auto result = flush_block_list(); if (auto result = flush_block_list(); result.is_error())
if (result.is_error())
return result; return result;
m_raw_inode.i_size = new_size; m_raw_inode.i_size = new_size;
@ -1004,8 +978,7 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const UserOrKernel
Locker inode_locker(m_lock); Locker inode_locker(m_lock);
auto result = prepare_to_write_data(); if (auto result = prepare_to_write_data(); result.is_error())
if (result.is_error())
return result; return result;
if (is_symlink()) { if (is_symlink()) {
@ -1026,9 +999,8 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const UserOrKernel
const auto block_size = fs().block_size(); const auto block_size = fs().block_size();
auto new_size = max(static_cast<u64>(offset) + count, size()); auto new_size = max(static_cast<u64>(offset) + count, size());
auto resize_result = resize(new_size); if (auto result = resize(new_size); result.is_error())
if (resize_result.is_error()) return result;
return resize_result;
if (m_block_list.is_empty()) if (m_block_list.is_empty())
m_block_list = compute_block_list(); m_block_list = compute_block_list();
@ -1054,8 +1026,7 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const UserOrKernel
size_t offset_into_block = (bi == first_block_logical_index) ? offset_into_first_block : 0; size_t offset_into_block = (bi == first_block_logical_index) ? offset_into_first_block : 0;
size_t num_bytes_to_copy = min((off_t)block_size - offset_into_block, remaining_count); size_t num_bytes_to_copy = min((off_t)block_size - offset_into_block, remaining_count);
dbgln_if(EXT2_DEBUG, "Ext2FSInode[{}]::write_bytes(): Writing block {} (offset_into_block: {})", identifier(), m_block_list[bi.value()], offset_into_block); dbgln_if(EXT2_DEBUG, "Ext2FSInode[{}]::write_bytes(): Writing block {} (offset_into_block: {})", identifier(), m_block_list[bi.value()], offset_into_block);
result = fs().write_block(m_block_list[bi.value()], data.offset(nwritten), num_bytes_to_copy, offset_into_block, allow_cache); if (auto result = fs().write_block(m_block_list[bi.value()], data.offset(nwritten), num_bytes_to_copy, offset_into_block, allow_cache); result.is_error()) {
if (result.is_error()) {
dbgln("Ext2FSInode[{}]::write_bytes(): Failed to write block {} (index {})", identifier(), m_block_list[bi.value()], bi); dbgln("Ext2FSInode[{}]::write_bytes(): Failed to write block {} (index {})", identifier(), m_block_list[bi.value()], bi);
return result; return result;
} }
@ -1337,8 +1308,7 @@ auto Ext2FS::allocate_blocks(GroupIndex preferred_group_index, size_t count) ->
dbgln_if(EXT2_DEBUG, "Ext2FS: allocating free region of size: {} [{}]", free_region_size, group_index); dbgln_if(EXT2_DEBUG, "Ext2FS: allocating free region of size: {} [{}]", free_region_size, group_index);
for (size_t i = 0; i < free_region_size; ++i) { for (size_t i = 0; i < free_region_size; ++i) {
BlockIndex block_index = (first_unset_bit_index.value() + i) + first_block_in_group.value(); BlockIndex block_index = (first_unset_bit_index.value() + i) + first_block_in_group.value();
auto result = set_block_allocation_state(block_index, true); if (auto result = set_block_allocation_state(block_index, true); result.is_error()) {
if (result.is_error()) {
dbgln("Ext2FS: Failed to allocate block {} in allocate_blocks()", block_index); dbgln("Ext2FS: Failed to allocate block {} in allocate_blocks()", block_index);
return result; return result;
} }
@ -1497,8 +1467,7 @@ KResultOr<Ext2FS::CachedBitmap*> Ext2FS::get_bitmap_block(BlockIndex bitmap_bloc
auto block = KBuffer::create_with_size(block_size(), Region::Access::Read | Region::Access::Write, "Ext2FS: Cached bitmap block"); auto block = KBuffer::create_with_size(block_size(), Region::Access::Read | Region::Access::Write, "Ext2FS: Cached bitmap block");
auto buffer = UserOrKernelBuffer::for_kernel_buffer(block.data()); auto buffer = UserOrKernelBuffer::for_kernel_buffer(block.data());
auto result = read_block(bitmap_block_index, &buffer, block_size()); if (auto result = read_block(bitmap_block_index, &buffer, block_size()); result.is_error()) {
if (result.is_error()) {
dbgln("Ext2FS: Failed to load bitmap block {}", bitmap_block_index); dbgln("Ext2FS: Failed to load bitmap block {}", bitmap_block_index);
return result; return result;
} }
@ -1537,12 +1506,10 @@ KResult Ext2FS::create_directory(Ext2FSInode& parent_inode, const String& name,
entries.empend(".", inode->index(), static_cast<u8>(EXT2_FT_DIR)); entries.empend(".", inode->index(), static_cast<u8>(EXT2_FT_DIR));
entries.empend("..", parent_inode.index(), static_cast<u8>(EXT2_FT_DIR)); entries.empend("..", parent_inode.index(), static_cast<u8>(EXT2_FT_DIR));
auto result = static_cast<Ext2FSInode&>(*inode).write_directory(entries); if (auto result = static_cast<Ext2FSInode&>(*inode).write_directory(entries); result.is_error())
if (result.is_error())
return result; return result;
result = parent_inode.increment_link_count(); if (auto result = parent_inode.increment_link_count(); result.is_error())
if (result.is_error())
return result; return result;
auto& bgd = const_cast<ext2_group_desc&>(group_descriptor(group_index_from_inode(inode->identifier().index()))); auto& bgd = const_cast<ext2_group_desc&>(group_descriptor(group_index_from_inode(inode->identifier().index())));
@ -1592,8 +1559,7 @@ KResultOr<NonnullRefPtr<Inode>> Ext2FS::create_inode(Ext2FSInode& parent_inode,
VERIFY(new_inode); VERIFY(new_inode);
dbgln_if(EXT2_DEBUG, "Ext2FS: Adding inode '{}' (mode {:o}) to parent directory {}", name, mode, parent_inode.index()); dbgln_if(EXT2_DEBUG, "Ext2FS: Adding inode '{}' (mode {:o}) to parent directory {}", name, mode, parent_inode.index());
auto result = parent_inode.add_child(*new_inode, name, mode); if (auto result = parent_inode.add_child(*new_inode, name, mode); result.is_error())
if (result.is_error())
return result; return result;
return new_inode.release_nonnull(); return new_inode.release_nonnull();
} }
@ -1733,8 +1699,7 @@ KResult Ext2FSInode::truncate(u64 size)
LOCKER(m_lock); LOCKER(m_lock);
if (static_cast<u64>(m_raw_inode.i_size) == size) if (static_cast<u64>(m_raw_inode.i_size) == size)
return KSuccess; return KSuccess;
auto result = resize(size); if (auto result = resize(size); result.is_error())
if (result.is_error())
return result; return result;
set_metadata_dirty(true); set_metadata_dirty(true);
return KSuccess; return KSuccess;