root / Whitix / branches / hybrid / fs / isofs / 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 <error.h>
#include <typedefs.h>
#include <fs/vfs.h>
#include <malloc.h>
#include <init.h>

#include "isofs.h"

static inline void IsoTranslateDirEnt(struct VNode* vNode,struct IsoDirEntry* dirEntry)
{
        vNode->mode=((dirEntry->flags & 2) ? VFS_ATTR_DIR : VFS_ATTR_FILE) | VFS_ATTR_READ;

        if (dirEntry->flags & 0x80)
        {
                KePrint("dirEntry->flags & 0x80!\n");
                cli(); hlt();
        }else
                vNode->size=dirEntry->length.native;
}

int IsoReadVNode(struct VNode* vNode)
{
        struct Buffer* buffer;
        DWORD offset=ISO_VNUM_OFFSET(vNode->id);
        struct IsoDirEntry* dirEntry, *tmpDirEntry=NULL;
        struct IsoVNodePriv* isoPriv;
        struct IsoSbPriv* sbPriv=IsoGetSbPriv(vNode->superBlock);
        int err=0;

        buffer=BlockRead(vNode->superBlock->sDevice,ISO_VNUM_SECTOR(vNode->id));

        if (!buffer)
        {
                KePrint("IsoReadVNode: failed to read buffer\n");
                return -EIO;
        }

        dirEntry=(struct IsoDirEntry*)(buffer->data+offset);

        /* Does the directory entry cross a sector boundary? If so,
         * read in the next sector and piece the entry together. */
        if (offset+dirEntry->entryLength > sbPriv->sectorSize)
        {
                int firstFrag = sbPriv->sectorSize-offset;
                tmpDirEntry=(struct IsoDirEntry*)malloc(sizeof(struct IsoDirEntry));
                if (!tmpDirEntry)
                {
                        err=-ENOMEM;
                        goto out;
                }
                        
                memcpy(tmpDirEntry, buffer->data+offset, firstFrag);
                BlockFree(buffer);
                
                buffer=BlockRead(vNode->superBlock->sDevice, ISO_VNUM_SECTOR(vNode->id)+1);
                if (!buffer)
                {
                        err=-EIO;
                        goto out;
                }
                
                memcpy((char*)(tmpDirEntry+firstFrag), buffer->data, tmpDirEntry->entryLength - firstFrag);
                dirEntry=tmpDirEntry;
        }

        IsoTranslateDirEnt(vNode,dirEntry);

        vNode->extraInfo=(struct IsoVNodePriv*)malloc(sizeof(struct IsoVNodePriv));

        if (!vNode->extraInfo)
        {
                err=-ENOMEM;
                goto out;
        }

        isoPriv=IsoGetPriv(vNode);
        isoPriv->firstSector=dirEntry->firstSector.native+dirEntry->extAddrLength;

        vNode->vNodeOps=&isoVNodeOps;
        vNode->fileOps=&isoFileOps;

out:
        if (tmpDirEntry)
                free(tmpDirEntry);

        BlockFree(buffer);
        return err;
}

/* TODO: Get the multisession information */

DWORD IsoGetVolStart(struct VfsSuperBlock* superBlock)
{
/* 
        int ret;
        struct CdRomMultiSession msInfo;

        ret=BlockIoCtl(superBlock->dev,CDROM_MULTISESSION,(void*)&msInfo);
*/
        return 0;
}

/* ISO volume descriptor types */

#define ISO_VD_PRI      0x01
#define ISO_VD_END      0xFF

#define ISO_VD_IDS      "CD001"

struct SuperBlockOps isoSbOps=
{
        .readVNode = IsoReadVNode,
        .writeVNode = NULL,
};

struct VfsSuperBlock* IsoReadSuper(struct StorageDevice* dev,int flags,char* data)
{
        struct VfsSuperBlock* retVal;
        struct Buffer* buff,*priBuff=NULL;
        struct IsoVolumeDesc* volDesc;
        struct IsoPrimaryDesc* priDesc=NULL;
        struct IsoDirEntry* rootEntry;
        struct IsoSbPriv* sbPriv;
        int currBlock;
        DWORD volStart;

        if (!dev || BlockSetSize(dev,2048))
                return NULL;

        retVal=VfsAllocSuper(dev,flags);

        if (!retVal)
                return NULL;

        retVal->sbOps=&isoSbOps;

        volStart=IsoGetVolStart(retVal);

        for (currBlock=volStart+16; currBlock<volStart+100; currBlock++)
        {
                buff=BlockRead(dev,currBlock);
                if (!buff)
                        goto freeSuper;

                volDesc=(struct IsoVolumeDesc*)buff->data;

                if (!strncmp((char*)volDesc->id,ISO_VD_IDS,5))
                {
                        if (volDesc->type == ISO_VD_END)
                                break;

                        if (volDesc->type == ISO_VD_PRI)
                        {
                                priDesc=(struct IsoPrimaryDesc*)volDesc;
                                priBuff=buff;
                                buff=NULL; /* So it isn't freed */
                        }
                }

                if (buff)
                        BlockFree(buff);
        }

        if (!priDesc)
                goto freeSuper;

        rootEntry=&priDesc->root.dirEntry;

        retVal->privData=malloc(sizeof(struct IsoSbPriv));
        sbPriv=IsoGetSbPriv(retVal);
        sbPriv->sectorSize=priDesc->sectorSize.native;
        
        /* Is the sector size less than the hardware block size? If so, error out. */
        if (sbPriv->sectorSize < dev->blockSize)
                goto freeSuper;
                
        BlockSetSize(dev, sbPriv->sectorSize);

        if (sbPriv->sectorSize != 512 && sbPriv->sectorSize != 1024 && sbPriv->sectorSize != 2048)
                /* Not a valid size, so pretend we never read it. */
                goto freeSuper;

        retVal->mount=VNodeGet(retVal,ISO_TO_VNUM(rootEntry->firstSector.native,0));
        if (!retVal->mount)
                goto freeSuper;

        /* CDFS is always a read-only filesystem */
        retVal->flags|=SB_RDONLY;

freeBlock:
        if (priBuff)
                BlockFree(priBuff);
        return retVal;

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

static struct FileSystem isoFileSystem={
        .name="CDFS",
        .readSuper=IsoReadSuper,
};

int IsoFsInit()
{
        return VfsRegisterFileSystem(&isoFileSystem);
}

void IsoFsExit()
{
        VfsDeregisterFileSystem(&isoFileSystem);
}

FsInit(IsoFsInit);