// SPDX-License-Identifier: GPL-2.0-or-later
/******************************************************************************
 *
 * futex_lock_pi_exiting.c
 *
 * Coverage for the FUTEX_LOCK_PI owner-exiting path.  futex_wait_timeout.c
 * already covers FUTEX_LOCK_PI timeout semantics and robust_list.c covers
 * owner death via the robust list, but nothing exercises FUTEX_LOCK_PI when a
 * non-robust PI owner exits while holding the lock, nor the basic ownership /
 * EDEADLK / unlock word semantics.
 *
 * DESCRIPTION
 *      Three tests:
 *
 *      1. lock_unlock_basic - uncontended FUTEX_LOCK_PI semantics: the futex
 *         word carries the owner TID, a recursive lock by the owner returns
 *         EDEADLK, and FUTEX_UNLOCK_PI clears the word.
 *
 *      2. owner_dies_with_blocked_waiter - a thread acquires a PI futex and
 *         exits while holding it.  do_exit() runs futex_cleanup_begin() (which
 *         flips the task's futex state to FUTEX_STATE_EXITING) and
 *         exit_pi_state_list() (which hands off / tears down the pi_state).  A
 *         contending FUTEX_LOCK_PI waiter must end up in one of:
 *
 *           0          - ownership was transferred to / acquired by the waiter
 *           EOWNERDEAD - previous owner died holding the lock; the caller is
 *                        now the owner and must acknowledge by unlocking
 *           ESRCH      - the owner encoded in the futex word is already gone
 *
 *         and on the first two it must actually own the lock afterwards.
 *
 *      3. stress_owner_exits - hammer that same exiting-owner path.  This is
 *         where the following bug lived: the 'exiting' task pointer was not
 *         reset at the retry label, so after wait_for_owner_exiting() dropped
 *         its reference a subsequent retry that returned a non-EBUSY error fed
 *         the stale pointer back in and tripped WARN_ON_ONCE(exiting).  That
 *         warning is invisible to user space, so this test cannot observe it
 *         through a syscall return value; it only becomes a visible failure
 *         (crash) on a kernel booted with panic_on_warn=1 (or built with
 *         CONFIG_BUG_ON_DATA_CORRUPTION).  The loop drives the path so that
 *         such a kernel trips on it - the canonical way fuzz/CI catch these.
 *
 *        Fix:    210d36d892de ("futex: Clear stale exiting pointer in
 *                              futex_lock_pi() retry path")
 *        Fixes:  3ef240eaff36 ("futex: Prevent exit livelock")
 *
 * AUTHOR
 *      Based on futex test boilerplate by Darren Hart <dvhart@linux.intel.com>
 *
 *****************************************************************************/

#define _GNU_SOURCE

#include <errno.h>
#include <pthread.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <sys/syscall.h>

#include "futextest.h"
#include "kselftest_harness.h"

/*
 * Iterations for the stress variant.  Enough to repeatedly land in the narrow
 * EXITING window while keeping the test fast.
 */
#define STRESS_ITERS 1000

static futex_t pi_futex;
static pthread_barrier_t locked_barrier;
static pthread_barrier_t release_barrier;

static pid_t sys_gettid(void)
{
	return syscall(SYS_gettid);
}

/*
 * Owner thread: acquire the PI futex and exit while still holding it.  Two
 * modes:
 *   park == 0: signal that we hold the lock, then exit immediately (racy; the
 *              waiter races against our exit path).
 *   park == 1: signal that we hold the lock and keep holding until released
 *              via release_barrier, so a waiter has time to contend as a real
 *              PI waiter before we die.
 */
static void *owner_thread(void *arg)
{
	long park = (long)arg;

	if (futex_lock_pi(&pi_futex, NULL, 0, FUTEX_PRIVATE_FLAG) != 0)
		return (void *)(intptr_t)-errno;

	pthread_barrier_wait(&locked_barrier);

	if (park)
		pthread_barrier_wait(&release_barrier);

	/* Die while still holding the lock. */
	pthread_exit((void *)0);
}

/*
 * Block on the PI futex as a waiter.  Returns 0 on acquisition, otherwise the
 * positive errno.
 */
static int waiter_lock_pi(void)
{
	int ret = futex_lock_pi(&pi_futex, NULL, 0, FUTEX_PRIVATE_FLAG);

	return ret == 0 ? 0 : errno;
}

static int outcome_ok(int outcome)
{
	return outcome == 0 || outcome == EOWNERDEAD || outcome == ESRCH;
}

/* Results published by waiter_thread() for the owning thread to assert on. */
static int waiter_outcome;
static int waiter_owns;

/*
 * Waiter thread for the blocked-waiter test.  Contends for the lock and, when
 * it acquires, records whether the futex word actually carries its TID and
 * releases the lock itself (FUTEX_UNLOCK_PI must run in the owning thread).
 */
static void *waiter_thread(void *arg)
{
	pid_t tid = sys_gettid();

	waiter_outcome = waiter_lock_pi();
	if (waiter_outcome == 0 || waiter_outcome == EOWNERDEAD) {
		waiter_owns = (pi_futex & FUTEX_TID_MASK) == (futex_t)tid;
		futex_unlock_pi(&pi_futex, FUTEX_PRIVATE_FLAG);
	}
	return NULL;
}

