arch/powerpc/include/asm/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
  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  */
 139 enum {
 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  */
 151 enum {
 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  */
 164 enum {
 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  */
 175 struct 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  */
 186 struct 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  */
 196 struct 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  */
 206 struct 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  */
 217 struct 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  */
 231 struct 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  */
 243 struct 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  */
 257 struct kvmppc_gs_parser {
 258         /* private: */
 259         struct kvmppc_gs_bitmap iterator;
 260         struct kvmppc_gs_elem *gses[KVMPPC_GSE_IDEN_COUNT];
 261 };
 262
 263 enum {
 264         GSM_GUEST_WIDE = 0x1,
 265         GSM_SEND = 0x2,
 266         GSM_RECEIVE = 0x4,
 267         GSM_GSB_OWNER = 0x8,
 268 };
 269
 270 struct 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  */
 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);
 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  */
 295 struct 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
 306 u16 kvmppc_gsid_size(u16 iden);
 307 unsigned long kvmppc_gsid_flags(u16 iden);
 308 u64 kvmppc_gsid_mask(u16 iden);
 309
 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);
 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  */
 326 static inline struct kvmppc_gs_header *
 327 kvmppc_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  */
 338 static 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  */
 349 static 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  */
 360 static 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  */
 371 static 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  */
 382 static 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  */
 393 static 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  */
 405 static 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  */
 416 static 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  */
 444 static 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  */
 455 static 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  */
 466 static 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  */
 477 static 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  */
 488 static 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  */
 500 static 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  */
 514 static inline struct kvmppc_gs_elem *
 515 kvmppc_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
 536 int __kvmppc_gse_put(struct kvmppc_gs_buff *gsb, u16 iden, u16 size,
 537                      const void *data);
 538 int 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  */
 546 static 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  */
 562 static 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  */
 578 static 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  */
 594 static 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  */
 614 static 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  */
 639 static 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  */
 663 static 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  */
 683 static 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  */
 702 static 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
 712 int __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  */
 719 static 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  */
 730 static 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  */
 739 static 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  */
 750 static 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  */
 759 static 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
 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);
 787
 788 /**
 789  * kvmppc_gsbm_zero - zero the entire bitmap
 790  * @gsbm: guest state buffer bitmap
 791  */
 792 static 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  */
 801 static 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
 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,
 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
 853 int kvmppc_gsm_init(struct kvmppc_gs_msg *mgs, struct kvmppc_gs_msg_ops *ops,
 854                     void *data, unsigned long flags);
 855
 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);
 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  */
 870 static 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  */
 881 static 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  */
 892 static 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  */
 902 static 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  */
 916 static 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  */
 942 static 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  */
 962 static 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  */
 982 static 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 */