LOCK(2) 							System Calls Manual							   LOCK(2)

NAME

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

SYNOPSIS

       #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);
       };

DESCRIPTION

       These  routines	are used by processes sharing memory to synchronize using 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
       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  execu-
       tion 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.
       Moreover, if write access is granted no one may have read access until write access is released.

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

SOURCE

       /sys/src/liblock

SEE ALSO

       rfork in fork(2)

																	   LOCK(2)