![Sam Bobroff](/assets/img/avatar_default.png)
In KVM's XICS-on-XIVE emulation, kvmppc_xive_get_xive() returns the
value of state->guest_server as "server". However, this value is not
set by it's counterpart kvmppc_xive_set_xive(). When the guest uses
this interface to migrate interrupts away from a CPU that is going
offline, it sees all interrupts as belonging to CPU 0, so they are
left assigned to (now) offline CPUs.
This patch removes the guest_server field from the state, and returns
act_server in it's place (that is, the CPU actually handling the
interrupt, which may differ from the one requested).
Fixes: 5af5099385
("KVM: PPC: Book3S HV: Native usage of the XIVE interrupt controller")
Cc: stable@vger.kernel.org
Signed-off-by: Sam Bobroff <sam.bobroff@au1.ibm.com>
Acked-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Radim Krčmář <rkrcmar@redhat.com>
1893 lines
47 KiB
C
1893 lines
47 KiB
C
/*
|
|
* Copyright 2017 Benjamin Herrenschmidt, IBM Corporation.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License, version 2, as
|
|
* published by the Free Software Foundation.
|
|
*/
|
|
|
|
#define pr_fmt(fmt) "xive-kvm: " fmt
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/kvm_host.h>
|
|
#include <linux/err.h>
|
|
#include <linux/gfp.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/percpu.h>
|
|
#include <linux/cpumask.h>
|
|
#include <asm/uaccess.h>
|
|
#include <asm/kvm_book3s.h>
|
|
#include <asm/kvm_ppc.h>
|
|
#include <asm/hvcall.h>
|
|
#include <asm/xics.h>
|
|
#include <asm/xive.h>
|
|
#include <asm/xive-regs.h>
|
|
#include <asm/debug.h>
|
|
#include <asm/debugfs.h>
|
|
#include <asm/time.h>
|
|
#include <asm/opal.h>
|
|
|
|
#include <linux/debugfs.h>
|
|
#include <linux/seq_file.h>
|
|
|
|
#include "book3s_xive.h"
|
|
|
|
|
|
/*
|
|
* Virtual mode variants of the hcalls for use on radix/radix
|
|
* with AIL. They require the VCPU's VP to be "pushed"
|
|
*
|
|
* We still instanciate them here because we use some of the
|
|
* generated utility functions as well in this file.
|
|
*/
|
|
#define XIVE_RUNTIME_CHECKS
|
|
#define X_PFX xive_vm_
|
|
#define X_STATIC static
|
|
#define X_STAT_PFX stat_vm_
|
|
#define __x_tima xive_tima
|
|
#define __x_eoi_page(xd) ((void __iomem *)((xd)->eoi_mmio))
|
|
#define __x_trig_page(xd) ((void __iomem *)((xd)->trig_mmio))
|
|
#define __x_writeb __raw_writeb
|
|
#define __x_readw __raw_readw
|
|
#define __x_readq __raw_readq
|
|
#define __x_writeq __raw_writeq
|
|
|
|
#include "book3s_xive_template.c"
|
|
|
|
/*
|
|
* We leave a gap of a couple of interrupts in the queue to
|
|
* account for the IPI and additional safety guard.
|
|
*/
|
|
#define XIVE_Q_GAP 2
|
|
|
|
/*
|
|
* This is a simple trigger for a generic XIVE IRQ. This must
|
|
* only be called for interrupts that support a trigger page
|
|
*/
|
|
static bool xive_irq_trigger(struct xive_irq_data *xd)
|
|
{
|
|
/* This should be only for MSIs */
|
|
if (WARN_ON(xd->flags & XIVE_IRQ_FLAG_LSI))
|
|
return false;
|
|
|
|
/* Those interrupts should always have a trigger page */
|
|
if (WARN_ON(!xd->trig_mmio))
|
|
return false;
|
|
|
|
out_be64(xd->trig_mmio, 0);
|
|
|
|
return true;
|
|
}
|
|
|
|
static irqreturn_t xive_esc_irq(int irq, void *data)
|
|
{
|
|
struct kvm_vcpu *vcpu = data;
|
|
|
|
/* We use the existing H_PROD mechanism to wake up the target */
|
|
vcpu->arch.prodded = 1;
|
|
smp_mb();
|
|
if (vcpu->arch.ceded)
|
|
kvmppc_fast_vcpu_kick(vcpu);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static int xive_attach_escalation(struct kvm_vcpu *vcpu, u8 prio)
|
|
{
|
|
struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
|
|
struct xive_q *q = &xc->queues[prio];
|
|
char *name = NULL;
|
|
int rc;
|
|
|
|
/* Already there ? */
|
|
if (xc->esc_virq[prio])
|
|
return 0;
|
|
|
|
/* Hook up the escalation interrupt */
|
|
xc->esc_virq[prio] = irq_create_mapping(NULL, q->esc_irq);
|
|
if (!xc->esc_virq[prio]) {
|
|
pr_err("Failed to map escalation interrupt for queue %d of VCPU %d\n",
|
|
prio, xc->server_num);
|
|
return -EIO;
|
|
}
|
|
|
|
/*
|
|
* Future improvement: start with them disabled
|
|
* and handle DD2 and later scheme of merged escalation
|
|
* interrupts
|
|
*/
|
|
name = kasprintf(GFP_KERNEL, "kvm-%d-%d-%d",
|
|
vcpu->kvm->arch.lpid, xc->server_num, prio);
|
|
if (!name) {
|
|
pr_err("Failed to allocate escalation irq name for queue %d of VCPU %d\n",
|
|
prio, xc->server_num);
|
|
rc = -ENOMEM;
|
|
goto error;
|
|
}
|
|
rc = request_irq(xc->esc_virq[prio], xive_esc_irq,
|
|
IRQF_NO_THREAD, name, vcpu);
|
|
if (rc) {
|
|
pr_err("Failed to request escalation interrupt for queue %d of VCPU %d\n",
|
|
prio, xc->server_num);
|
|
goto error;
|
|
}
|
|
xc->esc_virq_names[prio] = name;
|
|
return 0;
|
|
error:
|
|
irq_dispose_mapping(xc->esc_virq[prio]);
|
|
xc->esc_virq[prio] = 0;
|
|
kfree(name);
|
|
return rc;
|
|
}
|
|
|
|
static int xive_provision_queue(struct kvm_vcpu *vcpu, u8 prio)
|
|
{
|
|
struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
|
|
struct kvmppc_xive *xive = xc->xive;
|
|
struct xive_q *q = &xc->queues[prio];
|
|
void *qpage;
|
|
int rc;
|
|
|
|
if (WARN_ON(q->qpage))
|
|
return 0;
|
|
|
|
/* Allocate the queue and retrieve infos on current node for now */
|
|
qpage = (__be32 *)__get_free_pages(GFP_KERNEL, xive->q_page_order);
|
|
if (!qpage) {
|
|
pr_err("Failed to allocate queue %d for VCPU %d\n",
|
|
prio, xc->server_num);
|
|
return -ENOMEM;;
|
|
}
|
|
memset(qpage, 0, 1 << xive->q_order);
|
|
|
|
/*
|
|
* Reconfigure the queue. This will set q->qpage only once the
|
|
* queue is fully configured. This is a requirement for prio 0
|
|
* as we will stop doing EOIs for every IPI as soon as we observe
|
|
* qpage being non-NULL, and instead will only EOI when we receive
|
|
* corresponding queue 0 entries
|
|
*/
|
|
rc = xive_native_configure_queue(xc->vp_id, q, prio, qpage,
|
|
xive->q_order, true);
|
|
if (rc)
|
|
pr_err("Failed to configure queue %d for VCPU %d\n",
|
|
prio, xc->server_num);
|
|
return rc;
|
|
}
|
|
|
|
/* Called with kvm_lock held */
|
|
static int xive_check_provisioning(struct kvm *kvm, u8 prio)
|
|
{
|
|
struct kvmppc_xive *xive = kvm->arch.xive;
|
|
struct kvm_vcpu *vcpu;
|
|
int i, rc;
|
|
|
|
lockdep_assert_held(&kvm->lock);
|
|
|
|
/* Already provisioned ? */
|
|
if (xive->qmap & (1 << prio))
|
|
return 0;
|
|
|
|
pr_devel("Provisioning prio... %d\n", prio);
|
|
|
|
/* Provision each VCPU and enable escalations */
|
|
kvm_for_each_vcpu(i, vcpu, kvm) {
|
|
if (!vcpu->arch.xive_vcpu)
|
|
continue;
|
|
rc = xive_provision_queue(vcpu, prio);
|
|
if (rc == 0)
|
|
xive_attach_escalation(vcpu, prio);
|
|
if (rc)
|
|
return rc;
|
|
}
|
|
|
|
/* Order previous stores and mark it as provisioned */
|
|
mb();
|
|
xive->qmap |= (1 << prio);
|
|
return 0;
|
|
}
|
|
|
|
static void xive_inc_q_pending(struct kvm *kvm, u32 server, u8 prio)
|
|
{
|
|
struct kvm_vcpu *vcpu;
|
|
struct kvmppc_xive_vcpu *xc;
|
|
struct xive_q *q;
|
|
|
|
/* Locate target server */
|
|
vcpu = kvmppc_xive_find_server(kvm, server);
|
|
if (!vcpu) {
|
|
pr_warn("%s: Can't find server %d\n", __func__, server);
|
|
return;
|
|
}
|
|
xc = vcpu->arch.xive_vcpu;
|
|
if (WARN_ON(!xc))
|
|
return;
|
|
|
|
q = &xc->queues[prio];
|
|
atomic_inc(&q->pending_count);
|
|
}
|
|
|
|
static int xive_try_pick_queue(struct kvm_vcpu *vcpu, u8 prio)
|
|
{
|
|
struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
|
|
struct xive_q *q;
|
|
u32 max;
|
|
|
|
if (WARN_ON(!xc))
|
|
return -ENXIO;
|
|
if (!xc->valid)
|
|
return -ENXIO;
|
|
|
|
q = &xc->queues[prio];
|
|
if (WARN_ON(!q->qpage))
|
|
return -ENXIO;
|
|
|
|
/* Calculate max number of interrupts in that queue. */
|
|
max = (q->msk + 1) - XIVE_Q_GAP;
|
|
return atomic_add_unless(&q->count, 1, max) ? 0 : -EBUSY;
|
|
}
|
|
|
|
static int xive_select_target(struct kvm *kvm, u32 *server, u8 prio)
|
|
{
|
|
struct kvm_vcpu *vcpu;
|
|
int i, rc;
|
|
|
|
/* Locate target server */
|
|
vcpu = kvmppc_xive_find_server(kvm, *server);
|
|
if (!vcpu) {
|
|
pr_devel("Can't find server %d\n", *server);
|
|
return -EINVAL;
|
|
}
|
|
|
|
pr_devel("Finding irq target on 0x%x/%d...\n", *server, prio);
|
|
|
|
/* Try pick it */
|
|
rc = xive_try_pick_queue(vcpu, prio);
|
|
if (rc == 0)
|
|
return rc;
|
|
|
|
pr_devel(" .. failed, looking up candidate...\n");
|
|
|
|
/* Failed, pick another VCPU */
|
|
kvm_for_each_vcpu(i, vcpu, kvm) {
|
|
if (!vcpu->arch.xive_vcpu)
|
|
continue;
|
|
rc = xive_try_pick_queue(vcpu, prio);
|
|
if (rc == 0) {
|
|
*server = vcpu->arch.xive_vcpu->server_num;
|
|
pr_devel(" found on 0x%x/%d\n", *server, prio);
|
|
return rc;
|
|
}
|
|
}
|
|
pr_devel(" no available target !\n");
|
|
|
|
/* No available target ! */
|
|
return -EBUSY;
|
|
}
|
|
|
|
static u8 xive_lock_and_mask(struct kvmppc_xive *xive,
|
|
struct kvmppc_xive_src_block *sb,
|
|
struct kvmppc_xive_irq_state *state)
|
|
{
|
|
struct xive_irq_data *xd;
|
|
u32 hw_num;
|
|
u8 old_prio;
|
|
u64 val;
|
|
|
|
/*
|
|
* Take the lock, set masked, try again if racing
|
|
* with H_EOI
|
|
*/
|
|
for (;;) {
|
|
arch_spin_lock(&sb->lock);
|
|
old_prio = state->guest_priority;
|
|
state->guest_priority = MASKED;
|
|
mb();
|
|
if (!state->in_eoi)
|
|
break;
|
|
state->guest_priority = old_prio;
|
|
arch_spin_unlock(&sb->lock);
|
|
}
|
|
|
|
/* No change ? Bail */
|
|
if (old_prio == MASKED)
|
|
return old_prio;
|
|
|
|
/* Get the right irq */
|
|
kvmppc_xive_select_irq(state, &hw_num, &xd);
|
|
|
|
/*
|
|
* If the interrupt is marked as needing masking via
|
|
* firmware, we do it here. Firmware masking however
|
|
* is "lossy", it won't return the old p and q bits
|
|
* and won't set the interrupt to a state where it will
|
|
* record queued ones. If this is an issue we should do
|
|
* lazy masking instead.
|
|
*
|
|
* For now, we work around this in unmask by forcing
|
|
* an interrupt whenever we unmask a non-LSI via FW
|
|
* (if ever).
|
|
*/
|
|
if (xd->flags & OPAL_XIVE_IRQ_MASK_VIA_FW) {
|
|
xive_native_configure_irq(hw_num,
|
|
xive->vp_base + state->act_server,
|
|
MASKED, state->number);
|
|
/* set old_p so we can track if an H_EOI was done */
|
|
state->old_p = true;
|
|
state->old_q = false;
|
|
} else {
|
|
/* Set PQ to 10, return old P and old Q and remember them */
|
|
val = xive_vm_esb_load(xd, XIVE_ESB_SET_PQ_10);
|
|
state->old_p = !!(val & 2);
|
|
state->old_q = !!(val & 1);
|
|
|
|
/*
|
|
* Synchronize hardware to sensure the queues are updated
|
|
* when masking
|
|
*/
|
|
xive_native_sync_source(hw_num);
|
|
}
|
|
|
|
return old_prio;
|
|
}
|
|
|
|
static void xive_lock_for_unmask(struct kvmppc_xive_src_block *sb,
|
|
struct kvmppc_xive_irq_state *state)
|
|
{
|
|
/*
|
|
* Take the lock try again if racing with H_EOI
|
|
*/
|
|
for (;;) {
|
|
arch_spin_lock(&sb->lock);
|
|
if (!state->in_eoi)
|
|
break;
|
|
arch_spin_unlock(&sb->lock);
|
|
}
|
|
}
|
|
|
|
static void xive_finish_unmask(struct kvmppc_xive *xive,
|
|
struct kvmppc_xive_src_block *sb,
|
|
struct kvmppc_xive_irq_state *state,
|
|
u8 prio)
|
|
{
|
|
struct xive_irq_data *xd;
|
|
u32 hw_num;
|
|
|
|
/* If we aren't changing a thing, move on */
|
|
if (state->guest_priority != MASKED)
|
|
goto bail;
|
|
|
|
/* Get the right irq */
|
|
kvmppc_xive_select_irq(state, &hw_num, &xd);
|
|
|
|
/*
|
|
* See command in xive_lock_and_mask() concerning masking
|
|
* via firmware.
|
|
*/
|
|
if (xd->flags & OPAL_XIVE_IRQ_MASK_VIA_FW) {
|
|
xive_native_configure_irq(hw_num,
|
|
xive->vp_base + state->act_server,
|
|
state->act_priority, state->number);
|
|
/* If an EOI is needed, do it here */
|
|
if (!state->old_p)
|
|
xive_vm_source_eoi(hw_num, xd);
|
|
/* If this is not an LSI, force a trigger */
|
|
if (!(xd->flags & OPAL_XIVE_IRQ_LSI))
|
|
xive_irq_trigger(xd);
|
|
goto bail;
|
|
}
|
|
|
|
/* Old Q set, set PQ to 11 */
|
|
if (state->old_q)
|
|
xive_vm_esb_load(xd, XIVE_ESB_SET_PQ_11);
|
|
|
|
/*
|
|
* If not old P, then perform an "effective" EOI,
|
|
* on the source. This will handle the cases where
|
|
* FW EOI is needed.
|
|
*/
|
|
if (!state->old_p)
|
|
xive_vm_source_eoi(hw_num, xd);
|
|
|
|
/* Synchronize ordering and mark unmasked */
|
|
mb();
|
|
bail:
|
|
state->guest_priority = prio;
|
|
}
|
|
|
|
/*
|
|
* Target an interrupt to a given server/prio, this will fallback
|
|
* to another server if necessary and perform the HW targetting
|
|
* updates as needed
|
|
*
|
|
* NOTE: Must be called with the state lock held
|
|
*/
|
|
static int xive_target_interrupt(struct kvm *kvm,
|
|
struct kvmppc_xive_irq_state *state,
|
|
u32 server, u8 prio)
|
|
{
|
|
struct kvmppc_xive *xive = kvm->arch.xive;
|
|
u32 hw_num;
|
|
int rc;
|
|
|
|
/*
|
|
* This will return a tentative server and actual
|
|
* priority. The count for that new target will have
|
|
* already been incremented.
|
|
*/
|
|
rc = xive_select_target(kvm, &server, prio);
|
|
|
|
/*
|
|
* We failed to find a target ? Not much we can do
|
|
* at least until we support the GIQ.
|
|
*/
|
|
if (rc)
|
|
return rc;
|
|
|
|
/*
|
|
* Increment the old queue pending count if there
|
|
* was one so that the old queue count gets adjusted later
|
|
* when observed to be empty.
|
|
*/
|
|
if (state->act_priority != MASKED)
|
|
xive_inc_q_pending(kvm,
|
|
state->act_server,
|
|
state->act_priority);
|
|
/*
|
|
* Update state and HW
|
|
*/
|
|
state->act_priority = prio;
|
|
state->act_server = server;
|
|
|
|
/* Get the right irq */
|
|
kvmppc_xive_select_irq(state, &hw_num, NULL);
|
|
|
|
return xive_native_configure_irq(hw_num,
|
|
xive->vp_base + server,
|
|
prio, state->number);
|
|
}
|
|
|
|
/*
|
|
* Targetting rules: In order to avoid losing track of
|
|
* pending interrupts accross mask and unmask, which would
|
|
* allow queue overflows, we implement the following rules:
|
|
*
|
|
* - Unless it was never enabled (or we run out of capacity)
|
|
* an interrupt is always targetted at a valid server/queue
|
|
* pair even when "masked" by the guest. This pair tends to
|
|
* be the last one used but it can be changed under some
|
|
* circumstances. That allows us to separate targetting
|
|
* from masking, we only handle accounting during (re)targetting,
|
|
* this also allows us to let an interrupt drain into its target
|
|
* queue after masking, avoiding complex schemes to remove
|
|
* interrupts out of remote processor queues.
|
|
*
|
|
* - When masking, we set PQ to 10 and save the previous value
|
|
* of P and Q.
|
|
*
|
|
* - When unmasking, if saved Q was set, we set PQ to 11
|
|
* otherwise we leave PQ to the HW state which will be either
|
|
* 10 if nothing happened or 11 if the interrupt fired while
|
|
* masked. Effectively we are OR'ing the previous Q into the
|
|
* HW Q.
|
|
*
|
|
* Then if saved P is clear, we do an effective EOI (Q->P->Trigger)
|
|
* which will unmask the interrupt and shoot a new one if Q was
|
|
* set.
|
|
*
|
|
* Otherwise (saved P is set) we leave PQ unchanged (so 10 or 11,
|
|
* effectively meaning an H_EOI from the guest is still expected
|
|
* for that interrupt).
|
|
*
|
|
* - If H_EOI occurs while masked, we clear the saved P.
|
|
*
|
|
* - When changing target, we account on the new target and
|
|
* increment a separate "pending" counter on the old one.
|
|
* This pending counter will be used to decrement the old
|
|
* target's count when its queue has been observed empty.
|
|
*/
|
|
|
|
int kvmppc_xive_set_xive(struct kvm *kvm, u32 irq, u32 server,
|
|
u32 priority)
|
|
{
|
|
struct kvmppc_xive *xive = kvm->arch.xive;
|
|
struct kvmppc_xive_src_block *sb;
|
|
struct kvmppc_xive_irq_state *state;
|
|
u8 new_act_prio;
|
|
int rc = 0;
|
|
u16 idx;
|
|
|
|
if (!xive)
|
|
return -ENODEV;
|
|
|
|
pr_devel("set_xive ! irq 0x%x server 0x%x prio %d\n",
|
|
irq, server, priority);
|
|
|
|
/* First, check provisioning of queues */
|
|
if (priority != MASKED)
|
|
rc = xive_check_provisioning(xive->kvm,
|
|
xive_prio_from_guest(priority));
|
|
if (rc) {
|
|
pr_devel(" provisioning failure %d !\n", rc);
|
|
return rc;
|
|
}
|
|
|
|
sb = kvmppc_xive_find_source(xive, irq, &idx);
|
|
if (!sb)
|
|
return -EINVAL;
|
|
state = &sb->irq_state[idx];
|
|
|
|
/*
|
|
* We first handle masking/unmasking since the locking
|
|
* might need to be retried due to EOIs, we'll handle
|
|
* targetting changes later. These functions will return
|
|
* with the SB lock held.
|
|
*
|
|
* xive_lock_and_mask() will also set state->guest_priority
|
|
* but won't otherwise change other fields of the state.
|
|
*
|
|
* xive_lock_for_unmask will not actually unmask, this will
|
|
* be done later by xive_finish_unmask() once the targetting
|
|
* has been done, so we don't try to unmask an interrupt
|
|
* that hasn't yet been targetted.
|
|
*/
|
|
if (priority == MASKED)
|
|
xive_lock_and_mask(xive, sb, state);
|
|
else
|
|
xive_lock_for_unmask(sb, state);
|
|
|
|
|
|
/*
|
|
* Then we handle targetting.
|
|
*
|
|
* First calculate a new "actual priority"
|
|
*/
|
|
new_act_prio = state->act_priority;
|
|
if (priority != MASKED)
|
|
new_act_prio = xive_prio_from_guest(priority);
|
|
|
|
pr_devel(" new_act_prio=%x act_server=%x act_prio=%x\n",
|
|
new_act_prio, state->act_server, state->act_priority);
|
|
|
|
/*
|
|
* Then check if we actually need to change anything,
|
|
*
|
|
* The condition for re-targetting the interrupt is that
|
|
* we have a valid new priority (new_act_prio is not 0xff)
|
|
* and either the server or the priority changed.
|
|
*
|
|
* Note: If act_priority was ff and the new priority is
|
|
* also ff, we don't do anything and leave the interrupt
|
|
* untargetted. An attempt of doing an int_on on an
|
|
* untargetted interrupt will fail. If that is a problem
|
|
* we could initialize interrupts with valid default
|
|
*/
|
|
|
|
if (new_act_prio != MASKED &&
|
|
(state->act_server != server ||
|
|
state->act_priority != new_act_prio))
|
|
rc = xive_target_interrupt(kvm, state, server, new_act_prio);
|
|
|
|
/*
|
|
* Perform the final unmasking of the interrupt source
|
|
* if necessary
|
|
*/
|
|
if (priority != MASKED)
|
|
xive_finish_unmask(xive, sb, state, priority);
|
|
|
|
/*
|
|
* Finally Update saved_priority to match. Only int_on/off
|
|
* set this field to a different value.
|
|
*/
|
|
state->saved_priority = priority;
|
|
|
|
arch_spin_unlock(&sb->lock);
|
|
return rc;
|
|
}
|
|
|
|
int kvmppc_xive_get_xive(struct kvm *kvm, u32 irq, u32 *server,
|
|
u32 *priority)
|
|
{
|
|
struct kvmppc_xive *xive = kvm->arch.xive;
|
|
struct kvmppc_xive_src_block *sb;
|
|
struct kvmppc_xive_irq_state *state;
|
|
u16 idx;
|
|
|
|
if (!xive)
|
|
return -ENODEV;
|
|
|
|
sb = kvmppc_xive_find_source(xive, irq, &idx);
|
|
if (!sb)
|
|
return -EINVAL;
|
|
state = &sb->irq_state[idx];
|
|
arch_spin_lock(&sb->lock);
|
|
*server = state->act_server;
|
|
*priority = state->guest_priority;
|
|
arch_spin_unlock(&sb->lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int kvmppc_xive_int_on(struct kvm *kvm, u32 irq)
|
|
{
|
|
struct kvmppc_xive *xive = kvm->arch.xive;
|
|
struct kvmppc_xive_src_block *sb;
|
|
struct kvmppc_xive_irq_state *state;
|
|
u16 idx;
|
|
|
|
if (!xive)
|
|
return -ENODEV;
|
|
|
|
sb = kvmppc_xive_find_source(xive, irq, &idx);
|
|
if (!sb)
|
|
return -EINVAL;
|
|
state = &sb->irq_state[idx];
|
|
|
|
pr_devel("int_on(irq=0x%x)\n", irq);
|
|
|
|
/*
|
|
* Check if interrupt was not targetted
|
|
*/
|
|
if (state->act_priority == MASKED) {
|
|
pr_devel("int_on on untargetted interrupt\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* If saved_priority is 0xff, do nothing */
|
|
if (state->saved_priority == MASKED)
|
|
return 0;
|
|
|
|
/*
|
|
* Lock and unmask it.
|
|
*/
|
|
xive_lock_for_unmask(sb, state);
|
|
xive_finish_unmask(xive, sb, state, state->saved_priority);
|
|
arch_spin_unlock(&sb->lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int kvmppc_xive_int_off(struct kvm *kvm, u32 irq)
|
|
{
|
|
struct kvmppc_xive *xive = kvm->arch.xive;
|
|
struct kvmppc_xive_src_block *sb;
|
|
struct kvmppc_xive_irq_state *state;
|
|
u16 idx;
|
|
|
|
if (!xive)
|
|
return -ENODEV;
|
|
|
|
sb = kvmppc_xive_find_source(xive, irq, &idx);
|
|
if (!sb)
|
|
return -EINVAL;
|
|
state = &sb->irq_state[idx];
|
|
|
|
pr_devel("int_off(irq=0x%x)\n", irq);
|
|
|
|
/*
|
|
* Lock and mask
|
|
*/
|
|
state->saved_priority = xive_lock_and_mask(xive, sb, state);
|
|
arch_spin_unlock(&sb->lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static bool xive_restore_pending_irq(struct kvmppc_xive *xive, u32 irq)
|
|
{
|
|
struct kvmppc_xive_src_block *sb;
|
|
struct kvmppc_xive_irq_state *state;
|
|
u16 idx;
|
|
|
|
sb = kvmppc_xive_find_source(xive, irq, &idx);
|
|
if (!sb)
|
|
return false;
|
|
state = &sb->irq_state[idx];
|
|
if (!state->valid)
|
|
return false;
|
|
|
|
/*
|
|
* Trigger the IPI. This assumes we never restore a pass-through
|
|
* interrupt which should be safe enough
|
|
*/
|
|
xive_irq_trigger(&state->ipi_data);
|
|
|
|
return true;
|
|
}
|
|
|
|
u64 kvmppc_xive_get_icp(struct kvm_vcpu *vcpu)
|
|
{
|
|
struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
|
|
|
|
if (!xc)
|
|
return 0;
|
|
|
|
/* Return the per-cpu state for state saving/migration */
|
|
return (u64)xc->cppr << KVM_REG_PPC_ICP_CPPR_SHIFT |
|
|
(u64)xc->mfrr << KVM_REG_PPC_ICP_MFRR_SHIFT;
|
|
}
|
|
|
|
int kvmppc_xive_set_icp(struct kvm_vcpu *vcpu, u64 icpval)
|
|
{
|
|
struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
|
|
struct kvmppc_xive *xive = vcpu->kvm->arch.xive;
|
|
u8 cppr, mfrr;
|
|
u32 xisr;
|
|
|
|
if (!xc || !xive)
|
|
return -ENOENT;
|
|
|
|
/* Grab individual state fields. We don't use pending_pri */
|
|
cppr = icpval >> KVM_REG_PPC_ICP_CPPR_SHIFT;
|
|
xisr = (icpval >> KVM_REG_PPC_ICP_XISR_SHIFT) &
|
|
KVM_REG_PPC_ICP_XISR_MASK;
|
|
mfrr = icpval >> KVM_REG_PPC_ICP_MFRR_SHIFT;
|
|
|
|
pr_devel("set_icp vcpu %d cppr=0x%x mfrr=0x%x xisr=0x%x\n",
|
|
xc->server_num, cppr, mfrr, xisr);
|
|
|
|
/*
|
|
* We can't update the state of a "pushed" VCPU, but that
|
|
* shouldn't happen.
|
|
*/
|
|
if (WARN_ON(vcpu->arch.xive_pushed))
|
|
return -EIO;
|
|
|
|
/* Update VCPU HW saved state */
|
|
vcpu->arch.xive_saved_state.cppr = cppr;
|
|
xc->hw_cppr = xc->cppr = cppr;
|
|
|
|
/*
|
|
* Update MFRR state. If it's not 0xff, we mark the VCPU as
|
|
* having a pending MFRR change, which will re-evaluate the
|
|
* target. The VCPU will thus potentially get a spurious
|
|
* interrupt but that's not a big deal.
|
|
*/
|
|
xc->mfrr = mfrr;
|
|
if (mfrr < cppr)
|
|
xive_irq_trigger(&xc->vp_ipi_data);
|
|
|
|
/*
|
|
* Now saved XIRR is "interesting". It means there's something in
|
|
* the legacy "1 element" queue... for an IPI we simply ignore it,
|
|
* as the MFRR restore will handle that. For anything else we need
|
|
* to force a resend of the source.
|
|
* However the source may not have been setup yet. If that's the
|
|
* case, we keep that info and increment a counter in the xive to
|
|
* tell subsequent xive_set_source() to go look.
|
|
*/
|
|
if (xisr > XICS_IPI && !xive_restore_pending_irq(xive, xisr)) {
|
|
xc->delayed_irq = xisr;
|
|
xive->delayed_irqs++;
|
|
pr_devel(" xisr restore delayed\n");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int kvmppc_xive_set_mapped(struct kvm *kvm, unsigned long guest_irq,
|
|
struct irq_desc *host_desc)
|
|
{
|
|
struct kvmppc_xive *xive = kvm->arch.xive;
|
|
struct kvmppc_xive_src_block *sb;
|
|
struct kvmppc_xive_irq_state *state;
|
|
struct irq_data *host_data = irq_desc_get_irq_data(host_desc);
|
|
unsigned int host_irq = irq_desc_get_irq(host_desc);
|
|
unsigned int hw_irq = (unsigned int)irqd_to_hwirq(host_data);
|
|
u16 idx;
|
|
u8 prio;
|
|
int rc;
|
|
|
|
if (!xive)
|
|
return -ENODEV;
|
|
|
|
pr_devel("set_mapped girq 0x%lx host HW irq 0x%x...\n",guest_irq, hw_irq);
|
|
|
|
sb = kvmppc_xive_find_source(xive, guest_irq, &idx);
|
|
if (!sb)
|
|
return -EINVAL;
|
|
state = &sb->irq_state[idx];
|
|
|
|
/*
|
|
* Mark the passed-through interrupt as going to a VCPU,
|
|
* this will prevent further EOIs and similar operations
|
|
* from the XIVE code. It will also mask the interrupt
|
|
* to either PQ=10 or 11 state, the latter if the interrupt
|
|
* is pending. This will allow us to unmask or retrigger it
|
|
* after routing it to the guest with a simple EOI.
|
|
*
|
|
* The "state" argument is a "token", all it needs is to be
|
|
* non-NULL to switch to passed-through or NULL for the
|
|
* other way around. We may not yet have an actual VCPU
|
|
* target here and we don't really care.
|
|
*/
|
|
rc = irq_set_vcpu_affinity(host_irq, state);
|
|
if (rc) {
|
|
pr_err("Failed to set VCPU affinity for irq %d\n", host_irq);
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* Mask and read state of IPI. We need to know if its P bit
|
|
* is set as that means it's potentially already using a
|
|
* queue entry in the target
|
|
*/
|
|
prio = xive_lock_and_mask(xive, sb, state);
|
|
pr_devel(" old IPI prio %02x P:%d Q:%d\n", prio,
|
|
state->old_p, state->old_q);
|
|
|
|
/* Turn the IPI hard off */
|
|
xive_vm_esb_load(&state->ipi_data, XIVE_ESB_SET_PQ_01);
|
|
|
|
/* Grab info about irq */
|
|
state->pt_number = hw_irq;
|
|
state->pt_data = irq_data_get_irq_handler_data(host_data);
|
|
|
|
/*
|
|
* Configure the IRQ to match the existing configuration of
|
|
* the IPI if it was already targetted. Otherwise this will
|
|
* mask the interrupt in a lossy way (act_priority is 0xff)
|
|
* which is fine for a never started interrupt.
|
|
*/
|
|
xive_native_configure_irq(hw_irq,
|
|
xive->vp_base + state->act_server,
|
|
state->act_priority, state->number);
|
|
|
|
/*
|
|
* We do an EOI to enable the interrupt (and retrigger if needed)
|
|
* if the guest has the interrupt unmasked and the P bit was *not*
|
|
* set in the IPI. If it was set, we know a slot may still be in
|
|
* use in the target queue thus we have to wait for a guest
|
|
* originated EOI
|
|
*/
|
|
if (prio != MASKED && !state->old_p)
|
|
xive_vm_source_eoi(hw_irq, state->pt_data);
|
|
|
|
/* Clear old_p/old_q as they are no longer relevant */
|
|
state->old_p = state->old_q = false;
|
|
|
|
/* Restore guest prio (unlocks EOI) */
|
|
mb();
|
|
state->guest_priority = prio;
|
|
arch_spin_unlock(&sb->lock);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(kvmppc_xive_set_mapped);
|
|
|
|
int kvmppc_xive_clr_mapped(struct kvm *kvm, unsigned long guest_irq,
|
|
struct irq_desc *host_desc)
|
|
{
|
|
struct kvmppc_xive *xive = kvm->arch.xive;
|
|
struct kvmppc_xive_src_block *sb;
|
|
struct kvmppc_xive_irq_state *state;
|
|
unsigned int host_irq = irq_desc_get_irq(host_desc);
|
|
u16 idx;
|
|
u8 prio;
|
|
int rc;
|
|
|
|
if (!xive)
|
|
return -ENODEV;
|
|
|
|
pr_devel("clr_mapped girq 0x%lx...\n", guest_irq);
|
|
|
|
sb = kvmppc_xive_find_source(xive, guest_irq, &idx);
|
|
if (!sb)
|
|
return -EINVAL;
|
|
state = &sb->irq_state[idx];
|
|
|
|
/*
|
|
* Mask and read state of IRQ. We need to know if its P bit
|
|
* is set as that means it's potentially already using a
|
|
* queue entry in the target
|
|
*/
|
|
prio = xive_lock_and_mask(xive, sb, state);
|
|
pr_devel(" old IRQ prio %02x P:%d Q:%d\n", prio,
|
|
state->old_p, state->old_q);
|
|
|
|
/*
|
|
* If old_p is set, the interrupt is pending, we switch it to
|
|
* PQ=11. This will force a resend in the host so the interrupt
|
|
* isn't lost to whatver host driver may pick it up
|
|
*/
|
|
if (state->old_p)
|
|
xive_vm_esb_load(state->pt_data, XIVE_ESB_SET_PQ_11);
|
|
|
|
/* Release the passed-through interrupt to the host */
|
|
rc = irq_set_vcpu_affinity(host_irq, NULL);
|
|
if (rc) {
|
|
pr_err("Failed to clr VCPU affinity for irq %d\n", host_irq);
|
|
return rc;
|
|
}
|
|
|
|
/* Forget about the IRQ */
|
|
state->pt_number = 0;
|
|
state->pt_data = NULL;
|
|
|
|
/* Reconfigure the IPI */
|
|
xive_native_configure_irq(state->ipi_number,
|
|
xive->vp_base + state->act_server,
|
|
state->act_priority, state->number);
|
|
|
|
/*
|
|
* If old_p is set (we have a queue entry potentially
|
|
* occupied) or the interrupt is masked, we set the IPI
|
|
* to PQ=10 state. Otherwise we just re-enable it (PQ=00).
|
|
*/
|
|
if (prio == MASKED || state->old_p)
|
|
xive_vm_esb_load(&state->ipi_data, XIVE_ESB_SET_PQ_10);
|
|
else
|
|
xive_vm_esb_load(&state->ipi_data, XIVE_ESB_SET_PQ_00);
|
|
|
|
/* Restore guest prio (unlocks EOI) */
|
|
mb();
|
|
state->guest_priority = prio;
|
|
arch_spin_unlock(&sb->lock);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(kvmppc_xive_clr_mapped);
|
|
|
|
static void kvmppc_xive_disable_vcpu_interrupts(struct kvm_vcpu *vcpu)
|
|
{
|
|
struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
|
|
struct kvm *kvm = vcpu->kvm;
|
|
struct kvmppc_xive *xive = kvm->arch.xive;
|
|
int i, j;
|
|
|
|
for (i = 0; i <= xive->max_sbid; i++) {
|
|
struct kvmppc_xive_src_block *sb = xive->src_blocks[i];
|
|
|
|
if (!sb)
|
|
continue;
|
|
for (j = 0; j < KVMPPC_XICS_IRQ_PER_ICS; j++) {
|
|
struct kvmppc_xive_irq_state *state = &sb->irq_state[j];
|
|
|
|
if (!state->valid)
|
|
continue;
|
|
if (state->act_priority == MASKED)
|
|
continue;
|
|
if (state->act_server != xc->server_num)
|
|
continue;
|
|
|
|
/* Clean it up */
|
|
arch_spin_lock(&sb->lock);
|
|
state->act_priority = MASKED;
|
|
xive_vm_esb_load(&state->ipi_data, XIVE_ESB_SET_PQ_01);
|
|
xive_native_configure_irq(state->ipi_number, 0, MASKED, 0);
|
|
if (state->pt_number) {
|
|
xive_vm_esb_load(state->pt_data, XIVE_ESB_SET_PQ_01);
|
|
xive_native_configure_irq(state->pt_number, 0, MASKED, 0);
|
|
}
|
|
arch_spin_unlock(&sb->lock);
|
|
}
|
|
}
|
|
}
|
|
|
|
void kvmppc_xive_cleanup_vcpu(struct kvm_vcpu *vcpu)
|
|
{
|
|
struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
|
|
struct kvmppc_xive *xive = xc->xive;
|
|
int i;
|
|
|
|
pr_devel("cleanup_vcpu(cpu=%d)\n", xc->server_num);
|
|
|
|
/* Ensure no interrupt is still routed to that VP */
|
|
xc->valid = false;
|
|
kvmppc_xive_disable_vcpu_interrupts(vcpu);
|
|
|
|
/* Mask the VP IPI */
|
|
xive_vm_esb_load(&xc->vp_ipi_data, XIVE_ESB_SET_PQ_01);
|
|
|
|
/* Disable the VP */
|
|
xive_native_disable_vp(xc->vp_id);
|
|
|
|
/* Free the queues & associated interrupts */
|
|
for (i = 0; i < KVMPPC_XIVE_Q_COUNT; i++) {
|
|
struct xive_q *q = &xc->queues[i];
|
|
|
|
/* Free the escalation irq */
|
|
if (xc->esc_virq[i]) {
|
|
free_irq(xc->esc_virq[i], vcpu);
|
|
irq_dispose_mapping(xc->esc_virq[i]);
|
|
kfree(xc->esc_virq_names[i]);
|
|
}
|
|
/* Free the queue */
|
|
xive_native_disable_queue(xc->vp_id, q, i);
|
|
if (q->qpage) {
|
|
free_pages((unsigned long)q->qpage,
|
|
xive->q_page_order);
|
|
q->qpage = NULL;
|
|
}
|
|
}
|
|
|
|
/* Free the IPI */
|
|
if (xc->vp_ipi) {
|
|
xive_cleanup_irq_data(&xc->vp_ipi_data);
|
|
xive_native_free_irq(xc->vp_ipi);
|
|
}
|
|
/* Free the VP */
|
|
kfree(xc);
|
|
}
|
|
|
|
int kvmppc_xive_connect_vcpu(struct kvm_device *dev,
|
|
struct kvm_vcpu *vcpu, u32 cpu)
|
|
{
|
|
struct kvmppc_xive *xive = dev->private;
|
|
struct kvmppc_xive_vcpu *xc;
|
|
int i, r = -EBUSY;
|
|
|
|
pr_devel("connect_vcpu(cpu=%d)\n", cpu);
|
|
|
|
if (dev->ops != &kvm_xive_ops) {
|
|
pr_devel("Wrong ops !\n");
|
|
return -EPERM;
|
|
}
|
|
if (xive->kvm != vcpu->kvm)
|
|
return -EPERM;
|
|
if (vcpu->arch.irq_type)
|
|
return -EBUSY;
|
|
if (kvmppc_xive_find_server(vcpu->kvm, cpu)) {
|
|
pr_devel("Duplicate !\n");
|
|
return -EEXIST;
|
|
}
|
|
if (cpu >= KVM_MAX_VCPUS) {
|
|
pr_devel("Out of bounds !\n");
|
|
return -EINVAL;
|
|
}
|
|
xc = kzalloc(sizeof(*xc), GFP_KERNEL);
|
|
if (!xc)
|
|
return -ENOMEM;
|
|
|
|
/* We need to synchronize with queue provisioning */
|
|
mutex_lock(&vcpu->kvm->lock);
|
|
vcpu->arch.xive_vcpu = xc;
|
|
xc->xive = xive;
|
|
xc->vcpu = vcpu;
|
|
xc->server_num = cpu;
|
|
xc->vp_id = xive->vp_base + cpu;
|
|
xc->mfrr = 0xff;
|
|
xc->valid = true;
|
|
|
|
r = xive_native_get_vp_info(xc->vp_id, &xc->vp_cam, &xc->vp_chip_id);
|
|
if (r)
|
|
goto bail;
|
|
|
|
/* Configure VCPU fields for use by assembly push/pull */
|
|
vcpu->arch.xive_saved_state.w01 = cpu_to_be64(0xff000000);
|
|
vcpu->arch.xive_cam_word = cpu_to_be32(xc->vp_cam | TM_QW1W2_VO);
|
|
|
|
/* Allocate IPI */
|
|
xc->vp_ipi = xive_native_alloc_irq();
|
|
if (!xc->vp_ipi) {
|
|
r = -EIO;
|
|
goto bail;
|
|
}
|
|
pr_devel(" IPI=0x%x\n", xc->vp_ipi);
|
|
|
|
r = xive_native_populate_irq_data(xc->vp_ipi, &xc->vp_ipi_data);
|
|
if (r)
|
|
goto bail;
|
|
|
|
/*
|
|
* Initialize queues. Initially we set them all for no queueing
|
|
* and we enable escalation for queue 0 only which we'll use for
|
|
* our mfrr change notifications. If the VCPU is hot-plugged, we
|
|
* do handle provisioning however.
|
|
*/
|
|
for (i = 0; i < KVMPPC_XIVE_Q_COUNT; i++) {
|
|
struct xive_q *q = &xc->queues[i];
|
|
|
|
/* Is queue already enabled ? Provision it */
|
|
if (xive->qmap & (1 << i)) {
|
|
r = xive_provision_queue(vcpu, i);
|
|
if (r == 0)
|
|
xive_attach_escalation(vcpu, i);
|
|
if (r)
|
|
goto bail;
|
|
} else {
|
|
r = xive_native_configure_queue(xc->vp_id,
|
|
q, i, NULL, 0, true);
|
|
if (r) {
|
|
pr_err("Failed to configure queue %d for VCPU %d\n",
|
|
i, cpu);
|
|
goto bail;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* If not done above, attach priority 0 escalation */
|
|
r = xive_attach_escalation(vcpu, 0);
|
|
if (r)
|
|
goto bail;
|
|
|
|
/* Enable the VP */
|
|
r = xive_native_enable_vp(xc->vp_id);
|
|
if (r)
|
|
goto bail;
|
|
|
|
/* Route the IPI */
|
|
r = xive_native_configure_irq(xc->vp_ipi, xc->vp_id, 0, XICS_IPI);
|
|
if (!r)
|
|
xive_vm_esb_load(&xc->vp_ipi_data, XIVE_ESB_SET_PQ_00);
|
|
|
|
bail:
|
|
mutex_unlock(&vcpu->kvm->lock);
|
|
if (r) {
|
|
kvmppc_xive_cleanup_vcpu(vcpu);
|
|
return r;
|
|
}
|
|
|
|
vcpu->arch.irq_type = KVMPPC_IRQ_XICS;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Scanning of queues before/after migration save
|
|
*/
|
|
static void xive_pre_save_set_queued(struct kvmppc_xive *xive, u32 irq)
|
|
{
|
|
struct kvmppc_xive_src_block *sb;
|
|
struct kvmppc_xive_irq_state *state;
|
|
u16 idx;
|
|
|
|
sb = kvmppc_xive_find_source(xive, irq, &idx);
|
|
if (!sb)
|
|
return;
|
|
|
|
state = &sb->irq_state[idx];
|
|
|
|
/* Some sanity checking */
|
|
if (!state->valid) {
|
|
pr_err("invalid irq 0x%x in cpu queue!\n", irq);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* If the interrupt is in a queue it should have P set.
|
|
* We warn so that gets reported. A backtrace isn't useful
|
|
* so no need to use a WARN_ON.
|
|
*/
|
|
if (!state->saved_p)
|
|
pr_err("Interrupt 0x%x is marked in a queue but P not set !\n", irq);
|
|
|
|
/* Set flag */
|
|
state->in_queue = true;
|
|
}
|
|
|
|
static void xive_pre_save_mask_irq(struct kvmppc_xive *xive,
|
|
struct kvmppc_xive_src_block *sb,
|
|
u32 irq)
|
|
{
|
|
struct kvmppc_xive_irq_state *state = &sb->irq_state[irq];
|
|
|
|
if (!state->valid)
|
|
return;
|
|
|
|
/* Mask and save state, this will also sync HW queues */
|
|
state->saved_scan_prio = xive_lock_and_mask(xive, sb, state);
|
|
|
|
/* Transfer P and Q */
|
|
state->saved_p = state->old_p;
|
|
state->saved_q = state->old_q;
|
|
|
|
/* Unlock */
|
|
arch_spin_unlock(&sb->lock);
|
|
}
|
|
|
|
static void xive_pre_save_unmask_irq(struct kvmppc_xive *xive,
|
|
struct kvmppc_xive_src_block *sb,
|
|
u32 irq)
|
|
{
|
|
struct kvmppc_xive_irq_state *state = &sb->irq_state[irq];
|
|
|
|
if (!state->valid)
|
|
return;
|
|
|
|
/*
|
|
* Lock / exclude EOI (not technically necessary if the
|
|
* guest isn't running concurrently. If this becomes a
|
|
* performance issue we can probably remove the lock.
|
|
*/
|
|
xive_lock_for_unmask(sb, state);
|
|
|
|
/* Restore mask/prio if it wasn't masked */
|
|
if (state->saved_scan_prio != MASKED)
|
|
xive_finish_unmask(xive, sb, state, state->saved_scan_prio);
|
|
|
|
/* Unlock */
|
|
arch_spin_unlock(&sb->lock);
|
|
}
|
|
|
|
static void xive_pre_save_queue(struct kvmppc_xive *xive, struct xive_q *q)
|
|
{
|
|
u32 idx = q->idx;
|
|
u32 toggle = q->toggle;
|
|
u32 irq;
|
|
|
|
do {
|
|
irq = __xive_read_eq(q->qpage, q->msk, &idx, &toggle);
|
|
if (irq > XICS_IPI)
|
|
xive_pre_save_set_queued(xive, irq);
|
|
} while(irq);
|
|
}
|
|
|
|
static void xive_pre_save_scan(struct kvmppc_xive *xive)
|
|
{
|
|
struct kvm_vcpu *vcpu = NULL;
|
|
int i, j;
|
|
|
|
/*
|
|
* See comment in xive_get_source() about how this
|
|
* work. Collect a stable state for all interrupts
|
|
*/
|
|
for (i = 0; i <= xive->max_sbid; i++) {
|
|
struct kvmppc_xive_src_block *sb = xive->src_blocks[i];
|
|
if (!sb)
|
|
continue;
|
|
for (j = 0; j < KVMPPC_XICS_IRQ_PER_ICS; j++)
|
|
xive_pre_save_mask_irq(xive, sb, j);
|
|
}
|
|
|
|
/* Then scan the queues and update the "in_queue" flag */
|
|
kvm_for_each_vcpu(i, vcpu, xive->kvm) {
|
|
struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
|
|
if (!xc)
|
|
continue;
|
|
for (j = 0; j < KVMPPC_XIVE_Q_COUNT; j++) {
|
|
if (xc->queues[j].qpage)
|
|
xive_pre_save_queue(xive, &xc->queues[j]);
|
|
}
|
|
}
|
|
|
|
/* Finally restore interrupt states */
|
|
for (i = 0; i <= xive->max_sbid; i++) {
|
|
struct kvmppc_xive_src_block *sb = xive->src_blocks[i];
|
|
if (!sb)
|
|
continue;
|
|
for (j = 0; j < KVMPPC_XICS_IRQ_PER_ICS; j++)
|
|
xive_pre_save_unmask_irq(xive, sb, j);
|
|
}
|
|
}
|
|
|
|
static void xive_post_save_scan(struct kvmppc_xive *xive)
|
|
{
|
|
u32 i, j;
|
|
|
|
/* Clear all the in_queue flags */
|
|
for (i = 0; i <= xive->max_sbid; i++) {
|
|
struct kvmppc_xive_src_block *sb = xive->src_blocks[i];
|
|
if (!sb)
|
|
continue;
|
|
for (j = 0; j < KVMPPC_XICS_IRQ_PER_ICS; j++)
|
|
sb->irq_state[j].in_queue = false;
|
|
}
|
|
|
|
/* Next get_source() will do a new scan */
|
|
xive->saved_src_count = 0;
|
|
}
|
|
|
|
/*
|
|
* This returns the source configuration and state to user space.
|
|
*/
|
|
static int xive_get_source(struct kvmppc_xive *xive, long irq, u64 addr)
|
|
{
|
|
struct kvmppc_xive_src_block *sb;
|
|
struct kvmppc_xive_irq_state *state;
|
|
u64 __user *ubufp = (u64 __user *) addr;
|
|
u64 val, prio;
|
|
u16 idx;
|
|
|
|
sb = kvmppc_xive_find_source(xive, irq, &idx);
|
|
if (!sb)
|
|
return -ENOENT;
|
|
|
|
state = &sb->irq_state[idx];
|
|
|
|
if (!state->valid)
|
|
return -ENOENT;
|
|
|
|
pr_devel("get_source(%ld)...\n", irq);
|
|
|
|
/*
|
|
* So to properly save the state into something that looks like a
|
|
* XICS migration stream we cannot treat interrupts individually.
|
|
*
|
|
* We need, instead, mask them all (& save their previous PQ state)
|
|
* to get a stable state in the HW, then sync them to ensure that
|
|
* any interrupt that had already fired hits its queue, and finally
|
|
* scan all the queues to collect which interrupts are still present
|
|
* in the queues, so we can set the "pending" flag on them and
|
|
* they can be resent on restore.
|
|
*
|
|
* So we do it all when the "first" interrupt gets saved, all the
|
|
* state is collected at that point, the rest of xive_get_source()
|
|
* will merely collect and convert that state to the expected
|
|
* userspace bit mask.
|
|
*/
|
|
if (xive->saved_src_count == 0)
|
|
xive_pre_save_scan(xive);
|
|
xive->saved_src_count++;
|
|
|
|
/* Convert saved state into something compatible with xics */
|
|
val = state->act_server;
|
|
prio = state->saved_scan_prio;
|
|
|
|
if (prio == MASKED) {
|
|
val |= KVM_XICS_MASKED;
|
|
prio = state->saved_priority;
|
|
}
|
|
val |= prio << KVM_XICS_PRIORITY_SHIFT;
|
|
if (state->lsi) {
|
|
val |= KVM_XICS_LEVEL_SENSITIVE;
|
|
if (state->saved_p)
|
|
val |= KVM_XICS_PENDING;
|
|
} else {
|
|
if (state->saved_p)
|
|
val |= KVM_XICS_PRESENTED;
|
|
|
|
if (state->saved_q)
|
|
val |= KVM_XICS_QUEUED;
|
|
|
|
/*
|
|
* We mark it pending (which will attempt a re-delivery)
|
|
* if we are in a queue *or* we were masked and had
|
|
* Q set which is equivalent to the XICS "masked pending"
|
|
* state
|
|
*/
|
|
if (state->in_queue || (prio == MASKED && state->saved_q))
|
|
val |= KVM_XICS_PENDING;
|
|
}
|
|
|
|
/*
|
|
* If that was the last interrupt saved, reset the
|
|
* in_queue flags
|
|
*/
|
|
if (xive->saved_src_count == xive->src_count)
|
|
xive_post_save_scan(xive);
|
|
|
|
/* Copy the result to userspace */
|
|
if (put_user(val, ubufp))
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct kvmppc_xive_src_block *xive_create_src_block(struct kvmppc_xive *xive,
|
|
int irq)
|
|
{
|
|
struct kvm *kvm = xive->kvm;
|
|
struct kvmppc_xive_src_block *sb;
|
|
int i, bid;
|
|
|
|
bid = irq >> KVMPPC_XICS_ICS_SHIFT;
|
|
|
|
mutex_lock(&kvm->lock);
|
|
|
|
/* block already exists - somebody else got here first */
|
|
if (xive->src_blocks[bid])
|
|
goto out;
|
|
|
|
/* Create the ICS */
|
|
sb = kzalloc(sizeof(*sb), GFP_KERNEL);
|
|
if (!sb)
|
|
goto out;
|
|
|
|
sb->id = bid;
|
|
|
|
for (i = 0; i < KVMPPC_XICS_IRQ_PER_ICS; i++) {
|
|
sb->irq_state[i].number = (bid << KVMPPC_XICS_ICS_SHIFT) | i;
|
|
sb->irq_state[i].guest_priority = MASKED;
|
|
sb->irq_state[i].saved_priority = MASKED;
|
|
sb->irq_state[i].act_priority = MASKED;
|
|
}
|
|
smp_wmb();
|
|
xive->src_blocks[bid] = sb;
|
|
|
|
if (bid > xive->max_sbid)
|
|
xive->max_sbid = bid;
|
|
|
|
out:
|
|
mutex_unlock(&kvm->lock);
|
|
return xive->src_blocks[bid];
|
|
}
|
|
|
|
static bool xive_check_delayed_irq(struct kvmppc_xive *xive, u32 irq)
|
|
{
|
|
struct kvm *kvm = xive->kvm;
|
|
struct kvm_vcpu *vcpu = NULL;
|
|
int i;
|
|
|
|
kvm_for_each_vcpu(i, vcpu, kvm) {
|
|
struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
|
|
|
|
if (!xc)
|
|
continue;
|
|
|
|
if (xc->delayed_irq == irq) {
|
|
xc->delayed_irq = 0;
|
|
xive->delayed_irqs--;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static int xive_set_source(struct kvmppc_xive *xive, long irq, u64 addr)
|
|
{
|
|
struct kvmppc_xive_src_block *sb;
|
|
struct kvmppc_xive_irq_state *state;
|
|
u64 __user *ubufp = (u64 __user *) addr;
|
|
u16 idx;
|
|
u64 val;
|
|
u8 act_prio, guest_prio;
|
|
u32 server;
|
|
int rc = 0;
|
|
|
|
if (irq < KVMPPC_XICS_FIRST_IRQ || irq >= KVMPPC_XICS_NR_IRQS)
|
|
return -ENOENT;
|
|
|
|
pr_devel("set_source(irq=0x%lx)\n", irq);
|
|
|
|
/* Find the source */
|
|
sb = kvmppc_xive_find_source(xive, irq, &idx);
|
|
if (!sb) {
|
|
pr_devel("No source, creating source block...\n");
|
|
sb = xive_create_src_block(xive, irq);
|
|
if (!sb) {
|
|
pr_devel("Failed to create block...\n");
|
|
return -ENOMEM;
|
|
}
|
|
}
|
|
state = &sb->irq_state[idx];
|
|
|
|
/* Read user passed data */
|
|
if (get_user(val, ubufp)) {
|
|
pr_devel("fault getting user info !\n");
|
|
return -EFAULT;
|
|
}
|
|
|
|
server = val & KVM_XICS_DESTINATION_MASK;
|
|
guest_prio = val >> KVM_XICS_PRIORITY_SHIFT;
|
|
|
|
pr_devel(" val=0x016%llx (server=0x%x, guest_prio=%d)\n",
|
|
val, server, guest_prio);
|
|
/*
|
|
* If the source doesn't already have an IPI, allocate
|
|
* one and get the corresponding data
|
|
*/
|
|
if (!state->ipi_number) {
|
|
state->ipi_number = xive_native_alloc_irq();
|
|
if (state->ipi_number == 0) {
|
|
pr_devel("Failed to allocate IPI !\n");
|
|
return -ENOMEM;
|
|
}
|
|
xive_native_populate_irq_data(state->ipi_number, &state->ipi_data);
|
|
pr_devel(" src_ipi=0x%x\n", state->ipi_number);
|
|
}
|
|
|
|
/*
|
|
* We use lock_and_mask() to set us in the right masked
|
|
* state. We will override that state from the saved state
|
|
* further down, but this will handle the cases of interrupts
|
|
* that need FW masking. We set the initial guest_priority to
|
|
* 0 before calling it to ensure it actually performs the masking.
|
|
*/
|
|
state->guest_priority = 0;
|
|
xive_lock_and_mask(xive, sb, state);
|
|
|
|
/*
|
|
* Now, we select a target if we have one. If we don't we
|
|
* leave the interrupt untargetted. It means that an interrupt
|
|
* can become "untargetted" accross migration if it was masked
|
|
* by set_xive() but there is little we can do about it.
|
|
*/
|
|
|
|
/* First convert prio and mark interrupt as untargetted */
|
|
act_prio = xive_prio_from_guest(guest_prio);
|
|
state->act_priority = MASKED;
|
|
|
|
/*
|
|
* We need to drop the lock due to the mutex below. Hopefully
|
|
* nothing is touching that interrupt yet since it hasn't been
|
|
* advertized to a running guest yet
|
|
*/
|
|
arch_spin_unlock(&sb->lock);
|
|
|
|
/* If we have a priority target the interrupt */
|
|
if (act_prio != MASKED) {
|
|
/* First, check provisioning of queues */
|
|
mutex_lock(&xive->kvm->lock);
|
|
rc = xive_check_provisioning(xive->kvm, act_prio);
|
|
mutex_unlock(&xive->kvm->lock);
|
|
|
|
/* Target interrupt */
|
|
if (rc == 0)
|
|
rc = xive_target_interrupt(xive->kvm, state,
|
|
server, act_prio);
|
|
/*
|
|
* If provisioning or targetting failed, leave it
|
|
* alone and masked. It will remain disabled until
|
|
* the guest re-targets it.
|
|
*/
|
|
}
|
|
|
|
/*
|
|
* Find out if this was a delayed irq stashed in an ICP,
|
|
* in which case, treat it as pending
|
|
*/
|
|
if (xive->delayed_irqs && xive_check_delayed_irq(xive, irq)) {
|
|
val |= KVM_XICS_PENDING;
|
|
pr_devel(" Found delayed ! forcing PENDING !\n");
|
|
}
|
|
|
|
/* Cleanup the SW state */
|
|
state->old_p = false;
|
|
state->old_q = false;
|
|
state->lsi = false;
|
|
state->asserted = false;
|
|
|
|
/* Restore LSI state */
|
|
if (val & KVM_XICS_LEVEL_SENSITIVE) {
|
|
state->lsi = true;
|
|
if (val & KVM_XICS_PENDING)
|
|
state->asserted = true;
|
|
pr_devel(" LSI ! Asserted=%d\n", state->asserted);
|
|
}
|
|
|
|
/*
|
|
* Restore P and Q. If the interrupt was pending, we
|
|
* force both P and Q, which will trigger a resend.
|
|
*
|
|
* That means that a guest that had both an interrupt
|
|
* pending (queued) and Q set will restore with only
|
|
* one instance of that interrupt instead of 2, but that
|
|
* is perfectly fine as coalescing interrupts that haven't
|
|
* been presented yet is always allowed.
|
|
*/
|
|
if (val & KVM_XICS_PRESENTED || val & KVM_XICS_PENDING)
|
|
state->old_p = true;
|
|
if (val & KVM_XICS_QUEUED || val & KVM_XICS_PENDING)
|
|
state->old_q = true;
|
|
|
|
pr_devel(" P=%d, Q=%d\n", state->old_p, state->old_q);
|
|
|
|
/*
|
|
* If the interrupt was unmasked, update guest priority and
|
|
* perform the appropriate state transition and do a
|
|
* re-trigger if necessary.
|
|
*/
|
|
if (val & KVM_XICS_MASKED) {
|
|
pr_devel(" masked, saving prio\n");
|
|
state->guest_priority = MASKED;
|
|
state->saved_priority = guest_prio;
|
|
} else {
|
|
pr_devel(" unmasked, restoring to prio %d\n", guest_prio);
|
|
xive_finish_unmask(xive, sb, state, guest_prio);
|
|
state->saved_priority = guest_prio;
|
|
}
|
|
|
|
/* Increment the number of valid sources and mark this one valid */
|
|
if (!state->valid)
|
|
xive->src_count++;
|
|
state->valid = true;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int kvmppc_xive_set_irq(struct kvm *kvm, int irq_source_id, u32 irq, int level,
|
|
bool line_status)
|
|
{
|
|
struct kvmppc_xive *xive = kvm->arch.xive;
|
|
struct kvmppc_xive_src_block *sb;
|
|
struct kvmppc_xive_irq_state *state;
|
|
u16 idx;
|
|
|
|
if (!xive)
|
|
return -ENODEV;
|
|
|
|
sb = kvmppc_xive_find_source(xive, irq, &idx);
|
|
if (!sb)
|
|
return -EINVAL;
|
|
|
|
/* Perform locklessly .... (we need to do some RCUisms here...) */
|
|
state = &sb->irq_state[idx];
|
|
if (!state->valid)
|
|
return -EINVAL;
|
|
|
|
/* We don't allow a trigger on a passed-through interrupt */
|
|
if (state->pt_number)
|
|
return -EINVAL;
|
|
|
|
if ((level == 1 && state->lsi) || level == KVM_INTERRUPT_SET_LEVEL)
|
|
state->asserted = 1;
|
|
else if (level == 0 || level == KVM_INTERRUPT_UNSET) {
|
|
state->asserted = 0;
|
|
return 0;
|
|
}
|
|
|
|
/* Trigger the IPI */
|
|
xive_irq_trigger(&state->ipi_data);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int xive_set_attr(struct kvm_device *dev, struct kvm_device_attr *attr)
|
|
{
|
|
struct kvmppc_xive *xive = dev->private;
|
|
|
|
/* We honor the existing XICS ioctl */
|
|
switch (attr->group) {
|
|
case KVM_DEV_XICS_GRP_SOURCES:
|
|
return xive_set_source(xive, attr->attr, attr->addr);
|
|
}
|
|
return -ENXIO;
|
|
}
|
|
|
|
static int xive_get_attr(struct kvm_device *dev, struct kvm_device_attr *attr)
|
|
{
|
|
struct kvmppc_xive *xive = dev->private;
|
|
|
|
/* We honor the existing XICS ioctl */
|
|
switch (attr->group) {
|
|
case KVM_DEV_XICS_GRP_SOURCES:
|
|
return xive_get_source(xive, attr->attr, attr->addr);
|
|
}
|
|
return -ENXIO;
|
|
}
|
|
|
|
static int xive_has_attr(struct kvm_device *dev, struct kvm_device_attr *attr)
|
|
{
|
|
/* We honor the same limits as XICS, at least for now */
|
|
switch (attr->group) {
|
|
case KVM_DEV_XICS_GRP_SOURCES:
|
|
if (attr->attr >= KVMPPC_XICS_FIRST_IRQ &&
|
|
attr->attr < KVMPPC_XICS_NR_IRQS)
|
|
return 0;
|
|
break;
|
|
}
|
|
return -ENXIO;
|
|
}
|
|
|
|
static void kvmppc_xive_cleanup_irq(u32 hw_num, struct xive_irq_data *xd)
|
|
{
|
|
xive_vm_esb_load(xd, XIVE_ESB_SET_PQ_01);
|
|
xive_native_configure_irq(hw_num, 0, MASKED, 0);
|
|
xive_cleanup_irq_data(xd);
|
|
}
|
|
|
|
static void kvmppc_xive_free_sources(struct kvmppc_xive_src_block *sb)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < KVMPPC_XICS_IRQ_PER_ICS; i++) {
|
|
struct kvmppc_xive_irq_state *state = &sb->irq_state[i];
|
|
|
|
if (!state->valid)
|
|
continue;
|
|
|
|
kvmppc_xive_cleanup_irq(state->ipi_number, &state->ipi_data);
|
|
xive_native_free_irq(state->ipi_number);
|
|
|
|
/* Pass-through, cleanup too */
|
|
if (state->pt_number)
|
|
kvmppc_xive_cleanup_irq(state->pt_number, state->pt_data);
|
|
|
|
state->valid = false;
|
|
}
|
|
}
|
|
|
|
static void kvmppc_xive_free(struct kvm_device *dev)
|
|
{
|
|
struct kvmppc_xive *xive = dev->private;
|
|
struct kvm *kvm = xive->kvm;
|
|
int i;
|
|
|
|
debugfs_remove(xive->dentry);
|
|
|
|
if (kvm)
|
|
kvm->arch.xive = NULL;
|
|
|
|
/* Mask and free interrupts */
|
|
for (i = 0; i <= xive->max_sbid; i++) {
|
|
if (xive->src_blocks[i])
|
|
kvmppc_xive_free_sources(xive->src_blocks[i]);
|
|
kfree(xive->src_blocks[i]);
|
|
xive->src_blocks[i] = NULL;
|
|
}
|
|
|
|
if (xive->vp_base != XIVE_INVALID_VP)
|
|
xive_native_free_vp_block(xive->vp_base);
|
|
|
|
|
|
kfree(xive);
|
|
kfree(dev);
|
|
}
|
|
|
|
static int kvmppc_xive_create(struct kvm_device *dev, u32 type)
|
|
{
|
|
struct kvmppc_xive *xive;
|
|
struct kvm *kvm = dev->kvm;
|
|
int ret = 0;
|
|
|
|
pr_devel("Creating xive for partition\n");
|
|
|
|
xive = kzalloc(sizeof(*xive), GFP_KERNEL);
|
|
if (!xive)
|
|
return -ENOMEM;
|
|
|
|
dev->private = xive;
|
|
xive->dev = dev;
|
|
xive->kvm = kvm;
|
|
|
|
/* Already there ? */
|
|
if (kvm->arch.xive)
|
|
ret = -EEXIST;
|
|
else
|
|
kvm->arch.xive = xive;
|
|
|
|
/* We use the default queue size set by the host */
|
|
xive->q_order = xive_native_default_eq_shift();
|
|
if (xive->q_order < PAGE_SHIFT)
|
|
xive->q_page_order = 0;
|
|
else
|
|
xive->q_page_order = xive->q_order - PAGE_SHIFT;
|
|
|
|
/* Allocate a bunch of VPs */
|
|
xive->vp_base = xive_native_alloc_vp_block(KVM_MAX_VCPUS);
|
|
pr_devel("VP_Base=%x\n", xive->vp_base);
|
|
|
|
if (xive->vp_base == XIVE_INVALID_VP)
|
|
ret = -ENOMEM;
|
|
|
|
if (ret) {
|
|
kfree(xive);
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int xive_debug_show(struct seq_file *m, void *private)
|
|
{
|
|
struct kvmppc_xive *xive = m->private;
|
|
struct kvm *kvm = xive->kvm;
|
|
struct kvm_vcpu *vcpu;
|
|
u64 t_rm_h_xirr = 0;
|
|
u64 t_rm_h_ipoll = 0;
|
|
u64 t_rm_h_cppr = 0;
|
|
u64 t_rm_h_eoi = 0;
|
|
u64 t_rm_h_ipi = 0;
|
|
u64 t_vm_h_xirr = 0;
|
|
u64 t_vm_h_ipoll = 0;
|
|
u64 t_vm_h_cppr = 0;
|
|
u64 t_vm_h_eoi = 0;
|
|
u64 t_vm_h_ipi = 0;
|
|
unsigned int i;
|
|
|
|
if (!kvm)
|
|
return 0;
|
|
|
|
seq_printf(m, "=========\nVCPU state\n=========\n");
|
|
|
|
kvm_for_each_vcpu(i, vcpu, kvm) {
|
|
struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
|
|
|
|
if (!xc)
|
|
continue;
|
|
|
|
seq_printf(m, "cpu server %#x CPPR:%#x HWCPPR:%#x"
|
|
" MFRR:%#x PEND:%#x h_xirr: R=%lld V=%lld\n",
|
|
xc->server_num, xc->cppr, xc->hw_cppr,
|
|
xc->mfrr, xc->pending,
|
|
xc->stat_rm_h_xirr, xc->stat_vm_h_xirr);
|
|
|
|
t_rm_h_xirr += xc->stat_rm_h_xirr;
|
|
t_rm_h_ipoll += xc->stat_rm_h_ipoll;
|
|
t_rm_h_cppr += xc->stat_rm_h_cppr;
|
|
t_rm_h_eoi += xc->stat_rm_h_eoi;
|
|
t_rm_h_ipi += xc->stat_rm_h_ipi;
|
|
t_vm_h_xirr += xc->stat_vm_h_xirr;
|
|
t_vm_h_ipoll += xc->stat_vm_h_ipoll;
|
|
t_vm_h_cppr += xc->stat_vm_h_cppr;
|
|
t_vm_h_eoi += xc->stat_vm_h_eoi;
|
|
t_vm_h_ipi += xc->stat_vm_h_ipi;
|
|
}
|
|
|
|
seq_printf(m, "Hcalls totals\n");
|
|
seq_printf(m, " H_XIRR R=%10lld V=%10lld\n", t_rm_h_xirr, t_vm_h_xirr);
|
|
seq_printf(m, " H_IPOLL R=%10lld V=%10lld\n", t_rm_h_ipoll, t_vm_h_ipoll);
|
|
seq_printf(m, " H_CPPR R=%10lld V=%10lld\n", t_rm_h_cppr, t_vm_h_cppr);
|
|
seq_printf(m, " H_EOI R=%10lld V=%10lld\n", t_rm_h_eoi, t_vm_h_eoi);
|
|
seq_printf(m, " H_IPI R=%10lld V=%10lld\n", t_rm_h_ipi, t_vm_h_ipi);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int xive_debug_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, xive_debug_show, inode->i_private);
|
|
}
|
|
|
|
static const struct file_operations xive_debug_fops = {
|
|
.open = xive_debug_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = single_release,
|
|
};
|
|
|
|
static void xive_debugfs_init(struct kvmppc_xive *xive)
|
|
{
|
|
char *name;
|
|
|
|
name = kasprintf(GFP_KERNEL, "kvm-xive-%p", xive);
|
|
if (!name) {
|
|
pr_err("%s: no memory for name\n", __func__);
|
|
return;
|
|
}
|
|
|
|
xive->dentry = debugfs_create_file(name, S_IRUGO, powerpc_debugfs_root,
|
|
xive, &xive_debug_fops);
|
|
|
|
pr_debug("%s: created %s\n", __func__, name);
|
|
kfree(name);
|
|
}
|
|
|
|
static void kvmppc_xive_init(struct kvm_device *dev)
|
|
{
|
|
struct kvmppc_xive *xive = (struct kvmppc_xive *)dev->private;
|
|
|
|
/* Register some debug interfaces */
|
|
xive_debugfs_init(xive);
|
|
}
|
|
|
|
struct kvm_device_ops kvm_xive_ops = {
|
|
.name = "kvm-xive",
|
|
.create = kvmppc_xive_create,
|
|
.init = kvmppc_xive_init,
|
|
.destroy = kvmppc_xive_free,
|
|
.set_attr = xive_set_attr,
|
|
.get_attr = xive_get_attr,
|
|
.has_attr = xive_has_attr,
|
|
};
|
|
|
|
void kvmppc_xive_init_module(void)
|
|
{
|
|
__xive_vm_h_xirr = xive_vm_h_xirr;
|
|
__xive_vm_h_ipoll = xive_vm_h_ipoll;
|
|
__xive_vm_h_ipi = xive_vm_h_ipi;
|
|
__xive_vm_h_cppr = xive_vm_h_cppr;
|
|
__xive_vm_h_eoi = xive_vm_h_eoi;
|
|
}
|
|
|
|
void kvmppc_xive_exit_module(void)
|
|
{
|
|
__xive_vm_h_xirr = NULL;
|
|
__xive_vm_h_ipoll = NULL;
|
|
__xive_vm_h_ipi = NULL;
|
|
__xive_vm_h_cppr = NULL;
|
|
__xive_vm_h_eoi = NULL;
|
|
}
|