Aren
/
haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Some more work towards adjusting the UserlandFS to the current FS interface: 

* Split the FSCapabilities bit mask into three bit masks for the FS, the
  volume, and the vnodes, since we have three independent FS interface
  structures, now. The latter is not supported in the kernel add-on, yet.
* Server:
  - Temporarily removed some things from the build (the BeOS interface
    and the cache implementations).
  - Some WIP in HaikuKernelVolume and [haiku_]kernel_emu.{h,cpp}.
  - Added HaikuKernelNode, which wraps fs_vnode for the client FS.
  The server is still quite a bit away from being buildable again.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29323 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Ingo Weinhold 2009-02-26 00:09:43 +00:00
parent 346ae57c93
commit cdebdeb0aa
21 changed files with 997 additions and 684 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

247
headers/private/userlandfs/private/FSCapabilities.h
View File

@ -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<const int CapabilityCount>
struct FSCapabilitiesBase {
uint8 capabilities[(CapabilityCount + 7) / 8];
inline void ClearAll();
@ -131,17 +157,19 @@ struct FSCapabilities {
};
// ClearAll
template<const int CapabilityCount>
inline void
FSCapabilities::ClearAll()
FSCapabilitiesBase<CapabilityCount>::ClearAll()
{
memset(capabilities, 0, sizeof(capabilities));
}
// Set
template<const int CapabilityCount>
inline void
FSCapabilities::Set(uint32 capability, bool set)
FSCapabilitiesBase<CapabilityCount>::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<const int CapabilityCount>
inline void
FSCapabilities::Clear(uint32 capability)
FSCapabilitiesBase<CapabilityCount>::Clear(uint32 capability)
{
Set(capability, false);
}
// Get
template<const int CapabilityCount>
inline bool
FSCapabilities::Get(uint32 capability) const
FSCapabilitiesBase<CapabilityCount>::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<const int CapabilityCount>
inline void
FSCapabilities::Dump() const
FSCapabilitiesBase<CapabilityCount>::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<FS_CAPABILITY_COUNT> FSCapabilities;
typedef FSCapabilitiesBase<FS_VOLUME_CAPABILITY_COUNT> FSVolumeCapabilities;
typedef FSCapabilitiesBase<FS_VNODE_CAPABILITY_COUNT> FSVNodeCapabilities;
} // namespace UserlandFSUtil
using UserlandFSUtil::FSCapabilities;

6
headers/private/userlandfs/private/Requests.h
View File

@ -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

115
src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.cpp
View File

@ -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

22
src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.h
View File

@ -7,6 +7,7 @@
#include <fs_interface.h>
#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

2
src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/kernel_interface.cpp
View File

@ -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

17
src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelVolume.cpp
View File

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

6
src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelVolume.h
View File

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

33
src/add-ons/kernel/file_systems/userlandfs/server/FSInfo.h
View File

@ -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

3
src/add-ons/kernel/file_systems/userlandfs/server/FileSystem.h
View File

@ -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

100
src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelFileSystem.cpp
View File

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

41
src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelNode.h Normal file
View File

@ -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 <fs_interface.h>
#include <SupportDefs.h>
#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<HaikuKernelNode*>(node);
}
} // namespace UserlandFS
using UserlandFS::HaikuKernelNode;
#endif // USERLAND_FS_NODE_H

515
src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelVolume.cpp
View File

File diff suppressed because it is too large Load Diff

173
src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelVolume.h
View File

@ -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 <fs_interface.h>
@ -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<const FSVolume*>(volume)->haikuVolume;
}
} // namespace UserlandFS
using UserlandFS::HaikuKernelVolume;
#endif // USERLAND_FS_BEOS_KERNEL_VOLUME_H
#endif // USERLAND_FS_HAIKU_KERNEL_VOLUME_H

12
src/add-ons/kernel/file_systems/userlandfs/server/Jamfile
View File

@ -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

1
src/add-ons/kernel/file_systems/userlandfs/server/UserlandFSDispatcher.cpp
View File

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

4
src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.cpp
View File

@ -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

126
src/add-ons/kernel/file_systems/userlandfs/server/Volume.cpp
View File

@ -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;
}

143
src/add-ons/kernel/file_systems/userlandfs/server/Volume.h
View File

@ -6,10 +6,14 @@
#include <fs_interface.h>
#include <SupportDefs.h>
#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

94
src/add-ons/kernel/file_systems/userlandfs/server/haiku_kernel_emu.cpp
View File

@ -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();
}

12
src/add-ons/kernel/file_systems/userlandfs/server/kernel_emu.cpp
View File

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

9
src/add-ons/kernel/file_systems/userlandfs/server/kernel_emu.h
View File

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