FIXTURE(lock_pi_exiting) {
};

FIXTURE_SETUP(lock_pi_exiting) {
}

FIXTURE_TEARDOWN(lock_pi_exiting) {
}

/*
 * Uncontended FUTEX_LOCK_PI semantics, fully deterministic.
 */
TEST_F(lock_pi_exiting, lock_unlock_basic)
{
	pid_t tid = sys_gettid();
	int ret;

	pi_futex = FUTEX_INITIALIZER;

	/* Acquire: we become the owner, our TID lands in the futex word. */
	ret = futex_lock_pi(&pi_futex, NULL, 0, FUTEX_PRIVATE_FLAG);
	ASSERT_EQ(ret, 0)
		TH_LOG("lock failed: errno=%d (%s)", errno, strerror(errno));
	ASSERT_EQ(pi_futex & FUTEX_TID_MASK, (futex_t)tid)
		TH_LOG("owner TID not in futex word: 0x%08x", pi_futex);

	/* A recursive lock by the owner must be refused, not deadlock. */
	errno = 0;
	ret = futex_lock_pi(&pi_futex, NULL, 0, FUTEX_PRIVATE_FLAG);
	ASSERT_EQ(ret, -1);
	ASSERT_EQ(errno, EDEADLK)
		TH_LOG("recursive lock: expected EDEADLK, got errno=%d", errno);

	/* Release: the futex word is handed back clean. */
	ret = futex_unlock_pi(&pi_futex, FUTEX_PRIVATE_FLAG);
	ASSERT_EQ(ret, 0)
		TH_LOG("unlock failed: errno=%d", errno);
	ASSERT_EQ(pi_futex, (futex_t)0)
		TH_LOG("futex word not cleared after unlock: 0x%08x", pi_futex);
}

/*
 * A PI waiter inherits the lock when the owner dies holding it.
 *
 * The owner parks while holding the lock, this thread contends for it, then
 * the owner exits.  The waiter must come out cleanly (no hang, no unexpected
 * error) and, when it acquires, must actually own the lock.
 */
TEST_F(lock_pi_exiting, owner_dies_with_blocked_waiter)
{
	pthread_t owner, waiter;

	pthread_barrier_init(&locked_barrier, NULL, 2);
	pthread_barrier_init(&release_barrier, NULL, 2);
	pi_futex = FUTEX_INITIALIZER;
	waiter_outcome = -1;
	waiter_owns = 0;

	ASSERT_EQ(pthread_create(&owner, NULL, owner_thread, (void *)1), 0);

	/* Wait until the owner actually holds the lock. */
	pthread_barrier_wait(&locked_barrier);

	/* Start the waiter and give it time to block as a real PI waiter. */
	ASSERT_EQ(pthread_create(&waiter, NULL, waiter_thread, NULL), 0);
	usleep(1000);

	/* Release the owner so it dies while the waiter is queued on it. */
	pthread_barrier_wait(&release_barrier);

	pthread_join(waiter, NULL);
	pthread_join(owner, NULL);

	ASSERT_TRUE(outcome_ok(waiter_outcome)) {
		TH_LOG("unexpected FUTEX_LOCK_PI outcome: %d (%s)",
		       waiter_outcome, strerror(waiter_outcome));
	}
	if (waiter_outcome == 0 || waiter_outcome == EOWNERDEAD) {
		ASSERT_TRUE(waiter_owns)
			TH_LOG("waiter acquired but futex word lacks its TID");
	}

	pthread_barrier_destroy(&locked_barrier);
	pthread_barrier_destroy(&release_barrier);
}

/*
 * Stress: repeatedly let an owner exit while a waiter contends for the lock.
 *
 * Each iteration drives the FUTEX_STATE_EXITING -> -EBUSY -> retry path that
 * the stale-'exiting'-pointer bug lived on (210d36d892de).  The warning it
 * fixed is invisible to user space, so on a normally-configured kernel both
 * the buggy and fixed kernels pass here; the point is to make a kernel booted
 * with panic_on_warn=1 trip during one of these iterations.
 */
TEST_F(lock_pi_exiting, stress_owner_exits)
{
	for (int i = 0; i < STRESS_ITERS; i++) {
		pthread_t owner;
		int outcome;

		pthread_barrier_init(&locked_barrier, NULL, 2);
		pi_futex = FUTEX_INITIALIZER;

		ASSERT_EQ(pthread_create(&owner, NULL, owner_thread, (void *)0), 0);

		/* Owner holds the lock; race FUTEX_LOCK_PI against its exit. */
		pthread_barrier_wait(&locked_barrier);

		outcome = waiter_lock_pi();
		ASSERT_TRUE(outcome_ok(outcome)) {
			TH_LOG("iter %d: unexpected outcome %d (%s)",
			       i, outcome, strerror(outcome));
		}
		if (outcome == 0 || outcome == EOWNERDEAD)
			futex_unlock_pi(&pi_futex, FUTEX_PRIVATE_FLAG);

		pthread_join(owner, NULL);
		pthread_barrier_destroy(&locked_barrier);
	}
}

TEST_HARNESS_MAIN