stk_c_pthread.h

Go to the documentation of this file.

/*
 * SuperTinyKernel(TM) RTOS: Lightweight High-Performance Deterministic C++ RTOS for Embedded Systems.
 *
 * Source: https://github.com/SuperTinyKernel-RTOS
 *
 * Copyright (c) 2022-2026 Neutron Code Limited <stk@neutroncode.com>. All Rights Reserved.
 * License: MIT License, see LICENSE for a full text.
 */
 
#ifndef STK_C_PTHREAD_H_
#define STK_C_PTHREAD_H_
 
#include "stk_c.h"
#include "stk_c_memory.h"
 
#ifdef __cplusplus
    #include <ctime>
    #include <cerrno>
#else
    #include <time.h>
    #include <errno.h>
#endif

 
#ifdef __cplusplus
extern "C" {
#endif
 
// =============================================================================
// Configuration macros (can be overridden before including this file)
// =============================================================================

#ifndef STK_C_PTHREAD_MAX_THREADS
    #define STK_C_PTHREAD_MAX_THREADS (8U)
#endif

#ifndef STK_C_PTHREAD_DEFAULT_STACK_WORDS
    #define STK_C_PTHREAD_DEFAULT_STACK_WORDS (1024U)
#endif

#ifndef STK_C_PTHREAD_REAPER_STACK_WORDS
    #define STK_C_PTHREAD_REAPER_STACK_WORDS (256U)
#endif

#ifndef STK_C_PTHREAD_KEYS_MAX
    #define STK_C_PTHREAD_KEYS_MAX (8U)
#endif
 
// =============================================================================
// Bootstrap (STK-specific, not part of POSIX)
// =============================================================================

void stk_pthread_bind_kernel(stk_kernel_t *kernel);
 
// =============================================================================
// Types
// =============================================================================

typedef struct pthread_stk_ctrl_t *pthread_t;

typedef struct pthread_attr_t
{
    size_t      __stack_bytes;  
    stk_word_t *__ext_stack;    
    int         __detachstate;  
} pthread_attr_t;
 
#define PTHREAD_CREATE_JOINABLE (0)
#define PTHREAD_CREATE_DETACHED (1)

typedef struct pthread_mutexattr_t
{
    int __type;
} pthread_mutexattr_t;
 
#define PTHREAD_MUTEX_NORMAL     (0)
#define PTHREAD_MUTEX_DEFAULT    (PTHREAD_MUTEX_NORMAL)
#define PTHREAD_MUTEX_ERRORCHECK (1)
#define PTHREAD_MUTEX_RECURSIVE  (2)

typedef struct pthread_mutex_t
{
    stk_mutex_mem_t __mem;
    stk_mutex_t    *__handle;
} pthread_mutex_t;
 
#define PTHREAD_MUTEX_INITIALIZER {0}

typedef struct pthread_condattr_t
{
    int __reserved;
} pthread_condattr_t;

typedef struct pthread_cond_t
{
    stk_cv_mem_t __mem;
    stk_cv_t    *__handle;
} pthread_cond_t;
 
#define PTHREAD_COND_INITIALIZER {0}

typedef struct pthread_rwlockattr_t
{
    int __reserved;
} pthread_rwlockattr_t;

typedef struct pthread_rwlock_t
{
    stk_rwmutex_mem_t __mem;
    stk_rwmutex_t    *__handle;
    bool              __wrlocked;
} pthread_rwlock_t;
 
#define PTHREAD_RWLOCK_INITIALIZER {0}
 
#define PTHREAD_PROCESS_PRIVATE (0)
#define PTHREAD_PROCESS_SHARED  (1)

typedef struct pthread_spinlock_t
{
    stk_spinlock_mem_t __mem;
    stk_spinlock_t     *__handle;
} pthread_spinlock_t;

typedef struct pthread_barrierattr_t
{
    int __reserved;
} pthread_barrierattr_t;

typedef struct pthread_barrier_t
{
    stk_barrier_mem_t __mem;
    stk_barrier_t    *__handle;
} pthread_barrier_t;

#define PTHREAD_BARRIER_SERIAL_THREAD (-1)

typedef struct pthread_once_t
{
    int             __state;   
    stk_mutex_mem_t __mem;
    stk_mutex_t    *__handle;
} pthread_once_t;
 
#define PTHREAD_ONCE_INIT {0}

typedef unsigned int pthread_key_t;

#define PTHREAD_KEYS_MAX (STK_C_PTHREAD_KEYS_MAX)

#define PTHREAD_DESTRUCTOR_ITERATIONS (4)
 
// =============================================================================
// Thread attributes
// =============================================================================

int pthread_attr_init(pthread_attr_t *attr);

int pthread_attr_destroy(pthread_attr_t *attr);

int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);

