From cdebdeb0aa35c9eabf093024474c865ce9bd6840 Mon Sep 17 00:00:00 2001 From: Ingo Weinhold Date: Thu, 26 Feb 2009 00:09:43 +0000 Subject: [PATCH] Some more work towards adjusting the UserlandFS to the current FS interface: * Split the FSCapabilities bit mask into three bit masks for the FS, the volume, and the vnodes, since we have three independent FS interface structures, now. The latter is not supported in the kernel add-on, yet. * Server: - Temporarily removed some things from the build (the BeOS interface and the cache implementations). - Some WIP in HaikuKernelVolume and [haiku_]kernel_emu.{h,cpp}. - Added HaikuKernelNode, which wraps fs_vnode for the client FS. The server is still quite a bit away from being buildable again. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29323 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- .../userlandfs/private/FSCapabilities.h | 247 +++++---- headers/private/userlandfs/private/Requests.h | 6 +- .../userlandfs/kernel_add_on/Volume.cpp | 115 ++-- .../userlandfs/kernel_add_on/Volume.h | 22 + .../kernel_add_on/kernel_interface.cpp | 2 - .../userlandfs/server/BeOSKernelVolume.cpp | 17 +- .../userlandfs/server/BeOSKernelVolume.h | 6 +- .../file_systems/userlandfs/server/FSInfo.h | 33 +- .../userlandfs/server/FileSystem.h | 3 + .../server/HaikuKernelFileSystem.cpp | 100 +--- .../userlandfs/server/HaikuKernelNode.h | 41 ++ .../userlandfs/server/HaikuKernelVolume.cpp | 515 ++++++++++++------ .../userlandfs/server/HaikuKernelVolume.h | 173 +++--- .../file_systems/userlandfs/server/Jamfile | 12 +- .../server/UserlandFSDispatcher.cpp | 1 + .../server/UserlandRequestHandler.cpp | 4 +- .../file_systems/userlandfs/server/Volume.cpp | 126 ++--- .../file_systems/userlandfs/server/Volume.h | 143 ++--- .../userlandfs/server/haiku_kernel_emu.cpp | 94 +++- .../userlandfs/server/kernel_emu.cpp | 12 +- .../userlandfs/server/kernel_emu.h | 9 +- 21 files changed, 997 insertions(+), 684 deletions(-) create mode 100644 src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelNode.h diff --git a/headers/private/userlandfs/private/FSCapabilities.h b/headers/private/userlandfs/private/FSCapabilities.h index 5cdd02ba74..b0990fed36 100644 --- a/headers/private/userlandfs/private/FSCapabilities.h +++ b/headers/private/userlandfs/private/FSCapabilities.h @@ -13,113 +13,139 @@ enum client_fs_type { CLIENT_FS_HAIKU_KERNEL, }; +// FS capabilities enum { // FS operations FS_CAPABILITY_MOUNT = 0, - FS_CAPABILITY_UNMOUNT, - FS_CAPABILITY_READ_FS_INFO, - FS_CAPABILITY_WRITE_FS_INFO, - FS_CAPABILITY_SYNC, - - // vnode operations - FS_CAPABILITY_LOOKUP, - FS_CAPABILITY_GET_VNODE_NAME, - - FS_CAPABILITY_GET_VNODE, - FS_CAPABILITY_PUT_VNODE, - FS_CAPABILITY_REMOVE_VNODE, - - // VM file access - FS_CAPABILITY_CAN_PAGE, - FS_CAPABILITY_READ_PAGES, - FS_CAPABILITY_WRITE_PAGES, - - // cache file access - FS_CAPABILITY_GET_FILE_MAP, - - // common operations - FS_CAPABILITY_IOCTL, - FS_CAPABILITY_SET_FLAGS, - FS_CAPABILITY_SELECT, - FS_CAPABILITY_DESELECT, - FS_CAPABILITY_FSYNC, - - FS_CAPABILITY_READ_SYMLINK, - FS_CAPABILITY_CREATE_SYMLINK, - - FS_CAPABILITY_LINK, - FS_CAPABILITY_UNLINK, - FS_CAPABILITY_RENAME, - - FS_CAPABILITY_ACCESS, - FS_CAPABILITY_READ_STAT, - FS_CAPABILITY_WRITE_STAT, - - // file operations - FS_CAPABILITY_CREATE, - FS_CAPABILITY_OPEN, - FS_CAPABILITY_CLOSE, - FS_CAPABILITY_FREE_COOKIE, - FS_CAPABILITY_READ, - FS_CAPABILITY_WRITE, - - // directory operations - FS_CAPABILITY_CREATE_DIR, - FS_CAPABILITY_REMOVE_DIR, - FS_CAPABILITY_OPEN_DIR, - FS_CAPABILITY_CLOSE_DIR, - FS_CAPABILITY_FREE_DIR_COOKIE, - FS_CAPABILITY_READ_DIR, - FS_CAPABILITY_REWIND_DIR, - - // attribute directory operations - FS_CAPABILITY_OPEN_ATTR_DIR, - FS_CAPABILITY_CLOSE_ATTR_DIR, - FS_CAPABILITY_FREE_ATTR_DIR_COOKIE, - FS_CAPABILITY_READ_ATTR_DIR, - FS_CAPABILITY_REWIND_ATTR_DIR, - - // attribute operations - FS_CAPABILITY_CREATE_ATTR, - FS_CAPABILITY_OPEN_ATTR, - FS_CAPABILITY_CLOSE_ATTR, - FS_CAPABILITY_FREE_ATTR_COOKIE, - FS_CAPABILITY_READ_ATTR, - FS_CAPABILITY_WRITE_ATTR, - - FS_CAPABILITY_READ_ATTR_STAT, - FS_CAPABILITY_WRITE_ATTR_STAT, - FS_CAPABILITY_RENAME_ATTR, - FS_CAPABILITY_REMOVE_ATTR, - - // index directory & index operations - FS_CAPABILITY_OPEN_INDEX_DIR, - FS_CAPABILITY_CLOSE_INDEX_DIR, - FS_CAPABILITY_FREE_INDEX_DIR_COOKIE, - FS_CAPABILITY_READ_INDEX_DIR, - FS_CAPABILITY_REWIND_INDEX_DIR, - - FS_CAPABILITY_CREATE_INDEX, - FS_CAPABILITY_REMOVE_INDEX, - FS_CAPABILITY_READ_INDEX_STAT, - - // query operations - FS_CAPABILITY_OPEN_QUERY, - FS_CAPABILITY_CLOSE_QUERY, - FS_CAPABILITY_FREE_QUERY_COOKIE, - FS_CAPABILITY_READ_QUERY, - FS_CAPABILITY_REWIND_QUERY, - - FS_CAPABILITY_COUNT, + FS_CAPABILITY_COUNT }; +// Volume capabilities +enum { + // general operations + FS_VOLUME_CAPABILITY_UNMOUNT, + + FS_VOLUME_CAPABILITY_READ_FS_INFO, + FS_VOLUME_CAPABILITY_WRITE_FS_INFO, + FS_VOLUME_CAPABILITY_SYNC, + + FS_VOLUME_CAPABILITY_GET_VNODE, + + // index directory & index operations + FS_VOLUME_CAPABILITY_OPEN_INDEX_DIR, + FS_VOLUME_CAPABILITY_CLOSE_INDEX_DIR, + FS_VOLUME_CAPABILITY_FREE_INDEX_DIR_COOKIE, + FS_VOLUME_CAPABILITY_READ_INDEX_DIR, + FS_VOLUME_CAPABILITY_REWIND_INDEX_DIR, + + FS_VOLUME_CAPABILITY_CREATE_INDEX, + FS_VOLUME_CAPABILITY_REMOVE_INDEX, + FS_VOLUME_CAPABILITY_READ_INDEX_STAT, + + // query operations + FS_VOLUME_CAPABILITY_OPEN_QUERY, + FS_VOLUME_CAPABILITY_CLOSE_QUERY, + FS_VOLUME_CAPABILITY_FREE_QUERY_COOKIE, + FS_VOLUME_CAPABILITY_READ_QUERY, + FS_VOLUME_CAPABILITY_REWIND_QUERY, + + // support for FS layers + FS_VOLUME_CAPABILITY_ALL_LAYERS_MOUNTED, + FS_VOLUME_CAPABILITY_CREATE_SUB_VNODE, + FS_VOLUME_CAPABILITY_DELETE_SUB_VNODE, + + FS_VOLUME_CAPABILITY_COUNT +}; + +// VNode capabilities +enum { + // vnode operations + FS_VNODE_CAPABILITY_LOOKUP, + FS_VNODE_CAPABILITY_GET_VNODE_NAME, + + FS_VNODE_CAPABILITY_PUT_VNODE, + FS_VNODE_CAPABILITY_REMOVE_VNODE, + + // VM file access + FS_VNODE_CAPABILITY_CAN_PAGE, + FS_VNODE_CAPABILITY_READ_PAGES, + FS_VNODE_CAPABILITY_WRITE_PAGES, + + // asynchronous I/O + FS_VNODE_CAPABILITY_IO, + FS_VNODE_CAPABILITY_CANCEL_IO, + + // cache file access + FS_VNODE_CAPABILITY_GET_FILE_MAP, + + // common operations + FS_VNODE_CAPABILITY_IOCTL, + FS_VNODE_CAPABILITY_SET_FLAGS, + FS_VNODE_CAPABILITY_SELECT, + FS_VNODE_CAPABILITY_DESELECT, + FS_VNODE_CAPABILITY_FSYNC, + + FS_VNODE_CAPABILITY_READ_SYMLINK, + FS_VNODE_CAPABILITY_CREATE_SYMLINK, + + FS_VNODE_CAPABILITY_LINK, + FS_VNODE_CAPABILITY_UNLINK, + FS_VNODE_CAPABILITY_RENAME, + + FS_VNODE_CAPABILITY_ACCESS, + FS_VNODE_CAPABILITY_READ_STAT, + FS_VNODE_CAPABILITY_WRITE_STAT, + + // file operations + FS_VNODE_CAPABILITY_CREATE, + FS_VNODE_CAPABILITY_OPEN, + FS_VNODE_CAPABILITY_CLOSE, + FS_VNODE_CAPABILITY_FREE_COOKIE, + FS_VNODE_CAPABILITY_READ, + FS_VNODE_CAPABILITY_WRITE, + + // directory operations + FS_VNODE_CAPABILITY_CREATE_DIR, + FS_VNODE_CAPABILITY_REMOVE_DIR, + FS_VNODE_CAPABILITY_OPEN_DIR, + FS_VNODE_CAPABILITY_CLOSE_DIR, + FS_VNODE_CAPABILITY_FREE_DIR_COOKIE, + FS_VNODE_CAPABILITY_READ_DIR, + FS_VNODE_CAPABILITY_REWIND_DIR, + + // attribute directory operations + FS_VNODE_CAPABILITY_OPEN_ATTR_DIR, + FS_VNODE_CAPABILITY_CLOSE_ATTR_DIR, + FS_VNODE_CAPABILITY_FREE_ATTR_DIR_COOKIE, + FS_VNODE_CAPABILITY_READ_ATTR_DIR, + FS_VNODE_CAPABILITY_REWIND_ATTR_DIR, + + // attribute operations + FS_VNODE_CAPABILITY_CREATE_ATTR, + FS_VNODE_CAPABILITY_OPEN_ATTR, + FS_VNODE_CAPABILITY_CLOSE_ATTR, + FS_VNODE_CAPABILITY_FREE_ATTR_COOKIE, + FS_VNODE_CAPABILITY_READ_ATTR, + FS_VNODE_CAPABILITY_WRITE_ATTR, + + FS_VNODE_CAPABILITY_READ_ATTR_STAT, + FS_VNODE_CAPABILITY_WRITE_ATTR_STAT, + FS_VNODE_CAPABILITY_RENAME_ATTR, + FS_VNODE_CAPABILITY_REMOVE_ATTR, + + // support for node and FS layers + FS_VNODE_CAPABILITY_CREATE_SPECIAL_NODE, + FS_VNODE_CAPABILITY_GET_SUPER_VNODE, + + FS_VNODE_CAPABILITY_COUNT +}; namespace UserlandFSUtil { -struct FSCapabilities { - client_fs_type clientFSType; - uint8 capabilities[(FS_CAPABILITY_COUNT + 7) / 8]; +template +struct FSCapabilitiesBase { + uint8 capabilities[(CapabilityCount + 7) / 8]; inline void ClearAll(); @@ -131,17 +157,19 @@ struct FSCapabilities { }; // ClearAll +template inline void -FSCapabilities::ClearAll() +FSCapabilitiesBase::ClearAll() { memset(capabilities, 0, sizeof(capabilities)); } // Set +template inline void -FSCapabilities::Set(uint32 capability, bool set) +FSCapabilitiesBase::Set(uint32 capability, bool set) { - if (capability >= FS_CAPABILITY_COUNT) + if (capability >= CapabilityCount) return; uint8 flag = uint8(1 << (capability % 8)); @@ -152,17 +180,19 @@ FSCapabilities::Set(uint32 capability, bool set) } // Clear +template inline void -FSCapabilities::Clear(uint32 capability) +FSCapabilitiesBase::Clear(uint32 capability) { Set(capability, false); } // Get +template inline bool -FSCapabilities::Get(uint32 capability) const +FSCapabilitiesBase::Get(uint32 capability) const { - if (capability >= FS_CAPABILITY_COUNT) + if (capability >= CapabilityCount) return false; uint8 flag = uint8(1 << (capability % 8)); @@ -170,8 +200,9 @@ FSCapabilities::Get(uint32 capability) const } // Dump +template inline void -FSCapabilities::Dump() const +FSCapabilitiesBase::Dump() const { D( char buffer[128]; @@ -179,11 +210,15 @@ FSCapabilities::Dump() const for (int i = 0; i < byteCount; i++) sprintf(buffer + 2 * i, "%02x", (int)capabilities[i]); - PRINT(("FSCapabilities[%d, %s]\n", clientFSType, buffer)); + PRINT(("FSCapabilities[%s]\n", buffer)); ) } +typedef FSCapabilitiesBase FSCapabilities; +typedef FSCapabilitiesBase FSVolumeCapabilities; +typedef FSCapabilitiesBase FSVNodeCapabilities; + } // namespace UserlandFSUtil using UserlandFSUtil::FSCapabilities; diff --git a/headers/private/userlandfs/private/Requests.h b/headers/private/userlandfs/private/Requests.h index d89749c4c2..9fede232b6 100644 --- a/headers/private/userlandfs/private/Requests.h +++ b/headers/private/userlandfs/private/Requests.h @@ -316,6 +316,7 @@ public: Address portInfos; int32 portInfoCount; FSCapabilities capabilities; + client_fs_type clientFSType; }; @@ -340,8 +341,9 @@ class MountVolumeReply : public ReplyRequest { public: MountVolumeReply() : ReplyRequest(MOUNT_VOLUME_REPLY) {} - ino_t rootID; - void* volume; + ino_t rootID; + void* volume; + FSVolumeCapabilities capabilities; }; // UnmountVolumeRequest diff --git a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.cpp b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.cpp index 4be9ae7a9c..e9dff6a893 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.cpp @@ -282,7 +282,7 @@ status_t Volume::Sync() { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_SYNC)) + if (!HasCapability(FS_VOLUME_CAPABILITY_SYNC)) return B_BAD_VALUE; // get a free port @@ -343,7 +343,7 @@ status_t Volume::WriteFSInfo(const struct fs_info *info, uint32 mask) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_WRITE_FS_INFO)) + if (!HasCapability(FS_VOLUME_CAPABILITY_WRITE_FS_INFO)) return B_BAD_VALUE; // get a free port @@ -635,7 +635,7 @@ Volume::IOCtl(void* node, void* cookie, uint32 command, void *buffer, } // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_IOCTL)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_IOCTL)) return B_BAD_VALUE; // get a free port @@ -695,7 +695,7 @@ status_t Volume::SetFlags(void* node, void* cookie, int flags) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_SET_FLAGS)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_SET_FLAGS)) return B_BAD_VALUE; // get a free port @@ -735,7 +735,7 @@ status_t Volume::Select(void* node, void* cookie, uint8 event, selectsync* sync) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_SELECT)) { + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_SELECT)) { notify_select_event(sync, event); return B_OK; } @@ -787,7 +787,7 @@ status_t Volume::Deselect(void* node, void* cookie, uint8 event, selectsync* sync) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_DESELECT)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_DESELECT)) return B_OK; struct SyncRemover { @@ -837,7 +837,7 @@ status_t Volume::FSync(void* node) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_FSYNC)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_FSYNC)) return B_BAD_VALUE; // get a free port @@ -878,7 +878,7 @@ Volume::ReadSymlink(void* node, char* buffer, size_t bufferSize, *bytesRead = 0; // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_SYMLINK)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_READ_SYMLINK)) return B_BAD_VALUE; // get a free port @@ -927,7 +927,7 @@ Volume::CreateSymlink(void* dir, const char* name, const char* target, int mode) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_CREATE_SYMLINK)) + if (!HasVNodeCapability(dir, FS_VNODE_CAPABILITY_CREATE_SYMLINK)) return B_BAD_VALUE; // get a free port @@ -971,7 +971,7 @@ status_t Volume::Link(void* dir, const char* name, void* node) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_LINK)) + if (!HasVNodeCapability(dir, FS_VNODE_CAPABILITY_LINK)) return B_BAD_VALUE; // get a free port @@ -1013,7 +1013,7 @@ status_t Volume::Unlink(void* dir, const char* name) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_UNLINK)) + if (!HasVNodeCapability(dir, FS_VNODE_CAPABILITY_UNLINK)) return B_BAD_VALUE; // get a free port @@ -1055,7 +1055,7 @@ Volume::Rename(void* oldDir, const char* oldName, void* newDir, const char* newName) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_RENAME)) + if (!HasVNodeCapability(oldDir, FS_VNODE_CAPABILITY_RENAME)) return B_BAD_VALUE; // get a free port @@ -1099,7 +1099,7 @@ status_t Volume::Access(void* node, int mode) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_ACCESS)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_ACCESS)) return B_OK; // get a free port @@ -1168,7 +1168,7 @@ status_t Volume::WriteStat(void* node, const struct stat* st, uint32 mask) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_WRITE_STAT)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_WRITE_STAT)) return B_BAD_VALUE; // get a free port @@ -1212,7 +1212,7 @@ Volume::Create(void* dir, const char* name, int openMode, int mode, void** cookie, ino_t* vnid) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_CREATE)) + if (!HasVNodeCapability(dir, FS_VNODE_CAPABILITY_CREATE)) return B_BAD_VALUE; // get a free port @@ -1262,7 +1262,7 @@ status_t Volume::Open(void* node, int openMode, void** cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_OPEN)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_OPEN)) return B_BAD_VALUE; // get a free port @@ -1341,7 +1341,7 @@ Volume::Read(void* node, void* cookie, off_t pos, void* buffer, *bytesRead = 0; // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_READ)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_READ)) return B_BAD_VALUE; // get a free port @@ -1394,7 +1394,7 @@ Volume::Write(void* node, void* cookie, off_t pos, const void* buffer, *bytesWritten = 0; // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_WRITE)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_WRITE)) return B_BAD_VALUE; // get a free port @@ -1441,7 +1441,7 @@ status_t Volume::CreateDir(void* dir, const char* name, int mode, ino_t *newDir) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_CREATE_DIR)) + if (!HasVNodeCapability(dir, FS_VNODE_CAPABILITY_CREATE_DIR)) return B_BAD_VALUE; // get a free port @@ -1484,7 +1484,7 @@ status_t Volume::RemoveDir(void* dir, const char* name) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_REMOVE_DIR)) + if (!HasVNodeCapability(dir, FS_VNODE_CAPABILITY_REMOVE_DIR)) return B_BAD_VALUE; // get a free port @@ -1525,7 +1525,7 @@ status_t Volume::OpenDir(void* node, void** cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_OPEN_DIR)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_OPEN_DIR)) return B_BAD_VALUE; // get a free port @@ -1604,7 +1604,7 @@ Volume::ReadDir(void* node, void* cookie, void* buffer, size_t bufferSize, *countRead = 0; // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_DIR)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_READ_DIR)) return B_BAD_VALUE; // get a free port @@ -1663,7 +1663,7 @@ status_t Volume::RewindDir(void* node, void* cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_REWIND_DIR)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_REWIND_DIR)) return B_BAD_VALUE; // get a free port @@ -1706,7 +1706,7 @@ status_t Volume::OpenAttrDir(void* node, void** cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_OPEN_ATTR_DIR)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_OPEN_ATTR_DIR)) return B_BAD_VALUE; // get a free port @@ -1785,7 +1785,7 @@ Volume::ReadAttrDir(void* node, void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_ATTR_DIR)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_READ_ATTR_DIR)) return B_BAD_VALUE; *countRead = 0; @@ -1843,7 +1843,7 @@ status_t Volume::RewindAttrDir(void* node, void* cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_REWIND_ATTR_DIR)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_REWIND_ATTR_DIR)) return B_BAD_VALUE; // get a free port @@ -1886,7 +1886,7 @@ Volume::CreateAttr(void* node, const char* name, uint32 type, int openMode, void** cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_CREATE_ATTR)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_CREATE_ATTR)) return B_BAD_VALUE; // get a free port @@ -1933,7 +1933,7 @@ Volume::OpenAttr(void* node, const char* name, int openMode, void** cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_OPEN_ATTR)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_OPEN_ATTR)) return B_BAD_VALUE; // get a free port @@ -2017,7 +2017,7 @@ Volume::ReadAttr(void* node, void* cookie, off_t pos, *bytesRead = 0; // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_ATTR)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_READ_ATTR)) return B_BAD_VALUE; // get a free port @@ -2070,7 +2070,7 @@ Volume::WriteAttr(void* node, void* cookie, off_t pos, *bytesWritten = 0; // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_WRITE_ATTR)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_WRITE_ATTR)) return B_BAD_VALUE; // get a free port @@ -2114,7 +2114,7 @@ status_t Volume::ReadAttrStat(void* node, void* cookie, struct stat *st) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_ATTR_STAT)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_READ_ATTR_STAT)) return B_BAD_VALUE; // get a free port @@ -2155,7 +2155,7 @@ Volume::WriteAttrStat(void* node, void* cookie, const struct stat *st, int statMask) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_WRITE_ATTR_STAT)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_WRITE_ATTR_STAT)) return B_BAD_VALUE; // get a free port @@ -2197,7 +2197,7 @@ Volume::RenameAttr(void* oldNode, const char* oldName, void* newNode, const char* newName) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_RENAME_ATTR)) + if (!HasVNodeCapability(oldNode, FS_VNODE_CAPABILITY_RENAME_ATTR)) return B_BAD_VALUE; // get a free port @@ -2241,7 +2241,7 @@ status_t Volume::RemoveAttr(void* node, const char* name) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_REMOVE_ATTR)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_REMOVE_ATTR)) return B_BAD_VALUE; // get a free port @@ -2286,7 +2286,7 @@ status_t Volume::OpenIndexDir(void** cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_OPEN_INDEX_DIR)) + if (!HasCapability(FS_VOLUME_CAPABILITY_OPEN_INDEX_DIR)) return B_BAD_VALUE; // get a free port @@ -2366,7 +2366,7 @@ Volume::ReadIndexDir(void* cookie, void* buffer, size_t bufferSize, *countRead = 0; // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_INDEX_DIR)) + if (!HasCapability(FS_VOLUME_CAPABILITY_READ_INDEX_DIR)) return B_BAD_VALUE; // get a free port @@ -2422,7 +2422,7 @@ status_t Volume::RewindIndexDir(void* cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_REWIND_INDEX_DIR)) + if (!HasCapability(FS_VOLUME_CAPABILITY_REWIND_INDEX_DIR)) return B_BAD_VALUE; // get a free port @@ -2460,7 +2460,7 @@ status_t Volume::CreateIndex(const char* name, uint32 type, uint32 flags) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_CREATE_INDEX)) + if (!HasCapability(FS_VOLUME_CAPABILITY_CREATE_INDEX)) return B_BAD_VALUE; // get a free port @@ -2502,7 +2502,7 @@ status_t Volume::RemoveIndex(const char* name) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_REMOVE_INDEX)) + if (!HasCapability(FS_VOLUME_CAPABILITY_REMOVE_INDEX)) return B_BAD_VALUE; // get a free port @@ -2542,7 +2542,7 @@ status_t Volume::ReadIndexStat(const char* name, struct stat *st) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_INDEX_STAT)) + if (!HasCapability(FS_VOLUME_CAPABILITY_READ_INDEX_STAT)) return B_BAD_VALUE; // get a free port @@ -2588,7 +2588,7 @@ Volume::OpenQuery(const char* queryString, uint32 flags, port_id targetPort, uint32 token, void** cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_OPEN_QUERY)) + if (!HasCapability(FS_VOLUME_CAPABILITY_OPEN_QUERY)) return B_BAD_VALUE; // get a free port @@ -2673,7 +2673,7 @@ Volume::ReadQuery(void* cookie, void* buffer, size_t bufferSize, *countRead = 0; // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_QUERY)) + if (!HasCapability(FS_VOLUME_CAPABILITY_READ_QUERY)) return B_BAD_VALUE; // get a free port @@ -2729,7 +2729,7 @@ status_t Volume::RewindQuery(void* cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_REWIND_QUERY)) + if (!HasCapability(FS_VOLUME_CAPABILITY_REWIND_QUERY)) return B_BAD_VALUE; // get a free port @@ -2810,6 +2810,7 @@ Volume::_Mount(const char* device, uint32 flags, const char* parameters) return reply->error; fRootID = reply->rootID; fUserlandVolume = reply->volume; + fCapabilities = reply->capabilities; // enable vnode counting fVNodeCountMap = new(nothrow) VNodeCountMap; @@ -2858,7 +2859,7 @@ status_t Volume::_ReadFSInfo(fs_info* info) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_FS_INFO)) + if (!HasCapability(FS_VOLUME_CAPABILITY_READ_FS_INFO)) return B_BAD_VALUE; // get a free port @@ -2970,7 +2971,7 @@ status_t Volume::_ReadStat(void* node, struct stat* st) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_STAT)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_READ_STAT)) return B_BAD_VALUE; // get a free port @@ -3009,7 +3010,7 @@ status_t Volume::_Close(void* node, void* cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_CLOSE)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_CLOSE)) return B_OK; // get a free port @@ -3048,7 +3049,7 @@ status_t Volume::_FreeCookie(void* node, void* cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_FREE_COOKIE)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_FREE_COOKIE)) return B_OK; // get a free port @@ -3087,7 +3088,7 @@ status_t Volume::_CloseDir(void* node, void* cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_CLOSE_DIR)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_CLOSE_DIR)) return B_OK; // get a free port @@ -3126,7 +3127,7 @@ status_t Volume::_FreeDirCookie(void* node, void* cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_FREE_DIR_COOKIE)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_FREE_DIR_COOKIE)) return B_OK; // get a free port @@ -3165,7 +3166,7 @@ status_t Volume::_CloseAttrDir(void* node, void* cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_CLOSE_ATTR_DIR)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_CLOSE_ATTR_DIR)) return B_OK; // get a free port @@ -3204,7 +3205,7 @@ status_t Volume::_FreeAttrDirCookie(void* node, void* cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_FREE_ATTR_DIR_COOKIE)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_FREE_ATTR_DIR_COOKIE)) return B_OK; // get a free port @@ -3243,7 +3244,7 @@ status_t Volume::_CloseAttr(void* node, void* cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_CLOSE_ATTR)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_CLOSE_ATTR)) return B_OK; // get a free port @@ -3282,7 +3283,7 @@ status_t Volume::_FreeAttrCookie(void* node, void* cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_FREE_ATTR_COOKIE)) + if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_FREE_ATTR_COOKIE)) return B_OK; // get a free port @@ -3321,7 +3322,7 @@ status_t Volume::_CloseIndexDir(void* cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_CLOSE_INDEX_DIR)) + if (!HasCapability(FS_VOLUME_CAPABILITY_CLOSE_INDEX_DIR)) return B_OK; // get a free port @@ -3359,7 +3360,7 @@ status_t Volume::_FreeIndexDirCookie(void* cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_FREE_INDEX_DIR_COOKIE)) + if (!HasCapability(FS_VOLUME_CAPABILITY_FREE_INDEX_DIR_COOKIE)) return B_OK; // get a free port @@ -3397,7 +3398,7 @@ status_t Volume::_CloseQuery(void* cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_CLOSE_QUERY)) + if (!HasCapability(FS_VOLUME_CAPABILITY_CLOSE_QUERY)) return B_OK; // get a free port @@ -3435,7 +3436,7 @@ status_t Volume::_FreeQueryCookie(void* cookie) { // check capability - if (!fFileSystem->HasCapability(FS_CAPABILITY_FREE_QUERY_COOKIE)) + if (!HasCapability(FS_VOLUME_CAPABILITY_FREE_QUERY_COOKIE)) return B_OK; // get a free port diff --git a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.h b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.h index 56ab51f48b..80244057a1 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.h +++ b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.h @@ -7,6 +7,7 @@ #include +#include "FSCapabilities.h" #include "Referencable.h" namespace UserlandFSUtil { @@ -19,6 +20,7 @@ struct userlandfs_ioctl; } +using UserlandFSUtil::FSVolumeCapabilities; using UserlandFSUtil::Request; using UserlandFSUtil::RequestAllocator; using UserlandFSUtil::RequestHandler; @@ -36,6 +38,10 @@ public: FileSystem* GetFileSystem() const; inline dev_t GetID() const; + inline bool HasCapability(int capability) const; + inline bool HasVNodeCapability(void* vnode, + int capability) const; + void* GetUserlandVolume() const; ino_t GetRootID() const; bool IsMounting() const; @@ -226,6 +232,7 @@ private: FileSystem* fFileSystem; fs_volume* fFSVolume; + FSVolumeCapabilities fCapabilities; void* fUserlandVolume; ino_t fRootID; void* fRootNode; @@ -252,4 +259,19 @@ Volume::GetID() const } +inline bool +Volume::HasCapability(int capability) const +{ + return fCapabilities.Get(capability); +} + + +inline bool +Volume::HasVNodeCapability(void* vnode, int capability) const +{ + // TODO: Implement for real! + return true; +} + + #endif // USERLAND_FS_VOLUME_H diff --git a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/kernel_interface.cpp b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/kernel_interface.cpp index 61d7d169e5..44928c93f9 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/kernel_interface.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/kernel_interface.cpp @@ -1168,13 +1168,11 @@ fs_vnode_ops gUserlandFSVnodeOps = { &userlandfs_put_vnode, &userlandfs_remove_vnode, - // VM file access NULL, // &userlandfs_can_page, NULL, // &userlandfs_read_pages, NULL, // &userlandfs_write_pages, - // asynchronous I/O NULL, // &userlandfs_io NULL, // &userlandfs_cancel_io diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelVolume.cpp b/src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelVolume.cpp index 62303c7d38..f286965454 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelVolume.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelVolume.cpp @@ -114,8 +114,7 @@ BeOSKernelVolume::WriteFSInfo(const struct fs_info* info, uint32 mask) // Lookup status_t -BeOSKernelVolume::Lookup(fs_vnode dir, const char* entryName, ino_t* vnid, - int* type) +BeOSKernelVolume::Lookup(fs_vnode dir, const char* entryName, ino_t* vnid) { if (!fFSOps->walk) return B_BAD_VALUE; @@ -147,7 +146,7 @@ BeOSKernelVolume::Lookup(fs_vnode dir, const char* entryName, ino_t* vnid, if (error == B_OK) *type = (st.st_mode & S_IFMT); - // put the node for our get_vnode() + // put the node for our get_vnode() UserlandFS::KernelEmu::put_vnode(GetID(), *vnid); // on error put the node for walk()'s get_vnode() @@ -169,8 +168,10 @@ BeOSKernelVolume::LookupNoType(fs_vnode dir, const char* entryName, // ReadVNode status_t -BeOSKernelVolume::ReadVNode(ino_t vnid, bool reenter, fs_vnode* node) +BeOSKernelVolume::ReadVNode(ino_t vnid, bool reenter, fs_vnode* node, int* type, + uint32* flags) { +#error Return type and flags! if (!fFSOps->read_vnode) return B_BAD_VALUE; return fFSOps->read_vnode(fVolumeCookie, vnid, (char)reenter, node); @@ -221,13 +222,13 @@ BeOSKernelVolume::SetFlags(fs_vnode node, fs_cookie cookie, int flags) // Select status_t BeOSKernelVolume::Select(fs_vnode node, fs_cookie cookie, uint8 event, - uint32 ref, selectsync* sync) + selectsync* sync) { if (!fFSOps->select) { UserlandFS::KernelEmu::notify_select_event(sync, event, false); return B_OK; } - return fFSOps->select(fVolumeCookie, node, cookie, event, ref, sync); + return fFSOps->select(fVolumeCookie, node, cookie, event, 0, sync); } // Deselect @@ -326,7 +327,7 @@ BeOSKernelVolume::WriteStat(fs_vnode node, const struct stat *st, uint32 mask) { if (!fFSOps->wstat) return B_BAD_VALUE; - + // Haiku's struct stat has an additional st_type field (for an attribute // type), but that doesn't matter here return fFSOps->wstat(fVolumeCookie, node, (struct beos_stat*)st, @@ -472,7 +473,7 @@ BeOSKernelVolume::ReadDir(fs_vnode node, fs_vnode cookie, void* buffer, return B_BAD_VALUE; *countRead = count; - + // Haiku's struct dirent equals BeOS's version return fFSOps->readdir(fVolumeCookie, node, cookie, (long*)countRead, (beos_dirent*)buffer, bufferSize); diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelVolume.h b/src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelVolume.h index 6f55ecf84a..3068e74753 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelVolume.h +++ b/src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelVolume.h @@ -26,12 +26,12 @@ public: // vnodes virtual status_t Lookup(fs_vnode dir, const char* entryName, - ino_t* vnid, int* type); + ino_t* vnid); virtual status_t LookupNoType(fs_vnode dir, const char* entryName, ino_t* vnid); // not required virtual status_t ReadVNode(ino_t vnid, bool reenter, - fs_vnode* node); + fs_vnode* node, int* type, uint32* flags); virtual status_t WriteVNode(fs_vnode node, bool reenter); virtual status_t RemoveVNode(fs_vnode node, bool reenter); @@ -41,7 +41,7 @@ public: virtual status_t SetFlags(fs_vnode node, fs_cookie cookie, int flags); virtual status_t Select(fs_vnode node, fs_cookie cookie, - uint8 event, uint32 ref, selectsync* sync); + uint8 event, selectsync* sync); virtual status_t Deselect(fs_vnode node, fs_cookie cookie, uint8 event, selectsync* sync); diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/FSInfo.h b/src/add-ons/kernel/file_systems/userlandfs/server/FSInfo.h index 8ef0e8ff41..14cffdfc91 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/FSInfo.h +++ b/src/add-ons/kernel/file_systems/userlandfs/server/FSInfo.h @@ -27,12 +27,12 @@ public: } FSInfo(const char* fsName, const Port::Info* infos, int32 count, - const FSCapabilities& capabilities) + const FSCapabilities& capabilities, client_fs_type clientFSType) : fName(), fInfos(NULL), fCount(0) { - SetTo(fsName, infos, count, capabilities); + SetTo(fsName, infos, count, capabilities, clientFSType); } FSInfo(const BMessage* message) @@ -48,7 +48,8 @@ public: fInfos(NULL), fCount(0) { - SetTo(other.GetName(), other.fInfos, other.fCount, other.fCapabilities); + SetTo(other.GetName(), other.fInfos, other.fCount, other.fCapabilities, + other.fClientFSType); } ~FSInfo() @@ -57,7 +58,7 @@ public: } status_t SetTo(const char* fsName, const Port::Info* infos, int32 count, - const FSCapabilities& capabilities) + const FSCapabilities& capabilities, client_fs_type clientFSType) { Unset(); @@ -73,7 +74,8 @@ public: memcpy(fInfos, infos, sizeof(Port::Info) * count); fCapabilities = capabilities; - + fClientFSType = clientFSType; + fCount = count; return B_OK; } @@ -90,16 +92,19 @@ public: const char* fsName; const void* capabilities; ssize_t capabilitiesSize; - + int32 clientFSType; + if (message->FindData("infos", B_RAW_TYPE, &infos, &size) != B_OK || size < 0 || message->FindString("fsName", &fsName) != B_OK || message->FindData("capabilities", B_RAW_TYPE, &capabilities, &capabilitiesSize) != B_OK - || capabilitiesSize != sizeof(FSCapabilities)) { + || capabilitiesSize != sizeof(FSCapabilities) + || message->FindInt32("clientFSType", &clientFSType) != B_OK) { return B_BAD_VALUE; } return SetTo(fsName, (const Port::Info*)infos, - size / sizeof(Port::Info), *(const FSCapabilities*)capabilities); + size / sizeof(Port::Info), *(const FSCapabilities*)capabilities, + (client_fs_type)clientFSType); } void Unset() @@ -135,6 +140,11 @@ public: return fCapabilities; } + client_fs_type GetClientFSType() const + { + return fClientFSType; + } + status_t Archive(BMessage* archive) { if (!fName.GetString() || !fInfos) @@ -149,8 +159,12 @@ public: if (error != B_OK) return error; - return archive->AddData("capabilities", B_RAW_TYPE, &fCapabilities, + error = archive->AddData("capabilities", B_RAW_TYPE, &fCapabilities, sizeof(FSCapabilities)); + if (error != B_OK) + return error; + + return archive->AddInt32("clientFSType", fClientFSType); } private: @@ -158,6 +172,7 @@ private: Port::Info* fInfos; int32 fCount; FSCapabilities fCapabilities; + client_fs_type fClientFSType; }; } // namespace UserlandFS diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/FileSystem.h b/src/add-ons/kernel/file_systems/userlandfs/server/FileSystem.h index 6ea3295375..3bdd594653 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/FileSystem.h +++ b/src/add-ons/kernel/file_systems/userlandfs/server/FileSystem.h @@ -23,9 +23,12 @@ public: void GetCapabilities( FSCapabilities& capabilities) const { capabilities = fCapabilities; } + client_fs_type GetClientFSType() const + { return fClientFSType; } protected: FSCapabilities fCapabilities; + client_fs_type fClientFSType; }; } // namespace UserlandFS diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelFileSystem.cpp b/src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelFileSystem.cpp index 4b8e759ac8..3fbb69bbf2 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelFileSystem.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelFileSystem.cpp @@ -68,106 +68,8 @@ HaikuKernelFileSystem::_InitCapabilities() fCapabilities.ClearAll(); // FS interface type - fCapabilities.clientFSType = CLIENT_FS_HAIKU_KERNEL; + fClientFSType = CLIENT_FS_HAIKU_KERNEL; // FS operations fCapabilities.Set(FS_CAPABILITY_MOUNT, fFSModule->mount); - fCapabilities.Set(FS_CAPABILITY_UNMOUNT, fFSModule->unmount); - - fCapabilities.Set(FS_CAPABILITY_READ_FS_INFO, fFSModule->read_fs_info); - fCapabilities.Set(FS_CAPABILITY_WRITE_FS_INFO, fFSModule->write_fs_info); - fCapabilities.Set(FS_CAPABILITY_SYNC, fFSModule->sync); - - // vnode operations - fCapabilities.Set(FS_CAPABILITY_LOOKUP, fFSModule->lookup); - fCapabilities.Set(FS_CAPABILITY_GET_VNODE_NAME, fFSModule->get_vnode_name); - - fCapabilities.Set(FS_CAPABILITY_GET_VNODE, fFSModule->get_vnode); - fCapabilities.Set(FS_CAPABILITY_PUT_VNODE, fFSModule->put_vnode); - fCapabilities.Set(FS_CAPABILITY_REMOVE_VNODE, fFSModule->remove_vnode); - - // VM file access - fCapabilities.Set(FS_CAPABILITY_CAN_PAGE, fFSModule->can_page); - fCapabilities.Set(FS_CAPABILITY_READ_PAGES, fFSModule->read_pages); - fCapabilities.Set(FS_CAPABILITY_WRITE_PAGES, fFSModule->write_pages); - - // cache file access - fCapabilities.Set(FS_CAPABILITY_GET_FILE_MAP, fFSModule->get_file_map); - - // common operations - fCapabilities.Set(FS_CAPABILITY_IOCTL, fFSModule->ioctl); - fCapabilities.Set(FS_CAPABILITY_SET_FLAGS, fFSModule->set_flags); - fCapabilities.Set(FS_CAPABILITY_SELECT, fFSModule->select); - fCapabilities.Set(FS_CAPABILITY_DESELECT, fFSModule->deselect); - fCapabilities.Set(FS_CAPABILITY_FSYNC, fFSModule->fsync); - - fCapabilities.Set(FS_CAPABILITY_READ_SYMLINK, fFSModule->read_symlink); - fCapabilities.Set(FS_CAPABILITY_CREATE_SYMLINK, fFSModule->create_symlink); - - fCapabilities.Set(FS_CAPABILITY_LINK, fFSModule->link); - fCapabilities.Set(FS_CAPABILITY_UNLINK, fFSModule->unlink); - fCapabilities.Set(FS_CAPABILITY_RENAME, fFSModule->rename); - - fCapabilities.Set(FS_CAPABILITY_ACCESS, fFSModule->access); - fCapabilities.Set(FS_CAPABILITY_READ_STAT, fFSModule->read_stat); - fCapabilities.Set(FS_CAPABILITY_WRITE_STAT, fFSModule->write_stat); - - // file operations - fCapabilities.Set(FS_CAPABILITY_CREATE, fFSModule->create); - fCapabilities.Set(FS_CAPABILITY_OPEN, fFSModule->open); - fCapabilities.Set(FS_CAPABILITY_CLOSE, fFSModule->close); - fCapabilities.Set(FS_CAPABILITY_FREE_COOKIE, fFSModule->free_cookie); - fCapabilities.Set(FS_CAPABILITY_READ, fFSModule->read); - fCapabilities.Set(FS_CAPABILITY_WRITE, fFSModule->write); - - // directory operations - fCapabilities.Set(FS_CAPABILITY_CREATE_DIR, fFSModule->create_dir); - fCapabilities.Set(FS_CAPABILITY_REMOVE_DIR, fFSModule->remove_dir); - fCapabilities.Set(FS_CAPABILITY_OPEN_DIR, fFSModule->open_dir); - fCapabilities.Set(FS_CAPABILITY_CLOSE_DIR, fFSModule->close_dir); - fCapabilities.Set(FS_CAPABILITY_FREE_DIR_COOKIE, fFSModule->free_dir_cookie); - fCapabilities.Set(FS_CAPABILITY_READ_DIR, fFSModule->read_dir); - fCapabilities.Set(FS_CAPABILITY_REWIND_DIR, fFSModule->rewind_dir); - - // attribute directory operations - fCapabilities.Set(FS_CAPABILITY_OPEN_ATTR_DIR, fFSModule->open_attr_dir); - fCapabilities.Set(FS_CAPABILITY_CLOSE_ATTR_DIR, fFSModule->close_attr_dir); - fCapabilities.Set(FS_CAPABILITY_FREE_ATTR_DIR_COOKIE, - fFSModule->free_attr_dir_cookie); - fCapabilities.Set(FS_CAPABILITY_READ_ATTR_DIR, fFSModule->read_attr_dir); - fCapabilities.Set(FS_CAPABILITY_REWIND_ATTR_DIR, fFSModule->rewind_attr_dir); - - // attribute operations - fCapabilities.Set(FS_CAPABILITY_CREATE_ATTR, fFSModule->create_attr); - fCapabilities.Set(FS_CAPABILITY_OPEN_ATTR, fFSModule->open_attr); - fCapabilities.Set(FS_CAPABILITY_CLOSE_ATTR, fFSModule->close_attr); - fCapabilities.Set(FS_CAPABILITY_FREE_ATTR_COOKIE, - fFSModule->free_attr_cookie); - fCapabilities.Set(FS_CAPABILITY_READ_ATTR, fFSModule->read_attr); - fCapabilities.Set(FS_CAPABILITY_WRITE_ATTR, fFSModule->write_attr); - - fCapabilities.Set(FS_CAPABILITY_READ_ATTR_STAT, fFSModule->read_attr_stat); - fCapabilities.Set(FS_CAPABILITY_WRITE_ATTR_STAT, - fFSModule->write_attr_stat); - fCapabilities.Set(FS_CAPABILITY_RENAME_ATTR, fFSModule->rename_attr); - fCapabilities.Set(FS_CAPABILITY_REMOVE_ATTR, fFSModule->remove_attr); - - // index directory & index operations - fCapabilities.Set(FS_CAPABILITY_OPEN_INDEX_DIR, fFSModule->open_index_dir); - fCapabilities.Set(FS_CAPABILITY_CLOSE_INDEX_DIR, fFSModule->close_index_dir); - fCapabilities.Set(FS_CAPABILITY_FREE_INDEX_DIR_COOKIE, - fFSModule->free_index_dir_cookie); - fCapabilities.Set(FS_CAPABILITY_READ_INDEX_DIR, fFSModule->read_index_dir); - fCapabilities.Set(FS_CAPABILITY_REWIND_INDEX_DIR, fFSModule->rewind_index_dir); - - fCapabilities.Set(FS_CAPABILITY_CREATE_INDEX, fFSModule->create_index); - fCapabilities.Set(FS_CAPABILITY_REMOVE_INDEX, fFSModule->remove_index); - fCapabilities.Set(FS_CAPABILITY_READ_INDEX_STAT, fFSModule->read_index_stat); - - // query operations - fCapabilities.Set(FS_CAPABILITY_OPEN_QUERY, fFSModule->open_query); - fCapabilities.Set(FS_CAPABILITY_CLOSE_QUERY, fFSModule->close_query); - fCapabilities.Set(FS_CAPABILITY_FREE_QUERY_COOKIE, fFSModule->free_query_cookie); - fCapabilities.Set(FS_CAPABILITY_READ_QUERY, fFSModule->read_query); - fCapabilities.Set(FS_CAPABILITY_REWIND_QUERY, fFSModule->rewind_query); } diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelNode.h b/src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelNode.h new file mode 100644 index 0000000000..d1b8fd2417 --- /dev/null +++ b/src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelNode.h @@ -0,0 +1,41 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ +#ifndef USERLAND_FS_HAIKU_KERNEL_NODE_H +#define USERLAND_FS_HAIKU_KERNEL_NODE_H + +#include +#include + +#include "FSCapabilities.h" + +namespace UserlandFS { + +class HaikuKernelVolume; + +using UserlandFSUtil::FSVNodeCapabilities; + + +struct HaikuKernelNode : fs_vnode { + HaikuKernelVolume* volume; + +public: + static HaikuKernelNode* GetNode(fs_vnode* node); + + HaikuKernelVolume* GetVolume() const { return volume; } +}; + + +/*static*/ inline HaikuKernelNode* +HaikuKernelNode::GetNode(fs_vnode* node) +{ + return static_cast(node); +} + + +} // namespace UserlandFS + +using UserlandFS::HaikuKernelNode; + +#endif // USERLAND_FS_NODE_H diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelVolume.cpp b/src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelVolume.cpp index 3e8778ecca..5943f58673 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelVolume.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelVolume.cpp @@ -10,15 +10,25 @@ #include "Debug.h" #include "kernel_emu.h" #include "haiku_fs_cache.h" +#include "HaikuKernelNode.h" // constructor HaikuKernelVolume::HaikuKernelVolume(FileSystem* fileSystem, dev_t id, file_system_module_info* fsModule) : Volume(fileSystem, id), - fFSModule(fsModule), - fVolumeCookie(NULL) + fFSModule(fsModule) { + fVolume.id = id; + fVolume.partition = -1; + fVolume.layer = 0; + fVolume.private_volume = NULL; // filled in by the FS + fVolume.ops = NULL; // filled in by the FS + fVolume.sub_volume = NULL; + fVolume.super_volume = NULL; + fVolume.file_system = fFSModule; + fVolume.file_system_name = "dummy"; // TODO: Init correctly! + fVolume.haikuVolume = this; } // destructor @@ -37,20 +47,21 @@ HaikuKernelVolume::Mount(const char* device, uint32 flags, if (!fFSModule->mount) return B_BAD_VALUE; - // make the volume know to the file cache emulation + // make the volume known to the file cache emulation status_t error = UserlandFS::HaikuKernelEmu::file_cache_register_volume(this); if (error != B_OK) return error; // mount - error = fFSModule->mount(GetID(), device, flags, parameters, - &fVolumeCookie, rootID); + error = fFSModule->mount(&fVolume, device, flags, parameters, rootID); if (error != B_OK) { UserlandFS::HaikuKernelEmu::file_cache_unregister_volume(this); return error; } + _InitCapabilities(); + return B_OK; } @@ -58,11 +69,11 @@ HaikuKernelVolume::Mount(const char* device, uint32 flags, status_t HaikuKernelVolume::Unmount() { - if (!fFSModule->unmount) + if (!fVolume.ops->unmount) return B_BAD_VALUE; // unmount - status_t error = fFSModule->unmount(fVolumeCookie); + status_t error = fVolume.ops->unmount(&fVolume); // unregister with the file cache emulation UserlandFS::HaikuKernelEmu::file_cache_unregister_volume(this); @@ -74,27 +85,27 @@ HaikuKernelVolume::Unmount() status_t HaikuKernelVolume::Sync() { - if (!fFSModule->sync) + if (!fVolume.ops->sync) return B_BAD_VALUE; - return fFSModule->sync(fVolumeCookie); + return fVolume.ops->sync(&fVolume); } // ReadFSInfo status_t HaikuKernelVolume::ReadFSInfo(fs_info* info) { - if (!fFSModule->read_fs_info) + if (!fVolume.ops->read_fs_info) return B_BAD_VALUE; - return fFSModule->read_fs_info(fVolumeCookie, info); + return fVolume.ops->read_fs_info(&fVolume, info); } // WriteFSInfo status_t HaikuKernelVolume::WriteFSInfo(const struct fs_info* info, uint32 mask) { - if (!fFSModule->write_fs_info) + if (!fVolume.ops->write_fs_info) return B_BAD_VALUE; - return fFSModule->write_fs_info(fVolumeCookie, info, mask); + return fVolume.ops->write_fs_info(&fVolume, info, mask); } @@ -103,12 +114,14 @@ HaikuKernelVolume::WriteFSInfo(const struct fs_info* info, uint32 mask) // GetFileMap status_t -HaikuKernelVolume::GetFileMap(fs_vnode node, off_t offset, size_t size, +HaikuKernelVolume::GetFileMap(void* _node, off_t offset, size_t size, struct file_io_vec* vecs, size_t* count) { - if (!fFSModule->get_file_map) + HaikuKernelNode* node = (HaikuKernelNode*)_node; + + if (!node->ops->get_file_map) return B_BAD_VALUE; - return fFSModule->get_file_map(fVolumeCookie, node, offset, size, vecs, + return node->ops->get_file_map(&fVolume, node, offset, size, vecs, count); } @@ -118,50 +131,79 @@ HaikuKernelVolume::GetFileMap(fs_vnode node, off_t offset, size_t size, // Lookup status_t -HaikuKernelVolume::Lookup(fs_vnode dir, const char* entryName, ino_t* vnid, - int* type) +HaikuKernelVolume::Lookup(void* _dir, const char* entryName, ino_t* vnid) { - if (!fFSModule->lookup) + HaikuKernelNode* dir = (HaikuKernelNode*)_dir; + + if (!dir->ops->lookup) return B_BAD_VALUE; - return fFSModule->lookup(fVolumeCookie, dir, entryName, vnid, type); + return dir->ops->lookup(&fVolume, dir, entryName, vnid); + } // GetVNodeName status_t -HaikuKernelVolume::GetVNodeName(fs_vnode node, char* buffer, size_t bufferSize) +HaikuKernelVolume::GetVNodeName(void* _node, char* buffer, size_t bufferSize) { + HaikuKernelNode* node = (HaikuKernelNode*)_node; + // If not implemented by the client file system, we invoke our super class // version, which emulates the functionality. - if (!fFSModule->get_vnode_name) - return Volume::GetVNodeName(node, buffer, bufferSize); - return fFSModule->get_vnode_name(fVolumeCookie, node, buffer, bufferSize); + if (!node->ops->get_vnode_name) + return Volume::GetVNodeName(_node, buffer, bufferSize); + return node->ops->get_vnode_name(&fVolume, node, buffer, bufferSize); } // ReadVNode status_t -HaikuKernelVolume::ReadVNode(ino_t vnid, bool reenter, fs_vnode* node) +HaikuKernelVolume::ReadVNode(ino_t vnid, bool reenter, void** _node, int* type, + uint32* flags) { - if (!fFSModule->get_vnode) + if (!fVolume.ops->get_vnode) return B_BAD_VALUE; - return fFSModule->get_vnode(fVolumeCookie, vnid, node, reenter); + + // create a new wrapper node + HaikuKernelNode* node = new(std::nothrow) HaikuKernelNode; + if (node == NULL) + return B_NO_MEMORY; + node->volume = this; + + // get the node + status_t error = fVolume.ops->get_vnode(&fVolume, vnid, node, type, flags, + reenter); + if (error != B_OK) { + delete node; + return error; + } + + *_node = node; + return B_OK; } // WriteVNode status_t -HaikuKernelVolume::WriteVNode(fs_vnode node, bool reenter) +HaikuKernelVolume::WriteVNode(void* _node, bool reenter) { - if (!fFSModule->put_vnode) + HaikuKernelNode* node = (HaikuKernelNode*)_node; + + if (!node->ops->put_vnode) return B_BAD_VALUE; - return fFSModule->put_vnode(fVolumeCookie, node, reenter); + status_t error = node->ops->put_vnode(&fVolume, node, reenter); + + delete node; + + return error; } // RemoveVNode status_t -HaikuKernelVolume::RemoveVNode(fs_vnode node, bool reenter) +HaikuKernelVolume::RemoveVNode(void* _node, bool reenter) { - if (!fFSModule->remove_vnode) + HaikuKernelNode* node = (HaikuKernelNode*)_node; + + if (!node->ops->remove_vnode) return B_BAD_VALUE; - return fFSModule->remove_vnode(fVolumeCookie, node, reenter); + return node->ops->remove_vnode(&fVolume, node, reenter); } @@ -170,131 +212,150 @@ HaikuKernelVolume::RemoveVNode(fs_vnode node, bool reenter) // IOCtl status_t -HaikuKernelVolume::IOCtl(fs_vnode node, fs_cookie cookie, uint32 command, +HaikuKernelVolume::IOCtl(void* _node, void* cookie, uint32 command, void* buffer, size_t size) { - if (!fFSModule->ioctl) + HaikuKernelNode* node = (HaikuKernelNode*)_node; + + if (!node->ops->ioctl) return B_BAD_VALUE; - return fFSModule->ioctl(fVolumeCookie, node, cookie, command, buffer, + return node->ops->ioctl(&fVolume, node, cookie, command, buffer, size); } // SetFlags status_t -HaikuKernelVolume::SetFlags(fs_vnode node, fs_cookie cookie, int flags) +HaikuKernelVolume::SetFlags(void* _node, void* cookie, int flags) { - if (!fFSModule->set_flags) + HaikuKernelNode* node = (HaikuKernelNode*)_node; + + if (!node->ops->set_flags) return B_BAD_VALUE; - return fFSModule->set_flags(fVolumeCookie, node, cookie, flags); + return node->ops->set_flags(&fVolume, node, cookie, flags); } // Select status_t -HaikuKernelVolume::Select(fs_vnode node, fs_cookie cookie, uint8 event, - uint32 ref, selectsync* sync) +HaikuKernelVolume::Select(void* _node, void* cookie, uint8 event, + selectsync* sync) { - if (!fFSModule->select) { + HaikuKernelNode* node = (HaikuKernelNode*)_node; + + if (!node->ops->select) { UserlandFS::KernelEmu::notify_select_event(sync, event, false); return B_OK; } - return fFSModule->select(fVolumeCookie, node, cookie, event, ref, sync); + return node->ops->select(&fVolume, node, cookie, event, sync); } // Deselect status_t -HaikuKernelVolume::Deselect(fs_vnode node, fs_cookie cookie, uint8 event, +HaikuKernelVolume::Deselect(void* _node, void* cookie, uint8 event, selectsync* sync) { - if (!fFSModule->select || !fFSModule->deselect) + HaikuKernelNode* node = (HaikuKernelNode*)_node; + + if (!node->ops->select || !node->ops->deselect) return B_OK; - return fFSModule->deselect(fVolumeCookie, node, cookie, event, sync); + return node->ops->deselect(&fVolume, node, cookie, event, sync); } // FSync status_t -HaikuKernelVolume::FSync(fs_vnode node) +HaikuKernelVolume::FSync(void* _node) { - if (!fFSModule->fsync) + HaikuKernelNode* node = (HaikuKernelNode*)_node; + + if (!node->ops->fsync) return B_BAD_VALUE; - return fFSModule->fsync(fVolumeCookie, node); + return node->ops->fsync(&fVolume, node); } // ReadSymlink status_t -HaikuKernelVolume::ReadSymlink(fs_vnode node, char* buffer, size_t bufferSize, +HaikuKernelVolume::ReadSymlink(void* _node, char* buffer, size_t bufferSize, size_t* bytesRead) { - if (!fFSModule->read_symlink) + HaikuKernelNode* node = (HaikuKernelNode*)_node; + + if (!node->ops->read_symlink) return B_BAD_VALUE; *bytesRead = bufferSize; - return fFSModule->read_symlink(fVolumeCookie, node, buffer, bytesRead); + return node->ops->read_symlink(&fVolume, node, buffer, bytesRead); } // CreateSymlink status_t -HaikuKernelVolume::CreateSymlink(fs_vnode dir, const char* name, +HaikuKernelVolume::CreateSymlink(void* _dir, const char* name, const char* target, int mode) { - if (!fFSModule->create_symlink) + HaikuKernelNode* dir = (HaikuKernelNode*)_dir; + + if (!dir->ops->create_symlink) return B_BAD_VALUE; - return fFSModule->create_symlink(fVolumeCookie, dir, name, target, mode); + return dir->ops->create_symlink(&fVolume, dir, name, target, mode); } // Link status_t -HaikuKernelVolume::Link(fs_vnode dir, const char* name, fs_vnode node) +HaikuKernelVolume::Link(void* _dir, const char* name, void* _node) { - if (!fFSModule->link) + HaikuKernelNode* dir = (HaikuKernelNode*)_dir; + HaikuKernelNode* node = (HaikuKernelNode*)_node; + + if (!dir->ops->link) return B_BAD_VALUE; - return fFSModule->link(fVolumeCookie, dir, name, node); + return dir->ops->link(&fVolume, dir, name, node); } // Unlink status_t -HaikuKernelVolume::Unlink(fs_vnode dir, const char* name) +HaikuKernelVolume::Unlink(void* _dir, const char* name) { - if (!fFSModule->unlink) + HaikuKernelNode* dir = (HaikuKernelNode*)_dir; + + if (!dir->ops->unlink) return B_BAD_VALUE; - return fFSModule->unlink(fVolumeCookie, dir, name); + return dir->ops->unlink(&fVolume, dir, name); } // Rename status_t -HaikuKernelVolume::Rename(fs_vnode oldDir, const char* oldName, fs_vnode newDir, +HaikuKernelVolume::Rename(void* oldDir, const char* oldName, void* newDir, const char* newName) { if (!fFSModule->rename) return B_BAD_VALUE; - return fFSModule->rename(fVolumeCookie, oldDir, oldName, newDir, newName); + return fFSModule->rename(&fVolume, oldDir, oldName, newDir, newName); } // Access status_t -HaikuKernelVolume::Access(fs_vnode node, int mode) +HaikuKernelVolume::Access(void* node, int mode) { if (!fFSModule->access) return B_OK; - return fFSModule->access(fVolumeCookie, node, mode); + return fFSModule->access(&fVolume, node, mode); } // ReadStat status_t -HaikuKernelVolume::ReadStat(fs_vnode node, struct stat* st) +HaikuKernelVolume::ReadStat(void* node, struct stat* st) { if (!fFSModule->read_stat) return B_BAD_VALUE; - return fFSModule->read_stat(fVolumeCookie, node, st); + return fFSModule->read_stat(&fVolume, node, st); } // WriteStat status_t -HaikuKernelVolume::WriteStat(fs_vnode node, const struct stat *st, uint32 mask) +HaikuKernelVolume::WriteStat(void* node, const struct stat *st, uint32 mask) { if (!fFSModule->write_stat) return B_BAD_VALUE; - return fFSModule->write_stat(fVolumeCookie, node, st, mask); + return fFSModule->write_stat(&fVolume, node, st, mask); } @@ -303,45 +364,45 @@ HaikuKernelVolume::WriteStat(fs_vnode node, const struct stat *st, uint32 mask) // Create status_t -HaikuKernelVolume::Create(fs_vnode dir, const char* name, int openMode, int mode, - fs_cookie* cookie, ino_t* vnid) +HaikuKernelVolume::Create(void* dir, const char* name, int openMode, int mode, + void** cookie, ino_t* vnid) { if (!fFSModule->create) return B_BAD_VALUE; - return fFSModule->create(fVolumeCookie, dir, name, openMode, mode, cookie, + return fFSModule->create(&fVolume, dir, name, openMode, mode, cookie, vnid); } // Open status_t -HaikuKernelVolume::Open(fs_vnode node, int openMode, fs_cookie* cookie) +HaikuKernelVolume::Open(void* node, int openMode, void** cookie) { if (!fFSModule->open) return B_BAD_VALUE; - return fFSModule->open(fVolumeCookie, node, openMode, cookie); + return fFSModule->open(&fVolume, node, openMode, cookie); } // Close status_t -HaikuKernelVolume::Close(fs_vnode node, fs_cookie cookie) +HaikuKernelVolume::Close(void* node, void* cookie) { if (!fFSModule->close) return B_OK; - return fFSModule->close(fVolumeCookie, node, cookie); + return fFSModule->close(&fVolume, node, cookie); } // FreeCookie status_t -HaikuKernelVolume::FreeCookie(fs_vnode node, fs_cookie cookie) +HaikuKernelVolume::FreeCookie(void* node, void* cookie) { if (!fFSModule->free_cookie) return B_OK; - return fFSModule->free_cookie(fVolumeCookie, node, cookie); + return fFSModule->free_cookie(&fVolume, node, cookie); } // Read status_t -HaikuKernelVolume::Read(fs_vnode node, fs_cookie cookie, off_t pos, void* buffer, +HaikuKernelVolume::Read(void* node, void* cookie, off_t pos, void* buffer, size_t bufferSize, size_t* bytesRead) { if (!fFSModule->read) @@ -349,12 +410,12 @@ HaikuKernelVolume::Read(fs_vnode node, fs_cookie cookie, off_t pos, void* buffer *bytesRead = bufferSize; - return fFSModule->read(fVolumeCookie, node, cookie, pos, buffer, bytesRead); + return fFSModule->read(&fVolume, node, cookie, pos, buffer, bytesRead); } // Write status_t -HaikuKernelVolume::Write(fs_vnode node, fs_cookie cookie, off_t pos, +HaikuKernelVolume::Write(void* node, void* cookie, off_t pos, const void* buffer, size_t bufferSize, size_t* bytesWritten) { if (!fFSModule->write) @@ -362,7 +423,7 @@ HaikuKernelVolume::Write(fs_vnode node, fs_cookie cookie, off_t pos, *bytesWritten = bufferSize; - return fFSModule->write(fVolumeCookie, node, cookie, pos, buffer, + return fFSModule->write(&fVolume, node, cookie, pos, buffer, bytesWritten); } @@ -372,53 +433,53 @@ HaikuKernelVolume::Write(fs_vnode node, fs_cookie cookie, off_t pos, // CreateDir status_t -HaikuKernelVolume::CreateDir(fs_vnode dir, const char* name, int mode, +HaikuKernelVolume::CreateDir(void* dir, const char* name, int mode, ino_t *newDir) { if (!fFSModule->create_dir) return B_BAD_VALUE; - return fFSModule->create_dir(fVolumeCookie, dir, name, mode, newDir); + return fFSModule->create_dir(&fVolume, dir, name, mode, newDir); } // RemoveDir status_t -HaikuKernelVolume::RemoveDir(fs_vnode dir, const char* name) +HaikuKernelVolume::RemoveDir(void* dir, const char* name) { if (!fFSModule->remove_dir) return B_BAD_VALUE; - return fFSModule->remove_dir(fVolumeCookie, dir, name); + return fFSModule->remove_dir(&fVolume, dir, name); } // OpenDir status_t -HaikuKernelVolume::OpenDir(fs_vnode node, fs_cookie* cookie) +HaikuKernelVolume::OpenDir(void* node, void** cookie) { if (!fFSModule->open_dir) return B_BAD_VALUE; - return fFSModule->open_dir(fVolumeCookie, node, cookie); + return fFSModule->open_dir(&fVolume, node, cookie); } // CloseDir status_t -HaikuKernelVolume::CloseDir(fs_vnode node, fs_vnode cookie) +HaikuKernelVolume::CloseDir(void* node, void* cookie) { if (!fFSModule->close_dir) return B_OK; - return fFSModule->close_dir(fVolumeCookie, node, cookie); + return fFSModule->close_dir(&fVolume, node, cookie); } // FreeDirCookie status_t -HaikuKernelVolume::FreeDirCookie(fs_vnode node, fs_vnode cookie) +HaikuKernelVolume::FreeDirCookie(void* node, void* cookie) { if (!fFSModule->free_dir_cookie) return B_OK; - return fFSModule->free_dir_cookie(fVolumeCookie, node, cookie); + return fFSModule->free_dir_cookie(&fVolume, node, cookie); } // ReadDir status_t -HaikuKernelVolume::ReadDir(fs_vnode node, fs_vnode cookie, void* buffer, +HaikuKernelVolume::ReadDir(void* node, void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead) { if (!fFSModule->read_dir) @@ -426,17 +487,17 @@ HaikuKernelVolume::ReadDir(fs_vnode node, fs_vnode cookie, void* buffer, *countRead = count; - return fFSModule->read_dir(fVolumeCookie, node, cookie, + return fFSModule->read_dir(&fVolume, node, cookie, (struct dirent*)buffer, bufferSize, countRead); } // RewindDir status_t -HaikuKernelVolume::RewindDir(fs_vnode node, fs_vnode cookie) +HaikuKernelVolume::RewindDir(void* node, void* cookie) { if (!fFSModule->rewind_dir) return B_BAD_VALUE; - return fFSModule->rewind_dir(fVolumeCookie, node, cookie); + return fFSModule->rewind_dir(&fVolume, node, cookie); } @@ -445,34 +506,34 @@ HaikuKernelVolume::RewindDir(fs_vnode node, fs_vnode cookie) // OpenAttrDir status_t -HaikuKernelVolume::OpenAttrDir(fs_vnode node, fs_cookie *cookie) +HaikuKernelVolume::OpenAttrDir(void* node, void** cookie) { if (!fFSModule->open_attr_dir) return B_BAD_VALUE; - return fFSModule->open_attr_dir(fVolumeCookie, node, cookie); + return fFSModule->open_attr_dir(&fVolume, node, cookie); } // CloseAttrDir status_t -HaikuKernelVolume::CloseAttrDir(fs_vnode node, fs_cookie cookie) +HaikuKernelVolume::CloseAttrDir(void* node, void* cookie) { if (!fFSModule->close_attr_dir) return B_OK; - return fFSModule->close_attr_dir(fVolumeCookie, node, cookie); + return fFSModule->close_attr_dir(&fVolume, node, cookie); } // FreeAttrDirCookie status_t -HaikuKernelVolume::FreeAttrDirCookie(fs_vnode node, fs_cookie cookie) +HaikuKernelVolume::FreeAttrDirCookie(void* node, void* cookie) { if (!fFSModule->free_attr_dir_cookie) return B_OK; - return fFSModule->free_attr_dir_cookie(fVolumeCookie, node, cookie); + return fFSModule->free_attr_dir_cookie(&fVolume, node, cookie); } // ReadAttrDir status_t -HaikuKernelVolume::ReadAttrDir(fs_vnode node, fs_cookie cookie, void* buffer, +HaikuKernelVolume::ReadAttrDir(void* node, void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead) { if (!fFSModule->read_attr_dir) @@ -480,17 +541,17 @@ HaikuKernelVolume::ReadAttrDir(fs_vnode node, fs_cookie cookie, void* buffer, *countRead = count; - return fFSModule->read_attr_dir(fVolumeCookie, node, cookie, + return fFSModule->read_attr_dir(&fVolume, node, cookie, (struct dirent*)buffer, bufferSize, countRead); } // RewindAttrDir status_t -HaikuKernelVolume::RewindAttrDir(fs_vnode node, fs_cookie cookie) +HaikuKernelVolume::RewindAttrDir(void* node, void* cookie) { if (!fFSModule->rewind_attr_dir) return B_BAD_VALUE; - return fFSModule->rewind_attr_dir(fVolumeCookie, node, cookie); + return fFSModule->rewind_attr_dir(&fVolume, node, cookie); } @@ -499,46 +560,46 @@ HaikuKernelVolume::RewindAttrDir(fs_vnode node, fs_cookie cookie) // CreateAttr status_t -HaikuKernelVolume::CreateAttr(fs_vnode node, const char* name, uint32 type, - int openMode, fs_cookie* cookie) +HaikuKernelVolume::CreateAttr(void* node, const char* name, uint32 type, + int openMode, void** cookie) { if (!fFSModule->create_attr) return B_BAD_VALUE; - return fFSModule->create_attr(fVolumeCookie, node, name, type, openMode, + return fFSModule->create_attr(&fVolume, node, name, type, openMode, cookie); } // OpenAttr status_t -HaikuKernelVolume::OpenAttr(fs_vnode node, const char* name, int openMode, - fs_cookie* cookie) +HaikuKernelVolume::OpenAttr(void* node, const char* name, int openMode, + void** cookie) { if (!fFSModule->open_attr) return B_BAD_VALUE; - return fFSModule->open_attr(fVolumeCookie, node, name, openMode, cookie); + return fFSModule->open_attr(&fVolume, node, name, openMode, cookie); } // CloseAttr status_t -HaikuKernelVolume::CloseAttr(fs_vnode node, fs_cookie cookie) +HaikuKernelVolume::CloseAttr(void* node, void* cookie) { if (!fFSModule->close_attr) return B_OK; - return fFSModule->close_attr(fVolumeCookie, node, cookie); + return fFSModule->close_attr(&fVolume, node, cookie); } // FreeAttrCookie status_t -HaikuKernelVolume::FreeAttrCookie(fs_vnode node, fs_cookie cookie) +HaikuKernelVolume::FreeAttrCookie(void* node, void* cookie) { if (!fFSModule->free_attr_cookie) return B_OK; - return fFSModule->free_attr_cookie(fVolumeCookie, node, cookie); + return fFSModule->free_attr_cookie(&fVolume, node, cookie); } // ReadAttr status_t -HaikuKernelVolume::ReadAttr(fs_vnode node, fs_cookie cookie, off_t pos, +HaikuKernelVolume::ReadAttr(void* node, void* cookie, off_t pos, void* buffer, size_t bufferSize, size_t* bytesRead) { if (!fFSModule->read_attr) @@ -546,13 +607,13 @@ HaikuKernelVolume::ReadAttr(fs_vnode node, fs_cookie cookie, off_t pos, *bytesRead = bufferSize; - return fFSModule->read_attr(fVolumeCookie, node, cookie, pos, buffer, + return fFSModule->read_attr(&fVolume, node, cookie, pos, buffer, bytesRead); } // WriteAttr status_t -HaikuKernelVolume::WriteAttr(fs_vnode node, fs_cookie cookie, off_t pos, +HaikuKernelVolume::WriteAttr(void* node, void* cookie, off_t pos, const void* buffer, size_t bufferSize, size_t* bytesWritten) { if (!fFSModule->write_attr) @@ -560,49 +621,49 @@ HaikuKernelVolume::WriteAttr(fs_vnode node, fs_cookie cookie, off_t pos, *bytesWritten = bufferSize; - return fFSModule->write_attr(fVolumeCookie, node, cookie, pos, buffer, + return fFSModule->write_attr(&fVolume, node, cookie, pos, buffer, bytesWritten); } // ReadAttrStat status_t -HaikuKernelVolume::ReadAttrStat(fs_vnode node, fs_cookie cookie, +HaikuKernelVolume::ReadAttrStat(void* node, void* cookie, struct stat *st) { if (!fFSModule->read_attr_stat) return B_BAD_VALUE; - return fFSModule->read_attr_stat(fVolumeCookie, node, cookie, st); + return fFSModule->read_attr_stat(&fVolume, node, cookie, st); } // WriteAttrStat status_t -HaikuKernelVolume::WriteAttrStat(fs_vnode node, fs_cookie cookie, +HaikuKernelVolume::WriteAttrStat(void* node, void* cookie, const struct stat* st, int statMask) { if (!fFSModule->write_attr_stat) return B_BAD_VALUE; - return fFSModule->write_attr_stat(fVolumeCookie, node, cookie, st, + return fFSModule->write_attr_stat(&fVolume, node, cookie, st, statMask); } // RenameAttr status_t -HaikuKernelVolume::RenameAttr(fs_vnode oldNode, const char* oldName, - fs_vnode newNode, const char* newName) +HaikuKernelVolume::RenameAttr(void* oldNode, const char* oldName, + void* newNode, const char* newName) { if (!fFSModule->rename_attr) return B_BAD_VALUE; - return fFSModule->rename_attr(fVolumeCookie, oldNode, oldName, newNode, + return fFSModule->rename_attr(&fVolume, oldNode, oldName, newNode, newName); } // RemoveAttr status_t -HaikuKernelVolume::RemoveAttr(fs_vnode node, const char* name) +HaikuKernelVolume::RemoveAttr(void* node, const char* name) { if (!fFSModule->remove_attr) return B_BAD_VALUE; - return fFSModule->remove_attr(fVolumeCookie, node, name); + return fFSModule->remove_attr(&fVolume, node, name); } @@ -611,79 +672,79 @@ HaikuKernelVolume::RemoveAttr(fs_vnode node, const char* name) // OpenIndexDir status_t -HaikuKernelVolume::OpenIndexDir(fs_cookie *cookie) +HaikuKernelVolume::OpenIndexDir(void** cookie) { - if (!fFSModule->open_index_dir) + if (!fVolume.ops->open_index_dir) return B_BAD_VALUE; - return fFSModule->open_index_dir(fVolumeCookie, cookie); + return fVolume.ops->open_index_dir(&fVolume, cookie); } // CloseIndexDir status_t -HaikuKernelVolume::CloseIndexDir(fs_cookie cookie) +HaikuKernelVolume::CloseIndexDir(void* cookie) { - if (!fFSModule->close_index_dir) + if (!fVolume.ops->close_index_dir) return B_OK; - return fFSModule->close_index_dir(fVolumeCookie, cookie); + return fVolume.ops->close_index_dir(&fVolume, cookie); } // FreeIndexDirCookie status_t -HaikuKernelVolume::FreeIndexDirCookie(fs_cookie cookie) +HaikuKernelVolume::FreeIndexDirCookie(void* cookie) { - if (!fFSModule->free_index_dir_cookie) + if (!fVolume.ops->free_index_dir_cookie) return B_OK; - return fFSModule->free_index_dir_cookie(fVolumeCookie, cookie); + return fVolume.ops->free_index_dir_cookie(&fVolume, cookie); } // ReadIndexDir status_t -HaikuKernelVolume::ReadIndexDir(fs_cookie cookie, void* buffer, +HaikuKernelVolume::ReadIndexDir(void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead) { - if (!fFSModule->read_index_dir) + if (!fVolume.ops->read_index_dir) return B_BAD_VALUE; *countRead = count; - return fFSModule->read_index_dir(fVolumeCookie, cookie, + return fVolume.ops->read_index_dir(&fVolume, cookie, (struct dirent*)buffer, bufferSize, countRead); } // RewindIndexDir status_t -HaikuKernelVolume::RewindIndexDir(fs_cookie cookie) +HaikuKernelVolume::RewindIndexDir(void* cookie) { - if (!fFSModule->rewind_index_dir) + if (!fVolume.ops->rewind_index_dir) return B_BAD_VALUE; - return fFSModule->rewind_index_dir(fVolumeCookie, cookie); + return fVolume.ops->rewind_index_dir(&fVolume, cookie); } // CreateIndex status_t HaikuKernelVolume::CreateIndex(const char* name, uint32 type, uint32 flags) { - if (!fFSModule->create_index) + if (!fVolume.ops->create_index) return B_BAD_VALUE; - return fFSModule->create_index(fVolumeCookie, name, type, flags); + return fVolume.ops->create_index(&fVolume, name, type, flags); } // RemoveIndex status_t HaikuKernelVolume::RemoveIndex(const char* name) { - if (!fFSModule->remove_index) + if (!fVolume.ops->remove_index) return B_BAD_VALUE; - return fFSModule->remove_index(fVolumeCookie, name); + return fVolume.ops->remove_index(&fVolume, name); } // StatIndex status_t HaikuKernelVolume::ReadIndexStat(const char *name, struct stat *st) { - if (!fFSModule->read_index_stat) + if (!fVolume.ops->read_index_stat) return B_BAD_VALUE; - return fFSModule->read_index_stat(fVolumeCookie, name, st); + return fVolume.ops->read_index_stat(&fVolume, name, st); } @@ -693,52 +754,176 @@ HaikuKernelVolume::ReadIndexStat(const char *name, struct stat *st) // OpenQuery status_t HaikuKernelVolume::OpenQuery(const char* queryString, uint32 flags, - port_id port, uint32 token, fs_cookie *cookie) + port_id port, uint32 token, void** cookie) { - if (!fFSModule->open_query) + if (!fVolume.ops->open_query) return B_BAD_VALUE; - return fFSModule->open_query(fVolumeCookie, queryString, flags, port, + return fVolume.ops->open_query(&fVolume, queryString, flags, port, token, cookie); } // CloseQuery status_t -HaikuKernelVolume::CloseQuery(fs_cookie cookie) +HaikuKernelVolume::CloseQuery(void* cookie) { - if (!fFSModule->close_query) + if (!fVolume.ops->close_query) return B_OK; - return fFSModule->close_query(fVolumeCookie, cookie); + return fVolume.ops->close_query(&fVolume, cookie); } // FreeQueryCookie status_t -HaikuKernelVolume::FreeQueryCookie(fs_cookie cookie) +HaikuKernelVolume::FreeQueryCookie(void* cookie) { - if (!fFSModule->free_query_cookie) + if (!fVolume.ops->free_query_cookie) return B_OK; - return fFSModule->free_query_cookie(fVolumeCookie, cookie); + return fVolume.ops->free_query_cookie(&fVolume, cookie); } // ReadQuery status_t -HaikuKernelVolume::ReadQuery(fs_cookie cookie, void* buffer, size_t bufferSize, +HaikuKernelVolume::ReadQuery(void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead) { - if (!fFSModule->read_query) + if (!fVolume.ops->read_query) return B_BAD_VALUE; *countRead = count; - return fFSModule->read_query(fVolumeCookie, cookie, (struct dirent*)buffer, + return fVolume.ops->read_query(&fVolume, cookie, (struct dirent*)buffer, bufferSize, countRead); } // RewindQuery status_t -HaikuKernelVolume::RewindQuery(fs_cookie cookie) +HaikuKernelVolume::RewindQuery(void* cookie) { - if (!fFSModule->rewind_query) + if (!fVolume.ops->rewind_query) return B_BAD_VALUE; - return fFSModule->rewind_query(fVolumeCookie, cookie); + return fVolume.ops->rewind_query(&fVolume, cookie); } +// _InitCapabilities +void +HaikuKernelVolume::_InitCapabilities() +{ + fCapabilities.ClearAll(); + + // FS operations + fCapabilities.Set(FS_VOLUME_CAPABILITY_UNMOUNT, fVolume.ops->unmount); + + fCapabilities.Set(FS_VOLUME_CAPABILITY_READ_FS_INFO, + fVolume.ops->read_fs_info); + fCapabilities.Set(FS_VOLUME_CAPABILITY_WRITE_FS_INFO, + fVolume.ops->write_fs_info); + fCapabilities.Set(FS_VOLUME_CAPABILITY_SYNC, fVolume.ops->sync); + + // vnode operations + fCapabilities.Set(FS_VOLUME_CAPABILITY_GET_VNODE, fVolume.ops->get_vnode); + + // index directory & index operations + fCapabilities.Set(FS_VOLUME_CAPABILITY_OPEN_INDEX_DIR, + fVolume.ops->open_index_dir); + fCapabilities.Set(FS_VOLUME_CAPABILITY_CLOSE_INDEX_DIR, + fVolume.ops->close_index_dir); + fCapabilities.Set(FS_VOLUME_CAPABILITY_FREE_INDEX_DIR_COOKIE, + fVolume.ops->free_index_dir_cookie); + fCapabilities.Set(FS_VOLUME_CAPABILITY_READ_INDEX_DIR, + fVolume.ops->read_index_dir); + fCapabilities.Set(FS_VOLUME_CAPABILITY_REWIND_INDEX_DIR, + fVolume.ops->rewind_index_dir); + + fCapabilities.Set(FS_VOLUME_CAPABILITY_CREATE_INDEX, + fVolume.ops->create_index); + fCapabilities.Set(FS_VOLUME_CAPABILITY_REMOVE_INDEX, + fVolume.ops->remove_index); + fCapabilities.Set(FS_VOLUME_CAPABILITY_READ_INDEX_STAT, + fVolume.ops->read_index_stat); + + // query operations + fCapabilities.Set(FS_VOLUME_CAPABILITY_OPEN_QUERY, fVolume.ops->open_query); + fCapabilities.Set(FS_VOLUME_CAPABILITY_CLOSE_QUERY, + fVolume.ops->close_query); + fCapabilities.Set(FS_VOLUME_CAPABILITY_FREE_QUERY_COOKIE, + fVolume.ops->free_query_cookie); + fCapabilities.Set(FS_VOLUME_CAPABILITY_READ_QUERY, fVolume.ops->read_query); + fCapabilities.Set(FS_VOLUME_CAPABILITY_REWIND_QUERY, + fVolume.ops->rewind_query); + + +#if 0 + // vnode operations + fCapabilities.Set(FS_VNODE_CAPABILITY_LOOKUP, fFSModule->lookup); + fCapabilities.Set(FS_VNODE_CAPABILITY_GET_VNODE_NAME, fFSModule->get_vnode_name); + + fCapabilities.Set(FS_VNODE_CAPABILITY_GET_VNODE, fFSModule->get_vnode); + fCapabilities.Set(FS_VNODE_CAPABILITY_PUT_VNODE, fFSModule->put_vnode); + fCapabilities.Set(FS_VNODE_CAPABILITY_REMOVE_VNODE, fFSModule->remove_vnode); + + // VM file access + fCapabilities.Set(FS_VNODE_CAPABILITY_CAN_PAGE, fFSModule->can_page); + fCapabilities.Set(FS_VNODE_CAPABILITY_READ_PAGES, fFSModule->read_pages); + fCapabilities.Set(FS_VNODE_CAPABILITY_WRITE_PAGES, fFSModule->write_pages); + + // cache file access + fCapabilities.Set(FS_VNODE_CAPABILITY_GET_FILE_MAP, fFSModule->get_file_map); + + // common operations + fCapabilities.Set(FS_VNODE_CAPABILITY_IOCTL, fFSModule->ioctl); + fCapabilities.Set(FS_VNODE_CAPABILITY_SET_FLAGS, fFSModule->set_flags); + fCapabilities.Set(FS_VNODE_CAPABILITY_SELECT, fFSModule->select); + fCapabilities.Set(FS_VNODE_CAPABILITY_DESELECT, fFSModule->deselect); + fCapabilities.Set(FS_VNODE_CAPABILITY_FSYNC, fFSModule->fsync); + + fCapabilities.Set(FS_VNODE_CAPABILITY_READ_SYMLINK, fFSModule->read_symlink); + fCapabilities.Set(FS_VNODE_CAPABILITY_CREATE_SYMLINK, fFSModule->create_symlink); + + fCapabilities.Set(FS_VNODE_CAPABILITY_LINK, fFSModule->link); + fCapabilities.Set(FS_VNODE_CAPABILITY_UNLINK, fFSModule->unlink); + fCapabilities.Set(FS_VNODE_CAPABILITY_RENAME, fFSModule->rename); + + fCapabilities.Set(FS_VNODE_CAPABILITY_ACCESS, fFSModule->access); + fCapabilities.Set(FS_VNODE_CAPABILITY_READ_STAT, fFSModule->read_stat); + fCapabilities.Set(FS_VNODE_CAPABILITY_WRITE_STAT, fFSModule->write_stat); + + // file operations + fCapabilities.Set(FS_VNODE_CAPABILITY_CREATE, fFSModule->create); + fCapabilities.Set(FS_VNODE_CAPABILITY_OPEN, fFSModule->open); + fCapabilities.Set(FS_VNODE_CAPABILITY_CLOSE, fFSModule->close); + fCapabilities.Set(FS_VNODE_CAPABILITY_FREE_COOKIE, fFSModule->free_cookie); + fCapabilities.Set(FS_VNODE_CAPABILITY_READ, fFSModule->read); + fCapabilities.Set(FS_VNODE_CAPABILITY_WRITE, fFSModule->write); + + // directory operations + fCapabilities.Set(FS_VNODE_CAPABILITY_CREATE_DIR, fFSModule->create_dir); + fCapabilities.Set(FS_VNODE_CAPABILITY_REMOVE_DIR, fFSModule->remove_dir); + fCapabilities.Set(FS_VNODE_CAPABILITY_OPEN_DIR, fFSModule->open_dir); + fCapabilities.Set(FS_VNODE_CAPABILITY_CLOSE_DIR, fFSModule->close_dir); + fCapabilities.Set(FS_VNODE_CAPABILITY_FREE_DIR_COOKIE, fFSModule->free_dir_cookie); + fCapabilities.Set(FS_VNODE_CAPABILITY_READ_DIR, fFSModule->read_dir); + fCapabilities.Set(FS_VNODE_CAPABILITY_REWIND_DIR, fFSModule->rewind_dir); + + // attribute directory operations + fCapabilities.Set(FS_VNODE_CAPABILITY_OPEN_ATTR_DIR, fFSModule->open_attr_dir); + fCapabilities.Set(FS_VNODE_CAPABILITY_CLOSE_ATTR_DIR, fFSModule->close_attr_dir); + fCapabilities.Set(FS_VNODE_CAPABILITY_FREE_ATTR_DIR_COOKIE, + fFSModule->free_attr_dir_cookie); + fCapabilities.Set(FS_VNODE_CAPABILITY_READ_ATTR_DIR, fFSModule->read_attr_dir); + fCapabilities.Set(FS_VNODE_CAPABILITY_REWIND_ATTR_DIR, fFSModule->rewind_attr_dir); + + // attribute operations + fCapabilities.Set(FS_VNODE_CAPABILITY_CREATE_ATTR, fFSModule->create_attr); + fCapabilities.Set(FS_VNODE_CAPABILITY_OPEN_ATTR, fFSModule->open_attr); + fCapabilities.Set(FS_VNODE_CAPABILITY_CLOSE_ATTR, fFSModule->close_attr); + fCapabilities.Set(FS_VNODE_CAPABILITY_FREE_ATTR_COOKIE, + fFSModule->free_attr_cookie); + fCapabilities.Set(FS_VNODE_CAPABILITY_READ_ATTR, fFSModule->read_attr); + fCapabilities.Set(FS_VNODE_CAPABILITY_WRITE_ATTR, fFSModule->write_attr); + + fCapabilities.Set(FS_VNODE_CAPABILITY_READ_ATTR_STAT, fFSModule->read_attr_stat); + fCapabilities.Set(FS_VNODE_CAPABILITY_WRITE_ATTR_STAT, + fFSModule->write_attr_stat); + fCapabilities.Set(FS_VNODE_CAPABILITY_RENAME_ATTR, fFSModule->rename_attr); + fCapabilities.Set(FS_VNODE_CAPABILITY_REMOVE_ATTR, fFSModule->remove_attr); +#endif +} diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelVolume.h b/src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelVolume.h index de53c2faff..339c9de240 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelVolume.h +++ b/src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelVolume.h @@ -1,7 +1,7 @@ // HaikuKernelVolume.h -#ifndef USERLAND_FS_BEOS_KERNEL_VOLUME_H -#define USERLAND_FS_BEOS_KERNEL_VOLUME_H +#ifndef USERLAND_FS_HAIKU_KERNEL_VOLUME_H +#define USERLAND_FS_HAIKU_KERNEL_VOLUME_H #include @@ -9,6 +9,9 @@ namespace UserlandFS { +class HaikuKernelNode; + + class HaikuKernelVolume : public Volume { public: HaikuKernelVolume(FileSystem* fileSystem, @@ -16,6 +19,18 @@ public: file_system_module_info* fsModule); virtual ~HaikuKernelVolume(); + static HaikuKernelVolume* GetVolume(const fs_volume* volume); + + inline fs_volume* GetFSVolume() { return &fVolume; } + + status_t NewVNode(ino_t vnodeID, void* privateNode, + fs_vnode_ops* ops, HaikuKernelNode** node); + status_t PublishVNode(ino_t vnodeID, void* privateNode, + fs_vnode_ops* ops, int type, uint32 flags, + HaikuKernelNode** node); + status_t UndoNewVNode(HaikuKernelNode* node); + status_t UndoPublishVNode(HaikuKernelNode* node); + // FS virtual status_t Mount(const char* device, uint32 flags, const char* parameters, ino_t* rootID); @@ -26,116 +41,116 @@ public: uint32 mask); // file cache - virtual status_t GetFileMap(fs_vnode node, off_t offset, + virtual status_t GetFileMap(void* node, off_t offset, size_t size, struct file_io_vec* vecs, size_t* count); // vnodes - virtual status_t Lookup(fs_vnode dir, const char* entryName, - ino_t* vnid, int* type); - virtual status_t GetVNodeName(fs_vnode node, char* buffer, + virtual status_t Lookup(void* dir, const char* entryName, + ino_t* vnid); + virtual status_t GetVNodeName(void* node, char* buffer, size_t bufferSize); virtual status_t ReadVNode(ino_t vnid, bool reenter, - fs_vnode* node); - virtual status_t WriteVNode(fs_vnode node, bool reenter); - virtual status_t RemoveVNode(fs_vnode node, bool reenter); + void** node, int* type, uint32* flags); + virtual status_t WriteVNode(void* node, bool reenter); + virtual status_t RemoveVNode(void* node, bool reenter); // nodes - virtual status_t IOCtl(fs_vnode node, fs_cookie cookie, + virtual status_t IOCtl(void* node, void* cookie, uint32 command, void* buffer, size_t size); - virtual status_t SetFlags(fs_vnode node, fs_cookie cookie, + virtual status_t SetFlags(void* node, void* cookie, int flags); - virtual status_t Select(fs_vnode node, fs_cookie cookie, - uint8 event, uint32 ref, selectsync* sync); - virtual status_t Deselect(fs_vnode node, fs_cookie cookie, + virtual status_t Select(void* node, void* cookie, + uint8 event, selectsync* sync); + virtual status_t Deselect(void* node, void* cookie, uint8 event, selectsync* sync); - virtual status_t FSync(fs_vnode node); + virtual status_t FSync(void* node); - virtual status_t ReadSymlink(fs_vnode node, char* buffer, + virtual status_t ReadSymlink(void* node, char* buffer, size_t bufferSize, size_t* bytesRead); - virtual status_t CreateSymlink(fs_vnode dir, const char* name, + virtual status_t CreateSymlink(void* dir, const char* name, const char* target, int mode); - virtual status_t Link(fs_vnode dir, const char* name, - fs_vnode node); - virtual status_t Unlink(fs_vnode dir, const char* name); - virtual status_t Rename(fs_vnode oldDir, const char* oldName, - fs_vnode newDir, const char* newName); + virtual status_t Link(void* dir, const char* name, + void* node); + virtual status_t Unlink(void* dir, const char* name); + virtual status_t Rename(void* oldDir, const char* oldName, + void* newDir, const char* newName); - virtual status_t Access(fs_vnode node, int mode); - virtual status_t ReadStat(fs_vnode node, struct stat* st); - virtual status_t WriteStat(fs_vnode node, const struct stat *st, + virtual status_t Access(void* node, int mode); + virtual status_t ReadStat(void* node, struct stat* st); + virtual status_t WriteStat(void* node, const struct stat *st, uint32 mask); // files - virtual status_t Create(fs_vnode dir, const char* name, - int openMode, int mode, fs_cookie* cookie, + virtual status_t Create(void* dir, const char* name, + int openMode, int mode, void** cookie, ino_t* vnid); - virtual status_t Open(fs_vnode node, int openMode, - fs_cookie* cookie); - virtual status_t Close(fs_vnode node, fs_cookie cookie); - virtual status_t FreeCookie(fs_vnode node, fs_cookie cookie); - virtual status_t Read(fs_vnode node, fs_cookie cookie, off_t pos, + virtual status_t Open(void* node, int openMode, + void** cookie); + virtual status_t Close(void* node, void* cookie); + virtual status_t FreeCookie(void* node, void* cookie); + virtual status_t Read(void* node, void* cookie, off_t pos, void* buffer, size_t bufferSize, size_t* bytesRead); - virtual status_t Write(fs_vnode node, fs_cookie cookie, + virtual status_t Write(void* node, void* cookie, off_t pos, const void* buffer, size_t bufferSize, size_t* bytesWritten); // directories - virtual status_t CreateDir(fs_vnode dir, const char* name, + virtual status_t CreateDir(void* dir, const char* name, int mode, ino_t *newDir); - virtual status_t RemoveDir(fs_vnode dir, const char* name); - virtual status_t OpenDir(fs_vnode node, fs_cookie* cookie); - virtual status_t CloseDir(fs_vnode node, fs_vnode cookie); - virtual status_t FreeDirCookie(fs_vnode node, fs_vnode cookie); - virtual status_t ReadDir(fs_vnode node, fs_vnode cookie, + virtual status_t RemoveDir(void* dir, const char* name); + virtual status_t OpenDir(void* node, void** cookie); + virtual status_t CloseDir(void* node, void* cookie); + virtual status_t FreeDirCookie(void* node, void* cookie); + virtual status_t ReadDir(void* node, void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead); - virtual status_t RewindDir(fs_vnode node, fs_vnode cookie); + virtual status_t RewindDir(void* node, void* cookie); // attribute directories - virtual status_t OpenAttrDir(fs_vnode node, fs_cookie *cookie); - virtual status_t CloseAttrDir(fs_vnode node, fs_cookie cookie); - virtual status_t FreeAttrDirCookie(fs_vnode node, - fs_cookie cookie); - virtual status_t ReadAttrDir(fs_vnode node, fs_cookie cookie, + virtual status_t OpenAttrDir(void* node, void** cookie); + virtual status_t CloseAttrDir(void* node, void* cookie); + virtual status_t FreeAttrDirCookie(void* node, + void* cookie); + virtual status_t ReadAttrDir(void* node, void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead); - virtual status_t RewindAttrDir(fs_vnode node, fs_cookie cookie); + virtual status_t RewindAttrDir(void* node, void* cookie); // attributes - virtual status_t CreateAttr(fs_vnode node, const char *name, + virtual status_t CreateAttr(void* node, const char *name, uint32 type, int openMode, - fs_cookie *cookie); - virtual status_t OpenAttr(fs_vnode node, const char *name, - int openMode, fs_cookie *cookie); - virtual status_t CloseAttr(fs_vnode node, fs_cookie cookie); - virtual status_t FreeAttrCookie(fs_vnode node, fs_cookie cookie); - virtual status_t ReadAttr(fs_vnode node, fs_cookie cookie, + void** cookie); + virtual status_t OpenAttr(void* node, const char *name, + int openMode, void** cookie); + virtual status_t CloseAttr(void* node, void* cookie); + virtual status_t FreeAttrCookie(void* node, void* cookie); + virtual status_t ReadAttr(void* node, void* cookie, off_t pos, void* buffer, size_t bufferSize, size_t* bytesRead); - virtual status_t WriteAttr(fs_vnode node, fs_cookie cookie, + virtual status_t WriteAttr(void* node, void* cookie, off_t pos, const void* buffer, size_t bufferSize, size_t* bytesWritten); - virtual status_t ReadAttrStat(fs_vnode node, fs_cookie cookie, + virtual status_t ReadAttrStat(void* node, void* cookie, struct stat *st); - virtual status_t WriteAttrStat(fs_vnode node, fs_cookie cookie, + virtual status_t WriteAttrStat(void* node, void* cookie, const struct stat* st, int statMask); - virtual status_t RenameAttr(fs_vnode oldNode, - const char* oldName, fs_vnode newNode, + virtual status_t RenameAttr(void* oldNode, + const char* oldName, void* newNode, const char* newName); - virtual status_t RemoveAttr(fs_vnode node, const char* name); + virtual status_t RemoveAttr(void* node, const char* name); // indices - virtual status_t OpenIndexDir(fs_cookie *cookie); - virtual status_t CloseIndexDir(fs_cookie cookie); - virtual status_t FreeIndexDirCookie(fs_cookie cookie); - virtual status_t ReadIndexDir(fs_cookie cookie, void* buffer, + virtual status_t OpenIndexDir(void** cookie); + virtual status_t CloseIndexDir(void* cookie); + virtual status_t FreeIndexDirCookie(void* cookie); + virtual status_t ReadIndexDir(void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead); - virtual status_t RewindIndexDir(fs_cookie cookie); + virtual status_t RewindIndexDir(void* cookie); virtual status_t CreateIndex(const char* name, uint32 type, uint32 flags); virtual status_t RemoveIndex(const char* name); @@ -145,21 +160,37 @@ public: // queries virtual status_t OpenQuery(const char* queryString, uint32 flags, port_id port, uint32 token, - fs_cookie *cookie); - virtual status_t CloseQuery(fs_cookie cookie); - virtual status_t FreeQueryCookie(fs_cookie cookie); - virtual status_t ReadQuery(fs_cookie cookie, void* buffer, + void** cookie); + virtual status_t CloseQuery(void* cookie); + virtual status_t FreeQueryCookie(void* cookie); + virtual status_t ReadQuery(void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead); - virtual status_t RewindQuery(fs_cookie cookie); + virtual status_t RewindQuery(void* cookie); + +private: + struct FSVolume : fs_volume { + HaikuKernelVolume* haikuVolume; + }; + +private: + void _InitCapabilities(); private: file_system_module_info* fFSModule; - fs_cookie fVolumeCookie; + FSVolume fVolume; }; + +/*static*/ inline HaikuKernelVolume* +HaikuKernelVolume::GetVolume(const fs_volume* volume) +{ + return static_cast(volume)->haikuVolume; +} + + } // namespace UserlandFS using UserlandFS::HaikuKernelVolume; -#endif // USERLAND_FS_BEOS_KERNEL_VOLUME_H +#endif // USERLAND_FS_HAIKU_KERNEL_VOLUME_H diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/Jamfile b/src/add-ons/kernel/file_systems/userlandfs/server/Jamfile index 9944806dfb..b186ca55f0 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/Jamfile +++ b/src/add-ons/kernel/file_systems/userlandfs/server/Jamfile @@ -33,15 +33,15 @@ Application UserlandFSServer SingleReplyRequestHandler.cpp String.cpp - beos_fs_cache.c +# beos_fs_cache.c - beos_lock.cpp - BeOSKernelFileSystem.cpp - BeOSKernelVolume.cpp +# beos_lock.cpp +# BeOSKernelFileSystem.cpp +# BeOSKernelVolume.cpp DispatcherFileSystem.cpp FileSystem.cpp - haiku_block_cache.cpp - haiku_file_cache.cpp +# haiku_block_cache.cpp +# haiku_file_cache.cpp haiku_hash.cpp haiku_lock.cpp HaikuKernelFileSystem.cpp diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/UserlandFSDispatcher.cpp b/src/add-ons/kernel/file_systems/userlandfs/server/UserlandFSDispatcher.cpp index 8705f356d5..1e54050606 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/UserlandFSDispatcher.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/server/UserlandFSDispatcher.cpp @@ -357,6 +357,7 @@ UserlandFSDispatcher::_ProcessRequests() info->GetInfos(), info->GetInfosSize(), sizeof(Port::Info)); reply->portInfoCount = info->CountInfos(); reply->capabilities = info->GetCapabilities(); + reply->clientFSType = info->GetClientFSType(); _PutFileSystem(fileSystem); } reply->error = result; diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.cpp b/src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.cpp index 8c00acfa90..0705d7b6bc 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.cpp @@ -254,6 +254,7 @@ UserlandRequestHandler::_HandleRequest(MountVolumeRequest* request) reply->error = result; reply->volume = volume; reply->rootID = rootID; + reply->capabilities = volume->GetCapabilities(); // send the reply return _SendReply(allocator, false); @@ -378,11 +379,10 @@ UserlandRequestHandler::_HandleRequest(LookupRequest* request) result = B_BAD_VALUE; ino_t vnid = 0; - int type = 0; if (result == B_OK) { RequestThreadContext context(volume); result = volume->Lookup(request->node, - (const char*)request->entryName.GetData(), &vnid, &type); + (const char*)request->entryName.GetData(), &vnid); } // prepare the reply diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/Volume.cpp b/src/add-ons/kernel/file_systems/userlandfs/server/Volume.cpp index 5d8eac90ec..b4bf024209 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/Volume.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/server/Volume.cpp @@ -80,14 +80,14 @@ Volume::WriteFSInfo(const struct fs_info* info, uint32 mask) // Lookup status_t -Volume::Lookup(fs_vnode dir, const char* entryName, ino_t* vnid, int* type) +Volume::Lookup(void* dir, const char* entryName, ino_t* vnid) { return B_BAD_VALUE; } // LookupNoType status_t -Volume::LookupNoType(fs_vnode dir, const char* entryName, ino_t* vnid) +Volume::LookupNoType(void* dir, const char* entryName, ino_t* vnid) { int type; return Lookup(dir, entryName, vnid, &type); @@ -95,7 +95,7 @@ Volume::LookupNoType(fs_vnode dir, const char* entryName, ino_t* vnid) // GetVNodeName status_t -Volume::GetVNodeName(fs_vnode node, char* buffer, size_t bufferSize) +Volume::GetVNodeName(void* node, char* buffer, size_t bufferSize) { // stat the node to get its ID struct stat st; @@ -110,7 +110,7 @@ Volume::GetVNodeName(fs_vnode node, char* buffer, size_t bufferSize) return error; // get the parent node handle - fs_vnode parentNode; + void* parentNode; error = UserlandFS::KernelEmu::get_vnode(GetID(), parentID, &parentNode); // Lookup() has already called get_vnode() for us, so we need to put it once UserlandFS::KernelEmu::put_vnode(GetID(), parentID); @@ -118,7 +118,7 @@ Volume::GetVNodeName(fs_vnode node, char* buffer, size_t bufferSize) return error; // open the parent dir - fs_cookie cookie; + void* cookie; error = OpenDir(parentNode, &cookie); if (error == B_OK) { @@ -163,21 +163,22 @@ Volume::GetVNodeName(fs_vnode node, char* buffer, size_t bufferSize) // ReadVNode status_t -Volume::ReadVNode(ino_t vnid, bool reenter, fs_vnode* node) +Volume::ReadVNode(ino_t vnid, bool reenter, void** node, int* type, + uint32* flags) { return B_BAD_VALUE; } // WriteVNode status_t -Volume::WriteVNode(fs_vnode node, bool reenter) +Volume::WriteVNode(void* node, bool reenter) { return B_BAD_VALUE; } // RemoveVNode status_t -Volume::RemoveVNode(fs_vnode node, bool reenter) +Volume::RemoveVNode(void* node, bool reenter) { return B_BAD_VALUE; } @@ -188,7 +189,7 @@ Volume::RemoveVNode(fs_vnode node, bool reenter) // IOCtl status_t -Volume::IOCtl(fs_vnode node, fs_cookie cookie, uint32 command, void *buffer, +Volume::IOCtl(void* node, void* cookie, uint32 command, void *buffer, size_t size) { return B_BAD_VALUE; @@ -196,36 +197,35 @@ Volume::IOCtl(fs_vnode node, fs_cookie cookie, uint32 command, void *buffer, // SetFlags status_t -Volume::SetFlags(fs_vnode node, fs_cookie cookie, int flags) +Volume::SetFlags(void* node, void* cookie, int flags) { return B_BAD_VALUE; } // Select status_t -Volume::Select(fs_vnode node, fs_cookie cookie, uint8 event, uint32 ref, - selectsync* sync) +Volume::Select(void* node, void* cookie, uint8 event, selectsync* sync) { return B_BAD_VALUE; } // Deselect status_t -Volume::Deselect(fs_vnode node, fs_cookie cookie, uint8 event, selectsync* sync) +Volume::Deselect(void* node, void* cookie, uint8 event, selectsync* sync) { return B_BAD_VALUE; } // FSync status_t -Volume::FSync(fs_vnode node) +Volume::FSync(void* node) { return B_BAD_VALUE; } // ReadSymlink status_t -Volume::ReadSymlink(fs_vnode node, char* buffer, size_t bufferSize, +Volume::ReadSymlink(void* node, char* buffer, size_t bufferSize, size_t* bytesRead) { return B_BAD_VALUE; @@ -233,7 +233,7 @@ Volume::ReadSymlink(fs_vnode node, char* buffer, size_t bufferSize, // CreateSymlink status_t -Volume::CreateSymlink(fs_vnode dir, const char* name, const char* target, +Volume::CreateSymlink(void* dir, const char* name, const char* target, int mode) { return B_BAD_VALUE; @@ -241,21 +241,21 @@ Volume::CreateSymlink(fs_vnode dir, const char* name, const char* target, // Link status_t -Volume::Link(fs_vnode dir, const char* name, fs_vnode node) +Volume::Link(void* dir, const char* name, void* node) { return B_BAD_VALUE; } // Unlink status_t -Volume::Unlink(fs_vnode dir, const char* name) +Volume::Unlink(void* dir, const char* name) { return B_BAD_VALUE; } // Rename status_t -Volume::Rename(fs_vnode oldDir, const char* oldName, fs_vnode newDir, +Volume::Rename(void* oldDir, const char* oldName, void* newDir, const char* newName) { return B_BAD_VALUE; @@ -263,21 +263,21 @@ Volume::Rename(fs_vnode oldDir, const char* oldName, fs_vnode newDir, // Access status_t -Volume::Access(fs_vnode node, int mode) +Volume::Access(void* node, int mode) { return B_BAD_VALUE; } // ReadStat status_t -Volume::ReadStat(fs_vnode node, struct stat* st) +Volume::ReadStat(void* node, struct stat* st) { return B_BAD_VALUE; } // WriteStat status_t -Volume::WriteStat(fs_vnode node, const struct stat *st, uint32 mask) +Volume::WriteStat(void* node, const struct stat *st, uint32 mask) { return B_BAD_VALUE; } @@ -288,36 +288,36 @@ Volume::WriteStat(fs_vnode node, const struct stat *st, uint32 mask) // Create status_t -Volume::Create(fs_vnode dir, const char* name, int openMode, int mode, - fs_cookie* cookie, ino_t* vnid) +Volume::Create(void* dir, const char* name, int openMode, int mode, + void** cookie, ino_t* vnid) { return B_BAD_VALUE; } // Open status_t -Volume::Open(fs_vnode node, int openMode, fs_cookie* cookie) +Volume::Open(void* node, int openMode, void** cookie) { return B_BAD_VALUE; } // Close status_t -Volume::Close(fs_vnode node, fs_cookie cookie) +Volume::Close(void* node, void* cookie) { return B_BAD_VALUE; } // FreeCookie status_t -Volume::FreeCookie(fs_vnode node, fs_cookie cookie) +Volume::FreeCookie(void* node, void* cookie) { return B_BAD_VALUE; } // Read status_t -Volume::Read(fs_vnode node, fs_cookie cookie, off_t pos, void* buffer, +Volume::Read(void* node, void* cookie, off_t pos, void* buffer, size_t bufferSize, size_t* bytesRead) { return B_BAD_VALUE; @@ -325,7 +325,7 @@ Volume::Read(fs_vnode node, fs_cookie cookie, off_t pos, void* buffer, // Write status_t -Volume::Write(fs_vnode node, fs_cookie cookie, off_t pos, const void* buffer, +Volume::Write(void* node, void* cookie, off_t pos, const void* buffer, size_t bufferSize, size_t* bytesWritten) { return B_BAD_VALUE; @@ -337,42 +337,42 @@ Volume::Write(fs_vnode node, fs_cookie cookie, off_t pos, const void* buffer, // CreateDir status_t -Volume::CreateDir(fs_vnode dir, const char* name, int mode, ino_t *newDir) +Volume::CreateDir(void* dir, const char* name, int mode, ino_t *newDir) { return B_BAD_VALUE; } // RemoveDir status_t -Volume::RemoveDir(fs_vnode dir, const char* name) +Volume::RemoveDir(void* dir, const char* name) { return B_BAD_VALUE; } // OpenDir status_t -Volume::OpenDir(fs_vnode node, fs_cookie* cookie) +Volume::OpenDir(void* node, void** cookie) { return B_BAD_VALUE; } // CloseDir status_t -Volume::CloseDir(fs_vnode node, fs_vnode cookie) +Volume::CloseDir(void* node, void* cookie) { return B_BAD_VALUE; } // FreeDirCookie status_t -Volume::FreeDirCookie(fs_vnode node, fs_vnode cookie) +Volume::FreeDirCookie(void* node, void* cookie) { return B_BAD_VALUE; } // ReadDir status_t -Volume::ReadDir(fs_vnode node, fs_vnode cookie, void* buffer, size_t bufferSize, +Volume::ReadDir(void* node, void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead) { return B_BAD_VALUE; @@ -380,7 +380,7 @@ Volume::ReadDir(fs_vnode node, fs_vnode cookie, void* buffer, size_t bufferSize, // RewindDir status_t -Volume::RewindDir(fs_vnode node, fs_vnode cookie) +Volume::RewindDir(void* node, void* cookie) { return B_BAD_VALUE; } @@ -391,28 +391,28 @@ Volume::RewindDir(fs_vnode node, fs_vnode cookie) // OpenAttrDir status_t -Volume::OpenAttrDir(fs_vnode node, fs_cookie *cookie) +Volume::OpenAttrDir(void* node, void** cookie) { return B_BAD_VALUE; } // CloseAttrDir status_t -Volume::CloseAttrDir(fs_vnode node, fs_cookie cookie) +Volume::CloseAttrDir(void* node, void* cookie) { return B_BAD_VALUE; } // FreeAttrDirCookie status_t -Volume::FreeAttrDirCookie(fs_vnode node, fs_cookie cookie) +Volume::FreeAttrDirCookie(void* node, void* cookie) { return B_BAD_VALUE; } // ReadAttrDir status_t -Volume::ReadAttrDir(fs_vnode node, fs_cookie cookie, void* buffer, +Volume::ReadAttrDir(void* node, void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead) { return B_BAD_VALUE; @@ -420,7 +420,7 @@ Volume::ReadAttrDir(fs_vnode node, fs_cookie cookie, void* buffer, // RewindAttrDir status_t -Volume::RewindAttrDir(fs_vnode node, fs_cookie cookie) +Volume::RewindAttrDir(void* node, void* cookie) { return B_BAD_VALUE; } @@ -431,37 +431,37 @@ Volume::RewindAttrDir(fs_vnode node, fs_cookie cookie) // CreateAttr status_t -Volume::CreateAttr(fs_vnode node, const char* name, uint32 type, int openMode, - fs_cookie* cookie) +Volume::CreateAttr(void* node, const char* name, uint32 type, int openMode, + void** cookie) { return B_BAD_VALUE; } // OpenAttr status_t -Volume::OpenAttr(fs_vnode node, const char* name, int openMode, - fs_cookie* cookie) +Volume::OpenAttr(void* node, const char* name, int openMode, + void** cookie) { return B_BAD_VALUE; } // CloseAttr status_t -Volume::CloseAttr(fs_vnode node, fs_cookie cookie) +Volume::CloseAttr(void* node, void* cookie) { return B_BAD_VALUE; } // FreeAttrCookie status_t -Volume::FreeAttrCookie(fs_vnode node, fs_cookie cookie) +Volume::FreeAttrCookie(void* node, void* cookie) { return B_BAD_VALUE; } // ReadAttr status_t -Volume::ReadAttr(fs_vnode node, fs_cookie cookie, off_t pos, void* buffer, +Volume::ReadAttr(void* node, void* cookie, off_t pos, void* buffer, size_t bufferSize, size_t* bytesRead) { return B_BAD_VALUE; @@ -469,7 +469,7 @@ Volume::ReadAttr(fs_vnode node, fs_cookie cookie, off_t pos, void* buffer, // WriteAttr status_t -Volume::WriteAttr(fs_vnode node, fs_cookie cookie, off_t pos, +Volume::WriteAttr(void* node, void* cookie, off_t pos, const void* buffer, size_t bufferSize, size_t* bytesWritten) { return B_BAD_VALUE; @@ -477,14 +477,14 @@ Volume::WriteAttr(fs_vnode node, fs_cookie cookie, off_t pos, // ReadAttrStat status_t -Volume::ReadAttrStat(fs_vnode node, fs_cookie cookie, struct stat *st) +Volume::ReadAttrStat(void* node, void* cookie, struct stat *st) { return B_BAD_VALUE; } // WriteAttrStat status_t -Volume::WriteAttrStat(fs_vnode node, fs_cookie cookie, const struct stat* st, +Volume::WriteAttrStat(void* node, void* cookie, const struct stat* st, int statMask) { return B_BAD_VALUE; @@ -492,7 +492,7 @@ Volume::WriteAttrStat(fs_vnode node, fs_cookie cookie, const struct stat* st, // RenameAttr status_t -Volume::RenameAttr(fs_vnode oldNode, const char* oldName, fs_vnode newNode, +Volume::RenameAttr(void* oldNode, const char* oldName, void* newNode, const char* newName) { return B_BAD_VALUE; @@ -500,7 +500,7 @@ Volume::RenameAttr(fs_vnode oldNode, const char* oldName, fs_vnode newNode, // RemoveAttr status_t -Volume::RemoveAttr(fs_vnode node, const char* name) +Volume::RemoveAttr(void* node, const char* name) { return B_BAD_VALUE; } @@ -511,28 +511,28 @@ Volume::RemoveAttr(fs_vnode node, const char* name) // OpenIndexDir status_t -Volume::OpenIndexDir(fs_cookie *cookie) +Volume::OpenIndexDir(void** cookie) { return B_BAD_VALUE; } // CloseIndexDir status_t -Volume::CloseIndexDir(fs_cookie cookie) +Volume::CloseIndexDir(void* cookie) { return B_BAD_VALUE; } // FreeIndexDirCookie status_t -Volume::FreeIndexDirCookie(fs_cookie cookie) +Volume::FreeIndexDirCookie(void* cookie) { return B_BAD_VALUE; } // ReadIndexDir status_t -Volume::ReadIndexDir(fs_cookie cookie, void* buffer, size_t bufferSize, +Volume::ReadIndexDir(void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead) { return B_BAD_VALUE; @@ -540,7 +540,7 @@ Volume::ReadIndexDir(fs_cookie cookie, void* buffer, size_t bufferSize, // RewindIndexDir status_t -Volume::RewindIndexDir(fs_cookie cookie) +Volume::RewindIndexDir(void* cookie) { return B_BAD_VALUE; } @@ -573,28 +573,28 @@ Volume::ReadIndexStat(const char *name, struct stat *st) // OpenQuery status_t Volume::OpenQuery(const char* queryString, uint32 flags, port_id port, - uint32 token, fs_cookie *cookie) + uint32 token, void** cookie) { return B_BAD_VALUE; } // CloseQuery status_t -Volume::CloseQuery(fs_cookie cookie) +Volume::CloseQuery(void* cookie) { return B_BAD_VALUE; } // FreeQueryCookie status_t -Volume::FreeQueryCookie(fs_cookie cookie) +Volume::FreeQueryCookie(void* cookie) { return B_BAD_VALUE; } // ReadQuery status_t -Volume::ReadQuery(fs_cookie cookie, void* buffer, size_t bufferSize, +Volume::ReadQuery(void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead) { return B_BAD_VALUE; @@ -602,7 +602,7 @@ Volume::ReadQuery(fs_cookie cookie, void* buffer, size_t bufferSize, // RewindQuery status_t -Volume::RewindQuery(fs_cookie cookie) +Volume::RewindQuery(void* cookie) { return B_BAD_VALUE; } diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/Volume.h b/src/add-ons/kernel/file_systems/userlandfs/server/Volume.h index 2006e438ff..09d6765135 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/Volume.h +++ b/src/add-ons/kernel/file_systems/userlandfs/server/Volume.h @@ -6,10 +6,14 @@ #include #include +#include "FSCapabilities.h" + namespace UserlandFS { class FileSystem; +using UserlandFSUtil::FSVolumeCapabilities; + class Volume { public: Volume(FileSystem* fileSystem, dev_t id); @@ -18,6 +22,10 @@ public: FileSystem* GetFileSystem() const; dev_t GetID() const; + void GetCapabilities( + FSVolumeCapabilities& capabilities) const + { capabilities = fCapabilities; } + // FS virtual status_t Mount(const char* device, uint32 flags, const char* parameters, ino_t* rootID); @@ -28,114 +36,114 @@ public: uint32 mask); // vnodes - virtual status_t Lookup(fs_vnode dir, const char* entryName, - ino_t* vnid, int* type); - virtual status_t LookupNoType(fs_vnode dir, + virtual status_t Lookup(void* dir, const char* entryName, + ino_t* vnid); + virtual status_t LookupNoType(void* dir, const char* entryName, ino_t* vnid); // not required - virtual status_t GetVNodeName(fs_vnode node, char* buffer, + virtual status_t GetVNodeName(void* node, char* buffer, size_t bufferSize); virtual status_t ReadVNode(ino_t vnid, bool reenter, - fs_vnode* node); - virtual status_t WriteVNode(fs_vnode node, bool reenter); - virtual status_t RemoveVNode(fs_vnode node, bool reenter); + void** node, int* type, uint32* flags); + virtual status_t WriteVNode(void* node, bool reenter); + virtual status_t RemoveVNode(void* node, bool reenter); // nodes - virtual status_t IOCtl(fs_vnode node, fs_cookie cookie, + virtual status_t IOCtl(void* node, void* cookie, uint32 command, void* buffer, size_t size); - virtual status_t SetFlags(fs_vnode node, fs_cookie cookie, + virtual status_t SetFlags(void* node, void* cookie, int flags); - virtual status_t Select(fs_vnode node, fs_cookie cookie, - uint8 event, uint32 ref, selectsync* sync); - virtual status_t Deselect(fs_vnode node, fs_cookie cookie, + virtual status_t Select(void* node, void* cookie, + uint8 event, selectsync* sync); + virtual status_t Deselect(void* node, void* cookie, uint8 event, selectsync* sync); - virtual status_t FSync(fs_vnode node); + virtual status_t FSync(void* node); - virtual status_t ReadSymlink(fs_vnode node, char* buffer, + virtual status_t ReadSymlink(void* node, char* buffer, size_t bufferSize, size_t* bytesRead); - virtual status_t CreateSymlink(fs_vnode dir, const char* name, + virtual status_t CreateSymlink(void* dir, const char* name, const char* target, int mode); - virtual status_t Link(fs_vnode dir, const char* name, - fs_vnode node); - virtual status_t Unlink(fs_vnode dir, const char* name); - virtual status_t Rename(fs_vnode oldDir, const char* oldName, - fs_vnode newDir, const char* newName); + virtual status_t Link(void* dir, const char* name, + void* node); + virtual status_t Unlink(void* dir, const char* name); + virtual status_t Rename(void* oldDir, const char* oldName, + void* newDir, const char* newName); - virtual status_t Access(fs_vnode node, int mode); - virtual status_t ReadStat(fs_vnode node, struct stat* st); - virtual status_t WriteStat(fs_vnode node, const struct stat *st, + virtual status_t Access(void* node, int mode); + virtual status_t ReadStat(void* node, struct stat* st); + virtual status_t WriteStat(void* node, const struct stat *st, uint32 mask); // files - virtual status_t Create(fs_vnode dir, const char* name, - int openMode, int mode, fs_cookie* cookie, + virtual status_t Create(void* dir, const char* name, + int openMode, int mode, void** cookie, ino_t* vnid); - virtual status_t Open(fs_vnode node, int openMode, - fs_cookie* cookie); - virtual status_t Close(fs_vnode node, fs_cookie cookie); - virtual status_t FreeCookie(fs_vnode node, fs_cookie cookie); - virtual status_t Read(fs_vnode node, fs_cookie cookie, off_t pos, + virtual status_t Open(void* node, int openMode, + void** cookie); + virtual status_t Close(void* node, void* cookie); + virtual status_t FreeCookie(void* node, void* cookie); + virtual status_t Read(void* node, void* cookie, off_t pos, void* buffer, size_t bufferSize, size_t* bytesRead); - virtual status_t Write(fs_vnode node, fs_cookie cookie, + virtual status_t Write(void* node, void* cookie, off_t pos, const void* buffer, size_t bufferSize, size_t* bytesWritten); // directories - virtual status_t CreateDir(fs_vnode dir, const char* name, + virtual status_t CreateDir(void* dir, const char* name, int mode, ino_t *newDir); - virtual status_t RemoveDir(fs_vnode dir, const char* name); - virtual status_t OpenDir(fs_vnode node, fs_cookie* cookie); - virtual status_t CloseDir(fs_vnode node, fs_vnode cookie); - virtual status_t FreeDirCookie(fs_vnode node, fs_vnode cookie); - virtual status_t ReadDir(fs_vnode node, fs_vnode cookie, + virtual status_t RemoveDir(void* dir, const char* name); + virtual status_t OpenDir(void* node, void** cookie); + virtual status_t CloseDir(void* node, void* cookie); + virtual status_t FreeDirCookie(void* node, void* cookie); + virtual status_t ReadDir(void* node, void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead); - virtual status_t RewindDir(fs_vnode node, fs_vnode cookie); + virtual status_t RewindDir(void* node, void* cookie); // attribute directories - virtual status_t OpenAttrDir(fs_vnode node, fs_cookie *cookie); - virtual status_t CloseAttrDir(fs_vnode node, fs_cookie cookie); - virtual status_t FreeAttrDirCookie(fs_vnode node, - fs_cookie cookie); - virtual status_t ReadAttrDir(fs_vnode node, fs_cookie cookie, + virtual status_t OpenAttrDir(void* node, void** cookie); + virtual status_t CloseAttrDir(void* node, void* cookie); + virtual status_t FreeAttrDirCookie(void* node, + void* cookie); + virtual status_t ReadAttrDir(void* node, void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead); - virtual status_t RewindAttrDir(fs_vnode node, fs_cookie cookie); + virtual status_t RewindAttrDir(void* node, void* cookie); // attributes - virtual status_t CreateAttr(fs_vnode node, const char* name, + virtual status_t CreateAttr(void* node, const char* name, uint32 type, int openMode, - fs_cookie* cookie); - virtual status_t OpenAttr(fs_vnode node, const char* name, - int openMode, fs_cookie* cookie); - virtual status_t CloseAttr(fs_vnode node, fs_cookie cookie); - virtual status_t FreeAttrCookie(fs_vnode node, fs_cookie cookie); - virtual status_t ReadAttr(fs_vnode node, fs_cookie cookie, + void** cookie); + virtual status_t OpenAttr(void* node, const char* name, + int openMode, void** cookie); + virtual status_t CloseAttr(void* node, void* cookie); + virtual status_t FreeAttrCookie(void* node, void* cookie); + virtual status_t ReadAttr(void* node, void* cookie, off_t pos, void* buffer, size_t bufferSize, size_t* bytesRead); - virtual status_t WriteAttr(fs_vnode node, fs_cookie cookie, + virtual status_t WriteAttr(void* node, void* cookie, off_t pos, const void* buffer, size_t bufferSize, size_t* bytesWritten); - virtual status_t ReadAttrStat(fs_vnode node, fs_cookie cookie, + virtual status_t ReadAttrStat(void* node, void* cookie, struct stat* st); - virtual status_t WriteAttrStat(fs_vnode node, fs_cookie cookie, + virtual status_t WriteAttrStat(void* node, void* cookie, const struct stat* st, int statMask); - virtual status_t RenameAttr(fs_vnode oldNode, - const char* oldName, fs_vnode newNode, + virtual status_t RenameAttr(void* oldNode, + const char* oldName, void* newNode, const char* newName); - virtual status_t RemoveAttr(fs_vnode node, const char* name); + virtual status_t RemoveAttr(void* node, const char* name); // indices - virtual status_t OpenIndexDir(fs_cookie *cookie); - virtual status_t CloseIndexDir(fs_cookie cookie); - virtual status_t FreeIndexDirCookie(fs_cookie cookie); - virtual status_t ReadIndexDir(fs_cookie cookie, void* buffer, + virtual status_t OpenIndexDir(void** cookie); + virtual status_t CloseIndexDir(void* cookie); + virtual status_t FreeIndexDirCookie(void* cookie); + virtual status_t ReadIndexDir(void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead); - virtual status_t RewindIndexDir(fs_cookie cookie); + virtual status_t RewindIndexDir(void* cookie); virtual status_t CreateIndex(const char* name, uint32 type, uint32 flags); virtual status_t RemoveIndex(const char* name); @@ -145,17 +153,18 @@ public: // queries virtual status_t OpenQuery(const char* queryString, uint32 flags, port_id port, uint32 token, - fs_cookie *cookie); - virtual status_t CloseQuery(fs_cookie cookie); - virtual status_t FreeQueryCookie(fs_cookie cookie); - virtual status_t ReadQuery(fs_cookie cookie, void* buffer, + void** cookie); + virtual status_t CloseQuery(void* cookie); + virtual status_t FreeQueryCookie(void* cookie); + virtual status_t ReadQuery(void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead); - virtual status_t RewindQuery(fs_cookie cookie); + virtual status_t RewindQuery(void* cookie); protected: FileSystem* fFileSystem; dev_t fID; + FSVolumeCapabilities fCapabilities; }; } // namespace UserlandFS diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/haiku_kernel_emu.cpp b/src/add-ons/kernel/file_systems/userlandfs/server/haiku_kernel_emu.cpp index 57554e8d7a..d6e3366a12 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/haiku_kernel_emu.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/server/haiku_kernel_emu.cpp @@ -111,51 +111,117 @@ notify_query_entry_removed(port_id port, int32 token, dev_t device, // new_vnode status_t -new_vnode(dev_t mountID, ino_t vnodeID, fs_vnode privateNode) +new_vnode(fs_volume *_volume, ino_t vnodeID, void *privateNode, + fs_vnode_ops *ops) { - return UserlandFS::KernelEmu::publish_vnode(mountID, vnodeID, privateNode); + HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume); + + // translate to a wrapper node + HaikuKernelNode* node; + status_t error = volume->NewVNode(vnodeID, privateNode, ops, &node); + if (error != B_OK) + return error; + + // announce the new node + error = UserlandFS::KernelEmu::new_vnode(volume->GetID(), vnodeID, node); + if (error != B_OK) + volume->UndoNewVNode(node); + + return error; } // publish_vnode status_t -publish_vnode(dev_t mountID, ino_t vnodeID, fs_vnode privateNode) +publish_vnode(fs_volume *_volume, ino_t vnodeID, void *privateNode, + fs_vnode_ops *ops, int type, uint32 flags) { - return UserlandFS::KernelEmu::publish_vnode(mountID, vnodeID, privateNode); + HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume); + + // translate to a wrapper node + HaikuKernelNode* node; + status_t error = volume->PublishVNode(vnodeID, privateNode, ops, type, + flags, &node); + if (error != B_OK) + return error; + + // publish the new node + error = UserlandFS::KernelEmu::publish_vnode(volume, vnodeID, node, type, + flags); + if (error != B_OK) + volume->UndoPublishVNode(node); + + return error; } // get_vnode status_t -get_vnode(dev_t mountID, ino_t vnodeID, fs_vnode *privateNode) +get_vnode(defs_volume *_volume, ino_t vnodeID, fs_vnode *privateNode) { - return UserlandFS::KernelEmu::get_vnode(mountID, vnodeID, privateNode); + HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume); + + // get the node + void* foundNode; + status_t error = UserlandFS::KernelEmu::get_vnode(volume, vnodeID, + &foundNode); + if (error != B_OK) + return error; + + ((HaikuKernelNode*)foundNode)->GetFSNode(privateNode); + + return B_OK; } // put_vnode status_t -put_vnode(dev_t mountID, ino_t vnodeID) +put_vnode(fs_volume *_volume, ino_t vnodeID) { - return UserlandFS::KernelEmu::put_vnode(mountID, vnodeID); + HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume); + + return UserlandFS::KernelEmu::put_vnode(volume->GetID(), vnodeID); +} + +// acquire_vnode +status_t +acquire_vnode(fs_volume *_volume, ino_t vnodeID) +{ + HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume); + + return UserlandFS::KernelEmu::acquire_vnode(volume->GetID(), vnodeID); } // remove_vnode status_t -remove_vnode(dev_t mountID, ino_t vnodeID) +remove_vnode(fs_volume *_volume, ino_t vnodeID) { - return UserlandFS::KernelEmu::remove_vnode(mountID, vnodeID); + HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume); + + return UserlandFS::KernelEmu::remove_vnode(volume->GetID(), vnodeID); } // unremove_vnode status_t -unremove_vnode(dev_t mountID, ino_t vnodeID) +unremove_vnode(fs_volume *_volume, ino_t vnodeID) { - return UserlandFS::KernelEmu::unremove_vnode(mountID, vnodeID); + HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume); + + return UserlandFS::KernelEmu::unremove_vnode(volume->GetID(), vnodeID); } // get_vnode_removed status_t -get_vnode_removed(dev_t mountID, ino_t vnodeID, bool* removed) +get_vnode_removed(fs_volume *_volume, ino_t vnodeID, bool* removed) { - return UserlandFS::KernelEmu::get_vnode_removed(mountID, vnodeID, removed); + HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume); + + return UserlandFS::KernelEmu::get_vnode_removed(volume->GetID(), vnodeID, + removed); +} + +// volume_for_vnode +fs_volume* +volume_for_vnode(fs_vnode *vnode) +{ + return HaikuKernelNode::GetNode(vnode)->GetVolume(); } diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/kernel_emu.cpp b/src/add-ons/kernel/file_systems/userlandfs/server/kernel_emu.cpp index fdb40e21b3..adc20e6e07 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/kernel_emu.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/server/kernel_emu.cpp @@ -255,7 +255,7 @@ UserlandFS::KernelEmu::notify_query(port_id targetPort, int32 token, // get_vnode status_t -UserlandFS::KernelEmu::get_vnode(dev_t nsid, ino_t vnid, fs_vnode* data) +UserlandFS::KernelEmu::get_vnode(dev_t nsid, ino_t vnid, void** node) { // get the request port and the file system RequestPort* port; @@ -285,7 +285,7 @@ UserlandFS::KernelEmu::get_vnode(dev_t nsid, ino_t vnid, fs_vnode* data) // process the reply if (reply->error != B_OK) return reply->error; - *data = reply->node; + *node = reply->node; return error; } @@ -326,7 +326,7 @@ UserlandFS::KernelEmu::put_vnode(dev_t nsid, ino_t vnid) // new_vnode status_t -UserlandFS::KernelEmu::new_vnode(dev_t nsid, ino_t vnid, fs_vnode data) +UserlandFS::KernelEmu::new_vnode(dev_t nsid, ino_t vnid, void* data) { // get the request port and the file system RequestPort* port; @@ -362,8 +362,8 @@ UserlandFS::KernelEmu::new_vnode(dev_t nsid, ino_t vnid, fs_vnode data) // publish_vnode status_t -UserlandFS::KernelEmu::publish_vnode(dev_t nsid, ino_t vnid, - fs_vnode data) +UserlandFS::KernelEmu::publish_vnode(dev_t nsid, ino_t vnid, void* data, + int type, uint32 flags) { // get the request port and the file system RequestPort* port; @@ -382,6 +382,8 @@ UserlandFS::KernelEmu::publish_vnode(dev_t nsid, ino_t vnid, request->nsid = nsid; request->vnid = vnid; request->node = data; + request->type = type; + request->flags = flags; // send the request UserlandRequestHandler handler(fileSystem, PUBLISH_VNODE_REPLY); diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/kernel_emu.h b/src/add-ons/kernel/file_systems/userlandfs/server/kernel_emu.h index 8d4e795f37..797cc7aa1b 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/kernel_emu.h +++ b/src/add-ons/kernel/file_systems/userlandfs/server/kernel_emu.h @@ -9,8 +9,6 @@ struct selectsync; namespace UserlandFS { namespace KernelEmu { -typedef void* fs_vnode; - int new_path(const char *path, char **copy); void free_path(char *p); @@ -22,10 +20,11 @@ status_t notify_select_event(selectsync *sync, uint8 event, status_t notify_query(port_id port, int32 token, int32 operation, dev_t device, ino_t directory, const char* name, ino_t node); -status_t get_vnode(dev_t nsid, ino_t vnid, fs_vnode* data); +status_t get_vnode(dev_t nsid, ino_t vnid, void** node); status_t put_vnode(dev_t nsid, ino_t vnid); -status_t new_vnode(dev_t nsid, ino_t vnid, fs_vnode data); -status_t publish_vnode(dev_t nsid, ino_t vnid, fs_vnode data); +status_t new_vnode(dev_t nsid, ino_t vnid, void* data); +status_t publish_vnode(dev_t nsid, ino_t vnid, void* data, int type, + uint32 flags); status_t remove_vnode(dev_t nsid, ino_t vnid); status_t unremove_vnode(dev_t nsid, ino_t vnid); status_t get_vnode_removed(dev_t nsid, ino_t vnid, bool* removed);