/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <mdb/mdb_modapi.h>
#include <mdb/mdb_ctf.h>

#include <configd.h>

mdb_ctf_id_t request_enum;
mdb_ctf_id_t response_enum;
mdb_ctf_id_t ptr_type_enum;
mdb_ctf_id_t thread_state_enum;

hrtime_t max_time_seen;

static void
enum_lookup(char *out, size_t size, mdb_ctf_id_t id, int val,
    const char *prefix, const char *prefix2)
{
	const char *cp;
	size_t len = strlen(prefix);
	size_t len2 = strlen(prefix2);

	if ((cp = mdb_ctf_enum_name(id, val)) != NULL) {
		if (strncmp(cp, prefix, len) == 0)
			cp += len;
		if (strncmp(cp, prefix2, len2) == 0)
			cp += len2;
		(void) strlcpy(out, cp, size);
	} else {
		mdb_snprintf(out, size, "? (%d)", val);
	}
}

static void
make_lower(char *out, size_t sz)
{
	while (*out != 0 && sz > 0) {
		if (*out >= 'A' && *out <= 'Z')
			*out += 'a' - 'A';
		out++;
		sz--;
	}
}

/*ARGSUSED*/
static int
configd_status(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	int num_servers;
	int num_started;

	if (argc != 0)
		return (DCMD_USAGE);

	if (mdb_readvar(&num_servers, "num_servers") == -1) {
		mdb_warn("unable to read num_servers");
		return (DCMD_ERR);
	}
	if (mdb_readvar(&num_started, "num_started") == -1) {
		mdb_warn("unable to read num_started");
		return (DCMD_ERR);
	}
	mdb_printf(
	    "\nserver threads:\t%d running, %d starting\n\n", num_servers,
	    num_started - num_servers);

	if (mdb_walk_dcmd("configd_threads", "configd_thread", argc,
	    argv) == -1) {
		mdb_warn("can't walk 'configd_threads'");
		return (DCMD_ERR);
	}
	return (DCMD_OK);
}

/*ARGSUSED*/
static int
configd_thread(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	thread_info_t t;
	char state[20];
	char oldstate[20];

	if (!(flags & DCMD_ADDRSPEC)) {
		if (mdb_walk_dcmd("configd_threads", "configd_thread", argc,
		    argv) == -1) {
			mdb_warn("can't walk 'configd_threads'");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}

	if (argc != 0)
		return (DCMD_USAGE);

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("%<u>%-?s %5s %-12s %-12s %-?s %-?s %-?s%</u>\n",
		    "ADDR", "TID", "STATE", "PREV_STATE", "CLIENT", "CLIENTRQ",
		    "MAINREQ");
	}

	if (mdb_vread(&t, sizeof (t), addr) == -1) {
		mdb_warn("failed to read thread_info_t at %p", addr);
		return (DCMD_ERR);
	}

	enum_lookup(state, sizeof (state), thread_state_enum,
	    t.ti_state, "TI_", "");
	make_lower(state, sizeof (state));

	enum_lookup(oldstate, sizeof (oldstate), thread_state_enum,
	    t.ti_prev_state, "TI_", "");
	make_lower(oldstate, sizeof (oldstate));

	mdb_printf("%0?p %5d %-12s %-12s %?p %?p %?p\n",
	    (void *)addr, t.ti_thread, state, oldstate,
	    t.ti_active_client, t.ti_client_request, t.ti_main_door_request);

	return (DCMD_OK);
}

static int
walk_thread_info_init(mdb_walk_state_t *wsp)
{
	if (mdb_readvar(&wsp->walk_addr, "thread_list") == -1) {
		mdb_warn("unable to read thread_list");
		return (WALK_ERR);
	}

	if (mdb_layered_walk("uu_list_node", wsp) == -1) {
		mdb_warn("couldn't walk 'uu_list_node'");
		return (WALK_ERR);
	}

	return (WALK_NEXT);
}

