mirror of
https://github.com/RGBCube/serenity
synced 2025-05-14 16:44:58 +00:00
23a7ccf607
This is a preparation before we can create a usable mechanism to use filesystem-specific mount flags. To keep some compatibility with userland code, LibC and LibCore mount functions are kept being usable, but now instead of doing an "atomic" syscall, they do multiple syscalls to perform the complete procedure of mounting a filesystem. The FileBackedFileSystem IntrusiveList in the VFS code is now changed to be protected by a Mutex, because when we mount a new filesystem, we need to check if a filesystem is already created for a given source_fd so we do a scan for that OpenFileDescription in that list. If we fail to find an already-created filesystem we create a new one and register it in the list if we successfully mounted it. We use a Mutex because we might need to initiate disk access during the filesystem creation, which will take other mutexes in other parts of the kernel, therefore making it not possible to take a spinlock while doing this.
131 lines
4.6 KiB
C++
131 lines
4.6 KiB
C++
/*
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <AK/Bitmap.h>
|
|
#include <AK/HashMap.h>
|
|
#include <Kernel/FileSystem/BlockBasedFileSystem.h>
|
|
#include <Kernel/FileSystem/Ext2FS/Definitions.h>
|
|
#include <Kernel/FileSystem/Inode.h>
|
|
#include <Kernel/Library/KBuffer.h>
|
|
#include <Kernel/UnixTypes.h>
|
|
|
|
namespace Kernel {
|
|
|
|
class Ext2FSInode;
|
|
|
|
class Ext2FS final : public BlockBasedFileSystem {
|
|
friend class Ext2FSInode;
|
|
|
|
public:
|
|
enum class FeaturesReadOnly : u32 {
|
|
None = 0,
|
|
FileSize64bits = 1 << 1,
|
|
};
|
|
|
|
static ErrorOr<NonnullRefPtr<FileSystem>> try_create(OpenFileDescription&, ReadonlyBytes);
|
|
|
|
virtual ~Ext2FS() override;
|
|
|
|
virtual unsigned total_block_count() const override;
|
|
virtual unsigned free_block_count() const override;
|
|
virtual unsigned total_inode_count() const override;
|
|
virtual unsigned free_inode_count() const override;
|
|
|
|
virtual bool supports_watchers() const override { return true; }
|
|
|
|
virtual u8 internal_file_type_to_directory_entry_type(DirectoryEntryView const& entry) const override;
|
|
|
|
FeaturesReadOnly get_features_readonly() const;
|
|
|
|
virtual StringView class_name() const override { return "Ext2FS"sv; }
|
|
virtual Inode& root_inode() override;
|
|
|
|
private:
|
|
AK_TYPEDEF_DISTINCT_ORDERED_ID(unsigned, GroupIndex);
|
|
|
|
explicit Ext2FS(OpenFileDescription&);
|
|
|
|
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(); }
|
|
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;
|
|
u64 blocks_per_group() const;
|
|
u64 inode_size() const;
|
|
|
|
ErrorOr<NonnullRefPtr<Ext2FSInode>> build_root_inode() const;
|
|
|
|
ErrorOr<void> write_ext2_inode(InodeIndex, ext2_inode const&);
|
|
bool find_block_containing_inode(InodeIndex, BlockIndex& block_index, unsigned& offset) const;
|
|
|
|
ErrorOr<void> flush_super_block();
|
|
|
|
virtual ErrorOr<void> initialize_while_locked() override;
|
|
virtual bool is_initialized_while_locked() override;
|
|
|
|
virtual ErrorOr<void> prepare_to_clear_last_mount() override;
|
|
ErrorOr<NonnullRefPtr<Inode>> get_inode(InodeIdentifier) const;
|
|
ErrorOr<NonnullRefPtr<Inode>> create_inode(Ext2FSInode& parent_inode, StringView name, mode_t, dev_t, UserID, GroupID);
|
|
ErrorOr<NonnullRefPtr<Inode>> create_directory(Ext2FSInode& parent_inode, StringView name, mode_t, UserID, GroupID);
|
|
virtual void flush_writes() override;
|
|
|
|
BlockIndex first_block_index() const;
|
|
ErrorOr<InodeIndex> allocate_inode(GroupIndex preferred_group = 0);
|
|
ErrorOr<Vector<BlockIndex>> allocate_blocks(GroupIndex preferred_group_index, size_t count);
|
|
GroupIndex group_index_from_inode(InodeIndex) const;
|
|
GroupIndex group_index_from_block_index(BlockIndex) const;
|
|
|
|
ErrorOr<bool> get_inode_allocation_state(InodeIndex) const;
|
|
ErrorOr<void> set_inode_allocation_state(InodeIndex, bool);
|
|
ErrorOr<void> set_block_allocation_state(BlockIndex, bool);
|
|
|
|
void uncache_inode(InodeIndex);
|
|
ErrorOr<void> free_inode(Ext2FSInode&);
|
|
|
|
struct BlockListShape {
|
|
unsigned direct_blocks { 0 };
|
|
unsigned indirect_blocks { 0 };
|
|
unsigned doubly_indirect_blocks { 0 };
|
|
unsigned triply_indirect_blocks { 0 };
|
|
unsigned meta_blocks { 0 };
|
|
};
|
|
|
|
BlockListShape compute_block_list_shape(unsigned blocks) const;
|
|
|
|
u64 m_block_group_count { 0 };
|
|
|
|
mutable ext2_super_block m_super_block {};
|
|
mutable OwnPtr<KBuffer> m_cached_group_descriptor_table;
|
|
|
|
mutable HashMap<InodeIndex, RefPtr<Ext2FSInode>> m_inode_cache;
|
|
|
|
bool m_super_block_dirty { false };
|
|
bool m_block_group_descriptors_dirty { false };
|
|
|
|
struct CachedBitmap {
|
|
CachedBitmap(BlockIndex bi, NonnullOwnPtr<KBuffer> buf)
|
|
: bitmap_block_index(bi)
|
|
, buffer(move(buf))
|
|
{
|
|
}
|
|
BlockIndex bitmap_block_index { 0 };
|
|
bool dirty { false };
|
|
NonnullOwnPtr<KBuffer> buffer;
|
|
Bitmap bitmap(u32 blocks_per_group) { return Bitmap { buffer->data(), blocks_per_group }; }
|
|
};
|
|
|
|
ErrorOr<CachedBitmap*> get_bitmap_block(BlockIndex);
|
|
ErrorOr<void> update_bitmap_block(BlockIndex bitmap_block, size_t bit_index, bool new_state, u32& super_block_counter, u16& group_descriptor_counter);
|
|
|
|
Vector<OwnPtr<CachedBitmap>> m_cached_bitmaps;
|
|
RefPtr<Ext2FSInode> m_root_inode;
|
|
};
|
|
|
|
}
|