Changeset 1912

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.

Location:

Whitix/trunk/fs/fat

Files:

• fat.c (modified) (5 diffs)
• fat.h (modified) (2 diffs)
• super.c (modified) (6 diffs)

Whitix/trunk/fs/fat/fat.c

@@ -229 +229 @@
         struct Buffer* buff;
 
+        DWORD freeClusters = sbInfo->freeClusters;
+        
         /* Cannot allocate clusters to the root directory in FAT12/16 */
         if (sbInfo->fatType != 32 && vNode->id == FAT_ROOT_ID)
@@ -283 +285 @@
                 *lastCluster=ret;
 
+        freeClusters--;
+        
+        /* If we've got FAT32 and a valid number of free clusters, update it. */
+        if (sbInfo->fatType == 32 && sbInfo->freeClusters != -1)
+        {
+                sbInfo->freeClusters = freeClusters;
+                SuperSetDirty(vNode->superBlock);
+        }       
+
         return 0;
 }
@@ -294 +305 @@
         int fromNum = number;
 
+        DWORD freeClusters = sbInfo->freeClusters;
+
         if (sbInfo->fatType != 32 && !vNode->id)
                 return -EPERM;
@@ -307 +320 @@
                 {
                         cluster=FatAccess(vNode->superBlock, cluster,-1);
+                        
+                        freeClusters++;
+                        
                         if (cluster >= sbInfo->invalidCluster)
-                        {
-                                KePrint("FatRemoveClusters: %d\n",number);
                                 return -EINVAL;
-                        }
 
                         --number;
@@ -331 +344 @@
                 fatVNodeInfo->startCluster=0; /* Since it doesn't have one anymore */
 
+        /* If we've got FAT32 and a valid number of free clusters, update it. */
+        if (sbInfo->fatType == 32 && sbInfo->freeClusters != -1)
+        {
+                sbInfo->freeClusters = freeClusters;
+                SuperSetDirty(vNode->superBlock);
+        }
+
         return 0;
 }

Whitix/trunk/fs/fat/fat.h

@@ -125 +125 @@
 }PACKED;
 
+struct FatFsInfo
+{
+        DWORD reserved1;
+        DWORD signature;
+        DWORD freeClusters;
+        DWORD nextCluster;
+        DWORD reserved2;
+};
+
 struct FatDirEntry
 {
@@ -155 +164 @@
 struct FatSbInfo
 {
-        DWORD fatStart,fatLength,rootDirStart,rootDirLength, rootDirEnts;
-        DWORD firstDataSector,totalDataSectors,clusterLength,secsPerClus;
-        DWORD fatType,invalidCluster,numFats;
+        /* FAT information */
+        DWORD fatStart, fatLength, fatType, invalidCluster, numFats;
+        
+        /* Root directory information */
+        DWORD rootDirStart, rootDirLength, rootDirEnts;
+        
+        /* Data sector and cluster layout */
+        DWORD firstDataSector,totalDataSectors, clusterLength, secsPerClus;
+        
+        /* Values that are only updated on FAT32 */
+        DWORD freeClusters, fsInfoSector;
 };
 

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)