1 /* 2 * kernel/stacktrace.c 3 * 4 * Stack trace management functions 5 * 6 * Copyright (C) 2006 Red Hat, Inc., Ingo Molnar <[email protected]> 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 /** 258 * stack_trace_save - Save a stack trace into a storage array 259 * @store: Pointer to storage array 260 * @size: Size of the storage array 261 * @skipnr: Number of entries to skip at the start of the stack trace 262 * 263 * Return: Number of trace entries stored 264 */ 265 unsigned int stack_trace_save(unsigned long *store, unsigned int size, 266 unsigned int skipnr) 267 { 268 struct stack_trace trace = { 269 .entries = store, 270 .max_entries = size, 271 .skip = skipnr + 1, 272 }; 273 274 save_stack_trace(&trace); 275 return trace.nr_entries; 276 } 277 EXPORT_SYMBOL_GPL(stack_trace_save); 278 279 /** 280 * stack_trace_save_tsk - Save a task stack trace into a storage array 281 * @task: The task to examine 282 * @store: Pointer to storage array 283 * @size: Size of the storage array 284 * @skipnr: Number of entries to skip at the start of the stack trace 285 * 286 * Return: Number of trace entries stored 287 */ 288 unsigned int stack_trace_save_tsk(struct task_struct *task, 289 unsigned long *store, unsigned int size, 290 unsigned int skipnr) 291 { 292 struct stack_trace trace = { 293 .entries = store, 294 .max_entries = size, 295 .skip = skipnr + 1, 296 }; 297 298 save_stack_trace_tsk(task, &trace); 299 return trace.nr_entries; 300 } 301 302 /** 303 * stack_trace_save_regs - Save a stack trace based on pt_regs into a storage array 304 * @regs: Pointer to pt_regs to examine 305 * @store: Pointer to storage array 306 * @size: Size of the storage array 307 * @skipnr: Number of entries to skip at the start of the stack trace 308 * 309 * Return: Number of trace entries stored 310 */ 311 unsigned int stack_trace_save_regs(struct pt_regs *regs, unsigned long *store, 312 unsigned int size, unsigned int skipnr) 313 { 314 struct stack_trace trace = { 315 .entries = store, 316 .max_entries = size, 317 .skip = skipnr, 318 }; 319 320 save_stack_trace_regs(regs, &trace); 321 return trace.nr_entries; 322 } 323 324 #ifdef CONFIG_HAVE_RELIABLE_STACKTRACE 325 /** 326 * stack_trace_save_tsk_reliable - Save task stack with verification 327 * @tsk: Pointer to the task to examine 328 * @store: Pointer to storage array 329 * @size: Size of the storage array 330 * 331 * Return: An error if it detects any unreliable features of the 332 * stack. Otherwise it guarantees that the stack trace is 333 * reliable and returns the number of entries stored. 334 * 335 * If the task is not 'current', the caller *must* ensure the task is inactive. 336 */ 337 int stack_trace_save_tsk_reliable(struct task_struct *tsk, unsigned long *store, 338 unsigned int size) 339 { 340 struct stack_trace trace = { 341 .entries = store, 342 .max_entries = size, 343 }; 344 int ret = save_stack_trace_tsk_reliable(tsk, &trace); 345 346 return ret ? ret : trace.nr_entries; 347 } 348 #endif 349 350 #ifdef CONFIG_USER_STACKTRACE_SUPPORT 351 /** 352 * stack_trace_save_user - Save a user space stack trace into a storage array 353 * @store: Pointer to storage array 354 * @size: Size of the storage array 355 * 356 * Return: Number of trace entries stored 357 */ 358 unsigned int stack_trace_save_user(unsigned long *store, unsigned int size) 359 { 360 struct stack_trace trace = { 361 .entries = store, 362 .max_entries = size, 363 }; 364 365 save_stack_trace_user(&trace); 366 return trace.nr_entries; 367 } 368 #endif /* CONFIG_USER_STACKTRACE_SUPPORT */ 369 370 #endif /* !CONFIG_ARCH_STACKWALK */ 371