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