trace_stack.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (C) 2008 Steven Rostedt <srostedt@redhat.com>
  4. *
  5. */
  6. #include <linux/sched/task_stack.h>
  7. #include <linux/stacktrace.h>
  8. #include <linux/kallsyms.h>
  9. #include <linux/seq_file.h>
  10. #include <linux/spinlock.h>
  11. #include <linux/uaccess.h>
  12. #include <linux/ftrace.h>
  13. #include <linux/module.h>
  14. #include <linux/sysctl.h>
  15. #include <linux/init.h>
  16. #include <asm/setup.h>
  17. #include "trace.h"
  18. static unsigned long stack_dump_trace[STACK_TRACE_ENTRIES+1] =
  19. { [0 ... (STACK_TRACE_ENTRIES)] = ULONG_MAX };
  20. unsigned stack_trace_index[STACK_TRACE_ENTRIES];
  21. /*
  22. * Reserve one entry for the passed in ip. This will allow
  23. * us to remove most or all of the stack size overhead
  24. * added by the stack tracer itself.
  25. */
  26. struct stack_trace stack_trace_max = {
  27. .max_entries = STACK_TRACE_ENTRIES - 1,
  28. .entries = &stack_dump_trace[0],
  29. };
  30. unsigned long stack_trace_max_size;
  31. arch_spinlock_t stack_trace_max_lock =
  32. (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
  33. DEFINE_PER_CPU(int, disable_stack_tracer);
  34. static DEFINE_MUTEX(stack_sysctl_mutex);
  35. int stack_tracer_enabled;
  36. static int last_stack_tracer_enabled;
  37. void stack_trace_print(void)
  38. {
  39. long i;
  40. int size;
  41. pr_emerg(" Depth Size Location (%d entries)\n"
  42. " ----- ---- --------\n",
  43. stack_trace_max.nr_entries);
  44. for (i = 0; i < stack_trace_max.nr_entries; i++) {
  45. if (stack_dump_trace[i] == ULONG_MAX)
  46. break;
  47. if (i+1 == stack_trace_max.nr_entries ||
  48. stack_dump_trace[i+1] == ULONG_MAX)
  49. size = stack_trace_index[i];
  50. else
  51. size = stack_trace_index[i] - stack_trace_index[i+1];
  52. pr_emerg("%3ld) %8d %5d %pS\n", i, stack_trace_index[i],
  53. size, (void *)stack_dump_trace[i]);
  54. }
  55. }
  56. /*
  57. * When arch-specific code overrides this function, the following
  58. * data should be filled up, assuming stack_trace_max_lock is held to
  59. * prevent concurrent updates.
  60. * stack_trace_index[]
  61. * stack_trace_max
  62. * stack_trace_max_size
  63. */
  64. void __weak
  65. check_stack(unsigned long ip, unsigned long *stack)
  66. {
  67. unsigned long this_size, flags; unsigned long *p, *top, *start;
  68. static int tracer_frame;
  69. int frame_size = READ_ONCE(tracer_frame);
  70. int i, x;
  71. this_size = ((unsigned long)stack) & (THREAD_SIZE-1);
  72. this_size = THREAD_SIZE - this_size;
  73. /* Remove the frame of the tracer */
  74. this_size -= frame_size;
  75. if (this_size <= stack_trace_max_size)
  76. return;
  77. /* we do not handle interrupt stacks yet */
  78. if (!object_is_on_stack(stack))
  79. return;
  80. /* Can't do this from NMI context (can cause deadlocks) */
  81. if (in_nmi())
  82. return;
  83. local_irq_save(flags);
  84. arch_spin_lock(&stack_trace_max_lock);
  85. /* In case another CPU set the tracer_frame on us */
  86. if (unlikely(!frame_size))
  87. this_size -= tracer_frame;
  88. /* a race could have already updated it */
  89. if (this_size <= stack_trace_max_size)
  90. goto out;
  91. stack_trace_max_size = this_size;
  92. stack_trace_max.nr_entries = 0;
  93. stack_trace_max.skip = 3;
  94. save_stack_trace(&stack_trace_max);
  95. /* Skip over the overhead of the stack tracer itself */
  96. for (i = 0; i < stack_trace_max.nr_entries; i++) {
  97. if (stack_dump_trace[i] == ip)
  98. break;
  99. }
  100. /*
  101. * Some archs may not have the passed in ip in the dump.
  102. * If that happens, we need to show everything.
  103. */
  104. if (i == stack_trace_max.nr_entries)
  105. i = 0;
  106. /*
  107. * Now find where in the stack these are.
  108. */
  109. x = 0;
  110. start = stack;
  111. top = (unsigned long *)
  112. (((unsigned long)start & ~(THREAD_SIZE-1)) + THREAD_SIZE);
  113. /*
  114. * Loop through all the entries. One of the entries may
  115. * for some reason be missed on the stack, so we may
  116. * have to account for them. If they are all there, this
  117. * loop will only happen once. This code only takes place
  118. * on a new max, so it is far from a fast path.
  119. */
  120. while (i < stack_trace_max.nr_entries) {
  121. int found = 0;
  122. stack_trace_index[x] = this_size;
  123. p = start;
  124. for (; p < top && i < stack_trace_max.nr_entries; p++) {
  125. if (stack_dump_trace[i] == ULONG_MAX)
  126. break;
  127. /*
  128. * The READ_ONCE_NOCHECK is used to let KASAN know that
  129. * this is not a stack-out-of-bounds error.
  130. */
  131. if ((READ_ONCE_NOCHECK(*p)) == stack_dump_trace[i]) {
  132. stack_dump_trace[x] = stack_dump_trace[i++];
  133. this_size = stack_trace_index[x++] =
  134. (top - p) * sizeof(unsigned long);
  135. found = 1;
  136. /* Start the search from here */
  137. start = p + 1;
  138. /*
  139. * We do not want to show the overhead
  140. * of the stack tracer stack in the
  141. * max stack. If we haven't figured
  142. * out what that is, then figure it out
  143. * now.
  144. */
  145. if (unlikely(!tracer_frame)) {
  146. tracer_frame = (p - stack) *
  147. sizeof(unsigned long);
  148. stack_trace_max_size -= tracer_frame;
  149. }
  150. }
  151. }
  152. if (!found)
  153. i++;
  154. }
  155. stack_trace_max.nr_entries = x;
  156. for (; x < i; x++)
  157. stack_dump_trace[x] = ULONG_MAX;
  158. if (task_stack_end_corrupted(current)) {
  159. stack_trace_print();
  160. BUG();
  161. }
  162. out:
  163. arch_spin_unlock(&stack_trace_max_lock);
  164. local_irq_restore(flags);
  165. }
  166. static void
  167. stack_trace_call(unsigned long ip, unsigned long parent_ip,
  168. struct ftrace_ops *op, struct pt_regs *pt_regs)
  169. {
  170. unsigned long stack;
  171. preempt_disable_notrace();
  172. /* no atomic needed, we only modify this variable by this cpu */
  173. __this_cpu_inc(disable_stack_tracer);
  174. if (__this_cpu_read(disable_stack_tracer) != 1)
  175. goto out;
  176. ip += MCOUNT_INSN_SIZE;
  177. check_stack(ip, &stack);
  178. out:
  179. __this_cpu_dec(disable_stack_tracer);
  180. /* prevent recursion in schedule */
  181. preempt_enable_notrace();
  182. }
  183. static struct ftrace_ops trace_ops __read_mostly =
  184. {
  185. .func = stack_trace_call,
  186. .flags = FTRACE_OPS_FL_RECURSION_SAFE,
  187. };
  188. static ssize_t
  189. stack_max_size_read(struct file *filp, char __user *ubuf,
  190. size_t count, loff_t *ppos)
  191. {
  192. unsigned long *ptr = filp->private_data;
  193. char buf[64];
  194. int r;
  195. r = snprintf(buf, sizeof(buf), "%ld\n", *ptr);
  196. if (r > sizeof(buf))
  197. r = sizeof(buf);
  198. return simple_read_from_buffer(ubuf, count, ppos, buf, r);
  199. }
  200. static ssize_t
  201. stack_max_size_write(struct file *filp, const char __user *ubuf,
  202. size_t count, loff_t *ppos)
  203. {
  204. long *ptr = filp->private_data;
  205. unsigned long val, flags;
  206. int ret;
  207. ret = kstrtoul_from_user(ubuf, count, 10, &val);
  208. if (ret)
  209. return ret;
  210. local_irq_save(flags);
  211. /*
  212. * In case we trace inside arch_spin_lock() or after (NMI),
  213. * we will cause circular lock, so we also need to increase
  214. * the percpu disable_stack_tracer here.
  215. */
  216. __this_cpu_inc(disable_stack_tracer);
  217. arch_spin_lock(&stack_trace_max_lock);
  218. *ptr = val;
  219. arch_spin_unlock(&stack_trace_max_lock);
  220. __this_cpu_dec(disable_stack_tracer);
  221. local_irq_restore(flags);
  222. return count;
  223. }
  224. static const struct file_operations stack_max_size_fops = {
  225. .open = tracing_open_generic,
  226. .read = stack_max_size_read,
  227. .write = stack_max_size_write,
  228. .llseek = default_llseek,
  229. };
  230. static void *
  231. __next(struct seq_file *m, loff_t *pos)
  232. {
  233. long n = *pos - 1;
  234. if (n > stack_trace_max.nr_entries || stack_dump_trace[n] == ULONG_MAX)
  235. return NULL;
  236. m->private = (void *)n;
  237. return &m->private;
  238. }
  239. static void *
  240. t_next(struct seq_file *m, void *v, loff_t *pos)
  241. {
  242. (*pos)++;
  243. return __next(m, pos);
  244. }
  245. static void *t_start(struct seq_file *m, loff_t *pos)
  246. {
  247. local_irq_disable();
  248. __this_cpu_inc(disable_stack_tracer);
  249. arch_spin_lock(&stack_trace_max_lock);
  250. if (*pos == 0)
  251. return SEQ_START_TOKEN;
  252. return __next(m, pos);
  253. }
  254. static void t_stop(struct seq_file *m, void *p)
  255. {
  256. arch_spin_unlock(&stack_trace_max_lock);
  257. __this_cpu_dec(disable_stack_tracer);
  258. local_irq_enable();
  259. }
  260. static void trace_lookup_stack(struct seq_file *m, long i)
  261. {
  262. unsigned long addr = stack_dump_trace[i];
  263. seq_printf(m, "%pS\n", (void *)addr);
  264. }
  265. static void print_disabled(struct seq_file *m)
  266. {
  267. seq_puts(m, "#\n"
  268. "# Stack tracer disabled\n"
  269. "#\n"
  270. "# To enable the stack tracer, either add 'stacktrace' to the\n"
  271. "# kernel command line\n"
  272. "# or 'echo 1 > /proc/sys/kernel/stack_tracer_enabled'\n"
  273. "#\n");
  274. }
  275. static int t_show(struct seq_file *m, void *v)
  276. {
  277. long i;
  278. int size;
  279. if (v == SEQ_START_TOKEN) {
  280. seq_printf(m, " Depth Size Location"
  281. " (%d entries)\n"
  282. " ----- ---- --------\n",
  283. stack_trace_max.nr_entries);
  284. if (!stack_tracer_enabled && !stack_trace_max_size)
  285. print_disabled(m);
  286. return 0;
  287. }
  288. i = *(long *)v;
  289. if (i >= stack_trace_max.nr_entries ||
  290. stack_dump_trace[i] == ULONG_MAX)
  291. return 0;
  292. if (i+1 == stack_trace_max.nr_entries ||
  293. stack_dump_trace[i+1] == ULONG_MAX)
  294. size = stack_trace_index[i];
  295. else
  296. size = stack_trace_index[i] - stack_trace_index[i+1];
  297. seq_printf(m, "%3ld) %8d %5d ", i, stack_trace_index[i], size);
  298. trace_lookup_stack(m, i);
  299. return 0;
  300. }
  301. static const struct seq_operations stack_trace_seq_ops = {
  302. .start = t_start,
  303. .next = t_next,
  304. .stop = t_stop,
  305. .show = t_show,
  306. };
  307. static int stack_trace_open(struct inode *inode, struct file *file)
  308. {
  309. return seq_open(file, &stack_trace_seq_ops);
  310. }
  311. static const struct file_operations stack_trace_fops = {
  312. .open = stack_trace_open,
  313. .read = seq_read,
  314. .llseek = seq_lseek,
  315. .release = seq_release,
  316. };
  317. #ifdef CONFIG_DYNAMIC_FTRACE
  318. static int
  319. stack_trace_filter_open(struct inode *inode, struct file *file)
  320. {
  321. struct ftrace_ops *ops = inode->i_private;
  322. return ftrace_regex_open(ops, FTRACE_ITER_FILTER,
  323. inode, file);
  324. }
  325. static const struct file_operations stack_trace_filter_fops = {
  326. .open = stack_trace_filter_open,
  327. .read = seq_read,
  328. .write = ftrace_filter_write,
  329. .llseek = tracing_lseek,
  330. .release = ftrace_regex_release,
  331. };
  332. #endif /* CONFIG_DYNAMIC_FTRACE */
  333. int
  334. stack_trace_sysctl(struct ctl_table *table, int write,
  335. void __user *buffer, size_t *lenp,
  336. loff_t *ppos)
  337. {
  338. int ret;
  339. mutex_lock(&stack_sysctl_mutex);
  340. ret = proc_dointvec(table, write, buffer, lenp, ppos);
  341. if (ret || !write ||
  342. (last_stack_tracer_enabled == !!stack_tracer_enabled))
  343. goto out;
  344. last_stack_tracer_enabled = !!stack_tracer_enabled;
  345. if (stack_tracer_enabled)
  346. register_ftrace_function(&trace_ops);
  347. else
  348. unregister_ftrace_function(&trace_ops);
  349. out:
  350. mutex_unlock(&stack_sysctl_mutex);
  351. return ret;
  352. }
  353. static char stack_trace_filter_buf[COMMAND_LINE_SIZE+1] __initdata;
  354. static __init int enable_stacktrace(char *str)
  355. {
  356. if (strncmp(str, "_filter=", 8) == 0)
  357. strncpy(stack_trace_filter_buf, str+8, COMMAND_LINE_SIZE);
  358. stack_tracer_enabled = 1;
  359. last_stack_tracer_enabled = 1;
  360. return 1;
  361. }
  362. __setup("stacktrace", enable_stacktrace);
  363. static __init int stack_trace_init(void)
  364. {
  365. struct dentry *d_tracer;
  366. d_tracer = tracing_init_dentry();
  367. if (IS_ERR(d_tracer))
  368. return 0;
  369. trace_create_file("stack_max_size", 0644, d_tracer,
  370. &stack_trace_max_size, &stack_max_size_fops);
  371. trace_create_file("stack_trace", 0444, d_tracer,
  372. NULL, &stack_trace_fops);
  373. #ifdef CONFIG_DYNAMIC_FTRACE
  374. trace_create_file("stack_trace_filter", 0444, d_tracer,
  375. &trace_ops, &stack_trace_filter_fops);
  376. #endif
  377. if (stack_trace_filter_buf[0])
  378. ftrace_set_early_filter(&trace_ops, stack_trace_filter_buf, 1);
  379. if (stack_tracer_enabled)
  380. register_ftrace_function(&trace_ops);
  381. return 0;
  382. }
  383. device_initcall(stack_trace_init);