root / Whitix / branches / hybrid / fs / devfs.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
 *
 */

/* devfs.c
 *
 * Implements the fully dynamic device filesystem and redirects I/O requests to the appropriate device. A fully dynamic 
 * device file-system. At startup, each device registers itself with the device file-system, and the fs keeps track of 
 * read, write and ioctl functions for each device. But this is hidden from the user, because it is mounted at DEVICES_PATH 
*/

#include <console.h>
#include <llist.h>
#include <typedefs.h>
#include <fs/vfs.h>
#include <fs/devfs.h>
#include <malloc.h>
#include <init.h>
#include <error.h>
#include <module.h>

/* Implement proper ramdisk support and remove. */
#include "../devices/storage/ata/ata.h"

/* Local prototypes */
int DevFsDirSize(struct DevFsDir* dir);

/* Root directory of the device filesystem. */
struct DevFsDir* rootDir;
struct DevFsEntry rootEntry;

struct SuperBlockOps devFsSbOps;
struct VNodeOps devFsVOps;
struct FileOps devFsFileOps;

int DevFsBlockRead(struct File* file,BYTE* buffer,DWORD size);
int DevFsBlockWrite(struct File* file,BYTE* buffer,DWORD size);
int DevFsBlockIoCtl(struct File* file,unsigned long code,char* data);

/* Generic operations for block devices */
struct FileOps devFsBlockOps={
        .read = DevFsBlockRead,
        .write = DevFsBlockWrite,
        .ioctl= DevFsBlockIoCtl
};

int DevFsBlockRead(struct File* file,BYTE* buffer,DWORD size)
{
        int readSize,readOffset,copyOffset=0;
        struct Buffer* buff;
        struct StorageDevice* sDevice;

        /* Get it from ops */
        sDevice=(struct StorageDevice*)DeviceGetOps(file->vNode);

        while (size > 0)
        {
                readOffset=(file->position % sDevice->softBlockSize);
                readSize=MIN(sDevice->softBlockSize-readOffset,size);

                buff=BlockRead(sDevice,file->position/sDevice->softBlockSize);

                /* Might be possible, if file->position > number of sectors */
                if (!buff)
                        return -EIO;

                memcpy(buffer+copyOffset,buff->data+readOffset,readSize);
                size-=readSize;
                copyOffset+=readSize;
                file->position+=readSize;
        }

        return copyOffset;
}

int DevFsBlockWrite(struct File* file,BYTE* buffer,DWORD size)
{
        int writeSize,writeOffset,copyOffset=0;
        struct Buffer* buff;
        struct StorageDevice* sDevice;

        /* Get it from ops */
        sDevice=(struct StorageDevice*)DeviceGetOps(file->vNode);

        while (size > 0)
        {
                writeOffset=(file->position % sDevice->softBlockSize);
                writeSize=MIN(sDevice->softBlockSize-writeOffset,size);

                buff=BlockRead(sDevice,file->position/sDevice->softBlockSize);

                /* Might be possible, if file->position > number of sectors */
                if (!buff)
                        return -EIO;

                memcpy((char*)(buff->data+writeOffset),(char*)(buffer+copyOffset),writeSize);
                BlockWrite(sDevice,buff);

                size-=writeSize;
                copyOffset+=writeSize;
                file->position+=writeSize;
        }

        return copyOffset;
}

int DevFsBlockIoCtl(struct File* file,unsigned long code,char* data)
{
        return StorageIoCtl((struct StorageDevice*)DeviceGetOps(file->vNode),code,data);
}

int DevFsReadVNode(struct VNode* vNode)
{
        struct DevFsEntry* entry=(struct DevFsEntry*)(vNode->id);
        struct StorageDevice* sDevice;

        vNode->extraInfo=entry;
        vNode->vNodeOps=&devFsVOps;

        vNode->mode=VFS_ATTR_READ | VFS_ATTR_WRITE;

        if (entry->type & VFS_ATTR_FILE)
        {
                vNode->mode |= VFS_ATTR_FILE;
                vNode->devId.major=entry->device.devId.major;
                vNode->devId.minor=entry->device.devId.minor;
                if (entry->type & DEVICE_BLOCK)
                {
                        vNode->fileOps=&devFsBlockOps;
                        vNode->mode |= VFS_ATTR_BLOCK;  
                
                        /* Get the total size of the block device. */
                        sDevice=(struct StorageDevice*)DeviceGetOps(vNode);
                        vNode->size=sDevice->blockSize*sDevice->totalSectors;
                }else if (entry->type & DEVICE_CHAR)
                {
                        vNode->mode |= VFS_ATTR_CHAR;
                        /* Just redirect to the usual char devices */
                        vNode->fileOps=entry->device.ops;
                        vNode->size=0;
                }
        }else if (entry->type & VFS_ATTR_DIR)
        {
                vNode->fileOps=&devFsFileOps;
                vNode->mode|=VFS_ATTR_DIR;
                vNode->size=DevFsDirSize(&entry->dir);
        }

        return 0;
}

