diff --git a/headers/private/userlandfs/private/Requests.h b/headers/private/userlandfs/private/Requests.h index b21c558c72..d89749c4c2 100644 --- a/headers/private/userlandfs/private/Requests.h +++ b/headers/private/userlandfs/private/Requests.h @@ -1,5 +1,7 @@ -// Requests.h - +/* + * Copyright 2001-2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ #ifndef USERLAND_FS_REQUESTS_H #define USERLAND_FS_REQUESTS_H @@ -227,7 +229,7 @@ class VolumeRequest : public Request { public: VolumeRequest(uint32 type) : Request(type) {} - fs_volume volume; + void* volume; }; // NodeRequest @@ -235,7 +237,7 @@ class NodeRequest : public VolumeRequest { public: NodeRequest(uint32 type) : VolumeRequest(type) {} - fs_vnode node; + void* node; }; // FileRequest @@ -243,7 +245,7 @@ class FileRequest : public NodeRequest { public: FileRequest(uint32 type) : NodeRequest(type) {} - fs_cookie fileCookie; + void* fileCookie; }; // DirRequest @@ -251,7 +253,7 @@ class DirRequest : public NodeRequest { public: DirRequest(uint32 type) : NodeRequest(type) {} - fs_cookie dirCookie; + void* dirCookie; }; // AttrDirRequest @@ -259,7 +261,7 @@ class AttrDirRequest : public NodeRequest { public: AttrDirRequest(uint32 type) : NodeRequest(type) {} - fs_cookie attrDirCookie; + void* attrDirCookie; }; // AttributeRequest @@ -267,7 +269,7 @@ class AttributeRequest : public NodeRequest { public: AttributeRequest(uint32 type) : NodeRequest(type) {} - fs_cookie attrCookie; + void* attrCookie; }; // IndexDirRequest @@ -275,7 +277,7 @@ class IndexDirRequest : public VolumeRequest { public: IndexDirRequest(uint32 type) : VolumeRequest(type) {} - fs_cookie indexDirCookie; + void* indexDirCookie; }; // QueryRequest @@ -283,7 +285,7 @@ class QueryRequest : public VolumeRequest { public: QueryRequest(uint32 type) : VolumeRequest(type) {} - fs_cookie queryCookie; + void* queryCookie; }; @@ -339,7 +341,7 @@ public: MountVolumeReply() : ReplyRequest(MOUNT_VOLUME_REPLY) {} ino_t rootID; - fs_volume volume; + void* volume; }; // UnmountVolumeRequest @@ -431,7 +433,6 @@ public: LookupReply() : ReplyRequest(LOOKUP_REPLY) {} ino_t vnid; - int type; }; // GetVNodeNameRequest @@ -465,7 +466,9 @@ class ReadVNodeReply : public ReplyRequest { public: ReadVNodeReply() : ReplyRequest(READ_VNODE_REPLY) {} - fs_vnode node; + void* node; + int type; + uint32 flags; }; // WriteVNodeRequest @@ -625,7 +628,7 @@ public: status_t GetAddressInfos(AddressInfo* infos, int32* count); Address name; - fs_vnode target; + void* target; }; // LinkReply @@ -655,9 +658,9 @@ public: RenameRequest() : VolumeRequest(RENAME_REQUEST) {} status_t GetAddressInfos(AddressInfo* infos, int32* count); - fs_vnode oldDir; + void* oldDir; Address oldName; - fs_vnode newDir; + void* newDir; Address newName; }; @@ -731,7 +734,7 @@ public: CreateReply() : ReplyRequest(CREATE_REPLY) {} ino_t vnid; - fs_cookie fileCookie; + void* fileCookie; }; // OpenRequest @@ -747,7 +750,7 @@ class OpenReply : public ReplyRequest { public: OpenReply() : ReplyRequest(OPEN_REPLY) {} - fs_cookie fileCookie; + void* fileCookie; }; // CloseRequest @@ -859,7 +862,7 @@ class OpenDirReply : public ReplyRequest { public: OpenDirReply() : ReplyRequest(OPEN_DIR_REPLY) {} - fs_cookie dirCookie; + void* dirCookie; }; // CloseDirRequest @@ -932,7 +935,7 @@ class OpenAttrDirReply : public ReplyRequest { public: OpenAttrDirReply() : ReplyRequest(OPEN_ATTR_DIR_REPLY) {} - fs_cookie attrDirCookie; + void* attrDirCookie; }; // CloseAttrDirRequest @@ -1010,7 +1013,7 @@ class CreateAttrReply : public ReplyRequest { public: CreateAttrReply() : ReplyRequest(CREATE_ATTR_REPLY) {} - fs_cookie attrCookie; + void* attrCookie; }; // OpenAttrRequest @@ -1028,7 +1031,7 @@ class OpenAttrReply : public ReplyRequest { public: OpenAttrReply() : ReplyRequest(OPEN_ATTR_REPLY) {} - fs_cookie attrCookie; + void* attrCookie; }; // CloseAttrRequest @@ -1128,8 +1131,8 @@ public: RenameAttrRequest() : VolumeRequest(RENAME_ATTR_REQUEST) {} status_t GetAddressInfos(AddressInfo* infos, int32* count); - fs_vnode oldNode; - fs_vnode newNode; + void* oldNode; + void* newNode; Address oldName; Address newName; }; @@ -1170,7 +1173,7 @@ class OpenIndexDirReply : public ReplyRequest { public: OpenIndexDirReply() : ReplyRequest(OPEN_INDEX_DIR_REPLY) {} - fs_cookie indexDirCookie; + void* indexDirCookie; }; // CloseIndexDirRequest @@ -1299,7 +1302,7 @@ class OpenQueryReply : public ReplyRequest { public: OpenQueryReply() : ReplyRequest(OPEN_QUERY_REPLY) {} - fs_cookie queryCookie; + void* queryCookie; }; // CloseQueryRequest @@ -1442,7 +1445,7 @@ class GetVNodeReply : public ReplyRequest { public: GetVNodeReply() : ReplyRequest(GET_VNODE_REPLY) {} - fs_vnode node; + void* node; }; // PutVNodeRequest @@ -1467,7 +1470,7 @@ public: dev_t nsid; ino_t vnid; - fs_vnode node; + void* node; }; // NewVNodeReply @@ -1483,7 +1486,9 @@ public: dev_t nsid; ino_t vnid; - fs_vnode node; + void* node; + int type; + uint32 flags; }; // PublishVNodeReply diff --git a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/FileSystem.cpp b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/FileSystem.cpp index 649c9f6175..81dcbb3555 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/FileSystem.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/FileSystem.cpp @@ -1,4 +1,7 @@ -// FileSystem.cpp +/* + * Copyright 2001-2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ #include "AutoLocker.h" #include "Compatibility.h" @@ -179,7 +182,7 @@ FileSystem::GetPortPool() // Mount status_t -FileSystem::Mount(dev_t id, const char* device, uint32 flags, +FileSystem::Mount(fs_volume* fsVolume, const char* device, uint32 flags, const char* parameters, Volume** _volume) { // check initialization and parameters @@ -187,7 +190,7 @@ FileSystem::Mount(dev_t id, const char* device, uint32 flags, return B_BAD_VALUE; // create volume - Volume* volume = new(nothrow) Volume(this, id); + Volume* volume = new(nothrow) Volume(this, fsVolume); if (!volume) return B_NO_MEMORY; diff --git a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/FileSystem.h b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/FileSystem.h index 9f893ca61e..dce9eb9594 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/FileSystem.h +++ b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/FileSystem.h @@ -1,5 +1,7 @@ -// FileSystem.h - +/* + * Copyright 2001-2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ #ifndef USERLAND_FS_FILE_SYSTEM_H #define USERLAND_FS_FILE_SYSTEM_H @@ -35,7 +37,7 @@ public: RequestPortPool* GetPortPool(); - status_t Mount(dev_t id, const char* device, + status_t Mount(fs_volume* fsVolume, const char* device, ulong flags, const char* parameters, Volume** volume); // status_t Initialize(const char* deviceName, diff --git a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/KernelRequestHandler.cpp b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/KernelRequestHandler.cpp index 2217796dbf..d90e199115 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/KernelRequestHandler.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/KernelRequestHandler.cpp @@ -1,4 +1,7 @@ -// KernelRequestHandler.cpp +/* + * Copyright 2001-2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ #include "Compatibility.h" #include "Debug.h" @@ -121,7 +124,7 @@ KernelRequestHandler::_HandleRequest(NotifyListenerRequest* request) if (!oldName) { ERROR(("NotifyListenerRequest: NULL oldName for " "B_ENTRY_MOVED\n")); - result = B_BAD_VALUE; + result = B_BAD_VALUE; break; } // fall through... @@ -131,7 +134,7 @@ KernelRequestHandler::_HandleRequest(NotifyListenerRequest* request) if (!name) { ERROR(("NotifyListenerRequest: NULL name for opcode: %ld\n", request->operation)); - result = B_BAD_VALUE; + result = B_BAD_VALUE; } break; case B_STAT_CHANGED: @@ -183,7 +186,7 @@ KernelRequestHandler::_HandleRequest(NotifyListenerRequest* request) default: ERROR(("NotifyQueryRequest: unsupported operation: %ld\n", request->operation)); - result = B_BAD_VALUE; + result = B_BAD_VALUE; break; } } @@ -249,7 +252,7 @@ KernelRequestHandler::_HandleRequest(NotifyQueryRequest* request) int32 nameLen = request->name.GetSize(); if (!name || nameLen <= 0) { ERROR(("NotifyQueryRequest: NULL name!\n")); - result = B_BAD_VALUE; + result = B_BAD_VALUE; } else name[nameLen - 1] = '\0'; // NULL-terminate to be safe @@ -278,7 +281,7 @@ KernelRequestHandler::_HandleRequest(NotifyQueryRequest* request) default: ERROR(("NotifyQueryRequest: unsupported operation: %ld\n", request->operation)); - result = B_BAD_VALUE; + result = B_BAD_VALUE; break; } } @@ -372,8 +375,10 @@ KernelRequestHandler::_HandleRequest(PublishVNodeRequest* request) Volume* volume = NULL; status_t result = _GetVolume(request->nsid, &volume); VolumePutter _(volume); - if (result == B_OK) - result = volume->PublishVNode(request->vnid, request->node); + if (result == B_OK) { + result = volume->PublishVNode(request->vnid, request->node, + request->type, request->flags); + } // prepare the reply RequestAllocator allocator(fPort->GetPort()); diff --git a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/KernelRequestHandler.h b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/KernelRequestHandler.h index c2eb705b9e..34f4b10f1c 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/KernelRequestHandler.h +++ b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/KernelRequestHandler.h @@ -1,4 +1,7 @@ -// KernelRequestHandler.h +/* + * Copyright 2001-2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ #ifndef USERLAND_FS_KERNEL_REQUEST_HANDLER_H #define USERLAND_FS_KERNEL_REQUEST_HANDLER_H diff --git a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.cpp b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.cpp index 654648f3f0..4be9ae7a9c 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.cpp @@ -1,4 +1,7 @@ -// Volume.cpp +/* + * Copyright 2001-2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ #include "Volume.h" @@ -13,6 +16,7 @@ #include "FileSystem.h" #include "HashMap.h" #include "IOCtlInfo.h" +#include "kernel_interface.h" #include "KernelRequestHandler.h" #include "PortReleaser.h" #include "RequestAllocator.h" @@ -66,10 +70,10 @@ private: }; // constructor -Volume::Volume(FileSystem* fileSystem, dev_t id) +Volume::Volume(FileSystem* fileSystem, fs_volume* fsVolume) : Referencable(true), fFileSystem(fileSystem), - fID(id), + fFSVolume(fsVolume), fUserlandVolume(NULL), fRootID(0), fRootNode(NULL), @@ -97,13 +101,6 @@ Volume::GetFileSystem() const return fFileSystem; } -// GetID -dev_t -Volume::GetID() const -{ - return fID; -} - // GetUserlandVolume void* Volume::GetUserlandVolume() const @@ -130,14 +127,14 @@ Volume::IsMounting() const // GetVNode status_t -Volume::GetVNode(ino_t vnid, fs_vnode* node) +Volume::GetVNode(ino_t vnid, void** node) { -PRINT(("get_vnode(%ld, %lld)\n", fID, vnid)); +PRINT(("get_vnode(%ld, %lld)\n", GetID(), vnid)); if (IsMounting() && !fMountVNodes->ContainsKey(vnid)) { ERROR(("Volume::GetVNode(): get_vnode() invoked for unknown vnode " "while mounting!\n")); } - status_t error = get_vnode(fID, vnid, node); + status_t error = get_vnode(fFSVolume, vnid, node); if (error == B_OK) _IncrementVNodeCount(vnid); return error; @@ -147,8 +144,8 @@ PRINT(("get_vnode(%ld, %lld)\n", fID, vnid)); status_t Volume::PutVNode(ino_t vnid) { -PRINT(("put_vnode(%ld, %lld)\n", fID, vnid)); - status_t error = put_vnode(fID, vnid); +PRINT(("put_vnode(%ld, %lld)\n", GetID(), vnid)); + status_t error = put_vnode(fFSVolume, vnid); if (error == B_OK) _DecrementVNodeCount(vnid); return error; @@ -156,18 +153,19 @@ PRINT(("put_vnode(%ld, %lld)\n", fID, vnid)); // NewVNode status_t -Volume::NewVNode(ino_t vnid, fs_vnode node) +Volume::NewVNode(ino_t vnid, void* node) { -PRINT(("new_vnode(%ld, %lld)\n", fID, vnid)); - status_t error = new_vnode(fID, vnid, node); +PRINT(("new_vnode(%ld, %lld)\n", GetID(), vnid)); + status_t error = new_vnode(fFSVolume, vnid, node, &gUserlandFSVnodeOps); if (error == B_OK) { if (IsMounting()) { error = fMountVNodes->Put(vnid, node); if (error != B_OK) { ERROR(("Volume::NewVNode(): Failed to add vnode to mount " "vnode map!\n")); - publish_vnode(fID, vnid, node); - put_vnode(fID, vnid); + publish_vnode(fFSVolume, vnid, node, &gUserlandFSVnodeOps, + S_IFDIR, 0); // dummy type and flags + put_vnode(fFSVolume, vnid); return error; } } @@ -179,17 +177,18 @@ PRINT(("new_vnode(%ld, %lld)\n", fID, vnid)); // PublishVNode status_t -Volume::PublishVNode(ino_t vnid, fs_vnode node) +Volume::PublishVNode(ino_t vnid, void* node, int type, uint32 flags) { -PRINT(("publish_vnode(%ld, %lld, %p)\n", fID, vnid, node)); - status_t error = publish_vnode(fID, vnid, node); +PRINT(("publish_vnode(%ld, %lld, %p)\n", GetID(), vnid, node)); + status_t error = publish_vnode(fFSVolume, vnid, node, &gUserlandFSVnodeOps, + type, flags); if (error == B_OK) { if (IsMounting()) { error = fMountVNodes->Put(vnid, node); if (error != B_OK) { ERROR(("Volume::PublishVNode(): Failed to add vnode to mount " "vnode map!\n")); - put_vnode(fID, vnid); + put_vnode(fFSVolume, vnid); return error; } } @@ -202,24 +201,24 @@ PRINT(("publish_vnode(%ld, %lld, %p)\n", fID, vnid, node)); status_t Volume::RemoveVNode(ino_t vnid) { -PRINT(("remove_vnode(%ld, %lld)\n", fID, vnid)); - return remove_vnode(fID, vnid); +PRINT(("remove_vnode(%ld, %lld)\n", GetID(), vnid)); + return remove_vnode(fFSVolume, vnid); } // UnremoveVNode status_t Volume::UnremoveVNode(ino_t vnid) { -PRINT(("unremove_vnode(%ld, %lld)\n", fID, vnid)); - return unremove_vnode(fID, vnid); +PRINT(("unremove_vnode(%ld, %lld)\n", GetID(), vnid)); + return unremove_vnode(fFSVolume, vnid); } // GetVNodeRemoved status_t Volume::GetVNodeRemoved(ino_t vnid, bool* removed) { -PRINT(("get_vnode_removed(%ld, %lld, %p)\n", fID, vnid, removed)); - return get_vnode_removed(fID, vnid, removed); +PRINT(("get_vnode_removed(%ld, %lld, %p)\n", GetID(), vnid, removed)); + return get_vnode_removed(fFSVolume, vnid, removed); } @@ -323,7 +322,7 @@ Volume::ReadFSInfo(fs_info* info) // read_fs_info() requests manually. status_t error = _ReadFSInfo(info); if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) { - WARN(("Volume::Lookup(): connection lost, emulating lookup `.'\n")); + WARN(("Volume::ReadFSInfo(): connection lost, emulating lookup `.'\n")); info->flags = B_FS_IS_PERSISTENT | B_FS_IS_READONLY; info->block_size = 512; @@ -384,11 +383,11 @@ 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) { // When the connection to the userland server is lost, we serve // lookup(fRootNode, `.') requests manually to allow clean unmounting. - status_t error = _Lookup(dir, entryName, vnid, type); + status_t error = _Lookup(dir, entryName, vnid); if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected() && dir == fRootNode && strcmp(entryName, ".") == 0) { WARN(("Volume::Lookup(): connection lost, emulating lookup `.'\n")); @@ -396,7 +395,6 @@ Volume::Lookup(fs_vnode dir, const char* entryName, ino_t* vnid, int* type) if (GetVNode(fRootID, &entryNode) != B_OK) RETURN_ERROR(B_BAD_VALUE); *vnid = fRootID; - *type = S_IFDIR; // The VFS will balance the get_vnode() call for the FS. _DecrementVNodeCount(*vnid); return B_OK; @@ -406,7 +404,7 @@ Volume::Lookup(fs_vnode dir, const char* entryName, ino_t* vnid, int* type) // GetVNodeName status_t -Volume::GetVNodeName(fs_vnode node, char* buffer, size_t bufferSize) +Volume::GetVNodeName(void* node, char* buffer, size_t bufferSize) { // We don't check the capability -- if not implemented by the client FS, // the functionality is emulated in userland. @@ -455,7 +453,8 @@ 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) { // get a free port RequestPort* port = fFileSystem->GetPortPool()->AcquirePort(); @@ -486,12 +485,14 @@ Volume::ReadVNode(ino_t vnid, bool reenter, fs_vnode* node) if (reply->error != B_OK) return reply->error; *node = reply->node; + *type = reply->type; + *flags = reply->flags; return error; } // WriteVNode status_t -Volume::WriteVNode(fs_vnode node, bool reenter) +Volume::WriteVNode(void* node, bool reenter) { status_t error = _WriteVNode(node, reenter); if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) { @@ -506,7 +507,7 @@ Volume::WriteVNode(fs_vnode node, bool reenter) // RemoveVNode status_t -Volume::RemoveVNode(fs_vnode node, bool reenter) +Volume::RemoveVNode(void* node, bool reenter) { // get a free port RequestPort* port = fFileSystem->GetPortPool()->AcquirePort(); @@ -545,7 +546,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 len) { // check the command and its parameters @@ -691,7 +692,7 @@ 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) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_SET_FLAGS)) @@ -731,8 +732,7 @@ Volume::SetFlags(fs_vnode node, fs_cookie cookie, int flags) // 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) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_SELECT)) { @@ -784,7 +784,7 @@ Volume::Select(fs_vnode node, fs_cookie cookie, uint8 event, uint32 ref, // 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) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_DESELECT)) @@ -834,7 +834,7 @@ Volume::Deselect(fs_vnode node, fs_cookie cookie, uint8 event, selectsync* sync) // FSync status_t -Volume::FSync(fs_vnode node) +Volume::FSync(void* node) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_FSYNC)) @@ -872,7 +872,7 @@ Volume::FSync(fs_vnode node) // 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) { *bytesRead = 0; @@ -923,7 +923,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) { // check capability @@ -968,7 +968,7 @@ 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) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_LINK)) @@ -1010,7 +1010,7 @@ Volume::Link(fs_vnode dir, const char* name, fs_vnode node) // Unlink status_t -Volume::Unlink(fs_vnode dir, const char* name) +Volume::Unlink(void* dir, const char* name) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_UNLINK)) @@ -1051,7 +1051,7 @@ Volume::Unlink(fs_vnode dir, const char* name) // 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) { // check capability @@ -1096,7 +1096,7 @@ 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) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_ACCESS)) @@ -1135,7 +1135,7 @@ Volume::Access(fs_vnode node, int mode) // ReadStat status_t -Volume::ReadStat(fs_vnode node, struct stat* st) +Volume::ReadStat(void* node, struct stat* st) { // When the connection to the userland server is lost, we serve // read_stat(fRootNode) requests manually to allow clean unmounting. @@ -1145,7 +1145,7 @@ Volume::ReadStat(fs_vnode node, struct stat* st) WARN(("Volume::ReadStat(): connection lost, emulating stat for the " "root node\n")); - st->st_dev = fID; + st->st_dev = GetID(); st->st_ino = fRootID; st->st_mode = ACCESSPERMS; st->st_nlink = 1; @@ -1165,7 +1165,7 @@ Volume::ReadStat(fs_vnode node, struct stat* st) // WriteStat status_t -Volume::WriteStat(fs_vnode node, const struct stat* st, uint32 mask) +Volume::WriteStat(void* node, const struct stat* st, uint32 mask) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_WRITE_STAT)) @@ -1208,7 +1208,7 @@ 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, +Volume::Create(void* dir, const char* name, int openMode, int mode, void** cookie, ino_t* vnid) { // check capability @@ -1259,7 +1259,7 @@ Volume::Create(fs_vnode dir, const char* name, int openMode, int mode, // Open status_t -Volume::Open(fs_vnode node, int openMode, fs_cookie* cookie) +Volume::Open(void* node, int openMode, void** cookie) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_OPEN)) @@ -1300,7 +1300,7 @@ Volume::Open(fs_vnode node, int openMode, fs_cookie* cookie) // Close status_t -Volume::Close(fs_vnode node, fs_cookie cookie) +Volume::Close(void* node, void* cookie) { status_t error = _Close(node, cookie); if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) { @@ -1315,7 +1315,7 @@ Volume::Close(fs_vnode node, fs_cookie cookie) // FreeCookie status_t -Volume::FreeCookie(fs_vnode node, fs_cookie cookie) +Volume::FreeCookie(void* node, void* cookie) { status_t error = _FreeCookie(node, cookie); bool disconnected = false; @@ -1335,7 +1335,7 @@ Volume::FreeCookie(fs_vnode node, fs_cookie cookie) // 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) { *bytesRead = 0; @@ -1388,7 +1388,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 size, size_t* bytesWritten) { *bytesWritten = 0; @@ -1438,7 +1438,7 @@ 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) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_CREATE_DIR)) @@ -1481,7 +1481,7 @@ Volume::CreateDir(fs_vnode dir, const char* name, int mode, ino_t *newDir) // RemoveDir status_t -Volume::RemoveDir(fs_vnode dir, const char* name) +Volume::RemoveDir(void* dir, const char* name) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_REMOVE_DIR)) @@ -1522,7 +1522,7 @@ Volume::RemoveDir(fs_vnode dir, const char* name) // OpenDir status_t -Volume::OpenDir(fs_vnode node, fs_cookie* cookie) +Volume::OpenDir(void* node, void** cookie) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_OPEN_DIR)) @@ -1563,7 +1563,7 @@ Volume::OpenDir(fs_vnode node, fs_cookie* cookie) // CloseDir status_t -Volume::CloseDir(fs_vnode node, fs_vnode cookie) +Volume::CloseDir(void* node, void* cookie) { status_t error = _CloseDir(node, cookie); if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) { @@ -1598,7 +1598,7 @@ Volume::FreeDirCookie(void* node, void* cookie) // 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) { *countRead = 0; @@ -1660,7 +1660,7 @@ reply->buffer.GetSize())); // RewindDir status_t -Volume::RewindDir(fs_vnode node, fs_vnode cookie) +Volume::RewindDir(void* node, void* cookie) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_REWIND_DIR)) @@ -1703,7 +1703,7 @@ 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) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_OPEN_ATTR_DIR)) @@ -1744,7 +1744,7 @@ Volume::OpenAttrDir(fs_vnode node, fs_cookie *cookie) // CloseAttrDir status_t -Volume::CloseAttrDir(fs_vnode node, fs_cookie cookie) +Volume::CloseAttrDir(void* node, void* cookie) { status_t error = _CloseAttrDir(node, cookie); if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) { @@ -1781,7 +1781,7 @@ Volume::FreeAttrDirCookie(void* node, void* cookie) // 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) { // check capability @@ -1840,7 +1840,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) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_REWIND_ATTR_DIR)) @@ -1882,8 +1882,8 @@ 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) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_CREATE_ATTR)) @@ -1929,8 +1929,8 @@ Volume::CreateAttr(fs_vnode node, const char* name, uint32 type, int openMode, // 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) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_OPEN_ATTR)) @@ -1975,7 +1975,7 @@ Volume::OpenAttr(fs_vnode node, const char* name, int openMode, // CloseAttr status_t -Volume::CloseAttr(fs_vnode node, fs_cookie cookie) +Volume::CloseAttr(void* node, void* cookie) { status_t error = _CloseAttr(node, cookie); if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) { @@ -1990,7 +1990,7 @@ Volume::CloseAttr(fs_vnode node, fs_cookie cookie) // FreeAttrCookie status_t -Volume::FreeAttrCookie(fs_vnode node, fs_cookie cookie) +Volume::FreeAttrCookie(void* node, void* cookie) { status_t error = _FreeAttrCookie(node, cookie); bool disconnected = false; @@ -2011,7 +2011,7 @@ Volume::FreeAttrCookie(fs_vnode node, fs_cookie cookie) // ReadAttr status_t -Volume::ReadAttr(fs_vnode node, fs_cookie cookie, off_t pos, +Volume::ReadAttr(void* node, void* cookie, off_t pos, void* buffer, size_t bufferSize, size_t* bytesRead) { *bytesRead = 0; @@ -2064,7 +2064,7 @@ Volume::ReadAttr(fs_vnode node, fs_cookie cookie, off_t pos, // 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) { *bytesWritten = 0; @@ -2111,7 +2111,7 @@ 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) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_ATTR_STAT)) @@ -2151,7 +2151,7 @@ Volume::ReadAttrStat(fs_vnode node, fs_cookie cookie, struct stat *st) // 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) { // check capability @@ -2193,7 +2193,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) { // check capability @@ -2238,7 +2238,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) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_REMOVE_ATTR)) @@ -2283,7 +2283,7 @@ Volume::RemoveAttr(fs_vnode node, const char* name) // OpenIndexDir status_t -Volume::OpenIndexDir(fs_cookie *cookie) +Volume::OpenIndexDir(void** cookie) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_OPEN_INDEX_DIR)) @@ -2323,7 +2323,7 @@ Volume::OpenIndexDir(fs_cookie *cookie) // CloseIndexDir status_t -Volume::CloseIndexDir(fs_cookie cookie) +Volume::CloseIndexDir(void* cookie) { status_t error = _CloseIndexDir(cookie); if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) { @@ -2339,7 +2339,7 @@ Volume::CloseIndexDir(fs_cookie cookie) // FreeIndexDirCookie status_t -Volume::FreeIndexDirCookie(fs_cookie cookie) +Volume::FreeIndexDirCookie(void* cookie) { status_t error = _FreeIndexDirCookie(cookie); bool disconnected = false; @@ -2360,7 +2360,7 @@ Volume::FreeIndexDirCookie(fs_cookie cookie) // 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) { *countRead = 0; @@ -2419,7 +2419,7 @@ Volume::ReadIndexDir(fs_cookie cookie, void* buffer, size_t bufferSize, // RewindIndexDir status_t -Volume::RewindIndexDir(fs_cookie cookie) +Volume::RewindIndexDir(void* cookie) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_REWIND_INDEX_DIR)) @@ -2585,7 +2585,7 @@ Volume::ReadIndexStat(const char* name, struct stat *st) // OpenQuery status_t Volume::OpenQuery(const char* queryString, uint32 flags, port_id targetPort, - uint32 token, fs_cookie *cookie) + uint32 token, void** cookie) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_OPEN_QUERY)) @@ -2631,7 +2631,7 @@ Volume::OpenQuery(const char* queryString, uint32 flags, port_id targetPort, // CloseQuery status_t -Volume::CloseQuery(fs_cookie cookie) +Volume::CloseQuery(void* cookie) { status_t error = _CloseQuery(cookie); if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) { @@ -2646,7 +2646,7 @@ Volume::CloseQuery(fs_cookie cookie) // FreeQueryCookie status_t -Volume::FreeQueryCookie(fs_cookie cookie) +Volume::FreeQueryCookie(void* cookie) { status_t error = _FreeQueryCookie(cookie); bool disconnected = false; @@ -2667,7 +2667,7 @@ Volume::FreeQueryCookie(fs_cookie cookie) // 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) { *countRead = 0; @@ -2726,7 +2726,7 @@ Volume::ReadQuery(fs_cookie cookie, void* buffer, size_t bufferSize, // RewindQuery status_t -Volume::RewindQuery(fs_cookie cookie) +Volume::RewindQuery(void* cookie) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_REWIND_QUERY)) @@ -2787,7 +2787,7 @@ Volume::_Mount(const char* device, uint32 flags, const char* parameters) if (error != B_OK) return error; - request->nsid = fID; + request->nsid = GetID(); error = allocator.AllocateString(request->cwd, cwd); if (error == B_OK) error = allocator.AllocateString(request->device, device); @@ -2893,7 +2893,7 @@ Volume::_ReadFSInfo(fs_info* info) // _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) { // get a free port RequestPort* port = fFileSystem->GetPortPool()->AcquirePort(); @@ -2925,7 +2925,6 @@ Volume::_Lookup(fs_vnode dir, const char* entryName, ino_t* vnid, int* type) if (reply->error != B_OK) return reply->error; *vnid = reply->vnid; - *type = reply->type; // The VFS will balance the get_vnode() call for the FS. _DecrementVNodeCount(*vnid); @@ -2934,7 +2933,7 @@ Volume::_Lookup(fs_vnode dir, const char* entryName, ino_t* vnid, int* type) // _WriteVNode status_t -Volume::_WriteVNode(fs_vnode node, bool reenter) +Volume::_WriteVNode(void* node, bool reenter) { // get a free port RequestPort* port = fFileSystem->GetPortPool()->AcquirePort(); @@ -2968,7 +2967,7 @@ Volume::_WriteVNode(fs_vnode node, bool reenter) // _ReadStat status_t -Volume::_ReadStat(fs_vnode node, struct stat* st) +Volume::_ReadStat(void* node, struct stat* st) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_STAT)) @@ -3007,7 +3006,7 @@ Volume::_ReadStat(fs_vnode node, struct stat* st) // _Close status_t -Volume::_Close(fs_vnode node, fs_cookie cookie) +Volume::_Close(void* node, void* cookie) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_CLOSE)) @@ -3046,7 +3045,7 @@ Volume::_Close(fs_vnode node, fs_cookie cookie) // _FreeCookie status_t -Volume::_FreeCookie(fs_vnode node, fs_cookie cookie) +Volume::_FreeCookie(void* node, void* cookie) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_FREE_COOKIE)) @@ -3085,7 +3084,7 @@ Volume::_FreeCookie(fs_vnode node, fs_cookie cookie) // _CloseDir status_t -Volume::_CloseDir(fs_vnode node, fs_vnode cookie) +Volume::_CloseDir(void* node, void* cookie) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_CLOSE_DIR)) @@ -3124,7 +3123,7 @@ Volume::_CloseDir(fs_vnode node, fs_vnode cookie) // _FreeDirCookie status_t -Volume::_FreeDirCookie(fs_vnode node, fs_vnode cookie) +Volume::_FreeDirCookie(void* node, void* cookie) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_FREE_DIR_COOKIE)) @@ -3163,7 +3162,7 @@ Volume::_FreeDirCookie(fs_vnode node, fs_vnode cookie) // _CloseAttrDir status_t -Volume::_CloseAttrDir(fs_vnode node, fs_cookie cookie) +Volume::_CloseAttrDir(void* node, void* cookie) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_CLOSE_ATTR_DIR)) @@ -3202,7 +3201,7 @@ Volume::_CloseAttrDir(fs_vnode node, fs_cookie cookie) // _FreeAttrDirCookie status_t -Volume::_FreeAttrDirCookie(fs_vnode node, fs_cookie cookie) +Volume::_FreeAttrDirCookie(void* node, void* cookie) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_FREE_ATTR_DIR_COOKIE)) @@ -3241,7 +3240,7 @@ Volume::_FreeAttrDirCookie(fs_vnode node, fs_cookie cookie) // _CloseAttr status_t -Volume::_CloseAttr(fs_vnode node, fs_cookie cookie) +Volume::_CloseAttr(void* node, void* cookie) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_CLOSE_ATTR)) @@ -3280,7 +3279,7 @@ Volume::_CloseAttr(fs_vnode node, fs_cookie cookie) // _FreeAttrCookie status_t -Volume::_FreeAttrCookie(fs_vnode node, fs_cookie cookie) +Volume::_FreeAttrCookie(void* node, void* cookie) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_FREE_ATTR_COOKIE)) @@ -3319,7 +3318,7 @@ Volume::_FreeAttrCookie(fs_vnode node, fs_cookie cookie) // _CloseIndexDir status_t -Volume::_CloseIndexDir(fs_cookie cookie) +Volume::_CloseIndexDir(void* cookie) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_CLOSE_INDEX_DIR)) @@ -3357,7 +3356,7 @@ Volume::_CloseIndexDir(fs_cookie cookie) // _FreeIndexDirCookie status_t -Volume::_FreeIndexDirCookie(fs_cookie cookie) +Volume::_FreeIndexDirCookie(void* cookie) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_FREE_INDEX_DIR_COOKIE)) @@ -3395,7 +3394,7 @@ Volume::_FreeIndexDirCookie(fs_cookie cookie) // _CloseQuery status_t -Volume::_CloseQuery(fs_cookie cookie) +Volume::_CloseQuery(void* cookie) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_CLOSE_QUERY)) @@ -3433,7 +3432,7 @@ Volume::_CloseQuery(fs_cookie cookie) // _FreeQueryCookie status_t -Volume::_FreeQueryCookie(fs_cookie cookie) +Volume::_FreeQueryCookie(void* cookie) { // check capability if (!fFileSystem->HasCapability(FS_CAPABILITY_FREE_QUERY_COOKIE)) diff --git a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.h b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.h index fa4b7f6b4e..56ab51f48b 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.h +++ b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.h @@ -1,5 +1,7 @@ -// Volume.h - +/* + * Copyright 2001-2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ #ifndef USERLAND_FS_VOLUME_H #define USERLAND_FS_VOLUME_H @@ -27,21 +29,23 @@ class FileSystem; class Volume : public Referencable { public: - Volume(FileSystem* fileSystem, dev_t id); + Volume(FileSystem* fileSystem, + fs_volume* fsVolume); ~Volume(); FileSystem* GetFileSystem() const; - dev_t GetID() const; + inline dev_t GetID() const; void* GetUserlandVolume() const; ino_t GetRootID() const; bool IsMounting() const; // client methods - status_t GetVNode(ino_t vnid, fs_vnode* node); + status_t GetVNode(ino_t vnid, void** node); status_t PutVNode(ino_t vnid); - status_t NewVNode(ino_t vnid, fs_vnode node); - status_t PublishVNode(ino_t vnid, fs_vnode node); + status_t NewVNode(ino_t vnid, void* node); + status_t PublishVNode(ino_t vnid, void* node, + int type, uint32 flags); status_t RemoveVNode(ino_t vnid); status_t UnremoveVNode(ino_t vnid); status_t GetVNodeRemoved(ino_t vnid, bool* removed); @@ -56,111 +60,111 @@ public: uint32 mask); // vnodes - status_t Lookup(fs_vnode dir, const char* entryName, - ino_t* vnid, int* type); - status_t GetVNodeName(fs_vnode node, char* buffer, + status_t Lookup(void* dir, const char* entryName, + ino_t* vnid); + status_t GetVNodeName(void* node, char* buffer, size_t bufferSize); status_t ReadVNode(ino_t vnid, bool reenter, - fs_vnode* node); - status_t WriteVNode(fs_vnode node, bool reenter); - status_t RemoveVNode(fs_vnode node, bool reenter); + void** node, int* type, uint32* flags); + status_t WriteVNode(void* node, bool reenter); + status_t RemoveVNode(void* node, bool reenter); // nodes - status_t IOCtl(fs_vnode node, fs_cookie cookie, + status_t IOCtl(void* node, void* cookie, uint32 command, void *buffer, size_t size); - status_t SetFlags(fs_vnode node, fs_cookie cookie, + status_t SetFlags(void* node, void* cookie, int flags); - status_t Select(fs_vnode node, fs_cookie cookie, - uint8 event, uint32 ref, selectsync* sync); - status_t Deselect(fs_vnode node, fs_cookie cookie, - uint8 event, selectsync* sync); + status_t Select(void* node, void* cookie, uint8 event, + selectsync* sync); + status_t Deselect(void* node, void* cookie, uint8 event, + selectsync* sync); - status_t FSync(fs_vnode node); + status_t FSync(void* node); - status_t ReadSymlink(fs_vnode node, char* buffer, + status_t ReadSymlink(void* node, char* buffer, size_t bufferSize, size_t* bytesRead); - status_t CreateSymlink(fs_vnode dir, const char* name, + status_t CreateSymlink(void* dir, const char* name, const char* target, int mode); - status_t Link(fs_vnode dir, const char* name, - fs_vnode node); - status_t Unlink(fs_vnode dir, const char* name); - status_t Rename(fs_vnode oldDir, const char* oldName, - fs_vnode newDir, const char* newName); + status_t Link(void* dir, const char* name, + void* node); + status_t Unlink(void* dir, const char* name); + status_t Rename(void* oldDir, const char* oldName, + void* newDir, const char* newName); - status_t Access(fs_vnode node, int mode); - status_t ReadStat(fs_vnode node, struct stat* st); - status_t WriteStat(fs_vnode node, const struct stat *st, + status_t Access(void* node, int mode); + status_t ReadStat(void* node, struct stat* st); + status_t WriteStat(void* node, const struct stat *st, uint32 mask); // files - status_t Create(fs_vnode dir, const char* name, - int openMode, int mode, fs_cookie* cookie, + status_t Create(void* dir, const char* name, + int openMode, int mode, void** cookie, ino_t* vnid); - status_t Open(fs_vnode node, int openMode, - fs_cookie* cookie); - status_t Close(fs_vnode node, fs_cookie cookie); - status_t FreeCookie(fs_vnode node, fs_cookie cookie); - status_t Read(fs_vnode node, fs_cookie cookie, off_t pos, + status_t Open(void* node, int openMode, + void** cookie); + status_t Close(void* node, void* cookie); + status_t FreeCookie(void* node, void* cookie); + status_t Read(void* node, void* cookie, off_t pos, void* buffer, size_t bufferSize, size_t* bytesRead); - status_t Write(fs_vnode node, fs_cookie cookie, + status_t Write(void* node, void* cookie, off_t pos, const void* buffer, size_t bufferSize, size_t* bytesWritten); // directories - status_t CreateDir(fs_vnode dir, const char* name, + status_t CreateDir(void* dir, const char* name, int mode, ino_t *newDir); - status_t RemoveDir(fs_vnode dir, const char* name); - status_t OpenDir(fs_vnode node, fs_cookie* cookie); - status_t CloseDir(fs_vnode node, fs_vnode cookie); - status_t FreeDirCookie(fs_vnode node, fs_vnode cookie); - status_t ReadDir(fs_vnode node, fs_vnode cookie, + status_t RemoveDir(void* dir, const char* name); + status_t OpenDir(void* node, void** cookie); + status_t CloseDir(void* node, void* cookie); + status_t FreeDirCookie(void* node, void* cookie); + status_t ReadDir(void* node, void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead); - status_t RewindDir(fs_vnode node, fs_vnode cookie); + status_t RewindDir(void* node, void* cookie); // attribute directories - status_t OpenAttrDir(fs_vnode node, fs_cookie *cookie); - status_t CloseAttrDir(fs_vnode node, fs_cookie cookie); - status_t FreeAttrDirCookie(fs_vnode node, - fs_cookie cookie); - status_t ReadAttrDir(fs_vnode node, fs_cookie cookie, + status_t OpenAttrDir(void* node, void** cookie); + status_t CloseAttrDir(void* node, void* cookie); + status_t FreeAttrDirCookie(void* node, + void* cookie); + status_t ReadAttrDir(void* node, void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead); - status_t RewindAttrDir(fs_vnode node, fs_cookie cookie); + status_t RewindAttrDir(void* node, void* cookie); // attributes - status_t CreateAttr(fs_vnode node, const char* name, + status_t CreateAttr(void* node, const char* name, uint32 type, int openMode, - fs_cookie* cookie); - status_t OpenAttr(fs_vnode node, const char* name, - int openMode, fs_cookie* cookie); - status_t CloseAttr(fs_vnode node, fs_cookie cookie); - status_t FreeAttrCookie(fs_vnode node, fs_cookie cookie); - status_t ReadAttr(fs_vnode node, fs_cookie cookie, + void** cookie); + status_t OpenAttr(void* node, const char* name, + int openMode, void** cookie); + status_t CloseAttr(void* node, void* cookie); + status_t FreeAttrCookie(void* node, void* cookie); + status_t ReadAttr(void* node, void* cookie, off_t pos, void* buffer, size_t bufferSize, size_t* bytesRead); - status_t WriteAttr(fs_vnode node, fs_cookie cookie, + status_t WriteAttr(void* node, void* cookie, off_t pos, const void* buffer, size_t bufferSize, size_t* bytesWritten); - status_t ReadAttrStat(fs_vnode node, fs_cookie cookie, + status_t ReadAttrStat(void* node, void* cookie, struct stat *st); - status_t WriteAttrStat(fs_vnode node, fs_cookie cookie, + status_t WriteAttrStat(void* node, void* cookie, const struct stat *st, int statMask); - status_t RenameAttr(fs_vnode oldNode, - const char* oldName, fs_vnode newNode, + status_t RenameAttr(void* oldNode, + const char* oldName, void* newNode, const char* newName); - status_t RemoveAttr(fs_vnode node, const char* name); + status_t RemoveAttr(void* node, const char* name); // indices - status_t OpenIndexDir(fs_cookie *cookie); - status_t CloseIndexDir(fs_cookie cookie); - status_t FreeIndexDirCookie(fs_cookie cookie); - status_t ReadIndexDir(fs_cookie cookie, void* buffer, + status_t OpenIndexDir(void** cookie); + status_t CloseIndexDir(void* cookie); + status_t FreeIndexDirCookie(void* cookie); + status_t ReadIndexDir(void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead); - status_t RewindIndexDir(fs_cookie cookie); + status_t RewindIndexDir(void* cookie); status_t CreateIndex(const char* name, uint32 type, uint32 flags); status_t RemoveIndex(const char* name); @@ -170,37 +174,37 @@ public: // queries status_t OpenQuery(const char* queryString, uint32 flags, port_id port, uint32 token, - fs_cookie *cookie); - status_t CloseQuery(fs_cookie cookie); - status_t FreeQueryCookie(fs_cookie cookie); - status_t ReadQuery(fs_cookie cookie, void* buffer, + void** cookie); + status_t CloseQuery(void* cookie); + status_t FreeQueryCookie(void* cookie); + status_t ReadQuery(void* cookie, void* buffer, size_t bufferSize, uint32 count, uint32* countRead); - status_t RewindQuery(fs_cookie cookie); + status_t RewindQuery(void* cookie); private: status_t _Mount(const char* device, uint32 flags, const char* parameters); status_t _Unmount(); status_t _ReadFSInfo(fs_info* info); - status_t _Lookup(fs_vnode dir, const char* entryName, - ino_t* vnid, int* type); - status_t _WriteVNode(fs_vnode node, bool reenter); - status_t _ReadStat(fs_vnode node, struct stat* st); - status_t _Close(fs_vnode node, fs_cookie cookie); - status_t _FreeCookie(fs_vnode node, fs_cookie cookie); - status_t _CloseDir(fs_vnode node, fs_vnode cookie); - status_t _FreeDirCookie(fs_vnode node, fs_vnode cookie); - status_t _CloseAttrDir(fs_vnode node, fs_cookie cookie); - status_t _FreeAttrDirCookie(fs_vnode node, - fs_cookie cookie); - status_t _CloseAttr(fs_vnode node, fs_cookie cookie); - status_t _FreeAttrCookie(fs_vnode node, - fs_cookie cookie); - status_t _CloseIndexDir(fs_cookie cookie); - status_t _FreeIndexDirCookie(fs_cookie cookie); - status_t _CloseQuery(fs_cookie cookie); - status_t _FreeQueryCookie(fs_cookie cookie); + status_t _Lookup(void* dir, const char* entryName, + ino_t* vnid); + status_t _WriteVNode(void* node, bool reenter); + status_t _ReadStat(void* node, struct stat* st); + status_t _Close(void* node, void* cookie); + status_t _FreeCookie(void* node, void* cookie); + status_t _CloseDir(void* node, void* cookie); + status_t _FreeDirCookie(void* node, void* cookie); + status_t _CloseAttrDir(void* node, void* cookie); + status_t _FreeAttrDirCookie(void* node, + void* cookie); + status_t _CloseAttr(void* node, void* cookie); + status_t _FreeAttrCookie(void* node, + void* cookie); + status_t _CloseIndexDir(void* cookie); + status_t _FreeIndexDirCookie(void* cookie); + status_t _CloseQuery(void* cookie); + status_t _FreeQueryCookie(void* cookie); status_t _SendRequest(RequestPort* port, RequestAllocator* allocator, @@ -221,10 +225,10 @@ private: class AutoIncrementer; FileSystem* fFileSystem; - dev_t fID; + fs_volume* fFSVolume; void* fUserlandVolume; ino_t fRootID; - fs_vnode fRootNode; + void* fRootNode; MountVNodeMap* fMountVNodes; vint32 fOpenFiles; vint32 fOpenDirectories; @@ -239,4 +243,13 @@ private: volatile bool fVNodeCountingEnabled; }; + +// GetID +inline dev_t +Volume::GetID() const +{ + return fFSVolume->id; +} + + #endif // USERLAND_FS_VOLUME_H diff --git a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/kernel_interface.cpp b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/kernel_interface.cpp index 26931d1191..61d7d169e5 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/kernel_interface.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/kernel_interface.cpp @@ -1,4 +1,9 @@ -// kernel_interface.cpp +/* + * Copyright 2001-2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ + +#include "kernel_interface.h" #include @@ -64,11 +69,11 @@ parse_parameters(const char *parameters, String &fsName, // userlandfs_mount static status_t -userlandfs_mount(dev_t id, const char *device, uint32 flags, - const char *args, fs_volume *fsCookie, ino_t *rootVnodeID) +userlandfs_mount(fs_volume* fsVolume, const char* device, uint32 flags, + const char* args, ino_t* rootVnodeID) { - PRINT(("userlandfs_mount(%ld, %s, 0x%lx, %s, %p, %p)\n", id, device, flags, - args, fsCookie, rootVnodeID)); + PRINT(("userlandfs_mount(%p (%ld), %s, 0x%lx, %s, %p, %p)\n", fsVolume, + fsVolume->id, device, flags, args, fsCookie, rootVnodeID)); status_t error = B_OK; @@ -93,26 +98,28 @@ userlandfs_mount(dev_t id, const char *device, uint32 flags, // mount the volume Volume* volume = NULL; - error = fileSystem->Mount(id, device, flags, fsParameters, &volume); + error = fileSystem->Mount(fsVolume, device, flags, fsParameters, &volume); if (error != B_OK) { userlandFS->UnregisterFileSystem(fileSystem); RETURN_ERROR(error); } - *fsCookie = volume; + fsVolume->private_volume = volume; + fsVolume->ops = &gUserlandFSVolumeOps; *rootVnodeID = volume->GetRootID(); - PRINT(("userlandfs_mount() done: %p, %lld\n", *fsCookie, *rootVnodeID)); + PRINT(("userlandfs_mount() done: %p, %lld\n", *fsVolume->private_volume, + *rootVnodeID)); return error; } // userlandfs_unmount static status_t -userlandfs_unmount(fs_volume fs) +userlandfs_unmount(fs_volume* fsVolume) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_unmount(%p)\n", fs)); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_unmount(%p)\n", volume)); FileSystem* fileSystem = volume->GetFileSystem(); status_t error = volume->Unmount(); @@ -127,10 +134,10 @@ userlandfs_unmount(fs_volume fs) // userlandfs_sync static status_t -userlandfs_sync(fs_volume fs) +userlandfs_sync(fs_volume* fsVolume) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_sync(%p)\n", fs)); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_sync(%p)\n", volume)); status_t error = volume->Sync(); PRINT(("userlandfs_sync() done: %lx \n", error)); return error; @@ -138,10 +145,10 @@ userlandfs_sync(fs_volume fs) // userlandfs_read_fs_info static status_t -userlandfs_read_fs_info(fs_volume fs, struct fs_info *info) +userlandfs_read_fs_info(fs_volume* fsVolume, struct fs_info* info) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_read_fs_info(%p, %p)\n", fs, info)); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_read_fs_info(%p, %p)\n", volume, info)); status_t error = volume->ReadFSInfo(info); PRINT(("userlandfs_read_fs_info() done: %lx \n", error)); return error; @@ -149,10 +156,11 @@ userlandfs_read_fs_info(fs_volume fs, struct fs_info *info) // userlandfs_write_fs_info static status_t -userlandfs_write_fs_info(fs_volume fs, const struct fs_info *info, uint32 mask) +userlandfs_write_fs_info(fs_volume* fsVolume, const struct fs_info* info, + uint32 mask) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_write_fs_info(%p, %p, 0x%lx)\n", fs, info, mask)); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_write_fs_info(%p, %p, 0x%lx)\n", volume, info, mask)); status_t error = volume->WriteFSInfo(info, mask); PRINT(("userlandfs_write_fs_info() done: %lx \n", error)); return error; @@ -164,27 +172,27 @@ userlandfs_write_fs_info(fs_volume fs, const struct fs_info *info, uint32 mask) // userlandfs_lookup static status_t -userlandfs_lookup(fs_volume fs, fs_vnode dir, const char *entryName, - ino_t *vnid, int *type) +userlandfs_lookup(fs_volume* fsVolume, fs_vnode* fsDir, const char* entryName, + ino_t* vnid) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_lookup(%p, %p, `%s', %p, %p)\n", fs, dir, - entryName, vnid, type)); - status_t error = volume->Lookup(dir, entryName, vnid, type); - PRINT(("userlandfs_lookup() done: (%lx, %lld, 0x%x)\n", error, *vnid, - *type)); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_lookup(%p, %p, `%s', %p)\n", volume, fsDir->private_node, + entryName, vnid)); + status_t error = volume->Lookup(fsDir->private_node, entryName, vnid); + PRINT(("userlandfs_lookup() done: (%lx, %lld)\n", error, *vnid)); return error; } // userlandfs_get_vnode_name static status_t -userlandfs_get_vnode_name(fs_volume fs, fs_vnode node, char *buffer, +userlandfs_get_vnode_name(fs_volume* fsVolume, fs_vnode* fsNode, char* buffer, size_t bufferSize) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_get_vnode_name(%p, %p, %p, %lu)\n", fs, node, - buffer, bufferSize)); - status_t error = volume->GetVNodeName(node, buffer, bufferSize); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_get_vnode_name(%p, %p, %p, %lu)\n", volume, + fsNode->private_node, buffer, bufferSize)); + status_t error = volume->GetVNodeName(fsNode->private_node, buffer, + bufferSize); PRINT(("userlandfs_get_vnode_name() done: (%lx, \"%.*s\")\n", error, (int)bufferSize, (error == B_OK ? buffer : NULL))); return error; @@ -192,40 +200,49 @@ userlandfs_get_vnode_name(fs_volume fs, fs_vnode node, char *buffer, // userlandfs_get_vnode static status_t -userlandfs_get_vnode(fs_volume fs, ino_t vnid, fs_vnode *node, bool reenter) +userlandfs_get_vnode(fs_volume* fsVolume, ino_t vnid, fs_vnode* fsNode, + int* _type, uint32* _flags, bool reenter) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_get_vnode(%p, %lld, %p, %d)\n", fs, vnid, node, - reenter)); - status_t error = volume->ReadVNode(vnid, reenter, node); - PRINT(("userlandfs_get_vnode() done: (%lx, %p)\n", error, *node)); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_get_vnode(%p, %lld, %p, %d)\n", volume, vnid, + fsNode->private_node, reenter)); + void* node; + status_t error = volume->ReadVNode(vnid, reenter, &node, _type, _flags); + if (error == B_OK) { + fsNode->private_node = node; + fsNode->ops = &gUserlandFSVnodeOps; + } + + PRINT(("userlandfs_get_vnode() done: (%lx, %p)\n", error, node)); return error; } // userlandfs_put_vnode static status_t -userlandfs_put_vnode(fs_volume fs, fs_vnode node, bool reenter) +userlandfs_put_vnode(fs_volume* fsVolume, fs_vnode* fsNode, bool reenter) { - Volume* volume = (Volume*)fs; + Volume* volume = (Volume*)fsVolume->private_volume; // DANGER: If dbg_printf() is used, this thread will enter another FS and // even perform a write operation. The is dangerous here, since this hook // may be called out of the other FSs, since, for instance a put_vnode() // called from another FS may cause the VFS layer to free vnodes and thus // invoke this hook. -// PRINT(("userlandfs_put_vnode(%p, %p, %d)\n", fs, node, reenter)); - status_t error = volume->WriteVNode(node, reenter); +// PRINT(("userlandfs_put_vnode(%p, %p, %d)\n", volume, fsNode->private_node, +// reenter)); + status_t error = volume->WriteVNode(fsNode->private_node, reenter); // PRINT(("userlandfs_put_vnode() done: %lx\n", error)); return error; } // userlandfs_remove_vnode static status_t -userlandfs_remove_vnode(fs_volume fs, fs_vnode node, bool reenter) +userlandfs_remove_vnode(fs_volume* fsVolume, fs_vnode* fsNode, bool reenter) { - Volume* volume = (Volume*)fs; + Volume* volume = (Volume*)fsVolume->private_volume; // DANGER: See userlandfs_write_vnode(). -// PRINT(("userlandfs_remove_vnode(%p, %p, %d)\n", fs, node, reenter)); - status_t error = volume->RemoveVNode(node, reenter); +// PRINT(("userlandfs_remove_vnode(%p, %p, %d)\n", volume, +// fsNode->private_node, reenter)); + status_t error = volume->RemoveVNode(fsNode->private_node, reenter); // PRINT(("userlandfs_remove_vnode() done: %lx\n", error)); return error; } @@ -239,6 +256,13 @@ userlandfs_remove_vnode(fs_volume fs, fs_vnode node, bool reenter) // TODO: userlandfs_write_pages() +// #pragma mark - asynchronous I/O + + +// TODO: userlandfs_io() +// TODO: userlandfs_cancel_io() + + // #pragma mark - cache file access @@ -250,158 +274,170 @@ userlandfs_remove_vnode(fs_volume fs, fs_vnode node, bool reenter) // userlandfs_ioctl static status_t -userlandfs_ioctl(fs_volume fs, fs_vnode node, fs_cookie cookie, ulong op, - void *buffer, size_t length) +userlandfs_ioctl(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie, ulong op, + void* buffer, size_t length) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_ioctl(%p, %p, %p, %lu, %p, %lu)\n", fs, node, cookie, op, - buffer, length)); - status_t error = volume->IOCtl(node, cookie, op, buffer, length); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_ioctl(%p, %p, %p, %lu, %p, %lu)\n", volume, + fsNode->private_node, cookie, op, buffer, length)); + status_t error = volume->IOCtl(fsNode->private_node, cookie, op, buffer, + length); PRINT(("userlandfs_ioctl() done: (%lx)\n", error)); return error; } // userlandfs_set_flags static status_t -userlandfs_set_flags(fs_volume fs, fs_vnode node, fs_cookie cookie, int flags) +userlandfs_set_flags(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie, + int flags) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_set_flags(%p, %p, %p, %d)\n", fs, node, cookie, flags)); - status_t error = volume->SetFlags(node, cookie, flags); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_set_flags(%p, %p, %p, %d)\n", fs, fsNode->private_node, + cookie, flags)); + status_t error = volume->SetFlags(fsNode->private_node, cookie, flags); PRINT(("userlandfs_set_flags() done: (%lx)\n", error)); return error; } // userlandfs_select static status_t -userlandfs_select(fs_volume fs, fs_vnode node, fs_cookie cookie, - uint8 event, uint32 ref, selectsync *sync) +userlandfs_select(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie, + uint8 event, selectsync* sync) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_select(%p, %p, %p, %hhd, %lu, %p)\n", fs, node, cookie, - event, ref, sync)); - status_t error = volume->Select(node, cookie, event, ref, sync); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_select(%p, %p, %p, %hhd, %p)\n", volume, + fsNode->private_node, cookie, event, sync)); + status_t error = volume->Select(fsNode->private_node, cookie, event, sync); PRINT(("userlandfs_select() done: (%lx)\n", error)); return error; } // userlandfs_deselect static status_t -userlandfs_deselect(fs_volume fs, fs_vnode node, fs_cookie cookie, uint8 event, - selectsync *sync) +userlandfs_deselect(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie, + uint8 event, selectsync* sync) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_deselect(%p, %p, %p, %hhd, %p)\n", fs, node, cookie, - event, sync)); - status_t error = volume->Deselect(node, cookie, event, sync); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_deselect(%p, %p, %p, %hhd, %p)\n", volume, + fsNode->private_node, cookie, event, sync)); + status_t error = volume->Deselect(fsNode->private_node, cookie, event, + sync); PRINT(("userlandfs_deselect() done: (%lx)\n", error)); return error; } // userlandfs_fsync static status_t -userlandfs_fsync(fs_volume fs, fs_vnode node) +userlandfs_fsync(fs_volume* fsVolume, fs_vnode* fsNode) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_fsync(%p, %p)\n", fs, node)); - status_t error = volume->FSync(node); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_fsync(%p, %p)\n", volume, fsNode->private_node)); + status_t error = volume->FSync(fsNode->private_node); PRINT(("userlandfs_fsync() done: %lx\n", error)); return error; } // userlandfs_read_symlink static status_t -userlandfs_read_symlink(fs_volume fs, fs_vnode link, char *buffer, - size_t *bufferSize) +userlandfs_read_symlink(fs_volume* fsVolume, fs_vnode* fsLink, char* buffer, + size_t* bufferSize) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_read_symlink(%p, %p, %p, %lu)\n", fs, link, buffer, - *bufferSize)); - status_t error = volume->ReadSymlink(link, buffer, *bufferSize, bufferSize); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_read_symlink(%p, %p, %p, %lu)\n", volume, + fsLink->private_node, buffer, *bufferSize)); + status_t error = volume->ReadSymlink(fsLink->private_node, buffer, + *bufferSize, bufferSize); PRINT(("userlandfs_read_symlink() done: (%lx, %lu)\n", error, *bufferSize)); return error; } -// TODO: userlandfs_write_symlink - // userlandfs_create_symlink static status_t -userlandfs_create_symlink(fs_volume fs, fs_vnode dir, const char *name, - const char *path, int mode) +userlandfs_create_symlink(fs_volume* fsVolume, fs_vnode* fsDir, + const char* name, const char* path, int mode) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_create_symlink(%p, %p, `%s', `%s', %d)\n", fs, dir, name, - path, mode)); - status_t error = volume->CreateSymlink(dir, name, path, mode); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_create_symlink(%p, %p, `%s', `%s', %d)\n", volume, + fsDir->private_node, name, path, mode)); + status_t error = volume->CreateSymlink(fsDir->private_node, name, path, + mode); PRINT(("userlandfs_create_symlink() done: (%lx)\n", error)); return error; } // userlandfs_link static status_t -userlandfs_link(fs_volume fs, fs_vnode dir, const char *name, fs_vnode node) +userlandfs_link(fs_volume* fsVolume, fs_vnode* fsDir, const char* name, + fs_vnode* fsNode) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_link(%p, %p, `%s', %p)\n", fs, dir, name, node)); - status_t error = volume->Link(dir, name, node); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_link(%p, %p, `%s', %p)\n", volume, + fsDir->private_node, name, node)); + status_t error = volume->Link(fsDir->private_node, name, + fsNode->private_node); PRINT(("userlandfs_link() done: (%lx)\n", error)); return error; } // userlandfs_unlink static status_t -userlandfs_unlink(fs_volume fs, fs_vnode dir, const char *name) +userlandfs_unlink(fs_volume* fsVolume, fs_vnode* fsDir, const char* name) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_unlink(%p, %p, `%s')\n", fs, dir, name)); - status_t error = volume->Unlink(dir, name); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_unlink(%p, %p, `%s')\n", volume, fsDir->private_node, + name)); + status_t error = volume->Unlink(fsDir->private_node, name); PRINT(("userlandfs_unlink() done: (%lx)\n", error)); return error; } // userlandfs_rename static status_t -userlandfs_rename(fs_volume fs, fs_vnode fromDir, const char *fromName, - fs_vnode toDir, const char *toName) +userlandfs_rename(fs_volume* fsVolume, fs_vnode* fsFromDir, + const char *fromName, fs_vnode* fsToDir, const char *toName) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_rename(%p, %p, `%s', %p, `%s')\n", fs, fromDir, fromName, - toDir, toName)); - status_t error = volume->Rename(fromDir, fromName, toDir, toName); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_rename(%p, %p, `%s', %p, `%s')\n", volume, + fsFromDir->private_node, fromName, fsToDir->private_node, toName)); + status_t error = volume->Rename(fsFromDir->private_node, fromName, + fsToDir->private_node, toName); PRINT(("userlandfs_rename() done: (%lx)\n", error)); return error; } // userlandfs_access static status_t -userlandfs_access(fs_volume fs, fs_vnode node, int mode) +userlandfs_access(fs_volume* fsVolume, fs_vnode* fsNode, int mode) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_access(%p, %p, %d)\n", fs, node, mode)); - status_t error = volume->Access(node, mode); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_access(%p, %p, %d)\n", volume, fsNode->private_node, + mode)); + status_t error = volume->Access(fsNode->private_node, mode); PRINT(("userlandfs_access() done: %lx\n", error)); return error; } // userlandfs_read_stat static status_t -userlandfs_read_stat(fs_volume fs, fs_vnode node, struct stat *st) +userlandfs_read_stat(fs_volume* fsVolume, fs_vnode* fsNode, struct stat* st) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_read_stat(%p, %p, %p)\n", fs, node, st)); - status_t error = volume->ReadStat(node, st); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_read_stat(%p, %p, %p)\n", volume, fsNode->private_node, + st)); + status_t error = volume->ReadStat(fsNode->private_node, st); PRINT(("userlandfs_read_stat() done: %lx\n", error)); return error; } // userlandfs_write_stat static status_t -userlandfs_write_stat(fs_volume fs, fs_vnode node, const struct stat *st, - uint32 mask) +userlandfs_write_stat(fs_volume* fsVolume, fs_vnode* fsNode, + const struct stat* st, uint32 mask) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_write_stat(%p, %p, %p, %ld)\n", fs, node, st, mask)); - status_t error = volume->WriteStat(node, st, mask); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_write_stat(%p, %p, %p, %ld)\n", volume, + fsNode->private_node, st, mask)); + status_t error = volume->WriteStat(fsNode->private_node, st, mask); PRINT(("userlandfs_write_stat() done: %lx\n", error)); return error; } @@ -412,13 +448,14 @@ userlandfs_write_stat(fs_volume fs, fs_vnode node, const struct stat *st, // userlandfs_create static status_t -userlandfs_create(fs_volume fs, fs_vnode dir, const char *name, int openMode, - int perms, fs_cookie *cookie, ino_t *vnid) +userlandfs_create(fs_volume* fsVolume, fs_vnode* fsDir, const char* name, + int openMode, int perms, void** cookie, ino_t* vnid) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_create(%p, %p, `%s', %d, %d, %p, %p)\n", fs, dir, - name, openMode, perms, cookie, vnid)); - status_t error = volume->Create(dir, name, openMode, perms, cookie, vnid); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_create(%p, %p, `%s', %d, %d, %p, %p)\n", volume, + fsDir->private_node, name, openMode, perms, cookie, vnid)); + status_t error = volume->Create(fsDir->private_node, name, openMode, perms, + cookie, vnid); PRINT(("userlandfs_create() done: (%lx, %lld, %p)\n", error, *vnid, *cookie)); return error; @@ -426,60 +463,65 @@ userlandfs_create(fs_volume fs, fs_vnode dir, const char *name, int openMode, // userlandfs_open static status_t -userlandfs_open(fs_volume fs, fs_vnode node, int openMode, fs_cookie *cookie) +userlandfs_open(fs_volume* fsVolume, fs_vnode* fsNode, int openMode, + void** cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_open(%p, %p, %d)\n", fs, node, openMode)); - status_t error = volume->Open(node, openMode, cookie); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_open(%p, %p, %d)\n", volume, fsNode->private_node, + openMode)); + status_t error = volume->Open(fsNode->private_node, openMode, cookie); PRINT(("userlandfs_open() done: (%lx, %p)\n", error, *cookie)); return error; } // userlandfs_close static status_t -userlandfs_close(fs_volume fs, fs_vnode node, fs_cookie cookie) +userlandfs_close(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_close(%p, %p, %p)\n", fs, node, cookie)); - status_t error = volume->Close(node, cookie); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_close(%p, %p, %p)\n", volume, fsNode->private_node, + cookie)); + status_t error = volume->Close(fsNode->private_node, cookie); PRINT(("userlandfs_close() done: %lx\n", error)); return error; } // userlandfs_free_cookie static status_t -userlandfs_free_cookie(fs_volume fs, fs_vnode node, fs_cookie cookie) +userlandfs_free_cookie(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_free_cookie(%p, %p, %p)\n", fs, node, cookie)); - status_t error = volume->FreeCookie(node, cookie); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_free_cookie(%p, %p, %p)\n", volume, fsNode->private_node, + cookie)); + status_t error = volume->FreeCookie(fsNode->private_node, cookie); PRINT(("userlandfs_free_cookie() done: %lx\n", error)); return error; } // userlandfs_read static status_t -userlandfs_read(fs_volume fs, fs_vnode node, fs_cookie cookie, off_t pos, - void *buffer, size_t *length) +userlandfs_read(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie, off_t pos, + void* buffer, size_t* length) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_read(%p, %p, %p, %Ld, %p, %lu)\n", fs, node, cookie, pos, - buffer, *length)); - status_t error = volume->Read(node, cookie, pos, buffer, *length, - length); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_read(%p, %p, %p, %Ld, %p, %lu)\n", volume, + fsNode->private_node, cookie, pos, buffer, *length)); + status_t error = volume->Read(fsNode->private_node, cookie, pos, buffer, + *length, length); PRINT(("userlandfs_read() done: (%lx, %lu)\n", error, *length)); return error; } // userlandfs_write static status_t -userlandfs_write(fs_volume fs, fs_vnode node, fs_cookie cookie, off_t pos, - const void *buffer, size_t *length) +userlandfs_write(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie, off_t pos, + const void* buffer, size_t* length) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_write(%p, %p, %p, %Ld, %p, %lu)\n", fs, node, cookie, - pos, buffer, *length)); - status_t error = volume->Write(node, cookie, pos, buffer, *length, length); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_write(%p, %p, %p, %Ld, %p, %lu)\n", volume, + fsNode->private_node, cookie, pos, buffer, *length)); + status_t error = volume->Write(fsNode->private_node, cookie, pos, buffer, + *length, length); PRINT(("userlandfs_write() done: (%lx, %lu)\n", error, *length)); return error; } @@ -490,71 +532,75 @@ userlandfs_write(fs_volume fs, fs_vnode node, fs_cookie cookie, off_t pos, // userlandfs_create_dir static status_t -userlandfs_create_dir(fs_volume fs, fs_vnode parent, const char *name, - int perms, ino_t *newDir) +userlandfs_create_dir(fs_volume* fsVolume, fs_vnode* fsParent, const char* name, + int perms, ino_t* newDir) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_create_dir(%p, %p, `%s', %d, %p)\n", fs, parent, name, - perms, newDir)); - status_t error = volume->CreateDir(parent, name, perms, newDir); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_create_dir(%p, %p, `%s', %d, %p)\n", volume, + fsParent->private_node, name, perms, newDir)); + status_t error = volume->CreateDir(fsParent->private_node, name, perms, + newDir); PRINT(("userlandfs_create_dir() done: (%lx, %lld)\n", error, *newDir)); return error; } // userlandfs_remove_dir static status_t -userlandfs_remove_dir(fs_volume fs, fs_vnode parent, const char *name) +userlandfs_remove_dir(fs_volume* fsVolume, fs_vnode* fsParent, const char* name) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_remove_dir(%p, %p, `%s')\n", fs, parent, name)); - status_t error = volume->RemoveDir(parent, name); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_remove_dir(%p, %p, `%s')\n", volume, + fsParent->private_node, name)); + status_t error = volume->RemoveDir(fsParent->private_node, name); PRINT(("userlandfs_remove_dir() done: (%lx)\n", error)); return error; } // userlandfs_open_dir static status_t -userlandfs_open_dir(fs_volume fs, fs_vnode node, fs_cookie *cookie) +userlandfs_open_dir(fs_volume* fsVolume, fs_vnode* fsNode, void** cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_open_dir(%p, %p)\n", fs, node)); - status_t error = volume->OpenDir(node, cookie); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_open_dir(%p, %p)\n", volume, fsNode->private_node)); + status_t error = volume->OpenDir(fsNode->private_node, cookie); PRINT(("userlandfs_open_dir() done: (%lx, %p)\n", error, *cookie)); return error; } // userlandfs_close_dir static status_t -userlandfs_close_dir(fs_volume fs, fs_vnode node, fs_cookie cookie) +userlandfs_close_dir(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_close_dir(%p, %p, %p)\n", fs, node, cookie)); - status_t error = volume->CloseDir(node, cookie); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_close_dir(%p, %p, %p)\n", volume, fsNode->private_node, + cookie)); + status_t error = volume->CloseDir(fsNode->private_node, cookie); PRINT(("userlandfs_close_dir() done: %lx\n", error)); return error; } // userlandfs_free_dir_cookie static status_t -userlandfs_free_dir_cookie(fs_volume fs, fs_vnode node, fs_cookie cookie) +userlandfs_free_dir_cookie(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_free_dir_cookie(%p, %p, %p)\n", fs, node, cookie)); - status_t error = volume->FreeDirCookie(node, cookie); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_free_dir_cookie(%p, %p, %p)\n", volume, + fsNode->private_node, cookie)); + status_t error = volume->FreeDirCookie(fsNode->private_node, cookie); PRINT(("userlandfs_free_dir_cookie() done: %lx \n", error)); return error; } // userlandfs_read_dir static status_t -userlandfs_read_dir(fs_volume fs, fs_vnode node, fs_cookie cookie, - struct dirent *buffer, size_t bufferSize, uint32 *count) +userlandfs_read_dir(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie, + struct dirent* buffer, size_t bufferSize, uint32* count) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_read_dir(%p, %p, %p, %p, %lu, %lu)\n", fs, node, cookie, - buffer, bufferSize, *count)); - status_t error = volume->ReadDir(node, cookie, buffer, bufferSize, *count, - count); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_read_dir(%p, %p, %p, %p, %lu, %lu)\n", volume, + fsNode->private_node, cookie, buffer, bufferSize, *count)); + status_t error = volume->ReadDir(fsNode->private_node, cookie, buffer, + bufferSize, *count, count); PRINT(("userlandfs_read_dir() done: (%lx, %lu)\n", error, *count)); #if DEBUG dirent* entry = buffer; @@ -577,11 +623,12 @@ userlandfs_read_dir(fs_volume fs, fs_vnode node, fs_cookie cookie, // userlandfs_rewind_dir static status_t -userlandfs_rewind_dir(fs_volume fs, fs_vnode node, fs_cookie cookie) +userlandfs_rewind_dir(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_rewind_dir(%p, %p, %p)\n", fs, node, cookie)); - status_t error = volume->RewindDir(node, cookie); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_rewind_dir(%p, %p, %p)\n", volume, fsNode->private_node, + cookie)); + status_t error = volume->RewindDir(fsNode->private_node, cookie); PRINT(("userlandfs_rewind_dir() done: %lx\n", error)); return error; } @@ -592,58 +639,62 @@ userlandfs_rewind_dir(fs_volume fs, fs_vnode node, fs_cookie cookie) // userlandfs_open_attr_dir static status_t -userlandfs_open_attr_dir(fs_volume fs, fs_vnode node, fs_cookie *cookie) +userlandfs_open_attr_dir(fs_volume* fsVolume, fs_vnode* fsNode, void** cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_open_attr_dir(%p, %p)\n", fs, node)); - status_t error = volume->OpenAttrDir(node, cookie); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_open_attr_dir(%p, %p)\n", volume, fsNode->private_node)); + status_t error = volume->OpenAttrDir(fsNode->private_node, cookie); PRINT(("userlandfs_open_attr_dir() done: (%lx, %p)\n", error, *cookie)); return error; } // userlandfs_close_attr_dir static status_t -userlandfs_close_attr_dir(fs_volume fs, fs_vnode node, fs_cookie cookie) +userlandfs_close_attr_dir(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_close_attr_dir(%p, %p, %p)\n", fs, node, cookie)); - status_t error = volume->CloseAttrDir(node, cookie); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_close_attr_dir(%p, %p, %p)\n", volume, + fsNode->private_node, cookie)); + status_t error = volume->CloseAttrDir(fsNode->private_node, cookie); PRINT(("userlandfs_close_attr_dir() done: (%lx)\n", error)); return error; } // userlandfs_free_attr_dir_cookie static status_t -userlandfs_free_attr_dir_cookie(fs_volume fs, fs_vnode node, fs_cookie cookie) +userlandfs_free_attr_dir_cookie(fs_volume* fsVolume, fs_vnode* fsNode, + void* cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_free_attr_dir_cookie(%p, %p, %p)\n", fs, node, cookie)); - status_t error = volume->FreeAttrDirCookie(node, cookie); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_free_attr_dir_cookie(%p, %p, %p)\n", volume, + fsNode->private_node, cookie)); + status_t error = volume->FreeAttrDirCookie(fsNode->private_node, cookie); PRINT(("userlandfs_free_attr_dir_cookie() done: (%lx)\n", error)); return error; } // userlandfs_read_attr_dir static status_t -userlandfs_read_attr_dir(fs_volume fs, fs_vnode node, fs_cookie cookie, - struct dirent *buffer, size_t bufferSize, uint32 *count) +userlandfs_read_attr_dir(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie, + struct dirent* buffer, size_t bufferSize, uint32* count) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_read_attr_dir(%p, %p, %p, %p, %lu, %lu)\n", fs, node, - cookie, buffer, bufferSize, *count)); - status_t error = volume->ReadAttrDir(node, cookie, buffer, bufferSize, - *count, count); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_read_attr_dir(%p, %p, %p, %p, %lu, %lu)\n", volume, + fsNode->private_node, cookie, buffer, bufferSize, *count)); + status_t error = volume->ReadAttrDir(fsNode->private_node, cookie, buffer, + bufferSize, *count, count); PRINT(("userlandfs_read_attr_dir() done: (%lx, %lu)\n", error, *count)); return error; } // userlandfs_rewind_attr_dir static status_t -userlandfs_rewind_attr_dir(fs_volume fs, fs_vnode node, fs_cookie cookie) +userlandfs_rewind_attr_dir(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_rewind_attr_dir(%p, %p, %p)\n", fs, node, cookie)); - status_t error = volume->RewindAttrDir(node, cookie); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_rewind_attr_dir(%p, %p, %p)\n", volume, + fsNode->private_node, cookie)); + status_t error = volume->RewindAttrDir(fsNode->private_node, cookie); PRINT(("userlandfs_rewind_attr_dir() done: (%lx)\n", error)); return error; } @@ -654,126 +705,133 @@ userlandfs_rewind_attr_dir(fs_volume fs, fs_vnode node, fs_cookie cookie) // userlandfs_create_attr status_t -userlandfs_create_attr(fs_volume fs, fs_vnode node, const char *name, - uint32 type, int openMode, fs_cookie *cookie) +userlandfs_create_attr(fs_volume* fsVolume, fs_vnode* fsNode, const char* name, + uint32 type, int openMode, void** cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_create_attr(%p, %p, \"%s\", 0x%lx, %d, %p)\n", fs, node, - name, type, openMode, cookie)); - status_t error = volume->CreateAttr(node, name, type, openMode, cookie); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_create_attr(%p, %p, \"%s\", 0x%lx, %d, %p)\n", volume, + fsNode->private_node, name, type, openMode, cookie)); + status_t error = volume->CreateAttr(fsNode->private_node, name, type, + openMode, cookie); PRINT(("userlandfs_create_attr() done: (%lx, %p)\n", error, *cookie)); return error; } // userlandfs_open_attr status_t -userlandfs_open_attr(fs_volume fs, fs_vnode node, const char *name, - int openMode, fs_cookie *cookie) +userlandfs_open_attr(fs_volume* fsVolume, fs_vnode* fsNode, const char* name, + int openMode, void** cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_open_attr(%p, %p, \"%s\", %d, %p)\n", fs, node, name, - openMode, cookie)); - status_t error = volume->OpenAttr(node, name, openMode, cookie); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_open_attr(%p, %p, \"%s\", %d, %p)\n", volume, + fsNode->private_node, name, openMode, cookie)); + status_t error = volume->OpenAttr(fsNode->private_node, name, openMode, + cookie); PRINT(("userlandfs_open_attr() done: (%lx, %p)\n", error, *cookie)); return error; } // userlandfs_close_attr status_t -userlandfs_close_attr(fs_volume fs, fs_vnode node, fs_cookie cookie) +userlandfs_close_attr(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_close_attr(%p, %p, %p)\n", fs, node, cookie)); - status_t error = volume->CloseAttr(node, cookie); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_close_attr(%p, %p, %p)\n", volume, fsNode->private_node, + cookie)); + status_t error = volume->CloseAttr(fsNode->private_node, cookie); PRINT(("userlandfs_close_attr() done: %lx\n", error)); return error; } // userlandfs_free_attr_cookie status_t -userlandfs_free_attr_cookie(fs_volume fs, fs_vnode node, fs_cookie cookie) +userlandfs_free_attr_cookie(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_free_attr_cookie(%p, %p, %p)\n", fs, node, cookie)); - status_t error = volume->FreeAttrCookie(node, cookie); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_free_attr_cookie(%p, %p, %p)\n", volume, + fsNode->private_node, cookie)); + status_t error = volume->FreeAttrCookie(fsNode->private_node, cookie); PRINT(("userlandfs_free_attr_cookie() done: %lx\n", error)); return error; } // userlandfs_read_attr static status_t -userlandfs_read_attr(fs_volume fs, fs_vnode node, fs_cookie cookie, - off_t pos, void *buffer, size_t *length) +userlandfs_read_attr(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie, + off_t pos, void* buffer, size_t* length) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_read_attr(%p, %p, %p, %lld, %p, %lu)\n", fs, node, - cookie, pos, buffer, *length)); - status_t error = volume->ReadAttr(node, cookie, pos, buffer, *length, - length); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_read_attr(%p, %p, %p, %lld, %p, %lu)\n", volume, + fsNode->private_node, cookie, pos, buffer, *length)); + status_t error = volume->ReadAttr(fsNode->private_node, cookie, pos, buffer, + *length, length); PRINT(("userlandfs_read_attr() done: (%lx, %lu)\n", error, *length)); return error; } // userlandfs_write_attr static status_t -userlandfs_write_attr(fs_volume fs, fs_vnode node, fs_cookie cookie, - off_t pos, const void *buffer, size_t *length) +userlandfs_write_attr(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie, + off_t pos, const void* buffer, size_t* length) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_write_attr(%p, %p, %p, %lld, %p, %lu)\n", fs, node, - cookie, pos, buffer, *length)); - status_t error = volume->WriteAttr(node, cookie, pos, buffer, *length, - length); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_write_attr(%p, %p, %p, %lld, %p, %lu)\n", volume, + fsNode->private_node, cookie, pos, buffer, *length)); + status_t error = volume->WriteAttr(fsNode->private_node, cookie, pos, + buffer, *length, length); PRINT(("userlandfs_write_attr() done: (%lx, %lu)\n", error, *length)); return error; } // userlandfs_read_attr_stat static status_t -userlandfs_read_attr_stat(fs_volume fs, fs_vnode node, fs_cookie cookie, - struct stat *st) +userlandfs_read_attr_stat(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie, + struct stat* st) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_read_attr_stat(%p, %p, %p, %p)\n", fs, node, cookie, - st)); - status_t error = volume->ReadAttrStat(node, cookie, st); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_read_attr_stat(%p, %p, %p, %p)\n", volume, + fsNode->private_node, cookie, st)); + status_t error = volume->ReadAttrStat(fsNode->private_node, cookie, st); PRINT(("userlandfs_read_attr_stat() done: (%lx)\n", error)); return error; } // userlandfs_write_attr_stat static status_t -userlandfs_write_attr_stat(fs_volume fs, fs_vnode node, fs_cookie cookie, - const struct stat *st, int statMask) +userlandfs_write_attr_stat(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie, + const struct stat* st, int statMask) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_write_attr_stat(%p, %p, %p, %p, 0x%x)\n", fs, node, - cookie, st, statMask)); - status_t error = volume->WriteAttrStat(node, cookie, st, statMask); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_write_attr_stat(%p, %p, %p, %p, 0x%x)\n", volume, + fsNode->private_node, cookie, st, statMask)); + status_t error = volume->WriteAttrStat(fsNode->private_node, cookie, st, + statMask); PRINT(("userlandfs_write_attr_stat() done: (%lx)\n", error)); return error; } // userlandfs_rename_attr static status_t -userlandfs_rename_attr(fs_volume fs, fs_vnode fromNode, const char *fromName, - fs_vnode toNode, const char *toName) +userlandfs_rename_attr(fs_volume* fsVolume, fs_vnode* fsFromNode, + const char* fromName, fs_vnode* fsToNode, const char* toName) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_rename_attr(%p, %p, `%s', %p, `%s')\n", fs, fromNode, - fromName, toNode, toName)); - status_t error = volume->RenameAttr(fromNode, fromName, toNode, toName); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_rename_attr(%p, %p, `%s', %p, `%s')\n", volume, + fsFromNode->private_node, fromName, fsToNode->private_node, toName)); + status_t error = volume->RenameAttr(fsFromNode->private_node, fromName, + fsToNode->private_node, toName); PRINT(("userlandfs_rename_attr() done: (%lx)\n", error)); return error; } // userlandfs_remove_attr static status_t -userlandfs_remove_attr(fs_volume fs, fs_vnode node, const char *name) +userlandfs_remove_attr(fs_volume* fsVolume, fs_vnode* fsNode, const char* name) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_remove_attr(%p, %p, `%s')\n", fs, node, name)); - status_t error = volume->RemoveAttr(node, name); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_remove_attr(%p, %p, `%s')\n", volume, + fsNode->private_node, name)); + status_t error = volume->RemoveAttr(fsNode->private_node, name); PRINT(("userlandfs_remove_attr() done: (%lx)\n", error)); return error; } @@ -784,10 +842,10 @@ userlandfs_remove_attr(fs_volume fs, fs_vnode node, const char *name) // userlandfs_open_index_dir static status_t -userlandfs_open_index_dir(fs_volume fs, fs_cookie *cookie) +userlandfs_open_index_dir(fs_volume* fsVolume, void** cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_open_index_dir(%p, %p)\n", fs, cookie)); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_open_index_dir(%p, %p)\n", volume, cookie)); status_t error = volume->OpenIndexDir(cookie); PRINT(("userlandfs_open_index_dir() done: (%lx, %p)\n", error, *cookie)); return error; @@ -795,10 +853,10 @@ userlandfs_open_index_dir(fs_volume fs, fs_cookie *cookie) // userlandfs_close_index_dir static status_t -userlandfs_close_index_dir(fs_volume fs, fs_cookie cookie) +userlandfs_close_index_dir(fs_volume* fsVolume, void* cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_close_index_dir(%p, %p)\n", fs, cookie)); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_close_index_dir(%p, %p)\n", volume, cookie)); status_t error = volume->CloseIndexDir(cookie); PRINT(("userlandfs_close_index_dir() done: (%lx)\n", error)); return error; @@ -806,10 +864,10 @@ userlandfs_close_index_dir(fs_volume fs, fs_cookie cookie) // userlandfs_free_index_dir_cookie static status_t -userlandfs_free_index_dir_cookie(fs_volume fs, fs_cookie cookie) +userlandfs_free_index_dir_cookie(fs_volume* fsVolume, void* cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_free_index_dir_cookie(%p, %p)\n", fs, cookie)); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_free_index_dir_cookie(%p, %p)\n", volume, cookie)); status_t error = volume->FreeIndexDirCookie(cookie); PRINT(("userlandfs_free_index_dir_cookie() done: (%lx)\n", error)); return error; @@ -817,11 +875,11 @@ userlandfs_free_index_dir_cookie(fs_volume fs, fs_cookie cookie) // userlandfs_read_index_dir static status_t -userlandfs_read_index_dir(fs_volume fs, fs_cookie cookie, - struct dirent *buffer, size_t bufferSize, uint32 *count) +userlandfs_read_index_dir(fs_volume* fsVolume, void* cookie, + struct dirent* buffer, size_t bufferSize, uint32* count) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_read_index_dir(%p, %p, %p, %lu, %lu)\n", fs, cookie, + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_read_index_dir(%p, %p, %p, %lu, %lu)\n", volume, cookie, buffer, bufferSize, *count)); status_t error = volume->ReadIndexDir(cookie, buffer, bufferSize, *count, count); @@ -831,10 +889,10 @@ userlandfs_read_index_dir(fs_volume fs, fs_cookie cookie, // userlandfs_rewind_index_dir static status_t -userlandfs_rewind_index_dir(fs_volume fs, fs_cookie cookie) +userlandfs_rewind_index_dir(fs_volume* fsVolume, void* cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_rewind_index_dir(%p, %p)\n", fs, cookie)); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_rewind_index_dir(%p, %p)\n", volume, cookie)); status_t error = volume->RewindIndexDir(cookie); PRINT(("userlandfs_rewind_index_dir() done: (%lx)\n", error)); return error; @@ -842,12 +900,12 @@ userlandfs_rewind_index_dir(fs_volume fs, fs_cookie cookie) // userlandfs_create_index static status_t -userlandfs_create_index(fs_volume fs, const char *name, uint32 type, +userlandfs_create_index(fs_volume* fsVolume, const char* name, uint32 type, uint32 flags) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_create_index(%p, `%s', 0x%lx, 0x%lx)\n", fs, name, type, - flags)); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_create_index(%p, `%s', 0x%lx, 0x%lx)\n", volume, name, + type, flags)); status_t error = volume->CreateIndex(name, type, flags); PRINT(("userlandfs_create_index() done: (%lx)\n", error)); return error; @@ -855,10 +913,10 @@ userlandfs_create_index(fs_volume fs, const char *name, uint32 type, // userlandfs_remove_index static status_t -userlandfs_remove_index(fs_volume fs, const char *name) +userlandfs_remove_index(fs_volume* fsVolume, const char* name) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_remove_index(%p, `%s')\n", fs, name)); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_remove_index(%p, `%s')\n", volume, name)); status_t error = volume->RemoveIndex(name); PRINT(("userlandfs_remove_index() done: (%lx)\n", error)); return error; @@ -866,10 +924,11 @@ userlandfs_remove_index(fs_volume fs, const char *name) // userlandfs_read_index_stat static status_t -userlandfs_read_index_stat(fs_volume fs, const char *name, struct stat *st) +userlandfs_read_index_stat(fs_volume* fsVolume, const char* name, + struct stat* st) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_read_index_stat(%p, `%s', %p)\n", fs, name, st)); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_read_index_stat(%p, `%s', %p)\n", volume, name, st)); status_t error = volume->ReadIndexStat(name, st); PRINT(("userlandfs_read_index_stat() done: (%lx)\n", error)); return error; @@ -881,11 +940,11 @@ userlandfs_read_index_stat(fs_volume fs, const char *name, struct stat *st) // userlandfs_open_query static status_t -userlandfs_open_query(fs_volume fs, const char *queryString, uint32 flags, - port_id port, uint32 token, fs_cookie *cookie) +userlandfs_open_query(fs_volume* fsVolume, const char *queryString, + uint32 flags, port_id port, uint32 token, void** cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_open_query(%p, `%s', %lu, %ld, %lu, %p)\n", fs, + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_open_query(%p, `%s', %lu, %ld, %lu, %p)\n", volume, queryString, flags, port, token, cookie)); status_t error = volume->OpenQuery(queryString, flags, port, token, cookie); PRINT(("userlandfs_open_query() done: (%lx, %p)\n", error, *cookie)); @@ -894,10 +953,10 @@ userlandfs_open_query(fs_volume fs, const char *queryString, uint32 flags, // userlandfs_close_query static status_t -userlandfs_close_query(fs_volume fs, fs_cookie cookie) +userlandfs_close_query(fs_volume* fsVolume, void* cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_close_query(%p, %p)\n", fs, cookie)); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_close_query(%p, %p)\n", volume, cookie)); status_t error = volume->CloseQuery(cookie); PRINT(("userlandfs_close_query() done: (%lx)\n", error)); return error; @@ -905,10 +964,10 @@ userlandfs_close_query(fs_volume fs, fs_cookie cookie) // userlandfs_free_query_cookie static status_t -userlandfs_free_query_cookie(fs_volume fs, fs_cookie cookie) +userlandfs_free_query_cookie(fs_volume* fsVolume, void* cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_free_query_cookie(%p, %p)\n", fs, cookie)); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_free_query_cookie(%p, %p)\n", volume, cookie)); status_t error = volume->FreeQueryCookie(cookie); PRINT(("userlandfs_free_query_cookie() done: (%lx)\n", error)); return error; @@ -916,11 +975,11 @@ userlandfs_free_query_cookie(fs_volume fs, fs_cookie cookie) // userlandfs_read_query static status_t -userlandfs_read_query(fs_volume fs, fs_cookie cookie, - struct dirent *buffer, size_t bufferSize, uint32 *count) +userlandfs_read_query(fs_volume* fsVolume, void* cookie, + struct dirent* buffer, size_t bufferSize, uint32* count) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_read_query(%p, %p, %p, %lu, %lu)\n", fs, cookie, + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_read_query(%p, %p, %p, %lu, %lu)\n", volume, cookie, buffer, bufferSize, *count)); status_t error = volume->ReadQuery(cookie, buffer, bufferSize, *count, count); @@ -944,10 +1003,10 @@ userlandfs_read_query(fs_volume fs, fs_cookie cookie, // userlandfs_rewind_query static status_t -userlandfs_rewind_query(fs_volume fs, fs_cookie cookie) +userlandfs_rewind_query(fs_volume* fsVolume, void* cookie) { - Volume* volume = (Volume*)fs; - PRINT(("userlandfs_rewind_query(%p, %p)\n", fs, cookie)); + Volume* volume = (Volume*)fsVolume->private_volume; + PRINT(("userlandfs_rewind_query(%p, %p)\n", volume, cookie)); status_t error = volume->RewindQuery(cookie); PRINT(("userlandfs_rewind_query() done: (%lx)\n", error)); return error; @@ -1043,26 +1102,87 @@ static file_system_module_info sUserlandFSModuleInfo = { NULL, // free_identify_partition_cookie() NULL, // free_partition_content_cookie() + // general operations &userlandfs_mount, + + // capability querying + NULL, // get_supported_operations() + NULL, // validate_resize() + NULL, // validate_move() + NULL, // validate_set_content_name() + NULL, // validate_set_content_parameters() + NULL, // validate_initialize() + + // shadow partition modification + NULL, // shadow_changed() + + // writing + NULL, // defragment() + NULL, // repair() + NULL, // resize() + NULL, // move() + NULL, // set_content_name() + NULL, // set_content_parameters() + NULL // initialize() +}; + + +fs_volume_ops gUserlandFSVolumeOps = { + // general operations &userlandfs_unmount, &userlandfs_read_fs_info, &userlandfs_write_fs_info, &userlandfs_sync, - /* vnode operations */ + &userlandfs_get_vnode, + + // index directory & index operations + &userlandfs_open_index_dir, + &userlandfs_close_index_dir, + &userlandfs_free_index_dir_cookie, + &userlandfs_read_index_dir, + &userlandfs_rewind_index_dir, + + &userlandfs_create_index, + &userlandfs_remove_index, + &userlandfs_read_index_stat, + + // query operations + &userlandfs_open_query, + &userlandfs_close_query, + &userlandfs_free_query_cookie, + &userlandfs_read_query, + &userlandfs_rewind_query, + + /* support for FS layers */ + NULL, // all_layers_mounted() + NULL, // create_sub_vnode() + NULL // delete_sub_vnode() +}; + + +fs_vnode_ops gUserlandFSVnodeOps = { + // vnode operations &userlandfs_lookup, &userlandfs_get_vnode_name, - &userlandfs_get_vnode, &userlandfs_put_vnode, &userlandfs_remove_vnode, - /* VM file access */ + + // VM file access NULL, // &userlandfs_can_page, NULL, // &userlandfs_read_pages, NULL, // &userlandfs_write_pages, - NULL, // &userlandfs_get_file_map, + // asynchronous I/O + NULL, // &userlandfs_io + NULL, // &userlandfs_cancel_io + + // cache file access + NULL, // &userlandfs_get_file_map + + // common operations &userlandfs_ioctl, &userlandfs_set_flags, &userlandfs_select, @@ -1080,7 +1200,7 @@ static file_system_module_info sUserlandFSModuleInfo = { &userlandfs_read_stat, &userlandfs_write_stat, - /* file operations */ + // file operations &userlandfs_create, &userlandfs_open, &userlandfs_close, @@ -1088,7 +1208,7 @@ static file_system_module_info sUserlandFSModuleInfo = { &userlandfs_read, &userlandfs_write, - /* directory operations */ + // directory operations &userlandfs_create_dir, &userlandfs_remove_dir, &userlandfs_open_dir, @@ -1096,15 +1216,15 @@ static file_system_module_info sUserlandFSModuleInfo = { &userlandfs_free_dir_cookie, &userlandfs_read_dir, &userlandfs_rewind_dir, - - /* attribute directory operations */ + + // attribute directory operations &userlandfs_open_attr_dir, &userlandfs_close_attr_dir, &userlandfs_free_attr_dir_cookie, &userlandfs_read_attr_dir, &userlandfs_rewind_attr_dir, - /* attribute operations */ + // attribute operations &userlandfs_create_attr, &userlandfs_open_attr, &userlandfs_close_attr, @@ -1117,25 +1237,12 @@ static file_system_module_info sUserlandFSModuleInfo = { &userlandfs_rename_attr, &userlandfs_remove_attr, - /* index directory & index operations */ - &userlandfs_open_index_dir, - &userlandfs_close_index_dir, - &userlandfs_free_index_dir_cookie, - &userlandfs_read_index_dir, - &userlandfs_rewind_index_dir, - - &userlandfs_create_index, - &userlandfs_remove_index, - &userlandfs_read_index_stat, - - /* query operations */ - &userlandfs_open_query, - &userlandfs_close_query, - &userlandfs_free_query_cookie, - &userlandfs_read_query, - &userlandfs_rewind_query + // support for node and FS layers + NULL, // create_special_node() + NULL // get_super_vnode() }; + module_info *modules[] = { (module_info *)&sUserlandFSModuleInfo, NULL, diff --git a/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/kernel_interface.h b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/kernel_interface.h new file mode 100644 index 0000000000..e289a03a25 --- /dev/null +++ b/src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/kernel_interface.h @@ -0,0 +1,15 @@ +/* + * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de. + * Distributed under the terms of the MIT License. + */ +#ifndef KERNEL_INTERFACE_H +#define KERNEL_INTERFACE_H + +#include + + +extern fs_volume_ops gUserlandFSVolumeOps; +extern fs_vnode_ops gUserlandFSVnodeOps; + + +#endif // KERNEL_INTERFACE_H