LOCK(2) 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 syn-
chronize 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
LOCK(2) LOCK(2)
to obtain a lock and returns a non-zero value if it was suc-
cessful, 0 otherwise. Unlock releases a lock.
Alef
Alef locks have similar functionality, but no special ini-
tialization 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 exam-
ple, Locks cannot synchronize 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 cur-
rent value.
SOURCE
/sys/src/liblock
SEE ALSO
rfork in fork(2)