Use two-page stacks
[akaros.git] / kern / include / kdebug.h
1 #pragma once
2
3 #include <ros/common.h>
4 #include <ros/trapframe.h>
5 #include <arch/kdebug.h>
6 #include <profiler.h>
7 /* for includes */
8 struct proc;
9 struct kthread;
10
11 struct symtab_entry {
12         const char *name;
13         uintptr_t addr;
14 };
15
16 /* An alternative here is to have backtrace_list kmalloc an array.  The downside
17  * is that we're calling into the allocator in potentially-delicate situations,
18  * such as the NMI handler. */
19 #define MAX_BT_DEPTH 20
20
21 /*** Printk Backtraces, usually used for debugging or from the monitor */
22 /* Backtraces the calling kernel context */
23 void backtrace(void);
24 void backtrace_trace(void);
25 void backtrace_trace_printx(void);
26 /* Backtraces a PC/FP, with no protections */
27 void backtrace_frame(uintptr_t pc, uintptr_t fp);
28 /* Backtraces a user PC/FP */
29 void backtrace_user_frame(uintptr_t pc, uintptr_t fp);
30 /* Backtraces a hardware TF.  Can handle user or kernel TFs */
31 void backtrace_hwtf(struct hw_trapframe *hw_tf);
32 /* Backtraces a user context */
33 void backtrace_user_ctx(struct proc *p, struct user_context *ctx);
34 /* Backtraces the current user context, if there is one */
35 void backtrace_current_ctx(void);
36 void backtrace_kthread(struct kthread *kth);
37
38 /*** Programmatic Backtraces */
39 /* Backtraces a PC/FP, stores results in *pcs, with no protections */
40 size_t backtrace_list(uintptr_t pc, uintptr_t fp, uintptr_t *pcs,
41                       size_t nr_slots);
42 /* Backtraces a user PC/FP, stores results in *pcs */
43 size_t backtrace_user_list(uintptr_t pc, uintptr_t fp, uintptr_t *pcs,
44                                                    size_t nr_slots);
45 /* Prints out a backtrace list, using pfunc(opaque, "line") for the printk.
46  * This does a symbol lookup on the kernel binary, so it is less useful for a
47  * user backtrace. */
48 void print_backtrace_list(uintptr_t *pcs, size_t nr_pcs,
49                                                   void (*pfunc)(void *, const char *), void *opaque);
50 /* Backtraces the calling kernel context, using pfunc for printing */
51 void gen_backtrace(void (*pfunc)(void *, const char *), void *opaque);
52
53 /* Arch dependent, listed here for ease-of-use */
54 static inline uintptr_t get_caller_pc(void);
55
56 /* Returns a null-terminated string with the function name for a given PC /
57  * instruction pointer.  Returns NULL on failure. */
58 const char *get_fn_name(uintptr_t pc);
59
60 /* Returns the address of sym, or 0 if it does not exist */
61 uintptr_t get_symbol_addr(char *sym);
62
63 /* For a poor-mans function tracer (can add these with spatch) */
64 void __print_func_entry(const char *func, const char *file);
65 void __print_func_exit(const char *func, const char *file);
66 #define print_func_entry() __print_func_entry(__FUNCTION__, __FILE__)
67 #define print_func_exit() __print_func_exit(__FUNCTION__, __FILE__)
68 void hexdump(void *v, int length);
69 void pahexdump(uintptr_t pa, int length);
70 int printdump(char *buf, int numprint, int buflen, uint8_t *data);
71
72 extern bool printx_on;
73 void set_printx(int mode);
74 #define printx(args...)                                                 \
75         do {                                                                                    \
76                 if (printx_on)                                                          \
77                         printk(args);                                                   \
78         } while (0)
79 #define trace_printx(args...)                                           \
80         do {                                                                                    \
81                 if (printx_on)                                                          \
82                         trace_printk(args);                             \
83         } while (0)
84
85 void debug_addr_proc(struct proc *p, unsigned long addr);
86 void debug_addr_pid(int pid, unsigned long addr);