1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#include "qemu/osdep.h"
29#include "qapi/error.h"
30#include "qemu-common.h"
31#include "trace.h"
32#include "sysemu/kvm.h"
33#include "hw/ppc/spapr.h"
34#include "hw/ppc/spapr_cpu_core.h"
35#include "hw/ppc/xics.h"
36#include "hw/ppc/xics_spapr.h"
37#include "kvm_ppc.h"
38#include "qemu/config-file.h"
39#include "qemu/error-report.h"
40
41#include <sys/ioctl.h>
42
43static int kernel_xics_fd = -1;
44
45typedef struct KVMEnabledICP {
46 unsigned long vcpu_id;
47 QLIST_ENTRY(KVMEnabledICP) node;
48} KVMEnabledICP;
49
50static QLIST_HEAD(, KVMEnabledICP)
51 kvm_enabled_icps = QLIST_HEAD_INITIALIZER(&kvm_enabled_icps);
52
53static void kvm_disable_icps(void)
54{
55 KVMEnabledICP *enabled_icp, *next;
56
57 QLIST_FOREACH_SAFE(enabled_icp, &kvm_enabled_icps, node, next) {
58 QLIST_REMOVE(enabled_icp, node);
59 g_free(enabled_icp);
60 }
61}
62
63
64
65
66void icp_get_kvm_state(ICPState *icp)
67{
68 uint64_t state;
69 int ret;
70
71
72 if (kernel_xics_fd == -1) {
73 return;
74 }
75
76
77 if (!icp->cs) {
78 return;
79 }
80
81 ret = kvm_get_one_reg(icp->cs, KVM_REG_PPC_ICP_STATE, &state);
82 if (ret != 0) {
83 error_report("Unable to retrieve KVM interrupt controller state"
84 " for CPU %ld: %s", kvm_arch_vcpu_id(icp->cs), strerror(errno));
85 exit(1);
86 }
87
88 icp->xirr = state >> KVM_REG_PPC_ICP_XISR_SHIFT;
89 icp->mfrr = (state >> KVM_REG_PPC_ICP_MFRR_SHIFT)
90 & KVM_REG_PPC_ICP_MFRR_MASK;
91 icp->pending_priority = (state >> KVM_REG_PPC_ICP_PPRI_SHIFT)
92 & KVM_REG_PPC_ICP_PPRI_MASK;
93}
94
95static void do_icp_synchronize_state(CPUState *cpu, run_on_cpu_data arg)
96{
97 icp_get_kvm_state(arg.host_ptr);
98}
99
100void icp_synchronize_state(ICPState *icp)
101{
102 if (icp->cs) {
103 run_on_cpu(icp->cs, do_icp_synchronize_state, RUN_ON_CPU_HOST_PTR(icp));
104 }
105}
106
107int icp_set_kvm_state(ICPState *icp, Error **errp)
108{
109 uint64_t state;
110 int ret;
111
112
113 if (kernel_xics_fd == -1) {
114 return 0;
115 }
116
117
118 if (!icp->cs) {
119 return 0;
120 }
121
122 state = ((uint64_t)icp->xirr << KVM_REG_PPC_ICP_XISR_SHIFT)
123 | ((uint64_t)icp->mfrr << KVM_REG_PPC_ICP_MFRR_SHIFT)
124 | ((uint64_t)icp->pending_priority << KVM_REG_PPC_ICP_PPRI_SHIFT);
125
126 ret = kvm_set_one_reg(icp->cs, KVM_REG_PPC_ICP_STATE, &state);
127 if (ret < 0) {
128 error_setg_errno(errp, -ret,
129 "Unable to restore KVM interrupt controller state (0x%"
130 PRIx64 ") for CPU %ld", state,
131 kvm_arch_vcpu_id(icp->cs));
132 return ret;
133 }
134
135 return 0;
136}
137
138void icp_kvm_realize(DeviceState *dev, Error **errp)
139{
140 ICPState *icp = ICP(dev);
141 CPUState *cs;
142 KVMEnabledICP *enabled_icp;
143 unsigned long vcpu_id;
144 int ret;
145
146
147 if (kernel_xics_fd == -1) {
148 return;
149 }
150
151 cs = icp->cs;
152 vcpu_id = kvm_arch_vcpu_id(cs);
153
154
155
156
157
158
159 QLIST_FOREACH(enabled_icp, &kvm_enabled_icps, node) {
160 if (enabled_icp->vcpu_id == vcpu_id) {
161 return;
162 }
163 }
164
165 ret = kvm_vcpu_enable_cap(cs, KVM_CAP_IRQ_XICS, 0, kernel_xics_fd, vcpu_id);
166 if (ret < 0) {
167 Error *local_err = NULL;
168
169 error_setg(&local_err, "Unable to connect CPU%ld to kernel XICS: %s",
170 vcpu_id, strerror(errno));
171 if (errno == ENOSPC) {
172 error_append_hint(&local_err, "Try -smp maxcpus=N with N < %u\n",
173 MACHINE(qdev_get_machine())->smp.max_cpus);
174 }
175 error_propagate(errp, local_err);
176 return;
177 }
178 enabled_icp = g_malloc(sizeof(*enabled_icp));
179 enabled_icp->vcpu_id = vcpu_id;
180 QLIST_INSERT_HEAD(&kvm_enabled_icps, enabled_icp, node);
181}
182
183
184
185
186void ics_get_kvm_state(ICSState *ics)
187{
188 uint64_t state;
189 int i;
190
191
192 if (kernel_xics_fd == -1) {
193 return;
194 }
195
196 for (i = 0; i < ics->nr_irqs; i++) {
197 ICSIRQState *irq = &ics->irqs[i];
198
199 if (ics_irq_free(ics, i)) {
200 continue;
201 }
202
203 kvm_device_access(kernel_xics_fd, KVM_DEV_XICS_GRP_SOURCES,
204 i + ics->offset, &state, false, &error_fatal);
205
206 irq->server = state & KVM_XICS_DESTINATION_MASK;
207 irq->saved_priority = (state >> KVM_XICS_PRIORITY_SHIFT)
208 & KVM_XICS_PRIORITY_MASK;
209
210
211
212
213
214
215
216
217 if (state & KVM_XICS_MASKED) {
218 irq->priority = 0xff;
219 } else {
220 irq->priority = irq->saved_priority;
221 }
222
223 irq->status = 0;
224 if (state & KVM_XICS_PENDING) {
225 if (state & KVM_XICS_LEVEL_SENSITIVE) {
226 irq->status |= XICS_STATUS_ASSERTED;
227 } else {
228
229
230
231
232
233
234
235 irq->status |= XICS_STATUS_MASKED_PENDING
236 | XICS_STATUS_REJECTED;
237 }
238 }
239 if (state & KVM_XICS_PRESENTED) {
240 irq->status |= XICS_STATUS_PRESENTED;
241 }
242 if (state & KVM_XICS_QUEUED) {
243 irq->status |= XICS_STATUS_QUEUED;
244 }
245 }
246}
247
248void ics_synchronize_state(ICSState *ics)
249{
250 ics_get_kvm_state(ics);
251}
252
253int ics_set_kvm_state_one(ICSState *ics, int srcno, Error **errp)
254{
255 uint64_t state;
256 ICSIRQState *irq = &ics->irqs[srcno];
257 int ret;
258
259
260 if (kernel_xics_fd == -1) {
261 return 0;
262 }
263
264 state = irq->server;
265 state |= (uint64_t)(irq->saved_priority & KVM_XICS_PRIORITY_MASK)
266 << KVM_XICS_PRIORITY_SHIFT;
267 if (irq->priority != irq->saved_priority) {
268 assert(irq->priority == 0xff);
269 }
270
271 if (irq->priority == 0xff) {
272 state |= KVM_XICS_MASKED;
273 }
274
275 if (irq->flags & XICS_FLAGS_IRQ_LSI) {
276 state |= KVM_XICS_LEVEL_SENSITIVE;
277 if (irq->status & XICS_STATUS_ASSERTED) {
278 state |= KVM_XICS_PENDING;
279 }
280 } else {
281 if (irq->status & XICS_STATUS_MASKED_PENDING) {
282 state |= KVM_XICS_PENDING;
283 }
284 }
285 if (irq->status & XICS_STATUS_PRESENTED) {
286 state |= KVM_XICS_PRESENTED;
287 }
288 if (irq->status & XICS_STATUS_QUEUED) {
289 state |= KVM_XICS_QUEUED;
290 }
291
292 ret = kvm_device_access(kernel_xics_fd, KVM_DEV_XICS_GRP_SOURCES,
293 srcno + ics->offset, &state, true, errp);
294 if (ret < 0) {
295 return ret;
296 }
297
298 return 0;
299}
300
301int ics_set_kvm_state(ICSState *ics, Error **errp)
302{
303 int i;
304
305
306 if (kernel_xics_fd == -1) {
307 return 0;
308 }
309
310 for (i = 0; i < ics->nr_irqs; i++) {
311 int ret;
312
313 if (ics_irq_free(ics, i)) {
314 continue;
315 }
316
317 ret = ics_set_kvm_state_one(ics, i, errp);
318 if (ret < 0) {
319 return ret;
320 }
321 }
322
323 return 0;
324}
325
326void ics_kvm_set_irq(ICSState *ics, int srcno, int val)
327{
328 struct kvm_irq_level args;
329 int rc;
330
331
332 assert(kernel_xics_fd != -1);
333
334 args.irq = srcno + ics->offset;
335 if (ics->irqs[srcno].flags & XICS_FLAGS_IRQ_MSI) {
336 if (!val) {
337 return;
338 }
339 args.level = KVM_INTERRUPT_SET;
340 } else {
341 args.level = val ? KVM_INTERRUPT_SET_LEVEL : KVM_INTERRUPT_UNSET;
342 }
343 rc = kvm_vm_ioctl(kvm_state, KVM_IRQ_LINE, &args);
344 if (rc < 0) {
345 perror("kvm_irq_line");
346 }
347}
348
349int xics_kvm_connect(SpaprInterruptController *intc, uint32_t nr_servers,
350 Error **errp)
351{
352 ICSState *ics = ICS_SPAPR(intc);
353 int rc;
354 CPUState *cs;
355 Error *local_err = NULL;
356
357
358
359
360
361 if (kernel_xics_fd != -1) {
362 return 0;
363 }
364
365 if (!kvm_enabled() || !kvm_check_extension(kvm_state, KVM_CAP_IRQ_XICS)) {
366 error_setg(errp,
367 "KVM and IRQ_XICS capability must be present for in-kernel XICS");
368 return -1;
369 }
370
371 rc = kvmppc_define_rtas_kernel_token(RTAS_IBM_SET_XIVE, "ibm,set-xive");
372 if (rc < 0) {
373 error_setg_errno(&local_err, -rc,
374 "kvmppc_define_rtas_kernel_token: ibm,set-xive");
375 goto fail;
376 }
377
378 rc = kvmppc_define_rtas_kernel_token(RTAS_IBM_GET_XIVE, "ibm,get-xive");
379 if (rc < 0) {
380 error_setg_errno(&local_err, -rc,
381 "kvmppc_define_rtas_kernel_token: ibm,get-xive");
382 goto fail;
383 }
384
385 rc = kvmppc_define_rtas_kernel_token(RTAS_IBM_INT_ON, "ibm,int-on");
386 if (rc < 0) {
387 error_setg_errno(&local_err, -rc,
388 "kvmppc_define_rtas_kernel_token: ibm,int-on");
389 goto fail;
390 }
391
392 rc = kvmppc_define_rtas_kernel_token(RTAS_IBM_INT_OFF, "ibm,int-off");
393 if (rc < 0) {
394 error_setg_errno(&local_err, -rc,
395 "kvmppc_define_rtas_kernel_token: ibm,int-off");
396 goto fail;
397 }
398
399
400 rc = kvm_create_device(kvm_state, KVM_DEV_TYPE_XICS, false);
401 if (rc < 0) {
402 error_setg_errno(&local_err, -rc, "Error on KVM_CREATE_DEVICE for XICS");
403 goto fail;
404 }
405
406
407 if (kvm_device_check_attr(rc, KVM_DEV_XICS_GRP_CTRL,
408 KVM_DEV_XICS_NR_SERVERS)) {
409 if (kvm_device_access(rc, KVM_DEV_XICS_GRP_CTRL,
410 KVM_DEV_XICS_NR_SERVERS, &nr_servers, true,
411 &local_err)) {
412 goto fail;
413 }
414 }
415
416 kernel_xics_fd = rc;
417 kvm_kernel_irqchip = true;
418 kvm_msi_via_irqfd_allowed = true;
419 kvm_gsi_direct_mapping = true;
420
421
422 CPU_FOREACH(cs) {
423 PowerPCCPU *cpu = POWERPC_CPU(cs);
424
425 icp_kvm_realize(DEVICE(spapr_cpu_state(cpu)->icp), &local_err);
426 if (local_err) {
427 goto fail;
428 }
429 }
430
431
432 ics_set_kvm_state(ics, &local_err);
433 if (local_err) {
434 goto fail;
435 }
436
437
438 CPU_FOREACH(cs) {
439 PowerPCCPU *cpu = POWERPC_CPU(cs);
440 icp_set_kvm_state(spapr_cpu_state(cpu)->icp, &local_err);
441 if (local_err) {
442 goto fail;
443 }
444 }
445
446 return 0;
447
448fail:
449 error_propagate(errp, local_err);
450 xics_kvm_disconnect(intc);
451 return -1;
452}
453
454void xics_kvm_disconnect(SpaprInterruptController *intc)
455{
456
457
458
459
460
461
462
463 if (kernel_xics_fd != -1) {
464 close(kernel_xics_fd);
465 kernel_xics_fd = -1;
466 }
467
468 kvmppc_define_rtas_kernel_token(0, "ibm,set-xive");
469 kvmppc_define_rtas_kernel_token(0, "ibm,get-xive");
470 kvmppc_define_rtas_kernel_token(0, "ibm,int-on");
471 kvmppc_define_rtas_kernel_token(0, "ibm,int-off");
472
473 kvm_kernel_irqchip = false;
474 kvm_msi_via_irqfd_allowed = false;
475 kvm_gsi_direct_mapping = false;
476
477
478 kvm_disable_icps();
479}
480
481
482
483
484
485
486bool xics_kvm_has_broken_disconnect(void)
487{
488 int rc;
489
490 rc = kvm_create_device(kvm_state, KVM_DEV_TYPE_XICS, false);
491 if (rc < 0) {
492
493
494
495
496
497 return false;
498 }
499
500 close(rc);
501
502 rc = kvm_create_device(kvm_state, KVM_DEV_TYPE_XICS, false);
503 if (rc >= 0) {
504 close(rc);
505 return false;
506 }
507
508 return errno == EEXIST;
509}
510