NuttxUserGuide.html

<p>The <i>pthread_setcancelstate()</i> 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>

<p>Any pending thread cancelation may occur at the time that the
cancelation state is set to PTHREAD_CANCEL_ENABLE.</p>

<b>Input Parameters:</b>
<p>
<ul>
<li><I>state</I> 
New cancelation state.  One of PTHREAD_CANCEL_ENABLE or PTHREAD_CANCEL_DISABLE.<.li>
<li><I>oldstate</I>.
Location to return the previous cancelation state.
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_setcancelstate()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be returned to indicate the error:
<p>
<ul>
<li><I>ESRCH</I>.
No thread could be found corresponding to that specified by the given thread ID.</li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadtestcancelstate">2.9.16 pthread_testcancelstate</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_setcancelstate(void);
</pre>
<p>
<b>Description:</b>
<p><b>NOT SUPPORTED</b>
<b>Input Parameters:</b>
<p>
<ul>
  <li><code>To be provided</code>.</li>
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_setcancelstate()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
  <li><code>To be provided</code>. </li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadjoin">2.9.17 pthread_join</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_join(pthread_t thread, pthread_addr_t *ppvValue);
</pre>
<p>
<b>Description:</b>
A thread can await termination of another thread and retrieve
the return value of the thread.
<p>
<b>Input Parameters:</b>
<p>
<ul>
  <li><code>To be provided</code>.</li>
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_join()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
  <li><code>To be provided</code>. </li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadyield">2.9.18 pthread_yield</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    void pthread_yield(void);
</pre>
<p>
<b>Description:</b>
A thread may tell the scheduler that its processor can be
made available.
<p>
<b>Input Parameters:</b>
<p>
<ul>
  <li><code>To be provided</code>.</li>
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_yield()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
  <li><code>To be provided</code>. </li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadself">2.9.19 pthread_self</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    pthread_t pthread_self(void);
</pre>
<p>
<b>Description:</b>
A thread may obtain a copy of its own thread handle.
<p>
<b>Input Parameters:</b>
<p>
<ul>
  <li><code>To be provided</code>.</li>
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_self()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
  <li><code>To be provided</code>. </li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadgetschedparam">2.9.20 pthread_getschedparam</a></H3>
<p>
  <b>Function Prototype:</b>
</p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_getschedparam(pthread_t thread, int *policy,
                              struct sched_param *param);
</pre>
<p>
  <b>Description:</b>
  The <code>pthread_getschedparam()</code> functions will get the 
  scheduling policy and parameters of threads.
  For <code>SCHED_FIFO</code> and <code>SCHED_RR</code>, the only
  required member of the <code>sched_param</code> structure is the
  priority <code>sched_priority</code>.
</p>
<p>
  The <code>pthread_getschedparam()</code> function will retrieve the
  scheduling policy and scheduling parameters for the thread whose thread
  ID is given by <code>thread</code> and will store those values in
  <code>policy</code> and <code>param</code>, respectively.
  The priority value returned from <code>pthread_getschedparam()</code>
  will be the value specified by the most recent <code>pthread_setschedparam()</code>,
  <code>pthread_setschedprio()</code>, or <code>pthread_create()</code> 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).
</p>
<p>
  The policy parameter may have the value <code>SCHED_FIFO</code> or <code>SCHED_RR</code>
  (<code>SCHED_OTHER</code> and <code>SCHED_SPORADIC</code>, in particular, are not supported).
  The <code>SCHED_FIFO</code> and <code>SCHED_RR<code> policies will have a single
  scheduling parameter, <code>sched_priority</code>.
</p>
<p>
  <b>Input Parameters:</b>
</p>
<ul>
  <li>
    <code>thread</code>.
    The ID of thread whose scheduling parameters will be queried.
  </li>
  <li>
    <code>policy</code>.
    The location to store the thread's scheduling policy.
  </li>
  <li>
    <code>param</code>.
    The location to store the thread's priority.
  </li>
</ul>
<p>
  <b>Returned Values:</b>
  0 (<code>OK</code>) if successful.
  Otherwise, the error code <code>ESRCH</code> if the value specified by
  <code>thread</code> does not refer to an existing thread.
</p>
<p>
  <b>Assumptions/Limitations:</b>
</p>
<p>
  <b>POSIX Compatibility:</b>
  Comparable to the POSIX interface of the same name.
</p>

<H3><a name="pthreadsetschedparam">2.9.21 pthread_setschedparam</a></H3>
<p>
  <b>Function Prototype:</b>
</p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_setschedparam(pthread_t thread, int policy,
                              const struct sched_param *param);
