irqchip.c File Reference

#include <linux/kvm_host.h>
#include <linux/slab.h>
#include <linux/srcu.h>
#include <linux/export.h>
#include <trace/events/kvm.h>

Include dependency graph for irqchip.c:

Go to the source code of this file.

Functions
int	kvm_irq_map_gsi (struct kvm *kvm, struct kvm_kernel_irq_routing_entry *entries, int gsi)
int	kvm_irq_map_chip_pin (struct kvm *kvm, unsigned irqchip, unsigned pin)
int	kvm_send_userspace_msi (struct kvm *kvm, struct kvm_msi *msi)
int	kvm_set_irq (struct kvm *kvm, int irq_source_id, u32 irq, int level, bool line_status)
static void	free_irq_routing_table (struct kvm_irq_routing_table *rt)
void	kvm_free_irq_routing (struct kvm *kvm)
static int	setup_routing_entry (struct kvm *kvm, struct kvm_irq_routing_table *rt, struct kvm_kernel_irq_routing_entry *e, const struct kvm_irq_routing_entry *ue)
void	__attribute__ ((weak))
bool __weak	kvm_arch_can_set_irq_routing (struct kvm *kvm)
int	kvm_set_irq_routing (struct kvm *kvm, const struct kvm_irq_routing_entry *ue, unsigned nr, unsigned flags)

Function Documentation

__attribute__()

void __attribute__

(

(weak)

)

Definition at line 159 of file irqchip.c.

{
}

free_irq_routing_table()

static void free_irq_routing_table ( struct kvm_irq_routing_table *  rt )

static

Definition at line 99 of file irqchip.c.

{
    int i;
 
    if (!rt)
        return;
 
    for (i = 0; i < rt->nr_rt_entries; ++i) {
        struct kvm_kernel_irq_routing_entry *e;
        struct hlist_node *n;
 
        hlist_for_each_entry_safe(e, n, &rt->map[i], link) {
            hlist_del(&e->link);
            kfree(e);
        }
    }
 
    kfree(rt);
}

Here is the caller graph for this function:

kvm_arch_can_set_irq_routing()

bool __weak kvm_arch_can_set_irq_routing

(

struct kvm *

kvm

)

Definition at line 163 of file irqchip.c.

{
    return true;
}

kvm_free_irq_routing()

void kvm_free_irq_routing

(

struct kvm *

kvm

)

Definition at line 119 of file irqchip.c.

