/*
 * 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 2019 Joyent, Inc.
 */

#include <mdb/mdb_modapi.h>
#include <mdb/mdb_ctf.h>
#include <sys/cpuvar.h>
#include <sys/x_call.h>

typedef struct {
		uint32_t xc_work_cnt;
		struct xc_msg *xc_curmsg;
		struct xc_msg *xc_msgbox;
		xc_data_t xc_data;
} mdb_xcall_machcpu_t;

typedef struct {
	processorid_t cpu_id;
	mdb_xcall_machcpu_t cpu_m;
} mdb_xcall_cpu_t;

typedef struct {
	uint_t xd_flags;
	processorid_t xd_cpu_id;
	size_t xd_msg_index;
	struct xc_msg xd_msgs[NCPU];
} xcall_data_t;

void
xcall_help(void)
{
	mdb_printf(
	    "Print all active cross-calls where the given CPU is the master.\n"
	    "The PEND column is ->xc_work_cnt, the pending message count -\n"
	    "this includes both master and slave messages.  For each\n"
	    "cross call, the message type and the slave CPU ID are shown.\n");
}

static int
cpu_id_to_addr(processorid_t cpun, uintptr_t *addrp)
{
	uintptr_t addr;
	GElf_Sym sym;

	if (mdb_lookup_by_name("cpu", &sym) == -1) {
		mdb_warn("failed to find symbol for 'cpu'");
		return (-1);
	}

	if (cpun * sizeof (uintptr_t) > sym.st_size)
		return (-1);

	addr = (uintptr_t)sym.st_value + cpun * sizeof (uintptr_t);

	if (mdb_vread(&addr, sizeof (addr), addr) == -1) {
		mdb_warn("failed to read cpu[%lu]", cpun);
		return (-1);
	}

	if (addr != (uintptr_t)NULL) {
		*addrp = addr;
		return (0);
	}

	return (-1);
}

static int
xcall_copy_msg(struct xc_msg *msg, xcall_data_t *data, boolean_t current)
{
	if (data->xd_msg_index >= NCPU) {
		mdb_warn("ran out of msg space: %lu >= %lu\n",
		    data->xd_msg_index, NCPU);
		return (-1);
	}

	bcopy(msg, &data->xd_msgs[data->xd_msg_index], sizeof (*msg));

	/*
	 * As we don't use .xc_next, store 'current' there.
	 */
	data->xd_msgs[data->xd_msg_index].xc_next = (void *)(uintptr_t)current;
	data->xd_msg_index++;
	return (0);
}

static int
xcall_get_msgs(uintptr_t addr, const void *wdata, void *priv)
{
	_NOTE(ARGUNUSED(wdata));
	xcall_data_t *data = priv;
	mdb_xcall_cpu_t xcpu = { 0, };
	struct xc_msg msg;
	uintptr_t msgaddr;

	if (mdb_ctf_vread(&xcpu, "unix`cpu_t", "mdb_xcall_cpu_t",
	    addr, MDB_CTF_VREAD_IGNORE_ABSENT) == -1)
		return (WALK_ERR);

	if (xcpu.cpu_m.xc_curmsg != NULL) {
		msgaddr = (uintptr_t)xcpu.cpu_m.xc_curmsg;

		if (mdb_vread(&msg, sizeof (msg), msgaddr) != sizeof (msg))
			return (WALK_ERR);

		if (msg.xc_master == data->xd_cpu_id) {
			if (data->xd_flags & DCMD_PIPE_OUT)
				mdb_printf("%p\n", msgaddr);
			else if (xcall_copy_msg(&msg, data, B_TRUE) != 0)
				return (WALK_ERR);
		}
	}

	for (msgaddr = (uintptr_t)xcpu.cpu_m.xc_msgbox;
	    msgaddr != (uintptr_t)NULL; msgaddr = (uintptr_t)msg.xc_next) {
		if (mdb_vread(&msg, sizeof (msg), msgaddr) != sizeof (msg))
			return (WALK_ERR);

		if (msg.xc_master != data->xd_cpu_id)
			continue;

		if (data->xd_flags & DCMD_PIPE_OUT)
			mdb_printf("%p\n", msgaddr);
		else if (xcall_copy_msg(&msg, data, B_FALSE) != 0)
			return (WALK_ERR);
	}

	return (WALK_NEXT);
}

