root / Whitix / branches / hybrid / fs / fat / super.c

/*  This file is part of Whitix.
 *
 *  Whitix is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Whitix is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Whitix; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include <console.h>
#include <typedefs.h>
#include <fs/vfs.h>
#include <malloc.h>
#include <error.h>
#include <init.h>
#include "fat.h"

struct SuperBlockOps fatSbOps=
{
        .allocVNode = NULL,
        .readVNode = FatReadVNode,
        .writeVNode = FatWriteVNode,
};

struct VNodeOps fatVNodeOps=
{
        .create = FatCreate,
        .remove = FatRemove,
        .lookup = FatLookup,
        .mkDir = FatMkDir,
        .rmDir = FatRmDir,
        .truncate = FatTruncate,
        .blockMap= FatBlockMap,
};

struct VfsSuperBlock* FatReadSuper(struct StorageDevice* dev,int flags,char* data)
{
        struct FatBootSector* bootSec;
        struct Buffer* buff;
        struct VfsSuperBlock* retVal;
        struct FatSbInfo* fatSbInfo;
        DWORD clusterCount,totalSectors;

        if (!dev)
                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);
        if (!buff)
        {
                printf("FAT: Failed to read superblock\n");
                return NULL;
        }

        bootSec=(struct FatBootSector*)(buff->data);

        if (bootSec->bytesPerSec != 512 && bootSec->bytesPerSec != 1024 && bootSec->bytesPerSec != 2048 && bootSec->bytesPerSec
                != 4096)
        {
                BlockFree(buff);
                return NULL;
        }

        retVal=VfsAllocSuper(dev,flags);
        if (!retVal)
                goto end;

        retVal->sbOps=&fatSbOps;

        /* Allocate the FAT-specific superblock structure */
        fatSbInfo=(struct FatSbInfo*)malloc(sizeof(struct FatSbInfo));
        if (!fatSbInfo)
                goto fail;

        retVal->privData=(void*)fatSbInfo;

        /* Fill the structure with info */
        fatSbInfo->fatStart=bootSec->reservedSectorCnt;

        if (!bootSec->secsPerFat && bootSec->secsPerFat32)
        {
                /* Must be FAT32 then */
                fatSbInfo->rootDirStart=bootSec->rootClus;
                fatSbInfo->fatLength=bootSec->secsPerFat32;
        }else{
                fatSbInfo->rootDirStart=bootSec->reservedSectorCnt+(bootSec->numFats*bootSec->secsPerFat);
                fatSbInfo->fatLength=bootSec->secsPerFat;
        }

        totalSectors=(bootSec->totalSecSmall) ? bootSec->totalSecSmall : bootSec->totalSectorsLarge;
        fatSbInfo->rootDirLength=(bootSec->numRootDirEnts*sizeof(struct FatDirEntry))/bootSec->bytesPerSec; /* FAT32 doesn't use this */
        fatSbInfo->firstDataSector=bootSec->reservedSectorCnt+(bootSec->numFats*fatSbInfo->fatLength)+fatSbInfo->rootDirLength;
        fatSbInfo->clusterLength=bootSec->bytesPerSec*bootSec->sectorsPerClus;
        fatSbInfo->secsPerClus=bootSec->sectorsPerClus;
        fatSbInfo->totalDataSectors=totalSectors-fatSbInfo->firstDataSector;
        fatSbInfo->numFats=bootSec->numFats;

        clusterCount=fatSbInfo->totalDataSectors/bootSec->sectorsPerClus;

        /* Set the FAT type and end of cluster marker, depending on the number of clusters */
        if (clusterCount < 4085)
        {
                fatSbInfo->fatType=12;
                fatSbInfo->invalidCluster=0xFF8;
        }else if (clusterCount < 65525)
        {
                fatSbInfo->fatType=16;
                fatSbInfo->invalidCluster=0xFFF8;
        }else{
                fatSbInfo->fatType=32;
                fatSbInfo->invalidCluster=0xFFFFFF8;
        }

        printf("Drive is a FAT%u volume\n",(DWORD)fatSbInfo->fatType);

        if (BlockSetSize(dev,bootSec->bytesPerSec))
                goto fail;

        retVal->mount=VNodeGet(retVal,FAT_ROOT_ID);

        if (!retVal->mount)
                goto fail;

end:
        if (buff->refs)
                BlockFree(buff);
        return retVal;

fail:
        /* privData is freed in VfsFreeSuper */
        VfsFreeSuper(retVal);
        retVal=NULL;
        goto end;
}

static struct FileSystem fatFileSystem={
        .name="FAT",
        .readSuper=FatReadSuper,
};

int FatInit()
{
        return VfsRegisterFileSystem(&fatFileSystem);
}

void FatExit()
{
        VfsDeregisterFileSystem(&fatFileSystem);
}

FsInit(FatInit);