RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 16:47:36 +00:00
Code Issues Activity Actions

Everywhere: Run clang-format

Browse source
This commit is contained in:
Idan Horowitz 2022-04-01 20:58:27 +03:00 • committed by Linus Groh
parent 0376c127f6
commit 086969277e
1665 changed files with 8479 additions and 8479 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Kernel/FileSystem/AnonymousFile.cpp
View file

@ -28,7 +28,7 @@ ErrorOr<Memory::Region*> AnonymousFile::mmap(Process& process, OpenFileDescripti
return process.address_space().allocate_region_with_vmobject(range, m_vmobject, offset, {}, prot, shared);
}
ErrorOr<NonnullOwnPtr<KString>> AnonymousFile::pseudo_path(const OpenFileDescription&) const
ErrorOr<NonnullOwnPtr<KString>> AnonymousFile::pseudo_path(OpenFileDescription const&) const
{
return KString::try_create(":anonymous-file:"sv);
}

8
Kernel/FileSystem/AnonymousFile.h
View file

@ -24,11 +24,11 @@ public:
private:
virtual StringView class_name() const override { return "AnonymousFile"sv; }
virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const override;
virtual bool can_read(const OpenFileDescription&, u64) const override { return false; }
virtual bool can_write(const OpenFileDescription&, u64) const override { return false; }
virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(OpenFileDescription const&) const override;
virtual bool can_read(OpenFileDescription const&, u64) const override { return false; }
virtual bool can_write(OpenFileDescription const&, u64) const override { return false; }
virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override { return ENOTSUP; }
virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return ENOTSUP; }
virtual ErrorOr<size_t> write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t) override { return ENOTSUP; }
explicit AnonymousFile(NonnullRefPtr<Memory::AnonymousVMObject>);

10
Kernel/FileSystem/BlockBasedFileSystem.cpp
View file

@ -89,7 +89,7 @@ public:
return &new_entry;
}
const CacheEntry* entries() const { return (const CacheEntry*)m_entries->data(); }
CacheEntry const* entries() const { return (CacheEntry const*)m_entries->data(); }
CacheEntry* entries() { return (CacheEntry*)m_entries->data(); }
template<typename Callback>
@ -129,7 +129,7 @@ ErrorOr<void> BlockBasedFileSystem::initialize()
return {};
}
ErrorOr<void> BlockBasedFileSystem::write_block(BlockIndex index, const UserOrKernelBuffer& data, size_t count, u64 offset, bool allow_cache)
ErrorOr<void> BlockBasedFileSystem::write_block(BlockIndex index, UserOrKernelBuffer const& data, size_t count, u64 offset, bool allow_cache)
{
VERIFY(m_logical_block_size);
VERIFY(offset + count <= block_size());
@ -172,7 +172,7 @@ ErrorOr<void> BlockBasedFileSystem::raw_read(BlockIndex index, UserOrKernelBuffe
return {};
}
ErrorOr<void> BlockBasedFileSystem::raw_write(BlockIndex index, const UserOrKernelBuffer& buffer)
ErrorOr<void> BlockBasedFileSystem::raw_write(BlockIndex index, UserOrKernelBuffer const& buffer)
{
auto base_offset = index.value() * m_logical_block_size;
auto nwritten = TRY(file_description().write(base_offset, buffer, m_logical_block_size));
@ -190,7 +190,7 @@ ErrorOr<void> BlockBasedFileSystem::raw_read_blocks(BlockIndex index, size_t cou
return {};
}
ErrorOr<void> BlockBasedFileSystem::raw_write_blocks(BlockIndex index, size_t count, const UserOrKernelBuffer& buffer)
ErrorOr<void> BlockBasedFileSystem::raw_write_blocks(BlockIndex index, size_t count, UserOrKernelBuffer const& buffer)
{
auto current = buffer;
for (auto block = index.value(); block < (index.value() + count); block++) {
@ -200,7 +200,7 @@ ErrorOr<void> BlockBasedFileSystem::raw_write_blocks(BlockIndex index, size_t co
return {};
}
ErrorOr<void> BlockBasedFileSystem::write_blocks(BlockIndex index, unsigned count, const UserOrKernelBuffer& data, bool allow_cache)
ErrorOr<void> BlockBasedFileSystem::write_blocks(BlockIndex index, unsigned count, UserOrKernelBuffer const& data, bool allow_cache)
{
VERIFY(m_logical_block_size);
dbgln_if(BBFS_DEBUG, "BlockBasedFileSystem::write_blocks {}, count={}", index, count);

8
Kernel/FileSystem/BlockBasedFileSystem.h
View file

@ -30,13 +30,13 @@ protected:
ErrorOr<void> read_blocks(BlockIndex, unsigned count, UserOrKernelBuffer&, bool allow_cache = true) const;
ErrorOr<void> raw_read(BlockIndex, UserOrKernelBuffer&);
ErrorOr<void> raw_write(BlockIndex, const UserOrKernelBuffer&);
ErrorOr<void> raw_write(BlockIndex, UserOrKernelBuffer const&);
ErrorOr<void> raw_read_blocks(BlockIndex index, size_t count, UserOrKernelBuffer&);
ErrorOr<void> raw_write_blocks(BlockIndex index, size_t count, const UserOrKernelBuffer&);
ErrorOr<void> raw_write_blocks(BlockIndex index, size_t count, UserOrKernelBuffer const&);
ErrorOr<void> write_block(BlockIndex, const UserOrKernelBuffer&, size_t count, u64 offset = 0, bool allow_cache = true);
ErrorOr<void> write_blocks(BlockIndex, unsigned count, const UserOrKernelBuffer&, bool allow_cache = true);
ErrorOr<void> write_block(BlockIndex, UserOrKernelBuffer const&, size_t count, u64 offset = 0, bool allow_cache = true);
ErrorOr<void> write_blocks(BlockIndex, unsigned count, UserOrKernelBuffer const&, bool allow_cache = true);
u64 m_logical_block_size { 512 };

2
Kernel/FileSystem/DevPtsFS.cpp
View file

@ -83,7 +83,7 @@ ErrorOr<size_t> DevPtsFSInode::read_bytes(off_t, size_t, UserOrKernelBuffer&, Op
VERIFY_NOT_REACHED();
}
ErrorOr<size_t> DevPtsFSInode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*)
ErrorOr<size_t> DevPtsFSInode::write_bytes(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*)
{
VERIFY_NOT_REACHED();
}

2
Kernel/FileSystem/DevPtsFS.h
View file

@ -52,7 +52,7 @@ private:
virtual ErrorOr<void> traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const override;
virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
virtual ErrorOr<void> flush_metadata() override;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const& buffer, OpenFileDescription*) override;
virtual ErrorOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
virtual ErrorOr<void> add_child(Inode&, StringView name, mode_t) override;
virtual ErrorOr<void> remove_child(StringView name) override;

4
Kernel/FileSystem/DevTmpFS.cpp
View file

@ -71,7 +71,7 @@ ErrorOr<void> DevTmpFSInode::flush_metadata()
return {};
}
ErrorOr<size_t> DevTmpFSInode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*)
ErrorOr<size_t> DevTmpFSInode::write_bytes(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*)
{
VERIFY_NOT_REACHED();
}
@ -318,7 +318,7 @@ ErrorOr<size_t> DevTmpFSDeviceInode::read_bytes(off_t offset, size_t count, User
return result.value();
}
ErrorOr<size_t> DevTmpFSDeviceInode::write_bytes(off_t offset, size_t count, const UserOrKernelBuffer& buffer, OpenFileDescription* description)
ErrorOr<size_t> DevTmpFSDeviceInode::write_bytes(off_t offset, size_t count, UserOrKernelBuffer const& buffer, OpenFileDescription* description)
{
MutexLocker locker(m_inode_lock);
VERIFY(!!description);

8
Kernel/FileSystem/DevTmpFS.h
View file

@ -53,7 +53,7 @@ protected:
virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
virtual ErrorOr<void> flush_metadata() override;
virtual InodeMetadata metadata() const override final;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const& buffer, OpenFileDescription*) override;
virtual ErrorOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
virtual ErrorOr<void> add_child(Inode&, StringView name, mode_t) override;
virtual ErrorOr<void> remove_child(StringView name) override;
@ -96,10 +96,10 @@ private:
// ^Inode
virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const& buffer, OpenFileDescription*) override;
NonnullOwnPtr<KString> m_name;
const bool m_block_device;
bool const m_block_device;
};
class DevTmpFSLinkInode final : public DevTmpFSInode {
@ -117,7 +117,7 @@ protected:
// ^Inode
virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const& buffer, OpenFileDescription*) override;
NonnullOwnPtr<KString> m_name;
OwnPtr<KString> m_link;