static int
walk_thread_info_step(mdb_walk_state_t *wsp)
{
	uintptr_t addr = wsp->walk_addr;
	thread_info_t ti;

	if (mdb_vread(&ti, sizeof (ti), addr) == -1) {
		mdb_warn("unable to read thread_info_t at %p", addr);
		return (WALK_ERR);
	}

	return (wsp->walk_callback(addr, &ti, wsp->walk_cbdata));
}

static int
request_log(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	request_log_entry_t cur;
	hrtime_t dur;
	hrtime_t dursec;
	hrtime_t durnsec;
	char durstr[20];
	char stampstr[20];
	char requstr[30];
	char respstr[30];
	char typestr[30];
	uintptr_t node = 0;
	uintptr_t client = 0;
	uint64_t clientid = 0;

	int idx;
	int opt_v = FALSE;			/* verbose */

	if (!(flags & DCMD_ADDRSPEC)) {
		if (mdb_walk_dcmd("configd_log", "configd_log", argc,
		    argv) == -1) {
			mdb_warn("can't walk 'configd_log'");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}

	if (mdb_getopts(argc, argv,
	    'c', MDB_OPT_UINTPTR, &client,
	    'i', MDB_OPT_UINT64, &clientid,
	    'n', MDB_OPT_UINTPTR, &node,
	    'v', MDB_OPT_SETBITS, TRUE, &opt_v, NULL) != argc)
		return (DCMD_USAGE);

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("%<u>%-?s %-4s %-14s %9s %-22s %-17s\n%</u>",
		    "ADDR", "THRD", "START", "DURATION", "REQUEST",
		    "RESPONSE");
	}

	if (mdb_vread(&cur, sizeof (cur), addr) == -1) {
		mdb_warn("couldn't read log entry at %p", addr);
		return (DCMD_ERR);
	}

	/*
	 * apply filters, if any.
	 */
	if (clientid != 0 && clientid != cur.rl_clientid)
		return (DCMD_OK);

	if (client != 0 && client != (uintptr_t)cur.rl_client)
		return (DCMD_OK);

	if (node != 0) {
		for (idx = 0; idx < MIN(MAX_PTRS, cur.rl_num_ptrs); idx++) {
			if ((uintptr_t)cur.rl_ptrs[idx].rlp_data == node) {
				node = 0;		/* found it */
				break;
			}
		}
		if (node != 0)
			return (DCMD_OK);
	}

	enum_lookup(requstr, sizeof (requstr), request_enum, cur.rl_request,
	    "REP_PROTOCOL_", "");

	if (cur.rl_end != 0) {
		enum_lookup(respstr, sizeof (respstr), response_enum,
		    cur.rl_response, "REP_PROTOCOL_", "FAIL_");

		dur = cur.rl_end - cur.rl_start;
		dursec = dur / NANOSEC;
		durnsec = dur % NANOSEC;

		if (dursec <= 9)
			mdb_snprintf(durstr, sizeof (durstr),
			    "%lld.%06lld",
			    dursec, durnsec / (NANOSEC / MICROSEC));
		else if (dursec <= 9999)
			mdb_snprintf(durstr, sizeof (durstr),
			    "%lld.%03lld",
			    dursec, NSEC2MSEC(durnsec));
		else
			mdb_snprintf(durstr, sizeof (durstr),
			    "%lld", dursec);
	} else {
		(void) strcpy(durstr, "-");
		(void) strcpy(respstr, "-");
	}

	if (max_time_seen != 0 && max_time_seen >= cur.rl_start) {
		dur = max_time_seen - cur.rl_start;
		dursec = dur / NANOSEC;
		durnsec = dur % NANOSEC;

		if (dursec <= 99ULL)
			mdb_snprintf(stampstr, sizeof (stampstr),
			    "-%lld.%09lld", dursec, durnsec);
		else if (dursec <= 99999ULL)
			mdb_snprintf(stampstr, sizeof (stampstr),
			    "-%lld.%06lld",
			    dursec, durnsec / (NANOSEC / MICROSEC));
		else if (dursec <= 99999999ULL)
			mdb_snprintf(stampstr, sizeof (stampstr),
			    "-%lld.%03lld",
			    dursec, NSEC2MSEC(durnsec));
		else
			mdb_snprintf(stampstr, sizeof (stampstr),
			    "-%lld", dursec);
	} else {
		(void) strcpy(stampstr, "-");
	}

	mdb_printf("%0?x %4d T%13s %9s %-22s %-17s\n",
	    addr, cur.rl_tid, stampstr, durstr, requstr, respstr);

	if (opt_v) {
		mdb_printf("\tclient: %?p (%d)\tptrs: %d\tstamp: %llx\n",
		    cur.rl_client, cur.rl_clientid, cur.rl_num_ptrs,
		    cur.rl_start);
		for (idx = 0; idx < MIN(MAX_PTRS, cur.rl_num_ptrs); idx++) {
			enum_lookup(typestr, sizeof (typestr), ptr_type_enum,
			    cur.rl_ptrs[idx].rlp_type, "RC_PTR_TYPE_", "");
			mdb_printf("\t\t%-7s %5d %?p %?p\n", typestr,
			    cur.rl_ptrs[idx].rlp_id, cur.rl_ptrs[idx].rlp_ptr,
			    cur.rl_ptrs[idx].rlp_data);
		}
		mdb_printf("\n");
	}
	return (DCMD_OK);
}

