xref: /onnv-gate/usr/src/cmd/sgs/librtld_db/demo/common/bpt.c (revision 12927:a27c46eb192b)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 (c) 1995, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/uio.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/signal.h>
#include <sys/fault.h>
#include <sys/syscall.h>
#include <procfs.h>
#include <sys/auxv.h>
#include <libelf.h>
#include <sys/param.h>
#include <sys/machelf.h>
#include <stdarg.h>

#include "rdb.h"

static const char *fault_strings[] = {
	"<null string>",
	"illegal instruction",
	"privileged instruction",
	"breakpoint instruction",
	"trace trap (single-step)",
	"Memory access (e.g., alignment)",
	"Memory bounds (invalid address)",
	"Integer overflow",
	"Integer zero divide"
	"Floating-point exception",
	"Irrecoverable stack faul",
	"Recoverable page fault (no associated sig)"
};

#define	MAXFAULT	FLTPAGE

retc_t
set_breakpoint(struct ps_prochandle *ph, ulong_t addr, unsigned flags)
{
	bptlist_t	*new, *cur, *prev;

	for (cur = ph->pp_breakpoints, prev = NULL;
	    (cur && (cur->bl_addr < addr));
	    prev = cur, cur = cur->bl_next)
		;
	if (cur && (cur->bl_addr == addr)) {
		/*
		 * already have break point set here.
		 */
		cur->bl_flags |= flags;
		return (RET_OK);
	}

	new = malloc(sizeof (bptlist_t));
	new->bl_addr = addr;
	new->bl_flags = flags;
	if (prev == NULL) {
		/*
		 * insert at head
		 */
		new->bl_next = ph->pp_breakpoints;
		ph->pp_breakpoints = new;
		return (RET_OK);
	}

	prev->bl_next = new;
	new->bl_next = cur;
	return (RET_OK);
}

static bptlist_t *
find_bp(struct ps_prochandle *ph, ulong_t addr)
{
	bptlist_t	*cur;

	for (cur = ph->pp_breakpoints;
	    (cur && (cur->bl_addr != addr));
	    cur = cur->bl_next)
		;

	if ((cur == NULL) || (cur->bl_addr != addr))
		return ((bptlist_t *)-1);
	return (cur);
}

static retc_t
delete_bp(struct ps_prochandle *ph, ulong_t addr)
{
	bptlist_t	*cur, *prev;

	for (cur = ph->pp_breakpoints, prev = NULL;
	    (cur && (cur->bl_addr < addr));
	    prev = cur, cur = cur->bl_next)
		;
	if ((cur == NULL) || (cur->bl_addr != addr))
		return (RET_FAILED);

	if (prev == NULL)
		ph->pp_breakpoints = cur->bl_next;
	else
		prev->bl_next = cur->bl_next;

	free(cur);
	return (RET_OK);
}

void
list_breakpoints(struct ps_prochandle *ph)
{
	bptlist_t	*cur;

	if (ph->pp_breakpoints == NULL) {
		(void) printf("no active breakpoints.\n");
		return;
	}

	(void) printf("active breakpoints:\n");
	for (cur = ph->pp_breakpoints; cur; cur = cur->bl_next) {
		(void) printf("\t0x%08lx:0x%04x - %s\n", cur->bl_addr,
		    cur->bl_flags, print_address_ps(ph, cur->bl_addr,
		    FLG_PAP_SONAME));
	}
}

static void
set_breaks(struct ps_prochandle *ph)
{
	bptlist_t	*cur;
	bptinstr_t	bpt_instr = BPINSTR;

	for (cur = ph->pp_breakpoints; cur; cur = cur->bl_next) {
		bptinstr_t	old_inst = 0;

		if (ps_pread(ph, cur->bl_addr, (char *)&old_inst,
		    sizeof (bptinstr_t)) != PS_OK)
			perr("sb: error setting breakpoint");

		cur->bl_instr = old_inst;

		if (ps_pwrite(ph, cur->bl_addr, (char *)&bpt_instr,
		    sizeof (bptinstr_t)) != PS_OK)
			perr("sb1: error setting breakpoint\n");
	}

}

