Changeset 1956

Timestamp:

02/28/09 16:03:24 (3 years ago)

Author:

mwhitworth

Message:

Rework buffer flusher, keep per-device dirty count, add waitqueue so threads can wait for a flush to be done.

Files:

• Whitix/tags/0.2b/fs/vfs/bcache.c (modified) (13 diffs)

Whitix/tags/0.2b/fs/vfs/bcache.c

@@ -41 +41 @@
 DWORD cacheSize=0;
 extern struct DevClass storageClass;
-int numDirty=0;
 
 static void _BufferWait(struct Buffer* buffer);
@@ -188 +187 @@
 static void BlockBufferRemove(struct Buffer* buff)
 {
-//      WaitForBuffer(buff); /* TODO: Have a wait parameter. */
+        DWORD flags;
+        
         MemFree(buff->data);
+        
+        IrqSaveFlags(flags);
         ListRemove(&buff->list);
+        IrqRestoreFlags(flags);
+        
         MemCacheFree(blockCache, buff);
 }
@@ -210 +214 @@
         /* Sleep on the request wait queue, which wakes up all waiters when EndRequest is called */
         WaitForBuffer(request->buffer);
+        
         return request->ioStatus;
 }
@@ -238 +243 @@
         {
                 /* I/O error */
-                KePrint("BlockSendRequest: error (%d) reading %u\n",err,request->sector);
+                KePrint("BlockSendRequest: error (%d) reading %u\n", err, request->sector);
                 err=-EIO;
         }
@@ -269 +274 @@
 
         if (!request)
-                return -EFAULT;
+        {
+                KePrint(KERN_ERROR "BlockSendRequest: could not build request for %u\n", buff->blockNum);
+                return -EIO;
+        }
 
         /* Buffer should already be locked if we're coming from BlockRead */
 
-        err = BlockSendRequestRaw(device,request);
+        err = BlockSendRequestRaw(device, request);
 
         MemCacheFree(requestCache, request);
@@ -293 +301 @@
                 return buff;
 
-        if (!(buff=BlockBufferAlloc(device,blockNum)))
+        if (!(buff=BlockBufferAlloc(device, blockNum)))
                 return NULL;
-
+                
         if (BlockBufferRead(device,buff))
         {
@@ -328 +336 @@
 {
         /* Just signal that the buffer is dirty, and let BufferFlusher write it to disk in the near future as an update */
+                
         if (!BitTestAndSet(&buffer->flags, BUFFER_DIRTY))
-                numDirty++;
-
-        if (numDirty == 1)
-        {
-                if (bufferFlusher)
-                        ThrResumeThread(bufferFlusher);
-        }
+                device->numDirty++;
+
+        if (bufferFlusher)
+                ThrResumeThread(bufferFlusher);
         
         return 0;
@@ -346 +352 @@
         struct Buffer* curr,*curr2;
         DWORD i;
-
+        
+        if (device->numDirty)
+        {
+                BlockSyncDevice(device);
+                WAIT_ON(&device->flushDone, !device->numDirty);
+        }
+        
         /* If any buffers were dirty - they would have been done by BlockWrite,
            which also writes them to disk through buffer flusher. So no need
@@ -375 +387 @@
         if (sDevice->softBlockSize == blockSize)
                 return 0;
-
+                
         /* Sync all buffers with the old size */
         BlockDeviceFreeAll(sDevice);
 
-        sDevice->softBlockSize=blockSize;
+        sDevice->softBlockSize = blockSize;
+                
         return 0;
 }
@@ -392 +405 @@
         struct Buffer* buff, *buff2;
 
-//      KePrint("BlockSyncDevice(%s), numDirty = %d\n", KeObjGetName(&device->device.object), numDirty);
-
+//      KePrint("BlockSyncDevice(%s), numDirty = %d\n", KeObjGetName(&device->device.object), device->numDirty);
+
+        if (device->syncing || !device->numDirty)
+                return 0;
+                
+        device->syncing = 1;
+
+again:
         for (i=0; i<HASH_NUM_ENTRIES; i++)
         {
-                struct ListHead* head=&device->hashLists[i];
+                struct ListHead* head = &device->hashLists[i];
 
                 /* Write all the blocks belonging to device to disk */
@@ -403 +422 @@
                         if (BufferDirty(buff))
                         {
+//                              KePrint("%#X: dirty(%u), %u\n", buff, buff->blockNum, device->numDirty);
+                                
+                                --device->numDirty;
+                                BitClear(&buff->flags, BUFFER_DIRTY);
+                                
                                 /* For each block, call the respective StorageDevice write function */
                                 DoBlockWrite(buff->device, buff);
-                                --numDirty;
-                                BitClear(&buff->flags, BUFFER_DIRTY);
+                                
+//                              KePrint("%#X: done dirty(%u), %u\n", buff, buff->blockNum, device->numDirty);
                         }
+                        
+                        if (!device->numDirty)
+                                goto out;
                 }
         }
-
+        
+out:
+        if (!device->numDirty)
+                WakeUpAll(&device->flushDone);
+        else
+                goto again;
+        
+        device->syncing = 0;
         return 0;
 }
@@ -459 +493 @@
         while (1)
         {
-                if (!numDirty)
-                {
-                        ThrSuspendThread(currThread);
-                        ThrSchedule();
-                }
+                ThrSuspendThread(currThread);
+                ThrSchedule();
                 
                 BlockSyncAll();
@@ -502 +533 @@
 
         PreemptDisable();
-
+        
         ListForEachEntry(curr, head, list)
                 if (curr->blockNum == blockNum)