xf_vfs_types.h

浏览该文件的文档.

 
/*
 * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef __XF_VFS_TYPES_H__
#define __XF_VFS_TYPES_H__
 
/* ==================== [Includes] ========================================== */
 
#include "xf_vfs_config_internal.h"
 
#include "xf_vfs_sys__timeval.h"
#include "xf_vfs_sys_dirent.h"
#include "xf_vfs_sys_fcntl.h"
#include "xf_vfs_sys_select.h"
#include "xf_vfs_sys_stat.h"
#include "xf_vfs_sys_types.h"
#include "xf_vfs_sys_unistd.h"
#include "xf_vfs_sys_utime.h"
 
#if XF_VFS_SUPPORT_SELECT_IS_ENABLE
#include "xf_osal.h"
#endif // XF_VFS_SUPPORT_SELECT_IS_ENABLE
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ==================== [Defines] =========================================== */
 
/* special length value for VFS which is never recognised by open() */
#define XF_VFS_PATH_PREFIX_LEN_IGNORED  (~(size_t)0)
 
#define XF_VFS_FLAG_DEFAULT             (1 << 0)
 
#define XF_VFS_FLAG_CONTEXT_PTR         (1 << 1)
 
#define XF_VFS_FLAG_READONLY_FS         (1 << 2)
 
#define XF_VFS_FLAG_STATIC              (1 << 3)
 
/* ==================== [Typedefs] ========================================== */
 
#if XF_VFS_SUPPORT_SELECT_IS_ENABLE
typedef struct {
    bool is_sem_local;      
    void *sem;              
} xf_vfs_select_sem_t;
#endif // XF_VFS_SUPPORT_SELECT_IS_ENABLE
 
/*
 * @brief VFS identificator used for xf_vfs_register_with_id()
 */
typedef int xf_vfs_id_t;
 
/* *INDENT-OFF* */
 
typedef struct
{
    int flags;      
    union {
        xf_vfs_ssize_t (*write_p)(void* p, int fd, const void * data, size_t size);                         
        xf_vfs_ssize_t (*write)(int fd, const void * data, size_t size);                                    
    };
    union {
        xf_vfs_off_t (*lseek_p)(void* p, int fd, xf_vfs_off_t size, int mode);                              
        xf_vfs_off_t (*lseek)(int fd, xf_vfs_off_t size, int mode);                                         
    };
    union {
        xf_vfs_ssize_t (*read_p)(void* ctx, int fd, void * dst, size_t size);                               
        xf_vfs_ssize_t (*read)(int fd, void * dst, size_t size);                                            
    };
    union {
        xf_vfs_ssize_t (*pread_p)(void *ctx, int fd, void * dst, size_t size, xf_vfs_off_t offset);         
        xf_vfs_ssize_t (*pread)(int fd, void * dst, size_t size, xf_vfs_off_t offset);                      
    };
    union {
        xf_vfs_ssize_t (*pwrite_p)(void *ctx, int fd, const void *src, size_t size, xf_vfs_off_t offset);   
        xf_vfs_ssize_t (*pwrite)(int fd, const void *src, size_t size, xf_vfs_off_t offset);                
    };
    union {
        int (*open_p)(void* ctx, const char * path, int flags, int mode);                           
        int (*open)(const char * path, int flags, int mode);                                        
    };
    union {
        int (*close_p)(void* ctx, int fd);                                                          
        int (*close)(int fd);                                                                       
    };
    union {
        int (*fstat_p)(void* ctx, int fd, xf_vfs_stat_t * st);                                      
        int (*fstat)(int fd, xf_vfs_stat_t * st);                                                   
    };
#if XF_VFS_SUPPORT_DIR_IS_ENABLE
    union {
        int (*stat_p)(void* ctx, const char * path, xf_vfs_stat_t * st);                            
        int (*stat)(const char * path, xf_vfs_stat_t * st);                                         
    };
    union {
        int (*link_p)(void* ctx, const char* n1, const char* n2);                                   
        int (*link)(const char* n1, const char* n2);                                                
    };
    union {
        int (*unlink_p)(void* ctx, const char *path);                                               
        int (*unlink)(const char *path);                                                            
    };
    union {
        int (*rename_p)(void* ctx, const char *src, const char *dst);                               
        int (*rename)(const char *src, const char *dst);                                            
    };
    union {
        xf_vfs_dir_t* (*opendir_p)(void* ctx, const char* name);                                    
        xf_vfs_dir_t* (*opendir)(const char* name);                                                 
    };
    union {
        xf_vfs_dirent_t* (*readdir_p)(void* ctx, xf_vfs_dir_t* pdir);                               
        xf_vfs_dirent_t* (*readdir)(xf_vfs_dir_t* pdir);                                            
    };
    union {
        int (*readdir_r_p)(void* ctx, xf_vfs_dir_t* pdir, xf_vfs_dirent_t* entry, xf_vfs_dirent_t** out_dirent); 
        int (*readdir_r)(xf_vfs_dir_t* pdir, xf_vfs_dirent_t* entry, xf_vfs_dirent_t** out_dirent);              
    };
    union {
        long (*telldir_p)(void* ctx, xf_vfs_dir_t* pdir);                                           
        long (*telldir)(xf_vfs_dir_t* pdir);                                                        
    };
    union {
        void (*seekdir_p)(void* ctx, xf_vfs_dir_t* pdir, long offset);                              
        void (*seekdir)(xf_vfs_dir_t* pdir, long offset);                                           
    };
    union {
        int (*closedir_p)(void* ctx, xf_vfs_dir_t* pdir);                                           
        int (*closedir)(xf_vfs_dir_t* pdir);                                                        
    };
    union {
        int (*mkdir_p)(void* ctx, const char* name, xf_vfs_mode_t mode);                            
        int (*mkdir)(const char* name, xf_vfs_mode_t mode);                                         
    };
    union {
        int (*rmdir_p)(void* ctx, const char* name);                                                
        int (*rmdir)(const char* name);                                                             
    };
#endif // CONFIG_XF_VFS_SUPPORT_DIR
    union {
        int (*fcntl_p)(void* ctx, int fd, int cmd, int arg);                                        
        int (*fcntl)(int fd, int cmd, int arg);                                                     
    };
    union {
        int (*ioctl_p)(void* ctx, int fd, int cmd, va_list args);                                   
        int (*ioctl)(int fd, int cmd, va_list args);                                                
    };
    union {
        int (*fsync_p)(void* ctx, int fd);                                                          
        int (*fsync)(int fd);                                                                       
    };
#if XF_VFS_SUPPORT_DIR_IS_ENABLE
    union {
        int (*access_p)(void* ctx, const char *path, int amode);                                    
        int (*access)(const char *path, int amode);                                                 
    };
    union {
        int (*truncate_p)(void* ctx, const char *path, xf_vfs_off_t length);                        
        int (*truncate)(const char *path, xf_vfs_off_t length);                                     
    };
    union {
        int (*ftruncate_p)(void* ctx, int fd, xf_vfs_off_t length);                                 
        int (*ftruncate)(int fd, xf_vfs_off_t length);                                              
    };
    union {
        int (*utime_p)(void* ctx, const char *path, const xf_vfs_utimbuf_t *times);                   
        int (*utime)(const char *path, const xf_vfs_utimbuf_t *times);                                
    };
#endif // CONFIG_XF_VFS_SUPPORT_DIR
#if XF_VFS_SUPPORT_SELECT_IS_ENABLE || defined __DOXYGEN__
    xf_err_t (*start_select)(int nfds, xf_fd_set *readfds, xf_fd_set *writefds, xf_fd_set *exceptfds, xf_vfs_select_sem_t sem, void **end_select_args);
    int (*socket_select)(int nfds, xf_fd_set *readfds, xf_fd_set *writefds, xf_fd_set *errorfds, xf_vfs_timeval_t *timeout);
    void (*stop_socket_select)(void *sem);
    void (*stop_socket_select_isr)(void *sem, int *woken);
    void* (*get_socket_select_semaphore)(void);
    xf_err_t (*end_select)(void *end_select_args);
#endif // XF_VFS_SUPPORT_SELECT_IS_ENABLE || defined __DOXYGEN__
} xf_vfs_t;
 
