The evp argument, if non-NULL, points to a sigevent structure. This structure is allocated by the called and defines the asynchronous notification to occur. If the evp argument is NULL, the effect is as if the evp argument pointed to a sigevent structure with the sigev_notify member having the value SIGEV_SIGNAL, the sigev_signo having a default signal number, and the sigev_value member having the value of the timer ID.

Each implementation defines a set of clocks that can be used as timing bases for per-thread timers. All implementations shall support a clock_id of CLOCK_REALTIME.

Input Parameters:

• clockid. Specifies the clock to use as the timing base. Must be CLOCK_REALTIME.
• evp. Refers to a user allocated sigevent structure that defines the asynchronous notification. evp may be NULL (see above).
• timerid. The pre-thread timer created by the call to timer_create().

Returned Values:

If the call succeeds, timer_create() will return 0 (OK) and update the location referenced by timerid to a timer_t, which can be passed to the other per-thread timer calls. If an error occurs, the function will return a value of -1 (ERROR) and set errno to indicate the error.

• EAGAIN. The system lacks sufficient signal queuing resources to honor the request.
• EAGAIN. The calling process has already created all of the timers it is allowed by this implementation.
• EINVAL. The specified clock ID is not defined.
• ENOTSUP. The implementation does not support the creation of a timer attached to the CPU-time clock that is specified by clock_id and associated with a thread different thread invoking timer_create().

POSIX Compatibility: Comparable to the POSIX interface of the same name. Differences from the full POSIX implementation include:

• Only CLOCK_REALTIME is supported for the clockid argument.

2.7.10 timer_delete

Function Prototype:

    #include <time.h>
    int timer_delete(timer_t timerid);

Description: The timer_delete() function deletes the specified timer, timerid, previously created by the timer_create() function. If the timer is armed when timer_delete() is called, the timer will be automatically disarmed before removal. The disposition of pending signals for the deleted timer is unspecified.

Input Parameters:

• timerid. The pre-thread timer, previously created by the call to timer_create(), to be deleted.

Returned Values:

If successful, the timer_delete() function will return zero (OK). Otherwise, the function will return a value of -1 (ERROR) and set errno to indicate the error:

• EINVAL. The timer specified timerid is not valid.

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.7.11 timer_settime

Function Prototype:

    #include <time.h>
    int timer_settime(timer_t timerid, int flags, const struct itimerspec *value,
                      struct itimerspec *ovalue);

Description: The timer_settime() function sets the time until the next expiration of the timer specified by timerid from the it_value member of the value argument and arm the timer if the it_value member of value is non-zero. If the specified timer was already armed when timer_settime() is called, this call will reset the time until next expiration to the value specified. If the it_value member of value is zero, the timer will be disarmed. The effect of disarming or resetting a timer with pending expiration notifications is unspecified.

If the flag TIMER_ABSTIME is not set in the argument flags, timer_settime() will behave as if the time until next expiration is set to be equal to the interval specified by the it_value member of value. That is, the timer will expire in it_value nanoseconds from when the call is made. If the flag TIMER_ABSTIME is set in the argument flags, timer_settime() will behave as if the time until next expiration is set to be equal to the difference between the absolute time specified by the it_value member of value and the current value of the clock associated with timerid. That is, the timer will expire when the clock reaches the value specified by the it_value member of value. If the specified time has already passed, the function will succeed and the expiration notification will be made.

The reload value of the timer will be set to the value specified by the it_interval member of value. When a timer is armed with a non-zero it_interval, a periodic (or repetitive) timer is specified.

Time values that are between two consecutive non-negative integer multiples of the resolution of the specified timer will be rounded up to the larger multiple of the resolution. Quantization error will not cause the timer to expire earlier than the rounded time value.

If the argument ovalue is not NULL, the timer_settime() function will store, in the location referenced by ovalue, a value representing the previous amount of time before the timer would have expired, or zero if the timer was disarmed, together with the previous timer reload value. Timers will not expire before their scheduled time.

Input Parameters:

• timerid. The pre-thread timer, previously created by the call to timer_create(), to be be set.
• flags. Specify characteristics of the timer (see above)
• value. Specifies the timer value to set
• ovalue. A location in which to return the time remaining from the previous timer setting (ignored).

Returned Values:

If the timer_gettime() succeeds, a value of 0 (OK) will be returned. If an error occurs, the value -1 (ERROR) will be returned, and errno set to indicate the error.

• EINVAL. The timerid argument does not correspond to an ID returned by timer_create() but not yet deleted by timer_delete().
• EINVAL. A value structure specified a nanosecond value less than zero or greater than or equal to 1000 million, and the it_value member of that structure did not specify zero seconds and nanoseconds.

POSIX Compatibility: Comparable to the POSIX interface of the same name. Differences from the full POSIX implementation include:

• The ovalue argument is ignored.

2.7.12 timer_gettime

Function Prototype:

    #include <time.h>
    int timer_gettime(timer_t timerid, struct itimerspec *value);

Description: The timer_gettime() function will store the amount of time until the specified timer, timerid, expires and the reload value of the timer into the space pointed to by the value argument. The it_value member of this structure will contain the amount of time before the timer expires, or zero if the timer is disarmed. This value is returned as the interval until timer expiration, even if the timer was armed with absolute time. The it_interval member of value will contain the reload value last set by timer_settime().

Due to the asynchronous operation of this function, the time reported by this function could be significantly more than that actual time remaining on the timer at any time.

Input Parameters:

• timerid. Specifies pre-thread timer, previously created by the call to timer_create(), whose remaining count will be returned.

Returned Values:

If successful, the timer_gettime() function will return zero (OK). Otherwise, an non-zero error number will be returned to indicate the error:

• EINVAL. The timerid argument does not correspond to an ID returned by timer_create() but not yet deleted by timer_delete().

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.7.13 timer_getoverrun

Function Prototype:

    #include <time.h>
    int timer_getoverrun(timer_t timerid);

Description: Only a single signal will be queued to the process for a given timer at any point in time. When a timer for which a signal is still pending expires, no signal will be queued, and a timer overrun will occur. When a timer expiration signal is delivered to or accepted by a process, if the implementation supports the Realtime Signals Extension, the timer_getoverrun() function will return the timer expiration overrun count for the specified timer. The overrun count returned contains the number of extra timer expirations that occurred between the time the signal was generated (queued) and when it was delivered or accepted, up to but not including an implementation-defined maximum of DELAYTIMER_MAX. If the number of such extra expirations is greater than or equal to DELAYTIMER_MAX, then the overrun count will be set to DELAYTIMER_MAX. The value returned by timer_getoverrun() will apply to the most recent expiration signal delivery or acceptance for the timer. If no expiration signal has been delivered for the timer, or if the Realtime Signals Extension is not supported, the return value of timer_getoverrun() is unspecified.

NOTE: This interface is not currently implemented in NuttX.

Input Parameters:

• timerid. Specifies pre-thread timer, previously created by the call to timer_create(), whose overrun count will be returned.

Returned Values: If the timer_getoverrun() function succeeds, it will return the timer expiration overrun count as explained above. timer_getoverrun() will fail if:

• EINVAL. The timerid argument does not correspond to an ID returned by timer_create() but not yet deleted by timer_delete().

POSIX Compatibility: Comparable to the POSIX interface of the same name. Differences from the full POSIX implementation include:

• This interface is not currently implemented by NuttX.

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.7.14 gettimeofday

Function Prototype:

    #include <sys/time.h>
    int gettimeofday(struct timeval *tp, void *tzp);

Description: This implementation of gettimeofday() is simply a thin wrapper around clock_gettime(). It simply calls clock_gettime() using the CLOCK_REALTIME timer and converts the result to the required struct timeval.

Input Parameters:

• tp. The current time will be returned to this user provided location.
• tzp. A reference to the timezone -- IGNORED.

Returned Values: See clock_gettime().

NuttX provides signal interfaces for tasks. Signals are used to alter the flow control of tasks by communicating asynchronous events within or between task contexts. Any task or interrupt handler can post (or send) a signal to a particular task. The task being signaled will execute task-specified signal handler function the next time that the task has priority. The signal handler is a user-supplied function that is bound to a specific signal and performs whatever actions are necessary whenever the signal is received.

There are no predefined actions for any signal. The default action for all signals (i.e., when no signal handler has been supplied by the user) is to ignore the signal. In this sense, all NuttX are real time signals.

Tasks may also suspend themselves and wait until a signal is received.

The following signal handling interfaces are provided by NuttX:

• 2.8.1 sigemptyset
• 2.8.2 sigfillset
• 2.8.3 sigaddset
• 2.8.4 sigdelset
• 2.8.5 sigismember
• 2.8.6 sigaction
• 2.8.7 sigprocmask
• 2.8.8 sigpending
• 2.8.9 sigsuspend
• 2.8.10 sigwaitinfo
• 2.8.11 sigtimedwait
• 2.8.12 sigqueue
• 2.8.13 kill

2.8.1 sigemptyset

Function Prototype:

    #include <signal.h>
    int sigemptyset(sigset_t *set);

Description: This function initializes the signal set specified by set such that all signals are excluded.

Input Parameters:

• set. Signal set to initialize.

Returned Values:

• 0 (OK), or -1 (ERROR) if the signal set cannot be initialized.

Assumptions/Limitations:

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.8.2 sigfillset

Function Prototype:

    #include <signal.h>
    int sigfillset(sigset_t *set);

Description: This function initializes the signal set specified by set such that all signals are included.

Input Parameters:

• set. Signal set to initialize

Returned Values:

• 0 (OK), or -1 (ERROR) if the signal set cannot be initialized.

Assumptions/Limitations:

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.8.3 sigaddset

Function Prototype:

    #include <signal.h>
    int sigaddset(sigset_t *set, int signo);

Description: This function adds the signal specified by signo to the signal set specified by set.

Input Parameters:

• set. Signal set to add signal to
• signo. Signal to add

Returned Values:

• 0 (OK), or -1 (ERROR) if the signal number is invalid.

Assumptions/Limitations:

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.8.4 sigdelset

Function Prototype:

    #include <signal.h>
    int sigdelset(sigset_t *set, int signo);

Description: This function deletes the signal specified by signo from the signal set specified by set.

Input Parameters:

• set. Signal set to delete the signal from
• signo. Signal to delete

Returned Values:

• 0 (OK), or -1 (ERROR) if the signal number is invalid.

Assumptions/Limitations:

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.8.5 sigismember

Function Prototype:

    #include <signal.h>
    int  sigismember(const sigset_t *set, int signo);

Description: This function tests whether the signal specified by signo is a member of the set specified by set.

Input Parameters:

• set. Signal set to test
• signo. Signal to test for

Returned Values:

• 1 (TRUE), if the specified signal is a member of the set,
• 0 (OK or FALSE), if it is not, or
• -1 (ERROR) if the signal number is invalid.

