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 * 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 * 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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