SLEEP_LOCK_SIG(D3)

NAME
     SLEEP_LOCK_SIG - acquire a sleep lock

SYNOPSIS
     #include <sys/types.h>
     #include <sys/ksynch.h>
     #include <sys/ddi.h>
     #include <sys/param.h>
     boolean_t SLEEP_LOCK_SIG(sleep_t *lockp, int priority);

   Arguments
     lockp     Pointer to the sleep lock to be acquired.

     priority  A hint to the scheduling policy as to the relative priority the
               caller wishes to be assigned while running in the kernel after
               waking up.

DESCRIPTION
     SLEEP_LOCK_SIG acquires the sleep lock specified by lockp.  If the lock
     is not immediately available, the caller is put to sleep (the caller's
     execution is suspended and other processes may be scheduled) until the
     lock becomes available to the caller, at which point the caller wakes up
     and returns with the lock held.

     SLEEP_LOCK_SIG may be interrupted by a signal, in which case it may
     return early without acquiring the lock.

     If the function is interrupted by a job control stop signal (e.g.,
     SIGSTOP, SIGTSTP, SIGTTIN, SIGTTOU) which results in the caller entering
     a stopped state, the SLEEP_LOCK_SIG function will transparently retry the
     lock operation upon continuing (the call will not return without the
     lock).

     If the function is interrupted by a signal other than a job control stop
     signal, or by a job control stop signal that does not result in the
     caller stopping (because the signal has a non-default disposition), the
     SLEEP_LOCK_SIG call will return early without acquiring the lock.

   Return Values
     SLEEP_LOCK_SIG returns TRUE (a non-zero value) if the lock is
     successfully acquired or FALSE (zero) if the function returned early
     because of a signal.

USAGE
   Priority Argument
     In general, a lower value will result in more favorable scheduling
     although the exact semantic of the priority argument is specific to the
     scheduling class of the caller, and some scheduling classes may choose to
     ignore the argument for the purposes of assigning a scheduling priority.
     The value of priority must be greater than PZERO (defined in sys/param.h)

     In general, a higher relative priority should be used when the caller is
     attempting to acquire a highly contended lock or resource,or when the
     caller is already holding one or more locks or kernel resources upon
     entry to SLEEP_LOCK_SIG.

   Level
     Base only.

   Synchronization Constraints
     Can sleep.

     Driver-defined basic locks and read/write locks may not be held across
     calls to this function.

     Driver-defined sleep locks may be held across calls to this function
     subject to the recursion restrictions described below.

   Warnings
     Sleep locks are not recursive.  A call to SLEEP_LOCK_SIG attempting to
     acquire a lock that is currently held by the calling context will result
     in deadlock.

REFERENCES
     SLEEP_ALLOC(D3), SLEEP_INIT(D3), SLEEP_DEALLOC(D3), SLEEP_DESTROY(D3),
     SLEEP_LOCK(D3), SLEEP_LOCKAVAIL(D3), SLEEP_TRYLOCK(D3), SLEEP_UNLOCK(D3),
     signals(D5).