LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-09-20 01:37:39 +03:00
Code Issues Packages Projects Releases Wiki Activity

Ext2FS: Fix build with EXT2_DEBUG enabled, and tweak some variable names.

Browse Source
This commit is contained in:
Andreas Kling 2019-05-25 17:23:17 +02:00
parent 9cfd674a75
commit 728327df8a
Notes: sideshowbarker 2024-07-19 13:57:30 +09:00 
Author: https://github.com/awesomekling
Commit: https://github.com/SerenityOS/serenity/commit/728327df8ab
1 changed files with 39 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
Kernel/FileSystem/Ext2FileSystem.cpp
View File

@ -51,9 +51,9 @@ bool Ext2FS::write_super_block(const ext2_super_block& sb)
return true; return true;
} }
unsigned Ext2FS::first_block_of_group(unsigned groupIndex) const unsigned Ext2FS::first_block_of_group(GroupIndex group_index) const
{ {
return super_block().s_first_data_block + (groupIndex * super_block().s_blocks_per_group); return super_block().s_first_data_block + (group_index * super_block().s_blocks_per_group);
} }
const ext2_super_block& Ext2FS::super_block() const const ext2_super_block& Ext2FS::super_block() const
@ -63,10 +63,10 @@ const ext2_super_block& Ext2FS::super_block() const
return *reinterpret_cast<ext2_super_block*>(m_cached_super_block.pointer()); return *reinterpret_cast<ext2_super_block*>(m_cached_super_block.pointer());
} }
const ext2_group_desc& Ext2FS::group_descriptor(unsigned groupIndex) const const ext2_group_desc& Ext2FS::group_descriptor(GroupIndex group_index) const
{ {
// FIXME: Should this fail gracefully somehow? // FIXME: Should this fail gracefully somehow?
ASSERT(groupIndex <= m_block_group_count); ASSERT(group_index <= m_block_group_count);
if (!m_cached_group_descriptor_table) { if (!m_cached_group_descriptor_table) {
LOCKER(m_lock); LOCKER(m_lock);
@ -78,7 +78,7 @@ const ext2_group_desc& Ext2FS::group_descriptor(unsigned groupIndex) const
#endif #endif
m_cached_group_descriptor_table = read_blocks(first_block_of_bgdt, blocks_to_read); m_cached_group_descriptor_table = read_blocks(first_block_of_bgdt, blocks_to_read);
} }
return reinterpret_cast<ext2_group_desc*>(m_cached_group_descriptor_table.pointer())[groupIndex - 1]; return reinterpret_cast<ext2_group_desc*>(m_cached_group_descriptor_table.pointer())[group_index - 1];
} }
bool Ext2FS::initialize() bool Ext2FS::initialize()
@ -262,29 +262,29 @@ bool Ext2FS::write_block_list_for_inode(InodeIndex inode_index, ext2_inode& e2in
ASSERT_NOT_REACHED(); ASSERT_NOT_REACHED();
} }
Vector<unsigned> Ext2FS::block_list_for_inode(const ext2_inode& e2inode, bool include_block_list_blocks) const Vector<Ext2FS::BlockIndex> Ext2FS::block_list_for_inode(const ext2_inode& e2inode, bool include_block_list_blocks) const
{ {
LOCKER(m_lock); LOCKER(m_lock);
unsigned entries_per_block = EXT2_ADDR_PER_BLOCK(&super_block()); unsigned entries_per_block = EXT2_ADDR_PER_BLOCK(&super_block());
// NOTE: i_blocks is number of 512-byte blocks, not number of fs-blocks. // NOTE: i_blocks is number of 512-byte blocks, not number of fs-blocks.
unsigned block_count = e2inode.i_blocks / (block_size() / 512); unsigned block_count = e2inode.i_blocks / (block_size() / 512);
unsigned blocksRemaining = block_count; unsigned blocks_remaining = block_count;
Vector<unsigned> list; Vector<BlockIndex> list;
if (include_block_list_blocks) { if (include_block_list_blocks) {
// This seems like an excessive over-estimate but w/e. // This seems like an excessive over-estimate but w/e.
list.ensure_capacity(blocksRemaining * 2); list.ensure_capacity(blocks_remaining * 2);
} else { } else {
list.ensure_capacity(blocksRemaining); list.ensure_capacity(blocks_remaining);
} }
unsigned direct_count = min(block_count, (unsigned)EXT2_NDIR_BLOCKS); unsigned direct_count = min(block_count, (unsigned)EXT2_NDIR_BLOCKS);
for (unsigned i = 0; i < direct_count; ++i) { for (unsigned i = 0; i < direct_count; ++i) {
list.unchecked_append(e2inode.i_block[i]); list.unchecked_append(e2inode.i_block[i]);
--blocksRemaining; --blocks_remaining;
} }
if (!blocksRemaining) if (!blocks_remaining)
return list; return list;
auto process_block_array = [&] (unsigned array_block_index, auto&& callback) { auto process_block_array = [&] (unsigned array_block_index, auto&& callback) {
@ -293,14 +293,14 @@ Vector<unsigned> Ext2FS::block_list_for_inode(const ext2_inode& e2inode, bool in
auto array_block = read_block(array_block_index); auto array_block = read_block(array_block_index);
ASSERT(array_block); ASSERT(array_block);
auto* array = reinterpret_cast<const __u32*>(array_block.pointer()); auto* array = reinterpret_cast<const __u32*>(array_block.pointer());
unsigned count = min(blocksRemaining, entries_per_block); unsigned count = min(blocks_remaining, entries_per_block);
for (unsigned i = 0; i < count; ++i) { for (unsigned i = 0; i < count; ++i) {
if (!array[i]) { if (!array[i]) {
blocksRemaining = 0; blocks_remaining = 0;
return; return;
} }
callback(array[i]); callback(array[i]);
--blocksRemaining; --blocks_remaining;
} }
}; };
@ -308,7 +308,7 @@ Vector<unsigned> Ext2FS::block_list_for_inode(const ext2_inode& e2inode, bool in
list.unchecked_append(entry); list.unchecked_append(entry);
}); });
if (!blocksRemaining) if (!blocks_remaining)
return list; return list;
process_block_array(e2inode.i_block[EXT2_DIND_BLOCK], [&] (unsigned entry) { process_block_array(e2inode.i_block[EXT2_DIND_BLOCK], [&] (unsigned entry) {
@ -317,7 +317,7 @@ Vector<unsigned> Ext2FS::block_list_for_inode(const ext2_inode& e2inode, bool in
}); });
}); });
if (!blocksRemaining) if (!blocks_remaining)
return list; return list;
process_block_array(e2inode.i_block[EXT2_TIND_BLOCK], [&] (unsigned entry) { process_block_array(e2inode.i_block[EXT2_TIND_BLOCK], [&] (unsigned entry) {
@ -535,6 +535,12 @@ bool Ext2FSInode::resize(qword new_size)
fs().set_block_allocation_state(new_block_index, true); fs().set_block_allocation_state(new_block_index, true);
block_list.append(move(new_blocks)); block_list.append(move(new_blocks));
} else if (blocks_needed_after < blocks_needed_before) { } else if (blocks_needed_after < blocks_needed_before) {
#ifdef EXT2_DEBUG
dbgprintf("Ext2FSInode::resize(): Shrinking. Old block list is %d entries:\n", block_list.size());
for (auto block_index : block_list) {
dbgprintf(" # %u\n", block_index);
}
#endif
while (block_list.size() != blocks_needed_after) { while (block_list.size() != blocks_needed_after) {
auto block_index = block_list.take_last(); auto block_index = block_list.take_last();
fs().set_block_allocation_state(block_index, false); fs().set_block_allocation_state(block_index, false);
@ -622,7 +628,7 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const byte* data,
memset(block.pointer() + padding_start, 0, padding_bytes); memset(block.pointer() + padding_start, 0, padding_bytes);
} }
#ifdef EXT2_DEBUG #ifdef EXT2_DEBUG
dbgprintf("Ext2FSInode::write_bytes: writing block %u (offset_into_block: %u)\n", block_list[bi], offset_into_block); dbgprintf("Ext2FSInode::write_bytes: writing block %u (offset_into_block: %u)\n", m_block_list[bi], offset_into_block);
#endif #endif
bool success = fs().write_block(m_block_list[bi], block); bool success = fs().write_block(m_block_list[bi], block);
if (!success) { if (!success) {
@ -636,7 +642,7 @@ ssize_t Ext2FSInode::write_bytes(off_t offset, ssize_t count, const byte* data,
} }
#ifdef EXT2_DEBUG #ifdef EXT2_DEBUG
dbgprintf("Ext2FSInode::write_bytes: after write, i_size=%u, i_blocks=%u (%u blocks in list)\n", m_raw_inode.i_size, m_raw_inode.i_blocks, block_list.size()); dbgprintf("Ext2FSInode::write_bytes: after write, i_size=%u, i_blocks=%u (%u blocks in list)\n", m_raw_inode.i_size, m_raw_inode.i_blocks, m_block_list.size());
#endif #endif
if (old_size != new_size) if (old_size != new_size)
@ -746,10 +752,10 @@ KResult Ext2FSInode::remove_child(const String& name)
return KSuccess; return KSuccess;
} }
bool Ext2FS::write_directory_inode(unsigned directoryInode, Vector<DirectoryEntry>&& entries) bool Ext2FS::write_directory_inode(InodeIndex directory_inode_index, Vector<DirectoryEntry>&& entries)
{ {
LOCKER(m_lock); LOCKER(m_lock);
dbgprintf("Ext2FS: New directory inode %u contents to write:\n", directoryInode); dbgprintf("Ext2FS: New directory inode %u contents to write:\n", directory_inode_index);
int directory_size = 0; int directory_size = 0;
for (auto& entry : entries) { for (auto& entry : entries) {
@ -791,7 +797,7 @@ bool Ext2FS::write_directory_inode(unsigned directoryInode, Vector<DirectoryEntr
stream.fill_to_end(0); stream.fill_to_end(0);
auto directory_inode = get_inode({ fsid(), directoryInode }); auto directory_inode = get_inode({ fsid(), directory_inode_index });
ssize_t nwritten = directory_inode->write_bytes(0, directory_data.size(), directory_data.pointer(), nullptr); ssize_t nwritten = directory_inode->write_bytes(0, directory_data.size(), directory_data.pointer(), nullptr);
return nwritten == directory_data.size(); return nwritten == directory_data.size();
} }
@ -869,7 +875,7 @@ Vector<Ext2FS::BlockIndex> Ext2FS::allocate_blocks(GroupIndex group_index, int c
unsigned Ext2FS::allocate_inode(GroupIndex preferred_group, off_t expected_size) unsigned Ext2FS::allocate_inode(GroupIndex preferred_group, off_t expected_size)
{ {
LOCKER(m_lock); LOCKER(m_lock);
dbgprintf("Ext2FS: allocate_inode(preferredGroup: %u, expectedSize: %u)\n", preferred_group, expected_size); dbgprintf("Ext2FS: allocate_inode(preferredGroup: %u, expected_size: %u)\n", preferred_group, expected_size);
unsigned needed_blocks = ceil_div(expected_size, block_size()); unsigned needed_blocks = ceil_div(expected_size, block_size());
@ -877,8 +883,8 @@ unsigned Ext2FS::allocate_inode(GroupIndex preferred_group, off_t expected_size)
unsigned group_index = 0; unsigned group_index = 0;
auto is_suitable_group = [this, needed_blocks] (unsigned groupIndex) { auto is_suitable_group = [this, needed_blocks] (GroupIndex group_index) {
auto& bgd = group_descriptor(groupIndex); auto& bgd = group_descriptor(group_index);
return bgd.bg_free_inodes_count && bgd.bg_free_blocks_count >= needed_blocks; return bgd.bg_free_inodes_count && bgd.bg_free_blocks_count >= needed_blocks;
}; };
@ -957,32 +963,32 @@ bool Ext2FS::get_inode_allocation_state(InodeIndex index) const
return bitmap.get(bit_index); return bitmap.get(bit_index);
} }
bool Ext2FS::set_inode_allocation_state(unsigned index, bool newState) bool Ext2FS::set_inode_allocation_state(InodeIndex inode_index, bool new_state)
{ {
LOCKER(m_lock); LOCKER(m_lock);
unsigned group_index = group_index_from_inode(index); unsigned group_index = group_index_from_inode(inode_index);
auto& bgd = group_descriptor(group_index); auto& bgd = group_descriptor(group_index);
unsigned index_in_group = index - ((group_index - 1) * inodes_per_group()); unsigned index_in_group = inode_index - ((group_index - 1) * inodes_per_group());
unsigned bit_index = (index_in_group - 1) % inodes_per_group(); unsigned bit_index = (index_in_group - 1) % inodes_per_group();
auto block = read_block(bgd.bg_inode_bitmap); auto block = read_block(bgd.bg_inode_bitmap);
ASSERT(block); ASSERT(block);
auto bitmap = Bitmap::wrap(block.pointer(), inodes_per_group()); auto bitmap = Bitmap::wrap(block.pointer(), inodes_per_group());
bool current_state = bitmap.get(bit_index); bool current_state = bitmap.get(bit_index);
dbgprintf("Ext2FS: set_inode_allocation_state(%u) %u -> %u\n", index, current_state, newState); dbgprintf("Ext2FS: set_inode_allocation_state(%u) %u -> %u\n", inode_index, current_state, new_state);
if (current_state == newState) { if (current_state == new_state) {
ASSERT_NOT_REACHED(); ASSERT_NOT_REACHED();
return true; return true;
} }
bitmap.set(bit_index, newState); bitmap.set(bit_index, new_state);
bool success = write_block(bgd.bg_inode_bitmap, block); bool success = write_block(bgd.bg_inode_bitmap, block);
ASSERT(success); ASSERT(success);
// Update superblock // Update superblock
auto& sb = *reinterpret_cast<ext2_super_block*>(m_cached_super_block.pointer()); auto& sb = *reinterpret_cast<ext2_super_block*>(m_cached_super_block.pointer());
dbgprintf("Ext2FS: superblock free inode count %u -> %u\n", sb.s_free_inodes_count, sb.s_free_inodes_count - 1); dbgprintf("Ext2FS: superblock free inode count %u -> %u\n", sb.s_free_inodes_count, sb.s_free_inodes_count - 1);
if (newState) if (new_state)
--sb.s_free_inodes_count; --sb.s_free_inodes_count;
else else
++sb.s_free_inodes_count; ++sb.s_free_inodes_count;
@ -990,7 +996,7 @@ bool Ext2FS::set_inode_allocation_state(unsigned index, bool newState)
// Update BGD // Update BGD
auto& mutable_bgd = const_cast<ext2_group_desc&>(bgd); auto& mutable_bgd = const_cast<ext2_group_desc&>(bgd);
if (newState) if (new_state)
--mutable_bgd.bg_free_inodes_count; --mutable_bgd.bg_free_inodes_count;
else else
++mutable_bgd.bg_free_inodes_count; ++mutable_bgd.bg_free_inodes_count;