struct request_log_walk {
	size_t		rlw_max;
	size_t		rlw_count;
	size_t		rlw_cur;
	struct request_entry {
		hrtime_t  timestamp;
		uintptr_t addr;
	}		*rlw_list;
};

/*
 * we want newer items at the top
 */
static int
request_entry_compare(const void *l, const void *r)
{
	const struct request_entry *lp = l;
	const struct request_entry *rp = r;

	if (rp->timestamp == lp->timestamp)
		return (0);

	/*
	 * 0 timestamps go first.
	 */
	if (rp->timestamp == 0)
		return (1);
	if (lp->timestamp == 0)
		return (-1);

	if (lp->timestamp < rp->timestamp)
		return (1);
	return (-1);
}

/*ARGSUSED*/
static int
request_log_count_thread(uintptr_t addr, thread_info_t *tip, uint_t *arg)
{
	(*arg)++;

	return (WALK_NEXT);
}

static int
request_log_add_thread(uintptr_t addr, thread_info_t *tip,
    struct request_entry **arg)
{
	if (max_time_seen < tip->ti_log.rl_start)
		max_time_seen = tip->ti_log.rl_start;

	if (max_time_seen < tip->ti_log.rl_end)
		max_time_seen = tip->ti_log.rl_end;

	if (tip->ti_log.rl_start != 0) {
		if (tip->ti_log.rl_end)
			(*arg)->timestamp = tip->ti_log.rl_start;
		else
			(*arg)->timestamp = 0;		/* sort to the top */

		(*arg)->addr = addr + offsetof(thread_info_t, ti_log);
		++*arg;
	}
	return (WALK_NEXT);
}

