NuttxUserGuide.html

    Network is unreachable.</li>
  <li><code>ENOTSOCK</code>
    The file descriptor is not associated with a socket.</li>
  <li><code>ETIMEDOUT</code>
    Timeout while attempting connection. The server may be too busy
    to accept new connections.</li>
</ul>

<h3><a name="listen">2.12.4 listen</a></h3>
<p>
  <b>Function Prototype:</b>
</p>
<pre>
  #include <sys/socket.h>
  int listen(int sockfd, int backlog);
</pre>
<p>
  <b>Description:</b>
  To accept connections, a socket is first created with <code>socket()</code>, a
  willingness to accept incoming connections and a queue limit for incoming
  connections are specified with <code>listen()</code>, and then the connections are
  accepted with <code>accept()</code>. The <code>listen()</coe> call applies only to sockets of
  type <code>SOCK_STREAM</code> or <code>SOCK_SEQPACKET</code>.
</p>
<p>
  <b>Input Parameters:</b>
</p>
<ul>
  <li><code>sockfd</code>: Socket descriptor of the bound socket.</li>
  <li><code>backlog</code>: The maximum length the queue of pending connections may grow.
    If a connection request arrives with the queue full, the client may receive an error
    with an indication of ECONNREFUSED or, if the underlying protocol supports retransmission,
    the request may be ignored so that retries succeed.</li>
</ul>
<p>
  <b>Returned Values:</b>
  On success, zero is returned. On error, -1 is returned, and
  <a href="#ErrnoAccess"><code>errno</code></a> is set appropriately.
</p>
<ul>
  <li><code>EADDRINUSE</code>: Another socket is already listening on the same port.</li>
  <li><code>EBADF</code>: The argument <code>sockfd</code> is not a valid descriptor.</li>
  <li><code>ENOTSOCK</code>: The argument <code>sockfd</code> is not a socket.</li>
  <li><code>EOPNOTSUPP</code>: The socket is not of a type that supports the listen operation.</li>
 </ul>
 
<h3><a name="accept">2.12.5 accept</a></h3>
<p>
  <b>Function Prototype:</b>
</p>
<pre>
  #include <sys/socket.h>
  int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
</pre>
<p>
  <b>Description:</b>
  The <code>accept()</code> function is used with connection-based socket types
 (<code>SOCK_STREAM</code>, <code>SOCK_SEQPACKET</code> and <code>SOCK_RDM</code>).
  It extracts the first connection request on the queue of pending connections,
  creates a new connected socket with most of the same properties as <code>sockfd</code>,
  and allocates a new socket descriptor for the socket, which is returned. The
  newly created socket is no longer in the listening state. The original
  socket <code>sockfd</code> is unaffected by this call.  Per file descriptor flags
  are not inherited across an accept.
</p>
<p>
  The <code>sockfd</code> argument is a socket descriptor that has been created with
  <code>socket()</code>, bound to a local address with <code>bind()</code>, and is listening for
  connections after a call to <code>listen()</code>.
</p>
<p>
  On return, the <code>addr</code> structure is filled in with the address of the
  connecting entity. The <code>addrlen</code> argument initially contains the size
  of the structure pointed to by <code>addr</code>; on return it will contain the
  actual length of the address returned.
</p>
<p>
  If no pending connections are present on the queue, and the socket is
  not marked as non-blocking, accept blocks the caller until a connection
  is present. If the socket is marked non-blocking and no pending
  connections are present on the queue, accept returns <code>EAGAIN</code>.
</p>
<p>
  <b>Input Parameters:</b>
</p>
<ul>
  <li><code>sockfd</code>: Socket descriptor of the listening socket.</li>
  <li><code>addr</code>: Receives the address of the connecting client.</li>
  <li><code>addrlen</code>: Input: allocated size of <code>addr</code>, Return: returned size of <code>addr</code>.</li>
</ul>
<p>
  <b>Returned Values:</b>
  Returns -1 on error. If it succeeds, it returns a non-negative integer
  that is a descriptor for the accepted socket.
