1 /* $OpenBSD: lock.h,v 1.11 2003/06/02 23:28:21 millert 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 #include <sys/simplelock.h> 42 43 typedef struct simplelock simple_lock_data_t; 44 typedef struct simplelock *simple_lock_t; 45 typedef struct lock lock_data_t; 46 typedef struct lock *lock_t; 47 48 /* 49 * The general lock structure. Provides for multiple shared locks, 50 * upgrading from shared to exclusive, and sleeping until the lock 51 * can be gained. The simple locks are defined in <machine/param.h>. 52 */ 53 struct lock { 54 struct simplelock lk_interlock; /* lock on remaining fields */ 55 u_int lk_flags; /* see below */ 56 int lk_sharecount; /* # of accepted shared locks */ 57 int lk_waitcount; /* # of processes sleeping for lock */ 58 short lk_exclusivecount; /* # of recursive exclusive locks */ 59 short lk_prio; /* priority at which to sleep */ 60 char *lk_wmesg; /* resource sleeping (for tsleep) */ 61 int lk_timo; /* maximum sleep time (for tsleep) */ 62 pid_t lk_lockholder; /* pid of exclusive lock holder */ 63 }; 64 /* 65 * Lock request types: 66 * LK_SHARED - get one of many possible shared locks. If a process 67 * holding an exclusive lock requests a shared lock, the exclusive 68 * lock(s) will be downgraded to shared locks. 69 * LK_EXCLUSIVE - stop further shared locks, when they are cleared, 70 * grant a pending upgrade if it exists, then grant an exclusive 71 * lock. Only one exclusive lock may exist at a time, except that 72 * a process holding an exclusive lock may get additional exclusive 73 * locks if it explicitly sets the LK_CANRECURSE flag in the lock 74 * request, or if the LK_CANRECUSE flag was set when the lock was 75 * initialized. 76 * LK_UPGRADE - the process must hold a shared lock that it wants to 77 * have upgraded to an exclusive lock. Other processes may get 78 * exclusive access to the resource between the time that the upgrade 79 * is requested and the time that it is granted. 80 * LK_EXCLUPGRADE - the process must hold a shared lock that it wants to 81 * have upgraded to an exclusive lock. If the request succeeds, no 82 * other processes will have gotten exclusive access to the resource 83 * between the time that the upgrade is requested and the time that 84 * it is granted. However, if another process has already requested 85 * an upgrade, the request will fail (see error returns below). 86 * LK_DOWNGRADE - the process must hold an exclusive lock that it wants 87 * to have downgraded to a shared lock. If the process holds multiple 88 * (recursive) exclusive locks, they will all be downgraded to shared 89 * locks. 90 * LK_RELEASE - release one instance of a lock. 91 * LK_DRAIN - wait for all activity on the lock to end, then mark it 92 * decommissioned. This feature is used before freeing a lock that 93 * is part of a piece of memory that is about to be freed. 94 * 95 * These are flags that are passed to the lockmgr routine. 96 */ 97 #define LK_TYPE_MASK 0x0000000f /* type of lock sought */ 98 #define LK_SHARED 0x00000001 /* shared lock */ 99 #define LK_EXCLUSIVE 0x00000002 /* exclusive lock */ 100 #define LK_UPGRADE 0x00000003 /* shared-to-exclusive upgrade */ 101 #define LK_EXCLUPGRADE 0x00000004 /* first shared-to-exclusive upgrade */ 102 #define LK_DOWNGRADE 0x00000005 /* exclusive-to-shared downgrade */ 103 #define LK_RELEASE 0x00000006 /* release any type of lock */ 104 #define LK_DRAIN 0x00000007 /* wait for all lock activity to end */ 105 /* 106 * External lock flags. 107 * 108 * The first three flags may be set in lock_init to set their mode permanently, 109 * or passed in as arguments to the lock manager. The LK_REENABLE flag may be 110 * set only at the release of a lock obtained by drain. 111 */ 112 #define LK_EXTFLG_MASK 0x00000770 /* mask of external flags */ 113 #define LK_NOWAIT 0x00000010 /* do not sleep to await lock */ 114 #define LK_SLEEPFAIL 0x00000020 /* sleep, then return failure */ 115 #define LK_CANRECURSE 0x00000040 /* allow recursive exclusive lock */ 116 #define LK_REENABLE 0x00000080 /* lock is be reenabled after drain */ 117 #define LK_RECURSEFAIL 0x00000100 /* fail if recursive exclusive lock */ 118 /* 119 * Internal lock flags. 120 * 121 * These flags are used internally to the lock manager. 122 */ 123 #define LK_WANT_UPGRADE 0x00001000 /* waiting for share-to-excl upgrade */ 124 #define LK_WANT_EXCL 0x00002000 /* exclusive lock sought */ 125 #define LK_HAVE_EXCL 0x00004000 /* exclusive lock obtained */ 126 #define LK_WAITDRAIN 0x00008000 /* process waiting for lock to drain */ 127 #define LK_DRAINING 0x00040000 /* lock is being drained */ 128 #define LK_DRAINED 0x00080000 /* lock has been decommissioned */ 129 /* 130 * Control flags 131 * 132 * Non-persistent external flags. 133 */ 134 #define LK_INTERLOCK 0x00100000 /* unlock passed simple lock after 135 getting lk_interlock */ 136 #define LK_RETRY 0x00200000 /* vn_lock: retry until locked */ 137 138 /* 139 * Lock return status. 140 * 141 * Successfully obtained locks return 0. Locks will always succeed 142 * unless one of the following is true: 143 * LK_FORCEUPGRADE is requested and some other process has already 144 * requested a lock upgrade (returns EBUSY). 145 * LK_NOWAIT is set and a sleep would be required (returns EBUSY). 146 * LK_SLEEPFAIL is set and a sleep was done (returns ENOLCK). 147 * PCATCH is set in lock priority and a signal arrives (returns 148 * either EINTR or ERESTART if system calls is to be restarted). 149 * Non-null lock timeout and timeout expires (returns EWOULDBLOCK). 150 * A failed lock attempt always returns a non-zero error value. No lock 151 * is held after an error return (in particular, a failed LK_UPGRADE 152 * or LK_FORCEUPGRADE will have released its shared access lock). 153 */ 154 155 /* 156 * Indicator that no process holds exclusive lock 157 */ 158 #define LK_KERNPROC ((pid_t) -2) 159 #define LK_NOPROC ((pid_t) -1) 160 161 struct proc; 162 163 void lockinit(struct lock *, int prio, char *wmesg, int timo, 164 int flags); 165 int lockmgr(__volatile struct lock *, u_int flags, 166 struct simplelock *, struct proc *p); 167 void lockmgr_printinfo(struct lock *); 168 int lockstatus(struct lock *); 169 170 #ifdef LOCKDEBUG 171 #define LOCK_ASSERT(x) KASSERT(x) 172 #else 173 #define LOCK_ASSERT(x) /* nothing */ 174 #endif 175 176 #endif /* !_LOCK_H_ */ 177 178