Assumptions/Limitations:

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.8.6 sigaction

Function Prototype:

    #include <signal.h>
    int sigaction( int signo, const struct sigaction *act,
                   struct sigaction *oact );

Description: This function allows the calling task to examine and/or specify the action to be associated with a specific signal.

The structure sigaction, used to describe an action to be taken, is defined to include the following members:

• sa_u.sa_handler. A pointer to a signal-catching function.
• sa_u.sa_sigaction. An alternative form for the signal catching function.
• sa_mask. Additional set of signals to be blocked during execution of the signal-catching function.
• sa_flags: Special flags to affect behavior of a signal.

If the argument act is not NULL, it points to a structure specifying the action to be associated with the specified signal. If the argument oact is not NULL, the action previously associated with the signal is stored in the location pointed to by the argument oact. If the argument act is NULL, signal handling is unchanged by this function call; thus, the call can be used to inquire about the current handling of a given signal.

When a signal is caught by a signal-catching function installed by the sigaction() function, a new signal mask is calculated and installed for the duration of the signal-catching function. This mask is formed by taking the union of the current signal mask and the value of the sa_mask for the signal being delivered, and then including the signal being delivered. If and when the signal handler returns, the original signal mask is restored.

Signal catching functions execute in the same address environment as the task that called sigaction() to install the signal-catching function.

Once an action is installed for a specific signal, it remains installed until another action is explicitly requested by another call to sigaction().

Input Parameters:

• sig. Signal of interest
• act. Location of new handler
• oact. Location to store old handler

Returned Values:

• 0 (OK), or -1 (ERROR) if the signal number is invalid.

Assumptions/Limitations:

POSIX Compatibility: Comparable to the POSIX interface of the same name. Differences from the POSIX implementation include:

• Special values of sa_handler in the struct sigaction act input not handled (SIG_DFL, SIG_IGN).
• All sa_flags in struct sigaction of act input are ignored (all treated like SA_SIGINFO).

2.8.7 sigprocmask

Function Prototype:

    #include <signal.h>
    int sigprocmask(int how, const sigset_t *set, sigset_t *oset);

Description: This function allows the calling task to examine and/or change its signal mask. If the set is not NULL, then it points to a set of signals to be used to change the currently blocked set. The value of how indicates the manner in which the set is changed.

If there are any pending unblocked signals after the call to sigprocmask(), those signals will be delivered before sigprocmask() returns.

If sigprocmask() fails, the signal mask of the task is not changed.

Input Parameters:

• how. How the signal mast will be changed:
  • SIG_BLOCK. The resulting set is the union of the current set and the signal set pointed to by the set input parameter.
  • SIG_UNBLOCK. The resulting set is the intersection of the current set and the complement of the signal set pointed to by the set input parameter.
  • SIG_SETMASK. The resulting set is the signal set pointed to by the set input parameter.
• set. Location of the new signal mask
• oset. Location to store the old signal mask

Returned Values:

• 0 (OK), or -1 (ERROR) if how is invalid.

Assumptions/Limitations:

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.8.8 sigpending

Function Prototype:

    #include <signal.h>
    int sigpending( sigset_t *set );

Description: This function stores the returns the set of signals that are blocked for delivery and that are pending for the calling task in the space pointed to by set.

If the task receiving a signal has the signal blocked via its sigprocmask, the signal will pend until it is unmasked. Only one pending signal (for a given signo) is retained by the system. This is consistent with POSIX which states: "If a subsequent occurrence of a pending signal is generated, it is implementation defined as to whether the signal is delivered more than once."

Input Parameters:

• set. The location to return the pending signal set.

Returned Values:

• 0 (OK) or -1 (ERROR)

Assumptions/Limitations:

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.8.9 sigsuspend

Function Prototype:

    #include <signal.h>
    int sigsuspend( const sigset_t *set );

Description: The sigsuspend() function replaces the signal mask with the set of signals pointed to by the argument set and then suspends the task until delivery of a signal to the task.

If the effect of the set argument is to unblock a pending signal, then no wait is performed.

The original signal mask is restored when sigsuspend() returns.

Waiting for an empty signal set stops a task without freeing any resources (a very bad idea).

Input Parameters:

• set. The value of the signal mask to use while suspended.

Returned Values:

• -1 (ERROR) always

Assumptions/Limitations:

POSIX Compatibility: Comparable to the POSIX interface of the same name. Differences from the POSIX specification include:

• POSIX does not indicate that the original signal mask is restored.
• POSIX states that sigsuspend() "suspends the task until delivery of a signal whose action is either to execute a signal-catching function or to terminate the task." Only delivery of the signal is required in the present implementation (even if the signal is ignored).

2.8.10 sigwaitinfo

Function Prototype:

    #include <signal.h>
    int sigwaitinfo(const sigset_t *set, struct siginfo *info);

Description: This function is equivalent to sigtimedwait() with a NULL timeout parameter. (see below).

Input Parameters:

• set. The set of pending signals to wait for.
• info. The returned signal values

Returned Values:

• Signal number that cause the wait to be terminated, otherwise -1 (ERROR) is returned.

Assumptions/Limitations:

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.8.11 sigtimedwait

Function Prototype:

    #include <signal.h>
    int sigtimedwait( const sigset_t *set, struct siginfo *info,
                      const struct timespec *timeout );