static int
print_xcall_msg(struct xc_msg *msg)
{
	boolean_t current = (boolean_t)msg->xc_next;
	char indent[] = "        ";
	const char *cmd;

	switch (msg->xc_command) {
		case XC_MSG_ASYNC: cmd = "ASYNC"; break;
		case XC_MSG_CALL: cmd = "CALL"; break;
		case XC_MSG_SYNC: cmd = "SYNC"; break;
		case XC_MSG_FREE:cmd = "FREE"; break;
		case XC_MSG_WAITING: cmd = "WAITING"; break;
		case XC_MSG_RELEASED: cmd = "RELEASED"; break;
		case XC_MSG_DONE: cmd = "DONE"; break;
		default: cmd = "?"; break;
	}

	mdb_printf("%s %s%-*s %-6u\n", indent, current ? "*" : "",
	    9 - current, cmd, msg->xc_slave);
	return (0);
}

/*
 * Show all xcall messages where the master is the given CPU.
 *
 * As non-free messages can be on the slave's ->xc_msgbox or ->xc_curmsg, we
 * need to walk across all of them to find each message where ->xc_master
 * is our CPU ID.
 */
int
xcall_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	mdb_xcall_cpu_t xcpu = { 0, };
	xcall_data_t data = { 0, };

	if (mdb_getopts(argc, argv, NULL) != argc)
		return (DCMD_USAGE);

	/*
	 * Yep, this will re-collect all the messages each time.  Shrug.
	 */
	if (!(flags & DCMD_ADDRSPEC)) {
		if (mdb_pwalk_dcmd("cpu", "xcall", argc, argv, 0) == -1) {
			mdb_warn("can't walk CPUs");
			return (DCMD_ERR);
		}

		return (DCMD_OK);
	}

	if (addr < NCPU && cpu_id_to_addr((processorid_t)addr, &addr) != 0) {
		mdb_warn("invalid CPU ID %lu\n", addr);
		return (DCMD_ERR);
	}

	if (mdb_ctf_vread(&xcpu, "unix`cpu_t", "mdb_xcall_cpu_t",
	    addr, MDB_CTF_VREAD_IGNORE_ABSENT) == -1) {
		mdb_warn("couldn't read cpu 0x%lx", addr);
		return (DCMD_ERR);
	}

	data.xd_cpu_id = xcpu.cpu_id;
	data.xd_flags = flags;

	if (mdb_pwalk("cpu", xcall_get_msgs, &data, (uintptr_t)NULL) == -1) {
		mdb_warn("can't walk CPUs");
		return (DCMD_ERR);
	}

	if (flags & DCMD_PIPE_OUT)
		return (DCMD_OK);

	if (DCMD_HDRSPEC(flags))
		mdb_printf("%<u>%3s %4s %s%</u>\n", "CPU", "PEND", "HANDLER");

	if (data.xd_msg_index == 0) {
		mdb_printf("%3d %4d -\n",
		    xcpu.cpu_id, xcpu.cpu_m.xc_work_cnt);
		return (DCMD_OK);
	}

	mdb_printf("%3d %4d %a(%a, %a, %a)\n",
	    xcpu.cpu_id, xcpu.cpu_m.xc_work_cnt,
	    xcpu.cpu_m.xc_data.xc_func, xcpu.cpu_m.xc_data.xc_a1,
	    xcpu.cpu_m.xc_data.xc_a2, xcpu.cpu_m.xc_data.xc_a3);

	if (!(flags & DCMD_PIPE_OUT))
		mdb_printf("         %<u>%-9s %-6s%</u>\n", "COMMAND", "SLAVE");

	for (size_t i = 0; i < data.xd_msg_index; i++) {
		if (print_xcall_msg(&data.xd_msgs[i]) != 0)
			return (DCMD_ERR);
	}

	return (DCMD_OK);
}