?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
btrfs: Attempt to fix GCC2 build.
[haiku.git] / src / system / kernel / arch / x86 / arch_debug.cpp
blob6bb1a4ed53dc9f14bd37094d62c727ffbdc4fb32
1 /*
2 * Copyright 2009-2011, Ingo Weinhold, ingo_weinhold@gmx.de.
3 * Copyright 2002-2008, Axel Dörfler, axeld@pinc-software.de.
4 * Copyright 2012, Alex Smith, alex@alex-smith.me.uk.
5 * Distributed under the terms of the MIT License.
6 *
7 * Copyright 2001, Travis Geiselbrecht. All rights reserved.
8 * Distributed under the terms of the NewOS License.
9 */
10
11
12 #include <arch/debug.h>
13
14 #include <stdio.h>
15 #include <stdlib.h>
16
17 #include <ByteOrder.h>
18 #include <TypeConstants.h>
19
20 #include <cpu.h>
21 #include <debug.h>
22 #include <debug_heap.h>
23 #include <elf.h>
24 #include <kernel.h>
25 #include <kimage.h>
26 #include <thread.h>
27 #include <vm/vm.h>
28 #include <vm/vm_types.h>
29 #include <vm/VMAddressSpace.h>
30 #include <vm/VMArea.h>
31
32
33 struct stack_frame {
34 stack_frame* previous;
35 addr_t return_address;
36 };
37
38 #define NUM_PREVIOUS_LOCATIONS 32
39
40
41 static bool is_kernel_stack_address(Thread* thread, addr_t address);
42
43
44 static bool
45 already_visited(addr_t* visited, int32* _last, int32* _num, addr_t bp)
46 {
47 int32 last = *_last;
48 int32 num = *_num;
49 int32 i;
50
51 for (i = 0; i < num; i++) {
52 if (visited[(NUM_PREVIOUS_LOCATIONS + last - i) % NUM_PREVIOUS_LOCATIONS] == bp)
53 return true;
54 }
55
56 *_last = last = (last + 1) % NUM_PREVIOUS_LOCATIONS;
57 visited[last] = bp;
58
59 if (num < NUM_PREVIOUS_LOCATIONS)
60 *_num = num + 1;
61
62 return false;
63 }
64
65
66 /*! Safe to be called only from outside the debugger.
67 */
68 static status_t
69 get_next_frame_no_debugger(addr_t bp, addr_t* _next, addr_t* _ip,
70 bool onKernelStack, Thread* thread)
71 {
72 // TODO: Do this more efficiently in assembly.
73 stack_frame frame;
74 if (onKernelStack
75 && is_kernel_stack_address(thread, bp + sizeof(frame) - 1))
76 memcpy(&frame, (void*)bp, sizeof(frame));
77 else if (user_memcpy(&frame, (void*)bp, sizeof(frame)) != B_OK)
78 return B_BAD_ADDRESS;
79
80 *_ip = frame.return_address;
81 *_next = (addr_t)frame.previous;
82
83 return B_OK;
84 }
85
86
87 /*! Safe to be called only from inside the debugger.
88 */
89 static status_t
90 get_next_frame_debugger(addr_t bp, addr_t* _next, addr_t* _ip)
91 {
92 stack_frame frame;
93 if (debug_memcpy(B_CURRENT_TEAM, &frame, (void*)bp, sizeof(frame)) != B_OK)
94 return B_BAD_ADDRESS;
95
96 *_ip = frame.return_address;
97 *_next = (addr_t)frame.previous;
98
99 return B_OK;
100 }
101
102
103 static status_t
104 lookup_symbol(Thread* thread, addr_t address, addr_t* _baseAddress,
105 const char** _symbolName, const char** _imageName, bool* _exactMatch)
106 {
107 status_t status = B_ENTRY_NOT_FOUND;
108
109 if (IS_KERNEL_ADDRESS(address)) {
110 // a kernel symbol
111 status = elf_debug_lookup_symbol_address(address, _baseAddress,
112 _symbolName, _imageName, _exactMatch);
113 } else if (thread != NULL && thread->team != NULL) {
114 // try a lookup using the userland runtime loader structures
115 status = elf_debug_lookup_user_symbol_address(thread->team, address,
116 _baseAddress, _symbolName, _imageName, _exactMatch);
117
118 if (status != B_OK) {
119 // try to locate the image in the images loaded into user space
120 status = image_debug_lookup_user_symbol_address(thread->team,
121 address, _baseAddress, _symbolName, _imageName, _exactMatch);
122 }
123 }
124
125 return status;
126 }
127
128
129 #ifndef __x86_64__
130
131
132 static void
133 set_debug_argument_variable(int32 index, uint64 value)
134 {
135 char name[8];
136 snprintf(name, sizeof(name), "_arg%ld", index);
137 set_debug_variable(name, value);
138 }
139
140
141 template<typename Type>
142 static Type
143 read_function_argument_value(void* argument, bool& _valueKnown)
144 {
145 Type value;
146 if (debug_memcpy(B_CURRENT_TEAM, &value, argument, sizeof(Type)) == B_OK) {
147 _valueKnown = true;
148 return value;
149 }
150
151 _valueKnown = false;
152 return 0;
153 }
154
155
156 static status_t
157 print_demangled_call(const char* image, const char* symbol, addr_t args,
158 bool noObjectMethod, bool addDebugVariables)
159 {
160 static const size_t kBufferSize = 256;
161 char* buffer = (char*)debug_malloc(kBufferSize);
162 if (buffer == NULL)
163 return B_NO_MEMORY;
164
165 bool isObjectMethod;
166 const char* name = debug_demangle_symbol(symbol, buffer, kBufferSize,
167 &isObjectMethod);
168 if (name == NULL) {
169 debug_free(buffer);
170 return B_ERROR;
171 }
172
173 uint32* arg = (uint32*)args;
174
175 if (noObjectMethod)
176 isObjectMethod = false;
177 if (isObjectMethod) {
178 const char* lastName = strrchr(name, ':') - 1;
179 int namespaceLength = lastName - name;
180
181 uint32 argValue = 0;
182 if (debug_memcpy(B_CURRENT_TEAM, &argValue, arg, 4) == B_OK) {
183 kprintf("<%s> %.*s<\33[32m%#" B_PRIx32 "\33[0m>%s", image,
184 namespaceLength, name, argValue, lastName);
185 } else
186 kprintf("<%s> %.*s<???>%s", image, namespaceLength, name, lastName);
187
188 if (addDebugVariables)
189 set_debug_variable("_this", argValue);
190 arg++;
191 } else
192 kprintf("<%s> %s", image, name);
193
194 kprintf("(");
195
196 size_t length;
197 int32 type, i = 0;
198 uint32 cookie = 0;
199 while (debug_get_next_demangled_argument(&cookie, symbol, buffer,
200 kBufferSize, &type, &length) == B_OK) {
201 if (i++ > 0)
202 kprintf(", ");
203
204 // retrieve value and type identifier
205
206 uint64 value;
207 bool valueKnown = false;
208
209 switch (type) {
210 case B_INT64_TYPE:
211 value = read_function_argument_value<int64>(arg, valueKnown);
212 if (valueKnown)
213 kprintf("int64: \33[34m%Ld\33[0m", value);
214 break;
215 case B_INT32_TYPE:
216 value = read_function_argument_value<int32>(arg, valueKnown);
217 if (valueKnown)
218 kprintf("int32: \33[34m%ld\33[0m", (int32)value);
219 break;
220 case B_INT16_TYPE:
221 value = read_function_argument_value<int16>(arg, valueKnown);
222 if (valueKnown)
223 kprintf("int16: \33[34m%d\33[0m", (int16)value);
224 break;
225 case B_INT8_TYPE:
226 value = read_function_argument_value<int8>(arg, valueKnown);
227 if (valueKnown)
228 kprintf("int8: \33[34m%d\33[0m", (int8)value);
229 break;
230 case B_UINT64_TYPE:
231 value = read_function_argument_value<uint64>(arg, valueKnown);
232 if (valueKnown) {
233 kprintf("uint64: \33[34m%#Lx\33[0m", value);
234 if (value < 0x100000)
235 kprintf(" (\33[34m%Lu\33[0m)", value);
236 }
237 break;
238 case B_UINT32_TYPE:
239 value = read_function_argument_value<uint32>(arg, valueKnown);
240 if (valueKnown) {
241 kprintf("uint32: \33[34m%#lx\33[0m", (uint32)value);
242 if (value < 0x100000)
243 kprintf(" (\33[34m%lu\33[0m)", (uint32)value);
244 }
245 break;
246 case B_UINT16_TYPE:
247 value = read_function_argument_value<uint16>(arg, valueKnown);
248 if (valueKnown) {
249 kprintf("uint16: \33[34m%#x\33[0m (\33[34m%u\33[0m)",
250 (uint16)value, (uint16)value);
251 }
252 break;
253 case B_UINT8_TYPE:
254 value = read_function_argument_value<uint8>(arg, valueKnown);
255 if (valueKnown) {
256 kprintf("uint8: \33[34m%#x\33[0m (\33[34m%u\33[0m)",
257 (uint8)value, (uint8)value);
258 }
259 break;
260 case B_BOOL_TYPE:
261 value = read_function_argument_value<uint8>(arg, valueKnown);
262 if (valueKnown)
263 kprintf("\33[34m%s\33[0m", value ? "true" : "false");
264 break;
265 default:
266 if (buffer[0])
267 kprintf("%s: ", buffer);
268
269 if (length == 4) {
270 value = read_function_argument_value<uint32>(arg,
271 valueKnown);
272 if (valueKnown) {
273 if (value == 0
274 && (type == B_POINTER_TYPE || type == B_REF_TYPE))
275 kprintf("NULL");
276 else
277 kprintf("\33[34m%#lx\33[0m", (uint32)value);
278 }
279 break;
280 }
281
282
283 if (length == 8) {
284 value = read_function_argument_value<uint64>(arg,
285 valueKnown);
286 } else
287 value = (uint64)arg;
288
289 if (valueKnown)
290 kprintf("\33[34m%#Lx\33[0m", value);
291 break;
292 }
293
294 if (!valueKnown)
295 kprintf("???");
296
297 if (valueKnown && type == B_STRING_TYPE) {
298 if (value == 0)
299 kprintf(" \33[31m\"<NULL>\"\33[0m");
300 else if (debug_strlcpy(B_CURRENT_TEAM, buffer, (char*)(addr_t)value,
301 kBufferSize) < B_OK) {
302 kprintf(" \33[31m\"<???>\"\33[0m");
303 } else
304 kprintf(" \33[36m\"%s\"\33[0m", buffer);
305 }
306
307 if (addDebugVariables)
308 set_debug_argument_variable(i, value);
309 arg = (uint32*)((uint8*)arg + length);
310 }
311
312 debug_free(buffer);
313
314 kprintf(")");
315 return B_OK;
316 }
317
318
319 #else // __x86_64__
320
321
322 static status_t
323 print_demangled_call(const char* image, const char* symbol, addr_t args,
324 bool noObjectMethod, bool addDebugVariables)
325 {
326 // Since x86_64 uses registers rather than the stack for the first 6
327 // arguments we cannot use the same method as x86 to read the function
328 // arguments. Maybe we need DWARF support in the kernel debugger. For now
329 // just print out the function signature without the argument values.
330
331 static const size_t kBufferSize = 256;
332 char* buffer = (char*)debug_malloc(kBufferSize);
333 if (buffer == NULL)
334 return B_NO_MEMORY;
335
336 bool isObjectMethod;
337 const char* name = debug_demangle_symbol(symbol, buffer, kBufferSize,
338 &isObjectMethod);
339 if (name == NULL) {
340 debug_free(buffer);
341 return B_ERROR;
342 }
343
344 kprintf("<%s> %s(", image, name);
345
346 size_t length;
347 int32 type, i = 0;
348 uint32 cookie = 0;
349 while (debug_get_next_demangled_argument(&cookie, symbol, buffer,
350 kBufferSize, &type, &length) == B_OK) {
351 if (i++ > 0)
352 kprintf(", ");
353
354 if (buffer[0])
355 kprintf("%s", buffer);
356 else
357 kprintf("???");
358 }
359
360 debug_free(buffer);
361
362 kprintf(")");
363 return B_OK;
364 }
365
366
367 #endif // __x86_64__
368
369
370 static void
371 print_stack_frame(Thread* thread, addr_t ip, addr_t bp, addr_t nextBp,
372 int32 callIndex, bool demangle)
373 {
374 const char* symbol;
375 const char* image;
376 addr_t baseAddress;
377 bool exactMatch;
378 status_t status;
379 addr_t diff;
380
381 diff = nextBp - bp;
382
383 // MSB set = kernel space/user space switch
384 if (diff & ~((addr_t)-1 >> 1))
385 diff = 0;
386
387 status = lookup_symbol(thread, ip, &baseAddress, &symbol, &image,
388 &exactMatch);
389
390 kprintf("%2" B_PRId32 " %0*lx (+%4ld) %0*lx ", callIndex,
391 B_PRINTF_POINTER_WIDTH, bp, diff, B_PRINTF_POINTER_WIDTH, ip);
392
393 if (status == B_OK) {
394 if (exactMatch && demangle) {
395 status = print_demangled_call(image, symbol,
396 nextBp + sizeof(stack_frame), false, false);
397 }
398
399 if (!exactMatch || !demangle || status != B_OK) {
400 if (symbol != NULL) {
401 kprintf("<%s> %s%s", image, symbol,
402 exactMatch ? "" : " (nearest)");
403 } else
404 kprintf("<%s@%p> <unknown>", image, (void*)baseAddress);
405 }
406
407 kprintf(" + %#04lx\n", ip - baseAddress);
408 } else {
409 VMArea *area = NULL;
410 if (thread != NULL && thread->team != NULL
411 && thread->team->address_space != NULL) {
412 area = thread->team->address_space->LookupArea(ip);
413 }
414 if (area != NULL) {
415 kprintf("%" B_PRId32 ":%s@%p + %#lx\n", area->id, area->name,
416 (void*)area->Base(), ip - area->Base());
417 } else
418 kprintf("\n");
419 }
420 }
421
422
423 static void
424 print_iframe(iframe* frame)
425 {
426 bool isUser = IFRAME_IS_USER(frame);
427
428 #ifdef __x86_64__
429 kprintf("%s iframe at %p (end = %p)\n", isUser ? "user" : "kernel", frame,
430 frame + 1);
431
432 kprintf(" rax %#-18lx rbx %#-18lx rcx %#lx\n", frame->ax,
433 frame->bx, frame->cx);
434 kprintf(" rdx %#-18lx rsi %#-18lx rdi %#lx\n", frame->dx,
435 frame->si, frame->di);
436 kprintf(" rbp %#-18lx r8 %#-18lx r9 %#lx\n", frame->bp,
437 frame->r8, frame->r9);
438 kprintf(" r10 %#-18lx r11 %#-18lx r12 %#lx\n", frame->r10,
439 frame->r11, frame->r12);
440 kprintf(" r13 %#-18lx r14 %#-18lx r15 %#lx\n", frame->r13,
441 frame->r14, frame->r15);
442 kprintf(" rip %#-18lx rsp %#-18lx rflags %#lx\n", frame->ip,
443 frame->sp, frame->flags);
444 #else
445 kprintf("%s iframe at %p (end = %p)\n", isUser ? "user" : "kernel", frame,
446 isUser ? (void*)(frame + 1) : (void*)&frame->user_sp);
447
448 kprintf(" eax %#-10lx ebx %#-10lx ecx %#-10lx edx %#lx\n",
449 frame->ax, frame->bx, frame->cx, frame->dx);
450 kprintf(" esi %#-10lx edi %#-10lx ebp %#-10lx esp %#lx\n",
451 frame->si, frame->di, frame->bp, frame->sp);
452 kprintf(" eip %#-10lx eflags %#-10lx", frame->ip, frame->flags);
453 if (isUser) {
454 // from user space
455 kprintf("user esp %#lx", frame->user_sp);
456 }
457 kprintf("\n");
458 #endif
459
460 kprintf(" vector: %#lx, error code: %#lx\n", frame->vector,
461 frame->error_code);
462 }
463
464
465 static bool
466 setup_for_thread(char* arg, Thread** _thread, addr_t* _bp,
467 phys_addr_t* _oldPageDirectory)
468 {
469 Thread* thread = NULL;
470
471 if (arg != NULL) {
472 thread_id id = strtoul(arg, NULL, 0);
473 thread = Thread::GetDebug(id);
474 if (thread == NULL) {
475 kprintf("could not find thread %" B_PRId32 "\n", id);
476 return false;
477 }
478
479 if (id != thread_get_current_thread_id()) {
480 // switch to the page directory of the new thread to be
481 // able to follow the stack trace into userland
482 phys_addr_t newPageDirectory = x86_next_page_directory(
483 thread_get_current_thread(), thread);
484
485 if (newPageDirectory != 0) {
486 *_oldPageDirectory = x86_read_cr3();
487 x86_write_cr3(newPageDirectory);
488 }
489
490 if (thread->state == B_THREAD_RUNNING) {
491 // The thread is currently running on another CPU.
492 if (thread->cpu == NULL)
493 return false;
494 arch_debug_registers* registers = debug_get_debug_registers(
495 thread->cpu->cpu_num);
496 if (registers == NULL)
497 return false;
498 *_bp = registers->bp;
499 } else {
500 // Read frame pointer from the thread's stack.
501 *_bp = thread->arch_info.GetFramePointer();
502 }
503 } else
504 thread = NULL;
505 }
506
507 if (thread == NULL) {
508 // if we don't have a thread yet, we want the current one
509 // (ebp has been set by the caller for this case already)
510 thread = thread_get_current_thread();
511 }
512
513 *_thread = thread;
514 return true;
515 }
516
517
518 static bool
519 is_double_fault_stack_address(int32 cpu, addr_t address)
520 {
521 size_t size;
522 addr_t bottom = (addr_t)x86_get_double_fault_stack(cpu, &size);
523 return address >= bottom && address < bottom + size;
524 }
525
526
527 static bool
528 is_kernel_stack_address(Thread* thread, addr_t address)
529 {
530 // We don't have a thread pointer in the early boot process, but then we are
531 // on the kernel stack for sure.
532 if (thread == NULL)
533 return IS_KERNEL_ADDRESS(address);
534
535 // Also in the early boot process we might have a thread structure, but it
536 // might not have its kernel stack attributes set yet.
537 if (thread->kernel_stack_top == 0)
538 return IS_KERNEL_ADDRESS(address);
539
540 return (address >= thread->kernel_stack_base
541 && address < thread->kernel_stack_top)
542 || (thread->cpu != NULL
543 && is_double_fault_stack_address(thread->cpu->cpu_num, address));
544 }
545
546
547 static bool
548 is_iframe(Thread* thread, addr_t frame)
549 {
550 if (!is_kernel_stack_address(thread, frame))
551 return false;
552
553 addr_t previousFrame = *(addr_t*)frame;
554 return ((previousFrame & ~(addr_t)IFRAME_TYPE_MASK) == 0
555 && previousFrame != 0);
556 }
557
558
559 static iframe*
560 find_previous_iframe(Thread* thread, addr_t frame)
561 {
562 // iterate backwards through the stack frames, until we hit an iframe
563 while (is_kernel_stack_address(thread, frame)) {
564 if (is_iframe(thread, frame))
565 return (iframe*)frame;
566
567 frame = *(addr_t*)frame;
568 }
569
570 return NULL;
571 }
572
573
574 static iframe*
575 get_previous_iframe(Thread* thread, iframe* frame)
576 {
577 if (frame == NULL)
578 return NULL;
579
580 return find_previous_iframe(thread, frame->bp);
581 }
582
583
584 static iframe*
585 get_current_iframe(Thread* thread)
586 {
587 if (thread == thread_get_current_thread())
588 return x86_get_current_iframe();
589
590 // NOTE: This doesn't work, if the thread is running (on another CPU).
591 return find_previous_iframe(thread, thread->arch_info.GetFramePointer());
592 }
593
594
595 #define CHECK_DEBUG_VARIABLE(_name, _member, _settable) \
596 if (strcmp(variableName, _name) == 0) { \
597 settable = _settable; \
598 return &_member; \
599 }
600
601
602 static size_t*
603 find_debug_variable(const char* variableName, bool& settable)
604 {
605 iframe* frame = get_current_iframe(debug_get_debugged_thread());
606 if (frame == NULL)
607 return NULL;
608
609 #ifdef __x86_64__
610 CHECK_DEBUG_VARIABLE("cs", frame->cs, false);
611 CHECK_DEBUG_VARIABLE("ss", frame->ss, false);
612 CHECK_DEBUG_VARIABLE("r15", frame->r15, true);
613 CHECK_DEBUG_VARIABLE("r14", frame->r14, true);
614 CHECK_DEBUG_VARIABLE("r13", frame->r13, true);
615 CHECK_DEBUG_VARIABLE("r12", frame->r12, true);
616 CHECK_DEBUG_VARIABLE("r11", frame->r11, true);
617 CHECK_DEBUG_VARIABLE("r10", frame->r10, true);
618 CHECK_DEBUG_VARIABLE("r9", frame->r9, true);
619 CHECK_DEBUG_VARIABLE("r8", frame->r8, true);
620 CHECK_DEBUG_VARIABLE("rbp", frame->bp, true);
621 CHECK_DEBUG_VARIABLE("rsi", frame->si, true);
622 CHECK_DEBUG_VARIABLE("rdi", frame->di, true);
623 CHECK_DEBUG_VARIABLE("rdx", frame->dx, true);
624 CHECK_DEBUG_VARIABLE("rcx", frame->cx, true);
625 CHECK_DEBUG_VARIABLE("rbx", frame->bx, true);
626 CHECK_DEBUG_VARIABLE("rax", frame->ax, true);
627 CHECK_DEBUG_VARIABLE("rip", frame->ip, true);
628 CHECK_DEBUG_VARIABLE("rflags", frame->flags, true);
629 CHECK_DEBUG_VARIABLE("rsp", frame->sp, true);
630 #else
631 CHECK_DEBUG_VARIABLE("gs", frame->gs, false);
632 CHECK_DEBUG_VARIABLE("fs", frame->fs, false);
633 CHECK_DEBUG_VARIABLE("es", frame->es, false);
634 CHECK_DEBUG_VARIABLE("ds", frame->ds, false);
635 CHECK_DEBUG_VARIABLE("cs", frame->cs, false);
636 CHECK_DEBUG_VARIABLE("edi", frame->di, true);
637 CHECK_DEBUG_VARIABLE("esi", frame->si, true);
638 CHECK_DEBUG_VARIABLE("ebp", frame->bp, true);
639 CHECK_DEBUG_VARIABLE("esp", frame->sp, true);
640 CHECK_DEBUG_VARIABLE("ebx", frame->bx, true);
641 CHECK_DEBUG_VARIABLE("edx", frame->dx, true);
642 CHECK_DEBUG_VARIABLE("ecx", frame->cx, true);
643 CHECK_DEBUG_VARIABLE("eax", frame->ax, true);
644 CHECK_DEBUG_VARIABLE("orig_eax", frame->orig_eax, true);
645 CHECK_DEBUG_VARIABLE("orig_edx", frame->orig_edx, true);
646 CHECK_DEBUG_VARIABLE("eip", frame->ip, true);
647 CHECK_DEBUG_VARIABLE("eflags", frame->flags, true);
648
649 if (IFRAME_IS_USER(frame)) {
650 CHECK_DEBUG_VARIABLE("user_esp", frame->user_sp, true);
651 CHECK_DEBUG_VARIABLE("user_ss", frame->user_ss, false);
652 }
653 #endif
654
655 return NULL;
656 }
657
658
659 static int
660 stack_trace(int argc, char** argv)
661 {
662 static const char* usage = "usage: %s [-d] [ <thread id> ]\n"
663 "Prints a stack trace for the current, respectively the specified\n"
664 "thread.\n"
665 " -d - Disables the demangling of the symbols.\n"
666 " <thread id> - The ID of the thread for which to print the stack\n"
667 " trace.\n";
668 bool demangle = true;
669 int32 threadIndex = 1;
670 if (argc > 1 && !strcmp(argv[1], "-d")) {
671 demangle = false;
672 threadIndex++;
673 }
674
675 if (argc > threadIndex + 1
676 || (argc == 2 && strcmp(argv[1], "--help") == 0)) {
677 kprintf(usage, argv[0]);
678 return 0;
679 }
680
681 addr_t previousLocations[NUM_PREVIOUS_LOCATIONS];
682 Thread* thread = NULL;
683 phys_addr_t oldPageDirectory = 0;
684 addr_t bp = x86_get_stack_frame();
685 int32 num = 0, last = 0;
686
687 if (!setup_for_thread(argc == threadIndex + 1 ? argv[threadIndex] : NULL,
688 &thread, &bp, &oldPageDirectory))
689 return 0;
690
691 DebuggedThreadSetter threadSetter(thread);
692
693 if (thread != NULL) {
694 kprintf("stack trace for thread %" B_PRId32 " \"%s\"\n", thread->id,
695 thread->name);
696
697 kprintf(" kernel stack: %p to %p\n",
698 (void*)thread->kernel_stack_base,
699 (void*)(thread->kernel_stack_top));
700 if (thread->user_stack_base != 0) {
701 kprintf(" user stack: %p to %p\n",
702 (void*)thread->user_stack_base,
703 (void*)(thread->user_stack_base + thread->user_stack_size));
704 }
705 }
706
707 kprintf("%-*s %-*s <image>:function + offset\n",
708 B_PRINTF_POINTER_WIDTH, "frame", B_PRINTF_POINTER_WIDTH, "caller");
709
710 bool onKernelStack = true;
711
712 for (int32 callIndex = 0;; callIndex++) {
713 onKernelStack = onKernelStack
714 && is_kernel_stack_address(thread, bp);
715
716 if (onKernelStack && is_iframe(thread, bp)) {
717 iframe* frame = (iframe*)bp;
718
719 print_iframe(frame);
720 print_stack_frame(thread, frame->ip, bp, frame->bp, callIndex,
721 demangle);
722
723 bp = frame->bp;
724 } else {
725 addr_t ip, nextBp;
726
727 if (get_next_frame_debugger(bp, &nextBp, &ip) != B_OK) {
728 kprintf("%0*lx -- read fault\n", B_PRINTF_POINTER_WIDTH, bp);
729 break;
730 }
731
732 if (ip == 0 || bp == 0)
733 break;
734
735 print_stack_frame(thread, ip, bp, nextBp, callIndex, demangle);
736 bp = nextBp;
737 }
738
739 if (already_visited(previousLocations, &last, &num, bp)) {
740 kprintf("circular stack frame: %p!\n", (void*)bp);
741 break;
742 }
743 if (bp == 0)
744 break;
745 }
746
747 if (oldPageDirectory != 0) {
748 // switch back to the previous page directory to no cause any troubles
749 x86_write_cr3(oldPageDirectory);
750 }
751
752 return 0;
753 }
754
755
756 #ifndef __x86_64__
757 static void
758 print_call(Thread *thread, addr_t eip, addr_t ebp, addr_t nextEbp,
759 int32 argCount)
760 {
761 const char *symbol, *image;
762 addr_t baseAddress;
763 bool exactMatch;
764 status_t status;
765 bool demangled = false;
766 int32 *arg = (int32 *)(nextEbp + 8);
767
768 status = lookup_symbol(thread, eip, &baseAddress, &symbol, &image,
769 &exactMatch);
770
771 kprintf("%08lx %08lx ", ebp, eip);
772
773 if (status == B_OK) {
774 if (symbol != NULL) {
775 if (exactMatch && (argCount == 0 || argCount == -1)) {
776 status = print_demangled_call(image, symbol, (addr_t)arg,
777 argCount == -1, true);
778 if (status == B_OK)
779 demangled = true;
780 }
781 if (!demangled) {
782 kprintf("<%s>:%s%s", image, symbol,
783 exactMatch ? "" : " (nearest)");
784 }
785 } else {
786 kprintf("<%s@%p>:unknown + 0x%04lx", image,
787 (void *)baseAddress, eip - baseAddress);
788 }
789 } else {
790 VMArea *area = NULL;
791 if (thread->team->address_space != NULL)
792 area = thread->team->address_space->LookupArea(eip);
793 if (area != NULL) {
794 kprintf("%ld:%s@%p + %#lx", area->id, area->name,
795 (void *)area->Base(), eip - area->Base());
796 }
797 }
798
799 if (!demangled) {
800 kprintf("(");
801
802 for (int32 i = 0; i < argCount; i++) {
803 if (i > 0)
804 kprintf(", ");
805 kprintf("%#lx", *arg);
806 if (*arg > -0x10000 && *arg < 0x10000)
807 kprintf(" (%ld)", *arg);
808
809 set_debug_argument_variable(i + 1, *(uint32 *)arg);
810 arg++;
811 }
812
813 kprintf(")\n");
814 } else
815 kprintf("\n");
816
817 set_debug_variable("_frame", nextEbp);
818 }
819
820
821 static int
822 show_call(int argc, char **argv)
823 {
824 static const char* usage
825 = "usage: %s [ <thread id> ] <call index> [ -<arg count> ]\n"
826 "Prints a function call with parameters of the current, respectively\n"
827 "the specified thread.\n"
828 " <thread id> - The ID of the thread for which to print the call.\n"
829 " <call index> - The index of the call in the stack trace.\n"
830 " <arg count> - The number of call arguments to print (use 'c' to\n"
831 " force the C++ demangler to use class methods,\n"
832 " use 'd' to disable demangling).\n";
833 if (argc == 2 && strcmp(argv[1], "--help") == 0) {
834 kprintf(usage, argv[0]);
835 return 0;
836 }
837
838 Thread *thread = NULL;
839 phys_addr_t oldPageDirectory = 0;
840 addr_t ebp = x86_get_stack_frame();
841 int32 argCount = 0;
842
843 if (argc >= 2 && argv[argc - 1][0] == '-') {
844 if (argv[argc - 1][1] == 'c')
845 argCount = -1;
846 else if (argv[argc - 1][1] == 'd')
847 argCount = -2;
848 else
849 argCount = strtoul(argv[argc - 1] + 1, NULL, 0);
850
851 if (argCount < -2 || argCount > 16) {
852 kprintf("Invalid argument count \"%ld\".\n", argCount);
853 return 0;
854 }
855 argc--;
856 }
857
858 if (argc < 2 || argc > 3) {
859 kprintf(usage, argv[0]);
860 return 0;
861 }
862
863 if (!setup_for_thread(argc == 3 ? argv[1] : NULL, &thread, &ebp,
864 &oldPageDirectory))
865 return 0;
866
867 DebuggedThreadSetter threadSetter(thread);
868
869 int32 callIndex = strtoul(argv[argc == 3 ? 2 : 1], NULL, 0);
870
871 if (thread != NULL)
872 kprintf("thread %ld, %s\n", thread->id, thread->name);
873
874 bool onKernelStack = true;
875
876 for (int32 index = 0; index <= callIndex; index++) {
877 onKernelStack = onKernelStack
878 && is_kernel_stack_address(thread, ebp);
879
880 if (onKernelStack && is_iframe(thread, ebp)) {
881 struct iframe *frame = (struct iframe *)ebp;
882
883 if (index == callIndex)
884 print_call(thread, frame->ip, ebp, frame->bp, argCount);
885
886 ebp = frame->bp;
887 } else {
888 addr_t eip, nextEbp;
889
890 if (get_next_frame_debugger(ebp, &nextEbp, &eip) != B_OK) {
891 kprintf("%08lx -- read fault\n", ebp);
892 break;
893 }
894
895 if (eip == 0 || ebp == 0)
896 break;
897
898 if (index == callIndex)
899 print_call(thread, eip, ebp, nextEbp, argCount);
900
901 ebp = nextEbp;
902 }
903
904 if (ebp == 0)
905 break;
906 }
907
908 if (oldPageDirectory != 0) {
909 // switch back to the previous page directory to not cause any troubles
910 x86_write_cr3(oldPageDirectory);
911 }
912
913 return 0;
914 }
915 #endif
916
917
918 static int
919 dump_iframes(int argc, char** argv)
920 {
921 static const char* usage = "usage: %s [ <thread id> ]\n"
922 "Prints the iframe stack for the current, respectively the specified\n"
923 "thread.\n"
924 " <thread id> - The ID of the thread for which to print the iframe\n"
925 " stack.\n";
926 if (argc == 2 && strcmp(argv[1], "--help") == 0) {
927 kprintf(usage, argv[0]);
928 return 0;
929 }
930
931 Thread* thread = NULL;
932
933 if (argc < 2) {
934 thread = thread_get_current_thread();
935 } else if (argc == 2) {
936 thread_id id = strtoul(argv[1], NULL, 0);
937 thread = Thread::GetDebug(id);
938 if (thread == NULL) {
939 kprintf("could not find thread %" B_PRId32 "\n", id);
940 return 0;
941 }
942 } else if (argc > 2) {
943 kprintf(usage, argv[0]);
944 return 0;
945 }
946
947 if (thread != NULL) {
948 kprintf("iframes for thread %" B_PRId32 " \"%s\"\n", thread->id,
949 thread->name);
950 }
951
952 DebuggedThreadSetter threadSetter(thread);
953
954 iframe* frame = find_previous_iframe(thread, x86_get_stack_frame());
955 while (frame != NULL) {
956 print_iframe(frame);
957 frame = get_previous_iframe(thread, frame);
958 }
959
960 return 0;
961 }
962
963
964 static bool
965 is_calling(Thread* thread, addr_t ip, const char* pattern, addr_t start,
966 addr_t end)
967 {
968 if (pattern == NULL)
969 return ip >= start && ip < end;
970
971 if (!IS_KERNEL_ADDRESS(ip))
972 return false;
973
974 const char* symbol;
975 if (lookup_symbol(thread, ip, NULL, &symbol, NULL, NULL) != B_OK)
976 return false;
977
978 return strstr(symbol, pattern);
979 }
980
981
982 static int
983 cmd_in_context(int argc, char** argv)
984 {
985 if (argc != 2) {
986 print_debugger_command_usage(argv[0]);
987 return 0;
988 }
989
990 // get the thread ID
991 const char* commandLine = argv[1];
992 char threadIDString[16];
993 if (parse_next_debug_command_argument(&commandLine, threadIDString,
994 sizeof(threadIDString)) != B_OK) {
995 kprintf("Failed to parse thread ID.\n");
996 return 0;
997 }
998
999 if (commandLine == NULL) {
1000 print_debugger_command_usage(argv[0]);
1001 return 0;
1002 }
1003
1004 uint64 threadID;
1005 if (!evaluate_debug_expression(threadIDString, &threadID, false))
1006 return 0;
1007
1008 // get the thread
1009 Thread* thread = Thread::GetDebug(threadID);
1010 if (thread == NULL) {
1011 kprintf("Could not find thread with ID \"%s\".\n", threadIDString);
1012 return 0;
1013 }
1014
1015 // switch the page directory, if necessary
1016 phys_addr_t oldPageDirectory = 0;
1017 if (thread != thread_get_current_thread()) {
1018 phys_addr_t newPageDirectory = x86_next_page_directory(
1019 thread_get_current_thread(), thread);
1020
1021 if (newPageDirectory != 0) {
1022 oldPageDirectory = x86_read_cr3();
1023 x86_write_cr3(newPageDirectory);
1024 }
1025 }
1026
1027 // execute the command
1028 {
1029 DebuggedThreadSetter threadSetter(thread);
1030 evaluate_debug_command(commandLine);
1031 }
1032
1033 // reset the page directory
1034 if (oldPageDirectory)
1035 x86_write_cr3(oldPageDirectory);
1036
1037 return 0;
1038 }
1039
1040
1041 // #pragma mark -
1042
1043
1044 void
1045 arch_debug_save_registers(arch_debug_registers* registers)
1046 {
1047 // get the caller's frame pointer
1048 stack_frame* frame = (stack_frame*)x86_get_stack_frame();
1049 registers->bp = (addr_t)frame->previous;
1050 }
1051
1052
1053 void
1054 arch_debug_stack_trace(void)
1055 {
1056 stack_trace(0, NULL);
1057 }
1058
1059
1060 bool
1061 arch_debug_contains_call(Thread* thread, const char* symbol, addr_t start,
1062 addr_t end)
1063 {
1064 DebuggedThreadSetter threadSetter(thread);
1065
1066 addr_t bp;
1067 if (thread == thread_get_current_thread())
1068 bp = x86_get_stack_frame();
1069 else {
1070 if (thread->state == B_THREAD_RUNNING) {
1071 // The thread is currently running on another CPU.
1072 if (thread->cpu == NULL)
1073 return false;
1074 arch_debug_registers* registers = debug_get_debug_registers(
1075 thread->cpu->cpu_num);
1076 if (registers == NULL)
1077 return false;
1078 bp = registers->bp;
1079 } else {
1080 // thread not running
1081 bp = thread->arch_info.GetFramePointer();
1082 }
1083 }
1084
1085 for (;;) {
1086 if (!is_kernel_stack_address(thread, bp))
1087 break;
1088
1089 if (is_iframe(thread, bp)) {
1090 iframe* frame = (iframe*)bp;
1091
1092 if (is_calling(thread, frame->ip, symbol, start, end))
1093 return true;
1094
1095 bp = frame->bp;
1096 } else {
1097 addr_t ip, nextBp;
1098
1099 if (get_next_frame_no_debugger(bp, &nextBp, &ip, true,
1100 thread) != B_OK
1101 || ip == 0 || bp == 0)
1102 break;
1103
1104 if (is_calling(thread, ip, symbol, start, end))
1105 return true;
1106
1107 bp = nextBp;
1108 }
1109
1110 if (bp == 0)
1111 break;
1112 }
1113
1114 return false;
1115 }
1116
1117
1118 void*
1119 arch_debug_get_caller(void)
1120 {
1121 stack_frame* frame = (stack_frame*)x86_get_stack_frame();
1122 return (void*)frame->previous->return_address;
1123 }
1124
1125
1126 /*! Captures a stack trace (the return addresses) of the current thread.
1127 \param returnAddresses The array the return address shall be written to.
1128 \param maxCount The maximum number of return addresses to be captured.
1129 \param skipIframes The number of interrupt frames that shall be skipped. If
1130 greater than 0, \a skipFrames is ignored.
1131 \param skipFrames The number of stack frames that shall be skipped.
1132 \param flags A combination of one or two of the following:
1133 - \c STACK_TRACE_KERNEL: Capture kernel return addresses.
1134 - \c STACK_TRACE_USER: Capture user return addresses.
1135 \return The number of return addresses written to the given array.
1136 */
1137 int32
1138 arch_debug_get_stack_trace(addr_t* returnAddresses, int32 maxCount,
1139 int32 skipIframes, int32 skipFrames, uint32 flags)
1140 {
1141 // Keep skipping normal stack frames until we've skipped the iframes we're
1142 // supposed to skip.
1143 if (skipIframes > 0)
1144 skipFrames = INT_MAX;
1145
1146 Thread* thread = thread_get_current_thread();
1147 int32 count = 0;
1148 addr_t bp = x86_get_stack_frame();
1149 bool onKernelStack = true;
1150
1151 while (bp != 0 && count < maxCount) {
1152 onKernelStack = onKernelStack
1153 && is_kernel_stack_address(thread, bp);
1154 if (!onKernelStack && (flags & STACK_TRACE_USER) == 0)
1155 break;
1156
1157 addr_t ip;
1158 addr_t nextBp;
1159
1160 if (onKernelStack && is_iframe(thread, bp)) {
1161 iframe* frame = (iframe*)bp;
1162 ip = frame->ip;
1163 nextBp = frame->bp;
1164
1165 if (skipIframes > 0) {
1166 if (--skipIframes == 0)
1167 skipFrames = 0;
1168 }
1169 } else {
1170 if (get_next_frame_no_debugger(bp, &nextBp, &ip,
1171 onKernelStack, thread) != B_OK) {
1172 break;
1173 }
1174 }
1175
1176 if (ip == 0)
1177 break;
1178
1179 if (skipFrames <= 0
1180 && ((flags & STACK_TRACE_KERNEL) != 0 || onKernelStack)) {
1181 returnAddresses[count++] = ip;
1182 } else
1183 skipFrames--;
1184
1185 bp = nextBp;
1186 }
1187
1188 return count;
1189 }
1190
1191
1192 /*! Returns the program counter of the currently debugged (respectively this)
1193 thread where the innermost interrupts happened. \a _isSyscall, if specified,
1194 is set to whether this interrupt frame was created by a syscall. Returns
1195 \c NULL, if there's no such frame or a problem occurred retrieving it;
1196 \a _isSyscall won't be set in this case.
1197 */
1198 void*
1199 arch_debug_get_interrupt_pc(bool* _isSyscall)
1200 {
1201 iframe* frame = get_current_iframe(debug_get_debugged_thread());
1202 if (frame == NULL)
1203 return NULL;
1204
1205 if (_isSyscall != NULL)
1206 *_isSyscall = frame->type == IFRAME_TYPE_SYSCALL;
1207
1208 return (void*)(addr_t)frame->ip;
1209 }
1210
1211
1212 /*! Sets the current thread to \c NULL.
1213 Invoked in the kernel debugger only.
1214 */
1215 void
1216 arch_debug_unset_current_thread(void)
1217 {
1218 // Can't just write 0 to the GS base, that will cause the read from %gs:0
1219 // to fault. Instead point it at a NULL pointer, %gs:0 will get this value.
1220 static Thread* unsetThread = NULL;
1221 #ifdef __x86_64__
1222 x86_write_msr(IA32_MSR_GS_BASE, (addr_t)&unsetThread);
1223 #else
1224 asm volatile("mov %0, %%gs:0" : : "r" (unsetThread) : "memory");
1225 #endif
1226 }
1227
1228
1229 bool
1230 arch_is_debug_variable_defined(const char* variableName)
1231 {
1232 bool settable;
1233 return find_debug_variable(variableName, settable);
1234 }
1235
1236
1237 status_t
1238 arch_set_debug_variable(const char* variableName, uint64 value)
1239 {
1240 bool settable;
1241 size_t* variable = find_debug_variable(variableName, settable);
1242 if (variable == NULL)
1243 return B_ENTRY_NOT_FOUND;
1244
1245 if (!settable)
1246 return B_NOT_ALLOWED;
1247
1248 *variable = (size_t)value;
1249 return B_OK;
1250 }
1251
1252
1253 status_t
1254 arch_get_debug_variable(const char* variableName, uint64* value)
1255 {
1256 bool settable;
1257 size_t* variable = find_debug_variable(variableName, settable);
1258 if (variable == NULL)
1259 return B_ENTRY_NOT_FOUND;
1260
1261 *value = *variable;
1262 return B_OK;
1263 }
1264
1265
1266 struct gdb_register {
1267 int32 type;
1268 uint64 value;
1269 };
1270
1271
1272 /*! Writes the contents of the CPU registers at some fixed outer stack frame or
1273 iframe into the given buffer in the format expected by gdb.
1274
1275 This function is called in response to gdb's 'g' command.
1276
1277 \param buffer The buffer to write the registers to.
1278 \param bufferSize The size of \a buffer in bytes.
1279 \return When successful, the number of bytes written to \a buffer, or a
1280 negative error code on error.
1281 */
1282 ssize_t
1283 arch_debug_gdb_get_registers(char* buffer, size_t bufferSize)
1284 {
1285 iframe* frame = get_current_iframe(debug_get_debugged_thread());
1286 if (frame == NULL)
1287 return B_NOT_SUPPORTED;
1288
1289 #ifdef __x86_64__
1290 // For x86_64 the register order is:
1291 //
1292 // rax, rbx, rcx, rdx, rsi, rdi, rbp, rsp,
1293 // r8, r9, r10, r11, r12, r13, r14, r15,
1294 // rip, rflags, cs, ss, ds, es, fs, gs
1295 //
1296 // Annoyingly, GDB wants all the registers as 64-bit values, but then
1297 // RFLAGS and the segment registers as 32-bit values, hence the need for
1298 // the type information.
1299 static const int32 kRegisterCount = 24;
1300 gdb_register registers[kRegisterCount] = {
1301 { B_UINT64_TYPE, frame->ax }, { B_UINT64_TYPE, frame->bx },
1302 { B_UINT64_TYPE, frame->cx }, { B_UINT64_TYPE, frame->dx },
1303 { B_UINT64_TYPE, frame->si }, { B_UINT64_TYPE, frame->di },
1304 { B_UINT64_TYPE, frame->bp }, { B_UINT64_TYPE, frame->sp },
1305 { B_UINT64_TYPE, frame->r8 }, { B_UINT64_TYPE, frame->r9 },
1306 { B_UINT64_TYPE, frame->r10 }, { B_UINT64_TYPE, frame->r11 },
1307 { B_UINT64_TYPE, frame->r12 }, { B_UINT64_TYPE, frame->r13 },
1308 { B_UINT64_TYPE, frame->r14 }, { B_UINT64_TYPE, frame->r15 },
1309 { B_UINT64_TYPE, frame->ip }, { B_UINT32_TYPE, frame->flags },
1310 { B_UINT32_TYPE, frame->cs }, { B_UINT32_TYPE, frame->ss },
1311 { B_UINT32_TYPE, 0 }, { B_UINT32_TYPE, 0 },
1312 { B_UINT32_TYPE, 0 }, { B_UINT32_TYPE, 0 },
1313 };
1314 #else
1315 // For x86 the register order is:
1316 //
1317 // eax, ecx, edx, ebx,
1318 // esp, ebp, esi, edi,
1319 // eip, eflags,
1320 // cs, ss, ds, es, fs, gs
1321 //
1322 // Note that even though the segment descriptors are actually 16 bits wide,
1323 // gdb requires them as 32 bit integers.
1324 static const int32 kRegisterCount = 16;
1325 gdb_register registers[kRegisterCount] = {
1326 { B_UINT32_TYPE, frame->ax }, { B_UINT32_TYPE, frame->cx },
1327 { B_UINT32_TYPE, frame->dx }, { B_UINT32_TYPE, frame->bx },
1328 { B_UINT32_TYPE, frame->sp }, { B_UINT32_TYPE, frame->bp },
1329 { B_UINT32_TYPE, frame->si }, { B_UINT32_TYPE, frame->di },
1330 { B_UINT32_TYPE, frame->ip }, { B_UINT32_TYPE, frame->flags },
1331 { B_UINT32_TYPE, frame->cs }, { B_UINT32_TYPE, frame->ds },
1332 // assume ss == ds
1333 { B_UINT32_TYPE, frame->ds }, { B_UINT32_TYPE, frame->es },
1334 { B_UINT32_TYPE, frame->fs }, { B_UINT32_TYPE, frame->gs },
1335 };
1336 #endif
1337
1338 const char* const bufferStart = buffer;
1339
1340 for (int32 i = 0; i < kRegisterCount; i++) {
1341 // For some reason gdb wants the register dump in *big endian* format.
1342 int result = 0;
1343 switch (registers[i].type) {
1344 case B_UINT64_TYPE:
1345 result = snprintf(buffer, bufferSize, "%016" B_PRIx64,
1346 (uint64)B_HOST_TO_BENDIAN_INT64(registers[i].value));
1347 break;
1348 case B_UINT32_TYPE:
1349 result = snprintf(buffer, bufferSize, "%08" B_PRIx32,
1350 (uint32)B_HOST_TO_BENDIAN_INT32((uint32)registers[i].value));
1351 break;
1352 }
1353 if (result >= (int)bufferSize)
1354 return B_BUFFER_OVERFLOW;
1355
1356 buffer += result;
1357 bufferSize -= result;
1358 }
1359
1360 return buffer - bufferStart;
1361 }
1362
1363
1364 status_t
1365 arch_debug_init(kernel_args* args)
1366 {
1367 // at this stage, the debugger command system is alive
1368
1369 add_debugger_command("where", &stack_trace, "Same as \"sc\"");
1370 add_debugger_command("bt", &stack_trace, "Same as \"sc\" (as in gdb)");
1371 add_debugger_command("sc", &stack_trace,
1372 "Stack crawl for current thread (or any other)");
1373 add_debugger_command("iframe", &dump_iframes,
1374 "Dump iframes for the specified thread");
1375 #ifndef __x86_64__
1376 add_debugger_command("call", &show_call, "Show call with arguments");
1377 #endif
1378 add_debugger_command_etc("in_context", &cmd_in_context,
1379 "Executes a command in the context of a given thread",
1380 "<thread ID> <command> ...\n"
1381 "Executes a command in the context of a given thread.\n",
1382 B_KDEBUG_DONT_PARSE_ARGUMENTS);
1383
1384 return B_NO_ERROR;
1385 }
1386
Clone of Haiku svn repository