72
Kernel/FileSystem/Ext2FileSystem.cpp
View file

@ -69,7 +69,7 @@ ErrorOr<void> Ext2FS::flush_super_block()
return raw_write_blocks(2, (sizeof(ext2_super_block) / logical_block_size()), super_block_buffer);
}
const ext2_group_desc& Ext2FS::group_descriptor(GroupIndex group_index) const
ext2_group_desc const& Ext2FS::group_descriptor(GroupIndex group_index) const
{
// FIXME: Should this fail gracefully somehow?
VERIFY(group_index <= m_block_group_count);
@ -164,7 +164,7 @@ bool Ext2FS::find_block_containing_inode(InodeIndex inode, BlockIndex& block_ind
Ext2FS::BlockListShape Ext2FS::compute_block_list_shape(unsigned blocks) const
{
BlockListShape shape;
const unsigned entries_per_block = EXT2_ADDR_PER_BLOCK(&super_block());
unsigned const entries_per_block = EXT2_ADDR_PER_BLOCK(&super_block());
unsigned blocks_remaining = blocks;
shape.direct_blocks = min((unsigned)EXT2_NDIR_BLOCKS, blocks_remaining);
@ -196,7 +196,7 @@ Ext2FS::BlockListShape Ext2FS::compute_block_list_shape(unsigned blocks) const
ErrorOr<void> Ext2FSInode::write_indirect_block(BlockBasedFileSystem::BlockIndex block, Span<BlockBasedFileSystem::BlockIndex> blocks_indices)
{
const auto entries_per_block = EXT2_ADDR_PER_BLOCK(&fs().super_block());
auto const entries_per_block = EXT2_ADDR_PER_BLOCK(&fs().super_block());
VERIFY(blocks_indices.size() <= entries_per_block);
auto block_contents = TRY(ByteBuffer::create_uninitialized(fs().block_size()));
@ -213,10 +213,10 @@ ErrorOr<void> Ext2FSInode::write_indirect_block(BlockBasedFileSystem::BlockIndex
ErrorOr<void> Ext2FSInode::grow_doubly_indirect_block(BlockBasedFileSystem::BlockIndex block, size_t old_blocks_length, Span<BlockBasedFileSystem::BlockIndex> blocks_indices, Vector<Ext2FS::BlockIndex>& new_meta_blocks, unsigned& meta_blocks)
{
const auto entries_per_block = EXT2_ADDR_PER_BLOCK(&fs().super_block());
const auto entries_per_doubly_indirect_block = entries_per_block * entries_per_block;
const auto old_indirect_blocks_length = ceil_div(old_blocks_length, entries_per_block);
const auto new_indirect_blocks_length = ceil_div(blocks_indices.size(), entries_per_block);
auto const entries_per_block = EXT2_ADDR_PER_BLOCK(&fs().super_block());
auto const entries_per_doubly_indirect_block = entries_per_block * entries_per_block;
auto const old_indirect_blocks_length = ceil_div(old_blocks_length, entries_per_block);
auto const new_indirect_blocks_length = ceil_div(blocks_indices.size(), entries_per_block);
VERIFY(blocks_indices.size() > 0);
VERIFY(blocks_indices.size() > old_blocks_length);
VERIFY(blocks_indices.size() <= entries_per_doubly_indirect_block);
@ -243,7 +243,7 @@ ErrorOr<void> Ext2FSInode::grow_doubly_indirect_block(BlockBasedFileSystem::Bloc
// 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;
auto const offset_block = i * entries_per_block;
TRY(write_indirect_block(block_as_pointers[i], blocks_indices.slice(offset_block, min(blocks_indices.size() - offset_block, entries_per_block))));
}
@ -253,10 +253,10 @@ ErrorOr<void> Ext2FSInode::grow_doubly_indirect_block(BlockBasedFileSystem::Bloc
ErrorOr<void> Ext2FSInode::shrink_doubly_indirect_block(BlockBasedFileSystem::BlockIndex block, size_t old_blocks_length, size_t new_blocks_length, unsigned& meta_blocks)
{
const auto entries_per_block = EXT2_ADDR_PER_BLOCK(&fs().super_block());
const auto entries_per_doubly_indirect_block = entries_per_block * entries_per_block;
const auto old_indirect_blocks_length = ceil_div(old_blocks_length, entries_per_block);
const auto new_indirect_blocks_length = ceil_div(new_blocks_length, entries_per_block);
auto const entries_per_block = EXT2_ADDR_PER_BLOCK(&fs().super_block());
auto const entries_per_doubly_indirect_block = entries_per_block * entries_per_block;
auto const old_indirect_blocks_length = ceil_div(old_blocks_length, entries_per_block);
auto const new_indirect_blocks_length = ceil_div(new_blocks_length, entries_per_block);
VERIFY(old_blocks_length > 0);
VERIFY(old_blocks_length >= new_blocks_length);
VERIFY(new_blocks_length <= entries_per_doubly_indirect_block);
@ -285,11 +285,11 @@ ErrorOr<void> Ext2FSInode::shrink_doubly_indirect_block(BlockBasedFileSystem::Bl
ErrorOr<void> Ext2FSInode::grow_triply_indirect_block(BlockBasedFileSystem::BlockIndex block, size_t old_blocks_length, Span<BlockBasedFileSystem::BlockIndex> blocks_indices, Vector<Ext2FS::BlockIndex>& new_meta_blocks, unsigned& meta_blocks)
{
const auto entries_per_block = EXT2_ADDR_PER_BLOCK(&fs().super_block());
const auto entries_per_doubly_indirect_block = entries_per_block * entries_per_block;
const auto entries_per_triply_indirect_block = entries_per_block * entries_per_block;
const auto old_doubly_indirect_blocks_length = ceil_div(old_blocks_length, entries_per_doubly_indirect_block);
const auto new_doubly_indirect_blocks_length = ceil_div(blocks_indices.size(), entries_per_doubly_indirect_block);
auto const entries_per_block = EXT2_ADDR_PER_BLOCK(&fs().super_block());
auto const entries_per_doubly_indirect_block = entries_per_block * entries_per_block;
auto const entries_per_triply_indirect_block = entries_per_block * entries_per_block;
auto const old_doubly_indirect_blocks_length = ceil_div(old_blocks_length, entries_per_doubly_indirect_block);
auto const new_doubly_indirect_blocks_length = ceil_div(blocks_indices.size(), entries_per_doubly_indirect_block);
VERIFY(blocks_indices.size() > 0);
VERIFY(blocks_indices.size() > old_blocks_length);
VERIFY(blocks_indices.size() <= entries_per_triply_indirect_block);
@ -316,9 +316,9 @@ ErrorOr<void> Ext2FSInode::grow_triply_indirect_block(BlockBasedFileSystem::Bloc
// Write out the doubly indirect blocks.
for (unsigned i = old_blocks_length / entries_per_doubly_indirect_block; i < new_doubly_indirect_blocks_length; i++) {
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);
auto const processed_blocks = i * entries_per_doubly_indirect_block;
auto const old_doubly_indirect_blocks_length = min(old_blocks_length > processed_blocks ? old_blocks_length - processed_blocks : 0, entries_per_doubly_indirect_block);
auto const new_doubly_indirect_blocks_length = min(blocks_indices.size() > processed_blocks ? blocks_indices.size() - processed_blocks : 0, entries_per_doubly_indirect_block);
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));
}
@ -328,11 +328,11 @@ ErrorOr<void> Ext2FSInode::grow_triply_indirect_block(BlockBasedFileSystem::Bloc
ErrorOr<void> Ext2FSInode::shrink_triply_indirect_block(BlockBasedFileSystem::BlockIndex block, size_t old_blocks_length, size_t new_blocks_length, unsigned& meta_blocks)
{
const auto entries_per_block = EXT2_ADDR_PER_BLOCK(&fs().super_block());
const auto entries_per_doubly_indirect_block = entries_per_block * entries_per_block;
const auto entries_per_triply_indirect_block = entries_per_doubly_indirect_block * entries_per_block;
const auto old_triply_indirect_blocks_length = ceil_div(old_blocks_length, entries_per_doubly_indirect_block);
const auto new_triply_indirect_blocks_length = new_blocks_length / entries_per_doubly_indirect_block;
auto const entries_per_block = EXT2_ADDR_PER_BLOCK(&fs().super_block());
auto const entries_per_doubly_indirect_block = entries_per_block * entries_per_block;
auto const entries_per_triply_indirect_block = entries_per_doubly_indirect_block * entries_per_block;
auto const old_triply_indirect_blocks_length = ceil_div(old_blocks_length, entries_per_doubly_indirect_block);
auto const new_triply_indirect_blocks_length = new_blocks_length / entries_per_doubly_indirect_block;
VERIFY(old_blocks_length > 0);
VERIFY(old_blocks_length >= new_blocks_length);
VERIFY(new_blocks_length <= entries_per_triply_indirect_block);
@ -344,9 +344,9 @@ ErrorOr<void> Ext2FSInode::shrink_triply_indirect_block(BlockBasedFileSystem::Bl
// Shrink the doubly indirect blocks.
for (unsigned i = new_triply_indirect_blocks_length; i < old_triply_indirect_blocks_length; i++) {
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(new_blocks_length > processed_blocks ? new_blocks_length - processed_blocks : 0, entries_per_doubly_indirect_block);
auto const processed_blocks = i * entries_per_doubly_indirect_block;
auto const old_doubly_indirect_blocks_length = min(old_blocks_length > processed_blocks ? old_blocks_length - processed_blocks : 0, entries_per_doubly_indirect_block);
auto const 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);
TRY(shrink_doubly_indirect_block(block_as_pointers[i], old_doubly_indirect_blocks_length, new_doubly_indirect_blocks_length, meta_blocks));
}
@ -373,10 +373,10 @@ ErrorOr<void> Ext2FSInode::flush_block_list()
}
// NOTE: There is a mismatch between i_blocks and blocks.size() since i_blocks includes meta blocks and blocks.size() does not.
const auto old_block_count = ceil_div(size(), static_cast<u64>(fs().block_size()));
auto const old_block_count = ceil_div(size(), static_cast<u64>(fs().block_size()));
auto old_shape = fs().compute_block_list_shape(old_block_count);
const auto new_shape = fs().compute_block_list_shape(m_block_list.size());
auto const new_shape = fs().compute_block_list_shape(m_block_list.size());
Vector<Ext2FS::BlockIndex> new_meta_blocks;
if (new_shape.meta_blocks > old_shape.meta_blocks) {
@ -813,7 +813,7 @@ ErrorOr<size_t> Ext2FSInode::read_bytes(off_t offset, size_t count, UserOrKernel
if (is_symlink() && size() < max_inline_symlink_length) {
VERIFY(offset == 0);
size_t nread = min((off_t)size() - offset, static_cast<off_t>(count));
TRY(buffer.write(((const u8*)m_raw_inode.i_block) + offset, nread));
TRY(buffer.write(((u8 const*)m_raw_inode.i_block) + offset, nread));
return nread;
}
@ -827,7 +827,7 @@ ErrorOr<size_t> Ext2FSInode::read_bytes(off_t offset, size_t count, UserOrKernel
bool allow_cache = !description || !description->is_direct();
const int block_size = fs().block_size();
int const block_size = fs().block_size();
BlockBasedFileSystem::BlockIndex first_block_logical_index = offset / block_size;
BlockBasedFileSystem::BlockIndex last_block_logical_index = (offset + count) / block_size;
@ -935,7 +935,7 @@ ErrorOr<void> Ext2FSInode::resize(u64 new_size)
return {};
}
ErrorOr<size_t> Ext2FSInode::write_bytes(off_t offset, size_t count, const UserOrKernelBuffer& data, OpenFileDescription* description)
ErrorOr<size_t> Ext2FSInode::write_bytes(off_t offset, size_t count, UserOrKernelBuffer const& data, OpenFileDescription* description)
{
VERIFY(offset >= 0);
@ -960,7 +960,7 @@ ErrorOr<size_t> Ext2FSInode::write_bytes(off_t offset, size_t count, const UserO
bool allow_cache = !description || !description->is_direct();
const auto block_size = fs().block_size();
auto const block_size = fs().block_size();
auto new_size = max(static_cast<u64>(offset) + count, size());
TRY(resize(new_size));
@ -1003,7 +1003,7 @@ ErrorOr<size_t> Ext2FSInode::write_bytes(off_t offset, size_t count, const UserO
return nwritten;
}
u8 Ext2FS::internal_file_type_to_directory_entry_type(const DirectoryEntryView& entry) const
u8 Ext2FS::internal_file_type_to_directory_entry_type(DirectoryEntryView const& entry) const
{
switch (entry.file_type) {
case EXT2_FT_REG_FILE:
@ -1219,7 +1219,7 @@ ErrorOr<void> Ext2FS::write_ext2_inode(InodeIndex inode, ext2_inode const& e2ino
unsigned offset;
if (!find_block_containing_inode(inode, block_index, offset))
return EINVAL;
auto buffer = UserOrKernelBuffer::for_kernel_buffer(const_cast<u8*>((const u8*)&e2inode));
auto buffer = UserOrKernelBuffer::for_kernel_buffer(const_cast<u8*>((u8 const*)&e2inode));
return write_block(block_index, buffer, inode_size(), offset);
}

16
Kernel/FileSystem/Ext2FileSystem.h
View file

@ -40,7 +40,7 @@ private:
virtual ErrorOr<void> traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const override;
virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
virtual ErrorOr<void> flush_metadata() override;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& data, OpenFileDescription*) override;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const& data, OpenFileDescription*) override;
virtual ErrorOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
virtual ErrorOr<void> add_child(Inode& child, StringView name, mode_t) override;
virtual ErrorOr<void> remove_child(StringView name) override;
@ -69,7 +69,7 @@ private:
ErrorOr<Vector<BlockBasedFileSystem::BlockIndex>> compute_block_list_impl_internal(ext2_inode const&, bool include_block_list_blocks) const;
Ext2FS& fs();
const Ext2FS& fs() const;
Ext2FS const& fs() const;
Ext2FSInode(Ext2FS&, InodeIndex);
mutable Vector<BlockBasedFileSystem::BlockIndex> m_block_list;
@ -100,7 +100,7 @@ public:
virtual bool supports_watchers() const override { return true; }
virtual u8 internal_file_type_to_directory_entry_type(const DirectoryEntryView& entry) const override;
virtual u8 internal_file_type_to_directory_entry_type(DirectoryEntryView const& entry) const override;
FeaturesReadOnly get_features_readonly() const;
@ -109,10 +109,10 @@ private:
explicit Ext2FS(OpenFileDescription&);
const ext2_super_block& super_block() const { return m_super_block; }
const ext2_group_desc& group_descriptor(GroupIndex) const;
ext2_super_block const& super_block() const { return m_super_block; }
ext2_group_desc const& group_descriptor(GroupIndex) const;
ext2_group_desc* block_group_descriptors() { return (ext2_group_desc*)m_cached_group_descriptor_table->data(); }
const ext2_group_desc* block_group_descriptors() const { return (const ext2_group_desc*)m_cached_group_descriptor_table->data(); }
ext2_group_desc const* block_group_descriptors() const { return (ext2_group_desc const*)m_cached_group_descriptor_table->data(); }
void flush_block_group_descriptor_table();
u64 inodes_per_block() const;
u64 inodes_per_group() const;
@ -188,9 +188,9 @@ inline Ext2FS& Ext2FSInode::fs()
return static_cast<Ext2FS&>(Inode::fs());
}
inline const Ext2FS& Ext2FSInode::fs() const
inline Ext2FS const& Ext2FSInode::fs() const
{
return static_cast<const Ext2FS&>(Inode::fs());
return static_cast<Ext2FS const&>(Inode::fs());
}
}

8
Kernel/FileSystem/FIFO.cpp
View file

@ -97,12 +97,12 @@ void FIFO::detach(Direction direction)
evaluate_block_conditions();
}
bool FIFO::can_read(const OpenFileDescription&, u64) const
bool FIFO::can_read(OpenFileDescription const&, u64) const
{
return !m_buffer->is_empty() || !m_writers;
}
bool FIFO::can_write(const OpenFileDescription&, u64) const
bool FIFO::can_write(OpenFileDescription const&, u64) const
{
return m_buffer->space_for_writing() || !m_readers;
}
@ -118,7 +118,7 @@ ErrorOr<size_t> FIFO::read(OpenFileDescription& fd, u64, UserOrKernelBuffer& buf
return m_buffer->read(buffer, size);
}
ErrorOr<size_t> FIFO::write(OpenFileDescription& fd, u64, const UserOrKernelBuffer& buffer, size_t size)
ErrorOr<size_t> FIFO::write(OpenFileDescription& fd, u64, UserOrKernelBuffer const& buffer, size_t size)
{
if (!m_readers) {
Thread::current()->send_signal(SIGPIPE, &Process::current());
@ -130,7 +130,7 @@ ErrorOr<size_t> FIFO::write(OpenFileDescription& fd, u64, const UserOrKernelBuff
return m_buffer->write(buffer, size);
}
ErrorOr<NonnullOwnPtr<KString>> FIFO::pseudo_path(const OpenFileDescription&) const
ErrorOr<NonnullOwnPtr<KString>> FIFO::pseudo_path(OpenFileDescription const&) const
{
return KString::formatted("fifo:{}", m_fifo_id);
}

8
Kernel/FileSystem/FIFO.h
View file

@ -40,12 +40,12 @@ public:
private:
// ^File
virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
virtual ErrorOr<size_t> write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t) override;
virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
virtual ErrorOr<struct stat> stat() const override;
virtual bool can_read(const OpenFileDescription&, u64) const override;
virtual bool can_write(const OpenFileDescription&, u64) const override;
virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const override;
virtual bool can_read(OpenFileDescription const&, u64) const override;
virtual bool can_write(OpenFileDescription const&, u64) const override;
virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(OpenFileDescription const&) const override;
virtual StringView class_name() const override { return "FIFO"sv; }
virtual bool is_fifo() const override { return true; }

8
Kernel/FileSystem/File.h
View file

@ -81,20 +81,20 @@ public:
virtual ErrorOr<NonnullRefPtr<OpenFileDescription>> open(int options);
virtual ErrorOr<void> close();
virtual bool can_read(const OpenFileDescription&, u64) const = 0;
virtual bool can_write(const OpenFileDescription&, u64) const = 0;
virtual bool can_read(OpenFileDescription const&, u64) const = 0;
virtual bool can_write(OpenFileDescription const&, u64) const = 0;
virtual ErrorOr<void> attach(OpenFileDescription&);
virtual void detach(OpenFileDescription&);
virtual void did_seek(OpenFileDescription&, off_t) { }
virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) = 0;
virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) = 0;
virtual ErrorOr<size_t> write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t) = 0;
virtual ErrorOr<void> ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg);
virtual ErrorOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared);
virtual ErrorOr<struct stat> stat() const { return EBADF; }
// Although this might be better described "name" or "description", these terms already have other meanings.
virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const = 0;
virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(OpenFileDescription const&) const = 0;
virtual ErrorOr<void> truncate(u64) { return EINVAL; }
virtual ErrorOr<void> sync() { return EINVAL; }

2
Kernel/FileSystem/FileBackedFileSystem.h
View file

@ -17,7 +17,7 @@ public:
File& file() { return m_file_description->file(); }
OpenFileDescription& file_description() { return *m_file_description; }
const File& file() const { return m_file_description->file(); }
File const& file() const { return m_file_description->file(); }
OpenFileDescription& file_description() const { return *m_file_description; }
protected:

6
Kernel/FileSystem/FileSystem.h
View file

@ -61,7 +61,7 @@ public:
virtual bool is_file_backed() const { return false; }
// Converts file types that are used internally by the filesystem to DT_* types
virtual u8 internal_file_type_to_directory_entry_type(const DirectoryEntryView& entry) const { return entry.file_type; }
virtual u8 internal_file_type_to_directory_entry_type(DirectoryEntryView const& entry) const { return entry.file_type; }
protected:
FileSystem();
@ -83,7 +83,7 @@ inline FileSystem* InodeIdentifier::fs() // NOLINT(readability-make-member-funct
return FileSystem::from_fsid(m_fsid);
}
inline const FileSystem* InodeIdentifier::fs() const
inline FileSystem const* InodeIdentifier::fs() const
{
return FileSystem::from_fsid(m_fsid);
}
@ -94,7 +94,7 @@ namespace AK {
template<>
struct Traits<Kernel::InodeIdentifier> : public GenericTraits<Kernel::InodeIdentifier> {
static unsigned hash(const Kernel::InodeIdentifier& inode) { return pair_int_hash(inode.fsid().value(), inode.index().value()); }
static unsigned hash(Kernel::InodeIdentifier const& inode) { return pair_int_hash(inode.fsid().value(), inode.index().value()); }
};
}

4
Kernel/FileSystem/ISO9660FileSystem.cpp
View file

@ -214,7 +214,7 @@ unsigned ISO9660FS::total_inode_count() const
return m_cached_inode_count;
}
u8 ISO9660FS::internal_file_type_to_directory_entry_type(const DirectoryEntryView& entry) const
u8 ISO9660FS::internal_file_type_to_directory_entry_type(DirectoryEntryView const& entry) const
{
if (has_flag(static_cast<ISO::FileFlags>(entry.file_type), ISO::FileFlags::Directory)) {
return DT_DIR;
@ -493,7 +493,7 @@ ErrorOr<void> ISO9660Inode::flush_metadata()
return {};
}
ErrorOr<size_t> ISO9660Inode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*)
ErrorOr<size_t> ISO9660Inode::write_bytes(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*)
{
return EROFS;
}

2
Kernel/FileSystem/ISO9660FileSystem.h
View file

@ -352,7 +352,7 @@ public:
virtual ErrorOr<void> traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const override;
virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
virtual ErrorOr<void> flush_metadata() override;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const& buffer, OpenFileDescription*) override;
virtual ErrorOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
virtual ErrorOr<void> add_child(Inode&, StringView name, mode_t) override;
virtual ErrorOr<void> remove_child(StringView name) override;

2
Kernel/FileSystem/Inode.cpp
View file

@ -63,7 +63,7 @@ ErrorOr<NonnullOwnPtr<KBuffer>> Inode::read_entire(OpenFileDescription* descript
VERIFY(nread <= sizeof(buffer));
if (nread == 0)
break;
TRY(builder.append((const char*)buffer, nread));
TRY(builder.append((char const*)buffer, nread));
offset += nread;
if (nread < sizeof(buffer))
break;

2
Kernel/FileSystem/Inode.h
View file

@ -54,7 +54,7 @@ public:
virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const = 0;
virtual ErrorOr<void> traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const = 0;
virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) = 0;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& data, OpenFileDescription*) = 0;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const& data, OpenFileDescription*) = 0;
virtual ErrorOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) = 0;
virtual ErrorOr<void> add_child(Inode&, StringView name, mode_t) = 0;
virtual ErrorOr<void> remove_child(StringView name) = 0;

