2 * Copyright (c) 1997, 1998
3 * Nan Yang Computer Services Limited. All rights reserved.
5 * Parts copyright (c) 1997, 1998 Cybernet Corporation, NetMAX project.
7 * Written by Greg Lehey
9 * This software is distributed under the so-called ``Berkeley
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. All advertising materials mentioning features or use of this software
21 * must display the following acknowledgement:
22 * This product includes software developed by Nan Yang Computer
24 * 4. Neither the name of the Company nor the names of its contributors
25 * may be used to endorse or promote products derived from this software
26 * without specific prior written permission.
28 * This software is provided ``as is'', and any express or implied
29 * warranties, including, but not limited to, the implied warranties of
30 * merchantability and fitness for a particular purpose are disclaimed.
31 * In no event shall the company or contributors be liable for any
32 * direct, indirect, incidental, special, exemplary, or consequential
33 * damages (including, but not limited to, procurement of substitute
34 * goods or services; loss of use, data, or profits; or business
35 * interruption) however caused and on any theory of liability, whether
36 * in contract, strict liability, or tort (including negligence or
37 * otherwise) arising in any way out of the use of this software, even if
38 * advised of the possibility of such damage.
40 * $Id: vinumlock.c,v 1.13 2000/05/02 23:25:02 grog Exp grog $
41 * $FreeBSD: src/sys/dev/vinum/vinumlock.c,v 1.18.2.3 2001/04/04 06:27:11 grog Exp $
42 * $DragonFly: src/sys/dev/raid/vinum/vinumlock.c,v 1.2 2003/06/17 04:28:33 dillon Exp $
45 #include <dev/vinum/vinumhdr.h>
46 #include <dev/vinum/request.h>
48 /* Lock a drive, wait if it's in use */
51 lockdrive(struct drive *drive, char *file, int line)
54 lockdrive(struct drive *drive)
59 /* XXX get rid of drive->flags |= VF_LOCKING; */
60 if ((drive->flags & VF_LOCKED) /* it's locked */
61 &&(drive->pid == curproc->p_pid)) { /* by us! */
64 "vinum lockdrive: already locking %s from %s:%d, called from %s:%d\n",
72 "vinum lockdrive: already locking %s\n",
77 while ((drive->flags & VF_LOCKED) != 0) {
79 * There are problems sleeping on a unique identifier,
80 * since the drive structure can move, and the unlock
81 * function can be called after killing the drive.
82 * Solve this by waiting on this function; the number
83 * of conflicts is negligible.
85 if ((error = tsleep(&lockdrive,
91 drive->flags |= VF_LOCKED;
92 drive->pid = curproc->p_pid; /* it's a panic error if curproc is null */
94 bcopy(basename(file), drive->lockfilename, 15);
95 drive->lockfilename[15] = '\0'; /* truncate if necessary */
96 drive->lockline = line;
101 /* Unlock a drive and let the next one at it */
103 unlockdrive(struct drive *drive)
105 drive->flags &= ~VF_LOCKED;
106 /* we don't reset pid: it's of hysterical interest */
110 /* Lock a stripe of a plex, wait if it's in use */
112 lockrange(daddr_t stripe, struct buf *bp, struct plex *plex)
115 struct rangelock *lock;
116 struct rangelock *pos; /* position of first free lock */
117 int foundlocks; /* number of locks found */
120 * We could get by without counting the number
121 * of locks we find, but we have a linear search
122 * through a table which in most cases will be
123 * empty. It's faster to stop when we've found
124 * all the locks that are there. This is also
125 * the reason why we put pos at the beginning
126 * instead of the end, though it requires an
133 * we can't use 0 as a valid address, so
134 * increment all addresses by 1.
138 * We give the locks back from an interrupt
139 * context, so we need to raise the spl here.
143 /* Wait here if the table is full */
144 while (plex->usedlocks == PLEX_LOCKS) /* all in use */
145 tsleep(&plex->usedlocks, PRIBIO, "vlock", 0);
148 if (plex->usedlocks >= PLEX_LOCKS)
149 panic("lockrange: Too many locks in use");
152 lock = plex->lock; /* pointer in lock table */
153 if (plex->usedlocks > 0) /* something locked, */
154 /* Search the lock table for our stripe */
155 for (; lock < &plex->lock[PLEX_LOCKS]
156 && foundlocks < plex->usedlocks;
158 if (lock->stripe) { /* in use */
159 foundlocks++; /* found another one in use */
160 if ((lock->stripe == stripe) /* it's our stripe */
161 &&(lock->bp != bp)) { /* but not our request */
163 if (debug & DEBUG_LASTREQS) {
164 struct rangelock info;
166 info.stripe = stripe;
168 logrq(loginfo_lockwait, (union rqinfou) &info, bp);
171 plex->lockwaits++; /* waited one more time */
172 tsleep(lock, PRIBIO, "vrlock", 0);
173 lock = &plex->lock[-1]; /* start again */
177 } else if (pos == NULL) /* still looking for somewhere? */
178 pos = lock; /* a place to put this one */
181 * This untidy looking code ensures that we'll
182 * always end up pointing to the first free lock
183 * entry, thus minimizing the number of
184 * iterations necessary.
186 if (pos == NULL) /* didn't find one on the way, */
187 pos = lock; /* use the one we're pointing to */
190 * The address range is free, and we're pointing
191 * to the first unused entry. Make it ours.
193 pos->stripe = stripe;
195 plex->usedlocks++; /* one more lock */
198 if (debug & DEBUG_LASTREQS)
199 logrq(loginfo_lock, (union rqinfou) pos, bp);
204 /* Unlock a volume and let the next one at it */
206 unlockrange(int plexno, struct rangelock *lock)
210 plex = &PLEX[plexno];
212 if (lock < &plex->lock[0] || lock >= &plex->lock[PLEX_LOCKS])
213 panic("vinum: rangelock %p on plex %d invalid, not between %p and %p",
217 &plex->lock[PLEX_LOCKS]);
220 if (debug & DEBUG_LASTREQS)
221 logrq(loginfo_unlock, (union rqinfou) lock, lock->bp);
223 lock->stripe = 0; /* no longer used */
224 plex->usedlocks--; /* one less lock */
225 if (plex->usedlocks == PLEX_LOCKS - 1) /* we were full, */
226 wakeup(&plex->usedlocks); /* get a waiter if one's there */
227 wakeup((void *) lock);
230 /* Get a lock for the global config, wait if it's not available */
236 while ((vinum_conf.flags & VF_LOCKED) != 0) {
237 vinum_conf.flags |= VF_LOCKING;
238 if ((error = tsleep(&vinum_conf, PRIBIO, "vincfg", 0)) != 0)
241 vinum_conf.flags |= VF_LOCKED;
245 /* Unlock and wake up any waiters */
249 vinum_conf.flags &= ~VF_LOCKED;
250 if ((vinum_conf.flags & VF_LOCKING) != 0) {
251 vinum_conf.flags &= ~VF_LOCKING;
255 /* Local Variables: */
256 /* fill-column: 50 */