</p>
<ul>
  <li><code>EAGAIN</code> or <code>EWOULDBLOCK</code>:
    The socket is marked non-blocking and no connections are present to be accepted.</li>
  <li><code>EBADF</code>:
    The descriptor is invalid.</li>
  <li><code>ENOTSOCK</code>:
    The descriptor references a file, not a socket.</li>
  <li><code>EOPNOTSUPP</code>:
    The referenced socket is not of type <code>SOCK_STREAM</code>.</li>
  <li><code>EINTR</code>:
    The system call was interrupted by a signal that was caught before a valid connection arrived.</li>
  <li><code>ECONNABORTED</code>:
    A connection has been aborted.</li>
  <li><code>EINVAL</code>:
    Socket is not listening for connections.</li>
  <li><code>EMFILE</code>:
    The per-process limit of open file descriptors has been reached.</li>
  <li><code>ENFILE</code>:
    The system maximum for file descriptors has been reached.</li>
  <li><code>EFAULT</code>:
    The addr parameter is not in a writable part of the user address space.</li>
  <li><code>ENOBUFS</code> or <code>ENOMEM</code>:
    Not enough free memory.</li>
  <li><code>EPROTO</code>:
    Protocol error.</li>
  <li><code>EPERM</code>:
    Firewall rules forbid connection.</li>
</ul>

<h3><a name="send">2.12.6 <code>send</code></a></h3>
<p>
  <b>Function Prototype:</b>
</p>
<pre>
  #include <sys/socket.h>
  ssize_t send(int sockfd, const void *buf, size_t len, int flags);
</pre>
<p>
  <b>Description:</b>
  The <code>send()</code> call may be used only when the socket is in a connected state
  (so that the intended recipient is known).
  The only difference between <code>send()</code> and <code>write()</code> is the
  presence of <code>flags</code>.
  With <code>zero</code> flags parameter, <code>send()</code> is equivalent to
  <code>write()</code>. Also, <code>send(s,buf,len,flags)</code> is
  equivalent to <code>sendto(s,buf,len,flags,NULL,0)</code>.
</p>
<p>
  <b>Input Parameters:</b>
</p>
<ul>
  <li><code>sockfd</code>: Socket descriptor of socket
  <li><code>buf</code>: Data to send
  <li><code>len</code>: Length of data to send
  <li><code>flags</code>: Send flags
</ul>
<p>
  <b>Returned Values:</b>
  See <a href="#sendto"><code>sendto()</code></a>.
</p>

<h3><a name="sendto">2.12.7 <code>sendto</code></a></h3>
<p>
  <b>Function Prototype:</b>
</p>
<pre>
  #include <sys/socket.h>
  ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                 const struct sockaddr *to, socklen_t tolen);
</pre>
<p>
  <b>Description:</b>
  If <code>sendto()</code> is used on a connection-mode (SOCK_STREAM, SOCK_SEQPACKET)
  socket, the parameters to and tolen are ignored (and the error EISCONN
  may be returned when they are not NULL and 0), and the error ENOTCONN is
  returned when the socket was not actually connected.
<p>
</p>
<p>
  <b>Input Parameters:</b>
</p>
<ul>
  <li><code>sockfd</code>: Socket descriptor of socket
  <li><code>buf</code>: Data to send
  <li><code>len</code>: Length of data to send
  <li><code>flags</code>: Send flags
  <li><code>to</code>: Address of recipient
  <li><code>tolen</code>: The length of the address structure
</ul>
<p>
  <b>Returned Values:</b>
  On success, returns the number of characters sent.  On  error, -1 is returned,
  and <a href="#ErrnoAccess"><code>errno</code></a> is set appropriately:
</p>
<ul>
  <li><code>EAGAIN</code> or <code>EWOULDBLOCK</code>.
    The socket is marked non-blocking and the requested operation would block.
  <li><code>EBADF</code>.
    An invalid descriptor was specified.
  <li><code>ECONNRESET</code>.
    Connection reset by peer.
  <li><code>EDESTADDRREQ</code>.
    The socket is not connection-mode, and no peer address is set.
  <li><code>EFAULT</code>.
    An invalid user space address was specified for a parameter.
  <li><code>EINTR</code>.
    A signal occurred before any data was transmitted.
  <li><code>EINVAL</code>.
    Invalid argument passed.
  <li><code>EISCONN</code>.
    The connection-mode socket was connected already but a recipient
    was specified. (Now either this error is returned, or the recipient
    specification is ignored.)
  <li><code>EMSGSIZE</code>.
    The socket type requires that message be sent atomically, and the
    size of the message to be sent made this impossible.
  <li><code>ENOBUFS</code>.
    The output queue for a network interface was full. This generally
    indicates that the interface has stopped sending, but may be
    caused by transient congestion.
  <li><code>ENOMEM</code>.
    No memory available.
  <li><code>ENOTCONN</code>.
    The socket is not connected, and no target has been given.
  <li><code>ENOTSOCK</code>.
    The argument s is not a socket.
  <li><code>EOPNOTSUPP</code>.
    Some bit in the flags argument is inappropriate for the socket type.
  <li><code>EPIPE</code>.
    The local end has been shut down on a connection oriented socket.
    In this case the process will also receive a SIGPIPE unless
    MSG_NOSIGNAL is set.
</ul>

<h3><a name="recv">2.12.8 <code>recv</code></a></h3>
<p>
  <b>Function Prototype:</b>
</p>
<pre>
  #include <sys/socket.h>
  ssize_t recv(int sockfd, void *buf, size_t len, int flags);
</pre>
<p>
  <b>Description:</b>
  The <code>recv()</code> call is identical to
  <a href="#recvfrom"><code>recvfrom()</code></a> with a NULL
  <code>from</code> parameter.
<p>
</p>
<p>
  <b>Input Parameters:</b>
</p>
<ul>
  </li>
  <li>sockfd</code>: Socket descriptor of socket </li>
  <li>buf</code>: Buffer to receive data </li>
  <li>len</code>: Length of buffer </li>
  <li>flags</code>: Receive flags </li>
</ul>
<p>
  <b>Returned Values:</b>
  see <a href="#recvfrom"><code>recvfrom()</code></a>.
  Zero on success.
</p>

<h3><a name="recvfrom">2.12.9 <code>recvfrom</code></a></h3>
<p>
  <b>Function Prototype:</b>
</p>
<pre>
  #include <sys/socket.h>
  ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                   struct sockaddr *from, socklen_t *fromlen);
</pre>
<p>
  <b>Description:</b>
  <code>recvfrom()</code> receives messages from a socket, and may be used to receive
  data on a socket whether or not it is connection-oriented.
</p>
<p>
  If <code>from</code> is not NULL, and the underlying protocol provides the source
  address, this source address is filled in. The argument <code>fromlen</code>
  initialized to the size of the buffer associated with <code>from</code>, and modified
  on return to indicate the actual size of the address stored there.
</p>
<p>
  <b>Input Parameters:</b>
</p>
<ul>
    <li><code>sockfd</code>: Socket descriptor of socket.</li>
    <li><code>buf</code>:  Buffer to receive data.</li>
    <li><code>len</code>: Length of buffer.</li>
    <li><code>flags</code>: Receive flags.</li>
    <li><code>from</code>: Address of source.</li>
    <li><code>fromlen</code>: The length of the address structure.</li>
</ul>
<p>
  <b>Returned Values:</b>
  On success, returns the number of characters sent.
  On error, -1 is returned, and <a href="#ErrnoAccess"><code>errno</code></a> is set appropriately:
</p>
<ul>
    <li><code>EAGAIN</code>.
      The socket is marked non-blocking and the receive operation would block,
      or a receive timeout had been set and the timeout expired before data
      was received.
    <li><code>EBADF</code>.
      The argument <code>sockfd</code> is an invalid descriptor.
    <li><code>ECONNREFUSED</code>.
      A remote host refused to allow the network connection (typically because
      it is not running the requested service).
    <li><code>EFAULT</code>.
      The receive buffer pointer(s) point outside the process's address space.
    <li><code>EINTR</code>.
      The receive was interrupted by delivery of a signal before any data were
      available.
    <li><code>EINVAL</code>.
      Invalid argument passed.
    <li><code>ENOMEM</code>.
      Could not allocate memory.
    <li><code>ENOTCONN</code>.
      The socket is associated with a connection-oriented protocol and has
      not been connected.
    <li><code>ENOTSOCK</code>.
      The argument <code>sockfd</code> does not refer to a socket.