4
Kernel/FileSystem/InodeFile.cpp
View file

@ -37,7 +37,7 @@ ErrorOr<size_t> InodeFile::read(OpenFileDescription& description, u64 offset, Us
return nread;
}
ErrorOr<size_t> InodeFile::write(OpenFileDescription& description, u64 offset, const UserOrKernelBuffer& data, size_t count)
ErrorOr<size_t> InodeFile::write(OpenFileDescription& description, u64 offset, UserOrKernelBuffer const& data, size_t count)
{
if (Checked<off_t>::addition_would_overflow(offset, count))
return EOVERFLOW;
@ -91,7 +91,7 @@ ErrorOr<Memory::Region*> InodeFile::mmap(Process& process, OpenFileDescription&
return process.address_space().allocate_region_with_vmobject(range, vmobject.release_nonnull(), offset, path->view(), prot, shared);
}
ErrorOr<NonnullOwnPtr<KString>> InodeFile::pseudo_path(const OpenFileDescription&) const
ErrorOr<NonnullOwnPtr<KString>> InodeFile::pseudo_path(OpenFileDescription const&) const
{
// If it has an inode, then it has a path, and therefore the caller should have been able to get a custody at some point.
VERIFY_NOT_REACHED();

10
Kernel/FileSystem/InodeFile.h
View file

@ -24,19 +24,19 @@ public:
virtual ~InodeFile() override;
const Inode& inode() const { return *m_inode; }
Inode const& inode() const { return *m_inode; }
Inode& inode() { return *m_inode; }
virtual bool can_read(const OpenFileDescription&, u64) const override { return true; }
virtual bool can_write(const OpenFileDescription&, u64) const override { return true; }
virtual bool can_read(OpenFileDescription const&, u64) const override { return true; }
virtual bool can_write(OpenFileDescription const&, u64) const override { return true; }
virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override;
virtual ErrorOr<size_t> write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t) override;
virtual ErrorOr<void> ioctl(OpenFileDescription&, unsigned request, Userspace<void*> arg) override;
virtual ErrorOr<Memory::Region*> mmap(Process&, OpenFileDescription&, Memory::VirtualRange const&, u64 offset, int prot, bool shared) override;
virtual ErrorOr<struct stat> stat() const override { return inode().metadata().stat(); }
virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const override;
virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(OpenFileDescription const&) const override;
virtual ErrorOr<void> truncate(u64) override;
virtual ErrorOr<void> sync() override;

6
Kernel/FileSystem/InodeIdentifier.h
View file

@ -33,14 +33,14 @@ public:
InodeIndex index() const { return m_index; }
FileSystem* fs();
const FileSystem* fs() const;
FileSystem const* fs() const;
bool operator==(const InodeIdentifier& other) const
bool operator==(InodeIdentifier const& other) const
{
return m_fsid == other.m_fsid && m_index == other.m_index;
}
bool operator!=(const InodeIdentifier& other) const
bool operator!=(InodeIdentifier const& other) const
{
return m_fsid != other.m_fsid || m_index != other.m_index;
}

6
Kernel/FileSystem/InodeMetadata.h
View file

@ -38,9 +38,9 @@ inline bool is_setgid(mode_t mode) { return (mode & S_ISGID) == S_ISGID; }
struct InodeMetadata {
bool is_valid() const { return inode.is_valid(); }
bool may_read(const Process&) const;
bool may_write(const Process&) const;
bool may_execute(const Process&) const;
bool may_read(Process const&) const;
bool may_write(Process const&) const;
bool may_execute(Process const&) const;
bool may_read(UserID u, GroupID g, Span<GroupID const> eg) const
{

4
Kernel/FileSystem/InodeWatcher.cpp
View file

@ -22,7 +22,7 @@ InodeWatcher::~InodeWatcher()
(void)close();
}
bool InodeWatcher::can_read(const OpenFileDescription&, u64) const
bool InodeWatcher::can_read(OpenFileDescription const&, u64) const
{
MutexLocker locker(m_lock);
return !m_queue.is_empty();
@ -81,7 +81,7 @@ ErrorOr<void> InodeWatcher::close()
return {};
}
ErrorOr<NonnullOwnPtr<KString>> InodeWatcher::pseudo_path(const OpenFileDescription&) const
ErrorOr<NonnullOwnPtr<KString>> InodeWatcher::pseudo_path(OpenFileDescription const&) const
{
return KString::formatted("InodeWatcher:({})", m_wd_to_watches.size());
}

8
Kernel/FileSystem/InodeWatcher.h
View file

@ -43,14 +43,14 @@ public:
static ErrorOr<NonnullRefPtr<InodeWatcher>> try_create();
virtual ~InodeWatcher() override;
virtual bool can_read(const OpenFileDescription&, u64) const override;
virtual bool can_read(OpenFileDescription const&, u64) const override;
virtual ErrorOr<size_t> read(OpenFileDescription&, u64, UserOrKernelBuffer&, size_t) override;
// Can't write to an inode watcher.
virtual bool can_write(const OpenFileDescription&, u64) const override { return true; }
virtual ErrorOr<size_t> write(OpenFileDescription&, u64, const UserOrKernelBuffer&, size_t) override { return EIO; }
virtual bool can_write(OpenFileDescription const&, u64) const override { return true; }
virtual ErrorOr<size_t> write(OpenFileDescription&, u64, UserOrKernelBuffer const&, size_t) override { return EIO; }
virtual ErrorOr<void> close() override;
virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(const OpenFileDescription&) const override;
virtual ErrorOr<NonnullOwnPtr<KString>> pseudo_path(OpenFileDescription const&) const override;
virtual StringView class_name() const override { return "InodeWatcher"sv; };
virtual bool is_inode_watcher() const override { return true; }

18
Kernel/FileSystem/OpenFileDescription.cpp
View file

@ -175,7 +175,7 @@ ErrorOr<size_t> OpenFileDescription::read(UserOrKernelBuffer& buffer, size_t cou
return nread;
}
ErrorOr<size_t> OpenFileDescription::write(const UserOrKernelBuffer& data, size_t size)
ErrorOr<size_t> OpenFileDescription::write(UserOrKernelBuffer const& data, size_t size)
{
auto offset = TRY(m_state.with([&](auto& state) -> ErrorOr<off_t> {
if (Checked<off_t>::addition_would_overflow(state.current_offset, size))
@ -275,11 +275,11 @@ bool OpenFileDescription::is_device() const
return m_file->is_device();
}
const Device* OpenFileDescription::device() const
Device const* OpenFileDescription::device() const
{
if (!is_device())
return nullptr;
return static_cast<const Device*>(m_file.ptr());
return static_cast<Device const*>(m_file.ptr());
}
Device* OpenFileDescription::device()
@ -313,11 +313,11 @@ bool OpenFileDescription::is_inode_watcher() const
return m_file->is_inode_watcher();
}
const InodeWatcher* OpenFileDescription::inode_watcher() const
InodeWatcher const* OpenFileDescription::inode_watcher() const
{
if (!is_inode_watcher())
return nullptr;
return static_cast<const InodeWatcher*>(m_file.ptr());
return static_cast<InodeWatcher const*>(m_file.ptr());
}
InodeWatcher* OpenFileDescription::inode_watcher()
@ -332,11 +332,11 @@ bool OpenFileDescription::is_master_pty() const
return m_file->is_master_pty();
}
const MasterPTY* OpenFileDescription::master_pty() const
MasterPTY const* OpenFileDescription::master_pty() const
{
if (!is_master_pty())
return nullptr;
return static_cast<const MasterPTY*>(m_file.ptr());
return static_cast<MasterPTY const*>(m_file.ptr());
}
MasterPTY* OpenFileDescription::master_pty()
@ -413,11 +413,11 @@ Socket* OpenFileDescription::socket()
return static_cast<Socket*>(m_file.ptr());
}
const Socket* OpenFileDescription::socket() const
Socket const* OpenFileDescription::socket() const
{
if (!is_socket())
return nullptr;
return static_cast<const Socket*>(m_file.ptr());
return static_cast<Socket const*>(m_file.ptr());
}
void OpenFileDescription::set_file_flags(u32 flags)

16
Kernel/FileSystem/OpenFileDescription.h
View file

@ -42,7 +42,7 @@ public:
ErrorOr<off_t> seek(off_t, int whence);
ErrorOr<size_t> read(UserOrKernelBuffer&, size_t);
ErrorOr<size_t> write(const UserOrKernelBuffer& data, size_t);
ErrorOr<size_t> write(UserOrKernelBuffer const& data, size_t);
ErrorOr<struct stat> stat();
// NOTE: These ignore the current offset of this file description.
@ -66,10 +66,10 @@ public:
bool is_directory() const;
File& file() { return *m_file; }
const File& file() const { return *m_file; }
File const& file() const { return *m_file; }
bool is_device() const;
const Device* device() const;
Device const* device() const;
Device* device();
bool is_tty() const;
@ -77,19 +77,19 @@ public:
TTY* tty();
bool is_inode_watcher() const;
const InodeWatcher* inode_watcher() const;
InodeWatcher const* inode_watcher() const;
InodeWatcher* inode_watcher();
bool is_master_pty() const;
const MasterPTY* master_pty() const;
MasterPTY const* master_pty() const;
MasterPTY* master_pty();
InodeMetadata metadata() const;
Inode* inode() { return m_inode.ptr(); }
const Inode* inode() const { return m_inode.ptr(); }
Inode const* inode() const { return m_inode.ptr(); }
Custody* custody() { return m_custody.ptr(); }
const Custody* custody() const { return m_custody.ptr(); }
Custody const* custody() const { return m_custody.ptr(); }
ErrorOr<Memory::Region*> mmap(Process&, Memory::VirtualRange const&, u64 offset, int prot, bool shared);
@ -103,7 +103,7 @@ public:
bool is_socket() const;
Socket* socket();
const Socket* socket() const;
Socket const* socket() const;
bool is_fifo() const;
FIFO* fifo();

12
Kernel/FileSystem/Plan9FileSystem.cpp
View file

@ -169,7 +169,7 @@ public:
~Message();
Message& operator=(Message&&);
const KBuffer& build();
KBuffer const& build();
static constexpr size_t max_header_size = 24;
@ -179,7 +179,7 @@ private:
{
VERIFY(!m_have_been_built);
// FIXME: Handle append failure.
(void)m_builder.append(reinterpret_cast<const char*>(&number), sizeof(number));
(void)m_builder.append(reinterpret_cast<char const*>(&number), sizeof(number));
return *this;
}
@ -375,7 +375,7 @@ Plan9FS::Message& Plan9FS::Message::operator=(Message&& message)
return *this;
}
const KBuffer& Plan9FS::Message::build()
KBuffer const& Plan9FS::Message::build()
{
VERIFY(!m_have_been_built);
@ -472,7 +472,7 @@ void Plan9FS::Plan9FSBlockerSet::try_unblock(Plan9FS::Blocker& blocker)
}
}
bool Plan9FS::is_complete(const ReceiveCompletion& completion)
bool Plan9FS::is_complete(ReceiveCompletion const& completion)
{
MutexLocker locker(m_lock);
if (m_completions.contains(completion.tag)) {
@ -490,7 +490,7 @@ bool Plan9FS::is_complete(const ReceiveCompletion& completion)
ErrorOr<void> Plan9FS::post_message(Message& message, RefPtr<ReceiveCompletion> completion)
{
auto const& buffer = message.build();
const u8* data = buffer.data();
u8 const* data = buffer.data();
size_t size = buffer.size();
auto& description = file_description();
@ -750,7 +750,7 @@ ErrorOr<size_t> Plan9FSInode::read_bytes(off_t offset, size_t size, UserOrKernel
return nread;
}
ErrorOr<size_t> Plan9FSInode::write_bytes(off_t offset, size_t size, const UserOrKernelBuffer& data, OpenFileDescription*)
ErrorOr<size_t> Plan9FSInode::write_bytes(off_t offset, size_t size, UserOrKernelBuffer const& data, OpenFileDescription*)
{
TRY(ensure_open_for_mode(O_WRONLY));
size = fs().adjust_buffer_size(size);

8
Kernel/FileSystem/Plan9FileSystem.h
View file

@ -93,7 +93,7 @@ private:
virtual Type blocker_type() const override { return Type::Plan9FS; }
virtual void will_unblock_immediately_without_blocking(UnblockImmediatelyReason) override;
const NonnullRefPtr<ReceiveCompletion>& completion() const { return m_completion; }
NonnullRefPtr<ReceiveCompletion> const& completion() const { return m_completion; }
u16 tag() const { return m_completion->tag; }
bool is_completed() const;
@ -115,7 +115,7 @@ private:
virtual StringView class_name() const override { return "Plan9FS"sv; }
bool is_complete(const ReceiveCompletion&);
bool is_complete(ReceiveCompletion const&);
ErrorOr<void> post_message(Message&, RefPtr<ReceiveCompletion>);
ErrorOr<void> do_read(u8* buffer, size_t);
ErrorOr<void> read_and_dispatch_one_message();
@ -157,7 +157,7 @@ public:
virtual InodeMetadata metadata() const override;
virtual ErrorOr<void> flush_metadata() override;
virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& data, OpenFileDescription*) override;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const& data, OpenFileDescription*) override;
virtual ErrorOr<void> traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const override;
virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
virtual ErrorOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
@ -211,7 +211,7 @@ private:
Plan9FS& fs() { return reinterpret_cast<Plan9FS&>(Inode::fs()); }
Plan9FS& fs() const
{
return const_cast<Plan9FS&>(reinterpret_cast<const Plan9FS&>(Inode::fs()));
return const_cast<Plan9FS&>(reinterpret_cast<Plan9FS const&>(Inode::fs()));
}
};

40
Kernel/FileSystem/ProcFS.cpp
View file

@ -56,7 +56,7 @@ Inode& ProcFS::root_inode()
return *m_root_inode;
}
ProcFSInode::ProcFSInode(const ProcFS& fs, InodeIndex index)
ProcFSInode::ProcFSInode(ProcFS const& fs, InodeIndex index)
: Inode(const_cast<ProcFS&>(fs), index)
{
}
@ -93,12 +93,12 @@ ErrorOr<void> ProcFSInode::chown(UserID, GroupID)
return EPERM;
}
ErrorOr<NonnullRefPtr<ProcFSGlobalInode>> ProcFSGlobalInode::try_create(const ProcFS& fs, const ProcFSExposedComponent& component)
ErrorOr<NonnullRefPtr<ProcFSGlobalInode>> ProcFSGlobalInode::try_create(ProcFS const& fs, ProcFSExposedComponent const& component)
{
return adopt_nonnull_ref_or_enomem(new (nothrow) ProcFSGlobalInode(fs, component));
}
ProcFSGlobalInode::ProcFSGlobalInode(const ProcFS& fs, const ProcFSExposedComponent& component)
ProcFSGlobalInode::ProcFSGlobalInode(ProcFS const& fs, ProcFSExposedComponent const& component)
: ProcFSInode(fs, component.component_index())
, m_associated_component(component)
{
@ -163,17 +163,17 @@ InodeMetadata ProcFSGlobalInode::metadata() const
return metadata;
}
ErrorOr<size_t> ProcFSGlobalInode::write_bytes(off_t offset, size_t count, const UserOrKernelBuffer& buffer, OpenFileDescription* fd)
ErrorOr<size_t> ProcFSGlobalInode::write_bytes(off_t offset, size_t count, UserOrKernelBuffer const& buffer, OpenFileDescription* fd)
{
return m_associated_component->write_bytes(offset, count, buffer, fd);
}
ErrorOr<NonnullRefPtr<ProcFSDirectoryInode>> ProcFSDirectoryInode::try_create(const ProcFS& procfs, const ProcFSExposedComponent& component)
ErrorOr<NonnullRefPtr<ProcFSDirectoryInode>> ProcFSDirectoryInode::try_create(ProcFS const& procfs, ProcFSExposedComponent const& component)
{
return adopt_nonnull_ref_or_enomem(new (nothrow) ProcFSDirectoryInode(procfs, component));
}
ProcFSDirectoryInode::ProcFSDirectoryInode(const ProcFS& fs, const ProcFSExposedComponent& component)
ProcFSDirectoryInode::ProcFSDirectoryInode(ProcFS const& fs, ProcFSExposedComponent const& component)
: ProcFSGlobalInode(fs, component)
{
}
@ -204,12 +204,12 @@ ErrorOr<NonnullRefPtr<Inode>> ProcFSDirectoryInode::lookup(StringView name)
return component->to_inode(procfs());
}
ErrorOr<NonnullRefPtr<ProcFSLinkInode>> ProcFSLinkInode::try_create(const ProcFS& procfs, const ProcFSExposedComponent& component)
ErrorOr<NonnullRefPtr<ProcFSLinkInode>> ProcFSLinkInode::try_create(ProcFS const& procfs, ProcFSExposedComponent const& component)
{
return adopt_nonnull_ref_or_enomem(new (nothrow) ProcFSLinkInode(procfs, component));
}
ProcFSLinkInode::ProcFSLinkInode(const ProcFS& fs, const ProcFSExposedComponent& component)
ProcFSLinkInode::ProcFSLinkInode(ProcFS const& fs, ProcFSExposedComponent const& component)
: ProcFSGlobalInode(fs, component)
{
}
@ -227,23 +227,23 @@ InodeMetadata ProcFSLinkInode::metadata() const
return metadata;
}
ProcFSProcessAssociatedInode::ProcFSProcessAssociatedInode(const ProcFS& fs, ProcessID associated_pid, InodeIndex determined_index)
ProcFSProcessAssociatedInode::ProcFSProcessAssociatedInode(ProcFS const& fs, ProcessID associated_pid, InodeIndex determined_index)
: ProcFSInode(fs, determined_index)
, m_pid(associated_pid)
{
}
ErrorOr<size_t> ProcFSProcessAssociatedInode::write_bytes(off_t, size_t, const UserOrKernelBuffer&, OpenFileDescription*)
ErrorOr<size_t> ProcFSProcessAssociatedInode::write_bytes(off_t, size_t, UserOrKernelBuffer const&, OpenFileDescription*)
{
return ENOTSUP;
}
ErrorOr<NonnullRefPtr<ProcFSProcessDirectoryInode>> ProcFSProcessDirectoryInode::try_create(const ProcFS& procfs, ProcessID pid)
ErrorOr<NonnullRefPtr<ProcFSProcessDirectoryInode>> ProcFSProcessDirectoryInode::try_create(ProcFS const& procfs, ProcessID pid)
{
return adopt_nonnull_ref_or_enomem(new (nothrow) ProcFSProcessDirectoryInode(procfs, pid));
}
ProcFSProcessDirectoryInode::ProcFSProcessDirectoryInode(const ProcFS& procfs, ProcessID pid)
ProcFSProcessDirectoryInode::ProcFSProcessDirectoryInode(ProcFS const& procfs, ProcessID pid)
: ProcFSProcessAssociatedInode(procfs, pid, SegmentedProcFSIndex::build_segmented_index_for_pid_directory(pid))
{
}
@ -312,12 +312,12 @@ ErrorOr<NonnullRefPtr<Inode>> ProcFSProcessDirectoryInode::lookup(StringView nam
return ENOENT;
}
ErrorOr<NonnullRefPtr<ProcFSProcessSubDirectoryInode>> ProcFSProcessSubDirectoryInode::try_create(const ProcFS& procfs, SegmentedProcFSIndex::ProcessSubDirectory sub_directory_type, ProcessID pid)
ErrorOr<NonnullRefPtr<ProcFSProcessSubDirectoryInode>> ProcFSProcessSubDirectoryInode::try_create(ProcFS const& procfs, SegmentedProcFSIndex::ProcessSubDirectory sub_directory_type, ProcessID pid)
{
return adopt_nonnull_ref_or_enomem(new (nothrow) ProcFSProcessSubDirectoryInode(procfs, sub_directory_type, pid));
}
ProcFSProcessSubDirectoryInode::ProcFSProcessSubDirectoryInode(const ProcFS& procfs, SegmentedProcFSIndex::ProcessSubDirectory sub_directory_type, ProcessID pid)
ProcFSProcessSubDirectoryInode::ProcFSProcessSubDirectoryInode(ProcFS const& procfs, SegmentedProcFSIndex::ProcessSubDirectory sub_directory_type, ProcessID pid)
: ProcFSProcessAssociatedInode(procfs, pid, SegmentedProcFSIndex::build_segmented_index_for_sub_directory(pid, sub_directory_type))
, m_sub_directory_type(sub_directory_type)
{
@ -389,34 +389,34 @@ ErrorOr<NonnullRefPtr<Inode>> ProcFSProcessSubDirectoryInode::lookup(StringView
}
}
ErrorOr<NonnullRefPtr<ProcFSProcessPropertyInode>> ProcFSProcessPropertyInode::try_create_for_file_description_link(const ProcFS& procfs, unsigned file_description_index, ProcessID pid)
ErrorOr<NonnullRefPtr<ProcFSProcessPropertyInode>> ProcFSProcessPropertyInode::try_create_for_file_description_link(ProcFS const& procfs, unsigned file_description_index, ProcessID pid)
{
return adopt_nonnull_ref_or_enomem(new (nothrow) ProcFSProcessPropertyInode(procfs, file_description_index, pid));
}
ErrorOr<NonnullRefPtr<ProcFSProcessPropertyInode>> ProcFSProcessPropertyInode::try_create_for_thread_stack(const ProcFS& procfs, ThreadID stack_thread_index, ProcessID pid)
ErrorOr<NonnullRefPtr<ProcFSProcessPropertyInode>> ProcFSProcessPropertyInode::try_create_for_thread_stack(ProcFS const& procfs, ThreadID stack_thread_index, ProcessID pid)
{
return adopt_nonnull_ref_or_enomem(new (nothrow) ProcFSProcessPropertyInode(procfs, stack_thread_index, pid));
}
ErrorOr<NonnullRefPtr<ProcFSProcessPropertyInode>> ProcFSProcessPropertyInode::try_create_for_pid_property(const ProcFS& procfs, SegmentedProcFSIndex::MainProcessProperty main_property_type, ProcessID pid)
ErrorOr<NonnullRefPtr<ProcFSProcessPropertyInode>> ProcFSProcessPropertyInode::try_create_for_pid_property(ProcFS const& procfs, SegmentedProcFSIndex::MainProcessProperty main_property_type, ProcessID pid)
{
return adopt_nonnull_ref_or_enomem(new (nothrow) ProcFSProcessPropertyInode(procfs, main_property_type, pid));
}
ProcFSProcessPropertyInode::ProcFSProcessPropertyInode(const ProcFS& procfs, SegmentedProcFSIndex::MainProcessProperty main_property_type, ProcessID pid)
ProcFSProcessPropertyInode::ProcFSProcessPropertyInode(ProcFS const& procfs, SegmentedProcFSIndex::MainProcessProperty main_property_type, ProcessID pid)
: ProcFSProcessAssociatedInode(procfs, pid, SegmentedProcFSIndex::build_segmented_index_for_main_property_in_pid_directory(pid, main_property_type))
, m_parent_sub_directory_type(SegmentedProcFSIndex::ProcessSubDirectory::Reserved)
{
m_possible_data.property_type = main_property_type;
}
ProcFSProcessPropertyInode::ProcFSProcessPropertyInode(const ProcFS& procfs, unsigned file_description_index, ProcessID pid)
ProcFSProcessPropertyInode::ProcFSProcessPropertyInode(ProcFS const& procfs, unsigned file_description_index, ProcessID pid)
: ProcFSProcessAssociatedInode(procfs, pid, SegmentedProcFSIndex::build_segmented_index_for_file_description(pid, file_description_index))
, m_parent_sub_directory_type(SegmentedProcFSIndex::ProcessSubDirectory::OpenFileDescriptions)
{
m_possible_data.property_index = file_description_index;
}
ProcFSProcessPropertyInode::ProcFSProcessPropertyInode(const ProcFS& procfs, ThreadID thread_stack_index, ProcessID pid)
ProcFSProcessPropertyInode::ProcFSProcessPropertyInode(ProcFS const& procfs, ThreadID thread_stack_index, ProcessID pid)
: ProcFSProcessAssociatedInode(procfs, pid, SegmentedProcFSIndex::build_segmented_index_for_thread_stack(pid, thread_stack_index))
, m_parent_sub_directory_type(SegmentedProcFSIndex::ProcessSubDirectory::Stacks)
{

40
Kernel/FileSystem/ProcFS.h
View file

@ -48,7 +48,7 @@ public:
virtual ~ProcFSInode() override;
protected:
ProcFSInode(const ProcFS&, InodeIndex);
ProcFSInode(ProcFS const&, InodeIndex);
ProcFS& procfs() { return static_cast<ProcFS&>(Inode::fs()); }
ProcFS const& procfs() const { return static_cast<ProcFS const&>(Inode::fs()); }
@ -68,17 +68,17 @@ class ProcFSGlobalInode : public ProcFSInode {
friend class ProcFS;
public:
static ErrorOr<NonnullRefPtr<ProcFSGlobalInode>> try_create(const ProcFS&, const ProcFSExposedComponent&);
static ErrorOr<NonnullRefPtr<ProcFSGlobalInode>> try_create(ProcFS const&, ProcFSExposedComponent const&);
virtual ~ProcFSGlobalInode() override {};
StringView name() const;
protected:
ProcFSGlobalInode(const ProcFS&, const ProcFSExposedComponent&);
ProcFSGlobalInode(ProcFS const&, ProcFSExposedComponent const&);
// ^Inode
virtual ErrorOr<void> attach(OpenFileDescription& description) override final;
virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override final;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override final;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const& buffer, OpenFileDescription*) override final;
virtual void did_seek(OpenFileDescription&, off_t) override final;
virtual InodeMetadata metadata() const override;
virtual ErrorOr<void> traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const override;
@ -93,10 +93,10 @@ class ProcFSLinkInode : public ProcFSGlobalInode {
friend class ProcFS;
public:
static ErrorOr<NonnullRefPtr<ProcFSLinkInode>> try_create(const ProcFS&, const ProcFSExposedComponent&);
static ErrorOr<NonnullRefPtr<ProcFSLinkInode>> try_create(ProcFS const&, ProcFSExposedComponent const&);
protected:
ProcFSLinkInode(const ProcFS&, const ProcFSExposedComponent&);
ProcFSLinkInode(ProcFS const&, ProcFSExposedComponent const&);
virtual InodeMetadata metadata() const override;
};
@ -104,11 +104,11 @@ class ProcFSDirectoryInode final : public ProcFSGlobalInode {
friend class ProcFS;
public:
static ErrorOr<NonnullRefPtr<ProcFSDirectoryInode>> try_create(const ProcFS&, const ProcFSExposedComponent&);
static ErrorOr<NonnullRefPtr<ProcFSDirectoryInode>> try_create(ProcFS const&, ProcFSExposedComponent const&);
virtual ~ProcFSDirectoryInode() override;
protected:
ProcFSDirectoryInode(const ProcFS&, const ProcFSExposedComponent&);
ProcFSDirectoryInode(ProcFS const&, ProcFSExposedComponent const&);
// ^Inode
virtual InodeMetadata metadata() const override;
virtual ErrorOr<void> traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const override;
@ -119,11 +119,11 @@ class ProcFSProcessAssociatedInode : public ProcFSInode {
friend class ProcFS;
protected:
ProcFSProcessAssociatedInode(const ProcFS&, ProcessID, InodeIndex);
ProcFSProcessAssociatedInode(ProcFS const&, ProcessID, InodeIndex);
ProcessID associated_pid() const { return m_pid; }
// ^Inode
virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override final;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const& buffer, OpenFileDescription*) override final;
private:
const ProcessID m_pid;
@ -133,10 +133,10 @@ class ProcFSProcessDirectoryInode final : public ProcFSProcessAssociatedInode {
friend class ProcFS;
public:
static ErrorOr<NonnullRefPtr<ProcFSProcessDirectoryInode>> try_create(const ProcFS&, ProcessID);
static ErrorOr<NonnullRefPtr<ProcFSProcessDirectoryInode>> try_create(ProcFS const&, ProcessID);
private:
ProcFSProcessDirectoryInode(const ProcFS&, ProcessID);
ProcFSProcessDirectoryInode(ProcFS const&, ProcessID);
// ^Inode
virtual ErrorOr<void> attach(OpenFileDescription& description) override;
virtual void did_seek(OpenFileDescription&, off_t) override { }
@ -150,10 +150,10 @@ class ProcFSProcessSubDirectoryInode final : public ProcFSProcessAssociatedInode
friend class ProcFS;
public:
static ErrorOr<NonnullRefPtr<ProcFSProcessSubDirectoryInode>> try_create(const ProcFS&, SegmentedProcFSIndex::ProcessSubDirectory, ProcessID);
static ErrorOr<NonnullRefPtr<ProcFSProcessSubDirectoryInode>> try_create(ProcFS const&, SegmentedProcFSIndex::ProcessSubDirectory, ProcessID);
private:
ProcFSProcessSubDirectoryInode(const ProcFS&, SegmentedProcFSIndex::ProcessSubDirectory, ProcessID);
ProcFSProcessSubDirectoryInode(ProcFS const&, SegmentedProcFSIndex::ProcessSubDirectory, ProcessID);
// ^Inode
virtual ErrorOr<void> attach(OpenFileDescription& description) override;
virtual void did_seek(OpenFileDescription&, off_t) override;
@ -169,14 +169,14 @@ class ProcFSProcessPropertyInode final : public ProcFSProcessAssociatedInode {
friend class ProcFS;
public:
static ErrorOr<NonnullRefPtr<ProcFSProcessPropertyInode>> try_create_for_file_description_link(const ProcFS&, unsigned, ProcessID);
static ErrorOr<NonnullRefPtr<ProcFSProcessPropertyInode>> try_create_for_thread_stack(const ProcFS&, ThreadID, ProcessID);
static ErrorOr<NonnullRefPtr<ProcFSProcessPropertyInode>> try_create_for_pid_property(const ProcFS&, SegmentedProcFSIndex::MainProcessProperty, ProcessID);
static ErrorOr<NonnullRefPtr<ProcFSProcessPropertyInode>> try_create_for_file_description_link(ProcFS const&, unsigned, ProcessID);
static ErrorOr<NonnullRefPtr<ProcFSProcessPropertyInode>> try_create_for_thread_stack(ProcFS const&, ThreadID, ProcessID);
static ErrorOr<NonnullRefPtr<ProcFSProcessPropertyInode>> try_create_for_pid_property(ProcFS const&, SegmentedProcFSIndex::MainProcessProperty, ProcessID);
private:
ProcFSProcessPropertyInode(const ProcFS&, SegmentedProcFSIndex::MainProcessProperty, ProcessID);
ProcFSProcessPropertyInode(const ProcFS&, ThreadID, ProcessID);
ProcFSProcessPropertyInode(const ProcFS&, unsigned, ProcessID);
ProcFSProcessPropertyInode(ProcFS const&, SegmentedProcFSIndex::MainProcessProperty, ProcessID);
ProcFSProcessPropertyInode(ProcFS const&, ThreadID, ProcessID);
ProcFSProcessPropertyInode(ProcFS const&, unsigned, ProcessID);
// ^Inode
virtual ErrorOr<void> attach(OpenFileDescription& description) override;
virtual void did_seek(OpenFileDescription&, off_t) override;

4
Kernel/FileSystem/TmpFS.cpp
View file

@ -37,7 +37,7 @@ unsigned TmpFS::next_inode_index()
return m_next_inode_index++;
}
TmpFSInode::TmpFSInode(TmpFS& fs, const InodeMetadata& metadata, WeakPtr<TmpFSInode> parent)
TmpFSInode::TmpFSInode(TmpFS& fs, InodeMetadata const& metadata, WeakPtr<TmpFSInode> parent)
: Inode(fs, fs.next_inode_index())
, m_metadata(metadata)
, m_parent(move(parent))
@ -106,7 +106,7 @@ ErrorOr<size_t> TmpFSInode::read_bytes(off_t offset, size_t size, UserOrKernelBu
return size;
}
ErrorOr<size_t> TmpFSInode::write_bytes(off_t offset, size_t size, const UserOrKernelBuffer& buffer, OpenFileDescription*)
ErrorOr<size_t> TmpFSInode::write_bytes(off_t offset, size_t size, UserOrKernelBuffer const& buffer, OpenFileDescription*)
{
MutexLocker locker(m_inode_lock);
VERIFY(!is_directory());

6
Kernel/FileSystem/TmpFS.h
View file

@ -44,7 +44,7 @@ public:
virtual ~TmpFSInode() override;
TmpFS& fs() { return static_cast<TmpFS&>(Inode::fs()); }
const TmpFS& fs() const { return static_cast<const TmpFS&>(Inode::fs()); }
TmpFS const& fs() const { return static_cast<TmpFS const&>(Inode::fs()); }
// ^Inode
virtual ErrorOr<size_t> read_bytes(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
@ -52,7 +52,7 @@ public:
virtual ErrorOr<void> traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const override;
virtual ErrorOr<NonnullRefPtr<Inode>> lookup(StringView name) override;
virtual ErrorOr<void> flush_metadata() override;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, const UserOrKernelBuffer& buffer, OpenFileDescription*) override;
virtual ErrorOr<size_t> write_bytes(off_t, size_t, UserOrKernelBuffer const& buffer, OpenFileDescription*) override;
virtual ErrorOr<NonnullRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
virtual ErrorOr<void> add_child(Inode&, StringView name, mode_t) override;
virtual ErrorOr<void> remove_child(StringView name) override;
@ -64,7 +64,7 @@ public:
virtual ErrorOr<void> set_mtime(time_t) override;
private:
TmpFSInode(TmpFS& fs, const InodeMetadata& metadata, WeakPtr<TmpFSInode> parent);
TmpFSInode(TmpFS& fs, InodeMetadata const& metadata, WeakPtr<TmpFSInode> parent);
static ErrorOr<NonnullRefPtr<TmpFSInode>> try_create(TmpFS&, InodeMetadata const& metadata, WeakPtr<TmpFSInode> parent);
static ErrorOr<NonnullRefPtr<TmpFSInode>> try_create_root(TmpFS&);

6
Kernel/FileSystem/VirtualFileSystem.cpp
View file

@ -571,7 +571,7 @@ ErrorOr<void> VirtualFileSystem::chown(StringView path, UserID a_uid, GroupID a_
return chown(custody, a_uid, a_gid);
}
static bool hard_link_allowed(const Inode& inode)
static bool hard_link_allowed(Inode const& inode)
{
auto metadata = inode.metadata();
@ -673,7 +673,7 @@ ErrorOr<void> VirtualFileSystem::symlink(StringView target, StringView linkpath,
auto inode = TRY(parent_inode.create_child(basename, S_IFLNK | 0644, 0, current_process.euid(), current_process.egid()));
auto target_buffer = UserOrKernelBuffer::for_kernel_buffer(const_cast<u8*>((const u8*)target.characters_without_null_termination()));
auto target_buffer = UserOrKernelBuffer::for_kernel_buffer(const_cast<u8*>((u8 const*)target.characters_without_null_termination()));
TRY(inode->write_bytes(0, target.length(), target_buffer, nullptr));
return {};
}
@ -838,7 +838,7 @@ ErrorOr<NonnullRefPtr<Custody>> VirtualFileSystem::resolve_path(StringView path,
return custody;
}
static bool safe_to_follow_symlink(const Inode& inode, const InodeMetadata& parent_metadata)
static bool safe_to_follow_symlink(Inode const& inode, InodeMetadata const& parent_metadata)
{
auto metadata = inode.metadata();
if (Process::current().euid() == metadata.uid)

2
Kernel/FileSystem/VirtualFileSystem.h
View file

@ -68,7 +68,7 @@ public:
ErrorOr<void> mknod(StringView path, mode_t, dev_t, Custody& base);
ErrorOr<NonnullRefPtr<Custody>> open_directory(StringView path, Custody& base);
ErrorOr<void> for_each_mount(Function<ErrorOr<void>(const Mount&)>) const;
ErrorOr<void> for_each_mount(Function<ErrorOr<void>(Mount const&)>) const;
InodeIdentifier root_inode_id() const;