kernel/stacktrace.c

   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 */