Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 1991, 1992 Linus Torvalds |
| 3 | * Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs |
| 4 | */ |
| 5 | #include <linux/kallsyms.h> |
| 6 | #include <linux/kprobes.h> |
| 7 | #include <linux/uaccess.h> |
| 8 | #include <linux/utsname.h> |
| 9 | #include <linux/hardirq.h> |
| 10 | #include <linux/kdebug.h> |
| 11 | #include <linux/module.h> |
| 12 | #include <linux/ptrace.h> |
Steven Rostedt | 712406a | 2009-02-09 10:54:03 -0800 | [diff] [blame] | 13 | #include <linux/ftrace.h> |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 14 | #include <linux/kexec.h> |
| 15 | #include <linux/bug.h> |
| 16 | #include <linux/nmi.h> |
| 17 | #include <linux/sysfs.h> |
| 18 | |
| 19 | #include <asm/stacktrace.h> |
| 20 | |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 21 | |
| 22 | int panic_on_unrecovered_nmi; |
Kurt Garloff | 5211a24 | 2009-06-24 14:32:11 -0700 | [diff] [blame] | 23 | int panic_on_io_nmi; |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 24 | unsigned int code_bytes = 64; |
| 25 | int kstack_depth_to_print = 3 * STACKSLOTS_PER_LINE; |
| 26 | static int die_counter; |
| 27 | |
Adrien Schildknecht | 1fc7f61 | 2015-02-20 03:34:21 +0100 | [diff] [blame] | 28 | static void printk_stack_address(unsigned long address, int reliable, |
| 29 | void *data) |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 30 | { |
Adrien Schildknecht | 1fc7f61 | 2015-02-20 03:34:21 +0100 | [diff] [blame] | 31 | printk("%s [<%p>] %s%pB\n", |
| 32 | (char *)data, (void *)address, reliable ? "" : "? ", |
| 33 | (void *)address); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 34 | } |
| 35 | |
Jiri Slaby | 5f01c98 | 2013-10-25 15:06:58 +0200 | [diff] [blame] | 36 | void printk_address(unsigned long address) |
| 37 | { |
| 38 | pr_cont(" [<%p>] %pS\n", (void *)address, (void *)address); |
| 39 | } |
| 40 | |
Steven Rostedt | 7ee991f | 2008-12-02 23:50:04 -0500 | [diff] [blame] | 41 | #ifdef CONFIG_FUNCTION_GRAPH_TRACER |
| 42 | static void |
| 43 | print_ftrace_graph_addr(unsigned long addr, void *data, |
| 44 | const struct stacktrace_ops *ops, |
Linus Torvalds | da01e18 | 2016-06-23 12:20:01 -0700 | [diff] [blame] | 45 | struct task_struct *task, int *graph) |
Steven Rostedt | 7ee991f | 2008-12-02 23:50:04 -0500 | [diff] [blame] | 46 | { |
Steven Rostedt | 7ee991f | 2008-12-02 23:50:04 -0500 | [diff] [blame] | 47 | unsigned long ret_addr; |
Hugh Dickins | 65c0ff4 | 2012-03-23 14:02:55 -0700 | [diff] [blame] | 48 | int index; |
Steven Rostedt | 7ee991f | 2008-12-02 23:50:04 -0500 | [diff] [blame] | 49 | |
| 50 | if (addr != (unsigned long)return_to_handler) |
| 51 | return; |
| 52 | |
Hugh Dickins | 65c0ff4 | 2012-03-23 14:02:55 -0700 | [diff] [blame] | 53 | index = task->curr_ret_stack; |
| 54 | |
Steven Rostedt | 7ee991f | 2008-12-02 23:50:04 -0500 | [diff] [blame] | 55 | if (!task->ret_stack || index < *graph) |
| 56 | return; |
| 57 | |
| 58 | index -= *graph; |
| 59 | ret_addr = task->ret_stack[index].ret; |
| 60 | |
| 61 | ops->address(data, ret_addr, 1); |
| 62 | |
| 63 | (*graph)++; |
| 64 | } |
| 65 | #else |
| 66 | static inline void |
| 67 | print_ftrace_graph_addr(unsigned long addr, void *data, |
| 68 | const struct stacktrace_ops *ops, |
Linus Torvalds | da01e18 | 2016-06-23 12:20:01 -0700 | [diff] [blame] | 69 | struct task_struct *task, int *graph) |
Steven Rostedt | 7ee991f | 2008-12-02 23:50:04 -0500 | [diff] [blame] | 70 | { } |
| 71 | #endif |
| 72 | |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 73 | /* |
| 74 | * x86-64 can have up to three kernel stacks: |
| 75 | * process stack |
| 76 | * interrupt stack |
| 77 | * severe exception (double fault, nmi, stack fault, debug, mce) hardware stack |
| 78 | */ |
| 79 | |
Linus Torvalds | da01e18 | 2016-06-23 12:20:01 -0700 | [diff] [blame] | 80 | static inline int valid_stack_ptr(struct task_struct *task, |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 81 | void *p, unsigned int size, void *end) |
| 82 | { |
Linus Torvalds | aca9c29 | 2016-06-24 16:55:53 -0700 | [diff] [blame] | 83 | void *t = task_stack_page(task); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 84 | if (end) { |
| 85 | if (p < end && p >= (end-THREAD_SIZE)) |
| 86 | return 1; |
| 87 | else |
| 88 | return 0; |
| 89 | } |
| 90 | return p > t && p < t + THREAD_SIZE - size; |
| 91 | } |
| 92 | |
| 93 | unsigned long |
Linus Torvalds | da01e18 | 2016-06-23 12:20:01 -0700 | [diff] [blame] | 94 | print_context_stack(struct task_struct *task, |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 95 | unsigned long *stack, unsigned long bp, |
| 96 | const struct stacktrace_ops *ops, void *data, |
Steven Rostedt | 7ee991f | 2008-12-02 23:50:04 -0500 | [diff] [blame] | 97 | unsigned long *end, int *graph) |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 98 | { |
| 99 | struct stack_frame *frame = (struct stack_frame *)bp; |
| 100 | |
Linus Torvalds | da01e18 | 2016-06-23 12:20:01 -0700 | [diff] [blame] | 101 | while (valid_stack_ptr(task, stack, sizeof(*stack), end)) { |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 102 | unsigned long addr; |
| 103 | |
| 104 | addr = *stack; |
| 105 | if (__kernel_text_address(addr)) { |
| 106 | if ((unsigned long) stack == bp + sizeof(long)) { |
| 107 | ops->address(data, addr, 1); |
| 108 | frame = frame->next_frame; |
| 109 | bp = (unsigned long) frame; |
| 110 | } else { |
Arjan van de Ven | 2c344e9 | 2009-02-07 12:23:37 -0800 | [diff] [blame] | 111 | ops->address(data, addr, 0); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 112 | } |
Linus Torvalds | da01e18 | 2016-06-23 12:20:01 -0700 | [diff] [blame] | 113 | print_ftrace_graph_addr(addr, data, ops, task, graph); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 114 | } |
| 115 | stack++; |
| 116 | } |
| 117 | return bp; |
| 118 | } |
Frederic Weisbecker | 06d65bd | 2009-12-17 05:40:34 +0100 | [diff] [blame] | 119 | EXPORT_SYMBOL_GPL(print_context_stack); |
| 120 | |
| 121 | unsigned long |
Linus Torvalds | da01e18 | 2016-06-23 12:20:01 -0700 | [diff] [blame] | 122 | print_context_stack_bp(struct task_struct *task, |
Frederic Weisbecker | 06d65bd | 2009-12-17 05:40:34 +0100 | [diff] [blame] | 123 | unsigned long *stack, unsigned long bp, |
| 124 | const struct stacktrace_ops *ops, void *data, |
| 125 | unsigned long *end, int *graph) |
| 126 | { |
| 127 | struct stack_frame *frame = (struct stack_frame *)bp; |
| 128 | unsigned long *ret_addr = &frame->return_address; |
| 129 | |
Linus Torvalds | da01e18 | 2016-06-23 12:20:01 -0700 | [diff] [blame] | 130 | while (valid_stack_ptr(task, ret_addr, sizeof(*ret_addr), end)) { |
Frederic Weisbecker | 06d65bd | 2009-12-17 05:40:34 +0100 | [diff] [blame] | 131 | unsigned long addr = *ret_addr; |
| 132 | |
Frederic Weisbecker | c2c5d45 | 2009-12-31 03:52:25 +0100 | [diff] [blame] | 133 | if (!__kernel_text_address(addr)) |
| 134 | break; |
| 135 | |
Alexei Starovoitov | 568b329 | 2016-02-17 19:58:57 -0800 | [diff] [blame] | 136 | if (ops->address(data, addr, 1)) |
| 137 | break; |
Frederic Weisbecker | c2c5d45 | 2009-12-31 03:52:25 +0100 | [diff] [blame] | 138 | frame = frame->next_frame; |
| 139 | ret_addr = &frame->return_address; |
Linus Torvalds | da01e18 | 2016-06-23 12:20:01 -0700 | [diff] [blame] | 140 | print_ftrace_graph_addr(addr, data, ops, task, graph); |
Frederic Weisbecker | 06d65bd | 2009-12-17 05:40:34 +0100 | [diff] [blame] | 141 | } |
Frederic Weisbecker | c2c5d45 | 2009-12-31 03:52:25 +0100 | [diff] [blame] | 142 | |
Frederic Weisbecker | 06d65bd | 2009-12-17 05:40:34 +0100 | [diff] [blame] | 143 | return (unsigned long)frame; |
| 144 | } |
| 145 | EXPORT_SYMBOL_GPL(print_context_stack_bp); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 146 | |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 147 | static int print_trace_stack(void *data, char *name) |
| 148 | { |
| 149 | printk("%s <%s> ", (char *)data, name); |
| 150 | return 0; |
| 151 | } |
| 152 | |
| 153 | /* |
| 154 | * Print one address/symbol entries per line. |
| 155 | */ |
Alexei Starovoitov | 568b329 | 2016-02-17 19:58:57 -0800 | [diff] [blame] | 156 | static int print_trace_address(void *data, unsigned long addr, int reliable) |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 157 | { |
| 158 | touch_nmi_watchdog(); |
Adrien Schildknecht | 1fc7f61 | 2015-02-20 03:34:21 +0100 | [diff] [blame] | 159 | printk_stack_address(addr, reliable, data); |
Alexei Starovoitov | 568b329 | 2016-02-17 19:58:57 -0800 | [diff] [blame] | 160 | return 0; |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 161 | } |
| 162 | |
| 163 | static const struct stacktrace_ops print_trace_ops = { |
Frederic Weisbecker | 06d65bd | 2009-12-17 05:40:34 +0100 | [diff] [blame] | 164 | .stack = print_trace_stack, |
| 165 | .address = print_trace_address, |
Frederic Weisbecker | 61c1917 | 2009-12-17 05:40:33 +0100 | [diff] [blame] | 166 | .walk_stack = print_context_stack, |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 167 | }; |
| 168 | |
| 169 | void |
| 170 | show_trace_log_lvl(struct task_struct *task, struct pt_regs *regs, |
Namhyung Kim | e8e999cf | 2011-03-18 11:40:06 +0900 | [diff] [blame] | 171 | unsigned long *stack, unsigned long bp, char *log_lvl) |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 172 | { |
| 173 | printk("%sCall Trace:\n", log_lvl); |
Namhyung Kim | e8e999cf | 2011-03-18 11:40:06 +0900 | [diff] [blame] | 174 | dump_trace(task, regs, stack, bp, &print_trace_ops, log_lvl); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 175 | } |
| 176 | |
| 177 | void show_trace(struct task_struct *task, struct pt_regs *regs, |
Namhyung Kim | e8e999cf | 2011-03-18 11:40:06 +0900 | [diff] [blame] | 178 | unsigned long *stack, unsigned long bp) |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 179 | { |
Namhyung Kim | e8e999cf | 2011-03-18 11:40:06 +0900 | [diff] [blame] | 180 | show_trace_log_lvl(task, regs, stack, bp, ""); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 181 | } |
| 182 | |
| 183 | void show_stack(struct task_struct *task, unsigned long *sp) |
| 184 | { |
Tejun Heo | a77f2a4 | 2013-04-30 15:27:09 -0700 | [diff] [blame] | 185 | unsigned long bp = 0; |
| 186 | unsigned long stack; |
| 187 | |
| 188 | /* |
| 189 | * Stack frames below this one aren't interesting. Don't show them |
| 190 | * if we're printing for %current. |
| 191 | */ |
| 192 | if (!sp && (!task || task == current)) { |
| 193 | sp = &stack; |
| 194 | bp = stack_frame(current, NULL); |
| 195 | } |
| 196 | |
| 197 | show_stack_log_lvl(task, NULL, sp, bp, ""); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 198 | } |
| 199 | |
Borislav Petkov | 81c2949 | 2016-07-05 00:31:27 +0200 | [diff] [blame^] | 200 | void show_stack_regs(struct pt_regs *regs) |
| 201 | { |
| 202 | show_stack_log_lvl(current, regs, (unsigned long *)regs->sp, regs->bp, ""); |
| 203 | } |
| 204 | |
Thomas Gleixner | edc35bd | 2009-12-03 12:38:57 +0100 | [diff] [blame] | 205 | static arch_spinlock_t die_lock = __ARCH_SPIN_LOCK_UNLOCKED; |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 206 | static int die_owner = -1; |
| 207 | static unsigned int die_nest_count; |
| 208 | |
Masami Hiramatsu | 9326638 | 2014-04-17 17:18:14 +0900 | [diff] [blame] | 209 | unsigned long oops_begin(void) |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 210 | { |
| 211 | int cpu; |
| 212 | unsigned long flags; |
| 213 | |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 214 | oops_enter(); |
| 215 | |
| 216 | /* racy, but better than risking deadlock. */ |
| 217 | raw_local_irq_save(flags); |
| 218 | cpu = smp_processor_id(); |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 219 | if (!arch_spin_trylock(&die_lock)) { |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 220 | if (cpu == die_owner) |
| 221 | /* nested oops. should stop eventually */; |
| 222 | else |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 223 | arch_spin_lock(&die_lock); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 224 | } |
| 225 | die_nest_count++; |
| 226 | die_owner = cpu; |
| 227 | console_verbose(); |
| 228 | bust_spinlocks(1); |
| 229 | return flags; |
| 230 | } |
Huang Ying | 81e88fd | 2011-01-12 14:44:55 +0800 | [diff] [blame] | 231 | EXPORT_SYMBOL_GPL(oops_begin); |
Masami Hiramatsu | 9326638 | 2014-04-17 17:18:14 +0900 | [diff] [blame] | 232 | NOKPROBE_SYMBOL(oops_begin); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 233 | |
Masami Hiramatsu | 9326638 | 2014-04-17 17:18:14 +0900 | [diff] [blame] | 234 | void oops_end(unsigned long flags, struct pt_regs *regs, int signr) |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 235 | { |
| 236 | if (regs && kexec_should_crash(current)) |
| 237 | crash_kexec(regs); |
| 238 | |
| 239 | bust_spinlocks(0); |
| 240 | die_owner = -1; |
Rusty Russell | 373d4d0 | 2013-01-21 17:17:39 +1030 | [diff] [blame] | 241 | add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 242 | die_nest_count--; |
| 243 | if (!die_nest_count) |
| 244 | /* Nest count reaches zero, release the lock. */ |
Thomas Gleixner | 0199c4e | 2009-12-02 20:01:25 +0100 | [diff] [blame] | 245 | arch_spin_unlock(&die_lock); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 246 | raw_local_irq_restore(flags); |
| 247 | oops_exit(); |
| 248 | |
| 249 | if (!signr) |
| 250 | return; |
| 251 | if (in_interrupt()) |
| 252 | panic("Fatal exception in interrupt"); |
| 253 | if (panic_on_oops) |
| 254 | panic("Fatal exception"); |
| 255 | do_exit(signr); |
| 256 | } |
Masami Hiramatsu | 9326638 | 2014-04-17 17:18:14 +0900 | [diff] [blame] | 257 | NOKPROBE_SYMBOL(oops_end); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 258 | |
Masami Hiramatsu | 9326638 | 2014-04-17 17:18:14 +0900 | [diff] [blame] | 259 | int __die(const char *str, struct pt_regs *regs, long err) |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 260 | { |
| 261 | #ifdef CONFIG_X86_32 |
| 262 | unsigned short ss; |
| 263 | unsigned long sp; |
| 264 | #endif |
Prarit Bhargava | b0f4c4b | 2012-01-26 08:55:34 -0500 | [diff] [blame] | 265 | printk(KERN_DEFAULT |
Rasmus Villemoes | 8fad7ec | 2016-03-26 21:40:16 +0100 | [diff] [blame] | 266 | "%s: %04lx [#%d]%s%s%s%s\n", str, err & 0xffff, ++die_counter, |
| 267 | IS_ENABLED(CONFIG_PREEMPT) ? " PREEMPT" : "", |
| 268 | IS_ENABLED(CONFIG_SMP) ? " SMP" : "", |
| 269 | debug_pagealloc_enabled() ? " DEBUG_PAGEALLOC" : "", |
| 270 | IS_ENABLED(CONFIG_KASAN) ? " KASAN" : ""); |
| 271 | |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 272 | if (notify_die(DIE_OOPS, str, regs, err, |
Srikar Dronamraju | 51e7dc7 | 2012-03-12 14:55:55 +0530 | [diff] [blame] | 273 | current->thread.trap_nr, SIGSEGV) == NOTIFY_STOP) |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 274 | return 1; |
| 275 | |
Jan Beulich | 0fa0e2f | 2012-06-18 11:40:04 +0100 | [diff] [blame] | 276 | print_modules(); |
Jan Beulich | 57da8b9 | 2012-05-09 08:47:37 +0100 | [diff] [blame] | 277 | show_regs(regs); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 278 | #ifdef CONFIG_X86_32 |
Andy Lutomirski | f39b6f0 | 2015-03-18 18:33:33 -0700 | [diff] [blame] | 279 | if (user_mode(regs)) { |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 280 | sp = regs->sp; |
| 281 | ss = regs->ss & 0xffff; |
H. Peter Anvin | a343c75 | 2009-10-12 14:11:09 -0700 | [diff] [blame] | 282 | } else { |
| 283 | sp = kernel_stack_pointer(regs); |
| 284 | savesegment(ss, ss); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 285 | } |
| 286 | printk(KERN_EMERG "EIP: [<%08lx>] ", regs->ip); |
| 287 | print_symbol("%s", regs->ip); |
| 288 | printk(" SS:ESP %04x:%08lx\n", ss, sp); |
| 289 | #else |
| 290 | /* Executive summary in case the oops scrolled away */ |
| 291 | printk(KERN_ALERT "RIP "); |
Jiri Slaby | 5f01c98 | 2013-10-25 15:06:58 +0200 | [diff] [blame] | 292 | printk_address(regs->ip); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 293 | printk(" RSP <%016lx>\n", regs->sp); |
| 294 | #endif |
| 295 | return 0; |
| 296 | } |
Masami Hiramatsu | 9326638 | 2014-04-17 17:18:14 +0900 | [diff] [blame] | 297 | NOKPROBE_SYMBOL(__die); |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 298 | |
| 299 | /* |
| 300 | * This is gone through when something in the kernel has done something bad |
| 301 | * and is about to be terminated: |
| 302 | */ |
| 303 | void die(const char *str, struct pt_regs *regs, long err) |
| 304 | { |
| 305 | unsigned long flags = oops_begin(); |
| 306 | int sig = SIGSEGV; |
| 307 | |
Andy Lutomirski | f39b6f0 | 2015-03-18 18:33:33 -0700 | [diff] [blame] | 308 | if (!user_mode(regs)) |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 309 | report_bug(regs->ip, regs); |
| 310 | |
| 311 | if (__die(str, regs, err)) |
| 312 | sig = 0; |
| 313 | oops_end(flags, regs, sig); |
| 314 | } |
| 315 | |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 316 | static int __init kstack_setup(char *s) |
| 317 | { |
Shuah Khan | 363f7ce | 2012-05-06 11:58:04 -0600 | [diff] [blame] | 318 | ssize_t ret; |
| 319 | unsigned long val; |
| 320 | |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 321 | if (!s) |
| 322 | return -EINVAL; |
Shuah Khan | 363f7ce | 2012-05-06 11:58:04 -0600 | [diff] [blame] | 323 | |
| 324 | ret = kstrtoul(s, 0, &val); |
| 325 | if (ret) |
| 326 | return ret; |
| 327 | kstack_depth_to_print = val; |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 328 | return 0; |
| 329 | } |
| 330 | early_param("kstack", kstack_setup); |
| 331 | |
| 332 | static int __init code_bytes_setup(char *s) |
| 333 | { |
Shuah Khan | 363f7ce | 2012-05-06 11:58:04 -0600 | [diff] [blame] | 334 | ssize_t ret; |
| 335 | unsigned long val; |
| 336 | |
| 337 | if (!s) |
| 338 | return -EINVAL; |
| 339 | |
| 340 | ret = kstrtoul(s, 0, &val); |
| 341 | if (ret) |
| 342 | return ret; |
| 343 | |
| 344 | code_bytes = val; |
Neil Horman | 878719e | 2008-10-23 10:40:06 -0400 | [diff] [blame] | 345 | if (code_bytes > 8192) |
| 346 | code_bytes = 8192; |
| 347 | |
| 348 | return 1; |
| 349 | } |
| 350 | __setup("code_bytes=", code_bytes_setup); |