/*
 * 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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <mdb/mdb_target.h>
#include <mdb/mdb_modapi.h>
#include <mdb/mdb_string.h>
#include <mdb/mdb.h>

#include <libproc.h>
#include <string.h>

/*ARGSUSED*/
void
cmd_event(mdb_tgt_t *t, int vid, void *s)
{
	if (s != NULL && mdb_eval(s) == -1)
		mdb_warn("failed to eval [ %d ] command \"%s\"", vid, s);
}

int
cmd_evset(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	uint_t setb = 0, clrb = 0;
	const char *opt_c = NULL;
	uint_t opt_F = FALSE;
	uintptr_t opt_n = 0;

	int *idv = mdb_zalloc(sizeof (int) * (argc + 1), UM_SLEEP | UM_GC);
	int idc = 0;

	int status = DCMD_OK;
	const char *p;
	void *data;
	int argi;

	if (flags & DCMD_ADDRSPEC)
		idv[idc++] = (int)(intptr_t)addr;

	/*
	 * Perform an initial pass through argv: we accumulate integer ids into
	 * idv, and compute a group of bits to set and a group to clear.
	 */
	while (argc != 0 && (argi = mdb_getopts(argc, argv,
	    'c', MDB_OPT_STR, &opt_c,
	    'd', MDB_OPT_SETBITS, MDB_TGT_SPEC_AUTODIS, &setb,
	    'D', MDB_OPT_SETBITS, MDB_TGT_SPEC_AUTODEL, &setb,
	    'e', MDB_OPT_SETBITS, MDB_TGT_SPEC_DISABLED, &clrb,
	    'F', MDB_OPT_SETBITS, TRUE, &opt_F,
	    'n', MDB_OPT_UINTPTR, &opt_n,
	    's', MDB_OPT_SETBITS, MDB_TGT_SPEC_AUTOSTOP, &setb,
	    't', MDB_OPT_SETBITS, MDB_TGT_SPEC_TEMPORARY, &setb,
	    'T', MDB_OPT_SETBITS, MDB_TGT_SPEC_STICKY, &setb,
	    NULL)) != argc) {

		argv += argi; /* advance past elements processed by getopts */
		argc -= argi; /* decrement argc by number of args processed */

		if (argv->a_type == MDB_TYPE_STRING) {
			if (argv->a_un.a_str[0] == '+') {
				for (p = argv->a_un.a_str + 1; *p != '\0'; ) {
					switch (*p++) {
					case 'd':
						clrb |= MDB_TGT_SPEC_AUTODIS;
						break;
					case 'D':
						clrb |= MDB_TGT_SPEC_AUTODEL;
						break;
					case 'e':
						setb |= MDB_TGT_SPEC_DISABLED;
						break;
					case 's':
						clrb |= MDB_TGT_SPEC_AUTOSTOP;
						break;
					case 't':
						clrb |= MDB_TGT_SPEC_TEMPORARY;
						break;
					case 'T':
						clrb |= MDB_TGT_SPEC_STICKY;
						break;
					default:
						mdb_warn("illegal option -- "
						    "+%c\n", p[-1]);
						return (DCMD_USAGE);
					}
				}
			} else if (argv->a_un.a_str[0] != '-') {
				idv[idc++] = (int)(intmax_t)
				    strtonum(argv->a_un.a_str, 10);
			} else
				return (DCMD_USAGE);
		} else
			idv[idc++] = (int)(intmax_t)argv->a_un.a_val;

		argc--;
		argv++;
	}

	if (idc == 0) {
		mdb_warn("expected one or more event IDs to be specified\n");
		return (DCMD_USAGE);
	}

	/*
	 * If -n was not specified, then -d means "disable now" instead of
	 * meaning "set auto-disable after n hits".
	 */
	if (opt_n == 0 && (setb & MDB_TGT_SPEC_AUTODIS))
		setb = (setb & ~MDB_TGT_SPEC_AUTODIS) | MDB_TGT_SPEC_DISABLED;

	while (idc-- != 0) {
		mdb_tgt_spec_desc_t sp;
		int id = *idv++;

		bzero(&sp, sizeof (mdb_tgt_spec_desc_t));
		(void) mdb_tgt_vespec_info(mdb.m_target, id, &sp, NULL, 0);
		data = sp.spec_data;

		if (opt_F == FALSE && (sp.spec_flags & MDB_TGT_SPEC_HIDDEN)) {
			mdb_warn("cannot modify event %d: internal "
			    "debugger event\n", id);
			status = DCMD_ERR;
			continue;
		}

		sp.spec_flags |= setb;
		sp.spec_flags &= ~clrb;

		if (opt_c && !(sp.spec_flags & MDB_TGT_SPEC_HIDDEN)) {
			if (opt_c[0] != '\0')
				sp.spec_data = strdup(opt_c);
			else
				sp.spec_data = NULL;
		}

		if (opt_n)
			sp.spec_limit = opt_n;

		if (mdb_tgt_vespec_modify(mdb.m_target, id, sp.spec_flags,
		    sp.spec_limit, sp.spec_data) == -1) {
			mdb_warn("failed to modify event %d", id);
			data = sp.spec_data;
			status = DCMD_ERR;
		}

		if (opt_c && data && !(sp.spec_flags & MDB_TGT_SPEC_HIDDEN))
			strfree(data);
	}

	return (status);
}

