vfs.h

Go to the documentation of this file.

/*
 * Copyright (C) 2016 Eistec AB
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */
 
#ifndef VFS_H
#define VFS_H
 
#include <stdint.h>
/* The stdatomic.h in GCC gives compilation errors with C++
 * see: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60932
 */
#ifdef __cplusplus
#include "c11_atomics_compat.hpp"
#else
#include <stdatomic.h> /* for atomic_int */
#endif
#include <sys/stat.h> /* for struct stat */
#include <sys/types.h> /* for off_t etc. */
#include <sys/statvfs.h> /* for struct statvfs */
 
#include "sched.h"
#include "clist.h"
 
#ifdef __cplusplus
extern "C" {
/* restrict is a C99 keyword, not valid in C++, but GCC and Clang have the
 * __restrict__ extension keyword which can be used instead */
#define restrict __restrict__
/* If the above is not supported by the compiler, you can replace it with an
 * empty definition instead: */
/* #define restrict */
#endif
 
#ifndef _MAX
#define _MAX(a, b) ((a) > (b) ? (a) : (b))
#endif
#ifndef MAX4
#define MAX4(a, b, c, d) _MAX(_MAX((a), (b)), _MAX((c),(d)))
#endif
 
#ifdef MODULE_FATFS_VFS
#define FATFS_VFS_DIR_BUFFER_SIZE       (44)
#define FATFS_VFS_FILE_BUFFER_SIZE      (72)
#else
#define FATFS_VFS_DIR_BUFFER_SIZE       (1)
#define FATFS_VFS_FILE_BUFFER_SIZE      (1)
#endif
 
#ifdef MODULE_LITTLEFS
#define LITTLEFS_VFS_DIR_BUFFER_SIZE    (44)
#define LITTLEFS_VFS_FILE_BUFFER_SIZE   (56)
#else
#define LITTLEFS_VFS_DIR_BUFFER_SIZE    (1)
#define LITTLEFS_VFS_FILE_BUFFER_SIZE   (1)
#endif
 
#ifdef MODULE_LITTLEFS2
#define LITTLEFS2_VFS_DIR_BUFFER_SIZE   (52)
#define LITTLEFS2_VFS_FILE_BUFFER_SIZE  (84)
#else
#define LITTLEFS2_VFS_DIR_BUFFER_SIZE   (1)
#define LITTLEFS2_VFS_FILE_BUFFER_SIZE  (1)
#endif
 
#ifdef MODULE_SPIFFS
#define SPIFFS_VFS_DIR_BUFFER_SIZE      (12)
#define SPIFFS_VFS_FILE_BUFFER_SIZE     (1)
#else
#define SPIFFS_VFS_DIR_BUFFER_SIZE      (1)
#define SPIFFS_VFS_FILE_BUFFER_SIZE     (1)
#endif
 
#ifndef VFS_MAX_OPEN_FILES
 
#define VFS_MAX_OPEN_FILES (16)
#endif
 
#ifndef VFS_DIR_BUFFER_SIZE
 
#define VFS_DIR_BUFFER_SIZE MAX4(FATFS_VFS_DIR_BUFFER_SIZE,     \
                                 LITTLEFS_VFS_DIR_BUFFER_SIZE,  \
                                 LITTLEFS2_VFS_DIR_BUFFER_SIZE, \
                                 SPIFFS_VFS_DIR_BUFFER_SIZE     \
                                )
#endif
 
#ifndef VFS_FILE_BUFFER_SIZE
 
#define VFS_FILE_BUFFER_SIZE MAX4(FATFS_VFS_FILE_BUFFER_SIZE,    \
                                  LITTLEFS_VFS_FILE_BUFFER_SIZE, \
                                  LITTLEFS2_VFS_FILE_BUFFER_SIZE,\
                                  SPIFFS_VFS_FILE_BUFFER_SIZE    \
                                 )
#endif
 
#ifndef VFS_NAME_MAX
 
#define VFS_NAME_MAX (31)
#endif
 
#define VFS_ANY_FD (-1)
 
/* Forward declarations */
typedef struct vfs_file_ops vfs_file_ops_t;
 
typedef struct vfs_dir_ops vfs_dir_ops_t;
 
typedef struct vfs_file_system_ops vfs_file_system_ops_t;
 
/* not struct vfs_mount because of name collision with the function */
typedef struct vfs_mount_struct vfs_mount_t;
 
typedef struct {
    const vfs_file_ops_t *f_op;         
    const vfs_dir_ops_t *d_op;          
    const vfs_file_system_ops_t *fs_op; 
} vfs_file_system_t;
 
