xref: /dflybsd-src/sys/sys/exislock2.h (revision 45270dd1e4c4f5fc2f0035f791edef2327aefec7)

/*
 * Copyright (c) 2020 The DragonFly Project.  All rights reserved.
 *
 * 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 DragonFly Project 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 COPYRIGHT HOLDERS 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
 * COPYRIGHT HOLDERS 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_EXISLOCK2_H_
#define	_SYS_EXISLOCK2_H_

#ifndef _SYS_GLOBALDATA_H_
#include <sys/globaldata.h>
#endif
#ifndef _MACHINE_THREAD_H_
#include <machine/thread.h>
#endif

/*
 * Initialize the structure.  To reduce confusion we also have exis_setlive()
 * when repurposing a structure, which does the same thing.
 */
static __inline void
exis_init(exislock_t *xlk)
{
	xlk->pseudo_ticks = 0;
}

static __inline void
exis_setlive(exislock_t *xlk)
{
	xlk->pseudo_ticks = 0;
}

/*
 * pcpu exis lock API.  Enter and and exit a type-safe critical section.
 */
static __inline void
exis_hold_gd(globaldata_t gd)
{
	++gd->gd_exislockcnt;
}

static __inline void
exis_drop_gd(globaldata_t gd)
{
	if (--gd->gd_exislockcnt == 0)
		gd->gd_exisarmed = 1;
}

static __inline void
exis_hold(void)
{
	exis_hold_gd(mycpu);
}

static __inline void
exis_drop(void)
{
	exis_drop_gd(mycpu);
}

/*
 * poll whether the object is usable or not.  A value >= 0 indicates that
 * the (possibly cached) object is usable.
 *
 * This call returns the approximate number of pseudo_ticks remaining until
 * the object becomes unusable, +/- one.
 *
 * The actual value returns is either >= 0, or a negative number.  Caller
 * should refrain from trying to interpret values >= 0 other than the fact
 * that they are >= 0.
 *
 * Negative numbers indicate the number of pseudo_ticks which have occurred
 * since the object became unusable.  Various negative values trigger
 * different actions.
 */
static __inline long
exis_poll(exislock_t *xlk)
{
	long val = xlk->pseudo_ticks;

	cpu_ccfence();
	if (val == 0)
		return val;
	return (val - pseudo_ticks);
}

/*
 * Return the current state.  Note that the NOTCACHED state persists for
 * two pseudo_ticks.  This is done because the global pseudo_ticks counter
 * can concurrently increment by 1 (but no more than 1) during a type-safe
 * critical section.
 *
 * The state can transition even while holding a type-safe critical section,
 * but sequencing is designed such that this does not cause any problems.
 */
static __inline int
exis_state(exislock_t *xlk)
{
	long val = xlk->pseudo_ticks;

	cpu_ccfence();
	if (val == 0)
		return EXIS_LIVE;
	val = val - pseudo_ticks;
	if (val >= 0)
		return EXIS_CACHED;
	if (val >= -2)
		return EXIS_NOTCACHED;
	return EXIS_TERMINATE;
}

/*
 * Returns non-zero if the structure is usable (either LIVE or CACHED).
 *
 * WARNING! The structure is not considered to be usable if it is in
 *	    an UNCACHED state, but if it is CACHED and transitions to
 *	    UNCACHED during a type-safe critical section it does remain
 *	    usable for the duration of that type-safe critical section.
 */
static __inline int
exis_usable(exislock_t *xlk)
{
	return (exis_poll(xlk) >= 0);
}

/*
 * Returns non-zero if the structure can be destroyed
 */
static __inline int
exis_freeable(exislock_t *xlk)
{
	return (exis_poll(xlk) <= -2);
}

/*
 * If the structure is in a LIVE or CACHED state, or if it was CACHED and
 * concurrently transitioned to NOTCACHED in the same type-safe critical
 * section, the state will be reset to a CACHED(n) state and non-zero is
 * returned.
 *
 * Otherwise 0 is returned and no action is taken.
 */
static __inline int
exis_cache(exislock_t *xlk, long n)
{
	long val = xlk->pseudo_ticks;
	long pticks = pseudo_ticks;

	cpu_ccfence();
	if (val)
		val = val - pticks;
	if (val >= -1) {
		/*
		 * avoid cache line ping-pong
		 */
		pticks += n + 1;
		if (xlk->pseudo_ticks != pticks) {
			cpu_ccfence();
			xlk->pseudo_ticks = pticks;
		}
		return 1;
	}
	return 0;
}

/*
 * The current state of the structure is ignored and the srtucture is
 * placed in a CACHED(0) state.  It will automatically sequence through
 * the NOTCACHED and TERMINATE states as psuedo_ticks increments.
 *
 * The NOTCACHED state is an indeterminant state, since the pseudo_ticks
 * counter might already be armed for increment, it can increment at least
 * once while code is inside an exis_hold().  The TERMINATE state occurs
 * at the second tick.
 *
 * If the caller repurposes the structure, it is usually a good idea to
 * place it back into a LIVE state by calling exis_setlive().
 */
static __inline void
exis_terminate(exislock_t *xlk)
{
	xlk->pseudo_ticks = pseudo_ticks - 1;
}

#endif /* !_SYS_EXISLOCK2_H_ */