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

More adjustments to the new FS interface. The enabled sources compile again,

Browse Source 
but don't link yet.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@29332 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Ingo Weinhold
2009-02-27 10:54:26 +00:00
parent f6583b4a17
commit b19b5f9dda
3 changed files with 191 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelVolume.cpp
+163 -97
View File
@@ -323,39 +323,48 @@ HaikuKernelVolume::Unlink(void* _dir, const char* name)
// Rename // Rename
status_t status_t
HaikuKernelVolume::Rename(void* oldDir, const char* oldName, void* newDir, HaikuKernelVolume::Rename(void* _oldDir, const char* oldName, void* _newDir,
const char* newName) const char* newName)
{ {
if (!fFSModule->rename) HaikuKernelNode* oldDir = (HaikuKernelNode*)_oldDir;
HaikuKernelNode* newDir = (HaikuKernelNode*)_newDir;
if (!oldDir->ops->rename)
return B_BAD_VALUE; return B_BAD_VALUE;
return fFSModule->rename(&fVolume, oldDir, oldName, newDir, newName); return oldDir->ops->rename(&fVolume, oldDir, oldName, newDir, newName);
} }
// Access // Access
status_t status_t
HaikuKernelVolume::Access(void* node, int mode) HaikuKernelVolume::Access(void* _node, int mode)
{ {
if (!fFSModule->access) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->access)
return B_OK; return B_OK;
return fFSModule->access(&fVolume, node, mode); return node->ops->access(&fVolume, node, mode);
} }
// ReadStat // ReadStat
status_t status_t
HaikuKernelVolume::ReadStat(void* node, struct stat* st) HaikuKernelVolume::ReadStat(void* _node, struct stat* st)
{ {
if (!fFSModule->read_stat) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->read_stat)
return B_BAD_VALUE; return B_BAD_VALUE;
return fFSModule->read_stat(&fVolume, node, st); return node->ops->read_stat(&fVolume, node, st);
} }
// WriteStat // WriteStat
status_t status_t
HaikuKernelVolume::WriteStat(void* node, const struct stat *st, uint32 mask) HaikuKernelVolume::WriteStat(void* _node, const struct stat *st, uint32 mask)
{ {
if (!fFSModule->write_stat) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->write_stat)
return B_BAD_VALUE; return B_BAD_VALUE;
return fFSModule->write_stat(&fVolume, node, st, mask); return node->ops->write_stat(&fVolume, node, st, mask);
} }
@@ -364,66 +373,78 @@ HaikuKernelVolume::WriteStat(void* node, const struct stat *st, uint32 mask)
// Create // Create
status_t status_t
HaikuKernelVolume::Create(void* dir, const char* name, int openMode, int mode, HaikuKernelVolume::Create(void* _dir, const char* name, int openMode, int mode,
void** cookie, ino_t* vnid) void** cookie, ino_t* vnid)
{ {
if (!fFSModule->create) HaikuKernelNode* dir = (HaikuKernelNode*)_dir;
if (!dir->ops->create)
return B_BAD_VALUE; return B_BAD_VALUE;
return fFSModule->create(&fVolume, dir, name, openMode, mode, cookie, return dir->ops->create(&fVolume, dir, name, openMode, mode, cookie,
vnid); vnid);
} }
// Open // Open
status_t status_t
HaikuKernelVolume::Open(void* node, int openMode, void** cookie) HaikuKernelVolume::Open(void* _node, int openMode, void** cookie)
{ {
if (!fFSModule->open) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->open)
return B_BAD_VALUE; return B_BAD_VALUE;
return fFSModule->open(&fVolume, node, openMode, cookie); return node->ops->open(&fVolume, node, openMode, cookie);
} }
// Close // Close
status_t status_t
HaikuKernelVolume::Close(void* node, void* cookie) HaikuKernelVolume::Close(void* _node, void* cookie)
{ {
if (!fFSModule->close) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->close)
return B_OK; return B_OK;
return fFSModule->close(&fVolume, node, cookie); return node->ops->close(&fVolume, node, cookie);
} }
// FreeCookie // FreeCookie
status_t status_t
HaikuKernelVolume::FreeCookie(void* node, void* cookie) HaikuKernelVolume::FreeCookie(void* _node, void* cookie)
{ {
if (!fFSModule->free_cookie) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->free_cookie)
return B_OK; return B_OK;
return fFSModule->free_cookie(&fVolume, node, cookie); return node->ops->free_cookie(&fVolume, node, cookie);
} }
// Read // Read
status_t status_t
HaikuKernelVolume::Read(void* node, void* cookie, off_t pos, void* buffer, HaikuKernelVolume::Read(void* _node, void* cookie, off_t pos, void* buffer,
size_t bufferSize, size_t* bytesRead) size_t bufferSize, size_t* bytesRead)
{ {
if (!fFSModule->read) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->read)
return B_BAD_VALUE; return B_BAD_VALUE;
*bytesRead = bufferSize; *bytesRead = bufferSize;
return fFSModule->read(&fVolume, node, cookie, pos, buffer, bytesRead); return node->ops->read(&fVolume, node, cookie, pos, buffer, bytesRead);
} }
// Write // Write
status_t status_t
HaikuKernelVolume::Write(void* node, void* cookie, off_t pos, HaikuKernelVolume::Write(void* _node, void* cookie, off_t pos,
const void* buffer, size_t bufferSize, size_t* bytesWritten) const void* buffer, size_t bufferSize, size_t* bytesWritten)
{ {
if (!fFSModule->write) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->write)
return B_BAD_VALUE; return B_BAD_VALUE;
*bytesWritten = bufferSize; *bytesWritten = bufferSize;
return fFSModule->write(&fVolume, node, cookie, pos, buffer, return node->ops->write(&fVolume, node, cookie, pos, buffer,
bytesWritten); bytesWritten);
} }
@@ -433,71 +454,85 @@ HaikuKernelVolume::Write(void* node, void* cookie, off_t pos,
// CreateDir // CreateDir
status_t status_t
HaikuKernelVolume::CreateDir(void* dir, const char* name, int mode, HaikuKernelVolume::CreateDir(void* _dir, const char* name, int mode,
ino_t *newDir) ino_t *newDir)
{ {
if (!fFSModule->create_dir) HaikuKernelNode* dir = (HaikuKernelNode*)_dir;
if (!dir->ops->create_dir)
return B_BAD_VALUE; return B_BAD_VALUE;
return fFSModule->create_dir(&fVolume, dir, name, mode, newDir); return dir->ops->create_dir(&fVolume, dir, name, mode, newDir);
} }
// RemoveDir // RemoveDir
status_t status_t
HaikuKernelVolume::RemoveDir(void* dir, const char* name) HaikuKernelVolume::RemoveDir(void* _dir, const char* name)
{ {
if (!fFSModule->remove_dir) HaikuKernelNode* dir = (HaikuKernelNode*)_dir;
if (!dir->ops->remove_dir)
return B_BAD_VALUE; return B_BAD_VALUE;
return fFSModule->remove_dir(&fVolume, dir, name); return dir->ops->remove_dir(&fVolume, dir, name);
} }
// OpenDir // OpenDir
status_t status_t
HaikuKernelVolume::OpenDir(void* node, void** cookie) HaikuKernelVolume::OpenDir(void* _node, void** cookie)
{ {
if (!fFSModule->open_dir) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->open_dir)
return B_BAD_VALUE; return B_BAD_VALUE;
return fFSModule->open_dir(&fVolume, node, cookie); return node->ops->open_dir(&fVolume, node, cookie);
} }
// CloseDir // CloseDir
status_t status_t
HaikuKernelVolume::CloseDir(void* node, void* cookie) HaikuKernelVolume::CloseDir(void* _node, void* cookie)
{ {
if (!fFSModule->close_dir) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->close_dir)
return B_OK; return B_OK;
return fFSModule->close_dir(&fVolume, node, cookie); return node->ops->close_dir(&fVolume, node, cookie);
} }
// FreeDirCookie // FreeDirCookie
status_t status_t
HaikuKernelVolume::FreeDirCookie(void* node, void* cookie) HaikuKernelVolume::FreeDirCookie(void* _node, void* cookie)
{ {
if (!fFSModule->free_dir_cookie) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->free_dir_cookie)
return B_OK; return B_OK;
return fFSModule->free_dir_cookie(&fVolume, node, cookie); return node->ops->free_dir_cookie(&fVolume, node, cookie);
} }
// ReadDir // ReadDir
status_t status_t
HaikuKernelVolume::ReadDir(void* node, void* cookie, void* buffer, HaikuKernelVolume::ReadDir(void* _node, void* cookie, void* buffer,
size_t bufferSize, uint32 count, uint32* countRead) size_t bufferSize, uint32 count, uint32* countRead)
{ {
if (!fFSModule->read_dir) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->read_dir)
return B_BAD_VALUE; return B_BAD_VALUE;
*countRead = count; *countRead = count;
return fFSModule->read_dir(&fVolume, node, cookie, return node->ops->read_dir(&fVolume, node, cookie,
(struct dirent*)buffer, bufferSize, countRead); (struct dirent*)buffer, bufferSize, countRead);
} }
// RewindDir // RewindDir
status_t status_t
HaikuKernelVolume::RewindDir(void* node, void* cookie) HaikuKernelVolume::RewindDir(void* _node, void* cookie)
{ {
if (!fFSModule->rewind_dir) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->rewind_dir)
return B_BAD_VALUE; return B_BAD_VALUE;
return fFSModule->rewind_dir(&fVolume, node, cookie); return node->ops->rewind_dir(&fVolume, node, cookie);
} }
@@ -506,52 +541,62 @@ HaikuKernelVolume::RewindDir(void* node, void* cookie)
// OpenAttrDir // OpenAttrDir
status_t status_t
HaikuKernelVolume::OpenAttrDir(void* node, void** cookie) HaikuKernelVolume::OpenAttrDir(void* _node, void** cookie)
{ {
if (!fFSModule->open_attr_dir) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->open_attr_dir)
return B_BAD_VALUE; return B_BAD_VALUE;
return fFSModule->open_attr_dir(&fVolume, node, cookie); return node->ops->open_attr_dir(&fVolume, node, cookie);
} }
// CloseAttrDir // CloseAttrDir
status_t status_t
HaikuKernelVolume::CloseAttrDir(void* node, void* cookie) HaikuKernelVolume::CloseAttrDir(void* _node, void* cookie)
{ {
if (!fFSModule->close_attr_dir) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->close_attr_dir)
return B_OK; return B_OK;
return fFSModule->close_attr_dir(&fVolume, node, cookie); return node->ops->close_attr_dir(&fVolume, node, cookie);
} }
// FreeAttrDirCookie // FreeAttrDirCookie
status_t status_t
HaikuKernelVolume::FreeAttrDirCookie(void* node, void* cookie) HaikuKernelVolume::FreeAttrDirCookie(void* _node, void* cookie)
{ {
if (!fFSModule->free_attr_dir_cookie) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->free_attr_dir_cookie)
return B_OK; return B_OK;
return fFSModule->free_attr_dir_cookie(&fVolume, node, cookie); return node->ops->free_attr_dir_cookie(&fVolume, node, cookie);
} }
// ReadAttrDir // ReadAttrDir
status_t status_t
HaikuKernelVolume::ReadAttrDir(void* node, void* cookie, void* buffer, HaikuKernelVolume::ReadAttrDir(void* _node, void* cookie, void* buffer,
size_t bufferSize, uint32 count, uint32* countRead) size_t bufferSize, uint32 count, uint32* countRead)
{ {
if (!fFSModule->read_attr_dir) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->read_attr_dir)
return B_BAD_VALUE; return B_BAD_VALUE;
*countRead = count; *countRead = count;
return fFSModule->read_attr_dir(&fVolume, node, cookie, return node->ops->read_attr_dir(&fVolume, node, cookie,
(struct dirent*)buffer, bufferSize, countRead); (struct dirent*)buffer, bufferSize, countRead);
} }
// RewindAttrDir // RewindAttrDir
status_t status_t
HaikuKernelVolume::RewindAttrDir(void* node, void* cookie) HaikuKernelVolume::RewindAttrDir(void* _node, void* cookie)
{ {
if (!fFSModule->rewind_attr_dir) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->rewind_attr_dir)
return B_BAD_VALUE; return B_BAD_VALUE;
return fFSModule->rewind_attr_dir(&fVolume, node, cookie); return node->ops->rewind_attr_dir(&fVolume, node, cookie);
} }
@@ -560,110 +605,131 @@ HaikuKernelVolume::RewindAttrDir(void* node, void* cookie)
// CreateAttr // CreateAttr
status_t status_t
HaikuKernelVolume::CreateAttr(void* node, const char* name, uint32 type, HaikuKernelVolume::CreateAttr(void* _node, const char* name, uint32 type,
int openMode, void** cookie) int openMode, void** cookie)
{ {
if (!fFSModule->create_attr) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->create_attr)
return B_BAD_VALUE; return B_BAD_VALUE;
return fFSModule->create_attr(&fVolume, node, name, type, openMode, return node->ops->create_attr(&fVolume, node, name, type, openMode,
cookie); cookie);
} }
// OpenAttr // OpenAttr
status_t status_t
HaikuKernelVolume::OpenAttr(void* node, const char* name, int openMode, HaikuKernelVolume::OpenAttr(void* _node, const char* name, int openMode,
void** cookie) void** cookie)
{ {
if (!fFSModule->open_attr) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->open_attr)
return B_BAD_VALUE; return B_BAD_VALUE;
return fFSModule->open_attr(&fVolume, node, name, openMode, cookie); return node->ops->open_attr(&fVolume, node, name, openMode, cookie);
} }
// CloseAttr // CloseAttr
status_t status_t
HaikuKernelVolume::CloseAttr(void* node, void* cookie) HaikuKernelVolume::CloseAttr(void* _node, void* cookie)
{ {
if (!fFSModule->close_attr) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->close_attr)
return B_OK; return B_OK;
return fFSModule->close_attr(&fVolume, node, cookie); return node->ops->close_attr(&fVolume, node, cookie);
} }
// FreeAttrCookie // FreeAttrCookie
status_t status_t
HaikuKernelVolume::FreeAttrCookie(void* node, void* cookie) HaikuKernelVolume::FreeAttrCookie(void* _node, void* cookie)
{ {
if (!fFSModule->free_attr_cookie) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->free_attr_cookie)
return B_OK; return B_OK;
return fFSModule->free_attr_cookie(&fVolume, node, cookie); return node->ops->free_attr_cookie(&fVolume, node, cookie);
} }
// ReadAttr // ReadAttr
status_t status_t
HaikuKernelVolume::ReadAttr(void* node, void* cookie, off_t pos, HaikuKernelVolume::ReadAttr(void* _node, void* cookie, off_t pos,
void* buffer, size_t bufferSize, size_t* bytesRead) void* buffer, size_t bufferSize, size_t* bytesRead)
{ {
if (!fFSModule->read_attr) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->read_attr)
return B_BAD_VALUE; return B_BAD_VALUE;
*bytesRead = bufferSize; *bytesRead = bufferSize;
return fFSModule->read_attr(&fVolume, node, cookie, pos, buffer, return node->ops->read_attr(&fVolume, node, cookie, pos, buffer,
bytesRead); bytesRead);
} }
// WriteAttr // WriteAttr
status_t status_t
HaikuKernelVolume::WriteAttr(void* node, void* cookie, off_t pos, HaikuKernelVolume::WriteAttr(void* _node, void* cookie, off_t pos,
const void* buffer, size_t bufferSize, size_t* bytesWritten) const void* buffer, size_t bufferSize, size_t* bytesWritten)
{ {
if (!fFSModule->write_attr) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->write_attr)
return B_BAD_VALUE; return B_BAD_VALUE;
*bytesWritten = bufferSize; *bytesWritten = bufferSize;
return fFSModule->write_attr(&fVolume, node, cookie, pos, buffer, return node->ops->write_attr(&fVolume, node, cookie, pos, buffer,
bytesWritten); bytesWritten);
} }
// ReadAttrStat // ReadAttrStat
status_t status_t
HaikuKernelVolume::ReadAttrStat(void* node, void* cookie, HaikuKernelVolume::ReadAttrStat(void* _node, void* cookie,
struct stat *st) struct stat *st)
{ {
if (!fFSModule->read_attr_stat) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->read_attr_stat)
return B_BAD_VALUE; return B_BAD_VALUE;
return fFSModule->read_attr_stat(&fVolume, node, cookie, st); return node->ops->read_attr_stat(&fVolume, node, cookie, st);
} }
// WriteAttrStat // WriteAttrStat
status_t status_t
HaikuKernelVolume::WriteAttrStat(void* node, void* cookie, HaikuKernelVolume::WriteAttrStat(void* _node, void* cookie,
const struct stat* st, int statMask) const struct stat* st, int statMask)
{ {
if (!fFSModule->write_attr_stat) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->write_attr_stat)
return B_BAD_VALUE; return B_BAD_VALUE;
return fFSModule->write_attr_stat(&fVolume, node, cookie, st, return node->ops->write_attr_stat(&fVolume, node, cookie, st,
statMask); statMask);
} }
// RenameAttr // RenameAttr
status_t status_t
HaikuKernelVolume::RenameAttr(void* oldNode, const char* oldName, HaikuKernelVolume::RenameAttr(void* _oldNode, const char* oldName,
void* newNode, const char* newName) void* _newNode, const char* newName)
{ {
if (!fFSModule->rename_attr) HaikuKernelNode* oldNode = (HaikuKernelNode*)_oldNode;
HaikuKernelNode* newNode = (HaikuKernelNode*)_newNode;
if (!oldNode->ops->rename_attr)
return B_BAD_VALUE; return B_BAD_VALUE;
return fFSModule->rename_attr(&fVolume, oldNode, oldName, newNode, return oldNode->ops->rename_attr(&fVolume, oldNode, oldName, newNode,
newName); newName);
} }
// RemoveAttr // RemoveAttr
status_t status_t
HaikuKernelVolume::RemoveAttr(void* node, const char* name) HaikuKernelVolume::RemoveAttr(void* _node, const char* name)
{ {
if (!fFSModule->remove_attr) HaikuKernelNode* node = (HaikuKernelNode*)_node;
if (!node->ops->remove_attr)
return B_BAD_VALUE; return B_BAD_VALUE;
return fFSModule->remove_attr(&fVolume, node, name); return node->ops->remove_attr(&fVolume, node, name);
} }
src/add-ons/kernel/file_systems/userlandfs/server/UserlandFSServer.cpp
+2 -2
View File
@@ -111,7 +111,7 @@ UserlandFSServer::Init(const char* fileSystem)
error = fRequestThreads[i].Init(fFileSystem); error = fRequestThreads[i].Init(fFileSystem);
if (error != B_OK) if (error != B_OK)
RETURN_ERROR(error); RETURN_ERROR(error);
} }
// run the threads // run the threads
for (int32 i = 0; i < kRequestThreadCount; i++) for (int32 i = 0; i < kRequestThreadCount; i++)
@@ -185,7 +185,7 @@ UserlandFSServer::_RegisterWithDispatcher(const char* fsName)
// init an FS info // init an FS info
FSInfo info; FSInfo info;
status_t error = info.SetTo(fsName, infos, kRequestThreadCount + 1, status_t error = info.SetTo(fsName, infos, kRequestThreadCount + 1,
capabilities); capabilities, fFileSystem->GetClientFSType());
// prepare the message // prepare the message
BMessage message(UFS_REGISTER_FS); BMessage message(UFS_REGISTER_FS);
src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.cpp
+26 -22
View File
@@ -254,7 +254,7 @@ UserlandRequestHandler::_HandleRequest(MountVolumeRequest* request)
reply->error = result; reply->error = result;
reply->volume = volume; reply->volume = volume;
reply->rootID = rootID; reply->rootID = rootID;
reply->capabilities = volume->GetCapabilities(); volume->GetCapabilities(reply->capabilities);
// send the reply // send the reply
return _SendReply(allocator, false); return _SendReply(allocator, false);
@@ -393,7 +393,6 @@ UserlandRequestHandler::_HandleRequest(LookupRequest* request)
RETURN_ERROR(error); RETURN_ERROR(error);
reply->vnid = vnid; reply->vnid = vnid;
reply->type = type;
reply->error = result; reply->error = result;
// send the reply // send the reply
@@ -449,10 +448,13 @@ UserlandRequestHandler::_HandleRequest(ReadVNodeRequest* request)
if (!volume) if (!volume)
result = B_BAD_VALUE; result = B_BAD_VALUE;
fs_vnode node; void* node;
int type;
uint32 flags;
if (result == B_OK) { if (result == B_OK) {
RequestThreadContext context(volume); RequestThreadContext context(volume);
result = volume->ReadVNode(request->vnid, request->reenter, &node); result = volume->ReadVNode(request->vnid, request->reenter, &node,
&type, &flags);
} }
// prepare the reply // prepare the reply
@@ -464,6 +466,8 @@ UserlandRequestHandler::_HandleRequest(ReadVNodeRequest* request)
reply->error = result; reply->error = result;
reply->node = node; reply->node = node;
reply->type = type;
reply->flags = flags;
// send the reply // send the reply
return _SendReply(allocator, false); return _SendReply(allocator, false);
@@ -627,7 +631,7 @@ UserlandRequestHandler::_HandleRequest(SelectRequest* request)
if (result == B_OK) { if (result == B_OK) {
RequestThreadContext context(volume); RequestThreadContext context(volume);
result = volume->Select(request->node, request->fileCookie, result = volume->Select(request->node, request->fileCookie,
request->event, 0, request->sync); request->event, request->sync);
} }
// prepare the reply // prepare the reply
@@ -960,7 +964,7 @@ UserlandRequestHandler::_HandleRequest(CreateRequest* request)
result = B_BAD_VALUE; result = B_BAD_VALUE;
ino_t vnid; ino_t vnid;
fs_cookie fileCookie; void* fileCookie;
if (result == B_OK) { if (result == B_OK) {
RequestThreadContext context(volume); RequestThreadContext context(volume);
result = volume->Create(request->node, result = volume->Create(request->node,
@@ -993,7 +997,7 @@ UserlandRequestHandler::_HandleRequest(OpenRequest* request)
if (!volume) if (!volume)
result = B_BAD_VALUE; result = B_BAD_VALUE;
fs_cookie fileCookie; void* fileCookie;
if (result == B_OK) { if (result == B_OK) {
RequestThreadContext context(volume); RequestThreadContext context(volume);
result = volume->Open(request->node, request->openMode, &fileCookie); result = volume->Open(request->node, request->openMode, &fileCookie);
@@ -1079,8 +1083,8 @@ UserlandRequestHandler::_HandleRequest(ReadRequest* request)
if (!volume) if (!volume)
result = B_BAD_VALUE; result = B_BAD_VALUE;
fs_vnode node = request->node; void* node = request->node;
fs_cookie fileCookie = request->fileCookie; void* fileCookie = request->fileCookie;
off_t pos = request->pos; off_t pos = request->pos;
size_t size = request->size; size_t size = request->size;
@@ -1219,7 +1223,7 @@ UserlandRequestHandler::_HandleRequest(OpenDirRequest* request)
if (!volume) if (!volume)
result = B_BAD_VALUE; result = B_BAD_VALUE;
fs_cookie dirCookie = NULL; void* dirCookie = NULL;
if (result == B_OK) { if (result == B_OK) {
RequestThreadContext context(volume); RequestThreadContext context(volume);
result = volume->OpenDir(request->node, &dirCookie); result = volume->OpenDir(request->node, &dirCookie);
@@ -1305,8 +1309,8 @@ UserlandRequestHandler::_HandleRequest(ReadDirRequest* request)
if (!volume) if (!volume)
result = B_BAD_VALUE; result = B_BAD_VALUE;
fs_vnode node = request->node; void* node = request->node;
fs_vnode dirCookie = request->dirCookie; void* dirCookie = request->dirCookie;
size_t bufferSize = request->bufferSize; size_t bufferSize = request->bufferSize;
uint32 count = request->count; uint32 count = request->count;
@@ -1392,7 +1396,7 @@ UserlandRequestHandler::_HandleRequest(OpenAttrDirRequest* request)
if (!volume) if (!volume)
result = B_BAD_VALUE; result = B_BAD_VALUE;
fs_cookie attrDirCookie; void* attrDirCookie;
if (result == B_OK) { if (result == B_OK) {
RequestThreadContext context(volume); RequestThreadContext context(volume);
result = volume->OpenAttrDir(request->node, &attrDirCookie); result = volume->OpenAttrDir(request->node, &attrDirCookie);
@@ -1479,8 +1483,8 @@ UserlandRequestHandler::_HandleRequest(ReadAttrDirRequest* request)
if (!volume) if (!volume)
result = B_BAD_VALUE; result = B_BAD_VALUE;
fs_vnode node = request->node; void* node = request->node;
fs_cookie attrDirCookie = request->attrDirCookie; void* attrDirCookie = request->attrDirCookie;
size_t bufferSize = request->bufferSize; size_t bufferSize = request->bufferSize;
uint32 count = request->count; uint32 count = request->count;
@@ -1556,7 +1560,7 @@ UserlandRequestHandler::_HandleRequest(CreateAttrRequest* request)
if (!volume) if (!volume)
result = B_BAD_VALUE; result = B_BAD_VALUE;
fs_cookie attrCookie; void* attrCookie;
if (result == B_OK) { if (result == B_OK) {
RequestThreadContext context(volume); RequestThreadContext context(volume);
result = volume->CreateAttr(request->node, result = volume->CreateAttr(request->node,
@@ -1588,7 +1592,7 @@ UserlandRequestHandler::_HandleRequest(OpenAttrRequest* request)
if (!volume) if (!volume)
result = B_BAD_VALUE; result = B_BAD_VALUE;
fs_cookie attrCookie; void* attrCookie;
if (result == B_OK) { if (result == B_OK) {
RequestThreadContext context(volume); RequestThreadContext context(volume);
result = volume->OpenAttr(request->node, result = volume->OpenAttr(request->node,
@@ -1677,7 +1681,7 @@ UserlandRequestHandler::_HandleRequest(ReadAttrRequest* request)
result = B_BAD_VALUE; result = B_BAD_VALUE;
void* node = request->node; void* node = request->node;
fs_cookie attrCookie = request->attrCookie; void* attrCookie = request->attrCookie;
off_t pos = request->pos; off_t pos = request->pos;
size_t size = request->size; size_t size = request->size;
@@ -1876,7 +1880,7 @@ UserlandRequestHandler::_HandleRequest(OpenIndexDirRequest* request)
if (!volume) if (!volume)
result = B_BAD_VALUE; result = B_BAD_VALUE;
fs_cookie indexDirCookie; void* indexDirCookie;
if (result == B_OK) { if (result == B_OK) {
RequestThreadContext context(volume); RequestThreadContext context(volume);
result = volume->OpenIndexDir(&indexDirCookie); result = volume->OpenIndexDir(&indexDirCookie);
@@ -1962,7 +1966,7 @@ UserlandRequestHandler::_HandleRequest(ReadIndexDirRequest* request)
if (!volume) if (!volume)
result = B_BAD_VALUE; result = B_BAD_VALUE;
fs_cookie indexDirCookie = request->indexDirCookie; void* indexDirCookie = request->indexDirCookie;
size_t bufferSize = request->bufferSize; size_t bufferSize = request->bufferSize;
uint32 count = request->count; uint32 count = request->count;
@@ -2126,7 +2130,7 @@ UserlandRequestHandler::_HandleRequest(OpenQueryRequest* request)
if (!volume) if (!volume)
result = B_BAD_VALUE; result = B_BAD_VALUE;
fs_cookie queryCookie; void* queryCookie;
if (result == B_OK) { if (result == B_OK) {
RequestThreadContext context(volume); RequestThreadContext context(volume);
result = volume->OpenQuery((const char*)request->queryString.GetData(), result = volume->OpenQuery((const char*)request->queryString.GetData(),
@@ -2213,7 +2217,7 @@ UserlandRequestHandler::_HandleRequest(ReadQueryRequest* request)
if (!volume) if (!volume)
result = B_BAD_VALUE; result = B_BAD_VALUE;
fs_cookie queryCookie = request->queryCookie; void* queryCookie = request->queryCookie;
size_t bufferSize = request->bufferSize; size_t bufferSize = request->bufferSize;
uint32 count = request->count; uint32 count = request->count;