struct vfs_mount_struct {
    clist_node_t list_entry;     
    const vfs_file_system_t *fs; 
    const char *mount_point;     
    size_t mount_point_len;      
    atomic_int open_files;       
    void *private_data;          
};
 
typedef struct {
    const vfs_file_ops_t *f_op; 
    vfs_mount_t *mp;            
    int flags;                  
    off_t pos;                  
    kernel_pid_t pid;           
    union {
        void *ptr;              
        int value;              
        uint8_t buffer[VFS_FILE_BUFFER_SIZE]; 
    } private_data;             
} vfs_file_t;
 
typedef struct {
    const vfs_dir_ops_t *d_op; 
    vfs_mount_t *mp;           
    union {
        void *ptr;             
        int value;             
        uint8_t buffer[VFS_DIR_BUFFER_SIZE]; 
    } private_data;            
} vfs_DIR;
 
typedef struct {
    ino_t d_ino; 
    char  d_name[VFS_NAME_MAX + 1]; 
} vfs_dirent_t;
 
struct vfs_file_ops {
    int (*close) (vfs_file_t *filp);
 
    int (*fcntl) (vfs_file_t *filp, int cmd, int arg);
 
    int (*fstat) (vfs_file_t *filp, struct stat *buf);
 
    off_t (*lseek) (vfs_file_t *filp, off_t off, int whence);
 
    int (*open) (vfs_file_t *filp, const char *name, int flags, mode_t mode, const char *abs_path);
 
    ssize_t (*read) (vfs_file_t *filp, void *dest, size_t nbytes);
 
    ssize_t (*write) (vfs_file_t *filp, const void *src, size_t nbytes);
};
 
struct vfs_dir_ops {
    int (*opendir) (vfs_DIR *dirp, const char *dirname, const char *abs_path);
 
    int (*readdir) (vfs_DIR *dirp, vfs_dirent_t *entry);
 
    int (*closedir) (vfs_DIR *dirp);
};
 
struct vfs_file_system_ops {
    int (*format) (vfs_mount_t *mountp);
 
    int (*mount) (vfs_mount_t *mountp);
 
    int (*umount) (vfs_mount_t *mountp);
 
    int (*rename) (vfs_mount_t *mountp, const char *from_path, const char *to_path);
 
    int (*unlink) (vfs_mount_t *mountp, const char *name);
 
    int (*mkdir) (vfs_mount_t *mountp, const char *name, mode_t mode);
 
    int (*rmdir) (vfs_mount_t *mountp, const char *name);
 
    int (*stat) (vfs_mount_t *mountp, const char *restrict path, struct stat *restrict buf);
 
    int (*statvfs) (vfs_mount_t *mountp, const char *restrict path, struct statvfs *restrict buf);
 
    int (*fstatvfs) (vfs_mount_t *mountp, vfs_file_t *filp, struct statvfs *buf);
};
 
void vfs_bind_stdio(void);
 
int vfs_close(int fd);
 
int vfs_fcntl(int fd, int cmd, int arg);
 
int vfs_fstat(int fd, struct stat *buf);
 
int vfs_fstatvfs(int fd, struct statvfs *buf);
 
off_t vfs_lseek(int fd, off_t off, int whence);
 
int vfs_open(const char *name, int flags, mode_t mode);
 
ssize_t vfs_read(int fd, void *dest, size_t count);
 
ssize_t vfs_write(int fd, const void *src, size_t count);
 
int vfs_opendir(vfs_DIR *dirp, const char *dirname);
 
int vfs_readdir(vfs_DIR *dirp, vfs_dirent_t *entry);
 
int vfs_closedir(vfs_DIR *dirp);
 
int vfs_format(vfs_mount_t *mountp);
 
int vfs_mount(vfs_mount_t *mountp);
 
int vfs_rename(const char *from_path, const char *to_path);
 
int vfs_umount(vfs_mount_t *mountp);
 
int vfs_unlink(const char *name);
 
int vfs_mkdir(const char *name, mode_t mode);
 
int vfs_rmdir(const char *name);
 
int vfs_stat(const char *restrict path, struct stat *restrict buf);
 
int vfs_statvfs(const char *restrict path, struct statvfs *restrict buf);
 
int vfs_bind(int fd, int flags, const vfs_file_ops_t *f_op, void *private_data);
 
int vfs_normalize_path(char *buf, const char *path, size_t buflen);
 
const vfs_mount_t *vfs_iterate_mounts(const vfs_mount_t *cur);
 
const vfs_file_t *vfs_file_get(int fd);
 
int vfs_sysop_stat_from_fstat(vfs_mount_t *mountp,
        const char *restrict path,
        struct stat *restrict buf);
 
#ifdef __cplusplus
}
#endif
 
#endif /* VFS_H */