hw/intc/spapr_xive_kvm.c

   1 /*
   2  * QEMU PowerPC sPAPR XIVE interrupt controller model
   3  *
   4  * Copyright (c) 2017-2019, IBM Corporation.
   5  *
   6  * This code is licensed under the GPL version 2 or later. See the
   7  * COPYING file in the top-level directory.
   8  */
   9
  10 #include "qemu/osdep.h"
  11 #include "qemu/log.h"
  12 #include "qemu/error-report.h"
  13 #include "qapi/error.h"
  14 #include "target/ppc/cpu.h"
  15 #include "sysemu/cpus.h"
  16 #include "sysemu/kvm.h"
  17 #include "sysemu/runstate.h"
  18 #include "hw/ppc/spapr.h"
  19 #include "hw/ppc/spapr_cpu_core.h"
  20 #include "hw/ppc/spapr_xive.h"
  21 #include "hw/ppc/xive.h"
  22 #include "kvm_ppc.h"
  23
  24 #include <sys/ioctl.h>
  25
  26 /*
  27  * Helpers for CPU hotplug
  28  *
  29  * TODO: make a common KVMEnabledCPU layer for XICS and XIVE
  30  */
  31 typedef struct KVMEnabledCPU {
  32     unsigned long vcpu_id;
  33     QLIST_ENTRY(KVMEnabledCPU) node;
  34 } KVMEnabledCPU;
  35
  36 static QLIST_HEAD(, KVMEnabledCPU)
  37     kvm_enabled_cpus = QLIST_HEAD_INITIALIZER(&kvm_enabled_cpus);
  38
  39 static bool kvm_cpu_is_enabled(CPUState *cs)
  40 {
  41     KVMEnabledCPU *enabled_cpu;
  42     unsigned long vcpu_id = kvm_arch_vcpu_id(cs);
  43
  44     QLIST_FOREACH(enabled_cpu, &kvm_enabled_cpus, node) {
  45         if (enabled_cpu->vcpu_id == vcpu_id) {
  46             return true;
  47         }
  48     }
  49     return false;
  50 }
  51
  52 static void kvm_cpu_enable(CPUState *cs)
  53 {
  54     KVMEnabledCPU *enabled_cpu;
  55     unsigned long vcpu_id = kvm_arch_vcpu_id(cs);
  56
  57     enabled_cpu = g_malloc(sizeof(*enabled_cpu));
  58     enabled_cpu->vcpu_id = vcpu_id;
  59     QLIST_INSERT_HEAD(&kvm_enabled_cpus, enabled_cpu, node);
  60 }
  61
  62 static void kvm_cpu_disable_all(void)
  63 {
  64     KVMEnabledCPU *enabled_cpu, *next;
  65
  66     QLIST_FOREACH_SAFE(enabled_cpu, &kvm_enabled_cpus, node, next) {
  67         QLIST_REMOVE(enabled_cpu, node);
  68         g_free(enabled_cpu);
  69     }
  70 }
  71
  72 /*
  73  * XIVE Thread Interrupt Management context (KVM)
  74  */
  75
  76 void kvmppc_xive_cpu_set_state(XiveTCTX *tctx, Error **errp)
  77 {
  78     SpaprXive *xive = SPAPR_MACHINE(qdev_get_machine())->xive;
  79     uint64_t state[2];
  80     int ret;
  81
  82     /* The KVM XIVE device is not in use yet */
  83     if (xive->fd == -1) {
  84         return;
  85     }
  86
  87     /* word0 and word1 of the OS ring. */
  88     state[0] = *((uint64_t *) &tctx->regs[TM_QW1_OS]);
  89
  90     ret = kvm_set_one_reg(tctx->cs, KVM_REG_PPC_VP_STATE, state);
  91     if (ret != 0) {
  92         error_setg_errno(errp, errno,
  93                          "XIVE: could not restore KVM state of CPU %ld",
  94                          kvm_arch_vcpu_id(tctx->cs));
  95     }
  96 }
  97
  98 void kvmppc_xive_cpu_get_state(XiveTCTX *tctx, Error **errp)
  99 {
 100     SpaprXive *xive = SPAPR_MACHINE(qdev_get_machine())->xive;
 101     uint64_t state[2] = { 0 };
 102     int ret;
 103
 104     /* The KVM XIVE device is not in use */
 105     if (xive->fd == -1) {
 106         return;
 107     }
 108
 109     ret = kvm_get_one_reg(tctx->cs, KVM_REG_PPC_VP_STATE, state);
 110     if (ret != 0) {
 111         error_setg_errno(errp, errno,
 112                          "XIVE: could not capture KVM state of CPU %ld",
 113                          kvm_arch_vcpu_id(tctx->cs));
 114         return;
 115     }
 116
 117     /* word0 and word1 of the OS ring. */
 118     *((uint64_t *) &tctx->regs[TM_QW1_OS]) = state[0];
 119 }
 120
 121 typedef struct {
 122     XiveTCTX *tctx;
 123     Error *err;
 124 } XiveCpuGetState;
 125
 126 static void kvmppc_xive_cpu_do_synchronize_state(CPUState *cpu,
 127                                                  run_on_cpu_data arg)
 128 {
 129     XiveCpuGetState *s = arg.host_ptr;
 130
 131     kvmppc_xive_cpu_get_state(s->tctx, &s->err);
 132 }
 133
 134 void kvmppc_xive_cpu_synchronize_state(XiveTCTX *tctx, Error **errp)
 135 {
 136     XiveCpuGetState s = {
 137         .tctx = tctx,
 138         .err = NULL,
 139     };
 140
 141     /*
 142      * Kick the vCPU to make sure they are available for the KVM ioctl.
 143      */
 144     run_on_cpu(tctx->cs, kvmppc_xive_cpu_do_synchronize_state,
 145                RUN_ON_CPU_HOST_PTR(&s));
 146
 147     if (s.err) {
 148         error_propagate(errp, s.err);
 149         return;
 150     }
 151 }
 152
 153 void kvmppc_xive_cpu_connect(XiveTCTX *tctx, Error **errp)
 154 {
 155     SpaprXive *xive = SPAPR_MACHINE(qdev_get_machine())->xive;
 156     unsigned long vcpu_id;
 157     int ret;
 158
 159     /* The KVM XIVE device is not in use */
 160     if (xive->fd == -1) {
 161         return;
 162     }
 163
 164     /* Check if CPU was hot unplugged and replugged. */
 165     if (kvm_cpu_is_enabled(tctx->cs)) {
 166         return;
 167     }
 168
 169     vcpu_id = kvm_arch_vcpu_id(tctx->cs);
 170
 171     ret = kvm_vcpu_enable_cap(tctx->cs, KVM_CAP_PPC_IRQ_XIVE, 0, xive->fd,
 172                               vcpu_id, 0);
 173     if (ret < 0) {
 174         error_setg(errp, "XIVE: unable to connect CPU%ld to KVM device: %s",
 175                    vcpu_id, strerror(errno));
 176         return;
 177     }
 178
 179     kvm_cpu_enable(tctx->cs);
 180 }
 181
 182 /*
 183  * XIVE Interrupt Source (KVM)
 184  */
 185
 186 void kvmppc_xive_set_source_config(SpaprXive *xive, uint32_t lisn, XiveEAS *eas,
 187                                    Error **errp)
 188 {
 189     uint32_t end_idx;
 190     uint32_t end_blk;
 191     uint8_t priority;
 192     uint32_t server;
 193     bool masked;
 194     uint32_t eisn;
 195     uint64_t kvm_src;
 196     Error *local_err = NULL;
 197
 198     assert(xive_eas_is_valid(eas));
 199
 200     end_idx = xive_get_field64(EAS_END_INDEX, eas->w);
 201     end_blk = xive_get_field64(EAS_END_BLOCK, eas->w);
 202     eisn = xive_get_field64(EAS_END_DATA, eas->w);
 203     masked = xive_eas_is_masked(eas);
 204
 205     spapr_xive_end_to_target(end_blk, end_idx, &server, &priority);
 206
 207     kvm_src = priority << KVM_XIVE_SOURCE_PRIORITY_SHIFT &
 208         KVM_XIVE_SOURCE_PRIORITY_MASK;
 209     kvm_src |= server << KVM_XIVE_SOURCE_SERVER_SHIFT &
 210         KVM_XIVE_SOURCE_SERVER_MASK;
 211     kvm_src |= ((uint64_t) masked << KVM_XIVE_SOURCE_MASKED_SHIFT) &
 212         KVM_XIVE_SOURCE_MASKED_MASK;
 213     kvm_src |= ((uint64_t)eisn << KVM_XIVE_SOURCE_EISN_SHIFT) &
 214         KVM_XIVE_SOURCE_EISN_MASK;
 215
 216     kvm_device_access(xive->fd, KVM_DEV_XIVE_GRP_SOURCE_CONFIG, lisn,
 217                       &kvm_src, true, &local_err);
 218     if (local_err) {
 219         error_propagate(errp, local_err);
 220         return;
 221     }
 222 }
 223
 224 void kvmppc_xive_sync_source(SpaprXive *xive, uint32_t lisn, Error **errp)
 225 {
 226     kvm_device_access(xive->fd, KVM_DEV_XIVE_GRP_SOURCE_SYNC, lisn,
 227                       NULL, true, errp);
 228 }
 229
 230 /*
 231  * At reset, the interrupt sources are simply created and MASKED. We
 232  * only need to inform the KVM XIVE device about their type: LSI or
 233  * MSI.
 234  */
 235 int kvmppc_xive_source_reset_one(XiveSource *xsrc, int srcno, Error **errp)
 236 {
 237     SpaprXive *xive = SPAPR_XIVE(xsrc->xive);
 238     uint64_t state = 0;
 239
 240     /* The KVM XIVE device is not in use */
 241     if (xive->fd == -1) {
 242         return -ENODEV;
 243     }
 244
 245     if (xive_source_irq_is_lsi(xsrc, srcno)) {
 246         state |= KVM_XIVE_LEVEL_SENSITIVE;
 247         if (xsrc->status[srcno] & XIVE_STATUS_ASSERTED) {
 248             state |= KVM_XIVE_LEVEL_ASSERTED;
 249         }
 250     }
 251
 252     return kvm_device_access(xive->fd, KVM_DEV_XIVE_GRP_SOURCE, srcno, &state,
 253                              true, errp);
 254 }
 255
 256 static void kvmppc_xive_source_reset(XiveSource *xsrc, Error **errp)
 257 {
 258     SpaprXive *xive = SPAPR_XIVE(xsrc->xive);
 259     int i;
 260
 261     for (i = 0; i < xsrc->nr_irqs; i++) {
 262         Error *local_err = NULL;
 263
 264         if (!xive_eas_is_valid(&xive->eat[i])) {
 265             continue;
 266         }
 267
 268         kvmppc_xive_source_reset_one(xsrc, i, &local_err);
 269         if (local_err) {
 270             error_propagate(errp, local_err);
 271             return;
 272         }
 273     }
 274 }
 275
 276 /*
 277  * This is used to perform the magic loads on the ESB pages, described
 278  * in xive.h.
 279  *
 280  * Memory barriers should not be needed for loads (no store for now).
 281  */
 282 static uint64_t xive_esb_rw(XiveSource *xsrc, int srcno, uint32_t offset,
 283                             uint64_t data, bool write)
 284 {
 285     uint64_t *addr = xsrc->esb_mmap + xive_source_esb_mgmt(xsrc, srcno) +
 286         offset;
 287
 288     if (write) {
 289         *addr = cpu_to_be64(data);
 290         return -1;
 291     } else {
 292         /* Prevent the compiler from optimizing away the load */
 293         volatile uint64_t value = be64_to_cpu(*addr);
 294         return value;
 295     }
 296 }
 297
 298 static uint8_t xive_esb_read(XiveSource *xsrc, int srcno, uint32_t offset)
 299 {
 300     return xive_esb_rw(xsrc, srcno, offset, 0, 0) & 0x3;
 301 }
 302
 303 static void xive_esb_trigger(XiveSource *xsrc, int srcno)
 304 {
 305     uint64_t *addr = xsrc->esb_mmap + xive_source_esb_page(xsrc, srcno);
 306
 307     *addr = 0x0;
 308 }
 309
 310 uint64_t kvmppc_xive_esb_rw(XiveSource *xsrc, int srcno, uint32_t offset,
 311                             uint64_t data, bool write)
 312 {
 313     if (write) {
 314         return xive_esb_rw(xsrc, srcno, offset, data, 1);
 315     }
 316
 317     /*
 318      * Special Load EOI handling for LSI sources. Q bit is never set
 319      * and the interrupt should be re-triggered if the level is still
 320      * asserted.
 321      */
 322     if (xive_source_irq_is_lsi(xsrc, srcno) &&
 323         offset == XIVE_ESB_LOAD_EOI) {
 324         xive_esb_read(xsrc, srcno, XIVE_ESB_SET_PQ_00);
 325         if (xsrc->status[srcno] & XIVE_STATUS_ASSERTED) {
 326             xive_esb_trigger(xsrc, srcno);
 327         }
 328         return 0;
 329     } else {
 330         return xive_esb_rw(xsrc, srcno, offset, 0, 0);
 331     }
 332 }
 333
 334 static void kvmppc_xive_source_get_state(XiveSource *xsrc)
 335 {
 336     SpaprXive *xive = SPAPR_XIVE(xsrc->xive);
 337     int i;
 338
 339     for (i = 0; i < xsrc->nr_irqs; i++) {
 340         uint8_t pq;
 341
 342         if (!xive_eas_is_valid(&xive->eat[i])) {
 343             continue;
 344         }
 345
 346         /* Perform a load without side effect to retrieve the PQ bits */
 347         pq = xive_esb_read(xsrc, i, XIVE_ESB_GET);
 348
 349         /* and save PQ locally */
 350         xive_source_esb_set(xsrc, i, pq);
 351     }
 352 }
 353
 354 void kvmppc_xive_source_set_irq(void *opaque, int srcno, int val)
 355 {
 356     XiveSource *xsrc = opaque;
 357
 358     if (!xive_source_irq_is_lsi(xsrc, srcno)) {
 359         if (!val) {
 360             return;
 361         }
 362     } else {
 363         if (val) {
 364             xsrc->status[srcno] |= XIVE_STATUS_ASSERTED;
 365         } else {
 366             xsrc->status[srcno] &= ~XIVE_STATUS_ASSERTED;
 367         }
 368     }
 369
 370     xive_esb_trigger(xsrc, srcno);
 371 }
 372
 373 /*
 374  * sPAPR XIVE interrupt controller (KVM)
 375  */
 376 void kvmppc_xive_get_queue_config(SpaprXive *xive, uint8_t end_blk,
 377                                   uint32_t end_idx, XiveEND *end,
 378                                   Error **errp)
 379 {
 380     struct kvm_ppc_xive_eq kvm_eq = { 0 };
 381     uint64_t kvm_eq_idx;
 382     uint8_t priority;
 383     uint32_t server;
 384     Error *local_err = NULL;
 385
 386     assert(xive_end_is_valid(end));
 387
 388     /* Encode the tuple (server, prio) as a KVM EQ index */
 389     spapr_xive_end_to_target(end_blk, end_idx, &server, &priority);
 390
 391     kvm_eq_idx = priority << KVM_XIVE_EQ_PRIORITY_SHIFT &
 392             KVM_XIVE_EQ_PRIORITY_MASK;
 393     kvm_eq_idx |= server << KVM_XIVE_EQ_SERVER_SHIFT &
 394         KVM_XIVE_EQ_SERVER_MASK;
 395
 396     kvm_device_access(xive->fd, KVM_DEV_XIVE_GRP_EQ_CONFIG, kvm_eq_idx,
 397                       &kvm_eq, false, &local_err);
 398     if (local_err) {
 399         error_propagate(errp, local_err);
 400         return;
 401     }
 402
 403     /*
 404      * The EQ index and toggle bit are updated by HW. These are the
 405      * only fields from KVM we want to update QEMU with. The other END
 406      * fields should already be in the QEMU END table.
 407      */
 408     end->w1 = xive_set_field32(END_W1_GENERATION, 0ul, kvm_eq.qtoggle) |
 409         xive_set_field32(END_W1_PAGE_OFF, 0ul, kvm_eq.qindex);
 410 }
 411
 412 void kvmppc_xive_set_queue_config(SpaprXive *xive, uint8_t end_blk,
 413                                   uint32_t end_idx, XiveEND *end,
 414                                   Error **errp)
 415 {
 416     struct kvm_ppc_xive_eq kvm_eq = { 0 };
 417     uint64_t kvm_eq_idx;
 418     uint8_t priority;
 419     uint32_t server;
 420     Error *local_err = NULL;
 421
 422     /*
 423      * Build the KVM state from the local END structure.
 424      */
 425
 426     kvm_eq.flags = 0;
 427     if (xive_get_field32(END_W0_UCOND_NOTIFY, end->w0)) {
 428         kvm_eq.flags |= KVM_XIVE_EQ_ALWAYS_NOTIFY;
 429     }
 430
 431     /*
 432      * If the hcall is disabling the EQ, set the size and page address
 433      * to zero. When migrating, only valid ENDs are taken into
 434      * account.
 435      */
 436     if (xive_end_is_valid(end)) {
 437         kvm_eq.qshift = xive_get_field32(END_W0_QSIZE, end->w0) + 12;
 438         kvm_eq.qaddr  = xive_end_qaddr(end);
 439         /*
 440          * The EQ toggle bit and index should only be relevant when
 441          * restoring the EQ state
 442          */
 443         kvm_eq.qtoggle = xive_get_field32(END_W1_GENERATION, end->w1);
 444         kvm_eq.qindex  = xive_get_field32(END_W1_PAGE_OFF, end->w1);
 445     } else {
 446         kvm_eq.qshift = 0;
 447         kvm_eq.qaddr  = 0;
 448     }
 449
 450     /* Encode the tuple (server, prio) as a KVM EQ index */
 451     spapr_xive_end_to_target(end_blk, end_idx, &server, &priority);
 452
 453     kvm_eq_idx = priority << KVM_XIVE_EQ_PRIORITY_SHIFT &
 454             KVM_XIVE_EQ_PRIORITY_MASK;
 455     kvm_eq_idx |= server << KVM_XIVE_EQ_SERVER_SHIFT &
 456         KVM_XIVE_EQ_SERVER_MASK;
 457
 458     kvm_device_access(xive->fd, KVM_DEV_XIVE_GRP_EQ_CONFIG, kvm_eq_idx,
 459                       &kvm_eq, true, &local_err);
 460     if (local_err) {
 461         error_propagate(errp, local_err);
 462         return;
 463     }
 464 }
 465
 466 void kvmppc_xive_reset(SpaprXive *xive, Error **errp)
 467 {
 468     kvm_device_access(xive->fd, KVM_DEV_XIVE_GRP_CTRL, KVM_DEV_XIVE_RESET,
 469                       NULL, true, errp);
 470 }
 471
 472 static void kvmppc_xive_get_queues(SpaprXive *xive, Error **errp)
 473 {
 474     Error *local_err = NULL;
 475     int i;
 476
 477     for (i = 0; i < xive->nr_ends; i++) {
 478         if (!xive_end_is_valid(&xive->endt[i])) {
 479             continue;
 480         }
 481
 482         kvmppc_xive_get_queue_config(xive, SPAPR_XIVE_BLOCK_ID, i,
 483                                      &xive->endt[i], &local_err);
 484         if (local_err) {
 485             error_propagate(errp, local_err);
 486             return;
 487         }
 488     }
 489 }
 490
 491 /*
 492  * The primary goal of the XIVE VM change handler is to mark the EQ
 493  * pages dirty when all XIVE event notifications have stopped.
 494  *
 495  * Whenever the VM is stopped, the VM change handler sets the source
 496  * PQs to PENDING to stop the flow of events and to possibly catch a
 497  * triggered interrupt occuring while the VM is stopped. The previous
 498  * state is saved in anticipation of a migration. The XIVE controller
 499  * is then synced through KVM to flush any in-flight event
 500  * notification and stabilize the EQs.
 501  *
 502  * At this stage, we can mark the EQ page dirty and let a migration
 503  * sequence transfer the EQ pages to the destination, which is done
 504  * just after the stop state.
 505  *
 506  * The previous configuration of the sources is restored when the VM
 507  * runs again. If an interrupt was queued while the VM was stopped,
 508  * simply generate a trigger.
 509  */
 510 static void kvmppc_xive_change_state_handler(void *opaque, int running,
 511                                              RunState state)
 512 {
 513     SpaprXive *xive = opaque;
 514     XiveSource *xsrc = &xive->source;
 515     Error *local_err = NULL;
 516     int i;
 517
 518     /*
 519      * Restore the sources to their initial state. This is called when
 520      * the VM resumes after a stop or a migration.
 521      */
 522     if (running) {
 523         for (i = 0; i < xsrc->nr_irqs; i++) {
 524             uint8_t pq;
 525             uint8_t old_pq;
 526
 527             if (!xive_eas_is_valid(&xive->eat[i])) {
 528                 continue;
 529             }
 530
 531             pq = xive_source_esb_get(xsrc, i);
 532             old_pq = xive_esb_read(xsrc, i, XIVE_ESB_SET_PQ_00 + (pq << 8));
 533
 534             /*
 535              * An interrupt was queued while the VM was stopped,
 536              * generate a trigger.
 537              */
 538             if (pq == XIVE_ESB_RESET && old_pq == XIVE_ESB_QUEUED) {
 539                 xive_esb_trigger(xsrc, i);
 540             }
 541         }
 542
 543         return;
 544     }
 545
 546     /*
 547      * Mask the sources, to stop the flow of event notifications, and
 548      * save the PQs locally in the XiveSource object. The XiveSource
 549      * state will be collected later on by its vmstate handler if a
 550      * migration is in progress.
 551      */
 552     for (i = 0; i < xsrc->nr_irqs; i++) {
 553         uint8_t pq;
 554
 555         if (!xive_eas_is_valid(&xive->eat[i])) {
 556             continue;
 557         }
 558
 559         pq = xive_esb_read(xsrc, i, XIVE_ESB_GET);
 560
 561         /*
 562          * PQ is set to PENDING to possibly catch a triggered
 563          * interrupt occuring while the VM is stopped (hotplug event
 564          * for instance) .
 565          */
 566         if (pq != XIVE_ESB_OFF) {
 567             pq = xive_esb_read(xsrc, i, XIVE_ESB_SET_PQ_10);
 568         }
 569         xive_source_esb_set(xsrc, i, pq);
 570     }
 571
 572     /*
 573      * Sync the XIVE controller in KVM, to flush in-flight event
 574      * notification that should be enqueued in the EQs and mark the
 575      * XIVE EQ pages dirty to collect all updates.
 576      */
 577     kvm_device_access(xive->fd, KVM_DEV_XIVE_GRP_CTRL,
 578                       KVM_DEV_XIVE_EQ_SYNC, NULL, true, &local_err);
 579     if (local_err) {
 580         error_report_err(local_err);
 581         return;
 582     }
 583 }
 584
 585 void kvmppc_xive_synchronize_state(SpaprXive *xive, Error **errp)
 586 {
 587     /* The KVM XIVE device is not in use */
 588     if (xive->fd == -1) {
 589         return;
 590     }
 591
 592     /*
 593      * When the VM is stopped, the sources are masked and the previous
 594      * state is saved in anticipation of a migration. We should not
 595      * synchronize the source state in that case else we will override
 596      * the saved state.
 597      */
 598     if (runstate_is_running()) {
 599         kvmppc_xive_source_get_state(&xive->source);
 600     }
 601
 602     /* EAT: there is no extra state to query from KVM */
 603
 604     /* ENDT */
 605     kvmppc_xive_get_queues(xive, errp);
 606 }
 607
 608 /*
 609  * The SpaprXive 'pre_save' method is called by the vmstate handler of
 610  * the SpaprXive model, after the XIVE controller is synced in the VM
 611  * change handler.
 612  */
 613 int kvmppc_xive_pre_save(SpaprXive *xive)
 614 {
 615     Error *local_err = NULL;
 616
 617     /* The KVM XIVE device is not in use */
 618     if (xive->fd == -1) {
 619         return 0;
 620     }
 621
 622     /* EAT: there is no extra state to query from KVM */
 623
 624     /* ENDT */
 625     kvmppc_xive_get_queues(xive, &local_err);
 626     if (local_err) {
 627         error_report_err(local_err);
 628         return -1;
 629     }
 630
 631     return 0;
 632 }
 633
 634 /*
 635  * The SpaprXive 'post_load' method is not called by a vmstate
 636  * handler. It is called at the sPAPR machine level at the end of the
 637  * migration sequence by the sPAPR IRQ backend 'post_load' method,
 638  * when all XIVE states have been transferred and loaded.
 639  */
 640 int kvmppc_xive_post_load(SpaprXive *xive, int version_id)
 641 {
 642     Error *local_err = NULL;
 643     CPUState *cs;
 644     int i;
 645
 646     /* The KVM XIVE device should be in use */
 647     assert(xive->fd != -1);
 648
 649     /* Restore the ENDT first. The targetting depends on it. */
 650     for (i = 0; i < xive->nr_ends; i++) {
 651         if (!xive_end_is_valid(&xive->endt[i])) {
 652             continue;
 653         }
 654
 655         kvmppc_xive_set_queue_config(xive, SPAPR_XIVE_BLOCK_ID, i,
 656                                      &xive->endt[i], &local_err);
 657         if (local_err) {
 658             error_report_err(local_err);
 659             return -1;
 660         }
 661     }
 662
 663     /* Restore the EAT */
 664     for (i = 0; i < xive->nr_irqs; i++) {
 665         if (!xive_eas_is_valid(&xive->eat[i])) {
 666             continue;
 667         }
 668
 669         /*
 670          * We can only restore the source config if the source has been
 671          * previously set in KVM. Since we don't do that for all interrupts
 672          * at reset time anymore, let's do it now.
 673          */
 674         kvmppc_xive_source_reset_one(&xive->source, i, &local_err);
 675         if (local_err) {
 676             error_report_err(local_err);
 677             return -1;
 678         }
 679
 680         kvmppc_xive_set_source_config(xive, i, &xive->eat[i], &local_err);
 681         if (local_err) {
 682             error_report_err(local_err);
 683             return -1;
 684         }
 685     }
 686
 687     /*
 688      * Restore the thread interrupt contexts of initial CPUs.
 689      *
 690      * The context of hotplugged CPUs is restored later, by the
 691      * 'post_load' handler of the XiveTCTX model because they are not
 692      * available at the time the SpaprXive 'post_load' method is
 693      * called. We can not restore the context of all CPUs in the
 694      * 'post_load' handler of XiveTCTX because the machine is not
 695      * necessarily connected to the KVM device at that time.
 696      */
 697     CPU_FOREACH(cs) {
 698         PowerPCCPU *cpu = POWERPC_CPU(cs);
 699
 700         kvmppc_xive_cpu_set_state(spapr_cpu_state(cpu)->tctx, &local_err);
 701         if (local_err) {
 702             error_report_err(local_err);
 703             return -1;
 704         }
 705     }
 706
 707     /* The source states will be restored when the machine starts running */
 708     return 0;
 709 }
 710
 711 static void *kvmppc_xive_mmap(SpaprXive *xive, int pgoff, size_t len,
 712                               Error **errp)
 713 {
 714     void *addr;
 715     uint32_t page_shift = 16; /* TODO: fix page_shift */
 716
 717     addr = mmap(NULL, len, PROT_WRITE | PROT_READ, MAP_SHARED, xive->fd,
 718                 pgoff << page_shift);
 719     if (addr == MAP_FAILED) {
 720         error_setg_errno(errp, errno, "XIVE: unable to set memory mapping");
 721         return NULL;
 722     }
 723
 724     return addr;
 725 }
 726
 727 /*
 728  * All the XIVE memory regions are now backed by mappings from the KVM
 729  * XIVE device.
 730  */
 731 int kvmppc_xive_connect(SpaprInterruptController *intc, uint32_t nr_servers,
 732                         Error **errp)
 733 {
 734     SpaprXive *xive = SPAPR_XIVE(intc);
 735     XiveSource *xsrc = &xive->source;
 736     Error *local_err = NULL;
 737     size_t esb_len = (1ull << xsrc->esb_shift) * xsrc->nr_irqs;
 738     size_t tima_len = 4ull << TM_SHIFT;
 739     CPUState *cs;
 740
 741     /*
 742      * The KVM XIVE device already in use. This is the case when
 743      * rebooting under the XIVE-only interrupt mode.
 744      */
 745     if (xive->fd != -1) {
 746         return 0;
 747     }
 748
 749     if (!kvmppc_has_cap_xive()) {
 750         error_setg(errp, "IRQ_XIVE capability must be present for KVM");
 751         return -1;
 752     }
 753
 754     /* First, create the KVM XIVE device */
 755     xive->fd = kvm_create_device(kvm_state, KVM_DEV_TYPE_XIVE, false);
 756     if (xive->fd < 0) {
 757         error_setg_errno(errp, -xive->fd, "XIVE: error creating KVM device");
 758         return -1;
 759     }
 760
 761     /*
 762      * 1. Source ESB pages - KVM mapping
 763      */
 764     xsrc->esb_mmap = kvmppc_xive_mmap(xive, KVM_XIVE_ESB_PAGE_OFFSET, esb_len,
 765                                       &local_err);
 766     if (local_err) {
 767         goto fail;
 768     }
 769
 770     memory_region_init_ram_device_ptr(&xsrc->esb_mmio_kvm, OBJECT(xsrc),
 771                                       "xive.esb", esb_len, xsrc->esb_mmap);
 772     memory_region_add_subregion_overlap(&xsrc->esb_mmio, 0,
 773                                         &xsrc->esb_mmio_kvm, 1);
 774
 775     /*
 776      * 2. END ESB pages (No KVM support yet)
 777      */
 778
 779     /*
 780      * 3. TIMA pages - KVM mapping
 781      */
 782     xive->tm_mmap = kvmppc_xive_mmap(xive, KVM_XIVE_TIMA_PAGE_OFFSET, tima_len,
 783                                      &local_err);
 784     if (local_err) {
 785         goto fail;
 786     }
 787     memory_region_init_ram_device_ptr(&xive->tm_mmio_kvm, OBJECT(xive),
 788                                       "xive.tima", tima_len, xive->tm_mmap);
 789     memory_region_add_subregion_overlap(&xive->tm_mmio, 0,
 790                                         &xive->tm_mmio_kvm, 1);
 791
 792     xive->change = qemu_add_vm_change_state_handler(
 793         kvmppc_xive_change_state_handler, xive);
 794
 795     /* Connect the presenters to the initial VCPUs of the machine */
 796     CPU_FOREACH(cs) {
 797         PowerPCCPU *cpu = POWERPC_CPU(cs);
 798
 799         kvmppc_xive_cpu_connect(spapr_cpu_state(cpu)->tctx, &local_err);
 800         if (local_err) {
 801             goto fail;
 802         }
 803     }
 804
 805     /* Update the KVM sources */
 806     kvmppc_xive_source_reset(xsrc, &local_err);
 807     if (local_err) {
 808         goto fail;
 809     }
 810
 811     kvm_kernel_irqchip = true;
 812     kvm_msi_via_irqfd_allowed = true;
 813     kvm_gsi_direct_mapping = true;
 814     return 0;
 815
 816 fail:
 817     error_propagate(errp, local_err);
 818     kvmppc_xive_disconnect(intc);
 819     return -1;
 820 }
 821
 822 void kvmppc_xive_disconnect(SpaprInterruptController *intc)
 823 {
 824     SpaprXive *xive = SPAPR_XIVE(intc);
 825     XiveSource *xsrc;
 826     size_t esb_len;
 827
 828     /* The KVM XIVE device is not in use */
 829     if (!xive || xive->fd == -1) {
 830         return;
 831     }
 832
 833     /* Clear the KVM mapping */
 834     xsrc = &xive->source;
 835     esb_len = (1ull << xsrc->esb_shift) * xsrc->nr_irqs;
 836
 837     if (xsrc->esb_mmap) {
 838         memory_region_del_subregion(&xsrc->esb_mmio, &xsrc->esb_mmio_kvm);
 839         object_unparent(OBJECT(&xsrc->esb_mmio_kvm));
 840         munmap(xsrc->esb_mmap, esb_len);
 841         xsrc->esb_mmap = NULL;
 842     }
 843
 844     if (xive->tm_mmap) {
 845         memory_region_del_subregion(&xive->tm_mmio, &xive->tm_mmio_kvm);
 846         object_unparent(OBJECT(&xive->tm_mmio_kvm));
 847         munmap(xive->tm_mmap, 4ull << TM_SHIFT);
 848         xive->tm_mmap = NULL;
 849     }
 850
 851     /*
 852      * When the KVM device fd is closed, the KVM device is destroyed
 853      * and removed from the list of devices of the VM. The VCPU
 854      * presenters are also detached from the device.
 855      */
 856     if (xive->fd != -1) {
 857         close(xive->fd);
 858         xive->fd = -1;
 859     }
 860
 861     kvm_kernel_irqchip = false;
 862     kvm_msi_via_irqfd_allowed = false;
 863     kvm_gsi_direct_mapping = false;
 864
 865     /* Clear the local list of presenter (hotplug) */
 866     kvm_cpu_disable_all();
 867
 868     /* VM Change state handler is not needed anymore */
 869     if (xive->change) {
 870         qemu_del_vm_change_state_handler(xive->change);
 871         xive->change = NULL;
 872     }
 873 }