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.
 */
 
#pragma once
 
#include <stdint.h>
#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"
#include "iolist.h"
#include "macros/utils.h"
#include "mtd.h"
#ifdef MODULE_NANOCOAP_FS
#include "net/sock/config.h"
#endif
#include "xfa.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 MAX6
#define MAX6(a, b, c, d, e, f) MAX(MAX(MAX(MAX((a), (b)), MAX((c), (d))), (e)), (f))
#endif
 
#ifdef MODULE_FATFS_VFS
#include "ffconf.h"
 
#  if FF_FS_TINY
#    define _FATFS_FILE_CACHE              (0)
#  else
#    define _FATFS_FILE_CACHE              FF_MAX_SS
#  endif
 
#  if FF_USE_FASTSEEK
#    if (__SIZEOF_POINTER__ == 8)
#      define _FATFS_FILE_SEEK_PTR         (8)
#    else
#      define _FATFS_FILE_SEEK_PTR         (4)
#    endif
#  else
#    define _FATFS_FILE_SEEK_PTR           (0)
#  endif
 
#  if FF_FS_EXFAT
#    define _FATFS_FILE_EXFAT              (48)
#    define _FATFS_DIR_EXFAT               (32)
#  else
#    define _FATFS_FILE_EXFAT              (0)
#    define _FATFS_DIR_EXFAT               (0)
#  endif
 
#  if FF_USE_LFN
#    if (__SIZEOF_POINTER__ == 8)
#      define _FATFS_DIR_LFN               (8)
#    else
#      define _FATFS_DIR_LFN               (4)
#    endif
#  else
#    define _FATFS_DIR_LFN                 (0)
#  endif
 
#  if (__SIZEOF_POINTER__ == 8)
#    define FATFS_VFS_DIR_BUFFER_SIZE      (64 + _FATFS_DIR_LFN + _FATFS_DIR_EXFAT)
#    define FATFS_VFS_FILE_BUFFER_SIZE     (64 + VFS_NAME_MAX + _FATFS_FILE_CACHE + \
                                           _FATFS_FILE_SEEK_PTR + _FATFS_FILE_EXFAT)
#  else
#    define FATFS_VFS_DIR_BUFFER_SIZE      (44 + _FATFS_DIR_LFN + _FATFS_DIR_EXFAT)
#    define FATFS_VFS_FILE_BUFFER_SIZE     (44 + VFS_NAME_MAX + _FATFS_FILE_CACHE + \
                                           _FATFS_FILE_SEEK_PTR + _FATFS_FILE_EXFAT)
#  endif
#else
#  define FATFS_VFS_DIR_BUFFER_SIZE        (1)
#  define FATFS_VFS_FILE_BUFFER_SIZE       (1)
#endif
#ifdef MODULE_LITTLEFS
#  if (__SIZEOF_POINTER__ == 8)
#    define LITTLEFS_VFS_DIR_BUFFER_SIZE   (48)
#    define LITTLEFS_VFS_FILE_BUFFER_SIZE  (72)
#  else
#    define LITTLEFS_VFS_DIR_BUFFER_SIZE   (44)
#    define LITTLEFS_VFS_FILE_BUFFER_SIZE  (56)
#  endif
#else
#  define LITTLEFS_VFS_DIR_BUFFER_SIZE     (1)
#  define LITTLEFS_VFS_FILE_BUFFER_SIZE    (1)
#endif
#ifdef MODULE_LITTLEFS2
#  if (__SIZEOF_POINTER__ == 8)
#    define LITTLEFS2_VFS_DIR_BUFFER_SIZE  (56)
#    define LITTLEFS2_VFS_FILE_BUFFER_SIZE (104)
#  else
#    define LITTLEFS2_VFS_DIR_BUFFER_SIZE  (52)
#    define LITTLEFS2_VFS_FILE_BUFFER_SIZE (84)
#  endif
#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
#if defined(MODULE_LWEXT4) || DOXYGEN
#  define LWEXT4_VFS_DIR_BUFFER_SIZE       (308)   
#  define LWEXT4_VFS_FILE_BUFFER_SIZE      (32)    
#else
#  define LWEXT4_VFS_DIR_BUFFER_SIZE       (1)
#  define LWEXT4_VFS_FILE_BUFFER_SIZE      (1)
#endif
#if defined(MODULE_NANOCOAP_FS) || DOXYGEN
#  define NANOCOAP_FS_VFS_DIR_BUFFER_SIZE  \
          (4 + CONFIG_SOCK_URLPATH_MAXLEN) 
