xref: /illumos-gate/usr/src/cmd/ptools/pstack/pstack.c (revision 616d60f414d125f2dfc25908ca90a7c4451076c6)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  *
25  * Copyright 2018 Joyent, Inc.
26  * Copyright 2024 Bill Sommerfeld <sommerfeld@hamachi.org>
27  */
28 
29 #include <sys/isa_defs.h>
30 
31 #include <stdio.h>
32 #include <stdio_ext.h>
33 #include <fcntl.h>
34 #include <ctype.h>
35 #include <string.h>
36 #include <signal.h>
37 #include <dirent.h>
38 #include <errno.h>
39 #include <stdlib.h>
40 #include <stdarg.h>
41 #include <unistd.h>
42 #include <sys/types.h>
43 #include <sys/stat.h>
44 #include <sys/stack.h>
45 #include <link.h>
46 #include <limits.h>
47 #include <libelf.h>
48 #include <thread_db.h>
49 #include <libproc.h>
50 #include <setjmp.h>
51 
52 static	char	*command;
53 static	int	Fflag;
54 static	int	is64;
55 static	GElf_Sym sigh;
56 
57 /*
58  * To keep the list of user-level threads for a multithreaded process.
59  */
60 struct threadinfo {
61 	struct threadinfo *next;
62 	id_t	threadid;
63 	id_t	lwpid;
64 	td_thr_state_e state;
65 	uintptr_t startfunc;
66 	uintptr_t exitval;
67 	prgregset_t regs;
68 };
69 
70 static struct threadinfo *thr_head, *thr_tail;
71 
72 #define	TRUE	1
73 #define	FALSE	0
74 
75 #define	MAX_ARGS	8
76 
77 /*
78  * To support debugging java programs, we display java frames within a stack.
79  * The logic to walk the java frames is contained in libjvm_db.so, which is
80  * found in the same directory as libjvm.so, linked with the program.  If we are
81  * debugging a 32-bit app with a 64-binary, then the debugging library is found
82  * in the '64' subdirectory.  If we find libjvm_db.so, then we fill in these
83  * stub routines.
84  */
85 typedef struct jvm_agent jvm_agent_t;
86 typedef int java_stack_f(void *, prgregset_t, const char *, int, int, void *);
87 
88 /*
89  * The j_agent_create function takes a version parameter.  This ensures that the
90  * interface can evolve appropriately.
91  */
92 #define	JVM_DB_VERSION	1
93 static void *libjvm;
94 typedef jvm_agent_t *(*j_agent_create_f)(struct ps_prochandle *, int);
95 typedef void (*j_agent_destroy_f)(jvm_agent_t *);
96 typedef int (*j_frame_iter_f)(jvm_agent_t *, prgregset_t, java_stack_f *,
97     void *);
98 
99 static j_agent_create_f j_agent_create;
100 static j_agent_destroy_f j_agent_destroy;
101 static j_frame_iter_f j_frame_iter;
102 
103 static jvm_agent_t *load_libjvm(struct ps_prochandle *P);
104 static void reset_libjvm(jvm_agent_t *);
105 
106 /*
107  * Similar to what's done for debugging java programs, here are prototypes for
108  * the library that allows us to debug Python programs.
109  */
110 #define	PYDB_VERSION	1
111 static void *libpython;
112 
113 typedef struct pydb_agent pydb_agent_t;
114 
115 typedef pydb_agent_t *(*pydb_agent_create_f)(struct ps_prochandle *P, int vers);
116 typedef void (*pydb_agent_destroy_f)(pydb_agent_t *py);
117 typedef int (*pydb_pc_frameinfo_f)(pydb_agent_t *py, uintptr_t pc,
118     uintptr_t frame_addr, char *fbuf, size_t bufsz);
119 typedef int (*pydb_pc_frameinfo_argv_f)(pydb_agent_t *py, uintptr_t pc,
120     const long *argv, char *fbuf, size_t bufsz);
121 
122 static pydb_agent_create_f pydb_agent_create;
123 static pydb_agent_destroy_f pydb_agent_destroy;
124 static pydb_pc_frameinfo_f pydb_pc_frameinfo;
125 static pydb_pc_frameinfo_argv_f pydb_pc_frameinfo_argv;
126 
127 static pydb_agent_t *load_libpython(struct ps_prochandle *P);
128 static void reset_libpython(pydb_agent_t *);
129 /*
130  * Since we must maintain both a proc handle and a jvm handle, this structure
131  * is the basic type that gets passed around.
132  */
133 typedef struct pstack_handle {
134 	struct ps_prochandle *proc;
135 	jvm_agent_t *jvm;
136 	int ignore_frame;
137 	const char *lwps;
138 	int count;
139 	pydb_agent_t *pydb;
140 } pstack_handle_t;
141 
142 static	int	thr_stack(const td_thrhandle_t *, void *);
143 static	void	free_threadinfo(void);
144 static	struct threadinfo *find_thread(id_t);
145 static	int	all_call_stacks(pstack_handle_t *, int);
146 static	void	tlhead(id_t, id_t, const char *);
147 static	int	print_frame(void *, prgregset_t, uint_t, const long *);
148 static	void	print_zombie(struct ps_prochandle *, struct threadinfo *);
149 static	void	print_syscall(const lwpstatus_t *, prgregset_t);
150 static	void	call_stack(pstack_handle_t *, const lwpstatus_t *);
151 
152 /*
153  * The number of active and zombie threads.
154  */
155 static	int	nthreads;
156 
157 int
main(int argc,char ** argv)158 main(int argc, char **argv)
159 {
160 	int retc = 0;
161 	int opt;
162 	int errflg = FALSE;
163 	core_content_t content = CC_CONTENT_DATA | CC_CONTENT_ANON |
164 	    CC_CONTENT_STACK;
165 	struct rlimit rlim;
166 
167 	if ((command = strrchr(argv[0], '/')) != NULL)
168 		command++;
169 	else
170 		command = argv[0];
171 
172 	/* options */
173 	while ((opt = getopt(argc, argv, "F")) != EOF) {
174 		switch (opt) {
175 		case 'F':
176 			/*
177 			 * If the user specifies the force option, we'll
178 			 * consent to printing out other threads' stacks
179 			 * even if the main stack is absent.
180 			 */
181 			content &= ~CC_CONTENT_STACK;
182 			Fflag = PGRAB_FORCE;
183 			break;
184 		default:
185 			errflg = TRUE;
186 			break;
187 		}
188 	}
189 
190 	argc -= optind;
191 	argv += optind;
192 
193 	if (errflg || argc <= 0) {
194 		(void) fprintf(stderr,
195 		    "usage:\t%s [-F] { pid | core }[/lwps] ...\n", command);
196 		(void) fprintf(stderr, "  (show process call stack)\n");
197 		(void) fprintf(stderr,
198 		    "  -F: force grabbing of the target process\n");
199 		exit(2);
200 	}
201 
202 	/*
203 	 * Make sure we'll have enough file descriptors to handle a target
204 	 * that has many many mappings.
205 	 */
206 	if (getrlimit(RLIMIT_NOFILE, &rlim) == 0) {
207 		rlim.rlim_cur = rlim.rlim_max;
208 		(void) setrlimit(RLIMIT_NOFILE, &rlim);
209 		(void) enable_extended_FILE_stdio(-1, -1);
210 	}
211 
212 	(void) proc_initstdio();
213 
214 	while (--argc >= 0) {
215 		int gcode;
216 		psinfo_t psinfo;
217 		const psinfo_t *tpsinfo;
218 		struct ps_prochandle *Pr = NULL;
219 		td_thragent_t *Tap;
220 		int threaded;
221 		pstack_handle_t handle;
222 		const char *lwps, *arg;
223 
224 		(void) proc_flushstdio();
225 
226 		arg = *argv++;
227 
228 		if ((Pr = proc_arg_xgrab(arg, NULL, PR_ARG_ANY,
229 		    Fflag, &gcode, &lwps)) == NULL) {
230 			(void) fprintf(stderr, "%s: cannot examine %s: %s\n",
231 			    command, arg, Pgrab_error(gcode));
232 			retc++;
233 			continue;
234 		}
235 
236 		if ((tpsinfo = Ppsinfo(Pr)) == NULL) {
237 			(void) fprintf(stderr, "%s: cannot examine %s: "
238 			    "lost control of process\n", command, arg);
239 			Prelease(Pr, 0);
240 			retc++;
241 			continue;
242 		}
243 		(void) memcpy(&psinfo, tpsinfo, sizeof (psinfo_t));
244 		proc_unctrl_psinfo(&psinfo);
245 
246 		if (Pstate(Pr) == PS_DEAD) {
247 			if ((Pcontent(Pr) & content) != content) {
248 				(void) fprintf(stderr, "%s: core '%s' has "
249 				    "insufficient content\n", command, arg);
250 				retc++;
251 				continue;
252 			}
253 			(void) printf("core '%s' of %d:\t%.70s\n",
254 			    arg, (int)psinfo.pr_pid, psinfo.pr_psargs);
255 		} else {
256 			(void) printf("%d:\t%.70s\n",
257 			    (int)psinfo.pr_pid, psinfo.pr_psargs);
258 		}
259 
260 		is64 = (psinfo.pr_dmodel == PR_MODEL_LP64);
261 
262 		if (Pgetauxval(Pr, AT_BASE) != -1L && Prd_agent(Pr) == NULL) {
263 			(void) fprintf(stderr, "%s: warning: librtld_db failed "
264 			    "to initialize; symbols from shared libraries will "
265 			    "not be available\n", command);
266 		}
267 
268 		/*
269 		 * First we need to get a thread agent handle.
270 		 */
271 		if (td_init() != TD_OK ||
272 		    td_ta_new(Pr, &Tap) != TD_OK)	/* no libc */
273 			threaded = FALSE;
274 		else {
275 			/*
276 			 * Iterate over all threads, calling:
277 			 *   thr_stack(td_thrhandle_t *Thp, NULL);
278 			 * for each one to generate the list of threads.
279 			 */
280 			nthreads = 0;
281 			(void) td_ta_thr_iter(Tap, thr_stack, NULL,
282 			    TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
283 			    TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
284 
285 			(void) td_ta_delete(Tap);
286 			threaded = TRUE;
287 		}
288 
289 		handle.proc = Pr;
290 		handle.jvm = load_libjvm(Pr);
291 		handle.pydb = load_libpython(Pr);
292 		handle.lwps = lwps;
293 		handle.count = 0;
294 
295 		if (all_call_stacks(&handle, threaded) != 0)
296 			retc++;
297 		if (threaded)
298 			free_threadinfo();
299 
300 		reset_libjvm(handle.jvm);
301 		reset_libpython(handle.pydb);
302 		Prelease(Pr, 0);
303 
304 		if (handle.count == 0)
305 			(void) fprintf(stderr, "%s: no matching LWPs found\n",
306 			    command);
307 	}
308 
309 	(void) proc_finistdio();
310 
311 	return (retc);
312 }
313 
314 /*
315  * Thread iteration call-back function.
316  * Called once for each user-level thread.
317  * Used to build the list of all threads.
318  */
319 /* ARGSUSED1 */
320 static int
thr_stack(const td_thrhandle_t * Thp,void * cd)321 thr_stack(const td_thrhandle_t *Thp, void *cd)
322 {
323 	td_thrinfo_t thrinfo;
324 	struct threadinfo *tip;
325 	td_err_e error;
326 
327 	if (td_thr_get_info(Thp, &thrinfo) != TD_OK)
328 		return (0);
329 
330 	tip = malloc(sizeof (struct threadinfo));
331 	tip->next = NULL;
332 	tip->threadid = thrinfo.ti_tid;
333 	tip->lwpid = thrinfo.ti_lid;
334 	tip->state = thrinfo.ti_state;
335 	tip->startfunc = thrinfo.ti_startfunc;
336 	tip->exitval = (uintptr_t)thrinfo.ti_exitval;
337 	nthreads++;
338 
339 	if (thrinfo.ti_state == TD_THR_ZOMBIE ||
340 	    ((error = td_thr_getgregs(Thp, tip->regs)) != TD_OK &&
341 	    error != TD_PARTIALREG))
342 		(void) memset(tip->regs, 0, sizeof (prgregset_t));
343 
344 	if (thr_tail)
345 		thr_tail->next = tip;
346 	else
347 		thr_head = tip;
348 	thr_tail = tip;
349 
350 	return (0);
351 }
352 
353 static void
free_threadinfo()354 free_threadinfo()
355 {
356 	struct threadinfo *tip = thr_head;
357 	struct threadinfo *next;
358 
359 	while (tip) {
360 		next = tip->next;
361 		free(tip);
362 		tip = next;
363 	}
364 
365 	thr_head = thr_tail = NULL;
366 }
367 
368 /*
369  * Find and eliminate the thread corresponding to the given lwpid.
370  */
371 static struct threadinfo *
find_thread(id_t lwpid)372 find_thread(id_t lwpid)
373 {
374 	struct threadinfo *tip;
375 
376 	for (tip = thr_head; tip; tip = tip->next) {
377 		if (lwpid == tip->lwpid) {
378 			tip->lwpid = 0;
379 			return (tip);
380 		}
381 	}
382 	return (NULL);
383 }
384 
385 static int
thread_call_stack(void * data,const lwpstatus_t * psp,const lwpsinfo_t * pip)386 thread_call_stack(void *data, const lwpstatus_t *psp,
387     const lwpsinfo_t *pip)
388 {
389 	char lwpname[THREAD_NAME_MAX] = "";
390 	pstack_handle_t *h = data;
391 	lwpstatus_t lwpstatus;
392 	struct threadinfo *tip;
393 
394 	if (!proc_lwp_in_set(h->lwps, pip->pr_lwpid))
395 		return (0);
396 	h->count++;
397 
398 	if ((tip = find_thread(pip->pr_lwpid)) == NULL)
399 		return (0);
400 
401 	(void) Plwp_getname(h->proc, pip->pr_lwpid,
402 	    lwpname, sizeof (lwpname));
403 
404 	tlhead(tip->threadid, pip->pr_lwpid, lwpname);
405 	tip->threadid = 0;	/* finish eliminating tid */
406 	if (psp)
407 		call_stack(h, psp);
408 	else {
409 		if (tip->state == TD_THR_ZOMBIE)
410 			print_zombie(h->proc, tip);
411 		else {
412 			(void) memset(&lwpstatus, 0, sizeof (lwpstatus));
413 			(void) memcpy(lwpstatus.pr_reg, tip->regs,
414 			    sizeof (prgregset_t));
415 			call_stack(h, &lwpstatus);
416 		}
417 	}
418 	return (0);
419 }
420 
421 static int
lwp_call_stack(void * data,const lwpstatus_t * psp,const lwpsinfo_t * pip)422 lwp_call_stack(void *data,
423     const lwpstatus_t *psp, const lwpsinfo_t *pip)
424 {
425 	char lwpname[THREAD_NAME_MAX] = "";
426 	pstack_handle_t *h = data;
427 
428 	if (!proc_lwp_in_set(h->lwps, pip->pr_lwpid))
429 		return (0);
430 	h->count++;
431 
432 	(void) Plwp_getname(h->proc, pip->pr_lwpid,
433 	    lwpname, sizeof (lwpname));
434 
435 	tlhead(0, pip->pr_lwpid, lwpname);
436 	if (psp)
437 		call_stack(h, psp);
438 	else
439 		(void) printf("\t** zombie "
440 		    "(exited, not detached, not yet joined) **\n");
441 	return (0);
442 }
443 
444 static int
all_call_stacks(pstack_handle_t * h,int dothreads)445 all_call_stacks(pstack_handle_t *h, int dothreads)
446 {
447 	struct ps_prochandle *Pr = h->proc;
448 	pstatus_t status = *Pstatus(Pr);
449 
450 	(void) memset(&sigh, 0, sizeof (GElf_Sym));
451 	(void) Plookup_by_name(Pr, "libc.so", "sigacthandler", &sigh);
452 
453 	if ((status.pr_nlwp + status.pr_nzomb) <= 1 &&
454 	    !(dothreads && nthreads > 1)) {
455 		if (proc_lwp_in_set(h->lwps, status.pr_lwp.pr_lwpid)) {
456 			call_stack(h, &status.pr_lwp);
457 			h->count++;
458 		}
459 	} else {
460 		lwpstatus_t lwpstatus;
461 		struct threadinfo *tip;
462 		id_t tid;
463 
464 		if (dothreads)
465 			(void) Plwp_iter_all(Pr, thread_call_stack, h);
466 		else
467 			(void) Plwp_iter_all(Pr, lwp_call_stack, h);
468 
469 		/* for each remaining thread w/o an lwp */
470 		(void) memset(&lwpstatus, 0, sizeof (lwpstatus));
471 		for (tip = thr_head; tip; tip = tip->next) {
472 
473 			if (!proc_lwp_in_set(h->lwps, tip->lwpid))
474 				tip->threadid = 0;
475 
476 			if ((tid = tip->threadid) != 0) {
477 				(void) memcpy(lwpstatus.pr_reg, tip->regs,
478 				    sizeof (prgregset_t));
479 				tlhead(tid, tip->lwpid, NULL);
480 				if (tip->state == TD_THR_ZOMBIE)
481 					print_zombie(Pr, tip);
482 				else
483 					call_stack(h, &lwpstatus);
484 			}
485 			tip->threadid = 0;
486 			tip->lwpid = 0;
487 		}
488 	}
489 	return (0);
490 }
491 
492 /* The width of the header */
493 #define	HEAD_WIDTH	(62)
494 static void
tlhead(id_t threadid,id_t lwpid,const char * name)495 tlhead(id_t threadid, id_t lwpid, const char *name)
496 {
497 	char buf[128] = { 0 };
498 	char num[16];
499 	ssize_t amt = 0;
500 	int i;
501 
502 	if (threadid == 0 && lwpid == 0)
503 		return;
504 
505 	if (lwpid > 0) {
506 		(void) snprintf(num, sizeof (num), "%d", (int)lwpid);
507 		(void) strlcat(buf, "thread# ", sizeof (buf));
508 		(void) strlcat(buf, num, sizeof (buf));
509 	}
510 
511 	if (threadid > 0) {
512 		(void) snprintf(num, sizeof (num), "%d", (int)threadid);
513 		if (lwpid > 0)
514 			(void) strlcat(buf, " / ", sizeof (buf));
515 		(void) strlcat(buf, "lwp# ", sizeof (buf));
516 		(void) strlcat(buf, num, sizeof (buf));
517 	}
518 
519 	if (name != NULL && strlen(name) > 0) {
520 		(void) strlcat(buf, " [", sizeof (buf));
521 		(void) strlcat(buf, name, sizeof (buf));
522 		(void) strlcat(buf, "]", sizeof (buf));
523 	}
524 
525 	amt = (HEAD_WIDTH - strlen(buf) - 2);
526 	if (amt < 4)
527 		amt = 4;
528 
529 	for (i = 0; i < amt / 2; i++)
530 		(void) putc('-', stdout);
531 	(void) printf(" %s ", buf);
532 	for (i = 0; i < (amt / 2) + (amt % 2); i++)
533 		(void) putc('-', stdout);
534 	(void) putc('\n', stdout);
535 }
536 
537 /*ARGSUSED*/
538 static int
print_java_frame(void * cld,prgregset_t gregs,const char * name,int bci,int line,void * handle)539 print_java_frame(void *cld, prgregset_t gregs, const char *name, int bci,
540     int line, void *handle)
541 {
542 	int length = (is64 ? 16 : 8);
543 
544 	(void) printf(" %.*lx * %s", length, (long)gregs[R_PC], name);
545 
546 	if (bci != -1) {
547 		(void) printf("+%d", bci);
548 		if (line)
549 			(void) printf(" (line %d)", line);
550 	}
551 	(void) printf("\n");
552 
553 	return (0);
554 }
555 
556 static sigjmp_buf jumpbuf;
557 
558 /*ARGSUSED*/
559 static void
fatal_signal(int signo)560 fatal_signal(int signo)
561 {
562 	siglongjmp(jumpbuf, 1);
563 }
564 
565 static int
print_frame(void * cd,prgregset_t gregs,uint_t argc,const long * argv)566 print_frame(void *cd, prgregset_t gregs, uint_t argc, const long *argv)
567 {
568 	pstack_handle_t *h = cd;
569 	struct ps_prochandle *Pr = h->proc;
570 	uintptr_t pc = gregs[R_PC];
571 	char buff[255];
572 	GElf_Sym sym;
573 	uintptr_t start;
574 	int length = (is64? 16 : 8);
575 	int i;
576 
577 	/*
578 	 * If we are in a system call, we display the entry frame in a more
579 	 * readable manner, using the name of the system call.  In this case, we
580 	 * want to ignore this first frame, since we already displayed it
581 	 * separately.
582 	 */
583 	if (h->ignore_frame) {
584 		h->ignore_frame = 0;
585 		return (0);
586 	}
587 
588 	(void) sprintf(buff, "%.*lx", length, (long)pc);
589 	(void) strcpy(buff + length, " ????????");
590 	if (Plookup_by_addr(Pr, pc,
591 	    buff + 1 + length, sizeof (buff) - 1 - length, &sym) == 0) {
592 		start = sym.st_value;
593 	} else if (h->jvm != NULL) {
594 		int ret;
595 		void (*segv)(int), (*bus)(int), (*ill)(int);
596 
597 		segv = signal(SIGSEGV, fatal_signal);
598 		bus = signal(SIGBUS, fatal_signal);
599 		ill = signal(SIGILL, fatal_signal);
600 
601 		/* Insure against a bad libjvm_db */
602 		if (sigsetjmp(jumpbuf, 0) == 0)
603 			ret = j_frame_iter(h->jvm, gregs, print_java_frame,
604 			    NULL);
605 		else
606 			ret = -1;
607 
608 		(void) signal(SIGSEGV, segv);
609 		(void) signal(SIGBUS, bus);
610 		(void) signal(SIGILL, ill);
611 
612 		if (ret == 0)
613 			return (ret);
614 	} else {
615 		start = pc;
616 	}
617 
618 	(void) printf(" %-17s (", buff);
619 	for (i = 0; i < argc && i < MAX_ARGS; i++)
620 		(void) printf((i+1 == argc) ? "%lx" : "%lx, ", argv[i]);
621 	if (i != argc)
622 		(void) printf("...");
623 	(void) printf((start != pc) ? ") + %lx\n" : ")\n", (long)(pc - start));
624 
625 	if (h->pydb != NULL && argc > 0) {
626 		char buf_py[1024];
627 		int rc;
628 		if (pydb_pc_frameinfo_argv != NULL) {
629 			rc = pydb_pc_frameinfo_argv(h->pydb, pc, argv, buf_py,
630 			    sizeof (buf_py));
631 		} else {
632 			rc = pydb_pc_frameinfo(h->pydb, pc, argv[0], buf_py,
633 			    sizeof (buf_py));
634 		}
635 		if (rc == 0) {
636 			(void) printf("   %s", buf_py);
637 		}
638 	}
639 
640 	/*
641 	 * If the frame's pc is in the "sigh" (a.k.a. signal handler, signal
642 	 * hack, or *sigh* ...) range, then we're about to cross a signal
643 	 * frame.  The signal number is the first argument to this function.
644 	 */
645 	if (pc - sigh.st_value < sigh.st_size) {
646 		if (sig2str((int)argv[0], buff) == -1)
647 			(void) strcpy(buff, " Unknown");
648 		(void) printf(" --- called from signal handler with "
649 		    "signal %d (SIG%s) ---\n", (int)argv[0], buff);
650 	}
651 
652 	return (0);
653 }
654 
655 static void
print_zombie(struct ps_prochandle * Pr,struct threadinfo * tip)656 print_zombie(struct ps_prochandle *Pr, struct threadinfo *tip)
657 {
658 	char buff[255];
659 	GElf_Sym sym;
660 	uintptr_t start;
661 	int length = (is64? 16 : 8);
662 
663 	(void) sprintf(buff, "%.*lx", length, (long)tip->startfunc);
664 	(void) strcpy(buff + length, " ????????");
665 	if (Plookup_by_addr(Pr, tip->startfunc,
666 	    buff + 1 + length, sizeof (buff) - 1 - length, &sym) == 0)
667 		start = sym.st_value;
668 	else
669 		start = tip->startfunc;
670 	(void) printf(" %s()", buff);
671 	if (start != tip->startfunc)	/* doesn't happen? */
672 		(void) printf("+%lx", (long)(tip->startfunc - start));
673 	(void) printf(", exit value = 0x%.*lx\n", length, (long)tip->exitval);
674 	(void) printf("\t** zombie "
675 	    "(exited, not detached, not yet joined) **\n");
676 }
677 
678 static void
print_syscall(const lwpstatus_t * psp,prgregset_t reg)679 print_syscall(const lwpstatus_t *psp, prgregset_t reg)
680 {
681 	char sname[32];
682 	int length = (is64? 16 : 8);
683 	uint_t i;
684 
685 	(void) proc_sysname(psp->pr_syscall, sname, sizeof (sname));
686 	(void) printf(" %.*lx %-8s (", length, (long)reg[R_PC], sname);
687 	for (i = 0; i < psp->pr_nsysarg; i++)
688 		(void) printf((i+1 == psp->pr_nsysarg)? "%lx" : "%lx, ",
689 		    (long)psp->pr_sysarg[i]);
690 	(void) printf(")\n");
691 }
692 
693 static void
call_stack(pstack_handle_t * h,const lwpstatus_t * psp)694 call_stack(pstack_handle_t *h, const lwpstatus_t *psp)
695 {
696 	prgregset_t reg;
697 
698 	(void) memcpy(reg, psp->pr_reg, sizeof (reg));
699 
700 	if ((psp->pr_flags & (PR_ASLEEP|PR_VFORKP)) ||
701 	    ((psp->pr_flags & PR_ISTOP) &&
702 	    (psp->pr_why == PR_SYSENTRY ||
703 	    psp->pr_why == PR_SYSEXIT))) {
704 		print_syscall(psp, reg);
705 		h->ignore_frame = 1;
706 	} else {
707 		h->ignore_frame = 0;
708 	}
709 
710 	(void) Pstack_iter(h->proc, reg, print_frame, h);
711 }
712 
713 /*ARGSUSED*/
714 static int
jvm_object_iter(void * cd,const prmap_t * pmp,const char * obj)715 jvm_object_iter(void *cd, const prmap_t *pmp, const char *obj)
716 {
717 	char path[PATH_MAX];
718 	char *name;
719 	char *s1, *s2;
720 	struct ps_prochandle *Pr = cd;
721 
722 	if ((name = strstr(obj, "/libjvm.so")) == NULL)
723 		name = strstr(obj, "/libjvm_g.so");
724 
725 	if (name) {
726 		(void) strcpy(path, obj);
727 		if (Pstatus(Pr)->pr_dmodel != PR_MODEL_NATIVE) {
728 			s1 = name;
729 			s2 = path + (s1 - obj);
730 			(void) strcpy(s2, "/64");
731 			s2 += 3;
732 			(void) strcpy(s2, s1);
733 		}
734 
735 		s1 = strstr(obj, ".so");
736 		s2 = strstr(path, ".so");
737 		(void) strcpy(s2, "_db");
738 		s2 += 3;
739 		(void) strcpy(s2, s1);
740 
741 		if ((libjvm = dlopen(path, RTLD_LAZY|RTLD_GLOBAL)) != NULL)
742 			return (1);
743 	}
744 
745 	return (0);
746 }
747 
748 static jvm_agent_t *
load_libjvm(struct ps_prochandle * Pr)749 load_libjvm(struct ps_prochandle *Pr)
750 {
751 	jvm_agent_t *ret;
752 
753 	/*
754 	 * Iterate through all the loaded objects in the target, looking
755 	 * for libjvm.so.  If we find libjvm.so we'll try to load the
756 	 * corresponding libjvm_db.so that lives in the same directory.
757 	 *
758 	 * At first glance it seems like we'd want to use
759 	 * Pobject_iter_resolved() here since we'd want to make sure that
760 	 * we have the full path to the libjvm.so.  But really, we don't
761 	 * want that since we're going to be dlopen()ing a library and
762 	 * executing code from that path, and therefore we don't want to
763 	 * load any library code that could be from a zone since it could
764 	 * have been replaced with a trojan.  Hence, we use Pobject_iter().
765 	 * So if we're debugging java processes in a zone from the global
766 	 * zone, and we want to get proper java stack stack frames, then
767 	 * the same jvm that is running within the zone needs to be
768 	 * installed in the global zone.
769 	 */
770 	(void) Pobject_iter(Pr, jvm_object_iter, Pr);
771 
772 	if (libjvm) {
773 		j_agent_create = (j_agent_create_f)
774 		    dlsym(libjvm, "Jagent_create");
775 		j_agent_destroy = (j_agent_destroy_f)
776 		    dlsym(libjvm, "Jagent_destroy");
777 		j_frame_iter = (j_frame_iter_f)
778 		    dlsym(libjvm, "Jframe_iter");
779 
780 		if (j_agent_create == NULL || j_agent_destroy == NULL ||
781 		    j_frame_iter == NULL ||
782 		    (ret = j_agent_create(Pr, JVM_DB_VERSION)) == NULL) {
783 			reset_libjvm(NULL);
784 			return (NULL);
785 		}
786 
787 		return (ret);
788 	}
789 
790 	return (NULL);
791 }
792 
793 static void
reset_libjvm(jvm_agent_t * agent)794 reset_libjvm(jvm_agent_t *agent)
795 {
796 	if (libjvm) {
797 		if (agent)
798 			j_agent_destroy(agent);
799 
800 		(void) dlclose(libjvm);
801 	}
802 
803 	j_agent_create = NULL;
804 	j_agent_destroy = NULL;
805 	j_frame_iter = NULL;
806 	libjvm = NULL;
807 }
808 
809 /*ARGSUSED*/
810 static int
python_object_iter(void * cd,const prmap_t * pmp,const char * obj)811 python_object_iter(void *cd, const prmap_t *pmp, const char *obj)
812 {
813 	char path[PATH_MAX];
814 	char *name;
815 	char *s1, *s2;
816 	struct ps_prochandle *Pr = cd;
817 
818 	name = strstr(obj, "/libpython");
819 
820 	if (name) {
821 		(void) strcpy(path, obj);
822 		if (Pstatus(Pr)->pr_dmodel != PR_MODEL_NATIVE) {
823 			s1 = name;
824 			s2 = path + (s1 - obj);
825 			(void) strcpy(s2, "/64");
826 			s2 += 3;
827 			(void) strcpy(s2, s1);
828 		}
829 
830 		s1 = strstr(obj, ".so");
831 		s2 = strstr(path, ".so");
832 		(void) strcpy(s2, "_db");
833 		s2 += 3;
834 		(void) strcpy(s2, s1);
835 
836 		if ((libpython = dlopen(path, RTLD_LAZY|RTLD_GLOBAL)) != NULL)
837 			return (1);
838 	}
839 
840 	return (0);
841 }
842 
843 static pydb_agent_t *
load_libpython(struct ps_prochandle * Pr)844 load_libpython(struct ps_prochandle *Pr)
845 {
846 	pydb_agent_t *pdb;
847 
848 	(void) Pobject_iter(Pr, python_object_iter, Pr);
849 
850 	if (libpython) {
851 		pydb_agent_create = (pydb_agent_create_f)
852 		    dlsym(libpython, "pydb_agent_create");
853 		pydb_agent_destroy = (pydb_agent_destroy_f)
854 		    dlsym(libpython, "pydb_agent_destroy");
855 		pydb_pc_frameinfo = (pydb_pc_frameinfo_f)
856 		    dlsym(libpython, "pydb_pc_frameinfo");
857 		pydb_pc_frameinfo_argv = (pydb_pc_frameinfo_argv_f)
858 		    dlsym(libpython, "pydb_pc_frameinfo_argv");
859 
860 		if (pydb_agent_create == NULL || pydb_agent_destroy == NULL ||
861 		    (pydb_pc_frameinfo == NULL &&
862 		    pydb_pc_frameinfo_argv == NULL)) {
863 			(void) dlclose(libpython);
864 			libpython = NULL;
865 			return (NULL);
866 		}
867 
868 		pdb = pydb_agent_create(Pr, PYDB_VERSION);
869 		if (pdb == NULL) {
870 			(void) dlclose(libpython);
871 			libpython = NULL;
872 			return (NULL);
873 		}
874 		return (pdb);
875 	}
876 
877 	return (NULL);
878 }
879 
880 static void
reset_libpython(pydb_agent_t * pdb)881 reset_libpython(pydb_agent_t *pdb)
882 {
883 	if (libpython != NULL) {
884 		if (pdb != NULL) {
885 			pydb_agent_destroy(pdb);
886 		}
887 		(void) dlclose(libpython);
888 	}
889 
890 	libpython = NULL;
891 	pydb_agent_create = NULL;
892 	pydb_agent_destroy = NULL;
893 	pydb_pc_frameinfo = NULL;
894 }
895