arch/arm64/kvm/hyp/nvhe/stacktrace.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * KVM nVHE hypervisor stack tracing support.
   4  *
   5  * Copyright (C) 2022 Google LLC
   6  */
   7 #include <asm/kvm_asm.h>
   8 #include <asm/kvm_hyp.h>
   9 #include <asm/memory.h>
  10 #include <asm/percpu.h>
  11
  12 DEFINE_PER_CPU(unsigned long [OVERFLOW_STACK_SIZE/sizeof(long)], overflow_stack)
  13         __aligned(16);
  14
  15 DEFINE_PER_CPU(struct kvm_nvhe_stacktrace_info, kvm_stacktrace_info);
  16
  17 /*
  18  * hyp_prepare_backtrace - Prepare non-protected nVHE backtrace.
  19  *
  20  * @fp : frame pointer at which to start the unwinding.
  21  * @pc : program counter at which to start the unwinding.
  22  *
  23  * Save the information needed by the host to unwind the non-protected
  24  * nVHE hypervisor stack in EL1.
  25  */
  26 static void hyp_prepare_backtrace(unsigned long fp, unsigned long pc)
  27 {
  28         struct kvm_nvhe_stacktrace_info *stacktrace_info = this_cpu_ptr(&kvm_stacktrace_info);
  29         struct kvm_nvhe_init_params *params = this_cpu_ptr(&kvm_init_params);
  30
  31         stacktrace_info->stack_base = (unsigned long)(params->stack_hyp_va - PAGE_SIZE);
  32         stacktrace_info->overflow_stack_base = (unsigned long)this_cpu_ptr(overflow_stack);
  33         stacktrace_info->fp = fp;
  34         stacktrace_info->pc = pc;
  35 }
  36
  37 #ifdef CONFIG_PROTECTED_NVHE_STACKTRACE
  38 #include <asm/stacktrace/nvhe.h>
  39
  40 DEFINE_PER_CPU(unsigned long [NVHE_STACKTRACE_SIZE/sizeof(long)], pkvm_stacktrace);
  41
  42 static struct stack_info stackinfo_get_overflow(void)
  43 {
  44         unsigned long low = (unsigned long)this_cpu_ptr(overflow_stack);
  45         unsigned long high = low + OVERFLOW_STACK_SIZE;
  46
  47         return (struct stack_info) {
  48                 .low = low,
  49                 .high = high,
  50         };
  51 }
  52
  53 static struct stack_info stackinfo_get_hyp(void)
  54 {
  55         struct kvm_nvhe_init_params *params = this_cpu_ptr(&kvm_init_params);
  56         unsigned long high = params->stack_hyp_va;
  57         unsigned long low = high - PAGE_SIZE;
  58
  59         return (struct stack_info) {
  60                 .low = low,
  61                 .high = high,
  62         };
  63 }
  64
  65 static int unwind_next(struct unwind_state *state)
  66 {
  67         return unwind_next_frame_record(state);
  68 }
  69
  70 static void notrace unwind(struct unwind_state *state,
  71                            stack_trace_consume_fn consume_entry,
  72                            void *cookie)
  73 {
  74         while (1) {
  75                 int ret;
  76
  77                 if (!consume_entry(cookie, state->pc))
  78                         break;
  79                 ret = unwind_next(state);
  80                 if (ret < 0)
  81                         break;
  82         }
  83 }
  84
  85 /*
  86  * pkvm_save_backtrace_entry - Saves a protected nVHE HYP stacktrace entry
  87  *
  88  * @arg    : index of the entry in the stacktrace buffer
  89  * @where  : the program counter corresponding to the stack frame
  90  *
  91  * Save the return address of a stack frame to the shared stacktrace buffer.
  92  * The host can access this shared buffer from EL1 to dump the backtrace.
  93  */
  94 static bool pkvm_save_backtrace_entry(void *arg, unsigned long where)
  95 {
  96         unsigned long *stacktrace = this_cpu_ptr(pkvm_stacktrace);
  97         int *idx = (int *)arg;
  98
  99         /*
 100          * Need 2 free slots: 1 for current entry and 1 for the
 101          * delimiter.
 102          */
 103         if (*idx > ARRAY_SIZE(pkvm_stacktrace) - 2)
 104                 return false;
 105
 106         stacktrace[*idx] = where;
 107         stacktrace[++*idx] = 0UL;
 108
 109         return true;
 110 }
 111
 112 /*
 113  * pkvm_save_backtrace - Saves the protected nVHE HYP stacktrace
 114  *
 115  * @fp : frame pointer at which to start the unwinding.
 116  * @pc : program counter at which to start the unwinding.
 117  *
 118  * Save the unwinded stack addresses to the shared stacktrace buffer.
 119  * The host can access this shared buffer from EL1 to dump the backtrace.
 120  */
 121 static void pkvm_save_backtrace(unsigned long fp, unsigned long pc)
 122 {
 123         struct stack_info stacks[] = {
 124                 stackinfo_get_overflow(),
 125                 stackinfo_get_hyp(),
 126         };
 127         struct unwind_state state = {
 128                 .stacks = stacks,
 129                 .nr_stacks = ARRAY_SIZE(stacks),
 130         };
 131         int idx = 0;
 132
 133         kvm_nvhe_unwind_init(&state, fp, pc);
 134
 135         unwind(&state, pkvm_save_backtrace_entry, &idx);
 136 }
 137 #else /* !CONFIG_PROTECTED_NVHE_STACKTRACE */
 138 static void pkvm_save_backtrace(unsigned long fp, unsigned long pc)
 139 {
 140 }
 141 #endif /* CONFIG_PROTECTED_NVHE_STACKTRACE */
 142
 143 /*
 144  * kvm_nvhe_prepare_backtrace - prepare to dump the nVHE backtrace
 145  *
 146  * @fp : frame pointer at which to start the unwinding.
 147  * @pc : program counter at which to start the unwinding.
 148  *
 149  * Saves the information needed by the host to dump the nVHE hypervisor
 150  * backtrace.
 151  */
 152 void kvm_nvhe_prepare_backtrace(unsigned long fp, unsigned long pc)
 153 {
 154         if (is_protected_kvm_enabled())
 155                 pkvm_save_backtrace(fp, pc);
 156         else
 157                 hyp_prepare_backtrace(fp, pc);
 158 }