Created student weenix repository

1 files changed, 222 insertions, 0 deletions

diff --git a/kernel/fs/vfs.c b/kernel/fs/vfs.c
new file mode 100644
index 0000000..3f5ed15
--- /dev/null
+++ b/kernel/fs/vfs.c
@@ -0,0 +1,222 @@
+#include "errno.h"
+#include "globals.h"
+#include "kernel.h"
+#include "util/string.h"
+#include <fs/s5fs/s5fs.h>
+#include <fs/vnode.h>
+
+#include "fs/file.h"
+#include "fs/ramfs/ramfs.h"
+
+#include "mm/kmalloc.h"
+#include "mm/slab.h"
+#include "util/debug.h"
+
+#ifdef __S5FS__
+#include "fs/s5fs/s5fs.h"
+#endif
+
+#ifdef __MOUNTING__
+/* The fs listed here are only the non-root file systems */
+list_t mounted_fs_list;
+
+/*
+ * Implementing this function is not required and strongly discouraged unless
+ * you are absolutley sure your Weenix is perfect.
+ *
+ * The purpose of this function is to set up the pointers between the file
+ * system struct and the vnode of the mount point. Remember to watch your
+ * reference counts. (The exception here is when the vnode's vn_mount field
+ * points to the mounted file system's root we do not increment the reference
+ * count on the file system's root vnode. The file system is already keeping
+ * a reference to the vnode which will not go away until the file system is
+ * unmounted. If we kept a second such reference it would conflict with the
+ * behavior of vfs_is_in_use(), make sure you understand why.)
+ *
+ * Once everything is set up add the file system to the list of mounted file
+ * systems.
+ *
+ * Remember proper error handling.
+ *
+ * This function is not meant to mount the root file system.
+ */
+int vfs_mount(struct vnode *mtpt, fs_t *fs)
+{
+    NOT_YET_IMPLEMENTED("MOUNTING: ***none***");
+    return -EINVAL;
+}
+
+/*
+ * Implementing this function is not required and strongly discouraged unless
+ * you are absolutley sure your Weenix is perfect.
+ *
+ * The purpose of this function is to undo the setup done in vfs_mount(). Also
+ * you should call the underlying file system's umount() function. Make sure
+ * to keep track of reference counts. You should also kfree the fs struct at
+ * the end of this method.
+ *
+ * Remember proper error handling. You might want to make sure that you do not
+ * try to call this function on the root file system (this function is not meant
+ * to unmount the root file system).
+ */
+int vfs_umount(fs_t *fs)
+{
+    NOT_YET_IMPLEMENTED("MOUNTING: ***none***");
+    return -EINVAL;
+}
+#endif /* __MOUNTING__ */
+
+fs_t vfs_root_fs = {
+    .fs_dev = VFS_ROOTFS_DEV,
+    .fs_type = VFS_ROOTFS_TYPE,
+    .vnode_list = LIST_INITIALIZER(vfs_root_fs.vnode_list),
+    .vnode_list_mutex = KMUTEX_INITIALIZER(vfs_root_fs.vnode_list_mutex),
+    .fs_vnode_allocator = NULL,
+    .fs_i = NULL,
+    .fs_ops = NULL,
+    .fs_root = NULL,
+};
+
+/*
+ * Call mountfunc on vfs_root_fs and set curproc->p_cwd (reference count!)
+ */
+void vfs_init()
+{
+    long err = mountfunc(&vfs_root_fs);
+    if (err)
+    {
+        panic(
+            "Failed to mount root fs of type \"%s\" on device "
+            "\"%s\" with errno of %ld\n",
+            vfs_root_fs.fs_type, vfs_root_fs.fs_dev, -err);
+    }
+
+    vlock(vfs_root_fs.fs_root);
+    vref(curproc->p_cwd = vfs_root_fs.fs_root);
+    vunlock(vfs_root_fs.fs_root);
+
+#ifdef __MOUNTING__
+    list_init(&mounted_fs_list);
+    fs->fs_mtpt = vfs_root_fs.fs_root;
+#endif
+}
+
+/*
+ * Wrapper around the sync call() to vfs_root_fs using fs_ops
+ */
+void do_sync()
+{
+    vfs_root_fs.fs_ops->sync(&vfs_root_fs);
+#ifdef __MOUNTING__
+    // if implementing mounting, just sync() all the mounted FS's as well
+#endif
+}
+
+/*
+ *
+ */
+long vfs_shutdown()
+{
+    dbg(DBG_VFS, "shutting down vfs\n");
+    long ret = 0;
+
+#ifdef __MOUNTING__
+    list_iterate(&mounted_fs_list, mtfs, fs_t, fs_link)
+    {
+        ret = vfs_umount(mtfs);
+        KASSERT(!ret);
+    }
+#endif
+
+    if (vfs_is_in_use(&vfs_root_fs))
+    {
+        panic("vfs_shutdown: found active vnodes in root filesystem");
+    }
+
+    if (vfs_root_fs.fs_ops->umount)
+    {
+        ret = vfs_root_fs.fs_ops->umount(&vfs_root_fs);
+    }
+    else
+    {
+        // vlock(vfs_root_fs.fs_root);
+        vput(&vfs_root_fs.fs_root);
+    }
+
+    if (vfs_count_active_vnodes(&vfs_root_fs))
+    {
+        panic(
+            "vfs_shutdown: vnodes still in use after unmounting root "
+            "filesystem");
+    }
+    return ret;
+}
+
+long mountfunc(fs_t *fs)
+{
+    static const struct
+    {
+        char *fstype;
+
+        long (*mountfunc)(fs_t *);
+    } types[] = {
+#ifdef __S5FS__
+        {"s5fs", s5fs_mount},
+#endif
+        {"ramfs", ramfs_mount},
+    };
+
+    for (unsigned int i = 0; i < sizeof(types) / sizeof(types[0]); i++)
+    {
+        if (strcmp(fs->fs_type, types[i].fstype) == 0)
+        {
+            return types[i].mountfunc(fs);
+        }
+    }
+
+    return -EINVAL;
+}
+
+/*
+ * A filesystem is in use if the total number of vnode refcounts for that
+ * filesystem > 1. The singular refcount in a fs NOT in use comes from fs_root.
+ *
+ * Error cases vfs_is_in_use is responsible for generating:
+ *  - EBUSY: if the filesystem is in use
+ */
+long vfs_is_in_use(fs_t *fs)
+{
+    long ret = 0;
+    // kmutex_lock(&fs->vnode_list_mutex);
+    list_iterate(&fs->vnode_list, vn, vnode_t, vn_link)
+    {
+        vlock(vn);
+        size_t expected_refcount = vn->vn_fs->fs_root == vn ? 1 : 0;
+        size_t refcount = vn->vn_mobj.mo_refcount;
+        vunlock(vn);
+        if (refcount != expected_refcount)
+        {
+            dbg(DBG_VFS,
+                "vnode %d still in use with %d references and %lu mobj "
+                "references (expected %lu)\n",
+                vn->vn_vno, vn->vn_mobj.mo_refcount, refcount,
+                expected_refcount);
+            ret = -EBUSY;
+            // break;
+        }
+    }
+    // kmutex_unlock(&fs->vnode_list_mutex);
+    return ret;
+}
+
+/*
+ * Return the size of fs->vnode_list
+ */
+size_t vfs_count_active_vnodes(fs_t *fs)
+{
+    size_t count = 0;
+    kmutex_lock(&fs->vnode_list_mutex);
+    list_iterate(&fs->vnode_list, vn, vnode_t, vn_link) { count++; }
+    kmutex_unlock(&fs->vnode_list_mutex);
+    return count;
+}