xref: /onnv-gate/usr/src/cmd/sgs/librtld_db/demo/common/ps.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 <sys/stat.h>
#include <sys/mman.h>
#include <libelf.h>
#include <sys/param.h>
#include <sys/machelf.h>
#include <stdarg.h>

#include <proc_service.h>

#include "rdb.h"
#include "disasm.h"

#if	!defined(_LP64)
static void
gelf_sym_to_elf32(GElf_Sym *src, Elf32_Sym *dst)
{
	dst->st_name	= src->st_name;
	dst->st_value	= src->st_value;
	dst->st_size	= src->st_size;
	dst->st_info	= ELF32_ST_INFO(GELF_ST_BIND(src->st_info),
	    GELF_ST_TYPE(src->st_info));
	dst->st_other	= src->st_other;
	dst->st_shndx	= src->st_shndx;
}
#endif

#define	PROCSIZE	20

static void
get_ldbase(struct ps_prochandle *procp)
{
	int		pauxvfd;
	char		pname[PROCSIZE];
	struct stat	stbuf;
	void		*auxvptr, *auxvtail;
	auxv_t		*auxvp;
	uint_t		entsize;

	(void) snprintf(pname, PROCSIZE, "/proc/%d/auxv",
	    EC_SWORD(procp->pp_pid));
	if ((pauxvfd = open(pname, O_RDONLY)) == -1)
		perr("open auxv");

	if (fstat(pauxvfd, &stbuf) == -1)
		perr("stat auxv");

	auxvptr = malloc(stbuf.st_size);
	if (read(pauxvfd, auxvptr, stbuf.st_size) == -1)
		perr("gldb: reading auxv");

	(void) close(pauxvfd);

	procp->pp_auxvp = auxvptr;
	auxvtail = (void *)((uintptr_t)auxvptr + stbuf.st_size);

#if defined(_LP64)
	if (procp->pp_dmodel == PR_MODEL_ILP32)
		entsize = sizeof (auxv32_t);
	else
#endif
		entsize = sizeof (auxv_t);

	while (auxvptr < auxvtail) {
		auxvp = auxvptr;
		if (auxvp->a_type == AT_BASE) {
#if defined(_LP64)
			if (procp->pp_dmodel == PR_MODEL_ILP32)
				procp->pp_ldsobase =
				    ((uintptr_t)((auxv32_t *)auxvp)->
				    a_un.a_val);
			else
#endif
				procp->pp_ldsobase =  auxvp->a_un.a_val;
		} else if (auxvp->a_type == AT_PHDR) {
#if defined(_LP64)
			if (procp->pp_dmodel == PR_MODEL_ILP32)
				procp->pp_execphdr =
				    ((uintptr_t)((auxv32_t *)auxvp)->
				    a_un.a_val);
			else
#endif
				procp->pp_execphdr =  auxvp->a_un.a_val;
		}
		auxvptr = (void *)((uintptr_t)auxvptr + entsize);
	}
}

