From a320fed3b5fd55a7e914ac9a6630d22b6d2ebc06 Mon Sep 17 00:00:00 2001 From: Angus Gratton Date: Wed, 4 Oct 2017 09:24:40 +1100 Subject: [PATCH 1/7] vfs: Add ioctl() to filesystem set --- components/vfs/include/esp_vfs.h | 4 ++++ components/vfs/vfs.c | 17 +++++++++++++++++ 2 files changed, 21 insertions(+) diff --git a/components/vfs/include/esp_vfs.h b/components/vfs/include/esp_vfs.h index 6ced2ce2b..fcd2e66bb 100644 --- a/components/vfs/include/esp_vfs.h +++ b/components/vfs/include/esp_vfs.h @@ -145,6 +145,10 @@ typedef struct int (*fcntl_p)(void* ctx, int fd, int cmd, va_list args); int (*fcntl)(int fd, int cmd, va_list args); }; + union { + int (*ioctl_p)(void* ctx, int fd, int cmd, va_list args); + int (*ioctl)(int fd, int cmd, va_list args); + }; } esp_vfs_t; diff --git a/components/vfs/vfs.c b/components/vfs/vfs.c index f07bf7c37..c307fdef1 100644 --- a/components/vfs/vfs.c +++ b/components/vfs/vfs.c @@ -489,3 +489,20 @@ int fcntl(int fd, int cmd, ...) va_end(args); return ret; } + +int ioctl(int fd, int cmd, ...) +{ + const vfs_entry_t* vfs = get_vfs_for_fd(fd); + struct _reent* r = __getreent(); + if (vfs == NULL) { + __errno_r(r) = EBADF; + return -1; + } + int local_fd = translate_fd(vfs, fd); + 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; +} From 3ebf7923d3d4370bc5e8a823fd1ae209bb2b8bc3 Mon Sep 17 00:00:00 2001 From: Angus Gratton Date: Tue, 3 Oct 2017 16:56:55 +1100 Subject: [PATCH 2/7] lwip: Route LWIP socket POSIX I/O functions via IDF VFS layer No more conflicts between LWIP & newlib read(), write(), fcntl(), etc. select() still only works if all of the fds are sockets. Closes https://github.com/espressif/esp-idf/issues/273 --- .../lwip/include/lwip/port/arch/sys_arch.h | 1 + .../lwip/include/lwip/port/arch/vfs_lwip.h | 28 +++++++ components/lwip/include/lwip/port/lwipopts.h | 14 ++++ components/lwip/port/freertos/sys_arch.c | 1 + components/lwip/port/vfs_lwip.c | 78 +++++++++++++++++++ components/vfs/include/esp_vfs.h | 33 +++++++- components/vfs/vfs.c | 49 +++++++++--- 7 files changed, 193 insertions(+), 11 deletions(-) create mode 100644 components/lwip/include/lwip/port/arch/vfs_lwip.h create mode 100644 components/lwip/port/vfs_lwip.c diff --git a/components/lwip/include/lwip/port/arch/sys_arch.h b/components/lwip/include/lwip/port/arch/sys_arch.h index 716fd9fa5..bb7ea18af 100644 --- a/components/lwip/include/lwip/port/arch/sys_arch.h +++ b/components/lwip/include/lwip/port/arch/sys_arch.h @@ -37,6 +37,7 @@ #include "freertos/task.h" #include "freertos/queue.h" #include "freertos/semphr.h" +#include "arch/vfs_lwip.h" #ifdef __cplusplus extern "C" { diff --git a/components/lwip/include/lwip/port/arch/vfs_lwip.h b/components/lwip/include/lwip/port/arch/vfs_lwip.h new file mode 100644 index 000000000..59ed087c5 --- /dev/null +++ b/components/lwip/include/lwip/port/arch/vfs_lwip.h @@ -0,0 +1,28 @@ +// Copyright 2017 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifdef __cplusplus +extern "C" { +#endif + +/* Internal declarations used to ingreate LWIP port layer + to ESP-IDF VFS for POSIX I/O. +*/ +extern unsigned lwip_socket_offset; + +void esp_vfs_lwip_sockets_register(); + +#ifdef __cplusplus +} +#endif diff --git a/components/lwip/include/lwip/port/lwipopts.h b/components/lwip/include/lwip/port/lwipopts.h index 47b80ff61..907f7db2e 100644 --- a/components/lwip/include/lwip/port/lwipopts.h +++ b/components/lwip/include/lwip/port/lwipopts.h @@ -34,6 +34,7 @@ #include #include +#include #include #include #include "esp_task.h" @@ -687,6 +688,19 @@ #define ETHARP_TRUST_IP_MAC CONFIG_LWIP_ETHARP_TRUST_IP_MAC +/** + * POSIX I/O functions are mapped to LWIP via the VFS layer + * (see port/vfs_lwip.c) + */ +#define LWIP_POSIX_SOCKETS_IO_NAMES 0 + + +/** + * Socket offset is also determined via the VFS layer at + * filesystem registration time (see port/vfs_lwip.c) + */ +#define LWIP_SOCKET_OFFSET lwip_socket_offset + /* Enable all Espressif-only options */ #define ESP_LWIP 1 diff --git a/components/lwip/port/freertos/sys_arch.c b/components/lwip/port/freertos/sys_arch.c index 5f1ca0898..6f14a3a29 100755 --- a/components/lwip/port/freertos/sys_arch.c +++ b/components/lwip/port/freertos/sys_arch.c @@ -433,6 +433,7 @@ sys_init(void) if (ERR_OK != sys_mutex_new(&g_lwip_protect_mutex)) { ESP_LOGE(TAG, "sys_init: failed to init lwip protect mutex\n"); } + esp_vfs_lwip_sockets_register(); } /*-----------------------------------------------------------------------------------*/ diff --git a/components/lwip/port/vfs_lwip.c b/components/lwip/port/vfs_lwip.c new file mode 100644 index 000000000..b1f064c33 --- /dev/null +++ b/components/lwip/port/vfs_lwip.c @@ -0,0 +1,78 @@ +// Copyright 2017 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include +#include +#include +#include +#include +#include +#include "esp_vfs.h" +#include "esp_vfs_dev.h" +#include "esp_attr.h" +#include "soc/uart_struct.h" +#include "lwip/sockets.h" +#include "sdkconfig.h" + +/* LWIP is a special case for VFS use. + + From the LWIP side: + - We set LWIP_SOCKET_OFFSET dynamically at VFS registration time so that native LWIP socket functions & VFS functions + see the same fd space. This is necessary to mix POSIX file operations defined in VFS with POSIX socket operations defined + in LWIP, without needing to wrap all of them. + + From the VFS side: + - ESP_VFS_FLAG_SHARED_FD_SPACE is set, so unlike other VFS implementations the FDs that the LWIP "VFS" sees and the + FDs that the user sees are the same FDs. +*/ + +unsigned lwip_socket_offset; + +static int lwip_fcntl_r_wrapper(int fd, int cmd, va_list args); +static int lwip_ioctl_r_wrapper(int fd, int cmd, va_list args); + +void esp_vfs_lwip_sockets_register() +{ + esp_vfs_t vfs = { + .fd_offset = 0, + .flags = ESP_VFS_FLAG_DEFAULT | ESP_VFS_FLAG_SHARED_FD_SPACE, + .write = &lwip_write_r, + .open = NULL, + .fstat = NULL, + .close = &lwip_close_r, + .read = &lwip_read_r, + .fcntl = &lwip_fcntl_r_wrapper, + .ioctl = &lwip_ioctl_r_wrapper, + }; + unsigned max_fd; + + ESP_ERROR_CHECK(esp_vfs_register_socket_space(&vfs, NULL, &lwip_socket_offset, &max_fd)); + + /* LWIP can't be allowed to create more sockets than fit in the per-VFS fd space. Currently this isn't configurable + * but it's set much larger than CONFIG_LWIP_MAX_SOCKETS should ever be (max 2^12 FDs). + */ + assert(CONFIG_LWIP_MAX_SOCKETS <= max_fd - lwip_socket_offset); +} + +static int lwip_fcntl_r_wrapper(int fd, int cmd, va_list args) +{ + return lwip_fcntl_r(fd, cmd, va_arg(args, int)); +} + +static int lwip_ioctl_r_wrapper(int fd, int cmd, va_list args) +{ + return lwip_ioctl_r(fd, cmd, va_arg(args, void *)); +} + + diff --git a/components/vfs/include/esp_vfs.h b/components/vfs/include/esp_vfs.h index fcd2e66bb..6a8ed3306 100644 --- a/components/vfs/include/esp_vfs.h +++ b/components/vfs/include/esp_vfs.h @@ -43,6 +43,21 @@ extern "C" { */ #define ESP_VFS_FLAG_CONTEXT_PTR 1 +/** + * Flag which indicates that the FD space of the VFS implementation should be made + * the same as the FD space in newlib. This means that the normal masking off + * of VFS-independent fd bits is ignored and the full user-facing fd is passed to + * the VFS implementation. + * + * Set the p_minimum_fd & p_maximum_fd pointers when registering the socket in + * order to know what range of FDs can be used with the registered VFS. + * + * This is mostly useful for LWIP which shares the socket FD space with + * socket-specific functions. + * + */ +#define ESP_VFS_FLAG_SHARED_FD_SPACE 2 + /** * @brief VFS definition structure * @@ -68,7 +83,7 @@ extern "C" { typedef struct { int fd_offset; /*!< file descriptor offset, determined by the FS driver */ - int flags; /*!< ESP_VFS_FLAG_CONTEXT_PTR or ESP_VFS_FLAG_DEFAULT */ + int flags; /*!< ESP_VFS_FLAG_CONTEXT_PTR or ESP_VFS_FLAG_DEFAULT, plus optionally ESP_VFS_FLAG_SHARED_FD_SPACE */ union { ssize_t (*write_p)(void* p, int fd, const void * data, size_t size); ssize_t (*write)(int fd, const void * data, size_t size); @@ -174,6 +189,22 @@ 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. + * + * 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 p_min_fd If non-NULL, on success this variable is written with the minimum (global/user-facing) FD that this VFS will use. This is useful when ESP_VFS_FLAG_SHARED_FD_SPACE is set in vfs->flags. + * @param p_max_fd If non-NULL, on success this variable is written with one higher than the maximum (global/user-facing) FD that this VFS will use. This is useful when ESP_VFS_FLAG_SHARED_FD_SPACE is set in vfs->flags. + * + * @return ESP_OK if successful, ESP_ERR_NO_MEM if too many VFSes are + * registered. + */ +esp_err_t esp_vfs_register_socket_space(const esp_vfs_t *vfs, void *ctx, unsigned *p_min_fd, unsigned *p_max_fd); + /** * Unregister a virtual filesystem for given path prefix * diff --git a/components/vfs/vfs.c b/components/vfs/vfs.c index c307fdef1..f3624259b 100644 --- a/components/vfs/vfs.c +++ b/components/vfs/vfs.c @@ -41,6 +41,8 @@ #define VFS_INDEX_MASK (VFS_MAX_COUNT << CONFIG_MAX_FD_BITS) #define VFS_INDEX_S CONFIG_MAX_FD_BITS +#define LEN_PATH_PREFIX_IGNORED SIZE_MAX /* special length value for VFS which is never recognised by open() */ + typedef struct vfs_entry_ { esp_vfs_t vfs; // contains pointers to VFS functions char path_prefix[ESP_VFS_PATH_MAX]; // path prefix mapped to this VFS @@ -52,14 +54,15 @@ typedef struct vfs_entry_ { static vfs_entry_t* s_vfs[VFS_MAX_COUNT] = { 0 }; static size_t s_vfs_count = 0; -esp_err_t esp_vfs_register(const char* base_path, const esp_vfs_t* vfs, void* ctx) +static esp_err_t esp_vfs_register_common(const char* base_path, size_t len, const esp_vfs_t* vfs, void* ctx, unsigned *p_minimum_fd, unsigned *p_maximum_fd) { - size_t len = strlen(base_path); - if ((len != 0 && len < 2)|| len > ESP_VFS_PATH_MAX) { - return ESP_ERR_INVALID_ARG; - } - if ((len > 0 && base_path[0] != '/') || base_path[len - 1] == '/') { - return ESP_ERR_INVALID_ARG; + if (len != LEN_PATH_PREFIX_IGNORED) { + if ((len != 0 && len < 2) || (len > ESP_VFS_PATH_MAX)) { + return ESP_ERR_INVALID_ARG; + } + if ((len > 0 && base_path[0] != '/') || base_path[len - 1] == '/') { + return ESP_ERR_INVALID_ARG; + } } vfs_entry_t *entry = (vfs_entry_t*) malloc(sizeof(vfs_entry_t)); if (entry == NULL) { @@ -79,14 +82,36 @@ esp_err_t esp_vfs_register(const char* base_path, const esp_vfs_t* vfs, void* ct ++s_vfs_count; } s_vfs[index] = entry; - strcpy(entry->path_prefix, base_path); // we have already verified argument length + if (len != LEN_PATH_PREFIX_IGNORED) { + strcpy(entry->path_prefix, base_path); // we have already verified argument length + } else { + bzero(entry->path_prefix, sizeof(entry->path_prefix)); + } memcpy(&entry->vfs, vfs, sizeof(esp_vfs_t)); entry->path_prefix_len = len; entry->ctx = ctx; entry->offset = index; + + if (p_minimum_fd != NULL) { + *p_minimum_fd = index << VFS_INDEX_S; + } + if (p_maximum_fd != NULL) { + *p_maximum_fd = (index + 1) << VFS_INDEX_S; + } + return ESP_OK; } +esp_err_t esp_vfs_register(const char* base_path, const esp_vfs_t* vfs, void* ctx) +{ + return esp_vfs_register_common(base_path, strlen(base_path), vfs, ctx, NULL, NULL); +} + +esp_err_t esp_vfs_register_socket_space(const esp_vfs_t *vfs, void *ctx, unsigned *p_min_fd, unsigned *p_max_fd) +{ + return esp_vfs_register_common("", LEN_PATH_PREFIX_IGNORED, vfs, ctx, p_min_fd, p_max_fd); +} + esp_err_t esp_vfs_unregister(const char* base_path) { for (size_t i = 0; i < s_vfs_count; ++i) { @@ -114,7 +139,11 @@ static const vfs_entry_t* get_vfs_for_fd(int fd) static int translate_fd(const vfs_entry_t* vfs, int fd) { - return (fd & VFS_FD_MASK) + vfs->vfs.fd_offset; + if (vfs->vfs.flags & ESP_VFS_FLAG_SHARED_FD_SPACE) { + return fd + vfs->vfs.fd_offset; + } else { + return (fd & VFS_FD_MASK) + vfs->vfs.fd_offset; + } } static const char* translate_path(const vfs_entry_t* vfs, const char* src_path) @@ -134,7 +163,7 @@ static const vfs_entry_t* get_vfs_for_path(const char* path) size_t len = strlen(path); for (size_t i = 0; i < s_vfs_count; ++i) { const vfs_entry_t* vfs = s_vfs[i]; - if (!vfs) { + if (!vfs || vfs->path_prefix_len == LEN_PATH_PREFIX_IGNORED) { continue; } // match path prefix From 48d9d507aaf50bbac023ac9fa888cb28c6bdf2c8 Mon Sep 17 00:00:00 2001 From: Angus Gratton Date: Wed, 4 Oct 2017 09:53:06 +1100 Subject: [PATCH 3/7] newlib: Remove fcntl() implementation from libc Allows fcntl() implementation in vfs to be used. Closes https://github.com/espressif/esp-idf/issues/1070 Note this is different to the other libc file-related syscalls, as there is no reent structure involved. --- components/newlib/lib/libc-psram-workaround.a | Bin 5930838 -> 5925086 bytes components/newlib/lib/libc.a | Bin 5022558 -> 5016906 bytes components/newlib/lib/libc_nano.a | Bin 3569308 -> 3563656 bytes components/newlib/libc_discard.list | 2 ++ 4 files changed, 2 insertions(+) diff --git a/components/newlib/lib/libc-psram-workaround.a b/components/newlib/lib/libc-psram-workaround.a index cddebee59ec65d9eefd798f6af5b67ede0b476b8..27557575ae29a8a1908365d368c67e192e8dbecf 100644 GIT binary patch delta 4468 zcmbu>4^&iD9tZI6%{yORm!ptZG%s+-fK!|W=m{B7o9AJPc$*`=wSy2fQNGPX&4C(-4sU^2 z+ye3RW+pomV!;}k6FjG8_Vqw4_#^@nNf#s$gOI4qkR;VJ&Q?eS>ov@?*^s>If~2zz zl8HL_1XjbxY=e*OB7Bxj!p9>t)!p!^%Y@J7F8Dl4ac>KJPBy|9M)-!d!&f=RXb0h& zF#_L3Quw+emIxfQh zfD8V|j>CVv8UZ1l2vC(HAoU^w91YBxNd#2pB4DE%0lyzYKzk(u_BApi?Fb-&vusRG z83OMaK;Y(T1n!(f;L)y2JP1-YF-!UpV6B$A>YEgani$WVRY1Io-@tl?V}hF7}d! z2f-_?2~xqTY^EU(Qo*h+W|Sfc^~`W1^pbozLIssl=1)$93XYh)!ouC~vNj>?h8U)< z9ASbtMwvrv5k|r_eF)DRWY)GL{J~yk>v4n&23%gAi0EEK+~LRkrVlqThx~C3 z(@_Qa9_oM45BaCm7o1W<{%s!=qP0*+)lkfCgF@d8MOGaYH#R|WcOw+*tD$&w6pE)R zpm>@39raN3G(+)`28!WaD9*^dq9tYUiqAzf@kB3^BYL?T(bXe}eyxHTkRnE#t=}Ax)Q@o=Y%9<)DxgYHwfUR- zjJdHrOinxI7D%u4W*X)SK3T;~Wg;%Tnn}+_oWR}5)M*eW*w&4>y%F%lounkuMAk7G zozMtYXqk;w&!2d~E55AX37ueK+)J+fU{2J(2ltI6C4ElPS zf4-jS3xZy7j>g2GbTf;3VYs~s29MCxx4^)4{DgfYYnqjD6+^l}&- z^)MDWVO-e-SU8ZX|E5M)I54NZ#FcnVD;b z`RyR)PzB6?%Z2&d^+-v$$lTJ6lr>{W**fkK8l-$&gOn3$qx*fywo%P)HLRb=U_C`O=gMIVSjf;8 z*vx*gT_)oX(c_Npz+A7Wq^91LR4kHJnHv8%m2j>W_9TI+)2 zM~h;EaJ9uUH3T<&D!)eVKqCZ8Q*77ByWb2!{{HG~I72n?N|VDWSRUaK8aN+OGq2I4 z;G;q20v$jK)Sb+dJQN7%=JaZ;M1g=l$-T~~Q9ueKa+!?vC=}c^j=~K_6h1c0Y%51$ zPYVhMJQ@@pv!U>86$&ToQ551v(d=BtHi9C-fjks_5rLxb%Hfg>z$L4LD_#v(+5}vS z(%^CpGn<@nJyQwSt3k{Mop2o$^# zO5g8h&QlF>D;pqjFB$H5B;>rjqdH-Szt}XtBg=Fwc%w0^)|e$CVj>|v#FzLHf8LlC zkbb0gnJSP3kzg{7gb*nSC1E6-M36`lMWz!OnL%cfSwv10B$~`7F(j5KiHfMn95R>0 z5e2|a)3kfkAv+qPe4^TxYAo4Ni~}s zotqXu`notZojZDBhMw<8T{JquJ({}6P}`?p%=hVU=D@1I(@*Cn)gG?NBRBDfYw}g4;?(5YsiXP))X`r zVQKaJx$=U^rQH7V0t2t!R-i}}n@s$Ip@On_?)o8`>k}15_Hr+X3TaK>FD%~7ee{^a zz}J@+?cT%PR$64>E9I_XrzD*&D%R;^;2*o!^^bgUvUlHT0lHmjJH#n;iO*&k_?a7u zw^xW$Q}}}?ipN8_11E}UpT8>}(Q|JmWf*z!oRZhVxI^j^13#2f^8Gzxa|U-*C(`qh ottBWzx%c*zCh;{Z-5)Cc2^ExVFaQ7m delta 5231 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 Q1@8^zHnF0$Jbv!K0YWNadH?_b delta 4315 zcmb8v4_H&@y$A5`ISC1bKLM1)CKy5p0g(gI%_<5t?Sj@^e&o%FsZukG-; zf1cj+p0V51F!huFmtvIyy6O-Q>wUgP?^I}Euz^w!>mt$ zYTFo84^2VU(F;|$AF8*?pc;M}snsU{5pF6@f|kiwHd^}8Hh;W zU5Lo)MS`MckU2#2JB`dI<4E|^aD?8_h6sNMdc}bf=5#akit(w4#1sP}$_9|A2yS&F zQSqCPk)$eR1RatTcTF>`SCOPRVnWjSUS_fZ$*}|9j8uYT#Vc2t55h=3PuE^Kf}j%S zrIsn=g-wLo1)1!>69F=YlUczEz@rcJ#tZEJ(+!AY3fhnYhSFe!dcYl>g3 zi!f`}!5rTQ^ZZ$uQ)^+)I0AFd49xBT%qw&-Z)$`2{v7666U@h^m>}K2toTb0Qlndt zN*}q@Wut$yWeTY+v=*}c|NL$Msoy~Gn>5YsS$N2Thn&P!E(ta_3v?(dVYHEUYNf}e`hE=hb z))dD)%=-aYf7J`?)lsDDr;u(eW0qQwzN(qo8AiI|86N3K6DOtsR#Ch>tKJ;1pCPn*xyfp{c<<# zpEtvPr4E^z8OAk^OvRlN^LP(372%W2=m;_?2iM0eZh@ny?k2&T3g7OBqfrOP!zMU7 zjz(m~)g#LiLY8YCvbLZ6TJ|a%vhN*5c1tU=r3Pf5>PGf(8?tA6u_$5szsc!$VXno8 zTH##n3c{5)jr{M_qTnBUQTT2vivIdBg!mDrWDJ60%P53h9T3_EA#@Hvc+mkN?1nJd z2jMKOT^xt-c@BgxXW*IF0*~z!JZ=L#RfF)XFM((K1U$P&nBHM{z80jD3w6wF8@%x+ z;Z2=_H{S+tSrfds<}i&RcojdIfcK{*%!hZttN80kgwIiih?+a#Q#{zj^oHQOp`@Y_ zb1exLAH@=C>CEI!mQ9(USV0%ewX(GzidAQBRzA;zh~goXD>l_J?HZITe%ix)IEiw_ zHA6(O!rp<1S`8``yY?{8^`S!X_EF~3aa2(Lg^iUU5WJ(SMy) z#ph5}Wn%8T8&!{1psKU}Tc?xl`B&7AK;wc;}#)mOu)(HT&4OBrgi??#Q+!Zb9aMiH{S z{I>3Nidt;iwd3WWwMnD$iCL1EEs2XHF-H;?OJc4hIwjF1iFuNkFNp<`=$6DnNh~@k3jHypZ;z0#DinOA zAc5nD7 zd;MDS$D}|sDcGP&A-}CNEYrS47xQ?5q&KJLku`0CmXw|l);jUPcOQtHp-Tka^q%JC zrti46(oT9sMWQN}Q>kNA;8ZH|X09reoiN#4V<}hmiBr+P0CIMvcRhJ*r|>Q9#*L9Z z$fXwqkE&tEW_jfX!;d+6;5~gbcd%K%;Fh`X7Tqr=0T#*R2}1T$;J-< zZJdvs=Bpq$bvV=~-M1xftRc+z8Px=d$=6F{JZLgM*({cdaRR@E4=VMP-_(C2tHZ zOqE~RAzX~^86DOryb;YncpeTepK<&4&|6$4`=7f z|61lB3z0_;R66DHv;OB^SB}Xk_Z_Hgyj@k4@9En3Dm}{IRlai@@Ai=3FU>BwxUlN{ zXMB;+^}#1jd4)A_-9s)l1e|i?w*n98d7oSPedNS@1Fvo-l@|godFB^^wTZktpX_hV ocFMai1onDJfvUzSI})p7|4ia{(_y`;=EN@E>yh=lYnG(^7gbFM`~Uy| diff --git a/components/newlib/lib/libc_nano.a b/components/newlib/lib/libc_nano.a index 9afd3798782c23c019833df6f472063fbc31fea0..09029a21c12682b5d613da3999701111f6415012 100644 GIT binary patch delta 3036 zcmcK5eNYtV9S895?H%A92OMyV9P)CPnrR_DI zk>+qjK|>N8sf*2Z#D-dup)D$PaWoZE6G=jRsU%{HFHtmPf(eZz;>b+<>^@D9PAAiU zx-*~W_uc3D?eoXZJiC!QmlchtE-RW-!w%!rMf1a>(dhR%e6*uX129X0yi%Yrl?qsa zHFd!DYT(cb>IM&m;WQLn4-^GfD3)|Wv0?&>iUBA#g`n7JgrfC26n`LV?}po=g?4lwIvZl;1E=Iil&KL-HiY0xgkXD8Aa6Z ztcdEVL)67eMBVO1)B`P|HLEFS1)?7fA$l>nuOwCSf`jTFL-Z93VwfPpFTR_0UM(>!a=kp&??8wbXJQVkKLOsP+!TN-hOt+UOR@<`qLLsY-|T zCpFaJmC#Bqg=BHo5aI$xB20##wIZ&zjym8+oaC=XviMnJkQG}IFWJye?e9mt_viPxI?B>cR|LVhwiDBRQTuV(CrQWPZD)wkQH_zQSxLZ5}yhp zvA&c#IDtgTJHymxJxC;yk_V=Ywjt>u;fHUMH;rJLH)bID(tIS}D*aaaL#OeLx5uFW z+NblOzaIjty$+T=4|cW=ta}jbqSas@w}9O^7zSG#1p7h@*nOm-BLcRk4D1;z*bgee z-dF(kiwRjuN*!c{?MRV4T}}NWgcQ;8jnoK`+CGfbLnTQ43r`L9AyqO#<_JSV54A8% z!ed$(0%b6KuM38?Dj1$Ag<(S{3|p#Ucx4!d&L(Q07KWPvSsK|u=AJ~_qCups*CTE7 z{3+x#q#Y)6@6><0@P9PS$}-~rVz3Ugh;*hG=^8!K*)CaF4qIE0{=pD3tO05%$=}Cx zN86Agxl)ac&ue6vnX4iD&PrrTsye9`dyyIGN9LO?)MvHGN(fM{1;~=DB6F*1!^k4% zS$3clSsk6oIy-`_o0G`;lsrHfbv%qS>!_k$7$ucD7@wb@4g_J8yju(7AX)oF597Ud znBrQeqyeVfHkb;EVJaSksk8>BsuM8n2R6Aeq{mI;Q-gu z0qzW$`|vur+g5O2j>D!7!j{?tn^g~6VJ~be{IHb|!&cQ#we-REuydubNyh8IE4#rb zje^fHg7;U0Uu31qn!@1An!uA|#=q*HuD=;PVc$_UP2RF1Nan7poW@Z)0NK{_a7bR$ zQs+pPeANmk`O`YtVK{TH!|Bt)xhPD+;{$M(N8qf{!AZUcvi31J3D?|oxQd$LdZGoc ziXON&S>b93!X*H%gX3@=4NxOSxW1Z%JGzMCn&6&S1NV0;r`yp6cVsnnF$j0~#(B8! zmcYY>;F*^W&oeDlL9QH;FbJxfO?IGR~&-(%mR2n ztcLei6TIWaGM_mD+0x>*<-w;z>w;Ljw&tfBfAr(>4M%pWKTbaKY(|HQaXXF}vp-jF zGw}^3UO_N~l28#*qKS`ot!+r&6HUYrGYB=IAz}$F5l6%m351SFB$9|^LQk+n3Ne#N zB@9FwF^fniGKfqfi!c%0{jaQY$Y;Jz=YQS-7;yW)~y3Y!56>QHM}Z8*sI~4;sXQU=n>vC@OH6l z8Na_u*tU$s+GD&eS6F_G#DN?9tH&6hPx$C|lwCX+v3H+Q=KHXJtH2;lf!xFS4zU_&LJIf+J5{ankX6wO~H! zu!~mSdG#fwzaU@OI-X<~eaD^qP6{!{opy2ZIoJ9XjN2zTuf^KMz5TAYmNQ_vw+^1vz1td#u!2kdN delta 3840 zcmcK6eQ*yn+s8FFT;q~gI z$Xhw8a#y&gqfyJzJBwDYyyzB1Xc2|e3grYv2BaczMao<`7^%qUJ-drSXPmqH=Q8v8 zJYmJ{-Yq_nMA53u<_b_5v1 z%fflU6ER?I4Y1>+?A!z})-Euv<6uVSfqC#Sm`6-tN_xR8+YDwyE|~gTVBVy2AGLuw z+Xv=av=gkp3T(0$Y)&=U@p-c8`Cy;qz%HZh+HzS_4OpQN><6V_PgCO@nkGOYX#4xJ6ADVHY=AO)vJc8D#r>#?n(>QP_Cd8- z3)QQ6P_@RO`g9Fc7f(a=eHPUEO3gXX-`6OZvk|3TcCTk1G<+j z(Cuu6?&K|rewYc8!Y1eoo1)M+7Rx?ugkJPxSQ3|22+5;8h!d^0$(q+7PIQ)&7zUI> z@+$`nqKZBkR^-dx@xmZFTOf(|79jqyTe9Cq5Wgl`L<6Q%}89}l~wg2@#QcQqhk0kjFt{a z#@E6qnw1CRf-sD=yzI^6Fp7?~$-dnTBQd#bi?SV1EbCBk8OKNmuy) z$h4;cKReO^(@(BhU}g$nHtmHuwHaov2jPYQUL>!w+(Dm))Qwf2q;<%p)7 zX+^4+lTD%hS*QEkSA|s3g$YQ#kuOPe=0Nh07ipr(8rhZ@(i)qP_EEX)+d`z@!^uXa zAYJqX&57vaOhu8tokx004bne5i1f=Rk$#OXpllW`Z0SX^{1|MaMLn>sJ1*NEhE4SM zLfE?KTyHOIKUO2d9JwRoG%|cu$Qb89MtCMf1nBW!ZO(B*TTN4 z81|RCVQ)ML`y0)$zdJ#8j@Dk*_7}Y?;Ycci!`2Fi?=T$W3S{pa;5d;B#|0&ZWR~3V zT_>DrHE?=3IPW#VS&;|lDleRG<-_?w1BTLny{xn>45QzMOWO?>{b!W?rWYJ9iI?8 zUEL*n?KIqXyHEx<#pySLvmORF4B&EkaFeRRP0N)nZ2-5lAqs9sAGkgF{hezBM|onA zezHpnAsW7*svqydZb-;^ct!hdvJ13N`3%kQCD+5}?t?G)I(+#y_@>deG};Z{vKIK( zIpEvUA$wN|ALYN_3;*;+_{*B$U)cfwv$^oUR0IDTCivge!rxIM`+-LwJ`sVGLfO~` z1j1_&m|fLhY&QZs%Vn2p5a>G(KB_AQKeiTp*bBa@Nw(7h{y;tW?u(0!exoV_qowrhUsYf6^S*)=HhpE@bC`i6V`4L3uvl!8)HD&dA(J$8mv zL5{X3FBRteH8qjd%oPt(nN7w`;+B%J24jq5&$8}PNoirgC~JvgeQ2Ya(okATN9n0J z%0R_a1E>Tlkup*PsU*ronW;h4J(PvAQpwa{Duqg=(x`OGMrBZ$l$~-=LntRTl*$r9 z8;AYw3fa5P-aIIl1m=wpv|Ovq4|=FS7r#$wLlbvKjQ30T>>nVL5qW ziZ7L{f61O6rSF|ku&QYcZM2$zI8v%o#gS4|DmNKolF?qIjdCyzjCKf(;>Soav5#p~ z%`Lerubxd;%4N(H&CJSqKMe}BI$A6)fX+#4oGKdFgu1KWxJj>HokCjbbqQoI$0U%~ zX8YoZ^FknjRGinDN#}_`9ND)dZ6MjSSZyK?P4yWx@6*Gu*h;oeWQLRK*Im;+SiEAf zbhEN&gC2QKW#z&}+4N0U+)yP&MI570>J(rU3bNx9+YtHQl5u71{UrRf%OL$E>Lv%C zAZ<^%3P>lf){^l-bx=9CZ00<2^=W1m+2k_YNbf5egYd^f-%X~j_hl_n*2P;$d4)@9 z{%L!ur9V#T9O_n#7)nkbF~>+liy}t4S8FUJ|A5PAixbZbI6yJd`2ihb|8~BU72Qo8sztIup<4c()i89${9K>w!de zbCQ3UeI6lqyZ7}nc4Sc6$~?$-<~j0Ci9cJg{n_{8el`%0@|Q~d^Cz=GzOH?TM|kFK z{|67VBY63;mZ$@#df1TxVe+*=)(Db1iXSdCx%g!XY``mIjN&iOB Date: Wed, 4 Oct 2017 10:18:10 +1100 Subject: [PATCH 4/7] lwip: Fix bug with LWIP_SOCKET_OFFSET & IGMP group support --- components/lwip/api/sockets.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/components/lwip/api/sockets.c b/components/lwip/api/sockets.c index 0da123839..b09cff19f 100755 --- a/components/lwip/api/sockets.c +++ b/components/lwip/api/sockets.c @@ -3139,13 +3139,14 @@ static void lwip_socket_drop_registered_memberships(int s) (default initialization is to 0) */ int sa = s + 1; int i; + struct lwip_sock *sock = get_socket(s); - LWIP_ASSERT("socket has no netconn", sockets[s].conn != NULL); + LWIP_ASSERT("socket has no netconn", sock->conn != NULL); for (i = 0; i < LWIP_SOCKET_MAX_MEMBERSHIPS; i++) { if (socket_multicast_memberships[i].sa == sa) { socket_multicast_memberships[i].sa = 0; - netconn_join_leave_group(sockets[s].conn, + netconn_join_leave_group(sock->conn, &socket_multicast_memberships[i].multi_addr, &socket_multicast_memberships[i].if_addr, NETCONN_LEAVE); From 541493d87769e0fa7fa128f7bdd0c2b5bcaa25d0 Mon Sep 17 00:00:00 2001 From: Angus Gratton Date: Wed, 4 Oct 2017 10:41:09 +1100 Subject: [PATCH 5/7] lwip: Check for underflow in FD_SET()/FD_GET() select() only works with LWIP sockets which have a high LWIP_SOCKET_OFFSET, so chance of accidental underflow is high. --- components/lwip/include/lwip/lwip/sockets.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/components/lwip/include/lwip/lwip/sockets.h b/components/lwip/include/lwip/lwip/sockets.h index cb458988a..10e8ace03 100755 --- a/components/lwip/include/lwip/lwip/sockets.h +++ b/components/lwip/include/lwip/lwip/sockets.h @@ -431,9 +431,9 @@ typedef struct ip_mreq { /* Make FD_SETSIZE match NUM_SOCKETS in socket.c */ #define FD_SETSIZE MEMP_NUM_NETCONN #define FDSETSAFESET(n, code) do { \ - if (((n) - LWIP_SOCKET_OFFSET < MEMP_NUM_NETCONN) && (((int)(n) - LWIP_SOCKET_OFFSET) >= 0)) { \ + if (n >= LWIP_SOCKET_OFFSET && ((n) - LWIP_SOCKET_OFFSET < MEMP_NUM_NETCONN) && (((int)(n) - LWIP_SOCKET_OFFSET) >= 0)) { \ code; }} while(0) -#define FDSETSAFEGET(n, code) (((n) - LWIP_SOCKET_OFFSET < MEMP_NUM_NETCONN) && (((int)(n) - LWIP_SOCKET_OFFSET) >= 0) ?\ +#define FDSETSAFEGET(n, code) (n >= LWIP_SOCKET_OFFSET && ((n) - LWIP_SOCKET_OFFSET < MEMP_NUM_NETCONN) && (((int)(n) - LWIP_SOCKET_OFFSET) >= 0) ?\ (code) : 0) #define FD_SET(n, p) FDSETSAFESET(n, (p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] |= (1 << (((n)-LWIP_SOCKET_OFFSET) & 7))) #define FD_CLR(n, p) FDSETSAFESET(n, (p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] &= ~(1 << (((n)-LWIP_SOCKET_OFFSET) & 7))) From 4a9d4587b735068cc9b5806a043494c78f4bfb9b Mon Sep 17 00:00:00 2001 From: Angus Gratton Date: Wed, 4 Oct 2017 10:55:54 +1100 Subject: [PATCH 6/7] vfs: Add C++ guards to esp_vfs_dev.h Closes https://github.com/espressif/esp-idf/issues/1069 --- components/vfs/include/esp_vfs_dev.h | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/components/vfs/include/esp_vfs_dev.h b/components/vfs/include/esp_vfs_dev.h index b51527fcf..b330b4c56 100644 --- a/components/vfs/include/esp_vfs_dev.h +++ b/components/vfs/include/esp_vfs_dev.h @@ -12,11 +12,14 @@ // See the License for the specific language governing permissions and // limitations under the License. -#ifndef __ESP_VFS_DEV_H__ -#define __ESP_VFS_DEV_H__ +#pragma once #include "esp_vfs.h" +#ifdef __cplusplus +extern "C" { +#endif + /** * @brief Line ending settings */ @@ -81,4 +84,6 @@ void esp_vfs_dev_uart_use_nonblocking(int uart_num); */ void esp_vfs_dev_uart_use_driver(int uart_num); -#endif //__ESP_VFS_DEV_H__ +#ifdef __cplusplus +} +#endif From 539262b5c2f186154092d727863dc39cb0c2ceee Mon Sep 17 00:00:00 2001 From: Angus Gratton Date: Tue, 10 Oct 2017 16:11:12 +1100 Subject: [PATCH 7/7] vfs: Remove fd_offset member This was intended for integrating LWIP, but a different approach was used. --- components/lwip/port/vfs_lwip.c | 1 - components/vfs/README.rst | 49 ++++++++++++++------------------ components/vfs/include/esp_vfs.h | 8 ++---- components/vfs/vfs.c | 7 ++--- components/vfs/vfs_uart.c | 1 - 5 files changed, 28 insertions(+), 38 deletions(-) diff --git a/components/lwip/port/vfs_lwip.c b/components/lwip/port/vfs_lwip.c index b1f064c33..b3c626192 100644 --- a/components/lwip/port/vfs_lwip.c +++ b/components/lwip/port/vfs_lwip.c @@ -45,7 +45,6 @@ static int lwip_ioctl_r_wrapper(int fd, int cmd, va_list args); void esp_vfs_lwip_sockets_register() { esp_vfs_t vfs = { - .fd_offset = 0, .flags = ESP_VFS_FLAG_DEFAULT | ESP_VFS_FLAG_SHARED_FD_SPACE, .write = &lwip_write_r, .open = NULL, diff --git a/components/vfs/README.rst b/components/vfs/README.rst index 943705539..2b2a6bc9f 100644 --- a/components/vfs/README.rst +++ b/components/vfs/README.rst @@ -22,7 +22,6 @@ To register an FS driver, application needs to define in instance of esp_vfs_t s :: esp_vfs_t myfs = { - .fd_offset = 0, .flags = ESP_VFS_FLAG_DEFAULT, .write = &myfs_write, .open = &myfs_open, @@ -43,7 +42,7 @@ Case 1: API functions are declared without an extra context pointer (FS driver i .flags = ESP_VFS_FLAG_DEFAULT, .write = &myfs_write, // ... other members initialized - + // When registering FS, context pointer (third argument) is NULL: ESP_ERROR_CHECK(esp_vfs_register("/data", &myfs, NULL)); @@ -55,7 +54,7 @@ Case 2: API functions are declared with an extra context pointer (FS driver supp .flags = ESP_VFS_FLAG_CONTEXT_PTR, .write_p = &myfs_write, // ... other members initialized - + // When registering FS, pass the FS context pointer into the third argument // (hypothetical myfs_mount function is used for illustrative purposes) myfs_t* myfs_inst1 = myfs_mount(partition1->offset, partition1->size); @@ -100,37 +99,34 @@ File descriptors It is suggested that filesystem drivers should use small positive integers as file descriptors. VFS component assumes that ``CONFIG_MAX_FD_BITS`` bits (12 by default) are sufficient to represent a file descriptor. -If filesystem is configured with an option to offset all file descriptors by a constant value, such value should be passed to ``fd_offset`` field of ``esp_vfs_t`` structure. VFS component will then remove this offset when working with FDs of that specific FS, bringing them into the range of small positive integers. +While file descriptors returned by VFS component to newlib library are rarely seen by the application, the following details may be useful for debugging purposes. File descriptors returned by VFS component are composed of two parts: FS driver ID, and the actual file descriptor. Because newlib stores file descriptors as 16-bit integers, VFS component is also limited by 16 bits to store both parts. -While file descriptors returned by VFS component to newlib library are rarely seen by the application, the following details may be useful for debugging purposes. File descriptors returned by VFS component are composed of two parts: FS driver ID, and the actual file descriptor. Because newlib stores file descriptors as 16-bit integers, VFS component is also limited by 16 bits to store both parts. +Lower ``CONFIG_MAX_FD_BITS`` bits are used to store zero-based file descriptor. The per-filesystem FD obtained from the FS ``open`` call, and this result is stored in the lower bits of the FD. Higher bits are used to save the index of FS in the internal table of registered filesystems. -Lower ``CONFIG_MAX_FD_BITS`` bits are used to store zero-based file descriptor. If FS driver has a non-zero ``fd_offset`` field, this ``fd_offset`` is subtracted FDs obtained from the FS ``open`` call, and the result is stored in the lower bits of the FD. Higher bits are used to save the index of FS in the internal table of registered filesystems. - -When VFS component receives a call from newlib which has a file descriptor, this file descriptor is translated back to the FS-specific file descriptor. First, higher bits of FD are used to identify the FS. Then ``fd_offset`` field of the FS is added to the lower ``CONFIG_MAX_FD_BITS`` bits of the fd, and resulting FD is passed to the FS driver. +When VFS component receives a call from newlib which has a file descriptor, this file descriptor is translated back to the FS-specific file descriptor. First, higher bits of FD are used to identify the FS. Then only the lower ``CONFIG_MAX_FD_BITS`` bits of the fd are masked in, and resulting FD is passed to the FS driver. .. highlight:: none :: FD as seen by newlib FD as seen by FS driver - +-----+ - +-------+---------------+ | | +------------------------+ - | FS id | Zero—based FD | +---------------> sum +----> | - +---+---+------+--------+ | | | +------------------------+ - | | | +--^--+ - | +--------------+ | - | | - | +-------------+ | - | | Table of | | - | | registered | | - | | filesystems | | - | +-------------+ +-------------+ | - +-------> entry +----> esp_vfs_t | | - index +-------------+ | structure | | - | | | | | - | | | + fd_offset +---+ - +-------------+ | | - +-------------+ + + +-------+---------------+ +------------------------+ + | FS id | Zero—based FD | +--------------------------> | + +---+---+------+--------+ | +------------------------+ + | | | + | +--------------+ + | + | +-------------+ + | | Table of | + | | registered | + | | filesystems | + | +-------------+ +-------------+ + +-------> entry +----> esp_vfs_t | + index +-------------+ | structure | + | | | | + | | | | + +-------------+ +-------------+ Standard IO streams (stdin, stdout, stderr) @@ -170,4 +166,3 @@ Such a design has the following consequences: - It is possible to set ``stdin``, ``stdout``, and ``stderr`` for any given task without affecting other tasks, e.g. by doing ``stdin = fopen("/dev/uart/1", "r")``. - Closing default ``stdin``, ``stdout``, or ``stderr`` using ``fclose`` will close the ``FILE`` stream object — this will affect all other tasks. - To change the default ``stdin``, ``stdout``, ``stderr`` streams for new tasks, modify ``_GLOBAL_REENT->_stdin`` (``_stdout``, ``_stderr``) before creating the task. - diff --git a/components/vfs/include/esp_vfs.h b/components/vfs/include/esp_vfs.h index 6a8ed3306..bd1cf322c 100644 --- a/components/vfs/include/esp_vfs.h +++ b/components/vfs/include/esp_vfs.h @@ -64,10 +64,9 @@ extern "C" { * This structure should be filled with pointers to corresponding * FS driver functions. * - * If the FS implementation has an option to use certain offset for - * all file descriptors, this value should be passed into fd_offset - * field. Otherwise VFS component will translate all FDs to start - * at zero offset. + * VFS component will translate all FDs so that the filesystem implementation + * sees them starting at zero. The caller sees a global FD which is prefixed + * with an pre-filesystem-implementation. * * Some FS implementations expect some state (e.g. pointer to some structure) * to be passed in as a first argument. For these implementations, @@ -82,7 +81,6 @@ extern "C" { */ typedef struct { - int fd_offset; /*!< file descriptor offset, determined by the FS driver */ int flags; /*!< ESP_VFS_FLAG_CONTEXT_PTR or ESP_VFS_FLAG_DEFAULT, plus optionally ESP_VFS_FLAG_SHARED_FD_SPACE */ union { ssize_t (*write_p)(void* p, int fd, const void * data, size_t size); diff --git a/components/vfs/vfs.c b/components/vfs/vfs.c index f3624259b..24fde2e30 100644 --- a/components/vfs/vfs.c +++ b/components/vfs/vfs.c @@ -140,9 +140,9 @@ static const vfs_entry_t* get_vfs_for_fd(int fd) static int translate_fd(const vfs_entry_t* vfs, int fd) { if (vfs->vfs.flags & ESP_VFS_FLAG_SHARED_FD_SPACE) { - return fd + vfs->vfs.fd_offset; + return fd; } else { - return (fd & VFS_FD_MASK) + vfs->vfs.fd_offset; + return fd & VFS_FD_MASK; } } @@ -255,8 +255,7 @@ int esp_vfs_open(struct _reent *r, const char * path, int flags, int mode) if (ret < 0) { return ret; } - assert(ret >= vfs->vfs.fd_offset); - return ret - vfs->vfs.fd_offset + (vfs->offset << VFS_INDEX_S); + return ret + (vfs->offset << VFS_INDEX_S); } ssize_t esp_vfs_write(struct _reent *r, int fd, const void * data, size_t size) diff --git a/components/vfs/vfs_uart.c b/components/vfs/vfs_uart.c index e477e0e84..f958278d2 100644 --- a/components/vfs/vfs_uart.c +++ b/components/vfs/vfs_uart.c @@ -263,7 +263,6 @@ static int uart_fcntl(int fd, int cmd, va_list args) void esp_vfs_dev_uart_register() { esp_vfs_t vfs = { - .fd_offset = 0, .flags = ESP_VFS_FLAG_DEFAULT, .write = &uart_write, .open = &uart_open,