406 lines
10 KiB
C
406 lines
10 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_mount_t *mounts;
|
|
|
|
// 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 (fsType < 0 || fsType >= VFS_MAX_FS || !fses[fsType])
|
|
return -1; // invalid filesystem type
|
|
if (!strcmp("/", mountPoint))
|
|
{
|
|
if (mounts)
|
|
return -2; // root already mounted
|
|
void *super = fses[fsType]->mount_super(maj, min);
|
|
if (!super)
|
|
return -3; // didn't mount superblock
|
|
vfs_mount_t *mnt = New(vfs_mount_t);
|
|
mnt->refs = 0;
|
|
mnt->fs = fsType;
|
|
mnt->major = maj;
|
|
mnt->minor = min;
|
|
mnt->super = super;
|
|
mnt->next = NULL;
|
|
mnt->prev = NULL;
|
|
mnt->mountPoint = kmalloc(2);
|
|
strcpy(mnt->mountPoint, mountPoint);
|
|
mnt->vfs_mount_inode = 0; // root not mounted on another fs
|
|
mnt->vfs_root_inode = ((vfs_inode_t)maj << 40) | ((vfs_inode_t)min << 32) | fses[fsType]->get_root_inode(mnt);
|
|
mnt->vfs_up_inode = mnt->vfs_root_inode;
|
|
mounts = mnt;
|
|
return 0; // successfully mounted root
|
|
}
|
|
if (mountPoint[0] != '/')
|
|
return -3; // mount point must be absolute
|
|
if (!mounts)
|
|
return -4; // no root dir yet
|
|
vfs_stat_t stat;
|
|
if (vfs_stat(mountPoint, &stat))
|
|
return -5; // error statting
|
|
if (stat.type != VFS_FT_DIR)
|
|
return -6; // mountPoint not a directory
|
|
vfs_inode_t vfs_inode = vfs_get_inode_number(mountPoint);
|
|
vfs_inode_t updir = vfs_entry_lookup(vfs_inode, "..");
|
|
if (!updir || (updir & 0x8000000000000000ULL))
|
|
return -7;
|
|
void *super = fses[fsType]->mount_super(maj, min);
|
|
if (!super)
|
|
return -3; // didn't mount superblock
|
|
vfs_mount_t *mnt = New(vfs_mount_t);
|
|
mnt->refs = 0;
|
|
mnt->super = super;
|
|
mnt->fs = fsType;
|
|
mnt->major = maj;
|
|
mnt->minor = min;
|
|
mnt->mountPoint = kmalloc(strlen(mountPoint) + 1);
|
|
strcpy(mnt->mountPoint, mountPoint);
|
|
mnt->vfs_mount_inode = vfs_inode;
|
|
mnt->vfs_up_inode = updir;
|
|
mnt->vfs_root_inode = ((vfs_inode_t)maj << 40) | ((vfs_inode_t)min << 32) | fses[fsType]->get_root_inode(mnt);
|
|
vfs_mount_t *mount = mounts;
|
|
while (mount->next)
|
|
mount = mount->next;
|
|
mount->next = mnt; // add mnt to end of mounts list
|
|
mnt->prev = mount;
|
|
mnt->next = NULL;
|
|
vfs_get_file_addr(updir).mount->refs++;
|
|
return -256;
|
|
}
|
|
|
|
int vfs_umount(char *mountPoint)
|
|
{
|
|
vfs_inode_t vfs_inode = vfs_get_inode_number(mountPoint);
|
|
if (!vfs_inode || (vfs_inode & 0x8000000000000000ULL))
|
|
return -1; // invalid
|
|
vfs_mount_t *mnt = mounts;
|
|
while (mnt)
|
|
{
|
|
if (mnt->vfs_root_inode == vfs_inode) // found mount point to unmount
|
|
{
|
|
if (mnt->refs)
|
|
return -2; // open references to mount point;
|
|
if (mnt->prev)
|
|
mnt->prev->next = mnt->next;
|
|
if (mnt->next)
|
|
mnt->next->prev = mnt->prev;
|
|
if (mnt == mounts)
|
|
mounts = NULL;
|
|
kfree(mnt->mountPoint);
|
|
kfree(mnt);
|
|
return 0;
|
|
}
|
|
}
|
|
return -3; // invalid mount point
|
|
}
|
|
|
|
vfs_inode_t vfs_get_inode_number(char *path)
|
|
{
|
|
if (path[0] != '/')
|
|
return 0;
|
|
if (!mounts)
|
|
return 0;
|
|
return vfs_get_inode_number_rel(mounts->vfs_root_inode, path + 1);
|
|
}
|
|
|
|
vfs_inode_t vfs_get_inode_number_rel(vfs_inode_t dir_inode, char *path)
|
|
{
|
|
char *path_copy = kmalloc(strlen(path) + 1);
|
|
strcpy(path_copy, path);
|
|
int stanzas = str_split(path_copy, '/');
|
|
char *lookup = path_copy;
|
|
vfs_inode_t vfs_inode = dir_inode;
|
|
for (; stanzas > 0; stanzas--)
|
|
{
|
|
vfs_inode_t vfs_inode_this_dir = vfs_inode;
|
|
vfs_inode = (strcmp("", lookup) ? vfs_entry_lookup(vfs_inode, lookup) : vfs_inode_this_dir);
|
|
vfs_stat_t stat;
|
|
if (vfs_stat_inode(vfs_inode, &stat))
|
|
return 0x8000000000000002ULL;
|
|
if (stat.type == VFS_FT_SYMLINK)
|
|
{
|
|
char *link = kmalloc(4096);
|
|
vfs_link_deref(vfs_inode, link);
|
|
if (link[0] == '/')
|
|
vfs_inode = vfs_get_inode_number(link);
|
|
else
|
|
vfs_inode = vfs_get_inode_number_rel(vfs_inode_this_dir, link);
|
|
kfree(link);
|
|
}
|
|
if (!vfs_inode || (vfs_inode & 0x8000000000000000ULL))
|
|
{
|
|
kfree(path_copy);
|
|
return 0;
|
|
}
|
|
lookup = str_advance(lookup);
|
|
}
|
|
kfree(path_copy);
|
|
return vfs_inode;
|
|
}
|
|
|
|
// look for entry in dir_inode, return the vfs_inode for the entry
|
|
vfs_inode_t vfs_entry_lookup(vfs_inode_t dir_inode, char *entry)
|
|
{
|
|
vfs_open_file_t *open_dir = vfs_open_dir_inode(dir_inode);
|
|
if (!open_dir)
|
|
return 0x8000000000000001ULL;
|
|
vfs_dir_entry_t dentry;
|
|
while (!vfs_read_dir(open_dir, &dentry))
|
|
{
|
|
if (!strcmp(dentry.name, entry))
|
|
{
|
|
vfs_close_dir(open_dir);
|
|
return vfs_real_inode((dir_inode & 0xFFFFFFFF00000000ULL) | dentry.inode_number);
|
|
}
|
|
}
|
|
vfs_close_dir(open_dir);
|
|
return 0x8000000000000002ULL;
|
|
}
|
|
|
|
// return the "real" vfs inode number (inode of the root of
|
|
// a mounted filesystem instead of the inode of the folder
|
|
// that the filesystem is mounted to)
|
|
vfs_inode_t vfs_real_inode(vfs_inode_t vfs_inode)
|
|
{
|
|
vfs_mount_t *mnt = mounts;
|
|
while (mnt)
|
|
{
|
|
if (mnt->vfs_mount_inode == vfs_inode)
|
|
return mnt->vfs_root_inode;
|
|
mnt = mnt->next;
|
|
}
|
|
return vfs_inode;
|
|
}
|
|
|
|
// translage a vfs inode number into a mount pointer and relative
|
|
// inode for a mounted filesystem
|
|
vfs_file_addr_t vfs_get_file_addr(vfs_inode_t vfs_inode)
|
|
{
|
|
vfs_inode = vfs_real_inode(vfs_inode);
|
|
vfs_file_addr_t addr = {mounts, vfs_inode & 0xFFFFFFFF};
|
|
vfs_mount_t *mnt = mounts;
|
|
while (mnt)
|
|
{
|
|
if ( (mnt->vfs_root_inode & 0xFFFFFFFF00000000ULL) == (vfs_inode & 0xFFFFFFFF00000000ULL) )
|
|
{
|
|
addr.mount = mnt;
|
|
return addr;
|
|
}
|
|
mnt = mnt->next;
|
|
}
|
|
return addr;
|
|
}
|
|
|
|
int vfs_mount_count()
|
|
{
|
|
vfs_mount_t *mnt = mounts;
|
|
int count = 0;
|
|
while (mnt)
|
|
{
|
|
count++;
|
|
mnt = mnt->next;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
vfs_mount_t *vfs_get_mount(int index)
|
|
{
|
|
vfs_mount_t *mnt = mounts;
|
|
while (mnt && index)
|
|
{
|
|
mnt = mnt->next;
|
|
index--;
|
|
}
|
|
if (!index)
|
|
return mnt;
|
|
return NULL;
|
|
}
|
|
|
|
int vfs_free_inodes(vfs_mount_t *mount)
|
|
{
|
|
if (fses[mount->fs]->free_inodes)
|
|
return fses[mount->fs]->free_inodes(mount);
|
|
return -1;
|
|
}
|
|
|
|
int vfs_total_inodes(vfs_mount_t *mount)
|
|
{
|
|
if (fses[mount->fs]->total_inodes)
|
|
return fses[mount->fs]->total_inodes(mount);
|
|
return -1;
|
|
}
|
|
|
|
int vfs_free_blocks(vfs_mount_t *mount)
|
|
{
|
|
if (fses[mount->fs]->free_blocks)
|
|
return fses[mount->fs]->free_blocks(mount);
|
|
return -1;
|
|
}
|
|
|
|
int vfs_total_blocks(vfs_mount_t *mount)
|
|
{
|
|
if (fses[mount->fs]->total_blocks)
|
|
return fses[mount->fs]->total_blocks(mount);
|
|
return -1;
|
|
}
|
|
|
|
vfs_inode_t vfs_alloc_inode(vfs_mount_t *mount)
|
|
{
|
|
if (fses[mount->fs]->alloc_inode)
|
|
{
|
|
u32_t fs_inode = fses[mount->fs]->alloc_inode(mount);
|
|
if (!fs_inode)
|
|
return 0;
|
|
return (mount->vfs_root_inode & 0xFFFFFFFF00000000ULL) | fs_inode;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int vfs_alloc_block(vfs_mount_t *mount)
|
|
{
|
|
if (fses[mount->fs]->alloc_block)
|
|
return fses[mount->fs]->alloc_block(mount);
|
|
return 0;
|
|
}
|
|
|
|
int vfs_link_deref(vfs_inode_t vfs_inode, char *link)
|
|
{
|
|
vfs_stat_t stat;
|
|
if (vfs_stat_inode(vfs_inode, &stat))
|
|
return -1;
|
|
if (stat.type != VFS_FT_SYMLINK)
|
|
return -2;
|
|
vfs_file_addr_t addr = vfs_get_file_addr(vfs_inode);
|
|
if (fses[addr.mount->fs]->link_deref)
|
|
return fses[addr.mount->fs]->link_deref(addr.mount, addr.inode, link);
|
|
return -3;
|
|
}
|
|
|
|
// 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_inode_t vfs_inode = vfs_get_inode_number(file);
|
|
if (!vfs_inode || (vfs_inode & 0x8000000000000000ULL))
|
|
return -256;
|
|
return vfs_stat_inode(vfs_inode, stat);
|
|
}
|
|
|
|
int vfs_stat_inode(vfs_inode_t vfs_inode, vfs_stat_t *stat)
|
|
{
|
|
vfs_file_addr_t addr = vfs_get_file_addr(vfs_inode);
|
|
if (fses[addr.mount->fs]->stat)
|
|
return fses[addr.mount->fs]->stat(addr.mount, addr.inode, stat);
|
|
return -257;
|
|
}
|
|
|
|
vfs_open_file_t *vfs_open_dir(char *path)
|
|
{
|
|
vfs_inode_t vfs_inode = vfs_get_inode_number(path);
|
|
if (!vfs_inode || (vfs_inode & 0x8000000000000000ULL))
|
|
return NULL;
|
|
return vfs_open_dir_inode(vfs_inode);
|
|
}
|
|
|
|
vfs_open_file_t *vfs_open_dir_inode(vfs_inode_t vfs_inode)
|
|
{
|
|
vfs_file_addr_t addr = vfs_get_file_addr(vfs_inode);
|
|
vfs_open_file_t *open_dir = New(vfs_open_file_t);
|
|
if (fses[addr.mount->fs]->open_dir && !(fses[addr.mount->fs]->open_dir(addr.mount, addr.inode, open_dir)))
|
|
{
|
|
open_dir->mount = addr.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 *path)
|
|
{
|
|
vfs_inode_t vfs_inode = vfs_get_inode_number(path);
|
|
if (!vfs_inode || (vfs_inode & 0x8000000000000000ULL))
|
|
return NULL;
|
|
return vfs_open_block_file_inode(vfs_inode);
|
|
}
|
|
|
|
vfs_open_file_t *vfs_open_block_file_inode(vfs_inode_t vfs_inode)
|
|
{
|
|
vfs_file_addr_t addr = vfs_get_file_addr(vfs_inode);
|
|
vfs_open_file_t *open_file = New(vfs_open_file_t);
|
|
if (fses[addr.mount->fs]->open_block_file && !(fses[addr.mount->fs]->open_block_file(addr.mount, addr.inode, open_file)))
|
|
{
|
|
open_file->mount = addr.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;
|
|
}
|
|
|