1/* 2 * Copyright 2007-2009, Ingo Weinhold, ingo_weinhold@gmx.de. 3 * Distributed under the terms of the MIT License. 4 */ 5#ifndef USERLAND_FS_HAIKU_KERNEL_VOLUME_H 6#define USERLAND_FS_HAIKU_KERNEL_VOLUME_H 7 8#include <fs_interface.h> 9 10#include "../Volume.h" 11 12namespace UserlandFS { 13 14class HaikuKernelFileSystem; 15class HaikuKernelNode; 16 17 18class HaikuKernelVolume : public Volume { 19public: 20 HaikuKernelVolume(FileSystem* fileSystem, 21 dev_t id, 22 file_system_module_info* fsModule); 23 virtual ~HaikuKernelVolume(); 24 25 static HaikuKernelVolume* GetVolume(const fs_volume* volume); 26 27 inline fs_volume* GetFSVolume() { return &fVolume; } 28 29 status_t Init(); 30 31 status_t NewVNode(ino_t vnodeID, void* privateNode, 32 fs_vnode_ops* ops, HaikuKernelNode** node); 33 status_t PublishVNode(ino_t vnodeID, void* privateNode, 34 fs_vnode_ops* ops, int type, uint32 flags, 35 HaikuKernelNode** node); 36 void UndoNewVNode(HaikuKernelNode* node); 37 void UndoPublishVNode(HaikuKernelNode* node); 38 39 HaikuKernelNode* NodeWithID(ino_t vnodeID) const; 40 41 // FS 42 virtual status_t Mount(const char* device, uint32 flags, 43 const char* parameters, ino_t* rootID); 44 virtual status_t Unmount(); 45 virtual status_t Sync(); 46 virtual status_t ReadFSInfo(fs_info* info); 47 virtual status_t WriteFSInfo(const struct fs_info* info, 48 uint32 mask); 49 50 // file cache 51 virtual status_t GetFileMap(void* node, off_t offset, 52 size_t size, struct file_io_vec* vecs, 53 size_t* count); 54 55 // vnodes 56 virtual status_t Lookup(void* dir, const char* entryName, 57 ino_t* vnid); 58 virtual status_t GetVNodeName(void* node, char* buffer, 59 size_t bufferSize); 60 virtual status_t ReadVNode(ino_t vnid, bool reenter, 61 void** node, int* type, uint32* flags, 62 FSVNodeCapabilities* _capabilities); 63 virtual status_t WriteVNode(void* node, bool reenter); 64 virtual status_t RemoveVNode(void* node, bool reenter); 65 66 // asynchronous I/O 67 virtual status_t DoIO(void* node, void* cookie, 68 const IORequestInfo& requestInfo); 69 virtual status_t CancelIO(void* node, void* cookie, 70 int32 ioRequestID); 71 virtual status_t IterativeIOGetVecs(void* cookie, 72 int32 requestID, off_t offset, size_t size, 73 struct file_io_vec* vecs, size_t* _count); 74 virtual status_t IterativeIOFinished(void* cookie, 75 int32 requestID, status_t status, 76 bool partialTransfer, 77 size_t bytesTransferred); 78 79 // nodes 80 virtual status_t IOCtl(void* node, void* cookie, 81 uint32 command, void* buffer, size_t size); 82 virtual status_t SetFlags(void* node, void* cookie, 83 int flags); 84 virtual status_t Select(void* node, void* cookie, 85 uint8 event, selectsync* sync); 86 virtual status_t Deselect(void* node, void* cookie, 87 uint8 event, selectsync* sync); 88 89 virtual status_t FSync(void* node); 90 91 virtual status_t ReadSymlink(void* node, char* buffer, 92 size_t bufferSize, size_t* bytesRead); 93 virtual status_t CreateSymlink(void* dir, const char* name, 94 const char* target, int mode); 95 96 virtual status_t Link(void* dir, const char* name, 97 void* node); 98 virtual status_t Unlink(void* dir, const char* name); 99 virtual status_t Rename(void* oldDir, const char* oldName, 100 void* newDir, const char* newName); 101 102 virtual status_t Access(void* node, int mode); 103 virtual status_t ReadStat(void* node, struct stat* st); 104 virtual status_t WriteStat(void* node, const struct stat *st, 105 uint32 mask); 106 107 // files 108 virtual status_t Create(void* dir, const char* name, 109 int openMode, int mode, void** cookie, 110 ino_t* vnid); 111 virtual status_t Open(void* node, int openMode, 112 void** cookie); 113 virtual status_t Close(void* node, void* cookie); 114 virtual status_t FreeCookie(void* node, void* cookie); 115 virtual status_t Read(void* node, void* cookie, off_t pos, 116 void* buffer, size_t bufferSize, 117 size_t* bytesRead); 118 virtual status_t Write(void* node, void* cookie, 119 off_t pos, const void* buffer, 120 size_t bufferSize, size_t* bytesWritten); 121 122 // directories 123 virtual status_t CreateDir(void* dir, const char* name, 124 int mode); 125 virtual status_t RemoveDir(void* dir, const char* name); 126 virtual status_t OpenDir(void* node, void** cookie); 127 virtual status_t CloseDir(void* node, void* cookie); 128 virtual status_t FreeDirCookie(void* node, void* cookie); 129 virtual status_t ReadDir(void* node, void* cookie, 130 void* buffer, size_t bufferSize, 131 uint32 count, uint32* countRead); 132 virtual status_t RewindDir(void* node, void* cookie); 133 134 // attribute directories 135 virtual status_t OpenAttrDir(void* node, void** cookie); 136 virtual status_t CloseAttrDir(void* node, void* cookie); 137 virtual status_t FreeAttrDirCookie(void* node, 138 void* cookie); 139 virtual status_t ReadAttrDir(void* node, void* cookie, 140 void* buffer, size_t bufferSize, 141 uint32 count, uint32* countRead); 142 virtual status_t RewindAttrDir(void* node, void* cookie); 143 144 // attributes 145 virtual status_t CreateAttr(void* node, const char *name, 146 uint32 type, int openMode, 147 void** cookie); 148 virtual status_t OpenAttr(void* node, const char *name, 149 int openMode, void** cookie); 150 virtual status_t CloseAttr(void* node, void* cookie); 151 virtual status_t FreeAttrCookie(void* node, void* cookie); 152 virtual status_t ReadAttr(void* node, void* cookie, 153 off_t pos, void* buffer, size_t bufferSize, 154 size_t* bytesRead); 155 virtual status_t WriteAttr(void* node, void* cookie, 156 off_t pos, const void* buffer, 157 size_t bufferSize, size_t* bytesWritten); 158 virtual status_t ReadAttrStat(void* node, void* cookie, 159 struct stat *st); 160 virtual status_t WriteAttrStat(void* node, void* cookie, 161 const struct stat* st, int statMask); 162 virtual status_t RenameAttr(void* oldNode, 163 const char* oldName, void* newNode, 164 const char* newName); 165 virtual status_t RemoveAttr(void* node, const char* name); 166 167 // indices 168 virtual status_t OpenIndexDir(void** cookie); 169 virtual status_t CloseIndexDir(void* cookie); 170 virtual status_t FreeIndexDirCookie(void* cookie); 171 virtual status_t ReadIndexDir(void* cookie, void* buffer, 172 size_t bufferSize, uint32 count, 173 uint32* countRead); 174 virtual status_t RewindIndexDir(void* cookie); 175 virtual status_t CreateIndex(const char* name, uint32 type, 176 uint32 flags); 177 virtual status_t RemoveIndex(const char* name); 178 virtual status_t ReadIndexStat(const char *name, 179 struct stat *st); 180 181 // queries 182 virtual status_t OpenQuery(const char* queryString, 183 uint32 flags, port_id port, uint32 token, 184 void** cookie); 185 virtual status_t CloseQuery(void* cookie); 186 virtual status_t FreeQueryCookie(void* cookie); 187 virtual status_t ReadQuery(void* cookie, void* buffer, 188 size_t bufferSize, uint32 count, 189 uint32* countRead); 190 virtual status_t RewindQuery(void* cookie); 191 192private: 193 struct FSVolume : fs_volume { 194 HaikuKernelVolume* haikuVolume; 195 }; 196 197 class NodeMap; 198 199private: 200 void _InitCapabilities(); 201 inline HaikuKernelFileSystem* _FileSystem() const; 202 203private: 204 file_system_module_info* fFSModule; 205 FSVolume fVolume; 206 NodeMap* fNodes; 207}; 208 209 210/*static*/ inline HaikuKernelVolume* 211HaikuKernelVolume::GetVolume(const fs_volume* volume) 212{ 213 return static_cast<const FSVolume*>(volume)->haikuVolume; 214} 215 216 217} // namespace UserlandFS 218 219using UserlandFS::HaikuKernelVolume; 220 221#endif // USERLAND_FS_HAIKU_KERNEL_VOLUME_H 222