1/*
2 * Copyright 2007-2009, Ingo Weinhold, ingo_weinhold@gmx.de.
3 * Distributed under the terms of the MIT License.
4 */
5#ifndef USERLAND_FS_HAIKU_KERNEL_VOLUME_H
6#define USERLAND_FS_HAIKU_KERNEL_VOLUME_H
7
8#include <fs_interface.h>
9
10#include "../Volume.h"
11
12namespace UserlandFS {
13
14class HaikuKernelFileSystem;
15class HaikuKernelNode;
16
17
18class HaikuKernelVolume : public Volume {
19public:
20								HaikuKernelVolume(FileSystem* fileSystem,
21									dev_t id,
22									file_system_module_info* fsModule);
23	virtual						~HaikuKernelVolume();
24
25	static	HaikuKernelVolume*	GetVolume(const fs_volume* volume);
26
27	inline	fs_volume*			GetFSVolume()	{ return &fVolume; }
28
29			status_t			Init();
30
31			status_t			NewVNode(ino_t vnodeID, void* privateNode,
32									fs_vnode_ops* ops, HaikuKernelNode** node);
33			status_t			PublishVNode(ino_t vnodeID, void* privateNode,
34									fs_vnode_ops* ops, int type, uint32 flags,
35									HaikuKernelNode** node);
36			void				UndoNewVNode(HaikuKernelNode* node);
37			void				UndoPublishVNode(HaikuKernelNode* node);
38
39			HaikuKernelNode*	NodeWithID(ino_t vnodeID) const;
40
41	// FS
42	virtual	status_t			Mount(const char* device, uint32 flags,
43									const char* parameters, ino_t* rootID);
44	virtual	status_t			Unmount();
45	virtual	status_t			Sync();
46	virtual	status_t			ReadFSInfo(fs_info* info);
47	virtual	status_t			WriteFSInfo(const struct fs_info* info,
48									uint32 mask);
49
50	// file cache
51	virtual	status_t			GetFileMap(void* node, off_t offset,
52									size_t size, struct file_io_vec* vecs,
53									size_t* count);
54
55	// vnodes
56	virtual	status_t			Lookup(void* dir, const char* entryName,
57									ino_t* vnid);
58	virtual	status_t			GetVNodeName(void* node, char* buffer,
59									size_t bufferSize);
60	virtual	status_t			ReadVNode(ino_t vnid, bool reenter,
61									void** node, int* type, uint32* flags,
62									FSVNodeCapabilities* _capabilities);
63	virtual	status_t			WriteVNode(void* node, bool reenter);
64	virtual	status_t			RemoveVNode(void* node, bool reenter);
65
66	// asynchronous I/O
67	virtual	status_t			DoIO(void* node, void* cookie,
68									const IORequestInfo& requestInfo);
69	virtual	status_t			CancelIO(void* node, void* cookie,
70									int32 ioRequestID);
71	virtual	status_t			IterativeIOGetVecs(void* cookie,
72									int32 requestID, off_t offset, size_t size,
73									struct file_io_vec* vecs, size_t* _count);
74	virtual	status_t			IterativeIOFinished(void* cookie,
75									int32 requestID, status_t status,
76									bool partialTransfer,
77									size_t bytesTransferred);
78
79	// nodes
80	virtual	status_t			IOCtl(void* node, void* cookie,
81									uint32 command, void* buffer, size_t size);
82	virtual	status_t			SetFlags(void* node, void* cookie,
83									int flags);
84	virtual	status_t			Select(void* node, void* cookie,
85									uint8 event, selectsync* sync);
86	virtual	status_t			Deselect(void* node, void* cookie,
87									uint8 event, selectsync* sync);
88
89	virtual	status_t			FSync(void* node);
90
91	virtual	status_t			ReadSymlink(void* node, char* buffer,
92									size_t bufferSize, size_t* bytesRead);
93	virtual	status_t			CreateSymlink(void* dir, const char* name,
94									const char* target, int mode);
95
96	virtual	status_t			Link(void* dir, const char* name,
97									void* node);
98	virtual	status_t			Unlink(void* dir, const char* name);
99	virtual	status_t			Rename(void* oldDir, const char* oldName,
100									void* newDir, const char* newName);
101
102	virtual	status_t			Access(void* node, int mode);
103	virtual	status_t			ReadStat(void* node, struct stat* st);
104	virtual	status_t			WriteStat(void* node, const struct stat *st,
105									uint32 mask);
106
107	// files
108	virtual	status_t			Create(void* dir, const char* name,
109									int openMode, int mode, void** cookie,
110									ino_t* vnid);
111	virtual	status_t			Open(void* node, int openMode,
112									void** cookie);
113	virtual	status_t			Close(void* node, void* cookie);
114	virtual	status_t			FreeCookie(void* node, void* cookie);
115	virtual	status_t			Read(void* node, void* cookie, off_t pos,
116									void* buffer, size_t bufferSize,
117									size_t* bytesRead);
118	virtual	status_t			Write(void* node, void* cookie,
119									off_t pos, const void* buffer,
120									size_t bufferSize, size_t* bytesWritten);
121
122	// directories
123	virtual	status_t			CreateDir(void* dir, const char* name,
124									int mode);
125	virtual	status_t			RemoveDir(void* dir, const char* name);
126	virtual	status_t			OpenDir(void* node, void** cookie);
127	virtual	status_t			CloseDir(void* node, void* cookie);
128	virtual	status_t			FreeDirCookie(void* node, void* cookie);
129	virtual	status_t			ReadDir(void* node, void* cookie,
130									void* buffer, size_t bufferSize,
131									uint32 count, uint32* countRead);
132	virtual	status_t			RewindDir(void* node, void* cookie);
133
134	// attribute directories
135	virtual	status_t			OpenAttrDir(void* node, void** cookie);
136	virtual	status_t			CloseAttrDir(void* node, void* cookie);
137	virtual	status_t			FreeAttrDirCookie(void* node,
138									void* cookie);
139	virtual	status_t			ReadAttrDir(void* node, void* cookie,
140									void* buffer, size_t bufferSize,
141									uint32 count, uint32* countRead);
142	virtual	status_t			RewindAttrDir(void* node, void* cookie);
143
144	// attributes
145	virtual	status_t			CreateAttr(void* node, const char *name,
146									uint32 type, int openMode,
147									void** cookie);
148	virtual	status_t			OpenAttr(void* node, const char *name,
149									int openMode, void** cookie);
150	virtual	status_t			CloseAttr(void* node, void* cookie);
151	virtual	status_t			FreeAttrCookie(void* node, void* cookie);
152	virtual	status_t			ReadAttr(void* node, void* cookie,
153									off_t pos, void* buffer, size_t bufferSize,
154									size_t* bytesRead);
155	virtual	status_t			WriteAttr(void* node, void* cookie,
156									off_t pos, const void* buffer,
157									size_t bufferSize, size_t* bytesWritten);
158	virtual	status_t			ReadAttrStat(void* node, void* cookie,
159									struct stat *st);
160	virtual	status_t			WriteAttrStat(void* node, void* cookie,
161									const struct stat* st, int statMask);
162	virtual	status_t			RenameAttr(void* oldNode,
163									const char* oldName, void* newNode,
164									const char* newName);
165	virtual	status_t			RemoveAttr(void* node, const char* name);
166
167	// indices
168	virtual	status_t			OpenIndexDir(void** cookie);
169	virtual	status_t			CloseIndexDir(void* cookie);
170	virtual	status_t			FreeIndexDirCookie(void* cookie);
171	virtual	status_t			ReadIndexDir(void* cookie, void* buffer,
172									size_t bufferSize, uint32 count,
173									uint32* countRead);
174	virtual	status_t			RewindIndexDir(void* cookie);
175	virtual	status_t			CreateIndex(const char* name, uint32 type,
176									uint32 flags);
177	virtual	status_t			RemoveIndex(const char* name);
178	virtual	status_t			ReadIndexStat(const char *name,
179									struct stat *st);
180
181	// queries
182	virtual	status_t			OpenQuery(const char* queryString,
183									uint32 flags, port_id port, uint32 token,
184									void** cookie);
185	virtual	status_t			CloseQuery(void* cookie);
186	virtual	status_t			FreeQueryCookie(void* cookie);
187	virtual	status_t			ReadQuery(void* cookie, void* buffer,
188									size_t bufferSize, uint32 count,
189									uint32* countRead);
190	virtual	status_t			RewindQuery(void* cookie);
191
192private:
193	struct FSVolume : fs_volume {
194		HaikuKernelVolume*	haikuVolume;
195	};
196
197	class NodeMap;
198
199private:
200			void				_InitCapabilities();
201	inline	HaikuKernelFileSystem* _FileSystem() const;
202
203private:
204			file_system_module_info* fFSModule;
205			FSVolume			fVolume;
206			NodeMap*			fNodes;
207};
208
209
210/*static*/ inline HaikuKernelVolume*
211HaikuKernelVolume::GetVolume(const fs_volume* volume)
212{
213	return static_cast<const FSVolume*>(volume)->haikuVolume;
214}
215
216
217}	// namespace UserlandFS
218
219using UserlandFS::HaikuKernelVolume;
220
221#endif	// USERLAND_FS_HAIKU_KERNEL_VOLUME_H
222