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