vfs.h

Go to the documentation of this file.

#pragma once
 
#include <kernel/fs/dentry.h>
#include <kernel/fs/file.h>
#include <kernel/fs/inode.h>
#include <kernel/fs/mount.h>
#include <kernel/fs/path.h>
#include <kernel/fs/superblock.h>
#include <kernel/fs/sysfs.h>
#include <kernel/proc/process.h>
#include <kernel/sync/rwlock.h>
#include <kernel/utils/map.h>
 
#include <sys/io.h>
#include <sys/list.h>
#include <sys/math.h>
#include <sys/proc.h>
 
typedef struct filesystem filesystem_t;
 
#define VFS_ROOT_ENTRY_NAME "__root__"
 
#define VFS_DEVICE_NAME_NONE "__no_device__"
 
typedef struct filesystem
{
    list_entry_t entry;
    const char* name;
    dentry_t* (*mount)(filesystem_t* fs, const char* devName, void* private);
} filesystem_t;
 
typedef struct
{
    list_t list;
    rwlock_t lock;
} vfs_list_t;
 
typedef struct
{
    map_t map;
    rwlock_t lock;
} vfs_map_t;
 
void vfs_init(void);
 
uint64_t vfs_get_new_id(void);
 
uint64_t vfs_register_fs(filesystem_t* fs);
 
uint64_t vfs_unregister_fs(filesystem_t* fs);
 
filesystem_t* vfs_get_fs(const char* name);
 
inode_t* vfs_get_inode(superblock_t* superblock, inode_number_t number);
 
dentry_t* vfs_get_dentry(const dentry_t* parent, const char* name);
 
dentry_t* vfs_get_or_lookup_dentry(const path_t* parent, const char* name);
 
uint64_t vfs_add_inode(inode_t* inode);
 
uint64_t vfs_add_dentry(dentry_t* dentry);
 
void vfs_remove_superblock(superblock_t* superblock);
 
void vfs_remove_inode(inode_t* inode);
 
void vfs_remove_dentry(dentry_t* dentry);
 
uint64_t vfs_walk(path_t* outPath, const pathname_t* pathname, walk_flags_t flags, process_t* process);
 
uint64_t vfs_walk_parent(path_t* outPath, const pathname_t* pathname, char* outLastName, walk_flags_t flags,
    process_t* process);
 
uint64_t vfs_walk_parent_and_child(path_t* outParent, path_t* outChild, const pathname_t* pathname, walk_flags_t flags,
    process_t* process);
 
bool vfs_is_name_valid(const char* name);
 
file_t* vfs_open(const pathname_t* pathname, process_t* process);
 
uint64_t vfs_open2(const pathname_t* pathname, file_t* files[2], process_t* process);
 
uint64_t vfs_read(file_t* file, void* buffer, uint64_t count);
 
uint64_t vfs_write(file_t* file, const void* buffer, uint64_t count);
 
uint64_t vfs_seek(file_t* file, int64_t offset, seek_origin_t origin);
 
uint64_t vfs_ioctl(file_t* file, uint64_t request, void* argp, uint64_t size);
 
void* vfs_mmap(file_t* file, void* address, uint64_t length, pml_flags_t flags);
 
uint64_t vfs_poll(poll_file_t* files, uint64_t amount, clock_t timeout);
 
uint64_t vfs_getdents(file_t* file, dirent_t* buffer, uint64_t count);
 
uint64_t vfs_stat(const pathname_t* pathname, stat_t* buffer, process_t* process);
 
uint64_t vfs_link(const pathname_t* oldPathname, const pathname_t* newPathname, process_t* process);
 
uint64_t vfs_remove(const pathname_t* pathname, process_t* process);
 
#define BUFFER_READ(buffer, count, offset, src, size) \
    ({ \
        uint64_t readCount = (*(offset) <= (size)) ? MIN((count), (size) - *(offset)) : 0; \
        memcpy((buffer), (src) + *(offset), readCount); \
        *(offset) += readCount; \
        readCount; \
    })