xref: /openbmc/linux/arch/x86/hyperv/ivm.c (revision 66c98360) 
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Hyper-V Isolation VM interface with paravisor and hypervisor
4  *
5  * Author:
6  *  Tianyu Lan <Tianyu.Lan@microsoft.com>
7  */
8 
9 #include <linux/bitfield.h>
10 #include <linux/hyperv.h>
11 #include <linux/types.h>
12 #include <linux/slab.h>
13 #include <asm/svm.h>
14 #include <asm/sev.h>
15 #include <asm/io.h>
16 #include <asm/coco.h>
17 #include <asm/mem_encrypt.h>
18 #include <asm/mshyperv.h>
19 #include <asm/hypervisor.h>
20 
21 #ifdef CONFIG_AMD_MEM_ENCRYPT
22 
23 #define GHCB_USAGE_HYPERV_CALL	1
24 
25 union hv_ghcb {
26 	struct ghcb ghcb;
27 	struct {
28 		u64 hypercalldata[509];
29 		u64 outputgpa;
30 		union {
31 			union {
32 				struct {
33 					u32 callcode        : 16;
34 					u32 isfast          : 1;
35 					u32 reserved1       : 14;
36 					u32 isnested        : 1;
37 					u32 countofelements : 12;
38 					u32 reserved2       : 4;
39 					u32 repstartindex   : 12;
40 					u32 reserved3       : 4;
41 				};
42 				u64 asuint64;
43 			} hypercallinput;
44 			union {
45 				struct {
46 					u16 callstatus;
47 					u16 reserved1;
48 					u32 elementsprocessed : 12;
49 					u32 reserved2         : 20;
50 				};
51 				u64 asunit64;
52 			} hypercalloutput;
53 		};
54 		u64 reserved2;
55 	} hypercall;
56 } __packed __aligned(HV_HYP_PAGE_SIZE);
57 
58 static u16 hv_ghcb_version __ro_after_init;
59 
60 u64 hv_ghcb_hypercall(u64 control, void *input, void *output, u32 input_size)
61 {
62 	union hv_ghcb *hv_ghcb;
63 	void **ghcb_base;
64 	unsigned long flags;
65 	u64 status;
66 
67 	if (!hv_ghcb_pg)
68 		return -EFAULT;
69 
70 	WARN_ON(in_nmi());
71 
72 	local_irq_save(flags);
73 	ghcb_base = (void **)this_cpu_ptr(hv_ghcb_pg);
74 	hv_ghcb = (union hv_ghcb *)*ghcb_base;
75 	if (!hv_ghcb) {
76 		local_irq_restore(flags);
77 		return -EFAULT;
78 	}
79 
80 	hv_ghcb->ghcb.protocol_version = GHCB_PROTOCOL_MAX;
81 	hv_ghcb->ghcb.ghcb_usage = GHCB_USAGE_HYPERV_CALL;
82 
83 	hv_ghcb->hypercall.outputgpa = (u64)output;
84 	hv_ghcb->hypercall.hypercallinput.asuint64 = 0;
85 	hv_ghcb->hypercall.hypercallinput.callcode = control;
86 
87 	if (input_size)
88 		memcpy(hv_ghcb->hypercall.hypercalldata, input, input_size);
89 
90 	VMGEXIT();
91 
92 	hv_ghcb->ghcb.ghcb_usage = 0xffffffff;
93 	memset(hv_ghcb->ghcb.save.valid_bitmap, 0,
94 	       sizeof(hv_ghcb->ghcb.save.valid_bitmap));
95 
96 	status = hv_ghcb->hypercall.hypercalloutput.callstatus;
97 
98 	local_irq_restore(flags);
99 
100 	return status;
101 }
102 
103 static inline u64 rd_ghcb_msr(void)
104 {
105 	return __rdmsr(MSR_AMD64_SEV_ES_GHCB);
106 }
107 
108 static inline void wr_ghcb_msr(u64 val)
109 {
110 	native_wrmsrl(MSR_AMD64_SEV_ES_GHCB, val);
111 }
112 
113 static enum es_result hv_ghcb_hv_call(struct ghcb *ghcb, u64 exit_code,
114 				   u64 exit_info_1, u64 exit_info_2)
115 {
116 	/* Fill in protocol and format specifiers */
117 	ghcb->protocol_version = hv_ghcb_version;
118 	ghcb->ghcb_usage       = GHCB_DEFAULT_USAGE;
119 
120 	ghcb_set_sw_exit_code(ghcb, exit_code);
121 	ghcb_set_sw_exit_info_1(ghcb, exit_info_1);
122 	ghcb_set_sw_exit_info_2(ghcb, exit_info_2);
123 
124 	VMGEXIT();
125 
126 	if (ghcb->save.sw_exit_info_1 & GENMASK_ULL(31, 0))
127 		return ES_VMM_ERROR;
128 	else
129 		return ES_OK;
130 }
131 
132 void __noreturn hv_ghcb_terminate(unsigned int set, unsigned int reason)
133 {
134 	u64 val = GHCB_MSR_TERM_REQ;
135 
136 	/* Tell the hypervisor what went wrong. */
137 	val |= GHCB_SEV_TERM_REASON(set, reason);
138 
139 	/* Request Guest Termination from Hypvervisor */
140 	wr_ghcb_msr(val);
141 	VMGEXIT();
142 
143 	while (true)
144 		asm volatile("hlt\n" : : : "memory");
145 }
146 
147 bool hv_ghcb_negotiate_protocol(void)
148 {
149 	u64 ghcb_gpa;
150 	u64 val;
151 
152 	/* Save ghcb page gpa. */
153 	ghcb_gpa = rd_ghcb_msr();
154 
155 	/* Do the GHCB protocol version negotiation */
156 	wr_ghcb_msr(GHCB_MSR_SEV_INFO_REQ);
157 	VMGEXIT();
158 	val = rd_ghcb_msr();
159 
160 	if (GHCB_MSR_INFO(val) != GHCB_MSR_SEV_INFO_RESP)
161 		return false;
162 
163 	if (GHCB_MSR_PROTO_MAX(val) < GHCB_PROTOCOL_MIN ||
164 	    GHCB_MSR_PROTO_MIN(val) > GHCB_PROTOCOL_MAX)
165 		return false;
166 
167 	hv_ghcb_version = min_t(size_t, GHCB_MSR_PROTO_MAX(val),
168 			     GHCB_PROTOCOL_MAX);
169 
170 	/* Write ghcb page back after negotiating protocol. */
171 	wr_ghcb_msr(ghcb_gpa);
172 	VMGEXIT();
173 
174 	return true;
175 }
176 
177 void hv_ghcb_msr_write(u64 msr, u64 value)
178 {
179 	union hv_ghcb *hv_ghcb;
180 	void **ghcb_base;
181 	unsigned long flags;
182 
183 	if (!hv_ghcb_pg)
184 		return;
185 
186 	WARN_ON(in_nmi());
187 
188 	local_irq_save(flags);
189 	ghcb_base = (void **)this_cpu_ptr(hv_ghcb_pg);
190 	hv_ghcb = (union hv_ghcb *)*ghcb_base;
191 	if (!hv_ghcb) {
192 		local_irq_restore(flags);
193 		return;
194 	}
195 
196 	ghcb_set_rcx(&hv_ghcb->ghcb, msr);
197 	ghcb_set_rax(&hv_ghcb->ghcb, lower_32_bits(value));
198 	ghcb_set_rdx(&hv_ghcb->ghcb, upper_32_bits(value));
199 
200 	if (hv_ghcb_hv_call(&hv_ghcb->ghcb, SVM_EXIT_MSR, 1, 0))
201 		pr_warn("Fail to write msr via ghcb %llx.\n", msr);
202 
203 	local_irq_restore(flags);
204 }
205 EXPORT_SYMBOL_GPL(hv_ghcb_msr_write);
206 
207 void hv_ghcb_msr_read(u64 msr, u64 *value)
208 {
209 	union hv_ghcb *hv_ghcb;
210 	void **ghcb_base;
211 	unsigned long flags;
212 
213 	/* Check size of union hv_ghcb here. */
214 	BUILD_BUG_ON(sizeof(union hv_ghcb) != HV_HYP_PAGE_SIZE);
215 
216 	if (!hv_ghcb_pg)
217 		return;
218 
219 	WARN_ON(in_nmi());
220 
221 	local_irq_save(flags);
222 	ghcb_base = (void **)this_cpu_ptr(hv_ghcb_pg);
223 	hv_ghcb = (union hv_ghcb *)*ghcb_base;
224 	if (!hv_ghcb) {
225 		local_irq_restore(flags);
226 		return;
227 	}
228 
229 	ghcb_set_rcx(&hv_ghcb->ghcb, msr);
230 	if (hv_ghcb_hv_call(&hv_ghcb->ghcb, SVM_EXIT_MSR, 0, 0))
231 		pr_warn("Fail to read msr via ghcb %llx.\n", msr);
232 	else
233 		*value = (u64)lower_32_bits(hv_ghcb->ghcb.save.rax)
234 			| ((u64)lower_32_bits(hv_ghcb->ghcb.save.rdx) << 32);
235 	local_irq_restore(flags);
236 }
237 EXPORT_SYMBOL_GPL(hv_ghcb_msr_read);
238 
239 /*
240  * hv_mark_gpa_visibility - Set pages visible to host via hvcall.
241  *
242  * In Isolation VM, all guest memory is encrypted from host and guest
243  * needs to set memory visible to host via hvcall before sharing memory
244  * with host.
245  */
246 static int hv_mark_gpa_visibility(u16 count, const u64 pfn[],
247 			   enum hv_mem_host_visibility visibility)
248 {
249 	struct hv_gpa_range_for_visibility **input_pcpu, *input;
250 	u16 pages_processed;
251 	u64 hv_status;
252 	unsigned long flags;
253 
254 	/* no-op if partition isolation is not enabled */
255 	if (!hv_is_isolation_supported())
256 		return 0;
257 
258 	if (count > HV_MAX_MODIFY_GPA_REP_COUNT) {
259 		pr_err("Hyper-V: GPA count:%d exceeds supported:%lu\n", count,
260 			HV_MAX_MODIFY_GPA_REP_COUNT);
261 		return -EINVAL;
262 	}
263 
264 	local_irq_save(flags);
265 	input_pcpu = (struct hv_gpa_range_for_visibility **)
266 			this_cpu_ptr(hyperv_pcpu_input_arg);
267 	input = *input_pcpu;
268 	if (unlikely(!input)) {
269 		local_irq_restore(flags);
270 		return -EINVAL;
271 	}
272 
273 	input->partition_id = HV_PARTITION_ID_SELF;
274 	input->host_visibility = visibility;
275 	input->reserved0 = 0;
276 	input->reserved1 = 0;
277 	memcpy((void *)input->gpa_page_list, pfn, count * sizeof(*pfn));
278 	hv_status = hv_do_rep_hypercall(
279 			HVCALL_MODIFY_SPARSE_GPA_PAGE_HOST_VISIBILITY, count,
280 			0, input, &pages_processed);
281 	local_irq_restore(flags);
282 
283 	if (hv_result_success(hv_status))
284 		return 0;
285 	else
286 		return -EFAULT;
287 }
288 
289 /*
290  * hv_vtom_set_host_visibility - Set specified memory visible to host.
291  *
292  * In Isolation VM, all guest memory is encrypted from host and guest
293  * needs to set memory visible to host via hvcall before sharing memory
294  * with host. This function works as wrap of hv_mark_gpa_visibility()
295  * with memory base and size.
296  */
297 static bool hv_vtom_set_host_visibility(unsigned long kbuffer, int pagecount, bool enc)
298 {
299 	enum hv_mem_host_visibility visibility = enc ?
300 			VMBUS_PAGE_NOT_VISIBLE : VMBUS_PAGE_VISIBLE_READ_WRITE;
301 	u64 *pfn_array;
302 	int ret = 0;
303 	bool result = true;
304 	int i, pfn;
305 
306 	pfn_array = kmalloc(HV_HYP_PAGE_SIZE, GFP_KERNEL);
307 	if (!pfn_array)
308 		return false;
309 
310 	for (i = 0, pfn = 0; i < pagecount; i++) {
311 		pfn_array[pfn] = virt_to_hvpfn((void *)kbuffer + i * HV_HYP_PAGE_SIZE);
312 		pfn++;
313 
314 		if (pfn == HV_MAX_MODIFY_GPA_REP_COUNT || i == pagecount - 1) {
315 			ret = hv_mark_gpa_visibility(pfn, pfn_array,
316 						     visibility);
317 			if (ret) {
318 				result = false;
319 				goto err_free_pfn_array;
320 			}
321 			pfn = 0;
322 		}
323 	}
324 
325  err_free_pfn_array:
326 	kfree(pfn_array);
327 	return result;
328 }
329 
330 static bool hv_vtom_tlb_flush_required(bool private)
331 {
332 	return true;
333 }
334 
335 static bool hv_vtom_cache_flush_required(void)
336 {
337 	return false;
338 }
339 
340 static bool hv_is_private_mmio(u64 addr)
341 {
342 	/*
343 	 * Hyper-V always provides a single IO-APIC in a guest VM.
344 	 * When a paravisor is used, it is emulated by the paravisor
345 	 * in the guest context and must be mapped private.
346 	 */
347 	if (addr >= HV_IOAPIC_BASE_ADDRESS &&
348 	    addr < (HV_IOAPIC_BASE_ADDRESS + PAGE_SIZE))
349 		return true;
350 
351 	/* Same with a vTPM */
352 	if (addr >= VTPM_BASE_ADDRESS &&
353 	    addr < (VTPM_BASE_ADDRESS + PAGE_SIZE))
354 		return true;
355 
356 	return false;
357 }
358 
359 void __init hv_vtom_init(void)
360 {
361 	/*
362 	 * By design, a VM using vTOM doesn't see the SEV setting,
363 	 * so SEV initialization is bypassed and sev_status isn't set.
364 	 * Set it here to indicate a vTOM VM.
365 	 */
366 	sev_status = MSR_AMD64_SNP_VTOM;
367 	cc_set_vendor(CC_VENDOR_AMD);
368 	cc_set_mask(ms_hyperv.shared_gpa_boundary);
369 	physical_mask &= ms_hyperv.shared_gpa_boundary - 1;
370 
371 	x86_platform.hyper.is_private_mmio = hv_is_private_mmio;
372 	x86_platform.guest.enc_cache_flush_required = hv_vtom_cache_flush_required;
373 	x86_platform.guest.enc_tlb_flush_required = hv_vtom_tlb_flush_required;
374 	x86_platform.guest.enc_status_change_finish = hv_vtom_set_host_visibility;
375 }
376 
377 #endif /* CONFIG_AMD_MEM_ENCRYPT */
378 
379 enum hv_isolation_type hv_get_isolation_type(void)
380 {
381 	if (!(ms_hyperv.priv_high & HV_ISOLATION))
382 		return HV_ISOLATION_TYPE_NONE;
383 	return FIELD_GET(HV_ISOLATION_TYPE, ms_hyperv.isolation_config_b);
384 }
385 EXPORT_SYMBOL_GPL(hv_get_isolation_type);
386 
387 /*
388  * hv_is_isolation_supported - Check system runs in the Hyper-V
389  * isolation VM.
390  */
391 bool hv_is_isolation_supported(void)
392 {
393 	if (!cpu_feature_enabled(X86_FEATURE_HYPERVISOR))
394 		return false;
395 
396 	if (!hypervisor_is_type(X86_HYPER_MS_HYPERV))
397 		return false;
398 
399 	return hv_get_isolation_type() != HV_ISOLATION_TYPE_NONE;
400 }
401 
402 DEFINE_STATIC_KEY_FALSE(isolation_type_snp);
403 
404 /*
405  * hv_isolation_type_snp - Check system runs in the AMD SEV-SNP based
406  * isolation VM.
407  */
408 bool hv_isolation_type_snp(void)
409 {
410 	return static_branch_unlikely(&isolation_type_snp);
411 }
412