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