mirror of
https://github.com/RIOT-OS/RIOT.git
synced 2024-12-29 04:50:03 +01:00
102 lines
3.3 KiB
C
102 lines
3.3 KiB
C
#ifndef RIOT_PTHREAD_H
|
|
#define RIOT_PTHREAD_H 1
|
|
|
|
#include <time.h>
|
|
|
|
#include "kernel.h"
|
|
#include "mutex.h"
|
|
#include "sched.h"
|
|
|
|
#include "pthreadtypes.h"
|
|
|
|
/* Create a new thread, starting with execution of START-ROUTINE
|
|
getting passed ARG. Creation attributed come from ATTR. The new
|
|
handle is stored in *NEWTHREAD. */
|
|
int pthread_create(pthread_t *newthread, const pthread_attr_t *attr,
|
|
void *(*start_routine)(void *), void *arg);
|
|
|
|
/* Terminate calling thread.
|
|
|
|
The registered cleanup handlers are called via exception handling .*/
|
|
void pthread_exit(void *retval);
|
|
|
|
/* Make calling thread wait for termination of the thread TH. The
|
|
exit status of the thread is stored in *THREAD_RETURN, if THREAD_RETURN
|
|
is not NULL.
|
|
|
|
This function is a cancellation point and therefore not marked with
|
|
. */
|
|
int pthread_join(pthread_t th, void **thread_return);
|
|
|
|
/* Indicate that the thread TH is never to be joined with PTHREAD_JOIN.
|
|
The resources of TH will therefore be freed immediately when it
|
|
terminates, instead of waiting for another thread to perform PTHREAD_JOIN
|
|
on it. */
|
|
int pthread_detach(pthread_t th);
|
|
|
|
/* Obtain the identifier of the current thread. */
|
|
pthread_t pthread_self(void);
|
|
|
|
/* Compare two thread identifiers. */
|
|
int pthread_equal(pthread_t thread1, pthread_t thread2);
|
|
|
|
#include "pthread_attr.h"
|
|
|
|
/* Functions for scheduling control. */
|
|
|
|
/* Set the scheduling parameters for TARGET_THREAD according to POLICY
|
|
and *PARAM. */
|
|
int pthread_setschedparam(pthread_t target_thread, int policy,
|
|
const struct sched_param *param);
|
|
|
|
/* Return in *POLICY and *PARAM the scheduling parameters for TARGET_THREAD. */
|
|
int pthread_getschedparam(pthread_t target_thread, int *policy,
|
|
struct sched_param *param);
|
|
|
|
/* Set the scheduling priority for TARGET_THREAD. */
|
|
int pthread_setschedprio(pthread_t target_thread, int prio);
|
|
|
|
/* Functions for handling initialization. */
|
|
|
|
/* Guarantee that the initialization function INIT_ROUTINE will be called
|
|
only once, even if pthread_once is executed several times with the
|
|
same ONCE_CONTROL argument. ONCE_CONTROL must point to a static or
|
|
variable initialized to PTHREAD_ONCE_INIT.
|
|
|
|
The initialization functions might throw exception */
|
|
int pthread_once(pthread_once_t *once_control, void (*init_routine)(void));
|
|
|
|
/* Functions for handling cancellation.
|
|
|
|
Note that these functions are explicitly not marked to not throw an
|
|
exception in C++ code. If cancellation is implemented by unwinding
|
|
this is necessary to have the compiler generate the unwind information. */
|
|
|
|
/* Set cancelability state of current thread to STATE, returning old
|
|
state in *OLDSTATE if OLDSTATE is not NULL. */
|
|
int pthread_setcancelstate(int state, int *oldstate);
|
|
|
|
/* Set cancellation state of current thread to TYPE, returning the old
|
|
type in *OLDTYPE if OLDTYPE is not NULL. */
|
|
int pthread_setcanceltype(int type, int *oldtype);
|
|
|
|
/* Cancel THREAD immediately or at the next possibility. */
|
|
int pthread_cancel(pthread_t th);
|
|
|
|
/* Test for pending cancellation for the current thread and terminate
|
|
the thread as per pthread_exit(PTHREAD_CANCELED) if it has been
|
|
cancelled. */
|
|
void pthread_testcancel(void);
|
|
|
|
#include "pthread_mutex.h"
|
|
|
|
#include "pthread_rwlock.h"
|
|
|
|
#include "pthread_spin.h"
|
|
|
|
#include "pthread_barrier.h"
|
|
|
|
#include "pthread_cleanup.h"
|
|
|
|
#endif /* pthread.h */
|