Crash_Override/OVMS3-idf
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

According to review comments

Browse source
This commit is contained in:
Alexey Gerenkov 2017-09-01 02:18:14 +03:00 committed by Ivan Grokhotkov
parent 8859dab10c
commit 20942421c3
7 changed files with 337 additions and 320 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
components/freertos/tasks.c
View file

@ -4623,7 +4623,6 @@ TickType_t uxReturn;
TickType_t xTimeToWake;
BaseType_t xReturn;
// UNTESTED_FUNCTION();
taskENTER_CRITICAL(&xTaskQueueMutex);
{
/* Only block if a notification is not already pending. */
@ -4747,7 +4746,6 @@ TickType_t uxReturn;
eNotifyValue eOriginalNotifyState;
BaseType_t xReturn = pdPASS;
// UNTESTED_FUNCTION();
configASSERT( xTaskToNotify );
pxTCB = ( TCB_t * ) xTaskToNotify;

2
components/newlib/include/pthread.h
View file

@ -31,7 +31,7 @@ extern "C" {
#include <sys/types.h>
#include <time.h>
#include <sched.h>
#include <sys/sched.h>
#include <sys/cdefs.h>
struct _pthread_cleanup_context {

3
components/newlib/include/sys/features.h
View file

@ -210,8 +210,11 @@ extern "C" {
#endif /* __CYGWIN__ */
/* ESP-IDF-specific: enable pthreads support */
#ifdef __XTENSA__
#define _POSIX_THREADS 1
#define _UNIX98_THREAD_MUTEX_ATTRIBUTES 1
#endif
/* Per the permission given in POSIX.1-2008 section 2.2.1, define
* _POSIX_C_SOURCE if _XOPEN_SOURCE is defined and _POSIX_C_SOURCE is not.

2
components/newlib/include/sys/sched.h
View file

@ -58,6 +58,8 @@ struct sched_param {
#endif
};
int sched_yield( void );
#ifdef __cplusplus
}
#endif

6
components/newlib/time.c
View file

@ -216,6 +216,12 @@ int usleep(useconds_t us)
return 0;
}
unsigned int sleep(unsigned int seconds)
{
usleep(seconds*1000000UL);
return 0;
}
uint32_t system_get_time(void)
{
#if defined( WITH_FRC1 ) || defined( WITH_RTC )

128
components/pthread/pthread.c
View file

@ -8,35 +8,35 @@
#include "freertos/semphr.h"
#include "freertos/list.h"
#define LOG_LOCAL_LEVEL CONFIG_LOG_DEFAULT_LEVEL//ESP_LOG_VERBOSE
#define LOG_LOCAL_LEVEL CONFIG_LOG_DEFAULT_LEVEL
#include "esp_log.h"
const static char *TAG = "esp_pthread";
#define ESP_PTHREAD_LOGE( _tag_, format, ... ) ESP_LOGE(_tag_, format, ##__VA_ARGS__)
#define ESP_PTHREAD_LOGW( _tag_, format, ... ) ESP_LOGW(_tag_, format, ##__VA_ARGS__)
#define ESP_PTHREAD_LOGI( _tag_, format, ... ) ESP_LOGI(_tag_, format, ##__VA_ARGS__)
#define ESP_PTHREAD_LOGD( _tag_, format, ... ) ESP_LOGD(_tag_, format, ##__VA_ARGS__)
#define ESP_PTHREAD_LOGV( _tag_, format, ... ) ESP_LOGV(_tag_, format, ##__VA_ARGS__)
#define PTHREAD_TASK_STATE_RUN 0
#define PTHREAD_TASK_STATE_EXIT 1
/** task state */
enum esp_pthread_task_state {
PTHREAD_TASK_STATE_RUN,
PTHREAD_TASK_STATE_EXIT
};
/** pthread thread FreeRTOS wrapper */
typedef struct {
ListItem_t list_item;
TaskHandle_t join_task;
int state;
bool detached;
ListItem_t list_item; ///< Tasks list node struct. FreeRTOS task handle is kept as list_item.xItemValue
TaskHandle_t join_task; ///< Handle of the task waiting to join
enum esp_pthread_task_state state; ///< pthread task state
bool detached; ///< True if pthread is detached
} esp_pthread_t;
/** pthread wrapper task arg */
typedef struct {
void *(*func)(void *);
void *arg;
void *(*func)(void *); ///< user task entry
void *arg; ///< user task argument
} esp_pthread_task_arg_t;
/** pthread mutex FreeRTOS wrapper */
typedef struct {
ListItem_t list_item;
SemaphoreHandle_t sem;
int type;
ListItem_t list_item; ///< mutexes list node struct
SemaphoreHandle_t sem; ///< Handle of the task waiting to join
int type; ///< Handle of the task waiting to join
} esp_pthread_mutex_t;
@ -52,43 +52,57 @@ int esp_pthread_init(void)
{
vListInitialise((List_t *)&s_threads_list);
s_once_mux = xSemaphoreCreateMutex();
if (s_once_mux == NULL)
return ESP_FAIL;
if (s_once_mux == NULL) {
return ESP_ERR_NO_MEM;
}
s_threads_mux = xSemaphoreCreateMutex();
if (s_threads_mux == NULL) {
vSemaphoreDelete(s_once_mux);
return ESP_FAIL;
return ESP_ERR_NO_MEM;
}
return ESP_OK;
}
static TaskHandle_t pthread_find_handle(pthread_t thread)
static void *pthread_find_list_item(void *(*item_check)(ListItem_t *, void *arg), void *check_arg)
{
ListItem_t const *list_end = listGET_END_MARKER(&s_threads_list);
ListItem_t *list_item = listGET_HEAD_ENTRY(&s_threads_list);
while (list_item != list_end) {
esp_pthread_t *pthread = listGET_LIST_ITEM_OWNER(list_item);
if ((pthread_t)pthread == thread) {
return (TaskHandle_t)listGET_LIST_ITEM_VALUE(list_item);
void *val = item_check(list_item, check_arg);
if (val) {
return val;
}
list_item = listGET_NEXT(list_item);
}
return NULL;
}
static esp_pthread_t *pthread_find(TaskHandle_t task_handle)
static void *pthread_get_handle_by_desc(ListItem_t *item, void *arg)
{
ListItem_t const *list_end = listGET_END_MARKER(&s_threads_list);
ListItem_t *list_item = listGET_HEAD_ENTRY(&s_threads_list);
while (list_item != list_end) {
TaskHandle_t cur_handle = (TaskHandle_t)listGET_LIST_ITEM_VALUE(list_item);
if (task_handle == cur_handle) {
return (esp_pthread_t *)listGET_LIST_ITEM_OWNER(list_item);
}
list_item = listGET_NEXT(list_item);
esp_pthread_t *pthread = listGET_LIST_ITEM_OWNER(item);
if (pthread == arg) {
return (void *)listGET_LIST_ITEM_VALUE(item);
}
return NULL;
}
static inline TaskHandle_t pthread_find_handle(pthread_t thread)
{
return pthread_find_list_item(pthread_get_handle_by_desc, (void *)thread);
}
static void *pthread_get_desc_by_handle(ListItem_t *item, void *arg)
{
TaskHandle_t task_handle = arg;
TaskHandle_t cur_handle = (TaskHandle_t)listGET_LIST_ITEM_VALUE(item);
if (task_handle == cur_handle) {
return (esp_pthread_t *)listGET_LIST_ITEM_OWNER(item);
}
return NULL;
}
static esp_pthread_t *pthread_find(TaskHandle_t task_handle)
{
return pthread_find_list_item(pthread_get_desc_by_handle, task_handle);
}
static void pthread_delete(esp_pthread_t *pthread)
{
@ -100,14 +114,14 @@ static void pthread_task_func(void *arg)
{
esp_pthread_task_arg_t *task_arg = (esp_pthread_task_arg_t *)arg;
ESP_PTHREAD_LOGV(TAG, "%s ENTER %p", __FUNCTION__, task_arg->func);
ESP_LOGV(TAG, "%s ENTER %p", __FUNCTION__, task_arg->func);
// wait for start
xTaskNotifyWait(0, 0, NULL, portMAX_DELAY);
ESP_PTHREAD_LOGV(TAG, "%s START %p", __FUNCTION__, task_arg->func);
ESP_LOGV(TAG, "%s START %p", __FUNCTION__, task_arg->func);
task_arg->func(task_arg->arg);
ESP_PTHREAD_LOGV(TAG, "%s END %p", __FUNCTION__, task_arg->func);
ESP_LOGV(TAG, "%s END %p", __FUNCTION__, task_arg->func);
free(task_arg);
if (xSemaphoreTake(s_threads_mux, portMAX_DELAY) != pdTRUE) {
@ -133,7 +147,7 @@ static void pthread_task_func(void *arg)
vTaskDelete(NULL);
ESP_PTHREAD_LOGV(TAG, "%s EXIT", __FUNCTION__);
ESP_LOGV(TAG, "%s EXIT", __FUNCTION__);
}
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
@ -141,21 +155,20 @@ int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
{
TaskHandle_t xHandle = NULL;
ESP_PTHREAD_LOGV(TAG, "%s", __FUNCTION__);
ESP_LOGV(TAG, "%s", __FUNCTION__);
if (attr) {
ESP_PTHREAD_LOGE(TAG, "Attrs not supported!");
return EINVAL;
assert(false && "pthread_create: attrs not supported!");
}
esp_pthread_task_arg_t *task_arg = malloc(sizeof(esp_pthread_task_arg_t));
if (task_arg == NULL) {
ESP_PTHREAD_LOGE(TAG, "Failed to allocate task args!");
ESP_LOGE(TAG, "Failed to allocate task args!");
errno = ENOMEM;
return ENOMEM;
}
memset(task_arg, 0, sizeof(esp_pthread_task_arg_t));
esp_pthread_t *pthread = malloc(sizeof(esp_pthread_t));
if (pthread == NULL) {
ESP_PTHREAD_LOGE(TAG, "Failed to allocate pthread data!");
ESP_LOGE(TAG, "Failed to allocate pthread data!");
free(task_arg);
errno = ENOMEM;
return ENOMEM;
@ -166,7 +179,7 @@ int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
BaseType_t res = xTaskCreate(&pthread_task_func, "pthread", CONFIG_ESP32_PTHREAD_TASK_STACK_SIZE_DEFAULT,
task_arg, CONFIG_ESP32_PTHREAD_TASK_PRIO_DEFAULT, &xHandle);
if(res != pdPASS) {
ESP_PTHREAD_LOGE(TAG, "Failed to create task!");
ESP_LOGE(TAG, "Failed to create task!");
free(pthread);
free(task_arg);
if (res == errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY) {
@ -192,7 +205,7 @@ int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
*thread = (pthread_t)pthread; // pointer value fit into pthread_t (uint32_t)
ESP_PTHREAD_LOGV(TAG, "Created task %x", (uint32_t)xHandle);
ESP_LOGV(TAG, "Created task %x", (uint32_t)xHandle);
return 0;
}
@ -202,7 +215,7 @@ int pthread_join(pthread_t thread, void **retval)
esp_pthread_t *pthread = (esp_pthread_t *)thread;
int ret = 0;
ESP_PTHREAD_LOGV(TAG, "%s %p", __FUNCTION__, pthread);
ESP_LOGV(TAG, "%s %p", __FUNCTION__, pthread);
// find task
if (xSemaphoreTake(s_threads_mux, portMAX_DELAY) != pdTRUE) {
@ -246,7 +259,7 @@ int pthread_join(pthread_t thread, void **retval)
*retval = 0; // no exit code in FreeRTOS
}
ESP_PTHREAD_LOGV(TAG, "%s %p EXIT %d", __FUNCTION__, pthread, ret);
ESP_LOGV(TAG, "%s %p EXIT %d", __FUNCTION__, pthread, ret);
return ret;
}
@ -266,7 +279,7 @@ int pthread_detach(pthread_t thread)
pthread->detached = true;
}
xSemaphoreGive(s_threads_mux);
ESP_PTHREAD_LOGV(TAG, "%s %p EXIT %d", __FUNCTION__, pthread, ret);
ESP_LOGV(TAG, "%s %p EXIT %d", __FUNCTION__, pthread, ret);
return ret;
}
@ -308,7 +321,7 @@ int pthread_key_create(pthread_key_t *key, void (*destructor)(void*))
//TODO: Key destructors not suppoted!
if (s_created) {
// key API supports just one key necessary by libstdcxx threading implementation
return ENOMEM;
assert(false && "pthread_key_create: multiple keys not supported!");
}
*key = 1;
s_created = 1;
@ -337,7 +350,7 @@ int pthread_setspecific(pthread_key_t key, const void *value)
int pthread_once(pthread_once_t *once_control, void (*init_routine)(void))
{
if (once_control == NULL || init_routine == NULL || !once_control->is_initialized) {
ESP_PTHREAD_LOGE(TAG, "%s: Invalid args!", __FUNCTION__);
ESP_LOGE(TAG, "%s: Invalid args!", __FUNCTION__);
return EINVAL;
}
@ -346,7 +359,7 @@ int pthread_once(pthread_once_t *once_control, void (*init_routine)(void))
if (!cur_task || xSemaphoreTake(s_once_mux, portMAX_DELAY) == pdTRUE)
{
if (!once_control->init_executed) {
ESP_PTHREAD_LOGV(TAG, "%s: call init_routine %p", __FUNCTION__, once_control);
ESP_LOGV(TAG, "%s: call init_routine %p", __FUNCTION__, once_control);
init_routine();
once_control->init_executed = 1;
}
@ -356,7 +369,7 @@ int pthread_once(pthread_once_t *once_control, void (*init_routine)(void))
}
else
{
ESP_PTHREAD_LOGE(TAG, "%s: Failed to lock!", __FUNCTION__);
ESP_LOGE(TAG, "%s: Failed to lock!", __FUNCTION__);
return EBUSY;
}
@ -421,7 +434,7 @@ int pthread_mutex_destroy(pthread_mutex_t *mutex)
{
esp_pthread_mutex_t *mux;
ESP_PTHREAD_LOGV(TAG, "%s %p", __FUNCTION__, mutex);
ESP_LOGV(TAG, "%s %p", __FUNCTION__, mutex);
if (!mutex) {
errno = EINVAL;
@ -537,12 +550,3 @@ int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type)
}
return res;
}
/***************** AUX ******************/
// TODO: move to newlib/time.c????
// needed for std::this_thread::sleep_for
unsigned int sleep(unsigned int seconds)
{
usleep(seconds*1000000UL);
return 0;
}

10
components/pthread/test/test_pthread_cxx.cpp
View file

@ -3,9 +3,11 @@
#include <mutex>
#include "unity.h"
std::shared_ptr<int> global_sp;
std::mutex mtx;
std::recursive_mutex recur_mtx;
#if __GTHREADS && __GTHREADS_CXX0X
static std::shared_ptr<int> global_sp;
static std::mutex mtx;
static std::recursive_mutex recur_mtx;
static void thread_do_nothing() {}
@ -77,3 +79,5 @@ TEST_CASE("pthread CXX", "[pthread]")
t4.join();
}
}
#endif