Description: This function selects the pending signal set specified by the argument set. If multiple signals are pending in set, it will remove and return the lowest numbered one. If no signals in set are pending at the time of the call, the calling task will be suspended until one of the signals in set becomes pending OR until the task interrupted by an unblocked signal OR until the time interval specified by timeout (if any), has expired. If timeout is NULL, then the timeout interval is forever.

If the info argument is non-NULL, the selected signal number is stored in the si_signo member and the cause of the signal is store in the si_code member. The content of si_value is only meaningful if the signal was generated by sigqueue(). The following values for si_code are defined in signal.h:

• SI_USER. Signal sent from kill, raise, or abort
• SI_QUEUE. Signal sent from sigqueue
• SI_TIMER. Signal is result of timer expiration
• SI_ASYNCIO. Signal is the result of asynchronous IO completion
• SI_MESGQ. Signal generated by arrival of a message on an empty message queue.

Input Parameters:

• set. The set of pending signals to wait for.
• info. The returned signal values
• timeout. The amount of time to wait

Returned Values:

• Signal number that cause the wait to be terminated, otherwise -1 (ERROR) is returned.

Assumptions/Limitations:

POSIX Compatibility: Comparable to the POSIX interface of the same name. Differences from the POSIX interface include:

• Values for si_codes differ
• No mechanism to return cause of ERROR. (It can be inferred from si_code in a non-standard way).
• POSIX states that "If no signal is pending at the time of the call, the calling task shall be suspended until one or more signals in set become pending or until it is interrupted by an unblocked, caught signal." The present implementation does not require that the unblocked signal be caught; the task will be resumed even if the unblocked signal is ignored.

2.8.12 sigqueue

Function Prototype:

    #include <signal.h>
    int sigqueue (int tid, int signo, union sigval value);

Description: This function sends the signal specified by signo with the signal parameter value to the task specified by tid.

If the receiving task has the signal blocked via its sigprocmask, the signal will pend until it is unmasked. Only one pending signal (for a given signo) is retained by the system. This is consistent with POSIX which states: "If a subsequent occurrence of a pending signal is generated, it is implementation defined as to whether the signal is delivered more than once."

Input Parameters:

• tid. ID of the task to receive signal
• signo. Signal number
• value. Value to pass to task with signal

Returned Values:

• On success (at least one signal was sent), zero (OK) is returned. On error, -1 (ERROR) is returned, and errno is set appropriately.
  • EGAIN. The limit of signals which may be queued has been reached.
  • EINVAL. signo was invalid.
  • EPERM. The task does not have permission to send the signal to the receiving process.
  • ESRCH. No process has a PID matching pid.

Assumptions/Limitations:

POSIX Compatibility: Comparable to the POSIX interface of the same name. Differences from the POSIX interface include:

• Default action is to ignore signals.
• Signals are processed one at a time in order
• POSIX states that, "If signo is zero (the null signal), error checking will be performed but no signal is actually sent." There is no null signal in the present implementation; a zero signal will be sent.

2.8.13 kill

Function Prototype:

   #include <sys/types.h>
   #include <signal.h>
   int kill(pid_t pid, int sig);

Description: The kill() system call can be used to send any signal to any task.

If the receiving task has the signal blocked via its sigprocmask, the signal will pend until it is unmasked. Only one pending signal (for a given signo) is retained by the system. This is consistent with POSIX which states: "If a subsequent occurrence of a pending signal is generated, it is implementation defined as to whether the signal is delivered more than once."

Input Parameters:

• pid. The id of the task to receive the signal. The POSIX kill() specification encodes process group information as zero and negative pid values. Only positive, non-zero values of pid are supported by this implementation. ID of the task to receive signal
• signo. The signal number to send. If signo is zero, no signal is sent, but all error checking is performed.

Returned Values:

• OK or ERROR

Assumptions/Limitations:

POSIX Compatibility: Comparable to the POSIX interface of the same name. Differences from the POSIX interface include:

• Default action is to ignore signals.
• Signals are processed one at a time in order
• Sending of signals to 'process groups' is not supported in NuttX.

NuttX does not support processes in the way that, say, Linux does. NuttX only supports simple threads or tasks running within the same address space. For the most part, threads and tasks are interchangeable and differ primarily only in such things as the inheritance of file descriptors. Basically, threads are initialized and uninitialized differently and share a few more resources than tasks.

The following pthread interfaces are supported in some form by NuttX:

• 2.9.1 pthread_attr_init
• 2.9.2 pthread_attr_destroy
• 2.9.3 pthread_attr_setschedpolicy
• 2.9.4 pthread_attr_getschedpolicy
• 2.9.5 pthread_attr_setschedparam
• 2.9.6 pthread_attr_getschedparam
• 2.9.7 pthread_attr_setinheritsched
• 2.9.8 pthread_attr_getinheritsched
• 2.9.9 pthread_attr_setstacksize
• 2.9.10 pthread_attr_getstacksize
• 2.9.11 pthread_create
• 2.9.12 pthread_detach
• 2.9.13 pthread_exit
• 2.9.14 pthread_cancel
• 2.9.15 pthread_setcancelstate
• 2.9.16 pthread_testcancelstate
• 2.9.17 pthread_join
• 2.9.18 pthread_yield
• 2.9.19 pthread_self
• 2.9.20 pthread_getschedparam
• 2.9.21 pthread_setschedparam
• 2.9.22 pthread_key_create
• 2.9.23 pthread_setspecific
• 2.9.24 pthread_getspecific
• 2.9.25 pthread_key_delete
• 2.9.26 pthread_mutexattr_init
• 2.9.27 pthread_mutexattr_destroy
• 2.9.28 pthread_mutexattr_getpshared
• 2.9.29 pthread_mutexattr_setpshared
• 2.9.30 pthread_mutexattr_gettype
• 2.9.31 pthread_mutexattr_settype
• 2.9.32 pthread_mutex_init
• 2.9.33 pthread_mutex_destroy
• 2.9.34 pthread_mutex_lock
• 2.9.35 pthread_mutex_trylock
• 2.9.36 pthread_mutex_unlock
• 2.9.37 pthread_condattr_init
• 2.9.38 pthread_condattr_destroy
• 2.9.39 pthread_cond_init
• 2.9.40 pthread_cond_destroy
• 2.9.41 pthread_cond_broadcast
• 2.9.42 pthread_cond_signal
• 2.9.43 pthread_cond_wait
• 2.9.44 pthread_cond_timedwait
• 2.9.45 pthread_barrierattr_init
• 2.9.46 pthread_barrierattr_destroy
• 2.9.47 pthread_barrierattr_setpshared
• 2.9.48 pthread_barrierattr_getpshared
• 2.9.49 pthread_barrier_init
• 2.9.50 pthread_barrier_destroy
• 2.9.51 pthread_barrier_wait
• 2.9.52 pthread_once
• 2.9.53 pthread_kill
• 2.9.54 pthread_sigmask

No support for the following pthread interfaces is provided by NuttX:

• pthread_atfork. register fork handlers.
• pthread_attr_getdetachstate. get and set the detachstate attribute.
• pthread_attr_getguardsize. get and set the thread guardsize attribute.
• pthread_attr_getinheritsched. get and set the inheritsched attribute.
• pthread_attr_getscope. get and set the contentionscope attribute.
• pthread_attr_getstack. get and set stack attributes.
• pthread_attr_getstackaddr. get and set the stackaddr attribute.
• pthread_attr_setdetachstate. get and set the detachstate attribute.
• pthread_attr_setguardsize. get and set the thread guardsize attribute.
• pthread_attr_setscope. get and set the contentionscope attribute.
• pthread_attr_setstack. get and set stack attributes.
• pthread_attr_setstackaddr. get and set the stackaddr attribute.
• pthread_barrier_destroy. destroy and initialize a barrier object.
• pthread_barrier_init. destroy and initialize a barrier object.
• pthread_barrier_wait. synchronize at a barrier.
• pthread_cleanup_pop. establish cancellation handlers.
• pthread_cleanup_push. establish cancellation handlers.
• pthread_condattr_getclock. set the clock selection condition variable attribute.
• pthread_condattr_getpshared. get the process-shared condition variable attribute.
• pthread_condattr_setclock. set the clock selection condition variable attribute.
• pthread_condattr_setpshared. set the process-shared condition variable attribute.
• pthread_getconcurrency. get and set the level of concurrency.
• pthread_getcpuclockid. access a thread CPU-time clock.
• pthread_mutex_getprioceiling. get and set the priority ceiling of a mutex.
• pthread_mutex_setprioceiling. get and set the priority ceiling of a mutex.
• pthread_mutex_timedlock. lock a mutex.
• pthread_mutexattr_getprioceiling. get and set the prioceiling attribute of the mutex attributes object.
• pthread_mutexattr_getprotocol. get and set the protocol attribute of the mutex attributes object.
• pthread_mutexattr_setprioceiling. get and set the prioceiling attribute of the mutex attributes object.
• pthread_mutexattr_setprotocol. get and set the protocol attribute of the mutex attributes object.
• pthread_rwlock_destroy. destroy and initialize a read-write lock object.
• pthread_rwlock_init. destroy and initialize a read-write lock object.
• pthread_rwlock_rdlock. lock a read-write lock object for reading.
• pthread_rwlock_timedrdlock. lock a read-write lock for reading.
• pthread_rwlock_timedwrlock. lock a read-write lock for writing.
• pthread_rwlock_tryrdlock. lock a read-write lock object for reading.
• pthread_rwlock_trywrlock. lock a read-write lock object for writing.
• pthread_rwlock_unlock. unlock a read-write lock object.
• pthread_rwlock_wrlock. lock a read-write lock object for writing.
• pthread_rwlockattr_destroy. destroy and initialize the read-write lock attributes object.
• pthread_rwlockattr_getpshared. get and set the process-shared attribute of the read-write lock attributes object.
• pthread_rwlockattr_init. destroy and initialize the read-write lock attributes object.
• pthread_rwlockattr_setpshared. get and set the process-shared attribute of the read-write lock attributes object.
• pthread_setcanceltype. set cancelability state.
• pthread_setconcurrency. get and set the level of concurrency.
• pthread_spin_destroy. destroy or initialize a spin lock object.
• pthread_spin_init. destroy or initialize a spin lock object.
• pthread_spin_lock. lock a spin lock object.
• pthread_spin_trylock. lock a spin lock object.
• pthread_spin_unlock. unlock a spin lock object.
• pthread_testcancel. set cancelability state.

2.9.1 pthread_attr_init

Function Prototype:

    #include <pthread.h>
    int pthread_attr_init(pthread_attr_t *attr);

Description: Initializes a thread attributes object (attr) with default values for all of the individual attributes used by the implementation.

Input Parameters:

• To be provided.

Returned Values:

If successful, the pthread_attr_init() function will return zero (OK). Otherwise, an error number will be returned to indicate the error:

• To be provided.

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.9.2 pthread_attr_destroy