retc_t
ps_init(int pctlfd, int pstatusfd, pid_t pid, struct ps_prochandle *procp)
{
	rd_notify_t	rd_notify;
	char		procname[PROCSIZE];
	long		oper, pflags;
	struct iovec	piov[2];

	procp->pp_pid = pid;
	procp->pp_ctlfd = pctlfd;
	procp->pp_statusfd = pstatusfd;

	(void) snprintf(procname, PROCSIZE, "/proc/%d/map",
	    EC_SWORD(procp->pp_pid));
	if ((procp->pp_mapfd = open(procname, O_RDONLY)) == -1)
		perr("psi: open of /proc/dpid/map failed");

	(void) snprintf(procname, PROCSIZE, "/proc/%d/as",
	    EC_SWORD(procp->pp_pid));
	if ((procp->pp_asfd = open(procname, O_RDWR)) == -1)
		perr("psi: open of /proc/dpid/as failed");

	if (ps_pdmodel(procp, &procp->pp_dmodel) != PS_OK)
		perr("psi: data model");

#if	!defined(_LP64)
	if (procp->pp_dmodel == PR_MODEL_LP64)
		perr("psi:  run 64-bit rdb to debug a 64-bit process");
#endif
	get_ldbase(procp);

	(void) load_map(procp, (caddr_t)procp->pp_ldsobase,
	    &(procp->pp_ldsomap));
	procp->pp_ldsomap.mi_addr += procp->pp_ldsobase;
	procp->pp_ldsomap.mi_end += procp->pp_ldsobase;
	procp->pp_ldsomap.mi_name = "<procfs: interp>";

	(void) load_map(procp, (caddr_t)procp->pp_execphdr,
	    &(procp->pp_execmap));
	procp->pp_execmap.mi_name = "<procfs: exec>";

	procp->pp_breakpoints = NULL;
	procp->pp_flags = FLG_PP_PACT | FLG_PP_PLTSKIP;
	procp->pp_lmaplist.ml_head = NULL;
	procp->pp_lmaplist.ml_tail = NULL;
	if ((procp->pp_rap = rd_new(procp)) == NULL) {
		(void) fprintf(stderr, "rdb: rtld_db: rd_new() call failed\n");
		exit(1);
	}
	(void) rd_event_enable(procp->pp_rap, 1);

	/*
	 * For those architectures that increment the PC on
	 * a breakpoint fault we enable the PR_BPTADJ adjustments.
	 */
	oper = PCSET;
	pflags = PR_BPTADJ;
	piov[0].iov_base = (caddr_t)(&oper);
	piov[0].iov_len = sizeof (oper);
	piov[1].iov_base = (caddr_t)(&pflags);
	piov[1].iov_len = sizeof (pflags);
	if (writev(procp->pp_ctlfd, piov, 2) == -1)
		perr("psinit: PCSET(PR_BTPADJ)");

	/*
	 * Set breakpoints for special handshakes between librtld_db.so
	 * and the debugger.  These include:
	 *	PREINIT		- before .init processing.
	 *	POSTINIT	- after .init processing
	 *	DLACTIVITY	- link_maps status has changed
	 */
	if (rd_event_addr(procp->pp_rap, RD_PREINIT, &rd_notify) == RD_OK) {
		if (set_breakpoint(procp, rd_notify.u.bptaddr,
		    FLG_BP_RDPREINIT) != RET_OK)
			(void) fprintf(stderr,
			    "psi: failed to set BP for preinit at: 0x%lx\n",
			    rd_notify.u.bptaddr);
	} else
		(void) fprintf(stderr, "psi: no event registered for "
		    "preinit\n");

	if (rd_event_addr(procp->pp_rap, RD_POSTINIT, &rd_notify) == RD_OK) {
		if (set_breakpoint(procp, rd_notify.u.bptaddr,
		    FLG_BP_RDPOSTINIT) != RET_OK)
			(void) fprintf(stderr,
			    "psi: failed to set BP for postinit at: 0x%lx\n",
			    rd_notify.u.bptaddr);
	} else
		(void) fprintf(stderr, "psi: no event registered for "
		    "postinit\n");

	if (rd_event_addr(procp->pp_rap, RD_DLACTIVITY, &rd_notify) == RD_OK) {
		if (set_breakpoint(procp, rd_notify.u.bptaddr,
		    FLG_BP_RDDLACT) != RET_OK)
			(void) fprintf(stderr,
			    "psi: failed to set BP for dlact at: 0x%lx\n",
			    rd_notify.u.bptaddr);
	} else
		(void) fprintf(stderr, "psi: no event registered for dlact\n");

	return (RET_OK);
}

retc_t
ps_close(struct ps_prochandle *ph)
{
	(void) delete_all_breakpoints(ph);

	if (ph->pp_auxvp)
		free(ph->pp_auxvp);
	free_linkmaps(ph);
	return (RET_OK);
}

