OpenSolaris Launch

1 files changed, 288 insertions, 0 deletions

diff --git a/usr/src/lib/libproc/common/Pstack.c b/usr/src/lib/libproc/common/Pstack.c
new file mode 100644
index 0000000000..f0f8b5ce8d
--- /dev/null
+++ b/usr/src/lib/libproc/common/Pstack.c
@@ -0,0 +1,288 @@
+/*
+ * 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"
+
+/*
+ * Pstack.c
+ *
+ * Common helper functions for stack walking.  The ISA-specific code is found in
+ * Pstack_iter() in Pisadep.c.
+ */
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+
+#include "libproc.h"
+#include "Pcontrol.h"
+#include "P32ton.h"
+#include "Pstack.h"
+
+/*
+ * Utility function to prevent stack loops from running on forever by
+ * detecting when there is a stack loop (the %fp has been seen before).
+ */
+int
+stack_loop(prgreg_t fp, prgreg_t **prevfpp, int *nfpp, uint_t *pfpsizep)
+{
+	prgreg_t *prevfp = *prevfpp;
+	uint_t pfpsize = *pfpsizep;
+	int nfp = *nfpp;
+	int i;
+
+	for (i = 0; i < nfp; i++) {
+		if (fp == prevfp[i])
+			return (1); /* stack loop detected */
+	}
+
+	if (nfp == pfpsize) {
+		pfpsize = pfpsize ? pfpsize * 2 : 16;
+		prevfp = realloc(prevfp, pfpsize * sizeof (prgreg_t));
+		/*
+		 * Just assume there is no loop in the face of allocation
+		 * failure; the caller still has the original prevfp pointer.
+		 */
+		if (prevfp == NULL)
+			return (0);
+	}
+
+	prevfp[nfp++] = fp;
+	*prevfpp = prevfp;
+	*pfpsizep = pfpsize;
+	*nfpp = nfp;
+
+	return (0);
+}
+
+/*
+ * Signal Frame Detection
+ *
+ * In order to facilitate detection and processing of signal handler frames
+ * during a stack backtrace, we define a set of utility routines to operate on
+ * a uclist (ucontext address list), and then use these routines in the various
+ * implementations of Pstack_iter below.  Certain source-level debuggers and
+ * virtual machines that shall remain nameless believe that in order to detect
+ * signal handler frames, one must hard-code checks for symbol names defined
+ * in libc and libthread and knowledge of their implementation.  We make no
+ * such assumptions, allowing us to operate on programs that manipulate their
+ * underlying kernel signal handlers (i.e. use __sigaction) and to not require
+ * changes in the face of future library modifications.
+ *
+ * A signal handler frame is essentially a set of data pushed on to the user
+ * stack by the kernel prior to returning to the user program in one of the
+ * pre-defined signal handlers.  The signal handler itself receives the signal
+ * number, an optional pointer to a siginfo_t, and a pointer to the interrupted
+ * ucontext as arguments.  When performing a stack backtrace, we would like to
+ * detect these frames so that we can correctly return the interrupted program
+ * counter and frame pointer as a separate frame.  When a signal handler frame
+ * is constructed on the stack by the kernel, the signalled LWP has its
+ * lwp_oldcontext member (exported through /proc as lwpstatus.pr_oldcontext)
+ * set to the user address at which the ucontext_t was placed on the LWP's
+ * stack.  The ucontext_t's uc_link member is set to the previous value of
+ * lwp_oldcontext.  Thus when signal handlers are active, pr_oldcontext will
+ * point to the first element of a linked list of ucontext_t addresses.
+ *
+ * The stack layout for a signal handler frame is as follows:
+ *
+ * SPARC v7/v9:                           Intel ia32:
+ * +--------------+ -        high         +--------------+ -
+ * |  struct fq   | ^        addrs        |  siginfo_t   | optional
+ * +--------------+ |          ^          +--------------+ -
+ * |  gwindows_t  |            |          |  ucontext_t  | ^
+ * +--------------+ optional              +--------------+ |
+ * |  siginfo_t   |                       | ucontext_t * | |
+ * +--------------+ |          |          +--------------+
+ * |  xregs data  | v          v          |  siginfo_t * | mandatory
+ * +--------------+ -         low         +--------------+
+ * |  ucontext_t  | ^        addrs        |  int (signo) | |
+ * +--------------+ mandatory             +--------------+ |
+ * | struct frame | v                     | struct frame | v
+ * +--------------+ - <- %sp on resume    +--------------+ - <- %esp on resume
+ *
+ * amd64 (64-bit):
+ * +--------------+ -
+ * |  siginfo_t   | optional
+ * +--------------+ -
+ * |  ucontext_t  | ^
+ * +--------------+ |
+ * |  siginfo_t * |
+ * +--------------+ mandatory
+ * |  int (signo) |
+ * +--------------+ |
+ * | struct frame | v
+ * +--------------+ - <- %rsp on resume
+ *
+ * The bottom-most struct frame is actually constructed by the kernel by
+ * copying the previous stack frame, allowing naive backtrace code to simply
+ * skip over the interrupted frame.  The copied frame is never really used,
+ * since it is presumed the libc or libthread signal handler wrapper function
+ * will explicitly setcontext(2) to the interrupted context if the user
+ * program's handler returns.  If we detect a signal handler frame, we simply
+ * read the interrupted context structure from the stack, use its embedded
+ * gregs to construct the register set for the interrupted frame, and then
+ * continue our backtrace.  Detecting the frame itself is easy according to
+ * the diagram ("oldcontext" represents any element in the uc_link chain):
+ *
+ * On SPARC v7 or v9:
+ * %fp + sizeof (struct frame) == oldcontext
+ *
+ * On Intel ia32:
+ * %ebp + sizeof (struct frame) + (3 * regsize) == oldcontext
+ *
+ * On amd64:
+ * %rbp + sizeof (struct frame) + (2 * regsize) == oldcontext
+ *
+ * A final complication is that we want libproc to support backtraces from
+ * arbitrary addresses without the caller passing in an LWP id.  To do this,
+ * we must first determine all the known oldcontexts by iterating over all
+ * LWPs and following their pr_oldcontext pointers.  We optimize our search
+ * by discarding NULL pointers and pointers whose value is less than that
+ * of the initial stack pointer (since stacks grow down from high memory),
+ * and then sort the resulting list by virtual address so we can binary search.
+ */
+
+int
+load_uclist(uclist_t *ucl, const lwpstatus_t *psp)
+{
+	struct ps_prochandle *P = ucl->uc_proc;
+	uintptr_t addr = psp->pr_oldcontext;
+
+	uintptr_t *new_addrs;
+	uint_t new_size, i;
+	ucontext_t uc;
+
+	if (addr == NULL)
+		return (0);
+
+	for (;;) {
+		if (ucl->uc_nelems == ucl->uc_size) {
+			new_size = ucl->uc_size ? ucl->uc_size * 2 : 16;
+			new_addrs = realloc(ucl->uc_addrs,
+			    new_size * sizeof (uintptr_t));
+
+			if (new_addrs != NULL) {
+				ucl->uc_addrs = new_addrs;
+				ucl->uc_size = new_size;
+			} else
+				break; /* abort if allocation failure */
+		}
+#ifdef _LP64
+		if (P->status.pr_dmodel == PR_MODEL_ILP32) {
+			ucontext32_t u32;
+
+			if (Pread(P, &u32, sizeof (u32), addr) != sizeof (u32))
+				break; /* abort if we fail to read ucontext */
+			uc.uc_link = (ucontext_t *)(uintptr_t)u32.uc_link;
+		} else
+#endif
+		if (Pread(P, &uc, sizeof (uc), addr) != sizeof (uc))
+			break; /* abort if we fail to read ucontext */
+
+		dprintf("detected lwp %d signal context at %p\n",
+		    (int)psp->pr_lwpid, (void *)addr);
+		ucl->uc_addrs[ucl->uc_nelems++] = addr;
+
+		addr = (uintptr_t)uc.uc_link;
+
+		/*
+		 * Abort if we find a NULL uc_link pointer or a duplicate
+		 * entry which could indicate a cycle or a very peculiar
+		 * interference pattern between threads.
+		 */
+		if (addr == NULL)
+			break;
+
+		for (i = 0; i < ucl->uc_nelems - 1; i++) {
+			if (ucl->uc_addrs[i] == addr)
+				return (0);
+		}
+	}
+
+	return (0);
+}
+
+int
+sort_uclist(const void *lhp, const void *rhp)
+{
+	uintptr_t lhs = *((const uintptr_t *)lhp);
+	uintptr_t rhs = *((const uintptr_t *)rhp);
+
+	if (lhs < rhs)
+		return (-1);
+	if (lhs > rhs)
+		return (+1);
+	return (0);
+}
+
+void
+init_uclist(uclist_t *ucl, struct ps_prochandle *P)
+{
+	if ((P->state == PS_STOP || P->state == PS_DEAD) &&
+	    P->ucaddrs != NULL) {
+		ucl->uc_proc = P;
+		ucl->uc_addrs = P->ucaddrs;
+		ucl->uc_nelems = P->ucnelems;
+		ucl->uc_size = P->ucnelems;
+		ucl->uc_cached = 1;
+		return;
+	}
+
+	ucl->uc_proc = P;
+	ucl->uc_addrs = NULL;
+	ucl->uc_nelems = 0;
+	ucl->uc_size = 0;
+
+	(void) Plwp_iter(P, (proc_lwp_f *)load_uclist, ucl);
+	qsort(ucl->uc_addrs, ucl->uc_nelems, sizeof (uintptr_t), sort_uclist);
+
+	if (P->state == PS_STOP || P->state == PS_DEAD) {
+		P->ucaddrs = ucl->uc_addrs;
+		P->ucnelems = ucl->uc_nelems;
+		ucl->uc_cached = 1;
+	} else {
+		ucl->uc_cached = 0;
+	}
+}
+
+void
+free_uclist(uclist_t *ucl)
+{
+	if (!ucl->uc_cached && ucl->uc_addrs != NULL)
+		free(ucl->uc_addrs);
+}
+
+int
+find_uclink(uclist_t *ucl, uintptr_t addr)
+{
+	if (ucl->uc_nelems != 0) {
+		return (bsearch(&addr, ucl->uc_addrs, ucl->uc_nelems,
+		    sizeof (uintptr_t), sort_uclist) != NULL);
+	}
+
+	return (0);
+}