term% ls -F
term% cat index.txt
LOCK(2)                       System Calls Manual                      LOCK(2)

       lockinit, lock, canlock, unlock - shared memory spin lock

       #include <lock.h>

       void lockinit(void);

       void lock(Lock *lk);

       int  canlock(Lock *lk);

       void unlock(Lock *lk);

       /* Alef only */

       adt Lock
            void lock(*Lock);
            void unlock(*Lock);
            int  canlock(*Lock);

       adt QLock
            void lock(*Lock);
            void unlock(*Lock);
            int  canlock(*Lock);

       adt RWlock
            void Rlock(*RWlock);
            void Runlock(*RWlock);
            void Wlock(*RWlock);
            void Wunlock(*RWlock);

       adt Ref
            int  inc(*Ref);
            int  dec(*Ref);
            int  ref(*Ref);

       These  routines are used by processes sharing memory to synchronize us‐
       ing spin locks.  Lockinit must be called before the first  use  of  the
       other routines.  Lock blocks until the lock has been obtained.  Canlock
       is non-blocking.  It tries to obtain a  lock  and  returns  a  non-zero
       value if it was successful, 0 otherwise.  Unlock releases a lock.

       Alef locks have similar functionality, but no special initialization is
       required.  The ADT Lock has functions lock, unlock, and  canlock,  just
       like  locks  in  C.   QLocks  have  the same interface but are not spin
       locks; instead if the lock is taken QLock.lock will  suspend  execution
       of the calling task until it is released.

       Although  Locks  are  the more primitive lock, their use is discouraged
       and even erroneous for most purposes.  For example, Locks  cannot  syn‐
       chronize between tasks in the same proc.  Use QLocks instead.

       RWlocks manage access to a data structure that has distinct readers and
       writers.  RWlock.Rlock grants read access; RWlock.Runlock releases  it.
       RWlock.Wlock  grants  write  access; RWlock.Wunlock releases it.  There
       may be any number of simultaneous readers, but only one writer.   More‐
       over,  if  write  access  is  granted no one may have read access until
       write access is released.

       Refs manage reference counters. increments the counter and re‐
       turns the old value; Ref.dec decrements the counter and returns the new
       value.  Ref.ref returns the current value.


       rfork in fork(2)