/*
 * Utility routine for performing the stock argument processing that is common
 * among the dcmds that create event specifiers.  We parse out the standard set
 * of event property options from the command-line, and return a copy of the
 * argument list to the caller that consists solely of the remaining non-option
 * arguments.  If a parsing error occurs, NULL is returned.
 */
static const mdb_arg_t *
ev_getopts(uintmax_t addr, uint_t flags, int argc, const mdb_arg_t *argv,
    uint_t *evflags, char **opt_c, uint_t *opt_i, uint_t *opt_l,
    uint64_t *opt_L, uintptr_t *opt_n, uint_t *opt_o, uint_t *opt_p,
    uint_t *rwx)
{
	uint_t setb = 0, clrb = 0;
	const char *p;
	int argi;

	mdb_arg_t *av;
	int ac = 0;

	/* keep lint happy */
	*opt_p = FALSE;

	av = mdb_alloc(sizeof (mdb_arg_t) * (argc + 2), UM_SLEEP | UM_GC);

	/*
	 * If an address was specified, take it as an additional immediate
	 * value argument by adding it to the argument list.
	 */
	if (flags & DCMD_ADDRSPEC) {
		av[ac].a_type = MDB_TYPE_IMMEDIATE;
		av[ac++].a_un.a_val = addr;
	}

	/*
	 * Now call mdb_getopts repeatedly to parse the argument list.  We need
	 * to handle '+[a-z]' processing manually, and we also manually copy
	 * each non-option argument into the av[] array as we encounter them.
	 */
	while (argc != 0 && (argi = mdb_getopts(argc, argv,
	    'c', MDB_OPT_STR, opt_c,
	    'd', MDB_OPT_SETBITS, MDB_TGT_SPEC_AUTODIS, &setb,
	    'D', MDB_OPT_SETBITS, MDB_TGT_SPEC_AUTODEL, &setb,
	    'e', MDB_OPT_SETBITS, MDB_TGT_SPEC_DISABLED, &clrb,
	    'i', MDB_OPT_SETBITS, TRUE, opt_i,
	    'n', MDB_OPT_UINTPTR, opt_n,
	    'o', MDB_OPT_SETBITS, TRUE, opt_o,
#ifdef _KMDB
	    'p', MDB_OPT_SETBITS, TRUE, opt_p,
#endif
	    'r', MDB_OPT_SETBITS, MDB_TGT_WA_R, rwx,
	    's', MDB_OPT_SETBITS, MDB_TGT_SPEC_AUTOSTOP, &setb,
	    'l', MDB_OPT_SETBITS, TRUE, opt_l,
	    'L', MDB_OPT_UINT64, opt_L,
	    't', MDB_OPT_SETBITS, MDB_TGT_SPEC_TEMPORARY, &setb,
	    'T', MDB_OPT_SETBITS, MDB_TGT_SPEC_STICKY, &setb,
	    'w', MDB_OPT_SETBITS, MDB_TGT_WA_W, rwx,
	    'x', MDB_OPT_SETBITS, MDB_TGT_WA_X, rwx, NULL)) != argc) {

		argv += argi; /* advance past elements processed by getopts */
		argc -= argi; /* decrement argc by number of args processed */

		if (argv->a_type == MDB_TYPE_STRING) {
			if (argv->a_un.a_str[0] == '+') {
				for (p = argv->a_un.a_str + 1; *p != '\0'; ) {
					switch (*p++) {
					case 'd':
						clrb |= MDB_TGT_SPEC_AUTODIS;
						break;
					case 'D':
						clrb |= MDB_TGT_SPEC_AUTODEL;
						break;
					case 'e':
						setb |= MDB_TGT_SPEC_DISABLED;
						break;
					case 's':
						clrb |= MDB_TGT_SPEC_AUTOSTOP;
						break;
					case 't':
						clrb |= MDB_TGT_SPEC_TEMPORARY;
						break;
					case 'T':
						clrb |= MDB_TGT_SPEC_STICKY;
						break;
					default:
						mdb_warn("illegal option -- "
						    "+%c\n", p[-1]);
						return (NULL);
					}
				}
			} else if (argv->a_un.a_str[0] != '-') {
				av[ac++] = *argv;
			} else
				return (NULL);
		} else
			av[ac++] = *argv;

		argc--;
		argv++;
	}

	/*
	 * If no arguments were found on the command-line, return NULL to
	 * indicate that the caller should return DCMD_USAGE.
	 */
	if (ac == 0)
		return (NULL);

	/*
	 * If -n was not specified, then -d means "disable now" instead of
	 * meaning "set auto-disable after n hits".
	 */
	if (opt_n == 0 && (setb & MDB_TGT_SPEC_AUTODIS))
		setb = (setb & ~MDB_TGT_SPEC_AUTODIS) | MDB_TGT_SPEC_DISABLED;

	/*
	 * Return the final set of flags, and terminate the argument array
	 * with a NULL string argument.
	 */
	*evflags = setb & ~clrb;

	av[ac].a_type = MDB_TYPE_STRING;
	av[ac].a_un.a_str = NULL;

	return (av);
}

