#ifndef USERLAND_FS_HAIKU_KERNEL_VOLUME_H
#define USERLAND_FS_HAIKU_KERNEL_VOLUME_H
#include <fs_interface.h>
#include "../Volume.h"
namespace UserlandFS {
class HaikuKernelFileSystem;
class HaikuKernelNode;
class HaikuKernelVolume : public Volume {
public:
HaikuKernelVolume(FileSystem* fileSystem,
dev_t id,
file_system_module_info* fsModule);
virtual ~HaikuKernelVolume();
static HaikuKernelVolume* GetVolume(const fs_volume* volume);
inline fs_volume* GetFSVolume() { return &fVolume; }
status_t Init();
status_t NewVNode(ino_t vnodeID, void* privateNode,
fs_vnode_ops* ops, HaikuKernelNode** node);
status_t PublishVNode(ino_t vnodeID, void* privateNode,
fs_vnode_ops* ops, int type, uint32 flags,
HaikuKernelNode** node);
void UndoNewVNode(HaikuKernelNode* node);
void UndoPublishVNode(HaikuKernelNode* node);
HaikuKernelNode* NodeWithID(ino_t vnodeID) const;
virtual status_t Mount(const char* device, uint32 flags,
const char* parameters, ino_t* rootID);
virtual status_t Unmount();
virtual status_t Sync();
virtual status_t ReadFSInfo(fs_info* info);
virtual status_t WriteFSInfo(const struct fs_info* info,
uint32 mask);
virtual status_t GetFileMap(void* node, off_t offset,
size_t size, struct file_io_vec* vecs,
size_t* count);
virtual status_t Lookup(void* dir, const char* entryName,
ino_t* vnid);
virtual status_t GetVNodeName(void* node, char* buffer,
size_t bufferSize);
virtual status_t ReadVNode(ino_t vnid, bool reenter,
void** node, int* type, uint32* flags,
FSVNodeCapabilities* _capabilities);
virtual status_t WriteVNode(void* node, bool reenter);
virtual status_t RemoveVNode(void* node, bool reenter);
virtual status_t DoIO(void* node, void* cookie,
const IORequestInfo& requestInfo);
virtual status_t CancelIO(void* node, void* cookie,
int32 ioRequestID);
virtual status_t IterativeIOGetVecs(void* cookie,
int32 requestID, off_t offset, size_t size,
struct file_io_vec* vecs, size_t* _count);
virtual status_t IterativeIOFinished(void* cookie,
int32 requestID, status_t status,
bool partialTransfer,
size_t bytesTransferred);
virtual status_t IOCtl(void* node, void* cookie,
uint32 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, selectsync* sync);
virtual status_t Deselect(void* node, void* cookie,
uint8 event, selectsync* sync);
virtual status_t FSync(void* node);
virtual status_t ReadSymlink(void* node, char* buffer,
size_t bufferSize, size_t* bytesRead);
virtual status_t CreateSymlink(void* dir, const char* name,
const char* target, int mode);
virtual status_t Link(void* dir, const char* name,
void* node);
virtual status_t Unlink(void* dir, const char* name);
virtual status_t Rename(void* oldDir, const char* oldName,
void* newDir, const char* newName);
virtual status_t Access(void* node, int mode);
virtual status_t ReadStat(void* node, struct stat* st);
virtual status_t WriteStat(void* node, const struct stat *st,
uint32 mask);
virtual status_t Create(void* dir, const char* name,
int openMode, int mode, void** cookie,
ino_t* vnid);
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,
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 CreateDir(void* dir, const char* name,
int mode);
virtual status_t RemoveDir(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,
void* buffer, size_t bufferSize,
uint32 count, uint32* countRead);
virtual status_t RewindDir(void* node, void* cookie);
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,
uint32 count, uint32* countRead);
virtual status_t RewindAttrDir(void* node, void* cookie);
virtual status_t CreateAttr(void* node, const char *name,
uint32 type, int openMode,
void** cookie);
virtual status_t OpenAttr(void* node, const char *name,
int openMode, void** cookie);
virtual status_t CloseAttr(void* node, void* cookie);
virtual status_t FreeAttrCookie(void* node, void* cookie);
virtual status_t ReadAttr(void* node, void* cookie,
off_t pos, void* buffer, size_t bufferSize,
size_t* bytesRead);
virtual status_t WriteAttr(void* node, void* cookie,
off_t pos, const void* buffer,
size_t bufferSize, size_t* bytesWritten);
virtual status_t ReadAttrStat(void* node, void* cookie,
struct stat *st);
virtual status_t WriteAttrStat(void* node, void* cookie,
const struct stat* st, int statMask);
virtual status_t RenameAttr(void* oldNode,
const char* oldName, void* newNode,
const char* newName);
virtual status_t RemoveAttr(void* node, const char* name);
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, uint32 count,
uint32* countRead);
virtual status_t RewindIndexDir(void* cookie);
virtual status_t CreateIndex(const char* name, uint32 type,
uint32 flags);
virtual status_t RemoveIndex(const char* name);
virtual status_t ReadIndexStat(const char *name,
struct stat *st);
virtual status_t OpenQuery(const char* queryString,
uint32 flags, port_id port, uint32 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, uint32 count,
uint32* countRead);
virtual status_t RewindQuery(void* cookie);
private:
struct FSVolume : fs_volume {
HaikuKernelVolume* haikuVolume;
};
class NodeMap;
private:
void _InitCapabilities();
inline HaikuKernelFileSystem* _FileSystem() const;
private:
file_system_module_info* fFSModule;
FSVolume fVolume;
NodeMap* fNodes;
};
inline HaikuKernelVolume*
HaikuKernelVolume::GetVolume(const fs_volume* volume)
{
return static_cast<const FSVolume*>(volume)->haikuVolume;
}
}
using UserlandFS::HaikuKernelVolume;
#endif
