xref: /freebsd/sys/kern/kern_lockf.c (revision 62be011ebd0374fa9a01e04aeecf31976a4f7414)
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