</pre>
<p>
  <b>Description:</b>
  The <code>pthread_setschedparam()</code> functions will set the scheduling policy
  and parameters of threads.
  For <code>SCHED_FIFO</code> and <code>SCHED_RR</code>, the only required member
  of the <code>sched_param</code> structure is the priority <code>sched_priority</code>.
</p>
</p>
  The <code>pthread_setschedparam()</code> function will set the scheduling policy
  and associated scheduling parameters for the thread whose thread ID is given by
  <code>thread</code> to the policy and associated parameters provided in
  <code>policy</code> and <code>param</code>, respectively.
</p>
<p>
  The policy parameter may have the value <code>SCHED_FIFO</code> or <code>SCHED_RR</code>.
  (<code>SCHED_OTHER</code> and <code>SCHED_SPORADIC</code>, in particular, are not supported).
  The <code>SCHED_FIFO</code> and <code>SCHED_RR</code> policies will have a single
  scheduling parameter, <code>sched_priority</code>.
</p>
<p>
  If the <code>pthread_setschedparam()</code> function fails, the scheduling
  parameters will not be changed for the target thread.
</p>
<p>
  <b>Input Parameters:</b>
</p>
<ul>
  <li>
    <code>thread</code>.
    The ID of thread whose scheduling parameters will be modified.
  </li>
  <li>
    <code>policy</code>.
    The new scheduling policy of the thread.
    Either <code>SCHED_FIFO</code> or <code>SCHED_RR<code>.
    <code>SCHED_OTHER<code> and <code>SCHED_SPORADIC<code> are not supported.
  </li>
  <li>
    <code>param</code>.
    The location to store the thread's priority.
  </li>
</ul>
<p>
  <b>Returned Values:</b>
</p>
<p>
  If successful, the <I>pthread_setschedparam()</I> function will return
  zero (<I>OK</I>).  Otherwise, an error number will be
  returned to indicate the error:
</p>
<ul>
  <li>
    <code>EINVAL</code>.
    The value specified by <code>policy</code> or one of the scheduling parameters
    associated with the scheduling policy <code>policy</code> is invalid.
  </li>
  <li>
    <code>ENOTSUP</code>.
    An attempt was made to set the policy or scheduling parameters to an unsupported
    value (<code>SCHED_OTHER</code> and <code>SCHED_SPORADIC</code> in particular are
    not supported)
  </li>
  <li>
    <code>EPERM</code>.
    The caller does not have the appropriate permission to set either the scheduling
    parameters or the scheduling policy of the specified thread.
    Or, the implementation does not allow the application to modify one of the
    parameters to the value specified.

  </li>
  <li>
    <code>ESRCH</code>.
    The value specified by thread does not refer to a existing thread.
  </li>
</ul>
<p>
  <b>Assumptions/Limitations:</b>
</p>
<p>
  <b>POSIX Compatibility:</b>
  Comparable to the POSIX interface of the same name.
</p>

<H3><a name="pthreadkeycreate">2.9.22 pthread_key_create</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_key_create( pthread_key_t *key, void (*destructor)(void*) )
</pre>
<p>
<b>Description:</b>
<p>
This function creates a thread-specific data key visible
to all threads in the system.  Although the same key value
may be used by different threads, the values bound to
the key by <I>pthread_setspecific()</I> are maintained on a
per-thread basis and persist for the life of the calling
thread.
<p>
Upon key creation, the value <I>NULL</I> will be associated with
the the new key in all active threads.  Upon thread
creation, the value <I>NULL</I> will be associated with all
defined keys in the new thread.
<p>
<b>Input Parameters:</b>
<p>
<ul>
<li><I>key</I> is a pointer to the key to create.
<li><I>destructor</I> is an optional destructor() function that may
be associated with each key that is invoked when a
thread exits.  However, this argument is ignored in
the current implementation.
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_key_create()</I> function will
store the newly created key value at *<I>key</I> and return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
<li><I>EAGAIN</I>.  The system lacked sufficient resources
to create another thread-specific data key, or the
system-imposed limit on the total number of keys
per task {<I>PTHREAD_KEYS_MAX</I>} has been exceeded
<li><I>ENONMEM</I>  Insufficient memory exists to create the key.
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.
<ul>
<li>The present implementation ignores the destructor argument.
</ul>

