stacktrace.c 3.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (C) 2008 ARM Limited
  4. * Copyright (C) 2014 Regents of the University of California
  5. */
  6. #include <linux/export.h>
  7. #include <linux/kallsyms.h>
  8. #include <linux/sched.h>
  9. #include <linux/sched/debug.h>
  10. #include <linux/sched/task_stack.h>
  11. #include <linux/stacktrace.h>
  12. #include <linux/ftrace.h>
  13. register unsigned long sp_in_global __asm__("sp");
  14. #ifdef CONFIG_FRAME_POINTER
  15. struct stackframe {
  16. unsigned long fp;
  17. unsigned long ra;
  18. };
  19. void notrace walk_stackframe(struct task_struct *task, struct pt_regs *regs,
  20. bool (*fn)(unsigned long, void *), void *arg)
  21. {
  22. unsigned long fp, sp, pc;
  23. if (regs) {
  24. fp = frame_pointer(regs);
  25. sp = user_stack_pointer(regs);
  26. pc = instruction_pointer(regs);
  27. } else if (task == NULL || task == current) {
  28. const register unsigned long current_sp = sp_in_global;
  29. fp = (unsigned long)__builtin_frame_address(0);
  30. sp = current_sp;
  31. pc = (unsigned long)walk_stackframe;
  32. } else {
  33. /* task blocked in __switch_to */
  34. fp = task->thread.s[0];
  35. sp = task->thread.sp;
  36. pc = task->thread.ra;
  37. }
  38. for (;;) {
  39. unsigned long low, high;
  40. struct stackframe *frame;
  41. if (unlikely(!__kernel_text_address(pc) || fn(pc, arg)))
  42. break;
  43. /* Validate frame pointer */
  44. low = sp + sizeof(struct stackframe);
  45. high = ALIGN(sp, THREAD_SIZE);
  46. if (unlikely(fp < low || fp > high || fp & 0x7))
  47. break;
  48. /* Unwind stack frame */
  49. frame = (struct stackframe *)fp - 1;
  50. sp = fp;
  51. fp = frame->fp;
  52. pc = ftrace_graph_ret_addr(current, NULL, frame->ra,
  53. (unsigned long *)(fp - 8));
  54. }
  55. }
  56. #else /* !CONFIG_FRAME_POINTER */
  57. void notrace walk_stackframe(struct task_struct *task,
  58. struct pt_regs *regs, bool (*fn)(unsigned long, void *), void *arg)
  59. {
  60. unsigned long sp, pc;
  61. unsigned long *ksp;
  62. if (regs) {
  63. sp = user_stack_pointer(regs);
  64. pc = instruction_pointer(regs);
  65. } else if (task == NULL || task == current) {
  66. sp = sp_in_global;
  67. pc = (unsigned long)walk_stackframe;
  68. } else {
  69. /* task blocked in __switch_to */
  70. sp = task->thread.sp;
  71. pc = task->thread.ra;
  72. }
  73. if (unlikely(sp & 0x7))
  74. return;
  75. ksp = (unsigned long *)sp;
  76. while (!kstack_end(ksp)) {
  77. if (__kernel_text_address(pc) && unlikely(fn(pc, arg)))
  78. break;
  79. pc = (*ksp++) - 0x4;
  80. }
  81. }
  82. #endif /* CONFIG_FRAME_POINTER */
  83. static bool print_trace_address(unsigned long pc, void *arg)
  84. {
  85. const char *loglvl = arg;
  86. print_ip_sym(loglvl, pc);
  87. return false;
  88. }
  89. void show_stack(struct task_struct *task, unsigned long *sp, const char *loglvl)
  90. {
  91. pr_cont("Call Trace:\n");
  92. walk_stackframe(task, NULL, print_trace_address, (void *)loglvl);
  93. }
  94. static bool save_wchan(unsigned long pc, void *arg)
  95. {
  96. if (!in_sched_functions(pc)) {
  97. unsigned long *p = arg;
  98. *p = pc;
  99. return true;
  100. }
  101. return false;
  102. }
  103. unsigned long get_wchan(struct task_struct *task)
  104. {
  105. unsigned long pc = 0;
  106. if (likely(task && task != current && task->state != TASK_RUNNING))
  107. walk_stackframe(task, NULL, save_wchan, &pc);
  108. return pc;
  109. }
  110. #ifdef CONFIG_STACKTRACE
  111. static bool __save_trace(unsigned long pc, void *arg, bool nosched)
  112. {
  113. struct stack_trace *trace = arg;
  114. if (unlikely(nosched && in_sched_functions(pc)))
  115. return false;
  116. if (unlikely(trace->skip > 0)) {
  117. trace->skip--;
  118. return false;
  119. }
  120. trace->entries[trace->nr_entries++] = pc;
  121. return (trace->nr_entries >= trace->max_entries);
  122. }
  123. static bool save_trace(unsigned long pc, void *arg)
  124. {
  125. return __save_trace(pc, arg, false);
  126. }
  127. /*
  128. * Save stack-backtrace addresses into a stack_trace buffer.
  129. */
  130. void save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace)
  131. {
  132. walk_stackframe(tsk, NULL, save_trace, trace);
  133. }
  134. EXPORT_SYMBOL_GPL(save_stack_trace_tsk);
  135. void save_stack_trace(struct stack_trace *trace)
  136. {
  137. save_stack_trace_tsk(NULL, trace);
  138. }
  139. EXPORT_SYMBOL_GPL(save_stack_trace);
  140. #endif /* CONFIG_STACKTRACE */