1 /* 2 * Copyright 2010, Jérôme Duval, korli@users.berlios.de. 3 * Copyright 2008, Axel Dörfler, axeld@pinc-software.de. 4 * This file may be used under the terms of the MIT License. 5 */ 6 7 8 #include <dirent.h> 9 #include <util/kernel_cpp.h> 10 #include <string.h> 11 12 #include <AutoDeleter.h> 13 #include <fs_cache.h> 14 #include <fs_info.h> 15 #include <io_requests.h> 16 #include <NodeMonitor.h> 17 #include <util/AutoLock.h> 18 19 #include "Attribute.h" 20 #include "CachedBlock.h" 21 #include "DirectoryIterator.h" 22 #include "ext2.h" 23 #include "HTree.h" 24 #include "Inode.h" 25 #include "Journal.h" 26 #include "Utility.h" 27 28 29 //#define TRACE_EXT2 30 #ifdef TRACE_EXT2 31 # define TRACE(x...) dprintf("\33[34mext2:\33[0m " x) 32 #else 33 # define TRACE(x...) ; 34 #endif 35 #define ERROR(x...) dprintf("\33[34mext2:\33[0m " x) 36 37 38 #define EXT2_IO_SIZE 65536 39 40 41 struct identify_cookie { 42 ext2_super_block super_block; 43 }; 44 45 46 //! ext2_io() callback hook 47 static status_t 48 iterative_io_get_vecs_hook(void* cookie, io_request* request, off_t offset, 49 size_t size, struct file_io_vec* vecs, size_t* _count) 50 { 51 Inode* inode = (Inode*)cookie; 52 53 return file_map_translate(inode->Map(), offset, size, vecs, _count, 54 inode->GetVolume()->BlockSize()); 55 } 56 57 58 //! ext2_io() callback hook 59 static status_t 60 iterative_io_finished_hook(void* cookie, io_request* request, status_t status, 61 bool partialTransfer, size_t bytesTransferred) 62 { 63 Inode* inode = (Inode*)cookie; 64 rw_lock_read_unlock(inode->Lock()); 65 return B_OK; 66 } 67 68 69 // #pragma mark - Scanning 70 71 72 static float 73 ext2_identify_partition(int fd, partition_data *partition, void **_cookie) 74 { 75 ext2_super_block superBlock; 76 status_t status = Volume::Identify(fd, &superBlock); 77 if (status != B_OK) 78 return -1; 79 80 identify_cookie *cookie = new identify_cookie; 81 memcpy(&cookie->super_block, &superBlock, sizeof(ext2_super_block)); 82 83 *_cookie = cookie; 84 return 0.8f; 85 } 86 87 88 static status_t 89 ext2_scan_partition(int fd, partition_data *partition, void *_cookie) 90 { 91 identify_cookie *cookie = (identify_cookie *)_cookie; 92 93 partition->status = B_PARTITION_VALID; 94 partition->flags |= B_PARTITION_FILE_SYSTEM; 95 partition->content_size = cookie->super_block.NumBlocks( 96 (cookie->super_block.CompatibleFeatures() 97 & EXT2_INCOMPATIBLE_FEATURE_64BIT) != 0) 98 << cookie->super_block.BlockShift(); 99 partition->block_size = 1UL << cookie->super_block.BlockShift(); 100 partition->content_name = strdup(cookie->super_block.name); 101 if (partition->content_name == NULL) 102 return B_NO_MEMORY; 103 104 return B_OK; 105 } 106 107 108 static void 109 ext2_free_identify_partition_cookie(partition_data* partition, void* _cookie) 110 { 111 delete (identify_cookie*)_cookie; 112 } 113 114 115 // #pragma mark - 116 117 118 static status_t 119 ext2_mount(fs_volume* _volume, const char* device, uint32 flags, 120 const char* args, ino_t* _rootID) 121 { 122 Volume* volume = new(std::nothrow) Volume(_volume); 123 if (volume == NULL) 124 return B_NO_MEMORY; 125 126 // TODO: this is a bit hacky: we can't use publish_vnode() to publish 127 // the root node, or else its file cache cannot be created (we could 128 // create it later, though). Therefore we're using get_vnode() in Mount(), 129 // but that requires us to export our volume data before calling it. 130 _volume->private_volume = volume; 131 _volume->ops = &gExt2VolumeOps; 132 133 status_t status = volume->Mount(device, flags); 134 if (status != B_OK) { 135 ERROR("Failed mounting the volume. Error: %s\n", strerror(status)); 136 delete volume; 137 return status; 138 } 139 140 *_rootID = volume->RootNode()->ID(); 141 return B_OK; 142 } 143 144 145 static status_t 146 ext2_unmount(fs_volume *_volume) 147 { 148 Volume* volume = (Volume *)_volume->private_volume; 149 150 status_t status = volume->Unmount(); 151 delete volume; 152 153 return status; 154 } 155 156 157 static status_t 158 ext2_read_fs_info(fs_volume* _volume, struct fs_info* info) 159 { 160 Volume* volume = (Volume*)_volume->private_volume; 161 162 // File system flags 163 info->flags = B_FS_IS_PERSISTENT | B_FS_HAS_ATTR 164 | (volume->IsReadOnly() ? B_FS_IS_READONLY : 0); 165 info->io_size = EXT2_IO_SIZE; 166 info->block_size = volume->BlockSize(); 167 info->total_blocks = volume->NumBlocks(); 168 info->free_blocks = volume->NumFreeBlocks(); 169 170 // Volume name 171 strlcpy(info->volume_name, volume->Name(), sizeof(info->volume_name)); 172 173 // File system name 174 strlcpy(info->fsh_name, "ext2", sizeof(info->fsh_name)); 175 176 return B_OK; 177 } 178 179 180 static status_t 181 ext2_write_fs_info(fs_volume* _volume, const struct fs_info* info, uint32 mask) 182 { 183 Volume* volume = (Volume*)_volume->private_volume; 184 185 if (volume->IsReadOnly()) 186 return B_READ_ONLY_DEVICE; 187 188 MutexLocker locker(volume->Lock()); 189 190 status_t status = B_BAD_VALUE; 191 192 if (mask & FS_WRITE_FSINFO_NAME) { 193 Transaction transaction(volume->GetJournal()); 194 volume->SetName(info->volume_name); 195 status = volume->WriteSuperBlock(transaction); 196 transaction.Done(); 197 } 198 return status; 199 } 200 201 202 static status_t 203 ext2_sync(fs_volume* _volume) 204 { 205 Volume* volume = (Volume*)_volume->private_volume; 206 return volume->Sync(); 207 } 208 209 210 // #pragma mark - 211 212 213 static status_t 214 ext2_get_vnode(fs_volume* _volume, ino_t id, fs_vnode* _node, int* _type, 215 uint32* _flags, bool reenter) 216 { 217 Volume* volume = (Volume*)_volume->private_volume; 218 219 if (id < 2 || id > volume->NumInodes()) { 220 ERROR("invalid inode id %" B_PRIdINO " requested!\n", id); 221 return B_BAD_VALUE; 222 } 223 224 Inode* inode = new(std::nothrow) Inode(volume, id); 225 if (inode == NULL) 226 return B_NO_MEMORY; 227 228 status_t status = inode->InitCheck(); 229 if (status != B_OK) 230 delete inode; 231 232 if (status == B_OK) { 233 _node->private_node = inode; 234 _node->ops = &gExt2VnodeOps; 235 *_type = inode->Mode(); 236 *_flags = 0; 237 } else 238 ERROR("get_vnode: InitCheck() failed. Error: %s\n", strerror(status)); 239 240 return status; 241 } 242 243 244 static status_t 245 ext2_put_vnode(fs_volume* _volume, fs_vnode* _node, bool reenter) 246 { 247 delete (Inode*)_node->private_node; 248 return B_OK; 249 } 250 251 252 static status_t 253 ext2_remove_vnode(fs_volume* _volume, fs_vnode* _node, bool reenter) 254 { 255 TRACE("ext2_remove_vnode()\n"); 256 Volume* volume = (Volume*)_volume->private_volume; 257 Inode* inode = (Inode*)_node->private_node; 258 ObjectDeleter<Inode> inodeDeleter(inode); 259 260 if (!inode->IsDeleted()) 261 return B_OK; 262 263 TRACE("ext2_remove_vnode(): Starting transaction\n"); 264 Transaction transaction(volume->GetJournal()); 265 266 if (!inode->IsSymLink() || inode->Size() >= EXT2_SHORT_SYMLINK_LENGTH) { 267 TRACE("ext2_remove_vnode(): Truncating\n"); 268 status_t status = inode->Resize(transaction, 0); 269 if (status != B_OK) 270 return status; 271 } 272 273 TRACE("ext2_remove_vnode(): Removing from orphan list\n"); 274 status_t status = volume->RemoveOrphan(transaction, inode->ID()); 275 if (status != B_OK) 276 return status; 277 278 TRACE("ext2_remove_vnode(): Setting deletion time\n"); 279 inode->Node().SetDeletionTime(real_time_clock()); 280 281 status = inode->WriteBack(transaction); 282 if (status != B_OK) 283 return status; 284 285 TRACE("ext2_remove_vnode(): Freeing inode\n"); 286 status = volume->FreeInode(transaction, inode->ID(), inode->IsDirectory()); 287 288 // TODO: When Transaction::Done() fails, do we have to re-add the vnode? 289 if (status == B_OK) 290 status = transaction.Done(); 291 292 return status; 293 } 294 295 296 static bool 297 ext2_can_page(fs_volume* _volume, fs_vnode* _node, void* _cookie) 298 { 299 return true; 300 } 301 302 303 static status_t 304 ext2_read_pages(fs_volume* _volume, fs_vnode* _node, void* _cookie, 305 off_t pos, const iovec* vecs, size_t count, size_t* _numBytes) 306 { 307 Volume* volume = (Volume*)_volume->private_volume; 308 Inode* inode = (Inode*)_node->private_node; 309 310 if (inode->FileCache() == NULL) 311 return B_BAD_VALUE; 312 313 rw_lock_read_lock(inode->Lock()); 314 315 uint32 vecIndex = 0; 316 size_t vecOffset = 0; 317 size_t bytesLeft = *_numBytes; 318 status_t status; 319 320 while (true) { 321 file_io_vec fileVecs[8]; 322 size_t fileVecCount = 8; 323 324 status = file_map_translate(inode->Map(), pos, bytesLeft, fileVecs, 325 &fileVecCount, 0); 326 if (status != B_OK && status != B_BUFFER_OVERFLOW) 327 break; 328 329 bool bufferOverflow = status == B_BUFFER_OVERFLOW; 330 331 size_t bytes = bytesLeft; 332 status = read_file_io_vec_pages(volume->Device(), fileVecs, 333 fileVecCount, vecs, count, &vecIndex, &vecOffset, &bytes); 334 if (status != B_OK || !bufferOverflow) 335 break; 336 337 pos += bytes; 338 bytesLeft -= bytes; 339 } 340 341 rw_lock_read_unlock(inode->Lock()); 342 343 return status; 344 } 345 346 347 static status_t 348 ext2_write_pages(fs_volume* _volume, fs_vnode* _node, void* _cookie, 349 off_t pos, const iovec* vecs, size_t count, size_t* _numBytes) 350 { 351 Volume* volume = (Volume*)_volume->private_volume; 352 Inode* inode = (Inode*)_node->private_node; 353 354 if (volume->IsReadOnly()) 355 return B_READ_ONLY_DEVICE; 356 357 if (inode->FileCache() == NULL) 358 return B_BAD_VALUE; 359 360 rw_lock_read_lock(inode->Lock()); 361 362 uint32 vecIndex = 0; 363 size_t vecOffset = 0; 364 size_t bytesLeft = *_numBytes; 365 status_t status; 366 367 while (true) { 368 file_io_vec fileVecs[8]; 369 size_t fileVecCount = 8; 370 371 status = file_map_translate(inode->Map(), pos, bytesLeft, fileVecs, 372 &fileVecCount, 0); 373 if (status != B_OK && status != B_BUFFER_OVERFLOW) 374 break; 375 376 bool bufferOverflow = status == B_BUFFER_OVERFLOW; 377 378 size_t bytes = bytesLeft; 379 status = write_file_io_vec_pages(volume->Device(), fileVecs, 380 fileVecCount, vecs, count, &vecIndex, &vecOffset, &bytes); 381 if (status != B_OK || !bufferOverflow) 382 break; 383 384 pos += bytes; 385 bytesLeft -= bytes; 386 } 387 388 rw_lock_read_unlock(inode->Lock()); 389 390 return status; 391 } 392 393 394 static status_t 395 ext2_io(fs_volume* _volume, fs_vnode* _node, void* _cookie, io_request* request) 396 { 397 Volume* volume = (Volume*)_volume->private_volume; 398 Inode* inode = (Inode*)_node->private_node; 399 400 #ifndef EXT2_SHELL 401 if (io_request_is_write(request) && volume->IsReadOnly()) { 402 notify_io_request(request, B_READ_ONLY_DEVICE); 403 return B_READ_ONLY_DEVICE; 404 } 405 #endif 406 407 if (inode->FileCache() == NULL) { 408 #ifndef EXT2_SHELL 409 notify_io_request(request, B_BAD_VALUE); 410 #endif 411 return B_BAD_VALUE; 412 } 413 414 // We lock the node here and will unlock it in the "finished" hook. 415 rw_lock_read_lock(inode->Lock()); 416 417 return do_iterative_fd_io(volume->Device(), request, 418 iterative_io_get_vecs_hook, iterative_io_finished_hook, inode); 419 } 420 421 422 static status_t 423 ext2_get_file_map(fs_volume* _volume, fs_vnode* _node, off_t offset, 424 size_t size, struct file_io_vec* vecs, size_t* _count) 425 { 426 TRACE("ext2_get_file_map()\n"); 427 Volume* volume = (Volume*)_volume->private_volume; 428 Inode* inode = (Inode*)_node->private_node; 429 size_t index = 0, max = *_count; 430 431 while (true) { 432 fsblock_t block; 433 uint32 count = 1; 434 status_t status = inode->FindBlock(offset, block, &count); 435 if (status != B_OK) 436 return status; 437 438 if (block > volume->NumBlocks()) { 439 panic("ext2_get_file_map() found block %" B_PRIu64 " for offset %" 440 B_PRIdOFF "\n", block, offset); 441 } 442 443 off_t blockOffset = block << volume->BlockShift(); 444 uint32 blockLength = volume->BlockSize() * count; 445 446 if (index > 0 && (vecs[index - 1].offset 447 == blockOffset - vecs[index - 1].length 448 || (vecs[index - 1].offset == -1 && block == 0))) { 449 vecs[index - 1].length += blockLength; 450 } else { 451 if (index >= max) { 452 // we're out of file_io_vecs; let's bail out 453 *_count = index; 454 return B_BUFFER_OVERFLOW; 455 } 456 457 // 'block' is 0 for sparse blocks 458 if (block != 0) 459 vecs[index].offset = blockOffset; 460 else 461 vecs[index].offset = -1; 462 463 vecs[index].length = blockLength; 464 index++; 465 } 466 467 offset += blockLength; 468 469 if (offset >= inode->Size() || size <= blockLength) { 470 // We're done! 471 *_count = index; 472 TRACE("ext2_get_file_map for inode %" B_PRIdINO "\n", inode->ID()); 473 return B_OK; 474 } 475 476 size -= blockLength; 477 } 478 479 // can never get here 480 return B_ERROR; 481 } 482 483 484 // #pragma mark - 485 486 487 static status_t 488 ext2_lookup(fs_volume* _volume, fs_vnode* _directory, const char* name, 489 ino_t* _vnodeID) 490 { 491 TRACE("ext2_lookup: name address: %p\n", name); 492 TRACE("ext2_lookup: name: %s\n", name); 493 Volume* volume = (Volume*)_volume->private_volume; 494 Inode* directory = (Inode*)_directory->private_node; 495 496 // check access permissions 497 status_t status = directory->CheckPermissions(X_OK); 498 if (status < B_OK) 499 return status; 500 501 HTree htree(volume, directory); 502 DirectoryIterator* iterator; 503 504 status = htree.Lookup(name, &iterator); 505 if (status != B_OK) 506 return status; 507 508 ObjectDeleter<DirectoryIterator> iteratorDeleter(iterator); 509 510 status = iterator->FindEntry(name, _vnodeID); 511 if (status != B_OK) 512 return status; 513 514 return get_vnode(volume->FSVolume(), *_vnodeID, NULL); 515 } 516 517 518 static status_t 519 ext2_ioctl(fs_volume* _volume, fs_vnode* _node, void* _cookie, uint32 cmd, 520 void* buffer, size_t bufferLength) 521 { 522 TRACE("ioctl: %" B_PRIu32 "\n", cmd); 523 524 Volume* volume = (Volume*)_volume->private_volume; 525 switch (cmd) { 526 case 56742: 527 { 528 TRACE("ioctl: Test the block allocator\n"); 529 // Test the block allocator 530 TRACE("ioctl: Creating transaction\n"); 531 Transaction transaction(volume->GetJournal()); 532 TRACE("ioctl: Creating cached block\n"); 533 CachedBlock cached(volume); 534 uint32 blocksPerGroup = volume->BlocksPerGroup(); 535 uint32 blockSize = volume->BlockSize(); 536 uint32 firstBlock = volume->FirstDataBlock(); 537 fsblock_t start = 0; 538 uint32 group = 0; 539 uint32 length; 540 541 TRACE("ioctl: blocks per group: %" B_PRIu32 ", block size: %" 542 B_PRIu32 ", first block: %" B_PRIu32 ", start: %" B_PRIu64 543 ", group: %" B_PRIu32 "\n", blocksPerGroup, 544 blockSize, firstBlock, start, group); 545 546 while (volume->AllocateBlocks(transaction, 1, 2048, group, start, 547 length) == B_OK) { 548 TRACE("ioctl: Allocated blocks in group %" B_PRIu32 ": %" 549 B_PRIu64 "-%" B_PRIu64 "\n", group, start, start + length); 550 off_t blockNum = start + group * blocksPerGroup - firstBlock; 551 552 for (uint32 i = 0; i < length; ++i) { 553 uint8* block = cached.SetToWritable(transaction, blockNum); 554 memset(block, 0, blockSize); 555 blockNum++; 556 } 557 558 TRACE("ioctl: Blocks cleared\n"); 559 560 transaction.Done(); 561 transaction.Start(volume->GetJournal()); 562 } 563 564 TRACE("ioctl: Done\n"); 565 566 return B_OK; 567 } 568 } 569 570 return B_DEV_INVALID_IOCTL; 571 } 572 573 574 static status_t 575 ext2_fsync(fs_volume* _volume, fs_vnode* _node) 576 { 577 Inode* inode = (Inode*)_node->private_node; 578 return inode->Sync(); 579 } 580 581 582 static status_t 583 ext2_read_stat(fs_volume* _volume, fs_vnode* _node, struct stat* stat) 584 { 585 Inode* inode = (Inode*)_node->private_node; 586 const ext2_inode& node = inode->Node(); 587 588 stat->st_dev = inode->GetVolume()->ID(); 589 stat->st_ino = inode->ID(); 590 stat->st_nlink = node.NumLinks(); 591 stat->st_blksize = EXT2_IO_SIZE; 592 593 stat->st_uid = node.UserID(); 594 stat->st_gid = node.GroupID(); 595 stat->st_mode = node.Mode(); 596 stat->st_type = 0; 597 598 inode->GetAccessTime(&stat->st_atim); 599 inode->GetModificationTime(&stat->st_mtim); 600 inode->GetChangeTime(&stat->st_ctim); 601 inode->GetCreationTime(&stat->st_crtim); 602 603 stat->st_size = inode->Size(); 604 stat->st_blocks = (inode->Size() + 511) / 512; 605 606 return B_OK; 607 } 608 609 610 status_t 611 ext2_write_stat(fs_volume* _volume, fs_vnode* _node, const struct stat* stat, 612 uint32 mask) 613 { 614 TRACE("ext2_write_stat\n"); 615 Volume* volume = (Volume*)_volume->private_volume; 616 617 if (volume->IsReadOnly()) 618 return B_READ_ONLY_DEVICE; 619 620 Inode* inode = (Inode*)_node->private_node; 621 622 ext2_inode& node = inode->Node(); 623 bool updateTime = false; 624 uid_t uid = geteuid(); 625 626 bool isOwnerOrRoot = uid == 0 || uid == (uid_t)node.UserID(); 627 bool hasWriteAccess = inode->CheckPermissions(W_OK) == B_OK; 628 629 TRACE("ext2_write_stat: Starting transaction\n"); 630 Transaction transaction(volume->GetJournal()); 631 inode->WriteLockInTransaction(transaction); 632 633 if ((mask & B_STAT_SIZE) != 0 && inode->Size() != stat->st_size) { 634 if (inode->IsDirectory()) 635 return B_IS_A_DIRECTORY; 636 if (!inode->IsFile()) 637 return B_BAD_VALUE; 638 if (!hasWriteAccess) 639 return B_NOT_ALLOWED; 640 641 TRACE("ext2_write_stat: Old size: %ld, new size: %ld\n", 642 (long)inode->Size(), (long)stat->st_size); 643 644 off_t oldSize = inode->Size(); 645 646 status_t status = inode->Resize(transaction, stat->st_size); 647 if (status != B_OK) 648 return status; 649 650 if ((mask & B_STAT_SIZE_INSECURE) == 0) { 651 rw_lock_write_unlock(inode->Lock()); 652 inode->FillGapWithZeros(oldSize, inode->Size()); 653 rw_lock_write_lock(inode->Lock()); 654 } 655 656 updateTime = true; 657 } 658 659 if ((mask & B_STAT_MODE) != 0) { 660 // only the user or root can do that 661 if (!isOwnerOrRoot) 662 return B_NOT_ALLOWED; 663 node.UpdateMode(stat->st_mode, S_IUMSK); 664 updateTime = true; 665 } 666 667 if ((mask & B_STAT_UID) != 0) { 668 // only root should be allowed 669 if (uid != 0) 670 return B_NOT_ALLOWED; 671 node.SetUserID(stat->st_uid); 672 updateTime = true; 673 } 674 675 if ((mask & B_STAT_GID) != 0) { 676 // only the user or root can do that 677 if (!isOwnerOrRoot) 678 return B_NOT_ALLOWED; 679 node.SetGroupID(stat->st_gid); 680 updateTime = true; 681 } 682 683 if ((mask & B_STAT_MODIFICATION_TIME) != 0 || updateTime 684 || (mask & B_STAT_CHANGE_TIME) != 0) { 685 // the user or root can do that or any user with write access 686 if (!isOwnerOrRoot && !hasWriteAccess) 687 return B_NOT_ALLOWED; 688 struct timespec newTimespec = { 0, 0}; 689 690 if ((mask & B_STAT_MODIFICATION_TIME) != 0) 691 newTimespec = stat->st_mtim; 692 693 if ((mask & B_STAT_CHANGE_TIME) != 0 694 && stat->st_ctim.tv_sec > newTimespec.tv_sec) 695 newTimespec = stat->st_ctim; 696 697 if (newTimespec.tv_sec == 0) 698 Inode::_BigtimeToTimespec(real_time_clock_usecs(), &newTimespec); 699 700 inode->SetModificationTime(&newTimespec); 701 } 702 if ((mask & B_STAT_CREATION_TIME) != 0) { 703 // the user or root can do that or any user with write access 704 if (!isOwnerOrRoot && !hasWriteAccess) 705 return B_NOT_ALLOWED; 706 inode->SetCreationTime(&stat->st_crtim); 707 } 708 709 status_t status = inode->WriteBack(transaction); 710 if (status == B_OK) 711 status = transaction.Done(); 712 if (status == B_OK) 713 notify_stat_changed(volume->ID(), -1, inode->ID(), mask); 714 715 return status; 716 } 717 718 719 static status_t 720 ext2_create(fs_volume* _volume, fs_vnode* _directory, const char* name, 721 int openMode, int mode, void** _cookie, ino_t* _vnodeID) 722 { 723 Volume* volume = (Volume*)_volume->private_volume; 724 Inode* directory = (Inode*)_directory->private_node; 725 726 TRACE("ext2_create()\n"); 727 728 if (volume->IsReadOnly()) 729 return B_READ_ONLY_DEVICE; 730 731 if (!directory->IsDirectory()) 732 return B_BAD_TYPE; 733 734 TRACE("ext2_create(): Creating cookie\n"); 735 736 // Allocate cookie 737 file_cookie* cookie = new(std::nothrow) file_cookie; 738 if (cookie == NULL) 739 return B_NO_MEMORY; 740 ObjectDeleter<file_cookie> cookieDeleter(cookie); 741 742 cookie->open_mode = openMode; 743 cookie->last_size = 0; 744 cookie->last_notification = system_time(); 745 746 TRACE("ext2_create(): Starting transaction\n"); 747 748 Transaction transaction(volume->GetJournal()); 749 750 TRACE("ext2_create(): Creating inode\n"); 751 752 Inode* inode; 753 bool created; 754 status_t status = Inode::Create(transaction, directory, name, 755 S_FILE | (mode & S_IUMSK), openMode, EXT2_TYPE_FILE, &created, _vnodeID, 756 &inode, &gExt2VnodeOps); 757 if (status != B_OK) 758 return status; 759 760 TRACE("ext2_create(): Created inode\n"); 761 762 if ((openMode & O_NOCACHE) != 0) { 763 status = inode->DisableFileCache(); 764 if (status != B_OK) 765 return status; 766 } 767 768 entry_cache_add(volume->ID(), directory->ID(), name, *_vnodeID); 769 770 status = transaction.Done(); 771 if (status != B_OK) { 772 entry_cache_remove(volume->ID(), directory->ID(), name); 773 return status; 774 } 775 776 *_cookie = cookie; 777 cookieDeleter.Detach(); 778 779 if (created) 780 notify_entry_created(volume->ID(), directory->ID(), name, *_vnodeID); 781 782 return B_OK; 783 } 784 785 786 static status_t 787 ext2_create_symlink(fs_volume* _volume, fs_vnode* _directory, const char* name, 788 const char* path, int mode) 789 { 790 TRACE("ext2_create_symlink()\n"); 791 792 Volume* volume = (Volume*)_volume->private_volume; 793 Inode* directory = (Inode*)_directory->private_node; 794 795 if (volume->IsReadOnly()) 796 return B_READ_ONLY_DEVICE; 797 798 if (!directory->IsDirectory()) 799 return B_BAD_TYPE; 800 801 status_t status = directory->CheckPermissions(W_OK); 802 if (status != B_OK) 803 return status; 804 805 TRACE("ext2_create_symlink(): Starting transaction\n"); 806 Transaction transaction(volume->GetJournal()); 807 808 Inode* link; 809 ino_t id; 810 status = Inode::Create(transaction, directory, name, S_SYMLINK | 0777, 811 0, (uint8)EXT2_TYPE_SYMLINK, NULL, &id, &link); 812 if (status != B_OK) 813 return status; 814 815 // TODO: We have to prepare the link before publishing? 816 817 size_t length = strlen(path); 818 TRACE("ext2_create_symlink(): Path (%s) length: %d\n", path, (int)length); 819 if (length < EXT2_SHORT_SYMLINK_LENGTH) { 820 strcpy(link->Node().symlink, path); 821 link->Node().SetSize((uint32)length); 822 823 TRACE("ext2_create_symlink(): Publishing vnode\n"); 824 publish_vnode(volume->FSVolume(), id, link, &gExt2VnodeOps, 825 link->Mode(), 0); 826 put_vnode(volume->FSVolume(), id); 827 } else { 828 TRACE("ext2_create_symlink(): Publishing vnode\n"); 829 publish_vnode(volume->FSVolume(), id, link, &gExt2VnodeOps, 830 link->Mode(), 0); 831 put_vnode(volume->FSVolume(), id); 832 833 if (!link->HasFileCache()) { 834 status = link->CreateFileCache(); 835 if (status != B_OK) 836 return status; 837 } 838 839 size_t written = length; 840 status = link->WriteAt(transaction, 0, (const uint8*)path, &written); 841 if (status == B_OK && written != length) 842 status = B_IO_ERROR; 843 } 844 845 if (status == B_OK) 846 status = link->WriteBack(transaction); 847 848 entry_cache_add(volume->ID(), directory->ID(), name, id); 849 850 status = transaction.Done(); 851 if (status != B_OK) { 852 entry_cache_remove(volume->ID(), directory->ID(), name); 853 return status; 854 } 855 856 notify_entry_created(volume->ID(), directory->ID(), name, id); 857 858 TRACE("ext2_create_symlink(): Done\n"); 859 860 return status; 861 } 862 863 864 static status_t 865 ext2_link(fs_volume* volume, fs_vnode* dir, const char* name, fs_vnode* node) 866 { 867 // TODO 868 869 return B_UNSUPPORTED; 870 } 871 872 873 static status_t 874 ext2_unlink(fs_volume* _volume, fs_vnode* _directory, const char* name) 875 { 876 TRACE("ext2_unlink()\n"); 877 if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0) 878 return B_NOT_ALLOWED; 879 880 Volume* volume = (Volume*)_volume->private_volume; 881 Inode* directory = (Inode*)_directory->private_node; 882 883 status_t status = directory->CheckPermissions(W_OK); 884 if (status != B_OK) 885 return status; 886 887 TRACE("ext2_unlink(): Starting transaction\n"); 888 Transaction transaction(volume->GetJournal()); 889 890 directory->WriteLockInTransaction(transaction); 891 892 TRACE("ext2_unlink(): Looking up for directory entry\n"); 893 HTree htree(volume, directory); 894 DirectoryIterator* directoryIterator; 895 896 status = htree.Lookup(name, &directoryIterator); 897 if (status != B_OK) 898 return status; 899 900 ino_t id; 901 status = directoryIterator->FindEntry(name, &id); 902 if (status != B_OK) 903 return status; 904 905 Vnode vnode(volume, id); 906 Inode* inode; 907 status = vnode.Get(&inode); 908 if (status != B_OK) 909 return status; 910 911 inode->WriteLockInTransaction(transaction); 912 913 status = inode->Unlink(transaction); 914 if (status != B_OK) 915 return status; 916 917 status = directoryIterator->RemoveEntry(transaction); 918 if (status != B_OK) 919 return status; 920 921 entry_cache_remove(volume->ID(), directory->ID(), name); 922 923 status = transaction.Done(); 924 if (status != B_OK) 925 entry_cache_add(volume->ID(), directory->ID(), name, id); 926 else 927 notify_entry_removed(volume->ID(), directory->ID(), name, id); 928 929 return status; 930 } 931 932 933 static status_t 934 ext2_rename(fs_volume* _volume, fs_vnode* _oldDir, const char* oldName, 935 fs_vnode* _newDir, const char* newName) 936 { 937 TRACE("ext2_rename()\n"); 938 939 Volume* volume = (Volume*)_volume->private_volume; 940 Inode* oldDirectory = (Inode*)_oldDir->private_node; 941 Inode* newDirectory = (Inode*)_newDir->private_node; 942 943 if (oldDirectory == newDirectory && strcmp(oldName, newName) == 0) 944 return B_OK; 945 946 Transaction transaction(volume->GetJournal()); 947 948 oldDirectory->WriteLockInTransaction(transaction); 949 if (oldDirectory != newDirectory) 950 newDirectory->WriteLockInTransaction(transaction); 951 952 status_t status = oldDirectory->CheckPermissions(W_OK); 953 if (status == B_OK) 954 status = newDirectory->CheckPermissions(W_OK); 955 if (status != B_OK) 956 return status; 957 958 HTree oldHTree(volume, oldDirectory); 959 DirectoryIterator* oldIterator; 960 961 status = oldHTree.Lookup(oldName, &oldIterator); 962 if (status != B_OK) 963 return status; 964 965 ObjectDeleter<DirectoryIterator> oldIteratorDeleter(oldIterator); 966 967 ino_t oldID; 968 status = oldIterator->FindEntry(oldName, &oldID); 969 if (status != B_OK) 970 return status; 971 972 if (oldDirectory != newDirectory) { 973 TRACE("ext2_rename(): Different parent directories\n"); 974 CachedBlock cached(volume); 975 976 ino_t parentID = newDirectory->ID(); 977 ino_t oldDirID = oldDirectory->ID(); 978 979 do { 980 Vnode vnode(volume, parentID); 981 Inode* parent; 982 983 status = vnode.Get(&parent); 984 if (status != B_OK) 985 return B_IO_ERROR; 986 987 fsblock_t blockNum; 988 status = parent->FindBlock(0, blockNum); 989 if (status != B_OK) 990 return status; 991 992 const HTreeRoot* data = (const HTreeRoot*)cached.SetTo(blockNum); 993 parentID = data->dotdot.InodeID(); 994 } while (parentID != oldID && parentID != oldDirID 995 && parentID != EXT2_ROOT_NODE); 996 997 if (parentID == oldID) 998 return B_BAD_VALUE; 999 } 1000 1001 HTree newHTree(volume, newDirectory); 1002 DirectoryIterator* newIterator; 1003 1004 status = newHTree.Lookup(newName, &newIterator); 1005 if (status != B_OK) 1006 return status; 1007 1008 ObjectDeleter<DirectoryIterator> newIteratorDeleter(newIterator); 1009 1010 Vnode vnode(volume, oldID); 1011 Inode* inode; 1012 1013 status = vnode.Get(&inode); 1014 if (status != B_OK) 1015 return status; 1016 1017 uint8 fileType; 1018 1019 // TODO: Support all file types? 1020 if (inode->IsDirectory()) 1021 fileType = EXT2_TYPE_DIRECTORY; 1022 else if (inode->IsSymLink()) 1023 fileType = EXT2_TYPE_SYMLINK; 1024 else 1025 fileType = EXT2_TYPE_FILE; 1026 1027 // Add entry in destination directory 1028 ino_t existentID; 1029 status = newIterator->FindEntry(newName, &existentID); 1030 if (status == B_OK) { 1031 if (existentID == oldID) { 1032 // Remove entry in oldID 1033 // return inode->Unlink(); 1034 return B_BAD_VALUE; 1035 } 1036 1037 Vnode vnodeExistent(volume, existentID); 1038 Inode* existent; 1039 1040 if (vnodeExistent.Get(&existent) != B_OK) 1041 return B_NAME_IN_USE; 1042 1043 if (existent->IsDirectory() != inode->IsDirectory()) { 1044 return existent->IsDirectory() ? B_IS_A_DIRECTORY 1045 : B_NOT_A_DIRECTORY; 1046 } 1047 1048 // TODO: Perhaps we have to revert this in case of error? 1049 status = newIterator->ChangeEntry(transaction, oldID, fileType); 1050 if (status != B_OK) 1051 return status; 1052 1053 notify_entry_removed(volume->ID(), newDirectory->ID(), newName, 1054 existentID); 1055 } else if (status == B_ENTRY_NOT_FOUND) { 1056 newIterator->Restart(); 1057 1058 status = newIterator->AddEntry(transaction, newName, strlen(newName), 1059 oldID, fileType); 1060 if (status != B_OK) 1061 return status; 1062 } else 1063 return status; 1064 1065 // Remove entry from source folder 1066 status = oldIterator->RemoveEntry(transaction); 1067 if (status != B_OK) 1068 return status; 1069 1070 inode->WriteLockInTransaction(transaction); 1071 1072 if (oldDirectory != newDirectory && inode->IsDirectory()) { 1073 DirectoryIterator inodeIterator(inode); 1074 1075 status = inodeIterator.FindEntry(".."); 1076 if (status == B_ENTRY_NOT_FOUND) { 1077 TRACE("Corrupt file system. Missing \"..\" in directory %" 1078 B_PRIdINO "\n", inode->ID()); 1079 return B_BAD_DATA; 1080 } else if (status != B_OK) 1081 return status; 1082 1083 inodeIterator.ChangeEntry(transaction, newDirectory->ID(), 1084 (uint8)EXT2_TYPE_DIRECTORY); 1085 } 1086 1087 status = inode->WriteBack(transaction); 1088 if (status != B_OK) 1089 return status; 1090 1091 entry_cache_remove(volume->ID(), oldDirectory->ID(), oldName); 1092 entry_cache_add(volume->ID(), newDirectory->ID(), newName, oldID); 1093 1094 status = transaction.Done(); 1095 if (status != B_OK) { 1096 entry_cache_remove(volume->ID(), oldDirectory->ID(), newName); 1097 entry_cache_add(volume->ID(), newDirectory->ID(), oldName, oldID); 1098 1099 return status; 1100 } 1101 1102 notify_entry_moved(volume->ID(), oldDirectory->ID(), oldName, 1103 newDirectory->ID(), newName, oldID); 1104 1105 return B_OK; 1106 } 1107 1108 1109 static status_t 1110 ext2_open(fs_volume* _volume, fs_vnode* _node, int openMode, void** _cookie) 1111 { 1112 Volume* volume = (Volume*)_volume->private_volume; 1113 Inode* inode = (Inode*)_node->private_node; 1114 1115 // opening a directory read-only is allowed, although you can't read 1116 // any data from it. 1117 if (inode->IsDirectory() && (openMode & O_RWMASK) != 0) 1118 return B_IS_A_DIRECTORY; 1119 1120 status_t status = inode->CheckPermissions(open_mode_to_access(openMode) 1121 | (openMode & O_TRUNC ? W_OK : 0)); 1122 if (status != B_OK) 1123 return status; 1124 1125 // Prepare the cookie 1126 file_cookie* cookie = new(std::nothrow) file_cookie; 1127 if (cookie == NULL) 1128 return B_NO_MEMORY; 1129 ObjectDeleter<file_cookie> cookieDeleter(cookie); 1130 1131 cookie->open_mode = openMode & EXT2_OPEN_MODE_USER_MASK; 1132 cookie->last_size = inode->Size(); 1133 cookie->last_notification = system_time(); 1134 1135 MethodDeleter<Inode, status_t> fileCacheEnabler(&Inode::EnableFileCache); 1136 if ((openMode & O_NOCACHE) != 0) { 1137 status = inode->DisableFileCache(); 1138 if (status != B_OK) 1139 return status; 1140 fileCacheEnabler.SetTo(inode); 1141 } 1142 1143 // Should we truncate the file? 1144 if ((openMode & O_TRUNC) != 0) { 1145 if ((openMode & O_RWMASK) == O_RDONLY) 1146 return B_NOT_ALLOWED; 1147 1148 Transaction transaction(volume->GetJournal()); 1149 inode->WriteLockInTransaction(transaction); 1150 1151 status_t status = inode->Resize(transaction, 0); 1152 if (status == B_OK) 1153 status = inode->WriteBack(transaction); 1154 if (status == B_OK) 1155 status = transaction.Done(); 1156 if (status != B_OK) 1157 return status; 1158 1159 // TODO: No need to notify file size changed? 1160 } 1161 1162 fileCacheEnabler.Detach(); 1163 cookieDeleter.Detach(); 1164 *_cookie = cookie; 1165 1166 return B_OK; 1167 } 1168 1169 1170 static status_t 1171 ext2_read(fs_volume* _volume, fs_vnode* _node, void* _cookie, off_t pos, 1172 void* buffer, size_t* _length) 1173 { 1174 Inode* inode = (Inode*)_node->private_node; 1175 1176 if (!inode->IsFile()) { 1177 *_length = 0; 1178 return inode->IsDirectory() ? B_IS_A_DIRECTORY : B_BAD_VALUE; 1179 } 1180 1181 return inode->ReadAt(pos, (uint8*)buffer, _length); 1182 } 1183 1184 1185 static status_t 1186 ext2_write(fs_volume* _volume, fs_vnode* _node, void* _cookie, off_t pos, 1187 const void* buffer, size_t* _length) 1188 { 1189 TRACE("ext2_write()\n"); 1190 Volume* volume = (Volume*)_volume->private_volume; 1191 Inode* inode = (Inode*)_node->private_node; 1192 1193 if (volume->IsReadOnly()) 1194 return B_READ_ONLY_DEVICE; 1195 1196 if (inode->IsDirectory()) { 1197 *_length = 0; 1198 return B_IS_A_DIRECTORY; 1199 } 1200 1201 TRACE("ext2_write(): Preparing cookie\n"); 1202 1203 file_cookie* cookie = (file_cookie*)_cookie; 1204 1205 if ((cookie->open_mode & O_APPEND) != 0) 1206 pos = inode->Size(); 1207 1208 TRACE("ext2_write(): Creating transaction\n"); 1209 Transaction transaction; 1210 1211 status_t status = inode->WriteAt(transaction, pos, (const uint8*)buffer, 1212 _length); 1213 if (status == B_OK) 1214 status = transaction.Done(); 1215 if (status == B_OK) { 1216 TRACE("ext2_write(): Finalizing\n"); 1217 ReadLocker lock(*inode->Lock()); 1218 1219 if (cookie->last_size != inode->Size() 1220 && system_time() > cookie->last_notification 1221 + INODE_NOTIFICATION_INTERVAL) { 1222 notify_stat_changed(volume->ID(), -1, inode->ID(), 1223 B_STAT_MODIFICATION_TIME | B_STAT_SIZE | B_STAT_INTERIM_UPDATE); 1224 cookie->last_size = inode->Size(); 1225 cookie->last_notification = system_time(); 1226 } 1227 } 1228 1229 TRACE("ext2_write(): Done\n"); 1230 1231 return status; 1232 } 1233 1234 1235 static status_t 1236 ext2_close(fs_volume *_volume, fs_vnode *_node, void *_cookie) 1237 { 1238 return B_OK; 1239 } 1240 1241 1242 static status_t 1243 ext2_free_cookie(fs_volume* _volume, fs_vnode* _node, void* _cookie) 1244 { 1245 file_cookie* cookie = (file_cookie*)_cookie; 1246 Volume* volume = (Volume*)_volume->private_volume; 1247 Inode* inode = (Inode*)_node->private_node; 1248 1249 if (inode->Size() != cookie->last_size) 1250 notify_stat_changed(volume->ID(), -1, inode->ID(), B_STAT_SIZE); 1251 1252 if ((cookie->open_mode & O_NOCACHE) != 0) 1253 inode->EnableFileCache(); 1254 1255 delete cookie; 1256 return B_OK; 1257 } 1258 1259 1260 static status_t 1261 ext2_access(fs_volume* _volume, fs_vnode* _node, int accessMode) 1262 { 1263 Inode* inode = (Inode*)_node->private_node; 1264 return inode->CheckPermissions(accessMode); 1265 } 1266 1267 1268 static status_t 1269 ext2_read_link(fs_volume *_volume, fs_vnode *_node, char *buffer, 1270 size_t *_bufferSize) 1271 { 1272 Inode* inode = (Inode*)_node->private_node; 1273 1274 if (!inode->IsSymLink()) 1275 return B_BAD_VALUE; 1276 1277 if (inode->Size() < (off_t)*_bufferSize) 1278 *_bufferSize = inode->Size(); 1279 1280 if (inode->Size() > EXT2_SHORT_SYMLINK_LENGTH) 1281 return inode->ReadAt(0, (uint8 *)buffer, _bufferSize); 1282 1283 memcpy(buffer, inode->Node().symlink, *_bufferSize); 1284 return B_OK; 1285 } 1286 1287 1288 // #pragma mark - Directory functions 1289 1290 1291 static status_t 1292 ext2_create_dir(fs_volume* _volume, fs_vnode* _directory, const char* name, 1293 int mode) 1294 { 1295 TRACE("ext2_create_dir()\n"); 1296 Volume* volume = (Volume*)_volume->private_volume; 1297 Inode* directory = (Inode*)_directory->private_node; 1298 1299 if (volume->IsReadOnly()) 1300 return B_READ_ONLY_DEVICE; 1301 1302 if (!directory->IsDirectory()) 1303 return B_BAD_TYPE; 1304 1305 status_t status = directory->CheckPermissions(W_OK); 1306 if (status != B_OK) 1307 return status; 1308 1309 TRACE("ext2_create_dir(): Starting transaction\n"); 1310 Transaction transaction(volume->GetJournal()); 1311 1312 ino_t id; 1313 status = Inode::Create(transaction, directory, name, 1314 S_DIRECTORY | (mode & S_IUMSK), 0, EXT2_TYPE_DIRECTORY, NULL, &id); 1315 if (status != B_OK) 1316 return status; 1317 1318 put_vnode(volume->FSVolume(), id); 1319 1320 entry_cache_add(volume->ID(), directory->ID(), name, id); 1321 1322 status = transaction.Done(); 1323 if (status != B_OK) { 1324 entry_cache_remove(volume->ID(), directory->ID(), name); 1325 return status; 1326 } 1327 1328 notify_entry_created(volume->ID(), directory->ID(), name, id); 1329 1330 TRACE("ext2_create_dir(): Done\n"); 1331 1332 return B_OK; 1333 } 1334 1335 1336 static status_t 1337 ext2_remove_dir(fs_volume* _volume, fs_vnode* _directory, const char* name) 1338 { 1339 TRACE("ext2_remove_dir()\n"); 1340 1341 Volume* volume = (Volume*)_volume->private_volume; 1342 Inode* directory = (Inode*)_directory->private_node; 1343 1344 status_t status = directory->CheckPermissions(W_OK); 1345 if (status != B_OK) 1346 return status; 1347 1348 TRACE("ext2_remove_dir(): Starting transaction\n"); 1349 Transaction transaction(volume->GetJournal()); 1350 1351 directory->WriteLockInTransaction(transaction); 1352 1353 TRACE("ext2_remove_dir(): Looking up for directory entry\n"); 1354 HTree htree(volume, directory); 1355 DirectoryIterator* directoryIterator; 1356 1357 status = htree.Lookup(name, &directoryIterator); 1358 if (status != B_OK) 1359 return status; 1360 1361 ino_t id; 1362 status = directoryIterator->FindEntry(name, &id); 1363 if (status != B_OK) 1364 return status; 1365 1366 Vnode vnode(volume, id); 1367 Inode* inode; 1368 status = vnode.Get(&inode); 1369 if (status != B_OK) 1370 return status; 1371 1372 inode->WriteLockInTransaction(transaction); 1373 1374 status = inode->Unlink(transaction); 1375 if (status != B_OK) 1376 return status; 1377 1378 status = directory->Unlink(transaction); 1379 if (status != B_OK) 1380 return status; 1381 1382 status = directoryIterator->RemoveEntry(transaction); 1383 if (status != B_OK) 1384 return status; 1385 1386 entry_cache_remove(volume->ID(), directory->ID(), name); 1387 entry_cache_remove(volume->ID(), id, ".."); 1388 1389 status = transaction.Done(); 1390 if (status != B_OK) { 1391 entry_cache_add(volume->ID(), directory->ID(), name, id); 1392 entry_cache_add(volume->ID(), id, "..", id); 1393 } else 1394 notify_entry_removed(volume->ID(), directory->ID(), name, id); 1395 1396 return status; 1397 } 1398 1399 1400 static status_t 1401 ext2_open_dir(fs_volume* _volume, fs_vnode* _node, void** _cookie) 1402 { 1403 Inode* inode = (Inode*)_node->private_node; 1404 status_t status = inode->CheckPermissions(R_OK); 1405 if (status < B_OK) 1406 return status; 1407 1408 if (!inode->IsDirectory()) 1409 return B_NOT_A_DIRECTORY; 1410 1411 DirectoryIterator* iterator = new(std::nothrow) DirectoryIterator(inode); 1412 if (iterator == NULL) 1413 return B_NO_MEMORY; 1414 1415 *_cookie = iterator; 1416 return B_OK; 1417 } 1418 1419 1420 static status_t 1421 ext2_read_dir(fs_volume *_volume, fs_vnode *_node, void *_cookie, 1422 struct dirent *dirent, size_t bufferSize, uint32 *_num) 1423 { 1424 DirectoryIterator *iterator = (DirectoryIterator *)_cookie; 1425 Volume* volume = (Volume*)_volume->private_volume; 1426 1427 uint32 maxCount = *_num; 1428 uint32 count = 0; 1429 1430 while (count < maxCount && bufferSize > sizeof(struct dirent)) { 1431 1432 size_t length = bufferSize - sizeof(struct dirent) + 1; 1433 ino_t id; 1434 1435 status_t status = iterator->GetNext(dirent->d_name, &length, &id); 1436 if (status == B_ENTRY_NOT_FOUND) 1437 break; 1438 1439 if (status == B_BUFFER_OVERFLOW) { 1440 // the remaining name buffer length was too small 1441 if (count == 0) 1442 return B_BUFFER_OVERFLOW; 1443 break; 1444 } 1445 1446 if (status != B_OK) 1447 return status; 1448 1449 status = iterator->Next(); 1450 if (status != B_OK && status != B_ENTRY_NOT_FOUND) 1451 return status; 1452 1453 dirent->d_dev = volume->ID(); 1454 dirent->d_ino = id; 1455 dirent->d_reclen = sizeof(struct dirent) + length; 1456 1457 bufferSize -= dirent->d_reclen; 1458 dirent = (struct dirent*)((uint8*)dirent + dirent->d_reclen); 1459 count++; 1460 } 1461 1462 *_num = count; 1463 return B_OK; 1464 } 1465 1466 1467 static status_t 1468 ext2_rewind_dir(fs_volume * /*_volume*/, fs_vnode * /*node*/, void *_cookie) 1469 { 1470 DirectoryIterator *iterator = (DirectoryIterator *)_cookie; 1471 return iterator->Rewind(); 1472 } 1473 1474 1475 static status_t 1476 ext2_close_dir(fs_volume * /*_volume*/, fs_vnode * /*node*/, void * /*_cookie*/) 1477 { 1478 return B_OK; 1479 } 1480 1481 1482 static status_t 1483 ext2_free_dir_cookie(fs_volume *_volume, fs_vnode *_node, void *_cookie) 1484 { 1485 delete (DirectoryIterator*)_cookie; 1486 return B_OK; 1487 } 1488 1489 1490 static status_t 1491 ext2_open_attr_dir(fs_volume *_volume, fs_vnode *_node, void **_cookie) 1492 { 1493 Inode* inode = (Inode*)_node->private_node; 1494 Volume* volume = (Volume*)_volume->private_volume; 1495 TRACE("%s()\n", __FUNCTION__); 1496 1497 if (!(volume->SuperBlock().CompatibleFeatures() & EXT2_FEATURE_EXT_ATTR)) 1498 return ENOSYS; 1499 1500 // on directories too ? 1501 if (!inode->IsFile()) 1502 return EINVAL; 1503 1504 int32 *index = new(std::nothrow) int32; 1505 if (index == NULL) 1506 return B_NO_MEMORY; 1507 *index = 0; 1508 *(int32**)_cookie = index; 1509 return B_OK; 1510 } 1511 1512 static status_t 1513 ext2_close_attr_dir(fs_volume* _volume, fs_vnode* _node, void* cookie) 1514 { 1515 TRACE("%s()\n", __FUNCTION__); 1516 return B_OK; 1517 } 1518 1519 1520 static status_t 1521 ext2_free_attr_dir_cookie(fs_volume* _volume, fs_vnode* _node, void* _cookie) 1522 { 1523 TRACE("%s()\n", __FUNCTION__); 1524 delete (int32 *)_cookie; 1525 return B_OK; 1526 } 1527 1528 1529 static status_t 1530 ext2_read_attr_dir(fs_volume* _volume, fs_vnode* _node, 1531 void* _cookie, struct dirent* dirent, size_t bufferSize, 1532 uint32* _num) 1533 { 1534 Inode* inode = (Inode*)_node->private_node; 1535 int32 index = *(int32 *)_cookie; 1536 Attribute attribute(inode); 1537 TRACE("%s()\n", __FUNCTION__); 1538 1539 size_t length = bufferSize; 1540 status_t status = attribute.Find(index); 1541 if (status == B_ENTRY_NOT_FOUND) { 1542 *_num = 0; 1543 return B_OK; 1544 } else if (status != B_OK) 1545 return status; 1546 1547 status = attribute.GetName(dirent->d_name, &length); 1548 if (status != B_OK) 1549 return B_OK; 1550 1551 Volume* volume = (Volume*)_volume->private_volume; 1552 1553 dirent->d_dev = volume->ID(); 1554 dirent->d_ino = inode->ID(); 1555 dirent->d_reclen = sizeof(struct dirent) + length; 1556 1557 *_num = 1; 1558 *(int32*)_cookie = index + 1; 1559 return B_OK; 1560 } 1561 1562 1563 static status_t 1564 ext2_rewind_attr_dir(fs_volume* _volume, fs_vnode* _node, void* _cookie) 1565 { 1566 *(int32*)_cookie = 0; 1567 TRACE("%s()\n", __FUNCTION__); 1568 return B_OK; 1569 } 1570 1571 1572 /* attribute operations */ 1573 static status_t 1574 ext2_create_attr(fs_volume* _volume, fs_vnode* _node, 1575 const char* name, uint32 type, int openMode, void** _cookie) 1576 { 1577 return EROFS; 1578 } 1579 1580 1581 static status_t 1582 ext2_open_attr(fs_volume* _volume, fs_vnode* _node, const char* name, 1583 int openMode, void** _cookie) 1584 { 1585 TRACE("%s()\n", __FUNCTION__); 1586 1587 Volume* volume = (Volume*)_volume->private_volume; 1588 Inode* inode = (Inode*)_node->private_node; 1589 Attribute attribute(inode); 1590 1591 if (!(volume->SuperBlock().CompatibleFeatures() & EXT2_FEATURE_EXT_ATTR)) 1592 return ENOSYS; 1593 1594 return attribute.Open(name, openMode, (attr_cookie**)_cookie); 1595 } 1596 1597 1598 static status_t 1599 ext2_close_attr(fs_volume* _volume, fs_vnode* _node, 1600 void* cookie) 1601 { 1602 return B_OK; 1603 } 1604 1605 1606 static status_t 1607 ext2_free_attr_cookie(fs_volume* _volume, fs_vnode* _node, 1608 void* cookie) 1609 { 1610 delete (attr_cookie*)cookie; 1611 return B_OK; 1612 } 1613 1614 1615 static status_t 1616 ext2_read_attr(fs_volume* _volume, fs_vnode* _node, void* _cookie, 1617 off_t pos, void* buffer, size_t* _length) 1618 { 1619 TRACE("%s()\n", __FUNCTION__); 1620 1621 attr_cookie* cookie = (attr_cookie*)_cookie; 1622 Inode* inode = (Inode*)_node->private_node; 1623 1624 Attribute attribute(inode, cookie); 1625 1626 return attribute.Read(cookie, pos, (uint8*)buffer, _length); 1627 } 1628 1629 1630 static status_t 1631 ext2_write_attr(fs_volume* _volume, fs_vnode* _node, void* cookie, 1632 off_t pos, const void* buffer, size_t* length) 1633 { 1634 return EROFS; 1635 } 1636 1637 1638 1639 static status_t 1640 ext2_read_attr_stat(fs_volume* _volume, fs_vnode* _node, 1641 void* _cookie, struct stat* stat) 1642 { 1643 attr_cookie* cookie = (attr_cookie*)_cookie; 1644 Inode* inode = (Inode*)_node->private_node; 1645 1646 Attribute attribute(inode, cookie); 1647 1648 return attribute.Stat(*stat); 1649 } 1650 1651 1652 static status_t 1653 ext2_write_attr_stat(fs_volume* _volume, fs_vnode* _node, 1654 void* cookie, const struct stat* stat, int statMask) 1655 { 1656 return EROFS; 1657 } 1658 1659 1660 static status_t 1661 ext2_rename_attr(fs_volume* _volume, fs_vnode* fromVnode, 1662 const char* fromName, fs_vnode* toVnode, const char* toName) 1663 { 1664 return ENOSYS; 1665 } 1666 1667 1668 static status_t 1669 ext2_remove_attr(fs_volume* _volume, fs_vnode* vnode, 1670 const char* name) 1671 { 1672 return ENOSYS; 1673 } 1674 1675 1676 fs_volume_ops gExt2VolumeOps = { 1677 &ext2_unmount, 1678 &ext2_read_fs_info, 1679 &ext2_write_fs_info, 1680 &ext2_sync, 1681 &ext2_get_vnode, 1682 }; 1683 1684 1685 fs_vnode_ops gExt2VnodeOps = { 1686 /* vnode operations */ 1687 &ext2_lookup, 1688 NULL, 1689 &ext2_put_vnode, 1690 &ext2_remove_vnode, 1691 1692 /* VM file access */ 1693 &ext2_can_page, 1694 &ext2_read_pages, 1695 &ext2_write_pages, 1696 1697 NULL, // io() 1698 NULL, // cancel_io() 1699 1700 &ext2_get_file_map, 1701 1702 &ext2_ioctl, 1703 NULL, 1704 NULL, // fs_select 1705 NULL, // fs_deselect 1706 &ext2_fsync, 1707 1708 &ext2_read_link, 1709 &ext2_create_symlink, 1710 1711 &ext2_link, 1712 &ext2_unlink, 1713 &ext2_rename, 1714 1715 &ext2_access, 1716 &ext2_read_stat, 1717 &ext2_write_stat, 1718 NULL, // fs_preallocate 1719 1720 /* file operations */ 1721 &ext2_create, 1722 &ext2_open, 1723 &ext2_close, 1724 &ext2_free_cookie, 1725 &ext2_read, 1726 &ext2_write, 1727 1728 /* directory operations */ 1729 &ext2_create_dir, 1730 &ext2_remove_dir, 1731 &ext2_open_dir, 1732 &ext2_close_dir, 1733 &ext2_free_dir_cookie, 1734 &ext2_read_dir, 1735 &ext2_rewind_dir, 1736 1737 /* attribute directory operations */ 1738 &ext2_open_attr_dir, 1739 &ext2_close_attr_dir, 1740 &ext2_free_attr_dir_cookie, 1741 &ext2_read_attr_dir, 1742 &ext2_rewind_attr_dir, 1743 1744 /* attribute operations */ 1745 NULL, //&ext2_create_attr, 1746 &ext2_open_attr, 1747 &ext2_close_attr, 1748 &ext2_free_attr_cookie, 1749 &ext2_read_attr, 1750 NULL, //&ext2_write_attr, 1751 &ext2_read_attr_stat, 1752 NULL, //&ext2_write_attr_stat, 1753 NULL, //&ext2_rename_attr, 1754 NULL, //&ext2_remove_attr, 1755 }; 1756 1757 1758 static file_system_module_info sExt2FileSystem = { 1759 { 1760 "file_systems/ext2" B_CURRENT_FS_API_VERSION, 1761 0, 1762 NULL, 1763 }, 1764 1765 "ext2", // short_name 1766 "Ext2 File System", // pretty_name 1767 B_DISK_SYSTEM_SUPPORTS_WRITING 1768 | B_DISK_SYSTEM_SUPPORTS_CONTENT_NAME, // DDM flags 1769 1770 // scanning 1771 ext2_identify_partition, 1772 ext2_scan_partition, 1773 ext2_free_identify_partition_cookie, 1774 NULL, // free_partition_content_cookie() 1775 1776 &ext2_mount, 1777 1778 NULL, 1779 }; 1780 1781 1782 module_info *modules[] = { 1783 (module_info *)&sExt2FileSystem, 1784 NULL, 1785 }; 1786