vfs_lockf.c revision 1.82 1 1.82 riastrad /* $NetBSD: vfs_lockf.c,v 1.82 2024/12/07 02:11:42 riastradh Exp $ */
2 1.5 cgd
3 1.1 ws /*
4 1.4 mycroft * Copyright (c) 1982, 1986, 1989, 1993
5 1.4 mycroft * The Regents of the University of California. All rights reserved.
6 1.1 ws *
7 1.1 ws * This code is derived from software contributed to Berkeley by
8 1.1 ws * Scooter Morris at Genentech Inc.
9 1.1 ws *
10 1.1 ws * Redistribution and use in source and binary forms, with or without
11 1.1 ws * modification, are permitted provided that the following conditions
12 1.1 ws * are met:
13 1.1 ws * 1. Redistributions of source code must retain the above copyright
14 1.1 ws * notice, this list of conditions and the following disclaimer.
15 1.1 ws * 2. Redistributions in binary form must reproduce the above copyright
16 1.1 ws * notice, this list of conditions and the following disclaimer in the
17 1.1 ws * documentation and/or other materials provided with the distribution.
18 1.33 agc * 3. Neither the name of the University nor the names of its contributors
19 1.1 ws * may be used to endorse or promote products derived from this software
20 1.1 ws * without specific prior written permission.
21 1.1 ws *
22 1.1 ws * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 1.1 ws * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 1.1 ws * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 1.1 ws * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 1.1 ws * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 1.1 ws * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 1.1 ws * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 1.1 ws * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 1.1 ws * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 1.1 ws * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 1.1 ws * SUCH DAMAGE.
33 1.1 ws *
34 1.12 fvdl * @(#)ufs_lockf.c 8.4 (Berkeley) 10/26/94
35 1.1 ws */
36 1.18 lukem
37 1.18 lukem #include <sys/cdefs.h>
38 1.82 riastrad __KERNEL_RCSID(0, "$NetBSD: vfs_lockf.c,v 1.82 2024/12/07 02:11:42 riastradh Exp $");
39 1.1 ws
40 1.1 ws #include <sys/param.h>
41 1.82 riastrad #include <sys/types.h>
42 1.82 riastrad
43 1.82 riastrad #include <sys/atomic.h>
44 1.82 riastrad #include <sys/fcntl.h>
45 1.82 riastrad #include <sys/file.h>
46 1.82 riastrad #include <sys/kauth.h>
47 1.1 ws #include <sys/kernel.h>
48 1.81 ad #include <sys/kmem.h>
49 1.1 ws #include <sys/lockf.h>
50 1.82 riastrad #include <sys/proc.h>
51 1.82 riastrad #include <sys/systm.h>
52 1.69 pooka #include <sys/uidinfo.h>
53 1.82 riastrad #include <sys/vnode.h>
54 1.22 thorpej
55 1.50 yamt /*
56 1.50 yamt * The lockf structure is a kernel structure which contains the information
57 1.50 yamt * associated with a byte range lock. The lockf structures are linked into
58 1.60 ad * the vnode structure. Locks are sorted by the starting byte of the lock for
59 1.50 yamt * efficiency.
60 1.50 yamt *
61 1.50 yamt * lf_next is used for two purposes, depending on whether the lock is
62 1.50 yamt * being held, or is in conflict with an existing lock. If this lock
63 1.50 yamt * is held, it indicates the next lock on the same vnode.
64 1.50 yamt * For pending locks, if lock->lf_next is non-NULL, then lock->lf_block
65 1.50 yamt * must be queued on the lf_blkhd TAILQ of lock->lf_next.
66 1.50 yamt */
67 1.50 yamt
68 1.50 yamt TAILQ_HEAD(locklist, lockf);
69 1.50 yamt
70 1.50 yamt struct lockf {
71 1.65 ad kcondvar_t lf_cv; /* Signalling */
72 1.50 yamt short lf_flags; /* Lock semantics: F_POSIX, F_FLOCK, F_WAIT */
73 1.50 yamt short lf_type; /* Lock type: F_RDLCK, F_WRLCK */
74 1.50 yamt off_t lf_start; /* The byte # of the start of the lock */
75 1.50 yamt off_t lf_end; /* The byte # of the end of the lock (-1=EOF)*/
76 1.50 yamt void *lf_id; /* process or file description holding lock */
77 1.50 yamt struct lockf **lf_head; /* Back pointer to the head of lockf list */
78 1.50 yamt struct lockf *lf_next; /* Next lock on this vnode, or blocking lock */
79 1.50 yamt struct locklist lf_blkhd; /* List of requests blocked on this lock */
80 1.50 yamt TAILQ_ENTRY(lockf) lf_block;/* A request waiting for a lock */
81 1.81 ad struct uidinfo *lf_uip; /* Cached pointer to uidinfo */
82 1.50 yamt };
83 1.50 yamt
84 1.50 yamt /* Maximum length of sleep chains to traverse to try and detect deadlock. */
85 1.50 yamt #define MAXDEPTH 50
86 1.50 yamt
87 1.81 ad static kmutex_t lockf_lock __cacheline_aligned;
88 1.65 ad static char lockstr[] = "lockf";
89 1.1 ws
90 1.1 ws /*
91 1.6 mycroft * This variable controls the maximum number of processes that will
92 1.6 mycroft * be checked in doing deadlock detection.
93 1.6 mycroft */
94 1.6 mycroft int maxlockdepth = MAXDEPTH;
95 1.6 mycroft
96 1.6 mycroft #ifdef LOCKF_DEBUG
97 1.6 mycroft int lockf_debug = 0;
98 1.6 mycroft #endif
99 1.6 mycroft
100 1.6 mycroft #define SELF 0x1
101 1.6 mycroft #define OTHERS 0x2
102 1.6 mycroft
103 1.6 mycroft /*
104 1.16 sommerfe * XXX TODO
105 1.58 christos * Misc cleanups: "void *id" should be visible in the API as a
106 1.16 sommerfe * "struct proc *".
107 1.16 sommerfe * (This requires rototilling all VFS's which support advisory locking).
108 1.16 sommerfe */
109 1.16 sommerfe
110 1.16 sommerfe /*
111 1.16 sommerfe * If there's a lot of lock contention on a single vnode, locking
112 1.16 sommerfe * schemes which allow for more paralleism would be needed. Given how
113 1.16 sommerfe * infrequently byte-range locks are actually used in typical BSD
114 1.16 sommerfe * code, a more complex approach probably isn't worth it.
115 1.16 sommerfe */
116 1.16 sommerfe
117 1.16 sommerfe /*
118 1.38 christos * We enforce a limit on locks by uid, so that a single user cannot
119 1.38 christos * run the kernel out of memory. For now, the limit is pretty coarse.
120 1.38 christos * There is no limit on root.
121 1.38 christos *
122 1.38 christos * Splitting a lock will always succeed, regardless of current allocations.
123 1.38 christos * If you're slightly above the limit, we still have to permit an allocation
124 1.38 christos * so that the unlock can succeed. If the unlocking causes too many splits,
125 1.38 christos * however, you're totally cutoff.
126 1.38 christos */
127 1.74 manu #define MAXLOCKSPERUID (2 * maxfiles)
128 1.38 christos
129 1.45 thorpej #ifdef LOCKF_DEBUG
130 1.45 thorpej /*
131 1.45 thorpej * Print out a lock.
132 1.45 thorpej */
133 1.45 thorpej static void
134 1.56 christos lf_print(const char *tag, struct lockf *lock)
135 1.45 thorpej {
136 1.45 thorpej
137 1.45 thorpej printf("%s: lock %p for ", tag, lock);
138 1.45 thorpej if (lock->lf_flags & F_POSIX)
139 1.45 thorpej printf("proc %d", ((struct proc *)lock->lf_id)->p_pid);
140 1.45 thorpej else
141 1.45 thorpej printf("file %p", (struct file *)lock->lf_id);
142 1.73 dholland printf(" %s, start %jd, end %jd",
143 1.45 thorpej lock->lf_type == F_RDLCK ? "shared" :
144 1.45 thorpej lock->lf_type == F_WRLCK ? "exclusive" :
145 1.45 thorpej lock->lf_type == F_UNLCK ? "unlock" :
146 1.73 dholland "unknown", (intmax_t)lock->lf_start, (intmax_t)lock->lf_end);
147 1.45 thorpej if (TAILQ_FIRST(&lock->lf_blkhd))
148 1.45 thorpej printf(" block %p\n", TAILQ_FIRST(&lock->lf_blkhd));
149 1.45 thorpej else
150 1.45 thorpej printf("\n");
151 1.45 thorpej }
152 1.45 thorpej
153 1.45 thorpej static void
154 1.56 christos lf_printlist(const char *tag, struct lockf *lock)
155 1.45 thorpej {
156 1.45 thorpej struct lockf *lf, *blk;
157 1.45 thorpej
158 1.45 thorpej printf("%s: Lock list:\n", tag);
159 1.45 thorpej for (lf = *lock->lf_head; lf; lf = lf->lf_next) {
160 1.45 thorpej printf("\tlock %p for ", lf);
161 1.45 thorpej if (lf->lf_flags & F_POSIX)
162 1.45 thorpej printf("proc %d", ((struct proc *)lf->lf_id)->p_pid);
163 1.45 thorpej else
164 1.45 thorpej printf("file %p", (struct file *)lf->lf_id);
165 1.73 dholland printf(", %s, start %jd, end %jd",
166 1.82 riastrad lf->lf_type == F_RDLCK ? "shared" :
167 1.82 riastrad lf->lf_type == F_WRLCK ? "exclusive" :
168 1.82 riastrad lf->lf_type == F_UNLCK ? "unlock" :
169 1.82 riastrad "unknown", (intmax_t)lf->lf_start, (intmax_t)lf->lf_end);
170 1.45 thorpej TAILQ_FOREACH(blk, &lf->lf_blkhd, lf_block) {
171 1.45 thorpej if (blk->lf_flags & F_POSIX)
172 1.66 skrll printf("; proc %d",
173 1.45 thorpej ((struct proc *)blk->lf_id)->p_pid);
174 1.45 thorpej else
175 1.66 skrll printf("; file %p", (struct file *)blk->lf_id);
176 1.73 dholland printf(", %s, start %jd, end %jd",
177 1.82 riastrad blk->lf_type == F_RDLCK ? "shared" :
178 1.82 riastrad blk->lf_type == F_WRLCK ? "exclusive" :
179 1.82 riastrad blk->lf_type == F_UNLCK ? "unlock" :
180 1.82 riastrad "unknown",
181 1.82 riastrad (intmax_t)blk->lf_start, (intmax_t)blk->lf_end);
182 1.45 thorpej if (TAILQ_FIRST(&blk->lf_blkhd))
183 1.45 thorpej panic("lf_printlist: bad list");
184 1.45 thorpej }
185 1.45 thorpej printf("\n");
186 1.45 thorpej }
187 1.45 thorpej }
188 1.45 thorpej #endif /* LOCKF_DEBUG */
189 1.45 thorpej
190 1.38 christos /*
191 1.38 christos * 3 options for allowfail.
192 1.38 christos * 0 - always allocate. 1 - cutoff at limit. 2 - cutoff at double limit.
193 1.38 christos */
194 1.45 thorpej static struct lockf *
195 1.71 yamt lf_alloc(int allowfail)
196 1.38 christos {
197 1.38 christos struct uidinfo *uip;
198 1.38 christos struct lockf *lock;
199 1.62 rmind u_long lcnt;
200 1.71 yamt const uid_t uid = kauth_cred_geteuid(kauth_cred_get());
201 1.38 christos
202 1.38 christos uip = uid_find(uid);
203 1.62 rmind lcnt = atomic_inc_ulong_nv(&uip->ui_lockcnt);
204 1.62 rmind if (uid && allowfail && lcnt >
205 1.74 manu (allowfail == 1 ? MAXLOCKSPERUID : (MAXLOCKSPERUID * 2))) {
206 1.62 rmind atomic_dec_ulong(&uip->ui_lockcnt);
207 1.40 christos return NULL;
208 1.40 christos }
209 1.62 rmind
210 1.81 ad lock = kmem_alloc(sizeof(*lock), KM_SLEEP);
211 1.81 ad lock->lf_uip = uip;
212 1.81 ad cv_init(&lock->lf_cv, lockstr);
213 1.40 christos return lock;
214 1.38 christos }
215 1.38 christos
216 1.45 thorpej static void
217 1.38 christos lf_free(struct lockf *lock)
218 1.38 christos {
219 1.80 ad
220 1.81 ad atomic_dec_ulong(&lock->lf_uip->ui_lockcnt);
221 1.61 ad cv_destroy(&lock->lf_cv);
222 1.81 ad kmem_free(lock, sizeof(*lock));
223 1.38 christos }
224 1.38 christos
225 1.38 christos /*
226 1.45 thorpej * Walk the list of locks for an inode to
227 1.45 thorpej * find an overlapping lock (if any).
228 1.45 thorpej *
229 1.45 thorpej * NOTE: this returns only the FIRST overlapping lock. There
230 1.45 thorpej * may be more than one.
231 1.1 ws */
232 1.45 thorpej static int
233 1.45 thorpej lf_findoverlap(struct lockf *lf, struct lockf *lock, int type,
234 1.45 thorpej struct lockf ***prev, struct lockf **overlap)
235 1.1 ws {
236 1.1 ws off_t start, end;
237 1.1 ws
238 1.45 thorpej *overlap = lf;
239 1.54 yamt if (lf == NULL)
240 1.45 thorpej return 0;
241 1.45 thorpej #ifdef LOCKF_DEBUG
242 1.45 thorpej if (lockf_debug & 2)
243 1.45 thorpej lf_print("lf_findoverlap: looking for overlap in", lock);
244 1.45 thorpej #endif /* LOCKF_DEBUG */
245 1.45 thorpej start = lock->lf_start;
246 1.45 thorpej end = lock->lf_end;
247 1.54 yamt while (lf != NULL) {
248 1.45 thorpej if (((type == SELF) && lf->lf_id != lock->lf_id) ||
249 1.45 thorpej ((type == OTHERS) && lf->lf_id == lock->lf_id)) {
250 1.45 thorpej *prev = &lf->lf_next;
251 1.45 thorpej *overlap = lf = lf->lf_next;
252 1.45 thorpej continue;
253 1.45 thorpej }
254 1.45 thorpej #ifdef LOCKF_DEBUG
255 1.45 thorpej if (lockf_debug & 2)
256 1.45 thorpej lf_print("\tchecking", lf);
257 1.45 thorpej #endif /* LOCKF_DEBUG */
258 1.1 ws /*
259 1.45 thorpej * OK, check for overlap
260 1.45 thorpej *
261 1.45 thorpej * Six cases:
262 1.45 thorpej * 0) no overlap
263 1.45 thorpej * 1) overlap == lock
264 1.45 thorpej * 2) overlap contains lock
265 1.45 thorpej * 3) lock contains overlap
266 1.45 thorpej * 4) overlap starts before lock
267 1.45 thorpej * 5) overlap ends after lock
268 1.1 ws */
269 1.45 thorpej if ((lf->lf_end != -1 && start > lf->lf_end) ||
270 1.45 thorpej (end != -1 && lf->lf_start > end)) {
271 1.45 thorpej /* Case 0 */
272 1.45 thorpej #ifdef LOCKF_DEBUG
273 1.45 thorpej if (lockf_debug & 2)
274 1.45 thorpej printf("no overlap\n");
275 1.45 thorpej #endif /* LOCKF_DEBUG */
276 1.45 thorpej if ((type & SELF) && end != -1 && lf->lf_start > end)
277 1.45 thorpej return 0;
278 1.45 thorpej *prev = &lf->lf_next;
279 1.45 thorpej *overlap = lf = lf->lf_next;
280 1.45 thorpej continue;
281 1.45 thorpej }
282 1.45 thorpej if ((lf->lf_start == start) && (lf->lf_end == end)) {
283 1.45 thorpej /* Case 1 */
284 1.45 thorpej #ifdef LOCKF_DEBUG
285 1.45 thorpej if (lockf_debug & 2)
286 1.45 thorpej printf("overlap == lock\n");
287 1.45 thorpej #endif /* LOCKF_DEBUG */
288 1.45 thorpej return 1;
289 1.45 thorpej }
290 1.45 thorpej if ((lf->lf_start <= start) &&
291 1.45 thorpej (end != -1) &&
292 1.45 thorpej ((lf->lf_end >= end) || (lf->lf_end == -1))) {
293 1.45 thorpej /* Case 2 */
294 1.45 thorpej #ifdef LOCKF_DEBUG
295 1.45 thorpej if (lockf_debug & 2)
296 1.45 thorpej printf("overlap contains lock\n");
297 1.45 thorpej #endif /* LOCKF_DEBUG */
298 1.45 thorpej return 2;
299 1.45 thorpej }
300 1.45 thorpej if (start <= lf->lf_start &&
301 1.45 thorpej (end == -1 ||
302 1.45 thorpej (lf->lf_end != -1 && end >= lf->lf_end))) {
303 1.45 thorpej /* Case 3 */
304 1.45 thorpej #ifdef LOCKF_DEBUG
305 1.45 thorpej if (lockf_debug & 2)
306 1.45 thorpej printf("lock contains overlap\n");
307 1.45 thorpej #endif /* LOCKF_DEBUG */
308 1.45 thorpej return 3;
309 1.45 thorpej }
310 1.45 thorpej if ((lf->lf_start < start) &&
311 1.45 thorpej ((lf->lf_end >= start) || (lf->lf_end == -1))) {
312 1.45 thorpej /* Case 4 */
313 1.45 thorpej #ifdef LOCKF_DEBUG
314 1.45 thorpej if (lockf_debug & 2)
315 1.45 thorpej printf("overlap starts before lock\n");
316 1.45 thorpej #endif /* LOCKF_DEBUG */
317 1.45 thorpej return 4;
318 1.45 thorpej }
319 1.45 thorpej if ((lf->lf_start > start) &&
320 1.45 thorpej (end != -1) &&
321 1.45 thorpej ((lf->lf_end > end) || (lf->lf_end == -1))) {
322 1.45 thorpej /* Case 5 */
323 1.45 thorpej #ifdef LOCKF_DEBUG
324 1.45 thorpej if (lockf_debug & 2)
325 1.45 thorpej printf("overlap ends after lock\n");
326 1.45 thorpej #endif /* LOCKF_DEBUG */
327 1.45 thorpej return 5;
328 1.45 thorpej }
329 1.45 thorpej panic("lf_findoverlap: default");
330 1.45 thorpej }
331 1.45 thorpej return 0;
332 1.45 thorpej }
333 1.1 ws
334 1.45 thorpej /*
335 1.45 thorpej * Split a lock and a contained region into
336 1.45 thorpej * two or three locks as necessary.
337 1.45 thorpej */
338 1.45 thorpej static void
339 1.45 thorpej lf_split(struct lockf *lock1, struct lockf *lock2, struct lockf **sparelock)
340 1.45 thorpej {
341 1.45 thorpej struct lockf *splitlock;
342 1.1 ws
343 1.45 thorpej #ifdef LOCKF_DEBUG
344 1.45 thorpej if (lockf_debug & 2) {
345 1.45 thorpej lf_print("lf_split", lock1);
346 1.45 thorpej lf_print("splitting from", lock2);
347 1.1 ws }
348 1.45 thorpej #endif /* LOCKF_DEBUG */
349 1.10 kleink /*
350 1.75 andvar * Check to see if splitting into only two pieces.
351 1.27 yamt */
352 1.45 thorpej if (lock1->lf_start == lock2->lf_start) {
353 1.45 thorpej lock1->lf_start = lock2->lf_end + 1;
354 1.45 thorpej lock2->lf_next = lock1;
355 1.45 thorpej return;
356 1.27 yamt }
357 1.45 thorpej if (lock1->lf_end == lock2->lf_end) {
358 1.45 thorpej lock1->lf_end = lock2->lf_start - 1;
359 1.45 thorpej lock2->lf_next = lock1->lf_next;
360 1.45 thorpej lock1->lf_next = lock2;
361 1.45 thorpej return;
362 1.27 yamt }
363 1.27 yamt /*
364 1.45 thorpej * Make a new lock consisting of the last part of
365 1.45 thorpej * the encompassing lock
366 1.10 kleink */
367 1.45 thorpej splitlock = *sparelock;
368 1.45 thorpej *sparelock = NULL;
369 1.70 yamt cv_destroy(&splitlock->lf_cv);
370 1.45 thorpej memcpy(splitlock, lock1, sizeof(*splitlock));
371 1.67 skrll cv_init(&splitlock->lf_cv, lockstr);
372 1.67 skrll
373 1.45 thorpej splitlock->lf_start = lock2->lf_end + 1;
374 1.45 thorpej TAILQ_INIT(&splitlock->lf_blkhd);
375 1.45 thorpej lock1->lf_end = lock2->lf_start - 1;
376 1.1 ws /*
377 1.45 thorpej * OK, now link it in
378 1.21 thorpej */
379 1.45 thorpej splitlock->lf_next = lock1->lf_next;
380 1.45 thorpej lock2->lf_next = splitlock;
381 1.45 thorpej lock1->lf_next = lock2;
382 1.45 thorpej }
383 1.45 thorpej
384 1.45 thorpej /*
385 1.45 thorpej * Wakeup a blocklist
386 1.45 thorpej */
387 1.45 thorpej static void
388 1.45 thorpej lf_wakelock(struct lockf *listhead)
389 1.45 thorpej {
390 1.45 thorpej struct lockf *wakelock;
391 1.21 thorpej
392 1.45 thorpej while ((wakelock = TAILQ_FIRST(&listhead->lf_blkhd))) {
393 1.45 thorpej KASSERT(wakelock->lf_next == listhead);
394 1.45 thorpej TAILQ_REMOVE(&listhead->lf_blkhd, wakelock, lf_block);
395 1.54 yamt wakelock->lf_next = NULL;
396 1.45 thorpej #ifdef LOCKF_DEBUG
397 1.45 thorpej if (lockf_debug & 2)
398 1.45 thorpej lf_print("lf_wakelock: awakening", wakelock);
399 1.45 thorpej #endif
400 1.61 ad cv_broadcast(&wakelock->lf_cv);
401 1.21 thorpej }
402 1.45 thorpej }
403 1.45 thorpej
404 1.45 thorpej /*
405 1.45 thorpej * Remove a byte-range lock on an inode.
406 1.45 thorpej *
407 1.45 thorpej * Generally, find the lock (or an overlap to that lock)
408 1.45 thorpej * and remove it (or shrink it), then wakeup anyone we can.
409 1.45 thorpej */
410 1.45 thorpej static int
411 1.45 thorpej lf_clearlock(struct lockf *unlock, struct lockf **sparelock)
412 1.45 thorpej {
413 1.45 thorpej struct lockf **head = unlock->lf_head;
414 1.45 thorpej struct lockf *lf = *head;
415 1.45 thorpej struct lockf *overlap, **prev;
416 1.45 thorpej int ovcase;
417 1.45 thorpej
418 1.54 yamt if (lf == NULL)
419 1.45 thorpej return 0;
420 1.45 thorpej #ifdef LOCKF_DEBUG
421 1.45 thorpej if (unlock->lf_type != F_UNLCK)
422 1.45 thorpej panic("lf_clearlock: bad type");
423 1.45 thorpej if (lockf_debug & 1)
424 1.45 thorpej lf_print("lf_clearlock", unlock);
425 1.45 thorpej #endif /* LOCKF_DEBUG */
426 1.45 thorpej prev = head;
427 1.45 thorpej while ((ovcase = lf_findoverlap(lf, unlock, SELF,
428 1.61 ad &prev, &overlap)) != 0) {
429 1.45 thorpej /*
430 1.45 thorpej * Wakeup the list of locks to be retried.
431 1.45 thorpej */
432 1.45 thorpej lf_wakelock(overlap);
433 1.45 thorpej
434 1.45 thorpej switch (ovcase) {
435 1.37 perry
436 1.45 thorpej case 1: /* overlap == lock */
437 1.45 thorpej *prev = overlap->lf_next;
438 1.45 thorpej lf_free(overlap);
439 1.45 thorpej break;
440 1.4 mycroft
441 1.45 thorpej case 2: /* overlap contains lock: split it */
442 1.45 thorpej if (overlap->lf_start == unlock->lf_start) {
443 1.45 thorpej overlap->lf_start = unlock->lf_end + 1;
444 1.45 thorpej break;
445 1.45 thorpej }
446 1.45 thorpej lf_split(overlap, unlock, sparelock);
447 1.45 thorpej overlap->lf_next = unlock->lf_next;
448 1.45 thorpej break;
449 1.1 ws
450 1.45 thorpej case 3: /* lock contains overlap */
451 1.45 thorpej *prev = overlap->lf_next;
452 1.45 thorpej lf = overlap->lf_next;
453 1.45 thorpej lf_free(overlap);
454 1.45 thorpej continue;
455 1.1 ws
456 1.45 thorpej case 4: /* overlap starts before lock */
457 1.45 thorpej overlap->lf_end = unlock->lf_start - 1;
458 1.45 thorpej prev = &overlap->lf_next;
459 1.45 thorpej lf = overlap->lf_next;
460 1.45 thorpej continue;
461 1.4 mycroft
462 1.45 thorpej case 5: /* overlap ends after lock */
463 1.45 thorpej overlap->lf_start = unlock->lf_end + 1;
464 1.45 thorpej break;
465 1.45 thorpej }
466 1.31 fvdl break;
467 1.27 yamt }
468 1.45 thorpej #ifdef LOCKF_DEBUG
469 1.45 thorpej if (lockf_debug & 1)
470 1.45 thorpej lf_printlist("lf_clearlock", unlock);
471 1.45 thorpej #endif /* LOCKF_DEBUG */
472 1.45 thorpej return 0;
473 1.45 thorpej }
474 1.27 yamt
475 1.45 thorpej /*
476 1.45 thorpej * Walk the list of locks for an inode and
477 1.45 thorpej * return the first blocking lock.
478 1.45 thorpej */
479 1.45 thorpej static struct lockf *
480 1.45 thorpej lf_getblock(struct lockf *lock)
481 1.45 thorpej {
482 1.45 thorpej struct lockf **prev, *overlap, *lf = *(lock->lf_head);
483 1.27 yamt
484 1.45 thorpej prev = lock->lf_head;
485 1.45 thorpej while (lf_findoverlap(lf, lock, OTHERS, &prev, &overlap) != 0) {
486 1.45 thorpej /*
487 1.45 thorpej * We've found an overlap, see if it blocks us
488 1.45 thorpej */
489 1.45 thorpej if ((lock->lf_type == F_WRLCK || overlap->lf_type == F_WRLCK))
490 1.45 thorpej return overlap;
491 1.45 thorpej /*
492 1.45 thorpej * Nope, point to the next one on the list and
493 1.45 thorpej * see if it blocks us
494 1.45 thorpej */
495 1.45 thorpej lf = overlap->lf_next;
496 1.45 thorpej }
497 1.54 yamt return NULL;
498 1.1 ws }
499 1.1 ws
500 1.1 ws /*
501 1.1 ws * Set a byte-range lock.
502 1.1 ws */
503 1.24 yamt static int
504 1.27 yamt lf_setlock(struct lockf *lock, struct lockf **sparelock,
505 1.61 ad kmutex_t *interlock)
506 1.1 ws {
507 1.15 augustss struct lockf *block;
508 1.1 ws struct lockf **head = lock->lf_head;
509 1.1 ws struct lockf **prev, *overlap, *ltmp;
510 1.61 ad int ovcase, needtolink, error;
511 1.1 ws
512 1.1 ws #ifdef LOCKF_DEBUG
513 1.1 ws if (lockf_debug & 1)
514 1.1 ws lf_print("lf_setlock", lock);
515 1.1 ws #endif /* LOCKF_DEBUG */
516 1.1 ws
517 1.1 ws /*
518 1.1 ws * Scan lock list for this file looking for locks that would block us.
519 1.1 ws */
520 1.7 christos while ((block = lf_getblock(lock)) != NULL) {
521 1.1 ws /*
522 1.1 ws * Free the structure and return if nonblocking.
523 1.1 ws */
524 1.1 ws if ((lock->lf_flags & F_WAIT) == 0) {
525 1.38 christos lf_free(lock);
526 1.29 yamt return EAGAIN;
527 1.1 ws }
528 1.1 ws /*
529 1.1 ws * We are blocked. Since flock style locks cover
530 1.1 ws * the whole file, there is no chance for deadlock.
531 1.1 ws * For byte-range locks we must check for deadlock.
532 1.1 ws *
533 1.1 ws * Deadlock detection is done by looking through the
534 1.1 ws * wait channels to see if there are any cycles that
535 1.1 ws * involve us. MAXDEPTH is set just to make sure we
536 1.16 sommerfe * do not go off into neverneverland.
537 1.1 ws */
538 1.1 ws if ((lock->lf_flags & F_POSIX) &&
539 1.1 ws (block->lf_flags & F_POSIX)) {
540 1.21 thorpej struct lwp *wlwp;
541 1.48 perry volatile const struct lockf *waitblock;
542 1.1 ws int i = 0;
543 1.52 yamt struct proc *p;
544 1.1 ws
545 1.52 yamt p = (struct proc *)block->lf_id;
546 1.52 yamt KASSERT(p != NULL);
547 1.52 yamt while (i++ < maxlockdepth) {
548 1.64 ad mutex_enter(p->p_lock);
549 1.52 yamt if (p->p_nlwps > 1) {
550 1.64 ad mutex_exit(p->p_lock);
551 1.52 yamt break;
552 1.52 yamt }
553 1.52 yamt wlwp = LIST_FIRST(&p->p_lwps);
554 1.57 ad lwp_lock(wlwp);
555 1.65 ad if (wlwp->l_wchan == NULL ||
556 1.65 ad wlwp->l_wmesg != lockstr) {
557 1.57 ad lwp_unlock(wlwp);
558 1.64 ad mutex_exit(p->p_lock);
559 1.52 yamt break;
560 1.52 yamt }
561 1.44 christos waitblock = wlwp->l_wchan;
562 1.57 ad lwp_unlock(wlwp);
563 1.64 ad mutex_exit(p->p_lock);
564 1.1 ws /* Get the owner of the blocking lock */
565 1.1 ws waitblock = waitblock->lf_next;
566 1.1 ws if ((waitblock->lf_flags & F_POSIX) == 0)
567 1.1 ws break;
568 1.52 yamt p = (struct proc *)waitblock->lf_id;
569 1.52 yamt if (p == curproc) {
570 1.38 christos lf_free(lock);
571 1.29 yamt return EDEADLK;
572 1.1 ws }
573 1.1 ws }
574 1.16 sommerfe /*
575 1.36 peter * If we're still following a dependency chain
576 1.16 sommerfe * after maxlockdepth iterations, assume we're in
577 1.16 sommerfe * a cycle to be safe.
578 1.16 sommerfe */
579 1.16 sommerfe if (i >= maxlockdepth) {
580 1.38 christos lf_free(lock);
581 1.29 yamt return EDEADLK;
582 1.16 sommerfe }
583 1.1 ws }
584 1.1 ws /*
585 1.1 ws * For flock type locks, we must first remove
586 1.1 ws * any shared locks that we hold before we sleep
587 1.1 ws * waiting for an exclusive lock.
588 1.1 ws */
589 1.1 ws if ((lock->lf_flags & F_FLOCK) &&
590 1.1 ws lock->lf_type == F_WRLCK) {
591 1.1 ws lock->lf_type = F_UNLCK;
592 1.27 yamt (void) lf_clearlock(lock, NULL);
593 1.1 ws lock->lf_type = F_WRLCK;
594 1.1 ws }
595 1.1 ws /*
596 1.1 ws * Add our lock to the blocked list and sleep until we're free.
597 1.1 ws * Remember who blocked us (for deadlock detection).
598 1.1 ws */
599 1.1 ws lock->lf_next = block;
600 1.12 fvdl TAILQ_INSERT_TAIL(&block->lf_blkhd, lock, lf_block);
601 1.1 ws #ifdef LOCKF_DEBUG
602 1.1 ws if (lockf_debug & 1) {
603 1.1 ws lf_print("lf_setlock: blocking on", block);
604 1.1 ws lf_printlist("lf_setlock", block);
605 1.1 ws }
606 1.1 ws #endif /* LOCKF_DEBUG */
607 1.61 ad error = cv_wait_sig(&lock->lf_cv, interlock);
608 1.16 sommerfe
609 1.16 sommerfe /*
610 1.65 ad * We may have been awoken by a signal (in
611 1.16 sommerfe * which case we must remove ourselves from the
612 1.16 sommerfe * blocked list) and/or by another process
613 1.16 sommerfe * releasing a lock (in which case we have already
614 1.16 sommerfe * been removed from the blocked list and our
615 1.54 yamt * lf_next field set to NULL).
616 1.16 sommerfe */
617 1.54 yamt if (lock->lf_next != NULL) {
618 1.16 sommerfe TAILQ_REMOVE(&lock->lf_next->lf_blkhd, lock, lf_block);
619 1.54 yamt lock->lf_next = NULL;
620 1.16 sommerfe }
621 1.7 christos if (error) {
622 1.38 christos lf_free(lock);
623 1.29 yamt return error;
624 1.1 ws }
625 1.1 ws }
626 1.1 ws /*
627 1.1 ws * No blocks!! Add the lock. Note that we will
628 1.1 ws * downgrade or upgrade any overlapping locks this
629 1.1 ws * process already owns.
630 1.1 ws *
631 1.1 ws * Skip over locks owned by other processes.
632 1.1 ws * Handle any locks that overlap and are owned by ourselves.
633 1.1 ws */
634 1.1 ws prev = head;
635 1.1 ws block = *head;
636 1.1 ws needtolink = 1;
637 1.1 ws for (;;) {
638 1.7 christos ovcase = lf_findoverlap(block, lock, SELF, &prev, &overlap);
639 1.7 christos if (ovcase)
640 1.1 ws block = overlap->lf_next;
641 1.1 ws /*
642 1.1 ws * Six cases:
643 1.1 ws * 0) no overlap
644 1.1 ws * 1) overlap == lock
645 1.1 ws * 2) overlap contains lock
646 1.1 ws * 3) lock contains overlap
647 1.1 ws * 4) overlap starts before lock
648 1.1 ws * 5) overlap ends after lock
649 1.1 ws */
650 1.1 ws switch (ovcase) {
651 1.1 ws case 0: /* no overlap */
652 1.1 ws if (needtolink) {
653 1.1 ws *prev = lock;
654 1.1 ws lock->lf_next = overlap;
655 1.1 ws }
656 1.1 ws break;
657 1.1 ws
658 1.1 ws case 1: /* overlap == lock */
659 1.1 ws /*
660 1.1 ws * If downgrading lock, others may be
661 1.1 ws * able to acquire it.
662 1.1 ws */
663 1.1 ws if (lock->lf_type == F_RDLCK &&
664 1.1 ws overlap->lf_type == F_WRLCK)
665 1.1 ws lf_wakelock(overlap);
666 1.1 ws overlap->lf_type = lock->lf_type;
667 1.38 christos lf_free(lock);
668 1.1 ws lock = overlap; /* for debug output below */
669 1.1 ws break;
670 1.1 ws
671 1.1 ws case 2: /* overlap contains lock */
672 1.1 ws /*
673 1.1 ws * Check for common starting point and different types.
674 1.1 ws */
675 1.1 ws if (overlap->lf_type == lock->lf_type) {
676 1.38 christos lf_free(lock);
677 1.1 ws lock = overlap; /* for debug output below */
678 1.1 ws break;
679 1.1 ws }
680 1.1 ws if (overlap->lf_start == lock->lf_start) {
681 1.1 ws *prev = lock;
682 1.1 ws lock->lf_next = overlap;
683 1.1 ws overlap->lf_start = lock->lf_end + 1;
684 1.1 ws } else
685 1.27 yamt lf_split(overlap, lock, sparelock);
686 1.1 ws lf_wakelock(overlap);
687 1.1 ws break;
688 1.1 ws
689 1.1 ws case 3: /* lock contains overlap */
690 1.1 ws /*
691 1.1 ws * If downgrading lock, others may be able to
692 1.1 ws * acquire it, otherwise take the list.
693 1.1 ws */
694 1.1 ws if (lock->lf_type == F_RDLCK &&
695 1.1 ws overlap->lf_type == F_WRLCK) {
696 1.1 ws lf_wakelock(overlap);
697 1.1 ws } else {
698 1.82 riastrad while ((ltmp =
699 1.82 riastrad TAILQ_FIRST(&overlap->lf_blkhd))
700 1.82 riastrad != NULL) {
701 1.16 sommerfe KASSERT(ltmp->lf_next == overlap);
702 1.12 fvdl TAILQ_REMOVE(&overlap->lf_blkhd, ltmp,
703 1.12 fvdl lf_block);
704 1.16 sommerfe ltmp->lf_next = lock;
705 1.12 fvdl TAILQ_INSERT_TAIL(&lock->lf_blkhd,
706 1.12 fvdl ltmp, lf_block);
707 1.12 fvdl }
708 1.1 ws }
709 1.1 ws /*
710 1.82 riastrad * Add the new lock if necessary and delete the
711 1.82 riastrad * overlap.
712 1.1 ws */
713 1.1 ws if (needtolink) {
714 1.1 ws *prev = lock;
715 1.1 ws lock->lf_next = overlap->lf_next;
716 1.1 ws prev = &lock->lf_next;
717 1.1 ws needtolink = 0;
718 1.1 ws } else
719 1.1 ws *prev = overlap->lf_next;
720 1.39 christos lf_free(overlap);
721 1.1 ws continue;
722 1.1 ws
723 1.1 ws case 4: /* overlap starts before lock */
724 1.1 ws /*
725 1.1 ws * Add lock after overlap on the list.
726 1.1 ws */
727 1.1 ws lock->lf_next = overlap->lf_next;
728 1.1 ws overlap->lf_next = lock;
729 1.1 ws overlap->lf_end = lock->lf_start - 1;
730 1.1 ws prev = &lock->lf_next;
731 1.1 ws lf_wakelock(overlap);
732 1.1 ws needtolink = 0;
733 1.1 ws continue;
734 1.1 ws
735 1.1 ws case 5: /* overlap ends after lock */
736 1.1 ws /*
737 1.1 ws * Add the new lock before overlap.
738 1.1 ws */
739 1.1 ws if (needtolink) {
740 1.1 ws *prev = lock;
741 1.1 ws lock->lf_next = overlap;
742 1.1 ws }
743 1.1 ws overlap->lf_start = lock->lf_end + 1;
744 1.1 ws lf_wakelock(overlap);
745 1.1 ws break;
746 1.1 ws }
747 1.1 ws break;
748 1.1 ws }
749 1.1 ws #ifdef LOCKF_DEBUG
750 1.1 ws if (lockf_debug & 1) {
751 1.1 ws lf_print("lf_setlock: got the lock", lock);
752 1.1 ws lf_printlist("lf_setlock", lock);
753 1.1 ws }
754 1.1 ws #endif /* LOCKF_DEBUG */
755 1.29 yamt return 0;
756 1.1 ws }
757 1.1 ws
758 1.1 ws /*
759 1.1 ws * Check whether there is a blocking lock,
760 1.1 ws * and if so return its process identifier.
761 1.1 ws */
762 1.24 yamt static int
763 1.25 yamt lf_getlock(struct lockf *lock, struct flock *fl)
764 1.1 ws {
765 1.15 augustss struct lockf *block;
766 1.1 ws
767 1.1 ws #ifdef LOCKF_DEBUG
768 1.1 ws if (lockf_debug & 1)
769 1.1 ws lf_print("lf_getlock", lock);
770 1.1 ws #endif /* LOCKF_DEBUG */
771 1.1 ws
772 1.7 christos if ((block = lf_getblock(lock)) != NULL) {
773 1.1 ws fl->l_type = block->lf_type;
774 1.1 ws fl->l_whence = SEEK_SET;
775 1.1 ws fl->l_start = block->lf_start;
776 1.1 ws if (block->lf_end == -1)
777 1.1 ws fl->l_len = 0;
778 1.1 ws else
779 1.1 ws fl->l_len = block->lf_end - block->lf_start + 1;
780 1.1 ws if (block->lf_flags & F_POSIX)
781 1.23 mycroft fl->l_pid = ((struct proc *)block->lf_id)->p_pid;
782 1.1 ws else
783 1.1 ws fl->l_pid = -1;
784 1.1 ws } else {
785 1.1 ws fl->l_type = F_UNLCK;
786 1.1 ws }
787 1.29 yamt return 0;
788 1.1 ws }
789 1.1 ws
790 1.1 ws /*
791 1.45 thorpej * Do an advisory lock operation.
792 1.1 ws */
793 1.45 thorpej int
794 1.45 thorpej lf_advlock(struct vop_advlock_args *ap, struct lockf **head, off_t size)
795 1.1 ws {
796 1.45 thorpej struct flock *fl = ap->a_fl;
797 1.45 thorpej struct lockf *lock = NULL;
798 1.45 thorpej struct lockf *sparelock;
799 1.81 ad kmutex_t *interlock = &lockf_lock;
800 1.45 thorpej off_t start, end;
801 1.45 thorpej int error = 0;
802 1.1 ws
803 1.76 riastrad KASSERTMSG(size >= 0, "size=%jd", (intmax_t)size);
804 1.76 riastrad
805 1.45 thorpej /*
806 1.45 thorpej * Convert the flock structure into a start and end.
807 1.45 thorpej */
808 1.45 thorpej switch (fl->l_whence) {
809 1.45 thorpej case SEEK_SET:
810 1.45 thorpej case SEEK_CUR:
811 1.1 ws /*
812 1.45 thorpej * Caller is responsible for adding any necessary offset
813 1.45 thorpej * when SEEK_CUR is used.
814 1.1 ws */
815 1.45 thorpej start = fl->l_start;
816 1.45 thorpej break;
817 1.45 thorpej
818 1.45 thorpej case SEEK_END:
819 1.76 riastrad if (fl->l_start > __type_max(off_t) - size)
820 1.76 riastrad return EINVAL;
821 1.45 thorpej start = size + fl->l_start;
822 1.45 thorpej break;
823 1.45 thorpej
824 1.45 thorpej default:
825 1.45 thorpej return EINVAL;
826 1.1 ws }
827 1.72 dsl
828 1.72 dsl if (fl->l_len == 0)
829 1.72 dsl end = -1;
830 1.72 dsl else {
831 1.76 riastrad if (fl->l_len >= 0) {
832 1.77 riastrad if (start >= 0 &&
833 1.77 riastrad fl->l_len - 1 > __type_max(off_t) - start)
834 1.76 riastrad return EINVAL;
835 1.78 riastrad end = start + (fl->l_len - 1);
836 1.76 riastrad } else {
837 1.72 dsl /* lockf() allows -ve lengths */
838 1.76 riastrad if (start < 0)
839 1.76 riastrad return EINVAL;
840 1.72 dsl end = start - 1;
841 1.72 dsl start += fl->l_len;
842 1.72 dsl }
843 1.72 dsl }
844 1.45 thorpej if (start < 0)
845 1.45 thorpej return EINVAL;
846 1.1 ws
847 1.45 thorpej /*
848 1.61 ad * Allocate locks before acquiring the interlock. We need two
849 1.55 ad * locks in the worst case.
850 1.45 thorpej */
851 1.45 thorpej switch (ap->a_op) {
852 1.45 thorpej case F_SETLK:
853 1.45 thorpej case F_UNLCK:
854 1.1 ws /*
855 1.55 ad * XXX For F_UNLCK case, we can re-use the lock.
856 1.1 ws */
857 1.46 christos if ((ap->a_flags & F_FLOCK) == 0) {
858 1.45 thorpej /*
859 1.55 ad * Byte-range lock might need one more lock.
860 1.45 thorpej */
861 1.71 yamt sparelock = lf_alloc(0);
862 1.45 thorpej if (sparelock == NULL) {
863 1.45 thorpej error = ENOMEM;
864 1.45 thorpej goto quit;
865 1.45 thorpej }
866 1.45 thorpej break;
867 1.1 ws }
868 1.45 thorpej /* FALLTHROUGH */
869 1.45 thorpej
870 1.45 thorpej case F_GETLK:
871 1.45 thorpej sparelock = NULL;
872 1.45 thorpej break;
873 1.45 thorpej
874 1.45 thorpej default:
875 1.45 thorpej return EINVAL;
876 1.45 thorpej }
877 1.45 thorpej
878 1.71 yamt switch (ap->a_op) {
879 1.71 yamt case F_SETLK:
880 1.71 yamt lock = lf_alloc(1);
881 1.71 yamt break;
882 1.71 yamt case F_UNLCK:
883 1.71 yamt if (start == 0 || end == -1) {
884 1.71 yamt /* never split */
885 1.71 yamt lock = lf_alloc(0);
886 1.71 yamt } else {
887 1.71 yamt /* might split */
888 1.71 yamt lock = lf_alloc(2);
889 1.71 yamt }
890 1.71 yamt break;
891 1.71 yamt case F_GETLK:
892 1.71 yamt lock = lf_alloc(0);
893 1.71 yamt break;
894 1.71 yamt }
895 1.45 thorpej if (lock == NULL) {
896 1.45 thorpej error = ENOMEM;
897 1.45 thorpej goto quit;
898 1.1 ws }
899 1.1 ws
900 1.61 ad mutex_enter(interlock);
901 1.1 ws
902 1.1 ws /*
903 1.45 thorpej * Avoid the common case of unlocking when inode has no locks.
904 1.1 ws */
905 1.45 thorpej if (*head == (struct lockf *)0) {
906 1.45 thorpej if (ap->a_op != F_SETLK) {
907 1.45 thorpej fl->l_type = F_UNLCK;
908 1.45 thorpej error = 0;
909 1.45 thorpej goto quit_unlock;
910 1.45 thorpej }
911 1.1 ws }
912 1.45 thorpej
913 1.1 ws /*
914 1.45 thorpej * Create the lockf structure.
915 1.45 thorpej */
916 1.45 thorpej lock->lf_start = start;
917 1.45 thorpej lock->lf_end = end;
918 1.45 thorpej lock->lf_head = head;
919 1.45 thorpej lock->lf_type = fl->l_type;
920 1.45 thorpej lock->lf_next = (struct lockf *)0;
921 1.45 thorpej TAILQ_INIT(&lock->lf_blkhd);
922 1.45 thorpej lock->lf_flags = ap->a_flags;
923 1.45 thorpej if (lock->lf_flags & F_POSIX) {
924 1.45 thorpej KASSERT(curproc == (struct proc *)ap->a_id);
925 1.45 thorpej }
926 1.72 dsl lock->lf_id = ap->a_id;
927 1.45 thorpej
928 1.1 ws /*
929 1.45 thorpej * Do the requested operation.
930 1.1 ws */
931 1.45 thorpej switch (ap->a_op) {
932 1.1 ws
933 1.45 thorpej case F_SETLK:
934 1.45 thorpej error = lf_setlock(lock, &sparelock, interlock);
935 1.45 thorpej lock = NULL; /* lf_setlock freed it */
936 1.45 thorpej break;
937 1.1 ws
938 1.45 thorpej case F_UNLCK:
939 1.45 thorpej error = lf_clearlock(lock, &sparelock);
940 1.45 thorpej break;
941 1.1 ws
942 1.45 thorpej case F_GETLK:
943 1.45 thorpej error = lf_getlock(lock, fl);
944 1.45 thorpej break;
945 1.37 perry
946 1.45 thorpej default:
947 1.45 thorpej break;
948 1.45 thorpej /* NOTREACHED */
949 1.45 thorpej }
950 1.1 ws
951 1.45 thorpej quit_unlock:
952 1.61 ad mutex_exit(interlock);
953 1.45 thorpej quit:
954 1.45 thorpej if (lock)
955 1.45 thorpej lf_free(lock);
956 1.45 thorpej if (sparelock)
957 1.45 thorpej lf_free(sparelock);
958 1.1 ws
959 1.45 thorpej return error;
960 1.1 ws }
961 1.80 ad
962 1.80 ad /*
963 1.82 riastrad * Initialize subsystem.
964 1.82 riastrad *
965 1.82 riastrad * XXX We use a global lock. This could be the vnode interlock, but
966 1.82 riastrad * the deadlock detection code may need to inspect locks belonging to
967 1.82 riastrad * other files.
968 1.80 ad */
969 1.80 ad void
970 1.80 ad lf_init(void)
971 1.80 ad {
972 1.80 ad
973 1.81 ad mutex_init(&lockf_lock, MUTEX_DEFAULT, IPL_NONE);
974 1.80 ad }
975