Changeset 788 for Whitix/branches/fs/fs/journal/commit.c

Timestamp:

07/13/08 20:45:14 (5 months ago)

Author:

mwhitworth

Message:

Add to commit support, including waking up shadow block waiters when the metadata has been committed to disk.

Files:

• Whitix/branches/fs/fs/journal/commit.c (modified) (9 diffs)

Whitix/branches/fs/fs/journal/commit.c

@@ -20 +20 @@
 #include <fs/bcache.h>
 #include <fs/journal.h>
+#include <llist.h>
 #include <module.h>
 #include <print.h>
@@ -44 +45 @@
                 WakeUp(&journal->commitWait);
                 WaitAddToQueue(&journal->commitWaitDone, &waitEntry);
+                KePrint("%d %d\n", id, journal->commitSequence);
                 ThrSuspendThread(currThread);
                 ThrSchedule();
@@ -52 +54 @@
 }
 
+SYMBOL_EXPORT(JournalWaitCommit);
+
 struct JournalHead* JournalCommitMetadata(struct Journal* journal, struct JournalTrans* commitTrans)
 {
-        struct JournalHead* curr, *newHead;
+        struct JournalHead* curr, *curr2, *newHead;
         struct JournalHead* descriptor=NULL; /* On-disk structure. */
         struct JournalHeader* dHeader;
@@ -65 +69 @@
         DWORD blockNo;
 
-        ListForEachEntry(curr, &commitTrans->metaDataList, next)
-        {
+        ListForEachEntrySafe(curr, curr2, &commitTrans->metaDataList, next)
+        {
+                int tagFlags=0;
+
                 if (!descriptor)
                 {
@@ -92 +98 @@
 
                 JournalWriteMetadataBuffer(commitTrans, curr, &newHead, blockNo);
+
+                /* We get a copy of curr, newHead, that points at the journal block
+                 * to write to. The real write of metadata to the disk takes place
+                 * in the checkpoint.
+                 */
+
+                if (!firstTag)
+                        tagFlags |= JOURN_FLAG_SAME_UUID;
+
+                tag=(struct JournalBlockTag*)tagPointer;
+                tag->blockNum=CpuToBe32(JournHeadToBuffer(curr)->blockNum);
+                tag->flags=CpuToBe32(tagFlags);
+
+                tagPointer+=sizeof(struct JournalBlockTag);
+                spaceLeft-=sizeof(struct JournalBlockTag);
+
+                if (firstTag)
+                {
+                        memcpy(tagPointer, journal->uuid, 16);
+                        tagPointer+=16;
+                        spaceLeft-=16;
+                        firstTag=0;
+                }
+                
+                buffers[bufIndex++]=JournHeadToBuffer(newHead);
+                
+                /* Are we at the end of the list, or has the descriptor block run out of
+                 * space? 
+                 */
+                if (bufIndex == 64 || curr2->next.next == &commitTrans->metaDataList ||
+                        spaceLeft < sizeof(struct JournalBlockTag)+16)
+                {
+                        int i;
+                        
+                        KePrint("Submitting %d buffers\n", bufIndex);
+                        tag->flags|=CpuToBe32(JOURN_FLAG_LAST_TAG);
+                        
+                        JournalUnlock(journal);
+                        
+                        for (i=0; i<bufIndex; i++)
+                        {
+                                BlockWrite(buffers[i]->device, buffers[i]);
+                        }
+                        
+                        JournalLock(journal);
+                }
                 
         }
@@ -98 +150 @@
 }
 
-SYMBOL_EXPORT(JournalWaitCommit);
+int JournalWaitForIO(struct Journal* journal, struct JournalTrans* commitTrans)
+{
+        struct JournalHead* curr, *curr2;
+        struct JournalHead* shadow=ListEntry(commitTrans->shadowList.next, struct JournalHead, next), *shadow2;
+        
+        /* Go through the journal I/O list. */
+        ListForEachEntrySafe(curr, curr2, &commitTrans->ioList, next)
+        {
+                struct Buffer* buffer;
+                
+                buffer=JournHeadToBuffer(curr);
+                WaitForBuffer(buffer);
+                JournalUnfileBuffer(curr);
+                
+                /* Get the corresponding shadow buffer, and file that to a checkpoint list. */
+                shadow2=ListEntry(shadow->next.next, struct JournalHead, next);
+                KePrint("Filing %u\n", JournHeadToBuffer(shadow)->blockNum);            
+                JournalFileBuffer(shadow, commitTrans, JOURN_FORGET);
+                WakeUp(&shadow->wait);
+                shadow=shadow2;
+        }
+        
+        return 0;
+}
+
+int JournalWriteCommitRecord(struct Journal* journal, struct JournalTrans* commitTrans)
+{
+        struct JournalHead* head;
+        struct Buffer* buffer;
+        DWORD i;
+        
+        head=JournalGetDescriptorBuffer(journal);
+        buffer=JournHeadToBuffer(head);
+        
+        for (i=0; i<journal->sectorSize; i+=512)
+        {
+                struct JournalHeader* header=(struct JournalHeader*)(buffer->data+i);
+                header->magic=CpuToBe32(JFS_MAGIC);
+                header->blockType=CpuToBe32(JFS_COMMIT_BLOCK);
+                header->sequence=CpuToBe32(commitTrans->transId);
+        }
+        
+        JournalUnlock(journal);
+        
+        BlockWrite(buffer->device, buffer);
+        WaitForBuffer(buffer);
+        BufferRelease(buffer);
+        
+        return 0;
+}
 
 int JournalCommitTransaction(struct Journal* journal)
@@ -108 +209 @@
         commitTrans=journal->currTransaction;
 
-        KePrint(KERN_DEBUG "Committing %d\n", commitTrans->transId);
+        KePrint(KERN_DEBUG "Committing %d, %d\n", commitTrans->transId, commitTrans->updates);
+        
+        commitTrans->state=JTRANS_COMMIT;
 
         while (commitTrans->updates)
         {
-                KePrint("commitTrans = %u\n", commitTrans->updates);
+                JournalUnlock(journal);
+                KePrint("wait: %u ", commitTrans->updates);
+                WAIT_ON(journal->waitUpdates, !commitTrans->updates);
+                JournalLock(journal);
         }
 
@@ -120 +226 @@
         journal->committingTrans=commitTrans;
         journal->currTransaction=NULL;
+        
+        commitTrans->logStart=journal->head;
 
         /* Phase 2 */
@@ -127 +235 @@
         /* Write out metadata to the journal. */
         JournalCommitMetadata(journal, commitTrans);
-
-        JournalUnlock(journal);
+        
+        /* Make sure the data is written to disk, and the metadata is written to the
+         * journal.
+         */
+        JournalWaitForIO(journal, commitTrans);
+        
+        /* Make sure the descriptor records are written to disk */
+
+        ListAddTail(&commitTrans->next, &journal->checkpointTrans);
+        
+        /* Write the commit record. */
+        JournalWriteCommitRecord(journal, commitTrans);
+
+        /* TEST: Checkpoint the transaction. */
+        JournalCheckpoint(journal);
+
         WakeUp(&journal->commitWaitDone);