_lwp_mutex_lock,  _lwp_mutex_unlock,  _lwp_mutex_trylock   -
     mutual exclusion


     #include <sys/lwp.h>

     int _lwp_mutex_lock(lwp_mutex_t *mp);

     int _lwp_mutex_trylock(lwp_mutex_t *mp);

     int _lwp_mutex_unlock(lwp_mutex_t *mp);


     These  functions  serialize  the  execution  of  lightweight
     processes. They are useful for ensuring that only one light-
     weight process can execute a critical section of code at any
     one  time  (mutual exclusion).  LWP mutexes must be initial-
     ized to 0 before use.

     The _lwp_mutex_lock() function locks the LWP  mutex  pointed
     to  by  mp.  If the mutex is already locked, the calling LWP
     blocks   until   the   mutex   becomes   available.     When
     _lwp_mutex_lock()  returns, the mutex is locked and the cal-
     ling LWP is the "owner".

     The  _lwp_mutex_trylock()  function  attempts  to  lock  the
     mutex.  If  the  mutex  is already locked it returns with an
     error.  If  the  mutex  is  unlocked,  it  is   locked   and
     _lwp_mutex_trylock() returns.

     The _lwp_mutex_unlock() function unlocks a locked mutex. The
     mutex  must  be  locked  and the calling LWP must be the one
     that last locked the mutex (the owner). If  any  other  LWPs
     are  waiting  for the mutex to become available, one of them
     is unblocked.


     Upon successful completion, 0 is returned. A non-zero  value
     indicates an error.


     If  any  of   the   following   conditions   are   detected,
     _lwp_mutex_lock(),         _lwp_mutex_trylock(),         and
     _lwp_mutex_unlock() fail and return the corresponding value:

           The mp argument points to an invalid LWP mutex.

           The mp argument points to an illegal address.

     If    any    of    the    following    conditions     occur,
     _lwp_mutex_trylock()  fails  and  returns  the corresponding

     EBUSY The mp argument points to a locked mutex.


     intro(2), _lwp_cond_wait(2)

Man(1) output converted with man2html