arch/arm64/hyperv/hv_core.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 /*
   4  * Low level utility routines for interacting with Hyper-V.
   5  *
   6  * Copyright (C) 2021, Microsoft, Inc.
   7  *
   8  * Author : Michael Kelley <mikelley@microsoft.com>
   9  */
  10
  11 #include <linux/types.h>
  12 #include <linux/export.h>
  13 #include <linux/mm.h>
  14 #include <linux/hyperv.h>
  15 #include <linux/arm-smccc.h>
  16 #include <linux/module.h>
  17 #include <asm-generic/bug.h>
  18 #include <asm/hyperv-tlfs.h>
  19 #include <asm/mshyperv.h>
  20
  21 /*
  22  * hv_do_hypercall- Invoke the specified hypercall
  23  */
  24 u64 hv_do_hypercall(u64 control, void *input, void *output)
  25 {
  26         struct arm_smccc_res    res;
  27         u64                     input_address;
  28         u64                     output_address;
  29
  30         input_address = input ? virt_to_phys(input) : 0;
  31         output_address = output ? virt_to_phys(output) : 0;
  32
  33         arm_smccc_1_1_hvc(HV_FUNC_ID, control,
  34                           input_address, output_address, &res);
  35         return res.a0;
  36 }
  37 EXPORT_SYMBOL_GPL(hv_do_hypercall);
  38
  39 /*
  40  * hv_do_fast_hypercall8 -- Invoke the specified hypercall
  41  * with arguments in registers instead of physical memory.
  42  * Avoids the overhead of virt_to_phys for simple hypercalls.
  43  */
  44
  45 u64 hv_do_fast_hypercall8(u16 code, u64 input)
  46 {
  47         struct arm_smccc_res    res;
  48         u64                     control;
  49
  50         control = (u64)code | HV_HYPERCALL_FAST_BIT;
  51
  52         arm_smccc_1_1_hvc(HV_FUNC_ID, control, input, &res);
  53         return res.a0;
  54 }
  55 EXPORT_SYMBOL_GPL(hv_do_fast_hypercall8);
  56
  57 /*
  58  * Set a single VP register to a 64-bit value.
  59  */
  60 void hv_set_vpreg(u32 msr, u64 value)
  61 {
  62         struct arm_smccc_res res;
  63
  64         arm_smccc_1_1_hvc(HV_FUNC_ID,
  65                 HVCALL_SET_VP_REGISTERS | HV_HYPERCALL_FAST_BIT |
  66                         HV_HYPERCALL_REP_COMP_1,
  67                 HV_PARTITION_ID_SELF,
  68                 HV_VP_INDEX_SELF,
  69                 msr,
  70                 0,
  71                 value,
  72                 0,
  73                 &res);
  74
  75         /*
  76          * Something is fundamentally broken in the hypervisor if
  77          * setting a VP register fails. There's really no way to
  78          * continue as a guest VM, so panic.
  79          */
  80         BUG_ON(!hv_result_success(res.a0));
  81 }
  82 EXPORT_SYMBOL_GPL(hv_set_vpreg);
  83
  84 /*
  85  * Get the value of a single VP register.  One version
  86  * returns just 64 bits and another returns the full 128 bits.
  87  * The two versions are separate to avoid complicating the
  88  * calling sequence for the more frequently used 64 bit version.
  89  */
  90
  91 void hv_get_vpreg_128(u32 msr, struct hv_get_vp_registers_output *result)
  92 {
  93         struct arm_smccc_1_2_regs args;
  94         struct arm_smccc_1_2_regs res;
  95
  96         args.a0 = HV_FUNC_ID;
  97         args.a1 = HVCALL_GET_VP_REGISTERS | HV_HYPERCALL_FAST_BIT |
  98                         HV_HYPERCALL_REP_COMP_1;
  99         args.a2 = HV_PARTITION_ID_SELF;
 100         args.a3 = HV_VP_INDEX_SELF;
 101         args.a4 = msr;
 102
 103         /*
 104          * Use the SMCCC 1.2 interface because the results are in registers
 105          * beyond X0-X3.
 106          */
 107         arm_smccc_1_2_hvc(&args, &res);
 108
 109         /*
 110          * Something is fundamentally broken in the hypervisor if
 111          * getting a VP register fails. There's really no way to
 112          * continue as a guest VM, so panic.
 113          */
 114         BUG_ON(!hv_result_success(res.a0));
 115
 116         result->as64.low = res.a6;
 117         result->as64.high = res.a7;
 118 }
 119 EXPORT_SYMBOL_GPL(hv_get_vpreg_128);
 120
 121 u64 hv_get_vpreg(u32 msr)
 122 {
 123         struct hv_get_vp_registers_output output;
 124
 125         hv_get_vpreg_128(msr, &output);
 126
 127         return output.as64.low;
 128 }
 129 EXPORT_SYMBOL_GPL(hv_get_vpreg);
 130
 131 /*
 132  * hyperv_report_panic - report a panic to Hyper-V.  This function uses
 133  * the older version of the Hyper-V interface that admittedly doesn't
 134  * pass enough information to be useful beyond just recording the
 135  * occurrence of a panic. The parallel hv_kmsg_dump() uses the
 136  * new interface that allows reporting 4 Kbytes of data, which is much
 137  * more useful. Hyper-V on ARM64 always supports the newer interface, but
 138  * we retain support for the older version because the sysadmin is allowed
 139  * to disable the newer version via sysctl in case of information security
 140  * concerns about the more verbose version.
 141  */
 142 void hyperv_report_panic(struct pt_regs *regs, long err, bool in_die)
 143 {
 144         static bool     panic_reported;
 145         u64             guest_id;
 146
 147         /* Don't report a panic to Hyper-V if we're not going to panic */
 148         if (in_die && !panic_on_oops)
 149                 return;
 150
 151         /*
 152          * We prefer to report panic on 'die' chain as we have proper
 153          * registers to report, but if we miss it (e.g. on BUG()) we need
 154          * to report it on 'panic'.
 155          *
 156          * Calling code in the 'die' and 'panic' paths ensures that only
 157          * one CPU is running this code, so no atomicity is needed.
 158          */
 159         if (panic_reported)
 160                 return;
 161         panic_reported = true;
 162
 163         guest_id = hv_get_vpreg(HV_REGISTER_GUEST_OS_ID);
 164
 165         /*
 166          * Hyper-V provides the ability to store only 5 values.
 167          * Pick the passed in error value, the guest_id, the PC,
 168          * and the SP.
 169          */
 170         hv_set_vpreg(HV_REGISTER_GUEST_CRASH_P0, err);
 171         hv_set_vpreg(HV_REGISTER_GUEST_CRASH_P1, guest_id);
 172         hv_set_vpreg(HV_REGISTER_GUEST_CRASH_P2, regs->pc);
 173         hv_set_vpreg(HV_REGISTER_GUEST_CRASH_P3, regs->sp);
 174         hv_set_vpreg(HV_REGISTER_GUEST_CRASH_P4, 0);
 175
 176         /*
 177          * Let Hyper-V know there is crash data available
 178          */
 179         hv_set_vpreg(HV_REGISTER_GUEST_CRASH_CTL, HV_CRASH_CTL_CRASH_NOTIFY);
 180 }
 181 EXPORT_SYMBOL_GPL(hyperv_report_panic);