lunaix-os/includes/lunaix/fs.h

   1 #ifndef __LUNAIX_VFS_H
   2 #define __LUNAIX_VFS_H
   3
   4 #include <lunaix/clock.h>
   5 #include <lunaix/device.h>
   6 #include <lunaix/ds/btrie.h>
   7 #include <lunaix/ds/hashtable.h>
   8 #include <lunaix/ds/hstr.h>
   9 #include <lunaix/ds/llist.h>
  10 #include <lunaix/ds/lru.h>
  11 #include <lunaix/ds/mutex.h>
  12 #include <lunaix/process.h>
  13 #include <lunaix/status.h>
  14 #include <stdatomic.h>
  15
  16 #define VFS_NAME_MAXLEN 128
  17 #define VFS_MAX_FD 32
  18
  19 #define VFS_IFDIR 0x1
  20 #define VFS_IFFILE 0x2
  21 #define VFS_IFSEQDEV 0x4
  22 #define VFS_IFVOLDEV 0x8
  23 #define VFS_IFSYMLINK 0x16
  24
  25 #define VFS_WALK_MKPARENT 0x1
  26 #define VFS_WALK_FSRELATIVE 0x2
  27 #define VFS_WALK_PARENT 0x4
  28 #define VFS_WALK_NOFOLLOW 0x8
  29
  30 #define VFS_HASHTABLE_BITS 10
  31 #define VFS_HASHTABLE_SIZE (1 << VFS_HASHTABLE_BITS)
  32 #define VFS_HASH_MASK (VFS_HASHTABLE_SIZE - 1)
  33 #define VFS_HASHBITS (32 - VFS_HASHTABLE_BITS)
  34
  35 #define VFS_PATH_DELIM '/'
  36
  37 #define FSTYPE_ROFS 0x1
  38
  39 #define DO_STATUS(errno) SYSCALL_ESTATUS(__current->k_status = errno)
  40 #define DO_STATUS_OR_RETURN(errno) ({ errno < 0 ? DO_STATUS(errno) : errno; })
  41
  42 #define TEST_FD(fd) (fd >= 0 && fd < VFS_MAX_FD)
  43
  44 #define VFS_VALID_CHAR(chr)                                                    \
  45     (('A' <= (chr) && (chr) <= 'Z') || ('a' <= (chr) && (chr) <= 'z') ||       \
  46      ('0' <= (chr) && (chr) <= '9') || (chr) == '.' || (chr) == '_' ||         \
  47      (chr) == '-' || (chr) == ':')
  48
  49 #define unlock_inode(inode) mutex_unlock(&inode->lock)
  50 #define lock_inode(inode)                                                      \
  51     ({                                                                         \
  52         mutex_lock(&inode->lock);                                              \
  53         lru_use_one(inode_lru, &inode->lru);                                   \
  54     })
  55
  56 #define unlock_dnode(dnode) mutex_unlock(&dnode->lock)
  57 #define lock_dnode(dnode)                                                      \
  58     ({                                                                         \
  59         mutex_lock(&dnode->lock);                                              \
  60         lru_use_one(dnode_lru, &dnode->lru);                                   \
  61     })
  62
  63 typedef uint32_t inode_t;
  64
  65 struct v_dnode;
  66 struct v_inode;
  67 struct v_superblock;
  68 struct v_file;
  69 struct v_file_ops;
  70 struct v_inode_ops;
  71 struct v_fd;
  72 struct pcache;
  73 struct v_xattr_entry;
  74
  75 extern struct v_file_ops default_file_ops;
  76 extern struct v_inode_ops default_inode_ops;
  77
  78 extern struct hstr vfs_ddot;
  79 extern struct hstr vfs_dot;
  80 extern struct v_dnode* vfs_sysroot;
  81
  82 struct filesystem
  83 {
  84     struct hlist_node fs_list;
  85     struct hstr fs_name;
  86     uint32_t types;
  87     int fs_id;
  88     int (*mount)(struct v_superblock* vsb, struct v_dnode* mount_point);
  89     int (*unmount)(struct v_superblock* vsb);
  90 };
  91
  92 struct v_superblock
  93 {
  94     struct llist_header sb_list;
  95     struct device* dev;
  96     struct v_dnode* root;
  97     struct filesystem* fs;
  98     uint32_t iobuf_size;
  99     struct hbucket* i_cache;
 100     void* data;
 101     struct
 102     {
 103         uint32_t (*read_capacity)(struct v_superblock* vsb);
 104         uint32_t (*read_usage)(struct v_superblock* vsb);
 105         void (*init_inode)(struct v_superblock* vsb, struct v_inode* inode);
 106     } ops;
 107 };
 108
 109 struct dir_context
 110 {
 111     int index;
 112     void* cb_data;
 113     void (*read_complete_callback)(struct dir_context* dctx,
 114                                    const char* name,
 115                                    const int len,
 116                                    const int dtype);
 117 };
 118
 119 struct v_file_ops
 120 {
 121     int (*write)(struct v_inode* inode, void* buffer, size_t len, size_t fpos);
 122     int (*read)(struct v_inode* inode, void* buffer, size_t len, size_t fpos);
 123
 124     // for operatiosn {write|read}_page, following are true:
 125     //  + `len` always equals to PG_SIZE
 126     //  + `fpos` always PG_SIZE aligned.
 127     // These additional operations allow underlying fs to use more specialized
 128     // and optimized code.
 129
 130     int (*write_page)(struct v_inode* inode, void* pg, size_t len, size_t fpos);
 131     int (*read_page)(struct v_inode* inode, void* pg, size_t len, size_t fpos);
 132
 133     int (*readdir)(struct v_file* file, struct dir_context* dctx);
 134     int (*seek)(struct v_inode* inode, size_t offset); // optional
 135     int (*close)(struct v_file* file);
 136     int (*sync)(struct v_file* file);
 137 };
 138
 139 struct v_inode_ops
 140 {
 141     int (*create)(struct v_inode* this, struct v_dnode* dnode);
 142     int (*open)(struct v_inode* this, struct v_file* file);
 143     int (*sync)(struct v_inode* this);
 144     int (*mkdir)(struct v_inode* this, struct v_dnode* dnode);
 145     int (*rmdir)(struct v_inode* this, struct v_dnode* dir);
 146     int (*unlink)(struct v_inode* this);
 147     int (*link)(struct v_inode* this, struct v_dnode* new_name);
 148     int (*read_symlink)(struct v_inode* this, const char** path_out);
 149     int (*set_symlink)(struct v_inode* this, const char* target);
 150     int (*dir_lookup)(struct v_inode* this, struct v_dnode* dnode);
 151     int (*rename)(struct v_inode* from_inode,
 152                   struct v_dnode* from_dnode,
 153                   struct v_dnode* to_dnode);
 154     int (*getxattr)(struct v_inode* this,
 155                     struct v_xattr_entry* entry); // optional
 156     int (*setxattr)(struct v_inode* this,
 157                     struct v_xattr_entry* entry); // optional
 158     int (*delxattr)(struct v_inode* this,
 159                     struct v_xattr_entry* entry); // optional
 160 };
 161
 162 struct v_xattr_entry
 163 {
 164     struct llist_header entries;
 165     struct hstr name;
 166     const void* value;
 167     size_t len;
 168 };
 169
 170 struct v_file
 171 {
 172     struct v_inode* inode;
 173     struct v_dnode* dnode;
 174     struct llist_header* f_list;
 175     uint32_t f_pos;
 176     atomic_ulong ref_count;
 177     struct v_file_ops* ops; // for caching
 178 };
 179
 180 struct v_fd
 181 {
 182     struct v_file* file;
 183     int flags;
 184 };
 185
 186 //  [v_inode::aka_nodes]
 187 //  how do we invalidate corresponding v_dnodes given the v_inode?
 188 /*
 189     Consider taskfs, which is Lunaix's speak of Linux's procfs, that allow
 190     info of every process being accessible via file system. Each process's
 191     creation will result a creation of a directory under the root of task fs
 192     with it's pid as name. But that dir must delete when process is killed, and
 193     such deletion does not mediated by vfs itself, so there is a need of cache
 194     syncing.
 195     And this is also the case of all ramfs where argumentation to file tree is
 196     performed by third party.
 197 */
 198
 199 struct v_inode
 200 {
 201     inode_t id;
 202     mutex_t lock;
 203     uint32_t itype;
 204     time_t ctime;
 205     time_t mtime;
 206     time_t atime;
 207     lba_t lb_addr;
 208     uint32_t open_count;
 209     uint32_t link_count;
 210     uint32_t lb_usage;
 211     uint32_t fsize;
 212     void* data; // 允许底层FS绑定他的一些专有数据
 213     struct llist_header aka_dnodes;
 214     struct llist_header xattrs;
 215     struct v_superblock* sb;
 216     struct hlist_node hash_list;
 217     struct lru_node lru;
 218     struct pcache* pg_cache;
 219     struct v_inode_ops* ops;
 220     struct v_file_ops* default_fops;
 221 };
 222
 223 struct v_mount
 224 {
 225     mutex_t lock;
 226     struct llist_header list;
 227     struct llist_header submnts;
 228     struct llist_header sibmnts;
 229     struct v_mount* parent;
 230     struct v_dnode* mnt_point;
 231     struct v_superblock* super_block;
 232     uint32_t busy_counter;
 233     int flags;
 234 };
 235
 236 struct v_dnode
 237 {
 238     mutex_t lock; // sync the path walking
 239     struct lru_node lru;
 240     struct hstr name;
 241     struct v_inode* inode;
 242     struct v_dnode* parent;
 243     struct hlist_node hash_list;
 244     struct llist_header aka_list;
 245     struct llist_header children;
 246     struct llist_header siblings;
 247     struct v_superblock* super_block;
 248     struct v_mount* mnt;
 249     atomic_ulong ref_count;
 250
 251     void* data;
 252 };
 253
 254 struct v_fdtable
 255 {
 256     struct v_fd* fds[VFS_MAX_FD];
 257 };
 258
 259 struct pcache
 260 {
 261     struct v_inode* master;
 262     struct btrie tree;
 263     struct llist_header pages;
 264     struct llist_header dirty;
 265     uint32_t n_dirty;
 266     uint32_t n_pages;
 267 };
 268
 269 struct pcache_pg
 270 {
 271     struct llist_header pg_list;
 272     struct llist_header dirty_list;
 273     struct lru_node lru;
 274     struct pcache* holder;
 275     void* pg;
 276     uint32_t flags;
 277     uint32_t fpos;
 278 };
 279
 280 void
 281 fsm_init();
 282
 283 void
 284 fsm_register_all();
 285
 286 struct filesystem*
 287 fsm_new_fs(char* name, size_t name_len);
 288
 289 void
 290 fsm_register(struct filesystem* fs);
 291
 292 struct filesystem*
 293 fsm_get(const char* fs_name);
 294
 295 void
 296 vfs_init();
 297
 298 void
 299 vfs_export_attributes();
 300
 301 struct v_dnode*
 302 vfs_dcache_lookup(struct v_dnode* parent, struct hstr* str);
 303
 304 void
 305 vfs_dcache_add(struct v_dnode* parent, struct v_dnode* dnode);
 306
 307 void
 308 vfs_dcache_rehash(struct v_dnode* new_parent, struct v_dnode* dnode);
 309
 310 void
 311 vfs_dcache_remove(struct v_dnode* dnode);
 312
 313 int
 314 vfs_walk(struct v_dnode* start,
 315          const char* path,
 316          struct v_dnode** dentry,
 317          struct hstr* component,
 318          int walk_options);
 319
 320 int
 321 vfs_walk_proc(const char* path,
 322               struct v_dnode** dentry,
 323               struct hstr* component,
 324               int options);
 325
 326 int
 327 vfs_mount(const char* target,
 328           const char* fs_name,
 329           struct device* device,
 330           int options);
 331
 332 int
 333 vfs_unmount(const char* target);
 334
 335 int
 336 vfs_mount_at(const char* fs_name,
 337              struct device* device,
 338              struct v_dnode* mnt_point,
 339              int options);
 340
 341 int
 342 vfs_unmount_at(struct v_dnode* mnt_point);
 343
 344 int
 345 vfs_mkdir(const char* path, struct v_dnode** dentry);
 346
 347 int
 348 vfs_open(struct v_dnode* dnode, struct v_file** file);
 349
 350 int
 351 vfs_pclose(struct v_file* file, pid_t pid);
 352
 353 int
 354 vfs_close(struct v_file* file);
 355
 356 void
 357 vfs_free_fd(struct v_fd* fd);
 358
 359 int
 360 vfs_fsync(struct v_file* file);
 361
 362 void
 363 vfs_assign_inode(struct v_dnode* assign_to, struct v_inode* inode);
 364
 365 struct v_superblock*
 366 vfs_sb_alloc();
 367
 368 void
 369 vfs_sb_free(struct v_superblock* sb);
 370
 371 struct v_dnode*
 372 vfs_d_alloc();
 373
 374 void
 375 vfs_d_free(struct v_dnode* dnode);
 376
 377 struct v_inode*
 378 vfs_i_find(struct v_superblock* sb, uint32_t i_id);
 379
 380 void
 381 vfs_i_addhash(struct v_inode* inode);
 382
 383 struct v_inode*
 384 vfs_i_alloc(struct v_superblock* sb);
 385
 386 void
 387 vfs_i_free(struct v_inode* inode);
 388
 389 int
 390 vfs_dup_fd(struct v_fd* old, struct v_fd** new);
 391
 392 int
 393 vfs_getfd(int fd, struct v_fd** fd_s);
 394
 395 int
 396 vfs_get_dtype(int itype);
 397
 398 void
 399 vfs_ref_dnode(struct v_dnode* dnode);
 400
 401 void
 402 vfs_unref_dnode(struct v_dnode* dnode);
 403
 404 int
 405 vfs_get_path(struct v_dnode* dnode, char* buf, size_t size, int depth);
 406
 407 void
 408 pcache_init(struct pcache* pcache);
 409
 410 void
 411 pcache_release_page(struct pcache* pcache, struct pcache_pg* page);
 412
 413 struct pcache_pg*
 414 pcache_new_page(struct pcache* pcache, uint32_t index);
 415
 416 void
 417 pcache_set_dirty(struct pcache* pcache, struct pcache_pg* pg);
 418
 419 int
 420 pcache_get_page(struct pcache* pcache,
 421                 uint32_t index,
 422                 uint32_t* offset,
 423                 struct pcache_pg** page);
 424
 425 int
 426 pcache_write(struct v_inode* inode, void* data, uint32_t len, uint32_t fpos);
 427
 428 int
 429 pcache_read(struct v_inode* inode, void* data, uint32_t len, uint32_t fpos);
 430
 431 void
 432 pcache_release(struct pcache* pcache);
 433
 434 int
 435 pcache_commit(struct v_inode* inode, struct pcache_pg* page);
 436
 437 void
 438 pcache_commit_all(struct v_inode* inode);
 439
 440 void
 441 pcache_invalidate(struct pcache* pcache, struct pcache_pg* page);
 442
 443 /**
 444  * @brief 将挂载点标记为繁忙
 445  *
 446  * @param mnt
 447  */
 448 void
 449 mnt_mkbusy(struct v_mount* mnt);
 450
 451 /**
 452  * @brief 将挂载点标记为清闲
 453  *
 454  * @param mnt
 455  */
 456 void
 457 mnt_chillax(struct v_mount* mnt);
 458
 459 int
 460 vfs_mount_root(const char* fs_name, struct device* device);
 461
 462 struct v_mount*
 463 vfs_create_mount(struct v_mount* parent, struct v_dnode* mnt_point);
 464
 465 int
 466 vfs_check_writable(struct v_dnode* dnode);
 467
 468 int
 469 default_file_read(struct v_inode* inode, void* buffer, size_t len, size_t fpos);
 470
 471 int
 472 default_file_write(struct v_inode* inode,
 473                    void* buffer,
 474                    size_t len,
 475                    size_t fpos);
 476
 477 int
 478 default_file_readdir(struct v_file* file, struct dir_context* dctx);
 479
 480 int
 481 default_inode_dirlookup(struct v_inode* this, struct v_dnode* dnode);
 482
 483 int
 484 default_inode_rename(struct v_inode* from_inode,
 485                      struct v_dnode* from_dnode,
 486                      struct v_dnode* to_dnode);
 487
 488 int
 489 default_file_close(struct v_file* file);
 490
 491 int
 492 default_file_seek(struct v_inode* inode, size_t offset);
 493
 494 int
 495 default_inode_open(struct v_inode* this, struct v_file* file);
 496
 497 int
 498 default_inode_rmdir(struct v_inode* this, struct v_dnode* dir);
 499
 500 int
 501 default_inode_mkdir(struct v_inode* this, struct v_dnode* dir);
 502
 503 struct v_xattr_entry*
 504 xattr_new(struct hstr* name);
 505
 506 struct v_xattr_entry*
 507 xattr_getcache(struct v_inode* inode, struct hstr* name);
 508
 509 void
 510 xattr_addcache(struct v_inode* inode, struct v_xattr_entry* xattr);
 511
 512 #endif /* __LUNAIX_VFS_H */