/*
 * Copyright (c) 1995
 *	The Regents of the University of California.  All rights reserved.
 * Copyright (c) 2013-2017
 *	The DragonFly Project.  All rights reserved.
 *
 * This code contains ideas from software contributed to Berkeley by
 * Avadis Tevanian, Jr., Michael Wayne Young, and the Mach Operating
 * System project at Carnegie-Mellon University.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Matthew Dillon <dillon@backplane.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#ifndef	_SYS_LOCK_H_
#define	_SYS_LOCK_H_

/*
 * A number of third party programs #include <sys/lock.h> for no good
 * reason.  Don't actually include anything unless we are the kernel.
 */
#if defined(_KERNEL) || defined(_KERNEL_STRUCTURES)

#include <machine/lock.h>
#ifndef _SYS_THREAD_H_
#include <sys/thread.h>		/* lwkt_token */
#endif
#ifndef _SYS_SPINLOCK_H_
#include <sys/spinlock.h>
#endif

/*
 * The general lock structure.  Provides for multiple shared locks,
 * upgrading from shared to exclusive, and sleeping until the lock
 * can be gained.
 *
 * NOTE: We don't __cachealign struct lock, its too much bloat.  Users
 *	 of struct lock may be able to arrange it within greater structures
 *	 in more SMP-friendly ways.
 */
struct thread;

struct lock {
	u_int	lk_flags;		/* see below */
	int	lk_timo;		/* maximum sleep time (for tsleep) */
	uint64_t lk_count;		/* see LKC_* bits */
	const char *lk_wmesg;		/* resource sleeping (for tsleep) */
	struct thread *lk_lockholder;	/* thread of excl lock holder */
};

/*
 * Lock request types:
 *
 *   LK_SHARED
 *	Get one of many possible shared locks. If a process holding an
 *	exclusive lock requests a shared lock, the exclusive lock(s) will
 *	be downgraded to shared locks.
 *
 *   LK_EXCLUSIVE
 *	Stop further shared locks, when they are cleared, grant a pending
 *	upgrade if it exists, then grant an exclusive lock. Only one exclusive
 *	lock may exist at a time, except that a process holding an exclusive
 *	lock may get additional exclusive locks if it explicitly sets the
 *	LK_CANRECURSE flag in the lock request, or if the LK_CANRECURSE flag
 *	was set when the lock was initialized.
 *
 *   LK_UPGRADE
 *	The process must hold a shared lock that it wants to have upgraded
 *	to an exclusive lock. Other processes may get exclusive access to
 *	the resource between the time that the upgrade is requested and the
 *	time that it is granted.
 *
 *   LK_EXCLUPGRADE
 *	the process must hold a shared lock that it wants to have upgraded
 *	to an exclusive lock. If the request succeeds, no other processes
 *	will have gotten exclusive access to the resource between the time
 *	that the upgrade is requested and the time that it is granted.
 *	However, if another process has already requested an upgrade, the
 *	request will fail (see error returns below).
 *
 *   LK_DOWNGRADE
 *	The process must hold an exclusive lock that it wants to have
 *	downgraded to a shared lock. If the process holds multiple (recursive)
 *	exclusive locks, they will all be downgraded to shared locks.
 *
 *   LK_RELEASE
 *	Release one instance of a lock.
 *
 *   LK_CANCEL_BEG
 *	The current exclusive lock holder can cancel any blocked lock requests,
 *	or any new requests, whos callers specified LK_CANCELABLE.  They will
 *	receive a ENOLCK error code.  Cancel beg/end does not stack.
 *
 *	The cancel command stays in effect until the exclusive lock holder
 *	releases the last count on the lock or issues a LK_CANCEL_END command.
 *
 *   LK_CANCEL_END
 *	The current exclusive lock holder can stop canceling new requests
 *	whos callers specify LK_CANCELABLE.  The exclusive lock is maintained.
 *
 *	Note that the last release of the exclusive lock will also
 *	automatically end cancel mode.
 *
 *
 * ---
 *
 *   LK_EXCLOTHER - return for lockstatus().  Used when another process
 *	holds the lock exclusively.
 *
 * These are flags that are passed to the lockmgr routine.
 */