ps_err_e
ps_pauxv(struct ps_prochandle *ph, const auxv_t **auxvp)
{
	*auxvp = ph->pp_auxvp;
	return (PS_OK);
}

ps_err_e
ps_pdmodel(struct ps_prochandle *ph, int *dm)
{
	pstatus_t	pstatus;

	if (pread(ph->pp_statusfd, &pstatus, sizeof (pstatus), 0) == -1)
		return (PS_ERR);

	*dm = (int)pstatus.pr_dmodel;
	return (PS_OK);
}

ps_err_e
ps_pread(struct ps_prochandle *ph, psaddr_t addr, void *buf, size_t size)
{
	if (pread(ph->pp_asfd, buf, size, (off_t)addr) != size)
		return (PS_ERR);

	return (PS_OK);
}

ps_err_e
ps_pwrite(struct ps_prochandle *ph, psaddr_t addr, const void *buf, size_t size)
{
	if (pwrite(ph->pp_asfd, buf, size, (off_t)addr) != size)
		return (PS_ERR);

	return (PS_OK);
}

ps_err_e
ps_pglobal_sym(struct ps_prochandle *ph, const char *object_name,
    const char *sym_name, ps_sym_t *symp)
{
	map_info_t	*mip;
	GElf_Sym	gsym;

	if ((mip = str_to_map(ph, object_name)) == NULL)
		return (PS_ERR);

	if (str_map_sym(sym_name, mip, &gsym, NULL) == RET_FAILED)
		return (PS_ERR);

#if	defined(_LP64)
	*symp = gsym;
#else
	gelf_sym_to_elf32(&gsym, (Elf32_Sym *)symp);
#endif

	return (PS_OK);
}

ps_err_e
ps_pglobal_lookup(struct ps_prochandle *ph, const char *object_name,
    const char *sym_name, ulong_t *sym_addr)
{
	GElf_Sym	sym;
	map_info_t	*mip;

	if ((mip = str_to_map(ph, object_name)) == NULL)
		return (PS_ERR);

	if (str_map_sym(sym_name, mip, &sym, NULL) == RET_FAILED)
		return (PS_ERR);

	*sym_addr = sym.st_value;

	return (PS_OK);
}

ps_err_e
ps_lgetregs(struct ps_prochandle *ph, lwpid_t lid, prgregset_t gregset)
{
	char		procname[MAXPATHLEN];
	int		lwpfd;
	lwpstatus_t	lwpstatus;

	(void) snprintf(procname, MAXPATHLEN - 1,
	    "/proc/%d/lwp/%d/lwpstatus", EC_SWORD(ph->pp_pid), EC_SWORD(lid));

	if ((lwpfd = open(procname, O_RDONLY)) == -1)
		return (PS_ERR);

	if (read(lwpfd, &lwpstatus, sizeof (lwpstatus)) == -1)
		return (PS_ERR);

	gregset = lwpstatus.pr_reg;

	(void) close(lwpfd);
	return (PS_OK);
}

void
ps_plog(const char *fmt, ...)
{
	va_list		args;
	static FILE	*log_fp = NULL;

	if (log_fp == NULL) {
		char		log_fname[256];
		(void) sprintf(log_fname, "/tmp/tdlog.%d", EC_SWORD(getpid()));
		if ((log_fp = fopen(log_fname, "w")) == NULL) {
			/*
			 * Unable to open log file - default to stderr.
			 */
			(void) fprintf(stderr, "unable to open %s, logging "
			    "redirected to stderr", log_fname);
			log_fp = stderr;
		}
	}

	va_start(args, fmt);
	(void) vfprintf(log_fp, fmt, args);
	va_end(args);
	(void) fputc('\n', log_fp);
	(void) fflush(log_fp);
}

/* ARGSUSED0 */
ps_err_e
ps_pbrandname(struct ps_prochandle *P, char *buf, size_t len)
{
	return (PS_ERR);
}