lunaix-os/kernel/device/devfs.c

   1 #include <lunaix/device.h>
   2 #include <lunaix/fs.h>
   3 #include <lunaix/fs/devfs.h>
   4 #include <lunaix/spike.h>
   5
   6 #include <usr/lunaix/dirent_defs.h>
   7
   8 extern struct v_inode_ops devfs_inode_ops;
   9 extern struct v_file_ops devfs_file_ops;
  10
  11 int
  12 devfs_read(struct v_inode* inode, void* buffer, size_t len, size_t fpos)
  13 {
  14     assert(inode->data);
  15
  16     struct device* dev = (struct device*)inode->data;
  17
  18     if (!dev->ops.read) {
  19         return ENOTSUP;
  20     }
  21
  22     return dev->ops.read(dev, buffer, fpos, len);
  23 }
  24
  25 int
  26 devfs_write(struct v_inode* inode, void* buffer, size_t len, size_t fpos)
  27 {
  28     assert(inode->data);
  29
  30     struct device* dev = (struct device*)inode->data;
  31
  32     if (!dev->ops.write) {
  33         return ENOTSUP;
  34     }
  35
  36     return dev->ops.write(dev, buffer, fpos, len);
  37 }
  38
  39 int
  40 devfs_read_page(struct v_inode* inode, void* buffer, size_t len, size_t fpos)
  41 {
  42     assert(inode->data);
  43
  44     struct device* dev = (struct device*)inode->data;
  45
  46     if (!dev->ops.read_page) {
  47         return ENOTSUP;
  48     }
  49
  50     return dev->ops.read_page(dev, buffer, fpos);
  51 }
  52
  53 int
  54 devfs_write_page(struct v_inode* inode, void* buffer, size_t len, size_t fpos)
  55 {
  56     assert(inode->data);
  57
  58     struct device* dev = (struct device*)inode->data;
  59
  60     if (!dev->ops.read_page) {
  61         return ENOTSUP;
  62     }
  63
  64     return dev->ops.read_page(dev, buffer, fpos);
  65 }
  66
  67 int
  68 devfs_get_itype(struct device* dev)
  69 {
  70     int itype = VFS_IFFILE;
  71     int dev_if = dev->dev_type & DEV_MSKIF;
  72     if (dev_if == DEV_IFCAT) {
  73         itype = VFS_IFDIR;
  74     } else if (dev_if == DEV_IFVOL) {
  75         itype |= VFS_IFVOLDEV;
  76     } else {
  77         itype |= VFS_IFSEQDEV;
  78     }
  79     return itype;
  80 }
  81
  82 int
  83 devfs_get_dtype(struct device* dev)
  84 {
  85     switch (dev->dev_type & DEV_MSKIF) {
  86         case DEV_IFCAT:
  87             return DT_DIR;
  88
  89         default:
  90             return DT_FILE;
  91     }
  92 }
  93
  94 int
  95 devfs_mknod(struct v_dnode* dnode, struct device* dev)
  96 {
  97     assert(dev);
  98
  99     struct v_inode* devnod = vfs_i_find(dnode->super_block, dev->dev_id);
 100     if (!devnod) {
 101         if ((devnod = vfs_i_alloc(dnode->super_block))) {
 102             devnod->id = dev->dev_id;
 103             devnod->data = dev;
 104             devnod->itype = devfs_get_itype(dev);
 105
 106             vfs_i_addhash(devnod);
 107         } else {
 108             return ENOMEM;
 109         }
 110     }
 111
 112     vfs_assign_inode(dnode, devnod);
 113     return 0;
 114 }
 115
 116 int
 117 devfs_dirlookup(struct v_inode* this, struct v_dnode* dnode)
 118 {
 119     struct device* dev =
 120       device_getbyhname((struct device*)this->data, &dnode->name);
 121     if (!dev) {
 122         return ENOENT;
 123     }
 124     return devfs_mknod(dnode, dev);
 125 }
 126
 127 int
 128 devfs_readdir(struct v_file* file, struct dir_context* dctx)
 129 {
 130     struct device* dev =
 131       device_getbyoffset((struct device*)(file->inode->data), dctx->index);
 132     if (!dev) {
 133         return 0;
 134     }
 135     dctx->read_complete_callback(
 136       dctx, dev->name.value, dev->name.len, devfs_get_dtype(dev));
 137     return 1;
 138 }
 139
 140 void
 141 devfs_init_inode(struct v_superblock* vsb, struct v_inode* inode)
 142 {
 143     inode->ops = &devfs_inode_ops;
 144     inode->default_fops = &devfs_file_ops;
 145 }
 146
 147 int
 148 devfs_mount(struct v_superblock* vsb, struct v_dnode* mount_point)
 149 {
 150     vsb->ops.init_inode = devfs_init_inode;
 151
 152     struct v_inode* rootnod = vfs_i_alloc(vsb);
 153
 154     if (!rootnod) {
 155         return ENOMEM;
 156     }
 157
 158     rootnod->id = -1;
 159     rootnod->itype = VFS_IFDIR;
 160
 161     vfs_i_addhash(rootnod);
 162     vfs_assign_inode(mount_point, rootnod);
 163
 164     return 0;
 165 }
 166
 167 int
 168 devfs_unmount(struct v_superblock* vsb)
 169 {
 170     return 0;
 171 }
 172
 173 void
 174 devfs_init()
 175 {
 176     struct filesystem* fs = fsm_new_fs("devfs", 5);
 177     fsm_register(fs);
 178     fs->mount = devfs_mount;
 179     fs->unmount = devfs_unmount;
 180 }
 181
 182 struct v_inode_ops devfs_inode_ops = { .dir_lookup = devfs_dirlookup,
 183                                        .open = default_inode_open,
 184                                        .mkdir = default_inode_mkdir,
 185                                        .rmdir = default_inode_rmdir };
 186
 187 struct v_file_ops devfs_file_ops = { .close = default_file_close,
 188                                      .read = devfs_read,
 189                                      .read_page = devfs_read_page,
 190                                      .write = devfs_write,
 191                                      .write_page = devfs_write_page,
 192                                      .seek = default_file_seek,
 193                                      .readdir = devfs_readdir };