1 /* SPDX-License-Identifier: GPL-2.0 */
3 * Interface based on include/net/netlink.h
5 #ifndef _ASM_POWERPC_GUEST_STATE_BUFFER_H
6 #define _ASM_POWERPC_GUEST_STATE_BUFFER_H
8 #include "asm/hvcall.h"
10 #include <linux/bitmap.h>
11 #include <asm/plpar_wrappers.h>
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
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
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
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
96 #define KVMPPC_GSID_VSRS(x) (0x3000 + (x))
98 #define KVMPPC_GSID_HDAR 0xF000
99 #define KVMPPC_GSID_HDSISR 0xF001
100 #define KVMPPC_GSID_HEIR 0xF002
101 #define KVMPPC_GSID_ASDR 0xF003
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)
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)
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)
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)
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)
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)
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)
137 * Ranges of guest state buffer elements
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,
149 * Types of guest state buffer elements
155 KVMPPC_GSE_PARTITION_TABLE,
156 KVMPPC_GSE_PROCESS_TABLE,
158 __KVMPPC_GSE_TYPE_MAX,
162 * Flags for guest state elements
165 KVMPPC_GS_FLAGS_WIDE = 0x01,
169 * struct kvmppc_gs_part_table - deserialized partition table information
171 * @address: start of the partition table
172 * @ea_bits: number of bits in the effective address
173 * @gpd_size: root page directory size
175 struct kvmppc_gs_part_table {
182 * struct kvmppc_gs_proc_table - deserialized process table information element
183 * @address: start of the process table
184 * @gpd_size: process table size
186 struct kvmppc_gs_proc_table {
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
196 struct kvmppc_gs_buff_info {
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
206 struct kvmppc_gs_header {
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
217 struct kvmppc_gs_elem {
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
231 struct kvmppc_gs_buff {
234 unsigned long guest_id;
235 unsigned long vcpu_id;
236 struct kvmppc_gs_header *hdr;
240 * struct kvmppc_gs_bitmap - a bitmap for element ids
241 * @bitmap: a bitmap large enough for all Guest State IDs
243 struct kvmppc_gs_bitmap {
245 DECLARE_BITMAP(bitmap, KVMPPC_GSE_IDEN_COUNT);
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
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
257 struct kvmppc_gs_parser {
259 struct kvmppc_gs_bitmap iterator;
260 struct kvmppc_gs_elem *gses[KVMPPC_GSE_IDEN_COUNT];
264 GSM_GUEST_WIDE = 0x1,
270 struct kvmppc_gs_msg;
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
278 struct 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);
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.
292 * A guest state message is allows flexibility in sending in receiving data
293 * in a guest state buffer format.
295 struct kvmppc_gs_msg {
296 struct kvmppc_gs_bitmap bitmap;
297 struct kvmppc_gs_msg_ops *ops;
302 /**************************************************************************
304 **************************************************************************/
306 u16 kvmppc_gsid_size(u16 iden);
307 unsigned long kvmppc_gsid_flags(u16 iden);
308 u64 kvmppc_gsid_mask(u16 iden);
310 /**************************************************************************
311 * Guest State Buffers
312 **************************************************************************/
313 struct kvmppc_gs_buff *kvmppc_gsb_new(size_t size, unsigned long guest_id,
314 unsigned long vcpu_id, gfp_t flags);
315 void kvmppc_gsb_free(struct kvmppc_gs_buff *gsb);
316 void *kvmppc_gsb_put(struct kvmppc_gs_buff *gsb, size_t size);
317 int kvmppc_gsb_send(struct kvmppc_gs_buff *gsb, unsigned long flags);
318 int kvmppc_gsb_recv(struct kvmppc_gs_buff *gsb, unsigned long flags);
321 * kvmppc_gsb_header() - the header of a guest state buffer
322 * @gsb: guest state buffer
324 * Returns a pointer to the buffer header.
326 static inline struct kvmppc_gs_header *
327 kvmppc_gsb_header(struct kvmppc_gs_buff *gsb)
333 * kvmppc_gsb_data() - the elements of a guest state buffer
334 * @gsb: guest state buffer
336 * Returns a pointer to the first element of the buffer data.
338 static inline struct kvmppc_gs_elem *kvmppc_gsb_data(struct kvmppc_gs_buff *gsb)
340 return (struct kvmppc_gs_elem *)kvmppc_gsb_header(gsb)->data;
344 * kvmppc_gsb_len() - the current length of a guest state buffer
345 * @gsb: guest state buffer
347 * Returns the length including the header of a buffer.
349 static inline size_t kvmppc_gsb_len(struct kvmppc_gs_buff *gsb)
355 * kvmppc_gsb_capacity() - the capacity of a guest state buffer
356 * @gsb: guest state buffer
358 * Returns the capacity of a buffer.
360 static inline size_t kvmppc_gsb_capacity(struct kvmppc_gs_buff *gsb)
362 return gsb->capacity;
366 * kvmppc_gsb_paddress() - the physical address of buffer
367 * @gsb: guest state buffer
369 * Returns the physical address of the buffer.
371 static inline u64 kvmppc_gsb_paddress(struct kvmppc_gs_buff *gsb)
373 return __pa(kvmppc_gsb_header(gsb));
377 * kvmppc_gsb_nelems() - the number of elements in a buffer
378 * @gsb: guest state buffer
380 * Returns the number of elements in a buffer
382 static inline u32 kvmppc_gsb_nelems(struct kvmppc_gs_buff *gsb)
384 return be32_to_cpu(kvmppc_gsb_header(gsb)->nelems);
388 * kvmppc_gsb_reset() - empty a guest state buffer
389 * @gsb: guest state buffer
391 * Reset the number of elements and length of buffer to empty.
393 static inline void kvmppc_gsb_reset(struct kvmppc_gs_buff *gsb)
395 kvmppc_gsb_header(gsb)->nelems = cpu_to_be32(0);
396 gsb->len = sizeof(struct kvmppc_gs_header);
400 * kvmppc_gsb_data_len() - the length of a buffer excluding the header
401 * @gsb: guest state buffer
403 * Returns the length of a buffer excluding the header
405 static inline size_t kvmppc_gsb_data_len(struct kvmppc_gs_buff *gsb)
407 return gsb->len - sizeof(struct kvmppc_gs_header);
411 * kvmppc_gsb_data_cap() - the capacity of a buffer excluding the header
412 * @gsb: guest state buffer
414 * Returns the capacity of a buffer excluding the header
416 static inline size_t kvmppc_gsb_data_cap(struct kvmppc_gs_buff *gsb)
418 return gsb->capacity - sizeof(struct kvmppc_gs_header);
422 * kvmppc_gsb_for_each_elem - iterate over the elements in a buffer
424 * @pos: set to current element
425 * @gsb: guest state buffer
426 * @rem: initialized to buffer capacity, holds bytes currently remaining in
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)
434 /**************************************************************************
435 * Guest State Elements
436 **************************************************************************/
439 * kvmppc_gse_iden() - guest state ID of element
440 * @gse: guest state element
442 * Return the guest state ID in host endianness.
444 static inline u16 kvmppc_gse_iden(const struct kvmppc_gs_elem *gse)
446 return be16_to_cpu(gse->iden);
450 * kvmppc_gse_len() - length of guest state element data
451 * @gse: guest state element
453 * Returns the length of guest state element data
455 static inline u16 kvmppc_gse_len(const struct kvmppc_gs_elem *gse)
457 return be16_to_cpu(gse->len);
461 * kvmppc_gse_total_len() - total length of guest state element
462 * @gse: guest state element
464 * Returns the length of the data plus the ID and size header.
466 static inline u16 kvmppc_gse_total_len(const struct kvmppc_gs_elem *gse)
468 return be16_to_cpu(gse->len) + sizeof(*gse);
472 * kvmppc_gse_total_size() - space needed for a given data length
475 * Returns size plus the space needed for the ID and size header.
477 static inline u16 kvmppc_gse_total_size(u16 size)
479 return sizeof(struct kvmppc_gs_elem) + size;
483 * kvmppc_gse_data() - pointer to data of a guest state element
484 * @gse: guest state element
486 * Returns a pointer to the beginning of guest state element data.
488 static inline void *kvmppc_gse_data(const struct kvmppc_gs_elem *gse)
490 return (void *)gse->data;
494 * kvmppc_gse_ok() - checks space exists for guest state element
495 * @gse: guest state element
496 * @remaining: bytes of space remaining
498 * Returns true if the guest state element can fit in remaining space.
500 static inline bool kvmppc_gse_ok(const struct kvmppc_gs_elem *gse,
503 return remaining >= kvmppc_gse_total_len(gse);
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
511 * Returns the next guest state element in a stream of elements. The length of
512 * the stream is updated in remaining.
514 static inline struct kvmppc_gs_elem *
515 kvmppc_gse_next(const struct kvmppc_gs_elem *gse, int *remaining)
517 int len = sizeof(*gse) + kvmppc_gse_len(gse);
520 return (struct kvmppc_gs_elem *)(gse->data + kvmppc_gse_len(gse));
524 * kvmppc_gse_for_each_elem - iterate over a stream of guest state elements
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
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++)
536 int __kvmppc_gse_put(struct kvmppc_gs_buff *gsb, u16 iden, u16 size,
538 int kvmppc_gse_parse(struct kvmppc_gs_parser *gsp, struct kvmppc_gs_buff *gsb);
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
546 static inline int kvmppc_gse_put_be32(struct kvmppc_gs_buff *gsb, u16 iden,
552 return __kvmppc_gse_put(gsb, iden, sizeof(__be32), &tmp);
556 * kvmppc_gse_put_u32() - add a host endian 32bit int guest state element to a
558 * @gsb: guest state buffer to add element to
559 * @iden: guest state ID
560 * @val: host endian value
562 static inline int kvmppc_gse_put_u32(struct kvmppc_gs_buff *gsb, u16 iden,
567 val &= kvmppc_gsid_mask(iden);
568 tmp = cpu_to_be32(val);
569 return kvmppc_gse_put_be32(gsb, iden, tmp);
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
578 static inline int kvmppc_gse_put_be64(struct kvmppc_gs_buff *gsb, u16 iden,
584 return __kvmppc_gse_put(gsb, iden, sizeof(__be64), &tmp);
588 * kvmppc_gse_put_u64() - add a host endian 64bit guest state element to a
590 * @gsb: guest state buffer to add element to
591 * @iden: guest state ID
592 * @val: host endian value
594 static inline int kvmppc_gse_put_u64(struct kvmppc_gs_buff *gsb, u16 iden,
599 val &= kvmppc_gsid_mask(iden);
600 tmp = cpu_to_be64(val);
601 return kvmppc_gse_put_be64(gsb, iden, tmp);
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
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.
614 static inline int __kvmppc_gse_put_reg(struct kvmppc_gs_buff *gsb, u16 iden,
617 val &= kvmppc_gsid_mask(iden);
618 if (kvmppc_gsid_size(iden) == sizeof(u64))
619 return kvmppc_gse_put_u64(gsb, iden, val);
621 if (kvmppc_gsid_size(iden) == sizeof(u32)) {
628 return kvmppc_gse_put_u32(gsb, iden, tmp);
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
639 static inline int kvmppc_gse_put_vector128(struct kvmppc_gs_buff *gsb, u16 iden,
642 __be64 tmp[2] = { 0 };
649 tmp[0] = cpu_to_be64(u.dw[TS_FPROFFSET]);
651 tmp[1] = cpu_to_be64(u.dw[TS_VSRLOWOFFSET]);
653 return __kvmppc_gse_put(gsb, iden, sizeof(tmp), &tmp);
657 * kvmppc_gse_put_part_table() - add a partition table guest state element to a
659 * @gsb: guest state buffer to add element to
660 * @iden: guest state ID
661 * @val: partition table value
663 static inline int kvmppc_gse_put_part_table(struct kvmppc_gs_buff *gsb,
665 struct kvmppc_gs_part_table val)
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),
677 * kvmppc_gse_put_proc_table() - add a process table guest state element to a
679 * @gsb: guest state buffer to add element to
680 * @iden: guest state ID
681 * @val: process table value
683 static inline int kvmppc_gse_put_proc_table(struct kvmppc_gs_buff *gsb,
685 struct kvmppc_gs_proc_table val)
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),
696 * kvmppc_gse_put_buff_info() - adds a GSB description guest state element to a
698 * @gsb: guest state buffer to add element to
699 * @iden: guest state ID
700 * @val: guest state buffer description value
702 static inline int kvmppc_gse_put_buff_info(struct kvmppc_gs_buff *gsb, u16 iden,
703 struct kvmppc_gs_buff_info val)
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);
712 int __kvmppc_gse_put(struct kvmppc_gs_buff *gsb, u16 iden, u16 size,
716 * kvmppc_gse_get_be32() - return the data of a be32 element
717 * @gse: guest state element
719 static inline __be32 kvmppc_gse_get_be32(const struct kvmppc_gs_elem *gse)
721 if (WARN_ON(kvmppc_gse_len(gse) != sizeof(__be32)))
723 return *(__be32 *)kvmppc_gse_data(gse);
727 * kvmppc_gse_get_u32() - return the data of a be32 element in host endianness
728 * @gse: guest state element
730 static inline u32 kvmppc_gse_get_u32(const struct kvmppc_gs_elem *gse)
732 return be32_to_cpu(kvmppc_gse_get_be32(gse));
736 * kvmppc_gse_get_be64() - return the data of a be64 element
737 * @gse: guest state element
739 static inline __be64 kvmppc_gse_get_be64(const struct kvmppc_gs_elem *gse)
741 if (WARN_ON(kvmppc_gse_len(gse) != sizeof(__be64)))
743 return *(__be64 *)kvmppc_gse_data(gse);
747 * kvmppc_gse_get_u64() - return the data of a be64 element in host endianness
748 * @gse: guest state element
750 static inline u64 kvmppc_gse_get_u64(const struct kvmppc_gs_elem *gse)
752 return be64_to_cpu(kvmppc_gse_get_be64(gse));
756 * kvmppc_gse_get_vector128() - return the data of a vector element
757 * @gse: guest state element
759 static inline void kvmppc_gse_get_vector128(const struct kvmppc_gs_elem *gse,
768 if (WARN_ON(kvmppc_gse_len(gse) != sizeof(__vector128)))
771 src = (__be64 *)kvmppc_gse_data(gse);
772 u.dw[TS_FPROFFSET] = be64_to_cpu(src[0]);
774 u.dw[TS_VSRLOWOFFSET] = be64_to_cpu(src[1]);
779 /**************************************************************************
781 **************************************************************************/
783 bool kvmppc_gsbm_test(struct kvmppc_gs_bitmap *gsbm, u16 iden);
784 void kvmppc_gsbm_set(struct kvmppc_gs_bitmap *gsbm, u16 iden);
785 void kvmppc_gsbm_clear(struct kvmppc_gs_bitmap *gsbm, u16 iden);
786 u16 kvmppc_gsbm_next(struct kvmppc_gs_bitmap *gsbm, u16 prev);
789 * kvmppc_gsbm_zero - zero the entire bitmap
790 * @gsbm: guest state buffer bitmap
792 static inline void kvmppc_gsbm_zero(struct kvmppc_gs_bitmap *gsbm)
794 bitmap_zero(gsbm->bitmap, KVMPPC_GSE_IDEN_COUNT);
798 * kvmppc_gsbm_fill - fill the entire bitmap
799 * @gsbm: guest state buffer bitmap
801 static inline void kvmppc_gsbm_fill(struct kvmppc_gs_bitmap *gsbm)
803 bitmap_fill(gsbm->bitmap, KVMPPC_GSE_IDEN_COUNT);
804 clear_bit(0, gsbm->bitmap);
808 * kvmppc_gsbm_for_each - iterate the present guest state IDs
809 * @gsbm: guest state buffer bitmap
810 * @iden: current guest state ID
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))
816 /**************************************************************************
818 **************************************************************************/
820 void kvmppc_gsp_insert(struct kvmppc_gs_parser *gsp, u16 iden,
821 struct kvmppc_gs_elem *gse);
822 struct kvmppc_gs_elem *kvmppc_gsp_lookup(struct kvmppc_gs_parser *gsp,
826 * kvmppc_gsp_for_each - iterate the <guest state IDs, guest state element>
828 * @gsp: guest state buffer bitmap
829 * @iden: current guest state ID
830 * @gse: guest state element
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))
838 /**************************************************************************
839 * Guest State Message
840 **************************************************************************/
843 * kvmppc_gsm_for_each - iterate the guest state IDs included in a guest state
845 * @gsp: guest state buffer bitmap
846 * @iden: current guest state ID
847 * @gse: guest state element
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))
853 int kvmppc_gsm_init(struct kvmppc_gs_msg *mgs, struct kvmppc_gs_msg_ops *ops,
854 void *data, unsigned long flags);
856 struct kvmppc_gs_msg *kvmppc_gsm_new(struct kvmppc_gs_msg_ops *ops, void *data,
857 unsigned long flags, gfp_t gfp_flags);
858 void kvmppc_gsm_free(struct kvmppc_gs_msg *gsm);
859 size_t kvmppc_gsm_size(struct kvmppc_gs_msg *gsm);
860 int kvmppc_gsm_fill_info(struct kvmppc_gs_msg *gsm, struct kvmppc_gs_buff *gsb);
861 int kvmppc_gsm_refresh_info(struct kvmppc_gs_msg *gsm,
862 struct kvmppc_gs_buff *gsb);
865 * kvmppc_gsm_include - indicate a guest state ID should be included when
867 * @gsm: guest state message
868 * @iden: guest state ID
870 static inline void kvmppc_gsm_include(struct kvmppc_gs_msg *gsm, u16 iden)
872 kvmppc_gsbm_set(&gsm->bitmap, iden);
876 * kvmppc_gsm_includes - check if a guest state ID will be included when
878 * @gsm: guest state message
879 * @iden: guest state ID
881 static inline bool kvmppc_gsm_includes(struct kvmppc_gs_msg *gsm, u16 iden)
883 return kvmppc_gsbm_test(&gsm->bitmap, iden);
887 * kvmppc_gsm_includes - indicate all guest state IDs should be included when
889 * @gsm: guest state message
890 * @iden: guest state ID
892 static inline void kvmppc_gsm_include_all(struct kvmppc_gs_msg *gsm)
894 kvmppc_gsbm_fill(&gsm->bitmap);
898 * kvmppc_gsm_include - clear the guest state IDs that should be included when
900 * @gsm: guest state message
902 static inline void kvmppc_gsm_reset(struct kvmppc_gs_msg *gsm)
904 kvmppc_gsbm_zero(&gsm->bitmap);
908 * kvmppc_gsb_receive_data - flexibly update values from a guest state buffer
909 * @gsb: guest state buffer
910 * @gsm: guest state message
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
916 static inline int kvmppc_gsb_receive_data(struct kvmppc_gs_buff *gsb,
917 struct kvmppc_gs_msg *gsm)
921 kvmppc_gsb_reset(gsb);
922 rc = kvmppc_gsm_fill_info(gsm, gsb);
926 rc = kvmppc_gsb_recv(gsb, gsm->flags);
930 rc = kvmppc_gsm_refresh_info(gsm, gsb);
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
942 static inline int kvmppc_gsb_receive_datum(struct kvmppc_gs_buff *gsb,
943 struct kvmppc_gs_msg *gsm, u16 iden)
947 kvmppc_gsm_include(gsm, iden);
948 rc = kvmppc_gsb_receive_data(gsb, gsm);
951 kvmppc_gsm_reset(gsm);
956 * kvmppc_gsb_send_data - flexibly send values from a guest state buffer
957 * @gsb: guest state buffer
958 * @gsm: guest state message
960 * Sends the guest state values included in the guest state message.
962 static inline int kvmppc_gsb_send_data(struct kvmppc_gs_buff *gsb,
963 struct kvmppc_gs_msg *gsm)
967 kvmppc_gsb_reset(gsb);
968 rc = kvmppc_gsm_fill_info(gsm, gsb);
971 rc = kvmppc_gsb_send(gsb, gsm->flags);
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
982 static inline int kvmppc_gsb_send_datum(struct kvmppc_gs_buff *gsb,
983 struct kvmppc_gs_msg *gsm, u16 iden)
987 kvmppc_gsm_include(gsm, iden);
988 rc = kvmppc_gsb_send_data(gsb, gsm);
991 kvmppc_gsm_reset(gsm);
995 #endif /* _ASM_POWERPC_GUEST_STATE_BUFFER_H */