From 35d56691a2b6005ee2b21cc33b944df83e6d2162 Mon Sep 17 00:00:00 2001 From: Ingo Weinhold Date: Sat, 28 Feb 2009 16:00:09 +0000 Subject: [PATCH] Adjusted to interface changes in the server. Should be working save for the stubbed new_vnode(). git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29353 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- .../server/beos/BeOSKernelFileSystem.cpp | 172 +++++++++------- .../server/beos/BeOSKernelFileSystem.h | 11 +- .../server/beos/BeOSKernelVolume.cpp | 187 ++++++++---------- .../userlandfs/server/beos/BeOSKernelVolume.h | 131 ++++++------ .../server/beos/beos_kernel_emu.cpp | 10 +- 5 files changed, 258 insertions(+), 253 deletions(-) diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/beos/BeOSKernelFileSystem.cpp b/src/add-ons/kernel/file_systems/userlandfs/server/beos/BeOSKernelFileSystem.cpp index 6ccadcc62d..75a04c9111 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/beos/BeOSKernelFileSystem.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/server/beos/BeOSKernelFileSystem.cpp @@ -54,108 +54,130 @@ BeOSKernelFileSystem::_InitCapabilities() fCapabilities.ClearAll(); // FS interface type - fCapabilities.clientFSType = CLIENT_FS_BEOS_KERNEL; + fClientFSType = CLIENT_FS_BEOS_KERNEL; // FS operations fCapabilities.Set(FS_CAPABILITY_MOUNT, fFSOps->mount); - fCapabilities.Set(FS_CAPABILITY_UNMOUNT, fFSOps->unmount); - fCapabilities.Set(FS_CAPABILITY_READ_FS_INFO, fFSOps->rfsstat); - fCapabilities.Set(FS_CAPABILITY_WRITE_FS_INFO, fFSOps->wfsstat); - fCapabilities.Set(FS_CAPABILITY_SYNC, fFSOps->sync); + + // Volume operations + fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_UNMOUNT, fFSOps->unmount); + + fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_READ_FS_INFO, fFSOps->rfsstat); + fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_WRITE_FS_INFO, + fFSOps->wfsstat); + fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_SYNC, fFSOps->sync); + + fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_GET_VNODE, fFSOps->read_vnode); + + // index directory & index operations + fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_OPEN_INDEX_DIR, + fFSOps->open_indexdir); + fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_CLOSE_INDEX_DIR, + fFSOps->close_indexdir); + fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_FREE_INDEX_DIR_COOKIE, + fFSOps->free_indexdircookie); + fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_READ_INDEX_DIR, + fFSOps->read_indexdir); + fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_REWIND_INDEX_DIR, + fFSOps->rewind_indexdir); + + fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_CREATE_INDEX, + fFSOps->create_index); + fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_REMOVE_INDEX, + fFSOps->remove_index); + fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_READ_INDEX_STAT, + fFSOps->stat_index); + + // query operations + fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_OPEN_QUERY, + fFSOps->open_query); + fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_CLOSE_QUERY, + fFSOps->close_query); + fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_FREE_QUERY_COOKIE, + fFSOps->free_querycookie); + fVolumeCapabilities.Set(FS_VOLUME_CAPABILITY_READ_QUERY, + fFSOps->read_query); + // missing: FS_VOLUME_CAPABILITY_REWIND_QUERY, // vnode operations - fCapabilities.Set(FS_CAPABILITY_LOOKUP, fFSOps->walk); - // missing: FS_CAPABILITY_GET_VNODE_NAME, + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_LOOKUP, fFSOps->walk); + // missing: FS_VNODE_CAPABILITY_GET_VNODE_NAME, - fCapabilities.Set(FS_CAPABILITY_GET_VNODE, fFSOps->read_vnode); - fCapabilities.Set(FS_CAPABILITY_PUT_VNODE, fFSOps->write_vnode); - fCapabilities.Set(FS_CAPABILITY_REMOVE_VNODE, fFSOps->remove_vnode); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_PUT_VNODE, fFSOps->write_vnode); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_REMOVE_VNODE, + fFSOps->remove_vnode); // VM file access - // missing: FS_CAPABILITY_CAN_PAGE, - // missing: FS_CAPABILITY_READ_PAGES, - // missing: FS_CAPABILITY_WRITE_PAGES, + // missing: FS_VNODE_CAPABILITY_CAN_PAGE, + // missing: FS_VNODE_CAPABILITY_READ_PAGES, + // missing: FS_VNODE_CAPABILITY_WRITE_PAGES, // cache file access - // missing: FS_CAPABILITY_GET_FILE_MAP, + // missing: FS_VNODE_CAPABILITY_GET_FILE_MAP, // common operations - fCapabilities.Set(FS_CAPABILITY_IOCTL, fFSOps->ioctl); - fCapabilities.Set(FS_CAPABILITY_SET_FLAGS, fFSOps->setflags); - fCapabilities.Set(FS_CAPABILITY_SELECT, fFSOps->select); - fCapabilities.Set(FS_CAPABILITY_DESELECT, fFSOps->deselect); - fCapabilities.Set(FS_CAPABILITY_FSYNC, fFSOps->fsync); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_IOCTL, fFSOps->ioctl); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_SET_FLAGS, fFSOps->setflags); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_SELECT, fFSOps->select); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_DESELECT, fFSOps->deselect); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_FSYNC, fFSOps->fsync); - fCapabilities.Set(FS_CAPABILITY_READ_SYMLINK, fFSOps->readlink); - fCapabilities.Set(FS_CAPABILITY_CREATE_SYMLINK, fFSOps->symlink); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ_SYMLINK, fFSOps->readlink); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CREATE_SYMLINK, fFSOps->symlink); - fCapabilities.Set(FS_CAPABILITY_LINK, fFSOps->link); - fCapabilities.Set(FS_CAPABILITY_UNLINK, fFSOps->unlink); - fCapabilities.Set(FS_CAPABILITY_RENAME, fFSOps->rename); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_LINK, fFSOps->link); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_UNLINK, fFSOps->unlink); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_RENAME, fFSOps->rename); - fCapabilities.Set(FS_CAPABILITY_ACCESS, fFSOps->access); - fCapabilities.Set(FS_CAPABILITY_READ_STAT, fFSOps->rstat); - fCapabilities.Set(FS_CAPABILITY_WRITE_STAT, fFSOps->wstat); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_ACCESS, fFSOps->access); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ_STAT, fFSOps->rstat); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_WRITE_STAT, fFSOps->wstat); // file operations - fCapabilities.Set(FS_CAPABILITY_CREATE, fFSOps->create); - fCapabilities.Set(FS_CAPABILITY_OPEN, fFSOps->open); - fCapabilities.Set(FS_CAPABILITY_CLOSE, fFSOps->close); - fCapabilities.Set(FS_CAPABILITY_FREE_COOKIE, fFSOps->free_cookie); - fCapabilities.Set(FS_CAPABILITY_READ, fFSOps->read); - fCapabilities.Set(FS_CAPABILITY_WRITE, fFSOps->write); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CREATE, fFSOps->create); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_OPEN, fFSOps->open); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CLOSE, fFSOps->close); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_FREE_COOKIE, fFSOps->free_cookie); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ, fFSOps->read); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_WRITE, fFSOps->write); // directory operations - fCapabilities.Set(FS_CAPABILITY_CREATE_DIR, fFSOps->mkdir); - fCapabilities.Set(FS_CAPABILITY_REMOVE_DIR, fFSOps->rmdir); - fCapabilities.Set(FS_CAPABILITY_OPEN_DIR, fFSOps->opendir); - fCapabilities.Set(FS_CAPABILITY_CLOSE_DIR, fFSOps->closedir); - fCapabilities.Set(FS_CAPABILITY_FREE_DIR_COOKIE, fFSOps->free_dircookie); - fCapabilities.Set(FS_CAPABILITY_READ_DIR, fFSOps->readdir); - fCapabilities.Set(FS_CAPABILITY_REWIND_DIR, fFSOps->rewinddir); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CREATE_DIR, fFSOps->mkdir); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_REMOVE_DIR, fFSOps->rmdir); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_OPEN_DIR, fFSOps->opendir); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CLOSE_DIR, fFSOps->closedir); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_FREE_DIR_COOKIE, + fFSOps->free_dircookie); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ_DIR, fFSOps->readdir); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_REWIND_DIR, fFSOps->rewinddir); // attribute directory operations - fCapabilities.Set(FS_CAPABILITY_OPEN_ATTR_DIR, fFSOps->open_attrdir); - fCapabilities.Set(FS_CAPABILITY_CLOSE_ATTR_DIR, fFSOps->close_attrdir); - fCapabilities.Set(FS_CAPABILITY_FREE_ATTR_DIR_COOKIE, + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_OPEN_ATTR_DIR, + fFSOps->open_attrdir); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CLOSE_ATTR_DIR, + fFSOps->close_attrdir); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_FREE_ATTR_DIR_COOKIE, fFSOps->free_attrdircookie); - fCapabilities.Set(FS_CAPABILITY_READ_ATTR_DIR, fFSOps->read_attrdir); - fCapabilities.Set(FS_CAPABILITY_REWIND_ATTR_DIR, fFSOps->rewind_attrdir); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ_ATTR_DIR, + fFSOps->read_attrdir); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_REWIND_ATTR_DIR, + fFSOps->rewind_attrdir); // attribute operations // we emulate open_attr() and free_attr_dir_cookie() if either read_attr() // or write_attr() is present bool hasAttributes = (fFSOps->read_attr || fFSOps->write_attr); - fCapabilities.Set(FS_CAPABILITY_CREATE_ATTR, hasAttributes); - fCapabilities.Set(FS_CAPABILITY_OPEN_ATTR, hasAttributes); - fCapabilities.Set(FS_CAPABILITY_CLOSE_ATTR, false); - fCapabilities.Set(FS_CAPABILITY_FREE_ATTR_COOKIE, hasAttributes); - fCapabilities.Set(FS_CAPABILITY_READ_ATTR, fFSOps->read_attr); - fCapabilities.Set(FS_CAPABILITY_WRITE_ATTR, fFSOps->write_attr); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CREATE_ATTR, hasAttributes); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_OPEN_ATTR, hasAttributes); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CLOSE_ATTR, false); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_FREE_ATTR_COOKIE, hasAttributes); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ_ATTR, fFSOps->read_attr); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_WRITE_ATTR, fFSOps->write_attr); - fCapabilities.Set(FS_CAPABILITY_READ_ATTR_STAT, fFSOps->stat_attr); - // missing: FS_CAPABILITY_WRITE_ATTR_STAT - fCapabilities.Set(FS_CAPABILITY_RENAME_ATTR, fFSOps->rename_attr); - fCapabilities.Set(FS_CAPABILITY_REMOVE_ATTR, fFSOps->remove_attr); - - // index directory & index operations - fCapabilities.Set(FS_CAPABILITY_OPEN_INDEX_DIR, fFSOps->open_indexdir); - fCapabilities.Set(FS_CAPABILITY_CLOSE_INDEX_DIR, fFSOps->close_indexdir); - fCapabilities.Set(FS_CAPABILITY_FREE_INDEX_DIR_COOKIE, - fFSOps->free_indexdircookie); - fCapabilities.Set(FS_CAPABILITY_READ_INDEX_DIR, fFSOps->read_indexdir); - fCapabilities.Set(FS_CAPABILITY_REWIND_INDEX_DIR, fFSOps->rewind_indexdir); - - fCapabilities.Set(FS_CAPABILITY_CREATE_INDEX, fFSOps->create_index); - fCapabilities.Set(FS_CAPABILITY_REMOVE_INDEX, fFSOps->remove_index); - fCapabilities.Set(FS_CAPABILITY_READ_INDEX_STAT, fFSOps->stat_index); - - // query operations - fCapabilities.Set(FS_CAPABILITY_OPEN_QUERY, fFSOps->open_query); - fCapabilities.Set(FS_CAPABILITY_CLOSE_QUERY, fFSOps->close_query); - fCapabilities.Set(FS_CAPABILITY_FREE_QUERY_COOKIE, - fFSOps->free_querycookie); - fCapabilities.Set(FS_CAPABILITY_READ_QUERY, fFSOps->read_query); - // missing: FS_CAPABILITY_REWIND_QUERY, + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ_ATTR_STAT, + fFSOps->stat_attr); + // missing: FS_VNODE_CAPABILITY_WRITE_ATTR_STAT + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_RENAME_ATTR, fFSOps->rename_attr); + fNodeCapabilities.Set(FS_VNODE_CAPABILITY_REMOVE_ATTR, fFSOps->remove_attr); } diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/beos/BeOSKernelFileSystem.h b/src/add-ons/kernel/file_systems/userlandfs/server/beos/BeOSKernelFileSystem.h index a2ef1a208a..3859045478 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/beos/BeOSKernelFileSystem.h +++ b/src/add-ons/kernel/file_systems/userlandfs/server/beos/BeOSKernelFileSystem.h @@ -3,7 +3,7 @@ #ifndef USERLAND_FS_BEOS_KERNEL_FILE_SYSTEM_H #define USERLAND_FS_BEOS_KERNEL_FILE_SYSTEM_H -#include "FileSystem.h" +#include "../FileSystem.h" struct beos_vnode_ops; @@ -17,11 +17,20 @@ public: virtual status_t CreateVolume(Volume** volume, dev_t id); virtual status_t DeleteVolume(Volume* volume); + void GetVolumeCapabilities( + FSVolumeCapabilities& capabilities) const + { capabilities = fVolumeCapabilities; } + void GetNodeCapabilities( + FSVNodeCapabilities& capabilities) const + { capabilities = fNodeCapabilities; } + private: void _InitCapabilities(); private: beos_vnode_ops* fFSOps; + FSVolumeCapabilities fVolumeCapabilities; + FSVNodeCapabilities fNodeCapabilities; }; } // namespace UserlandFS diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/beos/BeOSKernelVolume.cpp b/src/add-ons/kernel/file_systems/userlandfs/server/beos/BeOSKernelVolume.cpp index f286965454..a7d0192d6a 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/beos/BeOSKernelVolume.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/server/beos/BeOSKernelVolume.cpp @@ -9,7 +9,8 @@ #include "beos_fs_interface.h" #include "Debug.h" -#include "kernel_emu.h" + +#include "../kernel_emu.h" using std::nothrow; @@ -114,52 +115,7 @@ BeOSKernelVolume::WriteFSInfo(const struct fs_info* info, uint32 mask) // Lookup status_t -BeOSKernelVolume::Lookup(fs_vnode dir, const char* entryName, ino_t* vnid) -{ - if (!fFSOps->walk) - return B_BAD_VALUE; - - status_t error = fFSOps->walk(fVolumeCookie, dir, entryName, NULL, vnid); - if (error != B_OK) - return error; - - // We need to get the node stat to return the node's type. -// TODO: This is quite expensive. get_vnode() and put_vnode() cause trips to -// the kernel. If it is implemented properly walk() has already called -// get_vnode() for our node. Introducing a mechanism that would allow us to -// temporarily track the {get,put,new}_vnode() calls of our thread would save -// those two kernel trips. - - // get the vnode - fs_vnode node; - error = UserlandFS::KernelEmu::get_vnode(GetID(), *vnid, &node); - if (error != B_OK) { - // walk() has called get_vnode() for the caller, so we need to put the - // node - UserlandFS::KernelEmu::put_vnode(GetID(), *vnid); - return error; - } - - // get the node's stat - struct stat st; - error = ReadStat(node, &st); - if (error == B_OK) - *type = (st.st_mode & S_IFMT); - - // put the node for our get_vnode() - UserlandFS::KernelEmu::put_vnode(GetID(), *vnid); - - // on error put the node for walk()'s get_vnode() - if (error != B_OK) - UserlandFS::KernelEmu::put_vnode(GetID(), *vnid); - - return error; -} - -// LookupNoType -status_t -BeOSKernelVolume::LookupNoType(fs_vnode dir, const char* entryName, - ino_t* vnid) +BeOSKernelVolume::Lookup(void* dir, const char* entryName, ino_t* vnid) { if (!fFSOps->walk) return B_BAD_VALUE; @@ -168,18 +124,35 @@ BeOSKernelVolume::LookupNoType(fs_vnode dir, const char* entryName, // ReadVNode status_t -BeOSKernelVolume::ReadVNode(ino_t vnid, bool reenter, fs_vnode* node, int* type, +BeOSKernelVolume::ReadVNode(ino_t vnid, bool reenter, void** 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); + + // get the node + status_t error = fFSOps->read_vnode(fVolumeCookie, vnid, (char)reenter, + node); + if (error != B_OK) + return error; + + // stat it -- we need to get the node type + struct stat st; + error = ReadStat(node, &st); + if (error != B_OK) { + WriteVNode(node, reenter); + return error; + } + + *type = (st.st_mode & S_IFMT); + *flags = 0; + + return B_OK; } // WriteVNode status_t -BeOSKernelVolume::WriteVNode(fs_vnode node, bool reenter) +BeOSKernelVolume::WriteVNode(void* node, bool reenter) { if (!fFSOps->write_vnode) return B_BAD_VALUE; @@ -188,7 +161,7 @@ BeOSKernelVolume::WriteVNode(fs_vnode node, bool reenter) // RemoveVNode status_t -BeOSKernelVolume::RemoveVNode(fs_vnode node, bool reenter) +BeOSKernelVolume::RemoveVNode(void* node, bool reenter) { if (!fFSOps->remove_vnode) return B_BAD_VALUE; @@ -201,7 +174,7 @@ BeOSKernelVolume::RemoveVNode(fs_vnode node, bool reenter) // IOCtl status_t -BeOSKernelVolume::IOCtl(fs_vnode node, fs_cookie cookie, uint32 command, +BeOSKernelVolume::IOCtl(void* node, void* cookie, uint32 command, void* buffer, size_t size) { if (!fFSOps->ioctl) @@ -212,7 +185,7 @@ BeOSKernelVolume::IOCtl(fs_vnode node, fs_cookie cookie, uint32 command, // SetFlags status_t -BeOSKernelVolume::SetFlags(fs_vnode node, fs_cookie cookie, int flags) +BeOSKernelVolume::SetFlags(void* node, void* cookie, int flags) { if (!fFSOps->setflags) return B_BAD_VALUE; @@ -221,7 +194,7 @@ BeOSKernelVolume::SetFlags(fs_vnode node, fs_cookie cookie, int flags) // Select status_t -BeOSKernelVolume::Select(fs_vnode node, fs_cookie cookie, uint8 event, +BeOSKernelVolume::Select(void* node, void* cookie, uint8 event, selectsync* sync) { if (!fFSOps->select) { @@ -233,7 +206,7 @@ BeOSKernelVolume::Select(fs_vnode node, fs_cookie cookie, uint8 event, // Deselect status_t -BeOSKernelVolume::Deselect(fs_vnode node, fs_cookie cookie, uint8 event, +BeOSKernelVolume::Deselect(void* node, void* cookie, uint8 event, selectsync* sync) { if (!fFSOps->select || !fFSOps->deselect) @@ -243,7 +216,7 @@ BeOSKernelVolume::Deselect(fs_vnode node, fs_cookie cookie, uint8 event, // FSync status_t -BeOSKernelVolume::FSync(fs_vnode node) +BeOSKernelVolume::FSync(void* node) { if (!fFSOps->fsync) return B_BAD_VALUE; @@ -252,7 +225,7 @@ BeOSKernelVolume::FSync(fs_vnode node) // ReadSymlink status_t -BeOSKernelVolume::ReadSymlink(fs_vnode node, char* buffer, size_t bufferSize, +BeOSKernelVolume::ReadSymlink(void* node, char* buffer, size_t bufferSize, size_t* bytesRead) { if (!fFSOps->readlink) @@ -263,7 +236,7 @@ BeOSKernelVolume::ReadSymlink(fs_vnode node, char* buffer, size_t bufferSize, // CreateSymlink status_t -BeOSKernelVolume::CreateSymlink(fs_vnode dir, const char* name, +BeOSKernelVolume::CreateSymlink(void* dir, const char* name, const char* target, int mode) { if (!fFSOps->symlink) @@ -274,7 +247,7 @@ BeOSKernelVolume::CreateSymlink(fs_vnode dir, const char* name, // Link status_t -BeOSKernelVolume::Link(fs_vnode dir, const char* name, fs_vnode node) +BeOSKernelVolume::Link(void* dir, const char* name, void* node) { if (!fFSOps->link) return B_BAD_VALUE; @@ -283,7 +256,7 @@ BeOSKernelVolume::Link(fs_vnode dir, const char* name, fs_vnode node) // Unlink status_t -BeOSKernelVolume::Unlink(fs_vnode dir, const char* name) +BeOSKernelVolume::Unlink(void* dir, const char* name) { if (!fFSOps->unlink) return B_BAD_VALUE; @@ -292,7 +265,7 @@ BeOSKernelVolume::Unlink(fs_vnode dir, const char* name) // Rename status_t -BeOSKernelVolume::Rename(fs_vnode oldDir, const char* oldName, fs_vnode newDir, +BeOSKernelVolume::Rename(void* oldDir, const char* oldName, void* newDir, const char* newName) { if (!fFSOps->rename) @@ -302,7 +275,7 @@ BeOSKernelVolume::Rename(fs_vnode oldDir, const char* oldName, fs_vnode newDir, // Access status_t -BeOSKernelVolume::Access(fs_vnode node, int mode) +BeOSKernelVolume::Access(void* node, int mode) { if (!fFSOps->access) return B_OK; @@ -311,7 +284,7 @@ BeOSKernelVolume::Access(fs_vnode node, int mode) // ReadStat status_t -BeOSKernelVolume::ReadStat(fs_vnode node, struct stat* st) +BeOSKernelVolume::ReadStat(void* node, struct stat* st) { if (!fFSOps->rstat) return B_BAD_VALUE; @@ -323,7 +296,7 @@ BeOSKernelVolume::ReadStat(fs_vnode node, struct stat* st) // WriteStat status_t -BeOSKernelVolume::WriteStat(fs_vnode node, const struct stat *st, uint32 mask) +BeOSKernelVolume::WriteStat(void* node, const struct stat *st, uint32 mask) { if (!fFSOps->wstat) return B_BAD_VALUE; @@ -340,8 +313,8 @@ BeOSKernelVolume::WriteStat(fs_vnode node, const struct stat *st, uint32 mask) // Create status_t -BeOSKernelVolume::Create(fs_vnode dir, const char* name, int openMode, int mode, - fs_cookie* cookie, ino_t* vnid) +BeOSKernelVolume::Create(void* dir, const char* name, int openMode, int mode, + void** cookie, ino_t* vnid) { if (!fFSOps->create) return B_BAD_VALUE; @@ -351,7 +324,7 @@ BeOSKernelVolume::Create(fs_vnode dir, const char* name, int openMode, int mode, // Open status_t -BeOSKernelVolume::Open(fs_vnode node, int openMode, fs_cookie* cookie) +BeOSKernelVolume::Open(void* node, int openMode, void** cookie) { if (!fFSOps->open) return B_BAD_VALUE; @@ -360,7 +333,7 @@ BeOSKernelVolume::Open(fs_vnode node, int openMode, fs_cookie* cookie) // Close status_t -BeOSKernelVolume::Close(fs_vnode node, fs_cookie cookie) +BeOSKernelVolume::Close(void* node, void* cookie) { if (!fFSOps->close) return B_OK; @@ -369,7 +342,7 @@ BeOSKernelVolume::Close(fs_vnode node, fs_cookie cookie) // FreeCookie status_t -BeOSKernelVolume::FreeCookie(fs_vnode node, fs_cookie cookie) +BeOSKernelVolume::FreeCookie(void* node, void* cookie) { if (!fFSOps->free_cookie) return B_OK; @@ -378,7 +351,7 @@ BeOSKernelVolume::FreeCookie(fs_vnode node, fs_cookie cookie) // Read status_t -BeOSKernelVolume::Read(fs_vnode node, fs_cookie cookie, off_t pos, void* buffer, +BeOSKernelVolume::Read(void* node, void* cookie, off_t pos, void* buffer, size_t bufferSize, size_t* bytesRead) { if (!fFSOps->read) @@ -389,7 +362,7 @@ BeOSKernelVolume::Read(fs_vnode node, fs_cookie cookie, off_t pos, void* buffer, // Write status_t -BeOSKernelVolume::Write(fs_vnode node, fs_cookie cookie, off_t pos, +BeOSKernelVolume::Write(void* node, void* cookie, off_t pos, const void* buffer, size_t bufferSize, size_t* bytesWritten) { if (!fFSOps->write) @@ -405,7 +378,7 @@ BeOSKernelVolume::Write(fs_vnode node, fs_cookie cookie, off_t pos, // CreateDir status_t -BeOSKernelVolume::CreateDir(fs_vnode dir, const char* name, int mode, +BeOSKernelVolume::CreateDir(void* dir, const char* name, int mode, ino_t *newDir) { if (!fFSOps->mkdir || !fFSOps->walk) // we need walk() too @@ -430,7 +403,7 @@ BeOSKernelVolume::CreateDir(fs_vnode dir, const char* name, int mode, // RemoveDir status_t -BeOSKernelVolume::RemoveDir(fs_vnode dir, const char* name) +BeOSKernelVolume::RemoveDir(void* dir, const char* name) { if (!fFSOps->rmdir) return B_BAD_VALUE; @@ -439,7 +412,7 @@ BeOSKernelVolume::RemoveDir(fs_vnode dir, const char* name) // OpenDir status_t -BeOSKernelVolume::OpenDir(fs_vnode node, fs_cookie* cookie) +BeOSKernelVolume::OpenDir(void* node, void** cookie) { if (!fFSOps->opendir) return B_BAD_VALUE; @@ -448,7 +421,7 @@ BeOSKernelVolume::OpenDir(fs_vnode node, fs_cookie* cookie) // CloseDir status_t -BeOSKernelVolume::CloseDir(fs_vnode node, fs_vnode cookie) +BeOSKernelVolume::CloseDir(void* node, void* cookie) { if (!fFSOps->closedir) return B_OK; @@ -457,7 +430,7 @@ BeOSKernelVolume::CloseDir(fs_vnode node, fs_vnode cookie) // FreeDirCookie status_t -BeOSKernelVolume::FreeDirCookie(fs_vnode node, fs_vnode cookie) +BeOSKernelVolume::FreeDirCookie(void* node, void* cookie) { if (!fFSOps->free_dircookie) return B_OK; @@ -466,7 +439,7 @@ BeOSKernelVolume::FreeDirCookie(fs_vnode node, fs_vnode cookie) // ReadDir status_t -BeOSKernelVolume::ReadDir(fs_vnode node, fs_vnode cookie, void* buffer, +BeOSKernelVolume::ReadDir(void* node, void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead) { if (!fFSOps->readdir) @@ -481,7 +454,7 @@ BeOSKernelVolume::ReadDir(fs_vnode node, fs_vnode cookie, void* buffer, // RewindDir status_t -BeOSKernelVolume::RewindDir(fs_vnode node, fs_vnode cookie) +BeOSKernelVolume::RewindDir(void* node, void* cookie) { if (!fFSOps->rewinddir) return B_BAD_VALUE; @@ -494,7 +467,7 @@ BeOSKernelVolume::RewindDir(fs_vnode node, fs_vnode cookie) // OpenAttrDir status_t -BeOSKernelVolume::OpenAttrDir(fs_vnode node, fs_cookie *cookie) +BeOSKernelVolume::OpenAttrDir(void* node, void** cookie) { if (!fFSOps->open_attrdir) return B_BAD_VALUE; @@ -503,7 +476,7 @@ BeOSKernelVolume::OpenAttrDir(fs_vnode node, fs_cookie *cookie) // CloseAttrDir status_t -BeOSKernelVolume::CloseAttrDir(fs_vnode node, fs_cookie cookie) +BeOSKernelVolume::CloseAttrDir(void* node, void* cookie) { if (!fFSOps->close_attrdir) return B_OK; @@ -512,7 +485,7 @@ BeOSKernelVolume::CloseAttrDir(fs_vnode node, fs_cookie cookie) // FreeAttrDirCookie status_t -BeOSKernelVolume::FreeAttrDirCookie(fs_vnode node, fs_cookie cookie) +BeOSKernelVolume::FreeAttrDirCookie(void* node, void* cookie) { if (!fFSOps->free_attrdircookie) return B_OK; @@ -521,7 +494,7 @@ BeOSKernelVolume::FreeAttrDirCookie(fs_vnode node, fs_cookie cookie) // ReadAttrDir status_t -BeOSKernelVolume::ReadAttrDir(fs_vnode node, fs_cookie cookie, void* buffer, +BeOSKernelVolume::ReadAttrDir(void* node, void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead) { if (!fFSOps->read_attrdir) @@ -536,7 +509,7 @@ BeOSKernelVolume::ReadAttrDir(fs_vnode node, fs_cookie cookie, void* buffer, // RewindAttrDir status_t -BeOSKernelVolume::RewindAttrDir(fs_vnode node, fs_cookie cookie) +BeOSKernelVolume::RewindAttrDir(void* node, void* cookie) { if (!fFSOps->rewind_attrdir) return B_BAD_VALUE; @@ -549,30 +522,30 @@ BeOSKernelVolume::RewindAttrDir(fs_vnode node, fs_cookie cookie) // CreateAttr status_t -BeOSKernelVolume::CreateAttr(fs_vnode node, const char* name, uint32 type, - int openMode, fs_cookie* cookie) +BeOSKernelVolume::CreateAttr(void* node, const char* name, uint32 type, + int openMode, void** cookie) { return _OpenAttr(node, name, type, openMode, true, cookie); } // OpenAttr status_t -BeOSKernelVolume::OpenAttr(fs_vnode node, const char* name, int openMode, - fs_cookie* cookie) +BeOSKernelVolume::OpenAttr(void* node, const char* name, int openMode, + void** cookie) { return _OpenAttr(node, name, 0, openMode, false, cookie); } // CloseAttr status_t -BeOSKernelVolume::CloseAttr(fs_vnode node, fs_cookie cookie) +BeOSKernelVolume::CloseAttr(void* node, void* cookie) { return B_OK; } // FreeAttrCookie status_t -BeOSKernelVolume::FreeAttrCookie(fs_vnode node, fs_cookie _cookie) +BeOSKernelVolume::FreeAttrCookie(void* node, void* _cookie) { AttributeCookie* cookie = (AttributeCookie*)_cookie; @@ -587,7 +560,7 @@ BeOSKernelVolume::FreeAttrCookie(fs_vnode node, fs_cookie _cookie) // ReadAttr status_t -BeOSKernelVolume::ReadAttr(fs_vnode node, fs_cookie _cookie, off_t pos, +BeOSKernelVolume::ReadAttr(void* node, void* _cookie, off_t pos, void* buffer, size_t bufferSize, size_t* bytesRead) { AttributeCookie* cookie = (AttributeCookie*)_cookie; @@ -607,7 +580,7 @@ BeOSKernelVolume::ReadAttr(fs_vnode node, fs_cookie _cookie, off_t pos, // WriteAttr status_t -BeOSKernelVolume::WriteAttr(fs_vnode node, fs_cookie _cookie, off_t pos, +BeOSKernelVolume::WriteAttr(void* node, void* _cookie, off_t pos, const void* buffer, size_t bufferSize, size_t* bytesWritten) { AttributeCookie* cookie = (AttributeCookie*)_cookie; @@ -627,7 +600,7 @@ BeOSKernelVolume::WriteAttr(fs_vnode node, fs_cookie _cookie, off_t pos, // ReadAttrStat status_t -BeOSKernelVolume::ReadAttrStat(fs_vnode node, fs_cookie _cookie, +BeOSKernelVolume::ReadAttrStat(void* node, void* _cookie, struct stat *st) { AttributeCookie* cookie = (AttributeCookie*)_cookie; @@ -651,8 +624,8 @@ BeOSKernelVolume::ReadAttrStat(fs_vnode node, fs_cookie _cookie, // RenameAttr status_t -BeOSKernelVolume::RenameAttr(fs_vnode oldNode, const char* oldName, - fs_vnode newNode, const char* newName) +BeOSKernelVolume::RenameAttr(void* oldNode, const char* oldName, + void* newNode, const char* newName) { if (!fFSOps->rename_attr) return B_BAD_VALUE; @@ -664,7 +637,7 @@ BeOSKernelVolume::RenameAttr(fs_vnode oldNode, const char* oldName, // RemoveAttr status_t -BeOSKernelVolume::RemoveAttr(fs_vnode node, const char* name) +BeOSKernelVolume::RemoveAttr(void* node, const char* name) { if (!fFSOps->remove_attr) return B_BAD_VALUE; @@ -677,7 +650,7 @@ BeOSKernelVolume::RemoveAttr(fs_vnode node, const char* name) // OpenIndexDir status_t -BeOSKernelVolume::OpenIndexDir(fs_cookie *cookie) +BeOSKernelVolume::OpenIndexDir(void** cookie) { if (!fFSOps->open_indexdir) return B_BAD_VALUE; @@ -686,7 +659,7 @@ BeOSKernelVolume::OpenIndexDir(fs_cookie *cookie) // CloseIndexDir status_t -BeOSKernelVolume::CloseIndexDir(fs_cookie cookie) +BeOSKernelVolume::CloseIndexDir(void* cookie) { if (!fFSOps->close_indexdir) return B_OK; @@ -695,7 +668,7 @@ BeOSKernelVolume::CloseIndexDir(fs_cookie cookie) // FreeIndexDirCookie status_t -BeOSKernelVolume::FreeIndexDirCookie(fs_cookie cookie) +BeOSKernelVolume::FreeIndexDirCookie(void* cookie) { if (!fFSOps->free_indexdircookie) return B_OK; @@ -704,7 +677,7 @@ BeOSKernelVolume::FreeIndexDirCookie(fs_cookie cookie) // ReadIndexDir status_t -BeOSKernelVolume::ReadIndexDir(fs_cookie cookie, void* buffer, +BeOSKernelVolume::ReadIndexDir(void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead) { if (!fFSOps->read_indexdir) @@ -719,7 +692,7 @@ BeOSKernelVolume::ReadIndexDir(fs_cookie cookie, void* buffer, // RewindIndexDir status_t -BeOSKernelVolume::RewindIndexDir(fs_cookie cookie) +BeOSKernelVolume::RewindIndexDir(void* cookie) { if (!fFSOps->rewind_indexdir) return B_BAD_VALUE; @@ -774,7 +747,7 @@ BeOSKernelVolume::ReadIndexStat(const char *name, struct stat *st) // OpenQuery status_t BeOSKernelVolume::OpenQuery(const char* queryString, uint32 flags, port_id port, - uint32 token, fs_cookie *cookie) + uint32 token, void** cookie) { if (!fFSOps->open_query) return B_BAD_VALUE; @@ -784,7 +757,7 @@ BeOSKernelVolume::OpenQuery(const char* queryString, uint32 flags, port_id port, // CloseQuery status_t -BeOSKernelVolume::CloseQuery(fs_cookie cookie) +BeOSKernelVolume::CloseQuery(void* cookie) { if (!fFSOps->close_query) return B_OK; @@ -793,7 +766,7 @@ BeOSKernelVolume::CloseQuery(fs_cookie cookie) // FreeQueryCookie status_t -BeOSKernelVolume::FreeQueryCookie(fs_cookie cookie) +BeOSKernelVolume::FreeQueryCookie(void* cookie) { if (!fFSOps->free_querycookie) return B_OK; @@ -802,7 +775,7 @@ BeOSKernelVolume::FreeQueryCookie(fs_cookie cookie) // ReadQuery status_t -BeOSKernelVolume::ReadQuery(fs_cookie cookie, void* buffer, size_t bufferSize, +BeOSKernelVolume::ReadQuery(void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead) { if (!fFSOps->read_query) @@ -821,8 +794,8 @@ BeOSKernelVolume::ReadQuery(fs_cookie cookie, void* buffer, size_t bufferSize, // _OpenAttr status_t -BeOSKernelVolume::_OpenAttr(fs_vnode node, const char* name, uint32 type, - int openMode, bool create, fs_cookie* _cookie) +BeOSKernelVolume::_OpenAttr(void* node, const char* name, uint32 type, + int openMode, bool create, void** _cookie) { // check permissions first int accessMode = open_mode_to_access(openMode) | (create ? W_OK : 0); diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/beos/BeOSKernelVolume.h b/src/add-ons/kernel/file_systems/userlandfs/server/beos/BeOSKernelVolume.h index 3068e74753..9adb6474d7 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/beos/BeOSKernelVolume.h +++ b/src/add-ons/kernel/file_systems/userlandfs/server/beos/BeOSKernelVolume.h @@ -3,7 +3,7 @@ #ifndef USERLAND_FS_BEOS_KERNEL_VOLUME_H #define USERLAND_FS_BEOS_KERNEL_VOLUME_H -#include "Volume.h" +#include "../Volume.h" struct beos_vnode_ops; @@ -25,110 +25,107 @@ public: uint32 mask); // vnodes - virtual status_t Lookup(fs_vnode dir, const char* entryName, + virtual status_t Lookup(void* dir, const char* entryName, 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, int* type, uint32* flags); - 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, + virtual status_t Select(void* node, void* cookie, uint8 event, selectsync* sync); - virtual status_t Deselect(fs_vnode node, fs_cookie cookie, + 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 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); @@ -138,10 +135,10 @@ 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); @@ -149,9 +146,9 @@ private: class AttributeCookie; private: - status_t _OpenAttr(fs_vnode node, const char* name, + status_t _OpenAttr(void* node, const char* name, uint32 type, int openMode, bool create, - fs_cookie* cookie); + void** cookie); private: beos_vnode_ops* fFSOps; diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/beos/beos_kernel_emu.cpp b/src/add-ons/kernel/file_systems/userlandfs/server/beos/beos_kernel_emu.cpp index 553b1902bd..f70ad7497d 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/beos/beos_kernel_emu.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/server/beos/beos_kernel_emu.cpp @@ -10,10 +10,12 @@ #include #include +#include "Debug.h" + +#include "../kernel_emu.h" + #include "beos_fs_cache.h" #include "beos_lock.h" -#include "Debug.h" -#include "kernel_emu.h" // #pragma mark - Paths @@ -145,7 +147,9 @@ new_vnode(nspace_id nsid, ino_t vnid, void *data) { // The semantics of new_vnode() has changed. The new publish_vnode() // should work like the former new_vnode(). - return UserlandFS::KernelEmu::publish_vnode(nsid, vnid, data); +// TODO: Implement correctly! Get the type! +// return UserlandFS::KernelEmu::publish_vnode(nsid, vnid, data); +return B_BAD_VALUE; } // remove_vnode