Mirrors/esp-idf
1
0
Fork 0
mirror of https://github.com/espressif/esp-idf.git synced 2026-08-18 06:35:35 +03:00
Code Issues Packages Projects Releases Wiki Activity

fix(linux): implement pthread-based locks for soft-preemption safety

Browse Source 
The Linux target's sys/lock.h provided no-op inline stubs, which was
safe only under the assumption of single-threaded execution.  With the
new FreeRTOS Linux simulator using soft preemption, an outgoing task
can still run concurrently with the incoming task until it reaches a
yield point, making no-op locks unsafe.

Replace the no-op implementation with real pthread mutexes:

- Change _lock_t from `typedef int` to `typedef void *` (pointer to a
  heap-allocated pthread_mutex_t).
- Implement all _lock_* functions in a new lock.c, supporting both
  normal and recursive mutexes.
- Zero-initialized locks are lazily created on first acquire using
  double-checked locking, preserving newlib/esp_libc semantics.
- Add lock.c unconditionally to the linux component sources and link
  pthread.
This commit is contained in:
Guillaume Souchere
2026-03-17 11:14:52 +01:00
parent 9835daba70
commit 445db75612
3 changed files with 126 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
components/linux/include/sys/lock.h
View File

@@ -1,5 +1,5 @@
/*
* SPDX-FileCopyrightText: 2021-2022 Espressif Systems (Shanghai) CO LTD
* SPDX-FileCopyrightText: 2021-2026 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
@@ -12,30 +12,23 @@
extern "C" {
#endif
/* newlib locks implementation for CONFIG_IDF_TARGET_LINUX, single threaded.
* Note, currently this doesn't implement the functions required
* when _RETARGETABLE_LOCKING is defined. They should be added.
/**
* Lock type backed by pthread mutexes. A zero-initialized _lock_t is valid
* and will be lazily created on first acquire (matching newlib/esp_libc
* semantics).
*/
typedef void * _lock_t;
/* Compatibility definitions for legacy newlib locking functions */
typedef int _lock_t;
static inline void _lock_init(_lock_t *plock) {}
static inline void _lock_init_recursive(_lock_t *plock) {}
static inline void _lock_close(_lock_t *plock) {}
static inline void _lock_close_recursive(_lock_t *plock) {}
static inline void _lock_acquire(_lock_t *plock) {}
static inline void _lock_acquire_recursive(_lock_t *plock) {}
static inline int _lock_try_acquire(_lock_t *plock)
{
return 1;
}
static inline int _lock_try_acquire_recursive(_lock_t *plock)
{
return 1;
}
static inline void _lock_release(_lock_t *plock) {}
static inline void _lock_release_recursive(_lock_t *plock) {}
void _lock_init(_lock_t *plock);
void _lock_init_recursive(_lock_t *plock);
void _lock_close(_lock_t *plock);
void _lock_close_recursive(_lock_t *plock);
void _lock_acquire(_lock_t *plock);
void _lock_acquire_recursive(_lock_t *plock);
int _lock_try_acquire(_lock_t *plock);
int _lock_try_acquire_recursive(_lock_t *plock);
void _lock_release(_lock_t *plock);
void _lock_release_recursive(_lock_t *plock);
#ifdef __cplusplus
}