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