192dc7331SDavid Greenman /* 292dc7331SDavid Greenman * Copyright (c) 1982, 1986, 1989, 1993 392dc7331SDavid Greenman * The Regents of the University of California. All rights reserved. 492dc7331SDavid Greenman * 592dc7331SDavid Greenman * This code is derived from software contributed to Berkeley by 692dc7331SDavid Greenman * Scooter Morris at Genentech Inc. 792dc7331SDavid Greenman * 892dc7331SDavid Greenman * Redistribution and use in source and binary forms, with or without 992dc7331SDavid Greenman * modification, are permitted provided that the following conditions 1092dc7331SDavid Greenman * are met: 1192dc7331SDavid Greenman * 1. Redistributions of source code must retain the above copyright 1292dc7331SDavid Greenman * notice, this list of conditions and the following disclaimer. 1392dc7331SDavid Greenman * 2. Redistributions in binary form must reproduce the above copyright 1492dc7331SDavid Greenman * notice, this list of conditions and the following disclaimer in the 1592dc7331SDavid Greenman * documentation and/or other materials provided with the distribution. 1692dc7331SDavid Greenman * 3. All advertising materials mentioning features or use of this software 1792dc7331SDavid Greenman * must display the following acknowledgement: 1892dc7331SDavid Greenman * This product includes software developed by the University of 1992dc7331SDavid Greenman * California, Berkeley and its contributors. 2092dc7331SDavid Greenman * 4. Neither the name of the University nor the names of its contributors 2192dc7331SDavid Greenman * may be used to endorse or promote products derived from this software 2292dc7331SDavid Greenman * without specific prior written permission. 2392dc7331SDavid Greenman * 2492dc7331SDavid Greenman * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 2592dc7331SDavid Greenman * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 2692dc7331SDavid Greenman * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 2792dc7331SDavid Greenman * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 2892dc7331SDavid Greenman * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 2992dc7331SDavid Greenman * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 3092dc7331SDavid Greenman * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 3192dc7331SDavid Greenman * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 3292dc7331SDavid Greenman * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 3392dc7331SDavid Greenman * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 3492dc7331SDavid Greenman * SUCH DAMAGE. 3592dc7331SDavid Greenman * 3692dc7331SDavid Greenman * @(#)ufs_lockf.c 8.3 (Berkeley) 1/6/94 37c3aac50fSPeter Wemm * $FreeBSD$ 3892dc7331SDavid Greenman */ 3992dc7331SDavid Greenman 403f2076daSEivind Eklund #include "opt_debug_lockf.h" 413f2076daSEivind Eklund 4292dc7331SDavid Greenman #include <sys/param.h> 4392dc7331SDavid Greenman #include <sys/systm.h> 441c5bb3eaSPeter Wemm #include <sys/kernel.h> 451cd52ec3SBruce Evans #include <sys/lock.h> 46fb919e4dSMark Murray #include <sys/mutex.h> 4792dc7331SDavid Greenman #include <sys/proc.h> 48b71fec07SBruce Evans #include <sys/unistd.h> 4992dc7331SDavid Greenman #include <sys/vnode.h> 5092dc7331SDavid Greenman #include <sys/malloc.h> 5192dc7331SDavid Greenman #include <sys/fcntl.h> 5292dc7331SDavid Greenman #include <sys/lockf.h> 5392dc7331SDavid Greenman 54b44af710SAndrey A. Chernov #include <machine/limits.h> 55b44af710SAndrey A. Chernov 5692dc7331SDavid Greenman /* 5792dc7331SDavid Greenman * This variable controls the maximum number of processes that will 5892dc7331SDavid Greenman * be checked in doing deadlock detection. 5992dc7331SDavid Greenman */ 60996c772fSJohn Dyson static int maxlockdepth = MAXDEPTH; 6192dc7331SDavid Greenman 6292dc7331SDavid Greenman #ifdef LOCKF_DEBUG 63a8687b6dSBruce Evans #include <sys/kernel.h> 64996c772fSJohn Dyson #include <sys/sysctl.h> 65a8687b6dSBruce Evans 66a8687b6dSBruce Evans #include <ufs/ufs/quota.h> 67a8687b6dSBruce Evans #include <ufs/ufs/inode.h> 68a8687b6dSBruce Evans 6955166637SPoul-Henning Kamp 707f725eacSBruce Evans static int lockf_debug = 0; 717f725eacSBruce Evans SYSCTL_INT(_debug, OID_AUTO, lockf_debug, CTLFLAG_RW, &lockf_debug, 0, ""); 7292dc7331SDavid Greenman #endif 7392dc7331SDavid Greenman 74603c8667SAlfred Perlstein MALLOC_DEFINE(M_LOCKF, "lockf", "Byte-range locking structures"); 7555166637SPoul-Henning Kamp 7692dc7331SDavid Greenman #define NOLOCKF (struct lockf *)0 7792dc7331SDavid Greenman #define SELF 0x1 7892dc7331SDavid Greenman #define OTHERS 0x2 7987b6de2bSPoul-Henning Kamp static int lf_clearlock __P((struct lockf *)); 8087b6de2bSPoul-Henning Kamp static int lf_findoverlap __P((struct lockf *, 8187b6de2bSPoul-Henning Kamp struct lockf *, int, struct lockf ***, struct lockf **)); 8287b6de2bSPoul-Henning Kamp static struct lockf * 8387b6de2bSPoul-Henning Kamp lf_getblock __P((struct lockf *)); 8487b6de2bSPoul-Henning Kamp static int lf_getlock __P((struct lockf *, struct flock *)); 8587b6de2bSPoul-Henning Kamp static int lf_setlock __P((struct lockf *)); 8687b6de2bSPoul-Henning Kamp static void lf_split __P((struct lockf *, struct lockf *)); 8787b6de2bSPoul-Henning Kamp static void lf_wakelock __P((struct lockf *)); 8892dc7331SDavid Greenman 8992dc7331SDavid Greenman /* 9092dc7331SDavid Greenman * Advisory record locking support 9192dc7331SDavid Greenman */ 9292dc7331SDavid Greenman int 9392dc7331SDavid Greenman lf_advlock(ap, head, size) 9492dc7331SDavid Greenman struct vop_advlock_args /* { 9592dc7331SDavid Greenman struct vnode *a_vp; 9692dc7331SDavid Greenman caddr_t a_id; 9792dc7331SDavid Greenman int a_op; 9892dc7331SDavid Greenman struct flock *a_fl; 9992dc7331SDavid Greenman int a_flags; 10092dc7331SDavid Greenman } */ *ap; 10192dc7331SDavid Greenman struct lockf **head; 10292dc7331SDavid Greenman u_quad_t size; 10392dc7331SDavid Greenman { 10492dc7331SDavid Greenman register struct flock *fl = ap->a_fl; 10592dc7331SDavid Greenman register struct lockf *lock; 10692dc7331SDavid Greenman off_t start, end; 10792dc7331SDavid Greenman int error; 10892dc7331SDavid Greenman 10992dc7331SDavid Greenman /* 11092dc7331SDavid Greenman * Convert the flock structure into a start and end. 11192dc7331SDavid Greenman */ 11292dc7331SDavid Greenman switch (fl->l_whence) { 11392dc7331SDavid Greenman 11492dc7331SDavid Greenman case SEEK_SET: 11592dc7331SDavid Greenman case SEEK_CUR: 11692dc7331SDavid Greenman /* 11792dc7331SDavid Greenman * Caller is responsible for adding any necessary offset 11892dc7331SDavid Greenman * when SEEK_CUR is used. 11992dc7331SDavid Greenman */ 12092dc7331SDavid Greenman start = fl->l_start; 12192dc7331SDavid Greenman break; 12292dc7331SDavid Greenman 12392dc7331SDavid Greenman case SEEK_END: 1246d24c65dSAndrey A. Chernov /* 'size' is always >= 0 */ 12569cc1d0dSAndrey A. Chernov if (fl->l_start > 0 && size > OFF_MAX - fl->l_start) 12669cc1d0dSAndrey A. Chernov return (EOVERFLOW); 12792dc7331SDavid Greenman start = size + fl->l_start; 12892dc7331SDavid Greenman break; 12992dc7331SDavid Greenman 13092dc7331SDavid Greenman default: 13192dc7331SDavid Greenman return (EINVAL); 13292dc7331SDavid Greenman } 13392dc7331SDavid Greenman if (start < 0) 13492dc7331SDavid Greenman return (EINVAL); 135f510e1c2SAndrey A. Chernov if (fl->l_len < 0) { 13662be011eSAndrey A. Chernov if (start == 0) 137f510e1c2SAndrey A. Chernov return (EINVAL); 138f510e1c2SAndrey A. Chernov end = start - 1; 13962be011eSAndrey A. Chernov start += fl->l_len; 14062be011eSAndrey A. Chernov if (start < 0) 14162be011eSAndrey A. Chernov return (EINVAL); 142f510e1c2SAndrey A. Chernov } else if (fl->l_len == 0) 14392dc7331SDavid Greenman end = -1; 144a88bd8aaSBruce Evans else { 14569cc1d0dSAndrey A. Chernov off_t oadd = fl->l_len - 1; 14669cc1d0dSAndrey A. Chernov 1476d24c65dSAndrey A. Chernov /* 'oadd' and 'start' are >= 0 */ 14869cc1d0dSAndrey A. Chernov if (oadd > OFF_MAX - start) 14969cc1d0dSAndrey A. Chernov return (EOVERFLOW); 15069cc1d0dSAndrey A. Chernov end = start + oadd; 151a88bd8aaSBruce Evans if (end < start) 152a88bd8aaSBruce Evans return (EINVAL); 153a88bd8aaSBruce Evans } 154a88bd8aaSBruce Evans /* 155a88bd8aaSBruce Evans * Avoid the common case of unlocking when inode has no locks. 156a88bd8aaSBruce Evans */ 157a88bd8aaSBruce Evans if (*head == (struct lockf *)0) { 158a88bd8aaSBruce Evans if (ap->a_op != F_SETLK) { 159a88bd8aaSBruce Evans fl->l_type = F_UNLCK; 160a88bd8aaSBruce Evans return (0); 161a88bd8aaSBruce Evans } 162a88bd8aaSBruce Evans } 16392dc7331SDavid Greenman /* 16492dc7331SDavid Greenman * Create the lockf structure 16592dc7331SDavid Greenman */ 16692dc7331SDavid Greenman MALLOC(lock, struct lockf *, sizeof *lock, M_LOCKF, M_WAITOK); 16792dc7331SDavid Greenman lock->lf_start = start; 16892dc7331SDavid Greenman lock->lf_end = end; 16992dc7331SDavid Greenman lock->lf_id = ap->a_id; 170996c772fSJohn Dyson /* lock->lf_inode = ip; */ /* XXX JH */ 17192dc7331SDavid Greenman lock->lf_type = fl->l_type; 172996c772fSJohn Dyson lock->lf_head = head; 17392dc7331SDavid Greenman lock->lf_next = (struct lockf *)0; 174996c772fSJohn Dyson TAILQ_INIT(&lock->lf_blkhd); 17592dc7331SDavid Greenman lock->lf_flags = ap->a_flags; 17692dc7331SDavid Greenman /* 17792dc7331SDavid Greenman * Do the requested operation. 17892dc7331SDavid Greenman */ 17992dc7331SDavid Greenman switch(ap->a_op) { 18092dc7331SDavid Greenman case F_SETLK: 18192dc7331SDavid Greenman return (lf_setlock(lock)); 18292dc7331SDavid Greenman 18392dc7331SDavid Greenman case F_UNLCK: 18492dc7331SDavid Greenman error = lf_clearlock(lock); 18592dc7331SDavid Greenman FREE(lock, M_LOCKF); 18692dc7331SDavid Greenman return (error); 18792dc7331SDavid Greenman 18892dc7331SDavid Greenman case F_GETLK: 18992dc7331SDavid Greenman error = lf_getlock(lock, fl); 19092dc7331SDavid Greenman FREE(lock, M_LOCKF); 19192dc7331SDavid Greenman return (error); 19292dc7331SDavid Greenman 19392dc7331SDavid Greenman default: 19492dc7331SDavid Greenman free(lock, M_LOCKF); 19592dc7331SDavid Greenman return (EINVAL); 19692dc7331SDavid Greenman } 19792dc7331SDavid Greenman /* NOTREACHED */ 19892dc7331SDavid Greenman } 19992dc7331SDavid Greenman 20092dc7331SDavid Greenman /* 20192dc7331SDavid Greenman * Set a byte-range lock. 20292dc7331SDavid Greenman */ 20387b6de2bSPoul-Henning Kamp static int 20492dc7331SDavid Greenman lf_setlock(lock) 20592dc7331SDavid Greenman register struct lockf *lock; 20692dc7331SDavid Greenman { 20792dc7331SDavid Greenman register struct lockf *block; 20892dc7331SDavid Greenman struct lockf **head = lock->lf_head; 20992dc7331SDavid Greenman struct lockf **prev, *overlap, *ltmp; 21092dc7331SDavid Greenman static char lockstr[] = "lockf"; 21192dc7331SDavid Greenman int ovcase, priority, needtolink, error; 21292dc7331SDavid Greenman 21392dc7331SDavid Greenman #ifdef LOCKF_DEBUG 21492dc7331SDavid Greenman if (lockf_debug & 1) 21592dc7331SDavid Greenman lf_print("lf_setlock", lock); 21692dc7331SDavid Greenman #endif /* LOCKF_DEBUG */ 21792dc7331SDavid Greenman 21892dc7331SDavid Greenman /* 21992dc7331SDavid Greenman * Set the priority 22092dc7331SDavid Greenman */ 22192dc7331SDavid Greenman priority = PLOCK; 22292dc7331SDavid Greenman if (lock->lf_type == F_WRLCK) 22392dc7331SDavid Greenman priority += 4; 22492dc7331SDavid Greenman priority |= PCATCH; 22592dc7331SDavid Greenman /* 22692dc7331SDavid Greenman * Scan lock list for this file looking for locks that would block us. 22792dc7331SDavid Greenman */ 228bb56ec4aSPoul-Henning Kamp while ((block = lf_getblock(lock))) { 22992dc7331SDavid Greenman /* 23092dc7331SDavid Greenman * Free the structure and return if nonblocking. 23192dc7331SDavid Greenman */ 23292dc7331SDavid Greenman if ((lock->lf_flags & F_WAIT) == 0) { 23392dc7331SDavid Greenman FREE(lock, M_LOCKF); 23492dc7331SDavid Greenman return (EAGAIN); 23592dc7331SDavid Greenman } 23692dc7331SDavid Greenman /* 23792dc7331SDavid Greenman * We are blocked. Since flock style locks cover 23892dc7331SDavid Greenman * the whole file, there is no chance for deadlock. 23992dc7331SDavid Greenman * For byte-range locks we must check for deadlock. 24092dc7331SDavid Greenman * 24192dc7331SDavid Greenman * Deadlock detection is done by looking through the 24292dc7331SDavid Greenman * wait channels to see if there are any cycles that 24392dc7331SDavid Greenman * involve us. MAXDEPTH is set just to make sure we 24492dc7331SDavid Greenman * do not go off into neverland. 24592dc7331SDavid Greenman */ 24692dc7331SDavid Greenman if ((lock->lf_flags & F_POSIX) && 24792dc7331SDavid Greenman (block->lf_flags & F_POSIX)) { 24892dc7331SDavid Greenman register struct proc *wproc; 24992dc7331SDavid Greenman register struct lockf *waitblock; 25092dc7331SDavid Greenman int i = 0; 25192dc7331SDavid Greenman 25292dc7331SDavid Greenman /* The block is waiting on something */ 25392dc7331SDavid Greenman wproc = (struct proc *)block->lf_id; 2548d272518SJohn Baldwin mtx_lock_spin(&sched_lock); 25592dc7331SDavid Greenman while (wproc->p_wchan && 25692dc7331SDavid Greenman (wproc->p_wmesg == lockstr) && 25792dc7331SDavid Greenman (i++ < maxlockdepth)) { 25892dc7331SDavid Greenman waitblock = (struct lockf *)wproc->p_wchan; 25992dc7331SDavid Greenman /* Get the owner of the blocking lock */ 26092dc7331SDavid Greenman waitblock = waitblock->lf_next; 26192dc7331SDavid Greenman if ((waitblock->lf_flags & F_POSIX) == 0) 26292dc7331SDavid Greenman break; 26392dc7331SDavid Greenman wproc = (struct proc *)waitblock->lf_id; 26492dc7331SDavid Greenman if (wproc == (struct proc *)lock->lf_id) { 2658d272518SJohn Baldwin mtx_unlock_spin(&sched_lock); 26692dc7331SDavid Greenman free(lock, M_LOCKF); 26792dc7331SDavid Greenman return (EDEADLK); 26892dc7331SDavid Greenman } 26992dc7331SDavid Greenman } 2708d272518SJohn Baldwin mtx_unlock_spin(&sched_lock); 27192dc7331SDavid Greenman } 27292dc7331SDavid Greenman /* 27392dc7331SDavid Greenman * For flock type locks, we must first remove 27492dc7331SDavid Greenman * any shared locks that we hold before we sleep 27592dc7331SDavid Greenman * waiting for an exclusive lock. 27692dc7331SDavid Greenman */ 27792dc7331SDavid Greenman if ((lock->lf_flags & F_FLOCK) && 27892dc7331SDavid Greenman lock->lf_type == F_WRLCK) { 27992dc7331SDavid Greenman lock->lf_type = F_UNLCK; 28092dc7331SDavid Greenman (void) lf_clearlock(lock); 28192dc7331SDavid Greenman lock->lf_type = F_WRLCK; 28292dc7331SDavid Greenman } 28392dc7331SDavid Greenman /* 28492dc7331SDavid Greenman * Add our lock to the blocked list and sleep until we're free. 28592dc7331SDavid Greenman * Remember who blocked us (for deadlock detection). 28692dc7331SDavid Greenman */ 28792dc7331SDavid Greenman lock->lf_next = block; 288996c772fSJohn Dyson TAILQ_INSERT_TAIL(&block->lf_blkhd, lock, lf_block); 28992dc7331SDavid Greenman #ifdef LOCKF_DEBUG 29092dc7331SDavid Greenman if (lockf_debug & 1) { 29192dc7331SDavid Greenman lf_print("lf_setlock: blocking on", block); 29292dc7331SDavid Greenman lf_printlist("lf_setlock", block); 29392dc7331SDavid Greenman } 29492dc7331SDavid Greenman #endif /* LOCKF_DEBUG */ 2951168ab08SBruce Evans error = tsleep((caddr_t)lock, priority, lockstr, 0); 29692dc7331SDavid Greenman /* 2971168ab08SBruce Evans * We may have been awakened by a signal and/or by a 2981168ab08SBruce Evans * debugger continuing us (in which cases we must remove 2991168ab08SBruce Evans * ourselves from the blocked list) and/or by another 3001168ab08SBruce Evans * process releasing a lock (in which case we have 3011168ab08SBruce Evans * already been removed from the blocked list and our 302996c772fSJohn Dyson * lf_next field set to NOLOCKF). 30392dc7331SDavid Greenman */ 3041168ab08SBruce Evans if (lock->lf_next) { 3051168ab08SBruce Evans TAILQ_REMOVE(&lock->lf_next->lf_blkhd, lock, lf_block); 3061168ab08SBruce Evans lock->lf_next = NOLOCKF; 3071168ab08SBruce Evans } 3081168ab08SBruce Evans if (error) { 30992dc7331SDavid Greenman free(lock, M_LOCKF); 31092dc7331SDavid Greenman return (error); 31192dc7331SDavid Greenman } 31292dc7331SDavid Greenman } 31392dc7331SDavid Greenman /* 31492dc7331SDavid Greenman * No blocks!! Add the lock. Note that we will 31592dc7331SDavid Greenman * downgrade or upgrade any overlapping locks this 31692dc7331SDavid Greenman * process already owns. 31792dc7331SDavid Greenman * 31892dc7331SDavid Greenman * Skip over locks owned by other processes. 31992dc7331SDavid Greenman * Handle any locks that overlap and are owned by ourselves. 32092dc7331SDavid Greenman */ 32192dc7331SDavid Greenman prev = head; 32292dc7331SDavid Greenman block = *head; 32392dc7331SDavid Greenman needtolink = 1; 32492dc7331SDavid Greenman for (;;) { 325bb56ec4aSPoul-Henning Kamp ovcase = lf_findoverlap(block, lock, SELF, &prev, &overlap); 326bb56ec4aSPoul-Henning Kamp if (ovcase) 32792dc7331SDavid Greenman block = overlap->lf_next; 32892dc7331SDavid Greenman /* 32992dc7331SDavid Greenman * Six cases: 33092dc7331SDavid Greenman * 0) no overlap 33192dc7331SDavid Greenman * 1) overlap == lock 33292dc7331SDavid Greenman * 2) overlap contains lock 33392dc7331SDavid Greenman * 3) lock contains overlap 33492dc7331SDavid Greenman * 4) overlap starts before lock 33592dc7331SDavid Greenman * 5) overlap ends after lock 33692dc7331SDavid Greenman */ 33792dc7331SDavid Greenman switch (ovcase) { 33892dc7331SDavid Greenman case 0: /* no overlap */ 33992dc7331SDavid Greenman if (needtolink) { 34092dc7331SDavid Greenman *prev = lock; 34192dc7331SDavid Greenman lock->lf_next = overlap; 34292dc7331SDavid Greenman } 34392dc7331SDavid Greenman break; 34492dc7331SDavid Greenman 34592dc7331SDavid Greenman case 1: /* overlap == lock */ 34692dc7331SDavid Greenman /* 34792dc7331SDavid Greenman * If downgrading lock, others may be 34892dc7331SDavid Greenman * able to acquire it. 34992dc7331SDavid Greenman */ 35092dc7331SDavid Greenman if (lock->lf_type == F_RDLCK && 35192dc7331SDavid Greenman overlap->lf_type == F_WRLCK) 35292dc7331SDavid Greenman lf_wakelock(overlap); 35392dc7331SDavid Greenman overlap->lf_type = lock->lf_type; 35492dc7331SDavid Greenman FREE(lock, M_LOCKF); 35592dc7331SDavid Greenman lock = overlap; /* for debug output below */ 35692dc7331SDavid Greenman break; 35792dc7331SDavid Greenman 35892dc7331SDavid Greenman case 2: /* overlap contains lock */ 35992dc7331SDavid Greenman /* 36092dc7331SDavid Greenman * Check for common starting point and different types. 36192dc7331SDavid Greenman */ 36292dc7331SDavid Greenman if (overlap->lf_type == lock->lf_type) { 36392dc7331SDavid Greenman free(lock, M_LOCKF); 36492dc7331SDavid Greenman lock = overlap; /* for debug output below */ 36592dc7331SDavid Greenman break; 36692dc7331SDavid Greenman } 36792dc7331SDavid Greenman if (overlap->lf_start == lock->lf_start) { 36892dc7331SDavid Greenman *prev = lock; 36992dc7331SDavid Greenman lock->lf_next = overlap; 37092dc7331SDavid Greenman overlap->lf_start = lock->lf_end + 1; 37192dc7331SDavid Greenman } else 37292dc7331SDavid Greenman lf_split(overlap, lock); 37392dc7331SDavid Greenman lf_wakelock(overlap); 37492dc7331SDavid Greenman break; 37592dc7331SDavid Greenman 37692dc7331SDavid Greenman case 3: /* lock contains overlap */ 37792dc7331SDavid Greenman /* 37892dc7331SDavid Greenman * If downgrading lock, others may be able to 37992dc7331SDavid Greenman * acquire it, otherwise take the list. 38092dc7331SDavid Greenman */ 38192dc7331SDavid Greenman if (lock->lf_type == F_RDLCK && 38292dc7331SDavid Greenman overlap->lf_type == F_WRLCK) { 38392dc7331SDavid Greenman lf_wakelock(overlap); 38492dc7331SDavid Greenman } else { 3851b727751SPoul-Henning Kamp while (!TAILQ_EMPTY(&overlap->lf_blkhd)) { 3861b727751SPoul-Henning Kamp ltmp = TAILQ_FIRST(&overlap->lf_blkhd); 387996c772fSJohn Dyson TAILQ_REMOVE(&overlap->lf_blkhd, ltmp, 388996c772fSJohn Dyson lf_block); 389996c772fSJohn Dyson TAILQ_INSERT_TAIL(&lock->lf_blkhd, 390996c772fSJohn Dyson ltmp, lf_block); 391db72e058SDmitrij Tejblum ltmp->lf_next = lock; 392996c772fSJohn Dyson } 39392dc7331SDavid Greenman } 39492dc7331SDavid Greenman /* 39592dc7331SDavid Greenman * Add the new lock if necessary and delete the overlap. 39692dc7331SDavid Greenman */ 39792dc7331SDavid Greenman if (needtolink) { 39892dc7331SDavid Greenman *prev = lock; 39992dc7331SDavid Greenman lock->lf_next = overlap->lf_next; 40092dc7331SDavid Greenman prev = &lock->lf_next; 40192dc7331SDavid Greenman needtolink = 0; 40292dc7331SDavid Greenman } else 40392dc7331SDavid Greenman *prev = overlap->lf_next; 40492dc7331SDavid Greenman free(overlap, M_LOCKF); 40592dc7331SDavid Greenman continue; 40692dc7331SDavid Greenman 40792dc7331SDavid Greenman case 4: /* overlap starts before lock */ 40892dc7331SDavid Greenman /* 40992dc7331SDavid Greenman * Add lock after overlap on the list. 41092dc7331SDavid Greenman */ 41192dc7331SDavid Greenman lock->lf_next = overlap->lf_next; 41292dc7331SDavid Greenman overlap->lf_next = lock; 41392dc7331SDavid Greenman overlap->lf_end = lock->lf_start - 1; 41492dc7331SDavid Greenman prev = &lock->lf_next; 41592dc7331SDavid Greenman lf_wakelock(overlap); 41692dc7331SDavid Greenman needtolink = 0; 41792dc7331SDavid Greenman continue; 41892dc7331SDavid Greenman 41992dc7331SDavid Greenman case 5: /* overlap ends after lock */ 42092dc7331SDavid Greenman /* 42192dc7331SDavid Greenman * Add the new lock before overlap. 42292dc7331SDavid Greenman */ 42392dc7331SDavid Greenman if (needtolink) { 42492dc7331SDavid Greenman *prev = lock; 42592dc7331SDavid Greenman lock->lf_next = overlap; 42692dc7331SDavid Greenman } 42792dc7331SDavid Greenman overlap->lf_start = lock->lf_end + 1; 42892dc7331SDavid Greenman lf_wakelock(overlap); 42992dc7331SDavid Greenman break; 43092dc7331SDavid Greenman } 43192dc7331SDavid Greenman break; 43292dc7331SDavid Greenman } 43392dc7331SDavid Greenman #ifdef LOCKF_DEBUG 43492dc7331SDavid Greenman if (lockf_debug & 1) { 43592dc7331SDavid Greenman lf_print("lf_setlock: got the lock", lock); 43692dc7331SDavid Greenman lf_printlist("lf_setlock", lock); 43792dc7331SDavid Greenman } 43892dc7331SDavid Greenman #endif /* LOCKF_DEBUG */ 43992dc7331SDavid Greenman return (0); 44092dc7331SDavid Greenman } 44192dc7331SDavid Greenman 44292dc7331SDavid Greenman /* 44392dc7331SDavid Greenman * Remove a byte-range lock on an inode. 44492dc7331SDavid Greenman * 44592dc7331SDavid Greenman * Generally, find the lock (or an overlap to that lock) 44692dc7331SDavid Greenman * and remove it (or shrink it), then wakeup anyone we can. 44792dc7331SDavid Greenman */ 44887b6de2bSPoul-Henning Kamp static int 44992dc7331SDavid Greenman lf_clearlock(unlock) 45092dc7331SDavid Greenman register struct lockf *unlock; 45192dc7331SDavid Greenman { 45292dc7331SDavid Greenman struct lockf **head = unlock->lf_head; 45392dc7331SDavid Greenman register struct lockf *lf = *head; 45492dc7331SDavid Greenman struct lockf *overlap, **prev; 45592dc7331SDavid Greenman int ovcase; 45692dc7331SDavid Greenman 45792dc7331SDavid Greenman if (lf == NOLOCKF) 45892dc7331SDavid Greenman return (0); 45992dc7331SDavid Greenman #ifdef LOCKF_DEBUG 46092dc7331SDavid Greenman if (unlock->lf_type != F_UNLCK) 46192dc7331SDavid Greenman panic("lf_clearlock: bad type"); 46292dc7331SDavid Greenman if (lockf_debug & 1) 46392dc7331SDavid Greenman lf_print("lf_clearlock", unlock); 46492dc7331SDavid Greenman #endif /* LOCKF_DEBUG */ 46592dc7331SDavid Greenman prev = head; 466bb56ec4aSPoul-Henning Kamp while ((ovcase = lf_findoverlap(lf, unlock, SELF, &prev, &overlap))) { 46792dc7331SDavid Greenman /* 46892dc7331SDavid Greenman * Wakeup the list of locks to be retried. 46992dc7331SDavid Greenman */ 47092dc7331SDavid Greenman lf_wakelock(overlap); 47192dc7331SDavid Greenman 47292dc7331SDavid Greenman switch (ovcase) { 47392dc7331SDavid Greenman 47492dc7331SDavid Greenman case 1: /* overlap == lock */ 47592dc7331SDavid Greenman *prev = overlap->lf_next; 47692dc7331SDavid Greenman FREE(overlap, M_LOCKF); 47792dc7331SDavid Greenman break; 47892dc7331SDavid Greenman 47992dc7331SDavid Greenman case 2: /* overlap contains lock: split it */ 48092dc7331SDavid Greenman if (overlap->lf_start == unlock->lf_start) { 48192dc7331SDavid Greenman overlap->lf_start = unlock->lf_end + 1; 48292dc7331SDavid Greenman break; 48392dc7331SDavid Greenman } 48492dc7331SDavid Greenman lf_split(overlap, unlock); 48592dc7331SDavid Greenman overlap->lf_next = unlock->lf_next; 48692dc7331SDavid Greenman break; 48792dc7331SDavid Greenman 48892dc7331SDavid Greenman case 3: /* lock contains overlap */ 48992dc7331SDavid Greenman *prev = overlap->lf_next; 49092dc7331SDavid Greenman lf = overlap->lf_next; 49192dc7331SDavid Greenman free(overlap, M_LOCKF); 49292dc7331SDavid Greenman continue; 49392dc7331SDavid Greenman 49492dc7331SDavid Greenman case 4: /* overlap starts before lock */ 49592dc7331SDavid Greenman overlap->lf_end = unlock->lf_start - 1; 49692dc7331SDavid Greenman prev = &overlap->lf_next; 49792dc7331SDavid Greenman lf = overlap->lf_next; 49892dc7331SDavid Greenman continue; 49992dc7331SDavid Greenman 50092dc7331SDavid Greenman case 5: /* overlap ends after lock */ 50192dc7331SDavid Greenman overlap->lf_start = unlock->lf_end + 1; 50292dc7331SDavid Greenman break; 50392dc7331SDavid Greenman } 50492dc7331SDavid Greenman break; 50592dc7331SDavid Greenman } 50692dc7331SDavid Greenman #ifdef LOCKF_DEBUG 50792dc7331SDavid Greenman if (lockf_debug & 1) 50892dc7331SDavid Greenman lf_printlist("lf_clearlock", unlock); 50992dc7331SDavid Greenman #endif /* LOCKF_DEBUG */ 51092dc7331SDavid Greenman return (0); 51192dc7331SDavid Greenman } 51292dc7331SDavid Greenman 51392dc7331SDavid Greenman /* 51492dc7331SDavid Greenman * Check whether there is a blocking lock, 51592dc7331SDavid Greenman * and if so return its process identifier. 51692dc7331SDavid Greenman */ 51787b6de2bSPoul-Henning Kamp static int 51892dc7331SDavid Greenman lf_getlock(lock, fl) 51992dc7331SDavid Greenman register struct lockf *lock; 52092dc7331SDavid Greenman register struct flock *fl; 52192dc7331SDavid Greenman { 52292dc7331SDavid Greenman register struct lockf *block; 52392dc7331SDavid Greenman 52492dc7331SDavid Greenman #ifdef LOCKF_DEBUG 52592dc7331SDavid Greenman if (lockf_debug & 1) 52692dc7331SDavid Greenman lf_print("lf_getlock", lock); 52792dc7331SDavid Greenman #endif /* LOCKF_DEBUG */ 52892dc7331SDavid Greenman 529bb56ec4aSPoul-Henning Kamp if ((block = lf_getblock(lock))) { 53092dc7331SDavid Greenman fl->l_type = block->lf_type; 53192dc7331SDavid Greenman fl->l_whence = SEEK_SET; 53292dc7331SDavid Greenman fl->l_start = block->lf_start; 53392dc7331SDavid Greenman if (block->lf_end == -1) 53492dc7331SDavid Greenman fl->l_len = 0; 53592dc7331SDavid Greenman else 53692dc7331SDavid Greenman fl->l_len = block->lf_end - block->lf_start + 1; 53792dc7331SDavid Greenman if (block->lf_flags & F_POSIX) 53892dc7331SDavid Greenman fl->l_pid = ((struct proc *)(block->lf_id))->p_pid; 53992dc7331SDavid Greenman else 54092dc7331SDavid Greenman fl->l_pid = -1; 54192dc7331SDavid Greenman } else { 54292dc7331SDavid Greenman fl->l_type = F_UNLCK; 54392dc7331SDavid Greenman } 54492dc7331SDavid Greenman return (0); 54592dc7331SDavid Greenman } 54692dc7331SDavid Greenman 54792dc7331SDavid Greenman /* 54892dc7331SDavid Greenman * Walk the list of locks for an inode and 54992dc7331SDavid Greenman * return the first blocking lock. 55092dc7331SDavid Greenman */ 55187b6de2bSPoul-Henning Kamp static struct lockf * 55292dc7331SDavid Greenman lf_getblock(lock) 55392dc7331SDavid Greenman register struct lockf *lock; 55492dc7331SDavid Greenman { 55592dc7331SDavid Greenman struct lockf **prev, *overlap, *lf = *(lock->lf_head); 55692dc7331SDavid Greenman int ovcase; 55792dc7331SDavid Greenman 55892dc7331SDavid Greenman prev = lock->lf_head; 559bb56ec4aSPoul-Henning Kamp while ((ovcase = lf_findoverlap(lf, lock, OTHERS, &prev, &overlap))) { 56092dc7331SDavid Greenman /* 56192dc7331SDavid Greenman * We've found an overlap, see if it blocks us 56292dc7331SDavid Greenman */ 56392dc7331SDavid Greenman if ((lock->lf_type == F_WRLCK || overlap->lf_type == F_WRLCK)) 56492dc7331SDavid Greenman return (overlap); 56592dc7331SDavid Greenman /* 56692dc7331SDavid Greenman * Nope, point to the next one on the list and 56792dc7331SDavid Greenman * see if it blocks us 56892dc7331SDavid Greenman */ 56992dc7331SDavid Greenman lf = overlap->lf_next; 57092dc7331SDavid Greenman } 57192dc7331SDavid Greenman return (NOLOCKF); 57292dc7331SDavid Greenman } 57392dc7331SDavid Greenman 57492dc7331SDavid Greenman /* 57592dc7331SDavid Greenman * Walk the list of locks for an inode to 57692dc7331SDavid Greenman * find an overlapping lock (if any). 57792dc7331SDavid Greenman * 57892dc7331SDavid Greenman * NOTE: this returns only the FIRST overlapping lock. There 57992dc7331SDavid Greenman * may be more than one. 58092dc7331SDavid Greenman */ 58187b6de2bSPoul-Henning Kamp static int 58292dc7331SDavid Greenman lf_findoverlap(lf, lock, type, prev, overlap) 58392dc7331SDavid Greenman register struct lockf *lf; 58492dc7331SDavid Greenman struct lockf *lock; 58592dc7331SDavid Greenman int type; 58692dc7331SDavid Greenman struct lockf ***prev; 58792dc7331SDavid Greenman struct lockf **overlap; 58892dc7331SDavid Greenman { 58992dc7331SDavid Greenman off_t start, end; 59092dc7331SDavid Greenman 59192dc7331SDavid Greenman *overlap = lf; 59292dc7331SDavid Greenman if (lf == NOLOCKF) 59392dc7331SDavid Greenman return (0); 59492dc7331SDavid Greenman #ifdef LOCKF_DEBUG 59592dc7331SDavid Greenman if (lockf_debug & 2) 59692dc7331SDavid Greenman lf_print("lf_findoverlap: looking for overlap in", lock); 59792dc7331SDavid Greenman #endif /* LOCKF_DEBUG */ 59892dc7331SDavid Greenman start = lock->lf_start; 59992dc7331SDavid Greenman end = lock->lf_end; 60092dc7331SDavid Greenman while (lf != NOLOCKF) { 60192dc7331SDavid Greenman if (((type & SELF) && lf->lf_id != lock->lf_id) || 60292dc7331SDavid Greenman ((type & OTHERS) && lf->lf_id == lock->lf_id)) { 60392dc7331SDavid Greenman *prev = &lf->lf_next; 60492dc7331SDavid Greenman *overlap = lf = lf->lf_next; 60592dc7331SDavid Greenman continue; 60692dc7331SDavid Greenman } 60792dc7331SDavid Greenman #ifdef LOCKF_DEBUG 60892dc7331SDavid Greenman if (lockf_debug & 2) 60992dc7331SDavid Greenman lf_print("\tchecking", lf); 61092dc7331SDavid Greenman #endif /* LOCKF_DEBUG */ 61192dc7331SDavid Greenman /* 61292dc7331SDavid Greenman * OK, check for overlap 61392dc7331SDavid Greenman * 61492dc7331SDavid Greenman * Six cases: 61592dc7331SDavid Greenman * 0) no overlap 61692dc7331SDavid Greenman * 1) overlap == lock 61792dc7331SDavid Greenman * 2) overlap contains lock 61892dc7331SDavid Greenman * 3) lock contains overlap 61992dc7331SDavid Greenman * 4) overlap starts before lock 62092dc7331SDavid Greenman * 5) overlap ends after lock 62192dc7331SDavid Greenman */ 62292dc7331SDavid Greenman if ((lf->lf_end != -1 && start > lf->lf_end) || 62392dc7331SDavid Greenman (end != -1 && lf->lf_start > end)) { 62492dc7331SDavid Greenman /* Case 0 */ 62592dc7331SDavid Greenman #ifdef LOCKF_DEBUG 62692dc7331SDavid Greenman if (lockf_debug & 2) 62792dc7331SDavid Greenman printf("no overlap\n"); 62892dc7331SDavid Greenman #endif /* LOCKF_DEBUG */ 62992dc7331SDavid Greenman if ((type & SELF) && end != -1 && lf->lf_start > end) 63092dc7331SDavid Greenman return (0); 63192dc7331SDavid Greenman *prev = &lf->lf_next; 63292dc7331SDavid Greenman *overlap = lf = lf->lf_next; 63392dc7331SDavid Greenman continue; 63492dc7331SDavid Greenman } 63592dc7331SDavid Greenman if ((lf->lf_start == start) && (lf->lf_end == end)) { 63692dc7331SDavid Greenman /* Case 1 */ 63792dc7331SDavid Greenman #ifdef LOCKF_DEBUG 63892dc7331SDavid Greenman if (lockf_debug & 2) 63992dc7331SDavid Greenman printf("overlap == lock\n"); 64092dc7331SDavid Greenman #endif /* LOCKF_DEBUG */ 64192dc7331SDavid Greenman return (1); 64292dc7331SDavid Greenman } 64392dc7331SDavid Greenman if ((lf->lf_start <= start) && 64492dc7331SDavid Greenman (end != -1) && 64592dc7331SDavid Greenman ((lf->lf_end >= end) || (lf->lf_end == -1))) { 64692dc7331SDavid Greenman /* Case 2 */ 64792dc7331SDavid Greenman #ifdef LOCKF_DEBUG 64892dc7331SDavid Greenman if (lockf_debug & 2) 64992dc7331SDavid Greenman printf("overlap contains lock\n"); 65092dc7331SDavid Greenman #endif /* LOCKF_DEBUG */ 65192dc7331SDavid Greenman return (2); 65292dc7331SDavid Greenman } 65392dc7331SDavid Greenman if (start <= lf->lf_start && 65492dc7331SDavid Greenman (end == -1 || 65592dc7331SDavid Greenman (lf->lf_end != -1 && end >= lf->lf_end))) { 65692dc7331SDavid Greenman /* Case 3 */ 65792dc7331SDavid Greenman #ifdef LOCKF_DEBUG 65892dc7331SDavid Greenman if (lockf_debug & 2) 65992dc7331SDavid Greenman printf("lock contains overlap\n"); 66092dc7331SDavid Greenman #endif /* LOCKF_DEBUG */ 66192dc7331SDavid Greenman return (3); 66292dc7331SDavid Greenman } 66392dc7331SDavid Greenman if ((lf->lf_start < start) && 66492dc7331SDavid Greenman ((lf->lf_end >= start) || (lf->lf_end == -1))) { 66592dc7331SDavid Greenman /* Case 4 */ 66692dc7331SDavid Greenman #ifdef LOCKF_DEBUG 66792dc7331SDavid Greenman if (lockf_debug & 2) 66892dc7331SDavid Greenman printf("overlap starts before lock\n"); 66992dc7331SDavid Greenman #endif /* LOCKF_DEBUG */ 67092dc7331SDavid Greenman return (4); 67192dc7331SDavid Greenman } 67292dc7331SDavid Greenman if ((lf->lf_start > start) && 67392dc7331SDavid Greenman (end != -1) && 67492dc7331SDavid Greenman ((lf->lf_end > end) || (lf->lf_end == -1))) { 67592dc7331SDavid Greenman /* Case 5 */ 67692dc7331SDavid Greenman #ifdef LOCKF_DEBUG 67792dc7331SDavid Greenman if (lockf_debug & 2) 67892dc7331SDavid Greenman printf("overlap ends after lock\n"); 67992dc7331SDavid Greenman #endif /* LOCKF_DEBUG */ 68092dc7331SDavid Greenman return (5); 68192dc7331SDavid Greenman } 68292dc7331SDavid Greenman panic("lf_findoverlap: default"); 68392dc7331SDavid Greenman } 68492dc7331SDavid Greenman return (0); 68592dc7331SDavid Greenman } 68692dc7331SDavid Greenman 68792dc7331SDavid Greenman /* 68892dc7331SDavid Greenman * Split a lock and a contained region into 68992dc7331SDavid Greenman * two or three locks as necessary. 69092dc7331SDavid Greenman */ 69187b6de2bSPoul-Henning Kamp static void 69292dc7331SDavid Greenman lf_split(lock1, lock2) 69392dc7331SDavid Greenman register struct lockf *lock1; 69492dc7331SDavid Greenman register struct lockf *lock2; 69592dc7331SDavid Greenman { 69692dc7331SDavid Greenman register struct lockf *splitlock; 69792dc7331SDavid Greenman 69892dc7331SDavid Greenman #ifdef LOCKF_DEBUG 69992dc7331SDavid Greenman if (lockf_debug & 2) { 70092dc7331SDavid Greenman lf_print("lf_split", lock1); 70192dc7331SDavid Greenman lf_print("splitting from", lock2); 70292dc7331SDavid Greenman } 70392dc7331SDavid Greenman #endif /* LOCKF_DEBUG */ 70492dc7331SDavid Greenman /* 70592dc7331SDavid Greenman * Check to see if spliting into only two pieces. 70692dc7331SDavid Greenman */ 70792dc7331SDavid Greenman if (lock1->lf_start == lock2->lf_start) { 70892dc7331SDavid Greenman lock1->lf_start = lock2->lf_end + 1; 70992dc7331SDavid Greenman lock2->lf_next = lock1; 71092dc7331SDavid Greenman return; 71192dc7331SDavid Greenman } 71292dc7331SDavid Greenman if (lock1->lf_end == lock2->lf_end) { 71392dc7331SDavid Greenman lock1->lf_end = lock2->lf_start - 1; 71492dc7331SDavid Greenman lock2->lf_next = lock1->lf_next; 71592dc7331SDavid Greenman lock1->lf_next = lock2; 71692dc7331SDavid Greenman return; 71792dc7331SDavid Greenman } 71892dc7331SDavid Greenman /* 71992dc7331SDavid Greenman * Make a new lock consisting of the last part of 72092dc7331SDavid Greenman * the encompassing lock 72192dc7331SDavid Greenman */ 72292dc7331SDavid Greenman MALLOC(splitlock, struct lockf *, sizeof *splitlock, M_LOCKF, M_WAITOK); 72392dc7331SDavid Greenman bcopy((caddr_t)lock1, (caddr_t)splitlock, sizeof *splitlock); 72492dc7331SDavid Greenman splitlock->lf_start = lock2->lf_end + 1; 725996c772fSJohn Dyson TAILQ_INIT(&splitlock->lf_blkhd); 72692dc7331SDavid Greenman lock1->lf_end = lock2->lf_start - 1; 72792dc7331SDavid Greenman /* 72892dc7331SDavid Greenman * OK, now link it in 72992dc7331SDavid Greenman */ 73092dc7331SDavid Greenman splitlock->lf_next = lock1->lf_next; 73192dc7331SDavid Greenman lock2->lf_next = splitlock; 73292dc7331SDavid Greenman lock1->lf_next = lock2; 73392dc7331SDavid Greenman } 73492dc7331SDavid Greenman 73592dc7331SDavid Greenman /* 73692dc7331SDavid Greenman * Wakeup a blocklist 73792dc7331SDavid Greenman */ 73887b6de2bSPoul-Henning Kamp static void 73992dc7331SDavid Greenman lf_wakelock(listhead) 74092dc7331SDavid Greenman struct lockf *listhead; 74192dc7331SDavid Greenman { 742996c772fSJohn Dyson register struct lockf *wakelock; 74392dc7331SDavid Greenman 7441b727751SPoul-Henning Kamp while (!TAILQ_EMPTY(&listhead->lf_blkhd)) { 7451b727751SPoul-Henning Kamp wakelock = TAILQ_FIRST(&listhead->lf_blkhd); 746996c772fSJohn Dyson TAILQ_REMOVE(&listhead->lf_blkhd, wakelock, lf_block); 74792dc7331SDavid Greenman wakelock->lf_next = NOLOCKF; 74892dc7331SDavid Greenman #ifdef LOCKF_DEBUG 74992dc7331SDavid Greenman if (lockf_debug & 2) 75092dc7331SDavid Greenman lf_print("lf_wakelock: awakening", wakelock); 75192dc7331SDavid Greenman #endif /* LOCKF_DEBUG */ 75292dc7331SDavid Greenman wakeup((caddr_t)wakelock); 75392dc7331SDavid Greenman } 75492dc7331SDavid Greenman } 75592dc7331SDavid Greenman 75692dc7331SDavid Greenman #ifdef LOCKF_DEBUG 75792dc7331SDavid Greenman /* 75892dc7331SDavid Greenman * Print out a lock. 75992dc7331SDavid Greenman */ 760b52748beSBruce Evans void 76192dc7331SDavid Greenman lf_print(tag, lock) 76292dc7331SDavid Greenman char *tag; 76392dc7331SDavid Greenman register struct lockf *lock; 76492dc7331SDavid Greenman { 76592dc7331SDavid Greenman 766d974cf4dSBruce Evans printf("%s: lock %p for ", tag, (void *)lock); 76792dc7331SDavid Greenman if (lock->lf_flags & F_POSIX) 768d974cf4dSBruce Evans printf("proc %ld", (long)((struct proc *)lock->lf_id)->p_pid); 76992dc7331SDavid Greenman else 770d974cf4dSBruce Evans printf("id %p", (void *)lock->lf_id); 771d974cf4dSBruce Evans /* XXX no %qd in kernel. Truncate. */ 772d974cf4dSBruce Evans printf(" in ino %lu on dev <%d, %d>, %s, start %ld, end %ld", 773d974cf4dSBruce Evans (u_long)lock->lf_inode->i_number, 77492dc7331SDavid Greenman major(lock->lf_inode->i_dev), 77592dc7331SDavid Greenman minor(lock->lf_inode->i_dev), 77692dc7331SDavid Greenman lock->lf_type == F_RDLCK ? "shared" : 77792dc7331SDavid Greenman lock->lf_type == F_WRLCK ? "exclusive" : 77892dc7331SDavid Greenman lock->lf_type == F_UNLCK ? "unlock" : 779d974cf4dSBruce Evans "unknown", (long)lock->lf_start, (long)lock->lf_end); 7801b727751SPoul-Henning Kamp if (!TAILQ_EMPTY(&lock->lf_blkhd)) 7811b727751SPoul-Henning Kamp printf(" block %p\n", (void *)TAILQ_FIRST(&lock->lf_blkhd)); 78292dc7331SDavid Greenman else 78392dc7331SDavid Greenman printf("\n"); 78492dc7331SDavid Greenman } 78592dc7331SDavid Greenman 786b52748beSBruce Evans void 78792dc7331SDavid Greenman lf_printlist(tag, lock) 78892dc7331SDavid Greenman char *tag; 78992dc7331SDavid Greenman struct lockf *lock; 79092dc7331SDavid Greenman { 791996c772fSJohn Dyson register struct lockf *lf, *blk; 79292dc7331SDavid Greenman 793d974cf4dSBruce Evans printf("%s: Lock list for ino %lu on dev <%d, %d>:\n", 794d974cf4dSBruce Evans tag, (u_long)lock->lf_inode->i_number, 79592dc7331SDavid Greenman major(lock->lf_inode->i_dev), 79692dc7331SDavid Greenman minor(lock->lf_inode->i_dev)); 79792dc7331SDavid Greenman for (lf = lock->lf_inode->i_lockf; lf; lf = lf->lf_next) { 798d974cf4dSBruce Evans printf("\tlock %p for ",(void *)lf); 79992dc7331SDavid Greenman if (lf->lf_flags & F_POSIX) 800d974cf4dSBruce Evans printf("proc %ld", 801d974cf4dSBruce Evans (long)((struct proc *)lf->lf_id)->p_pid); 80292dc7331SDavid Greenman else 803d974cf4dSBruce Evans printf("id %p", (void *)lf->lf_id); 804d974cf4dSBruce Evans /* XXX no %qd in kernel. Truncate. */ 805d974cf4dSBruce Evans printf(", %s, start %ld, end %ld", 80692dc7331SDavid Greenman lf->lf_type == F_RDLCK ? "shared" : 80792dc7331SDavid Greenman lf->lf_type == F_WRLCK ? "exclusive" : 80892dc7331SDavid Greenman lf->lf_type == F_UNLCK ? "unlock" : 809d974cf4dSBruce Evans "unknown", (long)lf->lf_start, (long)lf->lf_end); 8101b727751SPoul-Henning Kamp TAILQ_FOREACH(blk, &lf->lf_blkhd, lf_block) { 811d974cf4dSBruce Evans printf("\n\t\tlock request %p for ", (void *)blk); 812996c772fSJohn Dyson if (blk->lf_flags & F_POSIX) 813d974cf4dSBruce Evans printf("proc %ld", 814d974cf4dSBruce Evans (long)((struct proc *)blk->lf_id)->p_pid); 81592dc7331SDavid Greenman else 816d974cf4dSBruce Evans printf("id %p", (void *)blk->lf_id); 817d974cf4dSBruce Evans /* XXX no %qd in kernel. Truncate. */ 818d974cf4dSBruce Evans printf(", %s, start %ld, end %ld", 819996c772fSJohn Dyson blk->lf_type == F_RDLCK ? "shared" : 820996c772fSJohn Dyson blk->lf_type == F_WRLCK ? "exclusive" : 821996c772fSJohn Dyson blk->lf_type == F_UNLCK ? "unlock" : 822d974cf4dSBruce Evans "unknown", (long)blk->lf_start, 823d974cf4dSBruce Evans (long)blk->lf_end); 8241b727751SPoul-Henning Kamp if (!TAILQ_EMPTY(&blk->lf_blkhd)) 825996c772fSJohn Dyson panic("lf_printlist: bad list"); 826996c772fSJohn Dyson } 82792dc7331SDavid Greenman printf("\n"); 82892dc7331SDavid Greenman } 82992dc7331SDavid Greenman } 83092dc7331SDavid Greenman #endif /* LOCKF_DEBUG */ 831