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

First walk through the userlandfs kernel add-on to port it to the Haiku

Browse Source 
FS interface. Adjusted old hooks, but didn't add the new ones yet. The
module builds now at least.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@20235 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Ingo Weinhold
2007-02-26 02:54:05 +00:00
parent b881d6401c
commit b12d25d15d
12 changed files with 2481 additions and 2350 deletions
Download Patch File Download Diff File Expand all files Collapse all files
headers/private/userlandfs/private/Requests.h
+545 -538
View File
File diff suppressed because it is too large Load Diff
src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/FileSystem.cpp
+10 -6
View File
@@ -81,26 +81,29 @@ FileSystem::GetPortPool()
// Mount // Mount
status_t status_t
FileSystem::Mount(nspace_id id, const char* device, ulong flags, FileSystem::Mount(mount_id id, const char* device, uint32 flags,
const char* parameters, int32 len, Volume** _volume) const char* parameters, Volume** _volume)
{ {
// check initialization and parameters // check initialization and parameters
if (InitCheck() != B_OK) if (InitCheck() != B_OK)
return InitCheck(); return InitCheck();
if (!_volume) if (!_volume)
return B_BAD_VALUE; return B_BAD_VALUE;
// create volume // create volume
Volume* volume = new(nothrow) Volume(this, id); Volume* volume = new(nothrow) Volume(this, id);
if (!volume) if (!volume)
return B_NO_MEMORY; return B_NO_MEMORY;
// add volume to the volume list // add volume to the volume list
fVolumeLock.Lock(); fVolumeLock.Lock();
status_t error = fVolumes.PushBack(volume); status_t error = fVolumes.PushBack(volume);
fVolumeLock.Unlock(); fVolumeLock.Unlock();
if (error != B_OK) if (error != B_OK)
return error; return error;
// mount volume // mount volume
error = volume->Mount(device, flags, parameters, len); error = volume->Mount(device, flags, parameters);
if (error != B_OK) { if (error != B_OK) {
fVolumeLock.Lock(); fVolumeLock.Lock();
fVolumes.Remove(volume); fVolumes.Remove(volume);
@@ -108,12 +111,13 @@ FileSystem::Mount(nspace_id id, const char* device, ulong flags,
volume->RemoveReference(); volume->RemoveReference();
return error; return error;
} }
*_volume = volume; *_volume = volume;
return error; return error;
} }
// Initialize // Initialize
status_t /*status_t
FileSystem::Initialize(const char* deviceName, const char* parameters, FileSystem::Initialize(const char* deviceName, const char* parameters,
size_t len) size_t len)
{ {
@@ -144,7 +148,7 @@ FileSystem::Initialize(const char* deviceName, const char* parameters,
if (reply->error != B_OK) if (reply->error != B_OK)
return reply->error; return reply->error;
return error; return error;
} }*/
// VolumeUnmounted // VolumeUnmounted
void void
@@ -157,7 +161,7 @@ FileSystem::VolumeUnmounted(Volume* volume)
// GetVolume // GetVolume
Volume* Volume*
FileSystem::GetVolume(nspace_id id) FileSystem::GetVolume(mount_id id)
{ {
AutoLocker<Locker> _(fVolumeLock); AutoLocker<Locker> _(fVolumeLock);
for (Vector<Volume*>::Iterator it = fVolumes.Begin(); for (Vector<Volume*>::Iterator it = fVolumes.Begin();
src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/FileSystem.h
+6 -6
View File
@@ -3,7 +3,7 @@
#ifndef USERLAND_FS_FILE_SYSTEM_H #ifndef USERLAND_FS_FILE_SYSTEM_H
#define USERLAND_FS_FILE_SYSTEM_H #define USERLAND_FS_FILE_SYSTEM_H
#include <fsproto.h> #include <fs_interface.h>
#include "LazyInitializable.h" #include "LazyInitializable.h"
#include "Locker.h" #include "Locker.h"
@@ -35,14 +35,14 @@ public:
RequestPortPool* GetPortPool(); RequestPortPool* GetPortPool();
status_t Mount(nspace_id id, const char* device, status_t Mount(mount_id id, const char* device,
ulong flags, const char* parameters, ulong flags, const char* parameters,
int32 len, Volume** volume); Volume** volume);
status_t Initialize(const char* deviceName, // status_t Initialize(const char* deviceName,
const char* parameters, size_t len); // const char* parameters, size_t len);
void VolumeUnmounted(Volume* volume); void VolumeUnmounted(Volume* volume);
Volume* GetVolume(nspace_id id); Volume* GetVolume(mount_id id);
const IOCtlInfo* GetIOCtlInfo(int command) const; const IOCtlInfo* GetIOCtlInfo(int command) const;
src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/KernelRequestHandler.cpp
+4 -2
View File
@@ -8,6 +8,8 @@
#include "Requests.h" #include "Requests.h"
#include "Volume.h" #include "Volume.h"
#include <NodeMonitor.h>
// VolumePutter // VolumePutter
class VolumePutter { class VolumePutter {
public: public:
@@ -140,7 +142,7 @@ KernelRequestHandler::_HandleRequest(NotifySelectEventRequest* request)
status_t result = B_OK; status_t result = B_OK;
if (fFileSystem->KnowsSelectSyncEntry(request->sync)) { if (fFileSystem->KnowsSelectSyncEntry(request->sync)) {
PRINT(("notify_select_event(%p, %lu)\n", request->sync, request->ref)); PRINT(("notify_select_event(%p, %lu)\n", request->sync, request->ref));
notify_select_event(request->sync, request->ref); notify_select_event(request->sync, request->ref, request->event);
} else } else
result = B_BAD_VALUE; result = B_BAD_VALUE;
// prepare the reply // prepare the reply
@@ -338,7 +340,7 @@ KernelRequestHandler::_HandleRequest(IsVNodeRemovedRequest* request)
// _GetVolume // _GetVolume
status_t status_t
KernelRequestHandler::_GetVolume(nspace_id id, Volume** volume) KernelRequestHandler::_GetVolume(mount_id id, Volume** volume)
{ {
if (fVolume) { if (fVolume) {
if (fVolume->GetID() != id) { if (fVolume->GetID() != id) {
src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/KernelRequestHandler.h
+2 -2
View File
@@ -3,7 +3,7 @@
#ifndef USERLAND_FS_KERNEL_REQUEST_HANDLER_H #ifndef USERLAND_FS_KERNEL_REQUEST_HANDLER_H
#define USERLAND_FS_KERNEL_REQUEST_HANDLER_H #define USERLAND_FS_KERNEL_REQUEST_HANDLER_H
#include <fsproto.h> #include <fs_interface.h>
#include "RequestHandler.h" #include "RequestHandler.h"
@@ -59,7 +59,7 @@ private:
status_t _HandleRequest(UnremoveVNodeRequest* request); status_t _HandleRequest(UnremoveVNodeRequest* request);
status_t _HandleRequest(IsVNodeRemovedRequest* request); status_t _HandleRequest(IsVNodeRemovedRequest* request);
status_t _GetVolume(nspace_id id, Volume** volume); status_t _GetVolume(mount_id id, Volume** volume);
private: private:
FileSystem* fFileSystem; FileSystem* fFileSystem;
src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Settings.cpp
+2
View File
@@ -202,6 +202,7 @@ Settings::GetIOCtlInfo(int command) const
void void
Settings::Dump() const Settings::Dump() const
{ {
D(
PRINT(("Settings:\n")); PRINT(("Settings:\n"));
if (fIOCtlInfos) { if (fIOCtlInfos) {
for (IOCtlInfoMap::Iterator it = fIOCtlInfos->GetIterator(); for (IOCtlInfoMap::Iterator it = fIOCtlInfos->GetIterator();
@@ -212,6 +213,7 @@ Settings::Dump() const
info->command, info->bufferSize, info->writeBufferSize)); info->command, info->bufferSize, info->writeBufferSize));
} }
} }
)
} }
// _Init // _Init
src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/UserlandFS.cpp
+36 -85
View File
@@ -14,18 +14,14 @@
typedef AutoLocker<UserlandFS::FileSystemMap> FileSystemLocker; typedef AutoLocker<UserlandFS::FileSystemMap> FileSystemLocker;
UserlandFS* volatile UserlandFS::sUserlandFS = NULL; UserlandFS* UserlandFS::sUserlandFS = NULL;
spinlock UserlandFS::sUserlandFSLock = 0;
vint32 UserlandFS::sMountedFileSystems = 0;
// constructor // constructor
UserlandFS::UserlandFS() UserlandFS::UserlandFS()
: LazyInitializable(), : fPort(NULL),
fPort(NULL),
fFileSystems(NULL), fFileSystems(NULL),
fDebuggerCommandsAdded(false) fDebuggerCommandsAdded(false)
{ {
// beware what you do here: the caller holds a spin lock
} }
// destructor // destructor
@@ -50,88 +46,34 @@ PRINT(("UserlandFS::~UserlandFS()\n"))
KernelDebug::RemoveDebuggerCommands(); KernelDebug::RemoveDebuggerCommands();
} }
// RegisterUserlandFS // InitUserlandFS
status_t status_t
UserlandFS::RegisterUserlandFS(UserlandFS** _userlandFS) UserlandFS::InitUserlandFS(UserlandFS** _userlandFS)
{ {
// first check, if there's already an instance // create the singleton instance
bool create = false; sUserlandFS = new(nothrow) UserlandFS;
if (!sUserlandFS)
return B_NO_MEMORY;
cpu_status cpuStatus = disable_interrupts(); // init the thing
acquire_spinlock(&sUserlandFSLock); status_t error = sUserlandFS->_Init();
if (error != B_OK) {
if (sUserlandFS) delete sUserlandFS;
sMountedFileSystems++;
else
create = true;
release_spinlock(&sUserlandFSLock);
restore_interrupts(cpuStatus);
// if there's not, create a new
status_t error = B_OK;
if (create) {
// first create an instance
// Note, that we can't even construct a LazyInitializable with a
// spinlock being held, since it allocates a semaphore, which may
// allocate memory, which will acquire a semaphore.
UserlandFS* userlandFS = new(nothrow) UserlandFS;
if (userlandFS) {
// now set the instance unless someone else beat us to it
bool deleteInstance = false;
cpu_status cpuStatus = disable_interrupts();
acquire_spinlock(&sUserlandFSLock);
sMountedFileSystems++;
if (sUserlandFS)
deleteInstance = true;
else
sUserlandFS = userlandFS;
release_spinlock(&sUserlandFSLock);
restore_interrupts(cpuStatus);
// delete the new instance, if there was one already
if (deleteInstance)
delete userlandFS;
} else
error = B_NO_MEMORY;
}
if (error != B_OK)
return error;
// init the thing, if necessary
error = sUserlandFS->Access();
if (error == B_OK)
*_userlandFS = sUserlandFS;
else
UnregisterUserlandFS();
return error;
}
// UnregisterUserlandFS
void
UserlandFS::UnregisterUserlandFS()
{
cpu_status cpuStatus = disable_interrupts();
acquire_spinlock(&sUserlandFSLock);
--sMountedFileSystems;
UserlandFS* userlandFS = NULL;
if (sMountedFileSystems == 0 && sUserlandFS) {
userlandFS = sUserlandFS;
sUserlandFS = NULL; sUserlandFS = NULL;
return error;
} }
release_spinlock(&sUserlandFSLock); *_userlandFS = sUserlandFS;
restore_interrupts(cpuStatus);
// delete, if the last FS has been unmounted return B_OK;
if (userlandFS) {
userlandFS->~UserlandFS();
delete[] (uint8*)userlandFS;
} }
// UninitUserlandFS
void
UserlandFS::UninitUserlandFS()
{
delete sUserlandFS;
sUserlandFS = NULL;
} }
// GetUserlandFS // GetUserlandFS
@@ -145,11 +87,10 @@ UserlandFS::GetUserlandFS()
status_t status_t
UserlandFS::RegisterFileSystem(const char* name, FileSystem** _fileSystem) UserlandFS::RegisterFileSystem(const char* name, FileSystem** _fileSystem)
{ {
// check initialization and parameters // check parameters
if (InitCheck() != B_OK)
return InitCheck();
if (!name || !_fileSystem) if (!name || !_fileSystem)
return B_BAD_VALUE; return B_BAD_VALUE;
// check, if we do already know this file system, and create it, if not // check, if we do already know this file system, and create it, if not
FileSystem* fileSystem; FileSystem* fileSystem;
{ {
@@ -170,12 +111,14 @@ UserlandFS::RegisterFileSystem(const char* name, FileSystem** _fileSystem)
} }
} }
} }
// prepare the file system // prepare the file system
status_t error = fileSystem->Access(); status_t error = fileSystem->Access();
if (error != B_OK) { if (error != B_OK) {
UnregisterFileSystem(fileSystem); UnregisterFileSystem(fileSystem);
return error; return error;
} }
*_fileSystem = fileSystem; *_fileSystem = fileSystem;
return error; return error;
} }
@@ -186,6 +129,7 @@ UserlandFS::UnregisterFileSystem(FileSystem* fileSystem)
{ {
if (!fileSystem) if (!fileSystem)
return B_BAD_VALUE; return B_BAD_VALUE;
// find the FS and decrement its reference counter // find the FS and decrement its reference counter
bool deleteFS = false; bool deleteFS = false;
{ {
@@ -197,6 +141,7 @@ UserlandFS::UnregisterFileSystem(FileSystem* fileSystem)
if (deleteFS) if (deleteFS)
fFileSystems->Remove(fileSystem->GetName()); fFileSystems->Remove(fileSystem->GetName());
} }
// delete the FS, if the last reference has been removed // delete the FS, if the last reference has been removed
if (deleteFS) if (deleteFS)
delete fileSystem; delete fileSystem;
@@ -210,13 +155,14 @@ UserlandFS::CountFileSystems() const
return fFileSystems->Size(); return fFileSystems->Size();
} }
// FirstTimeInit // _Init
status_t status_t
UserlandFS::FirstTimeInit() UserlandFS::_Init()
{ {
// add debugger commands // add debugger commands
KernelDebug::AddDebuggerCommands(); KernelDebug::AddDebuggerCommands();
fDebuggerCommandsAdded = true; fDebuggerCommandsAdded = true;
// create file system map // create file system map
fFileSystems = new(nothrow) FileSystemMap; fFileSystems = new(nothrow) FileSystemMap;
if (!fFileSystems) if (!fFileSystems)
@@ -224,6 +170,7 @@ UserlandFS::FirstTimeInit()
status_t error = fFileSystems->InitCheck(); status_t error = fFileSystems->InitCheck();
if (error != B_OK) if (error != B_OK)
RETURN_ERROR(error); RETURN_ERROR(error);
// find the dispatcher ports // find the dispatcher ports
port_id port = find_port(kUserlandFSDispatcherPortName); port_id port = find_port(kUserlandFSDispatcherPortName);
if (port < 0) if (port < 0)
@@ -231,11 +178,13 @@ UserlandFS::FirstTimeInit()
port_id replyPort = find_port(kUserlandFSDispatcherReplyPortName); port_id replyPort = find_port(kUserlandFSDispatcherReplyPortName);
if (replyPort < 0) if (replyPort < 0)
RETURN_ERROR(B_ERROR); RETURN_ERROR(B_ERROR);
// create a reply port // create a reply port
// send a connection request // send a connection request
error = write_port(port, UFS_DISPATCHER_CONNECT, NULL, 0); error = write_port(port, UFS_DISPATCHER_CONNECT, NULL, 0);
if (error != B_OK) if (error != B_OK)
RETURN_ERROR(error); RETURN_ERROR(error);
// receive the reply // receive the reply
int32 replyCode; int32 replyCode;
Port::Info portInfo; Port::Info portInfo;
@@ -247,12 +196,14 @@ UserlandFS::FirstTimeInit()
RETURN_ERROR(B_BAD_DATA); RETURN_ERROR(B_BAD_DATA);
if (bytesRead != sizeof(Port::Info)) if (bytesRead != sizeof(Port::Info))
RETURN_ERROR(B_BAD_DATA); RETURN_ERROR(B_BAD_DATA);
// create a request port // create a request port
fPort = new(nothrow) RequestPort(&portInfo); fPort = new(nothrow) RequestPort(&portInfo);
if (!fPort) if (!fPort)
RETURN_ERROR(B_NO_MEMORY); RETURN_ERROR(B_NO_MEMORY);
if ((error = fPort->InitCheck()) != B_OK) if ((error = fPort->InitCheck()) != B_OK)
RETURN_ERROR(error); RETURN_ERROR(error);
RETURN_ERROR(error); RETURN_ERROR(error);
} }
src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/UserlandFS.h
+6 -9
View File
@@ -6,7 +6,6 @@
#include <SupportDefs.h> #include <SupportDefs.h>
#include "HashMap.h" #include "HashMap.h"
#include "LazyInitializable.h"
#include "String.h" #include "String.h"
namespace UserlandFSUtil { namespace UserlandFSUtil {
@@ -19,14 +18,14 @@ using UserlandFSUtil::RequestPort;
class FileSystem; class FileSystem;
class UserlandFS : public LazyInitializable { class UserlandFS {
private: private:
UserlandFS(); UserlandFS();
~UserlandFS(); ~UserlandFS();
public: public:
static status_t RegisterUserlandFS(UserlandFS** userlandFS); static status_t InitUserlandFS(UserlandFS** userlandFS);
static void UnregisterUserlandFS(); static void UninitUserlandFS();
static UserlandFS* GetUserlandFS(); static UserlandFS* GetUserlandFS();
status_t RegisterFileSystem(const char* name, status_t RegisterFileSystem(const char* name,
@@ -35,16 +34,14 @@ public:
int32 CountFileSystems() const; int32 CountFileSystems() const;
protected: private:
virtual status_t FirstTimeInit(); status_t _Init();
private: private:
friend class KernelDebug; friend class KernelDebug;
typedef SynchronizedHashMap<String, FileSystem*> FileSystemMap; typedef SynchronizedHashMap<String, FileSystem*> FileSystemMap;
static UserlandFS* volatile sUserlandFS; static UserlandFS* sUserlandFS;
static spinlock sUserlandFSLock;
static vint32 sMountedFileSystems;
RequestPort* fPort; RequestPort* fPort;
FileSystemMap* fFileSystems; FileSystemMap* fFileSystems;
src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.cpp
+848 -634
View File
File diff suppressed because it is too large Load Diff
src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Volume.h
+119 -106
View File
@@ -3,7 +3,7 @@
#ifndef USERLAND_FS_VOLUME_H #ifndef USERLAND_FS_VOLUME_H
#define USERLAND_FS_VOLUME_H #define USERLAND_FS_VOLUME_H
#include <fsproto.h> #include <fs_interface.h>
#include "Referencable.h" #include "Referencable.h"
@@ -24,11 +24,11 @@ struct userlandfs_ioctl;
class Volume : public Referencable { class Volume : public Referencable {
public: public:
Volume(FileSystem* fileSystem, nspace_id id); Volume(FileSystem* fileSystem, mount_id id);
~Volume(); ~Volume();
FileSystem* GetFileSystem() const; FileSystem* GetFileSystem() const;
nspace_id GetID() const; mount_id GetID() const;
void* GetUserlandVolume() const; void* GetUserlandVolume() const;
vnode_id GetRootID() const; vnode_id GetRootID() const;
@@ -43,133 +43,143 @@ public:
status_t IsVNodeRemoved(vnode_id vnid); status_t IsVNodeRemoved(vnode_id vnid);
// FS // FS
status_t Mount(const char* device, ulong flags, status_t Mount(const char* device, uint32 flags,
const char* parameters, int32 len); const char* parameters);
status_t Unmount(); status_t Unmount();
status_t Sync(); status_t Sync();
status_t ReadFSStat(fs_info* info); status_t ReadFSInfo(fs_info* info);
status_t WriteFSStat(struct fs_info* info, long mask); status_t WriteFSInfo(const struct fs_info* info,
uint32 mask);
// vnodes // vnodes
status_t ReadVNode(vnode_id vnid, char reenter, status_t Lookup(fs_vnode dir, const char* entryName,
void** node); vnode_id* vnid, int* type);
status_t WriteVNode(void* node, char reenter); status_t ReadVNode(vnode_id vnid, bool reenter,
status_t RemoveVNode(void* node, char reenter); fs_vnode* node);
status_t WriteVNode(fs_vnode node, bool reenter);
status_t RemoveVNode(fs_vnode node, bool reenter);
// nodes // nodes
status_t FSync(void* node); status_t IOCtl(fs_vnode node, fs_cookie cookie,
status_t ReadStat(void* node, struct stat* st); uint32 command, void *buffer, size_t size);
status_t WriteStat(void* node, struct stat *st, status_t SetFlags(fs_vnode node, fs_cookie cookie,
long mask); int flags);
status_t Access(void* node, int mode); status_t Select(fs_vnode node, fs_cookie cookie,
uint8 event, uint32 ref, selectsync* sync);
status_t Deselect(fs_vnode node, fs_cookie cookie,
uint8 event, selectsync* sync);
status_t FSync(fs_vnode node);
status_t ReadSymlink(fs_vnode node, char* buffer,
size_t bufferSize, size_t* bytesRead);
status_t CreateSymlink(fs_vnode dir, const char* name,
const char* target, int mode);
status_t Link(fs_vnode dir, const char* name,
fs_vnode node);
status_t Unlink(fs_vnode dir, const char* name);
status_t Rename(fs_vnode oldDir, const char* oldName,
fs_vnode newDir, const char* newName);
status_t Access(fs_vnode node, int mode);
status_t ReadStat(fs_vnode node, struct stat* st);
status_t WriteStat(fs_vnode node, const struct stat *st,
uint32 mask);
// files // files
status_t Create(void* dir, const char* name, status_t Create(fs_vnode dir, const char* name,
int openMode, int mode, vnode_id* vnid, int openMode, int mode, fs_cookie* cookie,
void** cookie); vnode_id* vnid);
status_t Open(void* node, int openMode, void** cookie); status_t Open(fs_vnode node, int openMode,
status_t Close(void* node, void* cookie); fs_cookie* cookie);
status_t FreeCookie(void* node, void* cookie); status_t Close(fs_vnode node, fs_cookie cookie);
status_t Read(void* node, void* cookie, off_t pos, status_t FreeCookie(fs_vnode node, fs_cookie cookie);
status_t Read(fs_vnode node, fs_cookie cookie, off_t pos,
void* buffer, size_t bufferSize, void* buffer, size_t bufferSize,
size_t* bytesRead); size_t* bytesRead);
status_t Write(void* node, void* cookie, off_t pos, status_t Write(fs_vnode node, fs_cookie cookie,
const void* buffer, size_t bufferSize, off_t pos, const void* buffer,
size_t* bytesWritten); size_t bufferSize, size_t* bytesWritten);
status_t IOCtl(void* node, void* cookie, int command,
void *buffer, size_t size);
status_t SetFlags(void* node, void* cookie, int flags);
status_t Select(void* node, void* cookie, uint8 event,
uint32 ref, selectsync* sync);
status_t Deselect(void* node, void* cookie, uint8 event,
selectsync* sync);
// hard links / symlinks
status_t Link(void* dir, const char* name, void* node);
status_t Unlink(void* dir, const char* name);
status_t Symlink(void* dir, const char* name,
const char* target);
status_t ReadLink(void* node, char* buffer,
size_t bufferSize, size_t* bytesRead);
status_t Rename(void* oldDir, const char* oldName,
void* newDir, const char* newName);
// directories // directories
status_t MkDir(void* dir, const char* name, int mode); status_t CreateDir(fs_vnode dir, const char* name,
status_t RmDir(void* dir, const char* name); int mode, vnode_id *newDir);
status_t OpenDir(void* node, void** cookie); status_t RemoveDir(fs_vnode dir, const char* name);
status_t CloseDir(void* node, void* cookie); status_t OpenDir(fs_vnode node, fs_cookie* cookie);
status_t FreeDirCookie(void* node, void* cookie); status_t CloseDir(fs_vnode node, fs_vnode cookie);
status_t ReadDir(void* node, void* cookie, status_t FreeDirCookie(fs_vnode node, fs_vnode cookie);
status_t ReadDir(fs_vnode node, fs_vnode cookie,
void* buffer, size_t bufferSize, void* buffer, size_t bufferSize,
int32 count, int32* countRead); uint32 count, uint32* countRead);
status_t RewindDir(void* node, void* cookie); status_t RewindDir(fs_vnode node, fs_vnode cookie);
status_t Walk(void* dir, const char* entryName,
char** resolvedPath, vnode_id* vnid); // attribute directories
status_t OpenAttrDir(fs_vnode node, fs_cookie *cookie);
status_t CloseAttrDir(fs_vnode node, fs_cookie cookie);
status_t FreeAttrDirCookie(fs_vnode node,
fs_cookie cookie);
status_t ReadAttrDir(fs_vnode node, fs_cookie cookie,
void* buffer, size_t bufferSize,
uint32 count, uint32* countRead);
status_t RewindAttrDir(fs_vnode node, fs_cookie cookie);
// attributes // attributes
status_t OpenAttrDir(void* node, void** cookie); status_t ReadAttr(fs_vnode node, fs_cookie cookie,
status_t CloseAttrDir(void* node, void* cookie); off_t pos, void* buffer, size_t bufferSize,
status_t FreeAttrDirCookie(void* node, void* cookie); size_t* bytesRead);
status_t ReadAttrDir(void* node, void* cookie, status_t WriteAttr(fs_vnode node, fs_cookie cookie,
void* buffer, size_t bufferSize, off_t pos, const void* buffer,
int32 count, int32* countRead);
status_t RewindAttrDir(void* node, void* cookie);
status_t ReadAttr(void* node, const char* name,
int type, off_t pos, void* buffer,
size_t bufferSize, size_t* bytesRead);
status_t WriteAttr(void* node, const char* name,
int type, off_t pos, const void* buffer,
size_t bufferSize, size_t* bytesWritten); size_t bufferSize, size_t* bytesWritten);
status_t RemoveAttr(void* node, const char* name); status_t ReadAttrStat(fs_vnode node, fs_cookie cookie,
status_t RenameAttr(void* node, const char* oldName, struct stat *st);
status_t RenameAttr(fs_vnode oldNode,
const char* oldName, fs_vnode newNode,
const char* newName); const char* newName);
status_t StatAttr(void* node, const char* name, status_t RemoveAttr(fs_vnode node, const char* name);
struct attr_info* attrInfo);
// indices // indices
status_t OpenIndexDir(void** cookie); status_t OpenIndexDir(fs_cookie *cookie);
status_t CloseIndexDir(void* cookie); status_t CloseIndexDir(fs_cookie cookie);
status_t FreeIndexDirCookie(void* cookie); status_t FreeIndexDirCookie(fs_cookie cookie);
status_t ReadIndexDir(void* cookie, void* buffer, status_t ReadIndexDir(fs_cookie cookie, void* buffer,
size_t bufferSize, int32 count, size_t bufferSize, uint32 count,
int32* countRead); uint32* countRead);
status_t RewindIndexDir(void* cookie); status_t RewindIndexDir(fs_cookie cookie);
status_t CreateIndex(const char* name, int type, status_t CreateIndex(const char* name, uint32 type,
int flags); uint32 flags);
status_t RemoveIndex(const char* name); status_t RemoveIndex(const char* name);
status_t RenameIndex(const char* oldName, status_t ReadIndexStat(const char *name,
const char* newName); struct stat *st);
status_t StatIndex(const char *name,
struct index_info* indexInfo);
// queries // queries
status_t OpenQuery(const char* queryString, status_t OpenQuery(const char* queryString,
ulong flags, port_id port, long token, uint32 flags, port_id port, uint32 token,
void** cookie); fs_cookie *cookie);
status_t CloseQuery(void* cookie); status_t CloseQuery(fs_cookie cookie);
status_t FreeQueryCookie(void* cookie); status_t FreeQueryCookie(fs_cookie cookie);
status_t ReadQuery(void* cookie, void* buffer, status_t ReadQuery(fs_cookie cookie, void* buffer,
size_t bufferSize, int32 count, size_t bufferSize, uint32 count,
int32* countRead); uint32* countRead);
private: private:
status_t _Mount(const char* device, ulong flags, status_t _Mount(const char* device, uint32 flags,
const char* parameters, int32 len); const char* parameters);
status_t _Unmount(); status_t _Unmount();
status_t _WriteVNode(void* node, char reenter); status_t _Lookup(fs_vnode dir, const char* entryName,
status_t _Close(void* node, void* cookie); vnode_id* vnid, int* type);
status_t _FreeCookie(void* node, void* cookie); status_t _WriteVNode(fs_vnode node, bool reenter);
status_t _CloseDir(void* node, void* cookie); status_t _Close(fs_vnode node, fs_cookie cookie);
status_t _FreeDirCookie(void* node, void* cookie); status_t _FreeCookie(fs_vnode node, fs_cookie cookie);
status_t _Walk(void* dir, const char* entryName, status_t _CloseDir(fs_vnode node, fs_vnode cookie);
char** resolvedPath, vnode_id* vnid); status_t _FreeDirCookie(fs_vnode node, fs_vnode cookie);
status_t _CloseAttrDir(void* node, void* cookie); status_t _CloseAttrDir(fs_vnode node, fs_cookie cookie);
status_t _FreeAttrDirCookie(void* node, void* cookie); status_t _FreeAttrDirCookie(fs_vnode node,
status_t _CloseIndexDir(void* cookie); fs_cookie cookie);
status_t _FreeIndexDirCookie(void* cookie); status_t _CloseIndexDir(fs_cookie cookie);
status_t _CloseQuery(void* cookie); status_t _FreeIndexDirCookie(fs_cookie cookie);
status_t _FreeQueryCookie(void* cookie); status_t _CloseQuery(fs_cookie cookie);
status_t _FreeQueryCookie(fs_cookie cookie);
status_t _SendRequest(RequestPort* port, status_t _SendRequest(RequestPort* port,
RequestAllocator* allocator, RequestAllocator* allocator,
@@ -190,10 +200,10 @@ private:
class AutoIncrementer; class AutoIncrementer;
FileSystem* fFileSystem; FileSystem* fFileSystem;
nspace_id fID; mount_id fID;
void* fUserlandVolume; void* fUserlandVolume;
vnode_id fRootID; vnode_id fRootID;
void* fRootNode; fs_vnode fRootNode;
MountVNodeMap* fMountVNodes; MountVNodeMap* fMountVNodes;
vint32 fOpenFiles; vint32 fOpenFiles;
vint32 fOpenDirectories; vint32 fOpenDirectories;
@@ -201,6 +211,9 @@ private:
vint32 fOpenIndexDirectories; vint32 fOpenIndexDirectories;
vint32 fOpenQueries; vint32 fOpenQueries;
VNodeCountMap* fVNodeCountMap; VNodeCountMap* fVNodeCountMap;
// Tracks the number of new/get_vnode()
// calls to be balanced by the FS by
// corresponding put_vnode()s.
volatile bool fVNodeCountingEnabled; volatile bool fVNodeCountingEnabled;
}; };
src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/kernel_interface.cpp
+784 -805
View File
File diff suppressed because it is too large Load Diff
src/add-ons/kernel/file_systems/userlandfs/private/Requests.cpp
+110 -148
View File
@@ -44,14 +44,14 @@ MountVolumeRequest::GetAddressInfos(AddressInfo* infos, int32* count)
return B_OK; return B_OK;
} }
// InitializeVolumeRequest //// InitializeVolumeRequest
status_t //status_t
InitializeVolumeRequest::GetAddressInfos(AddressInfo* infos, int32* count) //InitializeVolumeRequest::GetAddressInfos(AddressInfo* infos, int32* count)
{ //{
ADD_STRING(device); // ADD_STRING(device);
ADD_STRING(parameters); // ADD_STRING(parameters);
return B_OK; // return B_OK;
} //}
// CreateRequest // CreateRequest
status_t status_t
@@ -109,18 +109,18 @@ UnlinkRequest::GetAddressInfos(AddressInfo* infos, int32* count)
return B_OK; return B_OK;
} }
// SymlinkRequest // CreateSymlinkRequest
status_t status_t
SymlinkRequest::GetAddressInfos(AddressInfo* infos, int32* count) CreateSymlinkRequest::GetAddressInfos(AddressInfo* infos, int32* count)
{ {
ADD_NON_NULL_STRING(name); ADD_NON_NULL_STRING(name);
ADD_NON_NULL_STRING(target); ADD_NON_NULL_STRING(target);
return B_OK; return B_OK;
} }
// ReadLinkReply // ReadSymlinkReply
status_t status_t
ReadLinkReply::GetAddressInfos(AddressInfo* infos, int32* count) ReadSymlinkReply::GetAddressInfos(AddressInfo* infos, int32* count)
{ {
ADD_STRING(buffer); ADD_STRING(buffer);
return B_OK; return B_OK;
@@ -135,17 +135,17 @@ RenameRequest::GetAddressInfos(AddressInfo* infos, int32* count)
return B_OK; return B_OK;
} }
// MkDirRequest // CreateDirRequest
status_t status_t
MkDirRequest::GetAddressInfos(AddressInfo* infos, int32* count) CreateDirRequest::GetAddressInfos(AddressInfo* infos, int32* count)
{ {
ADD_NON_NULL_STRING(name); ADD_NON_NULL_STRING(name);
return B_OK; return B_OK;
} }
// RmDirRequest // RemoveDirRequest
status_t status_t
RmDirRequest::GetAddressInfos(AddressInfo* infos, int32* count) RemoveDirRequest::GetAddressInfos(AddressInfo* infos, int32* count)
{ {
ADD_NON_NULL_STRING(name); ADD_NON_NULL_STRING(name);
return B_OK; return B_OK;
@@ -159,22 +159,14 @@ ReadDirReply::GetAddressInfos(AddressInfo* infos, int32* count)
return B_OK; return B_OK;
} }
// WalkRequest // LookupRequest
status_t status_t
WalkRequest::GetAddressInfos(AddressInfo* infos, int32* count) LookupRequest::GetAddressInfos(AddressInfo* infos, int32* count)
{ {
ADD_NON_NULL_STRING(entryName); ADD_NON_NULL_STRING(entryName);
return B_OK; return B_OK;
} }
// WalkReply
status_t
WalkReply::GetAddressInfos(AddressInfo* infos, int32* count)
{
ADD_STRING(resolvedPath);
return B_OK;
}
// ReadAttrDirReply // ReadAttrDirReply
status_t status_t
ReadAttrDirReply::GetAddressInfos(AddressInfo* infos, int32* count) ReadAttrDirReply::GetAddressInfos(AddressInfo* infos, int32* count)
@@ -183,14 +175,6 @@ ReadAttrDirReply::GetAddressInfos(AddressInfo* infos, int32* count)
return B_OK; return B_OK;
} }
// ReadAttrRequest
status_t
ReadAttrRequest::GetAddressInfos(AddressInfo* infos, int32* count)
{
ADD_NON_NULL_STRING(name);
return B_OK;
}
// ReadAttrReply // ReadAttrReply
status_t status_t
ReadAttrReply::GetAddressInfos(AddressInfo* infos, int32* count) ReadAttrReply::GetAddressInfos(AddressInfo* infos, int32* count)
@@ -203,7 +187,6 @@ ReadAttrReply::GetAddressInfos(AddressInfo* infos, int32* count)
status_t status_t
WriteAttrRequest::GetAddressInfos(AddressInfo* infos, int32* count) WriteAttrRequest::GetAddressInfos(AddressInfo* infos, int32* count)
{ {
ADD_NON_NULL_STRING(name);
ADD_ADDRESS(buffer); ADD_ADDRESS(buffer);
return B_OK; return B_OK;
} }
@@ -225,14 +208,6 @@ RenameAttrRequest::GetAddressInfos(AddressInfo* infos, int32* count)
return B_OK; return B_OK;
} }
// StatAttrRequest
status_t
StatAttrRequest::GetAddressInfos(AddressInfo* infos, int32* count)
{
ADD_NON_NULL_STRING(name);
return B_OK;
}
// ReadIndexDirReply // ReadIndexDirReply
status_t status_t
ReadIndexDirReply::GetAddressInfos(AddressInfo* infos, int32* count) ReadIndexDirReply::GetAddressInfos(AddressInfo* infos, int32* count)
@@ -257,18 +232,9 @@ RemoveIndexRequest::GetAddressInfos(AddressInfo* infos, int32* count)
return B_OK; return B_OK;
} }
// RenameIndexRequest // ReadIndexStatRequest
status_t status_t
RenameIndexRequest::GetAddressInfos(AddressInfo* infos, int32* count) ReadIndexStatRequest::GetAddressInfos(AddressInfo* infos, int32* count)
{
ADD_NON_NULL_STRING(oldName);
ADD_NON_NULL_STRING(newName);
return B_OK;
}
// StatIndexRequest
status_t
StatIndexRequest::GetAddressInfos(AddressInfo* infos, int32* count)
{ {
ADD_NON_NULL_STRING(name); ADD_NON_NULL_STRING(name);
return B_OK; return B_OK;
@@ -499,37 +465,57 @@ UserlandFSUtil::is_kernel_request(uint32 type)
// FS // FS
case MOUNT_VOLUME_REQUEST: case MOUNT_VOLUME_REQUEST:
case UNMOUNT_VOLUME_REQUEST: case UNMOUNT_VOLUME_REQUEST:
case INITIALIZE_VOLUME_REQUEST: // case INITIALIZE_VOLUME_REQUEST:
case SYNC_VOLUME_REQUEST: case SYNC_VOLUME_REQUEST:
case READ_FS_STAT_REQUEST: case READ_FS_INFO_REQUEST:
case WRITE_FS_STAT_REQUEST: case WRITE_FS_INFO_REQUEST:
return true; return true;
case MOUNT_VOLUME_REPLY: case MOUNT_VOLUME_REPLY:
case UNMOUNT_VOLUME_REPLY: case UNMOUNT_VOLUME_REPLY:
case INITIALIZE_VOLUME_REPLY: // case INITIALIZE_VOLUME_REPLY:
case SYNC_VOLUME_REPLY: case SYNC_VOLUME_REPLY:
case READ_FS_STAT_REPLY: case READ_FS_INFO_REPLY:
case WRITE_FS_STAT_REPLY: case WRITE_FS_INFO_REPLY:
return false; return false;
// vnodes // vnodes
case LOOKUP_REQUEST:
case READ_VNODE_REQUEST: case READ_VNODE_REQUEST:
case WRITE_VNODE_REQUEST: case WRITE_VNODE_REQUEST:
case FS_REMOVE_VNODE_REQUEST: case FS_REMOVE_VNODE_REQUEST:
return true; return true;
case LOOKUP_REPLY:
case READ_VNODE_REPLY: case READ_VNODE_REPLY:
case WRITE_VNODE_REPLY: case WRITE_VNODE_REPLY:
case FS_REMOVE_VNODE_REPLY: case FS_REMOVE_VNODE_REPLY:
return false; return false;
// nodes // nodes
case IOCTL_REQUEST:
case SET_FLAGS_REQUEST:
case SELECT_REQUEST:
case DESELECT_REQUEST:
case FSYNC_REQUEST: case FSYNC_REQUEST:
case READ_SYMLINK_REQUEST:
case CREATE_SYMLINK_REQUEST:
case LINK_REQUEST:
case UNLINK_REQUEST:
case RENAME_REQUEST:
case ACCESS_REQUEST:
case READ_STAT_REQUEST: case READ_STAT_REQUEST:
case WRITE_STAT_REQUEST: case WRITE_STAT_REQUEST:
case ACCESS_REQUEST:
return true; return true;
case IOCTL_REPLY:
case SET_FLAGS_REPLY:
case SELECT_REPLY:
case DESELECT_REPLY:
case FSYNC_REPLY: case FSYNC_REPLY:
case READ_SYMLINK_REPLY:
case CREATE_SYMLINK_REPLY:
case LINK_REPLY:
case UNLINK_REPLY:
case RENAME_REPLY:
case ACCESS_REPLY:
case READ_STAT_REPLY: case READ_STAT_REPLY:
case WRITE_STAT_REPLY: case WRITE_STAT_REPLY:
case ACCESS_REPLY:
return false; return false;
// files // files
case CREATE_REQUEST: case CREATE_REQUEST:
@@ -538,10 +524,6 @@ UserlandFSUtil::is_kernel_request(uint32 type)
case FREE_COOKIE_REQUEST: case FREE_COOKIE_REQUEST:
case READ_REQUEST: case READ_REQUEST:
case WRITE_REQUEST: case WRITE_REQUEST:
case IOCTL_REQUEST:
case SET_FLAGS_REQUEST:
case SELECT_REQUEST:
case DESELECT_REQUEST:
return true; return true;
case CREATE_REPLY: case CREATE_REPLY:
case OPEN_REPLY: case OPEN_REPLY:
@@ -549,65 +531,49 @@ UserlandFSUtil::is_kernel_request(uint32 type)
case FREE_COOKIE_REPLY: case FREE_COOKIE_REPLY:
case READ_REPLY: case READ_REPLY:
case WRITE_REPLY: case WRITE_REPLY:
case IOCTL_REPLY:
case SET_FLAGS_REPLY:
case SELECT_REPLY:
case DESELECT_REPLY:
return false;
// hard links / symlinks
case LINK_REQUEST:
case UNLINK_REQUEST:
case SYMLINK_REQUEST:
case READ_LINK_REQUEST:
case RENAME_REQUEST:
return true;
case LINK_REPLY:
case UNLINK_REPLY:
case SYMLINK_REPLY:
case READ_LINK_REPLY:
case RENAME_REPLY:
return false; return false;
// directories // directories
case MKDIR_REQUEST: case CREATE_DIR_REQUEST:
case RMDIR_REQUEST: case REMOVE_DIR_REQUEST:
case OPEN_DIR_REQUEST: case OPEN_DIR_REQUEST:
case CLOSE_DIR_REQUEST: case CLOSE_DIR_REQUEST:
case FREE_DIR_COOKIE_REQUEST: case FREE_DIR_COOKIE_REQUEST:
case READ_DIR_REQUEST: case READ_DIR_REQUEST:
case REWIND_DIR_REQUEST: case REWIND_DIR_REQUEST:
case WALK_REQUEST:
return true; return true;
case MKDIR_REPLY: case CREATE_DIR_REPLY:
case RMDIR_REPLY: case REMOVE_DIR_REPLY:
case OPEN_DIR_REPLY: case OPEN_DIR_REPLY:
case CLOSE_DIR_REPLY: case CLOSE_DIR_REPLY:
case FREE_DIR_COOKIE_REPLY: case FREE_DIR_COOKIE_REPLY:
case READ_DIR_REPLY: case READ_DIR_REPLY:
case REWIND_DIR_REPLY: case REWIND_DIR_REPLY:
case WALK_REPLY:
return false; return false;
// attributes // attribute directories
case OPEN_ATTR_DIR_REQUEST: case OPEN_ATTR_DIR_REQUEST:
case CLOSE_ATTR_DIR_REQUEST: case CLOSE_ATTR_DIR_REQUEST:
case FREE_ATTR_DIR_COOKIE_REQUEST: case FREE_ATTR_DIR_COOKIE_REQUEST:
case READ_ATTR_DIR_REQUEST: case READ_ATTR_DIR_REQUEST:
case REWIND_ATTR_DIR_REQUEST: case REWIND_ATTR_DIR_REQUEST:
case READ_ATTR_REQUEST:
case WRITE_ATTR_REQUEST:
case REMOVE_ATTR_REQUEST:
case RENAME_ATTR_REQUEST:
case STAT_ATTR_REQUEST:
return true; return true;
case OPEN_ATTR_DIR_REPLY: case OPEN_ATTR_DIR_REPLY:
case CLOSE_ATTR_DIR_REPLY: case CLOSE_ATTR_DIR_REPLY:
case FREE_ATTR_DIR_COOKIE_REPLY: case FREE_ATTR_DIR_COOKIE_REPLY:
case READ_ATTR_DIR_REPLY: case READ_ATTR_DIR_REPLY:
case REWIND_ATTR_DIR_REPLY: case REWIND_ATTR_DIR_REPLY:
return false;
// attributes
case READ_ATTR_REQUEST:
case WRITE_ATTR_REQUEST:
case READ_ATTR_STAT_REQUEST:
case RENAME_ATTR_REQUEST:
case REMOVE_ATTR_REQUEST:
return true;
case READ_ATTR_REPLY: case READ_ATTR_REPLY:
case WRITE_ATTR_REPLY: case WRITE_ATTR_REPLY:
case REMOVE_ATTR_REPLY: case READ_ATTR_STAT_REPLY:
case RENAME_ATTR_REPLY: case RENAME_ATTR_REPLY:
case STAT_ATTR_REPLY: case REMOVE_ATTR_REPLY:
return false; return false;
// indices // indices
case OPEN_INDEX_DIR_REQUEST: case OPEN_INDEX_DIR_REQUEST:
@@ -617,8 +583,7 @@ UserlandFSUtil::is_kernel_request(uint32 type)
case REWIND_INDEX_DIR_REQUEST: case REWIND_INDEX_DIR_REQUEST:
case CREATE_INDEX_REQUEST: case CREATE_INDEX_REQUEST:
case REMOVE_INDEX_REQUEST: case REMOVE_INDEX_REQUEST:
case RENAME_INDEX_REQUEST: case READ_INDEX_STAT_REQUEST:
case STAT_INDEX_REQUEST:
return true; return true;
case OPEN_INDEX_DIR_REPLY: case OPEN_INDEX_DIR_REPLY:
case CLOSE_INDEX_DIR_REPLY: case CLOSE_INDEX_DIR_REPLY:
@@ -627,8 +592,7 @@ UserlandFSUtil::is_kernel_request(uint32 type)
case REWIND_INDEX_DIR_REPLY: case REWIND_INDEX_DIR_REPLY:
case CREATE_INDEX_REPLY: case CREATE_INDEX_REPLY:
case REMOVE_INDEX_REPLY: case REMOVE_INDEX_REPLY:
case RENAME_INDEX_REPLY: case READ_INDEX_STAT_REPLY:
case STAT_INDEX_REPLY:
return false; return false;
// queries // queries
case OPEN_QUERY_REQUEST: case OPEN_QUERY_REQUEST:
@@ -691,37 +655,57 @@ UserlandFSUtil::is_userland_request(uint32 type)
// FS // FS
case MOUNT_VOLUME_REQUEST: case MOUNT_VOLUME_REQUEST:
case UNMOUNT_VOLUME_REQUEST: case UNMOUNT_VOLUME_REQUEST:
case INITIALIZE_VOLUME_REQUEST: // case INITIALIZE_VOLUME_REQUEST:
case SYNC_VOLUME_REQUEST: case SYNC_VOLUME_REQUEST:
case READ_FS_STAT_REQUEST: case READ_FS_INFO_REQUEST:
case WRITE_FS_STAT_REQUEST: case WRITE_FS_INFO_REQUEST:
return false; return false;
case MOUNT_VOLUME_REPLY: case MOUNT_VOLUME_REPLY:
case UNMOUNT_VOLUME_REPLY: case UNMOUNT_VOLUME_REPLY:
case INITIALIZE_VOLUME_REPLY: // case INITIALIZE_VOLUME_REPLY:
case SYNC_VOLUME_REPLY: case SYNC_VOLUME_REPLY:
case READ_FS_STAT_REPLY: case READ_FS_INFO_REPLY:
case WRITE_FS_STAT_REPLY: case WRITE_FS_INFO_REPLY:
return true; return true;
// vnodes // vnodes
case LOOKUP_REQUEST:
case READ_VNODE_REQUEST: case READ_VNODE_REQUEST:
case WRITE_VNODE_REQUEST: case WRITE_VNODE_REQUEST:
case FS_REMOVE_VNODE_REQUEST: case FS_REMOVE_VNODE_REQUEST:
return false; return false;
case LOOKUP_REPLY:
case READ_VNODE_REPLY: case READ_VNODE_REPLY:
case WRITE_VNODE_REPLY: case WRITE_VNODE_REPLY:
case FS_REMOVE_VNODE_REPLY: case FS_REMOVE_VNODE_REPLY:
return true; return true;
// nodes // nodes
case IOCTL_REQUEST:
case SET_FLAGS_REQUEST:
case SELECT_REQUEST:
case DESELECT_REQUEST:
case FSYNC_REQUEST: case FSYNC_REQUEST:
case READ_SYMLINK_REQUEST:
case CREATE_SYMLINK_REQUEST:
case LINK_REQUEST:
case UNLINK_REQUEST:
case RENAME_REQUEST:
case ACCESS_REQUEST:
case READ_STAT_REQUEST: case READ_STAT_REQUEST:
case WRITE_STAT_REQUEST: case WRITE_STAT_REQUEST:
case ACCESS_REQUEST:
return false; return false;
case IOCTL_REPLY:
case SET_FLAGS_REPLY:
case SELECT_REPLY:
case DESELECT_REPLY:
case FSYNC_REPLY: case FSYNC_REPLY:
case READ_SYMLINK_REPLY:
case CREATE_SYMLINK_REPLY:
case LINK_REPLY:
case UNLINK_REPLY:
case RENAME_REPLY:
case ACCESS_REPLY:
case READ_STAT_REPLY: case READ_STAT_REPLY:
case WRITE_STAT_REPLY: case WRITE_STAT_REPLY:
case ACCESS_REPLY:
return true; return true;
// files // files
case CREATE_REQUEST: case CREATE_REQUEST:
@@ -730,10 +714,6 @@ UserlandFSUtil::is_userland_request(uint32 type)
case FREE_COOKIE_REQUEST: case FREE_COOKIE_REQUEST:
case READ_REQUEST: case READ_REQUEST:
case WRITE_REQUEST: case WRITE_REQUEST:
case IOCTL_REQUEST:
case SET_FLAGS_REQUEST:
case SELECT_REQUEST:
case DESELECT_REQUEST:
return false; return false;
case CREATE_REPLY: case CREATE_REPLY:
case OPEN_REPLY: case OPEN_REPLY:
@@ -741,65 +721,49 @@ UserlandFSUtil::is_userland_request(uint32 type)
case FREE_COOKIE_REPLY: case FREE_COOKIE_REPLY:
case READ_REPLY: case READ_REPLY:
case WRITE_REPLY: case WRITE_REPLY:
case IOCTL_REPLY:
case SET_FLAGS_REPLY:
case SELECT_REPLY:
case DESELECT_REPLY:
return true;
// hard links / symlinks
case LINK_REQUEST:
case UNLINK_REQUEST:
case SYMLINK_REQUEST:
case READ_LINK_REQUEST:
case RENAME_REQUEST:
return false;
case LINK_REPLY:
case UNLINK_REPLY:
case SYMLINK_REPLY:
case READ_LINK_REPLY:
case RENAME_REPLY:
return true; return true;
// directories // directories
case MKDIR_REQUEST: case CREATE_DIR_REQUEST:
case RMDIR_REQUEST: case REMOVE_DIR_REQUEST:
case OPEN_DIR_REQUEST: case OPEN_DIR_REQUEST:
case CLOSE_DIR_REQUEST: case CLOSE_DIR_REQUEST:
case FREE_DIR_COOKIE_REQUEST: case FREE_DIR_COOKIE_REQUEST:
case READ_DIR_REQUEST: case READ_DIR_REQUEST:
case REWIND_DIR_REQUEST: case REWIND_DIR_REQUEST:
case WALK_REQUEST:
return false; return false;
case MKDIR_REPLY: case CREATE_DIR_REPLY:
case RMDIR_REPLY: case REMOVE_DIR_REPLY:
case OPEN_DIR_REPLY: case OPEN_DIR_REPLY:
case CLOSE_DIR_REPLY: case CLOSE_DIR_REPLY:
case FREE_DIR_COOKIE_REPLY: case FREE_DIR_COOKIE_REPLY:
case READ_DIR_REPLY: case READ_DIR_REPLY:
case REWIND_DIR_REPLY: case REWIND_DIR_REPLY:
case WALK_REPLY:
return true; return true;
// attributes // attribute directories
case OPEN_ATTR_DIR_REQUEST: case OPEN_ATTR_DIR_REQUEST:
case CLOSE_ATTR_DIR_REQUEST: case CLOSE_ATTR_DIR_REQUEST:
case FREE_ATTR_DIR_COOKIE_REQUEST: case FREE_ATTR_DIR_COOKIE_REQUEST:
case READ_ATTR_DIR_REQUEST: case READ_ATTR_DIR_REQUEST:
case REWIND_ATTR_DIR_REQUEST: case REWIND_ATTR_DIR_REQUEST:
case READ_ATTR_REQUEST:
case WRITE_ATTR_REQUEST:
case REMOVE_ATTR_REQUEST:
case RENAME_ATTR_REQUEST:
case STAT_ATTR_REQUEST:
return false; return false;
case OPEN_ATTR_DIR_REPLY: case OPEN_ATTR_DIR_REPLY:
case CLOSE_ATTR_DIR_REPLY: case CLOSE_ATTR_DIR_REPLY:
case FREE_ATTR_DIR_COOKIE_REPLY: case FREE_ATTR_DIR_COOKIE_REPLY:
case READ_ATTR_DIR_REPLY: case READ_ATTR_DIR_REPLY:
case REWIND_ATTR_DIR_REPLY: case REWIND_ATTR_DIR_REPLY:
return true;
// attributes
case READ_ATTR_REQUEST:
case WRITE_ATTR_REQUEST:
case RENAME_ATTR_REQUEST:
case READ_ATTR_STAT_REQUEST:
case REMOVE_ATTR_REQUEST:
return false;
case READ_ATTR_REPLY: case READ_ATTR_REPLY:
case WRITE_ATTR_REPLY: case WRITE_ATTR_REPLY:
case REMOVE_ATTR_REPLY: case READ_ATTR_STAT_REPLY:
case RENAME_ATTR_REPLY: case RENAME_ATTR_REPLY:
case STAT_ATTR_REPLY: case REMOVE_ATTR_REPLY:
return true; return true;
// indices // indices
case OPEN_INDEX_DIR_REQUEST: case OPEN_INDEX_DIR_REQUEST:
@@ -809,8 +773,7 @@ UserlandFSUtil::is_userland_request(uint32 type)
case REWIND_INDEX_DIR_REQUEST: case REWIND_INDEX_DIR_REQUEST:
case CREATE_INDEX_REQUEST: case CREATE_INDEX_REQUEST:
case REMOVE_INDEX_REQUEST: case REMOVE_INDEX_REQUEST:
case RENAME_INDEX_REQUEST: case READ_INDEX_STAT_REQUEST:
case STAT_INDEX_REQUEST:
return false; return false;
case OPEN_INDEX_DIR_REPLY: case OPEN_INDEX_DIR_REPLY:
case CLOSE_INDEX_DIR_REPLY: case CLOSE_INDEX_DIR_REPLY:
@@ -819,8 +782,7 @@ UserlandFSUtil::is_userland_request(uint32 type)
case REWIND_INDEX_DIR_REPLY: case REWIND_INDEX_DIR_REPLY:
case CREATE_INDEX_REPLY: case CREATE_INDEX_REPLY:
case REMOVE_INDEX_REPLY: case REMOVE_INDEX_REPLY:
case RENAME_INDEX_REPLY: case READ_INDEX_STAT_REPLY:
case STAT_INDEX_REPLY:
return true; return true;
// queries // queries
case OPEN_QUERY_REQUEST: case OPEN_QUERY_REQUEST: