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