/*
 * Utility function for modifying the spec_data and spec_limit properties of an
 * event specifier.  We use this for handling the -c and -n options below.
 */
static void
ev_setopts(mdb_tgt_t *t, int id, const char *opt_c, uintptr_t opt_n)
{
	mdb_tgt_spec_desc_t sp;

	(void) mdb_tgt_vespec_info(t, id, &sp, NULL, 0);

	if (opt_c != NULL)
		sp.spec_data = strdup(opt_c);
	if (opt_n != 0)
		sp.spec_limit = opt_n;

	if (mdb_tgt_vespec_modify(t, id, sp.spec_flags,
	    sp.spec_limit, sp.spec_data) == -1) {
		mdb_warn("failed to modify event %d", id);
		if (opt_c != NULL)
			strfree(sp.spec_data);
	}
}

int
cmd_bp(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	char *opt_c = NULL;
	uint_t opt_i = FALSE;
	uint_t opt_l = FALSE;
	uint64_t opt_L = 0;
	uintptr_t opt_n = 0;
	uint_t opt_o = FALSE;
	uint_t opt_p = FALSE;
	uint_t opt_rwx = 0;
	int status = DCMD_OK;
	int id;

	if ((argv = ev_getopts(addr, flags, argc, argv, &flags, &opt_c, &opt_i,
	    &opt_l, &opt_L, &opt_n, &opt_o, &opt_p, &opt_rwx)) == NULL ||
	    opt_i || opt_o || opt_rwx != 0 || opt_l || opt_L != 0 || opt_p)
		return (DCMD_USAGE);

	while (argv->a_type != MDB_TYPE_STRING || argv->a_un.a_str != NULL) {
		if (argv->a_type == MDB_TYPE_STRING) {
			id = mdb_tgt_add_sbrkpt(mdb.m_target, argv->a_un.a_str,
			    flags, cmd_event, NULL);
		} else {
			id = mdb_tgt_add_vbrkpt(mdb.m_target, argv->a_un.a_val,
			    flags, cmd_event, NULL);
		}

		if (id == 0) {
			mdb_warn("failed to add breakpoint at %s",
			    argv->a_type == MDB_TYPE_STRING ? argv->a_un.a_str :
			    numtostr(argv->a_un.a_val, mdb.m_radix,
			    NTOS_UNSIGNED | NTOS_SHOWBASE));
			status = DCMD_ERR;

		} else if (opt_c || opt_n)
			ev_setopts(mdb.m_target, id, opt_c, opt_n);

		argv++;
	}

	return (status);
}


