i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Adjusted to interface changes in the server. Should be working save for the

Browse Source 
stubbed new_vnode().


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29353 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Ingo Weinhold
2009-02-28 16:00:09 +00:00
parent 3b8f138f43
commit 35d56691a2
5 changed files with 258 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/kernel/file_systems/userlandfs/server/beos/BeOSKernelFileSystem.cpp
+97 -75
View File
@@ -54,108 +54,130 @@ BeOSKernelFileSystem::_InitCapabilities()
fCapabilities.ClearAll(); fCapabilities.ClearAll();
// FS interface type // FS interface type
fCapabilities.clientFSType = CLIENT_FS_BEOS_KERNEL; fClientFSType = CLIENT_FS_BEOS_KERNEL;
// FS operations // FS operations
fCapabilities.Set(FS_CAPABILITY_MOUNT, fFSOps->mount); 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); // Volume operations
fCapabilities.Set(FS_CAPABILITY_SYNC, fFSOps->sync); 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 // vnode operations
fCapabilities.Set(FS_CAPABILITY_LOOKUP, fFSOps->walk); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_LOOKUP, fFSOps->walk);
// missing: FS_CAPABILITY_GET_VNODE_NAME, // missing: FS_VNODE_CAPABILITY_GET_VNODE_NAME,
fCapabilities.Set(FS_CAPABILITY_GET_VNODE, fFSOps->read_vnode); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_PUT_VNODE, fFSOps->write_vnode);
fCapabilities.Set(FS_CAPABILITY_PUT_VNODE, fFSOps->write_vnode); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_REMOVE_VNODE,
fCapabilities.Set(FS_CAPABILITY_REMOVE_VNODE, fFSOps->remove_vnode); fFSOps->remove_vnode);
// VM file access // VM file access
// missing: FS_CAPABILITY_CAN_PAGE, // missing: FS_VNODE_CAPABILITY_CAN_PAGE,
// missing: FS_CAPABILITY_READ_PAGES, // missing: FS_VNODE_CAPABILITY_READ_PAGES,
// missing: FS_CAPABILITY_WRITE_PAGES, // missing: FS_VNODE_CAPABILITY_WRITE_PAGES,
// cache file access // cache file access
// missing: FS_CAPABILITY_GET_FILE_MAP, // missing: FS_VNODE_CAPABILITY_GET_FILE_MAP,
// common operations // common operations
fCapabilities.Set(FS_CAPABILITY_IOCTL, fFSOps->ioctl); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_IOCTL, fFSOps->ioctl);
fCapabilities.Set(FS_CAPABILITY_SET_FLAGS, fFSOps->setflags); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_SET_FLAGS, fFSOps->setflags);
fCapabilities.Set(FS_CAPABILITY_SELECT, fFSOps->select); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_SELECT, fFSOps->select);
fCapabilities.Set(FS_CAPABILITY_DESELECT, fFSOps->deselect); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_DESELECT, fFSOps->deselect);
fCapabilities.Set(FS_CAPABILITY_FSYNC, fFSOps->fsync); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_FSYNC, fFSOps->fsync);
fCapabilities.Set(FS_CAPABILITY_READ_SYMLINK, fFSOps->readlink); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ_SYMLINK, fFSOps->readlink);
fCapabilities.Set(FS_CAPABILITY_CREATE_SYMLINK, fFSOps->symlink); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CREATE_SYMLINK, fFSOps->symlink);
fCapabilities.Set(FS_CAPABILITY_LINK, fFSOps->link); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_LINK, fFSOps->link);
fCapabilities.Set(FS_CAPABILITY_UNLINK, fFSOps->unlink); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_UNLINK, fFSOps->unlink);
fCapabilities.Set(FS_CAPABILITY_RENAME, fFSOps->rename); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_RENAME, fFSOps->rename);
fCapabilities.Set(FS_CAPABILITY_ACCESS, fFSOps->access); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_ACCESS, fFSOps->access);
fCapabilities.Set(FS_CAPABILITY_READ_STAT, fFSOps->rstat); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ_STAT, fFSOps->rstat);
fCapabilities.Set(FS_CAPABILITY_WRITE_STAT, fFSOps->wstat); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_WRITE_STAT, fFSOps->wstat);
// file operations // file operations
fCapabilities.Set(FS_CAPABILITY_CREATE, fFSOps->create); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CREATE, fFSOps->create);
fCapabilities.Set(FS_CAPABILITY_OPEN, fFSOps->open); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_OPEN, fFSOps->open);
fCapabilities.Set(FS_CAPABILITY_CLOSE, fFSOps->close); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CLOSE, fFSOps->close);
fCapabilities.Set(FS_CAPABILITY_FREE_COOKIE, fFSOps->free_cookie); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_FREE_COOKIE, fFSOps->free_cookie);
fCapabilities.Set(FS_CAPABILITY_READ, fFSOps->read); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ, fFSOps->read);
fCapabilities.Set(FS_CAPABILITY_WRITE, fFSOps->write); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_WRITE, fFSOps->write);
// directory operations // directory operations
fCapabilities.Set(FS_CAPABILITY_CREATE_DIR, fFSOps->mkdir); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CREATE_DIR, fFSOps->mkdir);
fCapabilities.Set(FS_CAPABILITY_REMOVE_DIR, fFSOps->rmdir); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_REMOVE_DIR, fFSOps->rmdir);
fCapabilities.Set(FS_CAPABILITY_OPEN_DIR, fFSOps->opendir); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_OPEN_DIR, fFSOps->opendir);
fCapabilities.Set(FS_CAPABILITY_CLOSE_DIR, fFSOps->closedir); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CLOSE_DIR, fFSOps->closedir);
fCapabilities.Set(FS_CAPABILITY_FREE_DIR_COOKIE, fFSOps->free_dircookie); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_FREE_DIR_COOKIE,
fCapabilities.Set(FS_CAPABILITY_READ_DIR, fFSOps->readdir); fFSOps->free_dircookie);
fCapabilities.Set(FS_CAPABILITY_REWIND_DIR, fFSOps->rewinddir); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ_DIR, fFSOps->readdir);
fNodeCapabilities.Set(FS_VNODE_CAPABILITY_REWIND_DIR, fFSOps->rewinddir);
// attribute directory operations // attribute directory operations
fCapabilities.Set(FS_CAPABILITY_OPEN_ATTR_DIR, fFSOps->open_attrdir); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_OPEN_ATTR_DIR,
fCapabilities.Set(FS_CAPABILITY_CLOSE_ATTR_DIR, fFSOps->close_attrdir); fFSOps->open_attrdir);
fCapabilities.Set(FS_CAPABILITY_FREE_ATTR_DIR_COOKIE, fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CLOSE_ATTR_DIR,
fFSOps->close_attrdir);
fNodeCapabilities.Set(FS_VNODE_CAPABILITY_FREE_ATTR_DIR_COOKIE,
fFSOps->free_attrdircookie); fFSOps->free_attrdircookie);
fCapabilities.Set(FS_CAPABILITY_READ_ATTR_DIR, fFSOps->read_attrdir); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ_ATTR_DIR,
fCapabilities.Set(FS_CAPABILITY_REWIND_ATTR_DIR, fFSOps->rewind_attrdir); fFSOps->read_attrdir);
fNodeCapabilities.Set(FS_VNODE_CAPABILITY_REWIND_ATTR_DIR,
fFSOps->rewind_attrdir);
// attribute operations // attribute operations
// we emulate open_attr() and free_attr_dir_cookie() if either read_attr() // we emulate open_attr() and free_attr_dir_cookie() if either read_attr()
// or write_attr() is present // or write_attr() is present
bool hasAttributes = (fFSOps->read_attr || fFSOps->write_attr); bool hasAttributes = (fFSOps->read_attr || fFSOps->write_attr);
fCapabilities.Set(FS_CAPABILITY_CREATE_ATTR, hasAttributes); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CREATE_ATTR, hasAttributes);
fCapabilities.Set(FS_CAPABILITY_OPEN_ATTR, hasAttributes); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_OPEN_ATTR, hasAttributes);
fCapabilities.Set(FS_CAPABILITY_CLOSE_ATTR, false); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_CLOSE_ATTR, false);
fCapabilities.Set(FS_CAPABILITY_FREE_ATTR_COOKIE, hasAttributes); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_FREE_ATTR_COOKIE, hasAttributes);
fCapabilities.Set(FS_CAPABILITY_READ_ATTR, fFSOps->read_attr); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ_ATTR, fFSOps->read_attr);
fCapabilities.Set(FS_CAPABILITY_WRITE_ATTR, fFSOps->write_attr); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_WRITE_ATTR, fFSOps->write_attr);
fCapabilities.Set(FS_CAPABILITY_READ_ATTR_STAT, fFSOps->stat_attr); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_READ_ATTR_STAT,
// missing: FS_CAPABILITY_WRITE_ATTR_STAT fFSOps->stat_attr);
fCapabilities.Set(FS_CAPABILITY_RENAME_ATTR, fFSOps->rename_attr); // missing: FS_VNODE_CAPABILITY_WRITE_ATTR_STAT
fCapabilities.Set(FS_CAPABILITY_REMOVE_ATTR, fFSOps->remove_attr); fNodeCapabilities.Set(FS_VNODE_CAPABILITY_RENAME_ATTR, fFSOps->rename_attr);
fNodeCapabilities.Set(FS_VNODE_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,
} }
src/add-ons/kernel/file_systems/userlandfs/server/beos/BeOSKernelFileSystem.h
+10 -1
View File
@@ -3,7 +3,7 @@
#ifndef USERLAND_FS_BEOS_KERNEL_FILE_SYSTEM_H #ifndef USERLAND_FS_BEOS_KERNEL_FILE_SYSTEM_H
#define 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; struct beos_vnode_ops;
@@ -17,11 +17,20 @@ public:
virtual status_t CreateVolume(Volume** volume, dev_t id); virtual status_t CreateVolume(Volume** volume, dev_t id);
virtual status_t DeleteVolume(Volume* volume); virtual status_t DeleteVolume(Volume* volume);
void GetVolumeCapabilities(
FSVolumeCapabilities& capabilities) const
{ capabilities = fVolumeCapabilities; }
void GetNodeCapabilities(
FSVNodeCapabilities& capabilities) const
{ capabilities = fNodeCapabilities; }
private: private:
void _InitCapabilities(); void _InitCapabilities();
private: private:
beos_vnode_ops* fFSOps; beos_vnode_ops* fFSOps;
FSVolumeCapabilities fVolumeCapabilities;
FSVNodeCapabilities fNodeCapabilities;
}; };
} // namespace UserlandFS } // namespace UserlandFS
src/add-ons/kernel/file_systems/userlandfs/server/beos/BeOSKernelVolume.cpp
+80 -107
View File
@@ -9,7 +9,8 @@
#include "beos_fs_interface.h" #include "beos_fs_interface.h"
#include "Debug.h" #include "Debug.h"
#include "kernel_emu.h"
#include "../kernel_emu.h"
using std::nothrow; using std::nothrow;
@@ -114,52 +115,7 @@ BeOSKernelVolume::WriteFSInfo(const struct fs_info* info, uint32 mask)
// Lookup // Lookup
status_t status_t
BeOSKernelVolume::Lookup(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;
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)
{ {
if (!fFSOps->walk) if (!fFSOps->walk)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -168,18 +124,35 @@ BeOSKernelVolume::LookupNoType(fs_vnode dir, const char* entryName,
// ReadVNode // ReadVNode
status_t 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) uint32* flags)
{ {
#error Return type and flags!
if (!fFSOps->read_vnode) if (!fFSOps->read_vnode)
return B_BAD_VALUE; 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 // WriteVNode
status_t status_t
BeOSKernelVolume::WriteVNode(fs_vnode node, bool reenter) BeOSKernelVolume::WriteVNode(void* node, bool reenter)
{ {
if (!fFSOps->write_vnode) if (!fFSOps->write_vnode)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -188,7 +161,7 @@ BeOSKernelVolume::WriteVNode(fs_vnode node, bool reenter)
// RemoveVNode // RemoveVNode
status_t status_t
BeOSKernelVolume::RemoveVNode(fs_vnode node, bool reenter) BeOSKernelVolume::RemoveVNode(void* node, bool reenter)
{ {
if (!fFSOps->remove_vnode) if (!fFSOps->remove_vnode)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -201,7 +174,7 @@ BeOSKernelVolume::RemoveVNode(fs_vnode node, bool reenter)
// IOCtl // IOCtl
status_t 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) void* buffer, size_t size)
{ {
if (!fFSOps->ioctl) if (!fFSOps->ioctl)
@@ -212,7 +185,7 @@ BeOSKernelVolume::IOCtl(fs_vnode node, fs_cookie cookie, uint32 command,
// SetFlags // SetFlags
status_t status_t
BeOSKernelVolume::SetFlags(fs_vnode node, fs_cookie cookie, int flags) BeOSKernelVolume::SetFlags(void* node, void* cookie, int flags)
{ {
if (!fFSOps->setflags) if (!fFSOps->setflags)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -221,7 +194,7 @@ BeOSKernelVolume::SetFlags(fs_vnode node, fs_cookie cookie, int flags)
// Select // Select
status_t status_t
BeOSKernelVolume::Select(fs_vnode node, fs_cookie cookie, uint8 event, BeOSKernelVolume::Select(void* node, void* cookie, uint8 event,
selectsync* sync) selectsync* sync)
{ {
if (!fFSOps->select) { if (!fFSOps->select) {
@@ -233,7 +206,7 @@ BeOSKernelVolume::Select(fs_vnode node, fs_cookie cookie, uint8 event,
// Deselect // Deselect
status_t status_t
BeOSKernelVolume::Deselect(fs_vnode node, fs_cookie cookie, uint8 event, BeOSKernelVolume::Deselect(void* node, void* cookie, uint8 event,
selectsync* sync) selectsync* sync)
{ {
if (!fFSOps->select || !fFSOps->deselect) if (!fFSOps->select || !fFSOps->deselect)
@@ -243,7 +216,7 @@ BeOSKernelVolume::Deselect(fs_vnode node, fs_cookie cookie, uint8 event,
// FSync // FSync
status_t status_t
BeOSKernelVolume::FSync(fs_vnode node) BeOSKernelVolume::FSync(void* node)
{ {
if (!fFSOps->fsync) if (!fFSOps->fsync)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -252,7 +225,7 @@ BeOSKernelVolume::FSync(fs_vnode node)
// ReadSymlink // ReadSymlink
status_t status_t
BeOSKernelVolume::ReadSymlink(fs_vnode node, char* buffer, size_t bufferSize, BeOSKernelVolume::ReadSymlink(void* node, char* buffer, size_t bufferSize,
size_t* bytesRead) size_t* bytesRead)
{ {
if (!fFSOps->readlink) if (!fFSOps->readlink)
@@ -263,7 +236,7 @@ BeOSKernelVolume::ReadSymlink(fs_vnode node, char* buffer, size_t bufferSize,
// CreateSymlink // CreateSymlink
status_t status_t
BeOSKernelVolume::CreateSymlink(fs_vnode dir, const char* name, BeOSKernelVolume::CreateSymlink(void* dir, const char* name,
const char* target, int mode) const char* target, int mode)
{ {
if (!fFSOps->symlink) if (!fFSOps->symlink)
@@ -274,7 +247,7 @@ BeOSKernelVolume::CreateSymlink(fs_vnode dir, const char* name,
// Link // Link
status_t 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) if (!fFSOps->link)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -283,7 +256,7 @@ BeOSKernelVolume::Link(fs_vnode dir, const char* name, fs_vnode node)
// Unlink // Unlink
status_t status_t
BeOSKernelVolume::Unlink(fs_vnode dir, const char* name) BeOSKernelVolume::Unlink(void* dir, const char* name)
{ {
if (!fFSOps->unlink) if (!fFSOps->unlink)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -292,7 +265,7 @@ BeOSKernelVolume::Unlink(fs_vnode dir, const char* name)
// Rename // Rename
status_t 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) const char* newName)
{ {
if (!fFSOps->rename) if (!fFSOps->rename)
@@ -302,7 +275,7 @@ BeOSKernelVolume::Rename(fs_vnode oldDir, const char* oldName, fs_vnode newDir,
// Access // Access
status_t status_t
BeOSKernelVolume::Access(fs_vnode node, int mode) BeOSKernelVolume::Access(void* node, int mode)
{ {
if (!fFSOps->access) if (!fFSOps->access)
return B_OK; return B_OK;
@@ -311,7 +284,7 @@ BeOSKernelVolume::Access(fs_vnode node, int mode)
// ReadStat // ReadStat
status_t status_t
BeOSKernelVolume::ReadStat(fs_vnode node, struct stat* st) BeOSKernelVolume::ReadStat(void* node, struct stat* st)
{ {
if (!fFSOps->rstat) if (!fFSOps->rstat)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -323,7 +296,7 @@ BeOSKernelVolume::ReadStat(fs_vnode node, struct stat* st)
// WriteStat // WriteStat
status_t 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) if (!fFSOps->wstat)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -340,8 +313,8 @@ BeOSKernelVolume::WriteStat(fs_vnode node, const struct stat *st, uint32 mask)
// Create // Create
status_t status_t
BeOSKernelVolume::Create(fs_vnode dir, const char* name, int openMode, int mode, BeOSKernelVolume::Create(void* dir, const char* name, int openMode, int mode,
fs_cookie* cookie, ino_t* vnid) void** cookie, ino_t* vnid)
{ {
if (!fFSOps->create) if (!fFSOps->create)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -351,7 +324,7 @@ BeOSKernelVolume::Create(fs_vnode dir, const char* name, int openMode, int mode,
// Open // Open
status_t status_t
BeOSKernelVolume::Open(fs_vnode node, int openMode, fs_cookie* cookie) BeOSKernelVolume::Open(void* node, int openMode, void** cookie)
{ {
if (!fFSOps->open) if (!fFSOps->open)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -360,7 +333,7 @@ BeOSKernelVolume::Open(fs_vnode node, int openMode, fs_cookie* cookie)
// Close // Close
status_t status_t
BeOSKernelVolume::Close(fs_vnode node, fs_cookie cookie) BeOSKernelVolume::Close(void* node, void* cookie)
{ {
if (!fFSOps->close) if (!fFSOps->close)
return B_OK; return B_OK;
@@ -369,7 +342,7 @@ BeOSKernelVolume::Close(fs_vnode node, fs_cookie cookie)
// FreeCookie // FreeCookie
status_t status_t
BeOSKernelVolume::FreeCookie(fs_vnode node, fs_cookie cookie) BeOSKernelVolume::FreeCookie(void* node, void* cookie)
{ {
if (!fFSOps->free_cookie) if (!fFSOps->free_cookie)
return B_OK; return B_OK;
@@ -378,7 +351,7 @@ BeOSKernelVolume::FreeCookie(fs_vnode node, fs_cookie cookie)
// Read // Read
status_t 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) size_t bufferSize, size_t* bytesRead)
{ {
if (!fFSOps->read) if (!fFSOps->read)
@@ -389,7 +362,7 @@ BeOSKernelVolume::Read(fs_vnode node, fs_cookie cookie, off_t pos, void* buffer,
// Write // Write
status_t 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) const void* buffer, size_t bufferSize, size_t* bytesWritten)
{ {
if (!fFSOps->write) if (!fFSOps->write)
@@ -405,7 +378,7 @@ BeOSKernelVolume::Write(fs_vnode node, fs_cookie cookie, off_t pos,
// CreateDir // CreateDir
status_t status_t
BeOSKernelVolume::CreateDir(fs_vnode dir, const char* name, int mode, BeOSKernelVolume::CreateDir(void* dir, const char* name, int mode,
ino_t *newDir) ino_t *newDir)
{ {
if (!fFSOps->mkdir || !fFSOps->walk) // we need walk() too if (!fFSOps->mkdir || !fFSOps->walk) // we need walk() too
@@ -430,7 +403,7 @@ BeOSKernelVolume::CreateDir(fs_vnode dir, const char* name, int mode,
// RemoveDir // RemoveDir
status_t status_t
BeOSKernelVolume::RemoveDir(fs_vnode dir, const char* name) BeOSKernelVolume::RemoveDir(void* dir, const char* name)
{ {
if (!fFSOps->rmdir) if (!fFSOps->rmdir)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -439,7 +412,7 @@ BeOSKernelVolume::RemoveDir(fs_vnode dir, const char* name)
// OpenDir // OpenDir
status_t status_t
BeOSKernelVolume::OpenDir(fs_vnode node, fs_cookie* cookie) BeOSKernelVolume::OpenDir(void* node, void** cookie)
{ {
if (!fFSOps->opendir) if (!fFSOps->opendir)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -448,7 +421,7 @@ BeOSKernelVolume::OpenDir(fs_vnode node, fs_cookie* cookie)
// CloseDir // CloseDir
status_t status_t
BeOSKernelVolume::CloseDir(fs_vnode node, fs_vnode cookie) BeOSKernelVolume::CloseDir(void* node, void* cookie)
{ {
if (!fFSOps->closedir) if (!fFSOps->closedir)
return B_OK; return B_OK;
@@ -457,7 +430,7 @@ BeOSKernelVolume::CloseDir(fs_vnode node, fs_vnode cookie)
// FreeDirCookie // FreeDirCookie
status_t status_t
BeOSKernelVolume::FreeDirCookie(fs_vnode node, fs_vnode cookie) BeOSKernelVolume::FreeDirCookie(void* node, void* cookie)
{ {
if (!fFSOps->free_dircookie) if (!fFSOps->free_dircookie)
return B_OK; return B_OK;
@@ -466,7 +439,7 @@ BeOSKernelVolume::FreeDirCookie(fs_vnode node, fs_vnode cookie)
// ReadDir // ReadDir
status_t 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) size_t bufferSize, uint32 count, uint32* countRead)
{ {
if (!fFSOps->readdir) if (!fFSOps->readdir)
@@ -481,7 +454,7 @@ BeOSKernelVolume::ReadDir(fs_vnode node, fs_vnode cookie, void* buffer,
// RewindDir // RewindDir
status_t status_t
BeOSKernelVolume::RewindDir(fs_vnode node, fs_vnode cookie) BeOSKernelVolume::RewindDir(void* node, void* cookie)
{ {
if (!fFSOps->rewinddir) if (!fFSOps->rewinddir)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -494,7 +467,7 @@ BeOSKernelVolume::RewindDir(fs_vnode node, fs_vnode cookie)
// OpenAttrDir // OpenAttrDir
status_t status_t
BeOSKernelVolume::OpenAttrDir(fs_vnode node, fs_cookie *cookie) BeOSKernelVolume::OpenAttrDir(void* node, void** cookie)
{ {
if (!fFSOps->open_attrdir) if (!fFSOps->open_attrdir)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -503,7 +476,7 @@ BeOSKernelVolume::OpenAttrDir(fs_vnode node, fs_cookie *cookie)
// CloseAttrDir // CloseAttrDir
status_t status_t
BeOSKernelVolume::CloseAttrDir(fs_vnode node, fs_cookie cookie) BeOSKernelVolume::CloseAttrDir(void* node, void* cookie)
{ {
if (!fFSOps->close_attrdir) if (!fFSOps->close_attrdir)
return B_OK; return B_OK;
@@ -512,7 +485,7 @@ BeOSKernelVolume::CloseAttrDir(fs_vnode node, fs_cookie cookie)
// FreeAttrDirCookie // FreeAttrDirCookie
status_t status_t
BeOSKernelVolume::FreeAttrDirCookie(fs_vnode node, fs_cookie cookie) BeOSKernelVolume::FreeAttrDirCookie(void* node, void* cookie)
{ {
if (!fFSOps->free_attrdircookie) if (!fFSOps->free_attrdircookie)
return B_OK; return B_OK;
@@ -521,7 +494,7 @@ BeOSKernelVolume::FreeAttrDirCookie(fs_vnode node, fs_cookie cookie)
// ReadAttrDir // ReadAttrDir
status_t 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) size_t bufferSize, uint32 count, uint32* countRead)
{ {
if (!fFSOps->read_attrdir) if (!fFSOps->read_attrdir)
@@ -536,7 +509,7 @@ BeOSKernelVolume::ReadAttrDir(fs_vnode node, fs_cookie cookie, void* buffer,
// RewindAttrDir // RewindAttrDir
status_t status_t
BeOSKernelVolume::RewindAttrDir(fs_vnode node, fs_cookie cookie) BeOSKernelVolume::RewindAttrDir(void* node, void* cookie)
{ {
if (!fFSOps->rewind_attrdir) if (!fFSOps->rewind_attrdir)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -549,30 +522,30 @@ BeOSKernelVolume::RewindAttrDir(fs_vnode node, fs_cookie cookie)
// CreateAttr // CreateAttr
status_t status_t
BeOSKernelVolume::CreateAttr(fs_vnode node, const char* name, uint32 type, BeOSKernelVolume::CreateAttr(void* node, const char* name, uint32 type,
int openMode, fs_cookie* cookie) int openMode, void** cookie)
{ {
return _OpenAttr(node, name, type, openMode, true, cookie); return _OpenAttr(node, name, type, openMode, true, cookie);
} }
// OpenAttr // OpenAttr
status_t status_t
BeOSKernelVolume::OpenAttr(fs_vnode node, const char* name, int openMode, BeOSKernelVolume::OpenAttr(void* node, const char* name, int openMode,
fs_cookie* cookie) void** cookie)
{ {
return _OpenAttr(node, name, 0, openMode, false, cookie); return _OpenAttr(node, name, 0, openMode, false, cookie);
} }
// CloseAttr // CloseAttr
status_t status_t
BeOSKernelVolume::CloseAttr(fs_vnode node, fs_cookie cookie) BeOSKernelVolume::CloseAttr(void* node, void* cookie)
{ {
return B_OK; return B_OK;
} }
// FreeAttrCookie // FreeAttrCookie
status_t status_t
BeOSKernelVolume::FreeAttrCookie(fs_vnode node, fs_cookie _cookie) BeOSKernelVolume::FreeAttrCookie(void* node, void* _cookie)
{ {
AttributeCookie* cookie = (AttributeCookie*)_cookie; AttributeCookie* cookie = (AttributeCookie*)_cookie;
@@ -587,7 +560,7 @@ BeOSKernelVolume::FreeAttrCookie(fs_vnode node, fs_cookie _cookie)
// ReadAttr // ReadAttr
status_t 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) void* buffer, size_t bufferSize, size_t* bytesRead)
{ {
AttributeCookie* cookie = (AttributeCookie*)_cookie; AttributeCookie* cookie = (AttributeCookie*)_cookie;
@@ -607,7 +580,7 @@ BeOSKernelVolume::ReadAttr(fs_vnode node, fs_cookie _cookie, off_t pos,
// WriteAttr // WriteAttr
status_t 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) const void* buffer, size_t bufferSize, size_t* bytesWritten)
{ {
AttributeCookie* cookie = (AttributeCookie*)_cookie; AttributeCookie* cookie = (AttributeCookie*)_cookie;
@@ -627,7 +600,7 @@ BeOSKernelVolume::WriteAttr(fs_vnode node, fs_cookie _cookie, off_t pos,
// ReadAttrStat // ReadAttrStat
status_t status_t
BeOSKernelVolume::ReadAttrStat(fs_vnode node, fs_cookie _cookie, BeOSKernelVolume::ReadAttrStat(void* node, void* _cookie,
struct stat *st) struct stat *st)
{ {
AttributeCookie* cookie = (AttributeCookie*)_cookie; AttributeCookie* cookie = (AttributeCookie*)_cookie;
@@ -651,8 +624,8 @@ BeOSKernelVolume::ReadAttrStat(fs_vnode node, fs_cookie _cookie,
// RenameAttr // RenameAttr
status_t status_t
BeOSKernelVolume::RenameAttr(fs_vnode oldNode, const char* oldName, BeOSKernelVolume::RenameAttr(void* oldNode, const char* oldName,
fs_vnode newNode, const char* newName) void* newNode, const char* newName)
{ {
if (!fFSOps->rename_attr) if (!fFSOps->rename_attr)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -664,7 +637,7 @@ BeOSKernelVolume::RenameAttr(fs_vnode oldNode, const char* oldName,
// RemoveAttr // RemoveAttr
status_t status_t
BeOSKernelVolume::RemoveAttr(fs_vnode node, const char* name) BeOSKernelVolume::RemoveAttr(void* node, const char* name)
{ {
if (!fFSOps->remove_attr) if (!fFSOps->remove_attr)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -677,7 +650,7 @@ BeOSKernelVolume::RemoveAttr(fs_vnode node, const char* name)
// OpenIndexDir // OpenIndexDir
status_t status_t
BeOSKernelVolume::OpenIndexDir(fs_cookie *cookie) BeOSKernelVolume::OpenIndexDir(void** cookie)
{ {
if (!fFSOps->open_indexdir) if (!fFSOps->open_indexdir)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -686,7 +659,7 @@ BeOSKernelVolume::OpenIndexDir(fs_cookie *cookie)
// CloseIndexDir // CloseIndexDir
status_t status_t
BeOSKernelVolume::CloseIndexDir(fs_cookie cookie) BeOSKernelVolume::CloseIndexDir(void* cookie)
{ {
if (!fFSOps->close_indexdir) if (!fFSOps->close_indexdir)
return B_OK; return B_OK;
@@ -695,7 +668,7 @@ BeOSKernelVolume::CloseIndexDir(fs_cookie cookie)
// FreeIndexDirCookie // FreeIndexDirCookie
status_t status_t
BeOSKernelVolume::FreeIndexDirCookie(fs_cookie cookie) BeOSKernelVolume::FreeIndexDirCookie(void* cookie)
{ {
if (!fFSOps->free_indexdircookie) if (!fFSOps->free_indexdircookie)
return B_OK; return B_OK;
@@ -704,7 +677,7 @@ BeOSKernelVolume::FreeIndexDirCookie(fs_cookie cookie)
// ReadIndexDir // ReadIndexDir
status_t status_t
BeOSKernelVolume::ReadIndexDir(fs_cookie cookie, void* buffer, BeOSKernelVolume::ReadIndexDir(void* cookie, void* buffer,
size_t bufferSize, uint32 count, uint32* countRead) size_t bufferSize, uint32 count, uint32* countRead)
{ {
if (!fFSOps->read_indexdir) if (!fFSOps->read_indexdir)
@@ -719,7 +692,7 @@ BeOSKernelVolume::ReadIndexDir(fs_cookie cookie, void* buffer,
// RewindIndexDir // RewindIndexDir
status_t status_t
BeOSKernelVolume::RewindIndexDir(fs_cookie cookie) BeOSKernelVolume::RewindIndexDir(void* cookie)
{ {
if (!fFSOps->rewind_indexdir) if (!fFSOps->rewind_indexdir)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -774,7 +747,7 @@ BeOSKernelVolume::ReadIndexStat(const char *name, struct stat *st)
// OpenQuery // OpenQuery
status_t status_t
BeOSKernelVolume::OpenQuery(const char* queryString, uint32 flags, port_id port, BeOSKernelVolume::OpenQuery(const char* queryString, uint32 flags, port_id port,
uint32 token, fs_cookie *cookie) uint32 token, void** cookie)
{ {
if (!fFSOps->open_query) if (!fFSOps->open_query)
return B_BAD_VALUE; return B_BAD_VALUE;
@@ -784,7 +757,7 @@ BeOSKernelVolume::OpenQuery(const char* queryString, uint32 flags, port_id port,
// CloseQuery // CloseQuery
status_t status_t
BeOSKernelVolume::CloseQuery(fs_cookie cookie) BeOSKernelVolume::CloseQuery(void* cookie)
{ {
if (!fFSOps->close_query) if (!fFSOps->close_query)
return B_OK; return B_OK;
@@ -793,7 +766,7 @@ BeOSKernelVolume::CloseQuery(fs_cookie cookie)
// FreeQueryCookie // FreeQueryCookie
status_t status_t
BeOSKernelVolume::FreeQueryCookie(fs_cookie cookie) BeOSKernelVolume::FreeQueryCookie(void* cookie)
{ {
if (!fFSOps->free_querycookie) if (!fFSOps->free_querycookie)
return B_OK; return B_OK;
@@ -802,7 +775,7 @@ BeOSKernelVolume::FreeQueryCookie(fs_cookie cookie)
// ReadQuery // ReadQuery
status_t 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) uint32 count, uint32* countRead)
{ {
if (!fFSOps->read_query) if (!fFSOps->read_query)
@@ -821,8 +794,8 @@ BeOSKernelVolume::ReadQuery(fs_cookie cookie, void* buffer, size_t bufferSize,
// _OpenAttr // _OpenAttr
status_t status_t
BeOSKernelVolume::_OpenAttr(fs_vnode node, const char* name, uint32 type, BeOSKernelVolume::_OpenAttr(void* node, const char* name, uint32 type,
int openMode, bool create, fs_cookie* _cookie) int openMode, bool create, void** _cookie)
{ {
// check permissions first // check permissions first
int accessMode = open_mode_to_access(openMode) | (create ? W_OK : 0); int accessMode = open_mode_to_access(openMode) | (create ? W_OK : 0);
src/add-ons/kernel/file_systems/userlandfs/server/beos/BeOSKernelVolume.h
+64 -67
View File
@@ -3,7 +3,7 @@
#ifndef USERLAND_FS_BEOS_KERNEL_VOLUME_H #ifndef USERLAND_FS_BEOS_KERNEL_VOLUME_H
#define USERLAND_FS_BEOS_KERNEL_VOLUME_H #define USERLAND_FS_BEOS_KERNEL_VOLUME_H
#include "Volume.h" #include "../Volume.h"
struct beos_vnode_ops; struct beos_vnode_ops;
@@ -25,110 +25,107 @@ public:
uint32 mask); uint32 mask);
// vnodes // vnodes
virtual status_t Lookup(fs_vnode dir, const char* entryName, virtual status_t Lookup(void* dir, const char* entryName,
ino_t* vnid); 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, virtual status_t ReadVNode(ino_t vnid, bool reenter,
fs_vnode* node, int* type, uint32* flags); void** node, int* type, uint32* flags);
virtual status_t WriteVNode(fs_vnode node, bool reenter); virtual status_t WriteVNode(void* node, bool reenter);
virtual status_t RemoveVNode(fs_vnode node, bool reenter); virtual status_t RemoveVNode(void* node, bool reenter);
// nodes // 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); 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); int flags);
virtual status_t Select(fs_vnode node, fs_cookie cookie, virtual status_t Select(void* node, void* cookie,
uint8 event, selectsync* sync); 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); 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); 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); const char* target, int mode);
virtual status_t Link(fs_vnode dir, const char* name, virtual status_t Link(void* dir, const char* name,
fs_vnode node); void* node);
virtual status_t Unlink(fs_vnode dir, const char* name); virtual status_t Unlink(void* dir, const char* name);
virtual status_t Rename(fs_vnode oldDir, const char* oldName, virtual status_t Rename(void* oldDir, const char* oldName,
fs_vnode newDir, const char* newName); void* newDir, const char* newName);
virtual status_t Access(fs_vnode node, int mode); virtual status_t Access(void* node, int mode);
virtual status_t ReadStat(fs_vnode node, struct stat* st); virtual status_t ReadStat(void* node, struct stat* st);
virtual status_t WriteStat(fs_vnode node, const struct stat *st, virtual status_t WriteStat(void* node, const struct stat *st,
uint32 mask); uint32 mask);
// files // files
virtual status_t Create(fs_vnode dir, const char* name, virtual status_t Create(void* dir, const char* name,
int openMode, int mode, fs_cookie* cookie, int openMode, int mode, void** cookie,
ino_t* vnid); ino_t* vnid);
virtual status_t Open(fs_vnode node, int openMode, virtual status_t Open(void* node, int openMode,
fs_cookie* cookie); void** cookie);
virtual status_t Close(fs_vnode node, fs_cookie cookie); virtual status_t Close(void* node, void* cookie);
virtual status_t FreeCookie(fs_vnode node, fs_cookie cookie); virtual status_t FreeCookie(void* node, void* cookie);
virtual status_t Read(fs_vnode node, fs_cookie cookie, off_t pos, virtual status_t Read(void* node, void* cookie, off_t pos,
void* buffer, size_t bufferSize, void* buffer, size_t bufferSize,
size_t* bytesRead); 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, off_t pos, const void* buffer,
size_t bufferSize, size_t* bytesWritten); size_t bufferSize, size_t* bytesWritten);
// directories // 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); int mode, ino_t *newDir);
virtual status_t RemoveDir(fs_vnode dir, const char* name); virtual status_t RemoveDir(void* dir, const char* name);
virtual status_t OpenDir(fs_vnode node, fs_cookie* cookie); virtual status_t OpenDir(void* node, void** cookie);
virtual status_t CloseDir(fs_vnode node, fs_vnode cookie); virtual status_t CloseDir(void* node, void* cookie);
virtual status_t FreeDirCookie(fs_vnode node, fs_vnode cookie); virtual status_t FreeDirCookie(void* node, void* cookie);
virtual status_t ReadDir(fs_vnode node, fs_vnode cookie, virtual status_t ReadDir(void* node, void* cookie,
void* buffer, size_t bufferSize, void* buffer, size_t bufferSize,
uint32 count, uint32* countRead); uint32 count, uint32* countRead);
virtual status_t RewindDir(fs_vnode node, fs_vnode cookie); virtual status_t RewindDir(void* node, void* cookie);
// attribute directories // attribute directories
virtual status_t OpenAttrDir(fs_vnode node, fs_cookie *cookie); virtual status_t OpenAttrDir(void* node, void** cookie);
virtual status_t CloseAttrDir(fs_vnode node, fs_cookie cookie); virtual status_t CloseAttrDir(void* node, void* cookie);
virtual status_t FreeAttrDirCookie(fs_vnode node, virtual status_t FreeAttrDirCookie(void* node,
fs_cookie cookie); void* cookie);
virtual status_t ReadAttrDir(fs_vnode node, fs_cookie cookie, virtual status_t ReadAttrDir(void* node, void* cookie,
void* buffer, size_t bufferSize, void* buffer, size_t bufferSize,
uint32 count, uint32* countRead); uint32 count, uint32* countRead);
virtual status_t RewindAttrDir(fs_vnode node, fs_cookie cookie); virtual status_t RewindAttrDir(void* node, void* cookie);
// attributes // attributes
virtual status_t CreateAttr(fs_vnode node, const char *name, virtual status_t CreateAttr(void* node, const char *name,
uint32 type, int openMode, uint32 type, int openMode,
fs_cookie *cookie); void** cookie);
virtual status_t OpenAttr(fs_vnode node, const char *name, virtual status_t OpenAttr(void* node, const char *name,
int openMode, fs_cookie *cookie); int openMode, void** cookie);
virtual status_t CloseAttr(fs_vnode node, fs_cookie cookie); virtual status_t CloseAttr(void* node, void* cookie);
virtual status_t FreeAttrCookie(fs_vnode node, fs_cookie cookie); virtual status_t FreeAttrCookie(void* node, void* cookie);
virtual status_t ReadAttr(fs_vnode node, fs_cookie cookie, virtual status_t ReadAttr(void* node, void* cookie,
off_t pos, void* buffer, size_t bufferSize, off_t pos, void* buffer, size_t bufferSize,
size_t* bytesRead); 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, off_t pos, const void* buffer,
size_t bufferSize, size_t* bytesWritten); 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); struct stat *st);
virtual status_t RenameAttr(fs_vnode oldNode, virtual status_t RenameAttr(void* oldNode,
const char* oldName, fs_vnode newNode, const char* oldName, void* newNode,
const char* newName); const char* newName);
virtual status_t RemoveAttr(fs_vnode node, const char* name); virtual status_t RemoveAttr(void* node, const char* name);
// indices // indices
virtual status_t OpenIndexDir(fs_cookie *cookie); virtual status_t OpenIndexDir(void** cookie);
virtual status_t CloseIndexDir(fs_cookie cookie); virtual status_t CloseIndexDir(void* cookie);
virtual status_t FreeIndexDirCookie(fs_cookie cookie); virtual status_t FreeIndexDirCookie(void* cookie);
virtual status_t ReadIndexDir(fs_cookie cookie, void* buffer, virtual status_t ReadIndexDir(void* cookie, void* buffer,
size_t bufferSize, uint32 count, size_t bufferSize, uint32 count,
uint32* countRead); uint32* countRead);
virtual status_t RewindIndexDir(fs_cookie cookie); virtual status_t RewindIndexDir(void* cookie);
virtual status_t CreateIndex(const char* name, uint32 type, virtual status_t CreateIndex(const char* name, uint32 type,
uint32 flags); uint32 flags);
virtual status_t RemoveIndex(const char* name); virtual status_t RemoveIndex(const char* name);
@@ -138,10 +135,10 @@ public:
// queries // queries
virtual status_t OpenQuery(const char* queryString, virtual status_t OpenQuery(const char* queryString,
uint32 flags, port_id port, uint32 token, uint32 flags, port_id port, uint32 token,
fs_cookie *cookie); void** cookie);
virtual status_t CloseQuery(fs_cookie cookie); virtual status_t CloseQuery(void* cookie);
virtual status_t FreeQueryCookie(fs_cookie cookie); virtual status_t FreeQueryCookie(void* cookie);
virtual status_t ReadQuery(fs_cookie cookie, void* buffer, virtual status_t ReadQuery(void* cookie, void* buffer,
size_t bufferSize, uint32 count, size_t bufferSize, uint32 count,
uint32* countRead); uint32* countRead);
@@ -149,9 +146,9 @@ private:
class AttributeCookie; class AttributeCookie;
private: private:
status_t _OpenAttr(fs_vnode node, const char* name, status_t _OpenAttr(void* node, const char* name,
uint32 type, int openMode, bool create, uint32 type, int openMode, bool create,
fs_cookie* cookie); void** cookie);
private: private:
beos_vnode_ops* fFSOps; beos_vnode_ops* fFSOps;
src/add-ons/kernel/file_systems/userlandfs/server/beos/beos_kernel_emu.cpp
+7 -3
View File
@@ -10,10 +10,12 @@
#include <legacy/fsproto.h> #include <legacy/fsproto.h>
#include <legacy/lock.h> #include <legacy/lock.h>
#include "Debug.h"
#include "../kernel_emu.h"
#include "beos_fs_cache.h" #include "beos_fs_cache.h"
#include "beos_lock.h" #include "beos_lock.h"
#include "Debug.h"
#include "kernel_emu.h"
// #pragma mark - Paths // #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() // The semantics of new_vnode() has changed. The new publish_vnode()
// should work like the former new_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 // remove_vnode