90c11e7ad83006ff051f082953d5d017f63911f7
[dragonfly.git] / sys / platform / vkernel64 / x86_64 / db_trace.c
1 /*
2  * Copyright (c) 2008 The DragonFly Project.  All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in
12  *    the documentation and/or other materials provided with the
13  *    distribution.
14  * 3. Neither the name of The DragonFly Project nor the names of its
15  *    contributors may be used to endorse or promote products derived
16  *    from this software without specific, prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
21  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
22  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
23  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
24  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
26  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
27  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
28  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  *
31  * --
32  *
33  * Mach Operating System
34  * Copyright (c) 1991,1990 Carnegie Mellon University
35  * All Rights Reserved.
36  *
37  * Permission to use, copy, modify and distribute this software and its
38  * documentation is hereby granted, provided that both the copyright
39  * notice and this permission notice appear in all copies of the
40  * software, derivative works or modified versions, and any portions
41  * thereof, and that both notices appear in supporting documentation.
42  *
43  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
44  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
45  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
46  *
47  * Carnegie Mellon requests users of this software to return to
48  *
49  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
50  *  School of Computer Science
51  *  Carnegie Mellon University
52  *  Pittsburgh PA 15213-3890
53  *
54  * any improvements or extensions that they make and grant Carnegie the
55  * rights to redistribute these changes.
56  *
57  * $FreeBSD: src/sys/i386/i386/db_trace.c,v 1.35.2.3 2002/02/21 22:31:25 silby Exp $
58  * $DragonFly: src/sys/platform/pc64/amd64/db_trace.c,v 1.3 2008/08/29 17:07:10 dillon Exp $
59  */
60
61 #include <sys/param.h>
62 #include <sys/systm.h>
63 #include <sys/linker_set.h>
64 #include <sys/lock.h>
65 #include <sys/proc.h>
66 #include <sys/reg.h>
67
68 #include <machine/cpu.h>
69 #include <machine/md_var.h>
70
71 #include <vm/vm.h>
72 #include <vm/vm_param.h>
73 #include <vm/pmap.h>
74 #include <vm/vm_map.h>
75 #include <ddb/ddb.h>
76 #include <dlfcn.h>      /* DLL */
77
78 #include <sys/user.h>
79
80 #include <ddb/db_access.h>
81 #include <ddb/db_sym.h>
82 #include <ddb/db_variables.h>
83
84 db_varfcn_t db_dr0;
85 db_varfcn_t db_dr1;
86 db_varfcn_t db_dr2;
87 db_varfcn_t db_dr3;
88 db_varfcn_t db_dr4;
89 db_varfcn_t db_dr5;
90 db_varfcn_t db_dr6;
91 db_varfcn_t db_dr7;
92
93 /*
94  * Machine register set.
95  */
96 struct db_variable db_regs[] = {
97         { "cs",         &ddb_regs.tf_cs,     NULL },
98 /*      { "ds",         &ddb_regs.tf_ds,     NULL },
99         { "es",         &ddb_regs.tf_es,     NULL },
100         { "fs",         &ddb_regs.tf_fs,     NULL },
101         { "gs",         &ddb_regs.tf_gs,     NULL }, */
102         { "ss",         &ddb_regs.tf_ss,     NULL },
103         { "rax",        &ddb_regs.tf_rax,    NULL },
104         { "rcx",        &ddb_regs.tf_rcx,    NULL },
105         { "rdx",        &ddb_regs.tf_rdx,    NULL },
106         { "rbx",        &ddb_regs.tf_rbx,    NULL },
107         { "rsp",        &ddb_regs.tf_rsp,    NULL },
108         { "rbp",        &ddb_regs.tf_rbp,    NULL },
109         { "rsi",        &ddb_regs.tf_rsi,    NULL },
110         { "rdi",        &ddb_regs.tf_rdi,    NULL },
111         { "rip",        &ddb_regs.tf_rip,    NULL },
112         { "rfl",        &ddb_regs.tf_rflags, NULL },
113         { "r8",         &ddb_regs.tf_r8,     NULL },
114         { "r9",         &ddb_regs.tf_r9,     NULL },
115         { "r10",        &ddb_regs.tf_r10,    NULL },
116         { "r11",        &ddb_regs.tf_r11,    NULL },
117         { "r12",        &ddb_regs.tf_r12,    NULL },
118         { "r13",        &ddb_regs.tf_r13,    NULL },
119         { "r14",        &ddb_regs.tf_r14,    NULL },
120         { "r15",        &ddb_regs.tf_r15,    NULL },
121         { "dr0",        NULL,                db_dr0 },
122         { "dr1",        NULL,                db_dr1 },
123         { "dr2",        NULL,                db_dr2 },
124         { "dr3",        NULL,                db_dr3 },
125         { "dr4",        NULL,                db_dr4 },
126         { "dr5",        NULL,                db_dr5 },
127         { "dr6",        NULL,                db_dr6 },
128         { "dr7",        NULL,                db_dr7 },
129 };
130 struct db_variable *db_eregs = db_regs + sizeof(db_regs)/sizeof(db_regs[0]);
131
132 /*
133  * Stack trace.
134  */
135 #define INKERNEL(va)    (((vm_offset_t)(va)) >= USRSTACK)
136
137 struct amd64_frame {
138         struct amd64_frame      *f_frame;
139         long                    f_retaddr;
140         long                    f_arg0;
141 };
142
143 #define NORMAL          0
144 #define TRAP            1
145 #define INTERRUPT       2
146 #define SYSCALL         3
147
148 static void     db_nextframe(struct amd64_frame **, db_addr_t *);
149 static int      db_numargs(struct amd64_frame *);
150 static void     db_print_stack_entry(const char *, int, char **, long *, db_addr_t);
151 static void     dl_symbol_values(long callpc, const char **name);
152
153
154 static char     *watchtype_str(int type);
155 static int      kamd64_set_watch(int watchnum, unsigned int watchaddr,
156                                int size, int access, struct dbreg * d);
157 static int      kamd64_clr_watch(int watchnum, struct dbreg * d);
158 int             db_md_set_watchpoint(db_expr_t addr, db_expr_t size);
159 int             db_md_clr_watchpoint(db_expr_t addr, db_expr_t size);
160 void            db_md_list_watchpoints(void);
161
162
163 /*
164  * Figure out how many arguments were passed into the frame at "fp".
165  */
166 static int
167 db_numargs(struct amd64_frame *fp)
168 {
169 #if 1
170         return (0);     /* regparm, needs dwarf2 info */
171 #else
172         int     args;
173 #if 0
174         int     *argp;
175         int     inst;
176
177         argp = (int *)db_get_value((int)&fp->f_retaddr, 4, FALSE);
178         /*
179          * XXX etext is wrong for LKMs.  We should attempt to interpret
180          * the instruction at the return address in all cases.  This
181          * may require better fault handling.
182          */
183         if (argp < (int *)btext || argp >= (int *)etext) {
184                 args = 5;
185         } else {
186                 inst = db_get_value((int)argp, 4, FALSE);
187                 if ((inst & 0xff) == 0x59)      /* popl %ecx */
188                         args = 1;
189                 else if ((inst & 0xffff) == 0xc483)     /* addl $Ibs, %esp */
190                         args = ((inst >> 16) & 0xff) / 4;
191                 else
192                         args = 5;
193         }
194 #endif
195         args = 5;
196         return(args);
197 #endif
198 }
199
200 static void
201 db_print_stack_entry(const char *name, int narg, char **argnp, long *argp,
202                      db_addr_t callpc)
203 {
204         db_printf("%s(", name);
205         while (narg) {
206                 if (argnp)
207                         db_printf("%s=", *argnp++);
208                 db_printf("%ld", (long)db_get_value((long)argp, 8, FALSE));
209                 argp++;
210                 if (--narg != 0)
211                         db_printf(",");
212         }
213         db_printf(") at ");
214         db_printsym(callpc, DB_STGY_PROC);
215         db_printf("\n");
216 }
217
218 /*
219  * Figure out the next frame up in the call stack.
220  */
221 static void
222 db_nextframe(struct amd64_frame **fp, db_addr_t *ip)
223 {
224         struct trapframe *tf;
225         int frame_type;
226         long rip, rsp, rbp;
227         db_expr_t offset;
228         const char *sym, *name;
229
230         if ((unsigned long)*fp < PAGE_SIZE) {
231                 *fp = NULL;
232                 return;
233         }
234         rip = db_get_value((long) &(*fp)->f_retaddr, 8, FALSE);
235         rbp = db_get_value((long) &(*fp)->f_frame, 8, FALSE);
236
237         /*
238          * Figure out frame type.
239          */
240
241         frame_type = NORMAL;
242
243         sym = db_search_symbol(rip, DB_STGY_ANY, &offset);
244         db_symbol_values(sym, &name, NULL);
245         dl_symbol_values(rip, &name);
246         if (name != NULL) {
247                 if (!strcmp(name, "calltrap")) {
248                         frame_type = TRAP;
249                 } else if (!strncmp(name, "Xresume", 7)) {
250                         frame_type = INTERRUPT;
251                 } else if (!strcmp(name, "_Xsyscall")) {
252                         frame_type = SYSCALL;
253                 }
254         }
255
256         /*
257          * Normal frames need no special processing.
258          */
259         if (frame_type == NORMAL) {
260                 *ip = (db_addr_t) rip;
261                 *fp = (struct amd64_frame *) rbp;
262                 return;
263         }
264
265         db_print_stack_entry(name, 0, 0, 0, rip);
266
267         /*
268          * Point to base of trapframe which is just above the
269          * current frame.
270          */
271         tf = (struct trapframe *)((long)*fp + 16);
272
273 #if 0
274         rsp = (ISPL(tf->tf_cs) == SEL_UPL) ?  tf->tf_rsp : (long)&tf->tf_rsp;
275 #endif
276         rsp = (long)&tf->tf_rsp;
277
278         switch (frame_type) {
279         case TRAP:
280                 {
281                         rip = tf->tf_rip;
282                         rbp = tf->tf_rbp;
283                         db_printf(
284             "--- trap %016lx, rip = %016lx, rsp = %016lx, rbp = %016lx ---\n",
285                             tf->tf_trapno, rip, rsp, rbp);
286                 }
287                 break;
288         case SYSCALL:
289                 {
290                         rip = tf->tf_rip;
291                         rbp = tf->tf_rbp;
292                         db_printf(
293         "--- syscall %016lx, rip = %016lx, rsp = %016lx, rbp = %016lx ---\n",
294                             tf->tf_rax, rip, rsp, rbp);
295                 }
296                 break;
297         case INTERRUPT:
298                 tf = (struct trapframe *)((long)*fp + 16);
299                 {
300                         rip = tf->tf_rip;
301                         rbp = tf->tf_rbp;
302                         db_printf(
303             "--- interrupt, rip = %016lx, rsp = %016lx, rbp = %016lx ---\n",
304                             rip, rsp, rbp);
305                 }
306                 break;
307         default:
308                 break;
309         }
310
311         *ip = (db_addr_t) rip;
312         *fp = (struct amd64_frame *) rbp;
313 }
314
315 void
316 db_stack_trace_cmd(db_expr_t addr, boolean_t have_addr, db_expr_t count,
317                    char *modif)
318 {
319         struct amd64_frame *frame;
320         long *argp;
321         db_addr_t callpc;
322         boolean_t first;
323         int i;
324
325         if (count == -1)
326                 count = 1024;
327
328         if (!have_addr) {
329                 frame = (struct amd64_frame *)BP_REGS(&ddb_regs);
330                 if (frame == NULL)
331                         frame = (struct amd64_frame *)(SP_REGS(&ddb_regs) - 8);
332                 callpc = PC_REGS(&ddb_regs);
333         } else {
334                 /*
335                  * Look for something that might be a frame pointer, just as
336                  * a convenience.
337                  */
338                 frame = (struct amd64_frame *)addr;
339                 for (i = 0; i < 4096; i += 8) {
340                         struct amd64_frame *check;
341
342                         check = (struct amd64_frame *)db_get_value((long)((char *)&frame->f_frame + i), 8, FALSE);
343                         if ((char *)check - (char *)frame >= 0 &&
344                             (char *)check - (char *)frame < 4096
345                         ) {
346                                 break;
347                         }
348                         db_printf("%p does not look like a stack frame, skipping\n", (char *)&frame->f_frame + i);
349                 }
350                 if (i == 4096) {
351                         db_printf("Unable to find anything that looks like a stack frame\n");
352                         return;
353                 }
354                 frame = (void *)((char *)frame + i);
355                 db_printf("Trace beginning at frame %p\n", frame);
356                 callpc = (db_addr_t)db_get_value((long)&frame->f_retaddr, 8, FALSE);
357         }
358
359         first = TRUE;
360         while (count--) {
361                 struct amd64_frame *actframe;
362                 int             narg;
363                 const char *    name;
364                 db_expr_t       offset;
365                 c_db_sym_t      sym;
366 #define MAXNARG 16
367                 char    *argnames[MAXNARG], **argnp = NULL;
368
369                 sym = db_search_symbol(callpc, DB_STGY_ANY, &offset);
370                 db_symbol_values(sym, &name, NULL);
371                 dl_symbol_values(callpc, &name);
372
373                 /*
374                  * Attempt to determine a (possibly fake) frame that gives
375                  * the caller's pc.  It may differ from `frame' if the
376                  * current function never sets up a standard frame or hasn't
377                  * set one up yet or has just discarded one.  The last two
378                  * cases can be guessed fairly reliably for code generated
379                  * by gcc.  The first case is too much trouble to handle in
380                  * general because the amount of junk on the stack depends
381                  * on the pc (the special handling of "calltrap", etc. in
382                  * db_nextframe() works because the `next' pc is special).
383                  */
384                 actframe = frame;
385                 if (first) {
386                         if (!have_addr) {
387                                 int instr;
388
389                                 instr = db_get_value(callpc, 4, FALSE);
390                                 if ((instr & 0xffffffff) == 0xe5894855) {
391                                         /* pushq %rbp; movq %rsp, %rbp */
392                                         actframe = (struct amd64_frame *)
393                                             (SP_REGS(&ddb_regs) - 8);
394                                 } else if ((instr & 0xffffff) == 0xe58948) {
395                                         /* movq %rsp, %rbp */
396                                         actframe = (struct amd64_frame *)
397                                             SP_REGS(&ddb_regs);
398                                         if (ddb_regs.tf_rbp == 0) {
399                                                 /* Fake caller's frame better. */
400                                                 frame = actframe;
401                                         }
402                                 } else if ((instr & 0xff) == 0xc3) {
403                                         /* ret */
404                                         actframe = (struct amd64_frame *)
405                                             (SP_REGS(&ddb_regs) - 8);
406                                 } else if (offset == 0) {
407                                         /* Probably a symbol in assembler code. */
408                                         actframe = (struct amd64_frame *)
409                                             (SP_REGS(&ddb_regs) - 8);
410                                 }
411                         } else if (name != NULL &&
412                                    strcmp(name, "fork_trampoline") == 0) {
413                                 /*
414                                  * Don't try to walk back on a stack for a
415                                  * process that hasn't actually been run yet.
416                                  */
417                                 db_print_stack_entry(name, 0, 0, 0, callpc);
418                                 break;
419                         }
420                         first = FALSE;
421                 }
422
423                 argp = &actframe->f_arg0;
424                 narg = MAXNARG;
425                 if (sym != NULL && db_sym_numargs(sym, &narg, argnames)) {
426                         argnp = argnames;
427                 } else {
428                         narg = db_numargs(frame);
429                 }
430
431                 db_print_stack_entry(name, narg, argnp, argp, callpc);
432
433                 if (actframe != frame) {
434                         /* `frame' belongs to caller. */
435                         callpc = (db_addr_t)
436                             db_get_value((long)&actframe->f_retaddr, 8, FALSE);
437                         continue;
438                 }
439
440                 db_nextframe(&frame, &callpc);
441                 if (frame == 0)
442                         break;
443         }
444 }
445
446 void
447 print_backtrace(int count)
448 {
449         register_t  rbp;
450
451         __asm __volatile("movq %%rbp, %0" : "=r" (rbp));
452         db_stack_trace_cmd(rbp, 1, count, NULL);
453 }
454
455 #define DB_DRX_FUNC(reg)                                                \
456 int                                                                     \
457 db_ ## reg (struct db_variable *vp, db_expr_t *valuep, int op)          \
458 {                                                                       \
459         if (op == DB_VAR_GET)                                           \
460                 *valuep = r ## reg ();                                  \
461         else                                                            \
462                 load_ ## reg (*valuep);                                 \
463                                                                         \
464         return(0);                                                      \
465 }
466
467 DB_DRX_FUNC(dr0)
468 DB_DRX_FUNC(dr1)
469 DB_DRX_FUNC(dr2)
470 DB_DRX_FUNC(dr3)
471 DB_DRX_FUNC(dr4)
472 DB_DRX_FUNC(dr5)
473 DB_DRX_FUNC(dr6)
474 DB_DRX_FUNC(dr7)
475
476 static int
477 kamd64_set_watch(int watchnum, unsigned int watchaddr, int size, int access,
478                struct dbreg *d)
479 {
480         int i;
481         unsigned int mask;
482
483         if (watchnum == -1) {
484                 for (i = 0, mask = 0x3; i < 4; i++, mask <<= 2)
485                         if ((d->dr[7] & mask) == 0)
486                                 break;
487                 if (i < 4)
488                         watchnum = i;
489                 else
490                         return(-1);
491         }
492
493         switch (access) {
494         case DBREG_DR7_EXEC:
495                 size = 1; /* size must be 1 for an execution breakpoint */
496                 /* fall through */
497         case DBREG_DR7_WRONLY:
498         case DBREG_DR7_RDWR:
499                 break;
500         default:
501                 return(-1);
502         }
503
504         /*
505          * we can watch a 1, 2, 4, or 8 byte sized location
506          */
507         switch (size) {
508         case 1:
509                 mask = 0x00;
510                 break;
511         case 2:
512                 mask = 0x01 << 2;
513                 break;
514         case 4:
515                 mask = 0x03 << 2;
516         case 8:
517                 mask = 0x02 << 2;
518                 break;
519         default:
520                 return(-1);
521         }
522
523         mask |= access;
524
525         /* clear the bits we are about to affect */
526         d->dr[7] &= ~((0x3 << (watchnum * 2)) | (0x0f << (watchnum * 4 + 16)));
527
528         /* set drN register to the address, N=watchnum */
529         DBREG_DRX(d, watchnum) = watchaddr;
530
531         /* enable the watchpoint */
532         d->dr[7] |= (0x2 << (watchnum * 2)) | (mask << (watchnum * 4 + 16));
533
534         return(watchnum);
535 }
536
537
538 int
539 kamd64_clr_watch(int watchnum, struct dbreg *d)
540 {
541         if (watchnum < 0 || watchnum >= 4)
542                 return(-1);
543
544         d->dr[7] &= ~((0x3 << (watchnum * 2)) | (0x0f << (watchnum * 4 + 16)));
545         DBREG_DRX(d, watchnum) = 0;
546
547         return(0);
548 }
549
550
551 int
552 db_md_set_watchpoint(db_expr_t addr, db_expr_t size)
553 {
554         int avail, wsize;
555         int i;
556         struct dbreg d;
557
558         fill_dbregs(NULL, &d);
559
560         avail = 0;
561         for (i = 0; i < 4; i++) {
562                 if ((d.dr[7] & (3 << (i * 2))) == 0)
563                         avail++;
564         }
565
566         if (avail * 8 < size)
567                 return(-1);
568
569         for (i=0; i < 4 && (size != 0); i++) {
570                 if ((d.dr[7] & (3 << (i * 2))) == 0) {
571                         if (size >= 8 || (avail == 1 && size > 4))
572                                 wsize = 8;
573                         else if (size > 2)
574                                 wsize = 4;
575                         else
576                                 wsize = size;
577                         if (wsize == 3)
578                                 wsize++;
579                         kamd64_set_watch(i, addr, wsize, DBREG_DR7_WRONLY, &d);
580                         addr += wsize;
581                         size -= wsize;
582                 }
583         }
584
585         set_dbregs(NULL, &d);
586
587         return(0);
588 }
589
590 int
591 db_md_clr_watchpoint(db_expr_t addr, db_expr_t size)
592 {
593         struct dbreg d;
594         int i;
595
596         fill_dbregs(NULL, &d);
597
598         for(i = 0; i < 4; i++) {
599                 if (d.dr[7] & (3 << (i * 2))) {
600                         if ((DBREG_DRX((&d), i) >= addr) &&
601                             (DBREG_DRX((&d), i) < addr + size))
602                                 kamd64_clr_watch(i, &d);
603                 }
604         }
605
606         set_dbregs(NULL, &d);
607
608         return(0);
609 }
610
611 static char *
612 watchtype_str(int type)
613 {
614         switch (type) {
615         case DBREG_DR7_EXEC:
616                 return "execute";
617         case DBREG_DR7_RDWR:
618                 return "read/write";
619         case DBREG_DR7_WRONLY:
620                 return "write";
621         default:
622                 return "invalid";
623         }
624 }
625
626 void
627 db_md_list_watchpoints(void)
628 {
629         int i;
630         struct dbreg d;
631
632         fill_dbregs(NULL, &d);
633
634         db_printf("\nhardware watchpoints:\n");
635         db_printf("  watch    status        type  len     address\n"
636                   "  -----  --------  ----------  ---  ----------\n");
637         for (i = 0; i < 4; i++) {
638                 if (d.dr[7] & (0x03 << (i * 2))) {
639                         unsigned type, len;
640                         type = (d.dr[7] >> (16 + (i * 4))) & 3;
641                         len =  (d.dr[7] >> (16 + (i * 4) + 2)) & 3;
642                         db_printf("  %-5d  %-8s  %10s  %3d  0x%08lx\n",
643                                   i, "enabled", watchtype_str(type),
644                                   len + 1, DBREG_DRX((&d), i));
645                 } else {
646                         db_printf("  %-5d  disabled\n", i);
647                 }
648         }
649
650         db_printf("\ndebug register values:\n");
651         for (i = 0; i < 8; i++)
652                 db_printf("  dr%d 0x%08lx\n", i, DBREG_DRX((&d),i));
653         db_printf("\n");
654 }
655
656 /*
657  * See if dladdr() can get the symbol name via the standard dynamic loader.
658  */
659 static
660 void
661 dl_symbol_values(long callpc, const char **name)
662 {
663 /*
664         Dl_info info;
665
666         if (*name == NULL) {
667                 if (dladdr((const void *)callpc, &info) != 0) {
668                         if (info.dli_saddr <= (const void *)callpc)
669                                 *name = info.dli_sname;
670                 }
671         }
672 */
673 }