Function Prototype:

    #include <pthread.h>
    int pthread_attr_destroy(pthread_attr_t *attr);

Description: An attributes object can be deleted when it is no longer needed.

Input Parameters:

• To be provided.

Returned Values:

If successful, the pthread_attr_destroy() function will return zero (OK). Otherwise, an error number will be returned to indicate the error:

• To be provided.

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.9.3 pthread_attr_setschedpolicy

Function Prototype:

    #include <pthread.h>
    int pthread_attr_setschedpolicy(pthread_attr_t *attr, int policy);

Description:

Input Parameters:

• To be provided.

Returned Values:

If successful, the pthread_attr_setschedpolicy() function will return zero (OK). Otherwise, an error number will be returned to indicate the error:

• To be provided.

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.9.4 pthread_attr_getschedpolicy

Function Prototype:

    #include <pthread.h>
    int pthread_attr_getschedpolicy(pthread_attr_t *attr, int *policy);

Description:

Input Parameters:

• To be provided.

Returned Values:

If successful, the pthread_attr_getschedpolicy() function will return zero (OK). Otherwise, an error number will be returned to indicate the error:

• To be provided.

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.9.5 pthread_attr_getschedpolicy

Function Prototype:

   #include <pthread.h>
    int pthread_attr_setschedparam(pthread_attr_t *attr,
				      const struct sched_param *param);

Description:

Input Parameters:

• To be provided.

Returned Values:

If successful, the pthread_attr_getschedpolicy() function will return zero (OK). Otherwise, an error number will be returned to indicate the error:

• To be provided.

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.9.6 pthread_attr_getschedparam

Function Prototype:

   #include <pthread.h>
     int pthread_attr_getschedparam(pthread_attr_t *attr,
				      struct sched_param *param);

Description:

Input Parameters:

• To be provided.

Returned Values:

If successful, the pthread_attr_getschedparam() function will return zero (OK). Otherwise, an error number will be returned to indicate the error:

• To be provided.

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.9.7 pthread_attr_setinheritsched

Function Prototype:

   #include <pthread.h>
    int pthread_attr_setinheritsched(pthread_attr_t *attr,
					int inheritsched);

Description:

Input Parameters:

• To be provided.

Returned Values:

If successful, the pthread_attr_setinheritsched() function will return zero (OK). Otherwise, an error number will be returned to indicate the error:

• To be provided.

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.9.8 pthread_attr_getinheritsched

Function Prototype:

   #include <pthread.h>
     int pthread_attr_getinheritsched(const pthread_attr_t *attr,
					int *inheritsched);

Description:

Input Parameters:

• To be provided.

Returned Values:

If successful, the pthread_attr_getinheritsched() function will return zero (OK). Otherwise, an error number will be returned to indicate the error:

• To be provided.

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.9.9 pthread_attr_setstacksize

Function Prototype:

   #include <pthread.h>
    int pthread_attr_setstacksize(pthread_attr_t *attr, long stacksize);

Description:

Input Parameters:

• To be provided.

Returned Values:

If successful, the pthread_attr_setstacksize() function will return zero (OK). Otherwise, an error number will be returned to indicate the error:

• To be provided.

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.9.10 pthread_attr_getstacksize

Function Prototype:

    #include <pthread.h>
   int pthread_attr_getstacksize(pthread_attr_t *attr, long *stackaddr);

Description:

Input Parameters:

• To be provided.

Returned Values:

If successful, the pthread_attr_getstacksize() function will return zero (OK). Otherwise, an error number will be returned to indicate the error:

• To be provided.

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.9.11 pthread_create

Function Prototype:

    #include <pthread.h>
    int pthread_create(pthread_t *thread, pthread_attr_t *attr,
			  pthread_startroutine_t startRoutine,
			  pthread_addr_t arg);

Description: To create a thread object and runnable thread, a routine must be specified as the new thread's start routine. An argument may be passed to this routine, as an untyped address; an untyped address may also be returned as the routine's value. An attributes object may be used to specify details about the kind of thread being created.

Input Parameters:

• To be provided.

Returned Values:

If successful, the pthread_create() function will return zero (OK). Otherwise, an error number will be returned to indicate the error:

• To be provided.

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.9.12 pthread_detach

Function Prototype:

    #include <pthread.h>
    int pthread_detach(pthread_t thread);

Description: A thread object may be "detached" to specify that the return value and completion status will not be requested.

Input Parameters:

• To be provided.

Returned Values:

If successful, the pthread_detach() function will return zero (OK). Otherwise, an error number will be returned to indicate the error:

• To be provided.

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.9.13 pthread_exit

Function Prototype:

    #include <pthread.h>
    void pthread_exit(pthread_addr_t pvValue);

Description: A thread may terminate it's own execution.

Input Parameters:

• To be provided.

Returned Values:

If successful, the pthread_exit() function will return zero (OK). Otherwise, an error number will be returned to indicate the error:

• To be provided.

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.9.14 pthread_cancel

Function Prototype:

    #include <pthread.h>
    int pthread_cancel(pthread_t thread);

Description:

The pthread_cancel() function shall request that thread be canceled. The target thread's cancelability state determines when the cancellation takes effect. When the cancellation is acted on, thread shall be terminated.

When cancelability is disabled, all cancels are held pending in the target thread until the thread changes the cancelability. When cancelability is deferred, all cancels are held pending in the target thread until the thread changes the cancelability or calls pthread_testcancel().

