alex/esp-idf
alex/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2024-09-19 04:16:01 -04:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity

Merge branch 'fix/freertos_sim_nonblock_select' into 'master'

Browse Source 
fix(freertos): Made select function non-blocking on Linux target (GitHub PR)

Closes IDFGH-13569 and IDFGH-13498

See merge request espressif/esp-idf!33331
This commit is contained in:
David Čermák 2024-09-12 16:57:58 +08:00
commit 4dd715922f
1 changed files with 81 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

123
components/freertos/esp_additions/FreeRTOSSimulator_wrappers.c
View File

@ -1,56 +1,95 @@
/*
* SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <pthread.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <dlfcn.h>
#include <sys/types.h>
#include "esp_err.h"
#include "errno.h"
#include <assert.h>
#include <sys/select.h>
#include <errno.h>
/** This module addresses the FreeRTOS simulator's coexistence with linux system calls from user apps.
* It's only included when building without lwIP, so we need to use linux system's select() which would receive
* EINTR event on every FreeRTOS interrupt; we workaround this problem by wrapping select()
* to bypass and silence these events.
/** This module addresses the FreeRTOS simulator's coexistence with Linux system calls from user apps.
* It wraps select so that it doesn't block the FreeRTOS task calling it, so that the
* scheduler will allow lower priority tasks to run.
* Without the wrapper, most components such as ESP-MQTT block lower priority tasks from running at all.
*/
typedef int (*select_func_t) (int fd, fd_set * rfds, fd_set * wfds, fd_set *efds, struct timeval *tval);
typedef int (*select_func_t)(int fd, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *tval);
static inline int64_t get_us(void)
int select(int fd, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeval *tval)
{
struct timespec spec;
clock_gettime(CLOCK_REALTIME, &spec);
return spec.tv_nsec / 1000 + spec.tv_sec * 1000000;
}
static select_func_t s_real_select = NULL;
TickType_t end_ticks = portMAX_DELAY;
fd_set o_rfds, o_wfds, o_efds;
int select (int fd, fd_set * rfds, fd_set * wfds, fd_set *efds, struct timeval *tval)
{
int ret;
struct timeval *tv = tval;
struct timeval timeval_local = {};
int64_t start = 0;
int64_t timeout_us = 0;
select_func_t real_select = (select_func_t) dlsym(RTLD_NEXT, "select");
if (tv != NULL) {
start = get_us();
timeout_us = tval->tv_sec * 1000000 + tval->tv_usec;
timeval_local.tv_sec = tval->tv_sec;
timeval_local.tv_usec = tval->tv_usec;
tv = &timeval_local; // this (tv != NULL) indicates that we should handle timeouts
// Lookup the select symbol
if (s_real_select == NULL) {
s_real_select = (select_func_t)dlsym(RTLD_NEXT, "select");
assert(s_real_select); // abort() if we cannot locate the symbol
}
while ((ret = real_select(fd, rfds, wfds, efds, tv)) < 0 && errno == EINTR) {
if (tv != NULL) {
int64_t now = get_us();
timeout_us -= now - start;
if (timeout_us < 0) {
errno = 0;
ret = 0;
break;
}
start = now;
tv->tv_usec = timeout_us % 1000000;
tv->tv_sec = timeout_us / 1000000;
// Calculate the end_ticks if a timeout is provided
if (tval != NULL) {
end_ticks = xTaskGetTickCount() + pdMS_TO_TICKS(tval->tv_sec * 1000 + tval->tv_usec / 1000);
}
// Preserve the original FD sets as select call will change them
if (rfds) {
o_rfds = *rfds;
}
if (wfds) {
o_wfds = *wfds;
}
if (efds) {
o_efds = *efds;
}
while (1) {
// Restore original FD sets before the select call
if (rfds) {
*rfds = o_rfds;
}
if (wfds) {
*wfds = o_wfds;
}
if (efds) {
*efds = o_efds;
}
// Call select with a zero timeout to avoid blocking
struct timeval zero_tv = {0, 0};
int ret = s_real_select(fd, rfds, wfds, efds, &zero_tv);
// Return on success
if (ret > 0) {
return ret;
}
// Return on any error except EINTR
if (ret == -1 && errno != EINTR) {
return ret;
}
/**
* Sleep for maximum 10 tick(s) to allow other tasks to run.
* This can be any value greater than zero.
* 10 is a good trade-off between CPU time usage and timeout resolution.
*/
const TickType_t max_sleep_ticks = 10;
TickType_t sleep_ticks = max_sleep_ticks;
if (tval != NULL) {
TickType_t now_ticks = xTaskGetTickCount();
if (now_ticks >= end_ticks) {
errno = 0;
return 0;
}
// Sleep for the remaining time or a maximum of 10 tick
TickType_t remaining_ticks = end_ticks - now_ticks;
sleep_ticks = (remaining_ticks < max_sleep_ticks) ? remaining_ticks : max_sleep_ticks;
}
vTaskDelay(sleep_ticks);
}
return ret;
}