</ul>

<h3><a name="setsockopt">2.12.10 <code>setsockopt</code></a></h3>
<p>
  <b>Function Prototype:</b>
</p>
<pre>
  #include <sys/socket.h>
  int setsockopt(int sockfd, int level, int option,
                 const void *value, socklen_t value_len);
</pre>
<p>
  <b>Description:</b>
  <code>setsockopt()</code> sets the option specified by the <code>option</code> argument,
  at the protocol level specified by the <code>level</code> argument, to the value
  pointed to by the <code>value</code> argument for the socket associated with the
  file descriptor specified by the <code>sockfd</code> argument.
</p>
<p>
  The <code>level</code> argument specifies the protocol level of the option. To set
  options at the socket level, specify the level argument as SOL_SOCKET.
</p>
<p>
  See <sys/socket.h> a complete list of values for the <code>option</code> argument.
</p>
<p>
  <b>Input Parameters:</b>
</p>
<ul>
  <li><code>sockfd</code>: Socket descriptor of socket
  <li><code>level</code>: Protocol level to set the option
  <li><code>option</code>: identifies the option to set
  <li><code>value</code>: Points to the argument value
  <li><code>value_len</code>: The length of the argument value
</ul>
<p>
  <b>Returned Values:</b>
  On success, returns the number of characters sent.
  On error, -1 is returned, and <a href="#ErrnoAccess"><code>errno</code></a> is set appropriately:
</p>
<ul>
  <li><code>BADF</code>.
     The <code>sockfd</code> argument is not a valid socket descriptor.
  <li><code>DOM</code>.
     The send and receive timeout values are too big to fit into the
     timeout fields in the socket structure.
  <li><code>INVAL</code>.
     The specified option is invalid at the specified socket <code>level</code> or the
     socket has been shut down.
  <li><code>ISCONN</code>.
     The socket is already connected, and a specified option cannot be set
     while the socket is connected.
  <li><code>NOPROTOOPT</code>.
     The <code>option</code> is not supported by the protocol.
  <li><code>NOTSOCK</code>.
     The <code>sockfd</code> argument does not refer to a socket.
  <li><code>NOMEM</code>.
     There was insufficient memory available for the operation to complete.
  <li><code>NOBUFS</code>.
     Insufficient resources are available in the system to complete the call.
</ul>

<h3><a name="getsockopt">2.12.11 <code>getsockopt</code></a></h3>
<p>
  <b>Function Prototype:</b>
</p>
<pre>
  #include <sys/socket.h>
  int getsockopt(int sockfd, int level, int option,
                 void *value, socklen_t *value_len);
</pre>
<p>
  <b>Description:</b>
  <code>getsockopt()</code> retrieve thse value for the option specified by the
  <code>option</code> argument for the socket specified by the <code>sockfd</code> argument. If
  the size of the option value is greater than <code>value_len</code>, the value
  stored in the object pointed to by the <code>value</code> argument will be silently
  truncated. Otherwise, the length pointed to by the <code>value_len</code> argument
  will be modified to indicate the actual length of the<code>value</code>.
</p>
<p>
  The <code>level</code> argument specifies the protocol level of the option. To
  retrieve options at the socket level, specify the level argument as
  SOL_SOCKET.
</p>
<p>
  See <sys/socket.h> a complete list of values for the <code>option</code> argument.
</p>
<p>
  <b>Input Parameters:</b>
</p>
<ul>
  <li><code>sockfd    Socket descriptor of socket
  <li><code>level     Protocol level to set the option
  <li><code>option    identifies the option to get
  <li><code>value     Points to the argument value
  <li><code>value_len The length of the argument value
</ul>
<p>
  <b>Returned Values:</b>
  On success, returns the number of characters sent.
  On error, -1 is returned, and <a href="#ErrnoAccess"><code>errno</code></a> is set appropriately:
</p>
<ul>
  <li><code>BADF</code>.
    The <code>sockfd</code> argument is not a valid socket descriptor.</li>
  <li><code>INVAL</code>.
    The specified option is invalid at the specified socket <code>level</code> or the
    socket has been shutdown.</li>
  <li><code>NOPROTOOPT</code>.
    The <code>option</code> is not supported by the protocol.</li>
  <li><code>NOTSOCK</code>.
    The <code>sockfd</code> argument does not refer to a socket.</li>
  <li><code>NOBUFS
    Insufficient resources are available in the system to complete the call.</li>
</ul>

<hr>
<h1>3.0 <A NAME="Data_Structures">OS Data Structures</A></h1>
<H2>3.1 <A NAME="ScalarType">Scalar Types</A></H2>
<p>
Many of the types used to communicate with NuttX are simple
scalar types. These types are used to provide architecture independence
of the OS from the application. The scalar types used at the NuttX
interface include:
<ul>
<li>pid_t
<li>size_t
<li>sigset_t
<li>STATUS
<li>time_t
</ul>

<H2>3.2 <A NAME="HiddenStructures">Hidden Interface Structures</A></H2>
<p>
Several of the types used to interface with NuttX are
structures that are intended to be hidden from the application.
From the standpoint of the application, these structures (and
structure pointers) should be treated as simple handles to reference
OS resources. These hidden structures include:
<ul>
<li>_TCB
<li>mqd_t
<li>sem_t
<li>WDOG_ID
<li>pthread_key_t
</ul>
<p>
  In order to maintain portability, applications should not reference
  specific elements within these hidden structures. These hidden
  structures will not be described further in this user's manual.
</p>
<p>

<H2>3.3 <A NAME="ErrnoAccess">Access to the <code>errno</code> Variable</A></H2>
<p>
  A pointer to the thread-specific <code>errno</code> value is available through a
  function call:
</p>
<p>
  <b>Function Prototype:</b>
<p>
<pre>    #include <errno.h>
    #define errno *get_errno_ptr()
    int *get_errno_ptr( void )</pre>
<p>
  <b>Description</b>:
  <code>get_errno_ptr()</code> returns a pointer to the thread-specific <code>errno</code> value.
  Note that the symbol <code>errno</code> is defined to be <code>get_errno_ptr()</code> so that the usual
  access by referencing the symbol <code>errno</code> will work as expected.
</p>
<p>
  There is a unique, private <code>errno</code> value for each NuttX task.
  However, the implementation of <code>errno</code> differs somewhat from the use of
  <code>errno</code> in most multi-threaded process environments:
  In NuttX, each pthread will also have its own private copy of <code>errno</code> and the
  <code>errno</code> will not be shared between pthreads.
  This is, perhaps, non-standard but promotes better thread independence.
<p>
<b>Input Parameters</b>:  None
<p>
<b>Returned Values</b>:
<p>
<ul>
<li>A pointer to the thread-specific <code>errno</code> value.
</ul>
<p>

<H2>3.4 <A NAME="UserStructures">User Interface Structures</A></H2>
<p>
<H3>3.4.1 main_t</H3>
<p>
main_t defines the type of a task entry point. main_t is declared
in sys/types.h as:
<pre>
    typedef int (*main_t)(int argc, char *argv[]);
</pre>

<H3>3.4.2 struct sched_param</H3>

<p>
This structure is used to pass scheduling priorities to and from
NuttX;
<pre>
    struct sched_param
    {
      int sched_priority;
    };
</pre>

<H3>3.4.3 struct timespec</H3>

<p>
This structure is used to pass timing information between the
NuttX and a user application:
<pre>
    struct timespec
    {
      time_t tv_sec;  /* Seconds */
      long   tv_nsec; /* Nanoseconds */
    };
</pre>

<H3>3.4.4 struct mq_attr</H3>

<p>
This structure is used to communicate message queue attributes
between NuttX and a MoBY application:
<pre>
    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 */
    };
</pre>

<H3>3.4.5 struct sigaction</H3>

<p>
The following structure defines the action to take for given signal:
<pre>
    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
</pre>

<H3>3.4.6 struct siginfo/siginfo_t</H3>