int
cmd_sigbp(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	char *opt_c = NULL;
	uint_t opt_i = FALSE;
	uint_t opt_l = FALSE;
	uint64_t opt_L = 0;
	uintptr_t opt_n = 0;
	uint_t opt_o = FALSE;
	uint_t opt_p = FALSE;
	uint_t opt_rwx = 0;
	int status = DCMD_OK;
	int id, sig;

	if ((argv = ev_getopts(addr, flags, argc, argv, &flags, &opt_c, &opt_i,
	    &opt_l, &opt_L, &opt_n, &opt_o, &opt_p, &opt_rwx)) == NULL ||
	    opt_i || opt_l || opt_L != 0 || opt_o || opt_p || opt_rwx != 0)
		return (DCMD_USAGE);

	while (argv->a_type != MDB_TYPE_STRING || argv->a_un.a_str != NULL) {
		if (argv->a_type == MDB_TYPE_STRING) {
			if (proc_str2sig(argv->a_un.a_str, &sig) == -1) {
				mdb_warn("invalid signal name -- %s\n",
				    argv->a_un.a_str);
				status = DCMD_ERR;
				argv++;
				continue;
			}
		} else
			sig = (int)(intmax_t)argv->a_un.a_val;

		if ((id = mdb_tgt_add_signal(mdb.m_target, sig, flags,
		    cmd_event, NULL)) == 0) {
			mdb_warn("failed to trace signal %d", sig);
			status = DCMD_ERR;
		} else if (opt_c || opt_n)
			ev_setopts(mdb.m_target, id, opt_c, opt_n);

		argv++;
	}

	return (status);
}

int
cmd_sysbp(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	char *opt_c = NULL;
	uint_t opt_i = FALSE;
	uint_t opt_l = FALSE;
	uint64_t opt_L = 0;
	uintptr_t opt_n = 0;
	uint_t opt_o = FALSE;
	uint_t opt_p = FALSE;
	uint_t opt_rwx = 0;
	int status = DCMD_OK;
	int id, sysnum;

	if ((argv = ev_getopts(addr, flags, argc, argv, &flags, &opt_c, &opt_i,
	    &opt_l, &opt_L, &opt_n, &opt_o, &opt_p, &opt_rwx)) == NULL ||
	    (opt_i && opt_o) || opt_l || opt_L != 0 || opt_p || opt_rwx != 0)
		return (DCMD_USAGE);

	while (argv->a_type != MDB_TYPE_STRING || argv->a_un.a_str != NULL) {
		if (argv->a_type == MDB_TYPE_STRING) {
			if (proc_str2sys(argv->a_un.a_str, &sysnum) == -1) {
				mdb_warn("invalid system call name -- %s\n",
				    argv->a_un.a_str);
				status = DCMD_ERR;
				argv++;
				continue;
			}
		} else
			sysnum = (int)(intmax_t)argv->a_un.a_val;

		if (opt_o) {
			id = mdb_tgt_add_sysexit(mdb.m_target, sysnum,
			    flags, cmd_event, NULL);
		} else {
			id = mdb_tgt_add_sysenter(mdb.m_target, sysnum,
			    flags, cmd_event, NULL);
		}

		if (id == 0) {
			mdb_warn("failed to trace system call %d", sysnum);
			status = DCMD_ERR;
		} else if (opt_c || opt_n)
			ev_setopts(mdb.m_target, id, opt_c, opt_n);

		argv++;
	}

	return (status);
}

