arch/powerpc/kvm/guest-state-buffer.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 #include "asm/hvcall.h"
   4 #include <linux/log2.h>
   5 #include <asm/pgalloc.h>
   6 #include <asm/guest-state-buffer.h>
   7
   8 static const u16 kvmppc_gse_iden_len[__KVMPPC_GSE_TYPE_MAX] = {
   9         [KVMPPC_GSE_BE32] = sizeof(__be32),
  10         [KVMPPC_GSE_BE64] = sizeof(__be64),
  11         [KVMPPC_GSE_VEC128] = sizeof(vector128),
  12         [KVMPPC_GSE_PARTITION_TABLE] = sizeof(struct kvmppc_gs_part_table),
  13         [KVMPPC_GSE_PROCESS_TABLE] = sizeof(struct kvmppc_gs_proc_table),
  14         [KVMPPC_GSE_BUFFER] = sizeof(struct kvmppc_gs_buff_info),
  15 };
  16
  17 /**
  18  * kvmppc_gsb_new() - create a new guest state buffer
  19  * @size: total size of the guest state buffer (includes header)
  20  * @guest_id: guest_id
  21  * @vcpu_id: vcpu_id
  22  * @flags: GFP flags
  23  *
  24  * Returns a guest state buffer.
  25  */
  26 struct kvmppc_gs_buff *kvmppc_gsb_new(size_t size, unsigned long guest_id,
  27                                       unsigned long vcpu_id, gfp_t flags)
  28 {
  29         struct kvmppc_gs_buff *gsb;
  30
  31         gsb = kzalloc(sizeof(*gsb), flags);
  32         if (!gsb)
  33                 return NULL;
  34
  35         size = roundup_pow_of_two(size);
  36         gsb->hdr = kzalloc(size, GFP_KERNEL);
  37         if (!gsb->hdr)
  38                 goto free;
  39
  40         gsb->capacity = size;
  41         gsb->len = sizeof(struct kvmppc_gs_header);
  42         gsb->vcpu_id = vcpu_id;
  43         gsb->guest_id = guest_id;
  44
  45         gsb->hdr->nelems = cpu_to_be32(0);
  46
  47         return gsb;
  48
  49 free:
  50         kfree(gsb);
  51         return NULL;
  52 }
  53 EXPORT_SYMBOL_GPL(kvmppc_gsb_new);
  54
  55 /**
  56  * kvmppc_gsb_free() - free a guest state buffer
  57  * @gsb: guest state buffer
  58  */
  59 void kvmppc_gsb_free(struct kvmppc_gs_buff *gsb)
  60 {
  61         kfree(gsb->hdr);
  62         kfree(gsb);
  63 }
  64 EXPORT_SYMBOL_GPL(kvmppc_gsb_free);
  65
  66 /**
  67  * kvmppc_gsb_put() - allocate space in a guest state buffer
  68  * @gsb: buffer to allocate in
  69  * @size: amount of space to allocate
  70  *
  71  * Returns a pointer to the amount of space requested within the buffer and
  72  * increments the count of elements in the buffer.
  73  *
  74  * Does not check if there is enough space in the buffer.
  75  */
  76 void *kvmppc_gsb_put(struct kvmppc_gs_buff *gsb, size_t size)
  77 {
  78         u32 nelems = kvmppc_gsb_nelems(gsb);
  79         void *p;
  80
  81         p = (void *)kvmppc_gsb_header(gsb) + kvmppc_gsb_len(gsb);
  82         gsb->len += size;
  83
  84         kvmppc_gsb_header(gsb)->nelems = cpu_to_be32(nelems + 1);
  85         return p;
  86 }
  87 EXPORT_SYMBOL_GPL(kvmppc_gsb_put);
  88
  89 static int kvmppc_gsid_class(u16 iden)
  90 {
  91         if ((iden >= KVMPPC_GSE_GUESTWIDE_START) &&
  92             (iden <= KVMPPC_GSE_GUESTWIDE_END))
  93                 return KVMPPC_GS_CLASS_GUESTWIDE;
  94
  95         if ((iden >= KVMPPC_GSE_META_START) && (iden <= KVMPPC_GSE_META_END))
  96                 return KVMPPC_GS_CLASS_META;
  97
  98         if ((iden >= KVMPPC_GSE_DW_REGS_START) &&
  99             (iden <= KVMPPC_GSE_DW_REGS_END))
 100                 return KVMPPC_GS_CLASS_DWORD_REG;
 101
 102         if ((iden >= KVMPPC_GSE_W_REGS_START) &&
 103             (iden <= KVMPPC_GSE_W_REGS_END))
 104                 return KVMPPC_GS_CLASS_WORD_REG;
 105
 106         if ((iden >= KVMPPC_GSE_VSRS_START) && (iden <= KVMPPC_GSE_VSRS_END))
 107                 return KVMPPC_GS_CLASS_VECTOR;
 108
 109         if ((iden >= KVMPPC_GSE_INTR_REGS_START) &&
 110             (iden <= KVMPPC_GSE_INTR_REGS_END))
 111                 return KVMPPC_GS_CLASS_INTR;
 112
 113         return -1;
 114 }
 115
 116 static int kvmppc_gsid_type(u16 iden)
 117 {
 118         int type = -1;
 119
 120         switch (kvmppc_gsid_class(iden)) {
 121         case KVMPPC_GS_CLASS_GUESTWIDE:
 122                 switch (iden) {
 123                 case KVMPPC_GSID_HOST_STATE_SIZE:
 124                 case KVMPPC_GSID_RUN_OUTPUT_MIN_SIZE:
 125                 case KVMPPC_GSID_TB_OFFSET:
 126                         type = KVMPPC_GSE_BE64;
 127                         break;
 128                 case KVMPPC_GSID_PARTITION_TABLE:
 129                         type = KVMPPC_GSE_PARTITION_TABLE;
 130                         break;
 131                 case KVMPPC_GSID_PROCESS_TABLE:
 132                         type = KVMPPC_GSE_PROCESS_TABLE;
 133                         break;
 134                 case KVMPPC_GSID_LOGICAL_PVR:
 135                         type = KVMPPC_GSE_BE32;
 136                         break;
 137                 }
 138                 break;
 139         case KVMPPC_GS_CLASS_META:
 140                 switch (iden) {
 141                 case KVMPPC_GSID_RUN_INPUT:
 142                 case KVMPPC_GSID_RUN_OUTPUT:
 143                         type = KVMPPC_GSE_BUFFER;
 144                         break;
 145                 case KVMPPC_GSID_VPA:
 146                         type = KVMPPC_GSE_BE64;
 147                         break;
 148                 }
 149                 break;
 150         case KVMPPC_GS_CLASS_DWORD_REG:
 151                 type = KVMPPC_GSE_BE64;
 152                 break;
 153         case KVMPPC_GS_CLASS_WORD_REG:
 154                 type = KVMPPC_GSE_BE32;
 155                 break;
 156         case KVMPPC_GS_CLASS_VECTOR:
 157                 type = KVMPPC_GSE_VEC128;
 158                 break;
 159         case KVMPPC_GS_CLASS_INTR:
 160                 switch (iden) {
 161                 case KVMPPC_GSID_HDAR:
 162                 case KVMPPC_GSID_ASDR:
 163                 case KVMPPC_GSID_HEIR:
 164                         type = KVMPPC_GSE_BE64;
 165                         break;
 166                 case KVMPPC_GSID_HDSISR:
 167                         type = KVMPPC_GSE_BE32;
 168                         break;
 169                 }
 170                 break;
 171         }
 172
 173         return type;
 174 }
 175
 176 /**
 177  * kvmppc_gsid_flags() - the flags for a guest state ID
 178  * @iden: guest state ID
 179  *
 180  * Returns any flags for the guest state ID.
 181  */
 182 unsigned long kvmppc_gsid_flags(u16 iden)
 183 {
 184         unsigned long flags = 0;
 185
 186         switch (kvmppc_gsid_class(iden)) {
 187         case KVMPPC_GS_CLASS_GUESTWIDE:
 188                 flags = KVMPPC_GS_FLAGS_WIDE;
 189                 break;
 190         case KVMPPC_GS_CLASS_META:
 191         case KVMPPC_GS_CLASS_DWORD_REG:
 192         case KVMPPC_GS_CLASS_WORD_REG:
 193         case KVMPPC_GS_CLASS_VECTOR:
 194         case KVMPPC_GS_CLASS_INTR:
 195                 break;
 196         }
 197
 198         return flags;
 199 }
 200 EXPORT_SYMBOL_GPL(kvmppc_gsid_flags);
 201
 202 /**
 203  * kvmppc_gsid_size() - the size of a guest state ID
 204  * @iden: guest state ID
 205  *
 206  * Returns the size of guest state ID.
 207  */
 208 u16 kvmppc_gsid_size(u16 iden)
 209 {
 210         int type;
 211
 212         type = kvmppc_gsid_type(iden);
 213         if (type == -1)
 214                 return 0;
 215
 216         if (type >= __KVMPPC_GSE_TYPE_MAX)
 217                 return 0;
 218
 219         return kvmppc_gse_iden_len[type];
 220 }
 221 EXPORT_SYMBOL_GPL(kvmppc_gsid_size);
 222
 223 /**
 224  * kvmppc_gsid_mask() - the settable bits of a guest state ID
 225  * @iden: guest state ID
 226  *
 227  * Returns a mask of settable bits for a guest state ID.
 228  */
 229 u64 kvmppc_gsid_mask(u16 iden)
 230 {
 231         u64 mask = ~0ull;
 232
 233         switch (iden) {
 234         case KVMPPC_GSID_LPCR:
 235                 mask = LPCR_DPFD | LPCR_ILE | LPCR_AIL | LPCR_LD | LPCR_MER |
 236                        LPCR_GTSE;
 237                 break;
 238         case KVMPPC_GSID_MSR:
 239                 mask = ~(MSR_HV | MSR_S | MSR_ME);
 240                 break;
 241         }
 242
 243         return mask;
 244 }
 245 EXPORT_SYMBOL_GPL(kvmppc_gsid_mask);
 246
 247 /**
 248  * __kvmppc_gse_put() - add a guest state element to a buffer
 249  * @gsb: buffer to the element to
 250  * @iden: guest state ID
 251  * @size: length of data
 252  * @data: pointer to data
 253  */
 254 int __kvmppc_gse_put(struct kvmppc_gs_buff *gsb, u16 iden, u16 size,
 255                      const void *data)
 256 {
 257         struct kvmppc_gs_elem *gse;
 258         u16 total_size;
 259
 260         total_size = sizeof(*gse) + size;
 261         if (total_size + kvmppc_gsb_len(gsb) > kvmppc_gsb_capacity(gsb))
 262                 return -ENOMEM;
 263
 264         if (kvmppc_gsid_size(iden) != size)
 265                 return -EINVAL;
 266
 267         gse = kvmppc_gsb_put(gsb, total_size);
 268         gse->iden = cpu_to_be16(iden);
 269         gse->len = cpu_to_be16(size);
 270         memcpy(gse->data, data, size);
 271
 272         return 0;
 273 }
 274 EXPORT_SYMBOL_GPL(__kvmppc_gse_put);
 275
 276 /**
 277  * kvmppc_gse_parse() - create a parse map from a guest state buffer
 278  * @gsp: guest state parser
 279  * @gsb: guest state buffer
 280  */
 281 int kvmppc_gse_parse(struct kvmppc_gs_parser *gsp, struct kvmppc_gs_buff *gsb)
 282 {
 283         struct kvmppc_gs_elem *curr;
 284         int rem, i;
 285
 286         kvmppc_gsb_for_each_elem(i, curr, gsb, rem) {
 287                 if (kvmppc_gse_len(curr) !=
 288                     kvmppc_gsid_size(kvmppc_gse_iden(curr)))
 289                         return -EINVAL;
 290                 kvmppc_gsp_insert(gsp, kvmppc_gse_iden(curr), curr);
 291         }
 292
 293         if (kvmppc_gsb_nelems(gsb) != i)
 294                 return -EINVAL;
 295         return 0;
 296 }
 297 EXPORT_SYMBOL_GPL(kvmppc_gse_parse);
 298
 299 static inline int kvmppc_gse_flatten_iden(u16 iden)
 300 {
 301         int bit = 0;
 302         int class;
 303
 304         class = kvmppc_gsid_class(iden);
 305
 306         if (class == KVMPPC_GS_CLASS_GUESTWIDE) {
 307                 bit += iden - KVMPPC_GSE_GUESTWIDE_START;
 308                 return bit;
 309         }
 310
 311         bit += KVMPPC_GSE_GUESTWIDE_COUNT;
 312
 313         if (class == KVMPPC_GS_CLASS_META) {
 314                 bit += iden - KVMPPC_GSE_META_START;
 315                 return bit;
 316         }
 317
 318         bit += KVMPPC_GSE_META_COUNT;
 319
 320         if (class == KVMPPC_GS_CLASS_DWORD_REG) {
 321                 bit += iden - KVMPPC_GSE_DW_REGS_START;
 322                 return bit;
 323         }
 324
 325         bit += KVMPPC_GSE_DW_REGS_COUNT;
 326
 327         if (class == KVMPPC_GS_CLASS_WORD_REG) {
 328                 bit += iden - KVMPPC_GSE_W_REGS_START;
 329                 return bit;
 330         }
 331
 332         bit += KVMPPC_GSE_W_REGS_COUNT;
 333
 334         if (class == KVMPPC_GS_CLASS_VECTOR) {
 335                 bit += iden - KVMPPC_GSE_VSRS_START;
 336                 return bit;
 337         }
 338
 339         bit += KVMPPC_GSE_VSRS_COUNT;
 340
 341         if (class == KVMPPC_GS_CLASS_INTR) {
 342                 bit += iden - KVMPPC_GSE_INTR_REGS_START;
 343                 return bit;
 344         }
 345
 346         return 0;
 347 }
 348
 349 static inline u16 kvmppc_gse_unflatten_iden(int bit)
 350 {
 351         u16 iden;
 352
 353         if (bit < KVMPPC_GSE_GUESTWIDE_COUNT) {
 354                 iden = KVMPPC_GSE_GUESTWIDE_START + bit;
 355                 return iden;
 356         }
 357         bit -= KVMPPC_GSE_GUESTWIDE_COUNT;
 358
 359         if (bit < KVMPPC_GSE_META_COUNT) {
 360                 iden = KVMPPC_GSE_META_START + bit;
 361                 return iden;
 362         }
 363         bit -= KVMPPC_GSE_META_COUNT;
 364
 365         if (bit < KVMPPC_GSE_DW_REGS_COUNT) {
 366                 iden = KVMPPC_GSE_DW_REGS_START + bit;
 367                 return iden;
 368         }
 369         bit -= KVMPPC_GSE_DW_REGS_COUNT;
 370
 371         if (bit < KVMPPC_GSE_W_REGS_COUNT) {
 372                 iden = KVMPPC_GSE_W_REGS_START + bit;
 373                 return iden;
 374         }
 375         bit -= KVMPPC_GSE_W_REGS_COUNT;
 376
 377         if (bit < KVMPPC_GSE_VSRS_COUNT) {
 378                 iden = KVMPPC_GSE_VSRS_START + bit;
 379                 return iden;
 380         }
 381         bit -= KVMPPC_GSE_VSRS_COUNT;
 382
 383         if (bit < KVMPPC_GSE_IDEN_COUNT) {
 384                 iden = KVMPPC_GSE_INTR_REGS_START + bit;
 385                 return iden;
 386         }
 387
 388         return 0;
 389 }
 390
 391 /**
 392  * kvmppc_gsp_insert() - add a mapping from an guest state ID to an element
 393  * @gsp: guest state parser
 394  * @iden: guest state id (key)
 395  * @gse: guest state element (value)
 396  */
 397 void kvmppc_gsp_insert(struct kvmppc_gs_parser *gsp, u16 iden,
 398                        struct kvmppc_gs_elem *gse)
 399 {
 400         int i;
 401
 402         i = kvmppc_gse_flatten_iden(iden);
 403         kvmppc_gsbm_set(&gsp->iterator, iden);
 404         gsp->gses[i] = gse;
 405 }
 406 EXPORT_SYMBOL_GPL(kvmppc_gsp_insert);
 407
 408 /**
 409  * kvmppc_gsp_lookup() - lookup an element from a guest state ID
 410  * @gsp: guest state parser
 411  * @iden: guest state ID (key)
 412  *
 413  * Returns the guest state element if present.
 414  */
 415 struct kvmppc_gs_elem *kvmppc_gsp_lookup(struct kvmppc_gs_parser *gsp, u16 iden)
 416 {
 417         int i;
 418
 419         i = kvmppc_gse_flatten_iden(iden);
 420         return gsp->gses[i];
 421 }
 422 EXPORT_SYMBOL_GPL(kvmppc_gsp_lookup);
 423
 424 /**
 425  * kvmppc_gsbm_set() - set the guest state ID
 426  * @gsbm: guest state bitmap
 427  * @iden: guest state ID
 428  */
 429 void kvmppc_gsbm_set(struct kvmppc_gs_bitmap *gsbm, u16 iden)
 430 {
 431         set_bit(kvmppc_gse_flatten_iden(iden), gsbm->bitmap);
 432 }
 433 EXPORT_SYMBOL_GPL(kvmppc_gsbm_set);
 434
 435 /**
 436  * kvmppc_gsbm_clear() - clear the guest state ID
 437  * @gsbm: guest state bitmap
 438  * @iden: guest state ID
 439  */
 440 void kvmppc_gsbm_clear(struct kvmppc_gs_bitmap *gsbm, u16 iden)
 441 {
 442         clear_bit(kvmppc_gse_flatten_iden(iden), gsbm->bitmap);
 443 }
 444 EXPORT_SYMBOL_GPL(kvmppc_gsbm_clear);
 445
 446 /**
 447  * kvmppc_gsbm_test() - test the guest state ID
 448  * @gsbm: guest state bitmap
 449  * @iden: guest state ID
 450  */
 451 bool kvmppc_gsbm_test(struct kvmppc_gs_bitmap *gsbm, u16 iden)
 452 {
 453         return test_bit(kvmppc_gse_flatten_iden(iden), gsbm->bitmap);
 454 }
 455 EXPORT_SYMBOL_GPL(kvmppc_gsbm_test);
 456
 457 /**
 458  * kvmppc_gsbm_next() - return the next set guest state ID
 459  * @gsbm: guest state bitmap
 460  * @prev: last guest state ID
 461  */
 462 u16 kvmppc_gsbm_next(struct kvmppc_gs_bitmap *gsbm, u16 prev)
 463 {
 464         int bit, pbit;
 465
 466         pbit = prev ? kvmppc_gse_flatten_iden(prev) + 1 : 0;
 467         bit = find_next_bit(gsbm->bitmap, KVMPPC_GSE_IDEN_COUNT, pbit);
 468
 469         if (bit < KVMPPC_GSE_IDEN_COUNT)
 470                 return kvmppc_gse_unflatten_iden(bit);
 471         return 0;
 472 }
 473 EXPORT_SYMBOL_GPL(kvmppc_gsbm_next);
 474
 475 /**
 476  * kvmppc_gsm_init() - initialize a guest state message
 477  * @gsm: guest state message
 478  * @ops: callbacks
 479  * @data: private data
 480  * @flags: guest wide or thread wide
 481  */
 482 int kvmppc_gsm_init(struct kvmppc_gs_msg *gsm, struct kvmppc_gs_msg_ops *ops,
 483                     void *data, unsigned long flags)
 484 {
 485         memset(gsm, 0, sizeof(*gsm));
 486         gsm->ops = ops;
 487         gsm->data = data;
 488         gsm->flags = flags;
 489
 490         return 0;
 491 }
 492 EXPORT_SYMBOL_GPL(kvmppc_gsm_init);
 493
 494 /**
 495  * kvmppc_gsm_new() - creates a new guest state message
 496  * @ops: callbacks
 497  * @data: private data
 498  * @flags: guest wide or thread wide
 499  * @gfp_flags: GFP allocation flags
 500  *
 501  * Returns an initialized guest state message.
 502  */
 503 struct kvmppc_gs_msg *kvmppc_gsm_new(struct kvmppc_gs_msg_ops *ops, void *data,
 504                                      unsigned long flags, gfp_t gfp_flags)
 505 {
 506         struct kvmppc_gs_msg *gsm;
 507
 508         gsm = kzalloc(sizeof(*gsm), gfp_flags);
 509         if (!gsm)
 510                 return NULL;
 511
 512         kvmppc_gsm_init(gsm, ops, data, flags);
 513
 514         return gsm;
 515 }
 516 EXPORT_SYMBOL_GPL(kvmppc_gsm_new);
 517
 518 /**
 519  * kvmppc_gsm_size() - creates a new guest state message
 520  * @gsm: self
 521  *
 522  * Returns the size required for the message.
 523  */
 524 size_t kvmppc_gsm_size(struct kvmppc_gs_msg *gsm)
 525 {
 526         if (gsm->ops->get_size)
 527                 return gsm->ops->get_size(gsm);
 528         return 0;
 529 }
 530 EXPORT_SYMBOL_GPL(kvmppc_gsm_size);
 531
 532 /**
 533  * kvmppc_gsm_free() - free guest state message
 534  * @gsm: guest state message
 535  *
 536  * Returns the size required for the message.
 537  */
 538 void kvmppc_gsm_free(struct kvmppc_gs_msg *gsm)
 539 {
 540         kfree(gsm);
 541 }
 542 EXPORT_SYMBOL_GPL(kvmppc_gsm_free);
 543
 544 /**
 545  * kvmppc_gsm_fill_info() - serialises message to guest state buffer format
 546  * @gsm: self
 547  * @gsb: buffer to serialise into
 548  */
 549 int kvmppc_gsm_fill_info(struct kvmppc_gs_msg *gsm, struct kvmppc_gs_buff *gsb)
 550 {
 551         if (!gsm->ops->fill_info)
 552                 return -EINVAL;
 553
 554         return gsm->ops->fill_info(gsb, gsm);
 555 }
 556 EXPORT_SYMBOL_GPL(kvmppc_gsm_fill_info);
 557
 558 /**
 559  * kvmppc_gsm_refresh_info() - deserialises from guest state buffer
 560  * @gsm: self
 561  * @gsb: buffer to serialise from
 562  */
 563 int kvmppc_gsm_refresh_info(struct kvmppc_gs_msg *gsm,
 564                             struct kvmppc_gs_buff *gsb)
 565 {
 566         if (!gsm->ops->fill_info)
 567                 return -EINVAL;
 568
 569         return gsm->ops->refresh_info(gsm, gsb);
 570 }
 571 EXPORT_SYMBOL_GPL(kvmppc_gsm_refresh_info);
 572
 573 /**
 574  * kvmppc_gsb_send - send all elements in the buffer to the hypervisor.
 575  * @gsb: guest state buffer
 576  * @flags: guest wide or thread wide
 577  *
 578  * Performs the H_GUEST_SET_STATE hcall for the guest state buffer.
 579  */
 580 int kvmppc_gsb_send(struct kvmppc_gs_buff *gsb, unsigned long flags)
 581 {
 582         unsigned long hflags = 0;
 583         unsigned long i;
 584         int rc;
 585
 586         if (kvmppc_gsb_nelems(gsb) == 0)
 587                 return 0;
 588
 589         if (flags & KVMPPC_GS_FLAGS_WIDE)
 590                 hflags |= H_GUEST_FLAGS_WIDE;
 591
 592         rc = plpar_guest_set_state(hflags, gsb->guest_id, gsb->vcpu_id,
 593                                    __pa(gsb->hdr), gsb->capacity, &i);
 594         return rc;
 595 }
 596 EXPORT_SYMBOL_GPL(kvmppc_gsb_send);
 597
 598 /**
 599  * kvmppc_gsb_recv - request all elements in the buffer have their value
 600  * updated.
 601  * @gsb: guest state buffer
 602  * @flags: guest wide or thread wide
 603  *
 604  * Performs the H_GUEST_GET_STATE hcall for the guest state buffer.
 605  * After returning from the hcall the guest state elements that were
 606  * present in the buffer will have updated values from the hypervisor.
 607  */
 608 int kvmppc_gsb_recv(struct kvmppc_gs_buff *gsb, unsigned long flags)
 609 {
 610         unsigned long hflags = 0;
 611         unsigned long i;
 612         int rc;
 613
 614         if (flags & KVMPPC_GS_FLAGS_WIDE)
 615                 hflags |= H_GUEST_FLAGS_WIDE;
 616
 617         rc = plpar_guest_get_state(hflags, gsb->guest_id, gsb->vcpu_id,
 618                                    __pa(gsb->hdr), gsb->capacity, &i);
 619         return rc;
 620 }
 621 EXPORT_SYMBOL_GPL(kvmppc_gsb_recv);