vfs.h

Go to the documentation of this file.

/*
 * MIT License
 *
 * Copyright (c) 2026 Grzegorz Grzęda
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#ifndef HOME_CORE_VFS_H
#define HOME_CORE_VFS_H
/*---------------------------------------------------------------------------*/
#if defined(__cplusplus)
extern "C" {
#endif
/*---------------------------------------------------------------------------*/
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#define VFS_SNAPSHOT_CAPACITY 32
#define VFS_PATH_CAPACITY 128
/*---------------------------------------------------------------------------*/
typedef struct vfs_node vfs_node_t;
/*---------------------------------------------------------------------------*/
typedef struct {
    int (*open)(vfs_node_t *node, int flags);
    int (*close)(vfs_node_t *node);
 
    int (*read)(vfs_node_t *node, void *buf, unsigned len);
    int (*write)(vfs_node_t *node, const void *buf, unsigned len);
 
    int (*ioctl)(vfs_node_t *node, unsigned request, void *arg);
 
    int (*lseek)(vfs_node_t *node, int offset, int whence);
 
    int (*snapshot)(vfs_node_t *node, char *buf, unsigned capacity);
} vfs_ops_t;
/*---------------------------------------------------------------------------*/
typedef struct vfs_node {
    const char *name;
    vfs_ops_t ops;
    void *driver_data;
    vfs_node_t *next;
    bool is_directory;
    bool is_regular;
    bool is_owned;
    unsigned size;
} vfs_node_t;
/*---------------------------------------------------------------------------*/
void vfs_init(void);
/*---------------------------------------------------------------------------*/
void vfs_register_node(vfs_node_t *node);
/*---------------------------------------------------------------------------*/
vfs_node_t *vfs_find_node(const char *name);
/*---------------------------------------------------------------------------*/
int vfs_resolve_path(const char *base, const char *path, char result[VFS_PATH_CAPACITY]);
/*---------------------------------------------------------------------------*/
int vfs_mkdir(const char *path);
/*---------------------------------------------------------------------------*/
int vfs_rmdir(const char *path);
/*---------------------------------------------------------------------------*/
int vfs_unlink(const char *path);
/*---------------------------------------------------------------------------*/
typedef int (*vfs_directory_visitor_t)(const char *name, bool is_directory, void *context);
/*---------------------------------------------------------------------------*/
int vfs_list(const char *path, vfs_directory_visitor_t visitor, void *context);
/*---------------------------------------------------------------------------*/
int vfs_open(const char *name, int flags);
/*---------------------------------------------------------------------------*/
int vfs_close(int fd);
/*---------------------------------------------------------------------------*/
int vfs_read(int fd, void *buf, unsigned len);
/*---------------------------------------------------------------------------*/
int vfs_write(int fd, const void *buf, unsigned len);
/*---------------------------------------------------------------------------*/
int vfs_ioctl(int fd, unsigned request, void *arg);
/*---------------------------------------------------------------------------*/
int vfs_lseek(int fd, int offset, int whence);
/*---------------------------------------------------------------------------*/
vfs_node_t *vfs_fd_node(int fd);
/*---------------------------------------------------------------------------*/
typedef struct {
    bool is_directory;
    bool is_regular;
    unsigned size;
} vfs_stat_t;
/*---------------------------------------------------------------------------*/
int vfs_stat(const char *path, vfs_stat_t *stat);
/*---------------------------------------------------------------------------*/
int vfs_fstat(int fd, vfs_stat_t *stat);
/*---------------------------------------------------------------------------*/
typedef struct {
    int (*open)(void *fs, const char *path, int flags, void **file);
    int (*close)(void *fs, void *file);
    int (*read)(void *fs, void *file, void *buf, unsigned len);
    int (*write)(void *fs, void *file, const void *buf, unsigned len);
    int (*lseek)(void *fs, void *file, int offset, int whence);
    int (*fstat)(void *fs, void *file, vfs_stat_t *stat);
    int (*stat)(void *fs, const char *path, vfs_stat_t *stat);
    int (*mkdir)(void *fs, const char *path);
    int (*rmdir)(void *fs, const char *path);
    int (*unlink)(void *fs, const char *path);
    int (*list)(void *fs, const char *path, vfs_directory_visitor_t visitor, void *context);
} vfs_fs_ops_t;
/*---------------------------------------------------------------------------*/
int vfs_mount(const char *path, const vfs_fs_ops_t *ops, void *fs);
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#if defined(__cplusplus)
}
#endif
/*---------------------------------------------------------------------------*/
#endif // HOME_CORE_VFS_H
/*---------------------------------------------------------------------------*/