From 8474904ee0f43a32780687a6648c5b1a9b77b3c4 Mon Sep 17 00:00:00 2001 From: Ingo Weinhold Date: Tue, 27 Feb 2007 23:27:27 +0000 Subject: [PATCH] Adjusted the FileSystem, Volume, and UserlandRequestHandler to the new FS interface. The classes actually interfacing with the client FS add-on still need to be adjusted. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@20246 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- headers/private/userlandfs/private/Requests.h | 3 +- .../server/BeOSKernelFileSystem.cpp | 7 +- .../userlandfs/server/BeOSKernelFileSystem.h | 2 +- .../userlandfs/server/FileSystem.h | 5 +- .../file_systems/userlandfs/server/Jamfile | 8 +- .../userlandfs/server/UserlandFSServer.cpp | 2 +- .../server/UserlandRequestHandler.cpp | 1221 ++++++++++------- .../server/UserlandRequestHandler.h | 107 +- .../file_systems/userlandfs/server/Volume.cpp | 375 ++--- .../file_systems/userlandfs/server/Volume.h | 193 +-- 10 files changed, 1096 insertions(+), 827 deletions(-) diff --git a/headers/private/userlandfs/private/Requests.h b/headers/private/userlandfs/private/Requests.h index 58b6f620aa..cf6e072ffe 100644 --- a/headers/private/userlandfs/private/Requests.h +++ b/headers/private/userlandfs/private/Requests.h @@ -384,7 +384,7 @@ public: WriteFSInfoRequest() : VolumeRequest(WRITE_FS_INFO_REQUEST) {} fs_info info; - long mask; + uint32 mask; }; // WriteFSInfoReply @@ -412,7 +412,6 @@ class LookupReply : public ReplyRequest { public: LookupReply() : ReplyRequest(LOOKUP_REPLY) {} - Address resolvedPath; vnode_id vnid; int type; }; diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelFileSystem.cpp b/src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelFileSystem.cpp index 81851ca3d3..aabf7ae151 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelFileSystem.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelFileSystem.cpp @@ -19,13 +19,12 @@ BeOSKernelFileSystem::~BeOSKernelFileSystem() // CreateVolume status_t -BeOSKernelFileSystem::CreateVolume(Volume** volume, nspace_id id) +BeOSKernelFileSystem::CreateVolume(Volume** volume, mount_id id) { // check initialization and parameters - if (!fFSOps) - return B_BAD_VALUE; - if (!volume) + if (!fFSOps || !volume) return B_BAD_VALUE; + // create the volume *volume = new(nothrow) BeOSKernelVolume(this, id, fFSOps); if (!*volume) diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelFileSystem.h b/src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelFileSystem.h index c6dc1c7433..ff09d26470 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelFileSystem.h +++ b/src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelFileSystem.h @@ -12,7 +12,7 @@ public: BeOSKernelFileSystem(vnode_ops* fsOps); virtual ~BeOSKernelFileSystem(); - virtual status_t CreateVolume(Volume** volume, nspace_id id); + virtual status_t CreateVolume(Volume** volume, mount_id id); virtual status_t DeleteVolume(Volume* volume); private: diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/FileSystem.h b/src/add-ons/kernel/file_systems/userlandfs/server/FileSystem.h index e652d7172c..ea8110ef8a 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/FileSystem.h +++ b/src/add-ons/kernel/file_systems/userlandfs/server/FileSystem.h @@ -3,7 +3,7 @@ #ifndef USERLAND_FS_FILE_SYSTEM_H #define USERLAND_FS_FILE_SYSTEM_H -#include +#include #include namespace UserlandFS { @@ -15,8 +15,7 @@ public: FileSystem(); virtual ~FileSystem(); - virtual status_t CreateVolume(Volume** volume, - nspace_id id) = 0; + virtual status_t CreateVolume(Volume** volume, mount_id id) = 0; virtual status_t DeleteVolume(Volume* volume) = 0; }; diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/Jamfile b/src/add-ons/kernel/file_systems/userlandfs/server/Jamfile index 87eef99fa4..18ba53485f 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/Jamfile +++ b/src/add-ons/kernel/file_systems/userlandfs/server/Jamfile @@ -38,14 +38,14 @@ Application UserlandFSServer # BeOSKernelFileSystem.cpp # BeOSKernelVolume.cpp DispatcherFileSystem.cpp -# FileSystem.cpp + FileSystem.cpp # kernel_emu.cpp main.cpp -# RequestThread.cpp + RequestThread.cpp ServerDefs.cpp UserlandFSDispatcher.cpp # UserlandFSServer.cpp -# UserlandRequestHandler.cpp -# Volume.cpp + UserlandRequestHandler.cpp + Volume.cpp : be ; diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/UserlandFSServer.cpp b/src/add-ons/kernel/file_systems/userlandfs/server/UserlandFSServer.cpp index 65c564ebe5..962d3a7a50 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/UserlandFSServer.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/server/UserlandFSServer.cpp @@ -8,7 +8,7 @@ #include #include #include -#include +#include #include #include #include diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.cpp b/src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.cpp index 19ccabd951..e9eb675dde 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.cpp @@ -52,26 +52,49 @@ UserlandRequestHandler::HandleRequest(Request* request) return _HandleRequest((UnmountVolumeRequest*)request); case SYNC_VOLUME_REQUEST: return _HandleRequest((SyncVolumeRequest*)request); - case READ_FS_STAT_REQUEST: - return _HandleRequest((ReadFSStatRequest*)request); - case WRITE_FS_STAT_REQUEST: - return _HandleRequest((WriteFSStatRequest*)request); + case READ_FS_INFO_REQUEST: + return _HandleRequest((ReadFSInfoRequest*)request); + case WRITE_FS_INFO_REQUEST: + return _HandleRequest((WriteFSInfoRequest*)request); + // vnodes + case LOOKUP_REQUEST: + return _HandleRequest((LookupRequest*)request); case READ_VNODE_REQUEST: return _HandleRequest((ReadVNodeRequest*)request); case WRITE_VNODE_REQUEST: return _HandleRequest((WriteVNodeRequest*)request); case FS_REMOVE_VNODE_REQUEST: return _HandleRequest((FSRemoveVNodeRequest*)request); + // nodes + case IOCTL_REQUEST: + return _HandleRequest((IOCtlRequest*)request); + case SET_FLAGS_REQUEST: + return _HandleRequest((SetFlagsRequest*)request); + case SELECT_REQUEST: + return _HandleRequest((SelectRequest*)request); + case DESELECT_REQUEST: + return _HandleRequest((DeselectRequest*)request); case FSYNC_REQUEST: return _HandleRequest((FSyncRequest*)request); + case READ_SYMLINK_REQUEST: + return _HandleRequest((ReadSymlinkRequest*)request); + case CREATE_SYMLINK_REQUEST: + return _HandleRequest((CreateSymlinkRequest*)request); + case LINK_REQUEST: + return _HandleRequest((LinkRequest*)request); + case UNLINK_REQUEST: + return _HandleRequest((UnlinkRequest*)request); + case RENAME_REQUEST: + return _HandleRequest((RenameRequest*)request); + case ACCESS_REQUEST: + return _HandleRequest((AccessRequest*)request); case READ_STAT_REQUEST: return _HandleRequest((ReadStatRequest*)request); case WRITE_STAT_REQUEST: return _HandleRequest((WriteStatRequest*)request); - case ACCESS_REQUEST: - return _HandleRequest((AccessRequest*)request); + // files case CREATE_REQUEST: return _HandleRequest((CreateRequest*)request); @@ -85,30 +108,12 @@ UserlandRequestHandler::HandleRequest(Request* request) return _HandleRequest((ReadRequest*)request); case WRITE_REQUEST: return _HandleRequest((WriteRequest*)request); - case IOCTL_REQUEST: - return _HandleRequest((IOCtlRequest*)request); - case SET_FLAGS_REQUEST: - return _HandleRequest((SetFlagsRequest*)request); - case SELECT_REQUEST: - return _HandleRequest((SelectRequest*)request); - case DESELECT_REQUEST: - return _HandleRequest((DeselectRequest*)request); - // hard links / symlinks - case LINK_REQUEST: - return _HandleRequest((LinkRequest*)request); - case UNLINK_REQUEST: - return _HandleRequest((UnlinkRequest*)request); - case SYMLINK_REQUEST: - return _HandleRequest((SymlinkRequest*)request); - case READ_LINK_REQUEST: - return _HandleRequest((ReadLinkRequest*)request); - case RENAME_REQUEST: - return _HandleRequest((RenameRequest*)request); + // directories - case MKDIR_REQUEST: - return _HandleRequest((MkDirRequest*)request); - case RMDIR_REQUEST: - return _HandleRequest((RmDirRequest*)request); + case CREATE_DIR_REQUEST: + return _HandleRequest((CreateDirRequest*)request); + case REMOVE_DIR_REQUEST: + return _HandleRequest((RemoveDirRequest*)request); case OPEN_DIR_REQUEST: return _HandleRequest((OpenDirRequest*)request); case CLOSE_DIR_REQUEST: @@ -119,9 +124,8 @@ UserlandRequestHandler::HandleRequest(Request* request) return _HandleRequest((ReadDirRequest*)request); case REWIND_DIR_REQUEST: return _HandleRequest((RewindDirRequest*)request); - case WALK_REQUEST: - return _HandleRequest((WalkRequest*)request); - // attributes + + // attribute directories case OPEN_ATTR_DIR_REQUEST: return _HandleRequest((OpenAttrDirRequest*)request); case CLOSE_ATTR_DIR_REQUEST: @@ -132,16 +136,19 @@ UserlandRequestHandler::HandleRequest(Request* request) return _HandleRequest((ReadAttrDirRequest*)request); case REWIND_ATTR_DIR_REQUEST: return _HandleRequest((RewindAttrDirRequest*)request); + + // attributes case READ_ATTR_REQUEST: return _HandleRequest((ReadAttrRequest*)request); case WRITE_ATTR_REQUEST: return _HandleRequest((WriteAttrRequest*)request); - case REMOVE_ATTR_REQUEST: - return _HandleRequest((RemoveAttrRequest*)request); + case READ_ATTR_STAT_REQUEST: + return _HandleRequest((ReadAttrStatRequest*)request); case RENAME_ATTR_REQUEST: return _HandleRequest((RenameAttrRequest*)request); - case STAT_ATTR_REQUEST: - return _HandleRequest((StatAttrRequest*)request); + case REMOVE_ATTR_REQUEST: + return _HandleRequest((RemoveAttrRequest*)request); + // indices case OPEN_INDEX_DIR_REQUEST: return _HandleRequest((OpenIndexDirRequest*)request); @@ -157,10 +164,9 @@ UserlandRequestHandler::HandleRequest(Request* request) return _HandleRequest((CreateIndexRequest*)request); case REMOVE_INDEX_REQUEST: return _HandleRequest((RemoveIndexRequest*)request); - case RENAME_INDEX_REQUEST: - return _HandleRequest((RenameIndexRequest*)request); - case STAT_INDEX_REQUEST: - return _HandleRequest((StatIndexRequest*)request); + case READ_INDEX_STAT_REQUEST: + return _HandleRequest((ReadIndexStatRequest*)request); + // queries case OPEN_QUERY_REQUEST: return _HandleRequest((OpenQueryRequest*)request); @@ -177,8 +183,8 @@ request->GetType())); } -// #pragma mark - -// #pragma mark ----- FS ----- +// #pragma mark - FS + // _HandleRequest status_t @@ -186,6 +192,7 @@ UserlandRequestHandler::_HandleRequest(MountVolumeRequest* request) { // check and execute the request status_t result = B_OK; + // if the device path is relative, make it absolute by appending the // provided CWD const char* device = (const char*)request->device.GetData(); @@ -217,8 +224,7 @@ UserlandRequestHandler::_HandleRequest(MountVolumeRequest* request) if (result == B_OK) { RequestThreadContext context(volume); result = volume->Mount(device, request->flags, - (const char*)request->parameters.GetData(), - request->parameters.GetSize(), &rootID); + (const char*)request->parameters.GetData(), &rootID); if (result != B_OK) fFileSystem->DeleteVolume(volume); } @@ -252,6 +258,7 @@ UserlandRequestHandler::_HandleRequest(UnmountVolumeRequest* request) RequestThreadContext context(volume); result = volume->Unmount(); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); UnmountVolumeReply* reply; @@ -259,6 +266,7 @@ UserlandRequestHandler::_HandleRequest(UnmountVolumeRequest* request) if (error != B_OK) RETURN_ERROR(error); reply->error = result; + // send the reply return _SendReply(allocator, false); } @@ -283,13 +291,14 @@ UserlandRequestHandler::_HandleRequest(SyncVolumeRequest* request) if (error != B_OK) RETURN_ERROR(error); reply->error = result; + // send the reply return _SendReply(allocator, false); } // _HandleRequest status_t -UserlandRequestHandler::_HandleRequest(ReadFSStatRequest* request) +UserlandRequestHandler::_HandleRequest(ReadFSInfoRequest* request) { // check and execute the request status_t result = B_OK; @@ -299,23 +308,24 @@ UserlandRequestHandler::_HandleRequest(ReadFSStatRequest* request) fs_info info; if (result == B_OK) { RequestThreadContext context(volume); - result = volume->ReadFSStat(&info); + result = volume->ReadFSInfo(&info); } // prepare the reply RequestAllocator allocator(fPort->GetPort()); - ReadFSStatReply* reply; + ReadFSInfoReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); reply->error = result; reply->info = info; + // send the reply return _SendReply(allocator, false); } // _HandleRequest status_t -UserlandRequestHandler::_HandleRequest(WriteFSStatRequest* request) +UserlandRequestHandler::_HandleRequest(WriteFSInfoRequest* request) { // check and execute the request status_t result = B_OK; @@ -324,22 +334,57 @@ UserlandRequestHandler::_HandleRequest(WriteFSStatRequest* request) result = B_BAD_VALUE; if (result == B_OK) { RequestThreadContext context(volume); - result = volume->WriteFSStat(&request->info, request->mask); + result = volume->WriteFSInfo(&request->info, request->mask); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); - WriteFSStatReply* reply; + WriteFSInfoReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); reply->error = result; + // send the reply return _SendReply(allocator, false); } -// #pragma mark - -// #pragma mark ----- vnodes ----- +// #pragma mark - vnodes + + +// _HandleRequest +status_t +UserlandRequestHandler::_HandleRequest(LookupRequest* request) +{ + // check and execute the request + status_t result = B_OK; + Volume* volume = (Volume*)request->volume; + if (!volume) + result = B_BAD_VALUE; + + vnode_id vnid = 0; + int type = 0; + if (result == B_OK) { + RequestThreadContext context(volume); + result = volume->Lookup(request->node, + (const char*)request->entryName.GetData(), &vnid, &type); + } + + // prepare the reply + RequestAllocator allocator(fPort->GetPort()); + LookupReply* reply; + status_t error = AllocateRequest(allocator, &reply); + if (error != B_OK) + RETURN_ERROR(error); + + reply->vnid = vnid; + reply->type = type; + reply->error = result; + + // send the reply + return _SendReply(allocator, false); +} // _HandleRequest status_t @@ -350,19 +395,23 @@ UserlandRequestHandler::_HandleRequest(ReadVNodeRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; - void* node; + + fs_vnode node; if (result == B_OK) { RequestThreadContext context(volume); result = volume->ReadVNode(request->vnid, request->reenter, &node); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); ReadVNodeReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; reply->node = node; + // send the reply return _SendReply(allocator, false); } @@ -376,17 +425,21 @@ UserlandRequestHandler::_HandleRequest(WriteVNodeRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->WriteVNode(request->node, request->reenter); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); WriteVNodeReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } @@ -400,296 +453,28 @@ UserlandRequestHandler::_HandleRequest(FSRemoveVNodeRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->RemoveVNode(request->node, request->reenter); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); FSRemoveVNodeReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } -// #pragma mark - -// #pragma mark ----- nodes ----- +// #pragma mark - nodes -// _HandleRequest -status_t -UserlandRequestHandler::_HandleRequest(FSyncRequest* request) -{ - // check and execute the request - status_t result = B_OK; - Volume* volume = (Volume*)request->volume; - if (!volume) - result = B_BAD_VALUE; - if (result == B_OK) { - RequestThreadContext context(volume); - result = volume->FSync(request->node); - } - // prepare the reply - RequestAllocator allocator(fPort->GetPort()); - FSyncReply* reply; - status_t error = AllocateRequest(allocator, &reply); - if (error != B_OK) - RETURN_ERROR(error); - reply->error = result; - // send the reply - return _SendReply(allocator, false); -} - -// _HandleRequest -status_t -UserlandRequestHandler::_HandleRequest(ReadStatRequest* request) -{ - // check and execute the request - status_t result = B_OK; - Volume* volume = (Volume*)request->volume; - if (!volume) - result = B_BAD_VALUE; - struct stat st; - if (result == B_OK) { - RequestThreadContext context(volume); - result = volume->ReadStat(request->node, &st); - } - // prepare the reply - RequestAllocator allocator(fPort->GetPort()); - ReadStatReply* reply; - status_t error = AllocateRequest(allocator, &reply); - if (error != B_OK) - RETURN_ERROR(error); - reply->error = result; - reply->st = st; - // send the reply - return _SendReply(allocator, false); -} - -// _HandleRequest -status_t -UserlandRequestHandler::_HandleRequest(WriteStatRequest* request) -{ - // check and execute the request - status_t result = B_OK; - Volume* volume = (Volume*)request->volume; - if (!volume) - result = B_BAD_VALUE; - if (result == B_OK) { - RequestThreadContext context(volume); - result = volume->WriteStat(request->node, &request->st, request->mask); - } - // prepare the reply - RequestAllocator allocator(fPort->GetPort()); - WriteStatReply* reply; - status_t error = AllocateRequest(allocator, &reply); - if (error != B_OK) - RETURN_ERROR(error); - reply->error = result; - // send the reply - return _SendReply(allocator, false); -} - -// _HandleRequest -status_t -UserlandRequestHandler::_HandleRequest(AccessRequest* request) -{ - // check and execute the request - status_t result = B_OK; - Volume* volume = (Volume*)request->volume; - if (!volume) - result = B_BAD_VALUE; - if (result == B_OK) { - RequestThreadContext context(volume); - result = volume->Access(request->node, request->mode); - } - // prepare the reply - RequestAllocator allocator(fPort->GetPort()); - AccessReply* reply; - status_t error = AllocateRequest(allocator, &reply); - if (error != B_OK) - RETURN_ERROR(error); - reply->error = result; - // send the reply - return _SendReply(allocator, false); -} - - -// #pragma mark - -// #pragma mark ----- files ----- - -// _HandleRequest -status_t -UserlandRequestHandler::_HandleRequest(CreateRequest* request) -{ - // check and execute the request - status_t result = B_OK; - Volume* volume = (Volume*)request->volume; - if (!volume) - result = B_BAD_VALUE; - vnode_id vnid; - void* fileCookie; - if (result == B_OK) { - RequestThreadContext context(volume); - result = volume->Create(request->node, - (const char*)request->name.GetData(), request->openMode, - request->mode, &vnid, &fileCookie); - } - // prepare the reply - RequestAllocator allocator(fPort->GetPort()); - CreateReply* reply; - status_t error = AllocateRequest(allocator, &reply); - if (error != B_OK) - RETURN_ERROR(error); - reply->error = result; - reply->vnid = vnid; - reply->fileCookie = fileCookie; - // send the reply - return _SendReply(allocator, false); -} - -// _HandleRequest -status_t -UserlandRequestHandler::_HandleRequest(OpenRequest* request) -{ - // check and execute the request - status_t result = B_OK; - Volume* volume = (Volume*)request->volume; - if (!volume) - result = B_BAD_VALUE; - void* fileCookie; - if (result == B_OK) { - RequestThreadContext context(volume); - result = volume->Open(request->node, request->openMode, &fileCookie); - } - // prepare the reply - RequestAllocator allocator(fPort->GetPort()); - OpenReply* reply; - status_t error = AllocateRequest(allocator, &reply); - if (error != B_OK) - RETURN_ERROR(error); - reply->error = result; - reply->fileCookie = fileCookie; - // send the reply - return _SendReply(allocator, false); -} - -// _HandleRequest -status_t -UserlandRequestHandler::_HandleRequest(CloseRequest* request) -{ - // check and execute the request - status_t result = B_OK; - Volume* volume = (Volume*)request->volume; - if (!volume) - result = B_BAD_VALUE; - if (result == B_OK) { - RequestThreadContext context(volume); - result = volume->Close(request->node, request->fileCookie); - } - // prepare the reply - RequestAllocator allocator(fPort->GetPort()); - CloseReply* reply; - status_t error = AllocateRequest(allocator, &reply); - if (error != B_OK) - RETURN_ERROR(error); - reply->error = result; - // send the reply - return _SendReply(allocator, false); -} - -// _HandleRequest -status_t -UserlandRequestHandler::_HandleRequest(FreeCookieRequest* request) -{ - // check and execute the request - status_t result = B_OK; - Volume* volume = (Volume*)request->volume; - if (!volume) - result = B_BAD_VALUE; - if (result == B_OK) { - RequestThreadContext context(volume); - result = volume->FreeCookie(request->node, request->fileCookie); - } - // prepare the reply - RequestAllocator allocator(fPort->GetPort()); - FreeCookieReply* reply; - status_t error = AllocateRequest(allocator, &reply); - if (error != B_OK) - RETURN_ERROR(error); - reply->error = result; - // send the reply - return _SendReply(allocator, false); -} - -// _HandleRequest -status_t -UserlandRequestHandler::_HandleRequest(ReadRequest* request) -{ - // check and execute the request - status_t result = B_OK; - Volume* volume = (Volume*)request->volume; - if (!volume) - result = B_BAD_VALUE; - void* node = request->node; - void* fileCookie = request->fileCookie; - off_t pos = request->pos; - size_t size = request->size; - // allocate the reply - RequestAllocator allocator(fPort->GetPort()); - ReadReply* reply; - status_t error = AllocateRequest(allocator, &reply); - if (error != B_OK) - RETURN_ERROR(error); - void* buffer; - if (result == B_OK) { - result = allocator.AllocateAddress(reply->buffer, size, 1, &buffer, - true); - } - // execute the request - size_t bytesRead; - if (result == B_OK) { - RequestThreadContext context(volume); - result = volume->Read(node, fileCookie, pos, buffer, size, &bytesRead); - } - // reconstruct the reply, in case it has been overwritten - reply = new(reply) ReadReply; - // send the reply - reply->error = result; - reply->bytesRead = bytesRead; - return _SendReply(allocator, (result == B_OK)); -} - -// _HandleRequest -status_t -UserlandRequestHandler::_HandleRequest(WriteRequest* request) -{ - // check and execute the request - status_t result = B_OK; - Volume* volume = (Volume*)request->volume; - if (!volume) - result = B_BAD_VALUE; - size_t bytesWritten; - if (result == B_OK) { - RequestThreadContext context(volume); - result = volume->Write(request->node, request->fileCookie, - request->pos, request->buffer.GetData(), request->buffer.GetSize(), - &bytesWritten); - } - // prepare the reply - RequestAllocator allocator(fPort->GetPort()); - WriteReply* reply; - status_t error = AllocateRequest(allocator, &reply); - if (error != B_OK) - RETURN_ERROR(error); - reply->error = result; - reply->bytesWritten = bytesWritten; - // send the reply - return _SendReply(allocator, false); -} // _HandleRequest status_t @@ -700,6 +485,7 @@ UserlandRequestHandler::_HandleRequest(IOCtlRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + void* buffer = request->bufferParameter; size_t len = request->lenParameter; bool isBuffer = request->isBuffer; @@ -709,12 +495,14 @@ UserlandRequestHandler::_HandleRequest(IOCtlRequest* request) buffer = request->buffer.GetData(); bufferSize = request->buffer.GetSize(); } + // allocate the reply RequestAllocator allocator(fPort->GetPort()); IOCtlReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + // allocate the writable buffer for the call void* writeBuffer = NULL; if (result == B_OK && isBuffer && writeSize > 0) { @@ -726,6 +514,7 @@ UserlandRequestHandler::_HandleRequest(IOCtlRequest* request) memcpy(writeBuffer, buffer, bufferSize); buffer = writeBuffer; } + // execute the request status_t ioctlError = B_OK; if (result == B_OK) { @@ -733,8 +522,10 @@ UserlandRequestHandler::_HandleRequest(IOCtlRequest* request) ioctlError = volume->IOCtl(request->node, request->fileCookie, request->command, buffer, len); } + // reconstruct the reply, in case it has been overwritten reply = new(reply) IOCtlReply; + // send the reply reply->error = result; reply->ioctlError = ioctlError; @@ -750,18 +541,22 @@ UserlandRequestHandler::_HandleRequest(SetFlagsRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->SetFlags(request->node, request->fileCookie, request->flags); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); SetFlagsReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } @@ -775,18 +570,22 @@ UserlandRequestHandler::_HandleRequest(SelectRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->Select(request->node, request->fileCookie, request->event, request->ref, request->sync); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); SelectReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } @@ -800,25 +599,124 @@ UserlandRequestHandler::_HandleRequest(DeselectRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->Deselect(request->node, request->fileCookie, request->event, request->sync); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); DeselectReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } +// _HandleRequest +status_t +UserlandRequestHandler::_HandleRequest(FSyncRequest* request) +{ + // check and execute the request + status_t result = B_OK; + Volume* volume = (Volume*)request->volume; + if (!volume) + result = B_BAD_VALUE; -// #pragma mark - -// #pragma mark ----- hard links / symlinks ----- + if (result == B_OK) { + RequestThreadContext context(volume); + result = volume->FSync(request->node); + } + + // prepare the reply + RequestAllocator allocator(fPort->GetPort()); + FSyncReply* reply; + status_t error = AllocateRequest(allocator, &reply); + if (error != B_OK) + RETURN_ERROR(error); + + reply->error = result; + + // send the reply + return _SendReply(allocator, false); +} + +// _HandleRequest +status_t +UserlandRequestHandler::_HandleRequest(ReadSymlinkRequest* request) +{ + // check and execute the request + status_t result = B_OK; + Volume* volume = (Volume*)request->volume; + if (!volume) + result = B_BAD_VALUE; + + void* node = request->node; + size_t bufferSize = request->size; + + // allocate the reply + RequestAllocator allocator(fPort->GetPort()); + ReadSymlinkReply* reply; + status_t error = AllocateRequest(allocator, &reply); + if (error != B_OK) + RETURN_ERROR(error); + char* buffer; + if (result == B_OK) { + result = allocator.AllocateAddress(reply->buffer, bufferSize, 1, + (void**)&buffer, true); + } + + // execute the request + size_t bytesRead; + if (result == B_OK) { + RequestThreadContext context(volume); + result = volume->ReadSymlink(node, buffer, bufferSize, &bytesRead); + } + + // reconstruct the reply, in case it has been overwritten + reply = new(reply) ReadSymlinkReply; + + // send the reply + reply->error = result; + reply->bytesRead = bytesRead; + return _SendReply(allocator, (result == B_OK)); +} + +// _HandleRequest +status_t +UserlandRequestHandler::_HandleRequest(CreateSymlinkRequest* request) +{ + // check and execute the request + status_t result = B_OK; + Volume* volume = (Volume*)request->volume; + if (!volume) + result = B_BAD_VALUE; + + if (result == B_OK) { + RequestThreadContext context(volume); + result = volume->CreateSymlink(request->node, + (const char*)request->name.GetData(), + (const char*)request->target.GetData(), request->mode); + } + + // prepare the reply + RequestAllocator allocator(fPort->GetPort()); + CreateSymlinkReply* reply; + status_t error = AllocateRequest(allocator, &reply); + if (error != B_OK) + RETURN_ERROR(error); + + reply->error = result; + + // send the reply + return _SendReply(allocator, false); +} // _HandleRequest status_t @@ -829,18 +727,22 @@ UserlandRequestHandler::_HandleRequest(LinkRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->Link(request->node, (const char*)request->name.GetData(), request->target); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); LinkReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } @@ -854,84 +756,26 @@ UserlandRequestHandler::_HandleRequest(UnlinkRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->Unlink(request->node, (const char*)request->name.GetData()); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); UnlinkReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } -// _HandleRequest -status_t -UserlandRequestHandler::_HandleRequest(SymlinkRequest* request) -{ - // check and execute the request - status_t result = B_OK; - Volume* volume = (Volume*)request->volume; - if (!volume) - result = B_BAD_VALUE; - if (result == B_OK) { - RequestThreadContext context(volume); - result = volume->Symlink(request->node, - (const char*)request->name.GetData(), - (const char*)request->target.GetData()); - } - // prepare the reply - RequestAllocator allocator(fPort->GetPort()); - SymlinkReply* reply; - status_t error = AllocateRequest(allocator, &reply); - if (error != B_OK) - RETURN_ERROR(error); - reply->error = result; - // send the reply - return _SendReply(allocator, false); -} - -// _HandleRequest -status_t -UserlandRequestHandler::_HandleRequest(ReadLinkRequest* request) -{ - // check and execute the request - status_t result = B_OK; - Volume* volume = (Volume*)request->volume; - if (!volume) - result = B_BAD_VALUE; - void* node = request->node; - size_t bufferSize = request->size; - // allocate the reply - RequestAllocator allocator(fPort->GetPort()); - ReadLinkReply* reply; - status_t error = AllocateRequest(allocator, &reply); - if (error != B_OK) - RETURN_ERROR(error); - char* buffer; - if (result == B_OK) { - result = allocator.AllocateAddress(reply->buffer, bufferSize, 1, - (void**)&buffer, true); - } - // execute the request - size_t bytesRead; - if (result == B_OK) { - RequestThreadContext context(volume); - result = volume->ReadLink(node, buffer, bufferSize, &bytesRead); - } - // reconstruct the reply, in case it has been overwritten - reply = new(reply) ReadLinkReply; - // send the reply - reply->error = result; - reply->bytesRead = bytesRead; - return _SendReply(allocator, (result == B_OK)); -} - // _HandleRequest status_t UserlandRequestHandler::_HandleRequest(RenameRequest* request) @@ -941,73 +785,373 @@ UserlandRequestHandler::_HandleRequest(RenameRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->Rename(request->oldDir, (const char*)request->oldName.GetData(), request->newDir, (const char*)request->newName.GetData()); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); RenameReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } - -// #pragma mark - -// #pragma mark ----- directories ----- - // _HandleRequest status_t -UserlandRequestHandler::_HandleRequest(MkDirRequest* request) +UserlandRequestHandler::_HandleRequest(AccessRequest* request) { // check and execute the request status_t result = B_OK; Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); - result = volume->MkDir(request->node, - (const char*)request->name.GetData(), request->mode); + result = volume->Access(request->node, request->mode); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); - MkDirReply* reply; + AccessReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } // _HandleRequest status_t -UserlandRequestHandler::_HandleRequest(RmDirRequest* request) +UserlandRequestHandler::_HandleRequest(ReadStatRequest* request) { // check and execute the request status_t result = B_OK; Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + + struct stat st; if (result == B_OK) { RequestThreadContext context(volume); - result = volume->RmDir(request->node, + result = volume->ReadStat(request->node, &st); + } + + // prepare the reply + RequestAllocator allocator(fPort->GetPort()); + ReadStatReply* reply; + status_t error = AllocateRequest(allocator, &reply); + if (error != B_OK) + RETURN_ERROR(error); + + reply->error = result; + reply->st = st; + + // send the reply + return _SendReply(allocator, false); +} + +// _HandleRequest +status_t +UserlandRequestHandler::_HandleRequest(WriteStatRequest* request) +{ + // check and execute the request + status_t result = B_OK; + Volume* volume = (Volume*)request->volume; + if (!volume) + result = B_BAD_VALUE; + + if (result == B_OK) { + RequestThreadContext context(volume); + result = volume->WriteStat(request->node, &request->st, request->mask); + } + + // prepare the reply + RequestAllocator allocator(fPort->GetPort()); + WriteStatReply* reply; + status_t error = AllocateRequest(allocator, &reply); + if (error != B_OK) + RETURN_ERROR(error); + + reply->error = result; + + // send the reply + return _SendReply(allocator, false); +} + + +// #pragma mark - files + + +// _HandleRequest +status_t +UserlandRequestHandler::_HandleRequest(CreateRequest* request) +{ + // check and execute the request + status_t result = B_OK; + Volume* volume = (Volume*)request->volume; + if (!volume) + result = B_BAD_VALUE; + + vnode_id vnid; + fs_cookie fileCookie; + if (result == B_OK) { + RequestThreadContext context(volume); + result = volume->Create(request->node, + (const char*)request->name.GetData(), request->openMode, + request->mode, &fileCookie, &vnid); + } + + // prepare the reply + RequestAllocator allocator(fPort->GetPort()); + CreateReply* reply; + status_t error = AllocateRequest(allocator, &reply); + if (error != B_OK) + RETURN_ERROR(error); + + reply->error = result; + reply->vnid = vnid; + reply->fileCookie = fileCookie; + + // send the reply + return _SendReply(allocator, false); +} + +// _HandleRequest +status_t +UserlandRequestHandler::_HandleRequest(OpenRequest* request) +{ + // check and execute the request + status_t result = B_OK; + Volume* volume = (Volume*)request->volume; + if (!volume) + result = B_BAD_VALUE; + + fs_cookie fileCookie; + if (result == B_OK) { + RequestThreadContext context(volume); + result = volume->Open(request->node, request->openMode, &fileCookie); + } + + // prepare the reply + RequestAllocator allocator(fPort->GetPort()); + OpenReply* reply; + status_t error = AllocateRequest(allocator, &reply); + if (error != B_OK) + RETURN_ERROR(error); + + reply->error = result; + reply->fileCookie = fileCookie; + + // send the reply + return _SendReply(allocator, false); +} + +// _HandleRequest +status_t +UserlandRequestHandler::_HandleRequest(CloseRequest* request) +{ + // check and execute the request + status_t result = B_OK; + Volume* volume = (Volume*)request->volume; + if (!volume) + result = B_BAD_VALUE; + + if (result == B_OK) { + RequestThreadContext context(volume); + result = volume->Close(request->node, request->fileCookie); + } + + // prepare the reply + RequestAllocator allocator(fPort->GetPort()); + CloseReply* reply; + status_t error = AllocateRequest(allocator, &reply); + if (error != B_OK) + RETURN_ERROR(error); + + reply->error = result; + + // send the reply + return _SendReply(allocator, false); +} + +// _HandleRequest +status_t +UserlandRequestHandler::_HandleRequest(FreeCookieRequest* request) +{ + // check and execute the request + status_t result = B_OK; + Volume* volume = (Volume*)request->volume; + if (!volume) + result = B_BAD_VALUE; + + if (result == B_OK) { + RequestThreadContext context(volume); + result = volume->FreeCookie(request->node, request->fileCookie); + } + + // prepare the reply + RequestAllocator allocator(fPort->GetPort()); + FreeCookieReply* reply; + status_t error = AllocateRequest(allocator, &reply); + if (error != B_OK) + RETURN_ERROR(error); + + reply->error = result; + + // send the reply + return _SendReply(allocator, false); +} + +// _HandleRequest +status_t +UserlandRequestHandler::_HandleRequest(ReadRequest* request) +{ + // check and execute the request + status_t result = B_OK; + Volume* volume = (Volume*)request->volume; + if (!volume) + result = B_BAD_VALUE; + + fs_vnode node = request->node; + fs_cookie fileCookie = request->fileCookie; + off_t pos = request->pos; + size_t size = request->size; + + // allocate the reply + RequestAllocator allocator(fPort->GetPort()); + ReadReply* reply; + status_t error = AllocateRequest(allocator, &reply); + if (error != B_OK) + RETURN_ERROR(error); + + void* buffer; + if (result == B_OK) { + result = allocator.AllocateAddress(reply->buffer, size, 1, &buffer, + true); + } + + // execute the request + size_t bytesRead; + if (result == B_OK) { + RequestThreadContext context(volume); + result = volume->Read(node, fileCookie, pos, buffer, size, &bytesRead); + } + + // reconstruct the reply, in case it has been overwritten + reply = new(reply) ReadReply; + + // send the reply + reply->error = result; + reply->bytesRead = bytesRead; + return _SendReply(allocator, (result == B_OK)); +} + +// _HandleRequest +status_t +UserlandRequestHandler::_HandleRequest(WriteRequest* request) +{ + // check and execute the request + status_t result = B_OK; + Volume* volume = (Volume*)request->volume; + if (!volume) + result = B_BAD_VALUE; + + size_t bytesWritten; + if (result == B_OK) { + RequestThreadContext context(volume); + result = volume->Write(request->node, request->fileCookie, + request->pos, request->buffer.GetData(), request->buffer.GetSize(), + &bytesWritten); + } + + // prepare the reply + RequestAllocator allocator(fPort->GetPort()); + WriteReply* reply; + status_t error = AllocateRequest(allocator, &reply); + if (error != B_OK) + RETURN_ERROR(error); + + reply->error = result; + reply->bytesWritten = bytesWritten; + + // send the reply + return _SendReply(allocator, false); +} + + +// #pragma mark - directories + + +// _HandleRequest +status_t +UserlandRequestHandler::_HandleRequest(CreateDirRequest* request) +{ + // check and execute the request + status_t result = B_OK; + Volume* volume = (Volume*)request->volume; + if (!volume) + result = B_BAD_VALUE; + + vnode_id newDir = 0; + if (result == B_OK) { + RequestThreadContext context(volume); + result = volume->CreateDir(request->node, + (const char*)request->name.GetData(), request->mode, &newDir); + } + + // prepare the reply + RequestAllocator allocator(fPort->GetPort()); + CreateDirReply* reply; + status_t error = AllocateRequest(allocator, &reply); + if (error != B_OK) + RETURN_ERROR(error); + + reply->error = result; + reply->newDir = newDir; + + // send the reply + return _SendReply(allocator, false); +} + +// _HandleRequest +status_t +UserlandRequestHandler::_HandleRequest(RemoveDirRequest* request) +{ + // check and execute the request + status_t result = B_OK; + Volume* volume = (Volume*)request->volume; + if (!volume) + result = B_BAD_VALUE; + + if (result == B_OK) { + RequestThreadContext context(volume); + result = volume->RemoveDir(request->node, (const char*)request->name.GetData()); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); - RmDirReply* reply; + RemoveDirReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } @@ -1021,19 +1165,23 @@ UserlandRequestHandler::_HandleRequest(OpenDirRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; - void* dirCookie; + + fs_cookie dirCookie = NULL; if (result == B_OK) { RequestThreadContext context(volume); result = volume->OpenDir(request->node, &dirCookie); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); OpenDirReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; reply->dirCookie = dirCookie; + // send the reply return _SendReply(allocator, false); } @@ -1047,17 +1195,21 @@ UserlandRequestHandler::_HandleRequest(CloseDirRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->CloseDir(request->node, request->dirCookie); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); CloseDirReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } @@ -1071,17 +1223,21 @@ UserlandRequestHandler::_HandleRequest(FreeDirCookieRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->FreeDirCookie(request->node, request->dirCookie); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); FreeDirCookieReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } @@ -1095,28 +1251,33 @@ UserlandRequestHandler::_HandleRequest(ReadDirRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; - void* node = request->node; - void* dirCookie = request->dirCookie; + + fs_vnode node = request->node; + fs_vnode dirCookie = request->dirCookie; size_t bufferSize = request->bufferSize; - int32 count = request->count; + uint32 count = request->count; + // allocate the reply RequestAllocator allocator(fPort->GetPort()); ReadDirReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + void* buffer; if (result == B_OK) { result = allocator.AllocateAddress(reply->buffer, bufferSize, 1, &buffer, true); } + // execute the request - int32 countRead; + uint32 countRead; if (result == B_OK) { RequestThreadContext context(volume); result = volume->ReadDir(node, dirCookie, buffer, bufferSize, count, &countRead); } + D( if (result == B_OK && countRead > 0) { dirent* entry = (dirent*)buffer; @@ -1126,8 +1287,10 @@ if (result == B_OK && countRead > 0) { entry->d_reclen, entry->d_name)); } ) + // reconstruct the reply, in case it has been overwritten reply = new(reply) ReadDirReply; + // send the reply reply->error = result; reply->count = countRead; @@ -1143,56 +1306,28 @@ UserlandRequestHandler::_HandleRequest(RewindDirRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->RewindDir(request->node, request->dirCookie); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); RewindDirReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } -// _HandleRequest -status_t -UserlandRequestHandler::_HandleRequest(WalkRequest* request) -{ - // check and execute the request - status_t result = B_OK; - Volume* volume = (Volume*)request->volume; - if (!volume) - result = B_BAD_VALUE; - vnode_id vnid; - char* resolvedPath = NULL; - if (result == B_OK) { - RequestThreadContext context(volume); - result = volume->Walk(request->node, - (const char*)request->entryName.GetData(), - (request->traverseLink ? &resolvedPath : NULL), &vnid); - } - MemoryDeleter _(resolvedPath); - // prepare the reply - RequestAllocator allocator(fPort->GetPort()); - WalkReply* reply; - status_t error = AllocateRequest(allocator, &reply); - if (error != B_OK) - RETURN_ERROR(error); - if (result == B_OK && resolvedPath) - result = allocator.AllocateString(reply->resolvedPath, resolvedPath); - reply->vnid = vnid; - reply->error = result; - // send the reply - return _SendReply(allocator, (result == B_OK && resolvedPath)); -} +// #pragma mark - attribute directories -// #pragma mark - -// #pragma mark ----- attributes ----- // _HandleRequest status_t @@ -1203,19 +1338,23 @@ UserlandRequestHandler::_HandleRequest(OpenAttrDirRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; - void* attrDirCookie; + + fs_cookie attrDirCookie; if (result == B_OK) { RequestThreadContext context(volume); result = volume->OpenAttrDir(request->node, &attrDirCookie); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); OpenAttrDirReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; reply->attrDirCookie = attrDirCookie; + // send the reply return _SendReply(allocator, false); } @@ -1229,17 +1368,21 @@ UserlandRequestHandler::_HandleRequest(CloseAttrDirRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->CloseAttrDir(request->node, request->attrDirCookie); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); CloseAttrDirReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } @@ -1253,18 +1396,22 @@ UserlandRequestHandler::_HandleRequest(FreeAttrDirCookieRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->FreeAttrDirCookie(request->node, request->attrDirCookie); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); FreeAttrDirCookieReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } @@ -1278,30 +1425,36 @@ UserlandRequestHandler::_HandleRequest(ReadAttrDirRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; - void* node = request->node; - void* attrDirCookie = request->attrDirCookie; + + fs_vnode node = request->node; + fs_cookie attrDirCookie = request->attrDirCookie; size_t bufferSize = request->bufferSize; - int32 count = request->count; + uint32 count = request->count; + // allocate the reply RequestAllocator allocator(fPort->GetPort()); ReadAttrDirReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + void* buffer; if (result == B_OK) { result = allocator.AllocateAddress(reply->buffer, bufferSize, 1, &buffer, true); } + // execute the request - int32 countRead; + uint32 countRead; if (result == B_OK) { RequestThreadContext context(volume); result = volume->ReadAttrDir(node, attrDirCookie, buffer, bufferSize, count, &countRead); } + // reconstruct the reply, in case it has been overwritten reply = new(reply) ReadAttrDirReply; + // send the reply reply->error = result; reply->count = countRead; @@ -1317,21 +1470,29 @@ UserlandRequestHandler::_HandleRequest(RewindAttrDirRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->RewindAttrDir(request->node, request->attrDirCookie); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); RewindAttrDirReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } + +// #pragma mark - attributes + + // _HandleRequest status_t UserlandRequestHandler::_HandleRequest(ReadAttrRequest* request) @@ -1341,29 +1502,36 @@ UserlandRequestHandler::_HandleRequest(ReadAttrRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + void* node = request->node; + fs_cookie attrCookie = request->attrCookie; off_t pos = request->pos; size_t size = request->size; + // allocate the reply RequestAllocator allocator(fPort->GetPort()); ReadAttrReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + void* buffer; if (result == B_OK) { result = allocator.AllocateAddress(reply->buffer, size, 1, &buffer, true); } + // execute the request size_t bytesRead; if (result == B_OK) { RequestThreadContext context(volume); - result = volume->ReadAttr(node, (const char*)request->name.GetData(), - request->type, pos, buffer, size, &bytesRead); + result = volume->ReadAttr(node, attrCookie, pos, buffer, size, + &bytesRead); } + // reconstruct the reply, in case it has been overwritten reply = new(reply) ReadAttrReply; + // send the reply reply->error = result; reply->bytesRead = bytesRead; @@ -1379,47 +1547,56 @@ UserlandRequestHandler::_HandleRequest(WriteAttrRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + size_t bytesWritten; if (result == B_OK) { RequestThreadContext context(volume); - result = volume->WriteAttr(request->node, - (const char*)request->name.GetData(), request->type, request->pos, - request->buffer.GetData(), request->buffer.GetSize(), + result = volume->WriteAttr(request->node, request->attrCookie, + request->pos, request->buffer.GetData(), request->buffer.GetSize(), &bytesWritten); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); WriteAttrReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; reply->bytesWritten = bytesWritten; + // send the reply return _SendReply(allocator, false); } // _HandleRequest status_t -UserlandRequestHandler::_HandleRequest(RemoveAttrRequest* request) +UserlandRequestHandler::_HandleRequest(ReadAttrStatRequest* request) { // check and execute the request status_t result = B_OK; Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + + struct stat st; if (result == B_OK) { RequestThreadContext context(volume); - result = volume->RemoveAttr(request->node, - (const char*)request->name.GetData()); + result = volume->ReadAttrStat(request->node, request->attrCookie, + &st); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); - RemoveAttrReply* reply; + ReadAttrStatReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + reply->st = st; + // send the reply return _SendReply(allocator, false); } @@ -1433,53 +1610,59 @@ UserlandRequestHandler::_HandleRequest(RenameAttrRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); - result = volume->RenameAttr(request->node, - (const char*)request->oldName.GetData(), - (const char*)request->newName.GetData()); + result = volume->RenameAttr( + request->oldNode, (const char*)request->oldName.GetData(), + request->newNode, (const char*)request->newName.GetData()); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); RenameAttrReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } // _HandleRequest status_t -UserlandRequestHandler::_HandleRequest(StatAttrRequest* request) +UserlandRequestHandler::_HandleRequest(RemoveAttrRequest* request) { // check and execute the request status_t result = B_OK; Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; - attr_info info; + if (result == B_OK) { RequestThreadContext context(volume); - result = volume->StatAttr(request->node, - (const char*)request->name.GetData(), &info); + result = volume->RemoveAttr(request->node, + (const char*)request->name.GetData()); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); - StatAttrReply* reply; + RemoveAttrReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; - reply->info = info; + // send the reply return _SendReply(allocator, false); } -// #pragma mark - -// #pragma mark ----- indices ----- +// #pragma mark - indices + // _HandleRequest status_t @@ -1490,19 +1673,23 @@ UserlandRequestHandler::_HandleRequest(OpenIndexDirRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; - void* indexDirCookie; + + fs_cookie indexDirCookie; if (result == B_OK) { RequestThreadContext context(volume); result = volume->OpenIndexDir(&indexDirCookie); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); OpenIndexDirReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; reply->indexDirCookie = indexDirCookie; + // send the reply return _SendReply(allocator, false); } @@ -1516,17 +1703,21 @@ UserlandRequestHandler::_HandleRequest(CloseIndexDirRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->CloseIndexDir(request->indexDirCookie); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); CloseIndexDirReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } @@ -1540,17 +1731,21 @@ UserlandRequestHandler::_HandleRequest(FreeIndexDirCookieRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->FreeIndexDirCookie(request->indexDirCookie); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); FreeIndexDirCookieReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } @@ -1564,29 +1759,35 @@ UserlandRequestHandler::_HandleRequest(ReadIndexDirRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; - void* indexDirCookie = request->indexDirCookie; + + fs_cookie indexDirCookie = request->indexDirCookie; size_t bufferSize = request->bufferSize; - int32 count = request->count; + uint32 count = request->count; + // allocate the reply RequestAllocator allocator(fPort->GetPort()); ReadIndexDirReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + void* buffer; if (result == B_OK) { result = allocator.AllocateAddress(reply->buffer, bufferSize, 1, &buffer, true); } + // execute the request - int32 countRead; + uint32 countRead; if (result == B_OK) { RequestThreadContext context(volume); result = volume->ReadIndexDir(indexDirCookie, buffer, bufferSize, count, &countRead); } + // reconstruct the reply, in case it has been overwritten reply = new(reply) ReadIndexDirReply; + // send the reply reply->error = result; reply->count = countRead; @@ -1602,17 +1803,21 @@ UserlandRequestHandler::_HandleRequest(RewindIndexDirRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->RewindIndexDir(request->indexDirCookie); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); RewindIndexDirReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } @@ -1626,18 +1831,22 @@ UserlandRequestHandler::_HandleRequest(CreateIndexRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->CreateIndex((const char*)request->name.GetData(), request->type, request->flags); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); CreateIndexReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } @@ -1651,75 +1860,59 @@ UserlandRequestHandler::_HandleRequest(RemoveIndexRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->RemoveIndex((const char*)request->name.GetData()); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); RemoveIndexReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } // _HandleRequest status_t -UserlandRequestHandler::_HandleRequest(RenameIndexRequest* request) +UserlandRequestHandler::_HandleRequest(ReadIndexStatRequest* request) { // check and execute the request status_t result = B_OK; Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; - if (result == B_OK) { - RequestThreadContext context(volume); - result = volume->RenameIndex((const char*)request->oldName.GetData(), - (const char*)request->newName.GetData()); - } - // prepare the reply - RequestAllocator allocator(fPort->GetPort()); - RenameIndexReply* reply; - status_t error = AllocateRequest(allocator, &reply); - if (error != B_OK) - RETURN_ERROR(error); - reply->error = result; - // send the reply - return _SendReply(allocator, false); -} -// _HandleRequest -status_t -UserlandRequestHandler::_HandleRequest(StatIndexRequest* request) -{ - // check and execute the request - status_t result = B_OK; - Volume* volume = (Volume*)request->volume; - if (!volume) - result = B_BAD_VALUE; - index_info info; + struct stat st; if (result == B_OK) { RequestThreadContext context(volume); - result = volume->StatIndex((const char*)request->name.GetData(), &info); + result = volume->ReadIndexStat((const char*)request->name.GetData(), + &st); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); - StatIndexReply* reply; + ReadIndexStatReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; - reply->info = info; + reply->st = st; + // send the reply return _SendReply(allocator, false); } -// #pragma mark - -// #pragma mark ----- queries ----- +// #pragma mark - queries + // _HandleRequest status_t @@ -1730,20 +1923,24 @@ UserlandRequestHandler::_HandleRequest(OpenQueryRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; - void* queryCookie; + + fs_cookie queryCookie; if (result == B_OK) { RequestThreadContext context(volume); result = volume->OpenQuery((const char*)request->queryString.GetData(), request->flags, request->port, request->token, &queryCookie); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); OpenQueryReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; reply->queryCookie = queryCookie; + // send the reply return _SendReply(allocator, false); } @@ -1757,17 +1954,21 @@ UserlandRequestHandler::_HandleRequest(CloseQueryRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->CloseQuery(request->queryCookie); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); CloseQueryReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } @@ -1781,17 +1982,21 @@ UserlandRequestHandler::_HandleRequest(FreeQueryCookieRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; + if (result == B_OK) { RequestThreadContext context(volume); result = volume->FreeQueryCookie(request->queryCookie); } + // prepare the reply RequestAllocator allocator(fPort->GetPort()); FreeQueryCookieReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + reply->error = result; + // send the reply return _SendReply(allocator, false); } @@ -1805,29 +2010,35 @@ UserlandRequestHandler::_HandleRequest(ReadQueryRequest* request) Volume* volume = (Volume*)request->volume; if (!volume) result = B_BAD_VALUE; - void* queryCookie = request->queryCookie; + + fs_cookie queryCookie = request->queryCookie; size_t bufferSize = request->bufferSize; - int32 count = request->count; + uint32 count = request->count; + // allocate the reply RequestAllocator allocator(fPort->GetPort()); ReadQueryReply* reply; status_t error = AllocateRequest(allocator, &reply); if (error != B_OK) RETURN_ERROR(error); + void* buffer; if (result == B_OK) { result = allocator.AllocateAddress(reply->buffer, bufferSize, 1, &buffer, true); } + // execute the request - int32 countRead; + uint32 countRead; if (result == B_OK) { RequestThreadContext context(volume); result = volume->ReadQuery(queryCookie, buffer, bufferSize, count, &countRead); } + // reconstruct the reply, in case it has been overwritten reply = new(reply) ReadQueryReply; + // send the reply reply->error = result; reply->count = countRead; @@ -1835,8 +2046,8 @@ UserlandRequestHandler::_HandleRequest(ReadQueryRequest* request) } -// #pragma mark - -// #pragma mark ----- other ----- +// #pragma mark - other + // _SendReply status_t diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.h b/src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.h index e72851f2a3..717bf9e0d8 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.h +++ b/src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.h @@ -7,27 +7,79 @@ namespace UserlandFSUtil { +// FS class MountVolumeRequest; class UnmountVolumeRequest; -class ReadFSStatRequest; +class SyncVolumeRequest; +class ReadFSInfoRequest; +class WriteFSInfoRequest; +// vnodes +class LookupRequest; class ReadVNodeRequest; class WriteVNodeRequest; -class ReadStatRequest; +class FSRemoveVNodeRequest; +// nodes +class IOCtlRequest; +class SetFlagsRequest; +class SelectRequest; +class DeselectRequest; +class FSyncRequest; +class ReadSymlinkRequest; +class CreateSymlinkRequest; +class LinkRequest; +class UnlinkRequest; +class RenameRequest; class AccessRequest; +class ReadStatRequest; +class WriteStatRequest; +// files +class CreateRequest; class OpenRequest; class CloseRequest; class FreeCookieRequest; class ReadRequest; -class WalkRequest; +class WriteRequest; +// directories +class CreateDirRequest; +class RemoveDirRequest; class OpenDirRequest; -class ReadDirRequest; -class RewindDirRequest; class CloseDirRequest; class FreeDirCookieRequest; -class ReadLinkRequest; +class ReadDirRequest; +class RewindDirRequest; +// attribute directories +class OpenAttrDirRequest; +class CloseAttrDirRequest; +class FreeAttrDirCookieRequest; +class ReadAttrDirRequest; +class RewindAttrDirRequest; +// attributes +class ReadAttrRequest; +class WriteAttrRequest; +class ReadAttrStatRequest; +class RenameAttrRequest; +class RemoveAttrRequest; +// indices +class OpenIndexDirRequest; +class CloseIndexDirRequest; +class FreeIndexDirCookieRequest; +class ReadIndexDirRequest; +class RewindIndexDirRequest; +class CreateIndexRequest; +class RemoveIndexRequest; +class ReadIndexStatRequest; +// queries +class OpenQueryRequest; +class CloseQueryRequest; +class FreeQueryCookieRequest; +class ReadQueryRequest; + +class RequestAllocator; } // namespace UserlandFSUtil +using namespace UserlandFSUtil; + namespace UserlandFS { class FileSystem; @@ -46,19 +98,29 @@ private: status_t _HandleRequest(MountVolumeRequest* request); status_t _HandleRequest(UnmountVolumeRequest* request); status_t _HandleRequest(SyncVolumeRequest* request); - status_t _HandleRequest(ReadFSStatRequest* request); - status_t _HandleRequest(WriteFSStatRequest* request); + status_t _HandleRequest(ReadFSInfoRequest* request); + status_t _HandleRequest(WriteFSInfoRequest* request); // vnodes + status_t _HandleRequest(LookupRequest* request); status_t _HandleRequest(ReadVNodeRequest* request); status_t _HandleRequest(WriteVNodeRequest* request); status_t _HandleRequest(FSRemoveVNodeRequest* request); // nodes + status_t _HandleRequest(IOCtlRequest* request); + status_t _HandleRequest(SetFlagsRequest* request); + status_t _HandleRequest(SelectRequest* request); + status_t _HandleRequest(DeselectRequest* request); status_t _HandleRequest(FSyncRequest* request); + status_t _HandleRequest(ReadSymlinkRequest* request); + status_t _HandleRequest(CreateSymlinkRequest* request); + status_t _HandleRequest(LinkRequest* request); + status_t _HandleRequest(UnlinkRequest* request); + status_t _HandleRequest(RenameRequest* request); + status_t _HandleRequest(AccessRequest* request); status_t _HandleRequest(ReadStatRequest* request); status_t _HandleRequest(WriteStatRequest* request); - status_t _HandleRequest(AccessRequest* request); // files status_t _HandleRequest(CreateRequest* request); @@ -67,40 +129,30 @@ private: status_t _HandleRequest(FreeCookieRequest* request); status_t _HandleRequest(ReadRequest* request); status_t _HandleRequest(WriteRequest* request); - status_t _HandleRequest(IOCtlRequest* request); - status_t _HandleRequest(SetFlagsRequest* request); - status_t _HandleRequest(SelectRequest* request); - status_t _HandleRequest(DeselectRequest* request); - - // hard links / symlinks - status_t _HandleRequest(LinkRequest* request); - status_t _HandleRequest(UnlinkRequest* request); - status_t _HandleRequest(SymlinkRequest* request); - status_t _HandleRequest(ReadLinkRequest* request); - status_t _HandleRequest(RenameRequest* request); // directories - status_t _HandleRequest(MkDirRequest* request); - status_t _HandleRequest(RmDirRequest* request); + status_t _HandleRequest(CreateDirRequest* request); + status_t _HandleRequest(RemoveDirRequest* request); status_t _HandleRequest(OpenDirRequest* request); status_t _HandleRequest(CloseDirRequest* request); status_t _HandleRequest(FreeDirCookieRequest* request); status_t _HandleRequest(ReadDirRequest* request); status_t _HandleRequest(RewindDirRequest* request); - status_t _HandleRequest(WalkRequest* request); - // attributes + // attribute directories status_t _HandleRequest(OpenAttrDirRequest* request); status_t _HandleRequest(CloseAttrDirRequest* request); status_t _HandleRequest( FreeAttrDirCookieRequest* request); status_t _HandleRequest(ReadAttrDirRequest* request); status_t _HandleRequest(RewindAttrDirRequest* request); + + // attributes status_t _HandleRequest(ReadAttrRequest* request); status_t _HandleRequest(WriteAttrRequest* request); - status_t _HandleRequest(RemoveAttrRequest* request); + status_t _HandleRequest(ReadAttrStatRequest* request); status_t _HandleRequest(RenameAttrRequest* request); - status_t _HandleRequest(StatAttrRequest* request); + status_t _HandleRequest(RemoveAttrRequest* request); // indices status_t _HandleRequest(OpenIndexDirRequest* request); @@ -111,8 +163,7 @@ private: status_t _HandleRequest(RewindIndexDirRequest* request); status_t _HandleRequest(CreateIndexRequest* request); status_t _HandleRequest(RemoveIndexRequest* request); - status_t _HandleRequest(RenameIndexRequest* request); - status_t _HandleRequest(StatIndexRequest* request); + status_t _HandleRequest(ReadIndexStatRequest* request); // queries status_t _HandleRequest(OpenQueryRequest* request); diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/Volume.cpp b/src/add-ons/kernel/file_systems/userlandfs/server/Volume.cpp index d18df1fe5d..471a0746ce 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/Volume.cpp +++ b/src/add-ons/kernel/file_systems/userlandfs/server/Volume.cpp @@ -3,7 +3,7 @@ #include "Volume.h" // constructor -Volume::Volume(FileSystem* fileSystem, nspace_id id) +Volume::Volume(FileSystem* fileSystem, mount_id id) : fFileSystem(fileSystem), fID(id) { @@ -22,19 +22,20 @@ Volume::GetFileSystem() const } // GetID -nspace_id +mount_id Volume::GetID() const { return fID; } -// #pragma mark - -// #pragma mark ----- FS ----- + +// #pragma mark - FS + // Mount status_t -Volume::Mount(const char* device, ulong flags, const char* parameters, - int32 len, vnode_id* rootID) +Volume::Mount(const char* device, uint32 flags, const char* parameters, + vnode_id* rootID) { return B_BAD_VALUE; } @@ -53,126 +54,59 @@ Volume::Sync() return B_BAD_VALUE; } -// ReadFSStat +// ReadFSInfo status_t -Volume::ReadFSStat(fs_info* info) +Volume::ReadFSInfo(fs_info* info) { return B_BAD_VALUE; } -// WriteFSStat +// WriteFSInfo status_t -Volume::WriteFSStat(struct fs_info *info, long mask) +Volume::WriteFSInfo(const struct fs_info *info, uint32 mask) { return B_BAD_VALUE; } -// #pragma mark - -// #pragma mark ----- vnodes ----- + +// #pragma mark - vnodes + + +// Lookup +status_t +Volume::Lookup(fs_vnode dir, const char* entryName, vnode_id* vnid, int* type) +{ + return B_BAD_VALUE; +} // ReadVNode status_t -Volume::ReadVNode(vnode_id vnid, char reenter, void** node) +Volume::ReadVNode(vnode_id vnid, bool reenter, fs_vnode* node) { return B_BAD_VALUE; } // WriteVNode status_t -Volume::WriteVNode(void* node, char reenter) +Volume::WriteVNode(fs_vnode node, bool reenter) { return B_BAD_VALUE; } // RemoveVNode status_t -Volume::RemoveVNode(void* node, char reenter) +Volume::RemoveVNode(fs_vnode node, bool reenter) { return B_BAD_VALUE; } -// #pragma mark - -// #pragma mark ----- nodes ----- -// FSync -status_t -Volume::FSync(void* node) -{ - return B_BAD_VALUE; -} +// #pragma mark - nodes -// ReadStat -status_t -Volume::ReadStat(void* node, struct stat* st) -{ - return B_BAD_VALUE; -} - -// WriteStat -status_t -Volume::WriteStat(void* node, struct stat* st, long mask) -{ - return B_BAD_VALUE; -} - -// Access -status_t -Volume::Access(void* node, int mode) -{ - return B_BAD_VALUE; -} - -// #pragma mark - -// #pragma mark ----- files ----- - -// Create -status_t -Volume::Create(void* dir, const char* name, int openMode, int mode, - vnode_id* vnid, void** cookie) -{ - return B_BAD_VALUE; -} - -// Open -status_t -Volume::Open(void* node, int openMode, void** cookie) -{ - return B_BAD_VALUE; -} - -// Close -status_t -Volume::Close(void* node, void* cookie) -{ - return B_BAD_VALUE; -} - -// FreeCookie -status_t -Volume::FreeCookie(void* node, void* cookie) -{ - return B_BAD_VALUE; -} - -// Read -status_t -Volume::Read(void* node, void* cookie, off_t pos, void* buffer, - size_t bufferSize, size_t* bytesRead) -{ - return B_BAD_VALUE; -} - -// Write -status_t -Volume::Write(void* node, void* cookie, off_t pos, const void* buffer, - size_t bufferSize, size_t* bytesWritten) -{ - return B_BAD_VALUE; -} // IOCtl status_t -Volume::IOCtl(void* node, void* cookie, int command, void *buffer, +Volume::IOCtl(fs_vnode node, fs_cookie cookie, uint32 command, void *buffer, size_t size) { return B_BAD_VALUE; @@ -180,14 +114,14 @@ Volume::IOCtl(void* node, void* cookie, int command, void *buffer, // SetFlags status_t -Volume::SetFlags(void* node, void* cookie, int flags) +Volume::SetFlags(fs_vnode node, fs_cookie cookie, int flags) { return B_BAD_VALUE; } // Select status_t -Volume::Select(void* node, void* cookie, uint8 event, uint32 ref, +Volume::Select(fs_vnode node, fs_cookie cookie, uint8 event, uint32 ref, selectsync* sync) { return B_BAD_VALUE; @@ -195,230 +129,305 @@ Volume::Select(void* node, void* cookie, uint8 event, uint32 ref, // Deselect status_t -Volume::Deselect(void* node, void* cookie, uint8 event, selectsync* sync) +Volume::Deselect(fs_vnode node, fs_cookie cookie, uint8 event, selectsync* sync) { return B_BAD_VALUE; } -// #pragma mark - -// #pragma mark ----- hard links / symlinks ----- +// FSync +status_t +Volume::FSync(fs_vnode node) +{ + return B_BAD_VALUE; +} + +// ReadSymlink +status_t +Volume::ReadSymlink(fs_vnode node, char* buffer, size_t bufferSize, + size_t* bytesRead) +{ + return B_BAD_VALUE; +} + +// CreateSymlink +status_t +Volume::CreateSymlink(fs_vnode dir, const char* name, const char* target, + int mode) +{ + return B_BAD_VALUE; +} // Link status_t -Volume::Link(void* dir, const char* name, void* node) +Volume::Link(fs_vnode dir, const char* name, fs_vnode node) { return B_BAD_VALUE; } // Unlink status_t -Volume::Unlink(void* dir, const char* name) -{ - return B_BAD_VALUE; -} - -// Symlink -status_t -Volume::Symlink(void* dir, const char* name, const char* target) -{ - return B_BAD_VALUE; -} - -// ReadLink -status_t -Volume::ReadLink(void* node, char* buffer, size_t bufferSize, - size_t* bytesRead) +Volume::Unlink(fs_vnode dir, const char* name) { return B_BAD_VALUE; } // Rename status_t -Volume::Rename(void* oldDir, const char* oldName, void* newDir, +Volume::Rename(fs_vnode oldDir, const char* oldName, fs_vnode newDir, const char* newName) { return B_BAD_VALUE; } -// #pragma mark - -// #pragma mark ----- directories ----- - -// MkDir +// Access status_t -Volume::MkDir(void* dir, const char* name, int mode) +Volume::Access(fs_vnode node, int mode) { return B_BAD_VALUE; } -// RmDir +// ReadStat status_t -Volume::RmDir(void* dir, const char* name) +Volume::ReadStat(fs_vnode node, struct stat* st) +{ + return B_BAD_VALUE; +} + +// WriteStat +status_t +Volume::WriteStat(fs_vnode node, const struct stat *st, uint32 mask) +{ + return B_BAD_VALUE; +} + + +// #pragma mark - files + + +// Create +status_t +Volume::Create(fs_vnode dir, const char* name, int openMode, int mode, + fs_cookie* cookie, vnode_id* vnid) +{ + return B_BAD_VALUE; +} + +// Open +status_t +Volume::Open(fs_vnode node, int openMode, fs_cookie* cookie) +{ + return B_BAD_VALUE; +} + +// Close +status_t +Volume::Close(fs_vnode node, fs_cookie cookie) +{ + return B_BAD_VALUE; +} + +// FreeCookie +status_t +Volume::FreeCookie(fs_vnode node, fs_cookie cookie) +{ + return B_BAD_VALUE; +} + +// Read +status_t +Volume::Read(fs_vnode node, fs_cookie cookie, off_t pos, void* buffer, + size_t bufferSize, size_t* bytesRead) +{ + return B_BAD_VALUE; +} + +// Write +status_t +Volume::Write(fs_vnode node, fs_cookie cookie, off_t pos, const void* buffer, + size_t bufferSize, size_t* bytesWritten) +{ + return B_BAD_VALUE; +} + + +// #pragma mark - directories + + +// CreateDir +status_t +Volume::CreateDir(fs_vnode dir, const char* name, int mode, vnode_id *newDir) +{ + return B_BAD_VALUE; +} + +// RemoveDir +status_t +Volume::RemoveDir(fs_vnode dir, const char* name) { return B_BAD_VALUE; } // OpenDir status_t -Volume::OpenDir(void* node, void** cookie) +Volume::OpenDir(fs_vnode node, fs_cookie* cookie) { return B_BAD_VALUE; } // CloseDir status_t -Volume::CloseDir(void* node, void* cookie) +Volume::CloseDir(fs_vnode node, fs_vnode cookie) { return B_BAD_VALUE; } // FreeDirCookie status_t -Volume::FreeDirCookie(void* node, void* cookie) +Volume::FreeDirCookie(fs_vnode node, fs_vnode cookie) { return B_BAD_VALUE; } // ReadDir status_t -Volume::ReadDir(void* node, void* cookie, void* buffer, size_t bufferSize, - int32 count, int32* countRead) +Volume::ReadDir(fs_vnode node, fs_vnode cookie, void* buffer, size_t bufferSize, + uint32 count, uint32* countRead) { return B_BAD_VALUE; } // RewindDir status_t -Volume::RewindDir(void* node, void* cookie) +Volume::RewindDir(fs_vnode node, fs_vnode cookie) { return B_BAD_VALUE; } -// Walk -status_t -Volume::Walk(void* dir, const char* entryName, char** resolvedPath, - vnode_id* vnid) -{ - return B_BAD_VALUE; -} -// #pragma mark - -// #pragma mark ----- attributes ----- +// #pragma mark - attribute directories + // OpenAttrDir status_t -Volume::OpenAttrDir(void* node, void** cookie) +Volume::OpenAttrDir(fs_vnode node, fs_cookie *cookie) { return B_BAD_VALUE; } // CloseAttrDir status_t -Volume::CloseAttrDir(void* node, void* cookie) +Volume::CloseAttrDir(fs_vnode node, fs_cookie cookie) { return B_BAD_VALUE; } // FreeAttrDirCookie status_t -Volume::FreeAttrDirCookie(void* node, void* cookie) +Volume::FreeAttrDirCookie(fs_vnode node, fs_cookie cookie) { return B_BAD_VALUE; } // ReadAttrDir status_t -Volume::ReadAttrDir(void* node, void* cookie, void* buffer, size_t bufferSize, - int32 count, int32* countRead) +Volume::ReadAttrDir(fs_vnode node, fs_cookie cookie, void* buffer, + size_t bufferSize, uint32 count, uint32* countRead) { return B_BAD_VALUE; } // RewindAttrDir status_t -Volume::RewindAttrDir(void* node, void* cookie) +Volume::RewindAttrDir(fs_vnode node, fs_cookie cookie) { return B_BAD_VALUE; } + +// #pragma mark - attributes + + // ReadAttr status_t -Volume::ReadAttr(void* node, const char* name, int type, off_t pos, - void* buffer, size_t bufferSize, size_t* bytesRead) +Volume::ReadAttr(fs_vnode node, fs_cookie cookie, off_t pos, void* buffer, + size_t bufferSize, size_t* bytesRead) { return B_BAD_VALUE; } // WriteAttr status_t -Volume::WriteAttr(void* node, const char* name, int type, off_t pos, +Volume::WriteAttr(fs_vnode node, fs_cookie cookie, off_t pos, const void* buffer, size_t bufferSize, size_t* bytesWritten) { return B_BAD_VALUE; } -// RemoveAttr -status_t -Volume::RemoveAttr(void* node, const char* name) -{ - return B_BAD_VALUE; -} - -// RenameAttr -status_t -Volume::RenameAttr(void* node, const char* oldName, const char* newName) -{ - return B_BAD_VALUE; -} - // StatAttr status_t -Volume::StatAttr(void* node, const char* name, struct attr_info* attrInfo) +Volume::ReadAttrStat(fs_vnode node, fs_cookie cookie, struct stat *st) { return B_BAD_VALUE; } -// #pragma mark - -// #pragma mark ----- indices ----- +// RenameAttr +status_t +Volume::RenameAttr(fs_vnode oldNode, const char* oldName, fs_vnode newNode, + const char* newName) +{ + return B_BAD_VALUE; +} + +// RemoveAttr +status_t +Volume::RemoveAttr(fs_vnode node, const char* name) +{ + return B_BAD_VALUE; +} + + +// #pragma mark - indices + // OpenIndexDir status_t -Volume::OpenIndexDir(void** cookie) +Volume::OpenIndexDir(fs_cookie *cookie) { return B_BAD_VALUE; } // CloseIndexDir status_t -Volume::CloseIndexDir(void* cookie) +Volume::CloseIndexDir(fs_cookie cookie) { return B_BAD_VALUE; } // FreeIndexDirCookie status_t -Volume::FreeIndexDirCookie(void* cookie) +Volume::FreeIndexDirCookie(fs_cookie cookie) { return B_BAD_VALUE; } // ReadIndexDir status_t -Volume::ReadIndexDir(void* cookie, void* buffer, size_t bufferSize, - int32 count, int32* countRead) +Volume::ReadIndexDir(fs_cookie cookie, void* buffer, size_t bufferSize, + uint32 count, uint32* countRead) { return B_BAD_VALUE; } // RewindIndexDir status_t -Volume::RewindIndexDir(void* cookie) +Volume::RewindIndexDir(fs_cookie cookie) { return B_BAD_VALUE; } // CreateIndex status_t -Volume::CreateIndex(const char* name, int type, int flags) +Volume::CreateIndex(const char* name, uint32 type, uint32 flags) { return B_BAD_VALUE; } @@ -430,49 +439,43 @@ Volume::RemoveIndex(const char* name) return B_BAD_VALUE; } -// RenameIndex +// ReadIndexStat status_t -Volume::RenameIndex(const char* oldName, const char* newName) +Volume::ReadIndexStat(const char *name, struct stat *st) { return B_BAD_VALUE; } -// StatIndex -status_t -Volume::StatIndex(const char *name, struct index_info* indexInfo) -{ - return B_BAD_VALUE; -} -// #pragma mark - -// #pragma mark ----- queries ----- +// #pragma mark - queries + // OpenQuery status_t -Volume::OpenQuery(const char* queryString, ulong flags, port_id port, - long token, void** cookie) +Volume::OpenQuery(const char* queryString, uint32 flags, port_id port, + uint32 token, fs_cookie *cookie) { return B_BAD_VALUE; } // CloseQuery status_t -Volume::CloseQuery(void* cookie) +Volume::CloseQuery(fs_cookie cookie) { return B_BAD_VALUE; } // FreeQueryCookie status_t -Volume::FreeQueryCookie(void* cookie) +Volume::FreeQueryCookie(fs_cookie cookie) { return B_BAD_VALUE; } // ReadQuery status_t -Volume::ReadQuery(void* cookie, void* buffer, size_t bufferSize, int32 count, - int32* countRead) +Volume::ReadQuery(fs_cookie cookie, void* buffer, size_t bufferSize, + uint32 count, uint32* countRead) { return B_BAD_VALUE; } diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/Volume.h b/src/add-ons/kernel/file_systems/userlandfs/server/Volume.h index 3e03869467..0f36a3da8e 100644 --- a/src/add-ons/kernel/file_systems/userlandfs/server/Volume.h +++ b/src/add-ons/kernel/file_systems/userlandfs/server/Volume.h @@ -3,7 +3,7 @@ #ifndef USERLAND_FS_VOLUME_H #define USERLAND_FS_VOLUME_H -#include +#include #include namespace UserlandFS { @@ -12,128 +12,135 @@ class FileSystem; class Volume { public: - Volume(FileSystem* fileSystem, - nspace_id id); + Volume(FileSystem* fileSystem, mount_id id); virtual ~Volume(); - FileSystem* GetFileSystem() const; - nspace_id GetID() const; + FileSystem* GetFileSystem() const; + mount_id GetID() const; // FS - virtual status_t Mount(const char* device, ulong flags, - const char* parameters, int32 len, - vnode_id* rootID); + virtual status_t Mount(const char* device, uint32 flags, + const char* parameters, vnode_id* rootID); virtual status_t Unmount(); virtual status_t Sync(); - virtual status_t ReadFSStat(fs_info* info); - virtual status_t WriteFSStat(struct fs_info *info, long mask); + virtual status_t ReadFSInfo(fs_info* info); + virtual status_t WriteFSInfo(const struct fs_info *info, + uint32 mask); // vnodes - virtual status_t ReadVNode(vnode_id vnid, char reenter, - void** node); - virtual status_t WriteVNode(void* node, char reenter); - virtual status_t RemoveVNode(void* node, char reenter); + virtual status_t Lookup(fs_vnode dir, const char* entryName, + vnode_id* vnid, int* type); + virtual status_t ReadVNode(vnode_id vnid, bool reenter, + fs_vnode* node); + virtual status_t WriteVNode(fs_vnode node, bool reenter); + virtual status_t RemoveVNode(fs_vnode node, bool reenter); // nodes - virtual status_t FSync(void* node); - virtual status_t ReadStat(void* node, struct stat* st); - virtual status_t WriteStat(void* node, struct stat* st, - long mask); - virtual status_t Access(void* node, int mode); + virtual status_t IOCtl(fs_vnode node, fs_cookie cookie, + uint32 command, void* buffer, size_t size); + virtual status_t SetFlags(fs_vnode node, fs_cookie cookie, + int flags); + virtual status_t Select(fs_vnode node, fs_cookie cookie, + uint8 event, uint32 ref, selectsync* sync); + virtual status_t Deselect(fs_vnode node, fs_cookie cookie, + uint8 event, selectsync* sync); + + virtual status_t FSync(fs_vnode node); + + virtual status_t ReadSymlink(fs_vnode node, char* buffer, + size_t bufferSize, size_t* bytesRead); + virtual status_t CreateSymlink(fs_vnode dir, const char* name, + const char* target, int mode); + + virtual status_t Link(fs_vnode dir, const char* name, + fs_vnode node); + virtual status_t Unlink(fs_vnode dir, const char* name); + virtual status_t Rename(fs_vnode oldDir, const char* oldName, + fs_vnode newDir, const char* newName); + + virtual status_t Access(fs_vnode node, int mode); + virtual status_t ReadStat(fs_vnode node, struct stat* st); + virtual status_t WriteStat(fs_vnode node, const struct stat *st, + uint32 mask); // files - virtual status_t Create(void* dir, const char* name, - int openMode, int mode, vnode_id* vnid, - void** cookie); - virtual status_t Open(void* node, int openMode, void** cookie); - virtual status_t Close(void* node, void* cookie); - virtual status_t FreeCookie(void* node, void* cookie); - virtual status_t Read(void* node, void* cookie, off_t pos, + virtual status_t Create(fs_vnode dir, const char* name, + int openMode, int mode, fs_cookie* cookie, + vnode_id* vnid); + virtual status_t Open(fs_vnode node, int openMode, + fs_cookie* cookie); + virtual status_t Close(fs_vnode node, fs_cookie cookie); + virtual status_t FreeCookie(fs_vnode node, fs_cookie cookie); + virtual status_t Read(fs_vnode node, fs_cookie cookie, off_t pos, void* buffer, size_t bufferSize, size_t* bytesRead); - virtual status_t Write(void* node, void* cookie, off_t pos, - const void* buffer, size_t bufferSize, - size_t* bytesWritten); - virtual status_t IOCtl(void* node, void* cookie, int command, - void *buffer, size_t size); - virtual status_t SetFlags(void* node, void* cookie, int flags); - virtual status_t Select(void* node, void* cookie, uint8 event, - uint32 ref, selectsync* sync); - virtual status_t Deselect(void* node, void* cookie, uint8 event, - selectsync* sync); - - // hard links / symlinks - virtual status_t Link(void* dir, const char* name, void* node); - virtual status_t Unlink(void* dir, const char* name); - virtual status_t Symlink(void* dir, const char* name, - const char* target); - virtual status_t ReadLink(void* node, char* buffer, - size_t bufferSize, size_t* bytesRead); - virtual status_t Rename(void* oldDir, const char* oldName, - void* newDir, const char* newName); + virtual status_t Write(fs_vnode node, fs_cookie cookie, + off_t pos, const void* buffer, + size_t bufferSize, size_t* bytesWritten); // directories - virtual status_t MkDir(void* dir, const char* name, int mode); - virtual status_t RmDir(void* dir, const char* name); - virtual status_t OpenDir(void* node, void** cookie); - virtual status_t CloseDir(void* node, void* cookie); - virtual status_t FreeDirCookie(void* node, void* cookie); - virtual status_t ReadDir(void* node, void* cookie, + virtual status_t CreateDir(fs_vnode dir, const char* name, + int mode, vnode_id *newDir); + virtual status_t RemoveDir(fs_vnode dir, const char* name); + virtual status_t OpenDir(fs_vnode node, fs_cookie* cookie); + virtual status_t CloseDir(fs_vnode node, fs_vnode cookie); + virtual status_t FreeDirCookie(fs_vnode node, fs_vnode cookie); + virtual status_t ReadDir(fs_vnode node, fs_vnode cookie, void* buffer, size_t bufferSize, - int32 count, int32* countRead); - virtual status_t RewindDir(void* node, void* cookie); - virtual status_t Walk(void* dir, const char* entryName, - char** resolvedPath, vnode_id* vnid); + uint32 count, uint32* countRead); + virtual status_t RewindDir(fs_vnode node, fs_vnode cookie); + + // attribute directories + virtual status_t OpenAttrDir(fs_vnode node, fs_cookie *cookie); + virtual status_t CloseAttrDir(fs_vnode node, fs_cookie cookie); + virtual status_t FreeAttrDirCookie(fs_vnode node, + fs_cookie cookie); + virtual status_t ReadAttrDir(fs_vnode node, fs_cookie cookie, + void* buffer, size_t bufferSize, + uint32 count, uint32* countRead); + virtual status_t RewindAttrDir(fs_vnode node, fs_cookie cookie); // attributes - virtual status_t OpenAttrDir(void* node, void** cookie); - virtual status_t CloseAttrDir(void* node, void* cookie); - virtual status_t FreeAttrDirCookie(void* node, void* cookie); - virtual status_t ReadAttrDir(void* node, void* cookie, - void* buffer, size_t bufferSize, - int32 count, int32* countRead); - virtual status_t RewindAttrDir(void* node, void* cookie); - virtual status_t ReadAttr(void* node, const char* name, - int type, off_t pos, void* buffer, - size_t bufferSize, size_t* bytesRead); - virtual status_t WriteAttr(void* node, const char* name, - int type, off_t pos, const void* buffer, + virtual status_t ReadAttr(fs_vnode node, fs_cookie cookie, + off_t pos, void* buffer, size_t bufferSize, + size_t* bytesRead); + virtual status_t WriteAttr(fs_vnode node, fs_cookie cookie, + off_t pos, const void* buffer, size_t bufferSize, size_t* bytesWritten); - virtual status_t RemoveAttr(void* node, const char* name); - virtual status_t RenameAttr(void* node, const char* oldName, + virtual status_t ReadAttrStat(fs_vnode node, fs_cookie cookie, + struct stat *st); + virtual status_t RenameAttr(fs_vnode oldNode, + const char* oldName, fs_vnode newNode, const char* newName); - virtual status_t StatAttr(void* node, const char* name, - struct attr_info* attrInfo); + virtual status_t RemoveAttr(fs_vnode node, const char* name); // indices - virtual status_t OpenIndexDir(void** cookie); - virtual status_t CloseIndexDir(void* cookie); - virtual status_t FreeIndexDirCookie(void* cookie); - virtual status_t ReadIndexDir(void* cookie, void* buffer, - size_t bufferSize, int32 count, - int32* countRead); - virtual status_t RewindIndexDir(void* cookie); - virtual status_t CreateIndex(const char* name, int type, - int flags); + virtual status_t OpenIndexDir(fs_cookie *cookie); + virtual status_t CloseIndexDir(fs_cookie cookie); + virtual status_t FreeIndexDirCookie(fs_cookie cookie); + virtual status_t ReadIndexDir(fs_cookie cookie, void* buffer, + size_t bufferSize, uint32 count, + uint32* countRead); + virtual status_t RewindIndexDir(fs_cookie cookie); + virtual status_t CreateIndex(const char* name, uint32 type, + uint32 flags); virtual status_t RemoveIndex(const char* name); - virtual status_t RenameIndex(const char* oldName, - const char* newName); - virtual status_t StatIndex(const char *name, - struct index_info* indexInfo); + virtual status_t ReadIndexStat(const char *name, + struct stat *st); // queries virtual status_t OpenQuery(const char* queryString, - ulong flags, port_id port, long token, - void** cookie); - virtual status_t CloseQuery(void* cookie); - virtual status_t FreeQueryCookie(void* cookie); - virtual status_t ReadQuery(void* cookie, void* buffer, - size_t bufferSize, int32 count, - int32* countRead); + uint32 flags, port_id port, uint32 token, + fs_cookie *cookie); + virtual status_t CloseQuery(fs_cookie cookie); + virtual status_t FreeQueryCookie(fs_cookie cookie); + virtual status_t ReadQuery(fs_cookie cookie, void* buffer, + size_t bufferSize, uint32 count, + uint32* countRead); protected: FileSystem* fFileSystem; - nspace_id fID; + mount_id fID; }; } // namespace UserlandFS