#define LK_TYPE_MASK	0x0000000f	/* type of lock sought */
#define LK_SHARED	0x00000001	/* shared lock */
#define LK_EXCLUSIVE	0x00000002	/* exclusive lock */
#define LK_UPGRADE	0x00000003	/* shared-to-exclusive upgrade */
#define LK_EXCLUPGRADE	0x00000004	/* first shared-to-exclusive upgrade */
#define LK_DOWNGRADE	0x00000005	/* exclusive-to-shared downgrade */
#define LK_RELEASE	0x00000006	/* release any type of lock */
#define LK_WAITUPGRADE	0x00000007
#define LK_EXCLOTHER	0x00000008	/* other process holds lock */
#define LK_CANCEL_BEG	0x00000009	/* cancel other requests */
#define LK_CANCEL_END	0x0000000a	/* stop canceling other requests */

/*
 * lk_count bit fields.
 *
 * Positive count is exclusive, negative count is shared.  The count field
 * must be large enough to accomodate all possible threads.
 */
#define LKC_RESERVED8	0x0000000080000000LU	/* (DNU, insn optimization) */
#define LKC_EXREQ	0x0000000040000000LU	/* waiting for excl lock */
#define LKC_SHARED	0x0000000020000000LU	/* shared lock(s) granted */
#define LKC_UPREQ	0x0000000010000000LU	/* waiting for upgrade */
#define LKC_EXREQ2	0x0000000008000000LU	/* multi-wait for EXREQ */
#define LKC_CANCEL	0x0000000004000000LU	/* cancel in effect */
#define LKC_XMASK	0x0000000003FFFFFFLU
#define LKC_SMASK	0xFFFFFFFF00000000LU
#define LKC_SCOUNT	0x0000000100000000LU
#define LKC_SSHIFT	32

/*
 * External lock flags.
 *
 * The first three flags may be set in lock_init to set their mode permanently,
 * or passed in as arguments to the lock manager.
 */
#define LK_EXTFLG_MASK	0x070000F0	/* mask of external flags */
#define LK_NOWAIT	0x00000010	/* do not sleep to await lock */
#define LK_SLEEPFAIL	0x00000020	/* sleep, then return failure */
#define LK_CANRECURSE	0x00000040	/* allow recursive exclusive lock */
#define LK_NOCOLLSTATS	0x00000080	/* v_lock_coll not applicable */
#define	LK_CANCELABLE	0x01000000	/* blocked caller can be canceled */
#define LK_TIMELOCK	0x02000000
#define LK_PCATCH	0x04000000	/* timelocked with signal catching */

/*
 * Control flags
 *
 * Non-persistent external flags.
 */
#define LK_FAILRECLAIM	0x00010000 /* vn_lock: allowed to fail on reclaim */
#define LK_RETRY	0x00020000 /* vn_lock: retry until locked */
#define	LK_UNUSED40000	0x00040000
#define	LK_UNUSED80000	0x00080000

/*
 * Lock return status.
 *
 * Successfully obtained locks return 0. Locks will always succeed
 * unless one of the following is true:
 *	LK_FORCEUPGRADE is requested and some other process has already
 *	    requested a lock upgrade (returns EBUSY).
 *	LK_WAIT is set and a sleep would be required (returns EBUSY).
 *	LK_SLEEPFAIL is set and a sleep was done (returns ENOLCK).
 *	PCATCH is set in lock priority and a signal arrives (returns
 *	    either EINTR or ERESTART if system calls is to be restarted).
 *	Non-null lock timeout and timeout expires (returns EWOULDBLOCK).
 * A failed lock attempt always returns a non-zero error value. No lock
 * is held after an error return (in particular, a failed LK_UPGRADE
 * or LK_FORCEUPGRADE will have released its shared access lock).
 */

/*
 * Indicator that no process holds exclusive lock
 */
#define LK_KERNTHREAD ((struct thread *)-2)

#ifdef _KERNEL

void dumplockinfo(struct lock *lkp);
struct proc;

struct lock_args {
	struct lock	*la_lock;
	const char 	*la_desc;
	int		la_flags;
};