Cancelability is asynchronous; all cancels are acted upon immediately (when enable), interrupting the thread with its processing.

Input Parameters:

• thread. Identifies the thread to be canceled.

Returned Values:

If successful, the pthread_cancel() function will return zero (OK). Otherwise, an error number will be returned to indicate the error:

• ESRCH. No thread could be found corresponding to that specified by the given thread ID.

POSIX Compatibility: Comparable to the POSIX interface of the same name. Except:

• The thread-specific data destructor functions shall be called for thread. However, these destructors are not currently supported.
• Cancellation types are not supported. The thread will be canceled at the time that pthread_cancel() is called or, if cancellation is disabled, at the time when cancellation is re-enabled.
• pthread_testcancel() is not supported.
• Thread cancellation at cancellation points is not supported.

2.9.15 pthread_setcancelstate

Function Prototype:

    #include <pthread.h>
    int pthread_setcancelstate(int state, int *oldstate);

Description:

The pthread_setcancelstate() function atomically sets both the calling thread's cancelability state to the indicated state and returns the previous cancelability state at the location referenced by oldstate. Legal values for state are PTHREAD_CANCEL_ENABLE and PTHREAD_CANCEL_DISABLE.<.li>

Any pending thread cancellation may occur at the time that the cancellation state is set to PTHREAD_CANCEL_ENABLE.

• state New cancellation state. One of PTHREAD_CANCEL_ENABLE or PTHREAD_CANCEL_DISABLE.<.li>
• oldstate. Location to return the previous cancellation state.

Returned Values:

If successful, the pthread_setcancelstate() function will return zero (OK). Otherwise, an error number will be returned to indicate the error:

• ESRCH. No thread could be found corresponding to that specified by the given thread ID.

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.9.16 pthread_testcancelstate

Function Prototype:

    #include <pthread.h>
    int pthread_setcancelstate(void);

Description:

NOT SUPPORTED Input Parameters:

• To be provided.

Returned Values:

If successful, the pthread_setcancelstate() function will return zero (OK). Otherwise, an error number will be returned to indicate the error:

• To be provided.

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.9.17 pthread_join

Function Prototype:

    #include <pthread.h>
    int pthread_join(pthread_t thread, pthread_addr_t *ppvValue);

Description: A thread can await termination of another thread and retrieve the return value of the thread.

Input Parameters:

• To be provided.

Returned Values:

If successful, the pthread_join() function will return zero (OK). Otherwise, an error number will be returned to indicate the error:

• To be provided.

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.9.18 pthread_yield

Function Prototype:

    #include <pthread.h>
    void pthread_yield(void);

Description: A thread may tell the scheduler that its processor can be made available.

Input Parameters:

• To be provided.

Returned Values:

If successful, the pthread_yield() function will return zero (OK). Otherwise, an error number will be returned to indicate the error:

• To be provided.

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.9.19 pthread_self

Function Prototype:

    #include <pthread.h>
    pthread_t pthread_self(void);

Description: A thread may obtain a copy of its own thread handle.

Input Parameters:

• To be provided.

Returned Values:

If successful, the pthread_self() function will return zero (OK). Otherwise, an error number will be returned to indicate the error:

• To be provided.

POSIX Compatibility: Comparable to the POSIX interface of the same name.

2.9.20 pthread_getschedparam

Function Prototype:

    #include <pthread.h>
    int pthread_getschedparam(pthread_t thread, int *policy,
                              struct sched_param *param);

Description: The pthread_getschedparam() functions will get the scheduling policy and parameters of threads. For SCHED_FIFO and SCHED_RR, the only required member of the sched_param structure is the priority sched_priority.

The pthread_getschedparam() function will retrieve the scheduling policy and scheduling parameters for the thread whose thread ID is given by thread and will store those values in policy and param, respectively. The priority value returned from pthread_getschedparam() will be the value specified by the most recent pthread_setschedparam(), pthread_setschedprio(), or pthread_create() call affecting the target thread. It will not reflect any temporary adjustments to its priority (such as might result of any priority inheritance, for example).

The policy parameter may have the value SCHED_FIFO or SCHED_RR (SCHED_OTHER and SCHED_SPORADIC, in particular, are not supported). The SCHED_FIFO and SCHED_RR policies will have a single scheduling parameter, sched_priority.

    #include <pthread.h>
    int pthread_setschedparam(pthread_t thread, int policy,
                              const struct sched_param *param);

    #include <pthread.h>
    int pthread_key_create( pthread_key_t *key, void (*destructor)(void*) )

    #include <pthread.h>
    int pthread_setspecific( pthread_key_t key, void *value )

    #include <pthread.h>
    void *pthread_getspecific( pthread_key_t key )

    #include <pthread.h>
    int pthread_key_delete( pthread_key_t key )

    #include <pthread.h>
    int pthread_mutexattr_init(pthread_mutexattr_t *attr);

    #include <pthread.h>
    int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);

    #include <pthread.h>
    int pthread_mutexattr_getpshared(pthread_mutexattr_t *attr,
					int *pshared);

    #include <pthread.h>
   int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr,
					int pshared);

    #include <pthread.h>
#ifdef CONFIG_MUTEX_TYPES
    int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr, int *type);
#endif

    #include <pthread.h>
#ifdef CONFIG_MUTEX_TYPES
    int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);