<p>
The following types is used to pass parameters to/from signal
handlers:
<pre>
    typedef struct siginfo
    {
      int          si_signo;
      int          si_code;
      union sigval si_value;
   } siginfo_t;
</pre>

<H3>3.4.7 union sigval</H3>

<p>
This defines the type of the struct siginfo si_value field and
is used to pass parameters with signals.
<pre>
    union sigval
    {
      int   sival_int;
      void *sival_ptr;
    };
</pre>

<H3>3.4.8 struct sigevent</H3>

<p>
The following is used to attach a signal to a message queue to
notify a task when a message is available on a queue.
<pre>
    struct sigevent
    {
      int          sigev_signo;
      union sigval sigev_value;
      int          sigev_notify;
    };
</pre>

<H3>3.4.9 Watchdog Data Types</H3>

<p>
  When a watchdog expires, the callback function with this
  type is called:
</p>
<pre>
    typedef void (*wdentry_t)(int argc, ...);
</pre>
<p>
  Where argc is the number of uint32 type arguments that follow.
</p>
  The arguments are passed as uint32 values.
  For systems where the sizeof(pointer) &lt; sizeof(uint32), the
  following union defines the alignment of the pointer within the
  uint32.  For example, the SDCC MCS51 general pointer is
  24-bits, but uint32 is 32-bits (of course).
</p>
<pre>
    union wdparm_u
    {
      void   *pvarg;
      uint32 *dwarg;
    };
    typedef union wdparm_u wdparm_t;
</pre>
<p>
  For most 32-bit systems, pointers and uint32 are the same size
  For systems where sizeof(pointer) > sizeof(uint32), we will
  have to do some redesign.
</p>

