?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / cmd / truss / fcall.c
blobe1fe50340907ce4529b4dd7c560ea420082d41e5
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 /*
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #define _SYSCALL32
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <unistd.h>
32 #include <ctype.h>
33 #include <string.h>
34 #include <memory.h>
35 #include <errno.h>
36 #include <sys/types.h>
37 #include <sys/stack.h>
38 #include <signal.h>
39 #include <limits.h>
40 #include <sys/isa_defs.h>
41 #include <proc_service.h>
42 #include <dlfcn.h>
43 #include <fnmatch.h>
44 #include <libproc.h>
45 #include "ramdata.h"
46 #include "systable.h"
47 #include "print.h"
48 #include "proto.h"
49 #include "htbl.h"
50
51 /*
52 * Functions supporting library function call tracing.
53 */
54
55 typedef struct {
56 prmap_t *pmap;
57 int nmap;
58 } ph_map_t;
59
60 /*
61 * static functions in this file.
62 */
63 void function_entry(private_t *, struct bkpt *, struct callstack *);
64 void function_return(private_t *, struct callstack *);
65 int object_iter(void *, const prmap_t *, const char *);
66 int object_present(void *, const prmap_t *, const char *);
67 int symbol_iter(void *, const GElf_Sym *, const char *);
68 uintptr_t get_return_address(uintptr_t *);
69 int get_arguments(long *argp);
70 uintptr_t previous_fp(uintptr_t, uintptr_t *);
71 int lwp_stack_traps(void *cd, const lwpstatus_t *Lsp);
72 int thr_stack_traps(const td_thrhandle_t *Thp, void *cd);
73 struct bkpt *create_bkpt(uintptr_t, int, int);
74 void set_deferred_breakpoints(void);
75
76 #define DEF_MAXCALL 16 /* initial value of Stk->maxcall */
77
78 #define FAULT_ADDR ((uintptr_t)(0-8))
79
80 #define HASHSZ 2048
81 #define bpt_hash(addr) ((((addr) >> 13) ^ ((addr) >> 2)) & 0x7ff)
82
83 static void
84 setup_thread_agent(void)
85 {
86 struct bkpt *Bp;
87 td_notify_t notify;
88 td_thr_events_t events;
89
90 if (Thr_agent != NULL) /* only once */
91 return;
92 if (td_init() != TD_OK || td_ta_new(Proc, &Thr_agent) != TD_OK)
93 Thr_agent = NULL;
94 else {
95 td_event_emptyset(&events);
96 td_event_addset(&events, TD_CREATE);
97 if (td_ta_event_addr(Thr_agent, TD_CREATE, &notify) == TD_OK &&
98 notify.type == NOTIFY_BPT &&
99 td_ta_set_event(Thr_agent, &events) == TD_OK &&
100 (Bp = create_bkpt(notify.u.bptaddr, 0, 1)) != NULL)
101 Bp->flags |= BPT_TD_CREATE;
102 }
103 }
104
105 /*
106 * Delete all breakpoints in the range [base .. base+size)
107 * from the breakpoint hash table.
108 */
109 static void
110 delete_breakpoints(uintptr_t base, size_t size)
111 {
112 struct bkpt **Bpp;
113 struct bkpt *Bp;
114 int i;
115
116 if (bpt_hashtable == NULL)
117 return;
118 for (i = 0; i < HASHSZ; i++) {
119 Bpp = &bpt_hashtable[i];
120 while ((Bp = *Bpp) != NULL) {
121 if (Bp->addr < base || Bp->addr >= base + size) {
122 Bpp = &Bp->next;
123 continue;
124 }
125 *Bpp = Bp->next;
126 if (Bp->sym_name)
127 free(Bp->sym_name);
128 free(Bp);
129 }
130 }
131 }
132
133 /*
134 * Establishment of breakpoints on traced library functions.
135 */
136 void
137 establish_breakpoints(void)
138 {
139 if (Dynpat == NULL)
140 return;
141
142 /* allocate the breakpoint hash table */
143 if (bpt_hashtable == NULL) {
144 bpt_hashtable = my_malloc(HASHSZ * sizeof (struct bkpt *),
145 NULL);
146 (void) memset(bpt_hashtable, 0,
147 HASHSZ * sizeof (struct bkpt *));
148 }
149
150 /*
151 * Set special rtld_db event breakpoints, first time only.
152 */
153 if (Rdb_agent == NULL &&
154 (Rdb_agent = Prd_agent(Proc)) != NULL) {
155 rd_notify_t notify;
156 struct bkpt *Bp;
157
158 (void) rd_event_enable(Rdb_agent, 1);
159 if (rd_event_addr(Rdb_agent, RD_PREINIT, &notify) == RD_OK &&
160 (Bp = create_bkpt(notify.u.bptaddr, 0, 1)) != NULL)
161 Bp->flags |= BPT_PREINIT;
162 if (rd_event_addr(Rdb_agent, RD_POSTINIT, &notify) == RD_OK &&
163 (Bp = create_bkpt(notify.u.bptaddr, 0, 1)) != NULL)
164 Bp->flags |= BPT_POSTINIT;
165 if (rd_event_addr(Rdb_agent, RD_DLACTIVITY, &notify) == RD_OK &&
166 (Bp = create_bkpt(notify.u.bptaddr, 0, 1)) != NULL)
167 Bp->flags |= BPT_DLACTIVITY;
168 }
169
170 /*
171 * Set special thread event breakpoint, first time libc is seen.
172 */
173 if (Thr_agent == NULL)
174 setup_thread_agent();
175
176 /*
177 * Tell libproc to update its mappings.
178 */
179 Pupdate_maps(Proc);
180
181 /*
182 * If rtld_db told us a library was being deleted,
183 * first mark all of the dynlibs as not present, then
184 * iterate over the shared objects, marking only those
185 * present that really are present, and finally delete
186 * all of the not-present dynlibs.
187 */
188 if (delete_library) {
189 struct dynlib **Dpp;
190 struct dynlib *Dp;
191
192 for (Dp = Dynlib; Dp != NULL; Dp = Dp->next)
193 Dp->present = FALSE;
194 (void) Pobject_iter(Proc, object_present, NULL);
195 Dpp = &Dynlib;
196 while ((Dp = *Dpp) != NULL) {
197 if (Dp->present) {
198 Dpp = &Dp->next;
199 continue;
200 }
201 delete_breakpoints(Dp->base, Dp->size);
202 *Dpp = Dp->next;
203 free(Dp->lib_name);
204 free(Dp->match_name);
205 free(Dp->prt_name);
206 free(Dp);
207 }
208 delete_library = FALSE;
209 }
210
211 /*
212 * Iterate over the shared objects, creating breakpoints.
213 */
214 (void) Pobject_iter(Proc, object_iter, NULL);
215
216 /*
217 * Now actually set all the breakpoints we just created.
218 */
219 set_deferred_breakpoints();
220 }
221
222 /*
223 * Initial establishment of stacks in a newly-grabbed process.
224 * establish_breakpoints() has already been called.
225 */
226 void
227 establish_stacks(void)
228 {
229 const pstatus_t *Psp = Pstatus(Proc);
230 char mapfile[64];
231 int mapfd;
232 struct stat statb;
233 prmap_t *Pmap = NULL;
234 int nmap = 0;
235 ph_map_t ph_map;
236
237 (void) sprintf(mapfile, "/proc/%d/rmap", (int)Psp->pr_pid);
238 if ((mapfd = open(mapfile, O_RDONLY)) < 0 ||
239 fstat(mapfd, &statb) != 0 ||
240 statb.st_size < sizeof (prmap_t) ||
241 (Pmap = my_malloc(statb.st_size, NULL)) == NULL ||
242 (nmap = pread(mapfd, Pmap, statb.st_size, 0L)) <= 0 ||
243 (nmap /= sizeof (prmap_t)) == 0) {
244 if (Pmap != NULL)
245 free(Pmap);
246 Pmap = NULL;
247 nmap = 0;
248 }
249 if (mapfd >= 0)
250 (void) close(mapfd);
251
252 /*
253 * Iterate over lwps, establishing stacks.
254 */
255 ph_map.pmap = Pmap;
256 ph_map.nmap = nmap;
257 (void) Plwp_iter(Proc, lwp_stack_traps, &ph_map);
258 if (Pmap != NULL)
259 free(Pmap);
260
261 if (Thr_agent == NULL)
262 return;
263
264 /*
265 * Iterate over unbound threads, establishing stacks.
266 */
267 (void) td_ta_thr_iter(Thr_agent, thr_stack_traps, NULL,
268 TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
269 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
270 }
271
272 void
273 do_symbol_iter(const char *object_name, struct dynpat *Dyp)
274 {
275 if (*Dyp->Dp->prt_name == '\0')
276 object_name = PR_OBJ_EXEC;
277
278 /*
279 * Always search the dynamic symbol table.
280 */
281 (void) Psymbol_iter(Proc, object_name,
282 PR_DYNSYM, BIND_WEAK|BIND_GLOBAL|TYPE_FUNC,
283 symbol_iter, Dyp);
284
285 /*
286 * Search the static symbol table if this is the
287 * executable file or if we are being asked to
288 * report internal calls within the library.
289 */
290 if (object_name == PR_OBJ_EXEC || Dyp->internal)
291 (void) Psymbol_iter(Proc, object_name,
292 PR_SYMTAB, BIND_ANY|TYPE_FUNC,
293 symbol_iter, Dyp);
294 }
295
296 /* ARGSUSED */
297 int
298 object_iter(void *cd, const prmap_t *pmp, const char *object_name)
299 {
300 char name[100];
301 struct dynpat *Dyp;
302 struct dynlib *Dp;
303 const char *str;
304 char *s;
305 int i;
306
307 if ((pmp->pr_mflags & MA_WRITE) || !(pmp->pr_mflags & MA_EXEC))
308 return (0);
309
310 /*
311 * Set special thread event breakpoint, first time libc is seen.
312 */
313 if (Thr_agent == NULL && strstr(object_name, "/libc.so.") != NULL)
314 setup_thread_agent();
315
316 for (Dp = Dynlib; Dp != NULL; Dp = Dp->next)
317 if (strcmp(object_name, Dp->lib_name) == 0 ||
318 (strcmp(Dp->lib_name, "a.out") == 0 &&
319 strcmp(pmp->pr_mapname, "a.out") == 0))
320 break;
321
322 if (Dp == NULL) {
323 Dp = my_malloc(sizeof (struct dynlib), NULL);
324 (void) memset(Dp, 0, sizeof (struct dynlib));
325 if (strcmp(pmp->pr_mapname, "a.out") == 0) {
326 Dp->lib_name = strdup(pmp->pr_mapname);
327 Dp->match_name = strdup(pmp->pr_mapname);
328 Dp->prt_name = strdup("");
329 } else {
330 Dp->lib_name = strdup(object_name);
331 if ((str = strrchr(object_name, '/')) != NULL)
332 str++;
333 else
334 str = object_name;
335 (void) strncpy(name, str, sizeof (name) - 2);
336 name[sizeof (name) - 2] = '\0';
337 if ((s = strstr(name, ".so")) != NULL)
338 *s = '\0';
339 Dp->match_name = strdup(name);
340 (void) strcat(name, ":");
341 Dp->prt_name = strdup(name);
342 }
343 Dp->next = Dynlib;
344 Dynlib = Dp;
345 }
346
347 if (Dp->built ||
348 (not_consist && strcmp(Dp->prt_name, "ld:") != 0)) /* kludge */
349 return (0);
350
351 if (hflag && not_consist)
352 (void) fprintf(stderr, "not_consist is TRUE, building %s\n",
353 Dp->lib_name);
354
355 Dp->base = pmp->pr_vaddr;
356 Dp->size = pmp->pr_size;
357
358 /*
359 * For every dynlib pattern that matches this library's name,
360 * iterate through all of the library's symbols looking for
361 * matching symbol name patterns.
362 */
363 for (Dyp = Dynpat; Dyp != NULL; Dyp = Dyp->next) {
364 if (interrupt|sigusr1)
365 break;
366 for (i = 0; i < Dyp->nlibpat; i++) {
367 if (interrupt|sigusr1)
368 break;
369 if (fnmatch(Dyp->libpat[i], Dp->match_name, 0) != 0)
370 continue; /* no match */
371
372 /*
373 * Require an exact match for the executable (a.out)
374 * and for the dynamic linker (ld.so.1).
375 */
376 if ((strcmp(Dp->match_name, "a.out") == 0 ||
377 strcmp(Dp->match_name, "ld") == 0) &&
378 strcmp(Dyp->libpat[i], Dp->match_name) != 0)
379 continue;
380
381 /*
382 * Set Dyp->Dp to Dp so symbol_iter() can use it.
383 */
384 Dyp->Dp = Dp;
385 do_symbol_iter(object_name, Dyp);
386 Dyp->Dp = NULL;
387 }
388 }
389
390 Dp->built = TRUE;
391 return (interrupt | sigusr1);
392 }
393
394 /* ARGSUSED */
395 int
396 object_present(void *cd, const prmap_t *pmp, const char *object_name)
397 {
398 struct dynlib *Dp;
399
400 for (Dp = Dynlib; Dp != NULL; Dp = Dp->next) {
401 if (Dp->base == pmp->pr_vaddr)
402 Dp->present = TRUE;
403 }
404
405 return (0);
406 }
407
408 /*
409 * Search for an existing breakpoint at the 'pc' location.
410 */
411 struct bkpt *
412 get_bkpt(uintptr_t pc)
413 {
414 struct bkpt *Bp;
415
416 for (Bp = bpt_hashtable[bpt_hash(pc)]; Bp != NULL; Bp = Bp->next)
417 if (pc == Bp->addr)
418 break;
419
420 return (Bp);
421 }
422
423 /*
424 * Create a breakpoint at 'pc', if one is not there already.
425 * 'ret' is true when creating a function return breakpoint, in which case
426 * fail and return NULL if the breakpoint would be created in writeable data.
427 * If 'set' it true, set the breakpoint in the process now.
428 */
429 struct bkpt *
430 create_bkpt(uintptr_t pc, int ret, int set)
431 {
432 uint_t hix = bpt_hash(pc);
433 struct bkpt *Bp;
434 const prmap_t *pmp;
435
436 for (Bp = bpt_hashtable[hix]; Bp != NULL; Bp = Bp->next)
437 if (pc == Bp->addr)
438 return (Bp);
439
440 /*
441 * Don't set return breakpoints on writeable data
442 * or on any space other than executable text.
443 * Don't set breakpoints in the child of a vfork()
444 * because that would modify the parent's address space.
445 */
446 if (is_vfork_child ||
447 (ret &&
448 ((pmp = Paddr_to_text_map(Proc, pc)) == NULL ||
449 !(pmp->pr_mflags & MA_EXEC) ||
450 (pmp->pr_mflags & MA_WRITE))))
451 return (NULL);
452
453 /* create a new unnamed breakpoint */
454 Bp = my_malloc(sizeof (struct bkpt), NULL);
455 Bp->sym_name = NULL;
456 Bp->dyn = NULL;
457 Bp->addr = pc;
458 Bp->instr = 0;
459 Bp->flags = 0;
460 if (set && Psetbkpt(Proc, Bp->addr, &Bp->instr) == 0)
461 Bp->flags |= BPT_ACTIVE;
462 Bp->next = bpt_hashtable[hix];
463 bpt_hashtable[hix] = Bp;
464
465 return (Bp);
466 }
467
468 /*
469 * Set all breakpoints that haven't been set yet.
470 * Deactivate all breakpoints from modules that are not present any more.
471 */
472 void
473 set_deferred_breakpoints(void)
474 {
475 struct bkpt *Bp;
476 int i;
477
478 if (is_vfork_child)
479 return;
480
481 for (i = 0; i < HASHSZ; i++) {
482 for (Bp = bpt_hashtable[i]; Bp != NULL; Bp = Bp->next) {
483 if (!(Bp->flags & BPT_ACTIVE)) {
484 if (!(Bp->flags & BPT_EXCLUDE) &&
485 Psetbkpt(Proc, Bp->addr, &Bp->instr) == 0)
486 Bp->flags |= BPT_ACTIVE;
487 } else if (Paddr_to_text_map(Proc, Bp->addr) == NULL) {
488 Bp->flags &= ~BPT_ACTIVE;
489 }
490 }
491 }
492 }
493
494 int
495 symbol_iter(void *cd, const GElf_Sym *sym, const char *sym_name)
496 {
497 struct dynpat *Dyp = cd;
498 struct dynlib *Dp = Dyp->Dp;
499 uintptr_t pc = sym->st_value;
500 struct bkpt *Bp;
501 int i;
502
503 /* ignore any undefined symbols */
504 if (sym->st_shndx == SHN_UNDEF)
505 return (0);
506
507 /*
508 * Arbitrarily omit "_start" from the executable.
509 * (Avoid indentation before main().)
510 */
511 if (*Dp->prt_name == '\0' && strcmp(sym_name, "_start") == 0)
512 return (0);
513
514 /*
515 * Arbitrarily omit "_rt_boot" from the dynamic linker.
516 * (Avoid indentation before main().)
517 */
518 if (strcmp(Dp->match_name, "ld") == 0 &&
519 strcmp(sym_name, "_rt_boot") == 0)
520 return (0);
521
522 /*
523 * Arbitrarily omit any symbols whose name starts with '.'.
524 * Apparantly putting a breakpoint on .umul causes a
525 * fatal error in libthread (%y is not restored correctly
526 * when a single step is taken). Looks like a /proc bug.
527 */
528 if (*sym_name == '.')
529 return (0);
530
531 /*
532 * For each pattern in the array of symbol patterns,
533 * if the pattern matches the symbol name, then
534 * create a breakpoint at the function in question.
535 */
536 for (i = 0; i < Dyp->nsympat; i++) {
537 if (interrupt|sigusr1)
538 break;
539 if (fnmatch(Dyp->sympat[i], sym_name, 0) != 0)
540 continue;
541
542 if ((Bp = create_bkpt(pc, 0, 0)) == NULL) /* can't fail */
543 return (0);
544
545 /*
546 * New breakpoints receive a name now.
547 * For existing breakpoints, prefer the subset name if possible,
548 * else prefer the shorter name.
549 */
550 if (Bp->sym_name == NULL) {
551 Bp->sym_name = strdup(sym_name);
552 } else if (strstr(Bp->sym_name, sym_name) != NULL ||
553 strlen(Bp->sym_name) > strlen(sym_name)) {
554 free(Bp->sym_name);
555 Bp->sym_name = strdup(sym_name);
556 }
557 Bp->dyn = Dp;
558 Bp->flags |= Dyp->flag;
559 if (Dyp->exclude)
560 Bp->flags |= BPT_EXCLUDE;
561 else if (Dyp->internal || *Dp->prt_name == '\0')
562 Bp->flags |= BPT_INTERNAL;
563 return (0);
564 }
565
566 return (interrupt | sigusr1);
567 }
568
569 /* For debugging only ---- */
570 void
571 report_htable_stats(void)
572 {
573 const pstatus_t *Psp = Pstatus(Proc);
574 struct callstack *Stk;
575 struct bkpt *Bp;
576 uint_t Min = 1000000;
577 uint_t Max = 0;
578 uint_t Avg = 0;
579 uint_t Total = 0;
580 uint_t i, j;
581 uint_t bucket[HASHSZ];
582
583 if (Dynpat == NULL || !hflag)
584 return;
585
586 hflag = FALSE;
587 (void) memset(bucket, 0, sizeof (bucket));
588
589 for (i = 0; i < HASHSZ; i++) {
590 j = 0;
591 for (Bp = bpt_hashtable[i]; Bp != NULL; Bp = Bp->next)
592 j++;
593 if (j < Min)
594 Min = j;
595 if (j > Max)
596 Max = j;
597 if (j < HASHSZ)
598 bucket[j]++;
599 Total += j;
600 }
601 Avg = (Total + HASHSZ / 2) / HASHSZ;
602 (void) fprintf(stderr, "truss hash table statistics --------\n");
603 (void) fprintf(stderr, " Total = %u\n", Total);
604 (void) fprintf(stderr, " Min = %u\n", Min);
605 (void) fprintf(stderr, " Max = %u\n", Max);
606 (void) fprintf(stderr, " Avg = %u\n", Avg);
607 for (i = 0; i < HASHSZ; i++)
608 if (bucket[i])
609 (void) fprintf(stderr, " %3u buckets of size %d\n",
610 bucket[i], i);
611
612 (void) fprintf(stderr, "truss-detected stacks --------\n");
613 for (Stk = callstack; Stk != NULL; Stk = Stk->next) {
614 (void) fprintf(stderr,
615 " base = 0x%.8lx end = 0x%.8lx size = %ld\n",
616 (ulong_t)Stk->stkbase,
617 (ulong_t)Stk->stkend,
618 (ulong_t)(Stk->stkend - Stk->stkbase));
619 }
620 (void) fprintf(stderr, "primary unix stack --------\n");
621 (void) fprintf(stderr,
622 " base = 0x%.8lx end = 0x%.8lx size = %ld\n",
623 (ulong_t)Psp->pr_stkbase,
624 (ulong_t)(Psp->pr_stkbase + Psp->pr_stksize),
625 (ulong_t)Psp->pr_stksize);
626 (void) fprintf(stderr, "nthr_create = %u\n", nthr_create);
627 }
628
629 void
630 make_lwp_stack(const lwpstatus_t *Lsp, prmap_t *Pmap, int nmap)
631 {
632 const pstatus_t *Psp = Pstatus(Proc);
633 uintptr_t sp = Lsp->pr_reg[R_SP];
634 id_t lwpid = Lsp->pr_lwpid;
635 struct callstack *Stk;
636 td_thrhandle_t th;
637 td_thrinfo_t thrinfo;
638
639 if (data_model != PR_MODEL_LP64)
640 sp = (uint32_t)sp;
641
642 /* check to see if we already have this stack */
643 if (sp == 0)
644 return;
645 for (Stk = callstack; Stk != NULL; Stk = Stk->next)
646 if (sp >= Stk->stkbase && sp < Stk->stkend)
647 return;
648
649 Stk = my_malloc(sizeof (struct callstack), NULL);
650 Stk->next = callstack;
651 callstack = Stk;
652 nstack++;
653 Stk->tref = 0;
654 Stk->tid = 0;
655 Stk->nthr_create = 0;
656 Stk->ncall = 0;
657 Stk->maxcall = DEF_MAXCALL;
658 Stk->stack = my_malloc(DEF_MAXCALL * sizeof (*Stk->stack), NULL);
659
660 /* primary stack */
661 if (sp >= Psp->pr_stkbase && sp < Psp->pr_stkbase + Psp->pr_stksize) {
662 Stk->stkbase = Psp->pr_stkbase;
663 Stk->stkend = Stk->stkbase + Psp->pr_stksize;
664 return;
665 }
666
667 /* alternate stack */
668 if ((Lsp->pr_altstack.ss_flags & SS_ONSTACK) &&
669 sp >= (uintptr_t)Lsp->pr_altstack.ss_sp &&
670 sp < (uintptr_t)Lsp->pr_altstack.ss_sp
671 + Lsp->pr_altstack.ss_size) {
672 Stk->stkbase = (uintptr_t)Lsp->pr_altstack.ss_sp;
673 Stk->stkend = Stk->stkbase + Lsp->pr_altstack.ss_size;
674 return;
675 }
676
677 /* thread stacks? */
678 if (Thr_agent != NULL &&
679 td_ta_map_lwp2thr(Thr_agent, lwpid, &th) == TD_OK &&
680 td_thr_get_info(&th, &thrinfo) == TD_OK &&
681 sp >= (uintptr_t)thrinfo.ti_stkbase - thrinfo.ti_stksize &&
682 sp < (uintptr_t)thrinfo.ti_stkbase) {
683 /* The bloody fools got this backwards! */
684 Stk->stkend = (uintptr_t)thrinfo.ti_stkbase;
685 Stk->stkbase = Stk->stkend - thrinfo.ti_stksize;
686 return;
687 }
688
689 /* last chance -- try the raw memory map */
690 for (; nmap; nmap--, Pmap++) {
691 if (sp >= Pmap->pr_vaddr &&
692 sp < Pmap->pr_vaddr + Pmap->pr_size) {
693 Stk->stkbase = Pmap->pr_vaddr;
694 Stk->stkend = Pmap->pr_vaddr + Pmap->pr_size;
695 return;
696 }
697 }
698
699 callstack = Stk->next;
700 nstack--;
701 free(Stk->stack);
702 free(Stk);
703 }
704
705 void
706 make_thr_stack(const td_thrhandle_t *Thp, prgregset_t reg)
707 {
708 const pstatus_t *Psp = Pstatus(Proc);
709 td_thrinfo_t thrinfo;
710 uintptr_t sp = reg[R_SP];
711 struct callstack *Stk;
712
713 if (data_model != PR_MODEL_LP64)
714 sp = (uint32_t)sp;
715
716 /* check to see if we already have this stack */
717 if (sp == 0)
718 return;
719 for (Stk = callstack; Stk != NULL; Stk = Stk->next)
720 if (sp >= Stk->stkbase && sp < Stk->stkend)
721 return;
722
723 Stk = my_malloc(sizeof (struct callstack), NULL);
724 Stk->next = callstack;
725 callstack = Stk;
726 nstack++;
727 Stk->tref = 0;
728 Stk->tid = 0;
729 Stk->nthr_create = 0;
730 Stk->ncall = 0;
731 Stk->maxcall = DEF_MAXCALL;
732 Stk->stack = my_malloc(DEF_MAXCALL * sizeof (*Stk->stack), NULL);
733
734 /* primary stack */
735 if (sp >= Psp->pr_stkbase && sp < Psp->pr_stkbase + Psp->pr_stksize) {
736 Stk->stkbase = Psp->pr_stkbase;
737 Stk->stkend = Stk->stkbase + Psp->pr_stksize;
738 return;
739 }
740
741 if (td_thr_get_info(Thp, &thrinfo) == TD_OK &&
742 sp >= (uintptr_t)thrinfo.ti_stkbase - thrinfo.ti_stksize &&
743 sp < (uintptr_t)thrinfo.ti_stkbase) {
744 /* The bloody fools got this backwards! */
745 Stk->stkend = (uintptr_t)thrinfo.ti_stkbase;
746 Stk->stkbase = Stk->stkend - thrinfo.ti_stksize;
747 return;
748 }
749
750 callstack = Stk->next;
751 nstack--;
752 free(Stk->stack);
753 free(Stk);
754 }
755
756 struct callstack *
757 find_lwp_stack(uintptr_t sp)
758 {
759 const pstatus_t *Psp = Pstatus(Proc);
760 char mapfile[64];
761 int mapfd;
762 struct stat statb;
763 prmap_t *Pmap = NULL;
764 prmap_t *pmap = NULL;
765 int nmap = 0;
766 struct callstack *Stk = NULL;
767
768 /*
769 * Get the address space map.
770 */
771 (void) sprintf(mapfile, "/proc/%d/rmap", (int)Psp->pr_pid);
772 if ((mapfd = open(mapfile, O_RDONLY)) < 0 ||
773 fstat(mapfd, &statb) != 0 ||
774 statb.st_size < sizeof (prmap_t) ||
775 (Pmap = my_malloc(statb.st_size, NULL)) == NULL ||
776 (nmap = pread(mapfd, Pmap, statb.st_size, 0L)) <= 0 ||
777 (nmap /= sizeof (prmap_t)) == 0) {
778 if (Pmap != NULL)
779 free(Pmap);
780 if (mapfd >= 0)
781 (void) close(mapfd);
782 return (NULL);
783 }
784 (void) close(mapfd);
785
786 for (pmap = Pmap; nmap--; pmap++) {
787 if (sp >= pmap->pr_vaddr &&
788 sp < pmap->pr_vaddr + pmap->pr_size) {
789 Stk = my_malloc(sizeof (struct callstack), NULL);
790 Stk->next = callstack;
791 callstack = Stk;
792 nstack++;
793 Stk->stkbase = pmap->pr_vaddr;
794 Stk->stkend = pmap->pr_vaddr + pmap->pr_size;
795 Stk->tref = 0;
796 Stk->tid = 0;
797 Stk->nthr_create = 0;
798 Stk->ncall = 0;
799 Stk->maxcall = DEF_MAXCALL;
800 Stk->stack = my_malloc(
801 DEF_MAXCALL * sizeof (*Stk->stack), NULL);
802 break;
803 }
804 }
805
806 free(Pmap);
807 return (Stk);
808 }
809
810 struct callstack *
811 find_stack(uintptr_t sp)
812 {
813 const pstatus_t *Psp = Pstatus(Proc);
814 private_t *pri = get_private();
815 const lwpstatus_t *Lsp = pri->lwpstat;
816 id_t lwpid = Lsp->pr_lwpid;
817 #if defined(__sparc)
818 prgreg_t tref = Lsp->pr_reg[R_G7];
819 #elif defined(__amd64)
820 prgreg_t tref = Lsp->pr_reg[REG_FS];
821 #elif defined(__i386)
822 prgreg_t tref = Lsp->pr_reg[GS];
823 #endif
824 struct callstack *Stk = NULL;
825 td_thrhandle_t th;
826 td_thrinfo_t thrinfo;
827 td_err_e error;
828
829 /* primary stack */
830 if (sp >= Psp->pr_stkbase && sp < Psp->pr_stkbase + Psp->pr_stksize) {
831 Stk = my_malloc(sizeof (struct callstack), NULL);
832 Stk->next = callstack;
833 callstack = Stk;
834 nstack++;
835 Stk->stkbase = Psp->pr_stkbase;
836 Stk->stkend = Stk->stkbase + Psp->pr_stksize;
837 Stk->tref = 0;
838 Stk->tid = 0;
839 Stk->nthr_create = 0;
840 Stk->ncall = 0;
841 Stk->maxcall = DEF_MAXCALL;
842 Stk->stack = my_malloc(DEF_MAXCALL * sizeof (*Stk->stack),
843 NULL);
844 return (Stk);
845 }
846
847 /* alternate stack */
848 if ((Lsp->pr_altstack.ss_flags & SS_ONSTACK) &&
849 sp >= (uintptr_t)Lsp->pr_altstack.ss_sp &&
850 sp < (uintptr_t)Lsp->pr_altstack.ss_sp
851 + Lsp->pr_altstack.ss_size) {
852 Stk = my_malloc(sizeof (struct callstack), NULL);
853 Stk->next = callstack;
854 callstack = Stk;
855 nstack++;
856 Stk->stkbase = (uintptr_t)Lsp->pr_altstack.ss_sp;
857 Stk->stkend = Stk->stkbase + Lsp->pr_altstack.ss_size;
858 Stk->tref = 0;
859 Stk->tid = 0;
860 Stk->nthr_create = 0;
861 Stk->ncall = 0;
862 Stk->maxcall = DEF_MAXCALL;
863 Stk->stack = my_malloc(DEF_MAXCALL * sizeof (*Stk->stack),
864 NULL);
865 return (Stk);
866 }
867
868 if (Thr_agent == NULL)
869 return (find_lwp_stack(sp));
870
871 /* thread stacks? */
872 if ((error = td_ta_map_lwp2thr(Thr_agent, lwpid, &th)) != TD_OK) {
873 if (hflag)
874 (void) fprintf(stderr,
875 "cannot get thread handle for "
876 "lwp#%d, error=%d, tref=0x%.8lx\n",
877 (int)lwpid, error, (long)tref);
878 return (NULL);
879 }
880
881 if ((error = td_thr_get_info(&th, &thrinfo)) != TD_OK) {
882 if (hflag)
883 (void) fprintf(stderr,
884 "cannot get thread info for "
885 "lwp#%d, error=%d, tref=0x%.8lx\n",
886 (int)lwpid, error, (long)tref);
887 return (NULL);
888 }
889
890 if (sp >= (uintptr_t)thrinfo.ti_stkbase - thrinfo.ti_stksize &&
891 sp < (uintptr_t)thrinfo.ti_stkbase) {
892 Stk = my_malloc(sizeof (struct callstack), NULL);
893 Stk->next = callstack;
894 callstack = Stk;
895 nstack++;
896 /* The bloody fools got this backwards! */
897 Stk->stkend = (uintptr_t)thrinfo.ti_stkbase;
898 Stk->stkbase = Stk->stkend - thrinfo.ti_stksize;
899 Stk->tref = tref;
900 Stk->tid = thrinfo.ti_tid;
901 Stk->nthr_create = nthr_create;
902 Stk->ncall = 0;
903 Stk->maxcall = DEF_MAXCALL;
904 Stk->stack = my_malloc(DEF_MAXCALL * sizeof (*Stk->stack),
905 NULL);
906 return (Stk);
907 }
908
909 /* stack bounds failure -- complain bitterly */
910 if (hflag) {
911 (void) fprintf(stderr,
912 "sp not within thread stack: "
913 "sp=0x%.8lx stkbase=0x%.8lx stkend=0x%.8lx\n",
914 (ulong_t)sp,
915 /* The bloody fools got this backwards! */
916 (ulong_t)thrinfo.ti_stkbase - thrinfo.ti_stksize,
917 (ulong_t)thrinfo.ti_stkbase);
918 }
919
920 return (NULL);
921 }
922
923 void
924 get_tid(struct callstack *Stk)
925 {
926 private_t *pri = get_private();
927 const lwpstatus_t *Lsp = pri->lwpstat;
928 id_t lwpid = Lsp->pr_lwpid;
929 #if defined(__sparc)
930 prgreg_t tref = Lsp->pr_reg[R_G7];
931 #elif defined(__amd64)
932 prgreg_t tref = (data_model == PR_MODEL_LP64) ?
933 Lsp->pr_reg[REG_FS] : Lsp->pr_reg[REG_GS];
934 #elif defined(__i386)
935 prgreg_t tref = Lsp->pr_reg[GS];
936 #endif
937 td_thrhandle_t th;
938 td_thrinfo_t thrinfo;
939 td_err_e error;
940
941 if (Thr_agent == NULL) {
942 Stk->tref = 0;
943 Stk->tid = 0;
944 Stk->nthr_create = 0;
945 return;
946 }
947
948 /*
949 * Shortcut here --
950 * If we have a matching tref and no new threads have
951 * been created since the last time we encountered this
952 * stack, then we don't have to go through the overhead
953 * of calling td_ta_map_lwp2thr() to get the thread-id.
954 */
955 if (tref == Stk->tref && Stk->nthr_create == nthr_create)
956 return;
957
958 if ((error = td_ta_map_lwp2thr(Thr_agent, lwpid, &th)) != TD_OK) {
959 if (hflag)
960 (void) fprintf(stderr,
961 "cannot get thread handle for "
962 "lwp#%d, error=%d, tref=0x%.8lx\n",
963 (int)lwpid, error, (long)tref);
964 Stk->tref = 0;
965 Stk->tid = 0;
966 Stk->nthr_create = 0;
967 } else if ((error = td_thr_get_info(&th, &thrinfo)) != TD_OK) {
968 if (hflag)
969 (void) fprintf(stderr,
970 "cannot get thread info for "
971 "lwp#%d, error=%d, tref=0x%.8lx\n",
972 (int)lwpid, error, (long)tref);
973 Stk->tref = 0;
974 Stk->tid = 0;
975 Stk->nthr_create = 0;
976 } else {
977 Stk->tref = tref;
978 Stk->tid = thrinfo.ti_tid;
979 Stk->nthr_create = nthr_create;
980 }
981 }
982
983 struct callstack *
984 callstack_info(uintptr_t sp, uintptr_t fp, int makeid)
985 {
986 struct callstack *Stk;
987 uintptr_t trash;
988
989 if (sp == 0 ||
990 Pread(Proc, &trash, sizeof (trash), sp) != sizeof (trash))
991 return (NULL);
992
993 for (Stk = callstack; Stk != NULL; Stk = Stk->next)
994 if (sp >= Stk->stkbase && sp < Stk->stkend)
995 break;
996
997 /*
998 * If we didn't find the stack, do it the hard way.
999 */
1000 if (Stk == NULL) {
1001 uintptr_t stkbase = sp;
1002 uintptr_t stkend;
1003 uint_t minsize;
1004
1005 #if defined(i386) || defined(__amd64)
1006 #ifdef _LP64
1007 if (data_model == PR_MODEL_LP64)
1008 minsize = 2 * sizeof (uintptr_t); /* fp + pc */
1009 else
1010 #endif
1011 minsize = 2 * sizeof (uint32_t);
1012 #else
1013 #ifdef _LP64
1014 if (data_model != PR_MODEL_LP64)
1015 minsize = SA32(MINFRAME32);
1016 else
1017 minsize = SA64(MINFRAME64);
1018 #else
1019 minsize = SA(MINFRAME);
1020 #endif
1021 #endif /* i386 */
1022 stkend = sp + minsize;
1023
1024 while (Stk == NULL && fp != 0 && fp >= sp) {
1025 stkend = fp + minsize;
1026 for (Stk = callstack; Stk != NULL; Stk = Stk->next)
1027 if ((fp >= Stk->stkbase && fp < Stk->stkend) ||
1028 (stkend > Stk->stkbase &&
1029 stkend <= Stk->stkend))
1030 break;
1031 if (Stk == NULL)
1032 fp = previous_fp(fp, NULL);
1033 }
1034
1035 if (Stk != NULL) /* the stack grew */
1036 Stk->stkbase = stkbase;
1037 }
1038
1039 if (Stk == NULL && makeid) /* new stack */
1040 Stk = find_stack(sp);
1041
1042 if (Stk == NULL)
1043 return (NULL);
1044
1045 /*
1046 * Ensure that there is room for at least one more entry.
1047 */
1048 if (Stk->ncall == Stk->maxcall) {
1049 Stk->maxcall *= 2;
1050 Stk->stack = my_realloc(Stk->stack,
1051 Stk->maxcall * sizeof (*Stk->stack), NULL);
1052 }
1053
1054 if (makeid)
1055 get_tid(Stk);
1056
1057 return (Stk);
1058 }
1059
1060 /*
1061 * Reset the breakpoint information (called on successful exec()).
1062 */
1063 void
1064 reset_breakpoints(void)
1065 {
1066 struct dynlib *Dp;
1067 struct bkpt *Bp;
1068 struct callstack *Stk;
1069 int i;
1070
1071 if (Dynpat == NULL)
1072 return;
1073
1074 /* destroy all previous dynamic library information */
1075 while ((Dp = Dynlib) != NULL) {
1076 Dynlib = Dp->next;
1077 free(Dp->lib_name);
1078 free(Dp->match_name);
1079 free(Dp->prt_name);
1080 free(Dp);
1081 }
1082
1083 /* destroy all previous breakpoint trap information */
1084 if (bpt_hashtable != NULL) {
1085 for (i = 0; i < HASHSZ; i++) {
1086 while ((Bp = bpt_hashtable[i]) != NULL) {
1087 bpt_hashtable[i] = Bp->next;
1088 if (Bp->sym_name)
1089 free(Bp->sym_name);
1090 free(Bp);
1091 }
1092 }
1093 }
1094
1095 /* destroy all the callstack information */
1096 while ((Stk = callstack) != NULL) {
1097 callstack = Stk->next;
1098 free(Stk->stack);
1099 free(Stk);
1100 }
1101
1102 /* we are not a multi-threaded process anymore */
1103 if (Thr_agent != NULL)
1104 (void) td_ta_delete(Thr_agent);
1105 Thr_agent = NULL;
1106
1107 /* tell libproc to clear out its mapping information */
1108 Preset_maps(Proc);
1109 Rdb_agent = NULL;
1110
1111 /* Reestablish the symbols from the executable */
1112 (void) establish_breakpoints();
1113 }
1114
1115 /*
1116 * Clear breakpoints from the process (called before Prelease()).
1117 * Don't actually destroy the breakpoint table;
1118 * threads currently fielding breakpoints will need it.
1119 */
1120 void
1121 clear_breakpoints(void)
1122 {
1123 struct bkpt *Bp;
1124 int i;
1125
1126 if (Dynpat == NULL)
1127 return;
1128
1129 /*
1130 * Change all breakpoint traps back to normal instructions.
1131 * We attempt to remove a breakpoint from every address which
1132 * may have ever contained a breakpoint to protect our victims.
1133 */
1134 report_htable_stats(); /* report stats first */
1135 for (i = 0; i < HASHSZ; i++) {
1136 for (Bp = bpt_hashtable[i]; Bp != NULL; Bp = Bp->next) {
1137 if (Bp->flags & BPT_ACTIVE)
1138 (void) Pdelbkpt(Proc, Bp->addr, Bp->instr);
1139 Bp->flags &= ~BPT_ACTIVE;
1140 }
1141 }
1142
1143 if (Thr_agent != NULL) {
1144 td_thr_events_t events;
1145
1146 td_event_fillset(&events);
1147 (void) td_ta_clear_event(Thr_agent, &events);
1148 (void) td_ta_delete(Thr_agent);
1149 }
1150 Thr_agent = NULL;
1151 }
1152
1153 /*
1154 * Reestablish the breakpoint traps in the process.
1155 * Called after resuming from a vfork() in the parent.
1156 */
1157 void
1158 reestablish_traps(void)
1159 {
1160 struct bkpt *Bp;
1161 ulong_t instr;
1162 int i;
1163
1164 if (Dynpat == NULL || is_vfork_child)
1165 return;
1166
1167 for (i = 0; i < HASHSZ; i++) {
1168 for (Bp = bpt_hashtable[i]; Bp != NULL; Bp = Bp->next) {
1169 if ((Bp->flags & BPT_ACTIVE) &&
1170 Psetbkpt(Proc, Bp->addr, &instr) != 0)
1171 Bp->flags &= ~BPT_ACTIVE;
1172 }
1173 }
1174 }
1175
1176 void
1177 show_function_call(private_t *pri,
1178 struct callstack *Stk, struct dynlib *Dp, struct bkpt *Bp)
1179 {
1180 long arg[8];
1181 int narg;
1182 int i;
1183
1184 narg = get_arguments(arg);
1185 make_pname(pri, (Stk != NULL)? Stk->tid : 0);
1186 putpname(pri);
1187 timestamp(pri);
1188 if (Stk != NULL) {
1189 for (i = 1; i < Stk->ncall; i++) {
1190 (void) fputc(' ', stdout);
1191 (void) fputc(' ', stdout);
1192 }
1193 }
1194 (void) printf("-> %s%s(", Dp->prt_name, Bp->sym_name);
1195 for (i = 0; i < narg; i++) {
1196 (void) printf("0x%lx", arg[i]);
1197 if (i < narg-1) {
1198 (void) fputc(',', stdout);
1199 (void) fputc(' ', stdout);
1200 }
1201 }
1202 (void) printf(")\n");
1203 Flush();
1204 }
1205
1206 /* ARGSUSED */
1207 void
1208 show_function_return(private_t *pri, long rval, int stret,
1209 struct callstack *Stk, struct dynlib *Dp, struct bkpt *Bp)
1210 {
1211 int i;
1212
1213 make_pname(pri, Stk->tid);
1214 putpname(pri);
1215 timestamp(pri);
1216 for (i = 0; i < Stk->ncall; i++) {
1217 (void) fputc(' ', stdout);
1218 (void) fputc(' ', stdout);
1219 }
1220 (void) printf("<- %s%s() = ", Dp->prt_name, Bp->sym_name);
1221 if (stret) {
1222 (void) printf("struct return\n");
1223 } else if (data_model == PR_MODEL_LP64) {
1224 if (rval >= (64 * 1024) || -rval >= (64 * 1024))
1225 (void) printf("0x%lx\n", rval);
1226 else
1227 (void) printf("%ld\n", rval);
1228 } else {
1229 int rval32 = (int)rval;
1230 if (rval32 >= (64 * 1024) || -rval32 >= (64 * 1024))
1231 (void) printf("0x%x\n", rval32);
1232 else
1233 (void) printf("%d\n", rval32);
1234 }
1235 Flush();
1236 }
1237
1238 /*
1239 * Called to deal with function-call tracing.
1240 * Return 0 on normal success, 1 to indicate a BPT_HANG success,
1241 * and -1 on failure (not tracing functions or unknown breakpoint).
1242 */
1243 int
1244 function_trace(private_t *pri, int first, int clear, int dotrace)
1245 {
1246 struct ps_lwphandle *Lwp = pri->Lwp;
1247 const lwpstatus_t *Lsp = pri->lwpstat;
1248 uintptr_t pc = Lsp->pr_reg[R_PC];
1249 uintptr_t sp = Lsp->pr_reg[R_SP];
1250 uintptr_t fp = Lsp->pr_reg[R_FP];
1251 struct bkpt *Bp;
1252 struct dynlib *Dp;
1253 struct callstack *Stk;
1254 ulong_t instr;
1255 int active;
1256 int rval = 0;
1257
1258 if (Dynpat == NULL)
1259 return (-1);
1260
1261 if (data_model != PR_MODEL_LP64) {
1262 pc = (uint32_t)pc;
1263 sp = (uint32_t)sp;
1264 fp = (uint32_t)fp;
1265 }
1266
1267 if ((Bp = get_bkpt(pc)) == NULL) {
1268 if (hflag)
1269 (void) fprintf(stderr,
1270 "function_trace(): "
1271 "cannot find breakpoint for pc: 0x%.8lx\n",
1272 (ulong_t)pc);
1273 return (-1);
1274 }
1275
1276 if ((Bp->flags & (BPT_PREINIT|BPT_POSTINIT|BPT_DLACTIVITY)) && !clear) {
1277 rd_event_msg_t event_msg;
1278
1279 if (hflag) {
1280 if (Bp->flags & BPT_PREINIT)
1281 (void) fprintf(stderr, "function_trace(): "
1282 "RD_PREINIT breakpoint\n");
1283 if (Bp->flags & BPT_POSTINIT)
1284 (void) fprintf(stderr, "function_trace(): "
1285 "RD_POSTINIT breakpoint\n");
1286 if (Bp->flags & BPT_DLACTIVITY)
1287 (void) fprintf(stderr, "function_trace(): "
1288 "RD_DLACTIVITY breakpoint\n");
1289 }
1290 if (rd_event_getmsg(Rdb_agent, &event_msg) == RD_OK) {
1291 if (event_msg.type == RD_DLACTIVITY) {
1292 switch (event_msg.u.state) {
1293 case RD_CONSISTENT:
1294 establish_breakpoints();
1295 break;
1296 case RD_ADD:
1297 not_consist = TRUE; /* kludge */
1298 establish_breakpoints();
1299 not_consist = FALSE;
1300 break;
1301 case RD_DELETE:
1302 delete_library = TRUE;
1303 break;
1304 default:
1305 break;
1306 }
1307 }
1308 if (hflag) {
1309 const char *et;
1310 char buf[32];
1311
1312 switch (event_msg.type) {
1313 case RD_NONE:
1314 et = "RD_NONE";
1315 break;
1316 case RD_PREINIT:
1317 et = "RD_PREINIT";
1318 break;
1319 case RD_POSTINIT:
1320 et = "RD_POSTINIT";
1321 break;
1322 case RD_DLACTIVITY:
1323 et = "RD_DLACTIVITY";
1324 break;
1325 default:
1326 (void) sprintf(buf, "0x%x",
1327 event_msg.type);
1328 et = buf;
1329 break;
1330 }
1331 (void) fprintf(stderr,
1332 "event_msg.type = %s ", et);
1333 switch (event_msg.u.state) {
1334 case RD_NOSTATE:
1335 et = "RD_NOSTATE";
1336 break;
1337 case RD_CONSISTENT:
1338 et = "RD_CONSISTENT";
1339 break;
1340 case RD_ADD:
1341 et = "RD_ADD";
1342 break;
1343 case RD_DELETE:
1344 et = "RD_DELETE";
1345 break;
1346 default:
1347 (void) sprintf(buf, "0x%x",
1348 event_msg.u.state);
1349 et = buf;
1350 break;
1351 }
1352 (void) fprintf(stderr,
1353 "event_msg.u.state = %s\n", et);
1354 }
1355 }
1356 }
1357
1358 if ((Bp->flags & BPT_TD_CREATE) && !clear) {
1359 nthr_create++;
1360 if (hflag)
1361 (void) fprintf(stderr, "function_trace(): "
1362 "BPT_TD_CREATE breakpoint\n");
1363 /* we don't care about the event message */
1364 }
1365
1366 Dp = Bp->dyn;
1367
1368 if (dotrace) {
1369 if ((Stk = callstack_info(sp, fp, 1)) == NULL) {
1370 if (Dp != NULL && !clear) {
1371 if (cflag) {
1372 add_fcall(fcall_tbl, Dp->prt_name,
1373 Bp->sym_name, (unsigned long)1);
1374 }
1375 else
1376 show_function_call(pri, NULL, Dp, Bp);
1377 if ((Bp->flags & BPT_HANG) && !first)
1378 rval = 1;
1379 }
1380 } else if (!clear) {
1381 if (Dp != NULL) {
1382 function_entry(pri, Bp, Stk);
1383 if ((Bp->flags & BPT_HANG) && !first)
1384 rval = 1;
1385 } else {
1386 function_return(pri, Stk);
1387 }
1388 }
1389 }
1390
1391 /*
1392 * Single-step the traced instruction. Since it's possible that
1393 * another thread has deactivated this breakpoint, we indicate
1394 * that we have reactivated it by virtue of executing it.
1395 *
1396 * To avoid a deadlock with some other thread in the process
1397 * performing a fork() or a thr_suspend() operation, we must
1398 * drop and later reacquire truss_lock. Some fancy dancing here.
1399 */
1400 active = (Bp->flags & BPT_ACTIVE);
1401 Bp->flags |= BPT_ACTIVE;
1402 instr = Bp->instr;
1403 (void) mutex_unlock(&truss_lock);
1404 (void) Lxecbkpt(Lwp, instr);
1405 (void) mutex_lock(&truss_lock);
1406
1407 if (rval || clear) { /* leave process stopped and abandoned */
1408 #if defined(__i386)
1409 /*
1410 * Leave it stopped in a state that a stack trace is reasonable.
1411 */
1412 /* XX64 needs to be updated for amd64 & gcc */
1413 if (rval && instr == 0x55) { /* pushl %ebp */
1414 /* step it over the movl %esp,%ebp */
1415 (void) mutex_unlock(&truss_lock);
1416 (void) Lsetrun(Lwp, 0, PRCFAULT|PRSTEP);
1417 /* we're wrapping up; wait one second at most */
1418 (void) Lwait(Lwp, MILLISEC);
1419 (void) mutex_lock(&truss_lock);
1420 }
1421 #endif
1422 if (get_bkpt(pc) != Bp)
1423 abend("function_trace: lost breakpoint", NULL);
1424 (void) Pdelbkpt(Proc, Bp->addr, Bp->instr);
1425 Bp->flags &= ~BPT_ACTIVE;
1426 (void) mutex_unlock(&truss_lock);
1427 (void) Lsetrun(Lwp, 0, PRCFAULT|PRSTOP);
1428 /* we're wrapping up; wait one second at most */
1429 (void) Lwait(Lwp, MILLISEC);
1430 (void) mutex_lock(&truss_lock);
1431 } else {
1432 if (get_bkpt(pc) != Bp)
1433 abend("function_trace: lost breakpoint", NULL);
1434 if (!active || !(Bp->flags & BPT_ACTIVE)) {
1435 (void) Pdelbkpt(Proc, Bp->addr, Bp->instr);
1436 Bp->flags &= ~BPT_ACTIVE;
1437 }
1438 }
1439 return (rval);
1440 }
1441
1442 void
1443 function_entry(private_t *pri, struct bkpt *Bp, struct callstack *Stk)
1444 {
1445 const lwpstatus_t *Lsp = pri->lwpstat;
1446 uintptr_t sp = Lsp->pr_reg[R_SP];
1447 uintptr_t rpc = get_return_address(&sp);
1448 struct dynlib *Dp = Bp->dyn;
1449 int oldframe = FALSE;
1450 int i;
1451
1452 #ifdef _LP64
1453 if (data_model != PR_MODEL_LP64) {
1454 sp = (uint32_t)sp;
1455 rpc = (uint32_t)rpc;
1456 }
1457 #endif
1458
1459 /*
1460 * If the sp is not within the stack bounds, forget it.
1461 * If the symbol's 'internal' flag is false,
1462 * don't report internal calls within the library.
1463 */
1464 if (!(sp >= Stk->stkbase && sp < Stk->stkend) ||
1465 (!(Bp->flags & BPT_INTERNAL) &&
1466 rpc >= Dp->base && rpc < Dp->base + Dp->size))
1467 return;
1468
1469 for (i = 0; i < Stk->ncall; i++) {
1470 if (sp >= Stk->stack[i].sp) {
1471 Stk->ncall = i;
1472 if (sp == Stk->stack[i].sp)
1473 oldframe = TRUE;
1474 break;
1475 }
1476 }
1477
1478 /*
1479 * Breakpoints for function returns are set here
1480 * If we're counting function calls, there is no need to set
1481 * a breakpoint upon return
1482 */
1483
1484 if (!oldframe && !cflag) {
1485 (void) create_bkpt(rpc, 1, 1); /* may or may not be set */
1486 Stk->stack[Stk->ncall].sp = sp; /* record it anyeay */
1487 Stk->stack[Stk->ncall].pc = rpc;
1488 Stk->stack[Stk->ncall].fcn = Bp;
1489 }
1490 Stk->ncall++;
1491 if (cflag) {
1492 add_fcall(fcall_tbl, Dp->prt_name, Bp->sym_name,
1493 (unsigned long)1);
1494 } else {
1495 show_function_call(pri, Stk, Dp, Bp);
1496 }
1497 }
1498
1499 /*
1500 * We are here because we hit an unnamed breakpoint.
1501 * Attempt to match this up with a return pc on the stack
1502 * and report the function return.
1503 */
1504 void
1505 function_return(private_t *pri, struct callstack *Stk)
1506 {
1507 const lwpstatus_t *Lsp = pri->lwpstat;
1508 uintptr_t sp = Lsp->pr_reg[R_SP];
1509 uintptr_t fp = Lsp->pr_reg[R_FP];
1510 int i;
1511
1512 #ifdef _LP64
1513 if (data_model != PR_MODEL_LP64) {
1514 sp = (uint32_t)sp;
1515 fp = (uint32_t)fp;
1516 }
1517 #endif
1518
1519 if (fp < sp + 8)
1520 fp = sp + 8;
1521
1522 for (i = Stk->ncall - 1; i >= 0; i--) {
1523 if (sp <= Stk->stack[i].sp && fp > Stk->stack[i].sp) {
1524 Stk->ncall = i;
1525 break;
1526 }
1527 }
1528
1529 #if defined(i386) || defined(__amd64)
1530 if (i < 0) {
1531 /* probably __mul64() or friends -- try harder */
1532 int j;
1533 for (j = 0; i < 0 && j < 8; j++) { /* up to 8 args */
1534 sp -= 4;
1535 for (i = Stk->ncall - 1; i >= 0; i--) {
1536 if (sp <= Stk->stack[i].sp &&
1537 fp > Stk->stack[i].sp) {
1538 Stk->ncall = i;
1539 break;
1540 }
1541 }
1542 }
1543 }
1544 #endif
1545
1546 if ((i >= 0) && (!cflag)) {
1547 show_function_return(pri, Lsp->pr_reg[R_R0], 0,
1548 Stk, Stk->stack[i].fcn->dyn, Stk->stack[i].fcn);
1549 }
1550 }
1551
1552 #if defined(__sparc)
1553 #define FPADJUST 0
1554 #elif defined(__amd64)
1555 #define FPADJUST 8
1556 #elif defined(__i386)
1557 #define FPADJUST 4
1558 #endif
1559
1560 void
1561 trap_one_stack(prgregset_t reg)
1562 {
1563 struct dynlib *Dp;
1564 struct bkpt *Bp;
1565 struct callstack *Stk;
1566 GElf_Sym sym;
1567 char sym_name[32];
1568 uintptr_t sp = reg[R_SP];
1569 uintptr_t pc = reg[R_PC];
1570 uintptr_t fp;
1571 uintptr_t rpc;
1572 uint_t nframe = 0;
1573 uint_t maxframe = 8;
1574 struct {
1575 uintptr_t sp; /* %sp within called function */
1576 uintptr_t pc; /* %pc within called function */
1577 uintptr_t rsp; /* the return sp */
1578 uintptr_t rpc; /* the return pc */
1579 } *frame = my_malloc(maxframe * sizeof (*frame), NULL);
1580
1581 /*
1582 * Gather stack frames bottom to top.
1583 */
1584 while (sp != 0) {
1585 fp = sp; /* remember higest non-null sp */
1586 frame[nframe].sp = sp;
1587 frame[nframe].pc = pc;
1588 sp = previous_fp(sp, &pc);
1589 frame[nframe].rsp = sp;
1590 frame[nframe].rpc = pc;
1591 if (++nframe == maxframe) {
1592 maxframe *= 2;
1593 frame = my_realloc(frame, maxframe * sizeof (*frame),
1594 NULL);
1595 }
1596 }
1597
1598 /*
1599 * Scan for function return breakpoints top to bottom.
1600 */
1601 while (nframe--) {
1602 /* lookup the called function in the symbol tables */
1603 if (Plookup_by_addr(Proc, frame[nframe].pc, sym_name,
1604 sizeof (sym_name), &sym) != 0)
1605 continue;
1606
1607 pc = sym.st_value; /* entry point of the function */
1608 rpc = frame[nframe].rpc; /* caller's return pc */
1609
1610 /* lookup the function in the breakpoint table */
1611 if ((Bp = get_bkpt(pc)) == NULL || (Dp = Bp->dyn) == NULL)
1612 continue;
1613
1614 if (!(Bp->flags & BPT_INTERNAL) &&
1615 rpc >= Dp->base && rpc < Dp->base + Dp->size)
1616 continue;
1617
1618 sp = frame[nframe].rsp + FPADJUST; /* %sp at time of call */
1619 if ((Stk = callstack_info(sp, fp, 0)) == NULL)
1620 continue; /* can't happen? */
1621
1622 if (create_bkpt(rpc, 1, 1) != NULL) {
1623 Stk->stack[Stk->ncall].sp = sp;
1624 Stk->stack[Stk->ncall].pc = rpc;
1625 Stk->stack[Stk->ncall].fcn = Bp;
1626 Stk->ncall++;
1627 }
1628 }
1629
1630 free(frame);
1631 }
1632
1633 int
1634 lwp_stack_traps(void *cd, const lwpstatus_t *Lsp)
1635 {
1636 ph_map_t *ph_map = (ph_map_t *)cd;
1637 prgregset_t reg;
1638
1639 (void) memcpy(reg, Lsp->pr_reg, sizeof (prgregset_t));
1640 make_lwp_stack(Lsp, ph_map->pmap, ph_map->nmap);
1641 trap_one_stack(reg);
1642
1643 return (interrupt | sigusr1);
1644 }
1645
1646 /* ARGSUSED */
1647 int
1648 thr_stack_traps(const td_thrhandle_t *Thp, void *cd)
1649 {
1650 prgregset_t reg;
1651
1652 /*
1653 * We have already dealt with all the lwps.
1654 * We only care about unbound threads here (TD_PARTIALREG).
1655 */
1656 if (td_thr_getgregs(Thp, reg) != TD_PARTIALREG)
1657 return (0);
1658
1659 make_thr_stack(Thp, reg);
1660 trap_one_stack(reg);
1661
1662 return (interrupt | sigusr1);
1663 }
1664
1665 #if defined(__sparc)
1666
1667 uintptr_t
1668 previous_fp(uintptr_t sp, uintptr_t *rpc)
1669 {
1670 uintptr_t fp = 0;
1671 uintptr_t pc = 0;
1672
1673 #ifdef _LP64
1674 if (data_model == PR_MODEL_LP64) {
1675 struct rwindow64 rwin;
1676 if (Pread(Proc, &rwin, sizeof (rwin), sp + STACK_BIAS)
1677 == sizeof (rwin)) {
1678 fp = (uintptr_t)rwin.rw_fp;
1679 pc = (uintptr_t)rwin.rw_rtn;
1680 }
1681 if (fp != 0 &&
1682 Pread(Proc, &rwin, sizeof (rwin), fp + STACK_BIAS)
1683 != sizeof (rwin))
1684 fp = pc = 0;
1685 } else {
1686 struct rwindow32 rwin;
1687 #else /* _LP64 */
1688 struct rwindow rwin;
1689 #endif /* _LP64 */
1690 if (Pread(Proc, &rwin, sizeof (rwin), sp) == sizeof (rwin)) {
1691 fp = (uint32_t)rwin.rw_fp;
1692 pc = (uint32_t)rwin.rw_rtn;
1693 }
1694 if (fp != 0 &&
1695 Pread(Proc, &rwin, sizeof (rwin), fp) != sizeof (rwin))
1696 fp = pc = 0;
1697 #ifdef _LP64
1698 }
1699 #endif
1700 if (rpc)
1701 *rpc = pc;
1702 return (fp);
1703 }
1704
1705 /* ARGSUSED */
1706 uintptr_t
1707 get_return_address(uintptr_t *psp)
1708 {
1709 instr_t inst;
1710 private_t *pri = get_private();
1711 const lwpstatus_t *Lsp = pri->lwpstat;
1712 uintptr_t rpc;
1713
1714 rpc = (uintptr_t)Lsp->pr_reg[R_O7] + 8;
1715 if (data_model != PR_MODEL_LP64)
1716 rpc = (uint32_t)rpc;
1717
1718 /* check for structure return (bletch!) */
1719 if (Pread(Proc, &inst, sizeof (inst), rpc) == sizeof (inst) &&
1720 inst < 0x1000)
1721 rpc += sizeof (instr_t);
1722
1723 return (rpc);
1724 }
1725
1726 int
1727 get_arguments(long *argp)
1728 {
1729 private_t *pri = get_private();
1730 const lwpstatus_t *Lsp = pri->lwpstat;
1731 int i;
1732
1733 if (data_model != PR_MODEL_LP64)
1734 for (i = 0; i < 4; i++)
1735 argp[i] = (uint_t)Lsp->pr_reg[R_O0+i];
1736 else
1737 for (i = 0; i < 4; i++)
1738 argp[i] = (long)Lsp->pr_reg[R_O0+i];
1739 return (4);
1740 }
1741
1742 #endif /* __sparc */
1743
1744 #if defined(__i386) || defined(__amd64)
1745
1746 uintptr_t
1747 previous_fp(uintptr_t fp, uintptr_t *rpc)
1748 {
1749 uintptr_t frame[2];
1750 uintptr_t trash[2];
1751
1752 if (Pread(Proc, frame, sizeof (frame), fp) != sizeof (frame) ||
1753 (frame[0] != 0 &&
1754 Pread(Proc, trash, sizeof (trash), frame[0]) != sizeof (trash)))
1755 frame[0] = frame[1] = 0;
1756
1757 if (rpc)
1758 *rpc = frame[1];
1759 return (frame[0]);
1760 }
1761
1762 #endif
1763
1764 #if defined(__amd64) || defined(__i386)
1765
1766 /*
1767 * Examine the instruction at the return location of a function call
1768 * and return the byte count by which the stack is adjusted on return.
1769 * It the instruction at the return location is an addl, as expected,
1770 * then adjust the return pc by the size of that instruction so that
1771 * we will place the return breakpoint on the following instruction.
1772 * This allows programs that interrogate their own stacks and record
1773 * function calls and arguments to work correctly even while we interfere.
1774 * Return the count on success, -1 on failure.
1775 */
1776 int
1777 return_count32(uint32_t *ppc)
1778 {
1779 uintptr_t pc = *ppc;
1780 struct bkpt *Bp;
1781 int count;
1782 uchar_t instr[6]; /* instruction at pc */
1783
1784 if ((count = Pread(Proc, instr, sizeof (instr), pc)) < 0)
1785 return (-1);
1786
1787 /* find the replaced instruction at pc (if any) */
1788 if ((Bp = get_bkpt(pc)) != NULL && (Bp->flags & BPT_ACTIVE))
1789 instr[0] = (uchar_t)Bp->instr;
1790
1791 if (count != sizeof (instr) &&
1792 (count < 3 || instr[0] != 0x83))
1793 return (-1);
1794
1795 /*
1796 * A bit of disassembly of the instruction is required here.
1797 */
1798 if (instr[1] != 0xc4) { /* not an addl mumble,%esp inctruction */
1799 count = 0;
1800 } else if (instr[0] == 0x81) { /* count is a longword */
1801 count = instr[2]+(instr[3]<<8)+(instr[4]<<16)+(instr[5]<<24);
1802 *ppc += 6;
1803 } else if (instr[0] == 0x83) { /* count is a byte */
1804 count = instr[2];
1805 *ppc += 3;
1806 } else { /* not an addl inctruction */
1807 count = 0;
1808 }
1809
1810 return (count);
1811 }
1812
1813 uintptr_t
1814 get_return_address32(uintptr_t *psp)
1815 {
1816 uint32_t sp = *psp;
1817 uint32_t rpc;
1818 int count;
1819
1820 *psp += 4; /* account for popping the stack on return */
1821 if (Pread(Proc, &rpc, sizeof (rpc), sp) != sizeof (rpc))
1822 return (0);
1823 if ((count = return_count32(&rpc)) < 0)
1824 count = 0;
1825 *psp += count; /* expected sp on return */
1826 return (rpc);
1827 }
1828
1829 uintptr_t
1830 get_return_address(uintptr_t *psp)
1831 {
1832 #ifdef _LP64
1833 uintptr_t rpc;
1834 uintptr_t sp = *psp;
1835
1836 if (data_model == PR_MODEL_LP64) {
1837 if (Pread(Proc, &rpc, sizeof (rpc), sp) != sizeof (rpc))
1838 return (0);
1839 /*
1840 * Ignore arguments pushed on the stack. See comments in
1841 * get_arguments().
1842 */
1843 return (rpc);
1844 } else
1845 #endif
1846 return (get_return_address32(psp));
1847 }
1848
1849
1850 int
1851 get_arguments32(long *argp)
1852 {
1853 private_t *pri = get_private();
1854 const lwpstatus_t *Lsp = pri->lwpstat;
1855 uint32_t frame[5]; /* return pc + 4 args */
1856 int narg;
1857 int count;
1858 int i;
1859
1860 narg = Pread(Proc, frame, sizeof (frame),
1861 (uintptr_t)Lsp->pr_reg[R_SP]);
1862 narg -= sizeof (greg32_t);
1863 if (narg <= 0)
1864 return (0);
1865 narg /= sizeof (greg32_t); /* no more than 4 */
1866
1867 /*
1868 * Given the return PC, determine the number of arguments.
1869 */
1870 if ((count = return_count32(&frame[0])) < 0)
1871 narg = 0;
1872 else {
1873 count /= sizeof (greg32_t);
1874 if (narg > count)
1875 narg = count;
1876 }
1877
1878 for (i = 0; i < narg; i++)
1879 argp[i] = (long)frame[i+1];
1880
1881 return (narg);
1882 }
1883
1884 int
1885 get_arguments(long *argp)
1886 {
1887 #ifdef _LP64
1888 private_t *pri = get_private();
1889 const lwpstatus_t *Lsp = pri->lwpstat;
1890
1891 if (data_model == PR_MODEL_LP64) {
1892 /*
1893 * On amd64, we do not know how many arguments are passed to
1894 * each function. While it may be possible to detect if we
1895 * have more than 6 arguments, it is of marginal value.
1896 * Instead, assume that we always have 6 arguments, which are
1897 * passed via registers.
1898 */
1899 argp[0] = Lsp->pr_reg[REG_RDI];
1900 argp[1] = Lsp->pr_reg[REG_RSI];
1901 argp[2] = Lsp->pr_reg[REG_RDX];
1902 argp[3] = Lsp->pr_reg[REG_RCX];
1903 argp[4] = Lsp->pr_reg[REG_R8];
1904 argp[5] = Lsp->pr_reg[REG_R9];
1905 return (6);
1906 } else
1907 #endif
1908 return (get_arguments32(argp));
1909 }
1910
1911 #endif /* __amd64 || __i386 */
unleashed repo fork