OpenSolaris Launch

1 files changed, 372 insertions, 0 deletions

diff --git a/usr/src/lib/libproc/common/Pservice.c b/usr/src/lib/libproc/common/Pservice.c
new file mode 100644
index 0000000000..6850696af4
--- /dev/null
+++ b/usr/src/lib/libproc/common/Pservice.c
@@ -0,0 +1,372 @@
+/*
+ * 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.
+ */
+
+#pragma ident	"%Z%%M%	%I%	%E% SMI"
+
+#include <stdarg.h>
+#include <string.h>
+#include "Pcontrol.h"
+
+/*
+ * This file implements the process services declared in <proc_service.h>.
+ * This enables libproc to be used in conjunction with libc_db and
+ * librtld_db.  As most of these facilities are already provided by
+ * (more elegant) interfaces in <libproc.h>, we can just call those.
+ *
+ * NOTE: We explicitly do *not* implement the functions ps_kill() and
+ * ps_lrolltoaddr() in this library.  The very existence of these functions
+ * causes libc_db to create an "agent thread" in the target process.
+ * The only way to turn off this behavior is to omit these functions.
+ */
+
+#pragma weak ps_pdread = ps_pread
+#pragma weak ps_ptread = ps_pread
+#pragma weak ps_pdwrite = ps_pwrite
+#pragma weak ps_ptwrite = ps_pwrite
+
+ps_err_e
+ps_pdmodel(struct ps_prochandle *P, int *modelp)
+{
+	*modelp = P->status.pr_dmodel;
+	return (PS_OK);
+}
+
+ps_err_e
+ps_pread(struct ps_prochandle *P, psaddr_t addr, void *buf, size_t size)
+{
+	if (P->ops->p_pread(P, buf, size, addr) != size)
+		return (PS_BADADDR);
+	return (PS_OK);
+}
+
+ps_err_e
+ps_pwrite(struct ps_prochandle *P, psaddr_t addr, const void *buf, size_t size)
+{
+	if (P->ops->p_pwrite(P, buf, size, addr) != size)
+		return (PS_BADADDR);
+	return (PS_OK);
+}
+
+/*
+ * libc_db calls matched pairs of ps_pstop()/ps_pcontinue()
+ * in the belief that the client may have left the process
+ * running while calling in to the libc_db interfaces.
+ *
+ * We interpret the meaning of these functions to be an inquiry
+ * as to whether the process is stopped, not an action to be
+ * performed to make it stopped.  For similar reasons, we also
+ * return PS_OK for core files in order to allow libc_db to
+ * operate on these as well.
+ */
+ps_err_e
+ps_pstop(struct ps_prochandle *P)
+{
+	if (P->state != PS_STOP && P->state != PS_DEAD)
+		return (PS_ERR);
+	return (PS_OK);
+}
+
+ps_err_e
+ps_pcontinue(struct ps_prochandle *P)
+{
+	if (P->state != PS_STOP && P->state != PS_DEAD)
+		return (PS_ERR);
+	return (PS_OK);
+}
+
+/*
+ * ps_lstop() and ps_lcontinue() are not called by any code in libc_db
+ * or librtld_db.  We make them behave like ps_pstop() and ps_pcontinue().
+ */
+/* ARGSUSED1 */
+ps_err_e
+ps_lstop(struct ps_prochandle *P, lwpid_t lwpid)
+{
+	if (P->state != PS_STOP && P->state != PS_DEAD)
+		return (PS_ERR);
+	return (PS_OK);
+}
+
+/* ARGSUSED1 */
+ps_err_e
+ps_lcontinue(struct ps_prochandle *P, lwpid_t lwpid)
+{
+	if (P->state != PS_STOP && P->state != PS_DEAD)
+		return (PS_ERR);
+	return (PS_OK);
+}
+
+ps_err_e
+ps_lgetregs(struct ps_prochandle *P, lwpid_t lwpid, prgregset_t regs)
+{
+	if (P->state != PS_STOP && P->state != PS_DEAD)
+		return (PS_ERR);
+
+	if (Plwp_getregs(P, lwpid, regs) == 0)
+		return (PS_OK);
+
+	return (PS_BADLID);
+}
+
+ps_err_e
+ps_lsetregs(struct ps_prochandle *P, lwpid_t lwpid, const prgregset_t regs)
+{
+	if (P->state != PS_STOP)
+		return (PS_ERR);
+
+	if (Plwp_setregs(P, lwpid, regs) == 0)
+		return (PS_OK);
+
+	return (PS_BADLID);
+}
+
+ps_err_e
+ps_lgetfpregs(struct ps_prochandle *P, lwpid_t lwpid, prfpregset_t *regs)
+{
+	if (P->state != PS_STOP && P->state != PS_DEAD)
+		return (PS_ERR);
+
+	if (Plwp_getfpregs(P, lwpid, regs) == 0)
+		return (PS_OK);
+
+	return (PS_BADLID);
+}
+
+ps_err_e
+ps_lsetfpregs(struct ps_prochandle *P, lwpid_t lwpid, const prfpregset_t *regs)
+{
+	if (P->state != PS_STOP)
+		return (PS_ERR);
+
+	if (Plwp_setfpregs(P, lwpid, regs) == 0)
+		return (PS_OK);
+
+	return (PS_BADLID);
+}
+
+#if defined(sparc) || defined(__sparc)
+
+ps_err_e
+ps_lgetxregsize(struct ps_prochandle *P, lwpid_t lwpid, int *xrsize)
+{
+	char fname[64];
+	struct stat statb;
+
+	if (P->state == PS_DEAD) {
+		lwp_info_t *lwp = list_next(&P->core->core_lwp_head);
+		uint_t i;
+
+		for (i = 0; i < P->core->core_nlwp; i++, lwp = list_next(lwp)) {
+			if (lwp->lwp_id == lwpid) {
+				if (lwp->lwp_xregs != NULL)
+					*xrsize = sizeof (prxregset_t);
+				else
+					*xrsize = 0;
+				return (PS_OK);
+			}
+		}
+
+		return (PS_BADLID);
+	}
+
+	(void) snprintf(fname, sizeof (fname), "/proc/%d/lwp/%d/xregs",
+	    (int)P->status.pr_pid, (int)lwpid);
+
+	if (stat(fname, &statb) != 0)
+		return (PS_BADLID);
+
+	*xrsize = (int)statb.st_size;
+	return (PS_OK);
+}
+
+ps_err_e
+ps_lgetxregs(struct ps_prochandle *P, lwpid_t lwpid, caddr_t xregs)
+{
+	if (P->state != PS_STOP && P->state != PS_DEAD)
+		return (PS_ERR);
+
+	/* LINTED - alignment */
+	if (Plwp_getxregs(P, lwpid, (prxregset_t *)xregs) == 0)
+		return (PS_OK);
+
+	return (PS_BADLID);
+}
+
+ps_err_e
+ps_lsetxregs(struct ps_prochandle *P, lwpid_t lwpid, caddr_t xregs)
+{
+	if (P->state != PS_STOP)
+		return (PS_ERR);
+
+	/* LINTED - alignment */
+	if (Plwp_setxregs(P, lwpid, (prxregset_t *)xregs) == 0)
+		return (PS_OK);
+
+	return (PS_BADLID);
+}
+
+#endif	/* sparc */
+
+#if defined(__i386) || defined(__amd64)
+
+ps_err_e
+ps_lgetLDT(struct ps_prochandle *P, lwpid_t lwpid, struct ssd *ldt)
+{
+#if defined(__amd64) && defined(_LP64)
+	if (P->status.pr_dmodel != PR_MODEL_NATIVE) {
+#endif
+	prgregset_t regs;
+	struct ssd *ldtarray;
+	ps_err_e error;
+	uint_t gs;
+	int nldt;
+	int i;
+
+	if (P->state != PS_STOP && P->state != PS_DEAD)
+		return (PS_ERR);
+
+	/*
+	 * We need to get the ldt entry that matches the
+	 * value in the lwp's GS register.
+	 */
+	if ((error = ps_lgetregs(P, lwpid, regs)) != PS_OK)
+		return (error);
+
+	gs = regs[GS];
+
+	if ((nldt = Pldt(P, NULL, 0)) <= 0 ||
+	    (ldtarray = malloc(nldt * sizeof (struct ssd))) == NULL)
+		return (PS_ERR);
+	if ((nldt = Pldt(P, ldtarray, nldt)) <= 0) {
+		free(ldtarray);
+		return (PS_ERR);
+	}
+
+	for (i = 0; i < nldt; i++) {
+		if (gs == ldtarray[i].sel) {
+			*ldt = ldtarray[i];
+			break;
+		}
+	}
+	free(ldtarray);
+
+	if (i < nldt)
+		return (PS_OK);
+#if defined(__amd64) && defined(_LP64)
+	}
+#endif
+
+	return (PS_ERR);
+}
+
+#endif	/* __i386 || __amd64 */
+
+/*
+ * Libthread_db doesn't use this function currently, but librtld_db uses
+ * it for its debugging output.  We turn this on via rd_log if our debugging
+ * switch is on, and then echo the messages sent to ps_plog to stderr.
+ */
+void
+ps_plog(const char *fmt, ...)
+{
+	va_list ap;
+
+	if (_libproc_debug && fmt != NULL && *fmt != '\0') {
+		va_start(ap, fmt);
+		(void) vfprintf(stderr, fmt, ap);
+		va_end(ap);
+		if (fmt[strlen(fmt) - 1] != '\n')
+			(void) fputc('\n', stderr);
+	}
+}
+
+/*
+ * Store a pointer to our internal copy of the aux vector at the address
+ * specified by the caller.  It should not hold on to this data for too long.
+ */
+ps_err_e
+ps_pauxv(struct ps_prochandle *P, const auxv_t **aux)
+{
+	if (P->auxv == NULL)
+		Preadauxvec(P);
+
+	if (P->auxv == NULL)
+		return (PS_ERR);
+
+	*aux = (const auxv_t *)P->auxv;
+	return (PS_OK);
+}
+
+/*
+ * Search for a symbol by name and return the corresponding address.
+ */
+ps_err_e
+ps_pglobal_lookup(struct ps_prochandle *P, const char *object_name,
+	const char *sym_name, psaddr_t *sym_addr)
+{
+	GElf_Sym sym;
+
+	if (Plookup_by_name(P, object_name, sym_name, &sym) == 0) {
+		dprintf("pglobal_lookup <%s> -> %p\n",
+		    sym_name, (void *)(uintptr_t)sym.st_value);
+		*sym_addr = (psaddr_t)sym.st_value;
+		return (PS_OK);
+	}
+
+	return (PS_NOSYM);
+}
+
+/*
+ * Search for a symbol by name and return the corresponding symbol
+ * information.  If we're compiled _LP64, we just call Plookup_by_name
+ * and return because ps_sym_t is defined to be an Elf64_Sym, which
+ * is the same as a GElf_Sym.  In the _ILP32 case, we have to convert
+ * Plookup_by_name's result back to a ps_sym_t (which is an Elf32_Sym).
+ */
+ps_err_e
+ps_pglobal_sym(struct ps_prochandle *P, const char *object_name,
+	const char *sym_name, ps_sym_t *symp)
+{
+#if defined(_ILP32)
+	GElf_Sym sym;
+
+	if (Plookup_by_name(P, object_name, sym_name, &sym) == 0) {
+		symp->st_name = (Elf32_Word)sym.st_name;
+		symp->st_value = (Elf32_Addr)sym.st_value;
+		symp->st_size = (Elf32_Word)sym.st_size;
+		symp->st_info = ELF32_ST_INFO(
+		    GELF_ST_BIND(sym.st_info), GELF_ST_TYPE(sym.st_info));
+		symp->st_other = sym.st_other;
+		symp->st_shndx = sym.st_shndx;
+		return (PS_OK);
+	}
+
+#elif defined(_LP64)
+	if (Plookup_by_name(P, object_name, sym_name, symp) == 0)
+		return (PS_OK);
+#endif
+	return (PS_NOSYM);
+}