AMD64 - Fix many compile-time warnings. int/ptr type mismatches, %llx, etc.
[dragonfly.git] / sys / platform / pc64 / amd64 / 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         rip = db_get_value((long) &(*fp)->f_retaddr, 8, FALSE);
231         rbp = db_get_value((long) &(*fp)->f_frame, 8, FALSE);
232
233         /*
234          * Figure out frame type.
235          */
236
237         frame_type = NORMAL;
238
239         sym = db_search_symbol(rip, DB_STGY_ANY, &offset);
240         db_symbol_values(sym, &name, NULL);
241         dl_symbol_values(rip, &name);
242         if (name != NULL) {
243                 if (!strcmp(name, "calltrap")) {
244                         frame_type = TRAP;
245                 } else if (!strncmp(name, "Xresume", 7)) {
246                         frame_type = INTERRUPT;
247                 } else if (!strcmp(name, "_Xsyscall")) {
248                         frame_type = SYSCALL;
249                 }
250         }
251
252         /*
253          * Normal frames need no special processing.
254          */
255         if (frame_type == NORMAL) {
256                 *ip = (db_addr_t) rip;
257                 *fp = (struct amd64_frame *) rbp;
258                 return;
259         }
260
261         db_print_stack_entry(name, 0, 0, 0, rip);
262
263         /*
264          * Point to base of trapframe which is just above the
265          * current frame.
266          */
267         tf = (struct trapframe *)((long)*fp + 16);
268
269 #if 0
270         rsp = (ISPL(tf->tf_cs) == SEL_UPL) ?  tf->tf_rsp : (long)&tf->tf_rsp;
271 #endif
272         rsp = (long)&tf->tf_rsp;
273
274         switch (frame_type) {
275         case TRAP:
276                 {
277                         rip = tf->tf_rip;
278                         rbp = tf->tf_rbp;
279                         db_printf(
280             "--- trap %016lx, rip = %016lx, rsp = %016lx, rbp = %016lx ---\n",
281                             tf->tf_trapno, rip, rsp, rbp);
282                 }
283                 break;
284         case SYSCALL:
285                 {
286                         rip = tf->tf_rip;
287                         rbp = tf->tf_rbp;
288                         db_printf(
289         "--- syscall %016lx, rip = %016lx, rsp = %016lx, rbp = %016lx ---\n",
290                             tf->tf_rax, rip, rsp, rbp);
291                 }
292                 break;
293         case INTERRUPT:
294                 tf = (struct trapframe *)((long)*fp + 16);
295                 {
296                         rip = tf->tf_rip;
297                         rbp = tf->tf_rbp;
298                         db_printf(
299             "--- interrupt, rip = %016lx, rsp = %016lx, rbp = %016lx ---\n",
300                             rip, rsp, rbp);
301                 }
302                 break;
303         default:
304                 break;
305         }
306
307         *ip = (db_addr_t) rip;
308         *fp = (struct amd64_frame *) rbp;
309 }
310
311 void
312 db_stack_trace_cmd(db_expr_t addr, boolean_t have_addr, db_expr_t count,
313                    char *modif)
314 {
315         struct amd64_frame *frame;
316         long *argp;
317         db_addr_t callpc;
318         boolean_t first;
319         int i;
320
321         if (count == -1)
322                 count = 1024;
323
324         if (!have_addr) {
325                 frame = (struct amd64_frame *)BP_REGS(&ddb_regs);
326                 if (frame == NULL)
327                         frame = (struct amd64_frame *)(SP_REGS(&ddb_regs) - 8);
328                 callpc = PC_REGS(&ddb_regs);
329         } else {
330                 /*
331                  * Look for something that might be a frame pointer, just as
332                  * a convenience.
333                  */
334                 frame = (struct amd64_frame *)addr;
335                 for (i = 0; i < 4096; i += 8) {
336                         struct amd64_frame *check;
337
338                         check = (struct amd64_frame *)db_get_value((long)((char *)&frame->f_frame + i), 8, FALSE);
339                         if ((char *)check - (char *)frame >= 0 &&
340                             (char *)check - (char *)frame < 4096
341                         ) {
342                                 break;
343                         }
344                         db_printf("%p does not look like a stack frame, skipping\n", (char *)&frame->f_frame + i);
345                 }
346                 if (i == 4096) {
347                         db_printf("Unable to find anything that looks like a stack frame\n");
348                         return;
349                 }
350                 frame = (void *)((char *)frame + i);
351                 db_printf("Trace beginning at frame %p\n", frame);
352                 callpc = (db_addr_t)db_get_value((long)&frame->f_retaddr, 8, FALSE);
353         }
354
355         first = TRUE;
356         while (count--) {
357                 struct amd64_frame *actframe;
358                 int             narg;
359                 const char *    name;
360                 db_expr_t       offset;
361                 c_db_sym_t      sym;
362 #define MAXNARG 16
363                 char    *argnames[MAXNARG], **argnp = NULL;
364
365                 sym = db_search_symbol(callpc, DB_STGY_ANY, &offset);
366                 db_symbol_values(sym, &name, NULL);
367                 dl_symbol_values(callpc, &name);
368
369                 /*
370                  * Attempt to determine a (possibly fake) frame that gives
371                  * the caller's pc.  It may differ from `frame' if the
372                  * current function never sets up a standard frame or hasn't
373                  * set one up yet or has just discarded one.  The last two
374                  * cases can be guessed fairly reliably for code generated
375                  * by gcc.  The first case is too much trouble to handle in
376                  * general because the amount of junk on the stack depends
377                  * on the pc (the special handling of "calltrap", etc. in
378                  * db_nextframe() works because the `next' pc is special).
379                  */
380                 actframe = frame;
381                 if (first) {
382                         if (!have_addr) {
383                                 int instr;
384
385                                 instr = db_get_value(callpc, 4, FALSE);
386                                 if ((instr & 0xffffffff) == 0xe5894855) {
387                                         /* pushq %rbp; movq %rsp, %rbp */
388                                         actframe = (struct amd64_frame *)
389                                             (SP_REGS(&ddb_regs) - 8);
390                                 } else if ((instr & 0xffffff) == 0xe58948) {
391                                         /* movq %rsp, %rbp */
392                                         actframe = (struct amd64_frame *)
393                                             SP_REGS(&ddb_regs);
394                                         if (ddb_regs.tf_rbp == 0) {
395                                                 /* Fake caller's frame better. */
396                                                 frame = actframe;
397                                         }
398                                 } else if ((instr & 0xff) == 0xc3) {
399                                         /* ret */
400                                         actframe = (struct amd64_frame *)
401                                             (SP_REGS(&ddb_regs) - 8);
402                                 } else if (offset == 0) {
403                                         /* Probably a symbol in assembler code. */
404                                         actframe = (struct amd64_frame *)
405                                             (SP_REGS(&ddb_regs) - 8);
406                                 }
407                         } else if (name != NULL &&
408                                    strcmp(name, "fork_trampoline") == 0) {
409                                 /*
410                                  * Don't try to walk back on a stack for a
411                                  * process that hasn't actually been run yet.
412                                  */
413                                 db_print_stack_entry(name, 0, 0, 0, callpc);
414                                 break;
415                         }
416                         first = FALSE;
417                 }
418
419                 argp = &actframe->f_arg0;
420                 narg = MAXNARG;
421                 if (sym != NULL && db_sym_numargs(sym, &narg, argnames)) {
422                         argnp = argnames;
423                 } else {
424                         narg = db_numargs(frame);
425                 }
426
427                 db_print_stack_entry(name, narg, argnp, argp, callpc);
428
429                 if (actframe != frame) {
430                         /* `frame' belongs to caller. */
431                         callpc = (db_addr_t)
432                             db_get_value((long)&actframe->f_retaddr, 8, FALSE);
433                         continue;
434                 }
435
436                 db_nextframe(&frame, &callpc);
437                 if (frame == 0)
438                         break;
439         }
440 }
441
442 void
443 print_backtrace(void)
444 {
445         register_t  rbp;
446
447         __asm __volatile("movq %%rbp, %0" : "=r" (rbp));
448         db_stack_trace_cmd(rbp, 1, -1, NULL);
449 }
450
451 #define DB_DRX_FUNC(reg)                                                \
452 int                                                                     \
453 db_ ## reg (struct db_variable *vp, db_expr_t *valuep, int op)          \
454 {                                                                       \
455         if (op == DB_VAR_GET)                                           \
456                 *valuep = r ## reg ();                                  \
457         else                                                            \
458                 load_ ## reg (*valuep);                                 \
459                                                                         \
460         return(0);                                                      \
461
462
463 DB_DRX_FUNC(dr0)
464 DB_DRX_FUNC(dr1)
465 DB_DRX_FUNC(dr2)
466 DB_DRX_FUNC(dr3)
467 DB_DRX_FUNC(dr4)
468 DB_DRX_FUNC(dr5)
469 DB_DRX_FUNC(dr6)
470 DB_DRX_FUNC(dr7)
471
472 static int
473 kamd64_set_watch(int watchnum, unsigned int watchaddr, int size, int access,
474                struct dbreg *d)
475 {
476         int i;
477         unsigned int mask;
478         
479         if (watchnum == -1) {
480                 for (i = 0, mask = 0x3; i < 4; i++, mask <<= 2)
481                         if ((d->dr[7] & mask) == 0)
482                                 break;
483                 if (i < 4)
484                         watchnum = i;
485                 else
486                         return(-1);
487         }
488
489         switch (access) {
490         case DBREG_DR7_EXEC:
491                 size = 1; /* size must be 1 for an execution breakpoint */
492                 /* fall through */
493         case DBREG_DR7_WRONLY:
494         case DBREG_DR7_RDWR:
495                 break;
496         default:
497                 return(-1);
498         }
499
500         /*
501          * we can watch a 1, 2, 4, or 8 byte sized location
502          */
503         switch (size) {
504         case 1:
505                 mask = 0x00;
506                 break;
507         case 2:
508                 mask = 0x01 << 2;
509                 break;
510         case 4:
511                 mask = 0x03 << 2;
512         case 8:
513                 mask = 0x02 << 2;
514                 break;
515         default:
516                 return(-1);
517         }
518
519         mask |= access;
520
521         /* clear the bits we are about to affect */
522         d->dr[7] &= ~((0x3 << (watchnum * 2)) | (0x0f << (watchnum * 4 + 16)));
523
524         /* set drN register to the address, N=watchnum */
525         DBREG_DRX(d, watchnum) = watchaddr;
526
527         /* enable the watchpoint */
528         d->dr[7] |= (0x2 << (watchnum * 2)) | (mask << (watchnum * 4 + 16));
529
530         return(watchnum);
531 }
532
533
534 int
535 kamd64_clr_watch(int watchnum, struct dbreg *d)
536 {
537         if (watchnum < 0 || watchnum >= 4)
538                 return(-1);
539
540         d->dr[7] &= ~((0x3 << (watchnum * 2)) | (0x0f << (watchnum * 4 + 16)));
541         DBREG_DRX(d, watchnum) = 0;
542
543         return(0);
544 }
545
546
547 int
548 db_md_set_watchpoint(db_expr_t addr, db_expr_t size)
549 {
550         int avail, wsize;
551         int i;
552         struct dbreg d;
553         
554         fill_dbregs(NULL, &d);
555
556         avail = 0;
557         for (i = 0; i < 4; i++) {
558                 if ((d.dr[7] & (3 << (i * 2))) == 0)
559                         avail++;
560         }
561
562         if (avail * 8 < size)
563                 return(-1);
564
565         for (i=0; i < 4 && (size != 0); i++) {
566                 if ((d.dr[7] & (3 << (i * 2))) == 0) {
567                         if (size >= 8 || (avail == 1 && size > 4))
568                                 wsize = 8;
569                         else if (size > 2)
570                                 wsize = 4;
571                         else
572                                 wsize = size;
573                         if (wsize == 3)
574                                 wsize++;
575                         kamd64_set_watch(i, addr, wsize, DBREG_DR7_WRONLY, &d);
576                         addr += wsize;
577                         size -= wsize;
578                 }
579         }
580
581         set_dbregs(NULL, &d);
582
583         return(0);
584 }
585
586 int
587 db_md_clr_watchpoint(db_expr_t addr, db_expr_t size)
588 {
589         struct dbreg d;
590         int i;
591
592         fill_dbregs(NULL, &d);
593
594         for(i = 0; i < 4; i++) {
595                 if (d.dr[7] & (3 << (i * 2))) {
596                         if ((DBREG_DRX((&d), i) >= addr) && 
597                             (DBREG_DRX((&d), i) < addr + size))
598                                 kamd64_clr_watch(i, &d);
599                 }
600         }
601
602         set_dbregs(NULL, &d);
603
604         return(0);
605 }
606
607 static char *
608 watchtype_str(int type)
609 {
610         switch (type) {
611         case DBREG_DR7_EXEC:
612                 return "execute";
613         case DBREG_DR7_RDWR:
614                 return "read/write";
615         case DBREG_DR7_WRONLY:
616                 return "write";
617         default:
618                 return "invalid";
619         }
620 }
621
622 void
623 db_md_list_watchpoints(void)
624 {
625         int i;
626         struct dbreg d;
627
628         fill_dbregs(NULL, &d);
629
630         db_printf("\nhardware watchpoints:\n");
631         db_printf("  watch    status        type  len     address\n"
632                   "  -----  --------  ----------  ---  ----------\n");
633         for (i = 0; i < 4; i++) {
634                 if (d.dr[7] & (0x03 << (i * 2))) {
635                         unsigned type, len;
636                         type = (d.dr[7] >> (16 + (i * 4))) & 3;
637                         len =  (d.dr[7] >> (16 + (i * 4) + 2)) & 3;
638                         db_printf("  %-5d  %-8s  %10s  %3d  0x%08lx\n",
639                                   i, "enabled", watchtype_str(type), 
640                                   len + 1, DBREG_DRX((&d), i));
641                 } else {
642                         db_printf("  %-5d  disabled\n", i);
643                 }
644         }
645
646         db_printf("\ndebug register values:\n");
647         for (i = 0; i < 8; i++)
648                 db_printf("  dr%d 0x%08lx\n", i, DBREG_DRX((&d),i));
649         db_printf("\n");
650 }
651
652 /*
653  * See if dladdr() can get the symbol name via the standard dynamic loader.
654  */
655 static
656 void
657 dl_symbol_values(long callpc, const char **name)
658 {
659         Dl_info info;
660
661 /*
662         if (*name == NULL) {
663                 if (dladdr((const void *)callpc, &info) != 0) {
664                         if (info.dli_saddr <= (const void *)callpc)
665                                 *name = info.dli_sname;
666                 }
667         }
668 */
669 }
670