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

Timestamp:

07/09/08 15:26:36 (5 months ago)

Author:

mwhitworth

Message:

Add to journal code. Support for per-journal threads, flushing of metadata, and start of commit code.

Files:

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

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

@@ -44 +44 @@
 }
 
+struct JournalHead* JournalAllocHeader()
+{
+        return malloc(sizeof(struct JournalHead));
+}
+
+struct JournalHead* JournalAddHeader(struct Buffer* buffer)
+{
+        struct JournalHead* ret;
+
+        if (BufferJournal(buffer))
+        {
+                ret=BufferToJournHead(buffer);
+        }else{
+                ret=JournalAllocHeader();
+
+                buffer->flags |= 1 << BUFFER_JOURNAL;
+                buffer->privData=ret;
+                ret->buffer=buffer;
+                BufferGet(buffer);
+        }
+
+        return buffer->privData;
+}
+
+extern void SleepWakeup(void* data);
+
+void JournalCommitSetTimer(struct Timer* commitTimer, struct Journal* journal)
+{
+        /* Set up timer. */
+        commitTimer->func=SleepWakeup;
+        commitTimer->expires=journal->commitInterval*100000;
+        commitTimer->data=currThread;
+
+        TimerAdd(commitTimer);
+}
+
+/* Journal commit thread. */
+
+/* TODO: Move to commit.c */
+void JournalCommitter(void* arg)
+{
+        struct Journal* journal=(struct Journal*)arg;
+        struct Timer commitTimer;
+        INIT_WAITQUEUE_ENTRY(commitWait);
+
+        INIT_WAITQUEUE_HEAD(&journal->commitWait);
+        INIT_WAITQUEUE_HEAD(&journal->commitWaitDone);
+
+        KePrint(KERN_INFO "JournalCommitter: started journal with commit interval of %d"
+                " seconds\n", journal->commitInterval);
+
+        while (1)
+        {
+                /* There should be a transaction to commit. */
+                if (journal->commitSequence != journal->commitRequest)
+                {
+                        TimerRemove(&commitTimer);
+
+                        JournalCommitTransaction(journal);
+                }
+
+                /* May not always want timer running, esp. if we are waiting for commits. */
+                JournalCommitSetTimer(&commitTimer, journal);
+
+                WaitAddToQueue(&journal->commitWait, &commitWait);
+
+                ThrSuspendThread(currThread);
+                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 JournalNextLogBlock(struct Journal* journal, DWORD* ret)
+{
+        DWORD blockNum;
+
+        blockNum=journal->head;
+
+        journal->head++;
+        journal->free--;
+        
+        /* Check for wraparound! */
+
+        return JournalBlockMap(journal, blockNum, ret);
+}
+
+struct JournalHead* JournalGetDescriptorBuffer(struct Journal* journal)
+{
+        int err;
+        DWORD blockNum;
+        struct Buffer* buffer;
+
+        err=JournalNextLogBlock(journal, &blockNum);
+
+        if (err)
+                return NULL;
+
+        buffer=JournalBlockRead(journal, blockNum);
+
+        if (!buffer)
+                return NULL;
+
+        memset(buffer->data, 0, journal->sectorSize);
+
+        return JournalAddHeader(buffer);
+}
+
 struct Journal* JournalCreate(struct VNode* vNode)
 {
-        struct Journal* journal=JournalAllocate();
+        struct Journal* journal;
         DWORD blockNo;
         struct Buffer* headerBuf;
@@ -52 +163 @@
         struct VfsSuperBlock* superBlock=vNode->superBlock;
 
+        journal=JournalAllocate();
+
         if (!journal)
                 return NULL;
@@ -100 +213 @@
                 journal->version, journal->maxLength);
 
+        /* Start the per-journal commit kernel thread. */
+        journal->commitThread=ThrCreateKernelThreadArg(JournalCommitter, journal);
+        journal->commitInterval=JOURN_COMMIT_INTERVAL;
+
+        JournalRecover(journal, jSb);
+
+        /* Set up transaction sequence numbers. */
+        journal->commitSequence=journal->transSequence-1;
+        journal->commitRequest=journal->commitSequence;
+
+        journal->head=BeToCpu32(jSb->first);
+        journal->free=BeToCpu32(jSb->maxLen)-journal->head;
+
+        ThrStartThread(journal->commitThread);
+
         return journal;
 }