arch/powerpc/kvm/book3s_xive.c

   1 /*
   2  * Copyright 2017 Benjamin Herrenschmidt, IBM Corporation.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License, version 2, as
   6  * published by the Free Software Foundation.
   7  */
   8
   9 #define pr_fmt(fmt) "xive-kvm: " fmt
  10
  11 #include <linux/kernel.h>
  12 #include <linux/kvm_host.h>
  13 #include <linux/err.h>
  14 #include <linux/gfp.h>
  15 #include <linux/spinlock.h>
  16 #include <linux/delay.h>
  17 #include <linux/percpu.h>
  18 #include <linux/cpumask.h>
  19 #include <asm/uaccess.h>
  20 #include <asm/kvm_book3s.h>
  21 #include <asm/kvm_ppc.h>
  22 #include <asm/hvcall.h>
  23 #include <asm/xics.h>
  24 #include <asm/xive.h>
  25 #include <asm/xive-regs.h>
  26 #include <asm/debug.h>
  27 #include <asm/debugfs.h>
  28 #include <asm/time.h>
  29 #include <asm/opal.h>
  30
  31 #include <linux/debugfs.h>
  32 #include <linux/seq_file.h>
  33
  34 #include "book3s_xive.h"
  35
  36
  37 /*
  38  * Virtual mode variants of the hcalls for use on radix/radix
  39  * with AIL. They require the VCPU's VP to be "pushed"
  40  *
  41  * We still instanciate them here because we use some of the
  42  * generated utility functions as well in this file.
  43  */
  44 #define XIVE_RUNTIME_CHECKS
  45 #define X_PFX xive_vm_
  46 #define X_STATIC static
  47 #define X_STAT_PFX stat_vm_
  48 #define __x_tima                xive_tima
  49 #define __x_eoi_page(xd)        ((void __iomem *)((xd)->eoi_mmio))
  50 #define __x_trig_page(xd)       ((void __iomem *)((xd)->trig_mmio))
  51 #define __x_readb       __raw_readb
  52 #define __x_writeb      __raw_writeb
  53 #define __x_readw       __raw_readw
  54 #define __x_readq       __raw_readq
  55 #define __x_writeq      __raw_writeq
  56
  57 #include "book3s_xive_template.c"
  58
  59 /*
  60  * We leave a gap of a couple of interrupts in the queue to
  61  * account for the IPI and additional safety guard.
  62  */
  63 #define XIVE_Q_GAP      2
  64
  65 /*
  66  * This is a simple trigger for a generic XIVE IRQ. This must
  67  * only be called for interrupts that support a trigger page
  68  */
  69 static bool xive_irq_trigger(struct xive_irq_data *xd)
  70 {
  71         /* This should be only for MSIs */
  72         if (WARN_ON(xd->flags & XIVE_IRQ_FLAG_LSI))
  73                 return false;
  74
  75         /* Those interrupts should always have a trigger page */
  76         if (WARN_ON(!xd->trig_mmio))
  77                 return false;
  78
  79         out_be64(xd->trig_mmio, 0);
  80
  81         return true;
  82 }
  83
  84 static irqreturn_t xive_esc_irq(int irq, void *data)
  85 {
  86         struct kvm_vcpu *vcpu = data;
  87
  88         /* We use the existing H_PROD mechanism to wake up the target */
  89         vcpu->arch.prodded = 1;
  90         smp_mb();
  91         if (vcpu->arch.ceded)
  92                 kvmppc_fast_vcpu_kick(vcpu);
  93
  94         return IRQ_HANDLED;
  95 }
  96
  97 static int xive_attach_escalation(struct kvm_vcpu *vcpu, u8 prio)
  98 {
  99         struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
 100         struct xive_q *q = &xc->queues[prio];
 101         char *name = NULL;
 102         int rc;
 103
 104         /* Already there ? */
 105         if (xc->esc_virq[prio])
 106                 return 0;
 107
 108         /* Hook up the escalation interrupt */
 109         xc->esc_virq[prio] = irq_create_mapping(NULL, q->esc_irq);
 110         if (!xc->esc_virq[prio]) {
 111                 pr_err("Failed to map escalation interrupt for queue %d of VCPU %d\n",
 112                        prio, xc->server_num);
 113                 return -EIO;
 114         }
 115
 116         /*
 117          * Future improvement: start with them disabled
 118          * and handle DD2 and later scheme of merged escalation
 119          * interrupts
 120          */
 121         name = kasprintf(GFP_KERNEL, "kvm-%d-%d-%d",
 122                          vcpu->kvm->arch.lpid, xc->server_num, prio);
 123         if (!name) {
 124                 pr_err("Failed to allocate escalation irq name for queue %d of VCPU %d\n",
 125                        prio, xc->server_num);
 126                 rc = -ENOMEM;
 127                 goto error;
 128         }
 129         rc = request_irq(xc->esc_virq[prio], xive_esc_irq,
 130                          IRQF_NO_THREAD, name, vcpu);
 131         if (rc) {
 132                 pr_err("Failed to request escalation interrupt for queue %d of VCPU %d\n",
 133                        prio, xc->server_num);
 134                 goto error;
 135         }
 136         xc->esc_virq_names[prio] = name;
 137         return 0;
 138 error:
 139         irq_dispose_mapping(xc->esc_virq[prio]);
 140         xc->esc_virq[prio] = 0;
 141         kfree(name);
 142         return rc;
 143 }
 144
 145 static int xive_provision_queue(struct kvm_vcpu *vcpu, u8 prio)
 146 {
 147         struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
 148         struct kvmppc_xive *xive = xc->xive;
 149         struct xive_q *q =  &xc->queues[prio];
 150         void *qpage;
 151         int rc;
 152
 153         if (WARN_ON(q->qpage))
 154                 return 0;
 155
 156         /* Allocate the queue and retrieve infos on current node for now */
 157         qpage = (__be32 *)__get_free_pages(GFP_KERNEL, xive->q_page_order);
 158         if (!qpage) {
 159                 pr_err("Failed to allocate queue %d for VCPU %d\n",
 160                        prio, xc->server_num);
 161                 return -ENOMEM;;
 162         }
 163         memset(qpage, 0, 1 << xive->q_order);
 164
 165         /*
 166          * Reconfigure the queue. This will set q->qpage only once the
 167          * queue is fully configured. This is a requirement for prio 0
 168          * as we will stop doing EOIs for every IPI as soon as we observe
 169          * qpage being non-NULL, and instead will only EOI when we receive
 170          * corresponding queue 0 entries
 171          */
 172         rc = xive_native_configure_queue(xc->vp_id, q, prio, qpage,
 173                                          xive->q_order, true);
 174         if (rc)
 175                 pr_err("Failed to configure queue %d for VCPU %d\n",
 176                        prio, xc->server_num);
 177         return rc;
 178 }
 179
 180 /* Called with kvm_lock held */
 181 static int xive_check_provisioning(struct kvm *kvm, u8 prio)
 182 {
 183         struct kvmppc_xive *xive = kvm->arch.xive;
 184         struct kvm_vcpu *vcpu;
 185         int i, rc;
 186
 187         lockdep_assert_held(&kvm->lock);
 188
 189         /* Already provisioned ? */
 190         if (xive->qmap & (1 << prio))
 191                 return 0;
 192
 193         pr_devel("Provisioning prio... %d\n", prio);
 194
 195         /* Provision each VCPU and enable escalations */
 196         kvm_for_each_vcpu(i, vcpu, kvm) {
 197                 if (!vcpu->arch.xive_vcpu)
 198                         continue;
 199                 rc = xive_provision_queue(vcpu, prio);
 200                 if (rc == 0)
 201                         xive_attach_escalation(vcpu, prio);
 202                 if (rc)
 203                         return rc;
 204         }
 205
 206         /* Order previous stores and mark it as provisioned */
 207         mb();
 208         xive->qmap |= (1 << prio);
 209         return 0;
 210 }
 211
 212 static void xive_inc_q_pending(struct kvm *kvm, u32 server, u8 prio)
 213 {
 214         struct kvm_vcpu *vcpu;
 215         struct kvmppc_xive_vcpu *xc;
 216         struct xive_q *q;
 217
 218         /* Locate target server */
 219         vcpu = kvmppc_xive_find_server(kvm, server);
 220         if (!vcpu) {
 221                 pr_warn("%s: Can't find server %d\n", __func__, server);
 222                 return;
 223         }
 224         xc = vcpu->arch.xive_vcpu;
 225         if (WARN_ON(!xc))
 226                 return;
 227
 228         q = &xc->queues[prio];
 229         atomic_inc(&q->pending_count);
 230 }
 231
 232 static int xive_try_pick_queue(struct kvm_vcpu *vcpu, u8 prio)
 233 {
 234         struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
 235         struct xive_q *q;
 236         u32 max;
 237
 238         if (WARN_ON(!xc))
 239                 return -ENXIO;
 240         if (!xc->valid)
 241                 return -ENXIO;
 242
 243         q = &xc->queues[prio];
 244         if (WARN_ON(!q->qpage))
 245                 return -ENXIO;
 246
 247         /* Calculate max number of interrupts in that queue. */
 248         max = (q->msk + 1) - XIVE_Q_GAP;
 249         return atomic_add_unless(&q->count, 1, max) ? 0 : -EBUSY;
 250 }
 251
 252 static int xive_select_target(struct kvm *kvm, u32 *server, u8 prio)
 253 {
 254         struct kvm_vcpu *vcpu;
 255         int i, rc;
 256
 257         /* Locate target server */
 258         vcpu = kvmppc_xive_find_server(kvm, *server);
 259         if (!vcpu) {
 260                 pr_devel("Can't find server %d\n", *server);
 261                 return -EINVAL;
 262         }
 263
 264         pr_devel("Finding irq target on 0x%x/%d...\n", *server, prio);
 265
 266         /* Try pick it */
 267         rc = xive_try_pick_queue(vcpu, prio);
 268         if (rc == 0)
 269                 return rc;
 270
 271         pr_devel(" .. failed, looking up candidate...\n");
 272
 273         /* Failed, pick another VCPU */
 274         kvm_for_each_vcpu(i, vcpu, kvm) {
 275                 if (!vcpu->arch.xive_vcpu)
 276                         continue;
 277                 rc = xive_try_pick_queue(vcpu, prio);
 278                 if (rc == 0) {
 279                         *server = vcpu->arch.xive_vcpu->server_num;
 280                         pr_devel("  found on 0x%x/%d\n", *server, prio);
 281                         return rc;
 282                 }
 283         }
 284         pr_devel("  no available target !\n");
 285
 286         /* No available target ! */
 287         return -EBUSY;
 288 }
 289
 290 static u8 xive_lock_and_mask(struct kvmppc_xive *xive,
 291                              struct kvmppc_xive_src_block *sb,
 292                              struct kvmppc_xive_irq_state *state)
 293 {
 294         struct xive_irq_data *xd;
 295         u32 hw_num;
 296         u8 old_prio;
 297         u64 val;
 298
 299         /*
 300          * Take the lock, set masked, try again if racing
 301          * with H_EOI
 302          */
 303         for (;;) {
 304                 arch_spin_lock(&sb->lock);
 305                 old_prio = state->guest_priority;
 306                 state->guest_priority = MASKED;
 307                 mb();
 308                 if (!state->in_eoi)
 309                         break;
 310                 state->guest_priority = old_prio;
 311                 arch_spin_unlock(&sb->lock);
 312         }
 313
 314         /* No change ? Bail */
 315         if (old_prio == MASKED)
 316                 return old_prio;
 317
 318         /* Get the right irq */
 319         kvmppc_xive_select_irq(state, &hw_num, &xd);
 320
 321         /*
 322          * If the interrupt is marked as needing masking via
 323          * firmware, we do it here. Firmware masking however
 324          * is "lossy", it won't return the old p and q bits
 325          * and won't set the interrupt to a state where it will
 326          * record queued ones. If this is an issue we should do
 327          * lazy masking instead.
 328          *
 329          * For now, we work around this in unmask by forcing
 330          * an interrupt whenever we unmask a non-LSI via FW
 331          * (if ever).
 332          */
 333         if (xd->flags & OPAL_XIVE_IRQ_MASK_VIA_FW) {
 334                 xive_native_configure_irq(hw_num,
 335                                           xive->vp_base + state->act_server,
 336                                           MASKED, state->number);
 337                 /* set old_p so we can track if an H_EOI was done */
 338                 state->old_p = true;
 339                 state->old_q = false;
 340         } else {
 341                 /* Set PQ to 10, return old P and old Q and remember them */
 342                 val = xive_vm_esb_load(xd, XIVE_ESB_SET_PQ_10);
 343                 state->old_p = !!(val & 2);
 344                 state->old_q = !!(val & 1);
 345
 346                 /*
 347                  * Synchronize hardware to sensure the queues are updated
 348                  * when masking
 349                  */
 350                 xive_native_sync_source(hw_num);
 351         }
 352
 353         return old_prio;
 354 }
 355
 356 static void xive_lock_for_unmask(struct kvmppc_xive_src_block *sb,
 357                                  struct kvmppc_xive_irq_state *state)
 358 {
 359         /*
 360          * Take the lock try again if racing with H_EOI
 361          */
 362         for (;;) {
 363                 arch_spin_lock(&sb->lock);
 364                 if (!state->in_eoi)
 365                         break;
 366                 arch_spin_unlock(&sb->lock);
 367         }
 368 }
 369
 370 static void xive_finish_unmask(struct kvmppc_xive *xive,
 371                                struct kvmppc_xive_src_block *sb,
 372                                struct kvmppc_xive_irq_state *state,
 373                                u8 prio)
 374 {
 375         struct xive_irq_data *xd;
 376         u32 hw_num;
 377
 378         /* If we aren't changing a thing, move on */
 379         if (state->guest_priority != MASKED)
 380                 goto bail;
 381
 382         /* Get the right irq */
 383         kvmppc_xive_select_irq(state, &hw_num, &xd);
 384
 385         /*
 386          * See command in xive_lock_and_mask() concerning masking
 387          * via firmware.
 388          */
 389         if (xd->flags & OPAL_XIVE_IRQ_MASK_VIA_FW) {
 390                 xive_native_configure_irq(hw_num,
 391                                           xive->vp_base + state->act_server,
 392                                           state->act_priority, state->number);
 393                 /* If an EOI is needed, do it here */
 394                 if (!state->old_p)
 395                         xive_vm_source_eoi(hw_num, xd);
 396                 /* If this is not an LSI, force a trigger */
 397                 if (!(xd->flags & OPAL_XIVE_IRQ_LSI))
 398                         xive_irq_trigger(xd);
 399                 goto bail;
 400         }
 401
 402         /* Old Q set, set PQ to 11 */
 403         if (state->old_q)
 404                 xive_vm_esb_load(xd, XIVE_ESB_SET_PQ_11);
 405
 406         /*
 407          * If not old P, then perform an "effective" EOI,
 408          * on the source. This will handle the cases where
 409          * FW EOI is needed.
 410          */
 411         if (!state->old_p)
 412                 xive_vm_source_eoi(hw_num, xd);
 413
 414         /* Synchronize ordering and mark unmasked */
 415         mb();
 416 bail:
 417         state->guest_priority = prio;
 418 }
 419
 420 /*
 421  * Target an interrupt to a given server/prio, this will fallback
 422  * to another server if necessary and perform the HW targetting
 423  * updates as needed
 424  *
 425  * NOTE: Must be called with the state lock held
 426  */
 427 static int xive_target_interrupt(struct kvm *kvm,
 428                                  struct kvmppc_xive_irq_state *state,
 429                                  u32 server, u8 prio)
 430 {
 431         struct kvmppc_xive *xive = kvm->arch.xive;
 432         u32 hw_num;
 433         int rc;
 434
 435         /*
 436          * This will return a tentative server and actual
 437          * priority. The count for that new target will have
 438          * already been incremented.
 439          */
 440         rc = xive_select_target(kvm, &server, prio);
 441
 442         /*
 443          * We failed to find a target ? Not much we can do
 444          * at least until we support the GIQ.
 445          */
 446         if (rc)
 447                 return rc;
 448
 449         /*
 450          * Increment the old queue pending count if there
 451          * was one so that the old queue count gets adjusted later
 452          * when observed to be empty.
 453          */
 454         if (state->act_priority != MASKED)
 455                 xive_inc_q_pending(kvm,
 456                                    state->act_server,
 457                                    state->act_priority);
 458         /*
 459          * Update state and HW
 460          */
 461         state->act_priority = prio;
 462         state->act_server = server;
 463
 464         /* Get the right irq */
 465         kvmppc_xive_select_irq(state, &hw_num, NULL);
 466
 467         return xive_native_configure_irq(hw_num,
 468                                          xive->vp_base + server,
 469                                          prio, state->number);
 470 }
 471
 472 /*
 473  * Targetting rules: In order to avoid losing track of
 474  * pending interrupts accross mask and unmask, which would
 475  * allow queue overflows, we implement the following rules:
 476  *
 477  *  - Unless it was never enabled (or we run out of capacity)
 478  *    an interrupt is always targetted at a valid server/queue
 479  *    pair even when "masked" by the guest. This pair tends to
 480  *    be the last one used but it can be changed under some
 481  *    circumstances. That allows us to separate targetting
 482  *    from masking, we only handle accounting during (re)targetting,
 483  *    this also allows us to let an interrupt drain into its target
 484  *    queue after masking, avoiding complex schemes to remove
 485  *    interrupts out of remote processor queues.
 486  *
 487  *  - When masking, we set PQ to 10 and save the previous value
 488  *    of P and Q.
 489  *
 490  *  - When unmasking, if saved Q was set, we set PQ to 11
 491  *    otherwise we leave PQ to the HW state which will be either
 492  *    10 if nothing happened or 11 if the interrupt fired while
 493  *    masked. Effectively we are OR'ing the previous Q into the
 494  *    HW Q.
 495  *
 496  *    Then if saved P is clear, we do an effective EOI (Q->P->Trigger)
 497  *    which will unmask the interrupt and shoot a new one if Q was
 498  *    set.
 499  *
 500  *    Otherwise (saved P is set) we leave PQ unchanged (so 10 or 11,
 501  *    effectively meaning an H_EOI from the guest is still expected
 502  *    for that interrupt).
 503  *
 504  *  - If H_EOI occurs while masked, we clear the saved P.
 505  *
 506  *  - When changing target, we account on the new target and
 507  *    increment a separate "pending" counter on the old one.
 508  *    This pending counter will be used to decrement the old
 509  *    target's count when its queue has been observed empty.
 510  */
 511
 512 int kvmppc_xive_set_xive(struct kvm *kvm, u32 irq, u32 server,
 513                          u32 priority)
 514 {
 515         struct kvmppc_xive *xive = kvm->arch.xive;
 516         struct kvmppc_xive_src_block *sb;
 517         struct kvmppc_xive_irq_state *state;
 518         u8 new_act_prio;
 519         int rc = 0;
 520         u16 idx;
 521
 522         if (!xive)
 523                 return -ENODEV;
 524
 525         pr_devel("set_xive ! irq 0x%x server 0x%x prio %d\n",
 526                  irq, server, priority);
 527
 528         /* First, check provisioning of queues */
 529         if (priority != MASKED)
 530                 rc = xive_check_provisioning(xive->kvm,
 531                               xive_prio_from_guest(priority));
 532         if (rc) {
 533                 pr_devel("  provisioning failure %d !\n", rc);
 534                 return rc;
 535         }
 536
 537         sb = kvmppc_xive_find_source(xive, irq, &idx);
 538         if (!sb)
 539                 return -EINVAL;
 540         state = &sb->irq_state[idx];
 541
 542         /*
 543          * We first handle masking/unmasking since the locking
 544          * might need to be retried due to EOIs, we'll handle
 545          * targetting changes later. These functions will return
 546          * with the SB lock held.
 547          *
 548          * xive_lock_and_mask() will also set state->guest_priority
 549          * but won't otherwise change other fields of the state.
 550          *
 551          * xive_lock_for_unmask will not actually unmask, this will
 552          * be done later by xive_finish_unmask() once the targetting
 553          * has been done, so we don't try to unmask an interrupt
 554          * that hasn't yet been targetted.
 555          */
 556         if (priority == MASKED)
 557                 xive_lock_and_mask(xive, sb, state);
 558         else
 559                 xive_lock_for_unmask(sb, state);
 560
 561
 562         /*
 563          * Then we handle targetting.
 564          *
 565          * First calculate a new "actual priority"
 566          */
 567         new_act_prio = state->act_priority;
 568         if (priority != MASKED)
 569                 new_act_prio = xive_prio_from_guest(priority);
 570
 571         pr_devel(" new_act_prio=%x act_server=%x act_prio=%x\n",
 572                  new_act_prio, state->act_server, state->act_priority);
 573
 574         /*
 575          * Then check if we actually need to change anything,
 576          *
 577          * The condition for re-targetting the interrupt is that
 578          * we have a valid new priority (new_act_prio is not 0xff)
 579          * and either the server or the priority changed.
 580          *
 581          * Note: If act_priority was ff and the new priority is
 582          *       also ff, we don't do anything and leave the interrupt
 583          *       untargetted. An attempt of doing an int_on on an
 584          *       untargetted interrupt will fail. If that is a problem
 585          *       we could initialize interrupts with valid default
 586          */
 587
 588         if (new_act_prio != MASKED &&
 589             (state->act_server != server ||
 590              state->act_priority != new_act_prio))
 591                 rc = xive_target_interrupt(kvm, state, server, new_act_prio);
 592
 593         /*
 594          * Perform the final unmasking of the interrupt source
 595          * if necessary
 596          */
 597         if (priority != MASKED)
 598                 xive_finish_unmask(xive, sb, state, priority);
 599
 600         /*
 601          * Finally Update saved_priority to match. Only int_on/off
 602          * set this field to a different value.
 603          */
 604         state->saved_priority = priority;
 605
 606         arch_spin_unlock(&sb->lock);
 607         return rc;
 608 }
 609
 610 int kvmppc_xive_get_xive(struct kvm *kvm, u32 irq, u32 *server,
 611                          u32 *priority)
 612 {
 613         struct kvmppc_xive *xive = kvm->arch.xive;
 614         struct kvmppc_xive_src_block *sb;
 615         struct kvmppc_xive_irq_state *state;
 616         u16 idx;
 617
 618         if (!xive)
 619                 return -ENODEV;
 620
 621         sb = kvmppc_xive_find_source(xive, irq, &idx);
 622         if (!sb)
 623                 return -EINVAL;
 624         state = &sb->irq_state[idx];
 625         arch_spin_lock(&sb->lock);
 626         *server = state->guest_server;
 627         *priority = state->guest_priority;
 628         arch_spin_unlock(&sb->lock);
 629
 630         return 0;
 631 }
 632
 633 int kvmppc_xive_int_on(struct kvm *kvm, u32 irq)
 634 {
 635         struct kvmppc_xive *xive = kvm->arch.xive;
 636         struct kvmppc_xive_src_block *sb;
 637         struct kvmppc_xive_irq_state *state;
 638         u16 idx;
 639
 640         if (!xive)
 641                 return -ENODEV;
 642
 643         sb = kvmppc_xive_find_source(xive, irq, &idx);
 644         if (!sb)
 645                 return -EINVAL;
 646         state = &sb->irq_state[idx];
 647
 648         pr_devel("int_on(irq=0x%x)\n", irq);
 649
 650         /*
 651          * Check if interrupt was not targetted
 652          */
 653         if (state->act_priority == MASKED) {
 654                 pr_devel("int_on on untargetted interrupt\n");
 655                 return -EINVAL;
 656         }
 657
 658         /* If saved_priority is 0xff, do nothing */
 659         if (state->saved_priority == MASKED)
 660                 return 0;
 661
 662         /*
 663          * Lock and unmask it.
 664          */
 665         xive_lock_for_unmask(sb, state);
 666         xive_finish_unmask(xive, sb, state, state->saved_priority);
 667         arch_spin_unlock(&sb->lock);
 668
 669         return 0;
 670 }
 671
 672 int kvmppc_xive_int_off(struct kvm *kvm, u32 irq)
 673 {
 674         struct kvmppc_xive *xive = kvm->arch.xive;
 675         struct kvmppc_xive_src_block *sb;
 676         struct kvmppc_xive_irq_state *state;
 677         u16 idx;
 678
 679         if (!xive)
 680                 return -ENODEV;
 681
 682         sb = kvmppc_xive_find_source(xive, irq, &idx);
 683         if (!sb)
 684                 return -EINVAL;
 685         state = &sb->irq_state[idx];
 686
 687         pr_devel("int_off(irq=0x%x)\n", irq);
 688
 689         /*
 690          * Lock and mask
 691          */
 692         state->saved_priority = xive_lock_and_mask(xive, sb, state);
 693         arch_spin_unlock(&sb->lock);
 694
 695         return 0;
 696 }
 697
 698 static bool xive_restore_pending_irq(struct kvmppc_xive *xive, u32 irq)
 699 {
 700         struct kvmppc_xive_src_block *sb;
 701         struct kvmppc_xive_irq_state *state;
 702         u16 idx;
 703
 704         sb = kvmppc_xive_find_source(xive, irq, &idx);
 705         if (!sb)
 706                 return false;
 707         state = &sb->irq_state[idx];
 708         if (!state->valid)
 709                 return false;
 710
 711         /*
 712          * Trigger the IPI. This assumes we never restore a pass-through
 713          * interrupt which should be safe enough
 714          */
 715         xive_irq_trigger(&state->ipi_data);
 716
 717         return true;
 718 }
 719
 720 u64 kvmppc_xive_get_icp(struct kvm_vcpu *vcpu)
 721 {
 722         struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
 723
 724         if (!xc)
 725                 return 0;
 726
 727         /* Return the per-cpu state for state saving/migration */
 728         return (u64)xc->cppr << KVM_REG_PPC_ICP_CPPR_SHIFT |
 729                (u64)xc->mfrr << KVM_REG_PPC_ICP_MFRR_SHIFT;
 730 }
 731
 732 int kvmppc_xive_set_icp(struct kvm_vcpu *vcpu, u64 icpval)
 733 {
 734         struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
 735         struct kvmppc_xive *xive = vcpu->kvm->arch.xive;
 736         u8 cppr, mfrr;
 737         u32 xisr;
 738
 739         if (!xc || !xive)
 740                 return -ENOENT;
 741
 742         /* Grab individual state fields. We don't use pending_pri */
 743         cppr = icpval >> KVM_REG_PPC_ICP_CPPR_SHIFT;
 744         xisr = (icpval >> KVM_REG_PPC_ICP_XISR_SHIFT) &
 745                 KVM_REG_PPC_ICP_XISR_MASK;
 746         mfrr = icpval >> KVM_REG_PPC_ICP_MFRR_SHIFT;
 747
 748         pr_devel("set_icp vcpu %d cppr=0x%x mfrr=0x%x xisr=0x%x\n",
 749                  xc->server_num, cppr, mfrr, xisr);
 750
 751         /*
 752          * We can't update the state of a "pushed" VCPU, but that
 753          * shouldn't happen.
 754          */
 755         if (WARN_ON(vcpu->arch.xive_pushed))
 756                 return -EIO;
 757
 758         /* Update VCPU HW saved state */
 759         vcpu->arch.xive_saved_state.cppr = cppr;
 760         xc->hw_cppr = xc->cppr = cppr;
 761
 762         /*
 763          * Update MFRR state. If it's not 0xff, we mark the VCPU as
 764          * having a pending MFRR change, which will re-evaluate the
 765          * target. The VCPU will thus potentially get a spurious
 766          * interrupt but that's not a big deal.
 767          */
 768         xc->mfrr = mfrr;
 769         if (mfrr < cppr)
 770                 xive_irq_trigger(&xc->vp_ipi_data);
 771
 772         /*
 773          * Now saved XIRR is "interesting". It means there's something in
 774          * the legacy "1 element" queue... for an IPI we simply ignore it,
 775          * as the MFRR restore will handle that. For anything else we need
 776          * to force a resend of the source.
 777          * However the source may not have been setup yet. If that's the
 778          * case, we keep that info and increment a counter in the xive to
 779          * tell subsequent xive_set_source() to go look.
 780          */
 781         if (xisr > XICS_IPI && !xive_restore_pending_irq(xive, xisr)) {
 782                 xc->delayed_irq = xisr;
 783                 xive->delayed_irqs++;
 784                 pr_devel("  xisr restore delayed\n");
 785         }
 786
 787         return 0;
 788 }
 789
 790 int kvmppc_xive_set_mapped(struct kvm *kvm, unsigned long guest_irq,
 791                            struct irq_desc *host_desc)
 792 {
 793         struct kvmppc_xive *xive = kvm->arch.xive;
 794         struct kvmppc_xive_src_block *sb;
 795         struct kvmppc_xive_irq_state *state;
 796         struct irq_data *host_data = irq_desc_get_irq_data(host_desc);
 797         unsigned int host_irq = irq_desc_get_irq(host_desc);
 798         unsigned int hw_irq = (unsigned int)irqd_to_hwirq(host_data);
 799         u16 idx;
 800         u8 prio;
 801         int rc;
 802
 803         if (!xive)
 804                 return -ENODEV;
 805
 806         pr_devel("set_mapped girq 0x%lx host HW irq 0x%x...\n",guest_irq, hw_irq);
 807
 808         sb = kvmppc_xive_find_source(xive, guest_irq, &idx);
 809         if (!sb)
 810                 return -EINVAL;
 811         state = &sb->irq_state[idx];
 812
 813         /*
 814          * Mark the passed-through interrupt as going to a VCPU,
 815          * this will prevent further EOIs and similar operations
 816          * from the XIVE code. It will also mask the interrupt
 817          * to either PQ=10 or 11 state, the latter if the interrupt
 818          * is pending. This will allow us to unmask or retrigger it
 819          * after routing it to the guest with a simple EOI.
 820          *
 821          * The "state" argument is a "token", all it needs is to be
 822          * non-NULL to switch to passed-through or NULL for the
 823          * other way around. We may not yet have an actual VCPU
 824          * target here and we don't really care.
 825          */
 826         rc = irq_set_vcpu_affinity(host_irq, state);
 827         if (rc) {
 828                 pr_err("Failed to set VCPU affinity for irq %d\n", host_irq);
 829                 return rc;
 830         }
 831
 832         /*
 833          * Mask and read state of IPI. We need to know if its P bit
 834          * is set as that means it's potentially already using a
 835          * queue entry in the target
 836          */
 837         prio = xive_lock_and_mask(xive, sb, state);
 838         pr_devel(" old IPI prio %02x P:%d Q:%d\n", prio,
 839                  state->old_p, state->old_q);
 840
 841         /* Turn the IPI hard off */
 842         xive_vm_esb_load(&state->ipi_data, XIVE_ESB_SET_PQ_01);
 843
 844         /* Grab info about irq */
 845         state->pt_number = hw_irq;
 846         state->pt_data = irq_data_get_irq_handler_data(host_data);
 847
 848         /*
 849          * Configure the IRQ to match the existing configuration of
 850          * the IPI if it was already targetted. Otherwise this will
 851          * mask the interrupt in a lossy way (act_priority is 0xff)
 852          * which is fine for a never started interrupt.
 853          */
 854         xive_native_configure_irq(hw_irq,
 855                                   xive->vp_base + state->act_server,
 856                                   state->act_priority, state->number);
 857
 858         /*
 859          * We do an EOI to enable the interrupt (and retrigger if needed)
 860          * if the guest has the interrupt unmasked and the P bit was *not*
 861          * set in the IPI. If it was set, we know a slot may still be in
 862          * use in the target queue thus we have to wait for a guest
 863          * originated EOI
 864          */
 865         if (prio != MASKED && !state->old_p)
 866                 xive_vm_source_eoi(hw_irq, state->pt_data);
 867
 868         /* Clear old_p/old_q as they are no longer relevant */
 869         state->old_p = state->old_q = false;
 870
 871         /* Restore guest prio (unlocks EOI) */
 872         mb();
 873         state->guest_priority = prio;
 874         arch_spin_unlock(&sb->lock);
 875
 876         return 0;
 877 }
 878 EXPORT_SYMBOL_GPL(kvmppc_xive_set_mapped);
 879
 880 int kvmppc_xive_clr_mapped(struct kvm *kvm, unsigned long guest_irq,
 881                            struct irq_desc *host_desc)
 882 {
 883         struct kvmppc_xive *xive = kvm->arch.xive;
 884         struct kvmppc_xive_src_block *sb;
 885         struct kvmppc_xive_irq_state *state;
 886         unsigned int host_irq = irq_desc_get_irq(host_desc);
 887         u16 idx;
 888         u8 prio;
 889         int rc;
 890
 891         if (!xive)
 892                 return -ENODEV;
 893
 894         pr_devel("clr_mapped girq 0x%lx...\n", guest_irq);
 895
 896         sb = kvmppc_xive_find_source(xive, guest_irq, &idx);
 897         if (!sb)
 898                 return -EINVAL;
 899         state = &sb->irq_state[idx];
 900
 901         /*
 902          * Mask and read state of IRQ. We need to know if its P bit
 903          * is set as that means it's potentially already using a
 904          * queue entry in the target
 905          */
 906         prio = xive_lock_and_mask(xive, sb, state);
 907         pr_devel(" old IRQ prio %02x P:%d Q:%d\n", prio,
 908                  state->old_p, state->old_q);
 909
 910         /*
 911          * If old_p is set, the interrupt is pending, we switch it to
 912          * PQ=11. This will force a resend in the host so the interrupt
 913          * isn't lost to whatver host driver may pick it up
 914          */
 915         if (state->old_p)
 916                 xive_vm_esb_load(state->pt_data, XIVE_ESB_SET_PQ_11);
 917
 918         /* Release the passed-through interrupt to the host */
 919         rc = irq_set_vcpu_affinity(host_irq, NULL);
 920         if (rc) {
 921                 pr_err("Failed to clr VCPU affinity for irq %d\n", host_irq);
 922                 return rc;
 923         }
 924
 925         /* Forget about the IRQ */
 926         state->pt_number = 0;
 927         state->pt_data = NULL;
 928
 929         /* Reconfigure the IPI */
 930         xive_native_configure_irq(state->ipi_number,
 931                                   xive->vp_base + state->act_server,
 932                                   state->act_priority, state->number);
 933
 934         /*
 935          * If old_p is set (we have a queue entry potentially
 936          * occupied) or the interrupt is masked, we set the IPI
 937          * to PQ=10 state. Otherwise we just re-enable it (PQ=00).
 938          */
 939         if (prio == MASKED || state->old_p)
 940                 xive_vm_esb_load(&state->ipi_data, XIVE_ESB_SET_PQ_10);
 941         else
 942                 xive_vm_esb_load(&state->ipi_data, XIVE_ESB_SET_PQ_00);
 943
 944         /* Restore guest prio (unlocks EOI) */
 945         mb();
 946         state->guest_priority = prio;
 947         arch_spin_unlock(&sb->lock);
 948
 949         return 0;
 950 }
 951 EXPORT_SYMBOL_GPL(kvmppc_xive_clr_mapped);
 952
 953 static void kvmppc_xive_disable_vcpu_interrupts(struct kvm_vcpu *vcpu)
 954 {
 955         struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
 956         struct kvm *kvm = vcpu->kvm;
 957         struct kvmppc_xive *xive = kvm->arch.xive;
 958         int i, j;
 959
 960         for (i = 0; i <= xive->max_sbid; i++) {
 961                 struct kvmppc_xive_src_block *sb = xive->src_blocks[i];
 962
 963                 if (!sb)
 964                         continue;
 965                 for (j = 0; j < KVMPPC_XICS_IRQ_PER_ICS; j++) {
 966                         struct kvmppc_xive_irq_state *state = &sb->irq_state[j];
 967
 968                         if (!state->valid)
 969                                 continue;
 970                         if (state->act_priority == MASKED)
 971                                 continue;
 972                         if (state->act_server != xc->server_num)
 973                                 continue;
 974
 975                         /* Clean it up */
 976                         arch_spin_lock(&sb->lock);
 977                         state->act_priority = MASKED;
 978                         xive_vm_esb_load(&state->ipi_data, XIVE_ESB_SET_PQ_01);
 979                         xive_native_configure_irq(state->ipi_number, 0, MASKED, 0);
 980                         if (state->pt_number) {
 981                                 xive_vm_esb_load(state->pt_data, XIVE_ESB_SET_PQ_01);
 982                                 xive_native_configure_irq(state->pt_number, 0, MASKED, 0);
 983                         }
 984                         arch_spin_unlock(&sb->lock);
 985                 }
 986         }
 987 }
 988
 989 void kvmppc_xive_cleanup_vcpu(struct kvm_vcpu *vcpu)
 990 {
 991         struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
 992         struct kvmppc_xive *xive = xc->xive;
 993         int i;
 994
 995         pr_devel("cleanup_vcpu(cpu=%d)\n", xc->server_num);
 996
 997         /* Ensure no interrupt is still routed to that VP */
 998         xc->valid = false;
 999         kvmppc_xive_disable_vcpu_interrupts(vcpu);
1000
1001         /* Mask the VP IPI */
1002         xive_vm_esb_load(&xc->vp_ipi_data, XIVE_ESB_SET_PQ_01);
1003
1004         /* Disable the VP */
1005         xive_native_disable_vp(xc->vp_id);
1006
1007         /* Free the queues & associated interrupts */
1008         for (i = 0; i < KVMPPC_XIVE_Q_COUNT; i++) {
1009                 struct xive_q *q = &xc->queues[i];
1010
1011                 /* Free the escalation irq */
1012                 if (xc->esc_virq[i]) {
1013                         free_irq(xc->esc_virq[i], vcpu);
1014                         irq_dispose_mapping(xc->esc_virq[i]);
1015                         kfree(xc->esc_virq_names[i]);
1016                 }
1017                 /* Free the queue */
1018                 xive_native_disable_queue(xc->vp_id, q, i);
1019                 if (q->qpage) {
1020                         free_pages((unsigned long)q->qpage,
1021                                    xive->q_page_order);
1022                         q->qpage = NULL;
1023                 }
1024         }
1025
1026         /* Free the IPI */
1027         if (xc->vp_ipi) {
1028                 xive_cleanup_irq_data(&xc->vp_ipi_data);
1029                 xive_native_free_irq(xc->vp_ipi);
1030         }
1031         /* Free the VP */
1032         kfree(xc);
1033 }
1034
1035 int kvmppc_xive_connect_vcpu(struct kvm_device *dev,
1036                              struct kvm_vcpu *vcpu, u32 cpu)
1037 {
1038         struct kvmppc_xive *xive = dev->private;
1039         struct kvmppc_xive_vcpu *xc;
1040         int i, r = -EBUSY;
1041
1042         pr_devel("connect_vcpu(cpu=%d)\n", cpu);
1043
1044         if (dev->ops != &kvm_xive_ops) {
1045                 pr_devel("Wrong ops !\n");
1046                 return -EPERM;
1047         }
1048         if (xive->kvm != vcpu->kvm)
1049                 return -EPERM;
1050         if (vcpu->arch.irq_type)
1051                 return -EBUSY;
1052         if (kvmppc_xive_find_server(vcpu->kvm, cpu)) {
1053                 pr_devel("Duplicate !\n");
1054                 return -EEXIST;
1055         }
1056         if (cpu >= KVM_MAX_VCPUS) {
1057                 pr_devel("Out of bounds !\n");
1058                 return -EINVAL;
1059         }
1060         xc = kzalloc(sizeof(*xc), GFP_KERNEL);
1061         if (!xc)
1062                 return -ENOMEM;
1063
1064         /* We need to synchronize with queue provisioning */
1065         mutex_lock(&vcpu->kvm->lock);
1066         vcpu->arch.xive_vcpu = xc;
1067         xc->xive = xive;
1068         xc->vcpu = vcpu;
1069         xc->server_num = cpu;
1070         xc->vp_id = xive->vp_base + cpu;
1071         xc->mfrr = 0xff;
1072         xc->valid = true;
1073
1074         r = xive_native_get_vp_info(xc->vp_id, &xc->vp_cam, &xc->vp_chip_id);
1075         if (r)
1076                 goto bail;
1077
1078         /* Configure VCPU fields for use by assembly push/pull */
1079         vcpu->arch.xive_saved_state.w01 = cpu_to_be64(0xff000000);
1080         vcpu->arch.xive_cam_word = cpu_to_be32(xc->vp_cam | TM_QW1W2_VO);
1081
1082         /* Allocate IPI */
1083         xc->vp_ipi = xive_native_alloc_irq();
1084         if (!xc->vp_ipi) {
1085                 r = -EIO;
1086                 goto bail;
1087         }
1088         pr_devel(" IPI=0x%x\n", xc->vp_ipi);
1089
1090         r = xive_native_populate_irq_data(xc->vp_ipi, &xc->vp_ipi_data);
1091         if (r)
1092                 goto bail;
1093
1094         /*
1095          * Initialize queues. Initially we set them all for no queueing
1096          * and we enable escalation for queue 0 only which we'll use for
1097          * our mfrr change notifications. If the VCPU is hot-plugged, we
1098          * do handle provisioning however.
1099          */
1100         for (i = 0; i < KVMPPC_XIVE_Q_COUNT; i++) {
1101                 struct xive_q *q = &xc->queues[i];
1102
1103                 /* Is queue already enabled ? Provision it */
1104                 if (xive->qmap & (1 << i)) {
1105                         r = xive_provision_queue(vcpu, i);
1106                         if (r == 0)
1107                                 xive_attach_escalation(vcpu, i);
1108                         if (r)
1109                                 goto bail;
1110                 } else {
1111                         r = xive_native_configure_queue(xc->vp_id,
1112                                                         q, i, NULL, 0, true);
1113                         if (r) {
1114                                 pr_err("Failed to configure queue %d for VCPU %d\n",
1115                                        i, cpu);
1116                                 goto bail;
1117                         }
1118                 }
1119         }
1120
1121         /* If not done above, attach priority 0 escalation */
1122         r = xive_attach_escalation(vcpu, 0);
1123         if (r)
1124                 goto bail;
1125
1126         /* Enable the VP */
1127         r = xive_native_enable_vp(xc->vp_id);
1128         if (r)
1129                 goto bail;
1130
1131         /* Route the IPI */
1132         r = xive_native_configure_irq(xc->vp_ipi, xc->vp_id, 0, XICS_IPI);
1133         if (!r)
1134                 xive_vm_esb_load(&xc->vp_ipi_data, XIVE_ESB_SET_PQ_00);
1135
1136 bail:
1137         mutex_unlock(&vcpu->kvm->lock);
1138         if (r) {
1139                 kvmppc_xive_cleanup_vcpu(vcpu);
1140                 return r;
1141         }
1142
1143         vcpu->arch.irq_type = KVMPPC_IRQ_XICS;
1144         return 0;
1145 }
1146
1147 /*
1148  * Scanning of queues before/after migration save
1149  */
1150 static void xive_pre_save_set_queued(struct kvmppc_xive *xive, u32 irq)
1151 {
1152         struct kvmppc_xive_src_block *sb;
1153         struct kvmppc_xive_irq_state *state;
1154         u16 idx;
1155
1156         sb = kvmppc_xive_find_source(xive, irq, &idx);
1157         if (!sb)
1158                 return;
1159
1160         state = &sb->irq_state[idx];
1161
1162         /* Some sanity checking */
1163         if (!state->valid) {
1164                 pr_err("invalid irq 0x%x in cpu queue!\n", irq);
1165                 return;
1166         }
1167
1168         /*
1169          * If the interrupt is in a queue it should have P set.
1170          * We warn so that gets reported. A backtrace isn't useful
1171          * so no need to use a WARN_ON.
1172          */
1173         if (!state->saved_p)
1174                 pr_err("Interrupt 0x%x is marked in a queue but P not set !\n", irq);
1175
1176         /* Set flag */
1177         state->in_queue = true;
1178 }
1179
1180 static void xive_pre_save_mask_irq(struct kvmppc_xive *xive,
1181                                    struct kvmppc_xive_src_block *sb,
1182                                    u32 irq)
1183 {
1184         struct kvmppc_xive_irq_state *state = &sb->irq_state[irq];
1185
1186         if (!state->valid)
1187                 return;
1188
1189         /* Mask and save state, this will also sync HW queues */
1190         state->saved_scan_prio = xive_lock_and_mask(xive, sb, state);
1191
1192         /* Transfer P and Q */
1193         state->saved_p = state->old_p;
1194         state->saved_q = state->old_q;
1195
1196         /* Unlock */
1197         arch_spin_unlock(&sb->lock);
1198 }
1199
1200 static void xive_pre_save_unmask_irq(struct kvmppc_xive *xive,
1201                                      struct kvmppc_xive_src_block *sb,
1202                                      u32 irq)
1203 {
1204         struct kvmppc_xive_irq_state *state = &sb->irq_state[irq];
1205
1206         if (!state->valid)
1207                 return;
1208
1209         /*
1210          * Lock / exclude EOI (not technically necessary if the
1211          * guest isn't running concurrently. If this becomes a
1212          * performance issue we can probably remove the lock.
1213          */
1214         xive_lock_for_unmask(sb, state);
1215
1216         /* Restore mask/prio if it wasn't masked */
1217         if (state->saved_scan_prio != MASKED)
1218                 xive_finish_unmask(xive, sb, state, state->saved_scan_prio);
1219
1220         /* Unlock */
1221         arch_spin_unlock(&sb->lock);
1222 }
1223
1224 static void xive_pre_save_queue(struct kvmppc_xive *xive, struct xive_q *q)
1225 {
1226         u32 idx = q->idx;
1227         u32 toggle = q->toggle;
1228         u32 irq;
1229
1230         do {
1231                 irq = __xive_read_eq(q->qpage, q->msk, &idx, &toggle);
1232                 if (irq > XICS_IPI)
1233                         xive_pre_save_set_queued(xive, irq);
1234         } while(irq);
1235 }
1236
1237 static void xive_pre_save_scan(struct kvmppc_xive *xive)
1238 {
1239         struct kvm_vcpu *vcpu = NULL;
1240         int i, j;
1241
1242         /*
1243          * See comment in xive_get_source() about how this
1244          * work. Collect a stable state for all interrupts
1245          */
1246         for (i = 0; i <= xive->max_sbid; i++) {
1247                 struct kvmppc_xive_src_block *sb = xive->src_blocks[i];
1248                 if (!sb)
1249                         continue;
1250                 for (j = 0;  j < KVMPPC_XICS_IRQ_PER_ICS; j++)
1251                         xive_pre_save_mask_irq(xive, sb, j);
1252         }
1253
1254         /* Then scan the queues and update the "in_queue" flag */
1255         kvm_for_each_vcpu(i, vcpu, xive->kvm) {
1256                 struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
1257                 if (!xc)
1258                         continue;
1259                 for (j = 0; j < KVMPPC_XIVE_Q_COUNT; j++) {
1260                         if (xc->queues[i].qpage)
1261                                 xive_pre_save_queue(xive, &xc->queues[i]);
1262                 }
1263         }
1264
1265         /* Finally restore interrupt states */
1266         for (i = 0; i <= xive->max_sbid; i++) {
1267                 struct kvmppc_xive_src_block *sb = xive->src_blocks[i];
1268                 if (!sb)
1269                         continue;
1270                 for (j = 0;  j < KVMPPC_XICS_IRQ_PER_ICS; j++)
1271                         xive_pre_save_unmask_irq(xive, sb, j);
1272         }
1273 }
1274
1275 static void xive_post_save_scan(struct kvmppc_xive *xive)
1276 {
1277         u32 i, j;
1278
1279         /* Clear all the in_queue flags */
1280         for (i = 0; i <= xive->max_sbid; i++) {
1281                 struct kvmppc_xive_src_block *sb = xive->src_blocks[i];
1282                 if (!sb)
1283                         continue;
1284                 for (j = 0;  j < KVMPPC_XICS_IRQ_PER_ICS; j++)
1285                         sb->irq_state[j].in_queue = false;
1286         }
1287
1288         /* Next get_source() will do a new scan */
1289         xive->saved_src_count = 0;
1290 }
1291
1292 /*
1293  * This returns the source configuration and state to user space.
1294  */
1295 static int xive_get_source(struct kvmppc_xive *xive, long irq, u64 addr)
1296 {
1297         struct kvmppc_xive_src_block *sb;
1298         struct kvmppc_xive_irq_state *state;
1299         u64 __user *ubufp = (u64 __user *) addr;
1300         u64 val, prio;
1301         u16 idx;
1302
1303         sb = kvmppc_xive_find_source(xive, irq, &idx);
1304         if (!sb)
1305                 return -ENOENT;
1306
1307         state = &sb->irq_state[idx];
1308
1309         if (!state->valid)
1310                 return -ENOENT;
1311
1312         pr_devel("get_source(%ld)...\n", irq);
1313
1314         /*
1315          * So to properly save the state into something that looks like a
1316          * XICS migration stream we cannot treat interrupts individually.
1317          *
1318          * We need, instead, mask them all (& save their previous PQ state)
1319          * to get a stable state in the HW, then sync them to ensure that
1320          * any interrupt that had already fired hits its queue, and finally
1321          * scan all the queues to collect which interrupts are still present
1322          * in the queues, so we can set the "pending" flag on them and
1323          * they can be resent on restore.
1324          *
1325          * So we do it all when the "first" interrupt gets saved, all the
1326          * state is collected at that point, the rest of xive_get_source()
1327          * will merely collect and convert that state to the expected
1328          * userspace bit mask.
1329          */
1330         if (xive->saved_src_count == 0)
1331                 xive_pre_save_scan(xive);
1332         xive->saved_src_count++;
1333
1334         /* Convert saved state into something compatible with xics */
1335         val = state->guest_server;
1336         prio = state->saved_scan_prio;
1337
1338         if (prio == MASKED) {
1339                 val |= KVM_XICS_MASKED;
1340                 prio = state->saved_priority;
1341         }
1342         val |= prio << KVM_XICS_PRIORITY_SHIFT;
1343         if (state->lsi) {
1344                 val |= KVM_XICS_LEVEL_SENSITIVE;
1345                 if (state->saved_p)
1346                         val |= KVM_XICS_PENDING;
1347         } else {
1348                 if (state->saved_p)
1349                         val |= KVM_XICS_PRESENTED;
1350
1351                 if (state->saved_q)
1352                         val |= KVM_XICS_QUEUED;
1353
1354                 /*
1355                  * We mark it pending (which will attempt a re-delivery)
1356                  * if we are in a queue *or* we were masked and had
1357                  * Q set which is equivalent to the XICS "masked pending"
1358                  * state
1359                  */
1360                 if (state->in_queue || (prio == MASKED && state->saved_q))
1361                         val |= KVM_XICS_PENDING;
1362         }
1363
1364         /*
1365          * If that was the last interrupt saved, reset the
1366          * in_queue flags
1367          */
1368         if (xive->saved_src_count == xive->src_count)
1369                 xive_post_save_scan(xive);
1370
1371         /* Copy the result to userspace */
1372         if (put_user(val, ubufp))
1373                 return -EFAULT;
1374
1375         return 0;
1376 }
1377
1378 static struct kvmppc_xive_src_block *xive_create_src_block(struct kvmppc_xive *xive,
1379                                                            int irq)
1380 {
1381         struct kvm *kvm = xive->kvm;
1382         struct kvmppc_xive_src_block *sb;
1383         int i, bid;
1384
1385         bid = irq >> KVMPPC_XICS_ICS_SHIFT;
1386
1387         mutex_lock(&kvm->lock);
1388
1389         /* block already exists - somebody else got here first */
1390         if (xive->src_blocks[bid])
1391                 goto out;
1392
1393         /* Create the ICS */
1394         sb = kzalloc(sizeof(*sb), GFP_KERNEL);
1395         if (!sb)
1396                 goto out;
1397
1398         sb->id = bid;
1399
1400         for (i = 0; i < KVMPPC_XICS_IRQ_PER_ICS; i++) {
1401                 sb->irq_state[i].number = (bid << KVMPPC_XICS_ICS_SHIFT) | i;
1402                 sb->irq_state[i].guest_priority = MASKED;
1403                 sb->irq_state[i].saved_priority = MASKED;
1404                 sb->irq_state[i].act_priority = MASKED;
1405         }
1406         smp_wmb();
1407         xive->src_blocks[bid] = sb;
1408
1409         if (bid > xive->max_sbid)
1410                 xive->max_sbid = bid;
1411
1412 out:
1413         mutex_unlock(&kvm->lock);
1414         return xive->src_blocks[bid];
1415 }
1416
1417 static bool xive_check_delayed_irq(struct kvmppc_xive *xive, u32 irq)
1418 {
1419         struct kvm *kvm = xive->kvm;
1420         struct kvm_vcpu *vcpu = NULL;
1421         int i;
1422
1423         kvm_for_each_vcpu(i, vcpu, kvm) {
1424                 struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
1425
1426                 if (!xc)
1427                         continue;
1428
1429                 if (xc->delayed_irq == irq) {
1430                         xc->delayed_irq = 0;
1431                         xive->delayed_irqs--;
1432                         return true;
1433                 }
1434         }
1435         return false;
1436 }
1437
1438 static int xive_set_source(struct kvmppc_xive *xive, long irq, u64 addr)
1439 {
1440         struct kvmppc_xive_src_block *sb;
1441         struct kvmppc_xive_irq_state *state;
1442         u64 __user *ubufp = (u64 __user *) addr;
1443         u16 idx;
1444         u64 val;
1445         u8 act_prio, guest_prio;
1446         u32 server;
1447         int rc = 0;
1448
1449         if (irq < KVMPPC_XICS_FIRST_IRQ || irq >= KVMPPC_XICS_NR_IRQS)
1450                 return -ENOENT;
1451
1452         pr_devel("set_source(irq=0x%lx)\n", irq);
1453
1454         /* Find the source */
1455         sb = kvmppc_xive_find_source(xive, irq, &idx);
1456         if (!sb) {
1457                 pr_devel("No source, creating source block...\n");
1458                 sb = xive_create_src_block(xive, irq);
1459                 if (!sb) {
1460                         pr_devel("Failed to create block...\n");
1461                         return -ENOMEM;
1462                 }
1463         }
1464         state = &sb->irq_state[idx];
1465
1466         /* Read user passed data */
1467         if (get_user(val, ubufp)) {
1468                 pr_devel("fault getting user info !\n");
1469                 return -EFAULT;
1470         }
1471
1472         server = val & KVM_XICS_DESTINATION_MASK;
1473         guest_prio = val >> KVM_XICS_PRIORITY_SHIFT;
1474
1475         pr_devel("  val=0x016%llx (server=0x%x, guest_prio=%d)\n",
1476                  val, server, guest_prio);
1477         /*
1478          * If the source doesn't already have an IPI, allocate
1479          * one and get the corresponding data
1480          */
1481         if (!state->ipi_number) {
1482                 state->ipi_number = xive_native_alloc_irq();
1483                 if (state->ipi_number == 0) {
1484                         pr_devel("Failed to allocate IPI !\n");
1485                         return -ENOMEM;
1486                 }
1487                 xive_native_populate_irq_data(state->ipi_number, &state->ipi_data);
1488                 pr_devel(" src_ipi=0x%x\n", state->ipi_number);
1489         }
1490
1491         /*
1492          * We use lock_and_mask() to set us in the right masked
1493          * state. We will override that state from the saved state
1494          * further down, but this will handle the cases of interrupts
1495          * that need FW masking. We set the initial guest_priority to
1496          * 0 before calling it to ensure it actually performs the masking.
1497          */
1498         state->guest_priority = 0;
1499         xive_lock_and_mask(xive, sb, state);
1500
1501         /*
1502          * Now, we select a target if we have one. If we don't we
1503          * leave the interrupt untargetted. It means that an interrupt
1504          * can become "untargetted" accross migration if it was masked
1505          * by set_xive() but there is little we can do about it.
1506          */
1507
1508         /* First convert prio and mark interrupt as untargetted */
1509         act_prio = xive_prio_from_guest(guest_prio);
1510         state->act_priority = MASKED;
1511         state->guest_server = server;
1512
1513         /*
1514          * We need to drop the lock due to the mutex below. Hopefully
1515          * nothing is touching that interrupt yet since it hasn't been
1516          * advertized to a running guest yet
1517          */
1518         arch_spin_unlock(&sb->lock);
1519
1520         /* If we have a priority target the interrupt */
1521         if (act_prio != MASKED) {
1522                 /* First, check provisioning of queues */
1523                 mutex_lock(&xive->kvm->lock);
1524                 rc = xive_check_provisioning(xive->kvm, act_prio);
1525                 mutex_unlock(&xive->kvm->lock);
1526
1527                 /* Target interrupt */
1528                 if (rc == 0)
1529                         rc = xive_target_interrupt(xive->kvm, state,
1530                                                    server, act_prio);
1531                 /*
1532                  * If provisioning or targetting failed, leave it
1533                  * alone and masked. It will remain disabled until
1534                  * the guest re-targets it.
1535                  */
1536         }
1537
1538         /*
1539          * Find out if this was a delayed irq stashed in an ICP,
1540          * in which case, treat it as pending
1541          */
1542         if (xive->delayed_irqs && xive_check_delayed_irq(xive, irq)) {
1543                 val |= KVM_XICS_PENDING;
1544                 pr_devel("  Found delayed ! forcing PENDING !\n");
1545         }
1546
1547         /* Cleanup the SW state */
1548         state->old_p = false;
1549         state->old_q = false;
1550         state->lsi = false;
1551         state->asserted = false;
1552
1553         /* Restore LSI state */
1554         if (val & KVM_XICS_LEVEL_SENSITIVE) {
1555                 state->lsi = true;
1556                 if (val & KVM_XICS_PENDING)
1557                         state->asserted = true;
1558                 pr_devel("  LSI ! Asserted=%d\n", state->asserted);
1559         }
1560
1561         /*
1562          * Restore P and Q. If the interrupt was pending, we
1563          * force both P and Q, which will trigger a resend.
1564          *
1565          * That means that a guest that had both an interrupt
1566          * pending (queued) and Q set will restore with only
1567          * one instance of that interrupt instead of 2, but that
1568          * is perfectly fine as coalescing interrupts that haven't
1569          * been presented yet is always allowed.
1570          */
1571         if (val & KVM_XICS_PRESENTED || val & KVM_XICS_PENDING)
1572                 state->old_p = true;
1573         if (val & KVM_XICS_QUEUED || val & KVM_XICS_PENDING)
1574                 state->old_q = true;
1575
1576         pr_devel("  P=%d, Q=%d\n", state->old_p, state->old_q);
1577
1578         /*
1579          * If the interrupt was unmasked, update guest priority and
1580          * perform the appropriate state transition and do a
1581          * re-trigger if necessary.
1582          */
1583         if (val & KVM_XICS_MASKED) {
1584                 pr_devel("  masked, saving prio\n");
1585                 state->guest_priority = MASKED;
1586                 state->saved_priority = guest_prio;
1587         } else {
1588                 pr_devel("  unmasked, restoring to prio %d\n", guest_prio);
1589                 xive_finish_unmask(xive, sb, state, guest_prio);
1590                 state->saved_priority = guest_prio;
1591         }
1592
1593         /* Increment the number of valid sources and mark this one valid */
1594         if (!state->valid)
1595                 xive->src_count++;
1596         state->valid = true;
1597
1598         return 0;
1599 }
1600
1601 int kvmppc_xive_set_irq(struct kvm *kvm, int irq_source_id, u32 irq, int level,
1602                         bool line_status)
1603 {
1604         struct kvmppc_xive *xive = kvm->arch.xive;
1605         struct kvmppc_xive_src_block *sb;
1606         struct kvmppc_xive_irq_state *state;
1607         u16 idx;
1608
1609         if (!xive)
1610                 return -ENODEV;
1611
1612         sb = kvmppc_xive_find_source(xive, irq, &idx);
1613         if (!sb)
1614                 return -EINVAL;
1615
1616         /* Perform locklessly .... (we need to do some RCUisms here...) */
1617         state = &sb->irq_state[idx];
1618         if (!state->valid)
1619                 return -EINVAL;
1620
1621         /* We don't allow a trigger on a passed-through interrupt */
1622         if (state->pt_number)
1623                 return -EINVAL;
1624
1625         if ((level == 1 && state->lsi) || level == KVM_INTERRUPT_SET_LEVEL)
1626                 state->asserted = 1;
1627         else if (level == 0 || level == KVM_INTERRUPT_UNSET) {
1628                 state->asserted = 0;
1629                 return 0;
1630         }
1631
1632         /* Trigger the IPI */
1633         xive_irq_trigger(&state->ipi_data);
1634
1635         return 0;
1636 }
1637
1638 static int xive_set_attr(struct kvm_device *dev, struct kvm_device_attr *attr)
1639 {
1640         struct kvmppc_xive *xive = dev->private;
1641
1642         /* We honor the existing XICS ioctl */
1643         switch (attr->group) {
1644         case KVM_DEV_XICS_GRP_SOURCES:
1645                 return xive_set_source(xive, attr->attr, attr->addr);
1646         }
1647         return -ENXIO;
1648 }
1649
1650 static int xive_get_attr(struct kvm_device *dev, struct kvm_device_attr *attr)
1651 {
1652         struct kvmppc_xive *xive = dev->private;
1653
1654         /* We honor the existing XICS ioctl */
1655         switch (attr->group) {
1656         case KVM_DEV_XICS_GRP_SOURCES:
1657                 return xive_get_source(xive, attr->attr, attr->addr);
1658         }
1659         return -ENXIO;
1660 }
1661
1662 static int xive_has_attr(struct kvm_device *dev, struct kvm_device_attr *attr)
1663 {
1664         /* We honor the same limits as XICS, at least for now */
1665         switch (attr->group) {
1666         case KVM_DEV_XICS_GRP_SOURCES:
1667                 if (attr->attr >= KVMPPC_XICS_FIRST_IRQ &&
1668                     attr->attr < KVMPPC_XICS_NR_IRQS)
1669                         return 0;
1670                 break;
1671         }
1672         return -ENXIO;
1673 }
1674
1675 static void kvmppc_xive_cleanup_irq(u32 hw_num, struct xive_irq_data *xd)
1676 {
1677         xive_vm_esb_load(xd, XIVE_ESB_SET_PQ_01);
1678         xive_native_configure_irq(hw_num, 0, MASKED, 0);
1679         xive_cleanup_irq_data(xd);
1680 }
1681
1682 static void kvmppc_xive_free_sources(struct kvmppc_xive_src_block *sb)
1683 {
1684         int i;
1685
1686         for (i = 0; i < KVMPPC_XICS_IRQ_PER_ICS; i++) {
1687                 struct kvmppc_xive_irq_state *state = &sb->irq_state[i];
1688
1689                 if (!state->valid)
1690                         continue;
1691
1692                 kvmppc_xive_cleanup_irq(state->ipi_number, &state->ipi_data);
1693                 xive_native_free_irq(state->ipi_number);
1694
1695                 /* Pass-through, cleanup too */
1696                 if (state->pt_number)
1697                         kvmppc_xive_cleanup_irq(state->pt_number, state->pt_data);
1698
1699                 state->valid = false;
1700         }
1701 }
1702
1703 static void kvmppc_xive_free(struct kvm_device *dev)
1704 {
1705         struct kvmppc_xive *xive = dev->private;
1706         struct kvm *kvm = xive->kvm;
1707         int i;
1708
1709         debugfs_remove(xive->dentry);
1710
1711         if (kvm)
1712                 kvm->arch.xive = NULL;
1713
1714         /* Mask and free interrupts */
1715         for (i = 0; i <= xive->max_sbid; i++) {
1716                 if (xive->src_blocks[i])
1717                         kvmppc_xive_free_sources(xive->src_blocks[i]);
1718                 kfree(xive->src_blocks[i]);
1719                 xive->src_blocks[i] = NULL;
1720         }
1721
1722         if (xive->vp_base != XIVE_INVALID_VP)
1723                 xive_native_free_vp_block(xive->vp_base);
1724
1725
1726         kfree(xive);
1727         kfree(dev);
1728 }
1729
1730 static int kvmppc_xive_create(struct kvm_device *dev, u32 type)
1731 {
1732         struct kvmppc_xive *xive;
1733         struct kvm *kvm = dev->kvm;
1734         int ret = 0;
1735
1736         pr_devel("Creating xive for partition\n");
1737
1738         xive = kzalloc(sizeof(*xive), GFP_KERNEL);
1739         if (!xive)
1740                 return -ENOMEM;
1741
1742         dev->private = xive;
1743         xive->dev = dev;
1744         xive->kvm = kvm;
1745
1746         /* Already there ? */
1747         if (kvm->arch.xive)
1748                 ret = -EEXIST;
1749         else
1750                 kvm->arch.xive = xive;
1751
1752         /* We use the default queue size set by the host */
1753         xive->q_order = xive_native_default_eq_shift();
1754         if (xive->q_order < PAGE_SHIFT)
1755                 xive->q_page_order = 0;
1756         else
1757                 xive->q_page_order = xive->q_order - PAGE_SHIFT;
1758
1759         /* Allocate a bunch of VPs */
1760         xive->vp_base = xive_native_alloc_vp_block(KVM_MAX_VCPUS);
1761         pr_devel("VP_Base=%x\n", xive->vp_base);
1762
1763         if (xive->vp_base == XIVE_INVALID_VP)
1764                 ret = -ENOMEM;
1765
1766         if (ret) {
1767                 kfree(xive);
1768                 return ret;
1769         }
1770
1771         return 0;
1772 }
1773
1774
1775 static int xive_debug_show(struct seq_file *m, void *private)
1776 {
1777         struct kvmppc_xive *xive = m->private;
1778         struct kvm *kvm = xive->kvm;
1779         struct kvm_vcpu *vcpu;
1780         u64 t_rm_h_xirr = 0;
1781         u64 t_rm_h_ipoll = 0;
1782         u64 t_rm_h_cppr = 0;
1783         u64 t_rm_h_eoi = 0;
1784         u64 t_rm_h_ipi = 0;
1785         u64 t_vm_h_xirr = 0;
1786         u64 t_vm_h_ipoll = 0;
1787         u64 t_vm_h_cppr = 0;
1788         u64 t_vm_h_eoi = 0;
1789         u64 t_vm_h_ipi = 0;
1790         unsigned int i;
1791
1792         if (!kvm)
1793                 return 0;
1794
1795         seq_printf(m, "=========\nVCPU state\n=========\n");
1796
1797         kvm_for_each_vcpu(i, vcpu, kvm) {
1798                 struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
1799
1800                 if (!xc)
1801                         continue;
1802
1803                 seq_printf(m, "cpu server %#x CPPR:%#x HWCPPR:%#x"
1804                            " MFRR:%#x PEND:%#x h_xirr: R=%lld V=%lld\n",
1805                            xc->server_num, xc->cppr, xc->hw_cppr,
1806                            xc->mfrr, xc->pending,
1807                            xc->stat_rm_h_xirr, xc->stat_vm_h_xirr);
1808
1809                 t_rm_h_xirr += xc->stat_rm_h_xirr;
1810                 t_rm_h_ipoll += xc->stat_rm_h_ipoll;
1811                 t_rm_h_cppr += xc->stat_rm_h_cppr;
1812                 t_rm_h_eoi += xc->stat_rm_h_eoi;
1813                 t_rm_h_ipi += xc->stat_rm_h_ipi;
1814                 t_vm_h_xirr += xc->stat_vm_h_xirr;
1815                 t_vm_h_ipoll += xc->stat_vm_h_ipoll;
1816                 t_vm_h_cppr += xc->stat_vm_h_cppr;
1817                 t_vm_h_eoi += xc->stat_vm_h_eoi;
1818                 t_vm_h_ipi += xc->stat_vm_h_ipi;
1819         }
1820
1821         seq_printf(m, "Hcalls totals\n");
1822         seq_printf(m, " H_XIRR  R=%10lld V=%10lld\n", t_rm_h_xirr, t_vm_h_xirr);
1823         seq_printf(m, " H_IPOLL R=%10lld V=%10lld\n", t_rm_h_ipoll, t_vm_h_ipoll);
1824         seq_printf(m, " H_CPPR  R=%10lld V=%10lld\n", t_rm_h_cppr, t_vm_h_cppr);
1825         seq_printf(m, " H_EOI   R=%10lld V=%10lld\n", t_rm_h_eoi, t_vm_h_eoi);
1826         seq_printf(m, " H_IPI   R=%10lld V=%10lld\n", t_rm_h_ipi, t_vm_h_ipi);
1827
1828         return 0;
1829 }
1830
1831 static int xive_debug_open(struct inode *inode, struct file *file)
1832 {
1833         return single_open(file, xive_debug_show, inode->i_private);
1834 }
1835
1836 static const struct file_operations xive_debug_fops = {
1837         .open = xive_debug_open,
1838         .read = seq_read,
1839         .llseek = seq_lseek,
1840         .release = single_release,
1841 };
1842
1843 static void xive_debugfs_init(struct kvmppc_xive *xive)
1844 {
1845         char *name;
1846
1847         name = kasprintf(GFP_KERNEL, "kvm-xive-%p", xive);
1848         if (!name) {
1849                 pr_err("%s: no memory for name\n", __func__);
1850                 return;
1851         }
1852
1853         xive->dentry = debugfs_create_file(name, S_IRUGO, powerpc_debugfs_root,
1854                                            xive, &xive_debug_fops);
1855
1856         pr_debug("%s: created %s\n", __func__, name);
1857         kfree(name);
1858 }
1859
1860 static void kvmppc_xive_init(struct kvm_device *dev)
1861 {
1862         struct kvmppc_xive *xive = (struct kvmppc_xive *)dev->private;
1863
1864         /* Register some debug interfaces */
1865         xive_debugfs_init(xive);
1866 }
1867
1868 struct kvm_device_ops kvm_xive_ops = {
1869         .name = "kvm-xive",
1870         .create = kvmppc_xive_create,
1871         .init = kvmppc_xive_init,
1872         .destroy = kvmppc_xive_free,
1873         .set_attr = xive_set_attr,
1874         .get_attr = xive_get_attr,
1875         .has_attr = xive_has_attr,
1876 };
1877
1878 void kvmppc_xive_init_module(void)
1879 {
1880         __xive_vm_h_xirr = xive_vm_h_xirr;
1881         __xive_vm_h_ipoll = xive_vm_h_ipoll;
1882         __xive_vm_h_ipi = xive_vm_h_ipi;
1883         __xive_vm_h_cppr = xive_vm_h_cppr;
1884         __xive_vm_h_eoi = xive_vm_h_eoi;
1885 }
1886
1887 void kvmppc_xive_exit_module(void)
1888 {
1889         __xive_vm_h_xirr = NULL;
1890         __xive_vm_h_ipoll = NULL;
1891         __xive_vm_h_ipi = NULL;
1892         __xive_vm_h_cppr = NULL;
1893         __xive_vm_h_eoi = NULL;
1894 }