vfs.h

Go to the documentation of this file.

#pragma once
 
#include <kernel/error.h>
#include <kernel/file.h>
#include <kernel/types.h>
#include <kernel/user.h>
#include <uapi/fcntl.h>
 
#include <lib/path.h>
#include <libalgo/linked_list.h>
#include <utils/compiler.h>
#include <utils/stringify.h>
 
#include <sys/stat.h>
 
struct block_device;
 
typedef struct vfs vfs_t;
typedef struct vnode vnode_t;
 
typedef enum vnode_type vnode_type;
 
typedef struct vfs_operations {
    vnode_t *(*root)(vfs_t *);
    void (*delete)(vfs_t *);
} vfs_ops_t;
 
typedef struct vfs {
    node_t this;
    vfs_ops_t *operations;       
    vnode_t *node;               
    void *pdata;                 
    struct block_device *blkdev; 
} vfs_t;
 
error_t vfs_mount(const char *path, const char *fs_type, struct block_device *);
 
error_t vfs_mount_root(const char *fs_type, struct block_device *);
 
error_t vfs_unmount(const char *path);
 
vnode_t *vfs_find_by_path(const char *path);
 
vnode_t *vfs_create(const char *path, vnode_type type);
 
error_t vfs_remove(const char *path);
 
struct file *vfs_open(const char *path, int oflags);
 
typedef enum vnode_type {
    VNODE_FIFO = S_IFIFO,        
    VNODE_CHARDEVICE = S_IFCHR,  
    VNODE_DIRECTORY = S_IFDIR,   
    VNODE_BLOCKDEVICE = S_IFBLK, 
    VNODE_FILE = S_IFREG,        
    VNODE_SYMLINK = S_IFLNK,     
    VNODE_SOCKET = S_IFSOCK,     
} vnode_type;
 
typedef struct vnode_operations {
 
    vnode_t *(*lookup)(vnode_t *, const path_segment_t *);
 
    vnode_t *(*create)(vnode_t *node, const char *name, vnode_type);
 
    error_t (*remove)(vnode_t *node, const char *child);
 
    struct file *(*open)(vnode_t *vnode);
 
    void (*release)(vnode_t *node);
 
} vnode_ops_t;
 
struct vnode {
    vfs_t *fs;               
    vnode_type type;         
    u16 refcount;            
    vnode_ops_t *operations; 
    void *pdata;             
    vfs_t *mounted_here;     
    struct stat stat;        
    spinlock_t lock;         
};
 
vnode_t *vfs_vnode_acquire(vnode_t *, bool *);
 
vnode_t *vfs_vnode_release(vnode_t *);
 
bool vfs_vnode_check_creds(const struct vnode *, const struct user_creds *,
                           int oflags);
 
static inline bool vfs_exist(const char *path)
{
    struct vnode *vnode = vfs_find_by_path(path);
    if (IS_ERR(vnode))
        return false;
    vfs_vnode_release(vnode);
    return true;
}
 
typedef struct vfs_fs {
    const char *const name;               
    vfs_t *(*new)(struct block_device *); 
} vfs_fs_t;
 
#define DECLARE_FILESYSTEM(fs_name, fs_new)      \
    SECTION(".data.vfs.filesystems")             \
    MAYBE_UNUSED                                 \
    static vfs_fs_t fs_name##_fs_declaration = { \
        .name = stringify(fs_name),              \
        .new = fs_new,                           \
    }