int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize);

int pthread_attr_setstack(pthread_attr_t *attr, void *stackaddr, size_t stacksize);

int pthread_attr_getstack(const pthread_attr_t *attr, void **stackaddr, size_t *stacksize);

int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);

int pthread_attr_getdetachstate(const pthread_attr_t *attr, int *detachstate);
 
// =============================================================================
// Thread lifecycle
// =============================================================================

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                    void *(*start_routine)(void *), void *arg);

int pthread_join(pthread_t thread, void **retval);

int pthread_detach(pthread_t thread);

void pthread_exit(void *retval);

pthread_t pthread_self(void);

int pthread_equal(pthread_t t1, pthread_t t2);

int pthread_yield(void);
 
// =============================================================================
// Mutex
// =============================================================================
 
int pthread_mutexattr_init(pthread_mutexattr_t *attr);
int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);

int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);
int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type);

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
int pthread_mutex_destroy(pthread_mutex_t *mutex);
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

int pthread_mutex_timedlock(pthread_mutex_t *mutex, const struct timespec *abstime);
 
// =============================================================================
// Condition variable
// =============================================================================
 
int pthread_condattr_init(pthread_condattr_t *attr);
int pthread_condattr_destroy(pthread_condattr_t *attr);
 
int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr);
int pthread_cond_destroy(pthread_cond_t *cond);

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
                            const struct timespec *abstime);
 
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
 
// =============================================================================
// Read-write lock
// =============================================================================
 
int pthread_rwlockattr_init(pthread_rwlockattr_t *attr);
int pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr);

int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr);
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);

int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

int pthread_rwlock_timedrdlock(pthread_rwlock_t *rwlock, const struct timespec *abstime);

int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

int pthread_rwlock_timedwrlock(pthread_rwlock_t *rwlock, const struct timespec *abstime);

int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
 
// =============================================================================
// Spin lock
// =============================================================================

int pthread_spin_init(pthread_spinlock_t *lock, int pshared);
int pthread_spin_destroy(pthread_spinlock_t *lock);

int pthread_spin_lock(pthread_spinlock_t *lock);

int pthread_spin_trylock(pthread_spinlock_t *lock);
int pthread_spin_unlock(pthread_spinlock_t *lock);
 
// =============================================================================
// Barrier
// =============================================================================
 
int pthread_barrierattr_init(pthread_barrierattr_t *attr);
int pthread_barrierattr_destroy(pthread_barrierattr_t *attr);

int pthread_barrier_init(pthread_barrier_t *barrier, const pthread_barrierattr_t *attr,
                          unsigned int count);
int pthread_barrier_destroy(pthread_barrier_t *barrier);

int pthread_barrier_wait(pthread_barrier_t *barrier);
 
// =============================================================================
// Once
// =============================================================================

int pthread_once(pthread_once_t *once_control, void (*init_routine)(void));
 
// =============================================================================
// Thread-specific data (keys)
// =============================================================================

int pthread_key_create(pthread_key_t *key, void (*destructor)(void *));

int pthread_key_delete(pthread_key_t key);

int pthread_setspecific(pthread_key_t key, const void *value);

void *pthread_getspecific(pthread_key_t key);
 
#ifdef __cplusplus
}
#endif

 
#endif /* STK_C_PTHREAD_H_ */