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 */
kvmppc_gsb_new(size_t size,unsigned long guest_id,unsigned long vcpu_id,gfp_t flags)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 */
kvmppc_gsb_free(struct kvmppc_gs_buff * gsb)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 */
kvmppc_gsb_put(struct kvmppc_gs_buff * gsb,size_t size)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
kvmppc_gsid_class(u16 iden)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
kvmppc_gsid_type(u16 iden)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 */
kvmppc_gsid_flags(u16 iden)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 */
kvmppc_gsid_size(u16 iden)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 */
kvmppc_gsid_mask(u16 iden)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 */
__kvmppc_gse_put(struct kvmppc_gs_buff * gsb,u16 iden,u16 size,const void * data)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 */
kvmppc_gse_parse(struct kvmppc_gs_parser * gsp,struct kvmppc_gs_buff * gsb)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
kvmppc_gse_flatten_iden(u16 iden)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
kvmppc_gse_unflatten_iden(int bit)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 */
kvmppc_gsp_insert(struct kvmppc_gs_parser * gsp,u16 iden,struct kvmppc_gs_elem * gse)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 */
kvmppc_gsp_lookup(struct kvmppc_gs_parser * gsp,u16 iden)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 */
kvmppc_gsbm_set(struct kvmppc_gs_bitmap * gsbm,u16 iden)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 */
kvmppc_gsbm_clear(struct kvmppc_gs_bitmap * gsbm,u16 iden)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 */
kvmppc_gsbm_test(struct kvmppc_gs_bitmap * gsbm,u16 iden)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 */
kvmppc_gsbm_next(struct kvmppc_gs_bitmap * gsbm,u16 prev)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 */
kvmppc_gsm_init(struct kvmppc_gs_msg * gsm,struct kvmppc_gs_msg_ops * ops,void * data,unsigned long flags)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 */
kvmppc_gsm_new(struct kvmppc_gs_msg_ops * ops,void * data,unsigned long flags,gfp_t gfp_flags)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 */
kvmppc_gsm_size(struct kvmppc_gs_msg * gsm)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 */
kvmppc_gsm_free(struct kvmppc_gs_msg * gsm)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 */
kvmppc_gsm_fill_info(struct kvmppc_gs_msg * gsm,struct kvmppc_gs_buff * gsb)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 */
kvmppc_gsm_refresh_info(struct kvmppc_gs_msg * gsm,struct kvmppc_gs_buff * gsb)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 */
kvmppc_gsb_send(struct kvmppc_gs_buff * gsb,unsigned long flags)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 */
kvmppc_gsb_recv(struct kvmppc_gs_buff * gsb,unsigned long flags)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