xref: /linux/arch/powerpc/kvm/guest-state-buffer.c (revision 9738280aae592b579a25b5b1b6584c894827d3c7) 
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 
8 static 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  */
26 struct 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 
49 free:
50 	kfree(gsb);
51 	return NULL;
52 }
53 EXPORT_SYMBOL_GPL(kvmppc_gsb_new);
54 
55 /**
56  * kvmppc_gsb_free() - free a guest state buffer
57  * @gsb: guest state buffer
58  */
59 void kvmppc_gsb_free(struct kvmppc_gs_buff *gsb)
60 {
61 	kfree(gsb->hdr);
62 	kfree(gsb);
63 }
64 EXPORT_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  */
76 void *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 }
87 EXPORT_SYMBOL_GPL(kvmppc_gsb_put);
88 
89 static 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 
120 static 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  */
201 unsigned 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 }
222 EXPORT_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  */
230 u16 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 }
243 EXPORT_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  */
251 u64 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 }
267 EXPORT_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  */
276 int __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 }
296 EXPORT_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  */
303 int 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 }
319 EXPORT_SYMBOL_GPL(kvmppc_gse_parse);
320 
321 static 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 
378 static 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  */
432 void 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 }
441 EXPORT_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  */
450 struct 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 }
457 EXPORT_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  */
464 void kvmppc_gsbm_set(struct kvmppc_gs_bitmap *gsbm, u16 iden)
465 {
466 	set_bit(kvmppc_gse_flatten_iden(iden), gsbm->bitmap);
467 }
468 EXPORT_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  */
475 void kvmppc_gsbm_clear(struct kvmppc_gs_bitmap *gsbm, u16 iden)
476 {
477 	clear_bit(kvmppc_gse_flatten_iden(iden), gsbm->bitmap);
478 }
479 EXPORT_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  */
486 bool kvmppc_gsbm_test(struct kvmppc_gs_bitmap *gsbm, u16 iden)
487 {
488 	return test_bit(kvmppc_gse_flatten_iden(iden), gsbm->bitmap);
489 }
490 EXPORT_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  */
497 u16 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 }
508 EXPORT_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  */
517 int 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 }
527 EXPORT_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  */
538 struct 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 }
551 EXPORT_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  */
559 size_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 }
565 EXPORT_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  */
573 void kvmppc_gsm_free(struct kvmppc_gs_msg *gsm)
574 {
575 	kfree(gsm);
576 }
577 EXPORT_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  */
584 int 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 }
591 EXPORT_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  */
598 int 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 }
606 EXPORT_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  */
615 int 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 }
633 EXPORT_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  */
645 int 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 }
660 EXPORT_SYMBOL_GPL(kvmppc_gsb_recv);
661