#define LOCK_INITIALIZER(wmesg, timo, flags)	\
{						\
	.lk_flags = ((flags) & LK_EXTFLG_MASK),	\
	.lk_timo = (timo),			\
	.lk_count = 0,				\
	.lk_wmesg = wmesg,			\
	.lk_lockholder = NULL			\
}

void	lockinit (struct lock *, const char *wmesg, int timo, int flags);
void	lockreinit (struct lock *, const char *wmesg, int timo, int flags);
void	lockuninit(struct lock *);
void	lock_sysinit(struct lock_args *);
int	lockmgr_shared (struct lock *, u_int flags);
int	lockmgr_exclusive (struct lock *, u_int flags);
int	lockmgr_downgrade (struct lock *, u_int flags);
int	lockmgr_upgrade (struct lock *, u_int flags);
int	lockmgr_release (struct lock *, u_int flags);
int	lockmgr_cancel_beg (struct lock *, u_int flags);
int	lockmgr_cancel_end (struct lock *, u_int flags);
void	lockmgr_kernproc (struct lock *);
void	lockmgr_printinfo (struct lock *);
int	lockstatus (struct lock *, struct thread *);
int	lockowned (struct lock *);

#define	LOCK_SYSINIT(name, lock, desc, flags)				\
	static struct lock_args name##_args = {				\
		(lock),							\
		(desc),							\
		(flags)							\
	};								\
	SYSINIT(name##_lock_sysinit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE,	\
	    lock_sysinit, &name##_args);				\
	SYSUNINIT(name##_lock_sysuninit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, \
	    lockuninit, (lock))

/*
 * Most lockmgr() calls pass a constant flags parameter which
 * we can optimize-out with an inline.
 */
static __inline
int
lockmgr(struct lock *lkp, u_int flags)
{
	switch (flags & LK_TYPE_MASK) {
	case LK_SHARED:
		return lockmgr_shared(lkp, flags);
	case LK_EXCLUSIVE:
		return lockmgr_exclusive(lkp, flags);
	case LK_DOWNGRADE:
		return lockmgr_downgrade(lkp, flags);
	case LK_EXCLUPGRADE:
	case LK_UPGRADE:
		return lockmgr_upgrade(lkp, flags);
	case LK_RELEASE:
		return lockmgr_release(lkp, flags);
	case LK_CANCEL_BEG:
		return lockmgr_cancel_beg(lkp, flags);
	case LK_CANCEL_END:
		return lockmgr_cancel_end(lkp, flags);
	default:
		panic("lockmgr: unknown locktype request %d",
		      flags & LK_TYPE_MASK);
		return EINVAL;	/* NOT REACHED */
	}
}

/*
 * Returns non-zero if the lock is in-use.  Cannot be used to count
 * refs on a lock (refs cannot be safely counted due to the use of
 * atomic_fetchadd_int() for shared locks.
 */
static __inline
int
lockinuse(struct lock *lkp)
{
	return ((lkp->lk_count & (LKC_SMASK | LKC_XMASK)) != 0);
}

/*
 * Returns true if the lock was acquired. Can be used to port
 * FreeBSD's mtx_trylock() and similar functions.
 */
static __inline
boolean_t
lockmgr_try(struct lock *lkp, u_int flags)
{
	return (lockmgr(lkp, flags | LK_NOWAIT) == 0);
}

/*
 * Returns true if the lock is exclusively held by anyone
 */
static __inline
boolean_t
lockmgr_anyexcl(struct lock *lkp)
{
	return ((lkp->lk_count & LKC_XMASK) != 0);
}

static __inline
boolean_t
lockmgr_oneexcl(struct lock *lkp)
{
	return ((lkp->lk_count & LKC_XMASK) == 1);
}

static __inline
boolean_t
lockmgr_exclpending(struct lock *lkp)
{
	return ((lkp->lk_count & (LKC_EXREQ | LKC_EXREQ2)) != 0);
}

#endif /* _KERNEL */
#endif /* _KERNEL || _KERNEL_STRUCTURES */
#endif /* _SYS_LOCK_H_ */