arch/s390/kernel/stacktrace.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Stack trace management functions
   4  *
   5  *  Copyright IBM Corp. 2006
   6  */
   7
   8 #include <linux/stacktrace.h>
   9 #include <linux/uaccess.h>
  10 #include <linux/compat.h>
  11 #include <asm/stacktrace.h>
  12 #include <asm/unwind.h>
  13 #include <asm/kprobes.h>
  14 #include <asm/ptrace.h>
  15
  16 void arch_stack_walk(stack_trace_consume_fn consume_entry, void *cookie,
  17                      struct task_struct *task, struct pt_regs *regs)
  18 {
  19         struct unwind_state state;
  20         unsigned long addr;
  21
  22         unwind_for_each_frame(&state, task, regs, 0) {
  23                 addr = unwind_get_return_address(&state);
  24                 if (!addr || !consume_entry(cookie, addr))
  25                         break;
  26         }
  27 }
  28
  29 int arch_stack_walk_reliable(stack_trace_consume_fn consume_entry,
  30                              void *cookie, struct task_struct *task)
  31 {
  32         struct unwind_state state;
  33         unsigned long addr;
  34
  35         unwind_for_each_frame(&state, task, NULL, 0) {
  36                 if (state.stack_info.type != STACK_TYPE_TASK)
  37                         return -EINVAL;
  38
  39                 if (state.regs)
  40                         return -EINVAL;
  41
  42                 addr = unwind_get_return_address(&state);
  43                 if (!addr)
  44                         return -EINVAL;
  45
  46 #ifdef CONFIG_RETHOOK
  47                 /*
  48                  * Mark stacktraces with krethook functions on them
  49                  * as unreliable.
  50                  */
  51                 if (state.ip == (unsigned long)arch_rethook_trampoline)
  52                         return -EINVAL;
  53 #endif
  54
  55                 if (!consume_entry(cookie, addr))
  56                         return -EINVAL;
  57         }
  58
  59         /* Check for stack corruption */
  60         if (unwind_error(&state))
  61                 return -EINVAL;
  62         return 0;
  63 }
  64
  65 void arch_stack_walk_user(stack_trace_consume_fn consume_entry, void *cookie,
  66                           const struct pt_regs *regs)
  67 {
  68         struct stack_frame_user __user *sf;
  69         unsigned long ip, sp;
  70         bool first = true;
  71
  72         if (is_compat_task())
  73                 return;
  74         if (!consume_entry(cookie, instruction_pointer(regs)))
  75                 return;
  76         sf = (void __user *)user_stack_pointer(regs);
  77         pagefault_disable();
  78         while (1) {
  79                 if (__get_user(sp, &sf->back_chain))
  80                         break;
  81                 if (__get_user(ip, &sf->gprs[8]))
  82                         break;
  83                 if (ip & 0x1) {
  84                         /*
  85                          * If the instruction address is invalid, and this
  86                          * is the first stack frame, assume r14 has not
  87                          * been written to the stack yet. Otherwise exit.
  88                          */
  89                         if (first && !(regs->gprs[14] & 0x1))
  90                                 ip = regs->gprs[14];
  91                         else
  92                                 break;
  93                 }
  94                 if (!consume_entry(cookie, ip))
  95                         break;
  96                 /* Sanity check: ABI requires SP to be aligned 8 bytes. */
  97                 if (!sp || sp & 0x7)
  98                         break;
  99                 sf = (void __user *)sp;
 100                 first = false;
 101         }
 102         pagefault_enable();
 103 }