root / Whitix / branches / hybrid / include / fs / vfs.h

/*  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
 *
 */

/* FIXME: Split file into separate headers. */

#ifndef VFS_H
#define VFS_H

/* VFS includes. */
#include <fs/exports.h>

#include <llist.h>
#include <sdevice.h>
#include <typedefs.h>
#include <types.h>
#include <time.h>
#include <wait.h>

/* vNode flags */

#define VFS_ATTR_FILE           1
#define VFS_ATTR_DIR            2
#define VFS_ATTR_READ           4
#define VFS_ATTR_WRITE          8
#define VFS_ATTR_BLOCK          16
#define VFS_ATTR_CHAR           32
#define VFS_ATTR_SOCKET         64

/* Flags for SysOpen and NameToVNode */

#define FILE_READ                       1
#define FILE_WRITE                      2
#define FILE_CREATE_OPEN        4
#define FILE_FORCE_OPEN         8
#define FILE_FORCE_CREATE       16
#define FILE_DIRECTORY          32 /* Only open the file if it is a directory */

/* General defines */
#define MAX_FILES 10 /* Max files per task */
#define PATH_MAX 2048

struct VNode;
struct File;
struct FileSystem;
struct VfsSuperBlock;
struct PollItem;
struct PollQueue;

int VfsInit();
int VfsMountRoot(struct StorageDevice* storageDev);
int VNodeInitCache();

/* Mount functions (super.c) */
int VfsMount(char* mountPoint,char* deviceName,char* fsName,void* mData);
struct VfsSuperBlock* VfsAllocSuper(struct StorageDevice* sDev,int flags);
void VfsFreeSuper(struct VfsSuperBlock* superBlock);

/* VNode functions (vnode.c) */
int NameToVNode(struct VNode** retVal,char* path,int flags);
struct VNode* DirNameVNode(char* path,char** retPath,int* retLen);

/* VNode cache functions (vcache.c) */
struct VNode* VNodeGet(struct VfsSuperBlock* superBlock,vid_t id);
struct VNode* VNodeGetEmpty();
void VNodeRelease(struct VNode* vNode);
void VNodeLock(struct VNode* vNode);
void VNodeUnlock(struct VNode* vNode);
void VNodeWrite(struct VNode* vNode);
int VNodeRead(struct VNode* vNode);
void VNodeWaitOn(struct VNode* vNode);

int VfsChangeDir(struct Process* process,char* dirName);

/* vNode time functions */
void VfsFileAccessed(struct VNode* vNode);
void VfsFileModified(struct VNode* vNode,int create);

/* File functions (file.cpp) */
int FileGenericRead(struct File* file,BYTE* buffer,size_t size);
int VfsGetFreeFd(struct Process* process);
struct File* FileGet(int fd);
int DoOpenFile(struct File* file,char* path,int flags,int perms);
int DoReadFile(struct File* file,BYTE* buffer,size_t size);
int DoWriteFile(struct File* file,BYTE* buffer,size_t size);
int DoCloseFile(struct File* file);
int DoSeekFile(struct File* file,int distance,int whence);

/* For demand loading */
int FileGenericReadPage(addr_t pageAddr,struct VNode* vNode,int offset);

char* GetName(char* path);

/* Move? */

typedef struct
{
        WORD major;
        WORD minor;
} DevId;

/* Used for the SysGetDirEntries system call */

struct DirEntry
{
        DWORD vNodeNum; /* Need this? */
        DWORD offset;
        WORD length;
        char name[1];
};

/* VNODE 

Represents an on-disk directory entry in memory 

*/

#define VNODE_DIRTY 1

struct VNode
{
        struct VNode* mountNode;
        DWORD flags,refs,size,mode;
        vid_t id;
        struct VfsSuperBlock* superBlock;
        struct VNodeOps* vNodeOps;
        struct FileOps* fileOps;
        struct ListHead next;
        DevId devId;
        WaitQueue waitQueue;
        int lock;
        void* extraInfo;
        struct Time aTime,cTime,mTime;

        /* Virtual memory */
        struct ListHead sharedList;
};

#define SetVNodeDirty(vNode) (((vNode)->flags) |= VNODE_DIRTY)

/* FILE

File object. Used when reading/writing to a file (VNode doesn't need those
things really)

*/

#define FILE_NONBLOCK   0x1

struct File
{
        struct VNode* vNode;
        int position; /* FIXME: Add position type soon. */
        int flags;
        struct FileOps* fileOps;
};

