guest-state-buffer.c

  1// SPDX-License-Identifier: GPL-2.0
  2
  3#include "asm/hvcall.h"
  4#include <linux/log2.h>
  5#include <asm/pgalloc.h>
  6#include <asm/guest-state-buffer.h>
  7
  8static const u16 kvmppc_gse_iden_len[__KVMPPC_GSE_TYPE_MAX] = {
  9	[KVMPPC_GSE_BE32] = sizeof(__be32),
 10	[KVMPPC_GSE_BE64] = sizeof(__be64),
 11	[KVMPPC_GSE_VEC128] = sizeof(vector128),
 12	[KVMPPC_GSE_PARTITION_TABLE] = sizeof(struct kvmppc_gs_part_table),
 13	[KVMPPC_GSE_PROCESS_TABLE] = sizeof(struct kvmppc_gs_proc_table),
 14	[KVMPPC_GSE_BUFFER] = sizeof(struct kvmppc_gs_buff_info),
 15};
 16
 17/**
 18 * kvmppc_gsb_new() - create a new guest state buffer
 19 * @size: total size of the guest state buffer (includes header)
 20 * @guest_id: guest_id
 21 * @vcpu_id: vcpu_id
 22 * @flags: GFP flags
 23 *
 24 * Returns a guest state buffer.
 25 */
 26struct kvmppc_gs_buff *kvmppc_gsb_new(size_t size, unsigned long guest_id,
 27				      unsigned long vcpu_id, gfp_t flags)
 28{
 29	struct kvmppc_gs_buff *gsb;
 30
 31	gsb = kzalloc(sizeof(*gsb), flags);
 32	if (!gsb)
 33		return NULL;
 34
 35	size = roundup_pow_of_two(size);
 36	gsb->hdr = kzalloc(size, GFP_KERNEL);
 37	if (!gsb->hdr)
 38		goto free;
 39
 40	gsb->capacity = size;
 41	gsb->len = sizeof(struct kvmppc_gs_header);
 42	gsb->vcpu_id = vcpu_id;
 43	gsb->guest_id = guest_id;
 44
 45	gsb->hdr->nelems = cpu_to_be32(0);
 46
 47	return gsb;
 48
 49free:
 50	kfree(gsb);
 51	return NULL;
 52}
 53EXPORT_SYMBOL_GPL(kvmppc_gsb_new);
 54
 55/**
 56 * kvmppc_gsb_free() - free a guest state buffer
 57 * @gsb: guest state buffer
 58 */
 59void kvmppc_gsb_free(struct kvmppc_gs_buff *gsb)
 60{
 61	kfree(gsb->hdr);
 62	kfree(gsb);
 63}
 64EXPORT_SYMBOL_GPL(kvmppc_gsb_free);
 65
 66/**
 67 * kvmppc_gsb_put() - allocate space in a guest state buffer
 68 * @gsb: buffer to allocate in
 69 * @size: amount of space to allocate
 70 *
 71 * Returns a pointer to the amount of space requested within the buffer and
 72 * increments the count of elements in the buffer.
 73 *
 74 * Does not check if there is enough space in the buffer.
 75 */
 76void *kvmppc_gsb_put(struct kvmppc_gs_buff *gsb, size_t size)
 77{
 78	u32 nelems = kvmppc_gsb_nelems(gsb);
 79	void *p;
 80
 81	p = (void *)kvmppc_gsb_header(gsb) + kvmppc_gsb_len(gsb);
 82	gsb->len += size;
 83
 84	kvmppc_gsb_header(gsb)->nelems = cpu_to_be32(nelems + 1);
 85	return p;
 86}
 87EXPORT_SYMBOL_GPL(kvmppc_gsb_put);
 88
 89static int kvmppc_gsid_class(u16 iden)
 90{
 91	if ((iden >= KVMPPC_GSE_GUESTWIDE_START) &&
 92	    (iden <= KVMPPC_GSE_GUESTWIDE_END))
 93		return KVMPPC_GS_CLASS_GUESTWIDE;
 94
 95	if ((iden >= KVMPPC_GSE_HOSTWIDE_START) &&
 96	    (iden <= KVMPPC_GSE_HOSTWIDE_END))
 97		return KVMPPC_GS_CLASS_HOSTWIDE;
 98
 99	if ((iden >= KVMPPC_GSE_META_START) && (iden <= KVMPPC_GSE_META_END))
100		return KVMPPC_GS_CLASS_META;
101
102	if ((iden >= KVMPPC_GSE_DW_REGS_START) &&
103	    (iden <= KVMPPC_GSE_DW_REGS_END))
104		return KVMPPC_GS_CLASS_DWORD_REG;
105
106	if ((iden >= KVMPPC_GSE_W_REGS_START) &&
107	    (iden <= KVMPPC_GSE_W_REGS_END))
108		return KVMPPC_GS_CLASS_WORD_REG;
109
110	if ((iden >= KVMPPC_GSE_VSRS_START) && (iden <= KVMPPC_GSE_VSRS_END))
111		return KVMPPC_GS_CLASS_VECTOR;
112
113	if ((iden >= KVMPPC_GSE_INTR_REGS_START) &&
114	    (iden <= KVMPPC_GSE_INTR_REGS_END))
115		return KVMPPC_GS_CLASS_INTR;
116
117	return -1;
118}
119
120static int kvmppc_gsid_type(u16 iden)
121{
122	int type = -1;
123
124	switch (kvmppc_gsid_class(iden)) {
125	case KVMPPC_GS_CLASS_HOSTWIDE:
126		switch (iden) {
127		case KVMPPC_GSID_L0_GUEST_HEAP:
128			fallthrough;
129		case KVMPPC_GSID_L0_GUEST_HEAP_MAX:
130			fallthrough;
131		case KVMPPC_GSID_L0_GUEST_PGTABLE_SIZE:
132			fallthrough;
133		case KVMPPC_GSID_L0_GUEST_PGTABLE_SIZE_MAX:
134			fallthrough;
135		case KVMPPC_GSID_L0_GUEST_PGTABLE_RECLAIM:
136			type = KVMPPC_GSE_BE64;
137			break;
138		}
139		break;
140	case KVMPPC_GS_CLASS_GUESTWIDE:
141		switch (iden) {
142		case KVMPPC_GSID_HOST_STATE_SIZE:
143		case KVMPPC_GSID_RUN_OUTPUT_MIN_SIZE:
144		case KVMPPC_GSID_TB_OFFSET:
145			type = KVMPPC_GSE_BE64;
146			break;
147		case KVMPPC_GSID_PARTITION_TABLE:
148			type = KVMPPC_GSE_PARTITION_TABLE;
149			break;
150		case KVMPPC_GSID_PROCESS_TABLE:
151			type = KVMPPC_GSE_PROCESS_TABLE;
152			break;
153		case KVMPPC_GSID_LOGICAL_PVR:
154			type = KVMPPC_GSE_BE32;
155			break;
156		}
157		break;
158	case KVMPPC_GS_CLASS_META:
159		switch (iden) {
160		case KVMPPC_GSID_RUN_INPUT:
161		case KVMPPC_GSID_RUN_OUTPUT:
162			type = KVMPPC_GSE_BUFFER;
163			break;
164		case KVMPPC_GSID_VPA:
165			type = KVMPPC_GSE_BE64;
166			break;
167		}
168		break;
169	case KVMPPC_GS_CLASS_DWORD_REG:
170		type = KVMPPC_GSE_BE64;
171		break;
172	case KVMPPC_GS_CLASS_WORD_REG:
173		type = KVMPPC_GSE_BE32;
174		break;
175	case KVMPPC_GS_CLASS_VECTOR:
176		type = KVMPPC_GSE_VEC128;
177		break;
178	case KVMPPC_GS_CLASS_INTR:
179		switch (iden) {
180		case KVMPPC_GSID_HDAR:
181		case KVMPPC_GSID_ASDR:
182		case KVMPPC_GSID_HEIR:
183			type = KVMPPC_GSE_BE64;
184			break;
185		case KVMPPC_GSID_HDSISR:
186			type = KVMPPC_GSE_BE32;
187			break;
188		}
189		break;
190	}
191
192	return type;
193}
194
195/**
196 * kvmppc_gsid_flags() - the flags for a guest state ID
197 * @iden: guest state ID
198 *
199 * Returns any flags for the guest state ID.
200 */
201unsigned long kvmppc_gsid_flags(u16 iden)
202{
203	unsigned long flags = 0;
204
205	switch (kvmppc_gsid_class(iden)) {
206	case KVMPPC_GS_CLASS_GUESTWIDE:
207		flags = KVMPPC_GS_FLAGS_WIDE;
208		break;
209	case KVMPPC_GS_CLASS_HOSTWIDE:
210		flags = KVMPPC_GS_FLAGS_HOST_WIDE;
211		break;
212	case KVMPPC_GS_CLASS_META:
213	case KVMPPC_GS_CLASS_DWORD_REG:
214	case KVMPPC_GS_CLASS_WORD_REG:
215	case KVMPPC_GS_CLASS_VECTOR:
216	case KVMPPC_GS_CLASS_INTR:
217		break;
218	}
219
220	return flags;
221}
222EXPORT_SYMBOL_GPL(kvmppc_gsid_flags);
223
224/**
225 * kvmppc_gsid_size() - the size of a guest state ID
226 * @iden: guest state ID
227 *
228 * Returns the size of guest state ID.
229 */
230u16 kvmppc_gsid_size(u16 iden)
231{
232	int type;
233
234	type = kvmppc_gsid_type(iden);
235	if (type == -1)
236		return 0;
237
238	if (type >= __KVMPPC_GSE_TYPE_MAX)
239		return 0;
240
241	return kvmppc_gse_iden_len[type];
242}
243EXPORT_SYMBOL_GPL(kvmppc_gsid_size);
244
245/**
246 * kvmppc_gsid_mask() - the settable bits of a guest state ID
247 * @iden: guest state ID
248 *
249 * Returns a mask of settable bits for a guest state ID.
250 */
251u64 kvmppc_gsid_mask(u16 iden)
252{
253	u64 mask = ~0ull;
254
255	switch (iden) {
256	case KVMPPC_GSID_LPCR:
257		mask = LPCR_DPFD | LPCR_ILE | LPCR_AIL | LPCR_LD | LPCR_MER |
258		       LPCR_GTSE;
259		break;
260	case KVMPPC_GSID_MSR:
261		mask = ~(MSR_HV | MSR_S | MSR_ME);
262		break;
263	}
264
265	return mask;
266}
267EXPORT_SYMBOL_GPL(kvmppc_gsid_mask);
268
269/**
270 * __kvmppc_gse_put() - add a guest state element to a buffer
271 * @gsb: buffer to the element to
272 * @iden: guest state ID
273 * @size: length of data
274 * @data: pointer to data
275 */
276int __kvmppc_gse_put(struct kvmppc_gs_buff *gsb, u16 iden, u16 size,
277		     const void *data)
278{
279	struct kvmppc_gs_elem *gse;
280	u16 total_size;
281
282	total_size = sizeof(*gse) + size;
283	if (total_size + kvmppc_gsb_len(gsb) > kvmppc_gsb_capacity(gsb))
284		return -ENOMEM;
285
286	if (kvmppc_gsid_size(iden) != size)
287		return -EINVAL;
288
289	gse = kvmppc_gsb_put(gsb, total_size);
290	gse->iden = cpu_to_be16(iden);
291	gse->len = cpu_to_be16(size);
292	memcpy(gse->data, data, size);
293
294	return 0;
295}
296EXPORT_SYMBOL_GPL(__kvmppc_gse_put);
297
298/**
299 * kvmppc_gse_parse() - create a parse map from a guest state buffer
300 * @gsp: guest state parser
301 * @gsb: guest state buffer
302 */
303int kvmppc_gse_parse(struct kvmppc_gs_parser *gsp, struct kvmppc_gs_buff *gsb)
304{
305	struct kvmppc_gs_elem *curr;
306	int rem, i;
307
308	kvmppc_gsb_for_each_elem(i, curr, gsb, rem) {
309		if (kvmppc_gse_len(curr) !=
310		    kvmppc_gsid_size(kvmppc_gse_iden(curr)))
311			return -EINVAL;
312		kvmppc_gsp_insert(gsp, kvmppc_gse_iden(curr), curr);
313	}
314
315	if (kvmppc_gsb_nelems(gsb) != i)
316		return -EINVAL;
317	return 0;
318}
319EXPORT_SYMBOL_GPL(kvmppc_gse_parse);
320
321static inline int kvmppc_gse_flatten_iden(u16 iden)
322{
323	int bit = 0;
324	int class;
325
326	class = kvmppc_gsid_class(iden);
327
328	if (class == KVMPPC_GS_CLASS_GUESTWIDE) {
329		bit += iden - KVMPPC_GSE_GUESTWIDE_START;
330		return bit;
331	}
332
333	bit += KVMPPC_GSE_GUESTWIDE_COUNT;
334
335	if (class == KVMPPC_GS_CLASS_HOSTWIDE) {
336		bit += iden - KVMPPC_GSE_HOSTWIDE_START;
337		return bit;
338	}
339
340	bit += KVMPPC_GSE_HOSTWIDE_COUNT;
341
342	if (class == KVMPPC_GS_CLASS_META) {
343		bit += iden - KVMPPC_GSE_META_START;
344		return bit;
345	}
346
347	bit += KVMPPC_GSE_META_COUNT;
348
349	if (class == KVMPPC_GS_CLASS_DWORD_REG) {
350		bit += iden - KVMPPC_GSE_DW_REGS_START;
351		return bit;
352	}
353
354	bit += KVMPPC_GSE_DW_REGS_COUNT;
355
356	if (class == KVMPPC_GS_CLASS_WORD_REG) {
357		bit += iden - KVMPPC_GSE_W_REGS_START;
358		return bit;
359	}
360
361	bit += KVMPPC_GSE_W_REGS_COUNT;
362
363	if (class == KVMPPC_GS_CLASS_VECTOR) {
364		bit += iden - KVMPPC_GSE_VSRS_START;
365		return bit;
366	}
367
368	bit += KVMPPC_GSE_VSRS_COUNT;
369
370	if (class == KVMPPC_GS_CLASS_INTR) {
371		bit += iden - KVMPPC_GSE_INTR_REGS_START;
372		return bit;
373	}
374
375	return 0;
376}
377
378static inline u16 kvmppc_gse_unflatten_iden(int bit)
379{
380	u16 iden;
381
382	if (bit < KVMPPC_GSE_GUESTWIDE_COUNT) {
383		iden = KVMPPC_GSE_GUESTWIDE_START + bit;
384		return iden;
385	}
386	bit -= KVMPPC_GSE_GUESTWIDE_COUNT;
387
388	if (bit < KVMPPC_GSE_HOSTWIDE_COUNT) {
389		iden = KVMPPC_GSE_HOSTWIDE_START + bit;
390		return iden;
391	}
392	bit -= KVMPPC_GSE_HOSTWIDE_COUNT;
393
394	if (bit < KVMPPC_GSE_META_COUNT) {
395		iden = KVMPPC_GSE_META_START + bit;
396		return iden;
397	}
398	bit -= KVMPPC_GSE_META_COUNT;
399
400	if (bit < KVMPPC_GSE_DW_REGS_COUNT) {
401		iden = KVMPPC_GSE_DW_REGS_START + bit;
402		return iden;
403	}
404	bit -= KVMPPC_GSE_DW_REGS_COUNT;
405
406	if (bit < KVMPPC_GSE_W_REGS_COUNT) {
407		iden = KVMPPC_GSE_W_REGS_START + bit;
408		return iden;
409	}
410	bit -= KVMPPC_GSE_W_REGS_COUNT;
411
412	if (bit < KVMPPC_GSE_VSRS_COUNT) {
413		iden = KVMPPC_GSE_VSRS_START + bit;
414		return iden;
415	}
416	bit -= KVMPPC_GSE_VSRS_COUNT;
417
418	if (bit < KVMPPC_GSE_IDEN_COUNT) {
419		iden = KVMPPC_GSE_INTR_REGS_START + bit;
420		return iden;
421	}
422
423	return 0;
424}
425
426/**
427 * kvmppc_gsp_insert() - add a mapping from an guest state ID to an element
428 * @gsp: guest state parser
429 * @iden: guest state id (key)
430 * @gse: guest state element (value)
431 */
432void kvmppc_gsp_insert(struct kvmppc_gs_parser *gsp, u16 iden,
433		       struct kvmppc_gs_elem *gse)
434{
435	int i;
436
437	i = kvmppc_gse_flatten_iden(iden);
438	kvmppc_gsbm_set(&gsp->iterator, iden);
439	gsp->gses[i] = gse;
440}
441EXPORT_SYMBOL_GPL(kvmppc_gsp_insert);
442
443/**
444 * kvmppc_gsp_lookup() - lookup an element from a guest state ID
445 * @gsp: guest state parser
446 * @iden: guest state ID (key)
447 *
448 * Returns the guest state element if present.
449 */
450struct kvmppc_gs_elem *kvmppc_gsp_lookup(struct kvmppc_gs_parser *gsp, u16 iden)
451{
452	int i;
453
454	i = kvmppc_gse_flatten_iden(iden);
455	return gsp->gses[i];
456}
457EXPORT_SYMBOL_GPL(kvmppc_gsp_lookup);
458
459/**
460 * kvmppc_gsbm_set() - set the guest state ID
461 * @gsbm: guest state bitmap
462 * @iden: guest state ID
463 */
464void kvmppc_gsbm_set(struct kvmppc_gs_bitmap *gsbm, u16 iden)
465{
466	set_bit(kvmppc_gse_flatten_iden(iden), gsbm->bitmap);
467}
468EXPORT_SYMBOL_GPL(kvmppc_gsbm_set);
469
470/**
471 * kvmppc_gsbm_clear() - clear the guest state ID
472 * @gsbm: guest state bitmap
473 * @iden: guest state ID
474 */
475void kvmppc_gsbm_clear(struct kvmppc_gs_bitmap *gsbm, u16 iden)
476{
477	clear_bit(kvmppc_gse_flatten_iden(iden), gsbm->bitmap);
478}
479EXPORT_SYMBOL_GPL(kvmppc_gsbm_clear);
480
481/**
482 * kvmppc_gsbm_test() - test the guest state ID
483 * @gsbm: guest state bitmap
484 * @iden: guest state ID
485 */
486bool kvmppc_gsbm_test(struct kvmppc_gs_bitmap *gsbm, u16 iden)
487{
488	return test_bit(kvmppc_gse_flatten_iden(iden), gsbm->bitmap);
489}
490EXPORT_SYMBOL_GPL(kvmppc_gsbm_test);
491
492/**
493 * kvmppc_gsbm_next() - return the next set guest state ID
494 * @gsbm: guest state bitmap
495 * @prev: last guest state ID
496 */
497u16 kvmppc_gsbm_next(struct kvmppc_gs_bitmap *gsbm, u16 prev)
498{
499	int bit, pbit;
500
501	pbit = prev ? kvmppc_gse_flatten_iden(prev) + 1 : 0;
502	bit = find_next_bit(gsbm->bitmap, KVMPPC_GSE_IDEN_COUNT, pbit);
503
504	if (bit < KVMPPC_GSE_IDEN_COUNT)
505		return kvmppc_gse_unflatten_iden(bit);
506	return 0;
507}
508EXPORT_SYMBOL_GPL(kvmppc_gsbm_next);
509
510/**
511 * kvmppc_gsm_init() - initialize a guest state message
512 * @gsm: guest state message
513 * @ops: callbacks
514 * @data: private data
515 * @flags: guest wide or thread wide
516 */
517int kvmppc_gsm_init(struct kvmppc_gs_msg *gsm, struct kvmppc_gs_msg_ops *ops,
518		    void *data, unsigned long flags)
519{
520	memset(gsm, 0, sizeof(*gsm));
521	gsm->ops = ops;
522	gsm->data = data;
523	gsm->flags = flags;
524
525	return 0;
526}
527EXPORT_SYMBOL_GPL(kvmppc_gsm_init);
528
529/**
530 * kvmppc_gsm_new() - creates a new guest state message
531 * @ops: callbacks
532 * @data: private data
533 * @flags: guest wide or thread wide
534 * @gfp_flags: GFP allocation flags
535 *
536 * Returns an initialized guest state message.
537 */
538struct kvmppc_gs_msg *kvmppc_gsm_new(struct kvmppc_gs_msg_ops *ops, void *data,
539				     unsigned long flags, gfp_t gfp_flags)
540{
541	struct kvmppc_gs_msg *gsm;
542
543	gsm = kzalloc(sizeof(*gsm), gfp_flags);
544	if (!gsm)
545		return NULL;
546
547	kvmppc_gsm_init(gsm, ops, data, flags);
548
549	return gsm;
550}
551EXPORT_SYMBOL_GPL(kvmppc_gsm_new);
552
553/**
554 * kvmppc_gsm_size() - creates a new guest state message
555 * @gsm: self
556 *
557 * Returns the size required for the message.
558 */
559size_t kvmppc_gsm_size(struct kvmppc_gs_msg *gsm)
560{
561	if (gsm->ops->get_size)
562		return gsm->ops->get_size(gsm);
563	return 0;
564}
565EXPORT_SYMBOL_GPL(kvmppc_gsm_size);
566
567/**
568 * kvmppc_gsm_free() - free guest state message
569 * @gsm: guest state message
570 *
571 * Returns the size required for the message.
572 */
573void kvmppc_gsm_free(struct kvmppc_gs_msg *gsm)
574{
575	kfree(gsm);
576}
577EXPORT_SYMBOL_GPL(kvmppc_gsm_free);
578
579/**
580 * kvmppc_gsm_fill_info() - serialises message to guest state buffer format
581 * @gsm: self
582 * @gsb: buffer to serialise into
583 */
584int kvmppc_gsm_fill_info(struct kvmppc_gs_msg *gsm, struct kvmppc_gs_buff *gsb)
585{
586	if (!gsm->ops->fill_info)
587		return -EINVAL;
588
589	return gsm->ops->fill_info(gsb, gsm);
590}
591EXPORT_SYMBOL_GPL(kvmppc_gsm_fill_info);
592
593/**
594 * kvmppc_gsm_refresh_info() - deserialises from guest state buffer
595 * @gsm: self
596 * @gsb: buffer to serialise from
597 */
598int kvmppc_gsm_refresh_info(struct kvmppc_gs_msg *gsm,
599			    struct kvmppc_gs_buff *gsb)
600{
601	if (!gsm->ops->fill_info)
602		return -EINVAL;
603
604	return gsm->ops->refresh_info(gsm, gsb);
605}
606EXPORT_SYMBOL_GPL(kvmppc_gsm_refresh_info);
607
608/**
609 * kvmppc_gsb_send - send all elements in the buffer to the hypervisor.
610 * @gsb: guest state buffer
611 * @flags: guest wide or thread wide
612 *
613 * Performs the H_GUEST_SET_STATE hcall for the guest state buffer.
614 */
615int kvmppc_gsb_send(struct kvmppc_gs_buff *gsb, unsigned long flags)
616{
617	unsigned long hflags = 0;
618	unsigned long i;
619	int rc;
620
621	if (kvmppc_gsb_nelems(gsb) == 0)
622		return 0;
623
624	if (flags & KVMPPC_GS_FLAGS_WIDE)
625		hflags |= H_GUEST_FLAGS_WIDE;
626	if (flags & KVMPPC_GS_FLAGS_HOST_WIDE)
627		hflags |= H_GUEST_FLAGS_HOST_WIDE;
628
629	rc = plpar_guest_set_state(hflags, gsb->guest_id, gsb->vcpu_id,
630				   __pa(gsb->hdr), gsb->capacity, &i);
631	return rc;
632}
633EXPORT_SYMBOL_GPL(kvmppc_gsb_send);
634
635/**
636 * kvmppc_gsb_recv - request all elements in the buffer have their value
637 * updated.
638 * @gsb: guest state buffer
639 * @flags: guest wide or thread wide
640 *
641 * Performs the H_GUEST_GET_STATE hcall for the guest state buffer.
642 * After returning from the hcall the guest state elements that were
643 * present in the buffer will have updated values from the hypervisor.
644 */
645int kvmppc_gsb_recv(struct kvmppc_gs_buff *gsb, unsigned long flags)
646{
647	unsigned long hflags = 0;
648	unsigned long i;
649	int rc;
650
651	if (flags & KVMPPC_GS_FLAGS_WIDE)
652		hflags |= H_GUEST_FLAGS_WIDE;
653	if (flags & KVMPPC_GS_FLAGS_HOST_WIDE)
654		hflags |= H_GUEST_FLAGS_HOST_WIDE;
655
656	rc = plpar_guest_get_state(hflags, gsb->guest_id, gsb->vcpu_id,
657				   __pa(gsb->hdr), gsb->capacity, &i);
658	return rc;
659}
660EXPORT_SYMBOL_GPL(kvmppc_gsb_recv);