espressif/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2026-04-27 19:13:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'feat/vfs_remove_old_api' into 'master'

Browse Source 
feat(storage/vfs): v6 API breaking changes

Closes DOC-13273

See merge request espressif/esp-idf!42182
This commit is contained in:
Tomas Rohlinek
2025-12-17 20:21:27 +01:00
parent 6ec20a9264 cd8351a620
commit 203c4da5f8
29 changed files with 1388 additions and 1231 deletions
Download Patch File Download Diff File Expand all files Collapse all files
components/bt/host/bluedroid/btc/profile/std/l2cap/btc_l2cap.c
+2 -6
View File
@@ -1252,19 +1252,15 @@ static void btc_l2cap_vfs_register(void)
break;
}
esp_vfs_t vfs = {
.flags = ESP_VFS_FLAG_DEFAULT,
static const esp_vfs_fs_ops_t vfs = {
.write = l2cap_vfs_write,
.open = NULL,
.fstat = NULL,
.close = l2cap_vfs_close,
.read = l2cap_vfs_read,
.fcntl = NULL
};
// No FD range is registered here: l2cap_vfs_id is used to register/unregister
// file descriptors
if (esp_vfs_register_with_id(&vfs, NULL, &l2cap_local_param.l2cap_vfs_id) != ESP_OK) {
if (esp_vfs_register_fs_with_id(&vfs, ESP_VFS_FLAG_STATIC, NULL, &l2cap_local_param.l2cap_vfs_id) != ESP_OK) {
ret = ESP_BT_L2CAP_FAILURE;
break;
}
components/bt/host/bluedroid/btc/profile/std/spp/btc_spp.c
+2 -6
View File
@@ -1659,19 +1659,15 @@ static void btc_spp_vfs_register(void)
break;
}
esp_vfs_t vfs = {
.flags = ESP_VFS_FLAG_DEFAULT,
static const esp_vfs_fs_ops_t vfs = {
.write = spp_vfs_write,
.open = NULL,
.fstat = NULL,
.close = spp_vfs_close,
.read = spp_vfs_read,
.fcntl = NULL
};
// No FD range is registered here: spp_vfs_id is used to register/unregister
// file descriptors
if (esp_vfs_register_with_id(&vfs, NULL, &spp_local_param.spp_vfs_id) != ESP_OK) {
if (esp_vfs_register_fs_with_id(&vfs, ESP_VFS_FLAG_STATIC, NULL, &spp_local_param.spp_vfs_id) != ESP_OK) {
ret = ESP_SPP_FAILURE;
break;
}
components/esp_driver_uart/include/driver/esp_private/uart_vfs.h
+1 -1
View File
@@ -18,7 +18,7 @@ extern "C" {
* This function is called in vfs_console in order to get the vfs implementation
* of uart.
*
* @return pointer to structure esp_vfs_t
* @return pointer to structure esp_vfs_fs_ops_t
*/
const esp_vfs_fs_ops_t *esp_vfs_uart_get_vfs(void);
components/esp_driver_usb_serial_jtag/include/driver/esp_private/usb_serial_jtag_vfs.h
+1 -1
View File
@@ -18,7 +18,7 @@ extern "C" {
* This function is called in vfs_console in order to get the vfs implementation
* of usb_serial_jtag.
*
* @return pointer to structure esp_vfs_t
* @return pointer to structure esp_vfs_fs_ops_t
*/
const esp_vfs_fs_ops_t *esp_vfs_usb_serial_jtag_get_vfs(void);
components/esp_libc/test_apps/newlib/main/test_file.c
+3 -5
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Unlicense OR CC0-1.0
*/
@@ -47,14 +47,12 @@ TEST_CASE("file - blksize", "[newlib_file]")
FILE* f;
blksize_test_ctx_t ctx = {};
const char c = 42;
const esp_vfs_t desc = {
.flags = ESP_VFS_FLAG_CONTEXT_PTR,
static const esp_vfs_fs_ops_t desc = {
.open_p = blksize_test_open,
.fstat_p = blksize_test_fstat,
.write_p = blksize_test_write,
};
TEST_ESP_OK(esp_vfs_register("/test", &desc, &ctx));
TEST_ESP_OK(esp_vfs_register_fs("/test", &desc, ESP_VFS_FLAG_CONTEXT_PTR | ESP_VFS_FLAG_STATIC, &ctx));
/* test with zero st_blksize (=not set) */
ctx.blksize = 0;
components/esp_libc/test_apps/newlib/main/test_misc.c
+7 -4
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2021-2023 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2021-2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@@ -153,14 +153,17 @@ TEST_CASE("file - scandir", "[newlib_misc]")
scandir_test_dir_context_t scandir_test_dir_ctx = { .filenames = test_filenames, .num_files = num_test_files };
const esp_vfs_t scandir_test_vfs = {
.flags = ESP_VFS_FLAG_CONTEXT_PTR,
static const esp_vfs_dir_ops_t dir_ops = {
.opendir_p = scandir_test_opendir,
.readdir_p = scandir_test_readdir,
.closedir_p = scandir_test_closedir
};
TEST_ESP_OK(esp_vfs_register("/data", &scandir_test_vfs, &scandir_test_dir_ctx));
static const esp_vfs_fs_ops_t fs_ops = {
.dir = &dir_ops,
};
TEST_ESP_OK(esp_vfs_register_fs("/data", &fs_ops, ESP_VFS_FLAG_CONTEXT_PTR | ESP_VFS_FLAG_STATIC, &scandir_test_dir_ctx));
struct dirent **namelist;
s_select_calls = 0;
components/esp_usb_cdc_rom_console/include/esp_private/esp_vfs_cdcacm.h
+1 -1
View File
@@ -18,7 +18,7 @@ extern "C" {
* This function is called in vfs_console in order to get the vfs implementation
* of cdcacm.
*
* @return pointer to structure esp_vfs_t
* @return pointer to structure esp_vfs_fs_ops_t
*/
const esp_vfs_fs_ops_t *esp_vfs_cdcacm_get_vfs(void);
components/fatfs/vfs/vfs_fat_spiflash.c
+1 -1
View File
@@ -23,7 +23,7 @@ static const char* TAG = "vfs_fat_spiflash";
static vfs_fat_spiflash_ctx_t *s_ctx[FF_VOLUMES] = {};
extern esp_err_t esp_vfs_set_readonly_flag(const char* base_path); // from vfs/vfs.c to set readonly flag in esp_vfs_t struct externally
extern esp_err_t esp_vfs_set_readonly_flag(const char* base_path); // from vfs/vfs.c to set readonly flag externally
static bool s_get_context_id_by_label(const char *label, uint32_t *out_id)
{
components/lwip/port/esp32xx/vfs_lwip.c
+31 -17
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2017-2022 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2017-2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@@ -13,6 +13,7 @@
#include <sys/select.h>
#include "esp_attr.h"
#include "esp_vfs.h"
#include "esp_private/socket.h"
#include "sdkconfig.h"
#include "lwip/sockets.h"
#include "lwip/sys.h"
@@ -88,26 +89,39 @@ static int lwip_fstat(int fd, struct stat * st)
void esp_vfs_lwip_sockets_register(void)
{
esp_vfs_t vfs = {
.flags = ESP_VFS_FLAG_DEFAULT,
.write = &lwip_write,
.open = NULL,
.fstat = &lwip_fstat,
.close = &lwip_close,
.read = &lwip_read,
.fcntl = &lwip_fcntl_r_wrapper,
.ioctl = &lwip_ioctl_r_wrapper,
#ifdef CONFIG_VFS_SUPPORT_SELECT
static const esp_vfs_select_ops_t s_lwip_select_ops = {
.socket_select = &lwip_select,
.get_socket_select_semaphore = &lwip_get_socket_select_semaphore,
.stop_socket_select = &lwip_stop_socket_select,
.stop_socket_select_isr = &lwip_stop_socket_select_isr,
#endif // CONFIG_VFS_SUPPORT_SELECT
.get_socket_select_semaphore = &lwip_get_socket_select_semaphore,
};
/* Non-LWIP file descriptors are from 0 to (LWIP_SOCKET_OFFSET-1). LWIP
* file descriptors are registered from LWIP_SOCKET_OFFSET to
* MAX_FDS-1.
*/
ESP_ERROR_CHECK(esp_vfs_register_fd_range(&vfs, NULL, LWIP_SOCKET_OFFSET, MAX_FDS));
#endif
static const esp_vfs_fs_ops_t s_lwip_vfs = {
.write = &lwip_write,
.read = &lwip_read,
.close = &lwip_close,
.fstat = &lwip_fstat,
.fcntl = &lwip_fcntl_r_wrapper,
.ioctl = &lwip_ioctl_r_wrapper,
#ifdef CONFIG_VFS_SUPPORT_SELECT
.select = &s_lwip_select_ops,
#endif
};
/* Non-LWIP file descriptors are from 0 to (LWIP_SOCKET_OFFSET-1).
* LWIP file descriptors are registered from LWIP_SOCKET_OFFSET to MAX_FDS-1.
*
* Use ESP_VFS_FLAG_STATIC since s_lwip_vfs and subcomponents are static.
* No context pointer needed -> flags have no ESP_VFS_FLAG_CONTEXT_PTR.
*/
ESP_ERROR_CHECK(esp_vfs_register_fd_range(&s_lwip_vfs,
ESP_VFS_FLAG_STATIC,
NULL /* ctx */,
LWIP_SOCKET_OFFSET,
MAX_FDS));
}
components/vfs/CMakeLists.txt
+2 -1
View File
@@ -7,7 +7,7 @@ if(${target} STREQUAL "linux")
if(CONFIG_VFS_SUPPORT_IO)
list(APPEND inc linux_include)
list(APPEND priv_inc private_include)
list(APPEND srcs "vfs_linux.c" "vfs.c")
list(APPEND srcs "vfs_linux.c" "vfs.c" "vfs_calls.c")
endif()
if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
@@ -36,6 +36,7 @@ if(IDF_BUILD_V2)
endif()
list(APPEND sources "vfs.c"
"vfs_calls.c"
"vfs_eventfd.c"
"vfs_semihost.c"
"nullfs.c"
components/vfs/include/esp_private/socket.h
+34
View File
@@ -0,0 +1,34 @@
/*
* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
#include "esp_vfs.h"
#include "esp_err.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* Special case function for registering a VFS that uses a method other than
* open() to open new file descriptors from the interval <min_fd; max_fd).
*
* This is a special-purpose function intended for registering LWIP sockets to VFS.
*
* @param vfs Pointer to esp_vfs_fs_ops_t. Meaning is the same as for esp_vfs_register_fs().
* @param ctx Pointer to context structure. Meaning is the same as for esp_vfs_register_fs().
* @param min_fd The smallest file descriptor this VFS will use.
* @param max_fd Upper boundary for file descriptors this VFS will use (the biggest file descriptor plus one).
*
* @return ESP_OK if successful,
* ESP_ERR_NO_MEM if too many VFSes are registered,
* ESP_ERR_INVALID_ARG if the file descriptor boundaries are incorrect.
*/
esp_err_t esp_vfs_register_fd_range(const esp_vfs_fs_ops_t *vfs, int flags, void *ctx, int min_fd, int max_fd);
#ifdef __cplusplus
}
#endif
components/vfs/include/esp_vfs.h
+3 -21
View File
@@ -48,7 +48,7 @@ extern "C" {
#define ESP_VFS_PATH_MAX 15
/**
* Default value of flags member in esp_vfs_t structure.
* Default value of flags member in esp_vfs_fs_ops_t structure.
*/
#define ESP_VFS_FLAG_DEFAULT (1 << 0)
@@ -70,6 +70,7 @@ extern "C" {
/**
* @brief VFS definition structure
* @note Prefer using esp_vfs_fs_ops_t with esp_vfs_register_fs*() instead.
*
* This structure should be filled with pointers to corresponding
* FS driver functions.
@@ -250,8 +251,6 @@ typedef struct
#endif // CONFIG_VFS_SUPPORT_SELECT || defined __DOXYGEN__
} esp_vfs_t;
/**
* Register a virtual filesystem for given path prefix.
*
@@ -277,23 +276,6 @@ typedef struct
*/
esp_err_t esp_vfs_register(const char* base_path, const esp_vfs_t* vfs, void* ctx);
/**
* Special case function for registering a VFS that uses a method other than
* open() to open new file descriptors from the interval <min_fd; max_fd).
*
* This is a special-purpose function intended for registering LWIP sockets to VFS.
*
* @param vfs Pointer to esp_vfs_t. Meaning is the same as for esp_vfs_register().
* @param ctx Pointer to context structure. Meaning is the same as for esp_vfs_register().
* @param min_fd The smallest file descriptor this VFS will use.
* @param max_fd Upper boundary for file descriptors this VFS will use (the biggest file descriptor plus one).
*
* @return ESP_OK if successful, ESP_ERR_NO_MEM if too many VFSes are
* registered, ESP_ERR_INVALID_ARG if the file descriptor boundaries
* are incorrect.
*/
esp_err_t esp_vfs_register_fd_range(const esp_vfs_t *vfs, void *ctx, int min_fd, int max_fd);
/**
* Special case function for registering a VFS that uses a method other than
* open() to open new file descriptors. In comparison with
@@ -310,7 +292,7 @@ esp_err_t esp_vfs_register_fd_range(const esp_vfs_t *vfs, void *ctx, int min_fd,
* registered, ESP_ERR_INVALID_ARG if the file descriptor boundaries
* are incorrect.
*/
esp_err_t esp_vfs_register_with_id(const esp_vfs_t *vfs, void *ctx, esp_vfs_id_t *vfs_id);
esp_err_t esp_vfs_register_with_id(const esp_vfs_t *vfs, void *ctx, esp_vfs_id_t *vfs_id) __attribute__((deprecated("Use esp_vfs_register_fs_with_id() instead")));
/**
* Unregister a virtual filesystem for given path prefix
components/vfs/linker.lf
+3 -1
View File
@@ -2,4 +2,6 @@
archive: libvfs.a
entries:
if VFS_SELECT_IN_RAM = y:
vfs:esp_vfs_select_triggered_isr (noflash)
vfs_calls:esp_vfs_select_triggered_isr (noflash)
vfs:get_vfs_count (noflash)
vfs:start_select (noflash)
components/vfs/private_include/esp_vfs_private.h
+49
View File
@@ -18,6 +18,14 @@ extern "C" {
#define VFS_MALLOC_FLAGS MALLOC_CAP_DEFAULT
#endif
#ifdef CONFIG_IDF_TARGET_LINUX
typedef uint16_t local_fd_t;
#else
typedef uint8_t local_fd_t;
#endif
typedef int8_t vfs_index_t;
typedef struct vfs_entry_ {
int flags; /*!< ESP_VFS_FLAG_CONTEXT_PTR and/or ESP_VFS_FLAG_READONLY_FS or ESP_VFS_FLAG_DEFAULT */
const esp_vfs_fs_ops_t *vfs; /*!< contains pointers to VFS functions */
@@ -27,6 +35,22 @@ typedef struct vfs_entry_ {
const char path_prefix[]; /*!< path prefix mapped to this VFS */
} vfs_entry_t;
typedef struct {
bool permanent :1;
bool has_pending_close :1;
bool has_pending_select :1;
uint8_t _reserved :5;
vfs_index_t vfs_index;
local_fd_t local_fd;
} fd_table_t;
typedef struct {
bool isset; // none or at least one bit is set in the following 3 fd sets
fd_set readfds;
fd_set writefds;
fd_set errorfds;
} fds_triple_t;
/**
* Register a virtual filesystem.
*
@@ -73,6 +97,31 @@ const vfs_entry_t *get_vfs_for_path(const char *path);
*/
const vfs_entry_t *get_vfs_for_index(int index);
const char* translate_path(const vfs_entry_t* vfs, const char* src_path);
const vfs_entry_t* get_vfs_for_path(const char* path);
const vfs_entry_t *get_vfs_for_fd(int fd);
int register_fd(int vfs_index, int local_fd, bool permanent);
void unregister_fd(int fd);
int get_local_fd(const vfs_entry_t *vfs, int fd);
const fd_table_t *get_fd_entry(int fd);
size_t get_vfs_count(void);
void close_pending(int nfds);
static inline bool esp_vfs_safe_fd_isset(int fd, const fd_set *fds)
{
return fds && FD_ISSET(fd, fds);
}
fd_table_t start_select(int fd, fd_set *errorfds);
#ifdef __cplusplus
}
#endif
components/vfs/private_include/esp_vfs_utils.h
+90
View File
@@ -0,0 +1,90 @@
/*
* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
/*
* Using huge multi-line macros is never nice, but in this case
* the only alternative is to repeat this chunk of code (with different function names)
* for each syscall being implemented. Given that this define is contained within a single
* file, this looks like a good tradeoff.
*
* First we check if syscall is implemented by VFS (corresponding member is not NULL),
* then call the right flavor of the method (e.g. open or open_p) depending on
* ESP_VFS_FLAG_CONTEXT_PTR flag. If ESP_VFS_FLAG_CONTEXT_PTR is set, context is passed
* in as first argument and _p variant is used for the call.
* It is enough to check just one of them for NULL, as both variants are part of a union.
*/
#define CHECK_AND_CALL(ret, r, pvfs, func, ...) \
if (pvfs->vfs->func == NULL) { \
__errno_r(r) = ENOSYS; \
return -1; \
} \
if (pvfs->flags & ESP_VFS_FLAG_CONTEXT_PTR) { \
ret = (*pvfs->vfs->func ## _p)(pvfs->ctx, __VA_ARGS__); \
} else { \
ret = (*pvfs->vfs->func)(__VA_ARGS__);\
}
#define CHECK_AND_CALL_SUBCOMPONENT(ret, r, pvfs, component, func, ...) \
if (pvfs->vfs->component == NULL || pvfs->vfs->component->func == NULL) { \
__errno_r(r) = ENOSYS; \
return -1; \
} \
if (pvfs->flags & ESP_VFS_FLAG_CONTEXT_PTR) { \
ret = (*pvfs->vfs->component->func ## _p)(pvfs->ctx, __VA_ARGS__); \
} else { \
ret = (*pvfs->vfs->component->func)(__VA_ARGS__);\
}
#define CHECK_AND_CALLV(r, pvfs, func, ...) \
if (pvfs->vfs->func == NULL) { \
__errno_r(r) = ENOSYS; \
return; \
} \
if (pvfs->flags & ESP_VFS_FLAG_CONTEXT_PTR) { \
(*pvfs->vfs->func ## _p)(pvfs->ctx, __VA_ARGS__); \
} else { \
(*pvfs->vfs->func)(__VA_ARGS__);\
}
#define CHECK_AND_CALL_SUBCOMPONENTV(r, pvfs, component, func, ...) \
if (pvfs->vfs->component == NULL || pvfs->vfs->component->func == NULL) { \
__errno_r(r) = ENOSYS; \
return; \
} \
if (pvfs->flags & ESP_VFS_FLAG_CONTEXT_PTR) { \
(*pvfs->vfs->component->func ## _p)(pvfs->ctx, __VA_ARGS__); \
} else { \
(*pvfs->vfs->component->func)(__VA_ARGS__);\
}
#define CHECK_AND_CALLP(ret, r, pvfs, func, ...) \
if (pvfs->vfs->func == NULL) { \
__errno_r(r) = ENOSYS; \
return NULL; \
} \
if (pvfs->flags & ESP_VFS_FLAG_CONTEXT_PTR) { \
ret = (*pvfs->vfs->func ## _p)(pvfs->ctx, __VA_ARGS__); \
} else { \
ret = (*pvfs->vfs->func)(__VA_ARGS__);\
}
#define CHECK_AND_CALL_SUBCOMPONENTP(ret, r, pvfs, component, func, ...) \
if (pvfs->vfs->component == NULL || pvfs->vfs->component->func == NULL) { \
__errno_r(r) = ENOSYS; \
return NULL; \
} \
if (pvfs->flags & ESP_VFS_FLAG_CONTEXT_PTR) { \
ret = (*pvfs->vfs->component->func ## _p)(pvfs->ctx, __VA_ARGS__); \
} else { \
ret = (*pvfs->vfs->component->func)(__VA_ARGS__);\
}
#define CHECK_VFS_READONLY_FLAG(flags) \
if (flags & ESP_VFS_FLAG_READONLY_FS) { \
__errno_r(r) = EROFS; \
return -1; \
}
components/vfs/test_apps/main/test_vfs_fd.c
+13 -16
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2015-2024 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@@ -15,6 +15,7 @@
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "esp_vfs.h"
#include "esp_private/socket.h"
#include "unity.h"
#include "esp_log.h"
#include "test_utils.h"
@@ -60,13 +61,12 @@ TEST_CASE("FDs from different VFSs don't collide", "[vfs]")
.fd = 1,
};
esp_vfs_t desc = {
.flags = ESP_VFS_FLAG_CONTEXT_PTR,
esp_vfs_fs_ops_t desc = {
.open_p = collision_test_vfs_open,
.close_p = collision_test_vfs_close,
};
TEST_ESP_OK( esp_vfs_register(VFS_PREF1, &desc, &param) );
TEST_ESP_OK( esp_vfs_register(VFS_PREF2, &desc, &param) );
TEST_ESP_OK( esp_vfs_register_fs(VFS_PREF1, &desc, ESP_VFS_FLAG_CONTEXT_PTR, &param) );
TEST_ESP_OK( esp_vfs_register_fs(VFS_PREF2, &desc, ESP_VFS_FLAG_CONTEXT_PTR, &param) );
const int fd1 = open(VFS_PREF1 FILE1, 0, 0);
const int fd2 = open(VFS_PREF2 FILE1, 0, 0);
@@ -155,13 +155,12 @@ static void concurrent_task(void *param)
TEST_CASE("VFS can handle concurrent open/close requests", "[vfs]")
{
esp_vfs_t desc = {
.flags = ESP_VFS_FLAG_DEFAULT,
esp_vfs_fs_ops_t desc = {
.open = concurrent_test_vfs_open,
.close = concurrent_test_vfs_close,
};
TEST_ESP_OK( esp_vfs_register(VFS_PREF1, &desc, NULL) );
TEST_ESP_OK( esp_vfs_register_fs(VFS_PREF1, &desc, ESP_VFS_FLAG_DEFAULT, NULL) );
concurrent_test_task_param_t param1 = { .path = VFS_PREF1 FILE1, .done = xSemaphoreCreateBinary() };
concurrent_test_task_param_t param2 = { .path = VFS_PREF1 FILE1, .done = xSemaphoreCreateBinary() };
@@ -233,14 +232,13 @@ static int time_test_vfs_write(int fd, const void *data, size_t size)
TEST_CASE("Open & write & close through VFS passes performance test", "[vfs]")
{
esp_vfs_t desc = {
.flags = ESP_VFS_FLAG_DEFAULT,
esp_vfs_fs_ops_t desc = {
.open = time_test_vfs_open,
.close = time_test_vfs_close,
.write = time_test_vfs_write,
};
TEST_ESP_OK( esp_vfs_register(VFS_PREF1, &desc, NULL) );
TEST_ESP_OK( esp_vfs_register_fs(VFS_PREF1, &desc, ESP_VFS_FLAG_DEFAULT, NULL) );
ccomp_timer_start();
const int iter_count = 5000;
@@ -278,17 +276,16 @@ static int vfs_overlap_test_close(int fd)
TEST_CASE("esp_vfs_register_fd_range checks for overlap", "[vfs]")
{
esp_vfs_t vfs1 = {
esp_vfs_fs_ops_t vfs1 = {
.open = vfs_overlap_test_open,
.close = vfs_overlap_test_close
};
TEST_ESP_OK(esp_vfs_register("/test", &vfs1, NULL));
TEST_ESP_OK(esp_vfs_register_fs("/test", &vfs1, ESP_VFS_FLAG_DEFAULT, NULL));
int fd = open("/test/1", 0, 0);
TEST_ASSERT_NOT_EQUAL(-1, fd);
esp_vfs_t vfs2 = { };
esp_err_t err = esp_vfs_register_fd_range(&vfs2, NULL, fd, fd + 1);
esp_vfs_fs_ops_t vfs2 = { };
esp_err_t err = esp_vfs_register_fd_range(&vfs2, ESP_VFS_FLAG_DEFAULT, NULL, fd, fd + 1);
close(fd);
TEST_ESP_OK(esp_vfs_unregister("/test"));
components/vfs/test_apps/main/test_vfs_open.c
+4 -3
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2022-2023 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2022-2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@@ -9,6 +9,7 @@
#include <fcntl.h>
#include <errno.h>
#include "esp_vfs.h"
#include "esp_vfs_ops.h"
#include "unity.h"
static int open_errno_test_open(const char * path, int flags, int mode)
@@ -19,10 +20,10 @@ static int open_errno_test_open(const char * path, int flags, int mode)
TEST_CASE("esp_vfs_open sets correct errno", "[vfs]")
{
esp_vfs_t desc = {
const esp_vfs_fs_ops_t desc = {
.open = open_errno_test_open
};
TEST_ESP_OK(esp_vfs_register("/test", &desc, NULL));
TEST_ESP_OK(esp_vfs_register_fs("/test", &desc, ESP_VFS_FLAG_DEFAULT, NULL));
int fd = open("/test/path", 0, 0);
int e = errno;
components/vfs/test_apps/main/test_vfs_paths.c
+23 -26
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2015-2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@@ -12,6 +12,7 @@
#include <sys/fcntl.h>
#include <dirent.h>
#include "esp_vfs.h"
#include "esp_vfs_ops.h"
#include "unity.h"
#include "esp_log.h"
@@ -68,13 +69,16 @@ static int dummy_closedir(void* ctx, DIR* pdir)
/* Initializer for this dummy VFS implementation
*/
#define DUMMY_VFS() { \
.flags = ESP_VFS_FLAG_CONTEXT_PTR, \
.open_p = dummy_open, \
.close_p = dummy_close, \
.opendir_p = dummy_opendir, \
.closedir_p = dummy_closedir \
}
static const esp_vfs_dir_ops_t s_dummy_vfs_dir = {
.opendir_p = dummy_opendir,
.closedir_p = dummy_closedir,
};
static const esp_vfs_fs_ops_t s_dummy_vfs = {
.open_p = dummy_open,
.close_p = dummy_close,
.dir = &s_dummy_vfs_dir,
};
/* Helper functions to test VFS behavior
*/
@@ -136,15 +140,13 @@ TEST_CASE("vfs parses paths correctly", "[vfs]")
.match_path = "",
.called = false
};
esp_vfs_t desc_foo = DUMMY_VFS();
TEST_ESP_OK( esp_vfs_register("/foo", &desc_foo, &inst_foo) );
TEST_ESP_OK( esp_vfs_register_fs("/foo", &s_dummy_vfs, ESP_VFS_FLAG_CONTEXT_PTR, &inst_foo) );
dummy_vfs_t inst_foo1 = {
.match_path = "",
.called = false
};
esp_vfs_t desc_foo1 = DUMMY_VFS();
TEST_ESP_OK( esp_vfs_register("/foo1", &desc_foo1, &inst_foo1) );
TEST_ESP_OK( esp_vfs_register_fs("/foo1", &s_dummy_vfs, ESP_VFS_FLAG_CONTEXT_PTR, &inst_foo1) );
inst_foo.match_path = "/file";
test_opened(&inst_foo, "/foo/file");
@@ -171,15 +173,13 @@ TEST_CASE("vfs parses paths correctly", "[vfs]")
.match_path = "",
.called = false
};
esp_vfs_t desc_foobar = DUMMY_VFS();
TEST_ESP_OK( esp_vfs_register("/foo/bar", &desc_foobar, &inst_foobar) );
TEST_ESP_OK( esp_vfs_register_fs("/foo/bar", &s_dummy_vfs, ESP_VFS_FLAG_CONTEXT_PTR, &inst_foobar) );
dummy_vfs_t inst_toplevel = {
.match_path = "",
.called = false
};
esp_vfs_t desc_toplevel = DUMMY_VFS();
TEST_ESP_OK( esp_vfs_register("", &desc_toplevel, &inst_toplevel) );
TEST_ESP_OK( esp_vfs_register_fs("", &s_dummy_vfs, ESP_VFS_FLAG_CONTEXT_PTR, &inst_toplevel) );
inst_foo.match_path = "/bar/file";
inst_foobar.match_path = "/file";
@@ -204,15 +204,13 @@ TEST_CASE("vfs unregisters correct nested mount point", "[vfs]")
.match_path = "/file",
.called = false
};
esp_vfs_t desc_foobar = DUMMY_VFS();
TEST_ESP_OK( esp_vfs_register("/foo/bar", &desc_foobar, &inst_foobar) );
TEST_ESP_OK( esp_vfs_register_fs("/foo/bar", &s_dummy_vfs, ESP_VFS_FLAG_CONTEXT_PTR, &inst_foobar) );
dummy_vfs_t inst_foo = {
.match_path = "/bar/file",
.called = false
};
esp_vfs_t desc_foo = DUMMY_VFS();
TEST_ESP_OK( esp_vfs_register("/foo", &desc_foo, &inst_foo) );
TEST_ESP_OK( esp_vfs_register_fs("/foo", &s_dummy_vfs, ESP_VFS_FLAG_CONTEXT_PTR, &inst_foo) );
/* basic operation */
test_opened(&inst_foobar, "/foo/bar/file");
@@ -228,8 +226,8 @@ TEST_CASE("vfs unregisters correct nested mount point", "[vfs]")
/* repeat the above, with the reverse order of registration */
TEST_ESP_OK( esp_vfs_unregister("/foo/bar") );
TEST_ESP_OK( esp_vfs_register("/foo", &desc_foo, &inst_foo) );
TEST_ESP_OK( esp_vfs_register("/foo/bar", &desc_foobar, &inst_foobar) );
TEST_ESP_OK( esp_vfs_register_fs("/foo", &s_dummy_vfs, ESP_VFS_FLAG_CONTEXT_PTR, &inst_foo) );
TEST_ESP_OK( esp_vfs_register_fs("/foo/bar", &s_dummy_vfs, ESP_VFS_FLAG_CONTEXT_PTR, &inst_foobar) );
test_opened(&inst_foobar, "/foo/bar/file");
test_not_called(&inst_foo, "/foo/bar/file");
TEST_ESP_OK( esp_vfs_unregister("/foo") );
@@ -242,13 +240,12 @@ TEST_CASE("vfs unregisters correct nested mount point", "[vfs]")
void test_vfs_register(const char* prefix, bool expect_success, int line)
{
dummy_vfs_t inst;
esp_vfs_t desc = DUMMY_VFS();
esp_err_t err = esp_vfs_register(prefix, &desc, &inst);
esp_err_t err = esp_vfs_register_fs(prefix, &s_dummy_vfs, ESP_VFS_FLAG_CONTEXT_PTR, &inst);
if (expect_success) {
UNITY_TEST_ASSERT_EQUAL_INT(ESP_OK, err, line, "esp_vfs_register should succeed");
UNITY_TEST_ASSERT_EQUAL_INT(ESP_OK, err, line, "esp_vfs_register_fs should succeed");
} else {
UNITY_TEST_ASSERT_EQUAL_INT(ESP_ERR_INVALID_ARG,
err, line, "esp_vfs_register should fail");
err, line, "esp_vfs_register_fs should fail");
}
if (err == ESP_OK) {
TEST_ESP_OK( esp_vfs_unregister(prefix) );
components/vfs/vfs.c
+73 -1087
View File
File diff suppressed because it is too large Load Diff
components/vfs/vfs_calls.c
+976
View File
@@ -0,0 +1,976 @@
/*
* SPDX-FileCopyrightText: 2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <sys/errno.h>
#include <sys/fcntl.h>
#include <sys/ioctl.h>
#include <sys/reent.h>
#include <sys/unistd.h>
#include <sys/lock.h>
#include <sys/param.h>
#include <dirent.h>
#include "inttypes_ext.h"
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
#include "esp_log.h"
#include "esp_vfs.h"
#include "esp_private/socket.h"
#include "esp_vfs_private.h"
#include "esp_vfs_utils.h"
#include "sdkconfig.h"
static const char __attribute__((unused)) *TAG = "vfs_calls";
int esp_vfs_open(struct _reent *r, const char *path, int flags, int mode)
{
const vfs_entry_t *vfs = get_vfs_for_path(path);
if (vfs == NULL) {
__errno_r(r) = ENOENT;
return -1;
}
int acc_mode = flags & O_ACCMODE;
int ro_filesystem = vfs->flags & ESP_VFS_FLAG_READONLY_FS;
if (acc_mode != O_RDONLY && ro_filesystem) {
__errno_r(r) = EROFS;
return -1;
}
const char *path_within_vfs = translate_path(vfs, path);
int fd_within_vfs;
CHECK_AND_CALL(fd_within_vfs, r, vfs, open, path_within_vfs, flags, mode);
if (fd_within_vfs < 0) {
__errno_r(r) = errno;
return -1;
}
int fd = register_fd(vfs->offset, fd_within_vfs, false);
if (fd >= 0) {
return fd;
}
int ret;
CHECK_AND_CALL(ret, r, vfs, close, fd_within_vfs);
(void) ret; // remove "set but not used" warning
__errno_r(r) = ENFILE;
return -1;
}
ssize_t esp_vfs_write(struct _reent *r, int fd, const void *data, size_t size)
{
const vfs_entry_t *vfs = get_vfs_for_fd(fd);
const int local_fd = get_local_fd(vfs, fd);
if (vfs == NULL || local_fd < 0) {
__errno_r(r) = EBADF;
return -1;
}
ssize_t ret;
CHECK_AND_CALL(ret, r, vfs, write, local_fd, data, size);
return ret;
}
off_t esp_vfs_lseek(struct _reent *r, int fd, off_t size, int mode)
{
const vfs_entry_t *vfs = get_vfs_for_fd(fd);
const int local_fd = get_local_fd(vfs, fd);
if (vfs == NULL || local_fd < 0) {
__errno_r(r) = EBADF;
return -1;
}
off_t ret;
CHECK_AND_CALL(ret, r, vfs, lseek, local_fd, size, mode);
return ret;
}
ssize_t esp_vfs_read(struct _reent *r, int fd, void *dst, size_t size)
{
const vfs_entry_t *vfs = get_vfs_for_fd(fd);
const int local_fd = get_local_fd(vfs, fd);
if (vfs == NULL || local_fd < 0) {
__errno_r(r) = EBADF;
return -1;
}
ssize_t ret;
CHECK_AND_CALL(ret, r, vfs, read, local_fd, dst, size);
return ret;
}
ssize_t esp_vfs_pread(int fd, void *dst, size_t size, off_t offset)
{
struct _reent __attribute__((unused)) *r = __getreent();
const vfs_entry_t *vfs = get_vfs_for_fd(fd);
const int local_fd = get_local_fd(vfs, fd);
if (vfs == NULL || local_fd < 0) {
__errno_r(r) = EBADF;
return -1;
}
ssize_t ret;
CHECK_AND_CALL(ret, r, vfs, pread, local_fd, dst, size, offset);
return ret;
}
ssize_t esp_vfs_pwrite(int fd, const void *src, size_t size, off_t offset)
{
struct _reent __attribute__((unused)) *r = __getreent();
const vfs_entry_t *vfs = get_vfs_for_fd(fd);
const int local_fd = get_local_fd(vfs, fd);
if (vfs == NULL || local_fd < 0) {
__errno_r(r) = EBADF;
return -1;
}
ssize_t ret;
CHECK_AND_CALL(ret, r, vfs, pwrite, local_fd, src, size, offset);
return ret;
}
int esp_vfs_close(struct _reent *r, int fd)
{
const vfs_entry_t *vfs = get_vfs_for_fd(fd);
const int local_fd = get_local_fd(vfs, fd);
if (vfs == NULL || local_fd < 0) {
__errno_r(r) = EBADF;
return -1;
}
int ret;
CHECK_AND_CALL(ret, r, vfs, close, local_fd);
unregister_fd(fd);
return ret;
}
int esp_vfs_fstat(struct _reent *r, int fd, struct stat *st)
{
const vfs_entry_t *vfs = get_vfs_for_fd(fd);
const int local_fd = get_local_fd(vfs, fd);
if (vfs == NULL || local_fd < 0) {
__errno_r(r) = EBADF;
return -1;
}
int ret;
CHECK_AND_CALL(ret, r, vfs, fstat, local_fd, st);
return ret;
}
int esp_vfs_fcntl_r(struct _reent *r, int fd, int cmd, int arg)
{
const vfs_entry_t *vfs = get_vfs_for_fd(fd);
const int local_fd = get_local_fd(vfs, fd);
if (vfs == NULL || local_fd < 0) {
__errno_r(r) = EBADF;
return -1;
}
int ret;
CHECK_AND_CALL(ret, r, vfs, fcntl, local_fd, cmd, arg);
return ret;
}
int esp_vfs_ioctl(int fd, int cmd, ...)
{
const vfs_entry_t *vfs = get_vfs_for_fd(fd);
const int local_fd = get_local_fd(vfs, fd);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL || local_fd < 0) {
__errno_r(r) = EBADF;
return -1;
}
int ret;
va_list args;
va_start(args, cmd);
CHECK_AND_CALL(ret, r, vfs, ioctl, local_fd, cmd, args);
va_end(args);
return ret;
}
int esp_vfs_fsync(int fd)
{
const vfs_entry_t *vfs = get_vfs_for_fd(fd);
const int local_fd = get_local_fd(vfs, fd);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL || local_fd < 0) {
__errno_r(r) = EBADF;
return -1;
}
int ret;
CHECK_AND_CALL(ret, r, vfs, fsync, local_fd);
return ret;
}
#ifdef CONFIG_VFS_SUPPORT_DIR
int esp_vfs_stat(struct _reent *r, const char *path, struct stat *st)
{
const vfs_entry_t *vfs = get_vfs_for_path(path);
if (vfs == NULL) {
__errno_r(r) = ENOENT;
return -1;
}
const char *path_within_vfs = translate_path(vfs, path);
int ret;
CHECK_AND_CALL_SUBCOMPONENT(ret, r, vfs, dir, stat, path_within_vfs, st);
return ret;
}
int esp_vfs_utime(const char *path, const struct utimbuf *times)
{
int ret;
const vfs_entry_t *vfs = get_vfs_for_path(path);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL) {
__errno_r(r) = ENOENT;
return -1;
}
const char *path_within_vfs = translate_path(vfs, path);
CHECK_AND_CALL_SUBCOMPONENT(ret, r, vfs, dir, utime, path_within_vfs, times);
return ret;
}
int esp_vfs_link(struct _reent *r, const char *n1, const char *n2)
{
const vfs_entry_t *vfs = get_vfs_for_path(n1);
if (vfs == NULL) {
__errno_r(r) = ENOENT;
return -1;
}
const vfs_entry_t *vfs2 = get_vfs_for_path(n2);
if (vfs != vfs2) {
__errno_r(r) = EXDEV;
return -1;
}
CHECK_VFS_READONLY_FLAG(vfs2->flags);
const char *path1_within_vfs = translate_path(vfs, n1);
const char *path2_within_vfs = translate_path(vfs, n2);
int ret;
CHECK_AND_CALL_SUBCOMPONENT(ret, r, vfs, dir, link, path1_within_vfs, path2_within_vfs);
return ret;
}
int esp_vfs_unlink(struct _reent *r, const char *path)
{
const vfs_entry_t *vfs = get_vfs_for_path(path);
if (vfs == NULL) {
__errno_r(r) = ENOENT;
return -1;
}
CHECK_VFS_READONLY_FLAG(vfs->flags);
const char *path_within_vfs = translate_path(vfs, path);
int ret;
CHECK_AND_CALL_SUBCOMPONENT(ret, r, vfs, dir, unlink, path_within_vfs);
return ret;
}
int esp_vfs_rename(struct _reent *r, const char *src, const char *dst)
{
const vfs_entry_t *vfs = get_vfs_for_path(src);
if (vfs == NULL) {
__errno_r(r) = ENOENT;
return -1;
}
CHECK_VFS_READONLY_FLAG(vfs->flags);
const vfs_entry_t *vfs_dst = get_vfs_for_path(dst);
if (vfs != vfs_dst) {
__errno_r(r) = EXDEV;
return -1;
}
CHECK_VFS_READONLY_FLAG(vfs_dst->flags);
const char *src_within_vfs = translate_path(vfs, src);
const char *dst_within_vfs = translate_path(vfs, dst);
int ret;
CHECK_AND_CALL_SUBCOMPONENT(ret, r, vfs, dir, rename, src_within_vfs, dst_within_vfs);
return ret;
}
DIR *esp_vfs_opendir(const char *name)
{
const vfs_entry_t *vfs = get_vfs_for_path(name);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL) {
__errno_r(r) = ENOENT;
return NULL;
}
const char *path_within_vfs = translate_path(vfs, name);
DIR *ret;
CHECK_AND_CALL_SUBCOMPONENTP(ret, r, vfs, dir, opendir, path_within_vfs);
if (ret != NULL) {
ret->dd_vfs_idx = vfs->offset;
}
return ret;
}
struct dirent *esp_vfs_readdir(DIR *pdir)
{
const vfs_entry_t *vfs = get_vfs_for_index(pdir->dd_vfs_idx);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL) {
__errno_r(r) = EBADF;
return NULL;
}
struct dirent *ret;
CHECK_AND_CALL_SUBCOMPONENTP(ret, r, vfs, dir, readdir, pdir);
return ret;
}
int esp_vfs_readdir_r(DIR *pdir, struct dirent *entry, struct dirent* *out_dirent)
{
const vfs_entry_t *vfs = get_vfs_for_index(pdir->dd_vfs_idx);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL) {
errno = EBADF;
return -1;
}
int ret;
CHECK_AND_CALL_SUBCOMPONENT(ret, r, vfs, dir, readdir_r, pdir, entry, out_dirent);
return ret;
}
long esp_vfs_telldir(DIR *pdir)
{
const vfs_entry_t *vfs = get_vfs_for_index(pdir->dd_vfs_idx);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL) {
errno = EBADF;
return -1;
}
long ret;
CHECK_AND_CALL_SUBCOMPONENT(ret, r, vfs, dir, telldir, pdir);
return ret;
}
void esp_vfs_seekdir(DIR *pdir, long loc)
{
const vfs_entry_t *vfs = get_vfs_for_index(pdir->dd_vfs_idx);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL) {
errno = EBADF;
return;
}
CHECK_AND_CALL_SUBCOMPONENTV(r, vfs, dir, seekdir, pdir, loc);
}
void esp_vfs_rewinddir(DIR *pdir)
{
seekdir(pdir, 0);
}
int esp_vfs_closedir(DIR *pdir)
{
const vfs_entry_t *vfs = get_vfs_for_index(pdir->dd_vfs_idx);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL) {
errno = EBADF;
return -1;
}
int ret;
CHECK_AND_CALL_SUBCOMPONENT(ret, r, vfs, dir, closedir, pdir);
return ret;
}
int esp_vfs_mkdir(const char *name, mode_t mode)
{
const vfs_entry_t *vfs = get_vfs_for_path(name);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL) {
__errno_r(r) = ENOENT;
return -1;
}
CHECK_VFS_READONLY_FLAG(vfs->flags);
const char *path_within_vfs = translate_path(vfs, name);
int ret;
CHECK_AND_CALL_SUBCOMPONENT(ret, r, vfs, dir, mkdir, path_within_vfs, mode);
return ret;
}
int esp_vfs_rmdir(const char *name)
{
const vfs_entry_t *vfs = get_vfs_for_path(name);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL) {
__errno_r(r) = ENOENT;
return -1;
}
CHECK_VFS_READONLY_FLAG(vfs->flags);
const char *path_within_vfs = translate_path(vfs, name);
int ret;
CHECK_AND_CALL_SUBCOMPONENT(ret, r, vfs, dir, rmdir, path_within_vfs);
return ret;
}
int esp_vfs_access(const char *path, int amode)
{
int ret;
const vfs_entry_t *vfs = get_vfs_for_path(path);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL) {
__errno_r(r) = ENOENT;
return -1;
}
const char *path_within_vfs = translate_path(vfs, path);
CHECK_AND_CALL_SUBCOMPONENT(ret, r, vfs, dir, access, path_within_vfs, amode);
return ret;
}
int esp_vfs_truncate(const char *path, off_t length)
{
int ret;
const vfs_entry_t *vfs = get_vfs_for_path(path);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL) {
__errno_r(r) = ENOENT;
return -1;
}
CHECK_VFS_READONLY_FLAG(vfs->flags);
const char *path_within_vfs = translate_path(vfs, path);
CHECK_AND_CALL_SUBCOMPONENT(ret, r, vfs, dir, truncate, path_within_vfs, length);
return ret;
}
int esp_vfs_ftruncate(int fd, off_t length)
{
const vfs_entry_t *vfs = get_vfs_for_fd(fd);
int local_fd = get_local_fd(vfs, fd);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL || local_fd < 0) {
__errno_r(r) = EBADF;
return -1;
}
CHECK_VFS_READONLY_FLAG(vfs->flags);
int ret;
CHECK_AND_CALL_SUBCOMPONENT(ret, r, vfs, dir, ftruncate, local_fd, length);
return ret;
}
#endif // CONFIG_VFS_SUPPORT_DIR
#ifdef CONFIG_VFS_SUPPORT_SELECT
static void call_end_selects(int end_index, const fds_triple_t *vfs_fds_triple, void **driver_args)
{
for (int i = 0; i < end_index; ++i) {
const vfs_entry_t *vfs = get_vfs_for_index(i);
const fds_triple_t *item = &vfs_fds_triple[i];
if (vfs != NULL
&& vfs->vfs->select != NULL
&& vfs->vfs->select->end_select != NULL
&& item->isset
) {
esp_err_t err = vfs->vfs->select->end_select(driver_args[i]);
if (err != ESP_OK) {
ESP_LOGD(TAG, "end_select failed: %s", esp_err_to_name(err));
}
}
}
}
static int set_global_fd_sets(const fds_triple_t *vfs_fds_triple, int size, fd_set *readfds, fd_set *writefds, fd_set *errorfds)
{
int ret = 0;
for (int i = 0; i < size; ++i) {
const fds_triple_t *item = &vfs_fds_triple[i];
if (item->isset) {
for (int fd = 0; fd < MAX_FDS; ++fd) {
const fd_table_t *fd_entry = get_fd_entry(fd);
if (fd_entry->vfs_index == i) {
const int local_fd = fd_entry->local_fd; // single read -> no locking is required
if (readfds && esp_vfs_safe_fd_isset(local_fd, &item->readfds)) {
ESP_LOGD(TAG, "FD %d in readfds was set from VFS ID %d", fd, i);
FD_SET(fd, readfds);
++ret;
}
if (writefds && esp_vfs_safe_fd_isset(local_fd, &item->writefds)) {
ESP_LOGD(TAG, "FD %d in writefds was set from VFS ID %d", fd, i);
FD_SET(fd, writefds);
++ret;
}
if (errorfds && esp_vfs_safe_fd_isset(local_fd, &item->errorfds)) {
ESP_LOGD(TAG, "FD %d in errorfds was set from VFS ID %d", fd, i);
FD_SET(fd, errorfds);
++ret;
}
}
}
}
}
return ret;
}
static void esp_vfs_log_fd_set(const char *fds_name, const fd_set *fds)
{
if (fds_name && fds) {
ESP_LOGD(TAG, "FDs in %s =", fds_name);
for (int i = 0; i < MAX_FDS; ++i) {
if (esp_vfs_safe_fd_isset(i, fds)) {
ESP_LOGD(TAG, "%d", i);
}
}
}
}
int esp_vfs_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *errorfds, struct timeval *timeout)
{
// NOTE: Please see the "Synchronous input/output multiplexing" section of the ESP-IDF Programming Guide
// (API Reference -> Storage -> Virtual Filesystem) for a general overview of the implementation of VFS select().
int ret = 0;
struct _reent __attribute__((unused)) *r = __getreent();
ESP_LOGD(TAG, "esp_vfs_select starts with nfds = %d", nfds);
if (timeout) {
ESP_LOGD(TAG, "timeout is %lds + %ldus", (long)timeout->tv_sec, timeout->tv_usec);
}
esp_vfs_log_fd_set("readfds", readfds);
esp_vfs_log_fd_set("writefds", writefds);
esp_vfs_log_fd_set("errorfds", errorfds);
if (nfds > MAX_FDS || nfds < 0) {
ESP_LOGD(TAG, "incorrect nfds");
__errno_r(r) = EINVAL;
return -1;
}
// Capture s_vfs_count to a local variable in case a new driver is registered or removed during this actual select()
// call. s_vfs_count cannot be protected with a mutex during a select() call (which can be one without a timeout)
// because that could block the registration of new driver.
const size_t vfs_count = get_vfs_count();
fds_triple_t *vfs_fds_triple;
if ((vfs_fds_triple = heap_caps_calloc(vfs_count, sizeof(fds_triple_t), VFS_MALLOC_FLAGS)) == NULL) {
__errno_r(r) = ENOMEM;
ESP_LOGD(TAG, "calloc is unsuccessful");
return -1;
}
esp_vfs_select_sem_t sel_sem = {
.is_sem_local = false,
.sem = NULL,
};
int (*socket_select)(int, fd_set *, fd_set *, fd_set *, struct timeval *) = NULL;
for (int fd = 0; fd < nfds; ++fd) {
const fd_table_t fd_entry = start_select(fd, errorfds);
const bool is_socket_fd = fd_entry.permanent;
const int vfs_index = fd_entry.vfs_index;
const int local_fd = fd_entry.local_fd;
if (vfs_index < 0) {
continue;
}
if (is_socket_fd) {
if (!socket_select) {
// no socket_select found yet so take a look
if (esp_vfs_safe_fd_isset(fd, readfds) ||
esp_vfs_safe_fd_isset(fd, writefds) ||
esp_vfs_safe_fd_isset(fd, errorfds)) {
const vfs_entry_t *vfs = get_vfs_for_index(vfs_index);
socket_select = vfs->vfs->select->socket_select;
sel_sem.sem = vfs->vfs->select->get_socket_select_semaphore();
}
}
continue;
}
fds_triple_t *item = &vfs_fds_triple[vfs_index]; // FD sets for VFS which belongs to fd
if (esp_vfs_safe_fd_isset(fd, readfds)) {
item->isset = true;
FD_SET(local_fd, &item->readfds);
FD_CLR(fd, readfds);
ESP_LOGD(TAG, "removing %d from readfds and adding as local FD %d to fd_set of VFS ID %d", fd, local_fd, vfs_index);
}
if (esp_vfs_safe_fd_isset(fd, writefds)) {
item->isset = true;
FD_SET(local_fd, &item->writefds);
FD_CLR(fd, writefds);
ESP_LOGD(TAG, "removing %d from writefds and adding as local FD %d to fd_set of VFS ID %d", fd, local_fd, vfs_index);
}
if (esp_vfs_safe_fd_isset(fd, errorfds)) {
item->isset = true;
FD_SET(local_fd, &item->errorfds);
FD_CLR(fd, errorfds);
ESP_LOGD(TAG, "removing %d from errorfds and adding as local FD %d to fd_set of VFS ID %d", fd, local_fd, vfs_index);
}
}
// all non-socket VFSs have their FD sets in vfs_fds_triple
// the global readfds, writefds and errorfds contain only socket FDs (if
// there any)
if (!socket_select) {
// There is no socket VFS registered or select() wasn't called for
// any socket. Therefore, we will use our own signalization.
sel_sem.is_sem_local = true;
if ((sel_sem.sem = xSemaphoreCreateBinary()) == NULL) {
free(vfs_fds_triple);
__errno_r(r) = ENOMEM;
ESP_LOGD(TAG, "cannot create select semaphore");
return -1;
}
}
void **driver_args = heap_caps_calloc(vfs_count, sizeof(void *), VFS_MALLOC_FLAGS);
if (driver_args == NULL) {
free(vfs_fds_triple);
__errno_r(r) = ENOMEM;
ESP_LOGD(TAG, "calloc is unsuccessful for driver args");
return -1;
}
for (size_t i = 0; i < vfs_count; ++i) {
const vfs_entry_t *vfs = get_vfs_for_index(i);
fds_triple_t *item = &vfs_fds_triple[i];
if (vfs == NULL || vfs->vfs->select == NULL || vfs->vfs->select->start_select == NULL) {
ESP_LOGD(TAG, "start_select function callback for this vfs (s_vfs[%d]) is not defined", vfs->offset);
continue;
}
if (!item->isset) {
continue;
}
// call start_select for all non-socket VFSs with has at least one FD set in readfds, writefds, or errorfds
// note: it can point to socket VFS but item->isset will be false for that
ESP_LOGD(TAG, "calling start_select for VFS ID " PRIuSIZE " with the following local FDs", i);
esp_vfs_log_fd_set("readfds", &item->readfds);
esp_vfs_log_fd_set("writefds", &item->writefds);
esp_vfs_log_fd_set("errorfds", &item->errorfds);
esp_err_t err = vfs->vfs->select->start_select(nfds, &item->readfds, &item->writefds, &item->errorfds, sel_sem,
driver_args + i);
if (err != ESP_OK) {
if (err != ESP_ERR_NOT_SUPPORTED) {
call_end_selects(i, vfs_fds_triple, driver_args);
}
(void) set_global_fd_sets(vfs_fds_triple, vfs_count, readfds, writefds, errorfds);
if (sel_sem.is_sem_local && sel_sem.sem) {
vSemaphoreDelete(sel_sem.sem);
sel_sem.sem = NULL;
}
free(vfs_fds_triple);
free(driver_args);
__errno_r(r) = EINTR;
ESP_LOGD(TAG, "start_select failed: %s", esp_err_to_name(err));
return -1;
}
}
if (socket_select) {
ESP_LOGD(TAG, "calling socket_select with the following FDs");
esp_vfs_log_fd_set("readfds", readfds);
esp_vfs_log_fd_set("writefds", writefds);
esp_vfs_log_fd_set("errorfds", errorfds);
ret = socket_select(nfds, readfds, writefds, errorfds, timeout);
ESP_LOGD(TAG, "socket_select returned %d and the FDs are the following", ret);
esp_vfs_log_fd_set("readfds", readfds);
esp_vfs_log_fd_set("writefds", writefds);
esp_vfs_log_fd_set("errorfds", errorfds);
} else {
if (readfds) {
FD_ZERO(readfds);
}
if (writefds) {
FD_ZERO(writefds);
}
if (errorfds) {
FD_ZERO(errorfds);
}
TickType_t ticks_to_wait = portMAX_DELAY;
if (timeout) {
uint32_t timeout_ms = (timeout->tv_sec *1000) + (timeout->tv_usec / 1000);
/* Round up the number of ticks.
* Not only we need to round up the number of ticks, but we also need to add 1.
* Indeed, `select` function shall wait for AT LEAST timeout, but on FreeRTOS,
* if we specify a timeout of 1 tick to `xSemaphoreTake`, it will take AT MOST
* 1 tick before triggering a timeout. Thus, we need to pass 2 ticks as a timeout
* to `xSemaphoreTake`. */
ticks_to_wait = ((timeout_ms + portTICK_PERIOD_MS - 1) / portTICK_PERIOD_MS) + 1;
ESP_LOGD(TAG, "timeout is %" PRIu32 "ms", timeout_ms);
}
ESP_LOGD(TAG, "waiting without calling socket_select");
xSemaphoreTake(sel_sem.sem, ticks_to_wait);
}
call_end_selects(vfs_count, vfs_fds_triple, driver_args); // for VFSs for start_select was called before
if (ret >= 0) {
ret += set_global_fd_sets(vfs_fds_triple, vfs_count, readfds, writefds, errorfds);
}
if (sel_sem.sem) { // Cleanup the select semaphore
if (sel_sem.is_sem_local) {
vSemaphoreDelete(sel_sem.sem);
} else if (socket_select) {
SemaphoreHandle_t *s = sel_sem.sem;
/* Select might have been triggered from both lwip and vfs fds at the same time, and
* we have to make sure that the lwip semaphore is cleared when we exit select().
* It is safe, as the semaphore belongs to the calling thread. */
xSemaphoreTake(*s, 0);
}
sel_sem.sem = NULL;
}
close_pending(nfds);
free(vfs_fds_triple);
free(driver_args);
ESP_LOGD(TAG, "esp_vfs_select returns %d", ret);
esp_vfs_log_fd_set("readfds", readfds);
esp_vfs_log_fd_set("writefds", writefds);
esp_vfs_log_fd_set("errorfds", errorfds);
return ret;
}
void esp_vfs_select_triggered(esp_vfs_select_sem_t sem)
{
if (sem.is_sem_local) {
xSemaphoreGive(sem.sem);
} else {
// Another way would be to go through s_fd_table and find the VFS
// which has a permanent FD. But in order to avoid to lock
// s_fd_table_lock we go through the VFS table.
size_t vfs_count = get_vfs_count();
for (int i = 0; i < vfs_count; ++i) {
// Note: vfs_count could have changed since the start of vfs_select() call. However, that change doesn't
// matter here stop_socket_select() will be called for only valid VFS drivers.
const vfs_entry_t *vfs = get_vfs_for_index(i);
if (vfs != NULL
&& vfs->vfs->select != NULL
&& vfs->vfs->select->stop_socket_select != NULL
) {
vfs->vfs->select->stop_socket_select(sem.sem);
break;
}
}
}
}
void esp_vfs_select_triggered_isr(esp_vfs_select_sem_t sem, BaseType_t *woken)
{
if (sem.is_sem_local) {
xSemaphoreGiveFromISR(sem.sem, woken);
} else {
// Another way would be to go through s_fd_table and find the VFS
// which has a permanent FD. But in order to avoid to lock
// s_fd_table_lock we go through the VFS table.
size_t vfs_count = get_vfs_count();
for (int i = 0; i < vfs_count; ++i) {
// Note: s_vfs_count could have changed since the start of vfs_select() call. However, that change doesn't
// matter here stop_socket_select() will be called for only valid VFS drivers.
const vfs_entry_t *vfs = get_vfs_for_index(i);
if (vfs != NULL
&& vfs->vfs->select != NULL
&& vfs->vfs->select->stop_socket_select_isr != NULL
) {
// Note: If the UART ISR resides in IRAM, the function referenced by stop_socket_select_isr should also be placed in IRAM.
vfs->vfs->select->stop_socket_select_isr(sem.sem, woken);
break;
}
}
}
}
#endif // CONFIG_VFS_SUPPORT_SELECT
#ifdef CONFIG_VFS_SUPPORT_TERMIOS
int tcgetattr(int fd, struct termios *p)
{
const vfs_entry_t *vfs = get_vfs_for_fd(fd);
const int local_fd = get_local_fd(vfs, fd);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL || local_fd < 0) {
__errno_r(r) = EBADF;
return -1;
}
int ret;
CHECK_AND_CALL_SUBCOMPONENT(ret, r, vfs, termios, tcgetattr, local_fd, p);
return ret;
}
int tcsetattr(int fd, int optional_actions, const struct termios *p)
{
const vfs_entry_t *vfs = get_vfs_for_fd(fd);
const int local_fd = get_local_fd(vfs, fd);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL || local_fd < 0) {
__errno_r(r) = EBADF;
return -1;
}
int ret;
CHECK_AND_CALL_SUBCOMPONENT(ret, r, vfs, termios, tcsetattr, local_fd, optional_actions, p);
return ret;
}
int tcdrain(int fd)
{
const vfs_entry_t *vfs = get_vfs_for_fd(fd);
const int local_fd = get_local_fd(vfs, fd);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL || local_fd < 0) {
__errno_r(r) = EBADF;
return -1;
}
int ret;
CHECK_AND_CALL_SUBCOMPONENT(ret, r, vfs, termios, tcdrain, local_fd);
return ret;
}
int tcflush(int fd, int select)
{
const vfs_entry_t *vfs = get_vfs_for_fd(fd);
const int local_fd = get_local_fd(vfs, fd);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL || local_fd < 0) {
__errno_r(r) = EBADF;
return -1;
}
int ret;
CHECK_AND_CALL_SUBCOMPONENT(ret, r, vfs, termios, tcflush, local_fd, select);
return ret;
}
int tcflow(int fd, int action)
{
const vfs_entry_t *vfs = get_vfs_for_fd(fd);
const int local_fd = get_local_fd(vfs, fd);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL || local_fd < 0) {
__errno_r(r) = EBADF;
return -1;
}
int ret;
CHECK_AND_CALL_SUBCOMPONENT(ret, r, vfs, termios, tcflow, local_fd, action);
return ret;
}
pid_t tcgetsid(int fd)
{
const vfs_entry_t *vfs = get_vfs_for_fd(fd);
const int local_fd = get_local_fd(vfs, fd);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL || local_fd < 0) {
__errno_r(r) = EBADF;
return -1;
}
int ret;
CHECK_AND_CALL_SUBCOMPONENT(ret, r, vfs, termios, tcgetsid, local_fd);
return ret;
}
int tcsendbreak(int fd, int duration)
{
const vfs_entry_t *vfs = get_vfs_for_fd(fd);
const int local_fd = get_local_fd(vfs, fd);
struct _reent __attribute__((unused)) *r = __getreent();
if (vfs == NULL || local_fd < 0) {
__errno_r(r) = EBADF;
return -1;
}
int ret;
CHECK_AND_CALL_SUBCOMPONENT(ret, r, vfs, termios, tcsendbreak, local_fd, duration);
return ret;
}
#endif // CONFIG_VFS_SUPPORT_TERMIOS
#ifndef CONFIG_IDF_TARGET_LINUX
/* Create aliases for libc syscalls
These functions are also available in ROM as stubs which use the syscall table, but linking them
directly here saves an additional function call when a software function is linked to one, and
makes linking with -stdlib easier.
*/
#ifdef CONFIG_VFS_SUPPORT_IO
int _open_r(struct _reent *r, const char *path, int flags, int mode)
__attribute__((alias("esp_vfs_open")));
int _close_r(struct _reent *r, int fd)
__attribute__((alias("esp_vfs_close")));
ssize_t _read_r(struct _reent *r, int fd, void *dst, size_t size)
__attribute__((alias("esp_vfs_read")));
ssize_t _write_r(struct _reent *r, int fd, const void *data, size_t size)
__attribute__((alias("esp_vfs_write")));
ssize_t pread(int fd, void *dst, size_t size, off_t offset)
__attribute__((alias("esp_vfs_pread")));
ssize_t pwrite(int fd, const void *src, size_t size, off_t offset)
__attribute__((alias("esp_vfs_pwrite")));
off_t _lseek_r(struct _reent *r, int fd, off_t size, int mode)
__attribute__((alias("esp_vfs_lseek")));
int _fcntl_r(struct _reent *r, int fd, int cmd, int arg)
__attribute__((alias("esp_vfs_fcntl_r")));
int _fstat_r(struct _reent *r, int fd, struct stat *st)
__attribute__((alias("esp_vfs_fstat")));
int fsync(int fd)
__attribute__((alias("esp_vfs_fsync")));
int ioctl(int fd, int cmd, ...)
__attribute__((alias("esp_vfs_ioctl")));
#endif // CONFIG_VFS_SUPPORT_IO
#ifdef CONFIG_VFS_SUPPORT_SELECT
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *errorfds, struct timeval *timeout)
__attribute__((alias("esp_vfs_select")));
#endif // CONFIG_VFS_SUPPORT_SELECT
#ifdef CONFIG_VFS_SUPPORT_DIR
int _stat_r(struct _reent *r, const char *path, struct stat *st)
__attribute__((alias("esp_vfs_stat")));
int _link_r(struct _reent *r, const char *n1, const char *n2)
__attribute__((alias("esp_vfs_link")));
int _unlink_r(struct _reent *r, const char *path)
__attribute__((alias("esp_vfs_unlink")));
int _rename_r(struct _reent *r, const char *src, const char *dst)
__attribute__((alias("esp_vfs_rename")));
int truncate(const char *path, off_t length)
__attribute__((alias("esp_vfs_truncate")));
int ftruncate(int fd, off_t length)
__attribute__((alias("esp_vfs_ftruncate")));
int access(const char *path, int amode)
__attribute__((alias("esp_vfs_access")));
int utime(const char *path, const struct utimbuf *times)
__attribute__((alias("esp_vfs_utime")));
int rmdir(const char *name)
__attribute__((alias("esp_vfs_rmdir")));
int mkdir(const char *name, mode_t mode)
__attribute__((alias("esp_vfs_mkdir")));
DIR *opendir(const char *name)
__attribute__((alias("esp_vfs_opendir")));
int closedir(DIR *pdir)
__attribute__((alias("esp_vfs_closedir")));
int readdir_r(DIR *pdir, struct dirent *entry, struct dirent* *out_dirent)
__attribute__((alias("esp_vfs_readdir_r")));
struct dirent *readdir(DIR *pdir)
__attribute__((alias("esp_vfs_readdir")));
long telldir(DIR *pdir)
__attribute__((alias("esp_vfs_telldir")));
void seekdir(DIR *pdir, long loc)
__attribute__((alias("esp_vfs_seekdir")));
void rewinddir(DIR *pdir)
__attribute__((alias("esp_vfs_rewinddir")));
#endif // CONFIG_VFS_SUPPORT_DIR
#endif //CONFIG_IDF_TARGET_LINUX
void vfs_include_syscalls_impl(void)
{
// Linker hook function, exists to make the linker examine this file
}
components/vfs/vfs_eventfd.c
+18 -12
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2021-2024 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2021-2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@@ -351,6 +351,22 @@ static int event_close(int fd)
return ret;
}
#ifdef CONFIG_VFS_SUPPORT_SELECT
static const esp_vfs_select_ops_t s_vfs_eventfd_select = {
.start_select = &event_start_select,
.end_select = &event_end_select,
};
#endif
static const esp_vfs_fs_ops_t s_vfs_eventfd = {
.write = &event_write,
.read = &event_read,
.close = &event_close,
#ifdef CONFIG_VFS_SUPPORT_SELECT
.select = &s_vfs_eventfd_select,
#endif
};
esp_err_t esp_vfs_eventfd_register(const esp_vfs_eventfd_config_t *config)
{
if (config == NULL || config->max_fds >= MAX_FDS) {
@@ -367,17 +383,7 @@ esp_err_t esp_vfs_eventfd_register(const esp_vfs_eventfd_config_t *config)
s_events[i].fd = FD_INVALID;
}
esp_vfs_t vfs = {
.flags = ESP_VFS_FLAG_DEFAULT,
.write = &event_write,
.close = &event_close,
.read = &event_read,
#ifdef CONFIG_VFS_SUPPORT_SELECT
.start_select = &event_start_select,
.end_select = &event_end_select,
#endif
};
return esp_vfs_register_with_id(&vfs, NULL, &s_eventfd_vfs_id);
return esp_vfs_register_fs_with_id(&s_vfs_eventfd, ESP_VFS_FLAG_STATIC | ESP_VFS_FLAG_STATIC, NULL, &s_eventfd_vfs_id);
}
esp_err_t esp_vfs_eventfd_unregister(void)
docs/en/api-reference/storage/vfs.rst
+1 -5
View File
@@ -17,10 +17,6 @@ For example, one can mount a FAT filesystem driver at the ``/fat`` prefix and ca
FS Registration
---------------
.. note::
For previous version of the API (using :cpp:type:`esp_vfs_t`), see documentation for previous release.
To register an FS driver, an application needs to define an instance of the :cpp:type:`esp_vfs_fs_ops_t` structure and populate it with function pointers to FS APIs:
.. highlight:: c
@@ -79,7 +75,7 @@ In some cases, it might be beneficial or even necessary to pass some context to
ssize_t myfs_write(myfs_t* fs, int fd, const void * data, size_t size);
// In definition of esp_vfs_t:
// In definition of esp_vfs_fs_ops_t:
.write_p = &myfs_write,
// ... other members initialized
docs/en/migration-guides/release-6.x/6.0/storage.rst
+2
View File
@@ -14,6 +14,8 @@ VFS
- Deleted deprecated UART-VFS functions (``esp_vfs_dev_uart_*``) located in the ``vfs`` component. Please use API from UART driver instead: ``uart_vfs_dev_*``.
- Deleted deprecated USB-Serial-JTAG-VFS functions (``esp_vfs_dev_usb_serial_jtag_*``) located in the ``vfs`` component. Please use API from USB-Serial-JTAG driver instead: ``usb_serial_jtag_vfs_*``.
- ``esp_vfs_register_fd_range`` is now considered private and its signature was changed to match the new VFS API style. Projects that still rely on this internal helper must include ``esp_private/socket.h`` and should be aware that the API may change without notice.
- Legacy VFS APIs (such as ``esp_vfs_register``) that operate on ``esp_vfs_t`` instead of ``esp_vfs_fs_ops_t`` are deprecated and will be removed in the next major release. Switch to the new ``esp_vfs_fs_ops_t``-based APIs.
``esp_vfs_console``
docs/zh_CN/api-reference/storage/vfs.rst
+1 -5
View File
@@ -17,10 +17,6 @@ VFS 组件支持 C 库函数（如 fopen 和 fprintf 等）与文件系统 (FS)
注册 FS 驱动程序
---------------------
.. note::
有关先前版本 API（使用 :cpp:type:`esp_vfs_t`）的内容，可以查阅之前发布的文档。
如需注册 FS 驱动程序，应用程序首先要定义一个 :cpp:type:`esp_vfs_fs_ops_t` 结构体实例，并用指向 FS API 的函数指针填充它。
.. highlight:: c
@@ -79,7 +75,7 @@ VFS 组件支持 C 库函数（如 fopen 和 fprintf 等）与文件系统 (FS)
ssize_t myfs_write(myfs_t* fs, int fd, const void * data, size_t size);
// 在 esp_vfs_t 的定义中：
// 在 esp_vfs_fs_ops_t 的定义中：
.write_p = &myfs_write,
// ... 初始化其他成员
docs/zh_CN/migration-guides/release-6.x/6.0/storage.rst
+2
View File
@@ -14,6 +14,8 @@ VFS
- 位于 ``vfs`` 组件中已弃用的 UART-VFS 函数 ``esp_vfs_dev_uart_*`` 现已删除，请改用 UART 驱动中的 API：``uart_vfs_dev_*``。
- 位于 ``vfs`` 组件中已弃用的 USB-Serial-JTAG-VFS 函数 ``esp_vfs_dev_usb_serial_jtag_*`` 现已删除，请改用 USB-Serial-JTAG 驱动中的 API：``usb_serial_jtag_vfs_*``。
- ``esp_vfs_register_fd_range`` 现被视为私有接口，其函数签名已调整为匹配新的 VFS API 风格。仍依赖此内部辅助函数的项目需包含 ``esp_private/socket.h`` 头文件，并请注意该 API 可能在不另行通知的情况下发生变更。
- 基于 ``esp_vfs_t`` 而非 ``esp_vfs_fs_ops_t`` 的传统 VFS API（如 ``esp_vfs_register``）已弃用，并将在下一个主版本中移除。请迁移至基于 ``esp_vfs_fs_ops_t`` 的新 API。
``esp_vfs_console``
examples/peripherals/usb/device/tusb_composite_msc_serialdevice/main/idf_component.yml
+1 -1
View File
@@ -1,4 +1,4 @@
## IDF Component Manager Manifest File
dependencies:
espressif/esp_tinyusb:
version: "^2.0.0"
version: "^2.0.1~1"
examples/peripherals/usb/device/tusb_console/main/idf_component.yml
+1 -1
View File
@@ -1,4 +1,4 @@
## IDF Component Manager Manifest File
dependencies:
espressif/esp_tinyusb:
version: "^2.0.0"
version: "^2.0.1~1"
examples/peripherals/usb/device/tusb_serial_device/main/idf_component.yml
+1 -1
View File
@@ -1,4 +1,4 @@
## IDF Component Manager Manifest File
dependencies:
espressif/esp_tinyusb:
version: "^2.0.0"
version: "^2.0.1~1"
tools/test_apps/storage/std_filesystem/main/test_status.cpp
+42 -9
View File
@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2024-2025 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@@ -81,15 +81,48 @@ static int test_vfs_closedir(void* ctx, DIR* pdir)
TEST_CASE("std::filesystem status functions")
{
test_vfs_ctx_t test_ctx = {};
esp_vfs_t desc = {};
desc.flags = ESP_VFS_FLAG_CONTEXT_PTR;
desc.open_p = test_vfs_open;
desc.stat_p = test_vfs_stat;
desc.opendir_p = test_vfs_opendir;
desc.readdir_p = test_vfs_readdir;
desc.closedir_p = test_vfs_closedir;
esp_vfs_dir_ops_t dir_desc = {
.stat_p = test_vfs_stat,
.link_p = nullptr,
.unlink_p = nullptr,
.rename_p = nullptr,
.opendir_p = test_vfs_opendir,
.readdir_p = test_vfs_readdir,
.readdir_r_p = nullptr,
.telldir_p = nullptr,
.seekdir_p = nullptr,
.closedir_p = test_vfs_closedir,
.mkdir_p = nullptr,
.rmdir_p = nullptr,
.access_p = nullptr,
.truncate_p = nullptr,
.ftruncate_p = nullptr,
.utime_p = nullptr,
};
REQUIRE(esp_vfs_register("/test", &desc, &test_ctx) == ESP_OK);
esp_vfs_fs_ops_t desc = {
.write_p = nullptr,
.lseek_p = nullptr,
.read_p = nullptr,
.pread_p = nullptr,
.pwrite_p = nullptr,
.open_p = test_vfs_open,
.close_p = nullptr,
.fstat_p = nullptr,
.fcntl_p = nullptr,
.ioctl_p = nullptr,
.fsync_p = nullptr,
.dir = &dir_desc,
#ifdef CONFIG_VFS_SUPPORT_TERMIOS
.termios = nullptr,
#endif
#if CONFIG_VFS_SUPPORT_SELECT || defined __DOXYGEN__
.select = nullptr,
#endif
};
REQUIRE(esp_vfs_register_fs("/test", &desc, ESP_VFS_FLAG_CONTEXT_PTR, &test_ctx) == ESP_OK);
SECTION("Test file exists") {
test_ctx.cmp_path = "/file.txt";