<H3><a name="pthreadsetspecific">2.9.23 pthread_setspecific</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_setspecific( pthread_key_t key, void *value )
</pre>
<p>
<b>Description:</b>
<p>
The <I>pthread_setspecific()</I> function associates a thread-
specific value with a key obtained via a previous call
to <I>pthread_key_create()</I>.  Different threads may bind
different values to the same key.  These values are
typically pointers to blocks of dynamically allocated
memory that have been reserved for use by the calling
thread.
<p>
The effect of calling <I>pthread_setspecific()</I> with a key value
not obtained from <I>pthread_key_create()</I> or after a key has been
deleted with <I>pthread_key_delete()</I> is undefined.
<p>
<b>Input Parameters:</b>
<p>
<ul>
<li><I>key</I>.  The data key to set the binding for.
<li><I>value</I>. The value to bind to the key.
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, <I>pthread_setspecific()</I> will return zero (<I>OK</I>).
Otherwise, an error number will be returned:
<p>
<ul>
<li><I>ENOMEM</I>.  Insufficient memory exists to associate the value
with the key.
<li><I>EINVAL</I>.  The key value is invalid.
</ul>
<p>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.
<ul>
<li>pthread_setspecific() may be called from a thread-specific data
destructor function.
</ul>

<H3><a name="pthreadgetspecific">2.9.24 pthread_getspecific</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    void *pthread_getspecific( pthread_key_t key )
</pre>
<p>
<b>Description:</b>
<p>
The <I>pthread_getspecific()</I> function returns the value
currently bound to the specified key on behalf of the
calling thread.
<p>
The effect of calling <I>pthread_getspecific()</I> with a key value
not obtained from <I>pthread_key_create()</I> or after a key has been
deleted with <I>pthread_key_delete()</I> is undefined.
<p>
<b>Input Parameters:</b>
<p>
<ul>
<li><I>key</I>.  The data key to get the binding for.
</ul>
<p>
<b>Returned Values:</b>
<p>
The function <I>pthread_getspecific()</I> returns the thread-
specific data associated with the given key.  If no
thread specific data is associated with the key, then
the value <I>NULL</I> is returned.
<p>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.
<ul>
<li>pthread_getspecific() may be called from a thread-specific data
destructor function.
</ul>

<H3><a name="pthreadkeydelete">2.9.25 pthread_key_delete</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_key_delete( pthread_key_t key )
</pre>
<p>
<b>Description:</b>
<p>
This POSIX function should delete a thread-specific data
key previously returned by <I>pthread_key_create()</I>.  However,
this function does nothing in the present implementation.
<p>
<b>Input Parameters:</b>
<p>
<ul>
<li><I>key</I>.  The key to delete
</ul>
<p>
<b>Returned Values:</b>
<p>
<ul>
<li>Always returns <I>EINVAL</I>.
</ul>
<p>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadmutexattrinit">2.9.26 pthread_mutexattr_init</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_mutexattr_init(pthread_mutexattr_t *attr);
</pre>
<p>
<b>Description:</b>
<p>
<b>Input Parameters:</b>
<p>
<ul>
  <li><code>To be provided</code>.</li>
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_mutexattr_init()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
  <li><code>To be provided</code>. </li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadmutexattrdestroy">2.9.27 pthread_mutexattr_destroy</a></H3>
<p>
<b>Function Protoype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
</pre>
<p>
<b>Description:</b>
<p>
<b>Input Parameters:</b>
<p>
<ul>
  <li><code>To be provided</code>.</li>
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_mutexattr_destroy()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
  <li><code>To be provided</code>. </li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadmutexattrgetpshared">2.9.28 pthread_mutexattr_getpshared</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_mutexattr_getpshared(pthread_mutexattr_t *attr,
					int *pshared);
</pre>
<p>
<b>Description:</b>
<p>
<b>Input Parameters:</b>
<p>
<ul>
  <li><code>To be provided</code>.</li>
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_mutexattr_getpshared()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
  <li><code>To be provided</code>. </li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadmutexattrsetpshared">2.9.29 pthread_mutexattr_setpshared</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
   int pthread_mutexattr_setpshared(pthread_mutexattr_t *attr,
					int pshared);
</pre>
<p>
<b>Description:</b>
<p>
<b>Input Parameters:</b>
<p>
<ul>
  <li><code>To be provided</code>.</li>
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_mutexattr_setpshared()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
  <li><code>To be provided</code>. </li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadmutexinit">2.9.30 pthread_mutex_init</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_mutex_init(pthread_mutex_t *mutex,
			      pthread_mutexattr_t *attr);
</pre>
<p>
<b>Description:</b>
<p>
<b>Input Parameters:</b>
<p>
<ul>
  <li><code>To be provided</code>.</li>
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_mutex_init()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
  <li><code>To be provided</code>. </li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadmutexdestrory">2.9.31 pthread_mutex_destroy</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_mutex_destroy(pthread_mutex_t *mutex);
