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);