Changeset 786 for Whitix/branches/fs/fs/journal/journals.c

Timestamp:

07/13/08 20:44:09 (5 months ago)

Author:

mwhitworth

Message:

Add DestroyJournal, JournalSetUuid and JournalUpdateSuperblock code, along with other fixes.

Files:

• Whitix/branches/fs/fs/journal/journals.c (modified) (10 diffs)

Whitix/branches/fs/fs/journal/journals.c

@@ -21 +21 @@
 #include <fs/vfs.h>
 #include <init.h>
+#include <malloc.h>
 #include <module.h>
 #include <print.h>
@@ -34 +35 @@
 int JournalBlockMap(struct Journal* journal, DWORD blockNo, DWORD* ret)
 {
-        int err;
+//      int err;
         struct VNode* vNode=journal->vNode;
 
@@ -62 +63 @@
                 buffer->privData=ret;
                 ret->buffer=buffer;
+                INIT_WAITQUEUE_HEAD(&ret->wait);
+                
                 BufferGet(buffer);
         }
 
-        return buffer->privData;
+        return ret;
+}
+
+void JournalUpdateSuperBlock(struct Journal* journal)
+{
+        DWORD blockNo;
+        struct Buffer* buffer;
+        struct JournalSuperBlock* jSb;
+        
+        JournalBlockMap(journal, 0, &blockNo);
+        
+        buffer=JournalBlockRead(journal, blockNo);
+        
+        jSb=(struct JournalSuperBlock*)(buffer->data);
+        
+        jSb->sequence=CpuToBe32(journal->tailSequence);
+        jSb->start=CpuToBe32(journal->tail);
+        
+        BlockWrite(buffer->device, buffer);
+        
+        WaitForBuffer(buffer);
 }
 
@@ -74 +97 @@
         /* Set up timer. */
         commitTimer->func=SleepWakeup;
-        commitTimer->expires=journal->commitInterval*100000;
+        commitTimer->expires=journal->commitInterval*100000/HZ;
         commitTimer->data=currThread;
 
@@ -97 +120 @@
         while (1)
         {
+                if (journal->flags & JOURN_UNMOUNT)
+                        break;
+                        
                 /* There should be a transaction to commit. */
                 if (journal->commitSequence != journal->commitRequest)
                 {
                         TimerRemove(&commitTimer);
-
                         JournalCommitTransaction(journal);
                 }
@@ -113 +138 @@
                 ThrSchedule(); /* Will return here when the thread is scheduled again */
                 WaitRemoveFromQueue(&journal->commitWait, &commitWait);
-                
+
                 /* Get the running transaction, if we timed out, and commit that. Check expires. */
                 if (journal->currTransaction && currTime.seconds >= journal->currTransaction->expires)
                         journal->commitRequest=journal->currTransaction->transId;
         }
-}
-
-int JournalWriteMetadataBuffer(struct JournalTrans* commmitTrans, struct JournalHead* old, 
-        struct JournalHead* new, DWORD blockNo)
-{
-        KePrint("JournalWriteMetadataBuffer\n");
+        
+        TimerRemove(&commitTimer);
+        
+        journal->flags=0;
+        WakeUp(&journal->commitWaitDone);
+        
+        ThrDoExitThread();
+}
+
+int JournalWriteMetadataBuffer(struct JournalTrans* commitTrans, struct JournalHead* old, 
+        struct JournalHead** new, DWORD blockNo)
+{
+        struct Buffer* newBuf, *oldBuf;
+
+        oldBuf=JournHeadToBuffer(old);
+        
+        newBuf=BlockBufferAlloc(oldBuf->device, blockNo);
+
+        /* Buffer is now locked, so copy over the data from old's buffer. */
+        memcpy(newBuf->data, oldBuf->data, oldBuf->device->blockSize);
+
+        *new=JournalAddHeader(newBuf);
+        (*new)->transaction=NULL;
+        
+        BufferUnlock(newBuf);
+
+        JournalFileBuffer(old, commitTrans, JOURN_SHADOW);
+        JournalFileBuffer(*new, commitTrans, JOURN_IO);
 
         return 0;
@@ -162 +209 @@
         return JournalAddHeader(buffer);
 }
+
+int JournalDestroy(struct Journal* journal)
+{
+        /* Shutdown the committer thread. */
+        journal->flags|=JOURN_UNMOUNT;
+        WakeUp(&journal->commitWait);
+        WAIT_ON(journal->commitWaitDone, !journal->flags);
+        
+        if (journal->currTransaction)
+                JournalCommitTransaction(journal->currTransaction);
+                
+        JournalLock(journal);
+        
+        JournalCheckpoint(journal);
+        
+        journal->tail=0;
+        journal->tailSequence=++journal->transSequence;
+        
+        JournalUpdateSuperBlock(journal);
+        
+        VNodeRelease(journal->vNode);
+        
+        JournalUnlock(journal); 
+        MemCacheFree(journalCache, journal);
+        
+        return 0;       
+}
+
+SYMBOL_EXPORT(JournalDestroy);
+
+void JournalSetUuid(struct Journal* journal, BYTE* uuid)
+{
+        memcpy(journal->uuid, uuid, 16);
+}
+
+SYMBOL_EXPORT(JournalSetUuid);
 
 struct Journal* JournalCreate(struct VNode* vNode)
@@ -177 +260 @@
 
         journal->vNode=vNode;
+        ListRemove(&vNode->next); /* So that SysUnmount can unmount. Is this the right way to do it? */
 
         /* Read the journal superblock. */
         JournalBlockMap(journal, 0, &blockNo);
+        
+        if ((int)blockNo == -1)
+        {
+                KePrint(KERN_ERROR "JournalCreate: could not read the journal superblock\n");
+                MemCacheFree(journalCache, journal);
+                return NULL;
+        }
 
         headerBuf=JournalBlockRead(journal, blockNo);
@@ -209 +300 @@
         journal->maxLength=vNode->size/BYTES_PER_SECTOR(vNode->superBlock);
         journal->sectorSize=BYTES_PER_SECTOR(vNode->superBlock);
-        journal->transSequence=1;
+        journal->transSequence=1; /* Check */
 
         if (BeToCpu32(jSb->maxLen) < journal->maxLength)
@@ -230 +321 @@
         journal->commitSequence=journal->transSequence-1;
         journal->commitRequest=journal->commitSequence;
-
-        journal->head=BeToCpu32(jSb->first);
+        journal->tailSequence=journal->transSequence;
+
+        journal->head=journal->tail=BeToCpu32(jSb->first);
         journal->free=BeToCpu32(jSb->maxLen)-journal->head;
 
+        INIT_LIST_HEAD(&journal->checkpointTrans);
+        INIT_WAITQUEUE_HEAD(&journal->waitUpdates);
+
         ThrStartThread(journal->commitThread);
 
+        /* TODO: Wait for it to get started up before continuing */
+
         return journal;
 }