int DevFsFreeVNode(struct VNode* vNode)
{
        /* This function is so that extraInfo (which contains the DevFsEntry and could be
        malloc'ed) is not freed by the virtual filesystem layer. */
        return 0;
}

int DevFsLookup(struct VNode** retVal,struct VNode* dir,char* name,int nameLength)
{
        struct DevFsDir* dDir;
        struct DevFsEntry* entry;

        entry=(struct DevFsEntry*)(dir->extraInfo);
        dDir=&entry->dir;

        /* Handle '..'. '..' on the root directory will already have been handled by the VFS. */
        if (nameLength == 2 && name[0] == '.' && name[1] == '.')
        {
                dDir=dDir->parent;
                entry=(struct DevFsEntry*)(((DWORD)dDir)-offsetof(struct DevFsEntry, dir));
                goto found;
        }

        ListForEachEntry(entry,&(dDir->entries),next)
                if (!strnicmp(entry->name,name,nameLength))
                        goto found;

        /* Cycled through the whole directory with no luck */
        return -ENOENT;

found:
        *retVal=VNodeGet(dir->superBlock,(DWORD)entry);
        return 0;
}

struct DevFsDir* DevDirLookup(char* name,int nameLength,struct DevFsDir* dir)
{
        struct DevFsEntry* entry;
        
        /* Look it up */
        ListForEachEntry(entry,&(dir->entries),next)
        {
                if ((entry->type & VFS_ATTR_DIR) && !strnicmp(entry->name, name, nameLength))
                        return &entry->dir;
        }       
        
        return NULL;
}

int DevAddDevice(char* name, WORD major, WORD minor, int type, void* ops)
{
        struct DevFsEntry* entry;
        struct DevFsDevice* device;
        struct DevFsDir* dir=rootDir;
        char* endName;
        DWORD offset;

        /* Sanity checks */
        if (!name || !ops)
                return -EFAULT;

        if (!major)
                return -EINVAL;

        /* Get to the directory first. */
        while ((endName=strchr(name,'/')))
        {
                offset=(DWORD)(endName-name);
                dir=DevDirLookup(name, offset,dir);
                if (!dir)
                        return -ENOENT;
                        
                name+=offset+1;
        }

//      printf("DevAddDevice(%s)\n", name);

        /* Check if the name exists already */
        ListForEachEntry(entry,&(dir->entries),next)
                if (!strnicmp(entry->name,name,strlen(name)))
                        return -EEXIST;

        /* Allocate the DevFsEntry, and the name with it */
        entry=(struct DevFsEntry*)malloc(sizeof(struct DevFsEntry)+strlen(name)+1);
        if (!entry)
                return -ENOMEM;

        /* Always a device */
        entry->type=type | VFS_ATTR_FILE | VFS_ATTR_READ | VFS_ATTR_WRITE;
        strcpy(entry->name,name);
        
        device=(struct DevFsDevice*)(&entry->device);
        
        device->ops=ops;
        device->devId.major=major;
        device->devId.minor=minor;
        ListAddTail(&entry->next,&dir->entries);

        return 0;
}

SYMBOL_EXPORT(DevAddDevice);

/* Find root block device by major/minor number. Used in the ISO boot, which
 * will soon be replaced with a init ramdisk. */

struct StorageDevice* DevFindRootDev(WORD major,WORD minor)
{
        /* Any storage devices will be found in the Storage directory. */
        struct DevFsDir* dir;
        struct DevFsEntry* entry;
        
        dir=DevDirLookup("Storage", strlen("Storage"), rootDir);
        
        if (!dir)
                return NULL;
        
        ListForEachEntry(entry,&(dir->entries), next)
        {
                if (entry->type & VFS_ATTR_FILE)
                {
                        if (entry->device.devId.major == major && entry->device.devId.minor == minor && (entry->type & DEVICE_BLOCK))
                                return (struct StorageDevice*)(entry->device.ops);
                }
        }

        return NULL;
}

/* FIXME: Must be a better way to handle this. */
struct StorageDevice* DevGetCdDevice()
{
        int i;
        struct StorageDevice* rootDev=NULL;

        /* Temporary hack for live cd */
        for (i=0; i<256; i+=64)
        {
                struct AtaDrive* drive;
                rootDev=DevFindRootDev(4,i);
                if (!rootDev)
                        continue;

                drive=(struct AtaDrive*)(rootDev->priv);

                if (drive->type & ATA_REMOVABLE)
                        break;
        }

        /* Didn't find it */
        if (i == 256)
                rootDev=NULL;

        return rootDev;
}