<h1><a name="index">Index</a></h1>
<table width="100%">
<tr>
<td>
  <li><a href="#accept">accept</a></li>
  <li><a href="#bind">bind</a></li>
  <li><a href="#clockgetres">clock_getres</a></li>
  <li><a href="#clockgettime">clock_gettime</a></li>
  <li><a href="#ClocksNTimers">Clocks</a></li>
  <li><a href="#clocksettime">clock_settime</a></li>
  <li><a href="#connect">connect</a></li>
  <li><a href="#Data_Structures">Data structures</a></li>
  <li><a href="#directoryoperations">Directory operations</a></li>
  <li><a href="#driveroperations">Driver operations</a></li>
  <li><a href="#exit">exit</a></li>
  <li><a href="#FileSystem">File system interfaces</a></li>
  <li><a href="#getpid">getpid</a></li>
  <li><a href="#getsockopt">getsockopt</a></li>
  <li><a href="#gmtimer">gmtime_r</a></li>
  <li><a href="#Introduction">Introduction</a>
  <li><a href="#kill">kill</a></li>
  <li><a href="#listen">listen</a></li>
  <li><a href="#localtimer">localtime_r</a></li>
  <li><a href="#Message_Queue">Named Message Queue Interfaces</a>
  <li><a href="#mktime">mktime</a></li>
  <li><a href="#mqclose">mq_close</a></li>
  <li><a href="#mqgetattr">mq_getattr</a></li>
  <li><a href="#mqnotify">mq_notify</a></li>
  <li><a href="#mqopen">mq_open</a></li>
  <li><a href="#mqreceive">mq_receive</a></li>
  <li><a href="#mqsend">mq_send</a></li>
  <li><a href="#mqsetattr">mq_setattr</a></li>
  <li><a href="#mqtimedreceive">mq_timedreceive</a></li>
  <li><a href="#mqtimedsend">mq_timedsend</a></li>
  <li><a href="#mqunlink">mq_unlink</a></li>
  <li><a href="#Network">Network Interfaces</a></li>
  <li><a href="#OS_Interfaces">OS Interfaces</a>
  <li><a href="#Pthread">Pthread Interfaces</a>
  <li><a href="#pthreadattrdestroy">pthread_attr_destroy</a></li>
  <li><a href="#pthreadattrgetinheritsched">pthread_attr_getinheritsched</a></li>
  <li><a href="#pthreadattrgetschedparam">pthread_attr_getschedparam</a></li>
  <li><a href="#pthreadattrgetschedpolicy">pthread_attr_getschedpolicy</a></li>
  <li><a href="#pthreadattrgetstacksize">0 pthread_attr_getstacksize</a></li>
  <li><a href="#pthreadattrinit">pthread_attr_init</a></li>
  <li><a href="#pthreadattrsetinheritsched">pthread_attr_setinheritsched</a></li>
  <li><a href="#pthreadattrsetschedparam">pthread_attr_setschedparam</a></li>
  <li><a href="#pthreadattrsetschedpolity">pthread_attr_setschedpolicy</a></li>
  <li><a href="#pthreadattrsetstacksize">pthread_attr_setstacksize</a></li>
  <li><a href="#pthreadbarrierattrinit">pthread_barrierattr_init</a></li>
  <li><a href="#pthreadbarrierattrdestroy">pthread_barrierattr_destroy</a></li>
  <li><a href="#pthreadbarrierattrgetpshared">pthread_barrierattr_getpshared</a></li>
  <li><a href="#pthreadbarrierattrsetpshared">pthread_barrierattr_setpshared</a></li>
  <li><a href="#pthreadbarrierdestroy">pthread_barrier_destroy</a></li>
  <li><a href="#pthreadbarrierinit">pthread_barrier_init</a></li>
  <li><a href="#pthreadbarrierwait">pthread_barrier_wait</a></li>
  <li><a href="#pthreadcancel">pthread_cancel</a></li>
  <li><a href="#pthreadconaddrinit">pthread_condattr_init</a></li>
  <li><a href="#pthreadcondbroadcast">pthread_cond_broadcast</a></li>
  <li><a href="#pthreadconddestroy">pthread_cond_destroy</a></li>
  <li><a href="#pthreadcondinit">pthread_cond_init</a></li>
  <li><a href="#pthreadcondsignal">pthread_cond_signal</a></li>
  <li><a href="#pthreadcondtimedwait">pthread_cond_timedwait</a></li>
  <li><a href="#pthreadcondwait">pthread_cond_wait</a></li>
  <li><a href="#pthreadcreate">pthread_create</a></li>
  <li><a href="#pthreaddetach">pthread_detach</a></li>
  <li><a href="#pthreadexit">pthread_exit</a></li>
  <li><a href="#pthreadgetschedparam">pthread_getschedparam</a></li>
  <li><a href="#pthreadgetspecific">pthread_getspecific</a></li>
  <li><a href="#Pthread"><i>pthreads</i></a> share some resources.
  <li><a href="#pthreadjoin">pthread_join</a></li>
  <li><a href="#pthreadkeycreate">pthread_key_create</a></li>
  <li><a href="#pthreadkeydelete">pthread_key_delete</a></li>
  <li><a href="#pthreadkill">pthread_kill</a></li>
  <li><a href="#pthreadmutexattrdestroy">pthread_mutexattr_destroy</a></li>
  <li><a href="#pthreadmutexattrgetpshared">pthread_mutexattr_getpshared</a></li>
  <li><a href="#pthreadmutexattrinit">pthread_mutexattr_init</a></li>
  <li><a href="#pthreadmutexattrsetpshared">pthread_mutexattr_setpshared</a></li>
  <li><a href="#pthreadmutexdestrory">pthread_mutex_destroy</a></li>