int
cmd_fltbp(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	char *opt_c = NULL;
	uint_t opt_i = FALSE;
	uint_t opt_l = FALSE;
	uint64_t opt_L = 0;
	uintptr_t opt_n = 0;
	uint_t opt_o = FALSE;
	uint_t opt_p = FALSE;
	uint_t opt_rwx = 0;
	int status = DCMD_OK;
	int id, fltnum;

	if ((argv = ev_getopts(addr, flags, argc, argv, &flags, &opt_c,
	    &opt_i, &opt_l, &opt_L, &opt_n, &opt_o, &opt_p,
	    &opt_rwx)) == NULL || opt_i || opt_l || opt_L != 0 || opt_o ||
	    opt_p || opt_rwx != 0)
		return (DCMD_USAGE);

	while (argv->a_type != MDB_TYPE_STRING || argv->a_un.a_str != NULL) {
		if (argv->a_type == MDB_TYPE_STRING) {
			if (proc_str2flt(argv->a_un.a_str, &fltnum) == -1) {
				mdb_warn("invalid fault name -- %s\n",
				    argv->a_un.a_str);
				status = DCMD_ERR;
				argv++;
				continue;
			}
		} else
			fltnum = (int)(intmax_t)argv->a_un.a_val;

		id = mdb_tgt_add_fault(mdb.m_target, fltnum,
		    flags, cmd_event, NULL);

		if (id == 0) {
			mdb_warn("failed to trace fault %d", fltnum);
			status = DCMD_ERR;
		} else if (opt_c || opt_n)
			ev_setopts(mdb.m_target, id, opt_c, opt_n);

		argv++;
	}

	return (status);
}

/*ARGSUSED*/
int
cmd_wp(uintptr_t x, uint_t flags, int argc, const mdb_arg_t *argv)
{
	mdb_tgt_addr_t addr = mdb_get_dot();
	char *opt_c = NULL;
	uint_t opt_i = FALSE;
	uint_t opt_l = FALSE;
	uint64_t opt_L = 0;
	uintptr_t opt_n = 0;
	uint_t opt_o = FALSE;
	uint_t opt_p = FALSE;
	uint_t opt_rwx = 0;
	int id;
	char buf[MDB_SYM_NAMLEN];
	GElf_Sym gsym;
	int size;

	if ((argv = ev_getopts(addr, flags, argc, argv, &flags, &opt_c, &opt_i,
	    &opt_l, &opt_L, &opt_n, &opt_o, &opt_p, &opt_rwx)) == NULL ||
	    opt_o || (opt_p && opt_i))
		return (DCMD_USAGE);

#ifndef _KMDB
	if (opt_i)
		return (DCMD_USAGE);
#endif

	if (argv->a_type != MDB_TYPE_IMMEDIATE)
		return (DCMD_USAGE);

	if (opt_rwx == 0) {
		mdb_warn("at least one of -r, -w, or -x must be specified\n");
		return (DCMD_USAGE);
	}

	if ((opt_l) + (opt_L > 0) + (mdb.m_dcount != 1) > 1) {
		mdb_warn("only one of -l, -L, or command count can be "
		    "specified\n");
		return (DCMD_ABORT);
	}

	if (opt_l) {
		if (mdb_lookup_by_addr(addr, MDB_SYM_EXACT, buf,
		    sizeof (buf), &gsym) == -1) {
			mdb_warn("failed to lookup symbol at %p", addr);
			return (DCMD_ERR);
		}

		if (gsym.st_size == 0) {
			mdb_warn("cannot set watchpoint: symbol '%s' has zero "
			    "size\n", buf);
			return (DCMD_ERR);
		}
		size = gsym.st_size;
	} else if (opt_L != 0) {
		size = opt_L;
	} else
		size = mdb.m_dcount;

	if (opt_p) {
		id = mdb_tgt_add_pwapt(mdb.m_target, addr, size, opt_rwx,
		    flags, cmd_event, NULL);
	} else if (opt_i) {
		id = mdb_tgt_add_iowapt(mdb.m_target, addr, size, opt_rwx,
		    flags, cmd_event, NULL);
	} else {
		id = mdb_tgt_add_vwapt(mdb.m_target, addr, size, opt_rwx,
		    flags, cmd_event, NULL);
	}

	if (id == 0) {
		mdb_warn("failed to set watchpoint at %p", addr);
		return ((opt_l || opt_L) ? DCMD_ERR : DCMD_ABORT);
	}

	if (opt_c || opt_n)
		ev_setopts(mdb.m_target, id, opt_c, opt_n);

	/*
	 * We use m_dcount as an argument; don't loop. We ignore this
	 * restriction with the -l and -L options, since we read the size from
	 * the symbol and don't rely on the count.
	 */
	return ((opt_l || opt_L) ? DCMD_OK : DCMD_ABORT);
}

