2 * QEMU PowerPC pSeries Logical Partition (aka sPAPR) hardware System Emulator
4 * PAPR Virtualized Interrupt System, aka ICS/ICP aka xics, in-kernel emulation
6 * Copyright (c) 2013 David Gibson, IBM Corporation.
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:
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
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
28 #include "qemu/osdep.h"
29 #include "qapi/error.h"
30 #include "qemu-common.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"
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
;
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
);
67 void icp_get_kvm_state(ICPState
*icp
)
72 /* The KVM XICS device is not in use */
73 if (kernel_xics_fd
== -1) {
77 /* ICP for this CPU thread is not in use, exiting */
82 ret
= kvm_get_one_reg(icp
->cs
, KVM_REG_PPC_ICP_STATE
, &state
);
84 error_report("Unable to retrieve KVM interrupt controller state"
85 " for CPU %ld: %s", kvm_arch_vcpu_id(icp
->cs
), strerror(errno
));
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
)
104 run_on_cpu(icp
->cs
, do_icp_synchronize_state
, RUN_ON_CPU_HOST_PTR(icp
));
108 int icp_set_kvm_state(ICPState
*icp
, Error
**errp
)
113 /* The KVM XICS device is not in use */
114 if (kernel_xics_fd
== -1) {
118 /* ICP for this CPU thread is not in use, exiting */
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
);
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
));
139 void icp_kvm_realize(DeviceState
*dev
, Error
**errp
)
141 ICPState
*icp
= ICP(dev
);
143 KVMEnabledICP
*enabled_icp
;
144 unsigned long vcpu_id
;
147 /* The KVM XICS device is not in use */
148 if (kernel_xics_fd
== -1) {
153 vcpu_id
= kvm_arch_vcpu_id(cs
);
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.
160 QLIST_FOREACH(enabled_icp
, &kvm_enabled_icps
, node
) {
161 if (enabled_icp
->vcpu_id
== vcpu_id
) {
166 ret
= kvm_vcpu_enable_cap(cs
, KVM_CAP_IRQ_XICS
, 0, kernel_xics_fd
, vcpu_id
);
168 error_setg(errp
, "Unable to connect CPU%ld to kernel XICS: %s", vcpu_id
,
172 enabled_icp
= g_malloc(sizeof(*enabled_icp
));
173 enabled_icp
->vcpu_id
= vcpu_id
;
174 QLIST_INSERT_HEAD(&kvm_enabled_icps
, enabled_icp
, node
);
180 void ics_get_kvm_state(ICSState
*ics
)
185 /* The KVM XICS device is not in use */
186 if (kernel_xics_fd
== -1) {
190 for (i
= 0; i
< ics
->nr_irqs
; i
++) {
191 ICSIRQState
*irq
= &ics
->irqs
[i
];
193 if (ics_irq_free(ics
, i
)) {
197 kvm_device_access(kernel_xics_fd
, KVM_DEV_XICS_GRP_SOURCES
,
198 i
+ ics
->offset
, &state
, false, &error_fatal
);
200 irq
->server
= state
& KVM_XICS_DESTINATION_MASK
;
201 irq
->saved_priority
= (state
>> KVM_XICS_PRIORITY_SHIFT
)
202 & KVM_XICS_PRIORITY_MASK
;
204 * To be consistent with the software emulation in xics.c, we
205 * split out the masked state + priority that we get from the
206 * kernel into 'current priority' (0xff if masked) and
207 * 'saved priority' (if masked, this is the priority the
208 * interrupt had before it was masked). Masking and unmasking
209 * are done with the ibm,int-off and ibm,int-on RTAS calls.
211 if (state
& KVM_XICS_MASKED
) {
212 irq
->priority
= 0xff;
214 irq
->priority
= irq
->saved_priority
;
218 if (state
& KVM_XICS_PENDING
) {
219 if (state
& KVM_XICS_LEVEL_SENSITIVE
) {
220 irq
->status
|= XICS_STATUS_ASSERTED
;
223 * A pending edge-triggered interrupt (or MSI)
224 * must have been rejected previously when we
225 * first detected it and tried to deliver it,
226 * so mark it as pending and previously rejected
227 * for consistency with how xics.c works.
229 irq
->status
|= XICS_STATUS_MASKED_PENDING
230 | XICS_STATUS_REJECTED
;
233 if (state
& KVM_XICS_PRESENTED
) {
234 irq
->status
|= XICS_STATUS_PRESENTED
;
236 if (state
& KVM_XICS_QUEUED
) {
237 irq
->status
|= XICS_STATUS_QUEUED
;
242 void ics_synchronize_state(ICSState
*ics
)
244 ics_get_kvm_state(ics
);
247 int ics_set_kvm_state_one(ICSState
*ics
, int srcno
, Error
**errp
)
250 ICSIRQState
*irq
= &ics
->irqs
[srcno
];
253 /* The KVM XICS device is not in use */
254 if (kernel_xics_fd
== -1) {
259 state
|= (uint64_t)(irq
->saved_priority
& KVM_XICS_PRIORITY_MASK
)
260 << KVM_XICS_PRIORITY_SHIFT
;
261 if (irq
->priority
!= irq
->saved_priority
) {
262 assert(irq
->priority
== 0xff);
265 if (irq
->priority
== 0xff) {
266 state
|= KVM_XICS_MASKED
;
269 if (irq
->flags
& XICS_FLAGS_IRQ_LSI
) {
270 state
|= KVM_XICS_LEVEL_SENSITIVE
;
271 if (irq
->status
& XICS_STATUS_ASSERTED
) {
272 state
|= KVM_XICS_PENDING
;
275 if (irq
->status
& XICS_STATUS_MASKED_PENDING
) {
276 state
|= KVM_XICS_PENDING
;
279 if (irq
->status
& XICS_STATUS_PRESENTED
) {
280 state
|= KVM_XICS_PRESENTED
;
282 if (irq
->status
& XICS_STATUS_QUEUED
) {
283 state
|= KVM_XICS_QUEUED
;
286 ret
= kvm_device_access(kernel_xics_fd
, KVM_DEV_XICS_GRP_SOURCES
,
287 srcno
+ ics
->offset
, &state
, true, errp
);
295 int ics_set_kvm_state(ICSState
*ics
, Error
**errp
)
299 /* The KVM XICS device is not in use */
300 if (kernel_xics_fd
== -1) {
304 for (i
= 0; i
< ics
->nr_irqs
; i
++) {
305 Error
*local_err
= NULL
;
308 if (ics_irq_free(ics
, i
)) {
312 ret
= ics_set_kvm_state_one(ics
, i
, &local_err
);
314 error_propagate(errp
, local_err
);
322 void ics_kvm_set_irq(ICSState
*ics
, int srcno
, int val
)
324 struct kvm_irq_level args
;
327 /* The KVM XICS device should be in use */
328 assert(kernel_xics_fd
!= -1);
330 args
.irq
= srcno
+ ics
->offset
;
331 if (ics
->irqs
[srcno
].flags
& XICS_FLAGS_IRQ_MSI
) {
335 args
.level
= KVM_INTERRUPT_SET
;
337 args
.level
= val
? KVM_INTERRUPT_SET_LEVEL
: KVM_INTERRUPT_UNSET
;
339 rc
= kvm_vm_ioctl(kvm_state
, KVM_IRQ_LINE
, &args
);
341 perror("kvm_irq_line");
345 int xics_kvm_connect(SpaprInterruptController
*intc
, Error
**errp
)
347 ICSState
*ics
= ICS_SPAPR(intc
);
350 Error
*local_err
= NULL
;
353 * The KVM XICS device already in use. This is the case when
354 * rebooting under the XICS-only interrupt mode.
356 if (kernel_xics_fd
!= -1) {
360 if (!kvm_enabled() || !kvm_check_extension(kvm_state
, KVM_CAP_IRQ_XICS
)) {
362 "KVM and IRQ_XICS capability must be present for in-kernel XICS");
366 rc
= kvmppc_define_rtas_kernel_token(RTAS_IBM_SET_XIVE
, "ibm,set-xive");
368 error_setg_errno(&local_err
, -rc
,
369 "kvmppc_define_rtas_kernel_token: ibm,set-xive");
373 rc
= kvmppc_define_rtas_kernel_token(RTAS_IBM_GET_XIVE
, "ibm,get-xive");
375 error_setg_errno(&local_err
, -rc
,
376 "kvmppc_define_rtas_kernel_token: ibm,get-xive");
380 rc
= kvmppc_define_rtas_kernel_token(RTAS_IBM_INT_ON
, "ibm,int-on");
382 error_setg_errno(&local_err
, -rc
,
383 "kvmppc_define_rtas_kernel_token: ibm,int-on");
387 rc
= kvmppc_define_rtas_kernel_token(RTAS_IBM_INT_OFF
, "ibm,int-off");
389 error_setg_errno(&local_err
, -rc
,
390 "kvmppc_define_rtas_kernel_token: ibm,int-off");
394 /* Create the KVM XICS device */
395 rc
= kvm_create_device(kvm_state
, KVM_DEV_TYPE_XICS
, false);
397 error_setg_errno(&local_err
, -rc
, "Error on KVM_CREATE_DEVICE for XICS");
402 kvm_kernel_irqchip
= true;
403 kvm_msi_via_irqfd_allowed
= true;
404 kvm_gsi_direct_mapping
= true;
406 /* Create the presenters */
408 PowerPCCPU
*cpu
= POWERPC_CPU(cs
);
410 icp_kvm_realize(DEVICE(spapr_cpu_state(cpu
)->icp
), &local_err
);
416 /* Update the KVM sources */
417 ics_set_kvm_state(ics
, &local_err
);
422 /* Connect the presenters to the initial VCPUs of the machine */
424 PowerPCCPU
*cpu
= POWERPC_CPU(cs
);
425 icp_set_kvm_state(spapr_cpu_state(cpu
)->icp
, &local_err
);
434 error_propagate(errp
, local_err
);
435 xics_kvm_disconnect(intc
);
439 void xics_kvm_disconnect(SpaprInterruptController
*intc
)
442 * Only on P9 using the XICS-on XIVE KVM device:
444 * When the KVM device fd is closed, the device is destroyed and
445 * removed from the list of devices of the VM. The VCPU presenters
446 * are also detached from the device.
448 if (kernel_xics_fd
!= -1) {
449 close(kernel_xics_fd
);
453 kvmppc_define_rtas_kernel_token(0, "ibm,set-xive");
454 kvmppc_define_rtas_kernel_token(0, "ibm,get-xive");
455 kvmppc_define_rtas_kernel_token(0, "ibm,int-on");
456 kvmppc_define_rtas_kernel_token(0, "ibm,int-off");
458 kvm_kernel_irqchip
= false;
459 kvm_msi_via_irqfd_allowed
= false;
460 kvm_gsi_direct_mapping
= false;
462 /* Clear the presenter from the VCPUs */
467 * This is a heuristic to detect older KVMs on POWER9 hosts that don't
468 * support destruction of a KVM XICS device while the VM is running.
469 * Required to start a spapr machine with ic-mode=dual,kernel-irqchip=on.
471 bool xics_kvm_has_broken_disconnect(SpaprMachineState
*spapr
)
475 rc
= kvm_create_device(kvm_state
, KVM_DEV_TYPE_XICS
, false);
478 * The error is ignored on purpose. The KVM XICS setup code
479 * will catch it again anyway. The goal here is to see if
480 * close() actually destroys the device or not.
487 rc
= kvm_create_device(kvm_state
, KVM_DEV_TYPE_XICS
, false);
493 return errno
== EEXIST
;