Multiuser, Capabilities and Access Controls (#54)

[lunaix-os.git] / lunaix-os / kernel / device / devfs.c

diff --git a/lunaix-os/kernel/device/devfs.c b/lunaix-os/kernel/device/devfs.c
index 69de7fa62cb2fa29b56bf7eaaead3b483252975d..969c8288b2f0b58b91d8c6183e16dc017f770284 100644 (file)
--- a/lunaix-os/kernel/device/devfs.c
+++ b/lunaix-os/kernel/device/devfs.c
@@ -1,9 +1,9 @@
 #include <lunaix/device.h>
 #include <lunaix/device.h>

-#include <lunaix/fs.h>
+#include <lunaix/fs/api.h>

 #include <lunaix/fs/devfs.h>
 #include <lunaix/spike.h>
 
 #include <lunaix/fs/devfs.h>
 #include <lunaix/spike.h>
 

-#include <usr/sys/dirent_defs.h>
+#include <usr/lunaix/dirent_defs.h>

 
 extern struct v_inode_ops devfs_inode_ops;
 extern struct v_file_ops devfs_file_ops;
 
 extern struct v_inode_ops devfs_inode_ops;
 extern struct v_file_ops devfs_file_ops;


@@ -13,13 +13,13 @@ devfs_read(struct v_inode* inode, void* buffer, size_t len, size_t fpos)
 {
     assert(inode->data);
 
 {
     assert(inode->data);
 

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

 
 

-    if (!dev->read) {
+    if (!dev || !dev->ops.read) {

         return ENOTSUP;
     }
 
         return ENOTSUP;
     }
 

-    return dev->read(dev, buffer, fpos, len);
+    return dev->ops.read(dev, buffer, fpos, len);

 }
 
 int
 }
 
 int


@@ -27,81 +27,99 @@ devfs_write(struct v_inode* inode, void* buffer, size_t len, size_t fpos)
 {
     assert(inode->data);
 
 {
     assert(inode->data);
 

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

 
 

-    if (!dev->write) {
+    if (!dev || !dev->ops.write) {

         return ENOTSUP;
     }
 
         return ENOTSUP;
     }
 

-    return dev->write(dev, buffer, fpos, len);
+    return dev->ops.write(dev, buffer, fpos, len);

 }
 
 int
 }
 
 int

-devfs_read_page(struct v_inode* inode, void* buffer, size_t len, size_t fpos)
+devfs_read_page(struct v_inode* inode, void* buffer, size_t fpos)

 {
     assert(inode->data);
 
 {
     assert(inode->data);
 

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

 
 

-    if (!dev->read_page) {
+    if (!dev || !dev->ops.read_page) {

         return ENOTSUP;
     }
 
         return ENOTSUP;
     }
 

-    return dev->read_page(dev, buffer, fpos);
+    return dev->ops.read_page(dev, buffer, fpos);

 }
 
 int
 }
 
 int

-devfs_write_page(struct v_inode* inode, void* buffer, size_t len, size_t fpos)
+devfs_write_page(struct v_inode* inode, void* buffer, size_t fpos)

 {
     assert(inode->data);
 
 {
     assert(inode->data);
 

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

 
 

-    if (!dev->read_page) {
+    if (!dev || !dev->ops.read_page) {

         return ENOTSUP;
     }
 
         return ENOTSUP;
     }
 

-    return dev->read_page(dev, buffer, fpos);
+    return dev->ops.read_page(dev, buffer, fpos);

 }
 
 int
 }
 
 int

-devfs_get_itype(struct device* dev)
+devfs_get_itype(morph_t* obj)

 {
 {

-    int itype = VFS_IFFILE;
+    int itype = VFS_IFDEV;
+
+    if (morph_type_of(obj, devcat_morpher)) {
+        return VFS_IFDIR;
+    }
+
+    struct device* dev = resolve_device(obj);
+
+    if (!dev) {
+        return itype;
+    }
+    

     int dev_if = dev->dev_type & DEV_MSKIF;
     int dev_if = dev->dev_type & DEV_MSKIF;

-    if (dev_if == DEV_IFCAT) {
-        itype = VFS_IFDIR;
-    } else if (dev_if == DEV_IFVOL) {
+    if (dev_if == DEV_IFVOL) {

         itype |= VFS_IFVOLDEV;
         itype |= VFS_IFVOLDEV;

-    } else {
-        itype |= VFS_IFSEQDEV;

     }
     }

+
+    // otherwise, the mapping is considered to be generic seq dev.

     return itype;
 }
 
     return itype;
 }
 

-int
-devfs_get_dtype(struct device* dev)
+static inline int
+devfs_get_dtype(morph_t* dev_morph)

 {
 {

-    switch (dev->dev_type & DEV_MSKIF) {
-        case DEV_IFCAT:
-            return DT_DIR;
+    if (morph_type_of(dev_morph, devcat_morpher)) {
+        return DT_DIR;
+    }
+    return DT_FILE;
+}

 
 

-        default:
-            return DT_FILE;
+static inline morph_t*
+__try_resolve(struct v_inode* inode)
+{
+    if (!inode->data) {
+        return dev_object_root;

     }
     }

+
+    return resolve_device_morph(inode->data);

 }
 
 int
 }
 
 int

-devfs_mknod(struct v_dnode* dnode, struct device* dev)
+devfs_mknod(struct v_dnode* dnode, morph_t* obj)

 {
 {

-    assert(dev);
+    struct v_inode* devnod;
+    
+    assert(obj);

 
 

-    struct v_inode* devnod = vfs_i_find(dnode->super_block, dev->dev_id);
+    devnod = vfs_i_find(dnode->super_block, morpher_uid(obj));

     if (!devnod) {
         if ((devnod = vfs_i_alloc(dnode->super_block))) {
     if (!devnod) {
         if ((devnod = vfs_i_alloc(dnode->super_block))) {

-            devnod->id = dev->dev_id;
-            devnod->data = dev;
-            devnod->itype = devfs_get_itype(dev);
+            devnod->id = morpher_uid(obj);
+            devnod->data = changeling_ref(obj);
+            devnod->itype = devfs_get_itype(obj);

 
             vfs_i_addhash(devnod);
         } else {
 
             vfs_i_addhash(devnod);
         } else {


@@ -116,24 +134,43 @@ devfs_mknod(struct v_dnode* dnode, struct device* dev)
 int
 devfs_dirlookup(struct v_inode* this, struct v_dnode* dnode)
 {
 int
 devfs_dirlookup(struct v_inode* this, struct v_dnode* dnode)
 {

-    struct device* dev =
-      device_getbyhname((struct device*)this->data, &dnode->name);
-    if (!dev) {
+    morph_t *mobj, *root;
+
+    root = __try_resolve(this);
+    if (!root) {
+        return ENOTDIR;
+    }
+
+    mobj = changeling_find(root, &dnode->name);
+    if (!mobj) {

         return ENOENT;
     }
         return ENOENT;
     }

-    return devfs_mknod(dnode, dev);
+
+    return devfs_mknod(dnode, mobj);

 }
 
 int
 devfs_readdir(struct v_file* file, struct dir_context* dctx)
 {
 }
 
 int
 devfs_readdir(struct v_file* file, struct dir_context* dctx)
 {

-    struct device* dev =
-      device_getbyoffset((struct device*)(file->inode->data), dctx->index);
-    if (!dev) {
+    morph_t *mobj, *root;
+
+    root = __try_resolve(file->inode);
+    if (!root) {
+        return ENOTDIR;
+    }
+
+    if (fsapi_handle_pseudo_dirent(file, dctx)) {
+        return 1;
+    }
+
+    mobj = changeling_get_at(root, file->f_pos - 2);
+    if (!mobj) {

         return 0;
     }
         return 0;
     }

-    dctx->read_complete_callback(
-      dctx, dev->name.value, dev->name.len, devfs_get_dtype(dev));
+
+    dctx->read_complete_callback(dctx, 
+                                 mobj->name.value, mobj->name.len, 
+                                 devfs_get_dtype(mobj));

     return 1;
 }
 
     return 1;
 }
 


@@ -142,6 +179,12 @@ devfs_init_inode(struct v_superblock* vsb, struct v_inode* inode)
 {
     inode->ops = &devfs_inode_ops;
     inode->default_fops = &devfs_file_ops;
 {
     inode->ops = &devfs_inode_ops;
     inode->default_fops = &devfs_file_ops;

+
+    // we set default access right to be 0775.
+    // TODO need a way to allow this to be changed
+    
+    fsapi_inode_setaccess(inode, FSACL_DEFAULT);
+    fsapi_inode_setowner(inode, 0, 0);

 }
 
 int
 }
 
 int


@@ -173,11 +216,13 @@ devfs_unmount(struct v_superblock* vsb)
 void
 devfs_init()
 {
 void
 devfs_init()
 {

-    struct filesystem* fs = fsm_new_fs("devfs", 5);
-    fsm_register(fs);
-    fs->mount = devfs_mount;
-    fs->unmount = devfs_unmount;
+    struct filesystem* fs;
+    fs = fsapi_fs_declare("devfs", FSTYPE_PSEUDO);
+    
+    fsapi_fs_set_mntops(fs, devfs_mount, devfs_unmount);
+    fsapi_fs_finalise(fs);

 }
 }

+EXPORT_FILE_SYSTEM(devfs, devfs_init);

 
 struct v_inode_ops devfs_inode_ops = { .dir_lookup = devfs_dirlookup,
                                        .open = default_inode_open,
 
 struct v_inode_ops devfs_inode_ops = { .dir_lookup = devfs_dirlookup,
                                        .open = default_inode_open,