/*ARGSUSED*/
int
cmd_oldbp(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	char *s = mdb_argv_to_str(argc, argv);

	if (mdb_tgt_add_vbrkpt(mdb.m_target, addr, 0, cmd_event, s) == 0) {
		mdb_warn("failed to add breakpoint");
		if (s != NULL)
			strfree(s);
		return (DCMD_ERR);
	}

	return (DCMD_OK);
}

/*ARGSUSED*/
static int
oldwp(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv, uint_t rwx)
{
	char *s = mdb_argv_to_str(argc, argv);

	if (mdb_tgt_add_vwapt(mdb.m_target, addr, mdb.m_dcount, rwx, 0,
	    cmd_event, s) == 0) {
		mdb_warn("failed to add watchpoint");
		if (s != NULL)
			strfree(s);
		return (DCMD_ABORT);
	}

	return (DCMD_ABORT); /* we use m_dcount as an argument; don't loop */
}

int
cmd_oldwpr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	return (oldwp(addr, flags, argc, argv, MDB_TGT_WA_R));
}

int
cmd_oldwpw(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	return (oldwp(addr, flags, argc, argv, MDB_TGT_WA_W));
}

int
cmd_oldwpx(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	return (oldwp(addr, flags, argc, argv, MDB_TGT_WA_X));
}

static const char _evset_help[] =
"+/-d     disable specifier when hit count reaches limit (+d to unset);\n"
"         if -n is not present with -d, specifier is disabled immediately\n\n"
"+/-D     delete specifier when hit count reaches limit (+D to unset);\n"
"+/-e     enable specifier (+e or -d to disable)\n"
"+/-s     stop target when hit count reaches limit (+s to unset)\n"
"+/-t     delete specifier the next time the target stops (+t to unset)\n"
"+/-T     sticky bit: ::delete all will not remove specifier (+T to unset)\n\n"
"-c cmd   execute \"cmd\" each time the corresponding event occurs\n"
"-n count set limit for -D, -d, or -s to \"count\" (default 1)\n\n";

void
bp_help(void)
{
	mdb_printf(_evset_help);
	mdb_printf("addr     set breakpoint at specified virtual address\n");
	mdb_printf("sym      set deferred breakpoint at specified symbol\n");
}

void
evset_help(void)
{
	mdb_printf(_evset_help);
	mdb_printf("addr/id  set properties of specified event ids\n");
}

void
fltbp_help(void)
{
	mdb_printf(_evset_help);
	mdb_printf("flt      fault name (see <sys/fault.h>) or number\n");
}

void
sigbp_help(void)
{
	mdb_printf(_evset_help);
	mdb_printf("SIG      signal name (see signal(3HEAD)) or number\n");
}

void
sysbp_help(void)
{
	mdb_printf(_evset_help);
	mdb_printf("-i       trace system call on entry into kernel (default)\n"
	    "-o       trace system call on exit from kernel\n\n"
	    "syscall  system call name (see <sys/syscall.h>) or number\n");
}

void
wp_help(void)
{
	mdb_printf(_evset_help);
	mdb_printf(
#ifdef _KMDB
	    "-p       treat addr as a physical address\n"
	    "-i       treat addr as an I/O port address\n"
#endif
	    "-l       use size of addr's type for watched region\n"
	    "-L size  set size of watched region (default 1)\n"
	    "-r       trace read access to watched region\n"
	    "-w       trace write access to watched region\n"
	    "-x       trace execute access to watched region\n\n"
	    "addr     address for base of watched region\n"
	    "repeat   size of watched region (equivalent to -L)\n");
}