{
    /* Called only during vm destruction. Nobody can use the pointer
       at this stage */
    struct kvm_irq_routing_table *rt = rcu_access_pointer(kvm->irq_routing);
    free_irq_routing_table(rt);
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_irq_map_chip_pin()

int kvm_irq_map_chip_pin	(	struct kvm *	kvm,
		unsigned	irqchip,
		unsigned	pin
	)

Definition at line 40 of file irqchip.c.

{
    struct kvm_irq_routing_table *irq_rt;
 
    irq_rt = srcu_dereference(kvm->irq_routing, &kvm->irq_srcu);
    return irq_rt->chip[irqchip][pin];
}

Here is the caller graph for this function:

kvm_irq_map_gsi()

int kvm_irq_map_gsi	(	struct kvm *	kvm,
		struct kvm_kernel_irq_routing_entry *	entries,
		int	gsi
	)

Definition at line 21 of file irqchip.c.

{
    struct kvm_irq_routing_table *irq_rt;
    struct kvm_kernel_irq_routing_entry *e;
    int n = 0;
 
    irq_rt = srcu_dereference_check(kvm->irq_routing, &kvm->irq_srcu,
                    lockdep_is_held(&kvm->irq_lock));
    if (irq_rt && gsi < irq_rt->nr_rt_entries) {
        hlist_for_each_entry(e, &irq_rt->map[gsi], link) {
            entries[n] = *e;
            ++n;
        }
    }
 
    return n;
}

Here is the caller graph for this function:

kvm_send_userspace_msi()

int kvm_send_userspace_msi	(	struct kvm *	kvm,
		struct kvm_msi *	msi
	)

Definition at line 48 of file irqchip.c.

{
    struct kvm_kernel_irq_routing_entry route;
 
    if (!kvm_arch_irqchip_in_kernel(kvm) || (msi->flags & ~KVM_MSI_VALID_DEVID))
        return -EINVAL;
 
    route.msi.address_lo = msi->address_lo;
    route.msi.address_hi = msi->address_hi;
    route.msi.data = msi->data;
    route.msi.flags = msi->flags;
    route.msi.devid = msi->devid;
 
    return kvm_set_msi(&route, kvm, KVM_USERSPACE_IRQ_SOURCE_ID, 1, false);
}

Here is the call graph for this function:

kvm_set_irq()

int kvm_set_irq	(	struct kvm *	kvm,
		int	irq_source_id,
		u32	irq,
		int	level,
		bool	line_status
	)

Definition at line 70 of file irqchip.c.

{
    struct kvm_kernel_irq_routing_entry irq_set[KVM_NR_IRQCHIPS];
    int ret = -1, i, idx;
 
    trace_kvm_set_irq(irq, level, irq_source_id);
 
    /* Not possible to detect if the guest uses the PIC or the
     * IOAPIC.  So set the bit in both. The guest will ignore
     * writes to the unused one.
     */
    idx = srcu_read_lock(&kvm->irq_srcu);
    i = kvm_irq_map_gsi(kvm, irq_set, irq);
    srcu_read_unlock(&kvm->irq_srcu, idx);
 
    while (i--) {
        int r;
        r = irq_set[i].set(&irq_set[i], kvm, irq_source_id, level,
                   line_status);
        if (r < 0)
            continue;
 
        ret = r + ((ret < 0) ? 0 : ret);
    }
 
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

kvm_set_irq_routing()

int kvm_set_irq_routing	(	struct kvm *	kvm,
		const struct kvm_irq_routing_entry *	ue,
		unsigned	nr,
		unsigned	flags
	)

Definition at line 168 of file irqchip.c.

{
    struct kvm_irq_routing_table *new, *old;
    struct kvm_kernel_irq_routing_entry *e;
    u32 i, j, nr_rt_entries = 0;
    int r;
 
    for (i = 0; i < nr; ++i) {
        if (ue[i].gsi >= KVM_MAX_IRQ_ROUTES)
            return -EINVAL;
        nr_rt_entries = max(nr_rt_entries, ue[i].gsi);
    }
 
    nr_rt_entries += 1;
 
    new = kzalloc(struct_size(new, map, nr_rt_entries), GFP_KERNEL_ACCOUNT);
    if (!new)
        return -ENOMEM;
 
    new->nr_rt_entries = nr_rt_entries;
    for (i = 0; i < KVM_NR_IRQCHIPS; i++)
        for (j = 0; j < KVM_IRQCHIP_NUM_PINS; j++)
            new->chip[i][j] = -1;
 
    for (i = 0; i < nr; ++i) {
        r = -ENOMEM;
        e = kzalloc(sizeof(*e), GFP_KERNEL_ACCOUNT);
        if (!e)
            goto out;
 
        r = -EINVAL;
        switch (ue->type) {
        case KVM_IRQ_ROUTING_MSI:
            if (ue->flags & ~KVM_MSI_VALID_DEVID)
                goto free_entry;
            break;
        default:
            if (ue->flags)
                goto free_entry;
            break;
        }
        r = setup_routing_entry(kvm, new, e, ue);
        if (r)
            goto free_entry;
        ++ue;
    }
 
    mutex_lock(&kvm->irq_lock);
    old = rcu_dereference_protected(kvm->irq_routing, 1);
    rcu_assign_pointer(kvm->irq_routing, new);
    kvm_irq_routing_update(kvm);
    kvm_arch_irq_routing_update(kvm);
    mutex_unlock(&kvm->irq_lock);
 
    kvm_arch_post_irq_routing_update(kvm);
 
    synchronize_srcu_expedited(&kvm->irq_srcu);
 
    new = old;
    r = 0;
    goto out;
 
free_entry:
    kfree(e);
out:
    free_irq_routing_table(new);
 
    return r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

setup_routing_entry()

static int setup_routing_entry ( struct kvm *  kvm, struct kvm_irq_routing_table *  rt, struct kvm_kernel_irq_routing_entry *  e, const struct kvm_irq_routing_entry *  ue  )

static

Definition at line 127 of file irqchip.c.

{
    struct kvm_kernel_irq_routing_entry *ei;
    int r;
    u32 gsi = array_index_nospec(ue->gsi, KVM_MAX_IRQ_ROUTES);
 
    /*
     * Do not allow GSI to be mapped to the same irqchip more than once.
     * Allow only one to one mapping between GSI and non-irqchip routing.
     */
    hlist_for_each_entry(ei, &rt->map[gsi], link)
        if (ei->type != KVM_IRQ_ROUTING_IRQCHIP ||
            ue->type != KVM_IRQ_ROUTING_IRQCHIP ||
            ue->u.irqchip.irqchip == ei->irqchip.irqchip)
            return -EINVAL;
 
    e->gsi = gsi;
    e->type = ue->type;
    r = kvm_set_routing_entry(kvm, e, ue);
    if (r)
        return r;
    if (e->type == KVM_IRQ_ROUTING_IRQCHIP)
        rt->chip[e->irqchip.irqchip][e->irqchip.pin] = e->gsi;
 
    hlist_add_head(&e->link, &rt->map[e->gsi]);
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: