1// KernelUserVolume.cpp
2
3#include "KernelUserVolume.h"
4
5// constructor
6KernelUserVolume::KernelUserVolume(UserFileSystem* fileSystem, nspace_id id,
7	vnode_ops* fsOps)
8	: UserVolume(fileSystem, id),
9	  fFSOps(fsOps),
10	  fVolumeCookie(NULL)
11{
12}
13
14// destructor
15KernelUserVolume::~KernelUserVolume()
16{
17}
18
19// #pragma mark -
20// #pragma mark ----- FS -----
21
22// Mount
23status_t
24KernelUserVolume::Mount(const char* device, ulong flags, const char* parameters,
25	int32 len, vnode_id* rootID)
26{
27	if (!fFSOps->mount)
28		return B_BAD_VALUE;
29	return fFSOps->mount(GetID(), device, flags, (void*)parameters, len,
30		&fVolumeCookie, rootID);
31}
32
33// Unmount
34status_t
35KernelUserVolume::Unmount()
36{
37	if (!fFSOps->unmount)
38		return B_BAD_VALUE;
39	return fFSOps->unmount(fVolumeCookie);
40}
41
42// Sync
43status_t
44KernelUserVolume::Sync()
45{
46	if (!fFSOps->sync)
47		return B_BAD_VALUE;
48	return fFSOps->sync(fVolumeCookie);
49}
50
51// ReadFSStat
52status_t
53KernelUserVolume::ReadFSStat(fs_info* info)
54{
55	if (!fFSOps->rfsstat)
56		return B_BAD_VALUE;
57	return fFSOps->rfsstat(fVolumeCookie, info);
58}
59
60// WriteFSStat
61status_t
62KernelUserVolume::WriteFSStat(struct fs_info *info, long mask)
63{
64	if (!fFSOps->wfsstat)
65		return B_BAD_VALUE;
66	return fFSOps->wfsstat(fVolumeCookie, info, mask);
67}
68
69// #pragma mark -
70// #pragma mark ----- vnodes -----
71
72// ReadVNode
73status_t
74KernelUserVolume::ReadVNode(vnode_id vnid, char reenter, void** node)
75{
76	if (!fFSOps->read_vnode)
77		return B_BAD_VALUE;
78	return fFSOps->read_vnode(fVolumeCookie, vnid, reenter, node);
79}
80
81// WriteVNode
82status_t
83KernelUserVolume::WriteVNode(void* node, char reenter)
84{
85	if (!fFSOps->write_vnode)
86		return B_BAD_VALUE;
87	return fFSOps->write_vnode(fVolumeCookie, node, reenter);
88}
89
90// RemoveVNode
91status_t
92KernelUserVolume::RemoveVNode(void* node, char reenter)
93{
94	if (!fFSOps->remove_vnode)
95		return B_BAD_VALUE;
96	return fFSOps->remove_vnode(fVolumeCookie, node, reenter);
97}
98
99// #pragma mark -
100// #pragma mark ----- nodes -----
101
102// FSync
103status_t
104KernelUserVolume::FSync(void* node)
105{
106	if (!fFSOps->fsync)
107		return B_BAD_VALUE;
108	return fFSOps->fsync(fVolumeCookie, node);
109}
110
111// ReadStat
112status_t
113KernelUserVolume::ReadStat(void* node, struct stat* st)
114{
115	if (!fFSOps->rstat)
116		return B_BAD_VALUE;
117	return fFSOps->rstat(fVolumeCookie, node, st);
118}
119
120// WriteStat
121status_t
122KernelUserVolume::WriteStat(void* node, struct stat* st, long mask)
123{
124	if (!fFSOps->wstat)
125		return B_BAD_VALUE;
126	return fFSOps->wstat(fVolumeCookie, node, st, mask);
127}
128
129// Access
130status_t
131KernelUserVolume::Access(void* node, int mode)
132{
133	if (!fFSOps->access)
134		return B_BAD_VALUE;
135	return fFSOps->access(fVolumeCookie, node, mode);
136}
137
138// #pragma mark -
139// #pragma mark ----- files -----
140
141// Create
142status_t
143KernelUserVolume::Create(void* dir, const char* name, int openMode, int mode,
144	vnode_id* vnid, void** cookie)
145{
146	if (!fFSOps->create)
147		return B_BAD_VALUE;
148	return fFSOps->create(fVolumeCookie, dir, name, openMode, mode, vnid,
149		cookie);
150}
151
152// Open
153status_t
154KernelUserVolume::Open(void* node, int openMode, void** cookie)
155{
156	if (!fFSOps->open)
157		return B_BAD_VALUE;
158	return fFSOps->open(fVolumeCookie, node, openMode, cookie);
159}
160
161// Close
162status_t
163KernelUserVolume::Close(void* node, void* cookie)
164{
165	if (!fFSOps->close)
166		return B_OK;
167	return fFSOps->close(fVolumeCookie, node, cookie);
168}
169
170// FreeCookie
171status_t
172KernelUserVolume::FreeCookie(void* node, void* cookie)
173{
174	if (!fFSOps->free_cookie)
175		return B_OK;
176	return fFSOps->free_cookie(fVolumeCookie, node, cookie);
177}
178
179// Read
180status_t
181KernelUserVolume::Read(void* node, void* cookie, off_t pos, void* buffer,
182	size_t bufferSize, size_t* bytesRead)
183{
184	if (!fFSOps->read)
185		return B_BAD_VALUE;
186	*bytesRead = bufferSize;
187	return fFSOps->read(fVolumeCookie, node, cookie, pos, buffer, bytesRead);
188}
189
190// Write
191status_t
192KernelUserVolume::Write(void* node, void* cookie, off_t pos, const void* buffer,
193	size_t bufferSize, size_t* bytesWritten)
194{
195	if (!fFSOps->write)
196		return B_BAD_VALUE;
197	*bytesWritten = bufferSize;
198	return fFSOps->write(fVolumeCookie, node, cookie, pos, buffer,
199		bytesWritten);
200}
201
202// IOCtl
203status_t
204KernelUserVolume::IOCtl(void* node, void* cookie, int command, void *buffer,
205	size_t size)
206{
207	if (!fFSOps->ioctl)
208		return B_BAD_VALUE;
209	return fFSOps->ioctl(fVolumeCookie, node, cookie, command, buffer, size);
210}
211
212// SetFlags
213status_t
214KernelUserVolume::SetFlags(void* node, void* cookie, int flags)
215{
216	if (!fFSOps->setflags)
217		return B_BAD_VALUE;
218	return fFSOps->setflags(fVolumeCookie, node, cookie, flags);
219}
220
221// Select
222status_t
223KernelUserVolume::Select(void* node, void* cookie, uint8 event, uint32 ref,
224	selectsync* sync)
225{
226	if (!fFSOps->select) {
227		notify_select_event(sync, ref);
228		return B_OK;
229	}
230	return fFSOps->select(fVolumeCookie, node, cookie, event, ref, sync);
231}
232
233// Deselect
234status_t
235KernelUserVolume::Deselect(void* node, void* cookie, uint8 event,
236	selectsync* sync)
237{
238	if (!fFSOps->select || !fFSOps->deselect)
239		return B_OK;
240	return fFSOps->deselect(fVolumeCookie, node, cookie, event, sync);
241}
242
243// #pragma mark -
244// #pragma mark ----- hard links / symlinks -----
245
246// Link
247status_t
248KernelUserVolume::Link(void* dir, const char* name, void* node)
249{
250	if (!fFSOps->link)
251		return B_BAD_VALUE;
252	return fFSOps->link(fVolumeCookie, dir, name, node);
253}
254
255// Unlink
256status_t
257KernelUserVolume::Unlink(void* dir, const char* name)
258{
259	if (!fFSOps->unlink)
260		return B_BAD_VALUE;
261	return fFSOps->unlink(fVolumeCookie, dir, name);
262}
263
264// Symlink
265status_t
266KernelUserVolume::Symlink(void* dir, const char* name, const char* target)
267{
268	if (!fFSOps->symlink)
269		return B_BAD_VALUE;
270	return fFSOps->symlink(fVolumeCookie, dir, name, target);
271}
272
273// ReadLink
274status_t
275KernelUserVolume::ReadLink(void* node, char* buffer, size_t bufferSize,
276	size_t* bytesRead)
277{
278	if (!fFSOps->readlink)
279		return B_BAD_VALUE;
280	*bytesRead = bufferSize;
281	return fFSOps->readlink(fVolumeCookie, node, buffer, bytesRead);
282}
283
284// Rename
285status_t
286KernelUserVolume::Rename(void* oldDir, const char* oldName, void* newDir,
287	const char* newName)
288{
289	if (!fFSOps->rename)
290		return B_BAD_VALUE;
291	return fFSOps->rename(fVolumeCookie, oldDir, oldName, newDir, newName);
292}
293
294// #pragma mark -
295// #pragma mark ----- directories -----
296
297// MkDir
298status_t
299KernelUserVolume::MkDir(void* dir, const char* name, int mode)
300{
301	if (!fFSOps->mkdir)
302		return B_BAD_VALUE;
303	return fFSOps->mkdir(fVolumeCookie, dir, name, mode);
304}
305
306// RmDir
307status_t
308KernelUserVolume::RmDir(void* dir, const char* name)
309{
310	if (!fFSOps->rmdir)
311		return B_BAD_VALUE;
312	return fFSOps->rmdir(fVolumeCookie, dir, name);
313}
314
315// OpenDir
316status_t
317KernelUserVolume::OpenDir(void* node, void** cookie)
318{
319	if (!fFSOps->opendir)
320		return B_BAD_VALUE;
321	return fFSOps->opendir(fVolumeCookie, node, cookie);
322}
323
324// CloseDir
325status_t
326KernelUserVolume::CloseDir(void* node, void* cookie)
327{
328	if (!fFSOps->closedir)
329		return B_OK;
330	return fFSOps->closedir(fVolumeCookie, node, cookie);
331}
332
333// FreeDirCookie
334status_t
335KernelUserVolume::FreeDirCookie(void* node, void* cookie)
336{
337	if (!fFSOps->free_dircookie)
338		return B_OK;
339	return fFSOps->free_dircookie(fVolumeCookie, node, cookie);
340}
341
342// ReadDir
343status_t
344KernelUserVolume::ReadDir(void* node, void* cookie, void* buffer,
345	size_t bufferSize, int32 count, int32* countRead)
346{
347	if (!fFSOps->readdir)
348		return B_BAD_VALUE;
349	*countRead = count;
350	return fFSOps->readdir(fVolumeCookie, node, cookie, countRead,
351		(dirent*)buffer, bufferSize);
352}
353
354// RewindDir
355status_t
356KernelUserVolume::RewindDir(void* node, void* cookie)
357{
358	if (!fFSOps->rewinddir)
359		return B_BAD_VALUE;
360	return fFSOps->rewinddir(fVolumeCookie, node, cookie);
361}
362
363// Walk
364status_t
365KernelUserVolume::Walk(void* dir, const char* entryName, char** resolvedPath,
366	vnode_id* vnid)
367{
368	if (!fFSOps->walk)
369		return B_BAD_VALUE;
370	return fFSOps->walk(fVolumeCookie, dir, entryName, resolvedPath, vnid);
371}
372
373// #pragma mark -
374// #pragma mark ----- attributes -----
375
376// OpenAttrDir
377status_t
378KernelUserVolume::OpenAttrDir(void* node, void** cookie)
379{
380	if (!fFSOps->open_attrdir)
381		return B_BAD_VALUE;
382	return fFSOps->open_attrdir(fVolumeCookie, node, cookie);
383}
384
385// CloseAttrDir
386status_t
387KernelUserVolume::CloseAttrDir(void* node, void* cookie)
388{
389	if (!fFSOps->close_attrdir)
390		return B_OK;
391	return fFSOps->close_attrdir(fVolumeCookie, node, cookie);
392}
393
394// FreeAttrDirCookie
395status_t
396KernelUserVolume::FreeAttrDirCookie(void* node, void* cookie)
397{
398	if (!fFSOps->free_attrdircookie)
399		return B_OK;
400	return fFSOps->free_attrdircookie(fVolumeCookie, node, cookie);
401}
402
403// ReadAttrDir
404status_t
405KernelUserVolume::ReadAttrDir(void* node, void* cookie, void* buffer,
406	size_t bufferSize, int32 count, int32* countRead)
407{
408	if (!fFSOps->read_attrdir)
409		return B_BAD_VALUE;
410	*countRead = count;
411	return fFSOps->read_attrdir(fVolumeCookie, node, cookie, countRead,
412		(struct dirent*)buffer, bufferSize);
413}
414
415// RewindAttrDir
416status_t
417KernelUserVolume::RewindAttrDir(void* node, void* cookie)
418{
419	if (!fFSOps->rewind_attrdir)
420		return B_BAD_VALUE;
421	return fFSOps->rewind_attrdir(fVolumeCookie, node, cookie);
422}
423
424// ReadAttr
425status_t
426KernelUserVolume::ReadAttr(void* node, const char* name, int type, off_t pos,
427	void* buffer, size_t bufferSize, size_t* bytesRead)
428{
429	if (!fFSOps->read_attr)
430		return B_BAD_VALUE;
431	*bytesRead = bufferSize;
432	return fFSOps->read_attr(fVolumeCookie, node, name, type, buffer, bytesRead,
433		pos);
434}
435
436// WriteAttr
437status_t
438KernelUserVolume::WriteAttr(void* node, const char* name, int type, off_t pos,
439	const void* buffer, size_t bufferSize, size_t* bytesWritten)
440{
441	if (!fFSOps->write_attr)
442		return B_BAD_VALUE;
443	*bytesWritten = bufferSize;
444	return fFSOps->write_attr(fVolumeCookie, node, name, type, buffer,
445		bytesWritten, pos);
446}
447
448// RemoveAttr
449status_t
450KernelUserVolume::RemoveAttr(void* node, const char* name)
451{
452	if (!fFSOps->remove_attr)
453		return B_BAD_VALUE;
454	return fFSOps->remove_attr(fVolumeCookie, node, name);
455}
456
457// RenameAttr
458status_t
459KernelUserVolume::RenameAttr(void* node, const char* oldName, const char* newName)
460{
461	if (!fFSOps->rename_attr)
462		return B_BAD_VALUE;
463	return fFSOps->rename_attr(fVolumeCookie, node, oldName, newName);
464}
465
466// StatAttr
467status_t
468KernelUserVolume::StatAttr(void* node, const char* name,
469	struct attr_info* attrInfo)
470{
471	if (!fFSOps->stat_attr)
472		return B_BAD_VALUE;
473	return fFSOps->stat_attr(fVolumeCookie, node, name, attrInfo);
474}
475
476// #pragma mark -
477// #pragma mark ----- indices -----
478
479// OpenIndexDir
480status_t
481KernelUserVolume::OpenIndexDir(void** cookie)
482{
483	if (!fFSOps->open_indexdir)
484		return B_BAD_VALUE;
485	return fFSOps->open_indexdir(fVolumeCookie, cookie);
486}
487
488// CloseIndexDir
489status_t
490KernelUserVolume::CloseIndexDir(void* cookie)
491{
492	if (!fFSOps->close_indexdir)
493		return B_OK;
494	return fFSOps->close_indexdir(fVolumeCookie, cookie);
495}
496
497// FreeIndexDirCookie
498status_t
499KernelUserVolume::FreeIndexDirCookie(void* cookie)
500{
501	if (!fFSOps->free_indexdircookie)
502		return B_OK;
503	return fFSOps->free_indexdircookie(fVolumeCookie, NULL, cookie);
504}
505
506// ReadIndexDir
507status_t
508KernelUserVolume::ReadIndexDir(void* cookie, void* buffer, size_t bufferSize,
509	int32 count, int32* countRead)
510{
511	if (!fFSOps->read_indexdir)
512		return B_BAD_VALUE;
513	*countRead = count;
514	return fFSOps->read_indexdir(fVolumeCookie, cookie, countRead,
515		(struct dirent*)buffer, bufferSize);
516}
517
518// RewindIndexDir
519status_t
520KernelUserVolume::RewindIndexDir(void* cookie)
521{
522	if (!fFSOps->rewind_indexdir)
523		return B_BAD_VALUE;
524	return fFSOps->rewind_indexdir(fVolumeCookie, cookie);
525}
526
527// CreateIndex
528status_t
529KernelUserVolume::CreateIndex(const char* name, int type, int flags)
530{
531	if (!fFSOps->create_index)
532		return B_BAD_VALUE;
533	return fFSOps->create_index(fVolumeCookie, name, type, flags);
534}
535
536// RemoveIndex
537status_t
538KernelUserVolume::RemoveIndex(const char* name)
539{
540	if (!fFSOps->remove_index)
541		return B_BAD_VALUE;
542	return fFSOps->remove_index(fVolumeCookie, name);
543}
544
545// RenameIndex
546status_t
547KernelUserVolume::RenameIndex(const char* oldName, const char* newName)
548{
549	if (!fFSOps->rename_index)
550		return B_BAD_VALUE;
551	return fFSOps->rename_index(fVolumeCookie, oldName, newName);
552}
553
554// StatIndex
555status_t
556KernelUserVolume::StatIndex(const char *name, struct index_info* indexInfo)
557{
558	if (!fFSOps->stat_index)
559		return B_BAD_VALUE;
560	return fFSOps->stat_index(fVolumeCookie, name, indexInfo);
561}
562
563// #pragma mark -
564// #pragma mark ----- queries -----
565
566// OpenQuery
567status_t
568KernelUserVolume::OpenQuery(const char* queryString, ulong flags, port_id port,
569	long token, void** cookie)
570{
571	if (!fFSOps->open_query)
572		return B_BAD_VALUE;
573	return fFSOps->open_query(fVolumeCookie, queryString, flags, port,
574		token, cookie);
575}
576
577// CloseQuery
578status_t
579KernelUserVolume::CloseQuery(void* cookie)
580{
581	if (!fFSOps->close_query)
582		return B_OK;
583	return fFSOps->close_query(fVolumeCookie, cookie);
584}
585
586// FreeQueryCookie
587status_t
588KernelUserVolume::FreeQueryCookie(void* cookie)
589{
590	if (!fFSOps->free_querycookie)
591		return B_OK;
592	return fFSOps->free_querycookie(fVolumeCookie, NULL, cookie);
593}
594
595// ReadQuery
596status_t
597KernelUserVolume::ReadQuery(void* cookie, void* buffer, size_t bufferSize,
598	int32 count, int32* countRead)
599{
600	if (!fFSOps->read_query)
601		return B_BAD_VALUE;
602	*countRead = count;
603	return fFSOps->read_query(fVolumeCookie, cookie, countRead,
604		(struct dirent*)buffer, bufferSize);
605}
606
607