1 /* 2 * kernel/stacktrace.c 3 * 4 * Stack trace management functions 5 * 6 * Copyright (C) 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com> 7 */ 8 #include <linux/sched/task_stack.h> 9 #include <linux/sched/debug.h> 10 #include <linux/sched.h> 11 #include <linux/kernel.h> 12 #include <linux/export.h> 13 #include <linux/kallsyms.h> 14 #include <linux/stacktrace.h> 15 16 /** 17 * stack_trace_print - Print the entries in the stack trace 18 * @entries: Pointer to storage array 19 * @nr_entries: Number of entries in the storage array 20 * @spaces: Number of leading spaces to print 21 */ 22 void stack_trace_print(unsigned long *entries, unsigned int nr_entries, 23 int spaces) 24 { 25 unsigned int i; 26 27 if (WARN_ON(!entries)) 28 return; 29 30 for (i = 0; i < nr_entries; i++) 31 printk("%*c%pS\n", 1 + spaces, ' ', (void *)entries[i]); 32 } 33 EXPORT_SYMBOL_GPL(stack_trace_print); 34 35 /** 36 * stack_trace_snprint - Print the entries in the stack trace into a buffer 37 * @buf: Pointer to the print buffer 38 * @size: Size of the print buffer 39 * @entries: Pointer to storage array 40 * @nr_entries: Number of entries in the storage array 41 * @spaces: Number of leading spaces to print 42 * 43 * Return: Number of bytes printed. 44 */ 45 int stack_trace_snprint(char *buf, size_t size, unsigned long *entries, 46 unsigned int nr_entries, int spaces) 47 { 48 unsigned int generated, i, total = 0; 49 50 if (WARN_ON(!entries)) 51 return 0; 52 53 for (i = 0; i < nr_entries && size; i++) { 54 generated = snprintf(buf, size, "%*c%pS\n", 1 + spaces, ' ', 55 (void *)entries[i]); 56 57 total += generated; 58 if (generated >= size) { 59 buf += size; 60 size = 0; 61 } else { 62 buf += generated; 63 size -= generated; 64 } 65 } 66 67 return total; 68 } 69 EXPORT_SYMBOL_GPL(stack_trace_snprint); 70 71 #ifdef CONFIG_ARCH_STACKWALK 72 73 struct stacktrace_cookie { 74 unsigned long *store; 75 unsigned int size; 76 unsigned int skip; 77 unsigned int len; 78 }; 79 80 static bool stack_trace_consume_entry(void *cookie, unsigned long addr, 81 bool reliable) 82 { 83 struct stacktrace_cookie *c = cookie; 84 85 if (c->len >= c->size) 86 return false; 87 88 if (c->skip > 0) { 89 c->skip--; 90 return true; 91 } 92 c->store[c->len++] = addr; 93 return c->len < c->size; 94 } 95 96 static bool stack_trace_consume_entry_nosched(void *cookie, unsigned long addr, 97 bool reliable) 98 { 99 if (in_sched_functions(addr)) 100 return true; 101 return stack_trace_consume_entry(cookie, addr, reliable); 102 } 103 104 /** 105 * stack_trace_save - Save a stack trace into a storage array 106 * @store: Pointer to storage array 107 * @size: Size of the storage array 108 * @skipnr: Number of entries to skip at the start of the stack trace 109 * 110 * Return: Number of trace entries stored. 111 */ 112 unsigned int stack_trace_save(unsigned long *store, unsigned int size, 113 unsigned int skipnr) 114 { 115 stack_trace_consume_fn consume_entry = stack_trace_consume_entry; 116 struct stacktrace_cookie c = { 117 .store = store, 118 .size = size, 119 .skip = skipnr + 1, 120 }; 121 122 arch_stack_walk(consume_entry, &c, current, NULL); 123 return c.len; 124 } 125 EXPORT_SYMBOL_GPL(stack_trace_save); 126 127 /** 128 * stack_trace_save_tsk - Save a task stack trace into a storage array 129 * @task: The task to examine 130 * @store: Pointer to storage array 131 * @size: Size of the storage array 132 * @skipnr: Number of entries to skip at the start of the stack trace 133 * 134 * Return: Number of trace entries stored. 135 */ 136 unsigned int stack_trace_save_tsk(struct task_struct *tsk, unsigned long *store, 137 unsigned int size, unsigned int skipnr) 138 { 139 stack_trace_consume_fn consume_entry = stack_trace_consume_entry_nosched; 140 struct stacktrace_cookie c = { 141 .store = store, 142 .size = size, 143 .skip = skipnr + 1, 144 }; 145 146 if (!try_get_task_stack(tsk)) 147 return 0; 148 149 arch_stack_walk(consume_entry, &c, tsk, NULL); 150 put_task_stack(tsk); 151 return c.len; 152 } 153 154 /** 155 * stack_trace_save_regs - Save a stack trace based on pt_regs into a storage array 156 * @regs: Pointer to pt_regs to examine 157 * @store: Pointer to storage array 158 * @size: Size of the storage array 159 * @skipnr: Number of entries to skip at the start of the stack trace 160 * 161 * Return: Number of trace entries stored. 162 */ 163 unsigned int stack_trace_save_regs(struct pt_regs *regs, unsigned long *store, 164 unsigned int size, unsigned int skipnr) 165 { 166 stack_trace_consume_fn consume_entry = stack_trace_consume_entry; 167 struct stacktrace_cookie c = { 168 .store = store, 169 .size = size, 170 .skip = skipnr, 171 }; 172 173 arch_stack_walk(consume_entry, &c, current, regs); 174 return c.len; 175 } 176 177 #ifdef CONFIG_HAVE_RELIABLE_STACKTRACE 178 /** 179 * stack_trace_save_tsk_reliable - Save task stack with verification 180 * @tsk: Pointer to the task to examine 181 * @store: Pointer to storage array 182 * @size: Size of the storage array 183 * 184 * Return: An error if it detects any unreliable features of the 185 * stack. Otherwise it guarantees that the stack trace is 186 * reliable and returns the number of entries stored. 187 * 188 * If the task is not 'current', the caller *must* ensure the task is inactive. 189 */ 190 int stack_trace_save_tsk_reliable(struct task_struct *tsk, unsigned long *store, 191 unsigned int size) 192 { 193 stack_trace_consume_fn consume_entry = stack_trace_consume_entry; 194 struct stacktrace_cookie c = { 195 .store = store, 196 .size = size, 197 }; 198 int ret; 199 200 /* 201 * If the task doesn't have a stack (e.g., a zombie), the stack is 202 * "reliably" empty. 203 */ 204 if (!try_get_task_stack(tsk)) 205 return 0; 206 207 ret = arch_stack_walk_reliable(consume_entry, &c, tsk); 208 put_task_stack(tsk); 209 return ret; 210 } 211 #endif 212 213 #ifdef CONFIG_USER_STACKTRACE_SUPPORT 214 /** 215 * stack_trace_save_user - Save a user space stack trace into a storage array 216 * @store: Pointer to storage array 217 * @size: Size of the storage array 218 * 219 * Return: Number of trace entries stored. 220 */ 221 unsigned int stack_trace_save_user(unsigned long *store, unsigned int size) 222 { 223 stack_trace_consume_fn consume_entry = stack_trace_consume_entry; 224 struct stacktrace_cookie c = { 225 .store = store, 226 .size = size, 227 }; 228 229 /* Trace user stack if not a kernel thread */ 230 if (!current->mm) 231 return 0; 232 233 arch_stack_walk_user(consume_entry, &c, task_pt_regs(current)); 234 return c.len; 235 } 236 #endif 237 238 #else /* CONFIG_ARCH_STACKWALK */ 239 240 /* 241 * Architectures that do not implement save_stack_trace_*() 242 * get these weak aliases and once-per-bootup warnings 243 * (whenever this facility is utilized - for example by procfs): 244 */ 245 __weak void 246 save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace) 247 { 248 WARN_ONCE(1, KERN_INFO "save_stack_trace_tsk() not implemented yet.\n"); 249 } 250 251 __weak void 252 save_stack_trace_regs(struct pt_regs *regs, struct stack_trace *trace) 253 { 254 WARN_ONCE(1, KERN_INFO "save_stack_trace_regs() not implemented yet.\n"); 255 } 256 257 __weak int 258 save_stack_trace_tsk_reliable(struct task_struct *tsk, 259 struct stack_trace *trace) 260 { 261 WARN_ONCE(1, KERN_INFO "save_stack_tsk_reliable() not implemented yet.\n"); 262 return -ENOSYS; 263 } 264 265 /** 266 * stack_trace_save - Save a stack trace into a storage array 267 * @store: Pointer to storage array 268 * @size: Size of the storage array 269 * @skipnr: Number of entries to skip at the start of the stack trace 270 * 271 * Return: Number of trace entries stored 272 */ 273 unsigned int stack_trace_save(unsigned long *store, unsigned int size, 274 unsigned int skipnr) 275 { 276 struct stack_trace trace = { 277 .entries = store, 278 .max_entries = size, 279 .skip = skipnr + 1, 280 }; 281 282 save_stack_trace(&trace); 283 return trace.nr_entries; 284 } 285 EXPORT_SYMBOL_GPL(stack_trace_save); 286 287 /** 288 * stack_trace_save_tsk - Save a task stack trace into a storage array 289 * @task: The task to examine 290 * @store: Pointer to storage array 291 * @size: Size of the storage array 292 * @skipnr: Number of entries to skip at the start of the stack trace 293 * 294 * Return: Number of trace entries stored 295 */ 296 unsigned int stack_trace_save_tsk(struct task_struct *task, 297 unsigned long *store, unsigned int size, 298 unsigned int skipnr) 299 { 300 struct stack_trace trace = { 301 .entries = store, 302 .max_entries = size, 303 .skip = skipnr + 1, 304 }; 305 306 save_stack_trace_tsk(task, &trace); 307 return trace.nr_entries; 308 } 309 310 /** 311 * stack_trace_save_regs - Save a stack trace based on pt_regs into a storage array 312 * @regs: Pointer to pt_regs to examine 313 * @store: Pointer to storage array 314 * @size: Size of the storage array 315 * @skipnr: Number of entries to skip at the start of the stack trace 316 * 317 * Return: Number of trace entries stored 318 */ 319 unsigned int stack_trace_save_regs(struct pt_regs *regs, unsigned long *store, 320 unsigned int size, unsigned int skipnr) 321 { 322 struct stack_trace trace = { 323 .entries = store, 324 .max_entries = size, 325 .skip = skipnr, 326 }; 327 328 save_stack_trace_regs(regs, &trace); 329 return trace.nr_entries; 330 } 331 332 #ifdef CONFIG_HAVE_RELIABLE_STACKTRACE 333 /** 334 * stack_trace_save_tsk_reliable - Save task stack with verification 335 * @tsk: Pointer to the task to examine 336 * @store: Pointer to storage array 337 * @size: Size of the storage array 338 * 339 * Return: An error if it detects any unreliable features of the 340 * stack. Otherwise it guarantees that the stack trace is 341 * reliable and returns the number of entries stored. 342 * 343 * If the task is not 'current', the caller *must* ensure the task is inactive. 344 */ 345 int stack_trace_save_tsk_reliable(struct task_struct *tsk, unsigned long *store, 346 unsigned int size) 347 { 348 struct stack_trace trace = { 349 .entries = store, 350 .max_entries = size, 351 }; 352 int ret = save_stack_trace_tsk_reliable(tsk, &trace); 353 354 return ret ? ret : trace.nr_entries; 355 } 356 #endif 357 358 #ifdef CONFIG_USER_STACKTRACE_SUPPORT 359 /** 360 * stack_trace_save_user - Save a user space stack trace into a storage array 361 * @store: Pointer to storage array 362 * @size: Size of the storage array 363 * 364 * Return: Number of trace entries stored 365 */ 366 unsigned int stack_trace_save_user(unsigned long *store, unsigned int size) 367 { 368 struct stack_trace trace = { 369 .entries = store, 370 .max_entries = size, 371 }; 372 373 save_stack_trace_user(&trace); 374 return trace.nr_entries; 375 } 376 #endif /* CONFIG_USER_STACKTRACE_SUPPORT */ 377 378 #endif /* !CONFIG_ARCH_STACKWALK */ 379