#endif

    #include <pthread.h>
    int pthread_mutex_init(pthread_mutex_t *mutex,
			      pthread_mutexattr_t *attr);

    #include <pthread.h>
    int pthread_mutex_destroy(pthread_mutex_t *mutex);

    #include <pthread.h>
    int pthread_mutex_lock(pthread_mutex_t *mutex);

    #include <pthread.h>
    int pthread_mutex_trylock(pthread_mutex_t *mutex);

    #include <pthread.h>
    int pthread_mutex_unlock(pthread_mutex_t *mutex);

    #include <pthread.h>
    int pthread_condattr_init(pthread_condattr_t *attr);

    #include <pthread.h>
    int pthread_condattr_destroy(pthread_condattr_t *attr);

    #include <pthread.h>
    int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *attr);

    #include <pthread.h>
    int pthread_cond_destroy(pthread_cond_t *cond);

    #include <pthread.h>
    int pthread_cond_broadcast(pthread_cond_t *cond);

    #include <pthread.h>
    int pthread_cond_signal(pthread_cond_t *dond);

    #include <pthread.h>
    int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);

    #include <pthread.h>
    int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
				  const struct timespec *abstime);

    #include <pthread.h>
    int pthread_barrierattr_init(FAR pthread_barrierattr_t *attr);

    #include <pthread.h>
    int pthread_barrierattr_destroy(FAR pthread_barrierattr_t *attr);

    #include <pthread.h>
    int pthread_barrierattr_setpshared(FAR pthread_barrierattr_t *attr, int pshared);

    #include <pthread.h>
    int pthread_barrierattr_getpshared(FAR const pthread_barrierattr_t *attr, FAR int *pshared);

    #include <pthread.h>
    int pthread_barrier_init(FAR pthread_barrier_t *barrier,
                             FAR const pthread_barrierattr_t *attr, unsigned int count);

    #include <pthread.h>
    int pthread_barrier_destroy(FAR pthread_barrier_t *barrier);

    #include <pthread.h>
    int pthread_barrier_wait(FAR pthread_barrier_t *barrier);

    #include <pthread.h>
    int pthread_once(FAR pthread_once_t *once_control, CODE void (*init_routine)(void));

    #include <signal.h>
    #include <pthread.h>
    int pthread_kill(pthread_t thread, int signo)

    #include <signal.h>
    #include <pthread.h>
    int pthread_sigmask(int how, FAR const sigset_t *set, FAR sigset_t *oset);

  #include <stdlib.h>
  FAR char *getenv(const char *name);

  #include <stdlib.h>
  int putenv(char *string);

  #include <stdlib.h>
  int clearenv(void);

  #include <stdlib.h>
  int setenv(const char *name, const char *value, int overwrite);

  #include <stdlib.h>
  int unsetenv(const char *name);

  #include <poll.h>
  int     poll(struct pollfd *fds, nfds_t nfds, int timeout);

  #include <sys/select.h>
  int     select(int nfds, FAR fd_set *readfds, FAR fd_set *writefds,
                 FAR fd_set *exceptfds, FAR struct timeval *timeout);

  #include <unistd.h>
  int pipe(int filedes[2]);

  #include <sys/stat.h>
  int mkfifo(FAR const char *pathname, mode_t mode);

  #include <sys/socket.h>
  int socket(int domain, int type, int protocol);

  #include <sys/socket.h>
  int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

  #include <sys/socket.h>
  int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

  #include <sys/socket.h>
  int listen(int sockfd, int backlog);

  #include <sys/socket.h>
  int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

  #include <sys/socket.h>
  ssize_t send(int sockfd, const void *buf, size_t len, int flags);

  #include <sys/socket.h>
  ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                 const struct sockaddr *to, socklen_t tolen);

  #include <sys/socket.h>
  ssize_t recv(int sockfd, void *buf, size_t len, int flags);

  #include <sys/socket.h>
  ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                   struct sockaddr *from, socklen_t *fromlen);

  #include <sys/socket.h>
  int setsockopt(int sockfd, int level, int option,
                 const void *value, socklen_t value_len);

  #include <sys/socket.h>
  int getsockopt(int sockfd, int level, int option,
                 void *value, socklen_t *value_len);

    #include <errno.h>
    #define errno *get_errno_ptr()
    int *get_errno_ptr( void )

    typedef int (*main_t)(int argc, char *argv[]);

    struct sched_param
    {
      int sched_priority;
    };

    struct timespec
    {
      time_t tv_sec;  /* Seconds */
      long   tv_nsec; /* Nanoseconds */
    };

    struct mq_attr {
      size_t       mq_maxmsg;   /* Max number of messages in queue */
      size_t       mq_msgsize;  /* Max message size */
      unsigned     mq_flags;    /* Queue flags */
      size_t       mq_curmsgs;  /* Number of messages currently in queue */
    };

    struct sigaction
    {
      union
      {
        void (*_sa_handler)(int);
        void (*_sa_sigaction)(int, siginfo_t *, void *);
      } sa_u;
      sigset_t           sa_mask;
      int                sa_flags;
    };
    #define sa_handler   sa_u._sa_handler
    #define sa_sigaction sa_u._sa_sigaction

    typedef struct siginfo
    {
      int          si_signo;
      int          si_code;
      union sigval si_value;
   } siginfo_t;

    union sigval
    {
      int   sival_int;
      void *sival_ptr;
    };

    struct sigevent
    {
      int          sigev_signo;
      union sigval sigev_value;
      int          sigev_notify;
    };

    typedef void (*wdentry_t)(int argc, ...);

    union wdparm_u
    {
      void   *pvarg;
      uint32_t *dwarg;
    };
    typedef union wdparm_u wdparm_t;