/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2026 Oxide Computer Company
 */

/*
 * This program operates alongside agent_target.c and verifies that libproc
 * can destroy the agent lwp even when an injected system call has to be
 * abandoned part-way through. The private _libproc_test_fail_copyinargs
 * flag makes Psyscall() treat the construction of the injected call's
 * stack frame as failed, which leaves the agent stopped on entry to that
 * call. libproc must abort the pending call and terminate the agent,
 * leaving the target undamaged and controllable. It must do so even
 * though the same failure applies to the _lwp_exit() injection which is
 * used to terminate the agent.
 *
 * Historically this went wrong in two ways. Pdestroy_agent() did not abort
 * a system call latched at an entry stop, so the agent was resumed with the
 * abandoned call still pending and ran off into arbitrary code, crashing or
 * silently corrupting the target. With that fixed, a failure to construct
 * the _lwp_exit() frame abandoned the teardown instead, orphaning the agent
 * and leaving the target stopped forever, since run-on-last-close is
 * skipped for a process which still has an agent lwp. On a libproc with
 * either defect this test crashes the target, or hangs and is timed out by
 * the test runner.
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <limits.h>
#include <err.h>
#include <errno.h>
#include <libproc.h>
#include <sys/wait.h>
#include <sys/resource.h>
#include <sys/stat.h>

extern int _libproc_test_fail_copyinargs;

static uint_t at_timeout = 5 * 1000; /* 5s in ms */

/*
 * Verify that the target has no agent lwp, according to both libproc's
 * cached status and the kernel.
 */
static bool
agent_absent(struct ps_prochandle *P)
{
	char path[PATH_MAX];
	struct stat st;

	if (Pstatus(P)->pr_agentid != 0) {
		warnx("TEST FAILED: pstatus reports an agent lwp (id %d)",
		    (int)Pstatus(P)->pr_agentid);
		return (false);
	}

	(void) snprintf(path, sizeof (path), "/proc/%d/lwp/agent",
	    (int)Pstatus(P)->pr_pid);
	if (stat(path, &st) == 0) {
		warnx("TEST FAILED: %s exists: the agent lwp was orphaned",
		    path);
		return (false);
	} else if (errno != ENOENT) {
		warn("TEST FAILED: unexpected error from stat(%s)", path);
		return (false);
	}

	return (true);
}

static bool
agent_checks(struct ps_prochandle *P)
{
	bool ret = true;
	struct rlimit rl;

	/*
	 * Baseline: a normal injection, and with it a full agent
	 * create/destroy cycle, must work.
	 */
	if (pr_getrlimit(P, RLIMIT_NOFILE, &rl) != 0) {
		warn("TEST FAILED: baseline pr_getrlimit() injection failed");
		ret = false;
	} else {
		(void) printf("TEST PASSED: baseline injection succeeded\n");
	}

	if (!agent_absent(P))
		ret = false;

	/*
	 * Force the write which constructs the injected call's stack frame
	 * to fail. The injection itself must fail cleanly, and libproc must
	 * still manage to abort the pending system call and destroy the
	 * agent.
	 */
	_libproc_test_fail_copyinargs = 1;

	if (pr_getrlimit(P, RLIMIT_NOFILE, &rl) == 0) {
		warnx("TEST FAILED: injection unexpectedly succeeded with "
		    "_libproc_test_fail_copyinargs set");
		ret = false;
	} else {
		(void) printf("TEST PASSED: injection failed with "
		    "_libproc_test_fail_copyinargs set\n");
	}

	_libproc_test_fail_copyinargs = 0;

	if (!agent_absent(P)) {
		ret = false;
	} else {
		(void) printf("TEST PASSED: agent destroyed after failed "
		    "injection\n");
	}

	/*
	 * The target must still be intact and controllable.
	 */
	if (pr_getrlimit(P, RLIMIT_NOFILE, &rl) != 0) {
		warn("TEST FAILED: pr_getrlimit() injection failed following "
		    "recovery");
		ret = false;
	} else {
		(void) printf("TEST PASSED: injection succeeded following "
		    "recovery\n");
	}

	if (!agent_absent(P))
		ret = false;

	return (ret);
}

int
main(int argc, char *argv[])
{
	int ret = EXIT_SUCCESS, perr, wstat;
	struct ps_prochandle *P;
	GElf_Sym sym;
	ulong_t bkpt;
	pid_t pid;

	if (argc != 2) {
		errx(EXIT_FAILURE, "missing required program to inject "
		    "against");
	}

	P = Pcreate(argv[1], &argv[1], &perr, NULL, 0);
	if (P == NULL) {
		errx(EXIT_FAILURE, "failed to create %s: %s (0x%x)", argv[1],
		    Pcreate_error(perr), perr);
	}

	(void) Punsetflags(P, PR_RLC);
	if (Psetflags(P, PR_KLC | PR_BPTADJ) != 0) {
		int e = errno;
		Prelease(P, PRELEASE_KILL);
		errc(EXIT_FAILURE, e, "failed to set PR_KLC | PR_BPTADJ flags");
	}

	if (Pxlookup_by_name(P, LM_ID_BASE, PR_OBJ_EXEC, "agent_target_hook",
	    &sym, NULL) != 0) {
		err(EXIT_FAILURE, "failed to find agent_target_hook symbol");
	}

	pid = Ppsinfo(P)->pr_pid;

	if (Pfault(P, FLTBPT, 1) != 0)
		errx(EXIT_FAILURE, "failed to set the FLTBPT disposition");

	if (Psetbkpt(P, sym.st_value, &bkpt) != 0) {
		err(EXIT_FAILURE, "failed to set breakpoint on "
		    "agent_target_hook (0x%" PRIx64 ")", sym.st_value);
	}

	if (Psetrun(P, 0, 0) != 0)
		err(EXIT_FAILURE, "failed to resume running our target");

	if (Pwait(P, at_timeout) != 0) {
		err(EXIT_FAILURE, "%s did not hit our expected breakpoint",
		    argv[1]);
	}

	/*
	 * The target is stopped at the breakpoint. Run the injections.
	 */
	if (!agent_checks(P))
		ret = EXIT_FAILURE;

	if (Pdelbkpt(P, sym.st_value, bkpt) != 0)
		err(EXIT_FAILURE, "failed to delete breakpoint");

	if (Psetrun(P, 0, PRCFAULT) != 0)
		err(EXIT_FAILURE, "failed to resume running our target");

	if (waitpid(pid, &wstat, 0) != pid) {
		err(EXIT_FAILURE, "failed to get our %s's (%" _PRIdID "), "
		    "wait info", argv[1], pid);
	}

	if (WIFEXITED(wstat) == 0)
		errx(EXIT_FAILURE, "%s didn't actually exit!", argv[1]);

	if (WEXITSTATUS(wstat) != 0) {
		errx(EXIT_FAILURE, "%s failed with 0x%x", argv[1],
		    WEXITSTATUS(wstat));
	} else {
		(void) printf("TEST PASSED: target ran to completion "
		    "undamaged\n");
	}

	if (ret == EXIT_SUCCESS)
		(void) printf("All tests passed successfully\n");

	return (ret);
}