lunaix-os/kernel/fs/twifs/twifs.c

   1 /**
   2  * @file twifs.c
   3  * @author Lunaixsky (zelong56@gmail.com)
   4  * @brief TwiFS - A pseudo file system for kernel state exposure.
   5  * @version 0.1
   6  * @date 2022-07-21
   7  *
   8  * @copyright Copyright (c) 2022
   9  *
  10  */
  11 #include <klibc/strfmt.h>
  12 #include <klibc/string.h>
  13 #include <lunaix/clock.h>
  14 #include <lunaix/fs.h>
  15 #include <lunaix/fs/twifs.h>
  16 #include <lunaix/fs/twimap.h>
  17 #include <lunaix/mm/cake.h>
  18 #include <lunaix/mm/valloc.h>
  19 #include <lunaix/spike.h>
  20
  21 #include <sys/mm/mempart.h>
  22
  23 static struct twifs_node* fs_root;
  24
  25 static struct cake_pile* twi_pile;
  26
  27 static volatile u32_t inode_id = 0;
  28
  29 extern const struct v_file_ops twifs_file_ops;
  30 extern const struct v_inode_ops twifs_inode_ops;
  31
  32 struct twifs_node*
  33 __twifs_new_node(struct twifs_node* parent,
  34                  const char* name,
  35                  int name_len,
  36                  u32_t itype)
  37 {
  38     struct twifs_node* node = cake_grab(twi_pile);
  39     memset(node, 0, sizeof(*node));
  40
  41     strncpy(node->name_val, name, VFS_NAME_MAXLEN);
  42
  43     node->name = HSTR(node->name_val, MIN(name_len, VFS_NAME_MAXLEN));
  44     node->itype = itype;
  45     node->ino_id = inode_id++;
  46     hstr_rehash(&node->name, HSTR_FULL_HASH);
  47     llist_init_head(&node->children);
  48
  49     if (parent) {
  50         llist_append(&parent->children, &node->siblings);
  51     }
  52
  53     return node;
  54 }
  55
  56 void
  57 __twifs_init_inode(struct v_superblock* vsb, struct v_inode* inode)
  58 {
  59     inode->ops = (struct v_inode_ops*)&twifs_inode_ops;
  60     inode->default_fops = (struct v_file_ops*)&twifs_file_ops;
  61 }
  62
  63 int
  64 __twifs_mount(struct v_superblock* vsb, struct v_dnode* mount_point)
  65 {
  66     vsb->ops.init_inode = __twifs_init_inode;
  67
  68     struct v_inode* inode = vfs_i_alloc(vsb);
  69     if (!inode) {
  70         return ENOMEM;
  71     }
  72
  73     inode->id = fs_root->ino_id;
  74     inode->itype = fs_root->itype;
  75     inode->data = fs_root;
  76
  77     vfs_i_addhash(inode);
  78     vfs_assign_inode(mount_point, inode);
  79     return 0;
  80 }
  81
  82 int
  83 __twifs_fwrite(struct v_inode* inode, void* buffer, size_t len, size_t fpos)
  84 {
  85     struct twifs_node* twi_node = (struct twifs_node*)inode->data;
  86     if (!twi_node || !twi_node->ops.write) {
  87         return ENOTSUP;
  88     }
  89     return twi_node->ops.write(inode, buffer, len, fpos);
  90 }
  91
  92 int
  93 __twifs_fwrite_pg(struct v_inode* inode, void* buffer, size_t fpos)
  94 {
  95     return __twifs_fwrite(inode, buffer, MEM_PAGE, fpos);
  96 }
  97
  98 int
  99 __twifs_fread(struct v_inode* inode, void* buffer, size_t len, size_t fpos)
 100 {
 101     struct twifs_node* twi_node = (struct twifs_node*)inode->data;
 102     if (!twi_node || !twi_node->ops.read) {
 103         return ENOTSUP;
 104     }
 105     return twi_node->ops.read(inode, buffer, len, fpos);
 106 }
 107
 108 int
 109 __twifs_fread_pg(struct v_inode* inode, void* buffer, size_t fpos)
 110 {
 111     return __twifs_fread(inode, buffer, MEM_PAGE, fpos);
 112 }
 113
 114 struct twifs_node*
 115 __twifs_get_node(struct twifs_node* parent, struct hstr* name)
 116 {
 117     if (!parent)
 118         return NULL;
 119
 120     struct twifs_node *pos, *n;
 121     llist_for_each(pos, n, &parent->children, siblings)
 122     {
 123         if (HSTR_EQ(&pos->name, name)) {
 124             return pos;
 125         }
 126     }
 127     return NULL;
 128 }
 129
 130 int
 131 __twifs_dirlookup(struct v_inode* inode, struct v_dnode* dnode)
 132 {
 133     struct twifs_node* twi_node = (struct twifs_node*)inode->data;
 134
 135     if ((twi_node->itype & F_FILE)) {
 136         return ENOTDIR;
 137     }
 138
 139     struct twifs_node* child_node = __twifs_get_node(twi_node, &dnode->name);
 140     if (child_node) {
 141         struct v_inode* child_inode = vfs_i_find(inode->sb, child_node->ino_id);
 142         if (child_inode) {
 143             goto done;
 144         }
 145
 146         if (!(child_inode = vfs_i_alloc(inode->sb))) {
 147             return ENOENT;
 148         }
 149
 150         child_inode->id = child_node->ino_id;
 151         child_inode->itype = child_node->itype;
 152         child_inode->data = child_node;
 153
 154         vfs_i_addhash(child_inode);
 155
 156     done:
 157         dnode->data = child_node->data;
 158         vfs_assign_inode(dnode, child_inode);
 159         return 0;
 160     }
 161     return ENOENT;
 162 }
 163
 164 int
 165 __twifs_iterate_dir(struct v_file* file, struct dir_context* dctx)
 166 {
 167     struct twifs_node* twi_node = (struct twifs_node*)(file->inode->data);
 168     int counter = 0;
 169     struct twifs_node *pos, *n;
 170
 171     llist_for_each(pos, n, &twi_node->children, siblings)
 172     {
 173         if (counter++ >= dctx->index) {
 174             dctx->index = counter;
 175             dctx->read_complete_callback(
 176               dctx, pos->name.value, pos->name.len, vfs_get_dtype(pos->itype));
 177             return 1;
 178         }
 179     }
 180
 181     return 0;
 182 }
 183
 184 int
 185 __twifs_openfile(struct v_inode* inode, struct v_file* file)
 186 {
 187     struct twifs_node* twi_node = (struct twifs_node*)inode->data;
 188     if (twi_node) {
 189         return 0;
 190     }
 191     return ENOTSUP;
 192 }
 193
 194 int
 195 twifs_rm_node(struct twifs_node* node)
 196 {
 197     if (!(node->itype & F_FILE) && !llist_empty(&node->children)) {
 198         return ENOTEMPTY;
 199     }
 200     llist_delete(&node->siblings);
 201     cake_release(twi_pile, node);
 202     return 0;
 203 }
 204
 205 struct twifs_node*
 206 twifs_file_node_vargs(struct twifs_node* parent, const char* fmt, va_list args)
 207 {
 208     char buf[VFS_NAME_MAXLEN];
 209     size_t len = ksnprintfv(buf, fmt, VFS_NAME_MAXLEN, args);
 210
 211     return __twifs_new_node(parent ? parent : fs_root, buf, len, F_FILE);
 212 }
 213
 214 struct twifs_node*
 215 twifs_file_node(struct twifs_node* parent, const char* fmt, ...)
 216 {
 217     va_list args;
 218     va_start(args, fmt);
 219
 220     struct twifs_node* twi_node = twifs_file_node_vargs(parent, fmt, args);
 221
 222     va_end(args);
 223
 224     return twi_node;
 225 }
 226
 227 struct twifs_node*
 228 twifs_dir_node(struct twifs_node* parent, const char* fmt, ...)
 229 {
 230     va_list args;
 231     va_start(args, fmt);
 232
 233     char buf[VFS_NAME_MAXLEN];
 234     size_t len = ksnprintfv(buf, fmt, VFS_NAME_MAXLEN, args);
 235     struct twifs_node* twi_node =
 236       __twifs_new_node(parent ? parent : fs_root, buf, len, VFS_IFDIR);
 237
 238     va_end(args);
 239
 240     return twi_node;
 241 }
 242
 243 void
 244 twifs_init()
 245 {
 246     twi_pile = cake_new_pile("twifs_node", sizeof(struct twifs_node), 1, 0);
 247
 248     struct filesystem* twifs = vzalloc(sizeof(struct filesystem));
 249     twifs->fs_name = HSTR("twifs", 5);
 250     twifs->mount = __twifs_mount;
 251     twifs->types = FSTYPE_ROFS;
 252     twifs->fs_id = 0;
 253
 254     fsm_register(twifs);
 255
 256     fs_root = twifs_dir_node(NULL, NULL, 0, 0);
 257 }
 258 EXPORT_FILE_SYSTEM(twifs, twifs_init);
 259
 260 void
 261 twifs_register_plugins()
 262 {
 263     ldga_invoke_fn0(twiplugin_inits);
 264 }
 265
 266 int
 267 __twifs_twimap_file_read(struct v_inode* inode,
 268                          void* buf,
 269                          size_t len,
 270                          size_t fpos)
 271 {
 272     struct twimap* map = twinode_getdata(inode, struct twimap*);
 273     return twimap_read(map, buf, len, fpos);
 274 }
 275
 276 struct twimap*
 277 twifs_mapping(struct twifs_node* parent, void* data, const char* fmt, ...)
 278 {
 279     va_list args;
 280     va_start(args, fmt);
 281
 282     struct twimap* map = twimap_create(data);
 283     struct twifs_node* node = twifs_file_node_vargs(parent, fmt, args);
 284     node->ops.read = __twifs_twimap_file_read;
 285     node->data = map;
 286
 287     return map;
 288 }
 289
 290 const struct v_file_ops twifs_file_ops = { .close = default_file_close,
 291                                            .read = __twifs_fread,
 292                                            .read_page = __twifs_fread_pg,
 293                                            .write = __twifs_fwrite,
 294                                            .write_page = __twifs_fwrite_pg,
 295                                            .readdir = __twifs_iterate_dir };
 296
 297 const struct v_inode_ops twifs_inode_ops = { .dir_lookup = __twifs_dirlookup,
 298                                              .mkdir = default_inode_mkdir,
 299                                              .rmdir = default_inode_rmdir,
 300                                              .open = __twifs_openfile };