virt/kvm/irqchip.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * irqchip.c: Common API for in kernel interrupt controllers
0004  * Copyright (c) 2007, Intel Corporation.
0005  * Copyright 2010 Red Hat, Inc. and/or its affiliates.
0006  * Copyright (c) 2013, Alexander Graf <agraf@suse.de>
0007  *
0008  * This file is derived from virt/kvm/irq_comm.c.
0009  *
0010  * Authors:
0011  *   Yaozu (Eddie) Dong <Eddie.dong@intel.com>
0012  *   Alexander Graf <agraf@suse.de>
0013  */
0014
0015 #include <linux/kvm_host.h>
0016 #include <linux/slab.h>
0017 #include <linux/srcu.h>
0018 #include <linux/export.h>
0019 #include <trace/events/kvm.h>
0020 #include "irq.h"
0021
0022 int kvm_irq_map_gsi(struct kvm *kvm,
0023             struct kvm_kernel_irq_routing_entry *entries, int gsi)
0024 {
0025     struct kvm_irq_routing_table *irq_rt;
0026     struct kvm_kernel_irq_routing_entry *e;
0027     int n = 0;
0028
0029     irq_rt = srcu_dereference_check(kvm->irq_routing, &kvm->irq_srcu,
0030                     lockdep_is_held(&kvm->irq_lock));
0031     if (irq_rt && gsi < irq_rt->nr_rt_entries) {
0032         hlist_for_each_entry(e, &irq_rt->map[gsi], link) {
0033             entries[n] = *e;
0034             ++n;
0035         }
0036     }
0037
0038     return n;
0039 }
0040
0041 int kvm_irq_map_chip_pin(struct kvm *kvm, unsigned irqchip, unsigned pin)
0042 {
0043     struct kvm_irq_routing_table *irq_rt;
0044
0045     irq_rt = srcu_dereference(kvm->irq_routing, &kvm->irq_srcu);
0046     return irq_rt->chip[irqchip][pin];
0047 }
0048
0049 int kvm_send_userspace_msi(struct kvm *kvm, struct kvm_msi *msi)
0050 {
0051     struct kvm_kernel_irq_routing_entry route;
0052
0053     if (!irqchip_in_kernel(kvm) || (msi->flags & ~KVM_MSI_VALID_DEVID))
0054         return -EINVAL;
0055
0056     route.msi.address_lo = msi->address_lo;
0057     route.msi.address_hi = msi->address_hi;
0058     route.msi.data = msi->data;
0059     route.msi.flags = msi->flags;
0060     route.msi.devid = msi->devid;
0061
0062     return kvm_set_msi(&route, kvm, KVM_USERSPACE_IRQ_SOURCE_ID, 1, false);
0063 }
0064
0065 /*
0066  * Return value:
0067  *  < 0   Interrupt was ignored (masked or not delivered for other reasons)
0068  *  = 0   Interrupt was coalesced (previous irq is still pending)
0069  *  > 0   Number of CPUs interrupt was delivered to
0070  */
0071 int kvm_set_irq(struct kvm *kvm, int irq_source_id, u32 irq, int level,
0072         bool line_status)
0073 {
0074     struct kvm_kernel_irq_routing_entry irq_set[KVM_NR_IRQCHIPS];
0075     int ret = -1, i, idx;
0076
0077     trace_kvm_set_irq(irq, level, irq_source_id);
0078
0079     /* Not possible to detect if the guest uses the PIC or the
0080      * IOAPIC.  So set the bit in both. The guest will ignore
0081      * writes to the unused one.
0082      */
0083     idx = srcu_read_lock(&kvm->irq_srcu);
0084     i = kvm_irq_map_gsi(kvm, irq_set, irq);
0085     srcu_read_unlock(&kvm->irq_srcu, idx);
0086
0087     while (i--) {
0088         int r;
0089         r = irq_set[i].set(&irq_set[i], kvm, irq_source_id, level,
0090                    line_status);
0091         if (r < 0)
0092             continue;
0093
0094         ret = r + ((ret < 0) ? 0 : ret);
0095     }
0096
0097     return ret;
0098 }
0099
0100 static void free_irq_routing_table(struct kvm_irq_routing_table *rt)
0101 {
0102     int i;
0103
0104     if (!rt)
0105         return;
0106
0107     for (i = 0; i < rt->nr_rt_entries; ++i) {
0108         struct kvm_kernel_irq_routing_entry *e;
0109         struct hlist_node *n;
0110
0111         hlist_for_each_entry_safe(e, n, &rt->map[i], link) {
0112             hlist_del(&e->link);
0113             kfree(e);
0114         }
0115     }
0116
0117     kfree(rt);
0118 }
0119
0120 void kvm_free_irq_routing(struct kvm *kvm)
0121 {
0122     /* Called only during vm destruction. Nobody can use the pointer
0123        at this stage */
0124     struct kvm_irq_routing_table *rt = rcu_access_pointer(kvm->irq_routing);
0125     free_irq_routing_table(rt);
0126 }
0127
0128 static int setup_routing_entry(struct kvm *kvm,
0129                    struct kvm_irq_routing_table *rt,
0130                    struct kvm_kernel_irq_routing_entry *e,
0131                    const struct kvm_irq_routing_entry *ue)
0132 {
0133     struct kvm_kernel_irq_routing_entry *ei;
0134     int r;
0135     u32 gsi = array_index_nospec(ue->gsi, KVM_MAX_IRQ_ROUTES);
0136
0137     /*
0138      * Do not allow GSI to be mapped to the same irqchip more than once.
0139      * Allow only one to one mapping between GSI and non-irqchip routing.
0140      */
0141     hlist_for_each_entry(ei, &rt->map[gsi], link)
0142         if (ei->type != KVM_IRQ_ROUTING_IRQCHIP ||
0143             ue->type != KVM_IRQ_ROUTING_IRQCHIP ||
0144             ue->u.irqchip.irqchip == ei->irqchip.irqchip)
0145             return -EINVAL;
0146
0147     e->gsi = gsi;
0148     e->type = ue->type;
0149     r = kvm_set_routing_entry(kvm, e, ue);
0150     if (r)
0151         return r;
0152     if (e->type == KVM_IRQ_ROUTING_IRQCHIP)
0153         rt->chip[e->irqchip.irqchip][e->irqchip.pin] = e->gsi;
0154
0155     hlist_add_head(&e->link, &rt->map[e->gsi]);
0156
0157     return 0;
0158 }
0159
0160 void __attribute__((weak)) kvm_arch_irq_routing_update(struct kvm *kvm)
0161 {
0162 }
0163
0164 bool __weak kvm_arch_can_set_irq_routing(struct kvm *kvm)
0165 {
0166     return true;
0167 }
0168
0169 int kvm_set_irq_routing(struct kvm *kvm,
0170             const struct kvm_irq_routing_entry *ue,
0171             unsigned nr,
0172             unsigned flags)
0173 {
0174     struct kvm_irq_routing_table *new, *old;
0175     struct kvm_kernel_irq_routing_entry *e;
0176     u32 i, j, nr_rt_entries = 0;
0177     int r;
0178
0179     for (i = 0; i < nr; ++i) {
0180         if (ue[i].gsi >= KVM_MAX_IRQ_ROUTES)
0181             return -EINVAL;
0182         nr_rt_entries = max(nr_rt_entries, ue[i].gsi);
0183     }
0184
0185     nr_rt_entries += 1;
0186
0187     new = kzalloc(struct_size(new, map, nr_rt_entries), GFP_KERNEL_ACCOUNT);
0188     if (!new)
0189         return -ENOMEM;
0190
0191     new->nr_rt_entries = nr_rt_entries;
0192     for (i = 0; i < KVM_NR_IRQCHIPS; i++)
0193         for (j = 0; j < KVM_IRQCHIP_NUM_PINS; j++)
0194             new->chip[i][j] = -1;
0195
0196     for (i = 0; i < nr; ++i) {
0197         r = -ENOMEM;
0198         e = kzalloc(sizeof(*e), GFP_KERNEL_ACCOUNT);
0199         if (!e)
0200             goto out;
0201
0202         r = -EINVAL;
0203         switch (ue->type) {
0204         case KVM_IRQ_ROUTING_MSI:
0205             if (ue->flags & ~KVM_MSI_VALID_DEVID)
0206                 goto free_entry;
0207             break;
0208         default:
0209             if (ue->flags)
0210                 goto free_entry;
0211             break;
0212         }
0213         r = setup_routing_entry(kvm, new, e, ue);
0214         if (r)
0215             goto free_entry;
0216         ++ue;
0217     }
0218
0219     mutex_lock(&kvm->irq_lock);
0220     old = rcu_dereference_protected(kvm->irq_routing, 1);
0221     rcu_assign_pointer(kvm->irq_routing, new);
0222     kvm_irq_routing_update(kvm);
0223     kvm_arch_irq_routing_update(kvm);
0224     mutex_unlock(&kvm->irq_lock);
0225
0226     kvm_arch_post_irq_routing_update(kvm);
0227
0228     synchronize_srcu_expedited(&kvm->irq_srcu);
0229
0230     new = old;
0231     r = 0;
0232     goto out;
0233
0234 free_entry:
0235     kfree(e);
0236 out:
0237     free_irq_routing_table(new);
0238
0239     return r;
0240 }