</td>
<td>
  <li><a href="#pthreadmutexinit">pthread_mutex_init</a></li>
  <li><a href="#pthreadmutexlock">pthread_mutex_lock</a></li>
  <li><a href="#pthreadmutextrylock">pthread_mutex_trylock</a></li>
  <li><a href="#pthreadmutexunlock">pthread_mutex_unlock</a></li>
  <li><a href="#pthreadocndattrdestroy">pthread_condattr_destroy</a></li>
  <li><a href="#pthreadonce">pthread_once</a></li>
  <li><a href="#pthreadself">pthread_self</a></li>
  <li><a href="#pthreadsetcancelstate">pthread_setcancelstate</a></li>
  <li><a href="#pthreadsetschedparam">pthread_setschedparam</a></li>
  <li><a href="#pthreadsetspecific">pthread_setspecific</a></li>
  <li><a href="#pthreadsigmask">pthread_sigmask</a></li>
  <li><a href="#pthreadtestcancelstate">pthread_testcancelstate</a></li>
  <li><a href="#pthreadyield">pthread_yield</a></li>
  <li><a href="#recv">recv</a></li>
  <li><a href="#recvfrom">recvfrom</a></li>
  <li><a href="#schedgetparam">sched_getparam</a></li>
  <li><a href="#schedgetprioritymax">sched_get_priority_max</a></li>
  <li><a href="#schedgetprioritymin">sched_get_priority_min</a></li>
  <li><a href="#schedgetrrinterval">sched_get_rr_interval</a></li>
  <li><a href="#schedlockcount">sched_lockcount</a></li>
  <li><a href="#schedlock">sched_lock</a></li>
  <li><a href="#schedsetparam">sched_setparam</a></li>
  <li><a href="#schedsetscheduler">sched_setscheduler</a></li>
  <li><a href="#schedunlock">sched_unlock</a></li>
  <li><a href="#sched_yield">sched_yield</a></li>
  <li><a href="#Semaphores">Counting Semaphore Interfaces</a>
  <li><a href="#semclose">sem_close</a></li>
  <li><a href="#semdestroy">sem_destroy</a></li>
  <li><a href="#semgetvalue">sem_getvalue</a></li>
  <li><a href="#seminit">sem_init</a></li>
  <li><a href="#semopen">sem_open</a></li>
  <li><a href="#sempost">sem_post</a></li>
  <li><a href="#semtrywait">sem_trywait</a></li>
  <li><a href="#semunlink">sem_unlink</a></li>
  <li><a href="#semwait">sem_wait</a></li>
  <li><a href="#setgetscheduler">sched_getscheduler</a></li>
  <li><a href="#send">send</a></li>
  <li><a href="#sendto">sendto</a></li>
  <li><a href="#setsockopt">setsockopt</a></li>
  <li><a href="#sigaction">sigaction</a></li>
  <li><a href="#sigaddset">sigaddset</a></li>
  <li><a href="#sigdelset">sigdelset</a></li>
  <li><a href="#sigemptyset">sigemptyset</a></li>
  <li><a href="#sigfillset">sigfillset</a></li>
  <li><a href="#sigismember">sigismember</a></li>
  <li><a href="#Signals">Signal Interfaces</a>
  <li><a href="#sigpending">sigpending</a></li>
  <li><a href="#sigprocmask">sigprocmask</a></li>
  <li><a href="#sigqueue">sigqueue</a></li>
  <li><a href="#sigsuspend">sigsuspend</a></li>
  <li><a href="#sigtimedwait">sigtimedwait</a></li>
  <li><a href="#sigwaitinfo">sigwaitinfo</a></li>
  <li><a href="#socket">socket</a></li>
  <li><a href="#standardio">Standard I/O</a></li>
  <li><a href="#taskactivate">task_activate</a></li>
  <li><a href="#Task_Control">Task Control Interfaces</a>
  <li><a href="#taskcreate">task_create</a></li>
  <li><a href="#taskdelete">task_delete</a></li>
  <li><a href="#taskinit">task_init</a></li>
  <li><a href="#taskrestart">task_restart</a></li>
  <li><a href="#Task_Schedule">Task Scheduling Interfaces</a>
  <li><a href="#Task_Switch">Task Switching Interfaces</a>
  <li><a href="#timercreate">timer_create</a></li>
  <li><a href="#timerdelete">timer_delete</a></li>
  <li><a href="#timergetoverrun">timer_getoverrun</a></li>
  <li><a href="#timergettime">timer_gettime</a></li>
  <li><a href="#ClocksNTimers">Timers</a></li>
  <li><a href="#timersettime">timer_settime</a></li>
  <li><a href="#Watchdogs">Watchdog Timer Interfaces</a>
  <li><a href="#wdcancel">wd_cancel</a></li>
  <li><a href="#wdcreate">wd_create</a></li>
  <li><a href="#wddelete">wd_delete</a></li>
  <li><a href="#wdgettime">wd_gettime</a></li>
  <li><a href="#wdstart">wd_start</a></li>
</td>
</tr>
</table>

</BODY>
</HTML>