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

Adjusted the FileSystem, Volume, and UserlandRequestHandler to the new FS

Browse Source 
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
This commit is contained in:
Ingo Weinhold
2007-02-27 23:27:27 +00:00
parent 583ed1c698
commit 8474904ee0
10 changed files with 1096 additions and 827 deletions
Download Patch File Download Diff File Expand all files Collapse all files
headers/private/userlandfs/private/Requests.h
+1 -2
View File
@@ -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;
};
src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelFileSystem.cpp
+3 -4
View File
@@ -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)
src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelFileSystem.h
+1 -1
View File
@@ -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:
src/add-ons/kernel/file_systems/userlandfs/server/FileSystem.h
+2 -3
View File
@@ -3,7 +3,7 @@
#ifndef USERLAND_FS_FILE_SYSTEM_H
#define USERLAND_FS_FILE_SYSTEM_H
#include <fsproto.h>
#include <fs_interface.h>
#include <SupportDefs.h>
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;
};
src/add-ons/kernel/file_systems/userlandfs/server/Jamfile
+4 -4
View File
@@ -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
;
src/add-ons/kernel/file_systems/userlandfs/server/UserlandFSServer.cpp
+1 -1
View File
@@ -8,7 +8,7 @@
#include <cache.h>
#include <Clipboard.h>
#include <FindDirectory.h>
#include <fsproto.h>
#include <fs_interface.h>
#include <image.h>
#include <Locker.h>
#include <Path.h>
src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.cpp
+716 -505
View File
File diff suppressed because it is too large Load Diff
src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.h
+79 -28
View File
@@ -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);
src/add-ons/kernel/file_systems/userlandfs/server/Volume.cpp
+189 -186
View File
@@ -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;
}
src/add-ons/kernel/file_systems/userlandfs/server/Volume.h
+100 -93
View File
@@ -3,7 +3,7 @@
#ifndef USERLAND_FS_VOLUME_H
#define USERLAND_FS_VOLUME_H
#include <fsproto.h>
#include <fs_interface.h>
#include <SupportDefs.h>
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