/* *INDENT-ON* */
 
#if XF_VFS_SUPPORT_SELECT_IS_ENABLE
/* *INDENT-OFF* */
 
typedef  xf_err_t  (*xf_vfs_start_select_op_t)                (int nfds, xf_fd_set *readfds, xf_fd_set *writefds, xf_fd_set *exceptfds, xf_vfs_select_sem_t sem, void **end_select_args);
typedef       int  (*xf_vfs_socket_select_op_t)               (int nfds, xf_fd_set *readfds, xf_fd_set *writefds, xf_fd_set *errorfds, xf_vfs_timeval_t *timeout);
typedef      void  (*xf_vfs_stop_socket_select_op_t)          (void *sem);
typedef      void  (*xf_vfs_stop_socket_select_isr_op_t)      (void *sem, int *woken);
typedef      void* (*xf_vfs_get_socket_select_semaphore_op_t) (void);
typedef  xf_err_t  (*xf_vfs_end_select_op_t)                  (void *end_select_args);
 
typedef struct {
    const xf_vfs_start_select_op_t                start_select;
 
    const xf_vfs_socket_select_op_t               socket_select;
 
    const xf_vfs_stop_socket_select_op_t          stop_socket_select;
 
    const xf_vfs_stop_socket_select_isr_op_t      stop_socket_select_isr;
 
    const xf_vfs_get_socket_select_semaphore_op_t get_socket_select_semaphore;
 
    const xf_vfs_end_select_op_t                  end_select;
} xf_vfs_select_ops_t;
 
/* *INDENT-ON* */
#endif // XF_VFS_SUPPORT_SELECT_IS_ENABLE
 
/* ==================== [Global Prototypes] ================================= */
 
/* ==================== [Macros] ============================================ */
 
#ifdef __cplusplus
} /* extern "C" */
#endif
 
#endif /* __XF_VFS_TYPES_H__ */