355 lines
8.4 KiB
C
355 lines
8.4 KiB
C
// vfs.c
|
|
// Author: Josh Holtrop
|
|
// Date: 08/22/04
|
|
// Modified: 12/21/04
|
|
|
|
#include "hos_defines.h"
|
|
#include "kout.h"
|
|
#include "fs/vfs.h"
|
|
#include "fs/ext2.h"
|
|
#include "kernel.h"
|
|
#include "mm/vmm.h"
|
|
#include "lang/lang.h"
|
|
|
|
vfs_fs_t *fses[VFS_MAX_FS]; // a vfs_fs structure for every filesystem we support
|
|
vfs_node_t *vfsMountTree; // points to the root node ('/') of the VFS Mount Tree
|
|
|
|
// basic initialization routine, init all filesystem drivers
|
|
int vfs_init()
|
|
{
|
|
k_check(ext2_init(FS_EXT2), "ext2_init() failed!");
|
|
return 0;
|
|
}
|
|
|
|
// called by a filesystem driver to let us know that it is ready to handle fs requests
|
|
int vfs_register_fs(int fsn, vfs_fs_t *fs)
|
|
{
|
|
if (fsn < 0 || fsn >= VFS_MAX_FS || fses[fsn])
|
|
{
|
|
kprintf("Invalid filesystem register: %d\n", fsn);
|
|
return -1;
|
|
}
|
|
fses[fsn] = fs;
|
|
return 0;
|
|
}
|
|
|
|
// called to mount a block device with a certain filesystem to a part of our VFS Mount Tree
|
|
int vfs_mount(major_t maj, minor_t min, int fsType, char *mountPoint)
|
|
{
|
|
if (mountPoint[0] != '/')
|
|
return -1; // mount point must be absolute
|
|
int l = strlen(mountPoint);
|
|
if (l < 1)
|
|
return -7; // mount point must be non-null string
|
|
if (mountPoint[l-1] != '/')
|
|
return -8; // mount point must end with a '/' character
|
|
if (fsType < 0 || fsType >= VFS_MAX_FS || !fses[fsType])
|
|
return -2; // invalid filesystem type
|
|
if (vfs_find_mount(mountPoint))
|
|
return -5; // mount point already mounted
|
|
void *super = fses[fsType]->mount_super(maj, min);
|
|
if (!super)
|
|
return -6; // filesystem superblock not correctly identified
|
|
vfs_mount_t *mnt = New(vfs_mount_t);
|
|
if (!mnt)
|
|
return -3; // could not allocate memory
|
|
mnt->refs = 0;
|
|
mnt->fs = fsType;
|
|
mnt->major = maj;
|
|
mnt->minor = min;
|
|
mnt->super = super;
|
|
if (vfs_add_mount(mnt, mountPoint))
|
|
{
|
|
kfree(mnt);
|
|
return -4; // could not add mount
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// invoked by vfs_mount to do the "dirty work" of adding the nodes to the tree
|
|
int vfs_add_mount(vfs_mount_t *mnt, char *mountPoint)
|
|
{
|
|
vfs_node_t *node = vfsMountTree;
|
|
char *mp = mountPoint;
|
|
if (!vfsMountTree)
|
|
{
|
|
vfsMountTree = New(vfs_node_t);
|
|
node = vfsMountTree;
|
|
node->chr = *mp;
|
|
node->up = NULL;
|
|
node->next = NULL;
|
|
node->down = NULL;
|
|
node->mount = NULL;
|
|
}
|
|
for (;;)
|
|
{
|
|
if (node->chr == *mp) // got a match
|
|
{
|
|
mp++;
|
|
if (*mp == 0)
|
|
{
|
|
if (node->mount)
|
|
return -1; // mount point already taken
|
|
node->mount = mnt;
|
|
return 0;
|
|
}
|
|
if (node->down)
|
|
node = node->down;
|
|
else
|
|
{
|
|
node->down = New(vfs_node_t);
|
|
node->down->up = node;
|
|
node = node->down;
|
|
node->next = NULL;
|
|
node->down = NULL;
|
|
node->mount = NULL;
|
|
node->chr = *mp;
|
|
}
|
|
}
|
|
else if (node->next)
|
|
{
|
|
node = node->next;
|
|
}
|
|
else // add a node for this character
|
|
{
|
|
node->next = New(vfs_node_t);
|
|
node->next->up = node->up;
|
|
node = node->next;
|
|
node->next = NULL;
|
|
node->down = NULL;
|
|
node->mount = NULL;
|
|
node->chr = *mp;
|
|
}
|
|
}
|
|
}
|
|
|
|
// lookup a path and return the match structure for the deepest path matched
|
|
vfs_mount_match_t vfs_get_rel_path(char *path)
|
|
{
|
|
vfs_mount_match_t matched = {NULL, 0};
|
|
char *pp = path;
|
|
int length = 0;
|
|
vfs_node_t *node = vfsMountTree;
|
|
while (*pp)
|
|
{
|
|
if (!node)
|
|
break;
|
|
if (node->chr == *pp) // got a character match
|
|
{
|
|
length++;
|
|
if (node->mount) // and there is something mounted here
|
|
{
|
|
matched.mount = node->mount;
|
|
matched.length = length;
|
|
}
|
|
pp++;
|
|
node = node->down;
|
|
}
|
|
else
|
|
node = node->next;
|
|
}
|
|
return matched;
|
|
}
|
|
|
|
// is mountPoint a valid mount point?
|
|
// returns a pointer to the mount structure if so
|
|
vfs_mount_t *vfs_find_mount(char *mountPoint)
|
|
{
|
|
char *mp = mountPoint;
|
|
vfs_node_t *node = vfsMountTree;
|
|
while (node)
|
|
{
|
|
if (node->chr == *mp)
|
|
{
|
|
mp++;
|
|
if (*mp == 0) // we matched the whole mount point string
|
|
return node->mount;
|
|
node = node->down;
|
|
}
|
|
else
|
|
node = node->next;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
// unmount the mountPoint, remove nodes from tree that aren't used anymore
|
|
int vfs_umount(char *mountPoint)
|
|
{
|
|
char *mp = mountPoint;
|
|
vfs_node_t *node = vfsMountTree;
|
|
while (node)
|
|
{
|
|
if (node->chr == *mp)
|
|
{
|
|
mp++;
|
|
if (*mp == 0) // we matched the whole mount point string
|
|
{
|
|
// is there something mounted underneath this directory?
|
|
if (node->down)
|
|
return -3; // yes, don't umount
|
|
if (!node->mount)
|
|
return -4; // no mount here
|
|
if (node->mount->refs)
|
|
return -5; // still refs open to mount
|
|
fses[node->mount->fs]->umount_super(node->mount);
|
|
kfree(node->mount);
|
|
node->mount = NULL;
|
|
return vfs_retire_node(node);
|
|
}
|
|
node = node->down;
|
|
}
|
|
else
|
|
node = node->next;
|
|
}
|
|
return -2; // mount point does not exist
|
|
}
|
|
|
|
// remove this node from the tree if it is not needed anymore
|
|
int vfs_retire_node(vfs_node_t *node)
|
|
{
|
|
if (node->down)
|
|
return 0; // node is part of another mount point, don't remove
|
|
if (node->mount)
|
|
return 0; // something is still mounted here
|
|
if (!node->up)
|
|
{
|
|
kfree(node);
|
|
vfsMountTree = NULL;
|
|
return 0; // we unmounted the root directory
|
|
}
|
|
// 3 cases left: node is first child (or only child), middle child, or last child
|
|
if (node->up->down == node) // first child
|
|
{
|
|
node->up->down = node->next; // re-point parent to next child
|
|
int r = vfs_retire_node(node->up); // retire parent if we were an only-child
|
|
kfree(node);
|
|
return r;
|
|
}
|
|
vfs_node_t *onode = node->up->down; // onode points to first child
|
|
while (onode)
|
|
{
|
|
if (onode->next == node) // onode is child before node
|
|
{
|
|
onode->next = node->next;
|
|
kfree(node);
|
|
return 0;
|
|
}
|
|
onode = onode->next;
|
|
}
|
|
return -1; // node wasn't found following onode
|
|
}
|
|
|
|
|
|
// stat a file, fills a vfs_stat_t structure with stat information and returns standard status
|
|
int vfs_stat(char *file, vfs_stat_t *stat)
|
|
{
|
|
vfs_mount_match_t match = vfs_get_rel_path(file);
|
|
if (match.mount == NULL)
|
|
return -256;
|
|
if (fses[match.mount->fs]->stat)
|
|
return fses[match.mount->fs]->stat(match.mount, file + match.length - 1, stat);
|
|
return -257;
|
|
}
|
|
|
|
|
|
vfs_open_file_t *vfs_open_dir(char *file)
|
|
{
|
|
vfs_mount_match_t match = vfs_get_rel_path(file);
|
|
if (match.mount == NULL)
|
|
return NULL;
|
|
vfs_open_file_t *open_dir = New(vfs_open_file_t);
|
|
if (fses[match.mount->fs]->open_dir && !(fses[match.mount->fs]->open_dir(match.mount, file + match.length - 1, open_dir)))
|
|
{
|
|
open_dir->mount = match.mount;
|
|
return open_dir;
|
|
}
|
|
kfree(open_dir);
|
|
return NULL;
|
|
}
|
|
|
|
int vfs_read_dir(vfs_open_file_t *open_dir, vfs_dir_entry_t *dentry)
|
|
{
|
|
return !(fses[open_dir->mount->fs]->read_dir &&
|
|
!(fses[open_dir->mount->fs]->read_dir(open_dir->mount, open_dir, dentry)));
|
|
}
|
|
|
|
int vfs_close_dir(vfs_open_file_t *open_dir)
|
|
{
|
|
int status = 0;
|
|
if (fses[open_dir->mount->fs]->close_dir)
|
|
status = fses[open_dir->mount->fs]->close_dir(open_dir->mount, open_dir);
|
|
kfree(open_dir);
|
|
return status;
|
|
}
|
|
|
|
|
|
vfs_open_file_t *vfs_open_block_file(char *file)
|
|
{
|
|
vfs_mount_match_t match = vfs_get_rel_path(file);
|
|
if (match.mount == NULL)
|
|
return NULL;
|
|
vfs_open_file_t *open_file = New(vfs_open_file_t);
|
|
if (fses[match.mount->fs]->open_block_file && !(fses[match.mount->fs]->open_block_file(match.mount, file + match.length - 1, open_file)))
|
|
{
|
|
open_file->mount = match.mount;
|
|
return open_file;
|
|
}
|
|
kfree(open_file);
|
|
return NULL;
|
|
}
|
|
|
|
int vfs_read_block_file(vfs_open_file_t *open_file, void *buffer)
|
|
{
|
|
if (fses[open_file->mount->fs]->read_block_file)
|
|
return fses[open_file->mount->fs]->read_block_file(open_file->mount, open_file, buffer);
|
|
return 0;
|
|
}
|
|
|
|
int vfs_block_file_seek(vfs_open_file_t *open_file, u32_t block_number)
|
|
{
|
|
if (fses[open_file->mount->fs]->block_file_seek)
|
|
return fses[open_file->mount->fs]->block_file_seek(open_file->mount, open_file, block_number);
|
|
return -1;
|
|
}
|
|
|
|
int vfs_close_block_file(vfs_open_file_t *open_file)
|
|
{
|
|
int status = 0;
|
|
if (fses[open_file->mount->fs]->close_block_file)
|
|
status = fses[open_file->mount->fs]->close_block_file(open_file->mount, open_file);
|
|
kfree(open_file);
|
|
return status;
|
|
}
|
|
|
|
|
|
// DEBUG routines to draw the VFS Mount Tree
|
|
/******************************************/
|
|
void vfs_dump_tree()
|
|
{
|
|
if (!vfsMountTree)
|
|
kprintf("vfsMountTree == NULL!\n");
|
|
else
|
|
vfs_dump_node(vfsMountTree, 0);
|
|
}
|
|
|
|
void vfs_dump_node(vfs_node_t *node, int level)
|
|
{
|
|
int i;
|
|
for (i = 0; i < level; i++)
|
|
{
|
|
putc(' ');
|
|
}
|
|
kprintf("%c (0x%x) mount: 0x%x, up: 0x%x, next:0x%x, down:0x%x\n", node->chr, node, node->mount, node->up, node->next, node->down);
|
|
node = node->down;
|
|
if (!node)
|
|
return;
|
|
while (node)
|
|
{
|
|
vfs_dump_node(node, level + 1);
|
|
node = node->next;
|
|
}
|
|
}
|
|
/******************************************/
|
|
|