Commit | Line | Data |
---|---|---|
3be1bc2f SS |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* | |
3 | * Copyright (c) 2023, Microsoft Corporation. | |
4 | * | |
5 | * Author: | |
6 | * Saurabh Sengar <ssengar@microsoft.com> | |
7 | */ | |
8 | ||
9 | #include <asm/apic.h> | |
10 | #include <asm/boot.h> | |
11 | #include <asm/desc.h> | |
12 | #include <asm/i8259.h> | |
13 | #include <asm/mshyperv.h> | |
14 | #include <asm/realmode.h> | |
15 | ||
16 | extern struct boot_params boot_params; | |
17 | static struct real_mode_header hv_vtl_real_mode_header; | |
18 | ||
19 | void __init hv_vtl_init_platform(void) | |
20 | { | |
21 | pr_info("Linux runs in Hyper-V Virtual Trust Level\n"); | |
22 | ||
cb6aeeb6 SS |
23 | x86_platform.realmode_reserve = x86_init_noop; |
24 | x86_platform.realmode_init = x86_init_noop; | |
3be1bc2f SS |
25 | x86_init.irqs.pre_vector_init = x86_init_noop; |
26 | x86_init.timers.timer_init = x86_init_noop; | |
27 | ||
9e2d0c33 SS |
28 | /* Avoid searching for BIOS MP tables */ |
29 | x86_init.mpparse.find_smp_config = x86_init_noop; | |
30 | x86_init.mpparse.get_smp_config = x86_init_uint_noop; | |
31 | ||
3be1bc2f SS |
32 | x86_platform.get_wallclock = get_rtc_noop; |
33 | x86_platform.set_wallclock = set_rtc_noop; | |
34 | x86_platform.get_nmi_reason = hv_get_nmi_reason; | |
35 | ||
36 | x86_platform.legacy.i8042 = X86_LEGACY_I8042_PLATFORM_ABSENT; | |
37 | x86_platform.legacy.rtc = 0; | |
38 | x86_platform.legacy.warm_reset = 0; | |
39 | x86_platform.legacy.reserve_bios_regions = 0; | |
40 | x86_platform.legacy.devices.pnpbios = 0; | |
41 | } | |
42 | ||
43 | static inline u64 hv_vtl_system_desc_base(struct ldttss_desc *desc) | |
44 | { | |
45 | return ((u64)desc->base3 << 32) | ((u64)desc->base2 << 24) | | |
46 | (desc->base1 << 16) | desc->base0; | |
47 | } | |
48 | ||
49 | static inline u32 hv_vtl_system_desc_limit(struct ldttss_desc *desc) | |
50 | { | |
51 | return ((u32)desc->limit1 << 16) | (u32)desc->limit0; | |
52 | } | |
53 | ||
54 | typedef void (*secondary_startup_64_fn)(void*, void*); | |
55 | static void hv_vtl_ap_entry(void) | |
56 | { | |
57 | ((secondary_startup_64_fn)secondary_startup_64)(&boot_params, &boot_params); | |
58 | } | |
59 | ||
60 | static int hv_vtl_bringup_vcpu(u32 target_vp_index, u64 eip_ignored) | |
61 | { | |
62 | u64 status; | |
63 | int ret = 0; | |
64 | struct hv_enable_vp_vtl *input; | |
65 | unsigned long irq_flags; | |
66 | ||
67 | struct desc_ptr gdt_ptr; | |
68 | struct desc_ptr idt_ptr; | |
69 | ||
70 | struct ldttss_desc *tss; | |
71 | struct ldttss_desc *ldt; | |
72 | struct desc_struct *gdt; | |
73 | ||
74 | u64 rsp = current->thread.sp; | |
75 | u64 rip = (u64)&hv_vtl_ap_entry; | |
76 | ||
77 | native_store_gdt(&gdt_ptr); | |
78 | store_idt(&idt_ptr); | |
79 | ||
80 | gdt = (struct desc_struct *)((void *)(gdt_ptr.address)); | |
81 | tss = (struct ldttss_desc *)(gdt + GDT_ENTRY_TSS); | |
82 | ldt = (struct ldttss_desc *)(gdt + GDT_ENTRY_LDT); | |
83 | ||
84 | local_irq_save(irq_flags); | |
85 | ||
86 | input = *this_cpu_ptr(hyperv_pcpu_input_arg); | |
87 | memset(input, 0, sizeof(*input)); | |
88 | ||
89 | input->partition_id = HV_PARTITION_ID_SELF; | |
90 | input->vp_index = target_vp_index; | |
91 | input->target_vtl.target_vtl = HV_VTL_MGMT; | |
92 | ||
93 | /* | |
94 | * The x86_64 Linux kernel follows the 16-bit -> 32-bit -> 64-bit | |
95 | * mode transition sequence after waking up an AP with SIPI whose | |
96 | * vector points to the 16-bit AP startup trampoline code. Here in | |
97 | * VTL2, we can't perform that sequence as the AP has to start in | |
98 | * the 64-bit mode. | |
99 | * | |
100 | * To make this happen, we tell the hypervisor to load a valid 64-bit | |
101 | * context (most of which is just magic numbers from the CPU manual) | |
102 | * so that AP jumps right to the 64-bit entry of the kernel, and the | |
103 | * control registers are loaded with values that let the AP fetch the | |
104 | * code and data and carry on with work it gets assigned. | |
105 | */ | |
106 | ||
107 | input->vp_context.rip = rip; | |
108 | input->vp_context.rsp = rsp; | |
109 | input->vp_context.rflags = 0x0000000000000002; | |
110 | input->vp_context.efer = __rdmsr(MSR_EFER); | |
111 | input->vp_context.cr0 = native_read_cr0(); | |
112 | input->vp_context.cr3 = __native_read_cr3(); | |
113 | input->vp_context.cr4 = native_read_cr4(); | |
114 | input->vp_context.msr_cr_pat = __rdmsr(MSR_IA32_CR_PAT); | |
115 | input->vp_context.idtr.limit = idt_ptr.size; | |
116 | input->vp_context.idtr.base = idt_ptr.address; | |
117 | input->vp_context.gdtr.limit = gdt_ptr.size; | |
118 | input->vp_context.gdtr.base = gdt_ptr.address; | |
119 | ||
120 | /* Non-system desc (64bit), long, code, present */ | |
121 | input->vp_context.cs.selector = __KERNEL_CS; | |
122 | input->vp_context.cs.base = 0; | |
123 | input->vp_context.cs.limit = 0xffffffff; | |
124 | input->vp_context.cs.attributes = 0xa09b; | |
125 | /* Non-system desc (64bit), data, present, granularity, default */ | |
126 | input->vp_context.ss.selector = __KERNEL_DS; | |
127 | input->vp_context.ss.base = 0; | |
128 | input->vp_context.ss.limit = 0xffffffff; | |
129 | input->vp_context.ss.attributes = 0xc093; | |
130 | ||
131 | /* System desc (128bit), present, LDT */ | |
132 | input->vp_context.ldtr.selector = GDT_ENTRY_LDT * 8; | |
133 | input->vp_context.ldtr.base = hv_vtl_system_desc_base(ldt); | |
134 | input->vp_context.ldtr.limit = hv_vtl_system_desc_limit(ldt); | |
135 | input->vp_context.ldtr.attributes = 0x82; | |
136 | ||
137 | /* System desc (128bit), present, TSS, 0x8b - busy, 0x89 -- default */ | |
138 | input->vp_context.tr.selector = GDT_ENTRY_TSS * 8; | |
139 | input->vp_context.tr.base = hv_vtl_system_desc_base(tss); | |
140 | input->vp_context.tr.limit = hv_vtl_system_desc_limit(tss); | |
141 | input->vp_context.tr.attributes = 0x8b; | |
142 | ||
143 | status = hv_do_hypercall(HVCALL_ENABLE_VP_VTL, input, NULL); | |
144 | ||
145 | if (!hv_result_success(status) && | |
146 | hv_result(status) != HV_STATUS_VTL_ALREADY_ENABLED) { | |
147 | pr_err("HVCALL_ENABLE_VP_VTL failed for VP : %d ! [Err: %#llx\n]", | |
148 | target_vp_index, status); | |
149 | ret = -EINVAL; | |
150 | goto free_lock; | |
151 | } | |
152 | ||
153 | status = hv_do_hypercall(HVCALL_START_VP, input, NULL); | |
154 | ||
155 | if (!hv_result_success(status)) { | |
156 | pr_err("HVCALL_START_VP failed for VP : %d ! [Err: %#llx]\n", | |
157 | target_vp_index, status); | |
158 | ret = -EINVAL; | |
159 | } | |
160 | ||
161 | free_lock: | |
162 | local_irq_restore(irq_flags); | |
163 | ||
164 | return ret; | |
165 | } | |
166 | ||
167 | static int hv_vtl_apicid_to_vp_id(u32 apic_id) | |
168 | { | |
169 | u64 control; | |
170 | u64 status; | |
171 | unsigned long irq_flags; | |
172 | struct hv_get_vp_from_apic_id_in *input; | |
173 | u32 *output, ret; | |
174 | ||
175 | local_irq_save(irq_flags); | |
176 | ||
177 | input = *this_cpu_ptr(hyperv_pcpu_input_arg); | |
178 | memset(input, 0, sizeof(*input)); | |
179 | input->partition_id = HV_PARTITION_ID_SELF; | |
180 | input->apic_ids[0] = apic_id; | |
181 | ||
182 | output = (u32 *)input; | |
183 | ||
184 | control = HV_HYPERCALL_REP_COMP_1 | HVCALL_GET_VP_ID_FROM_APIC_ID; | |
185 | status = hv_do_hypercall(control, input, output); | |
186 | ret = output[0]; | |
187 | ||
188 | local_irq_restore(irq_flags); | |
189 | ||
190 | if (!hv_result_success(status)) { | |
191 | pr_err("failed to get vp id from apic id %d, status %#llx\n", | |
192 | apic_id, status); | |
193 | return -EINVAL; | |
194 | } | |
195 | ||
196 | return ret; | |
197 | } | |
198 | ||
199 | static int hv_vtl_wakeup_secondary_cpu(int apicid, unsigned long start_eip) | |
200 | { | |
201 | int vp_id; | |
202 | ||
203 | pr_debug("Bringing up CPU with APIC ID %d in VTL2...\n", apicid); | |
204 | vp_id = hv_vtl_apicid_to_vp_id(apicid); | |
205 | ||
206 | if (vp_id < 0) { | |
207 | pr_err("Couldn't find CPU with APIC ID %d\n", apicid); | |
208 | return -EINVAL; | |
209 | } | |
210 | if (vp_id > ms_hyperv.max_vp_index) { | |
211 | pr_err("Invalid CPU id %d for APIC ID %d\n", vp_id, apicid); | |
212 | return -EINVAL; | |
213 | } | |
214 | ||
215 | return hv_vtl_bringup_vcpu(vp_id, start_eip); | |
216 | } | |
217 | ||
14058f72 | 218 | int __init hv_vtl_early_init(void) |
3be1bc2f SS |
219 | { |
220 | /* | |
221 | * `boot_cpu_has` returns the runtime feature support, | |
222 | * and here is the earliest it can be used. | |
223 | */ | |
224 | if (cpu_feature_enabled(X86_FEATURE_XSAVE)) | |
225 | panic("XSAVE has to be disabled as it is not supported by this module.\n" | |
226 | "Please add 'noxsave' to the kernel command line.\n"); | |
227 | ||
228 | real_mode_header = &hv_vtl_real_mode_header; | |
2744a7ce | 229 | apic_update_callback(wakeup_secondary_cpu_64, hv_vtl_wakeup_secondary_cpu); |
3be1bc2f SS |
230 | |
231 | return 0; | |
232 | } |