src/bin/bfs_tools/lib/Inode.cpp

   1 /*
   2  * Copyright 2001-2008 pinc Software. All Rights Reserved.
   3  * Released under the terms of the MIT license.
   4  */
   5
   6 //!     BFS Inode classes
   7
   8
   9 #include "Inode.h"
  10 #include "BPlusTree.h"
  11
  12 #include <Directory.h>
  13 #include <SymLink.h>
  14 #include <Entry.h>
  15 #include <Path.h>
  16 #include <String.h>
  17
  18 #include <new>
  19 #include <stdlib.h>
  20 #include <stdio.h>
  21 #include <string.h>
  22
  23
  24 class NodeGetter {
  25         public:
  26                 NodeGetter(Inode* inode)
  27                         :
  28                         fInode(inode)
  29                 {
  30                         fInode->AcquireBuffer();
  31                 }
  32
  33                 ~NodeGetter()
  34                 {
  35                         fInode->ReleaseBuffer();
  36                 }
  37
  38         private:
  39                 Inode*  fInode;
  40 };
  41
  42
  43 //      #pragma mark -
  44
  45
  46 Inode::Inode(Disk* disk, bfs_inode* inode, bool ownBuffer)
  47         :
  48         fDisk(disk),
  49         fInode(inode),
  50         fOwnBuffer(ownBuffer),
  51         fPath(NULL),
  52         fRefCount(1),
  53         fCurrentSmallData(NULL),
  54         fAttributes(NULL),
  55         fAttributeBuffer(NULL)
  56 {
  57         if (inode != NULL)
  58                 fBlockRun = inode->inode_num;
  59 }
  60
  61
  62 Inode::Inode(const Inode& inode)
  63         :
  64         fDisk(inode.fDisk),
  65         fInode(inode.fInode),
  66         fOwnBuffer(false),
  67         fPath(NULL),
  68         fBlockRun(inode.fBlockRun),
  69         fRefCount(1),
  70         fCurrentSmallData(NULL),
  71         fAttributes(NULL),
  72         fAttributeBuffer(NULL)
  73 {
  74 }
  75
  76
  77 Inode::~Inode()
  78 {
  79         _Unset();
  80 }
  81
  82
  83 void
  84 Inode::_Unset()
  85 {
  86         if (fOwnBuffer)
  87                 free(fInode);
  88
  89         fInode = NULL;
  90         fBlockRun.SetTo(0, 0, 0);
  91
  92         free(fPath);
  93         fPath = NULL;
  94
  95         delete fAttributes;
  96         fAttributes = NULL;
  97 }
  98
  99
 100 status_t
 101 Inode::SetTo(bfs_inode *inode)
 102 {
 103         _Unset();
 104
 105         fInode = inode;
 106         fBlockRun = inode->inode_num;
 107         return B_OK;
 108 }
 109
 110
 111 status_t
 112 Inode::InitCheck() const
 113 {
 114         if (!fInode)
 115                 return B_ERROR;
 116
 117         // test inode magic and flags
 118         if (fInode->magic1 != INODE_MAGIC1
 119                 || !(fInode->flags & INODE_IN_USE)
 120                 || fInode->inode_num.length != 1)
 121                 return B_ERROR;
 122
 123         if (fDisk->BlockSize()) {
 124                         // matches known block size?
 125                 if (fInode->inode_size != fDisk->SuperBlock()->inode_size
 126                         // parent resides on disk?
 127                         || fInode->parent.allocation_group > fDisk->SuperBlock()->num_ags
 128                         || fInode->parent.allocation_group < 0
 129                         || fInode->parent.start > (1L << fDisk->SuperBlock()->ag_shift)
 130                         || fInode->parent.length != 1
 131                         // attributes, too?
 132                         || fInode->attributes.allocation_group > fDisk->SuperBlock()->num_ags
 133                         || fInode->attributes.allocation_group < 0
 134                         || fInode->attributes.start > (1L << fDisk->SuperBlock()->ag_shift))
 135                         return B_ERROR;
 136         } else {
 137                 // is inode size one of the valid values?
 138                 switch (fInode->inode_size) {
 139                         case 1024:
 140                         case 2048:
 141                         case 4096:
 142                         case 8192:
 143                                 break;
 144                         default:
 145                                 return B_ERROR;
 146                 }
 147         }
 148         return B_OK;
 149         // is inode on a boundary matching it's size?
 150         //return (Offset() % fInode->inode_size) == 0 ? B_OK : B_ERROR;
 151 }
 152
 153
 154 status_t
 155 Inode::CopyBuffer()
 156 {
 157         if (!fInode)
 158                 return B_ERROR;
 159
 160         bfs_inode *buffer = (bfs_inode *)malloc(fInode->inode_size);
 161         if (!buffer)
 162                 return B_NO_MEMORY;
 163
 164         memcpy(buffer, fInode, fInode->inode_size);
 165         fInode = buffer;
 166         fOwnBuffer = true;
 167         BufferClobbered();
 168                 // this must not be deleted anymore
 169
 170         return B_OK;
 171 }
 172
 173
 174 /*static*/ bool
 175 Inode::_LowMemory()
 176 {
 177         static bigtime_t lastChecked;
 178         static int32 percentUsed;
 179
 180         if (system_time() > lastChecked + 1000000LL) {
 181                 system_info info;
 182                 get_system_info(&info);
 183                 percentUsed = 100 * info.used_pages / info.max_pages;
 184         }
 185
 186         return percentUsed > 75;
 187 }
 188
 189
 190 void
 191 Inode::ReleaseBuffer()
 192 {
 193         if (atomic_add(&fRefCount, -1) != 1)
 194                 return;
 195
 196         if (fOwnBuffer) {
 197                 if (!_LowMemory())
 198                         return;
 199
 200                 free(fInode);
 201                 fInode = NULL;
 202         }
 203 }
 204
 205
 206 status_t
 207 Inode::AcquireBuffer()
 208 {
 209         if (atomic_add(&fRefCount, 1) != 0)
 210                 return B_OK;
 211
 212         if (!fOwnBuffer || fInode != NULL)
 213                 return B_OK;
 214
 215         fInode = (bfs_inode*)malloc(fDisk->BlockSize());
 216         if (fInode == NULL)
 217                 return B_NO_MEMORY;
 218
 219         ssize_t bytesRead = fDisk->ReadAt(Offset(), fInode, fDisk->BlockSize());
 220         if (bytesRead < B_OK)
 221                 return bytesRead;
 222
 223         return B_OK;
 224 }
 225
 226
 227 void
 228 Inode::BufferClobbered()
 229 {
 230         AcquireBuffer();
 231 }
 232
 233
 234 void
 235 Inode::SetParent(const block_run& run)
 236 {
 237         fInode->parent = run;
 238         BufferClobbered();
 239 }
 240
 241
 242 void
 243 Inode::SetBlockRun(const block_run& run)
 244 {
 245         fInode->inode_num = run;
 246         fBlockRun = run;
 247         BufferClobbered();
 248 }
 249
 250
 251 void
 252 Inode::SetMode(uint32 mode)
 253 {
 254         fInode->mode = mode;
 255         BufferClobbered();
 256 }
 257
 258
 259 status_t
 260 Inode::SetName(const char *name)
 261 {
 262         if (name == NULL || *name == '\0')
 263                 return B_BAD_VALUE;
 264
 265         small_data *data = fInode->small_data_start, *nameData = NULL;
 266         BufferClobbered();
 267
 268         while (!data->IsLast(fInode)) {
 269                 if (data->type == FILE_NAME_TYPE
 270                         && data->name_size == FILE_NAME_NAME_LENGTH
 271                         && *data->Name() == FILE_NAME_NAME)
 272                         nameData = data;
 273
 274                 data = data->Next();
 275         }
 276
 277         int32 oldLength = nameData == NULL ? 0 : nameData->data_size;
 278         int32 newLength = strlen(name) + (nameData == NULL ? sizeof(small_data) + 5 : 0);
 279
 280         if ((addr_t)data + newLength - oldLength >= (addr_t)(fInode
 281                         + fDisk->BlockSize()))
 282                 return B_NO_MEMORY;
 283
 284         if (nameData == NULL) {
 285                 memmove(newLength + (uint8 *)fInode->small_data_start,
 286                         fInode->small_data_start,
 287                         (addr_t)data - (addr_t)fInode->small_data_start);
 288                 nameData = fInode->small_data_start;
 289         } else {
 290                 memmove(newLength + (uint8 *)nameData, nameData,
 291                         (addr_t)data - (addr_t)fInode->small_data_start);
 292         }
 293
 294         memset(nameData, 0, sizeof(small_data) + 5 + strlen(name));
 295         nameData->type = FILE_NAME_TYPE;
 296         nameData->name_size = FILE_NAME_NAME_LENGTH;
 297         nameData->data_size = strlen(name);
 298         *nameData->Name() = FILE_NAME_NAME;
 299         strcpy((char *)nameData->Data(),name);
 300
 301         return B_OK;
 302 }
 303
 304
 305 const char *
 306 Inode::Name() const
 307 {
 308         if (InitCheck() != B_OK) {
 309                 puts("Not getting name because node is invalid");
 310                 return NULL;
 311         }
 312         small_data *data = fInode->small_data_start;
 313         while (!data->IsLast(fInode)) {
 314                 if (data->type == FILE_NAME_TYPE
 315                         && data->name_size == FILE_NAME_NAME_LENGTH
 316                         && *data->Name() == FILE_NAME_NAME)
 317                         return (const char *)data->Data();
 318
 319                 data = data->Next();
 320         }
 321         return NULL;
 322 }
 323
 324
 325 status_t
 326 Inode::GetNextSmallData(small_data **smallData)
 327 {
 328         if (!fInode)
 329                 return B_ERROR;
 330
 331         small_data *data = *smallData;
 332
 333         // begin from the start?
 334         if (data == NULL)
 335                 data = fInode->small_data_start;
 336         else
 337                 data = data->Next();
 338
 339         // is already last item?
 340         if (data->IsLast(fInode))
 341                 return B_ENTRY_NOT_FOUND;
 342
 343         *smallData = data;
 344         return B_OK;
 345 }
 346
 347
 348 status_t
 349 Inode::RewindAttributes()
 350 {
 351         fCurrentSmallData = NULL;
 352
 353         if (fAttributes != NULL)
 354                 fAttributes->Rewind();
 355
 356         return B_OK;
 357 }
 358
 359
 360 status_t
 361 Inode::GetNextAttribute(char *name, uint32 *type, void **data, size_t *length)
 362 {
 363         // read attributes out of the small data section
 364
 365         if (fCurrentSmallData == NULL || !fCurrentSmallData->IsLast(fInode)) {
 366                 if (fCurrentSmallData == NULL)
 367                         fCurrentSmallData = fInode->small_data_start;
 368                 else
 369                         fCurrentSmallData = fCurrentSmallData->Next();
 370
 371                 // skip name attribute
 372                 if (!fCurrentSmallData->IsLast(fInode)
 373                         && fCurrentSmallData->name_size == FILE_NAME_NAME_LENGTH
 374                         && *fCurrentSmallData->Name() == FILE_NAME_NAME)
 375                         fCurrentSmallData = fCurrentSmallData->Next();
 376
 377                 if (!fCurrentSmallData->IsLast(fInode)) {
 378                         strncpy(name,fCurrentSmallData->Name(), B_FILE_NAME_LENGTH);
 379                         *type = fCurrentSmallData->type;
 380                         *data = fCurrentSmallData->Data();
 381                         *length = fCurrentSmallData->data_size;
 382
 383                         return B_OK;
 384                 }
 385         }
 386
 387         // read attributes out of the attribute directory
 388
 389         if (Attributes().IsZero())
 390                 return B_ENTRY_NOT_FOUND;
 391
 392         if (fAttributes == NULL)
 393                 fAttributes = (Directory *)Inode::Factory(fDisk, Attributes());
 394
 395         status_t status = fAttributes ? fAttributes->InitCheck() : B_ERROR;
 396         if (status < B_OK)
 397                 return status;
 398
 399         block_run run;
 400         status = fAttributes->GetNextEntry(name, &run);
 401         if (status < B_OK) {
 402                 free(fAttributeBuffer);
 403                 fAttributeBuffer = NULL;
 404                 return status;
 405         }
 406
 407         Attribute *attribute = (Attribute *)Inode::Factory(fDisk, run);
 408         if (attribute == NULL || attribute->InitCheck() < B_OK)
 409                 return B_IO_ERROR;
 410
 411         *type = attribute->Type();
 412
 413         void *buffer = realloc(fAttributeBuffer, attribute->Size());
 414         if (buffer == NULL) {
 415                 free(fAttributeBuffer);
 416                 fAttributeBuffer = NULL;
 417                 delete attribute;
 418                 return B_NO_MEMORY;
 419         }
 420         fAttributeBuffer = buffer;
 421
 422         ssize_t size =  attribute->Read(fAttributeBuffer, attribute->Size());
 423         delete attribute;
 424
 425         *length = size;
 426         *data = fAttributeBuffer;
 427
 428         return size < B_OK ? size : B_OK;
 429 }
 430
 431
 432 status_t
 433 Inode::_FindPath(Inode::Source *source)
 434 {
 435         BString path;
 436
 437         block_run parent = Parent();
 438         while (!parent.IsZero() && parent != fDisk->Root()) {
 439                 Inode *inode;
 440                 if (source)
 441                         inode = source->InodeAt(parent);
 442                 else
 443                         inode = Inode::Factory(fDisk, parent);
 444
 445                 if (inode == NULL
 446                         || inode->InitCheck() < B_OK
 447                         || inode->Name() == NULL
 448                         || !*inode->Name()) {
 449                         BString sub;
 450                         sub << "__recovered " << parent.allocation_group << ":"
 451                                 << (int32)parent.start << "/";
 452                         path.Prepend(sub);
 453
 454                         delete inode;
 455                         break;
 456                 }
 457                 parent = inode->Parent();
 458                 path.Prepend("/");
 459                 path.Prepend(inode->Name());
 460
 461                 delete inode;
 462         }
 463         fPath = strdup(path.String());
 464
 465         return B_OK;
 466 }
 467
 468
 469 const char *
 470 Inode::Path(Inode::Source *source)
 471 {
 472         if (fPath == NULL)
 473                 _FindPath(source);
 474
 475         return fPath;
 476 }
 477
 478
 479 status_t
 480 Inode::CopyTo(const char *root, bool fullPath, Inode::Source *source)
 481 {
 482         if (root == NULL)
 483                 return B_ENTRY_NOT_FOUND;
 484
 485         BString path;
 486
 487         if (fullPath)
 488                 path.Append(Path(source));
 489
 490         if (*(root + strlen(root) - 1) != '/')
 491                 path.Prepend("/");
 492         path.Prepend(root);
 493
 494         return create_directory(path.String(), 0777);
 495 }
 496
 497
 498 status_t
 499 Inode::CopyAttributesTo(BNode *node)
 500 {
 501         // copy attributes
 502
 503         RewindAttributes();
 504
 505         char name[B_FILE_NAME_LENGTH];
 506         const uint32 kMaxBrokenAttributes = 64;
 507                 // sanity max value
 508         uint32 count = 0;
 509         uint32 type;
 510         void *data;
 511         size_t size;
 512
 513         status_t status;
 514         while ((status = GetNextAttribute(name, &type, &data, &size))
 515                         != B_ENTRY_NOT_FOUND) {
 516                 if (status != B_OK) {
 517                         printf("could not open attribute (possibly: %s): %s!\n",
 518                                 name, strerror(status));
 519                         if (count++ > kMaxBrokenAttributes)
 520                                 break;
 521
 522                         continue;
 523                 }
 524
 525                 ssize_t written = node->WriteAttr(name, type, 0, data, size);
 526                 if (written < B_OK) {
 527                         printf("could not write attribute \"%s\": %s\n", name,
 528                                 strerror(written));
 529                 } else if ((size_t)written < size) {
 530                         printf("could only write %ld bytes (from %ld) at attribute \"%s\"\n",
 531                                 written, size, name);
 532                 }
 533         }
 534
 535         // copy stats
 536
 537         node->SetPermissions(fInode->mode);
 538         node->SetOwner(fInode->uid);
 539         node->SetGroup(fInode->gid);
 540         node->SetModificationTime(fInode->last_modified_time >> 16);
 541         node->SetCreationTime(fInode->create_time >> 16);
 542
 543         return B_OK;
 544 }
 545
 546
 547 Inode *
 548 Inode::Factory(Disk *disk, bfs_inode *inode, bool ownBuffer)
 549 {
 550         // attributes (of a file)
 551         if ((inode->mode & (S_ATTR | S_ATTR_DIR)) == S_ATTR)
 552                 return new Attribute(disk, inode, ownBuffer);
 553
 554         // directories, attribute directories, indices
 555         if (S_ISDIR(inode->mode) || inode->mode & S_ATTR_DIR)
 556                 return new Directory(disk, inode, ownBuffer);
 557
 558         // regular files
 559         if (S_ISREG(inode->mode))
 560                 return new File(disk, inode, ownBuffer);
 561
 562         // symlinks (short and link in data-stream)
 563         if (S_ISLNK(inode->mode))
 564                 return new Symlink(disk, inode, ownBuffer);
 565
 566         return NULL;
 567 }
 568
 569
 570 Inode *
 571 Inode::Factory(Disk *disk, block_run run)
 572 {
 573         bfs_inode *inode = (bfs_inode *)malloc(disk->BlockSize());
 574         if (!inode)
 575                 return NULL;
 576
 577         if (disk->ReadAt(disk->ToOffset(run), inode, disk->BlockSize()) <= 0)
 578                 return NULL;
 579
 580         Inode *object = Factory(disk, inode);
 581         if (object == NULL)
 582                 free(inode);
 583
 584         return object;
 585 }
 586
 587
 588 Inode *
 589 Inode::Factory(Disk *disk, Inode *inode, bool copyBuffer)
 590 {
 591         bfs_inode *inodeBuffer = inode->fInode;
 592
 593         if (copyBuffer) {
 594                 bfs_inode *inodeCopy = (bfs_inode *)malloc(inodeBuffer->inode_size);
 595                 if (!inodeCopy)
 596                         return NULL;
 597
 598                 memcpy(inodeCopy, inodeBuffer, inodeBuffer->inode_size);
 599                 inodeBuffer = inodeCopy;
 600         }
 601         return Factory(disk, inodeBuffer, copyBuffer);
 602 }
 603
 604
 605 Inode *
 606 Inode::EmptyInode(Disk *disk, const char *name, int32 mode)
 607 {
 608         bfs_inode *inode = (bfs_inode *)malloc(disk->BlockSize());
 609         if (!inode)
 610                 return NULL;
 611
 612         memset(inode, 0, sizeof(bfs_inode));
 613
 614         inode->magic1 = INODE_MAGIC1;
 615         inode->inode_size = disk->BlockSize();
 616         inode->mode = mode;
 617         inode->flags = INODE_IN_USE | (mode & S_IFDIR ? INODE_LOGGED : 0);
 618
 619         if (name) {
 620                 small_data *data = inode->small_data_start;
 621                 data->type = FILE_NAME_TYPE;
 622                 data->name_size = FILE_NAME_NAME_LENGTH;
 623                 *data->Name() = FILE_NAME_NAME;
 624                 data->data_size = strlen(name);
 625                 strcpy((char *)data->Data(), name);
 626         }
 627
 628         Inode *object = new (std::nothrow) Inode(disk, inode);
 629         if (object == NULL) {
 630                 free(inode);
 631                 return NULL;
 632         }
 633
 634         object->AcquireBuffer();
 635                 // this must not be deleted anymore!
 636         return object;
 637 }
 638
 639
 640 //      #pragma mark -
 641
 642
 643 DataStream::DataStream(Disk *disk, bfs_inode *inode, bool ownBuffer)
 644         : Inode(disk,inode,ownBuffer),
 645         fCurrent(-1),
 646         fPosition(0LL)
 647 {
 648 }
 649
 650
 651 DataStream::DataStream(const Inode &inode)
 652         : Inode(inode),
 653         fCurrent(-1),
 654         fPosition(0LL)
 655 {
 656 }
 657
 658
 659 DataStream::~DataStream()
 660 {
 661 }
 662
 663
 664 status_t
 665 DataStream::FindBlockRun(off_t pos)
 666 {
 667         NodeGetter _(this);
 668
 669         if (pos > fInode->data.size)
 670                 return B_ENTRY_NOT_FOUND;
 671
 672         if (fCurrent < 0)
 673                 fLevel = 0;
 674
 675         fRunBlockEnd = fCurrent >= 0
 676                 ? fRunFileOffset + (fRun.length << fDisk->BlockShift()) : 0LL;
 677
 678         // access in current block run?
 679
 680         if (fCurrent >= 0 && pos >= fRunFileOffset && pos < fRunBlockEnd)
 681                 return B_OK;
 682
 683         // find matching block run
 684
 685         if (fInode->data.max_direct_range > 0
 686                 && pos >= fInode->data.max_direct_range) {
 687                 if (fInode->data.max_double_indirect_range > 0
 688                         && pos >= fInode->data.max_indirect_range) {
 689                         // read from double indirect blocks
 690
 691                         //printf("find double indirect block: %ld,%d!\n",fInode->data.double_indirect.allocation_group,fInode->data.double_indirect.start);
 692                         block_run *indirect = (block_run *)fDisk->ReadBlockRun(fInode->data.double_indirect);
 693                         if (indirect == NULL)
 694                                 return B_ERROR;
 695
 696                         off_t start = pos - fInode->data.max_indirect_range;
 697                         int32 indirectSize = fDisk->BlockSize() * 16 * (fDisk->BlockSize() / sizeof(block_run));
 698                         int32 directSize = fDisk->BlockSize() * 4;
 699                         int32 index = start / indirectSize;
 700
 701                         //printf("\tstart = %Ld, indirectSize = %ld, directSize = %ld, index = %ld\n",start,indirectSize,directSize,index);
 702                         //printf("\tlook for indirect block at %ld,%d\n",indirect[index].allocation_group,indirect[index].start);
 703                         indirect = (block_run *)fDisk->ReadBlockRun(indirect[index]);
 704                         if (indirect == NULL)
 705                                 return B_ERROR;
 706
 707                         fCurrent = (start % indirectSize) / directSize;
 708                         fRunFileOffset = fInode->data.max_indirect_range + (index * indirectSize) + (fCurrent * directSize);
 709                         fRunBlockEnd = fRunFileOffset + directSize;
 710                         fRun = indirect[fCurrent];
 711                         //printf("\tfCurrent = %ld, fRunFileOffset = %Ld, fRunBlockEnd = %Ld, fRun = %ld,%d\n",fCurrent,fRunFileOffset,fRunBlockEnd,fRun.allocation_group,fRun.start);
 712                 } else {
 713                         // access from indirect blocks
 714
 715                         block_run *indirect = (block_run *)fDisk->ReadBlockRun(fInode->data.indirect);
 716                         if (!indirect)
 717                                 return B_ERROR;
 718
 719                         int32 indirectRuns = (fInode->data.indirect.length << fDisk->BlockShift()) / sizeof(block_run);
 720
 721                         if (fLevel != 1 || pos < fRunFileOffset) {
 722                                 fRunBlockEnd = fInode->data.max_direct_range;
 723                                 fCurrent = -1;
 724                                 fLevel = 1;
 725                         }
 726
 727                         while (++fCurrent < indirectRuns) {
 728                                 if (indirect[fCurrent].IsZero())
 729                                         break;
 730
 731                                 fRunFileOffset = fRunBlockEnd;
 732                                 fRunBlockEnd += indirect[fCurrent].length << fDisk->BlockShift();
 733                                 if (fRunBlockEnd > pos)
 734                                         break;
 735                         }
 736                         if (fCurrent == indirectRuns || indirect[fCurrent].IsZero())
 737                                 return B_ERROR;
 738
 739                         fRun = indirect[fCurrent];
 740                         //printf("reading from indirect block: %ld,%d\n",fRun.allocation_group,fRun.start);
 741                         //printf("### indirect-run[%ld] = (%ld,%d,%d), offset = %Ld\n",fCurrent,fRun.allocation_group,fRun.start,fRun.length,fRunFileOffset);
 742                 }
 743         } else {
 744                 // access from direct blocks
 745                 if (fRunFileOffset > pos) {
 746                         fRunBlockEnd = 0LL;
 747                         fCurrent = -1;
 748                 }
 749                 fLevel = 0;
 750
 751                 while (++fCurrent < NUM_DIRECT_BLOCKS) {
 752                         if (fInode->data.direct[fCurrent].IsZero())
 753                                 break;
 754
 755                         fRunFileOffset = fRunBlockEnd;
 756                         fRunBlockEnd += fInode->data.direct[fCurrent].length << fDisk->BlockShift();
 757                         if (fRunBlockEnd > pos)
 758                                 break;
 759                 }
 760                 if (fCurrent == NUM_DIRECT_BLOCKS || fInode->data.direct[fCurrent].IsZero())
 761                         return B_ERROR;
 762
 763                 fRun = fInode->data.direct[fCurrent];
 764                 //printf("### run[%ld] = (%ld,%d,%d), offset = %Ld\n",fCurrent,fRun.allocation_group,fRun.start,fRun.length,fRunFileOffset);
 765         }
 766         return B_OK;
 767 }
 768
 769
 770 ssize_t
 771 DataStream::ReadAt(off_t pos, void *buffer, size_t size)
 772 {
 773         NodeGetter _(this);
 774
 775         //printf("DataStream::ReadAt(pos = %Ld,buffer = %p,size = %ld);\n",pos,buffer,size);
 776         // truncate size to read
 777         if (pos + (off_t)size > fInode->data.size) {
 778                 if (pos > fInode->data.size)    // reading outside the file
 779                         return B_ERROR;
 780
 781                 size = fInode->data.size - pos;
 782                 if (!size)      // there is nothing left to read
 783                         return 0;
 784         }
 785         ssize_t read = 0;
 786
 787         //printf("### read %ld bytes at %Ld\n",size,pos);
 788         while (size > 0) {
 789                 status_t status = FindBlockRun(pos);
 790                 if (status < B_OK)
 791                         return status;
 792
 793                 ssize_t bytes = min_c((off_t)size, fRunBlockEnd - pos);
 794
 795                 //printf("### read %ld bytes from %Ld\n### --\n",bytes,fDisk->ToOffset(fRun) + pos - fRunFileOffset);
 796                 bytes = fDisk->ReadAt(fDisk->ToOffset(fRun) + pos - fRunFileOffset,
 797                         buffer, bytes);
 798                 if (bytes <= 0) {
 799                         if (bytes == 0) {
 800                                 printf("could not read bytes at: %" B_PRId32 ",%d\n",
 801                                         fRun.allocation_group, fRun.start);
 802                         }
 803                         return bytes < 0 ? bytes : B_BAD_DATA;
 804                 }
 805
 806                 buffer = (void *)((uint8 *)buffer + bytes);
 807                 size -= bytes;
 808                 pos += bytes;
 809                 read += bytes;
 810         }
 811         if (read >= 0)
 812                 return read;
 813
 814         return B_IO_ERROR;
 815 }
 816
 817
 818 ssize_t
 819 DataStream::WriteAt(off_t pos, const void *buffer, size_t size)
 820 {
 821         NodeGetter _(this);
 822
 823         // FIXME: truncate size -> should enlargen the file
 824         if (pos + (off_t)size > fInode->data.size) {
 825                 if (pos > fInode->data.size)    // writing outside the file
 826                         return B_ERROR;
 827
 828                 size = fInode->data.size - pos;
 829                 if (!size)      // there is nothing left to write
 830                         return 0;
 831         }
 832         ssize_t written = 0;
 833
 834         //printf("### write %ld bytes at %Ld\n",size,pos);
 835         while (size > 0) {
 836                 status_t status = FindBlockRun(pos);
 837                 if (status < B_OK)
 838                         return status;
 839
 840                 ssize_t bytes = min_c((off_t)size, fRunBlockEnd - pos);
 841
 842                 //printf("### write %ld bytes to %Ld\n### --\n",bytes,fDisk->ToOffset(fRun) + pos - fRunFileOffset);
 843                 bytes = fDisk->WriteAt(fDisk->ToOffset(fRun) + pos - fRunFileOffset,buffer,bytes);
 844                 if (bytes < 0)
 845                         return bytes;
 846
 847                 buffer = (void *)((uint8 *)buffer + bytes);
 848                 size -= bytes;
 849                 pos += bytes;
 850                 written += bytes;
 851         }
 852         if (written >= 0)
 853                 return written;
 854
 855         return B_IO_ERROR;
 856 }
 857
 858
 859 off_t
 860 DataStream::Seek(off_t position, uint32 seekMode)
 861 {
 862         NodeGetter _(this);
 863
 864         if (seekMode == SEEK_SET)
 865                 fPosition = position;
 866         else if (seekMode == SEEK_END)
 867                 fPosition = fInode->data.size + position;
 868         else
 869                 fPosition += position;
 870
 871         return fPosition;
 872 }
 873
 874
 875 off_t
 876 DataStream::Position() const
 877 {
 878         return fPosition;
 879 }
 880
 881
 882 status_t
 883 DataStream::SetSize(off_t size)
 884 {
 885         NodeGetter _(this);
 886
 887         // FIXME: not yet supported
 888         if (size > fInode->data.size || size > fInode->data.max_direct_range)
 889                 return B_ERROR;
 890
 891         if (size == fInode->data.size)
 892                 return B_OK;
 893
 894         BufferClobbered();
 895
 896         fInode->data.size = size;
 897         fInode->data.max_direct_range = size;
 898         fInode->data.max_indirect_range = 0;
 899         fInode->data.max_double_indirect_range = 0;
 900
 901         for (int32 i = 0;i < NUM_DIRECT_BLOCKS;i++) {
 902                 if (size <= 0)
 903                         fInode->data.direct[i].SetTo(0, 0, 0);
 904                 else if ((fInode->data.direct[i].length << fDisk->BlockShift()) >= size) {
 905                         off_t blocks = (size + fDisk->BlockSize() - 1) / fDisk->BlockSize();
 906                         fInode->data.direct[i].length = blocks;
 907                         size = 0;
 908                 } else
 909                         size -= fInode->data.direct[i].length << fDisk->BlockShift();
 910         }
 911
 912         return B_OK;
 913 }
 914
 915
 916 //      #pragma mark -
 917
 918
 919 File::File(Disk *disk, bfs_inode *inode,bool ownBuffer)
 920         : DataStream(disk,inode,ownBuffer)
 921 {
 922 }
 923
 924
 925 File::File(const Inode &inode)
 926         : DataStream(inode)
 927 {
 928 }
 929
 930
 931 File::~File()
 932 {
 933 }
 934
 935
 936 status_t
 937 File::InitCheck() const
 938 {
 939         status_t status = DataStream::InitCheck();
 940         if (status == B_OK)
 941                 return IsFile() ? B_OK : B_ERROR;
 942
 943         return status;
 944 }
 945
 946
 947 status_t
 948 File::CopyTo(const char *root, bool fullPath, Inode::Source *source)
 949 {
 950         status_t status = Inode::CopyTo(root, fullPath, source);
 951         if (status < B_OK)
 952                 return status;
 953
 954         BPath path(root);
 955         if (fullPath && Path(source))
 956                 path.Append(Path(source));
 957
 958         char *name = (char *)Name();
 959         if (name != NULL) {
 960                 // changes the filename in the inode buffer (for deleted entries)
 961                 if (!*name)
 962                         *name = '_';
 963                 path.Append(name);
 964         } else {
 965                 BString sub;
 966                 sub << "__untitled " << BlockRun().allocation_group << ":"
 967                         << (int32)BlockRun().start;
 968                 path.Append(sub.String());
 969         }
 970         printf("%" B_PRId32 ",%d -> %s\n", BlockRun().allocation_group,
 971                 BlockRun().start, path.Path());
 972
 973         BFile file;
 974         status = file.SetTo(path.Path(),
 975                 B_WRITE_ONLY | B_CREATE_FILE | B_FAIL_IF_EXISTS);
 976         if (status < B_OK)
 977                 return status;
 978
 979         char buffer[fDisk->BlockSize()];
 980         ssize_t size;
 981         Seek(0, SEEK_SET);
 982
 983         while ((size = Read(buffer, sizeof(buffer))) > B_OK) {
 984                 ssize_t written = file.Write(buffer, size);
 985                 if (written < B_OK)
 986                         return written;
 987         }
 988
 989         return CopyAttributesTo(&file);
 990 }
 991
 992
 993 //      #pragma mark -
 994
 995
 996 Attribute::Attribute(Disk *disk, bfs_inode *inode, bool ownBuffer)
 997         : File(disk, inode, ownBuffer)
 998 {
 999 }
