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 class KMessage; 26 class Settings; 27 class Volume; 28 29 30 struct VNodeOps { 31 int32 refCount; 32 FSVNodeCapabilities capabilities; 33 fs_vnode_ops* ops; 34 VNodeOps* hash_link; 35 36 VNodeOps(const FSVNodeCapabilities& capabilities, fs_vnode_ops* ops) 37 : 38 refCount(1), 39 capabilities(capabilities), 40 ops(ops) 41 { 42 } 43 44 ~VNodeOps() 45 { 46 delete ops; 47 } 48 }; 49 50 51 struct VNodeOpsHashDefinition { 52 typedef FSVNodeCapabilities KeyType; 53 typedef VNodeOps ValueType; 54 55 size_t HashKey(const FSVNodeCapabilities& key) const 56 { return key.GetHashCode(); } 57 size_t Hash(const VNodeOps* value) const 58 { return HashKey(value->capabilities); } 59 bool Compare(const FSVNodeCapabilities& key, const VNodeOps* value) const 60 { return value->capabilities == key; } 61 VNodeOps*& GetLink(VNodeOps* value) const 62 { return value->hash_link; } 63 }; 64 65 66 class FileSystem { 67 public: 68 FileSystem(); 69 ~FileSystem(); 70 71 status_t Init(const char* name, team_id team, 72 Port::Info* infos, int32 infoCount, 73 const FSCapabilities& capabilities); 74 75 const char* GetName() const; 76 team_id GetTeam() const { return fTeam; } 77 78 const FSCapabilities& GetCapabilities() const; 79 inline bool HasCapability(uint32 capability) const; 80 81 RequestPortPool* GetPortPool(); 82 83 status_t Mount(fs_volume* fsVolume, const char* device, 84 ulong flags, const char* parameters, 85 Volume** volume); 86 // status_t Initialize(const char* deviceName, 87 // const char* parameters, size_t len); 88 void VolumeUnmounted(Volume* volume); 89 90 Volume* GetVolume(dev_t id); 91 92 const IOCtlInfo* GetIOCtlInfo(int command) const; 93 94 status_t AddSelectSyncEntry(selectsync* sync); 95 void RemoveSelectSyncEntry(selectsync* sync); 96 bool KnowsSelectSyncEntry(selectsync* sync); 97 98 status_t AddNodeListener(dev_t device, ino_t node, 99 uint32 flags, void* listener); 100 status_t RemoveNodeListener(dev_t device, ino_t node, 101 void* listener); 102 103 VNodeOps* GetVNodeOps( 104 const FSVNodeCapabilities& capabilities); 105 void PutVNodeOps(VNodeOps* ops); 106 107 bool IsUserlandServerThread() const; 108 109 private: 110 friend class KernelDebug; 111 struct SelectSyncMap; 112 struct NodeListenerKey; 113 struct NodeListenerProxy; 114 struct NodeListenerHashDefinition; 115 116 typedef BOpenHashTable<VNodeOpsHashDefinition> VNodeOpsMap; 117 typedef BOpenHashTable<NodeListenerHashDefinition> NodeListenerMap; 118 119 120 private: 121 void _InitVNodeOpsVector(fs_vnode_ops* ops, 122 const FSVNodeCapabilities& capabilities); 123 124 void _NodeListenerEventOccurred( 125 NodeListenerProxy* proxy, 126 const KMessage* event); 127 128 static int32 _NotificationThreadEntry(void* data); 129 int32 _NotificationThread(); 130 131 private: 132 Vector<Volume*> fVolumes; 133 mutex fVolumeLock; 134 VNodeOpsMap fVNodeOps; 135 mutex fVNodeOpsLock; 136 String fName; 137 team_id fTeam; 138 FSCapabilities fCapabilities; 139 RequestPort* fNotificationPort; 140 thread_id fNotificationThread; 141 RequestPortPool fPortPool; 142 SelectSyncMap* fSelectSyncs; 143 mutex fNodeListenersLock; 144 NodeListenerMap* fNodeListeners; 145 Settings* fSettings; 146 team_id fUserlandServerTeam; 147 bool fInitialized; 148 volatile bool fTerminating; 149 }; 150 151 152 // HasCapability 153 inline bool 154 FileSystem::HasCapability(uint32 capability) const 155 { 156 return fCapabilities.Get(capability); 157 } 158 159 #endif // USERLAND_FS_FILE_SYSTEM_H 160