forked from SerenityOS/serenity
-
Notifications
You must be signed in to change notification settings - Fork 0
/
VirtualFileSystem.h
142 lines (102 loc) Β· 4.34 KB
/
VirtualFileSystem.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
#pragma once
#include <AK/HashMap.h>
#include <AK/OwnPtr.h>
#include <AK/RetainPtr.h>
#include <AK/String.h>
#include <AK/Vector.h>
#include <AK/Function.h>
#include "InodeIdentifier.h"
#include "InodeMetadata.h"
#include "Limits.h"
#include "FileSystem.h"
#define O_RDONLY 0
#define O_WRONLY 1
#define O_RDWR 2
#define O_DIRECTORY 00200000
#define O_ 00400000
#define O__NOERROR 0x4000000
class CharacterDevice;
class FileDescriptor;
inline constexpr dword encodedDevice(unsigned major, unsigned minor)
{
return (minor & 0xff) | (major << 8) | ((minor & ~0xff) << 12);
}
class VirtualFileSystem {
AK_MAKE_ETERNAL
public:
static void initializeGlobals();
class Mount {
public:
Mount(InodeIdentifier host, RetainPtr<FileSystem>&&);
InodeIdentifier host() const { return m_host; }
InodeIdentifier guest() const { return m_guest; }
const FileSystem& fileSystem() const { return *m_fileSystem; }
private:
InodeIdentifier m_host;
InodeIdentifier m_guest;
RetainPtr<FileSystem> m_fileSystem;
};
struct Node {
InodeIdentifier inode;
const InodeMetadata& metadata() const;
bool inUse() const { return inode.isValid() || m_characterDevice; }
bool isCharacterDevice() const { return m_characterDevice; }
CharacterDevice* characterDevice() { return m_characterDevice; }
const CharacterDevice* characterDevice() const { return m_characterDevice; }
void retain();
void release();
FileSystem* fileSystem() { return inode.fileSystem(); }
const FileSystem* fileSystem() const { return inode.fileSystem(); }
VirtualFileSystem* vfs() { return m_vfs; }
const VirtualFileSystem* vfs() const { return m_vfs; }
private:
friend class VirtualFileSystem;
VirtualFileSystem* m_vfs { nullptr };
unsigned retainCount { 0 };
CharacterDevice* m_characterDevice { nullptr };
mutable InodeMetadata m_cachedMetadata;
};
static VirtualFileSystem& the() PURE;
VirtualFileSystem();
~VirtualFileSystem();
bool isDirectory(const String& path, InodeIdentifier base = InodeIdentifier());
void listDirectory(const String& path);
void listDirectoryRecursively(const String& path);
unsigned maxNodeCount() const { return m_maxNodeCount; }
unsigned allocatedNodeCount() const { return m_maxNodeCount - m_nodeFreeList.size(); }
Node* root() { return m_rootNode.ptr(); }
const Node* root() const { return m_rootNode.ptr(); }
bool mountRoot(RetainPtr<FileSystem>&&);
bool mount(RetainPtr<FileSystem>&&, const String& path);
RetainPtr<FileDescriptor> open(CharacterDevice&, int options);
RetainPtr<FileDescriptor> open(const String& path, int& error, int options = 0, InodeIdentifier base = InodeIdentifier());
RetainPtr<FileDescriptor> create(const String& path, InodeIdentifier base = InodeIdentifier());
RetainPtr<FileDescriptor> mkdir(const String& path, InodeIdentifier base = InodeIdentifier());
bool isRoot(InodeIdentifier) const;
bool touch(const String&path);
void registerCharacterDevice(CharacterDevice&);
size_t mountCount() const { return m_mounts.size(); }
void forEachMount(Function<void(const Mount&)>) const;
String absolutePath(InodeIdentifier);
private:
friend class FileDescriptor;
void enumerateDirectoryInode(InodeIdentifier, Function<bool(const FileSystem::DirectoryEntry&)>);
InodeIdentifier resolvePath(const String& path, int& error, InodeIdentifier base = InodeIdentifier(), int options = 0);
InodeIdentifier resolveSymbolicLink(InodeIdentifier base, InodeIdentifier symlinkInode, int& error);
RetainPtr<Node> allocateNode();
void freeNode(Node*);
RetainPtr<Node> makeNode(InodeIdentifier);
RetainPtr<Node> makeNode(CharacterDevice&);
RetainPtr<Node> getOrCreateNode(InodeIdentifier);
RetainPtr<Node> getOrCreateNode(CharacterDevice&);
Mount* findMountForHost(InodeIdentifier);
Mount* findMountForGuest(InodeIdentifier);
HashMap<InodeIdentifier, Node*> m_inode2vnode;
HashMap<dword, Node*> m_device2vnode;
Vector<OwnPtr<Mount>> m_mounts;
unsigned m_maxNodeCount { 0 };
Node* m_nodes { nullptr };
Vector<Node*> m_nodeFreeList;
RetainPtr<Node> m_rootNode;
HashMap<dword, CharacterDevice*> m_characterDevices;
};