static void
clear_breaks(struct ps_prochandle *ph)
{
	bptlist_t	*cur;

	/*
	 * Restore all the original instructions
	 */
	for (cur = ph->pp_breakpoints; cur; cur = cur->bl_next)
		if (ps_pwrite(ph, cur->bl_addr, (char *)&(cur->bl_instr),
		    sizeof (bptinstr_t)) != PS_OK)
			perr("cb: error clearing breakpoint");
}

retc_t
delete_all_breakpoints(struct ps_prochandle *ph)
{
	bptlist_t	*cur, *prev;

	if (ph->pp_breakpoints == NULL)
		return (RET_OK);

	for (prev = NULL, cur = ph->pp_breakpoints;
	    cur; prev = cur, cur = cur->bl_next)
		if (prev)
			free(prev);
	if (prev)
		free(prev);

	ph->pp_breakpoints = NULL;
	return (RET_OK);
}

retc_t
delete_breakpoint(struct ps_prochandle *ph, ulong_t addr, unsigned flags)
{
	bptlist_t	*bpt;

	if (((bpt = find_bp(ph, addr)) == (bptlist_t *)-1) ||
	    ((bpt->bl_flags & flags) == 0))
		return (RET_FAILED);

	bpt->bl_flags &= ~flags;
	if (bpt->bl_flags)
		return (RET_OK);

	return (delete_bp(ph, addr));
}

static void
handle_sp_break(struct ps_prochandle *ph)
{
	rd_event_msg_t	emt;

	if (rd_event_getmsg(ph->pp_rap, &emt) != RD_OK) {
		(void) fprintf(stderr, "hsb: failed rd_event_getmsg()\n");
		return;
	}

	if (emt.type == RD_DLACTIVITY) {
		if (emt.u.state == RD_CONSISTENT)
			ph->pp_flags |= FLG_PP_LMAPS;
		else
			ph->pp_flags &= ~FLG_PP_LMAPS;
		if ((rdb_flags & RDB_FL_EVENTS) == 0)
			return;

		(void) printf("dlactivity: state changed to: ");
		switch (emt.u.state) {
		case RD_CONSISTENT:
			(void) printf("RD_CONSISTENT\n");
			break;
		case RD_ADD:
			(void) printf("RD_ADD\n");
			break;
		case RD_DELETE:
			(void) printf("RD_DELETE\n");
			break;
		default:
			(void) printf("unknown: 0x%x\n", emt.u.state);
		}
		return;
	}

	if ((rdb_flags & RDB_FL_EVENTS) == 0)
		return;

	if (emt.type == RD_PREINIT) {
		(void) printf("preinit reached\n");
		return;
	}

	if (emt.type == RD_POSTINIT)
		(void) printf("postinit reached\n");
}