</pre>
<p>
<b>Description:</b>
<p>
<b>Input Parameters:</b>
<p>
<ul>
  <li><code>To be provided</code>.</li>
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_mutex_destroy()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
  <li><code>To be provided</code>. </li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadmutexlock">2.9.32 pthread_mutex_lock</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_mutex_lock(pthread_mutex_t *mutex);
</pre>
<p>
<b>Description:</b>
<p>
<b>Input Parameters:</b>
<p>
<ul>
  <li><code>To be provided</code>.</li>
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_mutex_lock()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
  <li><code>To be provided</code>. </li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadmutextrylock">2.9.33 pthread_mutex_trylock</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_mutex_trylock(pthread_mutex_t *mutex);
</pre>
<p>
<b>Description:</b>
<p>
<b>Input Parameters:</b>
<p>
<ul>
  <li><code>To be provided</code>.</li>
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_mutex_trylock()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
  <li><code>To be provided</code>. </li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadmutexunlock">2.9.34 pthread_mutex_unlock</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_mutex_unlock(pthread_mutex_t *mutex);
</pre>
<p>
<b>Description:</b>
<p>
<b>Input Parameters:</b>
<p>
<ul>
  <li><code>param<code>.</li>
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_mutex_unlock()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
  <li><code>To be provided</code>. </li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadconaddrinit">2.9.35 pthread_condattr_init</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_condattr_init(pthread_condattr_t *attr);
</pre>
<p>
<b>Description:</b>
<p>
<b>Input Parameters:</b>
<p>
<ul>
  <li><code>To be provided</code>.</li>
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_condattr_init()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
  <li><code>To be provided</code>. </li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadocndattrdestroy">2.9.36 pthread_condattr_destroy</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_condattr_destroy(pthread_condattr_t *attr);
</pre>
<p>
<b>Description:</b>
<p>
<b>Input Parameters:</b>
<p>
<ul>
  <li><code>To be provided</code>.</li>
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_condattr_destroy()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
  <li><code>To be provided</code>. </li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadcondinit">2.9.37 pthread_cond_init</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *attr);
</pre>
<p>
<b>Description:</b>
<p>
<b>Input Parameters:</b>
<p>
<ul>
  <li><code>To be provided</code>.</li>
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_cond_init()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
  <li><code>To be provided</code>. </li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadconddestroy">2.9.38 pthread_cond_destroy</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_cond_destroy(pthread_cond_t *cond);
</pre>
<p>
<b>Description:</b>
<p>
<b>Input Parameters:</b>
<p>
<ul>
  <li><code>To be provided</code>.</li>
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_cond_destroy()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
  <li><code>To be provided</code>. </li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadcondbroadcast">2.9.39 pthread_cond_broadcast</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_cond_broadcast(pthread_cond_t *cond);
</pre>
<p>
<b>Description:</b>
<p>
<b>Input Parameters:</b>
<p>
<ul>
  <li><code>To be provided</code>.</li>
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_cond_broadcast()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
  <li><code>To be provided</code>. </li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadcondsignal">2.9.40 pthread_cond_signal</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_cond_signal(pthread_cond_t *dond);
</pre>
<p>
<b>Description:</b>
<p>
<b>Input Parameters:</b>
<p>
<ul>
  <li><code>To be provided</code>.</li>
</ul>
<p>
<b>Returned Values:</b>
<p>
If successful, the <I>pthread_cond_signal()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
  <li><code>To be provided</code>. </li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadcondwait">2.9.41 pthread_cond_wait</a></H3>
<p>
<b>Function Prototype:</b>
<p>
<pre>
    #include &lt;pthread.h&gt;
    int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
</pre>
<p>
<b>Description:</b>
<p>
<b>Input Parameters:</b>
<p>
<ul>
  <li><code>To be provided</code>.</li>
</ul>
<p>
  <b>Returned Values:</b>
<p>
If successful, the <I>pthread_cond_wait()</I> function will return
zero (<I>OK</I>).  Otherwise, an error number will be
returned to indicate the error:
<p>
<ul>
  <li><code>To be provided</code>. </li>
</ul>
<b>Assumptions/Limitations:</b>
<p>
<b>POSIX Compatibility:</b> Comparable to the POSIX
interface of the same name.

<H3><a name="pthreadcondtimedwait">2.9.42 pthread_cond_timedwait</a></H3>
<p>
  <b>Function Prototype:</b>
</p>