daily pastebin goal
1%
SHARE
TWEET

Untitled

a guest Jun 5th, 2017 66 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. Index: src/add-ons/kernel/file_systems/ext2/InodeJournal.h
  2. ===================================================================
  3. --- src/add-ons/kernel/file_systems/ext2/InodeJournal.h (revision 0)
  4. +++ src/add-ons/kernel/file_systems/ext2/InodeJournal.h (revision 0)
  5. @@ -0,0 +1,29 @@
  6. +/*
  7. + * Copyright 2001-2010, Haiku Inc. All rights reserved.
  8. + * This file may be used under the terms of the MIT License.
  9. + *
  10. + * Authors:
  11. + *     Janito V. Ferreira Filho
  12. + */
  13. +#ifndef INODEJOURNAL_H
  14. +#define INODEJOURNAL_H
  15. +
  16. +
  17. +#include "Inode.h"
  18. +#include "Journal.h"
  19. +
  20. +
  21. +class InodeJournal : public Journal {
  22. +public:
  23. +                       InodeJournal(Inode* inode);
  24. +                       ~InodeJournal();
  25. +
  26. +           status_t    InitCheck();
  27. +          
  28. +           status_t    MapBlock(uint32 logical, uint32& physical);
  29. +private:
  30. +           Inode*      fInode;
  31. +           status_t    fInitStatus;
  32. +};
  33. +
  34. +#endif // INODEJOURNAL_H
  35. Index: src/add-ons/kernel/file_systems/ext2/InodeAllocator.cpp
  36. ===================================================================
  37. --- src/add-ons/kernel/file_systems/ext2/InodeAllocator.cpp (revision 0)
  38. +++ src/add-ons/kernel/file_systems/ext2/InodeAllocator.cpp (revision 0)
  39. @@ -0,0 +1,110 @@
  40. +/*
  41. + * Copyright 2001-2010, Haiku Inc. All rights reserved.
  42. + * This file may be used under the terms of the MIT License.
  43. + *
  44. + * Authors:
  45. + *     Janito V. Ferreira Filho
  46. + */
  47. +
  48. +#include "InodeAllocator.h"
  49. +
  50. +#include <util/AutoLock.h>
  51. +
  52. +#include "BitmapBlock.h"
  53. +#include "Volume.h"
  54. +
  55. +
  56. +//#define TRACE_EXT2
  57. +#ifdef TRACE_EXT2
  58. +#  define TRACE(x...) dprintf("\33[34mext2:\33[0m " x)
  59. +#else
  60. +#  define TRACE(x...) ;
  61. +#endif
  62. +
  63. +
  64. +InodeAllocator::InodeAllocator(Volume* volume)
  65. +   :
  66. +   fVolume(volume)
  67. +{
  68. +   mutex_init(&fLock, "ext2 inode allocator");
  69. +}
  70. +
  71. +
  72. +InodeAllocator::~InodeAllocator()
  73. +{
  74. +   mutex_destroy(&fLock);
  75. +}
  76. +
  77. +
  78. +status_t
  79. +InodeAllocator::New(Transaction& transaction, uint32 preferredBlockGroup,
  80. +   ino_t& id)
  81. +{
  82. +   MutexLocker lock(fLock);
  83. +
  84. +   uint32 blockGroup = preferredBlockGroup;
  85. +   uint32 lastBlockGroup = fVolume->NumGroups() - 1;
  86. +
  87. +   for (int i = 0; i < 2; ++i) {
  88. +       for (; blockGroup < lastBlockGroup; ++blockGroup) {
  89. +           ext2_block_group* group;
  90. +
  91. +           status_t status = fVolume->GetBlockGroup(blockGroup, &group);
  92. +           if (status != B_OK)
  93. +               return status;
  94. +
  95. +           if (group->FreeInodes() != 0) {
  96. +               return _MarkInBitmap(transaction, group->InodeBitmap(),
  97. +                   blockGroup, fVolume->InodesPerGroup(), id);
  98. +           }
  99. +       }
  100. +
  101. +       if (i == 0) {
  102. +           ext2_block_group* group;
  103. +
  104. +           status_t status = fVolume->GetBlockGroup(blockGroup, &group);
  105. +           if (status != B_OK)
  106. +               return status;
  107. +
  108. +           if (group->FreeInodes() != 0) {
  109. +               return _MarkInBitmap(transaction, group->InodeBitmap(),
  110. +                   blockGroup, fVolume->NumInodes()
  111. +                       - blockGroup * fVolume->InodesPerGroup(), id);
  112. +           }
  113. +       }
  114. +
  115. +       blockGroup = 0;
  116. +       lastBlockGroup = preferredBlockGroup;
  117. +   }
  118. +
  119. +   return B_DEVICE_FULL;
  120. +}
  121. +
  122. +
  123. +status_t
  124. +InodeAllocator::_MarkInBitmap(Transaction& transaction, uint32 bitmapBlock,
  125. +   uint32 blockGroup, uint32 numInodes, ino_t& id)
  126. +{
  127. +   BitmapBlock inodeBitmap(fVolume, numInodes);
  128. +
  129. +   if (!inodeBitmap.SetToWritable(transaction, bitmapBlock)) {
  130. +       TRACE("Unable to open inode bitmap (block number: %lu) for block group "
  131. +           "%lu\n", bitmapBlock, blockGroup);
  132. +       return B_IO_ERROR;
  133. +   }
  134. +
  135. +   uint32 pos = 0;
  136. +   inodeBitmap.FindNextUnmarked(pos);
  137. +
  138. +   if (pos == inodeBitmap.NumBits()) {
  139. +       TRACE("Even though the block group %lu indicates there are free "
  140. +           "inodes, no unmarked bit was found in the inode bitmap at block "
  141. +           "%lu.", blockGroup, bitmapBlock);
  142. +       return B_ERROR;
  143. +   }
  144. +
  145. +   inodeBitmap.Mark(pos, true);
  146. +   id = pos + blockGroup * fVolume->InodesPerGroup();
  147. +
  148. +   return B_OK;
  149. +}
  150.  
  151. Property changes on: src/add-ons/kernel/file_systems/ext2/InodeAllocator.cpp
  152. ___________________________________________________________________
  153. Added: svn:executable
  154.    + *
  155.  
  156. Index: src/add-ons/kernel/file_systems/ext2/BlockAllocator.h
  157. ===================================================================
  158. --- src/add-ons/kernel/file_systems/ext2/BlockAllocator.h   (revision 0)
  159. +++ src/add-ons/kernel/file_systems/ext2/BlockAllocator.h   (revision 0)
  160. @@ -0,0 +1,53 @@
  161. +/*
  162. + * Copyright 2001-2010, Haiku Inc. All rights reserved.
  163. + * This file may be used under the terms of the MIT License.
  164. + *
  165. + * Authors:
  166. + *     Janito V. Ferreira Filho
  167. + */
  168. +#ifndef BLOCKALLOCATOR_H
  169. +#define BLOCKALLOCATOR_H
  170. +
  171. +#include <lock.h>
  172. +
  173. +#include "Transaction.h"
  174. +
  175. +
  176. +class AllocationBlockGroup;
  177. +class Inode;
  178. +class Volume;
  179. +
  180. +
  181. +class BlockAllocator {
  182. +public:
  183. +                       BlockAllocator(Volume* volume);
  184. +                       ~BlockAllocator();
  185. +
  186. +           status_t    Initialize();
  187. +
  188. +           status_t    AllocateBlocks(Transaction& transaction,
  189. +                           uint32 minimum, uint32 maximum, uint32& blockGroup,
  190. +                           uint32& start, uint32& length);
  191. +           status_t    Allocate(Transaction& transaction, Inode* inode,
  192. +                           off_t numBlocks, uint32 minimum, uint32& start,
  193. +                           uint32& length);
  194. +           status_t    Free(Transaction& transaction, uint32 start,
  195. +                           uint32 length);
  196. +
  197. +           uint32      FreeBlocks();
  198. +
  199. +protected:
  200. +   static  status_t    _Initialize(BlockAllocator* allocator);
  201. +
  202. +
  203. +           Volume*     fVolume;
  204. +           mutex       fLock;
  205. +
  206. +           AllocationBlockGroup* fGroups;
  207. +           uint32      fBlocksPerGroup;
  208. +           uint32      fNumBlocks;
  209. +           uint32      fNumGroups;
  210. +           uint32      fFirstBlock;
  211. +};
  212. +
  213. +#endif // BLOCKALLOCATOR_H
  214.  
  215. Property changes on: src/add-ons/kernel/file_systems/ext2/BlockAllocator.h
  216. ___________________________________________________________________
  217. Added: svn:executable
  218.    + *
  219.  
  220. Index: src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp
  221. ===================================================================
  222. --- src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp (revision 37534)
  223. +++ src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.cpp (working copy)
  224. @@ -11,6 +11,7 @@
  225.  
  226.  #include <new>
  227.  
  228. +#include "CachedBlock.h"
  229.  #include "HTree.h"
  230.  #include "IndexedDirectoryIterator.h"
  231.  #include "Inode.h"
  232. @@ -27,81 +28,92 @@
  233.  
  234.  HTreeEntryIterator::HTreeEntryIterator(off_t offset, Inode* directory)
  235.     :
  236. +   fDirectory(directory),
  237. +   fVolume(directory->GetVolume()),
  238.     fHasCollision(false),
  239. -   fDirectory(directory),
  240. -   fOffset(offset),
  241. +   fBlockSize(directory->GetVolume()->BlockSize()),
  242.     fParent(NULL),
  243.     fChild(NULL)
  244.  {
  245. -   fBlockSize = fDirectory->GetVolume()->BlockSize();
  246. +   fInitStatus = fDirectory->FindBlock(offset, fBlockNum);
  247. +  
  248. +   if (fInitStatus == B_OK) {
  249. +       fFirstEntry = offset % fBlockSize / sizeof(HTreeEntry);
  250. +       fCurrentEntry = fFirstEntry;
  251. +   }
  252. +
  253. +   TRACE("HTreeEntryIterator::HTreeEntryIterator() block %lu entry no. %lu\n",
  254. +       fBlockNum, (uint32)fCurrentEntry);
  255.  }
  256.  
  257.  
  258.  HTreeEntryIterator::HTreeEntryIterator(uint32 block, uint32 blockSize,
  259.     Inode* directory, HTreeEntryIterator* parent, bool hasCollision)
  260.     :
  261. +   fDirectory(directory),
  262. +   fVolume(directory->GetVolume()),
  263.     fHasCollision(hasCollision),
  264. +   fFirstEntry(1),
  265. +   fCurrentEntry(1),
  266.     fBlockSize(blockSize),
  267. -   fDirectory(directory),
  268. -   fOffset(block * blockSize + sizeof(HTreeFakeDirEntry)),
  269. +   fBlockNum(block),
  270.     fParent(parent),
  271.     fChild(NULL)
  272.  {
  273. -   TRACE("HTreeEntryIterator::HTreeEntryIterator() block %ld offset %Lx\n",
  274. -       block, fOffset);
  275. +   // fCurrentEntry is initialized to 1 to skip the fake directory entry
  276. +   fInitStatus = B_OK;
  277. +
  278. +   TRACE("HTreeEntryIterator::HTreeEntryIterator() block %lu\n", block);
  279.  }
  280.  
  281.  
  282.  status_t
  283.  HTreeEntryIterator::Init()
  284.  {
  285. -   size_t length = sizeof(HTreeCountLimit);
  286. -   HTreeCountLimit countLimit;
  287. +   TRACE("HTreeEntryIterator::Init() first entry: %lu\n",
  288. +       (uint32)fFirstEntry);
  289.    
  290. -   status_t status = fDirectory->ReadAt(fOffset, (uint8*)&countLimit,
  291. -       &length);
  292. -  
  293. -   if (status != B_OK)
  294. -       return status;
  295. -  
  296. -   if (length != sizeof(HTreeCountLimit)) {
  297. -       ERROR("HTreeEntryIterator::Init() bad length %ld fOffset 0x%Lx\n",
  298. -           length, fOffset);
  299. +   if (fInitStatus != B_OK)
  300. +       return fInitStatus;
  301. +
  302. +   CachedBlock cached(fVolume);
  303. +   const uint8* block = cached.SetTo(fBlockNum);
  304. +   if (block == NULL) {
  305. +       ERROR("Failed to read htree entry block.\n");
  306.         fCount = fLimit = 0;
  307. -       return B_ERROR;
  308. +       return B_IO_ERROR;
  309.     }
  310. -  
  311. -   fCount = countLimit.Count();
  312. -   fLimit = countLimit.Limit();
  313.  
  314. +   HTreeCountLimit* countLimit = (HTreeCountLimit*)(
  315. +       &((HTreeEntry*)block)[fFirstEntry]);
  316. +
  317. +   fCount = countLimit->Count();
  318. +   fLimit = countLimit->Limit();
  319. +
  320.     if (fCount >= fLimit) {
  321. -       ERROR("HTreeEntryIterator::Init() bad fCount %d fOffset 0x%Lx\n",
  322. -           fCount, fOffset);
  323. +       ERROR("HTreeEntryIterator::Init() bad fCount %lu\n", (uint32)fCount);
  324.         fCount = fLimit = 0;
  325.         return B_ERROR;
  326.     }
  327.  
  328. -   if (fParent != NULL &&
  329. -       fLimit != ((fBlockSize - sizeof(HTreeFakeDirEntry))
  330. -           / sizeof(HTreeEntry)) ) {
  331. -       ERROR("HTreeEntryIterator::Init() bad fLimit %d should be %ld "
  332. -           "fOffset 0x%Lx\n", fLimit, (fBlockSize - sizeof(HTreeFakeDirEntry))
  333. -               / sizeof(HTreeEntry), fOffset);
  334. +   if (fLimit != fBlockSize / sizeof(HTreeEntry) - fFirstEntry) {
  335. +       ERROR("HTreeEntryIterator::Init() bad fLimit %lu should be %lu "
  336. +           "at block %lu\n", (uint32)fLimit, fBlockSize / sizeof(HTreeEntry)
  337. +               - fFirstEntry, fBlockNum);
  338.         fCount = fLimit = 0;
  339.         return B_ERROR;
  340. -   }
  341. +   }
  342.  
  343. -   TRACE("HTreeEntryIterator::Init() count 0x%x limit 0x%x\n", fCount,
  344. -       fLimit);
  345. +   TRACE("HTreeEntryIterator::Init() count %lu limit %lu\n",
  346. +       (uint32)fCount, (uint32)fLimit);
  347.  
  348. -   fMaxOffset = fOffset + (fCount - 1) * sizeof(HTreeEntry);
  349. -  
  350.     return B_OK;
  351.  }
  352.  
  353.  
  354.  HTreeEntryIterator::~HTreeEntryIterator()
  355.  {
  356. +   delete fChild;
  357.  }
  358.  
  359.  
  360. @@ -109,68 +121,77 @@
  361.  HTreeEntryIterator::Lookup(uint32 hash, int indirections,
  362.     DirectoryIterator** directoryIterator)
  363.  {
  364. -   off_t start = fOffset + sizeof(HTreeEntry);
  365. -   off_t end = fMaxOffset;
  366. -   off_t middle = start;
  367. -   size_t entrySize = sizeof(HTreeEntry);
  368. -   HTreeEntry entry;
  369. +   TRACE("HTreeEntryIterator::Lookup()\n");
  370. +   CachedBlock cached(fVolume);
  371. +   const uint8* block = cached.SetTo(fBlockNum);
  372. +   if (block == NULL) {
  373. +       ERROR("Failed to read htree entry block.\n");
  374. +       // Fallback to linear search
  375. +       *directoryIterator = new(std::nothrow)
  376. +           DirectoryIterator(fDirectory);
  377. +
  378. +       if (*directoryIterator == NULL)
  379. +           return B_NO_MEMORY;
  380. +
  381. +       return B_OK;
  382. +   }
  383. +
  384. +   HTreeEntry* start = (HTreeEntry*)block + fCurrentEntry + 1;
  385. +   HTreeEntry* end = (HTreeEntry*)block + fCount + fFirstEntry - 1;
  386. +   HTreeEntry* middle = start;
  387.    
  388. +   TRACE("HTreeEntryIterator::Lookup() current entry: %lu\n",
  389. +       (uint32)fCurrentEntry);
  390. +   TRACE("HTreeEntryIterator::Lookup() indirections: %d s:%p m:%p e:%p\n",
  391. +       indirections, start, middle, end);
  392. +
  393.     while (start <= end) {
  394. -       middle = (end - start) / 2;
  395. -       middle -= middle % entrySize; // Alignment
  396. -       middle += start;
  397. +       middle = (HTreeEntry*)((end - start) / 2
  398. +           + start);
  399.  
  400. -       TRACE("HTreeEntryIterator::Lookup() %d 0x%Lx 0x%Lx 0x%Lx\n",
  401. -           indirections, start, end, middle);
  402. -      
  403. -       status_t status = fDirectory->ReadAt(middle, (uint8*)&entry,
  404. -           &entrySize);
  405. +       TRACE("HTreeEntryIterator::Lookup() indirections: %d s:%p m:%p e:%p\n",
  406. +           indirections, start, middle, end);
  407.  
  408. -       TRACE("HTreeEntryIterator::Lookup() %lx %lx\n", hash, entry.Hash());
  409. -      
  410. -       if (status != B_OK)
  411. -           return status;
  412. -       else if (entrySize != sizeof(entry)) {
  413. -           // Fallback to linear search
  414. -           *directoryIterator = new(std::nothrow)
  415. -               DirectoryIterator(fDirectory);
  416. -          
  417. -           if (*directoryIterator == NULL)
  418. -               return B_NO_MEMORY;
  419. -          
  420. -           return B_OK;
  421. -       }
  422. -      
  423. -       if (hash >= entry.Hash())
  424. -           start = middle + entrySize;
  425. +       TRACE("HTreeEntryIterator::Lookup() %lx %lx\n", hash, middle->Hash());
  426. +
  427. +       if (hash >= middle->Hash())
  428. +           start = middle + 1;
  429.         else
  430. -           end = middle - entrySize;
  431. +           end = middle - 1;
  432.     }
  433.  
  434. -   status_t status = fDirectory->ReadAt(start - entrySize, (uint8*)&entry,
  435. -       &entrySize);
  436. -   if (status != B_OK)
  437. -       return status;
  438. -  
  439. +   --start;
  440. +
  441. +   fCurrentEntry = ((uint8*)start - block) / sizeof(HTreeEntry);
  442. +
  443.     if (indirections == 0) {
  444. +       TRACE("HTreeEntryIterator::Lookup(): Creating an indexed directory "
  445. +           "iterator starting at block: %lu, hash: 0x%lX\n", start->Block(),
  446. +           start->Hash());
  447.         *directoryIterator = new(std::nothrow)
  448. -           IndexedDirectoryIterator(entry.Block() * fBlockSize, fBlockSize,
  449. -           fDirectory, this);
  450. -      
  451. +           IndexedDirectoryIterator(start->Block() * fBlockSize, fDirectory,
  452. +               this);
  453. +
  454.         if (*directoryIterator == NULL)
  455.             return B_NO_MEMORY;
  456.  
  457.         return B_OK;
  458.     }
  459.  
  460. +   TRACE("HTreeEntryIterator::Lookup(): Creating a HTree entry iterator "
  461. +       "starting at block: %lu, hash: 0x%lX\n", start->Block(), start->Hash());
  462. +   uint32 blockNum;
  463. +   status_t status = fDirectory->FindBlock(start->Block() * fBlockSize,
  464. +       blockNum);
  465. +   if (status != B_OK)
  466. +       return status;
  467. +
  468.     delete fChild;
  469.  
  470. -   fChild = new(std::nothrow) HTreeEntryIterator(entry.Block(), fBlockSize,
  471. -       fDirectory, this, entry.Hash() & 1 == 1);
  472. -  
  473. +   fChild = new(std::nothrow) HTreeEntryIterator(blockNum, fBlockSize,
  474. +       fDirectory, this, start->Hash() & 1 == 1);
  475.     if (fChild == NULL)
  476.         return B_NO_MEMORY;
  477. -   fChildDeleter.SetTo(fChild);
  478.    
  479.     status = fChild->Init();
  480.     if (status != B_OK)
  481. @@ -181,40 +202,55 @@
  482.  
  483.  
  484.  status_t
  485. -HTreeEntryIterator::GetNext(off_t& childOffset)
  486. +HTreeEntryIterator::GetNext(uint32& childBlock)
  487.  {
  488. -   size_t entrySize = sizeof(HTreeEntry);
  489. -   fOffset += entrySize;
  490. -   bool firstEntry = fOffset >= fMaxOffset;
  491. -  
  492. -   if (firstEntry) {
  493. -       if (fParent == NULL)
  494. +   fCurrentEntry++;
  495. +   TRACE("HTreeEntryIterator::GetNext(): current entry: %lu\n",
  496. +       (uint32)fCurrentEntry);
  497. +   bool endOfBlock = fCurrentEntry >= (fCount + fFirstEntry);
  498. +
  499. +   if (endOfBlock) {
  500. +       TRACE("HTreeEntryIterator::GetNext(): end of entries in the block\n");
  501. +       if (fParent == NULL) {
  502. +           TRACE("HTreeEntryIterator::GetNext(): block was the root block\n");
  503.             return B_ENTRY_NOT_FOUND;
  504. +       }
  505.        
  506. -       status_t status = fParent->GetNext(fOffset);
  507. +       uint32 logicalBlock;
  508. +       status_t status = fParent->GetNext(logicalBlock);
  509.         if (status != B_OK)
  510.             return status;
  511.        
  512. +       TRACE("HTreeEntryIterator::GetNext(): moving to next block: %lu\n",
  513. +           logicalBlock);
  514. +      
  515. +       status = fDirectory->FindBlock(logicalBlock * fBlockSize, fBlockNum);
  516. +       if (status != B_OK)
  517. +           return status;
  518. +      
  519. +       fFirstEntry = 1; // Skip fake directory entry
  520. +       fCurrentEntry = 1;
  521.         status = Init();
  522.         if (status != B_OK)
  523.             return status;
  524.  
  525.         fHasCollision = fParent->HasCollision();
  526.     }
  527. +
  528. +   CachedBlock cached(fVolume);
  529. +   const uint8* block = cached.SetTo(fBlockNum);
  530. +   if (block == NULL)
  531. +       return B_IO_ERROR;
  532. +
  533. +   HTreeEntry* entry = &((HTreeEntry*)block)[fCurrentEntry];
  534. +
  535. +   if (!endOfBlock)
  536. +       fHasCollision = (entry[fCurrentEntry].Hash() & 1) == 1;
  537.    
  538. -   HTreeEntry entry;
  539. -   status_t status = fDirectory->ReadAt(fOffset, (uint8*)&entry, &entrySize);
  540. -   if (status != B_OK)
  541. -       return status;
  542. -   else if (entrySize != sizeof(entry)) {
  543. -       // Weird error, try to skip it
  544. -       return GetNext(childOffset);
  545. -   }
  546. +   TRACE("HTreeEntryIterator::GetNext(): next block: %lu\n",
  547. +       entry->Block());
  548. +
  549. +   childBlock = entry->Block();
  550.    
  551. -   if (!firstEntry)
  552. -       fHasCollision = (entry.Hash() & 1) == 1;
  553. -  
  554. -   childOffset = entry.Block() * fBlockSize;
  555. -  
  556.     return B_OK;
  557.  }
  558. Index: src/add-ons/kernel/file_systems/ext2/Inode.h
  559. ===================================================================
  560. --- src/add-ons/kernel/file_systems/ext2/Inode.h    (revision 37534)
  561. +++ src/add-ons/kernel/file_systems/ext2/Inode.h    (working copy)
  562. @@ -23,6 +23,8 @@
  563.  
  564.             rw_lock*    Lock() { return &fLock; }
  565.  
  566. +           status_t    WriteBack(Transaction& transaction);
  567. +
  568.             bool        IsDirectory() const
  569.                             { return S_ISDIR(Mode()); }
  570.             bool        IsFile() const
  571. @@ -32,16 +34,16 @@
  572.  
  573.             status_t    CheckPermissions(int accessMode) const;
  574.  
  575. -           mode_t      Mode() const { return fNode->Mode(); }
  576. -           int32       Flags() const { return fNode->Flags(); }
  577. +           mode_t      Mode() const { return fNode.Mode(); }
  578. +           int32       Flags() const { return fNode.Flags(); }
  579.  
  580. -           off_t       Size() const { return fNode->Size(); }
  581. +           off_t       Size() const { return fNode.Size(); }
  582.             time_t      ModificationTime() const
  583. -                           { return fNode->ModificationTime(); }
  584. +                           { return fNode.ModificationTime(); }
  585.             time_t      CreationTime() const
  586. -                           { return fNode->CreationTime(); }
  587. +                           { return fNode.CreationTime(); }
  588.             time_t      AccessTime() const
  589. -                           { return fNode->AccessTime(); }
  590. +                           { return fNode.AccessTime(); }
  591.  
  592.             //::Volume* _Volume() const { return fVolume; }
  593.             Volume*     GetVolume() const { return fVolume; }
  594. @@ -52,10 +54,19 @@
  595.             status_t    AttributeBlockReadAt(off_t pos, uint8 *buffer,
  596.                             size_t *length);
  597.  
  598. -           ext2_inode& Node() { return *fNode; }
  599. +           ext2_inode& Node() { return fNode; }
  600.  
  601. +   static  status_t    Create(Transaction& transaction, Inode* parent,
  602. +                           const char* name, int32 mode, int openMode,
  603. +                           uint32 type, bool* _created = NULL,
  604. +                           ino_t* _id = NULL, Inode** _inode = NULL,
  605. +                           fs_vnode_ops* vnodeOps = NULL,
  606. +                           uint32 publishFlags = 0);
  607. +
  608.             void*       FileCache() const { return fCache; }
  609.             void*       Map() const { return fMap; }
  610. +           status_t    DisableFileCache();
  611. +           bool        IsFileCacheDisabled() const { return !fCached; }
  612.  
  613.  private:
  614.                         Inode(const Inode&);
  615. @@ -63,13 +74,18 @@
  616.                             // no implementation
  617.  
  618.  private:
  619. -   rw_lock             fLock;
  620. -   ::Volume*           fVolume;
  621. -   ino_t               fID;
  622. -   void*               fCache;
  623. -   void*               fMap;
  624. -   ext2_inode*         fNode;
  625. -   ext2_xattr_header*  fAttributesBlock;
  626. +           rw_lock     fLock;
  627. +           ::Volume*   fVolume;
  628. +           ino_t       fID;
  629. +           void*       fCache;
  630. +           void*       fMap;
  631. +           bool        fCached;
  632. +           ext2_inode  fNode;
  633. +           uint32      fNodeSize;
  634. +               // Inodes have a varible size, but the important
  635. +               // information is always the same size (except in ext4)
  636. +           ext2_xattr_header* fAttributesBlock;
  637. +           status_t    fInitStatus;
  638.  };
  639.  
  640.  #endif // INODE_H
  641. Index: src/add-ons/kernel/file_systems/ext2/Volume.cpp
  642. ===================================================================
  643. --- src/add-ons/kernel/file_systems/ext2/Volume.cpp (revision 37534)
  644. +++ src/add-ons/kernel/file_systems/ext2/Volume.cpp (working copy)
  645. @@ -20,7 +20,10 @@
  646.  
  647.  #include <util/AutoLock.h>
  648.  
  649. +#include "CachedBlock.h"
  650.  #include "Inode.h"
  651. +#include "InodeJournal.h"
  652. +#include "NoJournal.h"
  653.  
  654.  
  655.  //#define TRACE_EXT2
  656. @@ -199,7 +202,7 @@
  657.     // TODO: check some more values!
  658.     if (Magic() != (uint32)EXT2_SUPER_BLOCK_MAGIC)
  659.         return false;
  660. -
  661. +  
  662.     return true;
  663.  }
  664.  
  665. @@ -210,6 +213,9 @@
  666.  Volume::Volume(fs_volume* volume)
  667.     :
  668.     fFSVolume(volume),
  669. +   fBlockAllocator(this),
  670. +   fInodeAllocator(this),
  671. +   fJournalInode(NULL),
  672.     fFlags(0),
  673.     fGroupBlocks(NULL),
  674.     fRootNode(NULL)
  675. @@ -220,6 +226,7 @@
  676.  
  677.  Volume::~Volume()
  678.  {
  679. +   TRACE("Volume destructor.\n");
  680.     if (fGroupBlocks != NULL) {
  681.         uint32 blockCount = (fNumGroups + fGroupsPerBlock - 1)
  682.             / fGroupsPerBlock;
  683. @@ -252,8 +259,14 @@
  684.  status_t
  685.  Volume::Mount(const char* deviceName, uint32 flags)
  686.  {
  687. -   flags |= B_MOUNT_READ_ONLY;
  688. +   // flags |= B_MOUNT_READ_ONLY;
  689.         // we only support read-only for now
  690. +  
  691. +   if ((flags & B_MOUNT_READ_ONLY) != 0) {
  692. +       TRACE("Volume::Mount(): Read only\n");
  693. +   } else {
  694. +       TRACE("Volume::Mount(): Read write\n");
  695. +   }
  696.  
  697.     DeviceOpener opener(deviceName, (flags & B_MOUNT_READ_ONLY) != 0
  698.         ? O_RDONLY : O_RDWR);
  699. @@ -278,10 +291,17 @@
  700.     fBlockSize = 1UL << fSuperBlock.BlockShift();
  701.     fFirstDataBlock = fSuperBlock.FirstDataBlock();
  702.  
  703. +   fFreeBlocks = fSuperBlock.FreeBlocks();
  704. +   fFreeInodes = fSuperBlock.FreeInodes();
  705. +
  706. +   uint32 numBlocks = fSuperBlock.NumBlocks() - fFirstDataBlock;
  707. +   uint32 blocksPerGroup = fSuperBlock.BlocksPerGroup();
  708. +   fNumGroups = numBlocks / blocksPerGroup;
  709. +   if (numBlocks % blocksPerGroup != 0)
  710. +       fNumGroups++;
  711. +
  712. +   fGroupsPerBlock = fBlockSize / sizeof(ext2_block_group);
  713.     fNumInodes = fSuperBlock.NumInodes();
  714. -   fNumGroups = (fSuperBlock.NumBlocks() - fFirstDataBlock - 1)
  715. -       / fSuperBlock.BlocksPerGroup() + 1;
  716. -   fGroupsPerBlock = fBlockSize / sizeof(ext2_block_group);
  717.  
  718.     TRACE("block size %ld, num groups %ld, groups per block %ld, first %lu\n",
  719.         fBlockSize, fNumGroups, fGroupsPerBlock, fFirstDataBlock);
  720. @@ -309,7 +329,55 @@
  721.     fBlockCache = opener.InitCache(NumBlocks(), fBlockSize);
  722.     if (fBlockCache == NULL)
  723.         return B_ERROR;
  724. +  
  725. +   TRACE("Volume::Mount(): Initialized block cache: %p\n", fBlockCache);
  726.  
  727. +   // initialize journal
  728. +   if ((fSuperBlock.CompatibleFeatures() & EXT2_FEATURE_HAS_JOURNAL) != 0) {
  729. +       // TODO: There should be a mount option to ignore the existent journal
  730. +       if (fSuperBlock.JournalInode() != 0) {
  731. +           fJournalInode = new(std::nothrow) Inode(this,
  732. +               fSuperBlock.JournalInode());
  733. +
  734. +           if (fJournalInode == NULL)
  735. +               return B_NO_MEMORY;
  736. +
  737. +           TRACE("Opening an on disk, inode mapped journal.\n");
  738. +           fJournal = new(std::nothrow) InodeJournal(fJournalInode);
  739. +       } else {
  740. +           // TODO: external journal
  741. +           TRACE("Can not open an external journal.\n");
  742. +           return B_NOT_SUPPORTED;
  743. +       }
  744. +   } else {
  745. +       TRACE("Opening a fake journal (NoJournal).\n");
  746. +       fJournal = new(std::nothrow) NoJournal(this);
  747. +   }
  748. +
  749. +   if (fJournal == NULL) {
  750. +       TRACE("No memory to create the journal\n");
  751. +       return B_NO_MEMORY;
  752. +   }
  753. +
  754. +   status = fJournal->InitCheck();
  755. +   if (status != B_OK)
  756. +       return status;
  757. +
  758. +   // TODO: Only recover if asked to
  759. +   status = fJournal->Recover();
  760. +   if (status != B_OK)
  761. +       return status;
  762. +
  763. +   status = fJournal->StartLog();
  764. +   if (status != B_OK)
  765. +       return status;
  766. +
  767. +   // Initialize allocators
  768. +   status = fBlockAllocator.Initialize();
  769. +   if (status != B_OK)
  770. +       return status;
  771. +
  772. +   // ready
  773.     status = get_vnode(fFSVolume, EXT2_ROOT_NODE, (void**)&fRootNode);
  774.     if (status != B_OK) {
  775.         TRACE("could not create root node: get_vnode() failed!\n");
  776. @@ -342,10 +410,19 @@
  777.  status_t
  778.  Volume::Unmount()
  779.  {
  780. +   TRACE("Volume::Unmount()\n");
  781. +
  782. +   delete fJournal;
  783. +   delete fJournalInode;
  784. +
  785. +   TRACE("Volume::Unmount(): Putting root node\n");
  786.     put_vnode(fFSVolume, RootNode()->ID());
  787. +   TRACE("Volume::Unmount(): Deleting the block cache\n");
  788.     block_cache_delete(fBlockCache, !IsReadOnly());
  789. +   TRACE("Volume::Unmount(): Closing device\n");
  790.     close(fDevice);
  791.  
  792. +   TRACE("Volume::Unmount(): Done\n");
  793.     return B_OK;
  794.  }
  795.  
  796. @@ -443,6 +520,106 @@
  797.  }
  798.  
  799.  
  800. +status_t
  801. +Volume::AllocateInode(Transaction& transaction, uint32 preferredBlockGroup,
  802. +   ino_t& id)
  803. +{
  804. +   if (IsReadOnly())
  805. +       return B_READ_ONLY_DEVICE;
  806. +
  807. +   status_t status = fInodeAllocator.New(transaction, preferredBlockGroup, id);
  808. +   if (status == B_OK)
  809. +       fFreeInodes -= 1;
  810. +
  811. +   return status;
  812. +}
  813. +
  814. +
  815. +status_t
  816. +Volume::AllocateBlocks(Transaction& transaction, uint32 minimum, uint32 maximum,
  817. +   uint32& blockGroup, uint32& start, uint32& length)
  818. +{
  819. +   TRACE("Volume::AllocateBlocks()\n");
  820. +   if (IsReadOnly())
  821. +       return B_READ_ONLY_DEVICE;
  822. +
  823. +   TRACE("Volume::AllocateBlocks(): Calling the block allocator\n");
  824. +
  825. +   status_t status = fBlockAllocator.AllocateBlocks(transaction, minimum,
  826. +       maximum, blockGroup, start, length);
  827. +   if (status != B_OK)
  828. +       return status;
  829. +
  830. +   TRACE("Volume::AllocateBlocks(): Allocated %lu blocks\n", length);
  831. +
  832. +   fFreeBlocks -= length;
  833. +
  834. +   return WriteSuperBlock(transaction);
  835. +}
  836. +
  837. +
  838. +status_t
  839. +Volume::LoadSuperBlock()
  840. +{
  841. +   CachedBlock cached(this);
  842. +   const uint8* block = cached.SetTo(fFirstDataBlock);
  843. +
  844. +   if (block == NULL)
  845. +       return B_IO_ERROR;
  846. +
  847. +   if (fFirstDataBlock == 0)
  848. +       memcpy(&fSuperBlock, block + 1024, sizeof(fSuperBlock));
  849. +   else
  850. +       memcpy(&fSuperBlock, block, sizeof(fSuperBlock));
  851. +
  852. +   fFreeBlocks = fSuperBlock.FreeBlocks();
  853. +   fFreeInodes = fSuperBlock.FreeInodes();
  854. +
  855. +   return B_OK;
  856. +}
  857. +
  858. +
  859. +status_t
  860. +Volume::WriteSuperBlock(Transaction& transaction)
  861. +{
  862. +   TRACE("Volume::WriteSuperBlock()\n");
  863. +   fSuperBlock.SetFreeBlocks(fFreeBlocks);
  864. +   fSuperBlock.SetFreeInodes(fFreeInodes);
  865. +   // TODO: Rest of fields that can be modified
  866. +
  867. +   CachedBlock cached(this);
  868. +   uint8* block = cached.SetToWritable(transaction, fFirstDataBlock);
  869. +
  870. +   if (block == NULL)
  871. +       return B_IO_ERROR;
  872. +
  873. +   if (fFirstDataBlock == 0)
  874. +       memcpy(block + 1024, &fSuperBlock, sizeof(fSuperBlock));
  875. +   else
  876. +       memcpy(block, &fSuperBlock, sizeof(fSuperBlock));
  877. +
  878. +   TRACE("Volume::WriteSuperBlock(): Done\n");
  879. +
  880. +   return B_OK;
  881. +}
  882. +
  883. +
  884. +status_t
  885. +Volume::FlushDevice()
  886. +{
  887. +   TRACE("Volume::FlushDevice()\n");
  888. +   return block_cache_sync(fBlockCache);
  889. +}
  890. +
  891. +
  892. +status_t
  893. +Volume::Sync()
  894. +{
  895. +   TRACE("Volume::Sync()\n");
  896. +   return fJournal->FlushLogAndBlocks();
  897. +}
  898. +
  899. +
  900.  // #pragma mark - Disk scanning and initialization
  901.  
  902.  
  903. @@ -460,3 +637,18 @@
  904.         ? B_OK : B_NOT_SUPPORTED;
  905.  }
  906.  
  907. +
  908. +void
  909. +Volume::TransactionDone(bool success)
  910. +{
  911. +   status_t status = LoadSuperBlock();
  912. +   if (status != B_OK)
  913. +       panic("Failed to relead ext2 superblock.\n");
  914. +}
  915. +
  916. +
  917. +void
  918. +Volume::RemovedFromTransaction()
  919. +{
  920. +   // TODO: Does it make a difference?
  921. +}
  922. Index: src/add-ons/kernel/file_systems/ext2/Journal.cpp
  923. ===================================================================
  924. --- src/add-ons/kernel/file_systems/ext2/Journal.cpp    (revision 0)
  925. +++ src/add-ons/kernel/file_systems/ext2/Journal.cpp    (revision 0)
  926. @@ -0,0 +1,1111 @@
  927. +/*
  928. + * Copyright 2001-2010, Haiku Inc. All rights reserved.
  929. + * This file may be used under the terms of the MIT License.
  930. + *
  931. + * Authors:
  932. + *     Janito V. Ferreira Filho
  933. + */
  934. +
  935. +#include "Journal.h"
  936. +
  937. +#include <new>
  938. +#include <string.h>
  939. +#include <unistd.h>
  940. +
  941. +#include <fs_cache.h>
  942. +
  943. +#include "CachedBlock.h"
  944. +#include "HashRevokeManager.h"
  945. +
  946. +
  947. +//#define TRACE_EXT2
  948. +#ifdef TRACE_EXT2
  949. +#  define TRACE(x...) dprintf("\33[34mext2:\33[0m " x)
  950. +#else
  951. +#  define TRACE(x...) ;
  952. +#endif
  953. +
  954. +
  955. +class LogEntry : public DoublyLinkedListLinkImpl<LogEntry> {
  956. +public:
  957. +                           LogEntry(Journal* journal, uint32 logStart,
  958. +                               uint32 length);
  959. +                           ~LogEntry();
  960. +
  961. +           uint32          Start() const { return fStart; }
  962. +           uint32          CommitID() const { return fCommitID; }
  963. +
  964. +           Journal*        GetJournal() { return fJournal; }
  965. +
  966. +private:
  967. +           Journal*        fJournal;
  968. +           uint32          fStart;
  969. +           uint32          fCommitID;
  970. +};
  971. +
  972. +
  973. +LogEntry::LogEntry(Journal* journal, uint32 logStart, uint32 commitID)
  974. +   :
  975. +   fJournal(journal),
  976. +   fStart(logStart),
  977. +   fCommitID(commitID)
  978. +{
  979. +}
  980. +
  981. +
  982. +LogEntry::~LogEntry()
  983. +{
  984. +}
  985. +
  986. +
  987. +/*void
  988. +add_to_iovec(iovec* vecs, int32& index, int32 max, const void* address,
  989. +   size_t size)
  990. +{
  991. +   if (index > 0 && (addr_t)vecs[index - 1].iov_base
  992. +       + vecs[index - 1].iov_len == (addr_t)address) {
  993. +       // the iovec can be combined with the previous one
  994. +       vecs[index - 1].iov_len += size;
  995. +       return;
  996. +   }
  997. +
  998. +   if (index == max)
  999. +       panic("no more space for iovecs!");
  1000. +  
  1001. +   // start a new iovec
  1002. +   vecs[index].iov_base = const_cast<void*>(address);
  1003. +   vecs[index].iov_len = size;
  1004. +   index++;
  1005. +}*/
  1006. +
  1007. +
  1008. +void
  1009. +JournalHeader::MakeDescriptor(uint32 sequence)
  1010. +{
  1011. +   this->magic = B_HOST_TO_BENDIAN_INT32(JOURNAL_MAGIC);
  1012. +   this->sequence = B_HOST_TO_BENDIAN_INT32(sequence);
  1013. +   this->block_type = B_HOST_TO_BENDIAN_INT32(JOURNAL_DESCRIPTOR_BLOCK);
  1014. +}
  1015. +
  1016. +
  1017. +void
  1018. +JournalHeader::MakeCommit(uint32 sequence)
  1019. +{
  1020. +   this->magic = B_HOST_TO_BENDIAN_INT32(JOURNAL_MAGIC);
  1021. +   this->sequence = B_HOST_TO_BENDIAN_INT32(sequence);
  1022. +   this->block_type = B_HOST_TO_BENDIAN_INT32(JOURNAL_COMMIT_BLOCK);
  1023. +}
  1024. +
  1025. +
  1026. +Journal::Journal(Volume* fsVolume, Volume* jVolume)
  1027. +   :
  1028. +   fJournalVolume(jVolume),
  1029. +   fJournalBlockCache(jVolume->BlockCache()),
  1030. +   fFilesystemVolume(fsVolume),
  1031. +   fFilesystemBlockCache(fsVolume->BlockCache()),
  1032. +   fRevokeManager(NULL),
  1033. +   fInitStatus(B_OK),
  1034. +   fBlockSize(sizeof(JournalSuperBlock)),
  1035. +   fFirstCommitID(0),
  1036. +   fFirstCacheCommitID(0),
  1037. +   fFirstLogBlock(0),
  1038. +   fLogSize(0),
  1039. +   fVersion(0),
  1040. +   fLogStart(0),
  1041. +   fLogEnd(0),
  1042. +   fFreeBlocks(0),
  1043. +   fMaxTransactionSize(0),
  1044. +   fCurrentCommitID(0),
  1045. +   fHasSubTransaction(false),
  1046. +   fSeparateSubTransactions(false),
  1047. +   fUnwrittenTransactions(0),
  1048. +   fTransactionID(0)
  1049. +{
  1050. +   recursive_lock_init(&fLock, "ext2 journal");
  1051. +   mutex_init(&fLogEntriesLock, "ext2 journal log entries");
  1052. +
  1053. +   fRevokeManager = new(std::nothrow) HashRevokeManager;
  1054. +
  1055. +   if (fRevokeManager == NULL)
  1056. +       fInitStatus = B_NO_MEMORY;
  1057. +   else
  1058. +       fInitStatus = _LoadSuperBlock();
  1059. +}
  1060. +
  1061. +
  1062. +Journal::Journal()
  1063. +   :
  1064. +   fJournalVolume(NULL),
  1065. +   fJournalBlockCache(NULL),
  1066. +   fFilesystemVolume(NULL),
  1067. +   fFilesystemBlockCache(NULL),
  1068. +   fRevokeManager(NULL),
  1069. +   fInitStatus(B_OK),
  1070. +   fBlockSize(sizeof(JournalSuperBlock)),
  1071. +   fFirstCommitID(0),
  1072. +   fFirstCacheCommitID(0),
  1073. +   fFirstLogBlock(0),
  1074. +   fLogSize(0),
  1075. +   fVersion(0),
  1076. +   fLogStart(0),
  1077. +   fLogEnd(0),
  1078. +   fFreeBlocks(0),
  1079. +   fMaxTransactionSize(0),
  1080. +   fCurrentCommitID(0),
  1081. +   fHasSubTransaction(false),
  1082. +   fSeparateSubTransactions(false),
  1083. +   fUnwrittenTransactions(0),
  1084. +   fTransactionID(0)
  1085. +{
  1086. +   recursive_lock_init(&fLock, "ext2 journal");
  1087. +   mutex_init(&fLogEntriesLock, "ext2 journal log entries");
  1088. +}
  1089. +
  1090. +
  1091. +Journal::~Journal()
  1092. +{
  1093. +   TRACE("Journal destructor.\n");
  1094. +
  1095. +   FlushLogAndBlocks();
  1096. +
  1097. +   delete fRevokeManager;
  1098. +
  1099. +   recursive_lock_destroy(&fLock);
  1100. +   mutex_destroy(&fLogEntriesLock);
  1101. +}
  1102. +
  1103. +
  1104. +status_t
  1105. +Journal::InitCheck()
  1106. +{
  1107. +   return fInitStatus;
  1108. +}
  1109. +
  1110. +
  1111. +/*virtual*/ status_t
  1112. +Journal::StartLog()
  1113. +{
  1114. +   fLogStart = fFirstLogBlock;
  1115. +   fLogEnd = fFirstLogBlock;
  1116. +   fFreeBlocks = 0;
  1117. +
  1118. +   fCurrentCommitID = fFirstCommitID;
  1119. +   //fNextCommitID = fFirstCommitID;
  1120. +
  1121. +   return _SaveSuperBlock();
  1122. +}
  1123. +
  1124. +
  1125. +status_t
  1126. +Journal::RestartLog()
  1127. +{
  1128. +   fFirstCommitID = 1;
  1129. +
  1130. +   return B_OK;
  1131. +}
  1132. +
  1133. +
  1134. +/*virtual*/ status_t
  1135. +Journal::Lock(Transaction* owner, bool separateSubTransactions)
  1136. +{
  1137. +   TRACE("Journal::Lock()\n");
  1138. +   status_t status = recursive_lock_lock(&fLock);
  1139. +   if (status != B_OK)
  1140. +       return status;
  1141. +
  1142. +   TRACE("Journal::Lock(): Aquired lock\n");
  1143. +
  1144. +   if (!fSeparateSubTransactions && recursive_lock_get_recursion(&fLock) > 1) {
  1145. +       // reuse current transaction
  1146. +       TRACE("Journal::Lock(): Reusing current transaction\n");
  1147. +       return B_OK;
  1148. +   }
  1149. +
  1150. +   if(separateSubTransactions)
  1151. +       fSeparateSubTransactions = true;
  1152. +
  1153. +   if (owner != NULL)
  1154. +       owner->SetParent(fOwner);
  1155. +
  1156. +   fOwner = owner;
  1157. +
  1158. +   if (fOwner != NULL) {
  1159. +       if (fUnwrittenTransactions > 0) {
  1160. +           // start a sub transaction
  1161. +           TRACE("Journal::Lock(): Starting sub transaction\n");
  1162. +           cache_start_sub_transaction(fFilesystemBlockCache, fTransactionID);
  1163. +           fHasSubTransaction = true;
  1164. +       } else {
  1165. +           TRACE("Journal::Lock(): Starting new transaction\n");
  1166. +           fTransactionID = cache_start_transaction(fFilesystemBlockCache);
  1167. +       }
  1168. +
  1169. +       if (fTransactionID < B_OK) {
  1170. +           recursive_lock_unlock(&fLock);
  1171. +           return fTransactionID;
  1172. +       }
  1173. +
  1174. +       cache_add_transaction_listener(fFilesystemBlockCache, fTransactionID,
  1175. +           TRANSACTION_IDLE, _TransactionIdle, this);
  1176. +   }
  1177. +
  1178. +   return B_OK;
  1179. +}
  1180. +
  1181. +
  1182. +/*virtual*/ status_t
  1183. +Journal::Unlock(Transaction* owner, bool success)
  1184. +{
  1185. +   TRACE("Journal::Unlock()\n");
  1186. +   if (fSeparateSubTransactions
  1187. +       || recursive_lock_get_recursion(&fLock) == 1) {
  1188. +       // we only end the transaction if we unlock it
  1189. +       TRACE("Journal::Unlock(): Last lock holder\n");
  1190. +       if (owner != NULL) {
  1191. +           status_t status = _TransactionDone(success);
  1192. +           if (status != B_OK)
  1193. +               return status;
  1194. +
  1195. +           bool separateSubTransactions = fSeparateSubTransactions;
  1196. +           fSeparateSubTransactions = true;
  1197. +           owner->NotifyListeners(success);
  1198. +           fSeparateSubTransactions = separateSubTransactions;
  1199. +
  1200. +           fOwner = owner->Parent();
  1201. +       } else
  1202. +           fOwner = NULL;
  1203. +
  1204. +       if (fSeparateSubTransactions
  1205. +           && recursive_lock_get_recursion(&fLock) == 1)
  1206. +           fSeparateSubTransactions = false;
  1207. +   } else
  1208. +       owner->MoveListenersTo(fOwner);
  1209. +
  1210. +   recursive_lock_unlock(&fLock);
  1211. +   return B_OK;
  1212. +}
  1213. +
  1214. +
  1215. +status_t
  1216. +Journal::MapBlock(uint32 logical, uint32& physical)
  1217. +{
  1218. +   physical = logical;
  1219. +  
  1220. +   return B_OK;
  1221. +}
  1222. +
  1223. +
  1224. +inline uint32
  1225. +Journal::FreeLogBlocks() const
  1226. +{
  1227. +   return fLogStart <= fLogEnd
  1228. +       ? fLogSize - fLogEnd + fLogStart
  1229. +       : fLogStart - fLogEnd;
  1230. +}
  1231. +
  1232. +
  1233. +status_t
  1234. +Journal::FlushLogAndBlocks()
  1235. +{
  1236. +   return _FlushLog(true, true);
  1237. +}
  1238. +
  1239. +
  1240. +int32
  1241. +Journal::TransactionID() const
  1242. +{
  1243. +   return fTransactionID;
  1244. +}
  1245. +
  1246. +
  1247. +status_t
  1248. +Journal::_WriteTransactionToLog()
  1249. +{
  1250. +   TRACE("Journal::_WriteTransactionToLog()\n");
  1251. +   // Transaction enters the Flush state
  1252. +   bool detached = false;
  1253. +   size_t size = _FullTransactionSize();
  1254. +
  1255. +   if (size > fLogSize) {
  1256. +       TRACE("Journal::_WriteTransactionToLog(): not enough free space "
  1257. +           "for the transaction. Attempting to free some space.\n");
  1258. +       size = _MainTransactionSize();
  1259. +
  1260. +       if(fHasSubTransaction && size < fMaxTransactionSize)
  1261. +           detached = true;
  1262. +       else {
  1263. +           // Error: transaction can't fit in log
  1264. +           panic("transaction too large (size: %d, max size: %d)\n",
  1265. +               (int)_MainTransactionSize(), (int)fLogSize);
  1266. +           return B_BUFFER_OVERFLOW;
  1267. +       }
  1268. +   }
  1269. +
  1270. +   if (size > FreeLogBlocks()) {
  1271. +       cache_sync_transaction(fFilesystemBlockCache, fTransactionID);
  1272. +
  1273. +       if (size > FreeLogBlocks()) {
  1274. +           panic("Transaction fits, but sync didn't result in enough"
  1275. +               "free space.\n\tGot %ld when at least %ld was expected.",
  1276. +               (long)FreeLogBlocks(), (long)size);
  1277. +       }
  1278. +   }
  1279. +
  1280. +   fHasSubTransaction = false;
  1281. +
  1282. +   uint32 logBlock = fLogStart + 1;
  1283. +   uint32 physicalBlock;
  1284. +   status_t status = MapBlock(logBlock, physicalBlock);
  1285. +   if (status != B_OK)
  1286. +       return status;
  1287. +
  1288. +   off_t logOffset = physicalBlock * fBlockSize;
  1289. +   off_t blockNumber;
  1290. +   long cookie = 0;
  1291. +
  1292. +   JournalHeader* blockData = NULL;
  1293. +   JournalHeader* descriptorBlock =
  1294. +       (JournalHeader*)new(std::nothrow) uint8[fBlockSize];
  1295. +   descriptorBlock->MakeDescriptor(fCurrentCommitID);
  1296. +
  1297. +   JournalBlockTag* tag = (JournalBlockTag*)descriptorBlock->data;
  1298. +   int32 blockCount = 0;
  1299. +
  1300. +   uint8* escapedData = NULL;
  1301. +   void* finalData = NULL;
  1302. +
  1303. +   // TODO: use iovecs?
  1304. +   /*int maxVecs = detached ? _MainTransactionSize() : _FullTransactionSize();
  1305. +
  1306. +   iovec* vecs = new(std::nothrow) iovecs[maxVecs];
  1307. +   if (vecs == NULL)
  1308. +       return B_NO_MEMORY;
  1309. +
  1310. +   int32 index = 0;*/
  1311. +
  1312. +   while (cache_next_block_in_transaction(fFilesystemBlockCache,
  1313. +           fTransactionID, detached, &cookie, &blockNumber,
  1314. +           (void**)&blockData, NULL) == B_OK) {
  1315. +       tag->SetBlockNumber(blockNumber);
  1316. +       tag->SetFlags(0);
  1317. +
  1318. +       if (blockData == NULL) {
  1319. +           panic("Got a NULL pointer while iterating through transaction "
  1320. +               "blocks.\n");
  1321. +           return B_ERROR;
  1322. +       }
  1323. +
  1324. +       if (blockData->CheckMagic()) {
  1325. +           // The journaled block starts with the magic value
  1326. +           // We must remove it to prevent confusion
  1327. +           tag->SetEscapedFlag();
  1328. +
  1329. +           if (escapedData == NULL) {
  1330. +               escapedData = new(std::nothrow) uint8[fBlockSize];
  1331. +               ((int32*)escapedData)[0] = 0; // Remove magic
  1332. +           }
  1333. +
  1334. +           memcpy(escapedData + 4, blockData->data, fBlockSize - 4);
  1335. +           finalData = escapedData;
  1336. +       } else
  1337. +           finalData = (void*)blockData;
  1338. +
  1339. +       size_t written = write_pos(fJournalVolume->Device(), logOffset,
  1340. +           finalData, fBlockSize);
  1341. +       if (written != fBlockSize) {
  1342. +           TRACE("Failed to write journal block.\n");
  1343. +
  1344. +           delete [] descriptorBlock;
  1345. +          
  1346. +           if (escapedData != NULL)
  1347. +               delete [] escapedData;
  1348. +
  1349. +           return B_IO_ERROR;
  1350. +       }
  1351. +
  1352. +       logBlock = _WrapAroundLog(++logBlock);
  1353. +       status = MapBlock(logBlock, physicalBlock);
  1354. +       if (status != B_OK)
  1355. +           return status;
  1356. +
  1357. +       logOffset = physicalBlock * fBlockSize;
  1358. +
  1359. +       tag++;
  1360. +       blockCount++;
  1361. +   }
  1362. +
  1363. +   // Write descriptor block
  1364. +   --tag;
  1365. +   tag->SetLastTagFlag();
  1366. +  
  1367. +   status = MapBlock(fLogStart, physicalBlock);
  1368. +   if (status != B_OK)
  1369. +       return status;
  1370. +
  1371. +   off_t startOffset = physicalBlock * fBlockSize;
  1372. +
  1373. +   size_t written = write_pos(fJournalVolume->Device(), startOffset,
  1374. +       descriptorBlock, fBlockSize);
  1375. +   if (written != fBlockSize) {
  1376. +       TRACE("Failed to write journal descriptor block.\n");
  1377. +
  1378. +       delete [] descriptorBlock;
  1379. +      
  1380. +       if (escapedData != NULL)
  1381. +           delete [] escapedData;
  1382. +
  1383. +       return B_IO_ERROR;
  1384. +   }
  1385. +  
  1386. +   // Transaction will enter the Commit state
  1387. +   JournalHeader* commitBlock = descriptorBlock;
  1388. +       // Reuse buffer
  1389. +   commitBlock->MakeCommit(fCurrentCommitID);
  1390. +   memset(commitBlock->data, 0, fBlockSize - sizeof(JournalHeader));
  1391. +       // TODO: This probably isn't necessary
  1392. +
  1393. +   written = write_pos(fJournalVolume->Device(), logOffset, commitBlock,
  1394. +       fBlockSize);
  1395. +   if (written != fBlockSize) {
  1396. +       TRACE("Failed to write journal commit block.\n");
  1397. +
  1398. +       delete [] commitBlock;
  1399. +           // Which is also descriptorBlock
  1400. +      
  1401. +       if (escapedData != NULL)
  1402. +           delete [] escapedData;
  1403. +
  1404. +       return B_IO_ERROR;
  1405. +   }
  1406. +  
  1407. +   fLogEnd = _WrapAroundLog(fLogEnd + blockCount);
  1408. +
  1409. +   status = _SaveSuperBlock();
  1410. +
  1411. +   delete [] commitBlock;
  1412. +       // Which is aslo descriptorBlock
  1413. +  
  1414. +   if (escapedData != NULL)
  1415. +       delete [] escapedData;
  1416. +
  1417. +   // Transaction will enter Finished state
  1418. +   blockCount += 2;    // Include descriptor and commit blocks
  1419. +   LogEntry *logEntry = new LogEntry(this, fLogEnd, fCurrentCommitID++);
  1420. +   if (logEntry == NULL) {
  1421. +       panic("no memory to allocate log entries!");
  1422. +       return B_NO_MEMORY;
  1423. +   }
  1424. +
  1425. +   mutex_lock(&fLogEntriesLock);
  1426. +   fLogEntries.Add(logEntry);
  1427. +   mutex_unlock(&fLogEntriesLock);
  1428. +
  1429. +   if (detached) {
  1430. +       fTransactionID = cache_detach_sub_transaction(fFilesystemBlockCache,
  1431. +           fTransactionID, _TransactionWritten, logEntry);
  1432. +       fUnwrittenTransactions = 1;
  1433. +
  1434. +       if (status == B_OK && _FullTransactionSize() > fLogSize) {
  1435. +           // If the transaction is too large after writing, there is no way to
  1436. +           // recover, so let this transaction fail.
  1437. +           dprintf("transaction too large (%d blocks, log size %d)!\n",
  1438. +               (int)_FullTransactionSize(), (int)fLogSize);
  1439. +           return B_BUFFER_OVERFLOW;
  1440. +       }
  1441. +   } else {
  1442. +       cache_end_transaction(fFilesystemBlockCache, fTransactionID,
  1443. +           _TransactionWritten, logEntry);
  1444. +       fUnwrittenTransactions = 0;
  1445. +   }
  1446. +
  1447. +   return B_OK;
  1448. +}
  1449. +
  1450. +
  1451. +status_t
  1452. +Journal::_SaveSuperBlock()
  1453. +{
  1454. +   TRACE("Journal::_SaveSuperBlock()\n");
  1455. +   uint32 physicalBlock;
  1456. +   status_t status = MapBlock(0, physicalBlock);
  1457. +   if (status != B_OK)
  1458. +       return status;
  1459. +
  1460. +   off_t superblockPos = physicalBlock * fBlockSize;
  1461. +
  1462. +   JournalSuperBlock superblock;
  1463. +   size_t bytesRead = read_pos(fJournalVolume->Device(), superblockPos,
  1464. +       &superblock, sizeof(superblock));
  1465. +
  1466. +   if (bytesRead != sizeof(superblock))
  1467. +       return B_IO_ERROR;
  1468. +
  1469. +   superblock.SetFirstCommitID(fFirstCommitID);
  1470. +   superblock.SetLogStart(fLogStart);
  1471. +  
  1472. +   size_t bytesWritten = write_pos(fJournalVolume->Device(), superblockPos,
  1473. +       &superblock, sizeof(superblock));
  1474. +
  1475. +   if (bytesWritten != sizeof(superblock))
  1476. +       return B_IO_ERROR;
  1477. +
  1478. +   TRACE("Journal::_SaveSuperBlock(): Done\n");
  1479. +
  1480. +   return B_OK;
  1481. +}
  1482. +
  1483. +
  1484. +status_t
  1485. +Journal::_LoadSuperBlock()
  1486. +{
  1487. +   TRACE("Journal::_LoadSuperBlock()\n");
  1488. +   uint32 superblockPos;
  1489. +
  1490. +   status_t status = MapBlock(0, superblockPos);
  1491. +   if (status != B_OK)
  1492. +       return status;
  1493. +  
  1494. +   TRACE("Journal::_LoadSuperBlock(): super block physical block: %lu\n",
  1495. +       superblockPos);
  1496. +  
  1497. +   JournalSuperBlock superblock;
  1498. +   size_t bytesRead = read_pos(fJournalVolume->Device(), superblockPos
  1499. +       * fJournalVolume->BlockSize(), &superblock, sizeof(superblock));
  1500. +
  1501. +   if (bytesRead != sizeof(superblock)) {
  1502. +       TRACE("Journal::_LoadSuperBlock(): failed to read superblock\n");
  1503. +       return B_IO_ERROR;
  1504. +   }
  1505. +
  1506. +   if (!superblock.header.CheckMagic()) {
  1507. +       TRACE("Journal::_LoadSuperBlock(): Invalid superblock magic %lX\n",
  1508. +           superblock.header.Magic());
  1509. +       return B_BAD_VALUE;
  1510. +   }
  1511. +
  1512. +   if (superblock.header.BlockType() == JOURNAL_SUPERBLOCK_V1) {
  1513. +       TRACE("Journal::_LoadSuperBlock(): Journal superblock version 1\n");
  1514. +       fVersion = 1;
  1515. +   } else if (superblock.header.BlockType() == JOURNAL_SUPERBLOCK_V2) {
  1516. +       TRACE("Journal::_LoadSuperBlock(): Journal superblock version 2\n");
  1517. +       fVersion = 2;
  1518. +   } else {
  1519. +       TRACE("Journal::_LoadSuperBlock(): Invalid superblock version\n");
  1520. +       return B_BAD_VALUE;
  1521. +   }
  1522. +
  1523. +   if (fVersion >= 2) {
  1524. +       status = _CheckFeatures(&superblock);
  1525. +
  1526. +       if (status != B_OK) {
  1527. +           TRACE("Journal::_LoadSuperBlock(): Unsupported features\n");
  1528. +           return status;
  1529. +       }
  1530. +   }
  1531. +
  1532. +   fBlockSize = superblock.BlockSize();
  1533. +   fFirstCommitID = superblock.FirstCommitID();
  1534. +   fFirstLogBlock = superblock.FirstLogBlock();
  1535. +   fLogStart = superblock.LogStart();
  1536. +   fLogSize = superblock.NumBlocks();
  1537. +   fMaxTransactionSize = superblock.MaxTransactionData();
  1538. +   //fFirstCacheCommitID = fFirstCommitID - fTransactionID /*+ 1*/;
  1539. +
  1540. +   TRACE("Journal::_LoadSuperBlock(): block size: %lu, first commit id: %lu, "
  1541. +       "first log block: %lu, log start: %lu, log size: %lu, max transaction "
  1542. +       "size: %lu\n", fBlockSize, fFirstCommitID, fFirstLogBlock, fLogStart,
  1543. +       fLogSize, fMaxTransactionSize);
  1544. +
  1545. +   return B_OK;
  1546. +}
  1547. +
  1548. +
  1549. +status_t
  1550. +Journal::_CheckFeatures(JournalSuperBlock* superblock)
  1551. +{
  1552. +   if ((superblock->ReadOnlyCompatibleFeatures()
  1553. +           & ~JOURNAL_KNOWN_READ_ONLY_COMPATIBLE_FEATURES) != 0
  1554. +       || (superblock->IncompatibleFeatures()
  1555. +           & ~JOURNAL_KNOWN_INCOMPATIBLE_FEATURES) != 0)
  1556. +       return B_NOT_SUPPORTED;
  1557. +
  1558. +   return B_OK;
  1559. +}
  1560. +
  1561. +
  1562. +uint32
  1563. +Journal::_CountTags(JournalHeader* descriptorBlock)
  1564. +{
  1565. +   uint32 count = 0;
  1566. +
  1567. +   JournalBlockTag* tags = (JournalBlockTag*)descriptorBlock->data;
  1568. +       // Skip the header
  1569. +   JournalBlockTag* lastTag = (JournalBlockTag*)
  1570. +       (descriptorBlock + fBlockSize - sizeof(JournalBlockTag));
  1571. +
  1572. +   while (tags < lastTag && (tags->Flags() & JOURNAL_FLAG_LAST_TAG) == 0) {
  1573. +       if ((tags->Flags() & JOURNAL_FLAG_SAME_UUID) == 0) {
  1574. +           // sizeof(UUID) = 16 = 2*sizeof(JournalBlockTag)
  1575. +           tags += 2;  // Skip new UUID
  1576. +       }
  1577. +
  1578. +       tags++; // Go to next tag
  1579. +       count++;
  1580. +   }
  1581. +
  1582. +   return count;
  1583. +}
  1584. +
  1585. +
  1586. +/*virtual*/ status_t
  1587. +Journal::Recover()
  1588. +{
  1589. +   TRACE("Journal::Recover()\n");
  1590. +   if (fLogStart == 0) // Journal was cleanly unmounted
  1591. +       return B_OK;
  1592. +
  1593. +   TRACE("Journal::Recover(): Journal needs recovery\n");
  1594. +
  1595. +   uint32 lastCommitID;
  1596. +
  1597. +   status_t status = _RecoverPassScan(lastCommitID);
  1598. +   if (status != B_OK)
  1599. +       return status;
  1600. +  
  1601. +   status = _RecoverPassRevoke(lastCommitID);
  1602. +   if (status != B_OK)
  1603. +       return status;
  1604. +
  1605. +   return _RecoverPassReplay(lastCommitID);
  1606. +}
  1607. +
  1608. +
  1609. +// First pass: Find the end of the log
  1610. +status_t
  1611. +Journal::_RecoverPassScan(uint32& lastCommitID)
  1612. +{
  1613. +   TRACE("Journal Recover: 1st Pass: Scan\n");
  1614. +
  1615. +   CachedBlock cached(fJournalVolume);
  1616. +   JournalHeader* header;
  1617. +   uint32 nextCommitID = fFirstCommitID;
  1618. +   uint32 nextBlock = fLogStart;
  1619. +   uint32 nextBlockPos;
  1620. +
  1621. +   status_t status = MapBlock(nextBlock, nextBlockPos);
  1622. +   if (status != B_OK)
  1623. +       return status;
  1624. +
  1625. +   header = (JournalHeader*)cached.SetTo(nextBlockPos);
  1626. +
  1627. +   while (header->CheckMagic() && header->Sequence() == nextCommitID) {
  1628. +       uint32 blockType = header->BlockType();
  1629. +
  1630. +       if (blockType == JOURNAL_DESCRIPTOR_BLOCK)
  1631. +           nextBlock = _WrapAroundLog(nextBlock + _CountTags(header));
  1632. +       else if (blockType == JOURNAL_COMMIT_BLOCK)
  1633. +           nextCommitID++;
  1634. +       else if (blockType != JOURNAL_REVOKE_BLOCK) {
  1635. +               // TODO: Warn that we found an unrecognized block
  1636. +           break;
  1637. +       } // If blockType == JOURNAL_REVOKE_BLOCK we just skip it
  1638. +
  1639. +       nextBlock = _WrapAroundLog(nextBlock + 1);
  1640. +
  1641. +       status = MapBlock(nextBlock, nextBlockPos);
  1642. +       if (status != B_OK)
  1643. +           return status;
  1644. +
  1645. +       header = (JournalHeader*)cached.SetTo(nextBlockPos);
  1646. +   }
  1647. +
  1648. +   TRACE("Journal Recovery pass scan: Last detected transaction ID: %lu\n",
  1649. +       nextCommitID);
  1650. +
  1651. +   lastCommitID = nextCommitID;
  1652. +   return B_OK;
  1653. +}
  1654. +
  1655. +
  1656. +// Second pass: Collect all revoked blocks
  1657. +status_t
  1658. +Journal::_RecoverPassRevoke(uint32 lastCommitID)
  1659. +{
  1660. +   TRACE("Journal Recover: 2nd Pass: Revoke\n");
  1661. +
  1662. +   CachedBlock cached(fJournalVolume);
  1663. +   JournalHeader* header;
  1664. +   uint32 nextCommitID = fFirstCommitID;
  1665. +   uint32 nextBlock = fLogStart;
  1666. +   uint32 nextBlockPos;
  1667. +
  1668. +   status_t status = MapBlock(nextBlock, nextBlockPos);
  1669. +   if (status != B_OK)
  1670. +       return status;
  1671. +
  1672. +   header = (JournalHeader*)cached.SetTo(nextBlockPos);
  1673. +
  1674. +   while (nextCommitID < lastCommitID) {
  1675. +       if (!header->CheckMagic() || header->Sequence() != nextCommitID) {
  1676. +           // Somehow the log is different than the expexted
  1677. +           return B_ERROR;
  1678. +       }
  1679. +
  1680. +       uint32 blockType = header->BlockType();
  1681. +
  1682. +       if (blockType == JOURNAL_DESCRIPTOR_BLOCK)
  1683. +           nextBlock = _WrapAroundLog(nextBlock + _CountTags(header));
  1684. +       else if (blockType == JOURNAL_COMMIT_BLOCK)
  1685. +           nextCommitID++;
  1686. +       else if (blockType == JOURNAL_REVOKE_BLOCK) {
  1687. +           status = fRevokeManager->ScanRevokeBlock(
  1688. +               (JournalRevokeHeader*)header, nextCommitID);
  1689. +
  1690. +           if (status != B_OK)
  1691. +               return status;
  1692. +       } else {
  1693. +               // TODO: Warn that we found an unrecognized block
  1694. +           break;
  1695. +       }
  1696. +
  1697. +       nextBlock = _WrapAroundLog(nextBlock + 1);
  1698. +
  1699. +       status = MapBlock(nextBlock, nextBlockPos);
  1700. +       if (status != B_OK)
  1701. +           return status;
  1702. +
  1703. +       header = (JournalHeader*)cached.SetTo(nextBlockPos);
  1704. +   }
  1705. +
  1706. +   if (nextCommitID != lastCommitID) {
  1707. +       // Possibly because of some sort of IO error
  1708. +       return B_ERROR;
  1709. +   }
  1710. +
  1711. +   TRACE("Journal recovery pass revoke: Revoked blocks: %lu\n",
  1712. +       fRevokeManager->NumRevokes());
  1713. +
  1714. +   return B_OK;
  1715. +}
  1716. +
  1717. +
  1718. +// Third pass: Replay log
  1719. +status_t
  1720. +Journal::_RecoverPassReplay(uint32 lastCommitID)
  1721. +{
  1722. +   TRACE("Journal Recover: 3rd Pass: Replay\n");
  1723. +
  1724. +   uint32 nextCommitID = fFirstCommitID;
  1725. +   uint32 nextBlock = fLogStart;
  1726. +   uint32 nextBlockPos;
  1727. +
  1728. +   status_t status = MapBlock(nextBlock, nextBlockPos);
  1729. +   if (status != B_OK)
  1730. +       return status;
  1731. +
  1732. +   CachedBlock cached(fJournalVolume);
  1733. +   JournalHeader* header = (JournalHeader*)cached.SetTo(nextBlockPos);
  1734. +
  1735. +   int count = 0;
  1736. +
  1737. +   uint8* data = new(std::nothrow) uint8[fBlockSize];
  1738. +
  1739. +   while (nextCommitID < lastCommitID) {
  1740. +       if (!header->CheckMagic() || header->Sequence() != nextCommitID) {
  1741. +           // Somehow the log is different than the expexted
  1742. +           return B_ERROR;
  1743. +       }
  1744. +
  1745. +       uint32 blockType = header->BlockType();
  1746. +
  1747. +       if (blockType == JOURNAL_DESCRIPTOR_BLOCK) {
  1748. +           JournalBlockTag* last_tag = (JournalBlockTag*)((uint8*)header
  1749. +               + fBlockSize - sizeof(JournalBlockTag));
  1750. +
  1751. +           for (JournalBlockTag* tag = (JournalBlockTag*)header->data;
  1752. +               tag <= last_tag; ++tag) {
  1753. +               nextBlock = _WrapAroundLog(nextBlock + 1);
  1754. +
  1755. +               status = MapBlock(nextBlock, nextBlockPos);
  1756. +               if (status != B_OK) {
  1757. +                   delete [] data;
  1758. +                   return status;
  1759. +               }
  1760. +
  1761. +               size_t read = read_pos(fJournalVolume->Device(),
  1762. +                   nextBlockPos * fBlockSize, data, fBlockSize);
  1763. +               if (read != fBlockSize) {
  1764. +                   delete [] data;
  1765. +                   return B_IO_ERROR;
  1766. +               }
  1767. +
  1768. +               if (!fRevokeManager->Lookup(tag->BlockNumber(),
  1769. +                       nextCommitID)) {
  1770. +                   // Block isn't revoked
  1771. +                   if ((tag->Flags() & JOURNAL_FLAG_ESCAPED) != 0) {
  1772. +                       // Block is escaped
  1773. +                       ((int32*)data)[0]
  1774. +                           = B_HOST_TO_BENDIAN_INT32(JOURNAL_MAGIC);
  1775. +                   }
  1776. +
  1777. +                   size_t written = write_pos(fFilesystemVolume->Device(),
  1778. +                       tag->BlockNumber() * fBlockSize, data, fBlockSize);
  1779. +
  1780. +                   if (written != fBlockSize) {
  1781. +                       delete [] data;
  1782. +                       return B_IO_ERROR;
  1783. +                   }
  1784. +
  1785. +                   ++count;
  1786. +               }
  1787. +
  1788. +               if ((tag->Flags() & JOURNAL_FLAG_LAST_TAG) != 0)
  1789. +                   break;
  1790. +               if ((tag->Flags() & JOURNAL_FLAG_SAME_UUID) == 0) {
  1791. +                   // TODO: Check new UUID with file system UUID
  1792. +                   tag += 2;
  1793. +                       // sizeof(JournalBlockTag) = 8
  1794. +                       // sizeof(UUID) = 16
  1795. +               }
  1796. +           }
  1797. +       }
  1798. +       else if (blockType == JOURNAL_COMMIT_BLOCK)
  1799. +           nextCommitID++;
  1800. +       else if (blockType != JOURNAL_REVOKE_BLOCK) {
  1801. +               // TODO: Warn that we found an unrecognized block
  1802. +           break;
  1803. +       } // If blockType == JOURNAL_REVOKE_BLOCK we just skip it
  1804. +
  1805. +       nextBlock = _WrapAroundLog(nextBlock + 1);
  1806. +
  1807. +       status = MapBlock(nextBlock, nextBlockPos);
  1808. +       if (status != B_OK)
  1809. +           return status;
  1810. +
  1811. +       header = (JournalHeader*)cached.SetTo(nextBlockPos);
  1812. +   }
  1813. +
  1814. +   delete [] data;
  1815. +
  1816. +   if (nextCommitID != lastCommitID) {
  1817. +       // Possibly because of some sort of IO error
  1818. +       return B_ERROR;
  1819. +   }
  1820. +
  1821. +   TRACE("Journal recovery pass replay: Replayed blocks: %u\n", count);
  1822. +
  1823. +   return B_OK;
  1824. +}
  1825. +
  1826. +
  1827. +status_t
  1828. +Journal::_FlushLog(bool canWait, bool flushBlocks)
  1829. +{
  1830. +   TRACE("Journal::_FlushLog()\n");
  1831. +   status_t status = canWait ? recursive_lock_lock(&fLock)
  1832. +       : recursive_lock_trylock(&fLock);
  1833. +   if (status != B_OK)
  1834. +       return status;
  1835. +
  1836. +   TRACE("Journal::_FlushLog(): Acquired fLock, recursion: %ld\n",
  1837. +       recursive_lock_get_recursion(&fLock));
  1838. +
  1839. +   if (recursive_lock_get_recursion(&fLock) > 1) {
  1840. +       // Called from inside a transaction
  1841. +       recursive_lock_unlock(&fLock);
  1842. +       TRACE("Journal::_FlushLog(): Called from a transaction. Leaving...\n");
  1843. +       return B_OK;
  1844. +   }
  1845. +
  1846. +   if (fUnwrittenTransactions != 0 && _FullTransactionSize() != 0) {
  1847. +       status = _WriteTransactionToLog();
  1848. +       if (status < B_OK)
  1849. +           panic("Failed flushing transaction: %s\n", strerror(status));
  1850. +   }
  1851. +
  1852. +   TRACE("Journal::_FlushLog(): Attempting to flush journal volume at %p\n",
  1853. +       fJournalVolume);
  1854. +
  1855. +   // TODO: Not sure this is correct. Need to review...
  1856. +   status = fJournalVolume->FlushDevice();
  1857. +   if (status != B_OK)
  1858. +       return status;
  1859. +
  1860. +   TRACE("Journal::_FlushLog(): Flushed journal volume\n");
  1861. +
  1862. +   if (flushBlocks) {
  1863. +       TRACE("Journal::_FlushLog(): Attempting to flush file system volume "
  1864. +           "at %p\n", fFilesystemVolume);
  1865. +       status = fFilesystemVolume->FlushDevice();
  1866. +       if (status == B_OK)
  1867. +           TRACE("Journal::_FlushLog(): Flushed file system volume\n");
  1868. +   }
  1869. +
  1870. +   TRACE("Journal::_FlushLog(): Finished. Releasing lock\n");
  1871. +
  1872. +   recursive_lock_unlock(&fLock);
  1873. +  
  1874. +   TRACE("Journal::_FlushLog(): Done, final status: %s\n", strerror(status));
  1875. +   return status;
  1876. +}
  1877. +
  1878. +
  1879. +inline uint32
  1880. +Journal::_WrapAroundLog(uint32 block)
  1881. +{
  1882. +   if (block >= fLogSize)
  1883. +       return block - fLogSize + fLogStart;
  1884. +   else
  1885. +       return block;
  1886. +}
  1887. +
  1888. +
  1889. +size_t
  1890. +Journal::_CurrentTransactionSize() const
  1891. +{
  1892. +   TRACE("Journal::_CurrentTransactionSize(): transaction %ld\n",
  1893. +       fTransactionID);
  1894. +
  1895. +   size_t count;
  1896. +
  1897. +   if (fHasSubTransaction) {
  1898. +       count = cache_blocks_in_sub_transaction(fFilesystemBlockCache,
  1899. +           fTransactionID);
  1900. +
  1901. +       TRACE("\tSub transaction size: %ld\n", count);
  1902. +   } else {
  1903. +       count =  cache_blocks_in_transaction(fFilesystemBlockCache,
  1904. +           fTransactionID);
  1905. +
  1906. +       TRACE("\tTransaction size: %ld\n", count);
  1907. +   }
  1908. +
  1909. +   return count;
  1910. +}
  1911. +
  1912. +
  1913. +size_t
  1914. +Journal::_FullTransactionSize() const
  1915. +{
  1916. +   TRACE("Journal::_FullTransactionSize(): transaction %ld\n", fTransactionID);
  1917. +   TRACE("\tFile sytem block cache: %p\n", fFilesystemBlockCache);
  1918. +
  1919. +   size_t count = cache_blocks_in_transaction(fFilesystemBlockCache,
  1920. +        fTransactionID);
  1921. +  
  1922. +   TRACE("\tFull transaction size: %ld\n", count);
  1923. +  
  1924. +   return count;
  1925. +}
  1926. +
  1927. +
  1928. +size_t
  1929. +Journal::_MainTransactionSize() const
  1930. +{
  1931. +   TRACE("Journal::_MainTransactionSize(): transaction %ld\n", fTransactionID);
  1932. +
  1933. +   size_t count =  cache_blocks_in_main_transaction(fFilesystemBlockCache,
  1934. +       fTransactionID);
  1935. +  
  1936. +   TRACE("\tMain transaction size: %ld\n", count);
  1937. +  
  1938. +   return count;
  1939. +}
  1940. +
  1941. +
  1942. +status_t
  1943. +Journal::_TransactionDone(bool success)
  1944. +{
  1945. +   if (!success) {
  1946. +       if (fHasSubTransaction) {
  1947. +           TRACE("Journal::_TransactionDone(): transaction %ld failed, "
  1948. +               "aborting subtransaction\n", fTransactionID);
  1949. +           cache_abort_sub_transaction(fFilesystemBlockCache, fTransactionID);
  1950. +           // parent is unaffected
  1951. +       } else {
  1952. +           TRACE("Journal::_TransactionDone(): transaction %ld failed,"
  1953. +               " aborting\n", fTransactionID);
  1954. +           cache_abort_transaction(fFilesystemBlockCache, fTransactionID);
  1955. +           fUnwrittenTransactions = 0;
  1956. +       }
  1957. +
  1958. +       return B_OK;
  1959. +   }
  1960. +  
  1961. +   // If possible, delay flushing the transaction
  1962. +   uint32 size = _FullTransactionSize();
  1963. +   if (fMaxTransactionSize > 0
  1964. +           && _FullTransactionSize() < fMaxTransactionSize) {
  1965. +       TRACE("Journal::_TransactionDone(): delaying flush of transaction "
  1966. +           "%ld\n", fTransactionID);
  1967. +      
  1968. +       // Make sure the transaction fits in the log
  1969. +       if (size < FreeLogBlocks())
  1970. +           cache_sync_transaction(fFilesystemBlockCache, fTransactionID);
  1971. +      
  1972. +       fUnwrittenTransactions++;
  1973. +       return B_OK;
  1974. +   }
  1975. +
  1976. +   return _WriteTransactionToLog();
  1977. +}
  1978. +
  1979. +
  1980. +/*static*/ void
  1981. +Journal::_TransactionWritten(int32 transactionID, int32 event, void* _logEntry)
  1982. +{
  1983. +   LogEntry* logEntry = (LogEntry*)_logEntry;
  1984. +
  1985. +   TRACE("Journal::_TransactionWritten(): Transaction %ld checkpointed\n",
  1986. +       transactionID);
  1987. +
  1988. +   Journal* journal = logEntry->GetJournal();
  1989. +
  1990. +   TRACE("Journal::_TransactionWritten(): log entry: %p, journal: %p\n",
  1991. +       logEntry, journal);
  1992. +   TRACE("Journal::_TransactionWritten(): log entries: %p\n",
  1993. +       &journal->fLogEntries);
  1994. +
  1995. +   mutex_lock(&journal->fLogEntriesLock);
  1996. +
  1997. +   TRACE("Journal::_TransactionWritten(): first log entry: %p\n",
  1998. +       journal->fLogEntries.First());
  1999. +   if (logEntry == journal->fLogEntries.First()) {
  2000. +       TRACE("Journal::_TransactionWritten(): second log entry: %p\n",
  2001. +           journal->fLogEntries.GetNext(logEntry));
  2002. +
  2003. +       LogEntry* next = journal->fLogEntries.GetNext(logEntry);
  2004. +
  2005. +       if (next != NULL) {
  2006. +           TRACE("Journal::_TransactionWritten(): Moving start of log to "
  2007. +               "%lu\n", next->Start());
  2008. +           journal->fLogStart = next->Start();
  2009. +       } else {
  2010. +           TRACE("Journal::_TransactionWritten(): Moving start of log to "
  2011. +               "%lu and setting commit ID to %lu\n", journal->fLogEnd,
  2012. +               logEntry->CommitID());
  2013. +           journal->fLogStart = journal->fLogEnd;
  2014. +           journal->fFirstCommitID = logEntry->CommitID();
  2015. +       }
  2016. +
  2017. +       if (journal->_SaveSuperBlock() != B_OK)
  2018. +           panic("ext2: Failed to write journal superblock\n");
  2019. +   }
  2020. +  
  2021. +   TRACE("Journal::_TransactionWritten(): Removing log entry\n");
  2022. +   journal->fLogEntries.Remove(logEntry);
  2023. +
  2024. +   TRACE("Journal::_TransactionWritten(): Unlocking entries list\n");
  2025. +   mutex_unlock(&journal->fLogEntriesLock);
  2026. +
  2027. +   TRACE("Journal::_TransactionWritten(): Deleting log entry\n");
  2028. +   delete logEntry;
  2029. +}
  2030. +
  2031. +
  2032. +/*static*/ void
  2033. +Journal::_TransactionIdle(int32 transactionID, int32 event, void* _journal)
  2034. +{
  2035. +   Journal* journal = (Journal*)_journal;
  2036. +   journal->_FlushLog(false, false);
  2037. +}
  2038.  
  2039. Property changes on: src/add-ons/kernel/file_systems/ext2/Journal.cpp
  2040. ___________________________________________________________________
  2041. Added: svn:executable
  2042.    + *
  2043.  
  2044. Index: src/add-ons/kernel/file_systems/ext2/NoJournal.h
  2045. ===================================================================
  2046. --- src/add-ons/kernel/file_systems/ext2/NoJournal.h    (revision 0)
  2047. +++ src/add-ons/kernel/file_systems/ext2/NoJournal.h    (revision 0)
  2048. @@ -0,0 +1,34 @@
  2049. +/*
  2050. + * Copyright 2001-2010, Haiku Inc. All rights reserved.
  2051. + * This file may be used under the terms of the MIT License.
  2052. + *
  2053. + * Authors:
  2054. + *     Janito V. Ferreira Filho
  2055. + */
  2056. +#ifndef NOJOURNAL_H
  2057. +#define NOJOURNAL_H
  2058. +
  2059. +
  2060. +#include "Journal.h"
  2061. +
  2062. +
  2063. +class NoJournal : public Journal {
  2064. +public:
  2065. +                       NoJournal(Volume* volume);
  2066. +                       ~NoJournal();
  2067. +
  2068. +           status_t    InitCheck();
  2069. +           status_t    Recover();
  2070. +           status_t    StartLog();
  2071. +          
  2072. +           status_t    Lock(Transaction* owner, bool separateSubTransactions);
  2073. +           status_t    Unlock(Transaction* owner, bool success);
  2074. +
  2075. +private:
  2076. +           status_t    _WriteTransactionToLog();
  2077. +
  2078. +   static  void        _TransactionWritten(int32 transactionID,
  2079. +                           int32 event, void* param);
  2080. +};
  2081. +
  2082. +#endif // NOJOURNAL_H
  2083. Index: src/add-ons/kernel/file_systems/ext2/HTree.h
  2084. ===================================================================
  2085. --- src/add-ons/kernel/file_systems/ext2/HTree.h    (revision 37534)
  2086. +++ src/add-ons/kernel/file_systems/ext2/HTree.h    (working copy)
  2087. @@ -9,8 +9,6 @@
  2088.  #define HTREE_H
  2089.  
  2090.  
  2091. -#include <AutoDeleter.h>
  2092. -
  2093.  #include "ext2.h"
  2094.  #include "DirectoryIterator.h"
  2095.  #include "HTreeEntryIterator.h"
  2096. @@ -127,7 +125,6 @@
  2097.             Inode*              fDirectory;
  2098.             uint32              fHashSeed[4];
  2099.             HTreeEntryIterator* fRootEntry;
  2100. -           ObjectDeleter<HTreeEntryIterator> fRootDeleter;
  2101.  };
  2102.  
  2103.  #endif // HTREE_H
  2104.  
  2105. Property changes on: src/add-ons/kernel/file_systems/ext2/HTree.h
  2106. ___________________________________________________________________
  2107. Added: svn:executable
  2108.    + *
  2109.  
  2110. Index: src/add-ons/kernel/file_systems/ext2/IndexedDirectoryIterator.cpp
  2111. ===================================================================
  2112. --- src/add-ons/kernel/file_systems/ext2/IndexedDirectoryIterator.cpp   (revision 37534)
  2113. +++ src/add-ons/kernel/file_systems/ext2/IndexedDirectoryIterator.cpp   (working copy)
  2114. @@ -15,6 +15,8 @@
  2115.  #include "Inode.h"
  2116.  
  2117.  
  2118. +//#define COLLISION_TEST
  2119. +
  2120.  //#define TRACE_EXT2
  2121.  #ifdef TRACE_EXT2
  2122.  #  define TRACE(x...) dprintf("\33[34mext2:\33[0m " x)
  2123. @@ -24,17 +26,18 @@
  2124.  
  2125.  
  2126.  IndexedDirectoryIterator::IndexedDirectoryIterator(off_t start,
  2127. -   uint32 blockSize, Inode* directory, HTreeEntryIterator* parent)
  2128. +   Inode* directory, HTreeEntryIterator* parent)
  2129.     :
  2130.     DirectoryIterator(directory),
  2131.     fIndexing(true),
  2132. -  
  2133.     fParent(parent),
  2134. -   fMaxOffset(start + blockSize),
  2135. -   fBlockSize(blockSize),
  2136. -   fMaxAttempts(0)
  2137. +   fMaxAttempts(0),
  2138. +   fPreviousBlock(start / fBlockSize)
  2139.  {
  2140. -   fOffset = start;
  2141. +   fDisplacement = start % fBlockSize;
  2142. +   fLogicalBlock = fPreviousBlock;
  2143. +
  2144. +   fInitStatus = fInode->FindBlock(fLogicalBlock * fBlockSize, fPhysicalBlock);
  2145.  }
  2146.  
  2147.  
  2148. @@ -46,16 +49,30 @@
  2149.  status_t
  2150.  IndexedDirectoryIterator::GetNext(char* name, size_t* nameLength, ino_t* id)
  2151.  {
  2152. -   if (fIndexing && fOffset + sizeof(HTreeFakeDirEntry) >= fMaxOffset) {
  2153. +   TRACE("IndexedDirectoryIterator::GetNext()\n");
  2154. +   if (fIndexing && fLogicalBlock != fPreviousBlock) {
  2155.         TRACE("IndexedDirectoryIterator::GetNext() calling next block\n");
  2156. -       status_t status = fParent->GetNext(fOffset);
  2157. +
  2158. +       if (!fParent->HasCollision()) {
  2159. +           TRACE("IndexedDirectoryIterator::GetNext(): next block doesn't "
  2160. +               "contain collisions from previous block\n");
  2161. +#ifndef COLLISION_TEST
  2162. +           return B_ENTRY_NOT_FOUND;
  2163. +#endif
  2164. +       }
  2165. +
  2166. +       fDisplacement = 0;
  2167. +       status_t status = fParent->GetNext(fLogicalBlock);
  2168.         if (status != B_OK)
  2169.             return status;
  2170.  
  2171. -       if (fMaxAttempts++ > 4)
  2172. -           return B_ERROR;
  2173. +       fPreviousBlock = fLogicalBlock;
  2174. +       status = fInode->FindBlock(fLogicalBlock * fBlockSize, fPhysicalBlock);
  2175. +       if (status != B_OK)
  2176. +           return status;
  2177.        
  2178. -       fMaxOffset = fOffset + fBlockSize;
  2179. +       /*if (fMaxAttempts++ > 4)
  2180. +           return B_ERROR;*/
  2181.     }
  2182.    
  2183.     return DirectoryIterator::GetNext(name, nameLength, id);
  2184. @@ -67,9 +84,25 @@
  2185.  {
  2186.     // The only way to rewind it is too loose indexing
  2187.    
  2188. -   fOffset = 0;
  2189. -   fMaxOffset = fInode->Size();
  2190. +   fLogicalBlock = 0;
  2191. +   fPreviousBlock = 0;
  2192. +   fDisplacement = 0;
  2193.     fIndexing = false;
  2194.  
  2195. -   return B_OK;
  2196. +   return fInode->FindBlock(fLogicalBlock, fPhysicalBlock);
  2197.  }
  2198. +
  2199. +
  2200. +status_t
  2201. +IndexedDirectoryIterator::AddEntry(Transaction& transaction, char* name,
  2202. +   size_t _nameLength, ino_t id)
  2203. +{
  2204. +   panic("Adding entries to a HTree is not supported yet.\n");
  2205. +
  2206. +   // TODO: Once the method DirectoryIterator::FindEmptyEntrySpot is
  2207. +   // implemented, we should call it to see if the offset exceeds the
  2208. +   // fMaxOffset. If it does, the current block is full, and we need
  2209. +   // to start splitting nodes.
  2210. +  
  2211. +   return B_NOT_SUPPORTED;
  2212. +}
  2213. Index: src/add-ons/kernel/file_systems/ext2/DirectoryIterator.h
  2214. ===================================================================
  2215. --- src/add-ons/kernel/file_systems/ext2/DirectoryIterator.h    (revision 37534)
  2216. +++ src/add-ons/kernel/file_systems/ext2/DirectoryIterator.h    (working copy)
  2217. @@ -8,7 +8,9 @@
  2218.  
  2219.  #include <SupportDefs.h>
  2220.  
  2221. +#include "Transaction.h"
  2222.  
  2223. +
  2224.  class Inode;
  2225.  
  2226.  class DirectoryIterator {
  2227. @@ -16,10 +18,15 @@
  2228.                         DirectoryIterator(Inode* inode);
  2229.     virtual             ~DirectoryIterator();
  2230.  
  2231. +   virtual status_t    InitCheck();
  2232. +
  2233.     virtual status_t    GetNext(char* name, size_t* _nameLength, ino_t* id);
  2234.  
  2235.     virtual status_t    Rewind();
  2236.  
  2237. +   virtual status_t    AddEntry(Transaction& transaction, char* name,
  2238. +                           size_t nameLength, ino_t id);
  2239. +
  2240.  private:
  2241.                         DirectoryIterator(const DirectoryIterator&);
  2242.                         DirectoryIterator &operator=(const DirectoryIterator&);
  2243. @@ -27,7 +34,12 @@
  2244.  
  2245.  protected:
  2246.     Inode*              fInode;
  2247. -   off_t               fOffset;
  2248. +   uint32              fLogicalBlock;
  2249. +   uint32              fPhysicalBlock;
  2250. +   uint32              fDisplacement;
  2251. +   uint32              fBlockSize;
  2252. +   status_t            fInitStatus;
  2253.  };
  2254.  
  2255.  #endif // DIRECTORY_ITERATOR_H
  2256. +
  2257. Index: src/add-ons/kernel/file_systems/ext2/RevokeManager.cpp
  2258. ===================================================================
  2259. --- src/add-ons/kernel/file_systems/ext2/RevokeManager.cpp  (revision 0)
  2260. +++ src/add-ons/kernel/file_systems/ext2/RevokeManager.cpp  (revision 0)
  2261. @@ -0,0 +1,38 @@
  2262. +/*
  2263. + * Copyright 2001-2010, Haiku Inc. All rights reserved.
  2264. + * This file may be used under the terms of the MIT License.
  2265. + *
  2266. + * Authors:
  2267. + *     Janito V. Ferreira Filho
  2268. + */
  2269. +
  2270. +#include "RevokeManager.h"
  2271. +
  2272. +
  2273. +RevokeManager::RevokeManager()
  2274. +   :
  2275. +   fRevokeCount(0)
  2276. +{
  2277. +}
  2278. +
  2279. +
  2280. +RevokeManager::~RevokeManager()
  2281. +{
  2282. +}
  2283. +
  2284. +
  2285. +status_t
  2286. +RevokeManager::ScanRevokeBlock(JournalRevokeHeader* revokeBlock, uint32 commitID)
  2287. +{
  2288. +   int count = revokeBlock->NumBytes() >> 3;
  2289. +  
  2290. +   for (int i = 0; i < count; ++i) {
  2291. +       status_t status = Insert(revokeBlock->RevokeBlock(i), commitID);
  2292. +      
  2293. +       if (status != B_OK)
  2294. +           return status;
  2295. +   }
  2296. +
  2297. +   return B_OK;
  2298. +}
  2299. +
  2300.  
  2301. Property changes on: src/add-ons/kernel/file_systems/ext2/RevokeManager.cpp
  2302. ___________________________________________________________________
  2303. Added: svn:executable
  2304.    + *
  2305.  
  2306. Index: src/add-ons/kernel/file_systems/ext2/Jamfile
  2307. ===================================================================
  2308. --- src/add-ons/kernel/file_systems/ext2/Jamfile    (revision 37534)
  2309. +++ src/add-ons/kernel/file_systems/ext2/Jamfile    (working copy)
  2310. @@ -18,6 +18,15 @@
  2311.     IndexedDirectoryIterator.cpp
  2312.     HTree.cpp
  2313.     HTreeEntryIterator.cpp
  2314. +   RevokeManager.cpp
  2315. +   HashRevokeManager.cpp
  2316. +   Journal.cpp
  2317. +   NoJournal.cpp
  2318. +   InodeJournal.cpp
  2319. +   Transaction.cpp
  2320. +   BitmapBlock.cpp
  2321. +   BlockAllocator.cpp
  2322. +   InodeAllocator.cpp
  2323.  
  2324.     kernel_interface.cpp
  2325.  ;
  2326. Index: src/add-ons/kernel/file_systems/ext2/BitmapBlock.cpp
  2327. ===================================================================
  2328. --- src/add-ons/kernel/file_systems/ext2/BitmapBlock.cpp    (revision 0)
  2329. +++ src/add-ons/kernel/file_systems/ext2/BitmapBlock.cpp    (revision 0)
  2330. @@ -0,0 +1,569 @@
  2331. +/*
  2332. + * Copyright 2001-2010, Haiku Inc. All rights reserved.
  2333. + * This file may be used under the terms of the MIT License.
  2334. + *
  2335. + * Authors:
  2336. + *     Janito V. Ferreira Filho
  2337. + */
  2338. +
  2339. +#include "BitmapBlock.h"
  2340. +
  2341. +
  2342. +//#define TRACE_EXT2
  2343. +#ifdef TRACE_EXT2
  2344. +#  define TRACE(x...) dprintf("\33[34mext2:\33[0m " x)
  2345. +#else
  2346. +#  define TRACE(x...) ;
  2347. +#endif
  2348. +
  2349. +
  2350. +BitmapBlock::BitmapBlock(Volume* volume, uint32 numBits)
  2351. +   :
  2352. +   CachedBlock(volume),
  2353. +   fData(NULL),
  2354. +   fReadOnlyData(NULL),
  2355. +   fNumBits(numBits)
  2356. +{
  2357. +   TRACE("BitmapBlock::BitmapBlock(): num bits: %lu\n", fNumBits);
  2358. +}
  2359. +
  2360. +
  2361. +BitmapBlock::~BitmapBlock()
  2362. +{
  2363. +}
  2364. +
  2365. +
  2366. +/*virtual*/ bool
  2367. +BitmapBlock::SetTo(uint32 block)
  2368. +{
  2369. +   fData = NULL;
  2370. +   fReadOnlyData = (uint32*)CachedBlock::SetTo(block);
  2371. +
  2372. +   return fReadOnlyData != NULL;
  2373. +}
  2374. +
  2375. +
  2376. +/*virtual*/ bool
  2377. +BitmapBlock::SetToWritable(Transaction& transaction, uint32 block, bool empty)
  2378. +{
  2379. +   fReadOnlyData = NULL;
  2380. +   fData = (uint32*)CachedBlock::SetToWritable(transaction, block, empty);
  2381. +
  2382. +   return fData != NULL;
  2383. +}
  2384. +
  2385. +
  2386. +/*virtual*/ bool
  2387. +BitmapBlock::CheckUnmarked(uint32 start, uint32 length)
  2388. +{
  2389. +   const uint32* data = fData == NULL ? fReadOnlyData : fData;
  2390. +   if (data == NULL)
  2391. +       return false;
  2392. +
  2393. +   if (start + length > fNumBits)
  2394. +       return false;
  2395. +
  2396. +   uint32 startIndex = start >> 5;
  2397. +   uint32 startBit = start & 0x1F;
  2398. +   uint32 iterations = (length - startBit) >> 5;
  2399. +   uint32 remainingBits = (length - startBit) & 0x1F;
  2400. +
  2401. +   uint32 index = startIndex;
  2402. +   uint32 mask = 0;
  2403. +
  2404. +   if (startBit != 0) {
  2405. +       mask = ~((1 << startBit) - 1);
  2406. +       uint32 bits = B_LENDIAN_TO_HOST_INT32(data[index]);
  2407. +
  2408. +       if ((bits & mask) != 0)
  2409. +           return false;
  2410. +
  2411. +       index += 1;
  2412. +   }
  2413. +
  2414. +   for (; iterations > 0; --iterations) {
  2415. +       if (data[index++] != 0)
  2416. +           return false;
  2417. +   }
  2418. +
  2419. +   if (remainingBits != 0) {
  2420. +       mask = (1 << remainingBits + 1) - 1;
  2421. +
  2422. +       uint32 bits = B_LENDIAN_TO_HOST_INT32(data[index]);
  2423. +       if ((bits & mask) != 0)
  2424. +           return false;
  2425. +   }
  2426. +
  2427. +   return true;
  2428. +}
  2429. +
  2430. +
  2431. +/*virtual*/ bool
  2432. +BitmapBlock::CheckMarked(uint32 start, uint32 length)
  2433. +{
  2434. +   const uint32* data = fData == NULL ? fReadOnlyData : fData;
  2435. +   if (data == NULL)
  2436. +       return false;
  2437. +
  2438. +   if (start + length > fNumBits)
  2439. +       return false;
  2440. +
  2441. +   uint32 startIndex = start >> 5;
  2442. +   uint32 startBit = start & 0x1F;
  2443. +   uint32 iterations = (length - startBit) >> 5;
  2444. +   uint32 remainingBits = (length - startBit) & 0x1F;
  2445. +
  2446. +   uint32 index = startIndex;
  2447. +   uint32 mask = 0;
  2448. +
  2449. +   if (startBit != 0) {
  2450. +       mask = ~((1 << startBit) - 1);
  2451. +       uint32 bits = B_LENDIAN_TO_HOST_INT32(data[index]);
  2452. +
  2453. +       if ((bits & mask) != mask)
  2454. +           return false;
  2455. +
  2456. +       index += 1;
  2457. +   }
  2458. +
  2459. +   mask = 0xFFFFFFFF;
  2460. +   for (; iterations > 0; --iterations) {
  2461. +       if (data[index++] != mask)
  2462. +           return false;
  2463. +   }
  2464. +
  2465. +   if (remainingBits != 0) {
  2466. +       mask = (1 << remainingBits + 1) - 1;
  2467. +       uint32 bits = B_HOST_TO_LENDIAN_INT32(data[index]);
  2468. +
  2469. +       if ((bits & mask) != mask)
  2470. +           return false;
  2471. +   }
  2472. +
  2473. +   return true;
  2474. +}
  2475. +
  2476. +
  2477. +/*virtual*/ bool
  2478. +BitmapBlock::Mark(uint32 start, uint32 length, bool force)
  2479. +{
  2480. +   if (fData == NULL || start + length > fNumBits)
  2481. +       return false;
  2482. +
  2483. +   uint32 startIndex = start >> 5;
  2484. +   uint32 startBit = start & 0x1F;
  2485. +   uint32 iterations = (length - 32 + startBit) >> 5;
  2486. +   uint32 remainingBits = (length - 32 + startBit) & 0x1F;
  2487. +
  2488. +   uint32 index = startIndex;
  2489. +   uint32 mask = 0;
  2490. +  
  2491. +   TRACE("BitmapBlock::Mark(): start: %lu, length: %lu, startIndex: %lu, "
  2492. +       "startBit: %lu, iterations: %lu, remainingBits: %lu\n", start, length,
  2493. +       startIndex, startBit, iterations, remainingBits);
  2494. +
  2495. +   if (startBit != 0) {
  2496. +       mask = ~((1 << startBit) - 1);
  2497. +       uint32 bits = B_LENDIAN_TO_HOST_INT32(fData[index]);
  2498. +      
  2499. +       TRACE("BitmapBlock::Mark(): mask: %lX, bits: %lX\n", mask, bits);
  2500. +
  2501. +       if (!force && (bits & mask) != 0)
  2502. +           return false;
  2503. +
  2504. +       bits |= mask;
  2505. +       fData[index] = B_HOST_TO_LENDIAN_INT32(bits);
  2506. +
  2507. +       index += 1;
  2508. +   }
  2509. +
  2510. +   mask = 0xFFFFFFFF;
  2511. +   for (; iterations > 0; --iterations) {
  2512. +       if (!force && fData[index] != 0)
  2513. +           return false;
  2514. +       fData[index++] |= mask;
  2515. +   }
  2516. +
  2517. +   if (remainingBits != 0) {
  2518. +       mask = (1 << remainingBits) - 1;
  2519. +       uint32 bits = B_LENDIAN_TO_HOST_INT32(fData[index]);
  2520. +       TRACE("BitmapBlock::(): marking remaining %lu bits: %lX, mask: %lX\n",
  2521. +           remainingBits, bits, mask);
  2522. +
  2523. +       if (!force && (bits & mask) != 0)
  2524. +           return false;
  2525. +
  2526. +       bits |= mask;
  2527. +       fData[index] = B_HOST_TO_LENDIAN_INT32(bits);
  2528. +   }
  2529. +
  2530. +   return true;
  2531. +}
  2532. +
  2533. +
  2534. +/*virtual*/ bool
  2535. +BitmapBlock::Unmark(uint32 start, uint32 length, bool force)
  2536. +{
  2537. +   if (fData == NULL || start + length > fNumBits)
  2538. +       return false;
  2539. +
  2540. +   uint32 startIndex = start >> 5;
  2541. +   uint32 startBit = start & 0x1F;
  2542. +   uint32 iterations = (length - 32 + startBit) >> 5;
  2543. +   uint32 remainingBits = (length - 32 + startBit) & 0x1F;
  2544. +
  2545. +   uint32 index = startIndex;
  2546. +   uint32 mask = 0;
  2547. +
  2548. +   if (startBit != 0) {
  2549. +       mask = ~((1 << startBit) - 1);
  2550. +       uint32 bits = B_LENDIAN_TO_HOST_INT32(fData[index]);
  2551. +
  2552. +       if (!force && (bits & mask) != mask)
  2553. +           return false;
  2554. +
  2555. +       bits &= ~mask;
  2556. +       fData[index] = B_HOST_TO_LENDIAN_INT32(bits);
  2557. +
  2558. +       index += 1;
  2559. +   }
  2560. +
  2561. +   mask = 0xFFFFFFFF;
  2562. +   for (; iterations > 0; --iterations) {
  2563. +       if (!force && fData[index] != mask)
  2564. +           return false;
  2565. +       fData[index++] = 0;
  2566. +   }
  2567. +
  2568. +   if (remainingBits != 0) {
  2569. +       mask = (1 << remainingBits) - 1;
  2570. +       uint32 bits = B_LENDIAN_TO_HOST_INT32(fData[index]);
  2571. +
  2572. +       if (!force && (bits & mask) != mask)
  2573. +           return false;
  2574. +
  2575. +       bits &= ~mask;
  2576. +       fData[index] = B_HOST_TO_LENDIAN_INT32(bits);
  2577. +   }
  2578. +
  2579. +   return true;
  2580. +}
  2581. +
  2582. +
  2583. +void
  2584. +BitmapBlock::FindNextMarked(uint32& pos)
  2585. +{
  2586. +   TRACE("BitmapBlock::FindNextMarked(): pos: %lu\n", pos);
  2587. +
  2588. +   const uint32* data = fData == NULL ? fReadOnlyData : fData;
  2589. +   if (data == NULL)
  2590. +       return;
  2591. +
  2592. +   if (pos >= fNumBits) {
  2593. +       pos = fNumBits;
  2594. +       return;
  2595. +   }
  2596. +
  2597. +   uint32 index = pos >> 5;
  2598. +   uint32 bit = pos & 0x1F;
  2599. +
  2600. +   uint32 mask = (1 << bit) - 1;
  2601. +   uint32 bits = B_LENDIAN_TO_HOST_INT32(data[index]);
  2602. +
  2603. +   TRACE("BitmapBlock::FindNextMarked(): index: %lu, bit: %lu, mask: %lX, "
  2604. +       "bits: %lX\n", index, bit, mask, bits);
  2605. +
  2606. +   bits = bits & ~mask;
  2607. +
  2608. +   if (bits == 0) {
  2609. +       // Find an block of 32 bits that has a marked bit
  2610. +       uint32 maxIndex = fNumBits >> 5;
  2611. +       TRACE("BitmapBlock::FindNextMarked(): max index: %lu\n", maxIndex);
  2612. +
  2613. +       do {
  2614. +           index++;
  2615. +       } while (index < maxIndex && data[index] == 0);
  2616. +
  2617. +       if (index >= maxIndex) {
  2618. +           // Not found
  2619. +           TRACE("BitmapBlock::FindNextMarked(): reached end of block, num "
  2620. +               "bits: %lu\n", fNumBits);
  2621. +           pos = fNumBits;
  2622. +           return;
  2623. +       }
  2624. +
  2625. +       bits = B_LENDIAN_TO_HOST_INT32(data[index]);
  2626. +       bit = 0;
  2627. +   }
  2628. +
  2629. +   for (; bit < 32; ++bit) {
  2630. +       // Find the marked bit
  2631. +       if ((bits >> bit & 1) != 0) {
  2632. +           pos = index << 5 | bit;
  2633. +           TRACE("BitmapBlock::FindNextMarked(): found bit: %lu\n", pos);
  2634. +           return;
  2635. +       }
  2636. +   }
  2637. +
  2638. +   panic("Couldn't find marked bit inside an int32 which is different than "
  2639. +       "zero!?\n");
  2640. +}
  2641. +
  2642. +
  2643. +void
  2644. +BitmapBlock::FindNextUnmarked(uint32& pos)
  2645. +{
  2646. +   TRACE("BitmapBlock::FindNextUnmarked(): pos: %lu\n", pos);
  2647. +
  2648. +   const uint32* data = fData == NULL ? fReadOnlyData : fData;
  2649. +   if (data == NULL)
  2650. +       return;
  2651. +
  2652. +   if (pos >= fNumBits) {
  2653. +       pos = fNumBits;
  2654. +       return;
  2655. +   }
  2656. +
  2657. +   uint32 index = pos >> 5;
  2658. +   uint32 bit = pos & 0x1F;
  2659. +
  2660. +   uint32 mask = (1 << bit) - 1;
  2661. +   uint32 bits = B_LENDIAN_TO_HOST_INT32(data[index]);
  2662. +
  2663. +   TRACE("BitmapBlock::FindNextUnmarked(): index: %lu, bit: %lu, mask: %lX, "
  2664. +       "bits: %lX\n", index, bit, mask, bits);
  2665. +
  2666. +   bits &= ~mask;
  2667. +
  2668. +   if (bits == ~mask) {
  2669. +       // Find an block of 32 bits that has a unmarked bit
  2670. +       uint32 maxIndex = fNumBits >> 5;
  2671. +       TRACE("BitmapBlock::FindNextUnmarked(): max index: %lu\n", maxIndex);
  2672. +
  2673. +       do {
  2674. +           index++;
  2675. +       } while (index < maxIndex && data[index] == 0xFFFFFFFF);
  2676. +
  2677. +       if (index >= maxIndex) {
  2678. +           // Not found
  2679. +           TRACE("BitmapBlock::FindNextUnmarked(): reached end of block, num "
  2680. +               "bits: %lu\n", fNumBits);
  2681. +           pos = fNumBits;
  2682. +           return;
  2683. +       }
  2684. +
  2685. +       bits = B_LENDIAN_TO_HOST_INT32(data[index]);
  2686. +       bit = 0;
  2687. +   }
  2688. +
  2689. +   for (; bit < 32; ++bit) {
  2690. +       // Find the unmarked bit
  2691. +       if ((bits >> bit & 1) == 0) {
  2692. +           pos = index << 5 | bit;
  2693. +           TRACE("BitmapBlock::FindNextUnmarked(): found bit: %lu\n", pos);
  2694. +           return;
  2695. +       }
  2696. +   }
  2697. +
  2698. +   panic("Couldn't find unmarked bit inside an int32 whith value zero!?\n");
  2699. +}
  2700. +
  2701. +
  2702. +void
  2703. +BitmapBlock::FindPreviousMarked(uint32& pos)
  2704. +{
  2705. +   const uint32* data = fData == NULL ? fReadOnlyData : fData;
  2706. +   if (data == NULL)
  2707. +       return;
  2708. +
  2709. +   if (pos >= fNumBits)
  2710. +       pos = fNumBits;
  2711. +
  2712. +   if (pos == 0)
  2713. +       return;
  2714. +
  2715. +   uint32 index = pos >> 5;
  2716. +   uint32 bit = pos & 0x1F;
  2717. +
  2718. +   uint32 mask = (1 << bit + 1) - 1;
  2719. +   uint32 bits = B_LENDIAN_TO_HOST_INT32(data[index]);
  2720. +   bits = bits & mask;
  2721. +
  2722. +   if (bits == 0) {
  2723. +       // Find an block of 32 bits that has a marked bit
  2724. +       do { index--; }
  2725. +           while (data[index] == 0 && index >= 0);
  2726. +
  2727. +       bits = B_LENDIAN_TO_HOST_INT32(data[index]);
  2728. +       if (bits == 0) {
  2729. +           // Not found
  2730. +           pos = 0;
  2731. +           return;
  2732. +       }
  2733. +
  2734. +       bit = 31;
  2735. +   }
  2736. +
  2737. +   for (; bit >= 0; --bit) {
  2738. +       // Find the unmarked bit
  2739. +       if ((bits >> bit & 1) == 0) {
  2740. +           pos = index << 5 | bit;
  2741. +           return;
  2742. +       }
  2743. +   }
  2744. +
  2745. +   panic("Couldn't find marked bit inside an int32 whith value different than "
  2746. +       "zero!?\n");
  2747. +}
  2748. +
  2749. +
  2750. +void
  2751. +BitmapBlock::FindLargestUnmarkedRange(uint32& start, uint32& length)
  2752. +{
  2753. +   const uint32* data = fData == NULL ? fReadOnlyData : fData;
  2754. +   if (data == NULL)
  2755. +       return;
  2756. +
  2757. +   uint32 wordSpan = length >> 5;
  2758. +   uint32 lastIndex = fNumBits >> 5;
  2759. +   uint32 startIndex = 0;
  2760. +   uint32 index = 0;
  2761. +   uint32 bits = B_LENDIAN_TO_HOST_INT32(data[0]);
  2762. +
  2763. +   TRACE("BitmapBlock::FindLargestUnmarkedRange(): word span: %lu, last "
  2764. +       "index: %lu, start index: %lu, index: %lu, bits: %lX, start: %lu, "
  2765. +       "length: %lu\n", wordSpan, lastIndex, startIndex, index, bits, start,
  2766. +       length);
  2767. +
  2768. +   if (wordSpan == 0) {
  2769. +       uint32 startPos = 0;
  2770. +       uint32 endPos = 0;
  2771. +
  2772. +       while (endPos < fNumBits) {
  2773. +           FindNextUnmarked(startPos);
  2774. +           endPos = startPos;
  2775. +
  2776. +           if (startPos != fNumBits) {
  2777. +               FindNextMarked(endPos);
  2778. +
  2779. +               uint32 newLength = endPos - startPos;
  2780. +
  2781. +               if (newLength > length) {
  2782. +                   start = startPos;
  2783. +                   length = newLength;
  2784. +                   TRACE("BitmapBlock::FindLargestUnmarkedRange(): Found "
  2785. +                       "larger length %lu starting at %lu\n", length, start);
  2786. +               }
  2787. +
  2788. +               startPos = endPos;
  2789. +
  2790. +               if (newLength >= 32)
  2791. +                   break;
  2792. +           }
  2793. +       }
  2794. +      
  2795. +       if (endPos >= fNumBits)
  2796. +           return;
  2797. +
  2798. +       wordSpan = length >> 5;
  2799. +       startIndex = startPos >> 5;
  2800. +       index = (endPos >> 5) + 1;
  2801. +       bits = B_LENDIAN_TO_HOST_INT32(data[index]);
  2802. +   }
  2803. +
  2804. +   for (; index < lastIndex; ++index) {
  2805. +       bits = B_LENDIAN_TO_HOST_INT32(data[index]);
  2806. +
  2807. +       if (bits != 0) {
  2808. +           // Contains marked bits
  2809. +           if (index - startIndex >= wordSpan) {
  2810. +               uint32 newLength = index - startIndex - 1 << 5;
  2811. +               uint32 newStart = startIndex + 1 << 5;
  2812. +
  2813. +               uint32 startBits =
  2814. +                   B_LENDIAN_TO_HOST_INT32(data[startIndex]);
  2815. +
  2816. +               for (int32 bit = 31; bit >= 0; --bit) {
  2817. +                   if ((startBits >> bit & 1) != 0)
  2818. +                       break;
  2819. +
  2820. +                   ++newLength;
  2821. +                   --newStart;
  2822. +               }
  2823. +
  2824. +               for (int32 bit = 0; bit < 32; ++bit) {
  2825. +                   if ((bits >> bit & 1) != 0)
  2826. +                       break;
  2827. +
  2828. +                   ++newLength;
  2829. +               }
  2830. +
  2831. +               if (newLength > length) {
  2832. +                   start = newStart;
  2833. +                   length = newLength;
  2834. +                   wordSpan = length >> 5;
  2835. +                  
  2836. +                   TRACE("BitmapBlock::FindLargestUnmarkedRange(): Found "
  2837. +                       "larger length %lu starting at %lu; word span: "
  2838. +                       "%lu\n", length, start, wordSpan);
  2839. +               }
  2840. +           }
  2841. +
  2842. +           startIndex = index;
  2843. +       }
  2844. +   }
  2845. +  
  2846. +   --index;
  2847. +
  2848. +   if (index - startIndex >= wordSpan) {
  2849. +       uint32 newLength = index - startIndex << 5;
  2850. +       uint32 newStart = startIndex + 1 << 5;
  2851. +      
  2852. +       TRACE("BitmapBlock::FindLargestUnmarkedRange(): Possibly found a "
  2853. +           "larger range. index: %lu, start index: %lu, word span: %lu, "
  2854. +           "new length: %lu, new start: %lu\n", index, startIndex, wordSpan,
  2855. +           newLength, newStart);
  2856. +
  2857. +       if (newStart != 0) {
  2858. +           uint32 startBits = B_LENDIAN_TO_HOST_INT32(data[startIndex]);
  2859. +          
  2860. +           TRACE("BitmapBlock::FindLargestUnmarkedRange(): start bits: %lu\n",
  2861. +               startBits);
  2862. +
  2863. +           for (int32 bit = 31; bit >= 0; --bit) {
  2864. +               if ((startBits >> bit & 1) != 0)
  2865. +                   break;
  2866. +
  2867. +               ++newLength;
  2868. +               --newStart;
  2869. +           }
  2870. +          
  2871. +           TRACE("BitmapBlock::FindLargestUnmarkedRange(): updated new start "
  2872. +               "to %lu and new length to %lu\n", newStart, newLength);
  2873. +       }
  2874. +
  2875. +       for (int32 bit = 0; bit < 32; ++bit) {
  2876. +           if ((bits >> bit & 1) == 0)
  2877. +               break;
  2878. +
  2879. +           ++newLength;
  2880. +       }
  2881. +      
  2882. +       TRACE("BitmapBlock::FindLargestUnmarkedRange(): updated new length to "
  2883. +           "%lu\n", newLength);
  2884. +
  2885. +       if (newLength > length) {
  2886. +           start = newStart;
  2887. +           length = newLength;
  2888. +           TRACE("BitmapBlock::FindLargestUnmarkedRange(): Found "
  2889. +               "largest length %lu starting at %lu\n", length, start);
  2890. +       }
  2891. +   }
  2892. +}
  2893. +
  2894. +
  2895. +uint32
  2896. +BitmapBlock::NumBits() const
  2897. +{
  2898. +   return fNumBits;
  2899. +}
  2900.  
  2901. Property changes on: src/add-ons/kernel/file_systems/ext2/BitmapBlock.cpp
  2902. ___________________________________________________________________
  2903. Added: svn:executable
  2904.    + *
  2905.  
  2906. Index: src/add-ons/kernel/file_systems/ext2/InodeJournal.cpp
  2907. ===================================================================
  2908. --- src/add-ons/kernel/file_systems/ext2/InodeJournal.cpp   (revision 0)
  2909. +++ src/add-ons/kernel/file_systems/ext2/InodeJournal.cpp   (revision 0)
  2910. @@ -0,0 +1,80 @@
  2911. +/*
  2912. + * Copyright 2001-2010, Haiku Inc. All rights reserved.
  2913. + * This file may be used under the terms of the MIT License.
  2914. + *
  2915. + * Authors:
  2916. + *     Janito V. Ferreira Filho
  2917. + */
  2918. +
  2919. +#include "InodeJournal.h"
  2920. +
  2921. +#include <new>
  2922. +
  2923. +#include <fs_cache.h>
  2924. +
  2925. +#include "HashRevokeManager.h"
  2926. +
  2927. +
  2928. +//#define TRACE_EXT2
  2929. +#ifdef TRACE_EXT2
  2930. +#  define TRACE(x...) dprintf("\33[34mext2:\33[0m " x)
  2931. +#else
  2932. +#  define TRACE(x...) ;
  2933. +#endif
  2934. +
  2935. +
  2936. +InodeJournal::InodeJournal(Inode* inode)
  2937. +   :
  2938. +   Journal(),
  2939. +   fInode(inode)
  2940. +{
  2941. +   if (inode == NULL)
  2942. +       fInitStatus = B_BAD_DATA;
  2943. +   else {
  2944. +       Volume* volume = inode->GetVolume();
  2945. +
  2946. +       fFilesystemVolume = volume;
  2947. +       fFilesystemBlockCache = volume->BlockCache();
  2948. +       fJournalVolume = volume;
  2949. +       fJournalBlockCache = volume->BlockCache();
  2950. +
  2951. +       if (!inode->IsFileCacheDisabled())
  2952. +           fInitStatus = inode->DisableFileCache();
  2953. +       else
  2954. +           fInitStatus = B_OK;
  2955. +      
  2956. +       if (fInitStatus == B_OK) {
  2957. +           TRACE("InodeJournal::InodeJournal(): Inode's file cache disabled "
  2958. +               "successfully\n");
  2959. +           fRevokeManager = new(std::nothrow) HashRevokeManager;
  2960. +
  2961. +           if (fRevokeManager == NULL) {
  2962. +               TRACE("InodeJournal::InodeJournal(): Insufficient memory to "
  2963. +                   "create the hash revoke manager\n");
  2964. +               fInitStatus = B_NO_MEMORY;
  2965. +           } else
  2966. +               fInitStatus = _LoadSuperBlock();
  2967. +       }
  2968. +   }
  2969. +}
  2970. +
  2971. +
  2972. +InodeJournal::~InodeJournal()
  2973. +{
  2974. +}
  2975. +
  2976. +
  2977. +status_t
  2978. +InodeJournal::InitCheck()
  2979. +{
  2980. +   if (fInitStatus != B_OK)
  2981. +       TRACE("InodeJournal: Initialization error\n");
  2982. +   return fInitStatus;
  2983. +}
  2984. +
  2985. +
  2986. +status_t
  2987. +InodeJournal::MapBlock(uint32 logical, uint32& physical)
  2988. +{
  2989. +   return fInode->FindBlock(logical * fBlockSize, physical);
  2990. +}
  2991. Index: src/add-ons/kernel/file_systems/ext2/Transaction.h
  2992. ===================================================================
  2993. --- src/add-ons/kernel/file_systems/ext2/Transaction.h  (revision 0)
  2994. +++ src/add-ons/kernel/file_systems/ext2/Transaction.h  (revision 0)
  2995. @@ -0,0 +1,72 @@
  2996. +/*
  2997. + * Copyright 2001-2010, Haiku Inc. All rights reserved.
  2998. + * This file may be used under the terms of the MIT License.
  2999. + *
  3000. + * Authors:
  3001. + *     Janito V. Ferreira Filho
  3002. + */
  3003. +#ifndef TRANSACTION_H
  3004. +#define TRANSACTION_H
  3005. +
  3006. +
  3007. +#include <util/DoublyLinkedList.h>
  3008. +
  3009. +
  3010. +class Journal;
  3011. +class Volume;
  3012. +
  3013. +
  3014. +class TransactionListener
  3015. +   : public DoublyLinkedListLinkImpl<TransactionListener> {
  3016. +public:
  3017. +                               TransactionListener();
  3018. +   virtual                     ~TransactionListener();
  3019. +
  3020. +   virtual void                TransactionDone(bool success) = 0;
  3021. +   virtual void                RemovedFromTransaction() = 0;
  3022. +};
  3023. +
  3024. +typedef DoublyLinkedList<TransactionListener> TransactionListeners;
  3025. +
  3026. +
  3027. +class Transaction {
  3028. +public:
  3029. +                                   Transaction();
  3030. +                                   Transaction(Journal* journal);
  3031. +                                   ~Transaction();
  3032. +
  3033. +           status_t                Start(Journal* journal);
  3034. +           status_t                Done(bool success = true);
  3035. +
  3036. +           bool                    IsStarted() const;
  3037. +           bool                    HasParent() const;
  3038. +
  3039. +           status_t                WriteBlocks(off_t blockNumber,
  3040. +                                       const uint8* buffer,
  3041. +                                       size_t numBlocks = 1);
  3042. +
  3043. +           void                    Split();
  3044. +
  3045. +           Volume*                 GetVolume() const;
  3046. +           int32                   ID() const;
  3047. +
  3048. +           void                    AddListener(TransactionListener* listener);
  3049. +           void                    RemoveListener(
  3050. +                                       TransactionListener* listener);
  3051. +
  3052. +           void                    NotifyListeners(bool success);
  3053. +           void                    MoveListenersTo(Transaction* transaction);
  3054. +          
  3055. +           void                    SetParent(Transaction* transaction);
  3056. +           Transaction*            Parent() const;
  3057. +private:
  3058. +                                   Transaction(const Transaction& other);
  3059. +           Transaction&            operator=(const Transaction& other);
  3060. +               // no implementation
  3061. +
  3062. +           Journal*                fJournal;
  3063. +           TransactionListeners    fListeners;
  3064. +           Transaction*            fParent;
  3065. +};
  3066. +
  3067. +#endif // TRANSACTION_H
  3068. Index: src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp
  3069. ===================================================================
  3070. --- src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp (revision 0)
  3071. +++ src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp (revision 0)
  3072. @@ -0,0 +1,653 @@
  3073. +/*
  3074. + * Copyright 2001-2010, Haiku Inc. All rights reserved.
  3075. + * This file may be used under the terms of the MIT License.
  3076. + *
  3077. + * Authors:
  3078. + *     Janito V. Ferreira Filho
  3079. + */
  3080. +
  3081. +#include "BlockAllocator.h"
  3082. +
  3083. +#include <util/AutoLock.h>
  3084. +
  3085. +#include "BitmapBlock.h"
  3086. +#include "Inode.h"
  3087. +
  3088. +
  3089. +//#define TRACE_EXT2
  3090. +#ifdef TRACE_EXT2
  3091. +#  define TRACE(x...) dprintf("\33[34mext2:\33[0m " x)
  3092. +#else
  3093. +#  define TRACE(x...) ;
  3094. +#endif
  3095. +
  3096. +
  3097. +class AllocationBlockGroup : public TransactionListener {
  3098. +public:
  3099. +                       AllocationBlockGroup();
  3100. +                       ~AllocationBlockGroup();
  3101. +
  3102. +           status_t    Initialize(Volume* v, uint32 blockGroup,
  3103. +                           uint32 numBits);
  3104. +
  3105. +           status_t    ScanFreeRanges();
  3106. +           bool        IsFull() const;
  3107. +
  3108. +           status_t    Allocate(Transaction& transaction, uint32 start,
  3109. +                           uint32 length);
  3110. +           status_t    Free(Transaction& transaction, uint32 start,
  3111. +                           uint32 length);
  3112. +           status_t    FreeAll(Transaction& transaction);
  3113. +           status_t    Check(uint32 start, uint32 length);
  3114. +
  3115. +           uint32      NumBits() const;
  3116. +           uint32      FreeBits() const;
  3117. +           uint32      Start() const;
  3118. +
  3119. +           uint32      LargestStart() const;
  3120. +           uint32      LargestLength() const;
  3121. +
  3122. +           // TransactionListener implementation
  3123. +           void        TransactionDone(bool success);
  3124. +           void        RemovedFromTransaction();
  3125. +
  3126. +private:
  3127. +           void        _AddFreeRange(uint32 start, uint32 length);
  3128. +
  3129. +
  3130. +           Volume*     fVolume;
  3131. +
  3132. +           uint32      fStart;
  3133. +           uint32      fNumBits;
  3134. +           uint32      fBitmapBlock;
  3135. +
  3136. +           uint32      fFreeBits;
  3137. +           uint32      fFirstFree;
  3138. +           uint32      fLargestStart;
  3139. +           uint32      fLargestLength;
  3140. +          
  3141. +           uint32      fPreviousFreeBits;
  3142. +           uint32      fPreviousFirstFree;
  3143. +           uint32      fPreviousLargestStart;
  3144. +           uint32      fPreviousLargestLength;
  3145. +};
  3146. +
  3147. +
  3148. +class BlockAllocatorTransactionListener : public TransactionListener {
  3149. +public:
  3150. +                       BlockAllocatorTransactionListener(
  3151. +                           BlockAllocator* allocator, uint32 blocks);
  3152. +                       ~BlockAllocatorTransactionListener();
  3153. +
  3154. +           void        TransactionDone(bool success);
  3155. +           void        RemovedFromTransaction();
  3156. +private:
  3157. +           BlockAllocator* fAllocator;
  3158. +           uint32      fBlockAffected;
  3159. +};
  3160. +
  3161. +
  3162. +AllocationBlockGroup::AllocationBlockGroup()
  3163. +   :
  3164. +   fStart(0),
  3165. +   fNumBits(0),
  3166. +   fBitmapBlock(0),
  3167. +   fFreeBits(0),
  3168. +   fFirstFree(0),
  3169. +   fLargestStart(0),
  3170. +   fLargestLength(0),
  3171. +   fPreviousFreeBits(0),
  3172. +   fPreviousFirstFree(0),
  3173. +   fPreviousLargestStart(0),
  3174. +   fPreviousLargestLength(0)
  3175. +{
  3176. +}
  3177. +
  3178. +
  3179. +AllocationBlockGroup::~AllocationBlockGroup()
  3180. +{
  3181. +}
  3182. +
  3183. +
  3184. +status_t
  3185. +AllocationBlockGroup::Initialize(Volume* volume, uint32 blockGroup,
  3186. +   uint32 numBits)
  3187. +{
  3188. +   fVolume = volume;
  3189. +   fNumBits = numBits;
  3190. +
  3191. +   ext2_block_group* group;
  3192. +   status_t status = fVolume->GetBlockGroup(blockGroup, &group);
  3193. +   if (status != B_OK)
  3194. +       return status;
  3195. +
  3196. +   fBitmapBlock = group->BlockBitmap();
  3197. +
  3198. +   status = ScanFreeRanges();
  3199. +
  3200. +   fPreviousFreeBits = fFreeBits;
  3201. +   fPreviousFirstFree = fFirstFree;
  3202. +   fPreviousLargestStart = fLargestStart;
  3203. +   fPreviousLargestLength = fLargestLength;
  3204. +  
  3205. +   return status;
  3206. +}
  3207. +
  3208. +
  3209. +status_t
  3210. +AllocationBlockGroup::ScanFreeRanges()
  3211. +{
  3212. +   TRACE("AllocationBlockGroup::ScanFreeRanges()\n");
  3213. +   BitmapBlock block(fVolume, fNumBits);
  3214. +
  3215. +   if (!block.SetTo(fBitmapBlock))
  3216. +       return B_ERROR;
  3217. +
  3218. +   uint32 start = 0;
  3219. +   uint32 end = 0;
  3220. +
  3221. +   while (end < fNumBits) {
  3222. +       block.FindNextUnmarked(start);
  3223. +       end = start;
  3224. +
  3225. +       if (start != block.NumBits()) {
  3226. +           block.FindNextMarked(end);
  3227. +           _AddFreeRange(start, end - start);
  3228. +           start = end;
  3229. +       }
  3230. +   }
  3231. +
  3232. +   return B_OK;
  3233. +}
  3234. +
  3235. +
  3236. +bool
  3237. +AllocationBlockGroup::IsFull() const
  3238. +{
  3239. +   return fFreeBits == 0;
  3240. +}
  3241. +
  3242. +
  3243. +status_t
  3244. +AllocationBlockGroup::Allocate(Transaction& transaction, uint32 start,
  3245. +   uint32 length)
  3246. +{
  3247. +   TRACE("AllocationBlockGroup::Allocate()\n");
  3248. +   uint32 end = start + length;
  3249. +   if (end > fLargestLength + fLargestStart)
  3250. +       return B_BAD_DATA;
  3251. +
  3252. +   BitmapBlock block(fVolume, fNumBits);
  3253. +
  3254. +   if (!block.SetToWritable(transaction, fBitmapBlock))
  3255. +       return B_ERROR;
  3256. +  
  3257. +   if (!block.Mark(start, length)) {
  3258. +       TRACE("Failed to allocate blocks from %lu to %lu. Some were "
  3259. +           "already allocated.\n", start, start + length);
  3260. +       return B_ERROR;
  3261. +   }
  3262. +
  3263. +   transaction.AddListener(this);
  3264. +
  3265. +   fFreeBits -= length;
  3266. +
  3267. +   if (start == fLargestStart) {
  3268. +       if (fFirstFree == fLargestStart)
  3269. +           fFirstFree += length;
  3270. +
  3271. +       fLargestStart += length;
  3272. +       fLargestLength -= length;
  3273. +   } else if (start + length == fLargestStart + fLargestLength) {
  3274. +       fLargestLength -= length;
  3275. +   } else if (start < fLargestStart + fLargestLength
  3276. +           && start > fLargestStart) {
  3277. +       uint32 firstLength = start - fLargestStart;
  3278. +       uint32 secondLength = fLargestStart + fLargestLength
  3279. +           - (start + length);
  3280. +
  3281. +       if (firstLength >= secondLength) {
  3282. +           fLargestLength = firstLength;
  3283. +       } else {
  3284. +           fLargestLength = secondLength;
  3285. +           fLargestStart = start + length;
  3286. +       }
  3287. +   } else {
  3288. +       // No need to revalidate the largest free range
  3289. +       return B_OK;
  3290. +   }
  3291. +
  3292. +   if (fLargestLength < fNumBits / 2)
  3293. +       block.FindLargestUnmarkedRange(fLargestStart, fLargestLength);
  3294. +
  3295. +   return B_OK;
  3296. +}
  3297. +
  3298. +
  3299. +status_t
  3300. +AllocationBlockGroup::Free(Transaction& transaction, uint32 start,
  3301. +   uint32 length)
  3302. +{
  3303. +   uint32 end = start + length;
  3304. +
  3305. +   if (end > fLargestLength)
  3306. +       return B_BAD_DATA;
  3307. +
  3308. +   BitmapBlock block(fVolume, fNumBits);
  3309. +
  3310. +   if (!block.SetToWritable(transaction, fBitmapBlock))
  3311. +       return B_ERROR;
  3312. +
  3313. +   if (!block.Unmark(start, length)) {
  3314. +       TRACE("Failed to free blocks from %lu to %lu. Some were "
  3315. +           "already freed.\n", start, start + length);
  3316. +       return B_ERROR;
  3317. +   }
  3318. +
  3319. +   transaction.AddListener(this);
  3320. +
  3321. +   if (fFirstFree > start)
  3322. +       fFirstFree = start;
  3323. +
  3324. +   if (start + length == fLargestStart) {
  3325. +       fLargestStart = start;
  3326. +       fLargestLength += length;
  3327. +   } else if (start == fLargestStart + fLargestLength) {
  3328. +       fLargestLength += length;
  3329. +   } else if (fLargestLength >= fNumBits / 2) {
  3330. +       // May have merged with some free blocks, becoming the largest
  3331. +       uint32 newEnd = start + length;
  3332. +       block.FindNextMarked(newEnd);
  3333. +
  3334. +       uint32 newStart = start;
  3335. +       block.FindPreviousMarked(newStart);
  3336. +
  3337. +       if (newEnd - newStart > fLargestLength) {
  3338. +           fLargestLength = newEnd - newStart;
  3339. +           fLargestStart = newStart;
  3340. +       }
  3341. +   }
  3342. +
  3343. +   fFreeBits += length;
  3344. +
  3345. +   return B_OK;
  3346. +}
  3347. +
  3348. +
  3349. +status_t
  3350. +AllocationBlockGroup::FreeAll(Transaction& transaction)
  3351. +{
  3352. +   return Free(transaction, 0, fNumBits);
  3353. +}
  3354. +
  3355. +
  3356. +uint32
  3357. +AllocationBlockGroup::NumBits() const
  3358. +{
  3359. +   return fNumBits;
  3360. +}
  3361. +
  3362. +
  3363. +uint32
  3364. +AllocationBlockGroup::FreeBits() const
  3365. +{
  3366. +   return fFreeBits;
  3367. +}
  3368. +
  3369. +
  3370. +uint32
  3371. +AllocationBlockGroup::Start() const
  3372. +{
  3373. +   return fStart;
  3374. +}
  3375. +
  3376. +
  3377. +uint32
  3378. +AllocationBlockGroup::LargestStart() const
  3379. +{
  3380. +   return fLargestStart;
  3381. +}
  3382. +
  3383. +
  3384. +uint32
  3385. +AllocationBlockGroup::LargestLength() const
  3386. +{
  3387. +   return fLargestLength;
  3388. +}
  3389. +
  3390. +
  3391. +void
  3392. +AllocationBlockGroup::_AddFreeRange(uint32 start, uint32 length)
  3393. +{
  3394. +   if (IsFull()) {
  3395. +       fFirstFree = start;
  3396. +       fLargestStart = start;
  3397. +       fLargestLength = length;
  3398. +   } else if (length > fLargestLength) {
  3399. +       fLargestStart = start;
  3400. +       fLargestLength = length;
  3401. +   }
  3402. +
  3403. +   fFreeBits += length;
  3404. +}
  3405. +
  3406. +
  3407. +void
  3408. +AllocationBlockGroup::TransactionDone(bool success)
  3409. +{
  3410. +   if (success) {
  3411. +       TRACE("AllocationBlockGroup::TransactionDone(): The transaction "
  3412. +           "succeeded, discarding previous state\n");
  3413. +       fPreviousFreeBits = fFreeBits;
  3414. +       fPreviousFirstFree = fFirstFree;
  3415. +       fPreviousLargestStart = fLargestStart;
  3416. +       fPreviousLargestLength = fLargestLength;
  3417. +   } else {
  3418. +       TRACE("AllocationBlockGroup::TransactionDone(): The transaction "
  3419. +           "failed, restoring to previous state\n");
  3420. +       fFreeBits = fPreviousFreeBits;
  3421. +       fFirstFree = fPreviousFirstFree;
  3422. +       fLargestStart = fPreviousLargestStart;
  3423. +       fLargestLength = fPreviousLargestLength;
  3424. +   }
  3425. +}
  3426. +
  3427. +
  3428. +void
  3429. +AllocationBlockGroup::RemovedFromTransaction()
  3430. +{
  3431. +   // TODO: What to do here?
  3432. +}
  3433. +
  3434. +
  3435. +BlockAllocator::BlockAllocator(Volume* volume)
  3436. +   :
  3437. +   fVolume(volume),
  3438. +   fGroups(NULL),
  3439. +   fBlocksPerGroup(0),
  3440. +   fNumBlocks(0),
  3441. +   fNumGroups(0)
  3442. +{
  3443. +   mutex_init(&fLock, "ext2 block allocator");
  3444. +}
  3445. +
  3446. +
  3447. +BlockAllocator::~BlockAllocator()
  3448. +{
  3449. +   mutex_destroy(&fLock);
  3450. +
  3451. +   if (fGroups != NULL)
  3452. +       delete [] fGroups;
  3453. +}
  3454. +
  3455. +
  3456. +status_t
  3457. +BlockAllocator::Initialize()
  3458. +{
  3459. +   fBlocksPerGroup = fVolume->BlocksPerGroup();
  3460. +   fNumGroups = fVolume->NumGroups();
  3461. +   fFirstBlock = fVolume->FirstDataBlock();
  3462. +   fNumBlocks = fVolume->NumBlocks();
  3463. +  
  3464. +   TRACE("BlockAllocator::Initialize(): blocks per group: %lu, block groups: "
  3465. +       "%lu, first block: %lu, num blocks: %lu\n", fBlocksPerGroup,
  3466. +       fNumGroups, fFirstBlock, fNumBlocks);
  3467. +
  3468. +   fGroups = new(std::nothrow) AllocationBlockGroup[fNumGroups];
  3469. +   if (fGroups == NULL)
  3470. +       return B_NO_MEMORY;
  3471. +
  3472. +   TRACE("BlockAllocator::Initialize(): allocated allocation block groups\n");
  3473. +
  3474. +   mutex_lock(&fLock);
  3475. +       // Released by _Initialize
  3476. +
  3477. +   thread_id id = -1; // spawn_kernel_thread(
  3478. +       // (thread_func)BlockAllocator::_Initialize, "ext2 block allocator",
  3479. +       // B_LOW_PRIORITY, this);
  3480. +   if (id < B_OK)
  3481. +       return _Initialize(this);
  3482. +
  3483. +   // mutex_transfer_lock(&fLock, id);
  3484. +
  3485. +   // return resume_thread(id);
  3486. +   panic("Failed to fall back to synchronous block allocator"
  3487. +       "initialization.\n");
  3488. +   return B_ERROR;
  3489. +}
  3490. +
  3491. +
  3492. +status_t
  3493. +BlockAllocator::AllocateBlocks(Transaction& transaction, uint32 minimum,
  3494. +   uint32 maximum, uint32& blockGroup, uint32& start, uint32& length)
  3495. +{
  3496. +   TRACE("BlockAllocator::AllocateBlocks()\n");
  3497. +   MutexLocker lock(fLock);
  3498. +   TRACE("BlockAllocator::AllocateBlocks(): Aquired lock\n");
  3499. +
  3500. +   TRACE("BlockAllocator::AllocateBlocks(): transaction: %ld, min: %lu, "
  3501. +       "max: %lu, block group: %lu, start: %lu, num groups: %lu\n",
  3502. +       transaction.ID(), minimum, maximum, blockGroup, start, fNumGroups);
  3503. +
  3504. +   uint32 bestStart = 0;
  3505. +   uint32 bestLength = 0;
  3506. +   uint32 bestGroup = 0;
  3507. +
  3508. +   uint32 groupNum = blockGroup;
  3509. +
  3510. +   AllocationBlockGroup* last = &fGroups[fNumGroups];
  3511. +   AllocationBlockGroup* group = &fGroups[blockGroup];
  3512. +
  3513. +   for (int32 iterations = 0; iterations < 2; iterations++) {
  3514. +       for (; group < last; ++group, ++groupNum) {
  3515. +           TRACE("BlockAllocator::AllocateBlocks(): Group %lu has largest "
  3516. +           "length of %lu\n", groupNum, group->LargestLength());
  3517. +
  3518. +           if (group->LargestLength() > bestLength) {
  3519. +               if (start <= group->LargestStart()) {
  3520. +                   bestStart = group->LargestStart();
  3521. +                   bestLength = group->LargestLength();
  3522. +                   bestGroup = groupNum;
  3523. +
  3524. +                   TRACE("BlockAllocator::AllocateBlocks(): Found a better "
  3525. +                       "range: block group: %lu, %lu-%lu\n", groupNum,
  3526. +                       bestStart, bestStart + bestLength);
  3527. +
  3528. +                   if (bestLength >= maximum)
  3529. +                       break;
  3530. +               }
  3531. +           }
  3532. +
  3533. +           start = 0;
  3534. +       }
  3535. +
  3536. +       if (bestLength >= maximum)
  3537. +           break;
  3538. +
  3539. +       groupNum = 0;
  3540. +
  3541. +       group = &fGroups[0];
  3542. +       last = &fGroups[blockGroup + 1];
  3543. +   }
  3544. +
  3545. +   if (bestLength < minimum) {
  3546. +       TRACE("BlockAllocator::AllocateBlocks(): best range (length %lu) "
  3547. +           "doesn't have minimum length of %lu\n", bestLength, minimum);
  3548. +       return B_DEVICE_FULL;
  3549. +   }
  3550. +
  3551. +   if (bestLength > maximum)
  3552. +       bestLength = maximum;
  3553. +
  3554. +   TRACE("BlockAllocator::AllocateBlocks(): Selected range: block group %lu, "
  3555. +       "%lu-%lu\n", bestGroup, bestStart, bestStart + bestLength);
  3556. +
  3557. +   status_t status = fGroups[bestGroup].Allocate(transaction, bestStart,
  3558. +       bestLength);
  3559. +   if (status != B_OK) {
  3560. +       TRACE("BlockAllocator::AllocateBlocks(): Failed to allocate %lu blocks "
  3561. +           "inside block group %lu.\n", bestLength, bestGroup);
  3562. +       return status;
  3563. +   }
  3564. +
  3565. +   start = bestStart;
  3566. +   length = bestLength;
  3567. +   blockGroup = bestGroup;
  3568. +
  3569. +   return B_OK;
  3570. +}
  3571. +
  3572. +
  3573. +status_t
  3574. +BlockAllocator::Allocate(Transaction& transaction, Inode* inode,
  3575. +   off_t numBlocks, uint32 minimum, uint32& start, uint32& allocated)
  3576. +{
  3577. +   if (numBlocks <= 0)
  3578. +       return B_ERROR;
  3579. +
  3580. +   uint32 group = inode->ID() / fVolume->InodesPerGroup();
  3581. +   uint32 preferred = 0;
  3582. +
  3583. +   if (inode->Size() > 0) {
  3584. +       // Try to allocate near it's last blocks
  3585. +       ext2_data_stream* dataStream = &inode->Node().stream;
  3586. +       uint32 numBlocks = inode->Size() / fVolume->BlockSize() + 1;
  3587. +       uint32 lastBlock = 0;
  3588. +
  3589. +       // DANGER! What happens with sparse files?
  3590. +       if (numBlocks < EXT2_DIRECT_BLOCKS) {
  3591. +           // Only direct blocks
  3592. +           lastBlock = dataStream->direct[numBlocks];
  3593. +       } else {
  3594. +           numBlocks -= EXT2_DIRECT_BLOCKS - 1;
  3595. +           uint32 numIndexes = fVolume->BlockSize() / 4;
  3596. +               // block size / sizeof(int32)
  3597. +           uint32 numIndexes2 = numIndexes * numIndexes;
  3598. +           uint32 numIndexes3 = numIndexes2 * numIndexes;
  3599. +           uint32 indexesInIndirect = numIndexes;
  3600. +           uint32 indexesInDoubleIndirect = indexesInIndirect
  3601. +               + numIndexes2;
  3602. +           // uint32 indexesInTripleIndirect = indexesInDoubleIndirect
  3603. +               // + numIndexes3;
  3604. +
  3605. +           uint32 doubleIndirectBlock = EXT2_DIRECT_BLOCKS + 1;
  3606. +           uint32 indirectBlock = EXT2_DIRECT_BLOCKS;
  3607. +
  3608. +           CachedBlock cached(fVolume);
  3609. +           uint32* indirectData;
  3610. +
  3611. +           if (numBlocks > indexesInDoubleIndirect) {
  3612. +               // Triple indirect blocks
  3613. +               indirectData = (uint32*)cached.SetTo(EXT2_DIRECT_BLOCKS + 2);
  3614. +               if (indirectData == NULL)
  3615. +                   return B_IO_ERROR;
  3616. +
  3617. +               uint32 index = (numBlocks - indexesInDoubleIndirect)
  3618. +                   / numIndexes3;
  3619. +               doubleIndirectBlock = indirectData[index];
  3620. +           }
  3621. +
  3622. +           if (numBlocks > indexesInIndirect) {
  3623. +               // Double indirect blocks
  3624. +               indirectData = (uint32*)cached.SetTo(doubleIndirectBlock);
  3625. +               if (indirectData == NULL)
  3626. +                   return B_IO_ERROR;
  3627. +
  3628. +               uint32 index = (numBlocks - indexesInIndirect) / numIndexes2;
  3629. +               indirectBlock = indirectData[index];
  3630. +           }
  3631. +
  3632. +           indirectData = (uint32*)cached.SetTo(indirectBlock);
  3633. +               if (indirectData == NULL)
  3634. +                   return B_IO_ERROR;
  3635. +
  3636. +           uint32 index = numBlocks / numIndexes;
  3637. +           lastBlock = indirectData[index];
  3638. +       }
  3639. +
  3640. +       group = (lastBlock - fFirstBlock) / fBlocksPerGroup;
  3641. +       preferred = (lastBlock - fFirstBlock) % fBlocksPerGroup + 1;
  3642. +   }
  3643. +
  3644. +   // TODO: Apply some more policies
  3645. +
  3646. +   return AllocateBlocks(transaction, minimum, minimum + 8, group, start,
  3647. +       allocated);
  3648. +}
  3649. +
  3650. +
  3651. +status_t
  3652. +BlockAllocator::Free(Transaction& transaction, uint32 start, uint32 length)
  3653. +{
  3654. +   MutexLocker lock(fLock);
  3655. +
  3656. +   uint32 group = (start - fFirstBlock) / fBlocksPerGroup;
  3657. +   start = (start - fFirstBlock) % fBlocksPerGroup;
  3658. +   uint32 lastGroup = (start + length - fFirstBlock) / fBlocksPerGroup;
  3659. +
  3660. +   if (group == lastGroup)
  3661. +       return fGroups[group].Free(transaction, start, length);
  3662. +
  3663. +   status_t status = fGroups[group].Free(transaction, start,
  3664. +       fGroups[group].NumBits());
  3665. +   if (status != B_OK)
  3666. +       return status;
  3667. +
  3668. +   for (++group; group < lastGroup; ++group) {
  3669. +       status = fGroups[group].FreeAll(transaction);
  3670. +       if (status != B_OK)
  3671. +           return status;
  3672. +   }
  3673. +
  3674. +   return fGroups[group].Free(transaction, 0, (start + length - fFirstBlock)
  3675. +       % fBlocksPerGroup);
  3676. +}
  3677. +
  3678. +
  3679. +/*static*/ status_t
  3680. +BlockAllocator::_Initialize(BlockAllocator* allocator)
  3681. +{
  3682. +   TRACE("BlockAllocator::_Initialize()\n");
  3683. +   // fLock is already heald
  3684. +   Volume* volume = allocator->fVolume;
  3685. +
  3686. +   AllocationBlockGroup* groups = allocator->fGroups;
  3687. +   uint32 numGroups = allocator->fNumGroups - 1;
  3688. +
  3689. +   uint32 freeBlocks = 0;
  3690. +   TRACE("BlockAllocator::_Initialize(): free blocks: %lu\n", freeBlocks);
  3691. +
  3692. +   for (uint32 i = 0; i < numGroups; ++i) {
  3693. +       status_t status = groups[i].Initialize(volume, i,
  3694. +           allocator->fBlocksPerGroup);
  3695. +       if (status != B_OK) {
  3696. +           mutex_unlock(&allocator->fLock);
  3697. +           return status;
  3698. +       }
  3699. +
  3700. +       freeBlocks += groups[i].FreeBits();
  3701. +       TRACE("BlockAllocator::_Initialize(): free blocks: %lu\n", freeBlocks);
  3702. +   }
  3703. +  
  3704. +   // Last block group may have less blocks
  3705. +   status_t status = groups[numGroups].Initialize(volume, numGroups,
  3706. +       allocator->fNumBlocks - allocator->fBlocksPerGroup * numGroups
  3707. +       - allocator->fFirstBlock);
  3708. +   if (status != B_OK) {
  3709. +       mutex_unlock(&allocator->fLock);
  3710. +       return status;
  3711. +   }
  3712. +  
  3713. +   freeBlocks += groups[numGroups].FreeBits();
  3714. +
  3715. +   TRACE("BlockAllocator::_Initialize(): free blocks: %lu\n", freeBlocks);
  3716. +
  3717. +   mutex_unlock(&allocator->fLock);
  3718. +
  3719. +   if (freeBlocks != volume->FreeBlocks()) {
  3720. +       TRACE("Counted free blocks doesn't match value in the superblock.\n");
  3721. +       return B_BAD_DATA;
  3722. +   }
  3723. +
  3724. +   return B_OK;
  3725. +}
  3726.  
  3727. Property changes on: src/add-ons/kernel/file_systems/ext2/BlockAllocator.cpp
  3728. ___________________________________________________________________
  3729. Added: svn:executable
  3730.    + *
  3731.  
  3732. Index: src/add-ons/kernel/file_systems/ext2/Inode.cpp
  3733. ===================================================================
  3734. --- src/add-ons/kernel/file_systems/ext2/Inode.cpp  (revision 37534)
  3735. +++ src/add-ons/kernel/file_systems/ext2/Inode.cpp  (working copy)
  3736. @@ -8,6 +8,7 @@
  3737.  
  3738.  #include <fs_cache.h>
  3739.  #include <string.h>
  3740. +#include <util/AutoLock.h>
  3741.  
  3742.  #include "CachedBlock.h"
  3743.  
  3744. @@ -26,56 +27,109 @@
  3745.     fID(id),
  3746.     fCache(NULL),
  3747.     fMap(NULL),
  3748. -   fNode(NULL),
  3749.     fAttributesBlock(NULL)
  3750.  {
  3751.     rw_lock_init(&fLock, "ext2 inode");
  3752.  
  3753.     uint32 block;
  3754. -   if (volume->GetInodeBlock(id, block) == B_OK) {
  3755. -       TRACE("inode %Ld at block %lu\n", ID(), block);
  3756. -       uint8* inodeBlock = (uint8*)block_cache_get(volume->BlockCache(),
  3757. -           block);
  3758. +   fInitStatus = volume->GetInodeBlock(id, block);
  3759. +   if (fInitStatus == B_OK) {
  3760. +       TRACE("inode %Ld at block %lu\n", id, block);
  3761. +
  3762. +       CachedBlock cached(volume);
  3763. +       const uint8* inodeBlock = cached.SetTo(block);
  3764. +       TRACE("Inode table block in memory: %p\n", inodeBlock);
  3765. +
  3766.         if (inodeBlock != NULL) {
  3767. -           fNode = (ext2_inode*)(inodeBlock + volume->InodeBlockIndex(id)
  3768. -               * volume->InodeSize());
  3769. -       }
  3770. +           TRACE("Inode size: %lu, inode index: %lu\n", volume->InodeSize(),
  3771. +               volume->InodeBlockIndex(id));
  3772. +           ext2_inode* inode = (ext2_inode*)(inodeBlock
  3773. +               + volume->InodeBlockIndex(id) * volume->InodeSize());
  3774. +          
  3775. +           fNodeSize = sizeof(ext2_inode) > volume->InodeSize()
  3776. +               ? volume->InodeSize() : sizeof(ext2_inode);
  3777. +          
  3778. +           TRACE("Attempting to copy inode data from %p to %p, ext2_inode "
  3779. +               "size: %lu\n", inode, &fNode, fNodeSize);
  3780. +          
  3781. +           memcpy(&fNode, inode, fNodeSize);
  3782. +       } else
  3783. +           fInitStatus = B_IO_ERROR;
  3784.     }
  3785.  
  3786. -   if (fNode != NULL) {
  3787. -       // TODO: we don't need a cache for short symlinks
  3788. -       fCache = file_cache_create(fVolume->ID(), ID(), Size());
  3789. -       fMap = file_map_create(fVolume->ID(), ID(), Size());
  3790. +   if (fInitStatus == B_OK) {
  3791. +       if (Size() == 0 || IsDirectory() || (IsSymLink() && Size() < 60)) {
  3792. +           fCached = false;
  3793. +       } else {
  3794. +           fCache = file_cache_create(fVolume->ID(), ID(), Size());
  3795. +           fMap = file_map_create(fVolume->ID(), ID(), Size());
  3796. +
  3797. +           if (fCache != NULL)
  3798. +               fCached = true;
  3799. +           else {
  3800. +               fCached = false;
  3801. +               fInitStatus = B_ERROR;
  3802. +           }
  3803. +       }
  3804. +   } else {
  3805. +       TRACE("Inode: Failed initialization\n");
  3806. +       fCached = false;
  3807.     }
  3808.  }
  3809.  
  3810.  
  3811.  Inode::~Inode()
  3812.  {
  3813. -   file_cache_delete(FileCache());
  3814. -   file_map_delete(Map());
  3815. +   TRACE("Inode destructor\n");
  3816.  
  3817. +   if (fCached) {
  3818. +       TRACE("Deleting the file cache and file map\n");
  3819. +       file_cache_delete(FileCache());
  3820. +       file_map_delete(Map());
  3821. +   }
  3822. +
  3823.     if (fAttributesBlock) {
  3824. +       TRACE("Returning the attributes block\n");
  3825.         uint32 block = B_LENDIAN_TO_HOST_INT32(Node().file_access_control);
  3826.         block_cache_put(fVolume->BlockCache(), block);
  3827.     }
  3828.  
  3829. -   if (fNode != NULL) {
  3830. -       uint32 block;
  3831. -       if (fVolume->GetInodeBlock(ID(), block) == B_OK)
  3832. -           block_cache_put(fVolume->BlockCache(), block);
  3833. -   }
  3834. +   TRACE("Inode destructor: Done\n");
  3835.  }
  3836.  
  3837.  
  3838.  status_t
  3839.  Inode::InitCheck()
  3840.  {
  3841. -   return fNode != NULL ? B_OK : B_ERROR;
  3842. +   return fInitStatus;
  3843.  }
  3844.  
  3845.  
  3846.  status_t
  3847. +Inode::WriteBack(Transaction& transaction)
  3848. +{
  3849. +   WriteLocker lock(fLock);
  3850. +
  3851. +   uint32 inodeBlock;
  3852. +
  3853. +   status_t status = fVolume->GetInodeBlock(fID, inodeBlock);
  3854. +   if (status != B_OK)
  3855. +       return status;
  3856. +
  3857. +   CachedBlock cached(fVolume);
  3858. +   uint8* inodeBlockData = cached.SetToWritable(transaction, inodeBlock);
  3859. +   if (inodeBlockData == NULL)
  3860. +       return B_IO_ERROR;
  3861. +
  3862. +   memcpy(inodeBlockData +
  3863. +           fVolume->InodeBlockIndex(fID) * fVolume->InodeSize(),
  3864. +       (uint8*)&fNode, fNodeSize);
  3865. +
  3866. +   return B_OK;
  3867. +}
  3868. +
  3869. +
  3870. +status_t
  3871.  Inode::CheckPermissions(int accessMode) const
  3872.  {
  3873.     uid_t user = geteuid();
  3874. @@ -95,9 +149,9 @@
  3875.  
  3876.     // shift mode bits, to check directly against accessMode
  3877.     mode_t mode = Mode();
  3878. -   if (user == (uid_t)fNode->UserID())
  3879. +   if (user == (uid_t)fNode.UserID())
  3880.         mode >>= 6;
  3881. -   else if (group == (gid_t)fNode->GroupID())
  3882. +   else if (group == (gid_t)fNode.GroupID())
  3883.         mode >>= 3;
  3884.  
  3885.     if (accessMode & ~(mode & S_IRWXO))
  3886. @@ -114,8 +168,10 @@
  3887.     uint32 perIndirectBlock = perBlock * perBlock;
  3888.     uint32 index = offset >> fVolume->BlockShift();
  3889.  
  3890. -   if (offset >= Size())
  3891. +   if (offset >= Size()) {
  3892. +       TRACE("FindBlock: offset larger than inode size\n");
  3893.         return B_ENTRY_NOT_FOUND;
  3894. +   }
  3895.  
  3896.     // TODO: we could return the size of the sparse range, as this might be more
  3897.     // than just a block
  3898. @@ -203,7 +259,8 @@
  3899.  
  3900.     // set/check boundaries for pos/length
  3901.     if (pos < 0) {
  3902. -       TRACE("inode %Ld: ReadAt failed(pos %Ld, length %lu)\n", ID(), pos, length);
  3903. +       TRACE("inode %Ld: ReadAt failed(pos %Ld, length %lu)\n", ID(), pos,
  3904. +           length);
  3905.         return B_BAD_VALUE;
  3906.     }
  3907.  
  3908. @@ -245,3 +302,34 @@
  3909.     *_length = length;
  3910.     return B_NO_ERROR;
  3911.  }
  3912. +
  3913. +
  3914. +/*static*/ status_t
  3915. +Inode::Create(Transaction& transaction, Inode* parent, const char* name,
  3916. +   int32 mode, int openMode, uint32 type, bool* _created, ino_t* _id,
  3917. +   Inode** _inode, fs_vnode_ops* vnodeOps, uint32 publishFlags)
  3918. +{
  3919. +   //DirectoryIterator* entries = NULL;
  3920. +
  3921. +   if (parent != NULL) {
  3922. +   }
  3923. +
  3924. +   return B_OK;
  3925. +}
  3926. +
  3927. +
  3928. +status_t
  3929. +Inode::DisableFileCache()
  3930. +{
  3931. +   TRACE("Inode::DisableFileCache()\n");
  3932. +
  3933. +   if (!fCached)
  3934. +       return B_OK;
  3935. +
  3936. +   file_cache_delete(FileCache());
  3937. +   file_map_delete(Map());
  3938. +
  3939. +   fCached = false;
  3940. +
  3941. +   return B_OK;
  3942. +}
  3943. Index: src/add-ons/kernel/file_systems/ext2/HashRevokeManager.h
  3944. ===================================================================
  3945. --- src/add-ons/kernel/file_systems/ext2/HashRevokeManager.h    (revision 0)
  3946. +++ src/add-ons/kernel/file_systems/ext2/HashRevokeManager.h    (revision 0)
  3947. @@ -0,0 +1,47 @@
  3948. +/*
  3949. + * Copyright 2001-2010, Haiku Inc. All rights reserved.
  3950. + * This file may be used under the terms of the MIT License.
  3951. + *
  3952. + * Authors:
  3953. + *     Janito V. Ferreira Filho
  3954. + */
  3955. +#ifndef HASHREVOKEMANAGER_H
  3956. +#define HASHREVOKEMANAGER_H
  3957. +
  3958. +#include <util/khash.h>
  3959. +
  3960. +#include "RevokeManager.h"
  3961. +
  3962. +
  3963. +struct RevokeElement {
  3964. +   RevokeElement*  next;   // Next in hash
  3965. +   uint32          block;
  3966. +   uint32          commitID;
  3967. +};
  3968. +
  3969. +
  3970. +class HashRevokeManager : public RevokeManager {
  3971. +public:
  3972. +                       HashRevokeManager();
  3973. +   virtual             ~HashRevokeManager();
  3974. +
  3975. +           status_t    Init();
  3976. +
  3977. +   virtual status_t    Insert(uint32 block, uint32 commitID);
  3978. +   virtual status_t    Remove(uint32 block);
  3979. +   virtual bool        Lookup(uint32 block, uint32 commitID);
  3980. +          
  3981. +   static  int         Compare(void* element, const void* key);
  3982. +   static  uint32      Hash(void* element, const void* key, uint32 range);
  3983. +
  3984. +protected:
  3985. +           status_t    _ForceInsert(uint32 block, uint32 commitID);
  3986. +
  3987. +private:
  3988. +           hash_table* fHash;
  3989. +
  3990. +   const   int         kInitialHashSize;
  3991. +};
  3992. +
  3993. +#endif // HASHREVOKEMANAGER_H
  3994. +
  3995.  
  3996. Property changes on: src/add-ons/kernel/file_systems/ext2/HashRevokeManager.h
  3997. ___________________________________________________________________
  3998. Added: svn:executable
  3999.    + *
  4000.  
  4001. Index: src/add-ons/kernel/file_systems/ext2/kernel_interface.cpp
  4002. ===================================================================
  4003. --- src/add-ons/kernel/file_systems/ext2/kernel_interface.cpp   (revision 37534)
  4004. +++ src/add-ons/kernel/file_systems/ext2/kernel_interface.cpp   (working copy)
  4005. @@ -13,6 +13,7 @@
  4006.  #include <fs_info.h>
  4007.  
  4008.  #include "AttributeIterator.h"
  4009. +#include "CachedBlock.h"
  4010.  #include "DirectoryIterator.h"
  4011.  #include "ext2.h"
  4012.  #include "HTree.h"
  4013. @@ -116,6 +117,7 @@
  4014.  
  4015.     status_t status = volume->Mount(device, flags);
  4016.     if (status != B_OK) {
  4017. +       TRACE("Failed mounting the volume. Error: %s\n", strerror(status));
  4018.         delete volume;
  4019.         return status;
  4020.     }
  4021. @@ -339,12 +341,66 @@
  4022.         if (!strcmp(buffer, name))
  4023.             break;
  4024.     }
  4025. -
  4026. +  
  4027.     return get_vnode(volume->FSVolume(), *_vnodeID, NULL);
  4028.  }
  4029.  
  4030.  
  4031.  static status_t
  4032. +ext2_ioctl(fs_volume* _volume, fs_vnode* _node, void* _cookie, uint32 cmd,
  4033. +   void* buffer, size_t bufferLength)
  4034. +{
  4035. +   TRACE("ioctl: %lu\n", cmd);
  4036. +
  4037. +   Volume* volume = (Volume*)_volume->private_volume;
  4038. +   switch (cmd) {
  4039. +       case 56742:
  4040. +       {
  4041. +           TRACE("ioctl: Test the block allocator\n");
  4042. +           // Test the block allocator
  4043. +           TRACE("ioctl: Creating transaction\n");
  4044. +           Transaction transaction(volume->GetJournal());
  4045. +           TRACE("ioctl: Creating cached block\n");
  4046. +           CachedBlock cached(volume);
  4047. +           uint32 blocksPerGroup = volume->BlocksPerGroup();
  4048. +           uint32 blockSize  = volume->BlockSize();
  4049. +           uint32 firstBlock = volume->FirstDataBlock();
  4050. +           uint32 start = 0;
  4051. +           uint32 group = 0;
  4052. +           uint32 length;
  4053. +           TRACE("ioctl: blocks per group: %lu, block size: %lu, "
  4054. +               "first block: %lu, start: %lu, group: %lu\n", blocksPerGroup,
  4055. +               blockSize, firstBlock, start, group);
  4056. +
  4057. +           while (volume->AllocateBlocks(transaction, 1, 64, group, start,
  4058. +                   length) == B_OK) {
  4059. +               TRACE("ioctl: Allocated blocks in group %lu: %lu-%lu\n", group,
  4060. +                   start, start + length);
  4061. +               uint32 blockNum = start + group * blocksPerGroup - firstBlock;
  4062. +
  4063. +               for (uint32 i = 0; i < length; ++i) {
  4064. +                   uint8* block = cached.SetToWritable(transaction, blockNum);
  4065. +                   memset(block, 0, blockSize);
  4066. +                   blockNum++;
  4067. +               }
  4068. +
  4069. +               TRACE("ioctl: Blocks cleared\n");
  4070. +              
  4071. +               transaction.Done();
  4072. +               transaction.Start(volume->GetJournal());
  4073. +           }
  4074. +
  4075. +           TRACE("ioctl: Done\n");
  4076. +
  4077. +           return B_OK;
  4078. +       }
  4079. +   }
  4080. +
  4081. +   return B_OK;
  4082. +}
  4083. +
  4084. +
  4085. +static status_t
  4086.  ext2_read_stat(fs_volume* _volume, fs_vnode* _node, struct stat* stat)
  4087.  {
  4088.     Inode* inode = (Inode*)_node->private_node;
  4089. @@ -748,8 +804,8 @@
  4090.  
  4091.     &ext2_get_file_map,
  4092.  
  4093. +   &ext2_ioctl,
  4094.     NULL,
  4095. -   NULL,
  4096.     NULL,   // fs_select
  4097.     NULL,   // fs_deselect
  4098.     NULL,
  4099. Index: src/add-ons/kernel/file_systems/ext2/InodeAllocator.h
  4100. ===================================================================
  4101. --- src/add-ons/kernel/file_systems/ext2/InodeAllocator.h   (revision 0)
  4102. +++ src/add-ons/kernel/file_systems/ext2/InodeAllocator.h   (revision 0)
  4103. @@ -0,0 +1,37 @@
  4104. +/*
  4105. + * Copyright 2001-2010, Haiku Inc. All rights reserved.
  4106. + * This file may be used under the terms of the MIT License.
  4107. + *
  4108. + * Authors:
  4109. + *     Janito V. Ferreira Filho
  4110. + */
  4111. +#ifndef INODEALLOCATOR_H
  4112. +#define INODEALLOCATOR_H
  4113. +
  4114. +#include <lock.h>
  4115. +
  4116. +#include "Transaction.h"
  4117. +
  4118. +
  4119. +class Volume;
  4120. +
  4121. +
  4122. +class InodeAllocator {
  4123. +public:
  4124. +                       InodeAllocator(Volume* volume);
  4125. +                       ~InodeAllocator();
  4126. +
  4127. +           status_t    New(Transaction& transaction,
  4128. +                           uint32 prefferedBlockGroup, ino_t& id);
  4129. +
  4130. +private:
  4131. +           status_t    _MarkInBitmap(Transaction& transaction,
  4132. +                           uint32 bitmapBlock, uint32 blockGroup,
  4133. +                           uint32 numInodes, ino_t& id);
  4134. +
  4135. +
  4136. +           Volume*     fVolume;
  4137. +           mutex       fLock;
  4138. +};
  4139. +
  4140. +#endif // INODEALLOCATOR_H
  4141.  
  4142. Property changes on: src/add-ons/kernel/file_systems/ext2/InodeAllocator.h
  4143. ___________________________________________________________________
  4144. Added: svn:executable
  4145.    + *
  4146.  
  4147. Index: src/add-ons/kernel/file_systems/ext2/HTree.cpp
  4148. ===================================================================
  4149. --- src/add-ons/kernel/file_systems/ext2/HTree.cpp  (revision 37534)
  4150. +++ src/add-ons/kernel/file_systems/ext2/HTree.cpp  (working copy)
  4151. @@ -7,6 +7,7 @@
  4152.   */
  4153.  
  4154.  
  4155. +#include "CachedBlock.h"
  4156.  #include "HTree.h"
  4157.  
  4158.  #include <new>
  4159. @@ -17,6 +18,8 @@
  4160.  #include "Volume.h"
  4161.  
  4162.  
  4163. +//#define COLLISION_TEST
  4164. +
  4165.  //#define TRACE_EXT2
  4166.  #ifdef TRACE_EXT2
  4167.  #  define TRACE(x...) dprintf("\33[34mext2:\33[0m " x)
  4168. @@ -75,54 +78,68 @@
  4169.  
  4170.  HTree::~HTree()
  4171.  {
  4172. +   delete fRootEntry;
  4173.  }
  4174.  
  4175.  
  4176.  status_t
  4177.  HTree::Lookup(const char* name, DirectoryIterator** iterator)
  4178.  {
  4179. +   TRACE("HTree::Lookup()\n");
  4180.     if (!fIndexed || (name[0] == '.'
  4181.         && (name[1] == '\0' || (name[1] == '.' && name[2] == '0')))) {
  4182.         // No HTree support or looking for trivial directories
  4183.         // TODO: Does these directories get hashed?
  4184.         *iterator = new(std::nothrow) DirectoryIterator(fDirectory);
  4185. +       TRACE("HTree::Lookup(): Falling back to linear iteration\n");
  4186.        
  4187.         if (*iterator == NULL)
  4188.             return B_NO_MEMORY;
  4189.         return B_OK;
  4190.     }
  4191.    
  4192. -   HTreeRoot root;
  4193. -   size_t length = sizeof(root);
  4194. +   uint32 blockNum;
  4195. +   status_t status = fDirectory->FindBlock(0, blockNum);
  4196. +   if (status != B_OK) {
  4197. +       *iterator = new(std::nothrow) DirectoryIterator(fDirectory);
  4198. +       TRACE("HTree::Lookup(): Failed to read block in diretory\n");
  4199. +      
  4200. +       if (*iterator == NULL)
  4201. +           return B_NO_MEMORY;
  4202. +       return B_OK;
  4203. +   }
  4204. +
  4205. +   CachedBlock cached(fDirectory->GetVolume());
  4206. +   const uint8* block = cached.SetTo(blockNum);
  4207. +
  4208. +   HTreeRoot* root = (HTreeRoot*)block;
  4209.    
  4210. -   status_t status = fDirectory->ReadAt(0, (uint8*)&root, &length);
  4211. -   if (status < B_OK)
  4212. -       return status;
  4213. -  
  4214. -   if (length != sizeof(root) || !root.IsValid()) {
  4215. +   if (root == NULL || !root->IsValid()) {
  4216.         // Fallback to linear search
  4217.         *iterator = new(std::nothrow) DirectoryIterator(fDirectory);
  4218. +       TRACE("HTree::Lookup(): Invalid root node\n");
  4219.         if (*iterator == NULL)
  4220.             return B_NO_MEMORY;
  4221.        
  4222.         return B_OK;
  4223.     }
  4224.    
  4225. -   uint32 hash = _Hash(name, root.hash_version);
  4226. +   uint32 hash = _Hash(name, root->hash_version);
  4227.    
  4228. -   off_t start = (off_t)root.root_info_length
  4229. +   off_t start = (off_t)root->root_info_length
  4230.         + 2 * (sizeof(HTreeFakeDirEntry) + 4);
  4231.  
  4232. +   delete fRootEntry;
  4233. +
  4234.     fRootEntry = new(std::nothrow) HTreeEntryIterator(start, fDirectory);
  4235.     if (fRootEntry == NULL)
  4236.         return B_NO_MEMORY;
  4237.    
  4238. -   fRootDeleter.SetTo(fRootEntry);
  4239.     status = fRootEntry->Init();
  4240.     if (status != B_OK)
  4241.         return status;
  4242.    
  4243. -   return fRootEntry->Lookup(hash, (uint32)root.indirection_levels, iterator);
  4244. +   return fRootEntry->Lookup(hash, (uint32)root->indirection_levels, iterator);
  4245.  }
  4246.  
  4247.  
  4248. @@ -131,6 +148,7 @@
  4249.  {
  4250.     uint32 hash;
  4251.    
  4252. +#ifndef COLLISION_TEST
  4253.     switch (version) {
  4254.         case HTREE_HASH_LEGACY:
  4255.             hash = _HashLegacy(name);
  4256. @@ -145,8 +163,11 @@
  4257.             panic("Hash verification succeeded but then failed?");
  4258.             hash = 0;
  4259.     };
  4260. +#else
  4261. +   hash = 0;
  4262. +#endif
  4263.  
  4264. -   TRACE("Filename hash: %u\n", hash);
  4265. +   TRACE("HTree::_Hash(): filename hash 0x%lX\n", hash);
  4266.    
  4267.     return hash & ~1;
  4268.  }
  4269. @@ -155,6 +176,7 @@
  4270.  uint32
  4271.  HTree::_HashLegacy(const char* name)
  4272.  {
  4273. +   TRACE("HTree::_HashLegacy()\n");
  4274.     uint32 hash = 0x12a3fe2d;
  4275.     uint32 previous = 0x37abe8f9;
  4276.    
  4277. @@ -168,7 +190,7 @@
  4278.         hash = next;
  4279.     }
  4280.    
  4281. -   return hash;
  4282. +   return hash << 1;
  4283.  }
  4284.  
  4285.  
  4286. @@ -230,8 +252,8 @@
  4287.     shifts[2] = 9;
  4288.     shifts[3] = 13;
  4289.  
  4290. -   for (int j = 0; j < 2; ++j) {
  4291. -       for (int i = j; i < 4; i += 2) {
  4292. +   for (int j = 1; j >= 0; --j) {
  4293. +       for (int i = j; i < 8; i += 2) {
  4294.             a += _MD4G(b, c, d) + blocks[i] + 013240474631UL;
  4295.             uint32 shift = shifts[i / 2];
  4296.             a = (a << shift) | (a >> (32 - shift));
  4297. @@ -247,13 +269,13 @@
  4298.  
  4299.     for (int i = 0; i < 4; ++i) {
  4300.         a += _MD4H(b, c, d) + blocks[3 - i] + 015666365641UL;
  4301. -       uint32 shift = shifts[i*2];
  4302. +       uint32 shift = shifts[i * 2 % 4];
  4303.         a = (a << shift) | (a >> (32 - shift));
  4304.        
  4305.         _MD4RotateVars(a, b, c, d);
  4306.        
  4307.         a += _MD4H(b, c, d) + blocks[7 - i] + 015666365641UL;
  4308. -       shift = shifts[i*2 + 1];
  4309. +       shift = shifts[(i * 2 + 1) % 4];
  4310.         a = (a << shift) | (a >> (32 - shift));
  4311.        
  4312.         _MD4RotateVars(a, b, c, d);
  4313. @@ -269,6 +291,7 @@
  4314.  uint32
  4315.  HTree::_HashHalfMD4(const char* name)
  4316.  {
  4317. +   TRACE("HTree::_HashHalfMD4()\n");
  4318.     uint32 buffer[4];
  4319.  
  4320.     buffer[0] = fHashSeed[0];
  4321. @@ -318,6 +341,7 @@
  4322.  uint32
  4323.  HTree::_HashTEA(const char* name)
  4324.  {
  4325. +   TRACE("HTree::_HashTEA()\n");
  4326.     uint32 buffer[4];
  4327.  
  4328.     buffer[0] = fHashSeed[0];
  4329. @@ -354,7 +378,7 @@
  4330.     int completeIterations = length / 4;
  4331.    
  4332.     for (int i = 0; i < completeIterations; ++i) {
  4333. -       uint32 value = 0 | *(string++);
  4334. +       uint32 value = (padding << 8) | *(string++);
  4335.         value = (value << 8) | *(string++);
  4336.         value = (value << 8) | *(string++);
  4337.         value = (value << 8) | *(string++);
  4338.  
  4339. Property changes on: src/add-ons/kernel/file_systems/ext2/HTree.cpp
  4340. ___________________________________________________________________
  4341. Added: svn:executable
  4342.    + *
  4343.  
  4344. Index: src/add-ons/kernel/file_systems/ext2/NoJournal.cpp
  4345. ===================================================================
  4346. --- src/add-ons/kernel/file_systems/ext2/NoJournal.cpp  (revision 0)
  4347. +++ src/add-ons/kernel/file_systems/ext2/NoJournal.cpp  (revision 0)
  4348. @@ -0,0 +1,100 @@
  4349. +/*
  4350. + * Copyright 2001-2010, Haiku Inc. All rights reserved.
  4351. + * This file may be used under the terms of the MIT License.
  4352. + *
  4353. + * Authors:
  4354. + *     Janito V. Ferreira Filho
  4355. + */
  4356. +
  4357. +#include "NoJournal.h"
  4358. +
  4359. +#include <string.h>
  4360. +
  4361. +#include <fs_cache.h>
  4362. +
  4363. +
  4364. +//#define TRACE_EXT2
  4365. +#ifdef TRACE_EXT2
  4366. +#  define TRACE(x...) dprintf("\33[34mext2:\33[0m " x)
  4367. +#else
  4368. +#  define TRACE(x...) ;
  4369. +#endif
  4370. +
  4371. +
  4372. +NoJournal::NoJournal(Volume* volume)
  4373. +   :
  4374. +   Journal()
  4375. +{
  4376. +   fFilesystemVolume = volume;
  4377. +   fFilesystemBlockCache = volume->BlockCache();
  4378. +   fJournalVolume = volume;
  4379. +   fHasSubTransaction = false;
  4380. +   fSeparateSubTransactions = false;
  4381. +}
  4382. +
  4383. +
  4384. +NoJournal::~NoJournal()
  4385. +{
  4386. +}
  4387. +
  4388. +
  4389. +status_t
  4390. +NoJournal::InitCheck()
  4391. +{
  4392. +   return B_OK;
  4393. +}
  4394. +
  4395. +
  4396. +status_t
  4397. +NoJournal::Recover()
  4398. +{
  4399. +   return B_OK;
  4400. +}
  4401. +
  4402. +
  4403. +status_t
  4404. +NoJournal::StartLog()
  4405. +{
  4406. +   return B_OK;
  4407. +}
  4408. +
  4409. +
  4410. +status_t
  4411. +NoJournal::Lock(Transaction* owner, bool separateSubTransactions)
  4412. +{
  4413. +   status_t status = block_cache_sync(fFilesystemBlockCache);
  4414. +   TRACE("NoJournal::Lock(): block_cache_sync: %s\n", strerror(status));
  4415. +  
  4416. +   if (status == B_OK)
  4417. +       status = Journal::Lock(owner, separateSubTransactions);
  4418. +  
  4419. +   return status;
  4420. +}
  4421. +
  4422. +
  4423. +status_t
  4424. +NoJournal::Unlock(Transaction* owner, bool success)
  4425. +{
  4426. +   TRACE("NoJournal::Unlock\n");
  4427. +   return Journal::Unlock(owner, success);
  4428. +}
  4429. +
  4430. +
  4431. +status_t
  4432. +NoJournal::_WriteTransactionToLog()
  4433. +{
  4434. +   TRACE("NoJournal::_WriteTransactionToLog(): Ending transaction %ld\n",
  4435. +       fTransactionID);
  4436. +
  4437. +   fTransactionID = cache_end_transaction(fFilesystemBlockCache,
  4438. +       fTransactionID, _TransactionWritten, NULL);
  4439. +  
  4440. +   return B_OK;
  4441. +}
  4442. +
  4443. +
  4444. +/*static*/ void
  4445. +NoJournal::_TransactionWritten(int32 transactionID, int32 event, void* param)
  4446. +{
  4447. +   TRACE("Transaction %ld checkpointed\n", transactionID);
  4448. +}
  4449. Index: src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.h
  4450. ===================================================================
  4451. --- src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.h   (revision 37534)
  4452. +++ src/add-ons/kernel/file_systems/ext2/HTreeEntryIterator.h   (working copy)
  4453. @@ -14,6 +14,9 @@
  4454.  #include "DirectoryIterator.h"
  4455.  
  4456.  
  4457. +class Volume;
  4458. +
  4459. +
  4460.  class HTreeEntryIterator {
  4461.  public:
  4462.                                 HTreeEntryIterator(off_t offset,
  4463. @@ -26,7 +29,7 @@
  4464.                                     DirectoryIterator** iterator);
  4465.             bool                HasCollision() { return fHasCollision; }
  4466.                        
  4467. -           status_t            GetNext(off_t& offset);
  4468. +           status_t            GetNext(uint32& offset);
  4469.  private:
  4470.                                 HTreeEntryIterator(uint32 block,
  4471.                                     uint32 blockSize, Inode* directory,
  4472. @@ -34,17 +37,20 @@
  4473.                                     bool hasCollision);
  4474.  
  4475.  private:
  4476. +           Inode*              fDirectory;
  4477. +           Volume*             fVolume;
  4478. +           status_t            fInitStatus;
  4479. +
  4480.             bool                fHasCollision;
  4481.             uint16              fLimit, fCount;
  4482. +           uint16              fFirstEntry;
  4483. +           uint16              fCurrentEntry;
  4484.  
  4485.             uint32              fBlockSize;
  4486. -           Inode*              fDirectory;
  4487. -           off_t               fOffset;
  4488. -           off_t               fMaxOffset;
  4489. +           uint32              fBlockNum;
  4490.  
  4491.             HTreeEntryIterator* fParent;
  4492.             HTreeEntryIterator* fChild;
  4493. -           ObjectDeleter<HTreeEntryIterator> fChildDeleter;
  4494.  };
  4495.  
  4496.  #endif // HTREE_ENTRY_ITERATOR_H
  4497. Index: src/add-ons/kernel/file_systems/ext2/Volume.h
  4498. ===================================================================
  4499. --- src/add-ons/kernel/file_systems/ext2/Volume.h   (revision 37534)
  4500. +++ src/add-ons/kernel/file_systems/ext2/Volume.h   (working copy)
  4501. @@ -9,8 +9,12 @@
  4502.  #include <lock.h>
  4503.  
  4504.  #include "ext2.h"
  4505. +#include "BlockAllocator.h"
  4506. +#include "InodeAllocator.h"
  4507. +#include "Transaction.h"
  4508.  
  4509.  class Inode;
  4510. +class Journal;
  4511.  
  4512.  
  4513.  enum volume_flags {
  4514. @@ -18,7 +22,7 @@
  4515.  };
  4516.  
  4517.  
  4518. -class Volume {
  4519. +class Volume : public TransactionListener {
  4520.  public:
  4521.                                 Volume(fs_volume* volume);
  4522.                                 ~Volume();
  4523. @@ -40,31 +44,59 @@
  4524.  
  4525.             uint32              NumInodes() const
  4526.                                     { return fNumInodes; }
  4527. +           uint32              NumGroups() const
  4528. +                                   { return fNumGroups; }
  4529.             off_t               NumBlocks() const
  4530.                                     { return fSuperBlock.NumBlocks(); }
  4531.             off_t               FreeBlocks() const
  4532. -                                   { return fSuperBlock.FreeBlocks(); }
  4533. +                                   { return fFreeBlocks; }
  4534. +           uint32              FirstDataBlock() const
  4535. +                                   { return fFirstDataBlock; }
  4536.  
  4537.             uint32              BlockSize() const { return fBlockSize; }
  4538.             uint32              BlockShift() const { return fBlockShift; }
  4539. +           uint32              BlocksPerGroup() const
  4540. +                                   { return fSuperBlock.BlocksPerGroup(); }
  4541.             uint32              InodeSize() const
  4542.                                     { return fSuperBlock.InodeSize(); }
  4543. +           uint32              InodesPerGroup() const
  4544. +                                   { return fSuperBlock.InodesPerGroup(); }
  4545.             ext2_super_block&   SuperBlock() { return fSuperBlock; }
  4546.  
  4547.             status_t            GetInodeBlock(ino_t id, uint32& block);
  4548.             uint32              InodeBlockIndex(ino_t id) const;
  4549.             status_t            GetBlockGroup(int32 index,
  4550.                                     ext2_block_group** _group);
  4551. -          
  4552. +
  4553. +           Journal*            GetJournal() { return fJournal; }
  4554. +
  4555.             bool                IndexedDirectories() const
  4556.                                     { return (fSuperBlock.CompatibleFeatures()
  4557.                                         & EXT2_FEATURE_DIRECTORY_INDEX) != 0; }
  4558.  
  4559. +           status_t            AllocateInode(Transaction& transaction,
  4560. +                                   uint32 preferredBlockGroup, ino_t& id);
  4561. +
  4562. +           status_t            AllocateBlocks(Transaction& transaction,
  4563. +                                   uint32 minimum, uint32 maximum,
  4564. +                                   uint32& blockGroup, uint32& start,
  4565. +                                   uint32& length);
  4566. +
  4567. +           status_t            LoadSuperBlock();
  4568. +           status_t            WriteSuperBlock(Transaction& transaction);
  4569. +
  4570.             // cache access
  4571.             void*               BlockCache() { return fBlockCache; }
  4572.  
  4573. +           status_t            FlushDevice();
  4574. +           status_t            Sync();
  4575. +
  4576.     static  status_t            Identify(int fd, ext2_super_block* superBlock);
  4577.  
  4578. +           // TransactionListener functions
  4579. +           void                TransactionDone(bool success);
  4580. +           void                RemovedFromTransaction();
  4581. +
  4582.  private:
  4583.     static  uint32              _UnsupportedIncompatibleFeatures(
  4584.                                     ext2_super_block& superBlock);
  4585. @@ -76,12 +108,21 @@
  4586.             int                 fDevice;
  4587.             ext2_super_block    fSuperBlock;
  4588.             char                fName[32];
  4589. +
  4590. +           BlockAllocator      fBlockAllocator;
  4591. +           InodeAllocator      fInodeAllocator;
  4592. +           Journal*            fJournal;
  4593. +           Inode*              fJournalInode;
  4594. +
  4595.             uint32              fFlags;
  4596.             uint32              fBlockSize;
  4597.             uint32              fBlockShift;
  4598.             uint32              fFirstDataBlock;
  4599. +
  4600.             uint32              fNumInodes;
  4601.             uint32              fNumGroups;
  4602. +           uint32              fFreeBlocks;
  4603. +           uint32              fFreeInodes;
  4604.             uint32              fGroupsPerBlock;
  4605.             ext2_block_group**  fGroupBlocks;
  4606.             uint32              fInodesPerBlock;
  4607. Index: src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp
  4608. ===================================================================
  4609. --- src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp  (revision 37534)
  4610. +++ src/add-ons/kernel/file_systems/ext2/DirectoryIterator.cpp  (working copy)
  4611. @@ -8,6 +8,7 @@
  4612.  
  4613.  #include <string.h>
  4614.  
  4615. +#include "CachedBlock.h"
  4616.  #include "HTree.h"
  4617.  #include "Inode.h"
  4618.  
  4619. @@ -23,8 +24,11 @@
  4620.  DirectoryIterator::DirectoryIterator(Inode* inode)
  4621.     :
  4622.     fInode(inode),
  4623. -   fOffset(0)
  4624. +   fLogicalBlock(0),
  4625. +   fDisplacement(0),
  4626. +   fBlockSize(inode->GetVolume()->BlockSize())
  4627.  {
  4628. +   fInitStatus = fInode->FindBlock(0, fPhysicalBlock);
  4629.  }
  4630.  
  4631.  
  4632. @@ -34,60 +38,132 @@
  4633.  
  4634.  
  4635.  status_t
  4636. +DirectoryIterator::InitCheck()
  4637. +{
  4638. +   return fInitStatus;
  4639. +}
  4640. +
  4641. +
  4642. +status_t
  4643.  DirectoryIterator::GetNext(char* name, size_t* _nameLength, ino_t* _id)
  4644.  {
  4645. -   if (fOffset + sizeof(ext2_dir_entry) >= fInode->Size()) {
  4646. +   if (fLogicalBlock * fBlockSize + fDisplacement
  4647. +           + ext2_dir_entry::MinimumSize() >= fInode->Size()) {
  4648.         TRACE("DirectoryIterator::GetNext() out of entries\n");
  4649.         return B_ENTRY_NOT_FOUND;
  4650.     }
  4651.  
  4652. -   ext2_dir_entry entry;
  4653. +   CachedBlock cached(fInode->GetVolume());
  4654. +   ext2_dir_entry* entry;
  4655.  
  4656. -   while (true) {
  4657. -       size_t length = ext2_dir_entry::MinimumSize();
  4658. -       status_t status = fInode->ReadAt(fOffset, (uint8*)&entry, &length);
  4659. -       if (status != B_OK)
  4660. -           return status;
  4661. -       if (length < ext2_dir_entry::MinimumSize() || entry.Length() == 0)
  4662. +   const uint8* block = cached.SetTo(fPhysicalBlock);
  4663. +   if (block == NULL)
  4664. +       return B_IO_ERROR;
  4665. +
  4666. +   bool gotEntry = false;
  4667. +   while (!gotEntry) {
  4668. +       TRACE("Checking entry at block %lu, displacement %lu\n", fPhysicalBlock,
  4669. +           fDisplacement);
  4670. +
  4671. +       entry = (ext2_dir_entry*)(block + fDisplacement);
  4672. +
  4673. +       if (entry->Length() == 0) {
  4674. +           TRACE("empty entry.\n");
  4675.             return B_ENTRY_NOT_FOUND;
  4676. -       if (!entry.IsValid())
  4677. +       }
  4678. +       if (!entry->IsValid()) {
  4679. +           TRACE("invalid entry.\n");
  4680.             return B_BAD_DATA;
  4681. +       }
  4682.  
  4683. -       if (entry.NameLength() != 0)
  4684. -           break;
  4685. +       if (entry->NameLength() != 0) {
  4686. +           // Get name
  4687. +           gotEntry = true;
  4688.  
  4689. -       fOffset += entry.Length();
  4690. -       TRACE("DirectoryIterator::GetNext() skipping entry\n");
  4691. -   }
  4692. +           size_t length = entry->NameLength();
  4693.  
  4694. -   TRACE("offset %Ld: entry ino %lu, length %u, name length %u, type %u\n",
  4695. -       fOffset, entry.InodeID(), entry.Length(), entry.NameLength(),
  4696. -       entry.FileType());
  4697. +           TRACE("block %lu, displacement %lu: entry ino %lu, length %u, "
  4698. +               "name length %lu, type %lu\n", fLogicalBlock, fDisplacement,
  4699. +               entry->InodeID(), entry->Length(), (uint32)length,
  4700. +               (uint32)entry->FileType());
  4701.  
  4702. -   // read name
  4703. +           if (*_nameLength < length)
  4704. +               length = *_nameLength - 1;
  4705. +           memcpy(name, entry->name, length);
  4706. +           name[length] = '\0';
  4707.  
  4708. -   size_t length = entry.NameLength();
  4709. -   status_t status = fInode->ReadAt(fOffset + ext2_dir_entry::MinimumSize(),
  4710. -       (uint8*)entry.name, &length);
  4711. -   if (status == B_OK) {
  4712. -       if (*_nameLength < length)
  4713. -           length = *_nameLength - 1;
  4714. -       memcpy(name, entry.name, length);
  4715. -       name[length] = '\0';
  4716. +           *_id = entry->InodeID();
  4717. +           *_nameLength = length;
  4718. +       }
  4719.  
  4720. -       *_id = entry.InodeID();
  4721. -       *_nameLength = length;
  4722. +       fDisplacement += entry->Length();
  4723.  
  4724. -       fOffset += entry.Length();
  4725. +       if (fDisplacement == fBlockSize) {
  4726. +           TRACE("Reached end of block\n");
  4727. +
  4728. +           fDisplacement = 0;
  4729. +           fLogicalBlock++;
  4730. +          
  4731. +           if (fLogicalBlock * fBlockSize + ext2_dir_entry::MinimumSize()
  4732. +                   < fInode->Size()) {
  4733. +               status_t status = fInode->FindBlock(fLogicalBlock * fBlockSize,
  4734. +                   fPhysicalBlock);
  4735. +               if (status != B_OK)
  4736. +                   return status;
  4737. +           } else if (!gotEntry) {
  4738. +               TRACE("DirectoryIterator::GetNext() end of directory file\n");
  4739. +               return B_ENTRY_NOT_FOUND;
  4740. +           }
  4741. +
  4742. +           if (!gotEntry) {
  4743. +               block = cached.SetTo(fPhysicalBlock);
  4744. +               if (block == NULL)
  4745. +                   return B_IO_ERROR;
  4746. +           }
  4747. +       } else if (fDisplacement > fBlockSize && !gotEntry) {
  4748. +           TRACE("The entry isn't block aligned.\n");
  4749. +           // TODO: Is block alignment obligatory?
  4750. +           return B_BAD_DATA;
  4751. +       }
  4752. +
  4753. +       TRACE("DirectoryIterator::GetNext() skipping entry\n");
  4754.     }
  4755.  
  4756. -   return status;
  4757. +   return B_OK;
  4758.  }
  4759.  
  4760.  
  4761.  status_t
  4762.  DirectoryIterator::Rewind()
  4763.  {
  4764. -   fOffset = 0;
  4765. +   fDisplacement = 0;
  4766. +   fLogicalBlock = 0;
  4767. +
  4768. +   return fInode->FindBlock(0, fPhysicalBlock);
  4769. +}
  4770. +
  4771. +
  4772. +status_t
  4773. +DirectoryIterator::AddEntry(Transaction& transaction, char* name,
  4774. +   size_t _nameLength, ino_t id)
  4775. +{
  4776. +   // TODO: Perhaps we should search for an empty spot with enough space for
  4777. +   // the entry, to try to minimize framgentation
  4778. +
  4779. +   /*off_t offset = fInode->Size();
  4780. +   fBlock = FindBlock(offset,
  4781. +   uint8 nameLength = _nameLength > EXT2_NAME_LENGTH ? EXT2_NAME_LENGTH
  4782. +       : _nameLength;
  4783. +
  4784. +   ext2_dir_entry entry;
  4785. +   entry.SetInodeID(id);
  4786. +   entry.SetLength(nameLength);
  4787. +
  4788. +   status_t status = fInode->WriteAt(transaction, fOffset, (uint8*)&entry,
  4789. +       ext2_dir_entry::MinimumSize());
  4790. +   if (status != B_OK)
  4791. +       return status;
  4792. +   return fInode->WriteAt(transaction, fOffset
  4793. +       + ext2_dir_entry::MinimumSize(), name, (size_t)nameLength);*/
  4794.     return B_OK;
  4795.  }
  4796. Index: src/add-ons/kernel/file_systems/ext2/Journal.h
  4797. ===================================================================
  4798. --- src/add-ons/kernel/file_systems/ext2/Journal.h  (revision 0)
  4799. +++ src/add-ons/kernel/file_systems/ext2/Journal.h  (revision 0)
  4800. @@ -0,0 +1,242 @@
  4801. +/*
  4802. + * Copyright 2001-2010, Haiku Inc. All rights reserved.
  4803. + * This file may be used under the terms of the MIT License.
  4804. + *
  4805. + * Authors:
  4806. + *     Janito V. Ferreira Filho
  4807. + */
  4808. +#ifndef JOURNAL_H
  4809. +#define JOURNAL_H
  4810. +
  4811. +
  4812. +#define JOURNAL_MAGIC                              0xc03b3998U
  4813. +
  4814. +#define JOURNAL_DESCRIPTOR_BLOCK                   1
  4815. +#define JOURNAL_COMMIT_BLOCK                       2
  4816. +#define JOURNAL_SUPERBLOCK_V1                      3
  4817. +#define JOURNAL_SUPERBLOCK_V2                      4
  4818. +#define JOURNAL_REVOKE_BLOCK                       5
  4819. +
  4820. +#define JOURNAL_FLAG_ESCAPED                       1
  4821. +#define JOURNAL_FLAG_SAME_UUID                     2
  4822. +#define JOURNAL_FLAG_DELETED                       4
  4823. +#define JOURNAL_FLAG_LAST_TAG                      8
  4824. +
  4825. +#define JOURNAL_FEATURE_INCOMPATIBLE_REVOKE            1
  4826. +
  4827. +#define JOURNAL_KNOWN_READ_ONLY_COMPATIBLE_FEATURES    0
  4828. +#define JOURNAL_KNOWN_INCOMPATIBLE_FEATURES            \
  4829. +   JOURNAL_FEATURE_INCOMPATIBLE_REVOKE
  4830. +
  4831. +
  4832. +#include "Volume.h"
  4833. +
  4834. +#include <util/DoublyLinkedList.h>
  4835. +
  4836. +#include "Transaction.h"
  4837. +
  4838. +
  4839. +class RevokeManager;
  4840. +
  4841. +
  4842. +struct JournalHeader {
  4843. +   uint32          magic;
  4844. +   uint32          block_type;
  4845. +   uint32          sequence;
  4846. +   char            data[0];
  4847. +
  4848. +   uint32          Magic()         const  
  4849. +       { return B_BENDIAN_TO_HOST_INT32(magic); }
  4850. +   uint32          BlockType()     const  
  4851. +       { return B_BENDIAN_TO_HOST_INT32(block_type); }
  4852. +   uint32          Sequence()      const  
  4853. +       { return B_BENDIAN_TO_HOST_INT32(sequence); }
  4854. +
  4855. +   bool            CheckMagic()    const
  4856. +       { return Magic() == JOURNAL_MAGIC; }
  4857. +
  4858. +   void            MakeDescriptor(uint32 sequence);
  4859. +   void            MakeCommit(uint32 sequence);
  4860. +} _PACKED;
  4861. +
  4862. +
  4863. +struct JournalBlockTag {
  4864. +   uint32          block_number;
  4865. +   uint32          flags;
  4866. +
  4867. +   uint32          BlockNumber()   const  
  4868. +       { return B_BENDIAN_TO_HOST_INT32(block_number); }
  4869. +   uint32          Flags()         const  
  4870. +       { return B_BENDIAN_TO_HOST_INT32(flags); }
  4871. +
  4872. +   void            SetBlockNumber(uint32 block)
  4873. +       { block_number = B_HOST_TO_BENDIAN_INT32(block); }
  4874. +   void            SetFlags(uint32 new_flags)
  4875. +       { flags = B_HOST_TO_BENDIAN_INT32(new_flags); }
  4876. +   void            SetLastTagFlag()
  4877. +       { flags |= B_HOST_TO_BENDIAN_INT32(JOURNAL_FLAG_LAST_TAG); }
  4878. +   void            SetEscapedFlag()
  4879. +       { flags |= B_HOST_TO_BENDIAN_INT32(JOURNAL_FLAG_ESCAPED); }
  4880. +} _PACKED;
  4881. +
  4882. +
  4883. +struct JournalRevokeHeader {
  4884. +   JournalHeader   header;
  4885. +   uint32          num_bytes;
  4886. +
  4887. +   uint32          revoke_blocks[0];
  4888. +
  4889. +   uint32          NumBytes()      const  
  4890. +       { return B_BENDIAN_TO_HOST_INT32(num_bytes); }
  4891. +   uint32          RevokeBlock(int offset) const  
  4892. +       { return B_BENDIAN_TO_HOST_INT32(revoke_blocks[offset]); }
  4893. +} _PACKED;
  4894. +
  4895. +
  4896. +struct JournalSuperBlock {
  4897. +   JournalHeader   header;
  4898. +  
  4899. +   uint32          block_size;
  4900. +   uint32          num_blocks;
  4901. +   uint32          first_log_block;
  4902. +
  4903. +   uint32          first_commit_id;
  4904. +   uint32          log_start;
  4905. +
  4906. +   uint32          error;
  4907. +
  4908. +   uint32          compatible_features;
  4909. +   uint32          incompatible_features;
  4910. +   uint32          read_only_compatible_features;
  4911. +
  4912. +   uint8           uuid[16];
  4913. +
  4914. +   uint32          num_users;
  4915. +   uint32          dynamic_superblock;
  4916. +
  4917. +   uint32          max_transaction_blocks;
  4918. +   uint32          max_transaction_data;
  4919. +
  4920. +   uint32          padding[44];
  4921. +
  4922. +   uint8           user_ids[16*48];
  4923. +
  4924. +   uint32          BlockSize() const
  4925. +       { return B_BENDIAN_TO_HOST_INT32(block_size); }
  4926. +   uint32          NumBlocks() const
  4927. +       { return B_BENDIAN_TO_HOST_INT32(num_blocks); }
  4928. +   uint32          FirstLogBlock() const
  4929. +       { return B_BENDIAN_TO_HOST_INT32(first_log_block); }
  4930. +   uint32          FirstCommitID() const
  4931. +       { return B_BENDIAN_TO_HOST_INT32(first_commit_id); }
  4932. +   uint32          LogStart() const
  4933. +       { return B_BENDIAN_TO_HOST_INT32(compatible_features); }
  4934. +   uint32          IncompatibleFeatures() const
  4935. +       { return B_BENDIAN_TO_HOST_INT32(incompatible_features); }
  4936. +   uint32          ReadOnlyCompatibleFeatures() const
  4937. +       { return B_BENDIAN_TO_HOST_INT32(read_only_compatible_features); }
  4938. +   uint32          MaxTransactionData() const
  4939. +       { return B_BENDIAN_TO_HOST_INT32(max_transaction_data); }
  4940. +
  4941. +   void            SetLogStart(uint32 logStart)
  4942. +       { log_start = B_HOST_TO_BENDIAN_INT32(logStart); }
  4943. +   void            SetFirstCommitID(uint32 firstCommitID)
  4944. +       { first_commit_id = B_HOST_TO_BENDIAN_INT32(firstCommitID); }
  4945. +} _PACKED;
  4946. +
  4947. +class LogEntry;
  4948. +class Transaction;
  4949. +typedef DoublyLinkedList<LogEntry> LogEntryList;
  4950. +
  4951. +
  4952. +class Journal {
  4953. +public:
  4954. +                               Journal(Volume *fsVolume, Volume *jVolume);
  4955. +   virtual                     ~Journal();
  4956. +
  4957. +   virtual status_t            InitCheck();
  4958. +   virtual status_t            Recover();
  4959. +   virtual status_t            StartLog();
  4960. +           status_t            RestartLog();
  4961. +
  4962. +   virtual status_t            Lock(Transaction* owner,
  4963. +                                   bool separateSubTransactions);
  4964. +   virtual status_t            Unlock(Transaction* owner, bool success);
  4965. +
  4966. +   virtual status_t            MapBlock(uint32 logical, uint32& physical);
  4967. +   inline  uint32              FreeLogBlocks() const;
  4968. +          
  4969. +           status_t            FlushLogAndBlocks();
  4970. +
  4971. +           int32               TransactionID() const;
  4972. +
  4973. +           Volume*             GetFilesystemVolume()
  4974. +               { return fFilesystemVolume; }
  4975. +protected:
  4976. +                               Journal();
  4977. +  
  4978. +   virtual status_t            _WriteTransactionToLog();
  4979. +
  4980. +           status_t            _SaveSuperBlock();
  4981. +           status_t            _LoadSuperBlock();
  4982. +
  4983. +
  4984. +           Volume*             fJournalVolume;
  4985. +           void*               fJournalBlockCache;
  4986. +           Volume*             fFilesystemVolume;
  4987. +           void*               fFilesystemBlockCache;
  4988. +
  4989. +           recursive_lock      fLock;
  4990. +           Transaction*        fOwner;
  4991. +
  4992. +           RevokeManager*      fRevokeManager;
  4993. +
  4994. +           status_t            fInitStatus;
  4995. +           uint32              fBlockSize;
  4996. +           uint32              fFirstCommitID;
  4997. +           uint32              fFirstCacheCommitID;
  4998. +           uint32              fFirstLogBlock;
  4999. +           uint32              fLogSize;
  5000. +           uint32              fVersion;
  5001. +          
  5002. +           uint32              fLogStart;
  5003. +           uint32              fLogEnd;
  5004. +           uint32              fFreeBlocks;
  5005. +           uint32              fMaxTransactionSize;
  5006. +
  5007. +           uint32              fCurrentCommitID;
  5008. +           //uint32                fNextCommitID;
  5009. +
  5010. +           LogEntryList        fLogEntries;
  5011. +           mutex               fLogEntriesLock;
  5012. +           bool                fHasSubTransaction;
  5013. +           bool                fSeparateSubTransactions;
  5014. +           int32               fUnwrittenTransactions;
  5015. +           int32               fTransactionID;
  5016. +
  5017. +private:
  5018. +           status_t            _CheckFeatures(JournalSuperBlock* superblock);
  5019. +
  5020. +           uint32              _CountTags(JournalHeader *descriptorBlock);
  5021. +           status_t            _RecoverPassScan(uint32& lastCommitID);
  5022. +           status_t            _RecoverPassRevoke(uint32 lastCommitID);
  5023. +           status_t            _RecoverPassReplay(uint32 lastCommitID);
  5024. +
  5025. +           status_t            _FlushLog(bool canWait, bool flushBlocks);
  5026. +
  5027. +   inline  uint32              _WrapAroundLog(uint32 block);
  5028. +          
  5029. +           size_t              _CurrentTransactionSize() const;
  5030. +           size_t              _FullTransactionSize() const;
  5031. +           size_t              _MainTransactionSize() const;
  5032. +          
  5033. +   virtual status_t            _TransactionDone(bool success);
  5034. +
  5035. +   static  void                _TransactionWritten(int32 transactionID,
  5036. +                                   int32 event, void* _logEntry);
  5037. +   static  void                _TransactionIdle(int32 transactionID,
  5038. +                                   int32 event, void* _journal);
  5039. +};
  5040. +
  5041. +#endif // JOURNAL_H
  5042. +
  5043.  
  5044. Property changes on: src/add-ons/kernel/file_systems/ext2/Journal.h
  5045. ___________________________________________________________________
  5046. Added: svn:executable
  5047.    + *
  5048.  
  5049. Index: src/add-ons/kernel/file_systems/ext2/IndexedDirectoryIterator.h
  5050. ===================================================================
  5051. --- src/add-ons/kernel/file_systems/ext2/IndexedDirectoryIterator.h (revision 37534)
  5052. +++ src/add-ons/kernel/file_systems/ext2/IndexedDirectoryIterator.h (working copy)
  5053. @@ -17,7 +17,7 @@
  5054.  class IndexedDirectoryIterator : public DirectoryIterator {
  5055.  public:
  5056.                                 IndexedDirectoryIterator(off_t start,
  5057. -                                   uint32 blockSize, Inode* directory,
  5058. +                                   Inode* directory,
  5059.                                     HTreeEntryIterator* parent);
  5060.     virtual                     ~IndexedDirectoryIterator();
  5061.    
  5062. @@ -25,12 +25,15 @@
  5063.                                     ino_t* id);
  5064.            
  5065.             status_t            Rewind();
  5066. +
  5067. +           status_t            AddEntry(Transaction& transaction, char* name,
  5068. +                                   size_t _nameLength, ino_t id);
  5069. +
  5070.  private:
  5071.             bool                fIndexing;
  5072.             HTreeEntryIterator* fParent;
  5073. -           off_t               fMaxOffset;
  5074. -           uint32              fBlockSize;
  5075.             uint32              fMaxAttempts;
  5076. +           uint32              fPreviousBlock;
  5077.  };
  5078.  
  5079.  #endif // INDEXED_DIRECTORY_ITERATOR_H
  5080. Index: src/add-ons/kernel/file_systems/ext2/Transaction.cpp
  5081. ===================================================================
  5082. --- src/add-ons/kernel/file_systems/ext2/Transaction.cpp    (revision 0)
  5083. +++ src/add-ons/kernel/file_systems/ext2/Transaction.cpp    (revision 0)
  5084. @@ -0,0 +1,201 @@
  5085. +/*
  5086. + * Copyright 2001-2010, Haiku Inc. All rights reserved.
  5087. + * This file may be used under the terms of the MIT License.
  5088. + *
  5089. + * Authors:
  5090. + *     Janito V. Ferreira Filho
  5091. + */
  5092. +
  5093. +#include "Transaction.h"
  5094. +
  5095. +#include <string.h>
  5096. +
  5097. +#include <fs_cache.h>
  5098. +
  5099. +#include "Journal.h"
  5100. +
  5101. +
  5102. +TransactionListener::TransactionListener()
  5103. +{
  5104. +}
  5105. +
  5106. +
  5107. +TransactionListener::~TransactionListener()
  5108. +{
  5109. +}
  5110. +
  5111. +
  5112. +Transaction::Transaction()
  5113. +   :
  5114. +   fJournal(NULL),
  5115. +   fParent(NULL)
  5116. +{
  5117. +}
  5118. +
  5119. +
  5120. +Transaction::Transaction(Journal* journal)
  5121. +   :
  5122. +   fJournal(NULL),
  5123. +   fParent(NULL)
  5124. +{
  5125. +   Start(journal);
  5126. +}
  5127. +
  5128. +
  5129. +Transaction::~Transaction()
  5130. +{
  5131. +   if (IsStarted())
  5132. +       fJournal->Unlock(this, false);
  5133. +}
  5134. +
  5135. +status_t
  5136. +Transaction::Start(Journal* journal)
  5137. +{
  5138. +   if (IsStarted())
  5139. +       return B_OK;
  5140. +
  5141. +   fJournal = journal;
  5142. +   if (fJournal == NULL)
  5143. +       return B_ERROR;
  5144. +  
  5145. +   status_t status = fJournal->Lock(this, false);
  5146. +   if (status != B_OK)
  5147. +       fJournal = NULL;
  5148. +
  5149. +   return status;
  5150. +}
  5151. +
  5152. +
  5153. +status_t
  5154. +Transaction::Done(bool success)
  5155. +{
  5156. +   if (!IsStarted())
  5157. +       return B_OK;
  5158. +
  5159. +   status_t status = fJournal->Unlock(this, success);
  5160. +  
  5161. +   if (status == B_OK)
  5162. +       fJournal = NULL;
  5163. +
  5164. +   return status;
  5165. +}
  5166. +
  5167. +
  5168. +int32
  5169. +Transaction::ID() const
  5170. +{
  5171. +   if (!IsStarted())
  5172. +       return -1;
  5173. +
  5174. +   return fJournal->TransactionID();
  5175. +}
  5176. +
  5177. +
  5178. +bool
  5179. +Transaction::IsStarted() const
  5180. +{
  5181. +   return fJournal != NULL;
  5182. +}
  5183. +
  5184. +
  5185. +bool
  5186. +Transaction::HasParent() const
  5187. +{
  5188. +   return fParent != NULL;
  5189. +}
  5190. +
  5191. +
  5192. +status_t
  5193. +Transaction::WriteBlocks(off_t blockNumber, const uint8* buffer,
  5194. +   size_t numBlocks)
  5195. +{
  5196. +   if (!IsStarted())
  5197. +       return B_NO_INIT;
  5198. +
  5199. +   void* cache = GetVolume()->BlockCache();
  5200. +   size_t blockSize = GetVolume()->BlockSize();
  5201. +
  5202. +   for (size_t i = 0; i < numBlocks; ++i) {
  5203. +       void* block = block_cache_get_empty(cache, blockNumber + i, ID());
  5204. +       if (block == NULL)
  5205. +           return B_ERROR;
  5206. +      
  5207. +       memcpy(block, buffer, blockSize);
  5208. +       buffer += blockSize;
  5209. +
  5210. +       block_cache_put(cache, blockNumber + i);
  5211. +   }
  5212. +
  5213. +   return B_OK;
  5214. +}
  5215. +
  5216. +
  5217. +void
  5218. +Transaction::Split()
  5219. +{
  5220. +   cache_start_sub_transaction(fJournal->GetFilesystemVolume()->BlockCache(),
  5221. +       ID());
  5222. +}
  5223. +
  5224. +
  5225. +Volume*
  5226. +Transaction::GetVolume() const
  5227. +{
  5228. +   if (!IsStarted())
  5229. +       return NULL;
  5230. +
  5231. +   return fJournal->GetFilesystemVolume();
  5232. +}
  5233. +
  5234. +
  5235. +void
  5236. +Transaction::AddListener(TransactionListener* listener)
  5237. +{
  5238. +   if (!IsStarted())
  5239. +       panic("Transaction is not running!");
  5240. +
  5241. +   fListeners.Add(listener);
  5242. +}
  5243. +
  5244. +
  5245. +void
  5246. +Transaction::RemoveListener(TransactionListener* listener)
  5247. +{
  5248. +   if (!IsStarted())
  5249. +       panic("Transaction is not running!");
  5250. +
  5251. +   fListeners.Remove(listener);
  5252. +   listener->RemovedFromTransaction();
  5253. +}
  5254. +
  5255. +
  5256. +void
  5257. +Transaction::NotifyListeners(bool success)
  5258. +{
  5259. +   while (TransactionListener* listener = fListeners.RemoveHead()) {
  5260. +       listener->TransactionDone(success);
  5261. +       listener->RemovedFromTransaction();
  5262. +   }
  5263. +}
  5264. +
  5265. +
  5266. +void
  5267. +Transaction::MoveListenersTo(Transaction* transaction)
  5268. +{
  5269. +   while (TransactionListener* listener = fListeners.RemoveHead())
  5270. +       transaction->fListeners.Add(listener);
  5271. +}
  5272. +
  5273. +
  5274. +void
  5275. +Transaction::SetParent(Transaction* transaction)
  5276. +{
  5277. +   fParent = transaction;
  5278. +}
  5279. +
  5280. +
  5281. +Transaction*
  5282. +Transaction::Parent() const
  5283. +{
  5284. +   return fParent;
  5285. +}
  5286. Index: src/add-ons/kernel/file_systems/ext2/ext2.h
  5287. ===================================================================
  5288. --- src/add-ons/kernel/file_systems/ext2/ext2.h (revision 37534)
  5289. +++ src/add-ons/kernel/file_systems/ext2/ext2.h (working copy)
  5290. @@ -13,6 +13,8 @@
  5291.  #include <KernelExport.h>
  5292.  
  5293.  
  5294. +#define TRACE_EXT2
  5295. +
  5296.  #define EXT2_SUPER_BLOCK_OFFSET    1024
  5297.  
  5298.  struct ext2_super_block {
  5299. @@ -108,9 +110,16 @@
  5300.         { return B_LENDIAN_TO_HOST_INT32(read_only_features); }
  5301.     uint32 IncompatibleFeatures() const
  5302.         { return B_LENDIAN_TO_HOST_INT32(incompatible_features); }
  5303. +   ino_t  JournalInode() const
  5304. +       { return B_LENDIAN_TO_HOST_INT32(journal_inode); }
  5305.     uint32 HashSeed(uint8 i) const
  5306.         { return B_LENDIAN_TO_HOST_INT32(hash_seed[i]); }
  5307.  
  5308. +   void SetFreeInodes(uint32 freeInodes)
  5309. +       { free_inodes = B_HOST_TO_LENDIAN_INT32(freeInodes); }
  5310. +   void SetFreeBlocks(uint32 freeBlocks)
  5311. +       { free_blocks = B_HOST_TO_LENDIAN_INT32(freeBlocks); }
  5312. +
  5313.     bool IsValid();
  5314.         // implemented in Volume.cpp
  5315.  } _PACKED;
  5316. @@ -162,8 +171,16 @@
  5317.     uint16  _padding;
  5318.     uint32  _reserved[3];
  5319.  
  5320. +   uint32 BlockBitmap() const
  5321. +       { return B_LENDIAN_TO_HOST_INT32(block_bitmap); }
  5322. +   uint32 InodeBitmap() const
  5323. +       { return B_LENDIAN_TO_HOST_INT32(inode_bitmap); }
  5324.     uint32 InodeTable() const
  5325.         { return B_LENDIAN_TO_HOST_INT32(inode_table); }
  5326. +   uint16 FreeBlocks() const
  5327. +       { return B_LENDIAN_TO_HOST_INT16(free_blocks); }
  5328. +   uint16 FreeInodes() const
  5329. +       { return B_LENDIAN_TO_HOST_INT16(free_inodes); }
  5330.  } _PACKED;
  5331.  
  5332.  #define EXT2_DIRECT_BLOCKS         12
  5333. @@ -214,6 +231,7 @@
  5334.     uint16 Mode() const { return B_LENDIAN_TO_HOST_INT16(mode); }
  5335.     uint32 Flags() const { return B_LENDIAN_TO_HOST_INT32(flags); }
  5336.     uint16 NumLinks() const { return B_LENDIAN_TO_HOST_INT16(num_links); }
  5337. +   uint32 NumBlocks() const { return B_LENDIAN_TO_HOST_INT32(num_blocks); }
  5338.  
  5339.     time_t AccessTime() const { return B_LENDIAN_TO_HOST_INT32(access_time); }
  5340.     time_t CreationTime() const { return B_LENDIAN_TO_HOST_INT32(creation_time); }
  5341. @@ -270,11 +288,26 @@
  5342.     uint8   file_type;
  5343.     char    name[EXT2_NAME_LENGTH];
  5344.  
  5345. -   uint32 InodeID() const { return B_LENDIAN_TO_HOST_INT32(inode_id); }
  5346. -   uint16 Length() const { return B_LENDIAN_TO_HOST_INT16(length); }
  5347. -   uint8 NameLength() const { return name_length; }
  5348. -   uint8 FileType() const { return file_type; }
  5349. +   uint32  InodeID() const { return B_LENDIAN_TO_HOST_INT32(inode_id); }
  5350. +   uint16  Length() const { return B_LENDIAN_TO_HOST_INT16(length); }
  5351. +   uint8   NameLength() const { return name_length; }
  5352. +   uint8   FileType() const { return file_type; }
  5353.  
  5354. +   void    SetInodeID(uint32 id) { inode_id = B_HOST_TO_LENDIAN_INT32(id); }
  5355. +
  5356. +   void    SetLength(uint8 nameLength)
  5357. +   {
  5358. +       name_length = nameLength;
  5359. +
  5360. +       if (nameLength % 4 == 0) {
  5361. +           length = B_HOST_TO_LENDIAN_INT16(
  5362. +               (short)(nameLength + MinimumSize()));
  5363. +       } else {
  5364. +           length = B_HOST_TO_LENDIAN_INT16(
  5365. +               (short)(nameLength % 4 + 1 + MinimumSize()));
  5366. +       }
  5367. +   }
  5368. +
  5369.     bool IsValid() const
  5370.     {
  5371.         return Length() > MinimumSize();
  5372. Index: src/add-ons/kernel/file_systems/ext2/CachedBlock.h
  5373. ===================================================================
  5374. --- src/add-ons/kernel/file_systems/ext2/CachedBlock.h  (revision 37534)
  5375. +++ src/add-ons/kernel/file_systems/ext2/CachedBlock.h  (working copy)
  5376. @@ -9,32 +9,40 @@
  5377.  
  5378.  #include <fs_cache.h>
  5379.  
  5380. +#include "Transaction.h"
  5381.  #include "Volume.h"
  5382.  
  5383.  
  5384.  class CachedBlock {
  5385.  public:
  5386. -                   CachedBlock(Volume* volume);
  5387. -                   CachedBlock(Volume* volume, uint32 block);
  5388. -                   ~CachedBlock();
  5389. +                           CachedBlock(Volume* volume);
  5390. +                           CachedBlock(Volume* volume, uint32 block);
  5391. +                           ~CachedBlock();
  5392.  
  5393. -           void    Keep();
  5394. -           void    Unset();
  5395. +           void            Keep();
  5396. +           void            Unset();
  5397.  
  5398. -   const   uint8*  SetTo(uint32 block);
  5399. +           const uint8*    SetTo(uint32 block);
  5400. +           uint8*          SetToWritable(Transaction& transaction,
  5401. +                               uint32 block, bool empty = false);
  5402. +           uint8*          SetToWritableWithoutTransaction(uint32 block,
  5403. +                               bool empty = false);
  5404.  
  5405. -   const   uint8*  Block() const { return fBlock; }
  5406. -           off_t   BlockNumber() const { return fBlockNumber; }
  5407. +           const uint8*    Block() const { return fBlock; }
  5408. +           off_t           BlockNumber() const { return fBlockNumber; }
  5409.  
  5410.  private:
  5411. -                   CachedBlock(const CachedBlock &);
  5412. -                   CachedBlock &operator=(const CachedBlock &);
  5413. -                       // no implementation
  5414. +                           CachedBlock(const CachedBlock &);
  5415. +                           CachedBlock &operator=(const CachedBlock &);
  5416. +                               // no implementation
  5417. +                      
  5418. +           uint8*          _SetToWritableEtc(int32 transaction, uint32 block,
  5419. +                               bool empty);
  5420.  
  5421.  protected:
  5422. -   Volume*         fVolume;
  5423. -   uint32          fBlockNumber;
  5424. -   uint8*          fBlock;
  5425. +           Volume*         fVolume;
  5426. +           uint32          fBlockNumber;
  5427. +           uint8*          fBlock;
  5428.  };
  5429.  
  5430.  
  5431. @@ -94,4 +102,35 @@
  5432.     return fBlock = (uint8 *)block_cache_get(fVolume->BlockCache(), block);
  5433.  }
  5434.  
  5435. +
  5436. +inline uint8*
  5437. +CachedBlock::SetToWritable(Transaction& transaction, uint32 block, bool empty)
  5438. +{
  5439. +   return _SetToWritableEtc(transaction.ID(), block, empty);
  5440. +}
  5441. +
  5442. +
  5443. +inline uint8*
  5444. +CachedBlock::SetToWritableWithoutTransaction(uint32 block, bool empty)
  5445. +{
  5446. +   return _SetToWritableEtc((int32)-1, block, empty);
  5447. +}
  5448. +
  5449. +inline uint8*
  5450. +CachedBlock::_SetToWritableEtc(int32 transaction, uint32 block, bool empty)
  5451. +{
  5452. +   Unset();
  5453. +   fBlockNumber = block;
  5454. +
  5455. +   if (empty) {
  5456. +       fBlock = (uint8*)block_cache_get_empty(fVolume->BlockCache(),
  5457. +           block, transaction);
  5458. +   } else {
  5459. +       fBlock = (uint8*)block_cache_get_writable(fVolume->BlockCache(),
  5460. +           block, transaction);
  5461. +   }
  5462. +
  5463. +   return fBlock;
  5464. +}
  5465. +
  5466.  #endif // CACHED_BLOCK_H
  5467. Index: src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp
  5468. ===================================================================
  5469. --- src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp  (revision 0)
  5470. +++ src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp  (revision 0)
  5471. @@ -0,0 +1,141 @@
  5472. +/*
  5473. + * Copyright 2001-2010, Haiku Inc. All rights reserved.
  5474. + * This file may be used under the terms of the MIT License.
  5475. + *
  5476. + * Authors:
  5477. + *     Janito V. Ferreira Filho
  5478. + */
  5479. +
  5480. +#include "HashRevokeManager.h"
  5481. +
  5482. +#include <new>
  5483. +
  5484. +
  5485. +HashRevokeManager::HashRevokeManager()
  5486. +   :
  5487. +   kInitialHashSize(128)
  5488. +       // TODO: Benchmark and find an optimal value
  5489. +{
  5490. +}
  5491. +
  5492. +
  5493. +HashRevokeManager::~HashRevokeManager()
  5494. +{
  5495. +   hash_uninit(fHash);
  5496. +}
  5497. +
  5498. +
  5499. +status_t
  5500. +HashRevokeManager::Init()
  5501. +{
  5502. +   RevokeElement dummyElement;
  5503. +  
  5504. +   fHash = hash_init(kInitialHashSize, offset_of_member(dummyElement, next),
  5505. +       &HashRevokeManager::Compare,
  5506. +       &HashRevokeManager::Hash);
  5507. +
  5508. +   if (fHash == NULL)
  5509. +       return B_NO_MEMORY;
  5510. +
  5511. +   return B_OK;
  5512. +}
  5513. +
  5514. +
  5515. +status_t
  5516. +HashRevokeManager::Insert(uint32 block, uint32 commitID)
  5517. +{
  5518. +   RevokeElement* element = (RevokeElement*)hash_lookup(fHash, &block);
  5519. +  
  5520. +   if (element != NULL) {
  5521. +       if (element->commitID < commitID) {
  5522. +           status_t retValue = hash_remove(fHash, element);
  5523. +          
  5524. +           if (retValue != B_OK)
  5525. +               return retValue;
  5526. +
  5527. +           delete element;
  5528. +       }
  5529. +       else {
  5530. +           return B_OK;
  5531. +               // We already have a newer version of the block
  5532. +       }
  5533. +   }
  5534. +
  5535. +   return _ForceInsert(block, commitID);
  5536. +}
  5537. +
  5538. +
  5539. +status_t
  5540. +HashRevokeManager::Remove(uint32 block)
  5541. +{
  5542. +   RevokeElement* element = (RevokeElement*)hash_lookup(fHash, &block);
  5543. +
  5544. +   if (element == NULL)
  5545. +       return B_ERROR; // TODO: Perhaps we should just ignore?
  5546. +
  5547. +   status_t retValue = hash_remove(fHash, element);
  5548. +  
  5549. +   if (retValue == B_OK)
  5550. +       delete element;
  5551. +
  5552. +   return retValue;
  5553. +}
  5554. +
  5555. +
  5556. +bool
  5557. +HashRevokeManager::Lookup(uint32 block, uint32 commitID)
  5558. +{
  5559. +   RevokeElement* element = (RevokeElement*)hash_lookup(fHash, &block);
  5560. +
  5561. +   if (element == NULL)
  5562. +       return false;
  5563. +
  5564. +   return element->commitID >= commitID;
  5565. +}
  5566. +
  5567. +
  5568. +/*static*/ int
  5569. +HashRevokeManager::Compare(void* _revoked, const void *_block)
  5570. +{
  5571. +   RevokeElement* revoked = (RevokeElement*)_revoked;
  5572. +   uint32 block = *(uint32*)_block;
  5573. +
  5574. +   if (revoked->block == block)
  5575. +       return 0;
  5576. +
  5577. +   return (revoked->block > block) ? 1 : -1;
  5578. +}
  5579. +
  5580. +
  5581. +/*static*/ uint32
  5582. +HashRevokeManager::Hash(void* _revoked, const void* _block, uint32 range)
  5583. +{
  5584. +   RevokeElement* revoked = (RevokeElement*)revoked;
  5585. +   uint32 block = *(uint32*)_block;
  5586. +
  5587. +   if (revoked != NULL)
  5588. +       return revoked->block % range;
  5589. +
  5590. +   return block % range;
  5591. +}
  5592. +
  5593. +
  5594. +status_t
  5595. +HashRevokeManager::_ForceInsert(uint32 block, uint32 commitID)
  5596. +{
  5597. +   RevokeElement* element = new(std::nothrow) RevokeElement;
  5598. +
  5599. +   if (element == NULL)
  5600. +       return B_NO_MEMORY;
  5601. +
  5602. +   element->block = block;
  5603. +   element->commitID = commitID;
  5604. +
  5605. +   status_t retValue = hash_insert_grow(fHash, element);
  5606. +
  5607. +   if (retValue == B_OK)
  5608. +       fRevokeCount++;
  5609. +
  5610. +   return retValue;
  5611. +}
  5612. +
  5613.  
  5614. Property changes on: src/add-ons/kernel/file_systems/ext2/HashRevokeManager.cpp
  5615. ___________________________________________________________________
  5616. Added: svn:executable
  5617.    + *
  5618.  
  5619. Index: src/add-ons/kernel/file_systems/ext2/RevokeManager.h
  5620. ===================================================================
  5621. --- src/add-ons/kernel/file_systems/ext2/RevokeManager.h    (revision 0)
  5622. +++ src/add-ons/kernel/file_systems/ext2/RevokeManager.h    (revision 0)
  5623. @@ -0,0 +1,35 @@
  5624. +/*
  5625. + * Copyright 2001-2010, Haiku Inc. All rights reserved.
  5626. + * This file may be used under the terms of the MIT License.
  5627. + *
  5628. + * Authors:
  5629. + *     Janito V. Ferreira Filho
  5630. + */
  5631. +#ifndef REVOKEMANAGER_H
  5632. +#define REVOKEMANAGER_H
  5633. +
  5634. +#include "Journal.h"
  5635. +
  5636. +
  5637. +struct JournalRevokeHeader;
  5638. +
  5639. +class RevokeManager {
  5640. +public:
  5641. +                       RevokeManager();
  5642. +   virtual             ~RevokeManager() = 0;
  5643. +
  5644. +   virtual status_t    Insert(uint32 block, uint32 commitID) = 0;
  5645. +   virtual status_t    Remove(uint32 block) = 0;
  5646. +   virtual bool        Lookup(uint32 block, uint32 commitID) = 0;
  5647. +          
  5648. +           uint32      NumRevokes() { return fRevokeCount; }
  5649. +
  5650. +           status_t    ScanRevokeBlock(JournalRevokeHeader* revokeBlock,
  5651. +                           uint32 commitID);
  5652. +
  5653. +protected:
  5654. +           uint32      fRevokeCount;
  5655. +};
  5656. +
  5657. +#endif // REVOKEMANAGER_H
  5658. +
  5659.  
  5660. Property changes on: src/add-ons/kernel/file_systems/ext2/RevokeManager.h
  5661. ___________________________________________________________________
  5662. Added: svn:executable
  5663.    + *
  5664.  
  5665. Index: src/add-ons/kernel/file_systems/ext2/BitmapBlock.h
  5666. ===================================================================
  5667. --- src/add-ons/kernel/file_systems/ext2/BitmapBlock.h  (revision 0)
  5668. +++ src/add-ons/kernel/file_systems/ext2/BitmapBlock.h  (revision 0)
  5669. @@ -0,0 +1,48 @@
  5670. +/*
  5671. + * Copyright 2001-2010, Haiku Inc. All rights reserved.
  5672. + * This file may be used under the terms of the MIT License.
  5673. + *
  5674. + * Authors:
  5675. + *     Janito V. Ferreira Filho
  5676. + */
  5677. +#ifndef BITMAPBLOCK_H
  5678. +#define BITMAPBLOCK_H
  5679. +
  5680. +#include "CachedBlock.h"
  5681. +
  5682. +
  5683. +class BitmapBlock : public CachedBlock {
  5684. +public:
  5685. +                           BitmapBlock(Volume* volume, uint32 numBits);
  5686. +                           ~BitmapBlock();
  5687. +
  5688. +           bool            SetTo(uint32 block);
  5689. +           bool            SetToWritable(Transaction& transaction,
  5690. +                               uint32 block, bool empty = false);
  5691. +
  5692. +           bool            CheckMarked(uint32 start, uint32 length);
  5693. +           bool            CheckUnmarked(uint32 start, uint32 length);
  5694. +
  5695. +           bool            Mark(uint32 start, uint32 length,
  5696. +                               bool force = false);
  5697. +           bool            Unmark(uint32 start, uint32 length,
  5698. +                               bool force = false);
  5699. +
  5700. +           void            FindNextMarked(uint32& pos);
  5701. +           void            FindNextUnmarked(uint32& pos);
  5702. +
  5703. +           void            FindPreviousMarked(uint32& pos);
  5704. +
  5705. +           void            FindLargestUnmarkedRange(uint32& start,
  5706. +                               uint32& length);
  5707. +
  5708. +           uint32          NumBits() const;
  5709. +
  5710. +protected:
  5711. +           uint32*         fData;
  5712. +           const uint32*   fReadOnlyData;
  5713. +
  5714. +           uint32          fNumBits;
  5715. +};
  5716. +
  5717. +#endif // BITMAPBLOCK_H
  5718.  
  5719. Property changes on: src/add-ons/kernel/file_systems/ext2/BitmapBlock.h
  5720. ___________________________________________________________________
  5721. Added: svn:executable
  5722.    + *
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top