exec/memory: Use struct Object typedef
[qemu/ar7.git] / hw / intc / xics_kvm.c
blob570d635bcc08596b1cc9cb1ab415c06b2b8af098
1 /*
2  * QEMU PowerPC pSeries Logical Partition (aka sPAPR) hardware System Emulator
3  *
4  * PAPR Virtualized Interrupt System, aka ICS/ICP aka xics, in-kernel emulation
5  *
6  * Copyright (c) 2013 David Gibson, IBM Corporation.
7  *
8  * Permission is hereby granted, free of charge, to any person obtaining a copy
9  * of this software and associated documentation files (the "Software"), to deal
10  * in the Software without restriction, including without limitation the rights
11  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12  * copies of the Software, and to permit persons to whom the Software is
13  * furnished to do so, subject to the following conditions:
14  *
15  * The above copyright notice and this permission notice shall be included in
16  * all copies or substantial portions of the Software.
17  *
18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24  * THE SOFTWARE.
25  *
26  */
28 #include "qemu/osdep.h"
29 #include "qapi/error.h"
30 #include "qemu-common.h"
31 #include "cpu.h"
32 #include "trace.h"
33 #include "sysemu/kvm.h"
34 #include "hw/ppc/spapr.h"
35 #include "hw/ppc/spapr_cpu_core.h"
36 #include "hw/ppc/xics.h"
37 #include "hw/ppc/xics_spapr.h"
38 #include "kvm_ppc.h"
39 #include "qemu/config-file.h"
40 #include "qemu/error-report.h"
42 #include <sys/ioctl.h>
44 static int kernel_xics_fd = -1;
46 typedef struct KVMEnabledICP {
47     unsigned long vcpu_id;
48     QLIST_ENTRY(KVMEnabledICP) node;
49 } KVMEnabledICP;
51 static QLIST_HEAD(, KVMEnabledICP)
52     kvm_enabled_icps = QLIST_HEAD_INITIALIZER(&kvm_enabled_icps);
54 static void kvm_disable_icps(void)
56     KVMEnabledICP *enabled_icp, *next;
58     QLIST_FOREACH_SAFE(enabled_icp, &kvm_enabled_icps, node, next) {
59         QLIST_REMOVE(enabled_icp, node);
60         g_free(enabled_icp);
61     }
65  * ICP-KVM
66  */
67 void icp_get_kvm_state(ICPState *icp)
69     uint64_t state;
70     int ret;
72     /* The KVM XICS device is not in use */
73     if (kernel_xics_fd == -1) {
74         return;
75     }
77     /* ICP for this CPU thread is not in use, exiting */
78     if (!icp->cs) {
79         return;
80     }
82     ret = kvm_get_one_reg(icp->cs, KVM_REG_PPC_ICP_STATE, &state);
83     if (ret != 0) {
84         error_report("Unable to retrieve KVM interrupt controller state"
85                 " for CPU %ld: %s", kvm_arch_vcpu_id(icp->cs), strerror(errno));
86         exit(1);
87     }
89     icp->xirr = state >> KVM_REG_PPC_ICP_XISR_SHIFT;
90     icp->mfrr = (state >> KVM_REG_PPC_ICP_MFRR_SHIFT)
91         & KVM_REG_PPC_ICP_MFRR_MASK;
92     icp->pending_priority = (state >> KVM_REG_PPC_ICP_PPRI_SHIFT)
93         & KVM_REG_PPC_ICP_PPRI_MASK;
96 static void do_icp_synchronize_state(CPUState *cpu, run_on_cpu_data arg)
98     icp_get_kvm_state(arg.host_ptr);
101 void icp_synchronize_state(ICPState *icp)
103     if (icp->cs) {
104         run_on_cpu(icp->cs, do_icp_synchronize_state, RUN_ON_CPU_HOST_PTR(icp));
105     }
108 int icp_set_kvm_state(ICPState *icp, Error **errp)
110     uint64_t state;
111     int ret;
113     /* The KVM XICS device is not in use */
114     if (kernel_xics_fd == -1) {
115         return 0;
116     }
118     /* ICP for this CPU thread is not in use, exiting */
119     if (!icp->cs) {
120         return 0;
121     }
123     state = ((uint64_t)icp->xirr << KVM_REG_PPC_ICP_XISR_SHIFT)
124         | ((uint64_t)icp->mfrr << KVM_REG_PPC_ICP_MFRR_SHIFT)
125         | ((uint64_t)icp->pending_priority << KVM_REG_PPC_ICP_PPRI_SHIFT);
127     ret = kvm_set_one_reg(icp->cs, KVM_REG_PPC_ICP_STATE, &state);
128     if (ret < 0) {
129         error_setg_errno(errp, -ret,
130                          "Unable to restore KVM interrupt controller state (0x%"
131                          PRIx64 ") for CPU %ld", state,
132                          kvm_arch_vcpu_id(icp->cs));
133         return ret;
134     }
136     return 0;
139 void icp_kvm_realize(DeviceState *dev, Error **errp)
141     ICPState *icp = ICP(dev);
142     CPUState *cs;
143     KVMEnabledICP *enabled_icp;
144     unsigned long vcpu_id;
145     int ret;
147     /* The KVM XICS device is not in use */
148     if (kernel_xics_fd == -1) {
149         return;
150     }
152     cs = icp->cs;
153     vcpu_id = kvm_arch_vcpu_id(cs);
155     /*
156      * If we are reusing a parked vCPU fd corresponding to the CPU
157      * which was hot-removed earlier we don't have to renable
158      * KVM_CAP_IRQ_XICS capability again.
159      */
160     QLIST_FOREACH(enabled_icp, &kvm_enabled_icps, node) {
161         if (enabled_icp->vcpu_id == vcpu_id) {
162             return;
163         }
164     }
166     ret = kvm_vcpu_enable_cap(cs, KVM_CAP_IRQ_XICS, 0, kernel_xics_fd, vcpu_id);
167     if (ret < 0) {
168         Error *local_err = NULL;
170         error_setg(&local_err, "Unable to connect CPU%ld to kernel XICS: %s",
171                    vcpu_id, strerror(errno));
172         if (errno == ENOSPC) {
173             error_append_hint(&local_err, "Try -smp maxcpus=N with N < %u\n",
174                               MACHINE(qdev_get_machine())->smp.max_cpus);
175         }
176         error_propagate(errp, local_err);
177         return;
178     }
179     enabled_icp = g_malloc(sizeof(*enabled_icp));
180     enabled_icp->vcpu_id = vcpu_id;
181     QLIST_INSERT_HEAD(&kvm_enabled_icps, enabled_icp, node);
185  * ICS-KVM
186  */
187 void ics_get_kvm_state(ICSState *ics)
189     uint64_t state;
190     int i;
192     /* The KVM XICS device is not in use */
193     if (kernel_xics_fd == -1) {
194         return;
195     }
197     for (i = 0; i < ics->nr_irqs; i++) {
198         ICSIRQState *irq = &ics->irqs[i];
200         if (ics_irq_free(ics, i)) {
201             continue;
202         }
204         kvm_device_access(kernel_xics_fd, KVM_DEV_XICS_GRP_SOURCES,
205                           i + ics->offset, &state, false, &error_fatal);
207         irq->server = state & KVM_XICS_DESTINATION_MASK;
208         irq->saved_priority = (state >> KVM_XICS_PRIORITY_SHIFT)
209             & KVM_XICS_PRIORITY_MASK;
210         /*
211          * To be consistent with the software emulation in xics.c, we
212          * split out the masked state + priority that we get from the
213          * kernel into 'current priority' (0xff if masked) and
214          * 'saved priority' (if masked, this is the priority the
215          * interrupt had before it was masked).  Masking and unmasking
216          * are done with the ibm,int-off and ibm,int-on RTAS calls.
217          */
218         if (state & KVM_XICS_MASKED) {
219             irq->priority = 0xff;
220         } else {
221             irq->priority = irq->saved_priority;
222         }
224         irq->status = 0;
225         if (state & KVM_XICS_PENDING) {
226             if (state & KVM_XICS_LEVEL_SENSITIVE) {
227                 irq->status |= XICS_STATUS_ASSERTED;
228             } else {
229                 /*
230                  * A pending edge-triggered interrupt (or MSI)
231                  * must have been rejected previously when we
232                  * first detected it and tried to deliver it,
233                  * so mark it as pending and previously rejected
234                  * for consistency with how xics.c works.
235                  */
236                 irq->status |= XICS_STATUS_MASKED_PENDING
237                     | XICS_STATUS_REJECTED;
238             }
239         }
240         if (state & KVM_XICS_PRESENTED) {
241                 irq->status |= XICS_STATUS_PRESENTED;
242         }
243         if (state & KVM_XICS_QUEUED) {
244                 irq->status |= XICS_STATUS_QUEUED;
245         }
246     }
249 void ics_synchronize_state(ICSState *ics)
251     ics_get_kvm_state(ics);
254 int ics_set_kvm_state_one(ICSState *ics, int srcno, Error **errp)
256     uint64_t state;
257     ICSIRQState *irq = &ics->irqs[srcno];
258     int ret;
260     /* The KVM XICS device is not in use */
261     if (kernel_xics_fd == -1) {
262         return 0;
263     }
265     state = irq->server;
266     state |= (uint64_t)(irq->saved_priority & KVM_XICS_PRIORITY_MASK)
267         << KVM_XICS_PRIORITY_SHIFT;
268     if (irq->priority != irq->saved_priority) {
269         assert(irq->priority == 0xff);
270     }
272     if (irq->priority == 0xff) {
273         state |= KVM_XICS_MASKED;
274     }
276     if (irq->flags & XICS_FLAGS_IRQ_LSI) {
277         state |= KVM_XICS_LEVEL_SENSITIVE;
278         if (irq->status & XICS_STATUS_ASSERTED) {
279             state |= KVM_XICS_PENDING;
280         }
281     } else {
282         if (irq->status & XICS_STATUS_MASKED_PENDING) {
283             state |= KVM_XICS_PENDING;
284         }
285     }
286     if (irq->status & XICS_STATUS_PRESENTED) {
287         state |= KVM_XICS_PRESENTED;
288     }
289     if (irq->status & XICS_STATUS_QUEUED) {
290         state |= KVM_XICS_QUEUED;
291     }
293     ret = kvm_device_access(kernel_xics_fd, KVM_DEV_XICS_GRP_SOURCES,
294                             srcno + ics->offset, &state, true, errp);
295     if (ret < 0) {
296         return ret;
297     }
299     return 0;
302 int ics_set_kvm_state(ICSState *ics, Error **errp)
304     int i;
306     /* The KVM XICS device is not in use */
307     if (kernel_xics_fd == -1) {
308         return 0;
309     }
311     for (i = 0; i < ics->nr_irqs; i++) {
312         int ret;
314         if (ics_irq_free(ics, i)) {
315             continue;
316         }
318         ret = ics_set_kvm_state_one(ics, i, errp);
319         if (ret < 0) {
320             return ret;
321         }
322     }
324     return 0;
327 void ics_kvm_set_irq(ICSState *ics, int srcno, int val)
329     struct kvm_irq_level args;
330     int rc;
332     /* The KVM XICS device should be in use */
333     assert(kernel_xics_fd != -1);
335     args.irq = srcno + ics->offset;
336     if (ics->irqs[srcno].flags & XICS_FLAGS_IRQ_MSI) {
337         if (!val) {
338             return;
339         }
340         args.level = KVM_INTERRUPT_SET;
341     } else {
342         args.level = val ? KVM_INTERRUPT_SET_LEVEL : KVM_INTERRUPT_UNSET;
343     }
344     rc = kvm_vm_ioctl(kvm_state, KVM_IRQ_LINE, &args);
345     if (rc < 0) {
346         perror("kvm_irq_line");
347     }
350 int xics_kvm_connect(SpaprInterruptController *intc, uint32_t nr_servers,
351                      Error **errp)
353     ICSState *ics = ICS_SPAPR(intc);
354     int rc;
355     CPUState *cs;
356     Error *local_err = NULL;
358     /*
359      * The KVM XICS device already in use. This is the case when
360      * rebooting under the XICS-only interrupt mode.
361      */
362     if (kernel_xics_fd != -1) {
363         return 0;
364     }
366     if (!kvm_enabled() || !kvm_check_extension(kvm_state, KVM_CAP_IRQ_XICS)) {
367         error_setg(errp,
368                    "KVM and IRQ_XICS capability must be present for in-kernel XICS");
369         return -1;
370     }
372     rc = kvmppc_define_rtas_kernel_token(RTAS_IBM_SET_XIVE, "ibm,set-xive");
373     if (rc < 0) {
374         error_setg_errno(&local_err, -rc,
375                          "kvmppc_define_rtas_kernel_token: ibm,set-xive");
376         goto fail;
377     }
379     rc = kvmppc_define_rtas_kernel_token(RTAS_IBM_GET_XIVE, "ibm,get-xive");
380     if (rc < 0) {
381         error_setg_errno(&local_err, -rc,
382                          "kvmppc_define_rtas_kernel_token: ibm,get-xive");
383         goto fail;
384     }
386     rc = kvmppc_define_rtas_kernel_token(RTAS_IBM_INT_ON, "ibm,int-on");
387     if (rc < 0) {
388         error_setg_errno(&local_err, -rc,
389                          "kvmppc_define_rtas_kernel_token: ibm,int-on");
390         goto fail;
391     }
393     rc = kvmppc_define_rtas_kernel_token(RTAS_IBM_INT_OFF, "ibm,int-off");
394     if (rc < 0) {
395         error_setg_errno(&local_err, -rc,
396                          "kvmppc_define_rtas_kernel_token: ibm,int-off");
397         goto fail;
398     }
400     /* Create the KVM XICS device */
401     rc = kvm_create_device(kvm_state, KVM_DEV_TYPE_XICS, false);
402     if (rc < 0) {
403         error_setg_errno(&local_err, -rc, "Error on KVM_CREATE_DEVICE for XICS");
404         goto fail;
405     }
407     /* Tell KVM about the # of VCPUs we may have (POWER9 and newer only) */
408     if (kvm_device_check_attr(rc, KVM_DEV_XICS_GRP_CTRL,
409                               KVM_DEV_XICS_NR_SERVERS)) {
410         if (kvm_device_access(rc, KVM_DEV_XICS_GRP_CTRL,
411                               KVM_DEV_XICS_NR_SERVERS, &nr_servers, true,
412                               &local_err)) {
413             goto fail;
414         }
415     }
417     kernel_xics_fd = rc;
418     kvm_kernel_irqchip = true;
419     kvm_msi_via_irqfd_allowed = true;
420     kvm_gsi_direct_mapping = true;
422     /* Create the presenters */
423     CPU_FOREACH(cs) {
424         PowerPCCPU *cpu = POWERPC_CPU(cs);
426         icp_kvm_realize(DEVICE(spapr_cpu_state(cpu)->icp), &local_err);
427         if (local_err) {
428             goto fail;
429         }
430     }
432     /* Update the KVM sources */
433     ics_set_kvm_state(ics, &local_err);
434     if (local_err) {
435         goto fail;
436     }
438     /* Connect the presenters to the initial VCPUs of the machine */
439     CPU_FOREACH(cs) {
440         PowerPCCPU *cpu = POWERPC_CPU(cs);
441         icp_set_kvm_state(spapr_cpu_state(cpu)->icp, &local_err);
442         if (local_err) {
443             goto fail;
444         }
445     }
447     return 0;
449 fail:
450     error_propagate(errp, local_err);
451     xics_kvm_disconnect(intc);
452     return -1;
455 void xics_kvm_disconnect(SpaprInterruptController *intc)
457     /*
458      * Only on P9 using the XICS-on XIVE KVM device:
459      *
460      * When the KVM device fd is closed, the device is destroyed and
461      * removed from the list of devices of the VM. The VCPU presenters
462      * are also detached from the device.
463      */
464     if (kernel_xics_fd != -1) {
465         close(kernel_xics_fd);
466         kernel_xics_fd = -1;
467     }
469     kvmppc_define_rtas_kernel_token(0, "ibm,set-xive");
470     kvmppc_define_rtas_kernel_token(0, "ibm,get-xive");
471     kvmppc_define_rtas_kernel_token(0, "ibm,int-on");
472     kvmppc_define_rtas_kernel_token(0, "ibm,int-off");
474     kvm_kernel_irqchip = false;
475     kvm_msi_via_irqfd_allowed = false;
476     kvm_gsi_direct_mapping = false;
478     /* Clear the presenter from the VCPUs */
479     kvm_disable_icps();
483  * This is a heuristic to detect older KVMs on POWER9 hosts that don't
484  * support destruction of a KVM XICS device while the VM is running.
485  * Required to start a spapr machine with ic-mode=dual,kernel-irqchip=on.
486  */
487 bool xics_kvm_has_broken_disconnect(void)
489     int rc;
491     rc = kvm_create_device(kvm_state, KVM_DEV_TYPE_XICS, false);
492     if (rc < 0) {
493         /*
494          * The error is ignored on purpose. The KVM XICS setup code
495          * will catch it again anyway. The goal here is to see if
496          * close() actually destroys the device or not.
497          */
498         return false;
499     }
501     close(rc);
503     rc = kvm_create_device(kvm_state, KVM_DEV_TYPE_XICS, false);
504     if (rc >= 0) {
505         close(rc);
506         return false;
507     }
509     return errno == EEXIST;