gonzui

    1: /*      $OpenBSD: lock.h,v 1.21 2010/04/26 05:48:19 deraadt Exp $    */
    2: 
    3: /* 
    4:  * Copyright (c) 1995
    5:  *      The Regents of the University of California.  All rights reserved.
    6:  *
    7:  * This code contains ideas from software contributed to Berkeley by
    8:  * Avadis Tevanian, Jr., Michael Wayne Young, and the Mach Operating
    9:  * System project at Carnegie-Mellon University.
   10:  *
   11:  * Redistribution and use in source and binary forms, with or without
   12:  * modification, are permitted provided that the following conditions
   13:  * are met:
   14:  * 1. Redistributions of source code must retain the above copyright
   15:  *    notice, this list of conditions and the following disclaimer.
   16:  * 2. Redistributions in binary form must reproduce the above copyright
   17:  *    notice, this list of conditions and the following disclaimer in the
   18:  *    documentation and/or other materials provided with the distribution.
   19:  * 3. Neither the name of the University nor the names of its contributors
   20:  *    may be used to endorse or promote products derived from this software
   21:  *    without specific prior written permission.
   22:  *
   23:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   24:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   25:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   26:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   27:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   28:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   29:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   30:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   31:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   32:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   33:  * SUCH DAMAGE.
   34:  *
   35:  *      @(#)lock.h   8.12 (Berkeley) 5/19/95
   36:  */
   37: 
   38: #ifndef _LOCK_H_
   39: #define _LOCK_H_
   40: 
   41: #ifdef _KERNEL
   42: #include <machine/lock.h>
   43: #endif
   44: 
   45: struct simplelock {
   46: };
   47: 
   48: typedef struct simplelock       simple_lock_data_t;
   49: typedef struct simplelock       *simple_lock_t;
   50: 
   51: #ifdef _KERNEL
   52: #define simple_lock(lkp)
   53: #define simple_lock_try(lkp)    (1)        /* always succeeds */
   54: #define simple_unlock(lkp)
   55: #define simple_lock_assert(lkp)
   56: 
   57: static __inline void simple_lock_init(struct simplelock *lkp)
   58: {
   59: }
   60: 
   61: #endif /* _KERNEL */
   62: 
   63: typedef struct lock             lock_data_t;
   64: typedef struct lock             *lock_t;
   65: 
   66: /*
   67:  * The general lock structure.  Provides for multiple shared locks,
   68:  * upgrading from shared to exclusive, and sleeping until the lock
   69:  * can be gained. The simple locks are defined in <machine/param.h>.
   70:  */
   71: struct lock {
   72:         u_int  lk_flags;                /* see below */
   73:         int    lk_sharecount;             /* # of accepted shared locks */
   74:         int    lk_waitcount;              /* # of processes sleeping for lock */
   75:         int    lk_exclusivecount; /* # of recursive exclusive locks */
   76: 
   77:         /*
   78:          * This is the sleep message for sleep locks, and a simple name
   79:          * for spin locks.
   80:          */
   81:         char   *lk_wmesg;                /* resource sleeping (for tsleep) */
   82: 
   83:         /* pid of exclusive lock holder */
   84:         pid_t lk_lockholder;
   85: 
   86:         /* priority at which to sleep */
   87:         int lk_prio;
   88: 
   89:         /* maximum sleep time (for tsleep) */
   90:         int lk_timo;
   91: };
   92: 
   93: /*
   94:  * Lock request types:
   95:  *   LK_SHARED - get one of many possible shared locks. If a process
   96:  *      holding an exclusive lock requests a shared lock, the exclusive
   97:  *      lock(s) will be downgraded to shared locks.
   98:  *   LK_EXCLUSIVE - stop further shared locks, when they are cleared,
   99:  *      grant a pending upgrade if it exists, then grant an exclusive
  100:  *      lock. Only one exclusive lock may exist at a time, except that
  101:  *      a process holding an exclusive lock may get additional exclusive
  102:  *      locks if it explicitly sets the LK_CANRECURSE flag in the lock
  103:  *      request, or if the LK_CANRECUSE flag was set when the lock was
  104:  *      initialized.
  105:  *   LK_RELEASE - release one instance of a lock.
  106:  *   LK_DRAIN - wait for all activity on the lock to end, then mark it
  107:  *      decommissioned. This feature is used before freeing a lock that
  108:  *      is part of a piece of memory that is about to be freed.
  109:  *
  110:  * These are flags that are passed to the lockmgr routine.
  111:  */
  112: #define LK_TYPE_MASK    0x0000000f /* type of lock sought */
  113: #define LK_SHARED       0x00000001    /* shared lock */
  114: #define LK_EXCLUSIVE    0x00000002 /* exclusive lock */
  115: #define LK_RELEASE      0x00000006   /* release any type of lock */
  116: #define LK_DRAIN        0x00000007     /* wait for all lock activity to end */
  117: /*
  118:  * External lock flags.
  119:  *
  120:  * The first three flags may be set in lock_init to set their mode permanently,
  121:  * or passed in as arguments to the lock manager.
  122:  */
  123: #define LK_EXTFLG_MASK  0x00200070       /* mask of external flags */
  124: #define LK_NOWAIT       0x00000010    /* do not sleep to await lock */
  125: #define LK_CANRECURSE   0x00000040        /* allow recursive exclusive lock */
  126: #define LK_RECURSEFAIL  0x00200000       /* fail if recursive exclusive lock */
  127: /*
  128:  * Internal lock flags.
  129:  *
  130:  * These flags are used internally to the lock manager.
  131:  */
  132: #define LK_WANT_EXCL    0x00002000 /* exclusive lock sought */
  133: #define LK_HAVE_EXCL    0x00004000 /* exclusive lock obtained */
  134: #define LK_WAITDRAIN    0x00008000 /* process waiting for lock to drain */
  135: #define LK_DRAINING     0x00040000  /* lock is being drained */
  136: #define LK_DRAINED      0x00080000   /* lock has been decommissioned */
  137: /*
  138:  * Control flags
  139:  *
  140:  * Non-persistent external flags.
  141:  */
  142: #define LK_RETRY        0x00020000     /* vn_lock: retry until locked */
  143: 
  144: /*
  145:  * Lock return status.
  146:  *
  147:  * Successfully obtained locks return 0. Locks will always succeed
  148:  * unless one of the following is true:
  149:  *      LK_NOWAIT is set and a sleep would be required (returns EBUSY).
  150:  *      PCATCH is set in lock priority and a signal arrives (returns
  151:  *          either EINTR or ERESTART if system calls is to be restarted).
  152:  *      Non-null lock timeout and timeout expires (returns EWOULDBLOCK).
  153:  * A failed lock attempt always returns a non-zero error value. No lock
  154:  * is held after an error return.
  155:  */
  156: 
  157: /*
  158:  * Indicator that no process holds exclusive lock
  159:  */
  160: #define LK_KERNPROC ((pid_t) -2)
  161: #define LK_NOPROC ((pid_t) -1)
  162: #define LK_NOCPU ((cpuid_t) -1)
  163: 
  164: void    lockinit(struct lock *, int prio, char *wmesg, int timo,
  165:                         int flags);
  166: int     lockmgr(__volatile struct lock *, u_int flags, void *);
  167: void    lockmgr_printinfo(__volatile struct lock *);
  168: int     lockstatus(struct lock *);
  169: 
  170: int     spinlock_release_all(__volatile struct lock *);
  171: void    spinlock_acquire_count(__volatile struct lock *, int);
  172: 
  173: #define LOCK_ASSERT(x)  /* nothing */
  174: 
  175: #endif /* !_LOCK_H_ */