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 $
47 /* Lock a drive, wait if it's in use */
50 lockdrive(struct drive *drive, char *file, int line)
53 lockdrive(struct drive *drive)
58 /* XXX get rid of drive->flags |= VF_LOCKING; */
59 if ((drive->flags & VF_LOCKED) /* it's locked */
60 &&(drive->pid == curproc->p_pid)) { /* by us! */
63 "vinum lockdrive: already locking %s from %s:%d, called from %s:%d\n",
71 "vinum lockdrive: already locking %s\n",
76 while ((drive->flags & VF_LOCKED) != 0) {
78 * There are problems sleeping on a unique identifier,
79 * since the drive structure can move, and the unlock
80 * function can be called after killing the drive.
81 * Solve this by waiting on this function; the number
82 * of conflicts is negligible.
84 if ((error = tsleep(&lockdrive, 0, "vindrv", 0)) != 0)
87 drive->flags |= VF_LOCKED;
88 drive->pid = curproc->p_pid; /* it's a panic error if curproc is null */
90 bcopy(basename(file), drive->lockfilename, 15);
91 drive->lockfilename[15] = '\0'; /* truncate if necessary */
92 drive->lockline = line;
97 /* Unlock a drive and let the next one at it */
99 unlockdrive(struct drive *drive)
101 drive->flags &= ~VF_LOCKED;
102 /* we don't reset pid: it's of hysterical interest */
106 /* Lock a stripe of a plex, wait if it's in use */
108 lockrange(vinum_off_t stripe, struct buf *bp, struct plex *plex)
110 struct rangelock *lock;
111 struct rangelock *pos; /* position of first free lock */
112 int foundlocks; /* number of locks found */
115 * We could get by without counting the number
116 * of locks we find, but we have a linear search
117 * through a table which in most cases will be
118 * empty. It's faster to stop when we've found
119 * all the locks that are there. This is also
120 * the reason why we put pos at the beginning
121 * instead of the end, though it requires an
128 * we can't use 0 as a valid address, so
129 * increment all addresses by 1.
133 * We give the locks back from an interrupt
134 * context, so we need to raise the spl here.
138 /* Wait here if the table is full */
139 while (plex->usedlocks == PLEX_LOCKS) /* all in use */
140 tsleep(&plex->usedlocks, 0, "vlock", 0);
143 if (plex->usedlocks >= PLEX_LOCKS)
144 panic("lockrange: Too many locks in use");
147 lock = plex->lock; /* pointer in lock table */
148 if (plex->usedlocks > 0) /* something locked, */
149 /* Search the lock table for our stripe */
150 for (; lock < &plex->lock[PLEX_LOCKS]
151 && foundlocks < plex->usedlocks;
153 if (lock->stripe) { /* in use */
154 foundlocks++; /* found another one in use */
155 if ((lock->stripe == stripe) /* it's our stripe */
156 &&(lock->bp != bp)) { /* but not our request */
158 if (debug & DEBUG_LASTREQS) {
159 struct rangelock info;
161 info.stripe = stripe;
163 logrq(loginfo_lockwait, (union rqinfou) &info, &bp->b_bio1);
166 plex->lockwaits++; /* waited one more time */
167 tsleep(lock, 0, "vrlock", 0);
168 lock = &plex->lock[-1]; /* start again */
172 } else if (pos == NULL) /* still looking for somewhere? */
173 pos = lock; /* a place to put this one */
176 * This untidy looking code ensures that we'll
177 * always end up pointing to the first free lock
178 * entry, thus minimizing the number of
179 * iterations necessary.
181 if (pos == NULL) /* didn't find one on the way, */
182 pos = lock; /* use the one we're pointing to */
185 * The address range is free, and we're pointing
186 * to the first unused entry. Make it ours.
188 pos->stripe = stripe;
190 plex->usedlocks++; /* one more lock */
193 if (debug & DEBUG_LASTREQS)
194 logrq(loginfo_lock, (union rqinfou) pos, &bp->b_bio1);
199 /* Unlock a volume and let the next one at it */
201 unlockrange(int plexno, struct rangelock *lock)
205 plex = &PLEX[plexno];
207 if (lock < &plex->lock[0] || lock >= &plex->lock[PLEX_LOCKS])
208 panic("vinum: rangelock %p on plex %d invalid, not between %p and %p",
212 &plex->lock[PLEX_LOCKS]);
215 if (debug & DEBUG_LASTREQS)
216 logrq(loginfo_unlock, (union rqinfou) lock, &lock->bp->b_bio1);
218 lock->stripe = 0; /* no longer used */
219 plex->usedlocks--; /* one less lock */
220 if (plex->usedlocks == PLEX_LOCKS - 1) /* we were full, */
221 wakeup(&plex->usedlocks); /* get a waiter if one's there */
222 wakeup((void *) lock);
225 /* Get a lock for the global config, wait if it's not available */
231 while ((vinum_conf.flags & VF_LOCKED) != 0) {
232 vinum_conf.flags |= VF_LOCKING;
233 if ((error = tsleep(&vinum_conf, 0, "vincfg", 0)) != 0)
236 vinum_conf.flags |= VF_LOCKED;
240 /* Unlock and wake up any waiters */
244 vinum_conf.flags &= ~VF_LOCKED;
245 if ((vinum_conf.flags & VF_LOCKING) != 0) {
246 vinum_conf.flags &= ~VF_LOCKING;