fix: memory leakage in file descriptor allocation

[lunaix-os.git] / lunaix-os / kernel / fs / mount.c

diff --git a/lunaix-os/kernel/fs/mount.c b/lunaix-os/kernel/fs/mount.c
index aa4acef20254d94cda3b2646d5392ec7c5078be6..ca8023805fc19435d1b6c61294721e007abf3356 100644 (file)
--- a/lunaix-os/kernel/fs/mount.c
+++ b/lunaix-os/kernel/fs/mount.c
@@ -1,9 +1,11 @@
+#include <lunaix/foptions.h>

 #include <lunaix/fs.h>
 #include <lunaix/mm/valloc.h>
 #include <lunaix/process.h>
 #include <lunaix/fs.h>
 #include <lunaix/mm/valloc.h>
 #include <lunaix/process.h>

+#include <lunaix/spike.h>

 #include <lunaix/types.h>
 
 #include <lunaix/types.h>
 

-static struct llist_header all_mnts = { .next = &all_mnts, .prev = &all_mnts };
+struct llist_header all_mnts = { .next = &all_mnts, .prev = &all_mnts };

 
 struct v_mount*
 vfs_create_mount(struct v_mount* parent, struct v_dnode* mnt_point)
 
 struct v_mount*
 vfs_create_mount(struct v_mount* parent, struct v_dnode* mnt_point)


@@ -17,12 +19,12 @@ vfs_create_mount(struct v_mount* parent, struct v_dnode* mnt_point)
     llist_append(&all_mnts, &mnt->list);
     mutex_init(&mnt->lock);
 
     llist_append(&all_mnts, &mnt->list);
     mutex_init(&mnt->lock);
 