unsigned
continue_to_break(struct ps_prochandle *ph)
{
	bptlist_t	*bpt;
	pstatus_t	pstatus;
	struct iovec	piov[5];
	long		oper1, oper2, oper3, pflags = 0;
	fltset_t	faults;

	/*
	 * We step by the first instruction incase their was
	 * a break-point there.
	 */
	(void) step_n(ph, 1, FLG_SN_NONE);

	premptyset(&faults);
	praddset(&faults, FLTBPT);
	praddset(&faults, FLTILL);
	praddset(&faults, FLTPRIV);
	praddset(&faults, FLTACCESS);
	praddset(&faults, FLTBOUNDS);
	praddset(&faults, FLTIZDIV);
	praddset(&faults, FLTSTACK);
	praddset(&faults, FLTTRACE);


	/* LINTED CONSTANT */
	while (1) {
		set_breaks(ph);
		oper1 = PCSFAULT;
		piov[0].iov_base = (caddr_t)(&oper1);
		piov[0].iov_len = sizeof (oper1);

		piov[1].iov_base = (caddr_t)(&faults);
		piov[1].iov_len = sizeof (faults);

		oper2 = PCRUN;
		piov[2].iov_base = (caddr_t)(&oper2);
		piov[2].iov_len = sizeof (oper2);
		pflags = PRCFAULT;
		piov[3].iov_base = (caddr_t)(&pflags);
		piov[3].iov_len = sizeof (pflags);

		oper3 = PCWSTOP;
		piov[4].iov_base = (caddr_t)(&oper3);
		piov[4].iov_len = sizeof (oper3);

		if (writev(ph->pp_ctlfd, piov, 5) == -1) {
			if (errno == ENOENT) {
				ph->pp_flags &= ~FLG_PP_PACT;

				(void) ps_close(ph);
				(void) printf("process terminated.\n");
				return (0);
			}
			perr("ctb: PCWSTOP");
		}

		if (pread(ph->pp_statusfd, &pstatus, sizeof (pstatus), 0) == -1)
			perr("ctb: reading status");


		if ((pstatus.pr_lwp.pr_why != PR_FAULTED) ||
		    (pstatus.pr_lwp.pr_what != FLTBPT)) {
			const char	*fltmsg;

			if ((pstatus.pr_lwp.pr_what <= MAXFAULT) &&
			    (pstatus.pr_lwp.pr_why == PR_FAULTED))
				fltmsg = fault_strings[pstatus.pr_lwp.pr_what];
			else
				fltmsg = "<unknown error>";

			(void) fprintf(stderr, "ctb: bad stop - stopped "
			    "on why: 0x%x what: %s(0x%x)\n",
			    pstatus.pr_lwp.pr_why, fltmsg,
			    pstatus.pr_lwp.pr_what);
			return (0);
		}

		oper1 = PCCFAULT;
		if (writev(ph->pp_ctlfd, piov, 1) == -1)
			perr("ctb: PCCFAULT");

		if ((bpt = find_bp(ph, pstatus.pr_lwp.pr_reg[R_PC])) ==
		    (bptlist_t *)-1) {
			(void) fprintf(stderr,
			    "stopped at unregistered breakpoint! "
			    "addr: 0x%x\n",
			    EC_WORD(pstatus.pr_lwp.pr_reg[R_PC]));
			break;
		}
		clear_breaks(ph);

		/*
		 * If this was a BP at which we should stop
		 */
		if (bpt->bl_flags & MASK_BP_STOP)
			break;

		(void) step_n(ph, 1, FLG_SN_NONE);
	}

	if (bpt->bl_flags & FLG_BP_USERDEF)
		(void) printf("break point reached at addr: 0x%x\n",
		    EC_WORD(pstatus.pr_lwp.pr_reg[R_PC]));

	if (bpt->bl_flags & MASK_BP_SPECIAL)
		handle_sp_break(ph);

	if (ph->pp_flags & FLG_PP_LMAPS) {
		if (get_linkmaps(ph) != PS_OK)
			(void) fprintf(stderr, "problem loading linkmaps\n");
	}

	return (bpt->bl_flags);
}

ulong_t
is_plt(struct ps_prochandle *ph, ulong_t pc)
{
	map_info_t	*mip;
	ulong_t		pltbase;

	if ((mip = addr_to_map(ph, pc)) == (map_info_t *)0)
		return ((ulong_t)0);

	pltbase = mip->mi_pltbase;
	if ((mip->mi_flags & FLG_MI_EXEC) == 0)
		pltbase += mip->mi_addr;

	if ((pc >= pltbase) && (pc <= (pltbase + mip->mi_pltsize)))
		return (pltbase);

	return ((ulong_t)0);
}