#  define NANOCOAP_FS_VFS_FILE_BUFFER_SIZE \
          (4 + CONFIG_SOCK_URLPATH_MAXLEN) 
#else
#  define NANOCOAP_FS_VFS_DIR_BUFFER_SIZE   (1)
#  define NANOCOAP_FS_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 MAX6(FATFS_VFS_DIR_BUFFER_SIZE,      \
                                 LITTLEFS_VFS_DIR_BUFFER_SIZE,   \
                                 LITTLEFS2_VFS_DIR_BUFFER_SIZE,  \
                                 SPIFFS_VFS_DIR_BUFFER_SIZE,     \
                                 LWEXT4_VFS_DIR_BUFFER_SIZE,     \
                                 NANOCOAP_FS_VFS_DIR_BUFFER_SIZE \
                                )
#endif
 
#ifndef VFS_FILE_BUFFER_SIZE
#define VFS_FILE_BUFFER_SIZE MAX6(FATFS_VFS_FILE_BUFFER_SIZE,      \
                                  LITTLEFS_VFS_FILE_BUFFER_SIZE,   \
                                  LITTLEFS2_VFS_FILE_BUFFER_SIZE,  \
                                  SPIFFS_VFS_FILE_BUFFER_SIZE,     \
                                  LWEXT4_VFS_FILE_BUFFER_SIZE,     \
                                  NANOCOAP_FS_VFS_FILE_BUFFER_SIZE \
                                 )
#endif
 
#ifndef VFS_NAME_MAX
#define VFS_NAME_MAX (31)
#endif
 
#define VFS_ANY_FD (-1)
 
#define VFS_MTD(mtd) { .dev = &mtd.base }
 
#define VFS_AUTO_MOUNT(type, mtd, path, idx)        \
    static type ## _desc_t fs_desc_ ## idx = mtd;   \
                                                    \
    XFA(vfs_mount_t, vfs_mountpoints_xfa, 0)        \
    _mount_mtd_ ## idx = {                          \
        .fs = &type ## _file_system,                \
        .mount_point = path,                        \
        .private_data = &fs_desc_ ## idx,           \
    }
 
/* 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;
 
extern const vfs_file_ops_t mtd_vfs_ops;
 
#define VFS_FS_FLAG_WANT_ABS_PATH   (1 << 0)
 
typedef struct {
    const vfs_file_ops_t *f_op;         
    const vfs_dir_ops_t *d_op;          
    const vfs_file_system_ops_t *fs_op; 
    const uint32_t flags;               
} 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;      
    uint16_t 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);
 
    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);
 
    int (*fsync) (vfs_file_t *filp);
};
 
struct vfs_dir_ops {
    int (*opendir) (vfs_DIR *dirp, const char *dirname);
 
    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);
};
 
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);
 
int vfs_dstatvfs(vfs_DIR *dirp, 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_readline(int fd, char *dest, size_t count);
 
ssize_t vfs_write(int fd, const void *src, size_t count);
 
ssize_t vfs_write_iol(int fd, const iolist_t *iolist);
 
int vfs_fsync(int fd);
 
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_format_by_path(const char *path);
 
int vfs_mount(vfs_mount_t *mountp);
 
int vfs_mount_by_path(const char *path);
 
int vfs_unmount_by_path(const char *path, bool force);
 
int vfs_rename(const char *from_path, const char *to_path);
 
int vfs_umount(vfs_mount_t *mountp, bool force);
 
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);
 
bool vfs_iterate_mount_dirs(vfs_DIR *dir);
 
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