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/* 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 */
 161enum {
 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 */
 174enum {
 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 */
 187enum {
 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 */
 199struct 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 */
 210struct 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 */
 220struct 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 */
 230struct 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 */
 241struct 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 */
 255struct 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 */
 267struct 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 */
 281struct kvmppc_gs_parser {
 282	/* private: */
 283	struct kvmppc_gs_bitmap iterator;
 284	struct kvmppc_gs_elem *gses[KVMPPC_GSE_IDEN_COUNT];
 285};
 286
 287enum {
 288	GSM_GUEST_WIDE = 0x1,
 289	GSM_SEND = 0x2,
 290	GSM_RECEIVE = 0x4,
 291	GSM_GSB_OWNER = 0x8,
 292};
 293
 294struct 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 */
 302struct 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 */
 319struct 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
 330u16 kvmppc_gsid_size(u16 iden);
 331unsigned long kvmppc_gsid_flags(u16 iden);
 332u64 kvmppc_gsid_mask(u16 iden);
 333
 334/**************************************************************************
 335 * Guest State Buffers
 336 **************************************************************************/
 337struct kvmppc_gs_buff *kvmppc_gsb_new(size_t size, unsigned long guest_id,
 338				      unsigned long vcpu_id, gfp_t flags);
 339void kvmppc_gsb_free(struct kvmppc_gs_buff *gsb);
 340void *kvmppc_gsb_put(struct kvmppc_gs_buff *gsb, size_t size);
 341int kvmppc_gsb_send(struct kvmppc_gs_buff *gsb, unsigned long flags);
 342int 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 */
 350static inline struct kvmppc_gs_header *
 351kvmppc_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 */
 362static 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 */
 373static 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 */
 384static 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 */
 395static 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 */
 406static 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 */
 417static 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 */
 429static 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 */
 440static 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 */
 468static 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 */
 479static 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 */
 490static 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 */
 501static 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 */
 512static 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 */
 524static 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 */
 538static inline struct kvmppc_gs_elem *
 539kvmppc_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
 560int __kvmppc_gse_put(struct kvmppc_gs_buff *gsb, u16 iden, u16 size,
 561		     const void *data);
 562int 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 */
 570static 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 */
 586static 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 */
 602static 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 */
 618static 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 */
 638static 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 */
 663static 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 */
 687static 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 */
 707static 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 */
 726static 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
 736int __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 */
 743static 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 */
 754static 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 */
 763static 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 */
 774static 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 */
 783static 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
 807bool kvmppc_gsbm_test(struct kvmppc_gs_bitmap *gsbm, u16 iden);
 808void kvmppc_gsbm_set(struct kvmppc_gs_bitmap *gsbm, u16 iden);
 809void kvmppc_gsbm_clear(struct kvmppc_gs_bitmap *gsbm, u16 iden);
 810u16 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 */
 816static 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 */
 825static 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
 844void kvmppc_gsp_insert(struct kvmppc_gs_parser *gsp, u16 iden,
 845		       struct kvmppc_gs_elem *gse);
 846struct 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
 877int kvmppc_gsm_init(struct kvmppc_gs_msg *mgs, struct kvmppc_gs_msg_ops *ops,
 878		    void *data, unsigned long flags);
 879
 880struct kvmppc_gs_msg *kvmppc_gsm_new(struct kvmppc_gs_msg_ops *ops, void *data,
 881				     unsigned long flags, gfp_t gfp_flags);
 882void kvmppc_gsm_free(struct kvmppc_gs_msg *gsm);
 883size_t kvmppc_gsm_size(struct kvmppc_gs_msg *gsm);
 884int kvmppc_gsm_fill_info(struct kvmppc_gs_msg *gsm, struct kvmppc_gs_buff *gsb);
 885int 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 */
 894static 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 */
 905static 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 */
 916static 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 */
 926static 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 */
 940static 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 */
 966static 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 */
 986static 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 */
1006static 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 */