Loading...
1/* SPDX-License-Identifier: GPL-2.0 */
2/*
3 * Interface based on include/net/netlink.h
4 */
5#ifndef _ASM_POWERPC_GUEST_STATE_BUFFER_H
6#define _ASM_POWERPC_GUEST_STATE_BUFFER_H
7
8#include "asm/hvcall.h"
9#include <linux/gfp.h>
10#include <linux/bitmap.h>
11#include <asm/plpar_wrappers.h>
12
13/**************************************************************************
14 * Guest State Buffer Constants
15 **************************************************************************/
16/* Element without a value and any length */
17#define KVMPPC_GSID_BLANK 0x0000
18/* Size required for the L0's internal VCPU representation */
19#define KVMPPC_GSID_HOST_STATE_SIZE 0x0001
20 /* Minimum size for the H_GUEST_RUN_VCPU output buffer */
21#define KVMPPC_GSID_RUN_OUTPUT_MIN_SIZE 0x0002
22 /* "Logical" PVR value as defined in the PAPR */
23#define KVMPPC_GSID_LOGICAL_PVR 0x0003
24 /* L0 relative timebase offset */
25#define KVMPPC_GSID_TB_OFFSET 0x0004
26 /* Partition Scoped Page Table Info */
27#define KVMPPC_GSID_PARTITION_TABLE 0x0005
28 /* Process Table Info */
29#define KVMPPC_GSID_PROCESS_TABLE 0x0006
30
31/* H_GUEST_RUN_VCPU input buffer Info */
32#define KVMPPC_GSID_RUN_INPUT 0x0C00
33/* H_GUEST_RUN_VCPU output buffer Info */
34#define KVMPPC_GSID_RUN_OUTPUT 0x0C01
35#define KVMPPC_GSID_VPA 0x0C02
36
37#define KVMPPC_GSID_GPR(x) (0x1000 + (x))
38#define KVMPPC_GSID_HDEC_EXPIRY_TB 0x1020
39#define KVMPPC_GSID_NIA 0x1021
40#define KVMPPC_GSID_MSR 0x1022
41#define KVMPPC_GSID_LR 0x1023
42#define KVMPPC_GSID_XER 0x1024
43#define KVMPPC_GSID_CTR 0x1025
44#define KVMPPC_GSID_CFAR 0x1026
45#define KVMPPC_GSID_SRR0 0x1027
46#define KVMPPC_GSID_SRR1 0x1028
47#define KVMPPC_GSID_DAR 0x1029
48#define KVMPPC_GSID_DEC_EXPIRY_TB 0x102A
49#define KVMPPC_GSID_VTB 0x102B
50#define KVMPPC_GSID_LPCR 0x102C
51#define KVMPPC_GSID_HFSCR 0x102D
52#define KVMPPC_GSID_FSCR 0x102E
53#define KVMPPC_GSID_FPSCR 0x102F
54#define KVMPPC_GSID_DAWR0 0x1030
55#define KVMPPC_GSID_DAWR1 0x1031
56#define KVMPPC_GSID_CIABR 0x1032
57#define KVMPPC_GSID_PURR 0x1033
58#define KVMPPC_GSID_SPURR 0x1034
59#define KVMPPC_GSID_IC 0x1035
60#define KVMPPC_GSID_SPRG0 0x1036
61#define KVMPPC_GSID_SPRG1 0x1037
62#define KVMPPC_GSID_SPRG2 0x1038
63#define KVMPPC_GSID_SPRG3 0x1039
64#define KVMPPC_GSID_PPR 0x103A
65#define KVMPPC_GSID_MMCR(x) (0x103B + (x))
66#define KVMPPC_GSID_MMCRA 0x103F
67#define KVMPPC_GSID_SIER(x) (0x1040 + (x))
68#define KVMPPC_GSID_BESCR 0x1043
69#define KVMPPC_GSID_EBBHR 0x1044
70#define KVMPPC_GSID_EBBRR 0x1045
71#define KVMPPC_GSID_AMR 0x1046
72#define KVMPPC_GSID_IAMR 0x1047
73#define KVMPPC_GSID_AMOR 0x1048
74#define KVMPPC_GSID_UAMOR 0x1049
75#define KVMPPC_GSID_SDAR 0x104A
76#define KVMPPC_GSID_SIAR 0x104B
77#define KVMPPC_GSID_DSCR 0x104C
78#define KVMPPC_GSID_TAR 0x104D
79#define KVMPPC_GSID_DEXCR 0x104E
80#define KVMPPC_GSID_HDEXCR 0x104F
81#define KVMPPC_GSID_HASHKEYR 0x1050
82#define KVMPPC_GSID_HASHPKEYR 0x1051
83#define KVMPPC_GSID_CTRL 0x1052
84
85#define KVMPPC_GSID_CR 0x2000
86#define KVMPPC_GSID_PIDR 0x2001
87#define KVMPPC_GSID_DSISR 0x2002
88#define KVMPPC_GSID_VSCR 0x2003
89#define KVMPPC_GSID_VRSAVE 0x2004
90#define KVMPPC_GSID_DAWRX0 0x2005
91#define KVMPPC_GSID_DAWRX1 0x2006
92#define KVMPPC_GSID_PMC(x) (0x2007 + (x))
93#define KVMPPC_GSID_WORT 0x200D
94#define KVMPPC_GSID_PSPB 0x200E
95
96#define KVMPPC_GSID_VSRS(x) (0x3000 + (x))
97
98#define KVMPPC_GSID_HDAR 0xF000
99#define KVMPPC_GSID_HDSISR 0xF001
100#define KVMPPC_GSID_HEIR 0xF002
101#define KVMPPC_GSID_ASDR 0xF003
102
103#define KVMPPC_GSE_GUESTWIDE_START KVMPPC_GSID_BLANK
104#define KVMPPC_GSE_GUESTWIDE_END KVMPPC_GSID_PROCESS_TABLE
105#define KVMPPC_GSE_GUESTWIDE_COUNT \
106 (KVMPPC_GSE_GUESTWIDE_END - KVMPPC_GSE_GUESTWIDE_START + 1)
107
108#define KVMPPC_GSE_META_START KVMPPC_GSID_RUN_INPUT
109#define KVMPPC_GSE_META_END KVMPPC_GSID_VPA
110#define KVMPPC_GSE_META_COUNT (KVMPPC_GSE_META_END - KVMPPC_GSE_META_START + 1)
111
112#define KVMPPC_GSE_DW_REGS_START KVMPPC_GSID_GPR(0)
113#define KVMPPC_GSE_DW_REGS_END KVMPPC_GSID_CTRL
114#define KVMPPC_GSE_DW_REGS_COUNT \
115 (KVMPPC_GSE_DW_REGS_END - KVMPPC_GSE_DW_REGS_START + 1)
116
117#define KVMPPC_GSE_W_REGS_START KVMPPC_GSID_CR
118#define KVMPPC_GSE_W_REGS_END KVMPPC_GSID_PSPB
119#define KVMPPC_GSE_W_REGS_COUNT \
120 (KVMPPC_GSE_W_REGS_END - KVMPPC_GSE_W_REGS_START + 1)
121
122#define KVMPPC_GSE_VSRS_START KVMPPC_GSID_VSRS(0)
123#define KVMPPC_GSE_VSRS_END KVMPPC_GSID_VSRS(63)
124#define KVMPPC_GSE_VSRS_COUNT (KVMPPC_GSE_VSRS_END - KVMPPC_GSE_VSRS_START + 1)
125
126#define KVMPPC_GSE_INTR_REGS_START KVMPPC_GSID_HDAR
127#define KVMPPC_GSE_INTR_REGS_END KVMPPC_GSID_ASDR
128#define KVMPPC_GSE_INTR_REGS_COUNT \
129 (KVMPPC_GSE_INTR_REGS_END - KVMPPC_GSE_INTR_REGS_START + 1)
130
131#define KVMPPC_GSE_IDEN_COUNT \
132 (KVMPPC_GSE_GUESTWIDE_COUNT + KVMPPC_GSE_META_COUNT + \
133 KVMPPC_GSE_DW_REGS_COUNT + KVMPPC_GSE_W_REGS_COUNT + \
134 KVMPPC_GSE_VSRS_COUNT + KVMPPC_GSE_INTR_REGS_COUNT)
135
136/**
137 * Ranges of guest state buffer elements
138 */
139enum {
140 KVMPPC_GS_CLASS_GUESTWIDE = 0x01,
141 KVMPPC_GS_CLASS_META = 0x02,
142 KVMPPC_GS_CLASS_DWORD_REG = 0x04,
143 KVMPPC_GS_CLASS_WORD_REG = 0x08,
144 KVMPPC_GS_CLASS_VECTOR = 0x10,
145 KVMPPC_GS_CLASS_INTR = 0x20,
146};
147
148/**
149 * Types of guest state buffer elements
150 */
151enum {
152 KVMPPC_GSE_BE32,
153 KVMPPC_GSE_BE64,
154 KVMPPC_GSE_VEC128,
155 KVMPPC_GSE_PARTITION_TABLE,
156 KVMPPC_GSE_PROCESS_TABLE,
157 KVMPPC_GSE_BUFFER,
158 __KVMPPC_GSE_TYPE_MAX,
159};
160
161/**
162 * Flags for guest state elements
163 */
164enum {
165 KVMPPC_GS_FLAGS_WIDE = 0x01,
166};
167
168/**
169 * struct kvmppc_gs_part_table - deserialized partition table information
170 * element
171 * @address: start of the partition table
172 * @ea_bits: number of bits in the effective address
173 * @gpd_size: root page directory size
174 */
175struct kvmppc_gs_part_table {
176 u64 address;
177 u64 ea_bits;
178 u64 gpd_size;
179};
180
181/**
182 * struct kvmppc_gs_proc_table - deserialized process table information element
183 * @address: start of the process table
184 * @gpd_size: process table size
185 */
186struct kvmppc_gs_proc_table {
187 u64 address;
188 u64 gpd_size;
189};
190
191/**
192 * struct kvmppc_gs_buff_info - deserialized meta guest state buffer information
193 * @address: start of the guest state buffer
194 * @size: size of the guest state buffer
195 */
196struct kvmppc_gs_buff_info {
197 u64 address;
198 u64 size;
199};
200
201/**
202 * struct kvmppc_gs_header - serialized guest state buffer header
203 * @nelem: count of guest state elements in the buffer
204 * @data: start of the stream of elements in the buffer
205 */
206struct kvmppc_gs_header {
207 __be32 nelems;
208 char data[];
209} __packed;
210
211/**
212 * struct kvmppc_gs_elem - serialized guest state buffer element
213 * @iden: Guest State ID
214 * @len: length of data
215 * @data: the guest state buffer element's value
216 */
217struct kvmppc_gs_elem {
218 __be16 iden;
219 __be16 len;
220 char data[];
221} __packed;
222
223/**
224 * struct kvmppc_gs_buff - a guest state buffer with metadata.
225 * @capacity: total length of the buffer
226 * @len: current length of the elements and header
227 * @guest_id: guest id associated with the buffer
228 * @vcpu_id: vcpu_id associated with the buffer
229 * @hdr: the serialised guest state buffer
230 */
231struct kvmppc_gs_buff {
232 size_t capacity;
233 size_t len;
234 unsigned long guest_id;
235 unsigned long vcpu_id;
236 struct kvmppc_gs_header *hdr;
237};
238
239/**
240 * struct kvmppc_gs_bitmap - a bitmap for element ids
241 * @bitmap: a bitmap large enough for all Guest State IDs
242 */
243struct kvmppc_gs_bitmap {
244 /* private: */
245 DECLARE_BITMAP(bitmap, KVMPPC_GSE_IDEN_COUNT);
246};
247
248/**
249 * struct kvmppc_gs_parser - a map of element ids to locations in a buffer
250 * @iterator: bitmap used for iterating
251 * @gses: contains the pointers to elements
252 *
253 * A guest state parser is used for deserialising a guest state buffer.
254 * Given a buffer, it then allows looking up guest state elements using
255 * a guest state id.
256 */
257struct kvmppc_gs_parser {
258 /* private: */
259 struct kvmppc_gs_bitmap iterator;
260 struct kvmppc_gs_elem *gses[KVMPPC_GSE_IDEN_COUNT];
261};
262
263enum {
264 GSM_GUEST_WIDE = 0x1,
265 GSM_SEND = 0x2,
266 GSM_RECEIVE = 0x4,
267 GSM_GSB_OWNER = 0x8,
268};
269
270struct kvmppc_gs_msg;
271
272/**
273 * struct kvmppc_gs_msg_ops - guest state message behavior
274 * @get_size: maximum size required for the message data
275 * @fill_info: serializes to the guest state buffer format
276 * @refresh_info: dserializes from the guest state buffer format
277 */
278struct kvmppc_gs_msg_ops {
279 size_t (*get_size)(struct kvmppc_gs_msg *gsm);
280 int (*fill_info)(struct kvmppc_gs_buff *gsb, struct kvmppc_gs_msg *gsm);
281 int (*refresh_info)(struct kvmppc_gs_msg *gsm,
282 struct kvmppc_gs_buff *gsb);
283};
284
285/**
286 * struct kvmppc_gs_msg - a guest state message
287 * @bitmap: the guest state ids that should be included
288 * @ops: modify message behavior for reading and writing to buffers
289 * @flags: guest wide or thread wide
290 * @data: location where buffer data will be written to or from.
291 *
292 * A guest state message is allows flexibility in sending in receiving data
293 * in a guest state buffer format.
294 */
295struct kvmppc_gs_msg {
296 struct kvmppc_gs_bitmap bitmap;
297 struct kvmppc_gs_msg_ops *ops;
298 unsigned long flags;
299 void *data;
300};
301
302/**************************************************************************
303 * Guest State IDs
304 **************************************************************************/
305
306u16 kvmppc_gsid_size(u16 iden);
307unsigned long kvmppc_gsid_flags(u16 iden);
308u64 kvmppc_gsid_mask(u16 iden);
309
310/**************************************************************************
311 * Guest State Buffers
312 **************************************************************************/
313struct kvmppc_gs_buff *kvmppc_gsb_new(size_t size, unsigned long guest_id,
314 unsigned long vcpu_id, gfp_t flags);
315void kvmppc_gsb_free(struct kvmppc_gs_buff *gsb);
316void *kvmppc_gsb_put(struct kvmppc_gs_buff *gsb, size_t size);
317int kvmppc_gsb_send(struct kvmppc_gs_buff *gsb, unsigned long flags);
318int kvmppc_gsb_recv(struct kvmppc_gs_buff *gsb, unsigned long flags);
319
320/**
321 * kvmppc_gsb_header() - the header of a guest state buffer
322 * @gsb: guest state buffer
323 *
324 * Returns a pointer to the buffer header.
325 */
326static inline struct kvmppc_gs_header *
327kvmppc_gsb_header(struct kvmppc_gs_buff *gsb)
328{
329 return gsb->hdr;
330}
331
332/**
333 * kvmppc_gsb_data() - the elements of a guest state buffer
334 * @gsb: guest state buffer
335 *
336 * Returns a pointer to the first element of the buffer data.
337 */
338static inline struct kvmppc_gs_elem *kvmppc_gsb_data(struct kvmppc_gs_buff *gsb)
339{
340 return (struct kvmppc_gs_elem *)kvmppc_gsb_header(gsb)->data;
341}
342
343/**
344 * kvmppc_gsb_len() - the current length of a guest state buffer
345 * @gsb: guest state buffer
346 *
347 * Returns the length including the header of a buffer.
348 */
349static inline size_t kvmppc_gsb_len(struct kvmppc_gs_buff *gsb)
350{
351 return gsb->len;
352}
353
354/**
355 * kvmppc_gsb_capacity() - the capacity of a guest state buffer
356 * @gsb: guest state buffer
357 *
358 * Returns the capacity of a buffer.
359 */
360static inline size_t kvmppc_gsb_capacity(struct kvmppc_gs_buff *gsb)
361{
362 return gsb->capacity;
363}
364
365/**
366 * kvmppc_gsb_paddress() - the physical address of buffer
367 * @gsb: guest state buffer
368 *
369 * Returns the physical address of the buffer.
370 */
371static inline u64 kvmppc_gsb_paddress(struct kvmppc_gs_buff *gsb)
372{
373 return __pa(kvmppc_gsb_header(gsb));
374}
375
376/**
377 * kvmppc_gsb_nelems() - the number of elements in a buffer
378 * @gsb: guest state buffer
379 *
380 * Returns the number of elements in a buffer
381 */
382static inline u32 kvmppc_gsb_nelems(struct kvmppc_gs_buff *gsb)
383{
384 return be32_to_cpu(kvmppc_gsb_header(gsb)->nelems);
385}
386
387/**
388 * kvmppc_gsb_reset() - empty a guest state buffer
389 * @gsb: guest state buffer
390 *
391 * Reset the number of elements and length of buffer to empty.
392 */
393static inline void kvmppc_gsb_reset(struct kvmppc_gs_buff *gsb)
394{
395 kvmppc_gsb_header(gsb)->nelems = cpu_to_be32(0);
396 gsb->len = sizeof(struct kvmppc_gs_header);
397}
398
399/**
400 * kvmppc_gsb_data_len() - the length of a buffer excluding the header
401 * @gsb: guest state buffer
402 *
403 * Returns the length of a buffer excluding the header
404 */
405static inline size_t kvmppc_gsb_data_len(struct kvmppc_gs_buff *gsb)
406{
407 return gsb->len - sizeof(struct kvmppc_gs_header);
408}
409
410/**
411 * kvmppc_gsb_data_cap() - the capacity of a buffer excluding the header
412 * @gsb: guest state buffer
413 *
414 * Returns the capacity of a buffer excluding the header
415 */
416static inline size_t kvmppc_gsb_data_cap(struct kvmppc_gs_buff *gsb)
417{
418 return gsb->capacity - sizeof(struct kvmppc_gs_header);
419}
420
421/**
422 * kvmppc_gsb_for_each_elem - iterate over the elements in a buffer
423 * @i: loop counter
424 * @pos: set to current element
425 * @gsb: guest state buffer
426 * @rem: initialized to buffer capacity, holds bytes currently remaining in
427 * stream
428 */
429#define kvmppc_gsb_for_each_elem(i, pos, gsb, rem) \
430 kvmppc_gse_for_each_elem(i, kvmppc_gsb_nelems(gsb), pos, \
431 kvmppc_gsb_data(gsb), \
432 kvmppc_gsb_data_cap(gsb), rem)
433
434/**************************************************************************
435 * Guest State Elements
436 **************************************************************************/
437
438/**
439 * kvmppc_gse_iden() - guest state ID of element
440 * @gse: guest state element
441 *
442 * Return the guest state ID in host endianness.
443 */
444static inline u16 kvmppc_gse_iden(const struct kvmppc_gs_elem *gse)
445{
446 return be16_to_cpu(gse->iden);
447}
448
449/**
450 * kvmppc_gse_len() - length of guest state element data
451 * @gse: guest state element
452 *
453 * Returns the length of guest state element data
454 */
455static inline u16 kvmppc_gse_len(const struct kvmppc_gs_elem *gse)
456{
457 return be16_to_cpu(gse->len);
458}
459
460/**
461 * kvmppc_gse_total_len() - total length of guest state element
462 * @gse: guest state element
463 *
464 * Returns the length of the data plus the ID and size header.
465 */
466static inline u16 kvmppc_gse_total_len(const struct kvmppc_gs_elem *gse)
467{
468 return be16_to_cpu(gse->len) + sizeof(*gse);
469}
470
471/**
472 * kvmppc_gse_total_size() - space needed for a given data length
473 * @size: data length
474 *
475 * Returns size plus the space needed for the ID and size header.
476 */
477static inline u16 kvmppc_gse_total_size(u16 size)
478{
479 return sizeof(struct kvmppc_gs_elem) + size;
480}
481
482/**
483 * kvmppc_gse_data() - pointer to data of a guest state element
484 * @gse: guest state element
485 *
486 * Returns a pointer to the beginning of guest state element data.
487 */
488static inline void *kvmppc_gse_data(const struct kvmppc_gs_elem *gse)
489{
490 return (void *)gse->data;
491}
492
493/**
494 * kvmppc_gse_ok() - checks space exists for guest state element
495 * @gse: guest state element
496 * @remaining: bytes of space remaining
497 *
498 * Returns true if the guest state element can fit in remaining space.
499 */
500static inline bool kvmppc_gse_ok(const struct kvmppc_gs_elem *gse,
501 int remaining)
502{
503 return remaining >= kvmppc_gse_total_len(gse);
504}
505
506/**
507 * kvmppc_gse_next() - iterate to the next guest state element in a stream
508 * @gse: stream of guest state elements
509 * @remaining: length of the guest element stream
510 *
511 * Returns the next guest state element in a stream of elements. The length of
512 * the stream is updated in remaining.
513 */
514static inline struct kvmppc_gs_elem *
515kvmppc_gse_next(const struct kvmppc_gs_elem *gse, int *remaining)
516{
517 int len = sizeof(*gse) + kvmppc_gse_len(gse);
518
519 *remaining -= len;
520 return (struct kvmppc_gs_elem *)(gse->data + kvmppc_gse_len(gse));
521}
522
523/**
524 * kvmppc_gse_for_each_elem - iterate over a stream of guest state elements
525 * @i: loop counter
526 * @max: number of elements
527 * @pos: set to current element
528 * @head: head of elements
529 * @len: length of the stream
530 * @rem: initialized to len, holds bytes currently remaining elements
531 */
532#define kvmppc_gse_for_each_elem(i, max, pos, head, len, rem) \
533 for (i = 0, pos = head, rem = len; kvmppc_gse_ok(pos, rem) && i < max; \
534 pos = kvmppc_gse_next(pos, &(rem)), i++)
535
536int __kvmppc_gse_put(struct kvmppc_gs_buff *gsb, u16 iden, u16 size,
537 const void *data);
538int kvmppc_gse_parse(struct kvmppc_gs_parser *gsp, struct kvmppc_gs_buff *gsb);
539
540/**
541 * kvmppc_gse_put_be32() - add a be32 guest state element to a buffer
542 * @gsb: guest state buffer to add element to
543 * @iden: guest state ID
544 * @val: big endian value
545 */
546static inline int kvmppc_gse_put_be32(struct kvmppc_gs_buff *gsb, u16 iden,
547 __be32 val)
548{
549 __be32 tmp;
550
551 tmp = val;
552 return __kvmppc_gse_put(gsb, iden, sizeof(__be32), &tmp);
553}
554
555/**
556 * kvmppc_gse_put_u32() - add a host endian 32bit int guest state element to a
557 * buffer
558 * @gsb: guest state buffer to add element to
559 * @iden: guest state ID
560 * @val: host endian value
561 */
562static inline int kvmppc_gse_put_u32(struct kvmppc_gs_buff *gsb, u16 iden,
563 u32 val)
564{
565 __be32 tmp;
566
567 val &= kvmppc_gsid_mask(iden);
568 tmp = cpu_to_be32(val);
569 return kvmppc_gse_put_be32(gsb, iden, tmp);
570}
571
572/**
573 * kvmppc_gse_put_be64() - add a be64 guest state element to a buffer
574 * @gsb: guest state buffer to add element to
575 * @iden: guest state ID
576 * @val: big endian value
577 */
578static inline int kvmppc_gse_put_be64(struct kvmppc_gs_buff *gsb, u16 iden,
579 __be64 val)
580{
581 __be64 tmp;
582
583 tmp = val;
584 return __kvmppc_gse_put(gsb, iden, sizeof(__be64), &tmp);
585}
586
587/**
588 * kvmppc_gse_put_u64() - add a host endian 64bit guest state element to a
589 * buffer
590 * @gsb: guest state buffer to add element to
591 * @iden: guest state ID
592 * @val: host endian value
593 */
594static inline int kvmppc_gse_put_u64(struct kvmppc_gs_buff *gsb, u16 iden,
595 u64 val)
596{
597 __be64 tmp;
598
599 val &= kvmppc_gsid_mask(iden);
600 tmp = cpu_to_be64(val);
601 return kvmppc_gse_put_be64(gsb, iden, tmp);
602}
603
604/**
605 * __kvmppc_gse_put_reg() - add a register type guest state element to a buffer
606 * @gsb: guest state buffer to add element to
607 * @iden: guest state ID
608 * @val: host endian value
609 *
610 * Adds a register type guest state element. Uses the guest state ID for
611 * determining the length of the guest element. If the guest state ID has
612 * bits that can not be set they will be cleared.
613 */
614static inline int __kvmppc_gse_put_reg(struct kvmppc_gs_buff *gsb, u16 iden,
615 u64 val)
616{
617 val &= kvmppc_gsid_mask(iden);
618 if (kvmppc_gsid_size(iden) == sizeof(u64))
619 return kvmppc_gse_put_u64(gsb, iden, val);
620
621 if (kvmppc_gsid_size(iden) == sizeof(u32)) {
622 u32 tmp;
623
624 tmp = (u32)val;
625 if (tmp != val)
626 return -EINVAL;
627
628 return kvmppc_gse_put_u32(gsb, iden, tmp);
629 }
630 return -EINVAL;
631}
632
633/**
634 * kvmppc_gse_put_vector128() - add a vector guest state element to a buffer
635 * @gsb: guest state buffer to add element to
636 * @iden: guest state ID
637 * @val: 16 byte vector value
638 */
639static inline int kvmppc_gse_put_vector128(struct kvmppc_gs_buff *gsb, u16 iden,
640 vector128 *val)
641{
642 __be64 tmp[2] = { 0 };
643 union {
644 __vector128 v;
645 u64 dw[2];
646 } u;
647
648 u.v = *val;
649 tmp[0] = cpu_to_be64(u.dw[TS_FPROFFSET]);
650#ifdef CONFIG_VSX
651 tmp[1] = cpu_to_be64(u.dw[TS_VSRLOWOFFSET]);
652#endif
653 return __kvmppc_gse_put(gsb, iden, sizeof(tmp), &tmp);
654}
655
656/**
657 * kvmppc_gse_put_part_table() - add a partition table guest state element to a
658 * buffer
659 * @gsb: guest state buffer to add element to
660 * @iden: guest state ID
661 * @val: partition table value
662 */
663static inline int kvmppc_gse_put_part_table(struct kvmppc_gs_buff *gsb,
664 u16 iden,
665 struct kvmppc_gs_part_table val)
666{
667 __be64 tmp[3];
668
669 tmp[0] = cpu_to_be64(val.address);
670 tmp[1] = cpu_to_be64(val.ea_bits);
671 tmp[2] = cpu_to_be64(val.gpd_size);
672 return __kvmppc_gse_put(gsb, KVMPPC_GSID_PARTITION_TABLE, sizeof(tmp),
673 &tmp);
674}
675
676/**
677 * kvmppc_gse_put_proc_table() - add a process table guest state element to a
678 * buffer
679 * @gsb: guest state buffer to add element to
680 * @iden: guest state ID
681 * @val: process table value
682 */
683static inline int kvmppc_gse_put_proc_table(struct kvmppc_gs_buff *gsb,
684 u16 iden,
685 struct kvmppc_gs_proc_table val)
686{
687 __be64 tmp[2];
688
689 tmp[0] = cpu_to_be64(val.address);
690 tmp[1] = cpu_to_be64(val.gpd_size);
691 return __kvmppc_gse_put(gsb, KVMPPC_GSID_PROCESS_TABLE, sizeof(tmp),
692 &tmp);
693}
694
695/**
696 * kvmppc_gse_put_buff_info() - adds a GSB description guest state element to a
697 * buffer
698 * @gsb: guest state buffer to add element to
699 * @iden: guest state ID
700 * @val: guest state buffer description value
701 */
702static inline int kvmppc_gse_put_buff_info(struct kvmppc_gs_buff *gsb, u16 iden,
703 struct kvmppc_gs_buff_info val)
704{
705 __be64 tmp[2];
706
707 tmp[0] = cpu_to_be64(val.address);
708 tmp[1] = cpu_to_be64(val.size);
709 return __kvmppc_gse_put(gsb, iden, sizeof(tmp), &tmp);
710}
711
712int __kvmppc_gse_put(struct kvmppc_gs_buff *gsb, u16 iden, u16 size,
713 const void *data);
714
715/**
716 * kvmppc_gse_get_be32() - return the data of a be32 element
717 * @gse: guest state element
718 */
719static inline __be32 kvmppc_gse_get_be32(const struct kvmppc_gs_elem *gse)
720{
721 if (WARN_ON(kvmppc_gse_len(gse) != sizeof(__be32)))
722 return 0;
723 return *(__be32 *)kvmppc_gse_data(gse);
724}
725
726/**
727 * kvmppc_gse_get_u32() - return the data of a be32 element in host endianness
728 * @gse: guest state element
729 */
730static inline u32 kvmppc_gse_get_u32(const struct kvmppc_gs_elem *gse)
731{
732 return be32_to_cpu(kvmppc_gse_get_be32(gse));
733}
734
735/**
736 * kvmppc_gse_get_be64() - return the data of a be64 element
737 * @gse: guest state element
738 */
739static inline __be64 kvmppc_gse_get_be64(const struct kvmppc_gs_elem *gse)
740{
741 if (WARN_ON(kvmppc_gse_len(gse) != sizeof(__be64)))
742 return 0;
743 return *(__be64 *)kvmppc_gse_data(gse);
744}
745
746/**
747 * kvmppc_gse_get_u64() - return the data of a be64 element in host endianness
748 * @gse: guest state element
749 */
750static inline u64 kvmppc_gse_get_u64(const struct kvmppc_gs_elem *gse)
751{
752 return be64_to_cpu(kvmppc_gse_get_be64(gse));
753}
754
755/**
756 * kvmppc_gse_get_vector128() - return the data of a vector element
757 * @gse: guest state element
758 */
759static inline void kvmppc_gse_get_vector128(const struct kvmppc_gs_elem *gse,
760 vector128 *v)
761{
762 union {
763 __vector128 v;
764 u64 dw[2];
765 } u = { 0 };
766 __be64 *src;
767
768 if (WARN_ON(kvmppc_gse_len(gse) != sizeof(__vector128)))
769 *v = u.v;
770
771 src = (__be64 *)kvmppc_gse_data(gse);
772 u.dw[TS_FPROFFSET] = be64_to_cpu(src[0]);
773#ifdef CONFIG_VSX
774 u.dw[TS_VSRLOWOFFSET] = be64_to_cpu(src[1]);
775#endif
776 *v = u.v;
777}
778
779/**************************************************************************
780 * Guest State Bitmap
781 **************************************************************************/
782
783bool kvmppc_gsbm_test(struct kvmppc_gs_bitmap *gsbm, u16 iden);
784void kvmppc_gsbm_set(struct kvmppc_gs_bitmap *gsbm, u16 iden);
785void kvmppc_gsbm_clear(struct kvmppc_gs_bitmap *gsbm, u16 iden);
786u16 kvmppc_gsbm_next(struct kvmppc_gs_bitmap *gsbm, u16 prev);
787
788/**
789 * kvmppc_gsbm_zero - zero the entire bitmap
790 * @gsbm: guest state buffer bitmap
791 */
792static inline void kvmppc_gsbm_zero(struct kvmppc_gs_bitmap *gsbm)
793{
794 bitmap_zero(gsbm->bitmap, KVMPPC_GSE_IDEN_COUNT);
795}
796
797/**
798 * kvmppc_gsbm_fill - fill the entire bitmap
799 * @gsbm: guest state buffer bitmap
800 */
801static inline void kvmppc_gsbm_fill(struct kvmppc_gs_bitmap *gsbm)
802{
803 bitmap_fill(gsbm->bitmap, KVMPPC_GSE_IDEN_COUNT);
804 clear_bit(0, gsbm->bitmap);
805}
806
807/**
808 * kvmppc_gsbm_for_each - iterate the present guest state IDs
809 * @gsbm: guest state buffer bitmap
810 * @iden: current guest state ID
811 */
812#define kvmppc_gsbm_for_each(gsbm, iden) \
813 for (iden = kvmppc_gsbm_next(gsbm, 0); iden != 0; \
814 iden = kvmppc_gsbm_next(gsbm, iden))
815
816/**************************************************************************
817 * Guest State Parser
818 **************************************************************************/
819
820void kvmppc_gsp_insert(struct kvmppc_gs_parser *gsp, u16 iden,
821 struct kvmppc_gs_elem *gse);
822struct kvmppc_gs_elem *kvmppc_gsp_lookup(struct kvmppc_gs_parser *gsp,
823 u16 iden);
824
825/**
826 * kvmppc_gsp_for_each - iterate the <guest state IDs, guest state element>
827 * pairs
828 * @gsp: guest state buffer bitmap
829 * @iden: current guest state ID
830 * @gse: guest state element
831 */
832#define kvmppc_gsp_for_each(gsp, iden, gse) \
833 for (iden = kvmppc_gsbm_next(&(gsp)->iterator, 0), \
834 gse = kvmppc_gsp_lookup((gsp), iden); \
835 iden != 0; iden = kvmppc_gsbm_next(&(gsp)->iterator, iden), \
836 gse = kvmppc_gsp_lookup((gsp), iden))
837
838/**************************************************************************
839 * Guest State Message
840 **************************************************************************/
841
842/**
843 * kvmppc_gsm_for_each - iterate the guest state IDs included in a guest state
844 * message
845 * @gsp: guest state buffer bitmap
846 * @iden: current guest state ID
847 * @gse: guest state element
848 */
849#define kvmppc_gsm_for_each(gsm, iden) \
850 for (iden = kvmppc_gsbm_next(&gsm->bitmap, 0); iden != 0; \
851 iden = kvmppc_gsbm_next(&gsm->bitmap, iden))
852
853int kvmppc_gsm_init(struct kvmppc_gs_msg *mgs, struct kvmppc_gs_msg_ops *ops,
854 void *data, unsigned long flags);
855
856struct kvmppc_gs_msg *kvmppc_gsm_new(struct kvmppc_gs_msg_ops *ops, void *data,
857 unsigned long flags, gfp_t gfp_flags);
858void kvmppc_gsm_free(struct kvmppc_gs_msg *gsm);
859size_t kvmppc_gsm_size(struct kvmppc_gs_msg *gsm);
860int kvmppc_gsm_fill_info(struct kvmppc_gs_msg *gsm, struct kvmppc_gs_buff *gsb);
861int kvmppc_gsm_refresh_info(struct kvmppc_gs_msg *gsm,
862 struct kvmppc_gs_buff *gsb);
863
864/**
865 * kvmppc_gsm_include - indicate a guest state ID should be included when
866 * serializing
867 * @gsm: guest state message
868 * @iden: guest state ID
869 */
870static inline void kvmppc_gsm_include(struct kvmppc_gs_msg *gsm, u16 iden)
871{
872 kvmppc_gsbm_set(&gsm->bitmap, iden);
873}
874
875/**
876 * kvmppc_gsm_includes - check if a guest state ID will be included when
877 * serializing
878 * @gsm: guest state message
879 * @iden: guest state ID
880 */
881static inline bool kvmppc_gsm_includes(struct kvmppc_gs_msg *gsm, u16 iden)
882{
883 return kvmppc_gsbm_test(&gsm->bitmap, iden);
884}
885
886/**
887 * kvmppc_gsm_includes - indicate all guest state IDs should be included when
888 * serializing
889 * @gsm: guest state message
890 * @iden: guest state ID
891 */
892static inline void kvmppc_gsm_include_all(struct kvmppc_gs_msg *gsm)
893{
894 kvmppc_gsbm_fill(&gsm->bitmap);
895}
896
897/**
898 * kvmppc_gsm_include - clear the guest state IDs that should be included when
899 * serializing
900 * @gsm: guest state message
901 */
902static inline void kvmppc_gsm_reset(struct kvmppc_gs_msg *gsm)
903{
904 kvmppc_gsbm_zero(&gsm->bitmap);
905}
906
907/**
908 * kvmppc_gsb_receive_data - flexibly update values from a guest state buffer
909 * @gsb: guest state buffer
910 * @gsm: guest state message
911 *
912 * Requests updated values for the guest state values included in the guest
913 * state message. The guest state message will then deserialize the guest state
914 * buffer.
915 */
916static inline int kvmppc_gsb_receive_data(struct kvmppc_gs_buff *gsb,
917 struct kvmppc_gs_msg *gsm)
918{
919 int rc;
920
921 kvmppc_gsb_reset(gsb);
922 rc = kvmppc_gsm_fill_info(gsm, gsb);
923 if (rc < 0)
924 return rc;
925
926 rc = kvmppc_gsb_recv(gsb, gsm->flags);
927 if (rc < 0)
928 return rc;
929
930 rc = kvmppc_gsm_refresh_info(gsm, gsb);
931 if (rc < 0)
932 return rc;
933 return 0;
934}
935
936/**
937 * kvmppc_gsb_recv - receive a single guest state ID
938 * @gsb: guest state buffer
939 * @gsm: guest state message
940 * @iden: guest state identity
941 */
942static inline int kvmppc_gsb_receive_datum(struct kvmppc_gs_buff *gsb,
943 struct kvmppc_gs_msg *gsm, u16 iden)
944{
945 int rc;
946
947 kvmppc_gsm_include(gsm, iden);
948 rc = kvmppc_gsb_receive_data(gsb, gsm);
949 if (rc < 0)
950 return rc;
951 kvmppc_gsm_reset(gsm);
952 return 0;
953}
954
955/**
956 * kvmppc_gsb_send_data - flexibly send values from a guest state buffer
957 * @gsb: guest state buffer
958 * @gsm: guest state message
959 *
960 * Sends the guest state values included in the guest state message.
961 */
962static inline int kvmppc_gsb_send_data(struct kvmppc_gs_buff *gsb,
963 struct kvmppc_gs_msg *gsm)
964{
965 int rc;
966
967 kvmppc_gsb_reset(gsb);
968 rc = kvmppc_gsm_fill_info(gsm, gsb);
969 if (rc < 0)
970 return rc;
971 rc = kvmppc_gsb_send(gsb, gsm->flags);
972
973 return rc;
974}
975
976/**
977 * kvmppc_gsb_recv - send a single guest state ID
978 * @gsb: guest state buffer
979 * @gsm: guest state message
980 * @iden: guest state identity
981 */
982static inline int kvmppc_gsb_send_datum(struct kvmppc_gs_buff *gsb,
983 struct kvmppc_gs_msg *gsm, u16 iden)
984{
985 int rc;
986
987 kvmppc_gsm_include(gsm, iden);
988 rc = kvmppc_gsb_send_data(gsb, gsm);
989 if (rc < 0)
990 return rc;
991 kvmppc_gsm_reset(gsm);
992 return 0;
993}
994
995#endif /* _ASM_POWERPC_GUEST_STATE_BUFFER_H */
1/* SPDX-License-Identifier: GPL-2.0 */
2/*
3 * Interface based on include/net/netlink.h
4 */
5#ifndef _ASM_POWERPC_GUEST_STATE_BUFFER_H
6#define _ASM_POWERPC_GUEST_STATE_BUFFER_H
7
8#include "asm/hvcall.h"
9#include <linux/gfp.h>
10#include <linux/bitmap.h>
11#include <asm/plpar_wrappers.h>
12
13/**************************************************************************
14 * Guest State Buffer Constants
15 **************************************************************************/
16/* Element without a value and any length */
17#define KVMPPC_GSID_BLANK 0x0000
18/* Size required for the L0's internal VCPU representation */
19#define KVMPPC_GSID_HOST_STATE_SIZE 0x0001
20 /* Minimum size for the H_GUEST_RUN_VCPU output buffer */
21#define KVMPPC_GSID_RUN_OUTPUT_MIN_SIZE 0x0002
22 /* "Logical" PVR value as defined in the PAPR */
23#define KVMPPC_GSID_LOGICAL_PVR 0x0003
24 /* L0 relative timebase offset */
25#define KVMPPC_GSID_TB_OFFSET 0x0004
26 /* Partition Scoped Page Table Info */
27#define KVMPPC_GSID_PARTITION_TABLE 0x0005
28 /* Process Table Info */
29#define KVMPPC_GSID_PROCESS_TABLE 0x0006
30
31/* H_GUEST_RUN_VCPU input buffer Info */
32#define KVMPPC_GSID_RUN_INPUT 0x0C00
33/* H_GUEST_RUN_VCPU output buffer Info */
34#define KVMPPC_GSID_RUN_OUTPUT 0x0C01
35#define KVMPPC_GSID_VPA 0x0C02
36
37#define KVMPPC_GSID_GPR(x) (0x1000 + (x))
38#define KVMPPC_GSID_HDEC_EXPIRY_TB 0x1020
39#define KVMPPC_GSID_NIA 0x1021
40#define KVMPPC_GSID_MSR 0x1022
41#define KVMPPC_GSID_LR 0x1023
42#define KVMPPC_GSID_XER 0x1024
43#define KVMPPC_GSID_CTR 0x1025
44#define KVMPPC_GSID_CFAR 0x1026
45#define KVMPPC_GSID_SRR0 0x1027
46#define KVMPPC_GSID_SRR1 0x1028
47#define KVMPPC_GSID_DAR 0x1029
48#define KVMPPC_GSID_DEC_EXPIRY_TB 0x102A
49#define KVMPPC_GSID_VTB 0x102B
50#define KVMPPC_GSID_LPCR 0x102C
51#define KVMPPC_GSID_HFSCR 0x102D
52#define KVMPPC_GSID_FSCR 0x102E
53#define KVMPPC_GSID_FPSCR 0x102F
54#define KVMPPC_GSID_DAWR0 0x1030
55#define KVMPPC_GSID_DAWR1 0x1031
56#define KVMPPC_GSID_CIABR 0x1032
57#define KVMPPC_GSID_PURR 0x1033
58#define KVMPPC_GSID_SPURR 0x1034
59#define KVMPPC_GSID_IC 0x1035
60#define KVMPPC_GSID_SPRG0 0x1036
61#define KVMPPC_GSID_SPRG1 0x1037
62#define KVMPPC_GSID_SPRG2 0x1038
63#define KVMPPC_GSID_SPRG3 0x1039
64#define KVMPPC_GSID_PPR 0x103A
65#define KVMPPC_GSID_MMCR(x) (0x103B + (x))
66#define KVMPPC_GSID_MMCRA 0x103F
67#define KVMPPC_GSID_SIER(x) (0x1040 + (x))
68#define KVMPPC_GSID_BESCR 0x1043
69#define KVMPPC_GSID_EBBHR 0x1044
70#define KVMPPC_GSID_EBBRR 0x1045
71#define KVMPPC_GSID_AMR 0x1046
72#define KVMPPC_GSID_IAMR 0x1047
73#define KVMPPC_GSID_AMOR 0x1048
74#define KVMPPC_GSID_UAMOR 0x1049
75#define KVMPPC_GSID_SDAR 0x104A
76#define KVMPPC_GSID_SIAR 0x104B
77#define KVMPPC_GSID_DSCR 0x104C
78#define KVMPPC_GSID_TAR 0x104D
79#define KVMPPC_GSID_DEXCR 0x104E
80#define KVMPPC_GSID_HDEXCR 0x104F
81#define KVMPPC_GSID_HASHKEYR 0x1050
82#define KVMPPC_GSID_HASHPKEYR 0x1051
83#define KVMPPC_GSID_CTRL 0x1052
84#define KVMPPC_GSID_DPDES 0x1053
85
86#define KVMPPC_GSID_CR 0x2000
87#define KVMPPC_GSID_PIDR 0x2001
88#define KVMPPC_GSID_DSISR 0x2002
89#define KVMPPC_GSID_VSCR 0x2003
90#define KVMPPC_GSID_VRSAVE 0x2004
91#define KVMPPC_GSID_DAWRX0 0x2005
92#define KVMPPC_GSID_DAWRX1 0x2006
93#define KVMPPC_GSID_PMC(x) (0x2007 + (x))
94#define KVMPPC_GSID_WORT 0x200D
95#define KVMPPC_GSID_PSPB 0x200E
96
97#define KVMPPC_GSID_VSRS(x) (0x3000 + (x))
98
99#define KVMPPC_GSID_HDAR 0xF000
100#define KVMPPC_GSID_HDSISR 0xF001
101#define KVMPPC_GSID_HEIR 0xF002
102#define KVMPPC_GSID_ASDR 0xF003
103
104#define KVMPPC_GSE_GUESTWIDE_START KVMPPC_GSID_BLANK
105#define KVMPPC_GSE_GUESTWIDE_END KVMPPC_GSID_PROCESS_TABLE
106#define KVMPPC_GSE_GUESTWIDE_COUNT \
107 (KVMPPC_GSE_GUESTWIDE_END - KVMPPC_GSE_GUESTWIDE_START + 1)
108
109#define KVMPPC_GSE_META_START KVMPPC_GSID_RUN_INPUT
110#define KVMPPC_GSE_META_END KVMPPC_GSID_VPA
111#define KVMPPC_GSE_META_COUNT (KVMPPC_GSE_META_END - KVMPPC_GSE_META_START + 1)
112
113#define KVMPPC_GSE_DW_REGS_START KVMPPC_GSID_GPR(0)
114#define KVMPPC_GSE_DW_REGS_END KVMPPC_GSID_DPDES
115#define KVMPPC_GSE_DW_REGS_COUNT \
116 (KVMPPC_GSE_DW_REGS_END - KVMPPC_GSE_DW_REGS_START + 1)
117
118#define KVMPPC_GSE_W_REGS_START KVMPPC_GSID_CR
119#define KVMPPC_GSE_W_REGS_END KVMPPC_GSID_PSPB
120#define KVMPPC_GSE_W_REGS_COUNT \
121 (KVMPPC_GSE_W_REGS_END - KVMPPC_GSE_W_REGS_START + 1)
122
123#define KVMPPC_GSE_VSRS_START KVMPPC_GSID_VSRS(0)
124#define KVMPPC_GSE_VSRS_END KVMPPC_GSID_VSRS(63)
125#define KVMPPC_GSE_VSRS_COUNT (KVMPPC_GSE_VSRS_END - KVMPPC_GSE_VSRS_START + 1)
126
127#define KVMPPC_GSE_INTR_REGS_START KVMPPC_GSID_HDAR
128#define KVMPPC_GSE_INTR_REGS_END KVMPPC_GSID_ASDR
129#define KVMPPC_GSE_INTR_REGS_COUNT \
130 (KVMPPC_GSE_INTR_REGS_END - KVMPPC_GSE_INTR_REGS_START + 1)
131
132#define KVMPPC_GSE_IDEN_COUNT \
133 (KVMPPC_GSE_GUESTWIDE_COUNT + KVMPPC_GSE_META_COUNT + \
134 KVMPPC_GSE_DW_REGS_COUNT + KVMPPC_GSE_W_REGS_COUNT + \
135 KVMPPC_GSE_VSRS_COUNT + KVMPPC_GSE_INTR_REGS_COUNT)
136
137/**
138 * Ranges of guest state buffer elements
139 */
140enum {
141 KVMPPC_GS_CLASS_GUESTWIDE = 0x01,
142 KVMPPC_GS_CLASS_META = 0x02,
143 KVMPPC_GS_CLASS_DWORD_REG = 0x04,
144 KVMPPC_GS_CLASS_WORD_REG = 0x08,
145 KVMPPC_GS_CLASS_VECTOR = 0x10,
146 KVMPPC_GS_CLASS_INTR = 0x20,
147};
148
149/**
150 * Types of guest state buffer elements
151 */
152enum {
153 KVMPPC_GSE_BE32,
154 KVMPPC_GSE_BE64,
155 KVMPPC_GSE_VEC128,
156 KVMPPC_GSE_PARTITION_TABLE,
157 KVMPPC_GSE_PROCESS_TABLE,
158 KVMPPC_GSE_BUFFER,
159 __KVMPPC_GSE_TYPE_MAX,
160};
161
162/**
163 * Flags for guest state elements
164 */
165enum {
166 KVMPPC_GS_FLAGS_WIDE = 0x01,
167};
168
169/**
170 * struct kvmppc_gs_part_table - deserialized partition table information
171 * element
172 * @address: start of the partition table
173 * @ea_bits: number of bits in the effective address
174 * @gpd_size: root page directory size
175 */
176struct kvmppc_gs_part_table {
177 u64 address;
178 u64 ea_bits;
179 u64 gpd_size;
180};
181
182/**
183 * struct kvmppc_gs_proc_table - deserialized process table information element
184 * @address: start of the process table
185 * @gpd_size: process table size
186 */
187struct kvmppc_gs_proc_table {
188 u64 address;
189 u64 gpd_size;
190};
191
192/**
193 * struct kvmppc_gs_buff_info - deserialized meta guest state buffer information
194 * @address: start of the guest state buffer
195 * @size: size of the guest state buffer
196 */
197struct kvmppc_gs_buff_info {
198 u64 address;
199 u64 size;
200};
201
202/**
203 * struct kvmppc_gs_header - serialized guest state buffer header
204 * @nelem: count of guest state elements in the buffer
205 * @data: start of the stream of elements in the buffer
206 */
207struct kvmppc_gs_header {
208 __be32 nelems;
209 char data[];
210} __packed;
211
212/**
213 * struct kvmppc_gs_elem - serialized guest state buffer element
214 * @iden: Guest State ID
215 * @len: length of data
216 * @data: the guest state buffer element's value
217 */
218struct kvmppc_gs_elem {
219 __be16 iden;
220 __be16 len;
221 char data[];
222} __packed;
223
224/**
225 * struct kvmppc_gs_buff - a guest state buffer with metadata.
226 * @capacity: total length of the buffer
227 * @len: current length of the elements and header
228 * @guest_id: guest id associated with the buffer
229 * @vcpu_id: vcpu_id associated with the buffer
230 * @hdr: the serialised guest state buffer
231 */
232struct kvmppc_gs_buff {
233 size_t capacity;
234 size_t len;
235 unsigned long guest_id;
236 unsigned long vcpu_id;
237 struct kvmppc_gs_header *hdr;
238};
239
240/**
241 * struct kvmppc_gs_bitmap - a bitmap for element ids
242 * @bitmap: a bitmap large enough for all Guest State IDs
243 */
244struct kvmppc_gs_bitmap {
245 /* private: */
246 DECLARE_BITMAP(bitmap, KVMPPC_GSE_IDEN_COUNT);
247};
248
249/**
250 * struct kvmppc_gs_parser - a map of element ids to locations in a buffer
251 * @iterator: bitmap used for iterating
252 * @gses: contains the pointers to elements
253 *
254 * A guest state parser is used for deserialising a guest state buffer.
255 * Given a buffer, it then allows looking up guest state elements using
256 * a guest state id.
257 */
258struct kvmppc_gs_parser {
259 /* private: */
260 struct kvmppc_gs_bitmap iterator;
261 struct kvmppc_gs_elem *gses[KVMPPC_GSE_IDEN_COUNT];
262};
263
264enum {
265 GSM_GUEST_WIDE = 0x1,
266 GSM_SEND = 0x2,
267 GSM_RECEIVE = 0x4,
268 GSM_GSB_OWNER = 0x8,
269};
270
271struct kvmppc_gs_msg;
272
273/**
274 * struct kvmppc_gs_msg_ops - guest state message behavior
275 * @get_size: maximum size required for the message data
276 * @fill_info: serializes to the guest state buffer format
277 * @refresh_info: dserializes from the guest state buffer format
278 */
279struct kvmppc_gs_msg_ops {
280 size_t (*get_size)(struct kvmppc_gs_msg *gsm);
281 int (*fill_info)(struct kvmppc_gs_buff *gsb, struct kvmppc_gs_msg *gsm);
282 int (*refresh_info)(struct kvmppc_gs_msg *gsm,
283 struct kvmppc_gs_buff *gsb);
284};
285
286/**
287 * struct kvmppc_gs_msg - a guest state message
288 * @bitmap: the guest state ids that should be included
289 * @ops: modify message behavior for reading and writing to buffers
290 * @flags: guest wide or thread wide
291 * @data: location where buffer data will be written to or from.
292 *
293 * A guest state message is allows flexibility in sending in receiving data
294 * in a guest state buffer format.
295 */
296struct kvmppc_gs_msg {
297 struct kvmppc_gs_bitmap bitmap;
298 struct kvmppc_gs_msg_ops *ops;
299 unsigned long flags;
300 void *data;
301};
302
303/**************************************************************************
304 * Guest State IDs
305 **************************************************************************/
306
307u16 kvmppc_gsid_size(u16 iden);
308unsigned long kvmppc_gsid_flags(u16 iden);
309u64 kvmppc_gsid_mask(u16 iden);
310
311/**************************************************************************
312 * Guest State Buffers
313 **************************************************************************/
314struct kvmppc_gs_buff *kvmppc_gsb_new(size_t size, unsigned long guest_id,
315 unsigned long vcpu_id, gfp_t flags);
316void kvmppc_gsb_free(struct kvmppc_gs_buff *gsb);
317void *kvmppc_gsb_put(struct kvmppc_gs_buff *gsb, size_t size);
318int kvmppc_gsb_send(struct kvmppc_gs_buff *gsb, unsigned long flags);
319int kvmppc_gsb_recv(struct kvmppc_gs_buff *gsb, unsigned long flags);
320
321/**
322 * kvmppc_gsb_header() - the header of a guest state buffer
323 * @gsb: guest state buffer
324 *
325 * Returns a pointer to the buffer header.
326 */
327static inline struct kvmppc_gs_header *
328kvmppc_gsb_header(struct kvmppc_gs_buff *gsb)
329{
330 return gsb->hdr;
331}
332
333/**
334 * kvmppc_gsb_data() - the elements of a guest state buffer
335 * @gsb: guest state buffer
336 *
337 * Returns a pointer to the first element of the buffer data.
338 */
339static inline struct kvmppc_gs_elem *kvmppc_gsb_data(struct kvmppc_gs_buff *gsb)
340{
341 return (struct kvmppc_gs_elem *)kvmppc_gsb_header(gsb)->data;
342}
343
344/**
345 * kvmppc_gsb_len() - the current length of a guest state buffer
346 * @gsb: guest state buffer
347 *
348 * Returns the length including the header of a buffer.
349 */
350static inline size_t kvmppc_gsb_len(struct kvmppc_gs_buff *gsb)
351{
352 return gsb->len;
353}
354
355/**
356 * kvmppc_gsb_capacity() - the capacity of a guest state buffer
357 * @gsb: guest state buffer
358 *
359 * Returns the capacity of a buffer.
360 */
361static inline size_t kvmppc_gsb_capacity(struct kvmppc_gs_buff *gsb)
362{
363 return gsb->capacity;
364}
365
366/**
367 * kvmppc_gsb_paddress() - the physical address of buffer
368 * @gsb: guest state buffer
369 *
370 * Returns the physical address of the buffer.
371 */
372static inline u64 kvmppc_gsb_paddress(struct kvmppc_gs_buff *gsb)
373{
374 return __pa(kvmppc_gsb_header(gsb));
375}
376
377/**
378 * kvmppc_gsb_nelems() - the number of elements in a buffer
379 * @gsb: guest state buffer
380 *
381 * Returns the number of elements in a buffer
382 */
383static inline u32 kvmppc_gsb_nelems(struct kvmppc_gs_buff *gsb)
384{
385 return be32_to_cpu(kvmppc_gsb_header(gsb)->nelems);
386}
387
388/**
389 * kvmppc_gsb_reset() - empty a guest state buffer
390 * @gsb: guest state buffer
391 *
392 * Reset the number of elements and length of buffer to empty.
393 */
394static inline void kvmppc_gsb_reset(struct kvmppc_gs_buff *gsb)
395{
396 kvmppc_gsb_header(gsb)->nelems = cpu_to_be32(0);
397 gsb->len = sizeof(struct kvmppc_gs_header);
398}
399
400/**
401 * kvmppc_gsb_data_len() - the length of a buffer excluding the header
402 * @gsb: guest state buffer
403 *
404 * Returns the length of a buffer excluding the header
405 */
406static inline size_t kvmppc_gsb_data_len(struct kvmppc_gs_buff *gsb)
407{
408 return gsb->len - sizeof(struct kvmppc_gs_header);
409}
410
411/**
412 * kvmppc_gsb_data_cap() - the capacity of a buffer excluding the header
413 * @gsb: guest state buffer
414 *
415 * Returns the capacity of a buffer excluding the header
416 */
417static inline size_t kvmppc_gsb_data_cap(struct kvmppc_gs_buff *gsb)
418{
419 return gsb->capacity - sizeof(struct kvmppc_gs_header);
420}
421
422/**
423 * kvmppc_gsb_for_each_elem - iterate over the elements in a buffer
424 * @i: loop counter
425 * @pos: set to current element
426 * @gsb: guest state buffer
427 * @rem: initialized to buffer capacity, holds bytes currently remaining in
428 * stream
429 */
430#define kvmppc_gsb_for_each_elem(i, pos, gsb, rem) \
431 kvmppc_gse_for_each_elem(i, kvmppc_gsb_nelems(gsb), pos, \
432 kvmppc_gsb_data(gsb), \
433 kvmppc_gsb_data_cap(gsb), rem)
434
435/**************************************************************************
436 * Guest State Elements
437 **************************************************************************/
438
439/**
440 * kvmppc_gse_iden() - guest state ID of element
441 * @gse: guest state element
442 *
443 * Return the guest state ID in host endianness.
444 */
445static inline u16 kvmppc_gse_iden(const struct kvmppc_gs_elem *gse)
446{
447 return be16_to_cpu(gse->iden);
448}
449
450/**
451 * kvmppc_gse_len() - length of guest state element data
452 * @gse: guest state element
453 *
454 * Returns the length of guest state element data
455 */
456static inline u16 kvmppc_gse_len(const struct kvmppc_gs_elem *gse)
457{
458 return be16_to_cpu(gse->len);
459}
460
461/**
462 * kvmppc_gse_total_len() - total length of guest state element
463 * @gse: guest state element
464 *
465 * Returns the length of the data plus the ID and size header.
466 */
467static inline u16 kvmppc_gse_total_len(const struct kvmppc_gs_elem *gse)
468{
469 return be16_to_cpu(gse->len) + sizeof(*gse);
470}
471
472/**
473 * kvmppc_gse_total_size() - space needed for a given data length
474 * @size: data length
475 *
476 * Returns size plus the space needed for the ID and size header.
477 */
478static inline u16 kvmppc_gse_total_size(u16 size)
479{
480 return sizeof(struct kvmppc_gs_elem) + size;
481}
482
483/**
484 * kvmppc_gse_data() - pointer to data of a guest state element
485 * @gse: guest state element
486 *
487 * Returns a pointer to the beginning of guest state element data.
488 */
489static inline void *kvmppc_gse_data(const struct kvmppc_gs_elem *gse)
490{
491 return (void *)gse->data;
492}
493
494/**
495 * kvmppc_gse_ok() - checks space exists for guest state element
496 * @gse: guest state element
497 * @remaining: bytes of space remaining
498 *
499 * Returns true if the guest state element can fit in remaining space.
500 */
501static inline bool kvmppc_gse_ok(const struct kvmppc_gs_elem *gse,
502 int remaining)
503{
504 return remaining >= kvmppc_gse_total_len(gse);
505}
506
507/**
508 * kvmppc_gse_next() - iterate to the next guest state element in a stream
509 * @gse: stream of guest state elements
510 * @remaining: length of the guest element stream
511 *
512 * Returns the next guest state element in a stream of elements. The length of
513 * the stream is updated in remaining.
514 */
515static inline struct kvmppc_gs_elem *
516kvmppc_gse_next(const struct kvmppc_gs_elem *gse, int *remaining)
517{
518 int len = sizeof(*gse) + kvmppc_gse_len(gse);
519
520 *remaining -= len;
521 return (struct kvmppc_gs_elem *)(gse->data + kvmppc_gse_len(gse));
522}
523
524/**
525 * kvmppc_gse_for_each_elem - iterate over a stream of guest state elements
526 * @i: loop counter
527 * @max: number of elements
528 * @pos: set to current element
529 * @head: head of elements
530 * @len: length of the stream
531 * @rem: initialized to len, holds bytes currently remaining elements
532 */
533#define kvmppc_gse_for_each_elem(i, max, pos, head, len, rem) \
534 for (i = 0, pos = head, rem = len; kvmppc_gse_ok(pos, rem) && i < max; \
535 pos = kvmppc_gse_next(pos, &(rem)), i++)
536
537int __kvmppc_gse_put(struct kvmppc_gs_buff *gsb, u16 iden, u16 size,
538 const void *data);
539int kvmppc_gse_parse(struct kvmppc_gs_parser *gsp, struct kvmppc_gs_buff *gsb);
540
541/**
542 * kvmppc_gse_put_be32() - add a be32 guest state element to a buffer
543 * @gsb: guest state buffer to add element to
544 * @iden: guest state ID
545 * @val: big endian value
546 */
547static inline int kvmppc_gse_put_be32(struct kvmppc_gs_buff *gsb, u16 iden,
548 __be32 val)
549{
550 __be32 tmp;
551
552 tmp = val;
553 return __kvmppc_gse_put(gsb, iden, sizeof(__be32), &tmp);
554}
555
556/**
557 * kvmppc_gse_put_u32() - add a host endian 32bit int guest state element to a
558 * buffer
559 * @gsb: guest state buffer to add element to
560 * @iden: guest state ID
561 * @val: host endian value
562 */
563static inline int kvmppc_gse_put_u32(struct kvmppc_gs_buff *gsb, u16 iden,
564 u32 val)
565{
566 __be32 tmp;
567
568 val &= kvmppc_gsid_mask(iden);
569 tmp = cpu_to_be32(val);
570 return kvmppc_gse_put_be32(gsb, iden, tmp);
571}
572
573/**
574 * kvmppc_gse_put_be64() - add a be64 guest state element to a buffer
575 * @gsb: guest state buffer to add element to
576 * @iden: guest state ID
577 * @val: big endian value
578 */
579static inline int kvmppc_gse_put_be64(struct kvmppc_gs_buff *gsb, u16 iden,
580 __be64 val)
581{
582 __be64 tmp;
583
584 tmp = val;
585 return __kvmppc_gse_put(gsb, iden, sizeof(__be64), &tmp);
586}
587
588/**
589 * kvmppc_gse_put_u64() - add a host endian 64bit guest state element to a
590 * buffer
591 * @gsb: guest state buffer to add element to
592 * @iden: guest state ID
593 * @val: host endian value
594 */
595static inline int kvmppc_gse_put_u64(struct kvmppc_gs_buff *gsb, u16 iden,
596 u64 val)
597{
598 __be64 tmp;
599
600 val &= kvmppc_gsid_mask(iden);
601 tmp = cpu_to_be64(val);
602 return kvmppc_gse_put_be64(gsb, iden, tmp);
603}
604
605/**
606 * __kvmppc_gse_put_reg() - add a register type guest state element to a buffer
607 * @gsb: guest state buffer to add element to
608 * @iden: guest state ID
609 * @val: host endian value
610 *
611 * Adds a register type guest state element. Uses the guest state ID for
612 * determining the length of the guest element. If the guest state ID has
613 * bits that can not be set they will be cleared.
614 */
615static inline int __kvmppc_gse_put_reg(struct kvmppc_gs_buff *gsb, u16 iden,
616 u64 val)
617{
618 val &= kvmppc_gsid_mask(iden);
619 if (kvmppc_gsid_size(iden) == sizeof(u64))
620 return kvmppc_gse_put_u64(gsb, iden, val);
621
622 if (kvmppc_gsid_size(iden) == sizeof(u32)) {
623 u32 tmp;
624
625 tmp = (u32)val;
626 if (tmp != val)
627 return -EINVAL;
628
629 return kvmppc_gse_put_u32(gsb, iden, tmp);
630 }
631 return -EINVAL;
632}
633
634/**
635 * kvmppc_gse_put_vector128() - add a vector guest state element to a buffer
636 * @gsb: guest state buffer to add element to
637 * @iden: guest state ID
638 * @val: 16 byte vector value
639 */
640static inline int kvmppc_gse_put_vector128(struct kvmppc_gs_buff *gsb, u16 iden,
641 vector128 *val)
642{
643 __be64 tmp[2] = { 0 };
644 union {
645 __vector128 v;
646 u64 dw[2];
647 } u;
648
649 u.v = *val;
650 tmp[0] = cpu_to_be64(u.dw[TS_FPROFFSET]);
651#ifdef CONFIG_VSX
652 tmp[1] = cpu_to_be64(u.dw[TS_VSRLOWOFFSET]);
653#endif
654 return __kvmppc_gse_put(gsb, iden, sizeof(tmp), &tmp);
655}
656
657/**
658 * kvmppc_gse_put_part_table() - add a partition table guest state element to a
659 * buffer
660 * @gsb: guest state buffer to add element to
661 * @iden: guest state ID
662 * @val: partition table value
663 */
664static inline int kvmppc_gse_put_part_table(struct kvmppc_gs_buff *gsb,
665 u16 iden,
666 struct kvmppc_gs_part_table val)
667{
668 __be64 tmp[3];
669
670 tmp[0] = cpu_to_be64(val.address);
671 tmp[1] = cpu_to_be64(val.ea_bits);
672 tmp[2] = cpu_to_be64(val.gpd_size);
673 return __kvmppc_gse_put(gsb, KVMPPC_GSID_PARTITION_TABLE, sizeof(tmp),
674 &tmp);
675}
676
677/**
678 * kvmppc_gse_put_proc_table() - add a process table guest state element to a
679 * buffer
680 * @gsb: guest state buffer to add element to
681 * @iden: guest state ID
682 * @val: process table value
683 */
684static inline int kvmppc_gse_put_proc_table(struct kvmppc_gs_buff *gsb,
685 u16 iden,
686 struct kvmppc_gs_proc_table val)
687{
688 __be64 tmp[2];
689
690 tmp[0] = cpu_to_be64(val.address);
691 tmp[1] = cpu_to_be64(val.gpd_size);
692 return __kvmppc_gse_put(gsb, KVMPPC_GSID_PROCESS_TABLE, sizeof(tmp),
693 &tmp);
694}
695
696/**
697 * kvmppc_gse_put_buff_info() - adds a GSB description guest state element to a
698 * buffer
699 * @gsb: guest state buffer to add element to
700 * @iden: guest state ID
701 * @val: guest state buffer description value
702 */
703static inline int kvmppc_gse_put_buff_info(struct kvmppc_gs_buff *gsb, u16 iden,
704 struct kvmppc_gs_buff_info val)
705{
706 __be64 tmp[2];
707
708 tmp[0] = cpu_to_be64(val.address);
709 tmp[1] = cpu_to_be64(val.size);
710 return __kvmppc_gse_put(gsb, iden, sizeof(tmp), &tmp);
711}
712
713int __kvmppc_gse_put(struct kvmppc_gs_buff *gsb, u16 iden, u16 size,
714 const void *data);
715
716/**
717 * kvmppc_gse_get_be32() - return the data of a be32 element
718 * @gse: guest state element
719 */
720static inline __be32 kvmppc_gse_get_be32(const struct kvmppc_gs_elem *gse)
721{
722 if (WARN_ON(kvmppc_gse_len(gse) != sizeof(__be32)))
723 return 0;
724 return *(__be32 *)kvmppc_gse_data(gse);
725}
726
727/**
728 * kvmppc_gse_get_u32() - return the data of a be32 element in host endianness
729 * @gse: guest state element
730 */
731static inline u32 kvmppc_gse_get_u32(const struct kvmppc_gs_elem *gse)
732{
733 return be32_to_cpu(kvmppc_gse_get_be32(gse));
734}
735
736/**
737 * kvmppc_gse_get_be64() - return the data of a be64 element
738 * @gse: guest state element
739 */
740static inline __be64 kvmppc_gse_get_be64(const struct kvmppc_gs_elem *gse)
741{
742 if (WARN_ON(kvmppc_gse_len(gse) != sizeof(__be64)))
743 return 0;
744 return *(__be64 *)kvmppc_gse_data(gse);
745}
746
747/**
748 * kvmppc_gse_get_u64() - return the data of a be64 element in host endianness
749 * @gse: guest state element
750 */
751static inline u64 kvmppc_gse_get_u64(const struct kvmppc_gs_elem *gse)
752{
753 return be64_to_cpu(kvmppc_gse_get_be64(gse));
754}
755
756/**
757 * kvmppc_gse_get_vector128() - return the data of a vector element
758 * @gse: guest state element
759 */
760static inline void kvmppc_gse_get_vector128(const struct kvmppc_gs_elem *gse,
761 vector128 *v)
762{
763 union {
764 __vector128 v;
765 u64 dw[2];
766 } u = { 0 };
767 __be64 *src;
768
769 if (WARN_ON(kvmppc_gse_len(gse) != sizeof(__vector128)))
770 *v = u.v;
771
772 src = (__be64 *)kvmppc_gse_data(gse);
773 u.dw[TS_FPROFFSET] = be64_to_cpu(src[0]);
774#ifdef CONFIG_VSX
775 u.dw[TS_VSRLOWOFFSET] = be64_to_cpu(src[1]);
776#endif
777 *v = u.v;
778}
779
780/**************************************************************************
781 * Guest State Bitmap
782 **************************************************************************/
783
784bool kvmppc_gsbm_test(struct kvmppc_gs_bitmap *gsbm, u16 iden);
785void kvmppc_gsbm_set(struct kvmppc_gs_bitmap *gsbm, u16 iden);
786void kvmppc_gsbm_clear(struct kvmppc_gs_bitmap *gsbm, u16 iden);
787u16 kvmppc_gsbm_next(struct kvmppc_gs_bitmap *gsbm, u16 prev);
788
789/**
790 * kvmppc_gsbm_zero - zero the entire bitmap
791 * @gsbm: guest state buffer bitmap
792 */
793static inline void kvmppc_gsbm_zero(struct kvmppc_gs_bitmap *gsbm)
794{
795 bitmap_zero(gsbm->bitmap, KVMPPC_GSE_IDEN_COUNT);
796}
797
798/**
799 * kvmppc_gsbm_fill - fill the entire bitmap
800 * @gsbm: guest state buffer bitmap
801 */
802static inline void kvmppc_gsbm_fill(struct kvmppc_gs_bitmap *gsbm)
803{
804 bitmap_fill(gsbm->bitmap, KVMPPC_GSE_IDEN_COUNT);
805 clear_bit(0, gsbm->bitmap);
806}
807
808/**
809 * kvmppc_gsbm_for_each - iterate the present guest state IDs
810 * @gsbm: guest state buffer bitmap
811 * @iden: current guest state ID
812 */
813#define kvmppc_gsbm_for_each(gsbm, iden) \
814 for (iden = kvmppc_gsbm_next(gsbm, 0); iden != 0; \
815 iden = kvmppc_gsbm_next(gsbm, iden))
816
817/**************************************************************************
818 * Guest State Parser
819 **************************************************************************/
820
821void kvmppc_gsp_insert(struct kvmppc_gs_parser *gsp, u16 iden,
822 struct kvmppc_gs_elem *gse);
823struct kvmppc_gs_elem *kvmppc_gsp_lookup(struct kvmppc_gs_parser *gsp,
824 u16 iden);
825
826/**
827 * kvmppc_gsp_for_each - iterate the <guest state IDs, guest state element>
828 * pairs
829 * @gsp: guest state buffer bitmap
830 * @iden: current guest state ID
831 * @gse: guest state element
832 */
833#define kvmppc_gsp_for_each(gsp, iden, gse) \
834 for (iden = kvmppc_gsbm_next(&(gsp)->iterator, 0), \
835 gse = kvmppc_gsp_lookup((gsp), iden); \
836 iden != 0; iden = kvmppc_gsbm_next(&(gsp)->iterator, iden), \
837 gse = kvmppc_gsp_lookup((gsp), iden))
838
839/**************************************************************************
840 * Guest State Message
841 **************************************************************************/
842
843/**
844 * kvmppc_gsm_for_each - iterate the guest state IDs included in a guest state
845 * message
846 * @gsp: guest state buffer bitmap
847 * @iden: current guest state ID
848 * @gse: guest state element
849 */
850#define kvmppc_gsm_for_each(gsm, iden) \
851 for (iden = kvmppc_gsbm_next(&gsm->bitmap, 0); iden != 0; \
852 iden = kvmppc_gsbm_next(&gsm->bitmap, iden))
853
854int kvmppc_gsm_init(struct kvmppc_gs_msg *mgs, struct kvmppc_gs_msg_ops *ops,
855 void *data, unsigned long flags);
856
857struct kvmppc_gs_msg *kvmppc_gsm_new(struct kvmppc_gs_msg_ops *ops, void *data,
858 unsigned long flags, gfp_t gfp_flags);
859void kvmppc_gsm_free(struct kvmppc_gs_msg *gsm);
860size_t kvmppc_gsm_size(struct kvmppc_gs_msg *gsm);
861int kvmppc_gsm_fill_info(struct kvmppc_gs_msg *gsm, struct kvmppc_gs_buff *gsb);
862int kvmppc_gsm_refresh_info(struct kvmppc_gs_msg *gsm,
863 struct kvmppc_gs_buff *gsb);
864
865/**
866 * kvmppc_gsm_include - indicate a guest state ID should be included when
867 * serializing
868 * @gsm: guest state message
869 * @iden: guest state ID
870 */
871static inline void kvmppc_gsm_include(struct kvmppc_gs_msg *gsm, u16 iden)
872{
873 kvmppc_gsbm_set(&gsm->bitmap, iden);
874}
875
876/**
877 * kvmppc_gsm_includes - check if a guest state ID will be included when
878 * serializing
879 * @gsm: guest state message
880 * @iden: guest state ID
881 */
882static inline bool kvmppc_gsm_includes(struct kvmppc_gs_msg *gsm, u16 iden)
883{
884 return kvmppc_gsbm_test(&gsm->bitmap, iden);
885}
886
887/**
888 * kvmppc_gsm_includes - indicate all guest state IDs should be included when
889 * serializing
890 * @gsm: guest state message
891 * @iden: guest state ID
892 */
893static inline void kvmppc_gsm_include_all(struct kvmppc_gs_msg *gsm)
894{
895 kvmppc_gsbm_fill(&gsm->bitmap);
896}
897
898/**
899 * kvmppc_gsm_include - clear the guest state IDs that should be included when
900 * serializing
901 * @gsm: guest state message
902 */
903static inline void kvmppc_gsm_reset(struct kvmppc_gs_msg *gsm)
904{
905 kvmppc_gsbm_zero(&gsm->bitmap);
906}
907
908/**
909 * kvmppc_gsb_receive_data - flexibly update values from a guest state buffer
910 * @gsb: guest state buffer
911 * @gsm: guest state message
912 *
913 * Requests updated values for the guest state values included in the guest
914 * state message. The guest state message will then deserialize the guest state
915 * buffer.
916 */
917static inline int kvmppc_gsb_receive_data(struct kvmppc_gs_buff *gsb,
918 struct kvmppc_gs_msg *gsm)
919{
920 int rc;
921
922 kvmppc_gsb_reset(gsb);
923 rc = kvmppc_gsm_fill_info(gsm, gsb);
924 if (rc < 0)
925 return rc;
926
927 rc = kvmppc_gsb_recv(gsb, gsm->flags);
928 if (rc < 0)
929 return rc;
930
931 rc = kvmppc_gsm_refresh_info(gsm, gsb);
932 if (rc < 0)
933 return rc;
934 return 0;
935}
936
937/**
938 * kvmppc_gsb_recv - receive a single guest state ID
939 * @gsb: guest state buffer
940 * @gsm: guest state message
941 * @iden: guest state identity
942 */
943static inline int kvmppc_gsb_receive_datum(struct kvmppc_gs_buff *gsb,
944 struct kvmppc_gs_msg *gsm, u16 iden)
945{
946 int rc;
947
948 kvmppc_gsm_include(gsm, iden);
949 rc = kvmppc_gsb_receive_data(gsb, gsm);
950 if (rc < 0)
951 return rc;
952 kvmppc_gsm_reset(gsm);
953 return 0;
954}
955
956/**
957 * kvmppc_gsb_send_data - flexibly send values from a guest state buffer
958 * @gsb: guest state buffer
959 * @gsm: guest state message
960 *
961 * Sends the guest state values included in the guest state message.
962 */
963static inline int kvmppc_gsb_send_data(struct kvmppc_gs_buff *gsb,
964 struct kvmppc_gs_msg *gsm)
965{
966 int rc;
967
968 kvmppc_gsb_reset(gsb);
969 rc = kvmppc_gsm_fill_info(gsm, gsb);
970 if (rc < 0)
971 return rc;
972 rc = kvmppc_gsb_send(gsb, gsm->flags);
973
974 return rc;
975}
976
977/**
978 * kvmppc_gsb_recv - send a single guest state ID
979 * @gsb: guest state buffer
980 * @gsm: guest state message
981 * @iden: guest state identity
982 */
983static inline int kvmppc_gsb_send_datum(struct kvmppc_gs_buff *gsb,
984 struct kvmppc_gs_msg *gsm, u16 iden)
985{
986 int rc;
987
988 kvmppc_gsm_include(gsm, iden);
989 rc = kvmppc_gsb_send_data(gsb, gsm);
990 if (rc < 0)
991 return rc;
992 kvmppc_gsm_reset(gsm);
993 return 0;
994}
995
996#endif /* _ASM_POWERPC_GUEST_STATE_BUFFER_H */