-    mnt_mkbusy(parent);

     mnt->parent = parent;
     mnt->mnt_point = mnt_point;
     mnt->super_block = mnt_point->super_block;
 
     if (parent) {
     mnt->parent = parent;
     mnt->mnt_point = mnt_point;
     mnt->super_block = mnt_point->super_block;
 
     if (parent) {

+        mnt_mkbusy(parent);

         mutex_lock(&mnt->parent->lock);
         llist_append(&parent->submnts, &mnt->sibmnts);
         mutex_unlock(&mnt->parent->lock);
         mutex_lock(&mnt->parent->lock);
         llist_append(&parent->submnts, &mnt->sibmnts);
         mutex_unlock(&mnt->parent->lock);


@@ -67,46 +69,42 @@ __vfs_do_unmount(struct v_mount* mnt)
 void
 mnt_mkbusy(struct v_mount* mnt)
 {
 void
 mnt_mkbusy(struct v_mount* mnt)
 {

-    while (mnt) {
-        mutex_lock(&mnt->lock);
-        mnt->busy_counter++;
-        mutex_unlock(&mnt->lock);
-
-        mnt = mnt->parent;
-    }
+    mutex_lock(&mnt->lock);
+    mnt->busy_counter++;
+    mutex_unlock(&mnt->lock);

 }
 
 void
 mnt_chillax(struct v_mount* mnt)
 {
 }
 
 void
 mnt_chillax(struct v_mount* mnt)
 {

-    while (mnt) {
-        mutex_lock(&mnt->lock);
-        mnt->busy_counter--;
-        mutex_unlock(&mnt->lock);
-
-        mnt = mnt->parent;
-    }
+    mutex_lock(&mnt->lock);
+    mnt->busy_counter--;
+    mutex_unlock(&mnt->lock);

 }
 
 int
 vfs_mount_root(const char* fs_name, struct device* device)
 {
 }
 
 int
 vfs_mount_root(const char* fs_name, struct device* device)
 {

+    extern struct v_dnode* vfs_sysroot;

     int errno = 0;
     if (vfs_sysroot->mnt && (errno = vfs_unmount_at(vfs_sysroot))) {
         return errno;
     }
     int errno = 0;
     if (vfs_sysroot->mnt && (errno = vfs_unmount_at(vfs_sysroot))) {
         return errno;
     }

-    return vfs_mount_at(fs_name, device, vfs_sysroot);
+    return vfs_mount_at(fs_name, device, vfs_sysroot, 0);

 }
 
 int
 }
 
 int

-vfs_mount(const char* target, const char* fs_name, struct device* device)
+vfs_mount(const char* target,
+          const char* fs_name,
+          struct device* device,
+          int options)

 {
     int errno;
     struct v_dnode* mnt;
 
     if (!(errno =
             vfs_walk(__current->cwd, target, &mnt, NULL, VFS_WALK_MKPARENT))) {
 {
     int errno;
     struct v_dnode* mnt;
 
     if (!(errno =
             vfs_walk(__current->cwd, target, &mnt, NULL, VFS_WALK_MKPARENT))) {

-        errno = vfs_mount_at(fs_name, device, mnt);
+        errno = vfs_mount_at(fs_name, device, mnt, options);

     }
 
     return errno;
     }
 
     return errno;


@@ -128,7 +126,8 @@ vfs_unmount(const char* target)
 int
 vfs_mount_at(const char* fs_name,
              struct device* device,
 int
 vfs_mount_at(const char* fs_name,
              struct device* device,

-             struct v_dnode* mnt_point)
+             struct v_dnode* mnt_point,
+             int options)

 {
     if (mnt_point->inode && !(mnt_point->inode->itype & VFS_IFDIR)) {
         return ENOTDIR;
 {
     if (mnt_point->inode && !(mnt_point->inode->itype & VFS_IFDIR)) {
         return ENOTDIR;


@@ -140,12 +139,12 @@ vfs_mount_at(const char* fs_name,
     }
 
     struct v_mount* parent_mnt = mnt_point->mnt;
     }
 
     struct v_mount* parent_mnt = mnt_point->mnt;

-    struct v_superblock* sb = vfs_sb_alloc();
+    struct v_superblock *sb = vfs_sb_alloc(), *old_sb = mnt_point->super_block;

     sb->dev = device;
     sb->dev = device;

+    mnt_point->super_block = sb;

 
     int errno = 0;
     if (!(errno = fs->mount(sb, mnt_point))) {
 
     int errno = 0;
     if (!(errno = fs->mount(sb, mnt_point))) {

-        mnt_point->super_block = sb;

         sb->fs = fs;
         sb->root = mnt_point;
 
         sb->fs = fs;
         sb->root = mnt_point;
 


@@ -153,6 +152,8 @@ vfs_mount_at(const char* fs_name,
             errno = ENOMEM;
             goto cleanup;
         }
             errno = ENOMEM;
             goto cleanup;
         }

+
+        mnt_point->mnt->flags = options;

     } else {
         goto cleanup;
     }
     } else {
         goto cleanup;
     }


@@ -160,6 +161,7 @@ vfs_mount_at(const char* fs_name,
     return errno;
 
 cleanup:
     return errno;
 
 cleanup:

+    mnt_point->super_block = old_sb;

     vfs_sb_free(sb);
     return errno;
 }
     vfs_sb_free(sb);
     return errno;
 }


@@ -188,14 +190,25 @@ vfs_unmount_at(struct v_dnode* mnt_point)
     return errno;
 }
 
     return errno;
 }
 

-__DEFINE_LXSYSCALL3(int,
+int
+vfs_check_writable(struct v_dnode* dnode)
+{
+    if ((dnode->mnt->flags & MNT_RO)) {
+        return EROFS;
+    }
+    return 0;
+}
+
+__DEFINE_LXSYSCALL4(int,

                     mount,
                     const char*,
                     source,
                     const char*,
                     target,
                     const char*,
                     mount,
                     const char*,
                     source,
                     const char*,
                     target,
                     const char*,

-                    fstype)
+                    fstype,
+                    int,
+                    options)

 {
     struct v_dnode *dev, *mnt;
     int errno = 0;
 {
     struct v_dnode *dev, *mnt;
     int errno = 0;


@@ -215,14 +228,14 @@ __DEFINE_LXSYSCALL3(int,
 
     // By our convention.
     // XXX could we do better?
 
     // By our convention.
     // XXX could we do better?

-    struct device* device = (struct device*)dev->data;
+    struct device* device = (struct device*)dev->inode->data;

 
     if (!(dev->inode->itype & VFS_IFVOLDEV) || !device) {
         errno = ENOTDEV;
         goto done;
     }
 
 
     if (!(dev->inode->itype & VFS_IFVOLDEV) || !device) {
         errno = ENOTDEV;
         goto done;
     }
 

-    errno = vfs_mount_at(fstype, device, mnt);
+    errno = vfs_mount_at(fstype, device, mnt, options);

 
 done:
     return DO_STATUS(errno);
 
 done:
     return DO_STATUS(errno);