void DevMountRoot(BYTE biosDriveNo, WORD rootDevMajor, WORD rootDevMinor)
{
        struct StorageDevice* rootDev=NULL;

        /* For ISO filesystems, have a ramdisk - makes life a lot easier */
        if (biosDriveNo > 0x80 && rootDevMajor == 4)
                rootDev=DevGetCdDevice();
        else
                /* Decode root filesystem here */
                rootDev=DevFindRootDev(rootDevMajor,rootDevMinor);

        if (!rootDev)
        {
                KePrint("Device major:%d, minor: %d not valid root device.\n",(int)rootDevMajor,(int)rootDevMinor);
                cli();
                hlt();
        }

        return VfsMountRoot(rootDev);
}

SYMBOL_EXPORT(DevMountRoot);

int DevAddDir(char* name)
{
        char* endName;
        DWORD offset;
        struct DevFsDir* dir=rootDir, *newDir;
        struct DevFsEntry* entry;       
        
        /* Get to the directory */
        while ((endName=strchr(name,'/')))
        {
                offset=(DWORD)(endName-name);
                dir=DevDirLookup(name, strlen(name),dir);
                if (!dir)
                        return -ENOENT;
        }
        
        /* Check it doesn't exist already. */
        ListForEachEntry(entry,&(dir->entries),next)
                if (!strnicmp(entry->name,name,strlen(name)))
                        return -EEXIST;
        
        /* Add entry. */
        entry=(struct DevFsEntry*)malloc(sizeof(struct DevFsEntry)+strlen(name)+1);
        entry->type=VFS_ATTR_DIR | VFS_ATTR_READ;
        strcpy(entry->name, name);
        
        newDir=&entry->dir;
        INIT_LIST_HEAD(&newDir->entries);
        newDir->parent=dir;
        
        ListAddTail(&entry->next,&dir->entries);
        return 0;
}

int DevRemoveDevice(struct DevFsEntry* device)
{
        KePrint("DevRemoveDevice\n");
        return 0;
}

int DevFsPermission(struct VNode* node,int access)
{
        KePrint("DevFsPermission\n");
        return 0;
}

int DevFsReadDir(struct File* file,void* dirEntries)
{
        struct DevFsEntry* entry;
        struct DevFsEntry* entryDir=(struct DevFsEntry*)(file->vNode->extraInfo);
        struct DevFsDir* dir=&entryDir->dir;
        int ret;

        ListForEachEntry(entry, &(dir->entries), next)
        {
                ret=FillDir(dirEntries,entry->name,strlen(entry->name),(DWORD)entry);
                if (ret < 0)
                        return ret;

                file->position++;
        }

        return 0;
}

struct SuperBlockOps devFsSbOps=
{
        .readVNode = DevFsReadVNode,
        .freeVNode = DevFsFreeVNode,
};

struct VNodeOps devFsVOps=
{
        .lookup=DevFsLookup,
        .permission=DevFsPermission,
};

/* Only for devfs directories */
struct FileOps devFsFileOps=
{
        .readDir=DevFsReadDir,
};

int DevFsDirSize(struct DevFsDir* dir)
{
        struct DevFsEntry* entry;
        int i=0;

        ListForEachEntry(entry, &(dir->entries), next)
                i++;

        return i;
}

struct VfsSuperBlock* DevFsReadSuper(struct StorageDevice* dev,int flags,char* data)
{
        struct VfsSuperBlock* retVal;

        /* Should not be mounted on a device */
        if (dev)
                return NULL;

        retVal=VfsAllocSuper(NULL,0);
        if (!retVal)
                return NULL;

        retVal->sbOps=&devFsSbOps;
        retVal->mount=VNodeGet(retVal,(DWORD)&rootEntry);
        retVal->mount->mode=VFS_ATTR_DIR | VFS_ATTR_READ;
        retVal->mount->size=DevFsDirSize(rootDir);
        retVal->mount->vNodeOps=&devFsVOps;
        retVal->mount->fileOps=&devFsFileOps;
        retVal->mount->extraInfo=(void*)&rootEntry;

        return retVal;
}

static struct FileSystem devFileSystem=
{
        .name = "DevFs",
        .readSuper = DevFsReadSuper,
};

int DevFsInit()
{
        /* Set up the data structure here, and DevFsReadSuper doesn't do too much (at the moment) */
        VfsRegisterFileSystem(&devFileSystem);

        /* Set up the root directory here, as devices will be added before ReadSuper is called. */
        rootEntry.type=VFS_ATTR_DIR | VFS_ATTR_READ | VFS_ATTR_WRITE;
        rootEntry.name[0]='\0';
        rootEntry.dir.parent=NULL; /* Parent is handled by VFS for the root directory. */
        INIT_LIST_HEAD(&rootEntry.dir.entries);
        rootDir=&rootEntry.dir;

        /* Add standard directories */
        DevAddDir("Consoles");
        DevAddDir("Special");
        DevAddDir("Storage");
        DevAddDir("Input");

        return 0;
}

void DevFsExit()
{
        VfsDeregisterFileSystem(&devFileSystem);
}

FsInit(DevFsInit);