root / Whitix / branches / scheduler / video / virtual.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
 *
 */

/* TODO: Needs to be tightened up and rewritten in parts. sprintf'ing on user buffers
 * is not a good idea. */

#include <console.h>
#include <fs/devfs.h>
#include <fs/vfs.h>
#include <init.h>
#include <error.h>
#include <malloc.h>
#include <i386/ioports.h>
#include <task.h>
#include <net/network.h>
#include <net/socket.h>

#define VIRTUAL_MAX             10
#define VIRTUAL_BUFFER_SIZE             4096

/* Device number */
#define VIRTUAL_MAJOR   255

/* Master ioctls */
#define VIRTUAL_OPEN_MASTER             0

/* Master child ioctls */
#define VIRTUAL_GET_NAME                0

struct VirtualTerm
{
        struct File* master;
        char* masterOutput;
        int masterHead, masterTail;
        WaitQueue masterQueue;
        char* slavesOutput;
        int slaveHead, slaveTail;
        WaitQueue slaveQueue;
};

struct FileOps vChildOps;

struct VirtualTerm virtualT[VIRTUAL_MAX];

struct VirtualTerm* VirtualTermGet(struct File* file)
{
        return &virtualT[file->vNode->devId.minor-1];
}

int VirtualChildRead(struct File* file, char* data, unsigned int length)
{
        struct VirtualTerm* vTerm;
        DWORD size=0, oldSize;
        DWORD flags;

        vTerm=VirtualTermGet(file);

        if (file == vTerm->master)
        {
                WAIT_ON(vTerm->slaveQueue, vTerm->slaveHead != vTerm->slaveTail);

                IrqSaveFlags(flags);
                size=MIN(vTerm->slaveHead-vTerm->slaveTail, length);
                oldSize=size;

                while (size--)
                {
                        *data++=vTerm->slavesOutput[vTerm->slaveTail++];
                        vTerm->slaveTail &= VIRTUAL_BUFFER_SIZE-1;
                }
        }else{
                WAIT_ON(vTerm->masterQueue, vTerm->masterHead != vTerm->masterTail);

                IrqSaveFlags(flags);
                size=MIN(vTerm->masterHead-vTerm->masterTail, length);
                oldSize=size;

                while (size--)
                {
                        *data++=vTerm->masterOutput[vTerm->masterTail++];
                        vTerm->masterTail &= VIRTUAL_BUFFER_SIZE-1;
                }
        }

        IrqRestoreFlags(flags);

        return oldSize;
}

int VirtualChildWrite(struct File* file, char* data, unsigned int length)
{
        struct VirtualTerm* vTerm;
        DWORD flags;
        unsigned int tempLength;
        vTerm=VirtualTermGet(file);

        IrqSaveFlags(flags);
        tempLength=length;

        if (file == vTerm->master)
        {
                /* Echo */
                memcpy(&vTerm->masterOutput[vTerm->masterHead], data, length);
                vTerm->masterHead+=length;

                /* TODO: Add noecho option. See ConsoleIoCtl */
                memcpy(&vTerm->slavesOutput[vTerm->slaveHead], data, length);
                vTerm->slaveHead+=length;

                WakeUp(&vTerm->masterQueue);
        }else{
                IrqSaveFlags(flags);
//              length=MIN(vTerm->slaveHead-vTerm->Tail, length);

                while (length--)
                {
                        vTerm->slavesOutput[vTerm->slaveHead++]=*data++;
                        vTerm->slaveHead &= VIRTUAL_BUFFER_SIZE-1;
                }

                WakeUp(&vTerm->slaveQueue);
        }

        IrqRestoreFlags(flags);

        return tempLength;
}

int VirtualChildIoCtl(struct File* file, unsigned long code, char* data)
{
        switch (code)
        {
                case VIRTUAL_GET_NAME:
                        sprintf(data, "Consoles/Virtual%d", file->vNode->devId.minor-1);
                        return 0;
        }

        return 0;
}

int VirtualChildPoll(struct File* file, struct PollItem* item, struct PollQueue* pollQueue)
{
        struct VirtualTerm* vTerm;

        vTerm=VirtualTermGet(file);

        if (file == vTerm->master)
        {
                if ((item->events & POLL_IN) && vTerm->slaveHead != vTerm->slaveTail)
                        item->revents |= POLL_IN;

                if ((item->events & POLL_OUT) && vTerm->masterTail != ((vTerm->masterHead - 1) % VIRTUAL_BUFFER_SIZE))
                        item->revents |= POLL_OUT;

                PollAddWait(pollQueue, &vTerm->slaveQueue);
        }else{
                KePrint("Slave poll\n");
        }

        return 0;
}

struct FileOps vChildOps=
{
        .read = VirtualChildRead,
        .write = VirtualChildWrite,
        .ioctl = VirtualChildIoCtl,
        .poll = VirtualChildPoll,
};

int VirtualOpenMaster(int* fd)
{
        char buf[32];
        char path[64];
        int i=0;

        for (i=0; i<VIRTUAL_MAX; i++)
                if (!virtualT[i].master)
                        break;

        if (i == VIRTUAL_MAX)
                return -EMFILE;

        sprintf(buf, "Consoles/Virtual%d", i);

        DevAddDevice(buf, VIRTUAL_MAJOR, i+1, DEVICE_CHAR, &vChildOps);

        *fd=VfsGetFreeFd(current);

        if (*fd < 0)
                return *fd;

        sprintf(path, "%s/%s", DEVICES_PATH, buf);

        virtualT[i].master = &current->files[*fd];

        /* Allocate buffers for I/O, before anything happens. */
        virtualT[i].masterOutput=(char*)malloc(VIRTUAL_BUFFER_SIZE);
        virtualT[i].slavesOutput=(char*)malloc(VIRTUAL_BUFFER_SIZE);

        INIT_WAITQUEUE_HEAD(&virtualT[i].masterQueue);
        INIT_WAITQUEUE_HEAD(&virtualT[i].slaveQueue);

        /* TODO: Handle case where DoOpenFile is not successful. */

        return DoOpenFile(&current->files[*fd], path, 0, 0);
}

int VirtualMasterIoCtl(struct File* file, unsigned long code, char* data)
{
        switch (code)
        {
                case VIRTUAL_OPEN_MASTER:
                        return VirtualOpenMaster((int*)data);
        }

        return -ENOTIMPL;
}

struct FileOps vMasterOps=
{
        .ioctl = VirtualMasterIoCtl,
};

int VirtualInit()
{
        ZeroMemory(virtualT, VIRTUAL_MAX * sizeof(struct VirtualTerm));

        DevAddDevice("Consoles/VirtualMaster", VIRTUAL_MAJOR, 0, DEVICE_CHAR, &vMasterOps);
        return 0;
}

DeviceInit(VirtualInit);