Changeset 1912 for Whitix/trunk/fs/fat/super.c

Timestamp:

02/24/09 20:57:26 (3 years ago)

Author:

mwhitworth

Message:

Add support for keep track of free clusters in a FAT32 filesystem, add WriteSuper function and ReadFsInfo.

Files:

• Whitix/trunk/fs/fat/super.c (modified) (6 diffs)

Whitix/trunk/fs/fat/super.c

@@ -27 +27 @@
 #include "fat.h"
 
+int FatWriteSuper(struct VfsSuperBlock* superBlock);
+
 struct SuperBlockOps fatSbOps=
 {
         .readVNode = FatReadVNode,
         .writeVNode = FatWriteVNode,
+        .writeSuper = FatWriteSuper,
 };
 
@@ -44 +47 @@
 };
 
+/* Update the freeClusters in the FsInfo sector on FAT32 */
+int FatWriteSuper(struct VfsSuperBlock* superBlock)
+{
+        struct FatSbInfo* sbInfo;
+        struct FatFsInfo* info;
+        struct Buffer* buff;
+        DWORD prevSize = superBlock->sDevice->softBlockSize;
+        
+        sbInfo = FatGetSbPriv(superBlock);
+
+        if (sbInfo->fatType != 32)
+                return 0;
+        
+        /* Need this to write the correct FsInfo sector. It will throw all blocks
+         * out of cache, but if we're calling this, we're either syncing or
+         * freeing the super typically.
+         */
+         
+        BlockSetSize(superBlock->sDevice, superBlock->sDevice->blockSize);
+        
+        buff = BlockRead(superBlock->sDevice, sbInfo->fsInfoSector);
+        
+        info = (struct FatFsInfo*)(buff->data + 0x1E0);
+        info->freeClusters = sbInfo->freeClusters;
+        
+        BlockWrite(buff->device, buff);
+        
+        BlockSetSize(superBlock->sDevice, prevSize);
+        
+        return 0;
+}
+
+int FatReadFsInfo(struct VfsSuperBlock* superBlock, unsigned long fsInfoSector)
+{
+        struct Buffer* buff;
+        struct FatFsInfo* info;
+        struct FatSbInfo* sbInfo;
+        BYTE* data;
+        int ret = 0;
+                
+        buff = BlockRead(superBlock->sDevice, fsInfoSector);
+        
+        if (!buff)
+                return -EIO;
+
+        data = (BYTE*)(buff->data);
+        info = (struct FatFsInfo*)(data + 0x1E0);
+                
+        /* Four byte signature at start of fsInfo sector. */
+        if (data[0] != 0x52 || data[1] != 0x52 || data[2] != 0x61 || data[3] != 0x41)
+        {
+                ret = -EINVAL;
+                goto out;
+        }
+        
+        /* TODO: Check info->signature? */
+        
+        /* Boot record signature at end of fsInfo sector. */
+        if (data[510] != 0x55 || data[511] != 0xAA)
+        {
+                ret = -EINVAL;
+                goto out;
+        }
+        
+        /* Store the number of free clusters, and update it again in WriteSuper. */
+        sbInfo = FatGetSbPriv(superBlock);
+        
+        sbInfo->freeClusters = info->freeClusters;
+        sbInfo->fsInfoSector = fsInfoSector;
+        
+        KePrint("sbInfo->freeClusters = %#X\n", sbInfo->freeClusters);
+        
+out:
+        if (ret)
+                KePrint(KERN_DEBUG "FAT: Invalid FAT32 filesystem.\n");
+                
+        BlockFree(buff);
+        return ret;
+}
+
 struct VfsSuperBlock* FatReadSuper(struct StorageDevice* dev,int flags,char* data)
 {
@@ -55 +138 @@
                 return NULL;
 
-        /* The soft block size at the start does not matter, so long as it is above 512,
-         * which is guaranteed. */
-
-        buff=BlockRead(dev, 0);
+        /* This fixes issue #110. The soft block size at the start should be the
+         * device's sector size as we may read the second sector of the disk in 
+         * FatReadFsInfo. */
+         
+        if (BlockSetSize(dev, dev->blockSize))
+                return NULL;
+
+        buff = BlockRead(dev, 0);
+        
         if (!buff)
         {
@@ -67 +155 @@
         bootSec=(struct FatBootSector*)(buff->data);
 
-        if (bootSec->bytesPerSec != 512 && bootSec->bytesPerSec != 1024 && bootSec->bytesPerSec != 2048 && bootSec->bytesPerSec
-                != 4096)
+        if (bootSec->bytesPerSec != 512 && bootSec->bytesPerSec != 1024 && bootSec->bytesPerSec != 2048 && bootSec->bytesPerSec != 4096)
         {
                 BlockFree(buff);
@@ -125 +212 @@
                 fatSbInfo->invalidCluster=0x0FFFFFF8;
         }
-
+        
+        /* Read the FsInfo structure if this is a FAT32 filesystem, so we can keep
+         * track of the free clusters and update it when necessary. */
+        if (fatSbInfo->fatType == 32)
+        {
+                if (FatReadFsInfo(retVal, bootSec->fsInfo))
+                        goto fail;
+        }
+        
         KePrint(KERN_DEBUG "FAT: drive is a FAT%u volume\n",(DWORD)fatSbInfo->fatType);
 
@@ -131 +226 @@
                 goto fail;
 
-        retVal->mount=VNodeGet(retVal, FAT_ROOT_ID);
+        retVal->mount = VNodeGet(retVal, FAT_ROOT_ID);
 
         if (!retVal->mount)