struct FileOps
{
        int (*open)(struct File* file);
        int (*close)(struct File* file);
        int (*read)(struct File* file,BYTE* buffer,DWORD size);
        int (*write)(struct File* file,BYTE* buffer,DWORD size);
        int (*seek)(struct File* file,int pos,int whence);
        int (*readDir)(struct File* file,void* dirEntries);
        int (*ioctl)(struct File* file,unsigned long code,char* data);
        int (*poll)(struct File* file, struct PollItem* item, struct PollQueue* pollQueue);
        int (*mMap)(struct VNode* vNode, DWORD address, DWORD offset);
};

int FillDir(void* dirEntry,char* name,int nameLen,DWORD vNodeNum); 

struct VNodeOps
{
        int (*create)(struct VNode** retVal,struct VNode* dir,char* name,int nameLength);
        int (*remove)(struct VNode* dir,char* name,int nameLen);
        int (*lookup)(struct VNode** retVal,struct VNode* dir,char* name,int nameLength);
        int (*mkDir)(struct VNode** retVal,struct VNode* dir,char* name,int nameLength);
        int (*rmDir)(struct VNode* dir,char* name,int nameLength);
        int (*permission)(struct VNode* vNode,int access);
        int (*blockMap)(struct VNode* vNode,int offset);
        int (*truncate)(struct VNode* vNode,int size);
};

struct SuperBlockOps
{
        /* General vNode functions */
        int (*allocVNode)(struct VNode* vNode);
        int (*freeVNode)(struct VNode* vNode);
        int (*readVNode)(struct VNode* vNode);
        int (*writeVNode)(struct VNode* vNode);

        /* General superblock functions */
        int (*writeSuper)(struct VfsSuperBlock* superBlock);
};

#define SB_DIRTY        0x1
#define SB_RDONLY       0x2

struct VfsSuperBlock
{
        struct SuperBlockOps* sbOps; /* A field so it is easier to set up a VfsSuperBlock */
        void* privData;
        DWORD coveredId; /* VNode id of the covered vnode by the mount */
        struct VfsSuperBlock* parent;
        struct StorageDevice* sDevice; /* Can be null */
        struct VNode* mount;
        int flags;
        struct ListHead vNodeList, sbList;
};

/* General defines for a superblock */

#define BYTES_PER_SECTOR(s)             ((s)->sDevice->softBlockSize)

struct Stat
{
        DWORD size,vNum,mode;
        unsigned long aTime,cTime,mTime;
}PACKED;

/* The StorageDevice parameter can be ignored if, for example, the filesystem is a network one */
typedef struct VfsSuperBlock* (*VfsReadSuperFunc)(struct StorageDevice* dev,int flags,char* data);

struct FileSystem
{
        char* name;
        VfsReadSuperFunc readSuper;
        struct ListHead list;
};

/* For filesystem drivers */
int VfsRegisterFileSystem(struct FileSystem* fs);
int VfsDeregisterFileSystem(struct FileSystem* fs);

/* Block cache functions and structures */

/* Buffer flags */

#define BUFFER_DIRTY    0x1
#define BUFFER_LOCKED   0x2

struct Buffer
{
        struct StorageDevice* device;
        struct ListHead list;
        DWORD blockNum;
        int flags,refs;
        BYTE* data;
        WaitQueue waitQueue;
};

/* buffer.c */

int BlockInit();
struct Buffer* BlockRead(struct StorageDevice* device,DWORD blockNum);
int BlockWrite(struct StorageDevice* device,struct Buffer* buffer);
int BlockSyncAll();
int BlockSyncDevice(struct StorageDevice* device);
int BlockFree(struct Buffer* buffer);
int BlockSetSize(struct StorageDevice* device,int blockSize);
void WaitForBuffer(struct Buffer* buffer);
void BufferUnlock(struct Buffer* buffer);
void BufferLock(struct Buffer* buffer);
struct Buffer* BlockBufferAlloc(struct StorageDevice* device,DWORD blockNum);
int BlockSendRequest(struct StorageDevice* device,struct Buffer* buff,int type);
int BlockSendRequestRaw(struct StorageDevice* device,struct Request* request);
struct Buffer* BlockFindBuffer(struct StorageDevice* sDevice,DWORD blockNum);

/* poll.c */
#define POLL_IN         1
#define POLL_OUT        2

struct PollQueue
{
        int i;
        int numFds;
        WaitQueue** waitQueues;
        struct WaitQueueEntry* waitEntries;
};

struct PollItem
{
        int fd;
        short events;
        short revents;
};

int PollAddWait(struct PollQueue* pollQueue, WaitQueue* waitQueue);

#endif