API tools faq
paste
Advertisement
Guest User

Untitled

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