1 /*
2 * Copyright 2001-2009, Ingo Weinhold, ingo_weinhold@gmx.de.
3 * Distributed under the terms of the MIT License.
4 */
5 #ifndef USERLAND_FS_FILE_SYSTEM_H
6 #define USERLAND_FS_FILE_SYSTEM_H
7
8
9 #include <fs_interface.h>
10
11 #include <util/OpenHashTable.h>
12
13 #include <lock.h>
14
15 #include "FSCapabilities.h"
16 #include "LazyInitializable.h"
17 #include "Locker.h"
18 #include "RequestPort.h"
19 #include "RequestPortPool.h"
20 #include "String.h"
21 #include "Vector.h"
22
23
24 struct IOCtlInfo;
25 namespace BPrivate { class KMessage; }
26 using BPrivate::KMessage;
27 class Settings;
28 class Volume;
29
30
31 struct VNodeOps {
32 int32 refCount;
33 FSVNodeCapabilities capabilities;
34 fs_vnode_ops* ops;
35 VNodeOps* hash_link;
36
VNodeOpsVNodeOps37 VNodeOps(const FSVNodeCapabilities& capabilities, fs_vnode_ops* ops)
38 :
39 refCount(1),
40 capabilities(capabilities),
41 ops(ops)
42 {
43 }
44
~VNodeOpsVNodeOps45 ~VNodeOps()
46 {
47 delete ops;
48 }
49 };
50
51
52 struct VNodeOpsHashDefinition {
53 typedef FSVNodeCapabilities KeyType;
54 typedef VNodeOps ValueType;
55
HashKeyVNodeOpsHashDefinition56 size_t HashKey(const FSVNodeCapabilities& key) const
57 { return key.GetHashCode(); }
HashVNodeOpsHashDefinition58 size_t Hash(const VNodeOps* value) const
59 { return HashKey(value->capabilities); }
CompareVNodeOpsHashDefinition60 bool Compare(const FSVNodeCapabilities& key, const VNodeOps* value) const
61 { return value->capabilities == key; }
GetLinkVNodeOpsHashDefinition62 VNodeOps*& GetLink(VNodeOps* value) const
63 { return value->hash_link; }
64 };
65
66
67 class FileSystem {
68 public:
69 FileSystem();
70 ~FileSystem();
71
72 status_t Init(const char* name, team_id team,
73 Port::Info* infos, int32 infoCount,
74 const FSCapabilities& capabilities);
75
76 const char* GetName() const;
GetTeam()77 team_id GetTeam() const { return fTeam; }
78
79 const FSCapabilities& GetCapabilities() const;
80 inline bool HasCapability(uint32 capability) const;
81
82 RequestPortPool* GetPortPool();
83
84 status_t Mount(fs_volume* fsVolume, const char* device,
85 uint32 flags, const char* parameters,
86 Volume** volume);
87 // status_t Initialize(const char* deviceName,
88 // const char* parameters, size_t len);
89 void VolumeUnmounted(Volume* volume);
90
91 Volume* GetVolume(dev_t id);
92
93 const IOCtlInfo* GetIOCtlInfo(int command) const;
94
95 status_t AddSelectSyncEntry(selectsync* sync);
96 void RemoveSelectSyncEntry(selectsync* sync);
97 bool KnowsSelectSyncEntry(selectsync* sync);
98
99 status_t AddNodeListener(dev_t device, ino_t node,
100 uint32 flags, void* listener);
101 status_t RemoveNodeListener(dev_t device, ino_t node,
102 void* listener);
103
104 VNodeOps* GetVNodeOps(
105 const FSVNodeCapabilities& capabilities);
106 void PutVNodeOps(VNodeOps* ops);
107
108 bool IsUserlandServerThread() const;
109
110 private:
111 struct SelectSyncMap;
112 struct NodeListenerKey;
113 struct NodeListenerProxy;
114 struct NodeListenerHashDefinition;
115
116 friend class KernelDebug;
117 friend struct NodeListenerProxy;
118
119 typedef BOpenHashTable<VNodeOpsHashDefinition> VNodeOpsMap;
120 typedef BOpenHashTable<NodeListenerHashDefinition> NodeListenerMap;
121
122
123 private:
124 void _InitVNodeOpsVector(fs_vnode_ops* ops,
125 const FSVNodeCapabilities& capabilities);
126
127 void _NodeListenerEventOccurred(
128 NodeListenerProxy* proxy,
129 const KMessage* event);
130
131 static int32 _NotificationThreadEntry(void* data);
132 int32 _NotificationThread();
133
134 private:
135 Vector<Volume*> fVolumes;
136 mutex fVolumeLock;
137 VNodeOpsMap fVNodeOps;
138 mutex fVNodeOpsLock;
139 String fName;
140 team_id fTeam;
141 FSCapabilities fCapabilities;
142 RequestPort* fNotificationPort;
143 thread_id fNotificationThread;
144 RequestPortPool fPortPool;
145 SelectSyncMap* fSelectSyncs;
146 mutex fNodeListenersLock;
147 NodeListenerMap* fNodeListeners;
148 Settings* fSettings;
149 team_id fUserlandServerTeam;
150 bool fInitialized;
151 volatile bool fTerminating;
152 };
153
154
155 // HasCapability
156 inline bool
HasCapability(uint32 capability)157 FileSystem::HasCapability(uint32 capability) const
158 {
159 return fCapabilities.Get(capability);
160 }
161
162 #endif // USERLAND_FS_FILE_SYSTEM_H
163