1000
1001
1002 Attribute::Attribute(const Inode &inode)
1003         : File(inode)
1004 {
1005 }
1006
1007
1008 Attribute::~Attribute()
1009 {
1010 }
1011
1012
1013 status_t
1014 Attribute::InitCheck() const
1015 {
1016         status_t status = DataStream::InitCheck();
1017         if (status == B_OK)
1018                 return IsAttribute() ? B_OK : B_ERROR;
1019
1020         return status;
1021 }
1022
1023
1024 status_t
1025 Attribute::CopyTo(const char */*path*/, bool /*fullPath*/,
1026         Inode::Source */*source*/)
1027 {
1028         // files and directories already copy all attributes
1029
1030         // eventually, this method should be implemented to recover lost
1031         // attributes on the disk
1032
1033         return B_OK;
1034 }
1035
1036
1037 //      #pragma mark -
1038
1039
1040 Directory::Directory(Disk *disk, bfs_inode *inode, bool ownBuffer)
1041         : DataStream(disk, inode, ownBuffer),
1042         fTree(NULL)
1043 {
1044 }
1045
1046
1047 Directory::Directory(const Inode &inode)
1048         : DataStream(inode),
1049         fTree(NULL)
1050 {
1051 }
1052
1053
1054 Directory::~Directory()
1055 {
1056         delete fTree;
1057 }
1058
1059
1060 status_t
1061 Directory::InitCheck() const
1062 {
1063         status_t status = DataStream::InitCheck();
1064         if (status == B_OK)
1065                 return (IsDirectory() || IsAttributeDirectory()) ? B_OK : B_ERROR;
1066
1067         return status;
1068 }
1069
1070
1071 status_t
1072 Directory::CopyTo(const char *root, bool fullPath, Inode::Source *source)
1073 {
1074         // don't copy attributes or indices
1075         // the recovery program should make empty files to recover lost attributes
1076         if (IsAttributeDirectory() || IsIndex())
1077                 return B_OK;
1078
1079         status_t status = Inode::CopyTo(root, fullPath, source);
1080         if (status < B_OK)
1081                 return status;
1082
1083         BPath path(root);
1084         if (fullPath && Path(source))
1085                 path.Append(Path(source));
1086
1087         char *name = (char *)Name();
1088         if (name != NULL) {
1089                 // changes the filename in the inode buffer (for deleted entries)
1090                 if (!*name)
1091                         *name = '_';
1092                 path.Append(name);
1093         } else {
1094                 // create unique name
1095                 BString sub;
1096                 sub << "__untitled " << BlockRun().allocation_group << ":"
1097                         << (int32)BlockRun().start;
1098                 path.Append(sub.String());
1099         }
1100
1101         BEntry entry(path.Path());
1102         BDirectory directory;
1103         if ((status = entry.GetParent(&directory)) < B_OK)
1104                 return status;
1105
1106         status = directory.CreateDirectory(path.Leaf(), NULL);
1107         if (status < B_OK && status != B_FILE_EXISTS)
1108                 return status;
1109
1110         if ((status = directory.SetTo(&entry)) < B_OK)
1111                 return status;
1112
1113         return CopyAttributesTo(&directory);
1114 }
1115
1116
1117 status_t
1118 Directory::Rewind()
1119 {
1120         if (!fTree) {
1121                 status_t status = CreateTree();
1122                 if (status < B_OK)
1123                         return status;
1124         }
1125         return fTree->Rewind();
1126 }
1127
1128
1129 status_t
1130 Directory::GetNextEntry(char *name, block_run *run)
1131 {
1132         status_t status;
1133
1134         if (!fTree) {
1135                 if ((status = Rewind()) < B_OK)
1136                         return status;
1137         }
1138         uint16 length;
1139         off_t offset;
1140
1141         if ((status = fTree->GetNextEntry(name, &length, B_FILE_NAME_LENGTH - 1,
1142                         &offset)) < B_OK)
1143                 return status;
1144
1145         *run = fDisk->ToBlockRun(offset);
1146
1147         return B_OK;
1148 }
1149
1150
1151 status_t
1152 Directory::GetNextEntry(block_run *run)
1153 {
1154         char name[B_FILE_NAME_LENGTH];
1155
1156         return GetNextEntry(name, run);
1157 }
1158
1159
1160 status_t
1161 Directory::Contains(const block_run *run)
1162 {
1163         status_t status;
1164
1165         if (!fTree) {
1166                 if ((status = Rewind()) < B_OK)
1167                         return status;
1168         }
1169
1170         block_run searchRun;
1171         while (GetNextEntry(&searchRun) == B_OK) {
1172                 if (searchRun == *run)
1173                         return B_OK;
1174         }
1175
1176         return B_ENTRY_NOT_FOUND;
1177 }
1178
1179
1180 status_t
1181 Directory::Contains(const Inode *inode)
1182 {
1183         status_t status;
1184
1185         if (!fTree) {
1186                 if ((status = CreateTree()) < B_OK)
1187                         return status;
1188         }
1189
1190         off_t value;
1191         const char *name = inode->Name();
1192         status = B_ENTRY_NOT_FOUND;
1193
1194         if (name && (status = fTree->Find((uint8 *)name, (uint16)strlen(name),
1195                         &value)) == B_OK) {
1196                 if (fDisk->ToBlockRun(value) == inode->InodeBuffer()->inode_num)
1197                         return B_OK;
1198
1199                 printf("inode address do not match (%s)!\n", inode->Name());
1200         }
1201
1202         if (status != B_OK && status != B_ENTRY_NOT_FOUND)
1203                 return status;
1204
1205         return Contains(&inode->InodeBuffer()->inode_num);
1206 }
1207
1208
1209 status_t
1210 Directory::FindEntry(const char *name, block_run *run)
1211 {
1212         status_t status;
1213
1214         if (!name)
1215                 return B_BAD_VALUE;
1216
1217         if (!fTree) {
1218                 if ((status = CreateTree()) < B_OK)
1219                         return status;
1220         }
1221
1222         off_t value;
1223
1224         if ((status = fTree->Find((uint8 *)name, (uint16)strlen(name),
1225                         &value)) >= B_OK) {
1226                 if (run)
1227                         *run = fDisk->ToBlockRun(value);
1228                 return B_OK;
1229         }
1230         return status;
1231 }
1232
1233
1234 status_t
1235 Directory::AddEntry(Inode *inode)
1236 {
1237         status_t status;
1238         bool created = false;
1239
1240         if (!fTree) {
1241                 status = CreateTree();
1242                 if (status == B_OK)
1243                         status = fTree->Validate();
1244
1245                 if (status == B_BAD_DATA) {
1246                         //puts("bplustree corrupted!");
1247                         fTree = new BPlusTree(BPLUSTREE_STRING_TYPE, BPLUSTREE_NODE_SIZE,
1248                                 false);
1249                         if ((status = fTree->InitCheck()) < B_OK) {
1250                                 delete fTree;
1251                                 fTree = NULL;
1252                         } else
1253                                 created = true;
1254                 }
1255
1256                 if (status < B_OK)
1257                         return status;
1258         }
1259         // keep all changes in memory
1260         fTree->SetHoldChanges(true);
1261
1262         if (created) {
1263                 // add . and ..
1264                 fTree->Insert(".", Block());
1265                 fTree->Insert("..", fDisk->ToBlock(Parent()));
1266         }
1267
1268         if (inode->Flags() & INODE_DELETED)
1269                 return B_ENTRY_NOT_FOUND;
1270
1271         BString name = inode->Name();
1272         if (name == "") {
1273                 name << "__file " << inode->BlockRun().allocation_group << ":"
1274                         << (int32)inode->BlockRun().start;
1275         }
1276
1277         return fTree->Insert(name.String(), inode->Block());
1278 }
1279
1280
1281 status_t
1282 Directory::CreateTree()
1283 {
1284         fTree = new BPlusTree(this);
1285
1286         status_t status = fTree->InitCheck();
1287         if (status < B_OK) {
1288                 delete fTree;
1289                 fTree = NULL;
1290                 return status;
1291         }
1292         return B_OK;
1293 }
1294
1295
1296 status_t
1297 Directory::GetTree(BPlusTree **tree)
1298 {
1299         if (!fTree) {
1300                 status_t status = CreateTree();
1301                 if (status < B_OK)
1302                         return status;
1303         }
1304         *tree = fTree;
1305         return B_OK;
1306 }
1307
1308
1309 //      #pragma mark -
1310
1311
1312 Symlink::Symlink(Disk *disk, bfs_inode *inode,bool ownBuffer)
1313         : Inode(disk,inode,ownBuffer)
1314 {
1315 }
1316
1317
1318 Symlink::Symlink(const Inode &inode)
1319         : Inode(inode)
1320 {
1321 }
1322
1323
1324 Symlink::~Symlink()
1325 {
1326 }
1327
1328
1329 status_t
1330 Symlink::InitCheck() const
1331 {
1332         status_t status = Inode::InitCheck();
1333         if (status == B_OK)
1334                 return IsSymlink() ? B_OK : B_ERROR;
1335
1336         return status;
1337 }
1338
1339
1340 status_t
1341 Symlink::CopyTo(const char *root, bool fullPath,Inode::Source *source)
1342 {
1343         status_t status = Inode::CopyTo(root,fullPath,source);
1344         if (status < B_OK)
1345                 return status;
1346
1347         BPath path(root);
1348         if (fullPath && Path(source))
1349                 path.Append(Path(source));
1350
1351         char *name = (char *)Name();
1352         if (name != NULL) {
1353                 // changes the filename in the inode buffer (for deleted entries)
1354                 if (!*name)
1355                         *name = '_';
1356                 path.Append(name);
1357         } else {
1358                 // create unique name
1359                 BString sub;
1360                 sub << "__symlink " << BlockRun().allocation_group << ":"
1361                         << (int32)BlockRun().start;
1362                 path.Append(sub.String());
1363         }
1364
1365         BEntry entry(path.Path());
1366         BDirectory directory;
1367         if ((status = entry.GetParent(&directory)) < B_OK)
1368                 return status;
1369
1370         char to[2048];
1371         if (LinksTo(to,sizeof(to)) < B_OK)
1372                 return B_ERROR;
1373
1374         BSymLink link;
1375         status = directory.CreateSymLink(path.Leaf(),to,&link);
1376         if (status < B_OK && status != B_FILE_EXISTS)
1377                 return status;
1378
1379         if ((status = link.SetTo(&entry)) < B_OK)
1380                 return status;
1381
1382         return CopyAttributesTo(&link);
1383 }
1384
1385
1386 status_t
1387 Symlink::LinksTo(char *to,size_t maxLength)
1388 {
1389         if ((fInode->flags & INODE_LONG_SYMLINK) == 0) {
1390                 strcpy(to,fInode->short_symlink);
1391                 return B_OK;
1392         }
1393
1394         DataStream stream(*this);
1395         status_t status = stream.InitCheck();
1396         if (status < B_OK)
1397                 return status;
1398
1399         status = stream.Read(to,maxLength);
1400
1401         return status < B_OK ? status : B_OK;
1402 }
1403