![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hfs_lockf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / hfs|
Return to hfs_lockf.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / hfs |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* (c) 1997-1998 Apple Computer, Inc. All Rights Reserved */
26: /*
27: * Copyright (c) 1982, 1986, 1989, 1993
28: * The Regents of the University of California. All rights reserved.
29: *
30: * This code is derived from software contributed to Berkeley by
31: * Scooter Morris at Genentech Inc.
32: *
33: * Redistribution and use in source and binary forms, with or without
34: * modification, are permitted provided that the following conditions
35: * are met:
36: * 1. Redistributions of source code must retain the above copyright
37: * notice, this list of conditions and the following disclaimer.
38: * 2. Redistributions in binary form must reproduce the above copyright
39: * notice, this list of conditions and the following disclaimer in the
40: * documentation and/or other materials provided with the distribution.
41: * 3. All advertising materials mentioning features or use of this software
42: * must display the following acknowledgement:
43: * This product includes software developed by the University of
44: * California, Berkeley and its contributors.
45: * 4. Neither the name of the University nor the names of its contributors
46: * may be used to endorse or promote products derived from this software
47: * without specific prior written permission.
48: *
49: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59: * SUCH DAMAGE.
60: *
61: * @(#)hfs_lockf.c 1.0
62: * derived from @(#)ufs_lockf.c 8.4 (Berkeley) 10/26/94
63: */
64:
65: #include "hfs.h"
66: #include "hfs_lockf.h"
67:
68: #include <sys/param.h>
69: #include <sys/systm.h>
70: //#include <sys/kernel.h>
71: #include <sys/file.h>
72: //#include <sys/proc.h>
73: //#include <sys/vnode.h>
74: //#include <sys/malloc.h>
75: #include <sys/fcntl.h>
76: /*
77: * This variable controls the maximum number of processes that will
78: * be checked in doing deadlock detection.
79: */
80: int hfsmaxlockdepth = MAXDEPTH;
81:
82: #ifdef LOCKF_DEBUG
83: #include <vm/vm.h>
84: #include <sys/sysctl.h>
85: int lockf_debug = 0;
86: struct ctldebug debug4 = { "lockf_debug", &lockf_debug };
87: #endif
88:
89: #define NOLOCKF (struct hfslockf *)0
90: #define SELF 0x1
91: #define OTHERS 0x2
92:
93: /*
94: * Set a byte-range lock.
95: */
96: int
97: hfs_setlock(lock)
98: register struct hfslockf *lock;
99: {
100: register struct hfslockf *block;
101: struct hfsnode *hp = lock->lf_hfsnode;
102: struct hfslockf **prev, *overlap, *ltmp;
103: static char lockstr[] = "hfslockf";
104: int ovcase, priority, needtolink, error;
105:
106: #ifdef LOCKF_DEBUG
107: if (lockf_debug & 1)
108: hfs_lprint("hfs_setlock", lock);
109: #endif /* LOCKF_DEBUG */
110:
111: /*
112: * Set the priority
113: */
114: priority = PLOCK;
115: if (lock->lf_type == F_WRLCK)
116: priority += 4;
117: priority |= PCATCH;
118: /*
119: * Scan lock list for this file looking for locks that would block us.
120: */
121: while ((block = hfs_getblock(lock))) {
122: /*
123: * Free the structure and return if nonblocking.
124: */
125: if ((lock->lf_flags & F_WAIT) == 0) {
126: FREE(lock, M_LOCKF);
127: return (EAGAIN);
128: }
129: /*
130: * We are blocked. Since flock style locks cover
131: * the whole file, there is no chance for deadlock.
132: * For byte-range locks we must check for deadlock.
133: *
134: * Deadlock detection is done by looking through the
135: * wait channels to see if there are any cycles that
136: * involve us. MAXDEPTH is set just to make sure we
137: * do not go off into neverland.
138: */
139: if ((lock->lf_flags & F_POSIX) &&
140: (block->lf_flags & F_POSIX)) {
141: register struct proc *wproc;
142: register struct hfslockf *waitblock;
143: int i = 0;
144:
145: /* The block is waiting on something */
146: wproc = (struct proc *)block->lf_id;
147: while (wproc->p_wchan &&
148: (wproc->p_wmesg == lockstr) &&
149: (i++ < hfsmaxlockdepth)) {
150: waitblock = (struct hfslockf *)wproc->p_wchan;
151: /* Get the owner of the blocking lock */
152: waitblock = waitblock->lf_next;
153: if ((waitblock->lf_flags & F_POSIX) == 0)
154: break;
155: wproc = (struct proc *)waitblock->lf_id;
156: if (wproc == (struct proc *)lock->lf_id) {
157: _FREE(lock, M_LOCKF);
158: return (EDEADLK);
159: }
160: }
161: }
162: /*
163: * For flock type locks, we must first remove
164: * any shared locks that we hold before we sleep
165: * waiting for an exclusive lock.
166: */
167: if ((lock->lf_flags & F_FLOCK) &&
168: lock->lf_type == F_WRLCK) {
169: lock->lf_type = F_UNLCK;
170: (void) hfs_clearlock(lock);
171: lock->lf_type = F_WRLCK;
172: }
173: /*
174: * Add our lock to the blocked list and sleep until we're free.
175: * Remember who blocked us (for deadlock detection).
176: */
177: lock->lf_next = block;
178: TAILQ_INSERT_TAIL(&block->lf_blkhd, lock, lf_block);
179: #ifdef LOCKF_DEBUG
180: if (lockf_debug & 1) {
181: hfs_lprint("hfs_setlock: blocking on", block);
182: hfs_lprintlist("hfs_setlock", block);
183: }
184: #endif /* LOCKF_DEBUG */
185: if ((error = tsleep((caddr_t)lock, priority, lockstr, 0))) {
186: /*
187: * We may have been awakened by a signal (in
188: * which case we must remove ourselves from the
189: * blocked list) and/or by another process
190: * releasing a lock (in which case we have already
191: * been removed from the blocked list and our
192: * lf_next field set to NOLOCKF).
193: */
194: if (lock->lf_next)
195: TAILQ_REMOVE(&lock->lf_next->lf_blkhd, lock,
196: lf_block);
197: _FREE(lock, M_LOCKF);
198: return (error);
199: }
200: }
201: /*
202: * No blocks!! Add the lock. Note that we will
203: * downgrade or upgrade any overlapping locks this
204: * process already owns.
205: *
206: * Skip over locks owned by other processes.
207: * Handle any locks that overlap and are owned by ourselves.
208: */
209: prev = &hp->h_lockf;
210: block = hp->h_lockf;
211: needtolink = 1;
212: for (;;) {
213: if ((ovcase = hfs_findoverlap(block, lock, SELF, &prev, &overlap)))
214: block = overlap->lf_next;
215: /*
216: * Six cases:
217: * 0) no overlap
218: * 1) overlap == lock
219: * 2) overlap contains lock
220: * 3) lock contains overlap
221: * 4) overlap starts before lock
222: * 5) overlap ends after lock
223: */
224: switch (ovcase) {
225: case 0: /* no overlap */
226: if (needtolink) {
227: *prev = lock;
228: lock->lf_next = overlap;
229: }
230: break;
231:
232: case 1: /* overlap == lock */
233: /*
234: * If downgrading lock, others may be
235: * able to acquire it.
236: */
237: if (lock->lf_type == F_RDLCK &&
238: overlap->lf_type == F_WRLCK)
239: hfs_wakelock(overlap);
240: overlap->lf_type = lock->lf_type;
241: FREE(lock, M_LOCKF);
242: lock = overlap; /* for debug output below */
243: break;
244:
245: case 2: /* overlap contains lock */
246: /*
247: * Check for common starting point and different types.
248: */
249: if (overlap->lf_type == lock->lf_type) {
250: _FREE(lock, M_LOCKF);
251: lock = overlap; /* for debug output below */
252: break;
253: }
254: if (overlap->lf_start == lock->lf_start) {
255: *prev = lock;
256: lock->lf_next = overlap;
257: overlap->lf_start = lock->lf_end + 1;
258: } else
259: hfs_split(overlap, lock);
260: hfs_wakelock(overlap);
261: break;
262:
263: case 3: /* lock contains overlap */
264: /*
265: * If downgrading lock, others may be able to
266: * acquire it, otherwise take the list.
267: */
268: if (lock->lf_type == F_RDLCK &&
269: overlap->lf_type == F_WRLCK) {
270: hfs_wakelock(overlap);
271: } else {
272: while ((ltmp = overlap->lf_blkhd.tqh_first)) {
273: TAILQ_REMOVE(&overlap->lf_blkhd, ltmp,
274: lf_block);
275: TAILQ_INSERT_TAIL(&lock->lf_blkhd,
276: ltmp, lf_block);
277: }
278: }
279: /*
280: * Add the new lock if necessary and delete the overlap.
281: */
282: if (needtolink) {
283: *prev = lock;
284: lock->lf_next = overlap->lf_next;
285: prev = &lock->lf_next;
286: needtolink = 0;
287: } else
288: *prev = overlap->lf_next;
289: _FREE(overlap, M_LOCKF);
290: continue;
291:
292: case 4: /* overlap starts before lock */
293: /*
294: * Add lock after overlap on the list.
295: */
296: lock->lf_next = overlap->lf_next;
297: overlap->lf_next = lock;
298: overlap->lf_end = lock->lf_start - 1;
299: prev = &lock->lf_next;
300: hfs_wakelock(overlap);
301: needtolink = 0;
302: continue;
303:
304: case 5: /* overlap ends after lock */
305: /*
306: * Add the new lock before overlap.
307: */
308: if (needtolink) {
309: *prev = lock;
310: lock->lf_next = overlap;
311: }
312: overlap->lf_start = lock->lf_end + 1;
313: hfs_wakelock(overlap);
314: break;
315: }
316: break;
317: }
318: #ifdef LOCKF_DEBUG
319: if (lockf_debug & 1) {
320: hfs_lprint("hfs_setlock: got the lock", lock);
321: hfs_lprintlist("hfs_setlock", lock);
322: }
323: #endif /* LOCKF_DEBUG */
324: return (0);
325: }
326:
327: /*
328: * Remove a byte-range lock on an hfsnode.
329: *
330: * Generally, find the lock (or an overlap to that lock)
331: * and remove it (or shrink it), then wakeup anyone we can.
332: */
333: int
334: hfs_clearlock(unlock)
335: register struct hfslockf *unlock;
336: {
337: struct hfsnode *hp = unlock->lf_hfsnode;
338: register struct hfslockf *lf = hp->h_lockf;
339: struct hfslockf *overlap, **prev;
340: int ovcase;
341:
342: if (lf == NOLOCKF)
343: return (0);
344: #ifdef LOCKF_DEBUG
345: if (unlock->lf_type != F_UNLCK)
346: panic("hfs_clearlock: bad type");
347: if (lockf_debug & 1)
348: hfs_lprint("hfs_clearlock", unlock);
349: #endif /* LOCKF_DEBUG */
350: prev = &hp->h_lockf;
351: while ((ovcase = hfs_findoverlap(lf, unlock, SELF, &prev, &overlap))) {
352: /*
353: * Wakeup the list of locks to be retried.
354: */
355: hfs_wakelock(overlap);
356:
357: switch (ovcase) {
358:
359: case 1: /* overlap == lock */
360: *prev = overlap->lf_next;
361: FREE(overlap, M_LOCKF);
362: break;
363:
364: case 2: /* overlap contains lock: split it */
365: if (overlap->lf_start == unlock->lf_start) {
366: overlap->lf_start = unlock->lf_end + 1;
367: break;
368: }
369: hfs_split(overlap, unlock);
370: overlap->lf_next = unlock->lf_next;
371: break;
372:
373: case 3: /* lock contains overlap */
374: *prev = overlap->lf_next;
375: lf = overlap->lf_next;
376: _FREE(overlap, M_LOCKF);
377: continue;
378:
379: case 4: /* overlap starts before lock */
380: overlap->lf_end = unlock->lf_start - 1;
381: prev = &overlap->lf_next;
382: lf = overlap->lf_next;
383: continue;
384:
385: case 5: /* overlap ends after lock */
386: overlap->lf_start = unlock->lf_end + 1;
387: break;
388: }
389: break;
390: }
391: #ifdef LOCKF_DEBUG
392: if (lockf_debug & 1)
393: hfs_lprintlist("hfs_clearlock", unlock);
394: #endif /* LOCKF_DEBUG */
395: return (0);
396: }
397:
398: /*
399: * Check whether there is a blocking lock,
400: * and if so return its process identifier.
401: */
402: int
403: hfs_getlock(lock, fl)
404: register struct hfslockf *lock;
405: register struct flock *fl;
406: {
407: register struct hfslockf *block;
408:
409: #ifdef LOCKF_DEBUG
410: if (lockf_debug & 1)
411: hfs_lprint("hfs_getlock", lock);
412: #endif /* LOCKF_DEBUG */
413:
414: if ((block = hfs_getblock(lock))) {
415: fl->l_type = block->lf_type;
416: fl->l_whence = SEEK_SET;
417: fl->l_start = block->lf_start;
418: if (block->lf_end == -1)
419: fl->l_len = 0;
420: else
421: fl->l_len = block->lf_end - block->lf_start + 1;
422: if (block->lf_flags & F_POSIX)
423: fl->l_pid = ((struct proc *)(block->lf_id))->p_pid;
424: else
425: fl->l_pid = -1;
426: } else {
427: fl->l_type = F_UNLCK;
428: }
429: return (0);
430: }
431:
432: /*
433: * Walk the list of locks for an hfsnode and
434: * return the first blocking lock.
435: */
436: struct hfslockf *
437: hfs_getblock(lock)
438: register struct hfslockf *lock;
439: {
440: struct hfslockf **prev, *overlap, *lf = lock->lf_hfsnode->h_lockf;
441: int ovcase;
442:
443: prev = &lock->lf_hfsnode->h_lockf;
444: while ((ovcase = hfs_findoverlap(lf, lock, OTHERS, &prev, &overlap))) {
445: /*
446: * We've found an overlap, see if it blocks us
447: */
448: if ((lock->lf_type == F_WRLCK || overlap->lf_type == F_WRLCK))
449: return (overlap);
450: /*
451: * Nope, point to the next one on the list and
452: * see if it blocks us
453: */
454: lf = overlap->lf_next;
455: }
456: return (NOLOCKF);
457: }
458:
459: /*
460: * Walk the list of locks for an hfsnode to
461: * find an overlapping lock (if any).
462: *
463: * NOTE: this returns only the FIRST overlapping lock. There
464: * may be more than one.
465: */
466: int
467: hfs_findoverlap(lf, lock, type, prev, overlap)
468: register struct hfslockf *lf;
469: struct hfslockf *lock;
470: int type;
471: struct hfslockf ***prev;
472: struct hfslockf **overlap;
473: {
474: off_t start, end;
475:
476: *overlap = lf;
477: if (lf == NOLOCKF)
478: return (0);
479: #ifdef LOCKF_DEBUG
480: if (lockf_debug & 2)
481: hfs_lprint("hfs_findoverlap: looking for overlap in", lock);
482: #endif /* LOCKF_DEBUG */
483: start = lock->lf_start;
484: end = lock->lf_end;
485: while (lf != NOLOCKF) {
486: if (((type & SELF) && lf->lf_id != lock->lf_id) ||
487: ((type & OTHERS) && lf->lf_id == lock->lf_id)) {
488: *prev = &lf->lf_next;
489: *overlap = lf = lf->lf_next;
490: continue;
491: }
492: #ifdef LOCKF_DEBUG
493: if (lockf_debug & 2)
494: hfs_lprint("\tchecking", lf);
495: #endif /* LOCKF_DEBUG */
496: /*
497: * OK, check for overlap
498: *
499: * Six cases:
500: * 0) no overlap
501: * 1) overlap == lock
502: * 2) overlap contains lock
503: * 3) lock contains overlap
504: * 4) overlap starts before lock
505: * 5) overlap ends after lock
506: */
507: if ((lf->lf_end != -1 && start > lf->lf_end) ||
508: (end != -1 && lf->lf_start > end)) {
509: /* Case 0 */
510: #ifdef LOCKF_DEBUG
511: if (lockf_debug & 2)
512: printf("no overlap\n");
513: #endif /* LOCKF_DEBUG */
514: if ((type & SELF) && end != -1 && lf->lf_start > end)
515: return (0);
516: *prev = &lf->lf_next;
517: *overlap = lf = lf->lf_next;
518: continue;
519: }
520: if ((lf->lf_start == start) && (lf->lf_end == end)) {
521: /* Case 1 */
522: #ifdef LOCKF_DEBUG
523: if (lockf_debug & 2)
524: printf("overlap == lock\n");
525: #endif /* LOCKF_DEBUG */
526: return (1);
527: }
528: if ((lf->lf_start <= start) &&
529: (end != -1) &&
530: ((lf->lf_end >= end) || (lf->lf_end == -1))) {
531: /* Case 2 */
532: #ifdef LOCKF_DEBUG
533: if (lockf_debug & 2)
534: printf("overlap contains lock\n");
535: #endif /* LOCKF_DEBUG */
536: return (2);
537: }
538: if (start <= lf->lf_start &&
539: (end == -1 ||
540: (lf->lf_end != -1 && end >= lf->lf_end))) {
541: /* Case 3 */
542: #ifdef LOCKF_DEBUG
543: if (lockf_debug & 2)
544: printf("lock contains overlap\n");
545: #endif /* LOCKF_DEBUG */
546: return (3);
547: }
548: if ((lf->lf_start < start) &&
549: ((lf->lf_end >= start) || (lf->lf_end == -1))) {
550: /* Case 4 */
551: #ifdef LOCKF_DEBUG
552: if (lockf_debug & 2)
553: printf("overlap starts before lock\n");
554: #endif /* LOCKF_DEBUG */
555: return (4);
556: }
557: if ((lf->lf_start > start) &&
558: (end != -1) &&
559: ((lf->lf_end > end) || (lf->lf_end == -1))) {
560: /* Case 5 */
561: #ifdef LOCKF_DEBUG
562: if (lockf_debug & 2)
563: printf("overlap ends after lock\n");
564: #endif /* LOCKF_DEBUG */
565: return (5);
566: }
567: panic("hfs_findoverlap: default");
568: }
569: return (0);
570: }
571:
572: /*
573: * Split a lock and a contained region into
574: * two or three locks as necessary.
575: */
576: void
577: hfs_split(lock1, lock2)
578: register struct hfslockf *lock1;
579: register struct hfslockf *lock2;
580: {
581: register struct hfslockf *splitlock;
582:
583: #ifdef LOCKF_DEBUG
584: if (lockf_debug & 2) {
585: hfs_lprint("hfs_split", lock1);
586: hfs_lprint("splitting from", lock2);
587: }
588: #endif /* LOCKF_DEBUG */
589: /*
590: * Check to see if spliting into only two pieces.
591: */
592: if (lock1->lf_start == lock2->lf_start) {
593: lock1->lf_start = lock2->lf_end + 1;
594: lock2->lf_next = lock1;
595: return;
596: }
597: if (lock1->lf_end == lock2->lf_end) {
598: lock1->lf_end = lock2->lf_start - 1;
599: lock2->lf_next = lock1->lf_next;
600: lock1->lf_next = lock2;
601: return;
602: }
603: /*
604: * Make a new lock consisting of the last part of
605: * the encompassing lock
606: */
607: MALLOC(splitlock, struct hfslockf *, sizeof *splitlock, M_LOCKF, M_WAITOK);
608: bcopy((caddr_t)lock1, (caddr_t)splitlock, sizeof *splitlock);
609: splitlock->lf_start = lock2->lf_end + 1;
610: TAILQ_INIT(&splitlock->lf_blkhd);
611: lock1->lf_end = lock2->lf_start - 1;
612: /*
613: * OK, now link it in
614: */
615: splitlock->lf_next = lock1->lf_next;
616: lock2->lf_next = splitlock;
617: lock1->lf_next = lock2;
618: }
619:
620: /*
621: * Wakeup a blocklist
622: */
623: void
624: hfs_wakelock(listhead)
625: struct hfslockf *listhead;
626: {
627: register struct hfslockf *wakelock;
628:
629: while ((wakelock = listhead->lf_blkhd.tqh_first)) {
630: TAILQ_REMOVE(&listhead->lf_blkhd, wakelock, lf_block);
631: wakelock->lf_next = NOLOCKF;
632: #ifdef LOCKF_DEBUG
633: if (lockf_debug & 2)
634: hfs_lprint("hfs_wakelock: awakening", wakelock);
635: #endif /* LOCKF_DEBUG */
636: wakeup((caddr_t)wakelock);
637: }
638: }
639:
640: #ifdef LOCKF_DEBUG
641: /*
642: * Print out a lock.
643: */
644: hfs_lprint(tag, lock)
645: char *tag;
646: register struct hfslockf *lock;
647: {
648:
649: printf("%s: lock 0x%lx for ", tag, lock);
650: if (lock->lf_flags & F_POSIX)
651: printf("proc %d", ((struct proc *)(lock->lf_id))->p_pid);
652: else
653: printf("id 0x%x", lock->lf_id);
654: printf(" in ino %d on dev <%d, %d>, %s, start %d, end %d",
655: lock->lf_hfsnode->i_number,
656: major(lock->lf_hfsnode->h_dev),
657: minor(lock->lf_hfsnode->h_dev),
658: lock->lf_type == F_RDLCK ? "shared" :
659: lock->lf_type == F_WRLCK ? "exclusive" :
660: lock->lf_type == F_UNLCK ? "unlock" :
661: "unknown", lock->lf_start, lock->lf_end);
662: if (lock->lf_blkhd.tqh_first)
663: printf(" block 0x%x\n", lock->lf_blkhd.tqh_first);
664: else
665: printf("\n");
666: }
667:
668: hfs_lprintlist(tag, lock)
669: char *tag;
670: struct hfslockf *lock;
671: {
672: register struct hfslockf *lf, *blk;
673:
674: printf("%s: Lock list for ino %d on dev <%d, %d>:\n",
675: tag, lock->lf_hfsnode->i_number,
676: major(lock->lf_hfsnode->h_dev),
677: minor(lock->lf_hfsnode->h_dev));
678: for (lf = lock->lf_hfsnode->h_lockf; lf; lf = lf->lf_next) {
679: printf("\tlock 0x%lx for ", lf);
680: if (lf->lf_flags & F_POSIX)
681: printf("proc %d", ((struct proc *)(lf->lf_id))->p_pid);
682: else
683: printf("id 0x%x", lf->lf_id);
684: printf(", %s, start %d, end %d",
685: lf->lf_type == F_RDLCK ? "shared" :
686: lf->lf_type == F_WRLCK ? "exclusive" :
687: lf->lf_type == F_UNLCK ? "unlock" :
688: "unknown", lf->lf_start, lf->lf_end);
689: for (blk = lf->lf_blkhd.tqh_first; blk;
690: blk = blk->lf_block.tqe_next) {
691: printf("\n\t\tlock request 0x%lx for ", blk);
692: if (blk->lf_flags & F_POSIX)
693: printf("proc %d",
694: ((struct proc *)(blk->lf_id))->p_pid);
695: else
696: printf("id 0x%x", blk->lf_id);
697: printf(", %s, start %d, end %d",
698: blk->lf_type == F_RDLCK ? "shared" :
699: blk->lf_type == F_WRLCK ? "exclusive" :
700: blk->lf_type == F_UNLCK ? "unlock" :
701: "unknown", blk->lf_start, blk->lf_end);
702: if (blk->lf_blkhd.tqh_first)
703: panic("hfs_lprintlist: bad list");
704: }
705: printf("\n");
706: }
707: }
708: #endif /* LOCKF_DEBUG */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.