retc_t
step_n(struct ps_prochandle *ph, size_t count, sn_flags_e flgs)
{
	pstatus_t	pstatus;
	fltset_t	faults;
	int		i;
	long		oper;
	long		flags;
	struct iovec	piov[2];

	if (pread(ph->pp_statusfd, &pstatus, sizeof (pstatus), 0) == -1)
		perr("stn: reading status");

	piov[0].iov_base = (caddr_t)(&oper);
	piov[0].iov_len = sizeof (oper);

	premptyset(&faults);
	praddset(&faults, FLTTRACE);

	flags = PRSTEP | PRCFAULT;

	for (i = 0; i < count; i++) {
		bptlist_t	*bpt;
		uintptr_t	pc, pltbase;

		pc = pstatus.pr_lwp.pr_reg[R_PC];

		if ((bpt = find_bp(ph, pc)) != (bptlist_t *)-1) {
			if (bpt->bl_flags & MASK_BP_SPECIAL)
				handle_sp_break(ph);
		}

		if (flgs & FLG_SN_VERBOSE)
			disasm(ph, 1);

		oper = PCSFAULT;
		piov[1].iov_base = (caddr_t)(&faults);
		piov[1].iov_len = sizeof (faults);

		if (writev(ph->pp_ctlfd, piov, 2) == -1)
			perr("stn: PCSFAULT");

		oper = PCRUN;
		piov[1].iov_base = (caddr_t)(&flags);
		piov[1].iov_len = sizeof (flags);
		if (writev(ph->pp_ctlfd, piov, 2) == -1)
			perr("stn: PCRUN(PRSETP)");

		oper = PCWSTOP;
		if (writev(ph->pp_ctlfd, piov, 1) == -1)
			perr("stn: PCWSTOP stepping");

		if (pread(ph->pp_statusfd, &pstatus, sizeof (pstatus), 0) == -1)
			perr("stn1: reading status");
		pc = pstatus.pr_lwp.pr_reg[R_PC];


		if ((pstatus.pr_lwp.pr_why != PR_FAULTED) ||
		    (pstatus.pr_lwp.pr_what != FLTTRACE)) {
			(void) fprintf(stderr, "sn: bad stop - stopped on "
			    "why: 0x%x what: 0x%x\n", pstatus.pr_lwp.pr_why,
			    pstatus.pr_lwp.pr_what);
			return (RET_FAILED);
		}

		if ((flgs & FLG_SN_PLTSKIP) &&
		    ((pltbase = is_plt(ph, pc)) != (ulong_t)0)) {
			rd_plt_info_t	rp;
			if (rd_plt_resolution(ph->pp_rap, pc,
			    pstatus.pr_lwp.pr_lwpid, pltbase, &rp) != RD_OK) {
				(void) fprintf(stderr,
				    "sn: rd_plt_resolution failed\n");
				return (RET_FAILED);
			}
			if (rp.pi_skip_method == RD_RESOLVE_TARGET_STEP) {
				unsigned	bpflags;

				(void) set_breakpoint(ph, rp.pi_target,
				    FLG_BP_PLTRES);
				bpflags = continue_to_break(ph);

				(void) delete_breakpoint(ph, rp.pi_target,
				    FLG_BP_PLTRES);

				if (bpflags & FLG_BP_PLTRES)
					(void) step_n(ph, rp.pi_nstep,
					    FLG_SN_NONE);
			} else if (rp.pi_skip_method == RD_RESOLVE_STEP)
				(void) step_n(ph, rp.pi_nstep, FLG_SN_NONE);
		}
	}

	oper = PRCFAULT;
	if (writev(ph->pp_ctlfd, piov, 1) == -1)
		perr("stn: PRCFAULT");

	if ((flgs & FLG_SN_VERBOSE) && (ph->pp_flags & FLG_PP_LMAPS)) {
		if (get_linkmaps(ph) != PS_OK)
			(void) fprintf(stderr, "problem loading linkmaps\n");
	}

	return (RET_OK);
}

void
step_to_addr(struct ps_prochandle *ph, ulong_t addr)
{
	pstatus_t	pstat;
	int		count = 0;
	ulong_t		caddr;

	if (read(ph->pp_statusfd, &pstat, sizeof (pstat)) == -1)
		perr("sta: reading status");

	caddr = pstat.pr_lwp.pr_reg[R_PC];

	while ((caddr > addr) || ((caddr + 0xff) < addr)) {
		(void) step_n(ph, 1, FLG_SN_NONE);
		if (read(ph->pp_statusfd, &pstat, sizeof (pstat)) == -1)
			perr("sta1: reading status");
		caddr = pstat.pr_lwp.pr_reg[R_PC];
		if ((count % 10000) == 0) {
			(void) printf("%d: ", count);
			disasm(ph, 1);
		}

		count++;
	}

	(void) printf("address found %d instructions in: pc: 0x%lx addr: "
	    "0x%lx\n", count, caddr, addr);
}