mirror of
https://github.com/SerenityOS/serenity.git
synced 2025-01-23 18:02:05 -05:00
0fd7b688af
The idea is to enable mounting FileSystem objects across multiple mounts in contrast to what happened until now - each mount has its own unique FileSystem object being attached to it. Considering a situation of mounting a block device at 2 different mount points at in system, there were a couple of critical flaws due to how the previous "design" worked: 1. BlockBasedFileSystem(s) that pointed to the same actual device had a separate DiskCache object being attached to them. Because both instances were not synchronized by any means, corruption of the filesystem is most likely achieveable by a simple cache flush of either of the instances. 2. For superblock-oriented filesystems (such as the ext2 filesystem), lack of synchronization between both instances can lead to severe corruption in the superblock, which could render the entire filesystem unusable. 3. Flags of a specific filesystem implementation (for example, with xfs on Linux, one can instruct to mount it with the discard option) must be honored across multiple mounts, to ensure expected behavior against a particular filesystem. This patch put the foundations to start fix the issues mentioned above. However, there are still major issues to solve, so this is only a start.
104 lines
2.9 KiB
C++
104 lines
2.9 KiB
C++
/*
|
|
* Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include <AK/AtomicRefCounted.h>
|
|
#include <AK/Error.h>
|
|
#include <AK/StringView.h>
|
|
#include <Kernel/FileSystem/InodeIdentifier.h>
|
|
#include <Kernel/Forward.h>
|
|
#include <Kernel/Library/LockRefPtr.h>
|
|
#include <Kernel/Locking/Mutex.h>
|
|
#include <Kernel/UnixTypes.h>
|
|
#include <Kernel/UserOrKernelBuffer.h>
|
|
|
|
namespace Kernel {
|
|
|
|
class FileSystem : public AtomicRefCounted<FileSystem> {
|
|
friend class Inode;
|
|
|
|
public:
|
|
virtual ~FileSystem();
|
|
|
|
FileSystemID fsid() const { return m_fsid; }
|
|
static FileSystem* from_fsid(FileSystemID);
|
|
static void sync();
|
|
static void lock_all();
|
|
|
|
virtual ErrorOr<void> initialize() = 0;
|
|
virtual StringView class_name() const = 0;
|
|
virtual Inode& root_inode() = 0;
|
|
virtual bool supports_watchers() const { return false; }
|
|
|
|
bool is_readonly() const { return m_readonly; }
|
|
|
|
virtual unsigned total_block_count() const { return 0; }
|
|
virtual unsigned free_block_count() const { return 0; }
|
|
virtual unsigned total_inode_count() const { return 0; }
|
|
virtual unsigned free_inode_count() const { return 0; }
|
|
|
|
ErrorOr<void> prepare_to_unmount();
|
|
|
|
struct DirectoryEntryView {
|
|
DirectoryEntryView(StringView name, InodeIdentifier, u8 file_type);
|
|
|
|
StringView name;
|
|
InodeIdentifier inode;
|
|
u8 file_type { 0 };
|
|
};
|
|
|
|
virtual void flush_writes() { }
|
|
|
|
u64 block_size() const { return m_block_size; }
|
|
size_t fragment_size() const { return m_fragment_size; }
|
|
|
|
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(DirectoryEntryView const& entry) const { return entry.file_type; }
|
|
|
|
SpinlockProtected<size_t>& mounted_count(Badge<VirtualFileSystem>) { return m_attach_count; }
|
|
|
|
protected:
|
|
FileSystem();
|
|
|
|
void set_block_size(u64 size) { m_block_size = size; }
|
|
void set_fragment_size(size_t size) { m_fragment_size = size; }
|
|
|
|
virtual ErrorOr<void> prepare_to_clear_last_mount() { return {}; }
|
|
|
|
mutable Mutex m_lock { "FS"sv };
|
|
|
|
private:
|
|
FileSystemID m_fsid;
|
|
u64 m_block_size { 0 };
|
|
size_t m_fragment_size { 0 };
|
|
bool m_readonly { false };
|
|
|
|
SpinlockProtected<size_t> m_attach_count { LockRank::FileSystem, 0 };
|
|
};
|
|
|
|
inline FileSystem* InodeIdentifier::fs() // NOLINT(readability-make-member-function-const) const InodeIdentifiers should not be able to modify the FileSystem
|
|
{
|
|
return FileSystem::from_fsid(m_fsid);
|
|
}
|
|
|
|
inline FileSystem const* InodeIdentifier::fs() const
|
|
{
|
|
return FileSystem::from_fsid(m_fsid);
|
|
}
|
|
|
|
}
|
|
|
|
namespace AK {
|
|
|
|
template<>
|
|
struct Traits<Kernel::InodeIdentifier> : public GenericTraits<Kernel::InodeIdentifier> {
|
|
static unsigned hash(Kernel::InodeIdentifier const& inode) { return pair_int_hash(inode.fsid().value(), inode.index().value()); }
|
|
};
|
|
|
|
}
|