static int
request_log_walk_init(mdb_walk_state_t *wsp)
{
	struct request_log_walk *rlw;
	struct request_entry *list, *listp;

	uint_t log_size;
	uint_t size;
	uint_t idx;
	uint_t pos;
	request_log_entry_t *base;
	request_log_entry_t cur;

	if (mdb_readvar(&base, "request_log") == -1) {
		mdb_warn("couldn't read 'request_log'");
		return (WALK_ERR);
	}
	if (mdb_readvar(&log_size, "request_log_size") == -1) {
		mdb_warn("couldn't read 'request_log_size'");
		return (WALK_ERR);
	}
	size = log_size;

	if (mdb_walk("configd_threads", (mdb_walk_cb_t)request_log_count_thread,
	    &size) == -1) {
		mdb_warn("couldn't walk 'configd_threads'");
		return (WALK_ERR);
	}

	list = mdb_zalloc(sizeof (*list) * size, UM_SLEEP);
	listp = list;

	if (mdb_walk("configd_threads", (mdb_walk_cb_t)request_log_add_thread,
	    &listp) == -1) {
		mdb_warn("couldn't walk 'configd_threads'");
		mdb_free(list, sizeof (*list) * size);
		return (WALK_ERR);
	}

	pos = listp - list;
	for (idx = 0; idx < log_size; idx++) {
		uintptr_t addr = (uintptr_t)&base[idx];
		if (mdb_vread(&cur, sizeof (cur), addr) == -1) {
			mdb_warn("couldn't read log entry at %p", addr);
			mdb_free(list, sizeof (*list) * size);
			return (WALK_ERR);
		}

		if (max_time_seen < cur.rl_start)
			max_time_seen = cur.rl_start;

		if (max_time_seen < cur.rl_end)
			max_time_seen = cur.rl_end;

		if (cur.rl_start != 0) {
			list[pos].timestamp = cur.rl_start;
			list[pos].addr = addr;
			pos++;
		}
	}
	qsort(list, pos, sizeof (*list), &request_entry_compare);

	rlw = mdb_zalloc(sizeof (*rlw), UM_SLEEP);
	rlw->rlw_max = size;
	rlw->rlw_count = pos;
	rlw->rlw_cur = 0;
	rlw->rlw_list = list;

	wsp->walk_data = rlw;

	return (WALK_NEXT);
}

static int
request_log_walk_step(mdb_walk_state_t *wsp)
{
	struct request_log_walk *rlw = wsp->walk_data;
	uintptr_t addr;
	request_log_entry_t cur;

	if (rlw->rlw_cur >= rlw->rlw_count)
		return (WALK_DONE);

	addr = rlw->rlw_list[rlw->rlw_cur++].addr;

	if (mdb_vread(&cur, sizeof (cur), addr) == -1) {
		mdb_warn("couldn't read log entry at %p", addr);
		return (WALK_ERR);
	}
	return (wsp->walk_callback(addr, &cur, wsp->walk_cbdata));
}

static void
request_log_walk_fini(mdb_walk_state_t *wsp)
{
	struct request_log_walk *rlw = wsp->walk_data;

	mdb_free(rlw->rlw_list, sizeof (*rlw->rlw_list) * rlw->rlw_max);
	mdb_free(rlw, sizeof (*rlw));
}

static const mdb_dcmd_t dcmds[] = {
	{ "configd_status", NULL, "svc.configd status summary",
	    configd_status },
	{ "configd_thread", "?", "Print a thread_info_t tabularly",
	    configd_thread },
	{ "configd_log", "?[-v] [-c clientptr] [-i clientid]",
	    "Print the request log, or a single entry", request_log },
	{ NULL }
};

static const mdb_walker_t walkers[] = {
	{ "configd_threads", "walks the thread_info_ts for all "
	    "threads", walk_thread_info_init, walk_thread_info_step },
	{ "configd_log", "walks the request_log_entry_ts",
	    request_log_walk_init, request_log_walk_step,
	    request_log_walk_fini},
	{ NULL }
};

static const mdb_modinfo_t modinfo = {
	MDB_API_VERSION, dcmds, walkers
};

const mdb_modinfo_t *
_mdb_init(void)
{
	if (mdb_ctf_lookup_by_name("enum rep_protocol_requestid",
	    &request_enum) == -1) {
		mdb_warn("enum rep_protocol_requestid not found");
	}
	if (mdb_ctf_lookup_by_name("enum rep_protocol_responseid",
	    &response_enum) == -1) {
		mdb_warn("enum rep_protocol_responseid not found");
	}
	if (mdb_ctf_lookup_by_name("enum rc_ptr_type",
	    &ptr_type_enum) == -1) {
		mdb_warn("enum rc_ptr_type not found");
	}
	if (mdb_ctf_lookup_by_name("enum thread_state",
	    &thread_state_enum) == -1) {
		mdb_warn("enum thread_state not found");
	}
	return (&modinfo);
}