]>
Commit | Line | Data |
---|---|---|
11ad93f6 DG |
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 | */ | |
27 | ||
0d75590d | 28 | #include "qemu/osdep.h" |
da34e65c | 29 | #include "qapi/error.h" |
4771d756 PB |
30 | #include "qemu-common.h" |
31 | #include "cpu.h" | |
11ad93f6 DG |
32 | #include "hw/hw.h" |
33 | #include "trace.h" | |
77ac58dd | 34 | #include "sysemu/kvm.h" |
11ad93f6 | 35 | #include "hw/ppc/spapr.h" |
3f777abc | 36 | #include "hw/ppc/spapr_cpu_core.h" |
11ad93f6 | 37 | #include "hw/ppc/xics.h" |
a51d5afc | 38 | #include "hw/ppc/xics_spapr.h" |
11ad93f6 DG |
39 | #include "kvm_ppc.h" |
40 | #include "qemu/config-file.h" | |
41 | #include "qemu/error-report.h" | |
42 | ||
43 | #include <sys/ioctl.h> | |
44 | ||
729f8a4f CLG |
45 | static int kernel_xics_fd = -1; |
46 | ||
de86eccc GK |
47 | typedef struct KVMEnabledICP { |
48 | unsigned long vcpu_id; | |
49 | QLIST_ENTRY(KVMEnabledICP) node; | |
50 | } KVMEnabledICP; | |
51 | ||
52 | static QLIST_HEAD(, KVMEnabledICP) | |
53 | kvm_enabled_icps = QLIST_HEAD_INITIALIZER(&kvm_enabled_icps); | |
54 | ||
56b11587 CLG |
55 | static void kvm_disable_icps(void) |
56 | { | |
57 | KVMEnabledICP *enabled_icp, *next; | |
58 | ||
59 | QLIST_FOREACH_SAFE(enabled_icp, &kvm_enabled_icps, node, next) { | |
60 | QLIST_REMOVE(enabled_icp, node); | |
61 | g_free(enabled_icp); | |
62 | } | |
63 | } | |
64 | ||
11ad93f6 DG |
65 | /* |
66 | * ICP-KVM | |
67 | */ | |
0e5c7fad | 68 | void icp_get_kvm_state(ICPState *icp) |
11ad93f6 DG |
69 | { |
70 | uint64_t state; | |
11ad93f6 DG |
71 | int ret; |
72 | ||
3bf84e99 CLG |
73 | /* The KVM XICS device is not in use */ |
74 | if (kernel_xics_fd == -1) { | |
75 | return; | |
76 | } | |
77 | ||
11ad93f6 | 78 | /* ICP for this CPU thread is not in use, exiting */ |
8e4fba20 | 79 | if (!icp->cs) { |
11ad93f6 DG |
80 | return; |
81 | } | |
82 | ||
bf358b54 | 83 | ret = kvm_get_one_reg(icp->cs, KVM_REG_PPC_ICP_STATE, &state); |
11ad93f6 DG |
84 | if (ret != 0) { |
85 | error_report("Unable to retrieve KVM interrupt controller state" | |
8e4fba20 | 86 | " for CPU %ld: %s", kvm_arch_vcpu_id(icp->cs), strerror(errno)); |
11ad93f6 DG |
87 | exit(1); |
88 | } | |
89 | ||
8e4fba20 CLG |
90 | icp->xirr = state >> KVM_REG_PPC_ICP_XISR_SHIFT; |
91 | icp->mfrr = (state >> KVM_REG_PPC_ICP_MFRR_SHIFT) | |
11ad93f6 | 92 | & KVM_REG_PPC_ICP_MFRR_MASK; |
8e4fba20 | 93 | icp->pending_priority = (state >> KVM_REG_PPC_ICP_PPRI_SHIFT) |
11ad93f6 DG |
94 | & KVM_REG_PPC_ICP_PPRI_MASK; |
95 | } | |
96 | ||
dcb556fc GK |
97 | static void do_icp_synchronize_state(CPUState *cpu, run_on_cpu_data arg) |
98 | { | |
99 | icp_get_kvm_state(arg.host_ptr); | |
100 | } | |
101 | ||
0e5c7fad | 102 | void icp_synchronize_state(ICPState *icp) |
dcb556fc GK |
103 | { |
104 | if (icp->cs) { | |
105 | run_on_cpu(icp->cs, do_icp_synchronize_state, RUN_ON_CPU_HOST_PTR(icp)); | |
106 | } | |
107 | } | |
108 | ||
330a21e3 | 109 | int icp_set_kvm_state(ICPState *icp, Error **errp) |
11ad93f6 DG |
110 | { |
111 | uint64_t state; | |
11ad93f6 DG |
112 | int ret; |
113 | ||
3bf84e99 CLG |
114 | /* The KVM XICS device is not in use */ |
115 | if (kernel_xics_fd == -1) { | |
116 | return 0; | |
117 | } | |
118 | ||
11ad93f6 | 119 | /* ICP for this CPU thread is not in use, exiting */ |
8e4fba20 | 120 | if (!icp->cs) { |
11ad93f6 DG |
121 | return 0; |
122 | } | |
123 | ||
8e4fba20 CLG |
124 | state = ((uint64_t)icp->xirr << KVM_REG_PPC_ICP_XISR_SHIFT) |
125 | | ((uint64_t)icp->mfrr << KVM_REG_PPC_ICP_MFRR_SHIFT) | |
126 | | ((uint64_t)icp->pending_priority << KVM_REG_PPC_ICP_PPRI_SHIFT); | |
11ad93f6 | 127 | |
bf358b54 | 128 | ret = kvm_set_one_reg(icp->cs, KVM_REG_PPC_ICP_STATE, &state); |
330a21e3 GK |
129 | if (ret < 0) { |
130 | error_setg_errno(errp, -ret, | |
131 | "Unable to restore KVM interrupt controller state (0x%" | |
132 | PRIx64 ") for CPU %ld", state, | |
133 | kvm_arch_vcpu_id(icp->cs)); | |
11ad93f6 DG |
134 | return ret; |
135 | } | |
136 | ||
137 | return 0; | |
138 | } | |
139 | ||
8e6e6efe | 140 | void icp_kvm_realize(DeviceState *dev, Error **errp) |
f0232434 | 141 | { |
a028dd42 | 142 | ICPState *icp = ICP(dev); |
a028dd42 | 143 | CPUState *cs; |
de86eccc | 144 | KVMEnabledICP *enabled_icp; |
a028dd42 | 145 | unsigned long vcpu_id; |
f0232434 CLG |
146 | int ret; |
147 | ||
3bf84e99 | 148 | /* The KVM XICS device is not in use */ |
f0232434 | 149 | if (kernel_xics_fd == -1) { |
3bf84e99 | 150 | return; |
f0232434 CLG |
151 | } |
152 | ||
a028dd42 CLG |
153 | cs = icp->cs; |
154 | vcpu_id = kvm_arch_vcpu_id(cs); | |
155 | ||
f0232434 CLG |
156 | /* |
157 | * If we are reusing a parked vCPU fd corresponding to the CPU | |
158 | * which was hot-removed earlier we don't have to renable | |
159 | * KVM_CAP_IRQ_XICS capability again. | |
160 | */ | |
de86eccc GK |
161 | QLIST_FOREACH(enabled_icp, &kvm_enabled_icps, node) { |
162 | if (enabled_icp->vcpu_id == vcpu_id) { | |
163 | return; | |
164 | } | |
f0232434 CLG |
165 | } |
166 | ||
de86eccc | 167 | ret = kvm_vcpu_enable_cap(cs, KVM_CAP_IRQ_XICS, 0, kernel_xics_fd, vcpu_id); |
f0232434 | 168 | if (ret < 0) { |
b1fd36c3 GK |
169 | error_setg(errp, "Unable to connect CPU%ld to kernel XICS: %s", vcpu_id, |
170 | strerror(errno)); | |
171 | return; | |
f0232434 | 172 | } |
de86eccc GK |
173 | enabled_icp = g_malloc(sizeof(*enabled_icp)); |
174 | enabled_icp->vcpu_id = vcpu_id; | |
175 | QLIST_INSERT_HEAD(&kvm_enabled_icps, enabled_icp, node); | |
f0232434 CLG |
176 | } |
177 | ||
11ad93f6 DG |
178 | /* |
179 | * ICS-KVM | |
180 | */ | |
d80b2ccf | 181 | void ics_get_kvm_state(ICSState *ics) |
11ad93f6 | 182 | { |
11ad93f6 | 183 | uint64_t state; |
11ad93f6 DG |
184 | int i; |
185 | ||
3bf84e99 CLG |
186 | /* The KVM XICS device is not in use */ |
187 | if (kernel_xics_fd == -1) { | |
188 | return; | |
189 | } | |
190 | ||
11ad93f6 DG |
191 | for (i = 0; i < ics->nr_irqs; i++) { |
192 | ICSIRQState *irq = &ics->irqs[i]; | |
11ad93f6 | 193 | |
bf358b54 | 194 | kvm_device_access(kernel_xics_fd, KVM_DEV_XICS_GRP_SOURCES, |
50beeb68 | 195 | i + ics->offset, &state, false, &error_fatal); |
11ad93f6 DG |
196 | |
197 | irq->server = state & KVM_XICS_DESTINATION_MASK; | |
198 | irq->saved_priority = (state >> KVM_XICS_PRIORITY_SHIFT) | |
199 | & KVM_XICS_PRIORITY_MASK; | |
200 | /* | |
201 | * To be consistent with the software emulation in xics.c, we | |
202 | * split out the masked state + priority that we get from the | |
203 | * kernel into 'current priority' (0xff if masked) and | |
204 | * 'saved priority' (if masked, this is the priority the | |
205 | * interrupt had before it was masked). Masking and unmasking | |
206 | * are done with the ibm,int-off and ibm,int-on RTAS calls. | |
207 | */ | |
208 | if (state & KVM_XICS_MASKED) { | |
209 | irq->priority = 0xff; | |
210 | } else { | |
211 | irq->priority = irq->saved_priority; | |
212 | } | |
213 | ||
063cb7cb | 214 | irq->status = 0; |
11ad93f6 DG |
215 | if (state & KVM_XICS_PENDING) { |
216 | if (state & KVM_XICS_LEVEL_SENSITIVE) { | |
217 | irq->status |= XICS_STATUS_ASSERTED; | |
218 | } else { | |
219 | /* | |
220 | * A pending edge-triggered interrupt (or MSI) | |
221 | * must have been rejected previously when we | |
222 | * first detected it and tried to deliver it, | |
223 | * so mark it as pending and previously rejected | |
224 | * for consistency with how xics.c works. | |
225 | */ | |
226 | irq->status |= XICS_STATUS_MASKED_PENDING | |
227 | | XICS_STATUS_REJECTED; | |
228 | } | |
229 | } | |
229e16fd SB |
230 | if (state & KVM_XICS_PRESENTED) { |
231 | irq->status |= XICS_STATUS_PRESENTED; | |
232 | } | |
233 | if (state & KVM_XICS_QUEUED) { | |
234 | irq->status |= XICS_STATUS_QUEUED; | |
235 | } | |
11ad93f6 DG |
236 | } |
237 | } | |
238 | ||
d80b2ccf | 239 | void ics_synchronize_state(ICSState *ics) |
dcb556fc GK |
240 | { |
241 | ics_get_kvm_state(ics); | |
242 | } | |
243 | ||
330a21e3 | 244 | int ics_set_kvm_state_one(ICSState *ics, int srcno, Error **errp) |
11ad93f6 | 245 | { |
11ad93f6 | 246 | uint64_t state; |
6cead90c GK |
247 | ICSIRQState *irq = &ics->irqs[srcno]; |
248 | int ret; | |
11ad93f6 | 249 | |
3bf84e99 CLG |
250 | /* The KVM XICS device is not in use */ |
251 | if (kernel_xics_fd == -1) { | |
252 | return 0; | |
253 | } | |
254 | ||
6cead90c GK |
255 | state = irq->server; |
256 | state |= (uint64_t)(irq->saved_priority & KVM_XICS_PRIORITY_MASK) | |
257 | << KVM_XICS_PRIORITY_SHIFT; | |
258 | if (irq->priority != irq->saved_priority) { | |
259 | assert(irq->priority == 0xff); | |
260 | state |= KVM_XICS_MASKED; | |
261 | } | |
11ad93f6 | 262 | |
6cead90c GK |
263 | if (irq->flags & XICS_FLAGS_IRQ_LSI) { |
264 | state |= KVM_XICS_LEVEL_SENSITIVE; | |
265 | if (irq->status & XICS_STATUS_ASSERTED) { | |
266 | state |= KVM_XICS_PENDING; | |
11ad93f6 | 267 | } |
6cead90c GK |
268 | } else { |
269 | if (irq->status & XICS_STATUS_MASKED_PENDING) { | |
270 | state |= KVM_XICS_PENDING; | |
229e16fd | 271 | } |
6cead90c GK |
272 | } |
273 | if (irq->status & XICS_STATUS_PRESENTED) { | |
274 | state |= KVM_XICS_PRESENTED; | |
275 | } | |
276 | if (irq->status & XICS_STATUS_QUEUED) { | |
277 | state |= KVM_XICS_QUEUED; | |
278 | } | |
279 | ||
280 | ret = kvm_device_access(kernel_xics_fd, KVM_DEV_XICS_GRP_SOURCES, | |
330a21e3 GK |
281 | srcno + ics->offset, &state, true, errp); |
282 | if (ret < 0) { | |
6cead90c GK |
283 | return ret; |
284 | } | |
285 | ||
286 | return 0; | |
287 | } | |
288 | ||
330a21e3 | 289 | int ics_set_kvm_state(ICSState *ics, Error **errp) |
6cead90c GK |
290 | { |
291 | int i; | |
292 | ||
3bf84e99 CLG |
293 | /* The KVM XICS device is not in use */ |
294 | if (kernel_xics_fd == -1) { | |
295 | return 0; | |
296 | } | |
297 | ||
6cead90c | 298 | for (i = 0; i < ics->nr_irqs; i++) { |
330a21e3 | 299 | Error *local_err = NULL; |
6cead90c | 300 | int ret; |
11ad93f6 | 301 | |
330a21e3 GK |
302 | ret = ics_set_kvm_state_one(ics, i, &local_err); |
303 | if (ret < 0) { | |
304 | error_propagate(errp, local_err); | |
11ad93f6 DG |
305 | return ret; |
306 | } | |
307 | } | |
308 | ||
309 | return 0; | |
310 | } | |
311 | ||
557b4567 | 312 | void ics_kvm_set_irq(ICSState *ics, int srcno, int val) |
11ad93f6 | 313 | { |
11ad93f6 DG |
314 | struct kvm_irq_level args; |
315 | int rc; | |
316 | ||
3bf84e99 CLG |
317 | /* The KVM XICS device should be in use */ |
318 | assert(kernel_xics_fd != -1); | |
319 | ||
11ad93f6 | 320 | args.irq = srcno + ics->offset; |
4af88944 | 321 | if (ics->irqs[srcno].flags & XICS_FLAGS_IRQ_MSI) { |
11ad93f6 DG |
322 | if (!val) { |
323 | return; | |
324 | } | |
325 | args.level = KVM_INTERRUPT_SET; | |
326 | } else { | |
327 | args.level = val ? KVM_INTERRUPT_SET_LEVEL : KVM_INTERRUPT_UNSET; | |
328 | } | |
329 | rc = kvm_vm_ioctl(kvm_state, KVM_IRQ_LINE, &args); | |
330 | if (rc < 0) { | |
331 | perror("kvm_irq_line"); | |
332 | } | |
333 | } | |
334 | ||
eab9f191 | 335 | int xics_kvm_connect(SpaprMachineState *spapr, Error **errp) |
11ad93f6 | 336 | { |
817bb6a4 | 337 | int rc; |
3f777abc CLG |
338 | CPUState *cs; |
339 | Error *local_err = NULL; | |
340 | ||
341 | /* | |
342 | * The KVM XICS device already in use. This is the case when | |
343 | * rebooting under the XICS-only interrupt mode. | |
344 | */ | |
345 | if (kernel_xics_fd != -1) { | |
346 | return 0; | |
347 | } | |
11ad93f6 DG |
348 | |
349 | if (!kvm_enabled() || !kvm_check_extension(kvm_state, KVM_CAP_IRQ_XICS)) { | |
350 | error_setg(errp, | |
351 | "KVM and IRQ_XICS capability must be present for in-kernel XICS"); | |
64fb9621 | 352 | return -1; |
11ad93f6 DG |
353 | } |
354 | ||
3a3b8502 | 355 | rc = kvmppc_define_rtas_kernel_token(RTAS_IBM_SET_XIVE, "ibm,set-xive"); |
11ad93f6 | 356 | if (rc < 0) { |
ab3d15fa GK |
357 | error_setg_errno(&local_err, -rc, |
358 | "kvmppc_define_rtas_kernel_token: ibm,set-xive"); | |
11ad93f6 DG |
359 | goto fail; |
360 | } | |
361 | ||
3a3b8502 | 362 | rc = kvmppc_define_rtas_kernel_token(RTAS_IBM_GET_XIVE, "ibm,get-xive"); |
11ad93f6 | 363 | if (rc < 0) { |
ab3d15fa GK |
364 | error_setg_errno(&local_err, -rc, |
365 | "kvmppc_define_rtas_kernel_token: ibm,get-xive"); | |
11ad93f6 DG |
366 | goto fail; |
367 | } | |
368 | ||
3a3b8502 | 369 | rc = kvmppc_define_rtas_kernel_token(RTAS_IBM_INT_ON, "ibm,int-on"); |
11ad93f6 | 370 | if (rc < 0) { |
ab3d15fa GK |
371 | error_setg_errno(&local_err, -rc, |
372 | "kvmppc_define_rtas_kernel_token: ibm,int-on"); | |
11ad93f6 DG |
373 | goto fail; |
374 | } | |
375 | ||
3a3b8502 | 376 | rc = kvmppc_define_rtas_kernel_token(RTAS_IBM_INT_OFF, "ibm,int-off"); |
11ad93f6 | 377 | if (rc < 0) { |
ab3d15fa GK |
378 | error_setg_errno(&local_err, -rc, |
379 | "kvmppc_define_rtas_kernel_token: ibm,int-off"); | |
11ad93f6 DG |
380 | goto fail; |
381 | } | |
382 | ||
bf358b54 CLG |
383 | /* Create the KVM XICS device */ |
384 | rc = kvm_create_device(kvm_state, KVM_DEV_TYPE_XICS, false); | |
11ad93f6 | 385 | if (rc < 0) { |
ab3d15fa | 386 | error_setg_errno(&local_err, -rc, "Error on KVM_CREATE_DEVICE for XICS"); |
11ad93f6 DG |
387 | goto fail; |
388 | } | |
389 | ||
bf358b54 | 390 | kernel_xics_fd = rc; |
9554233c | 391 | kvm_kernel_irqchip = true; |
9554233c AK |
392 | kvm_msi_via_irqfd_allowed = true; |
393 | kvm_gsi_direct_mapping = true; | |
394 | ||
3f777abc CLG |
395 | /* Create the presenters */ |
396 | CPU_FOREACH(cs) { | |
397 | PowerPCCPU *cpu = POWERPC_CPU(cs); | |
398 | ||
399 | icp_kvm_realize(DEVICE(spapr_cpu_state(cpu)->icp), &local_err); | |
400 | if (local_err) { | |
3f777abc CLG |
401 | goto fail; |
402 | } | |
403 | } | |
404 | ||
405 | /* Update the KVM sources */ | |
330a21e3 GK |
406 | ics_set_kvm_state(spapr->ics, &local_err); |
407 | if (local_err) { | |
408 | goto fail; | |
409 | } | |
3f777abc CLG |
410 | |
411 | /* Connect the presenters to the initial VCPUs of the machine */ | |
412 | CPU_FOREACH(cs) { | |
413 | PowerPCCPU *cpu = POWERPC_CPU(cs); | |
330a21e3 GK |
414 | icp_set_kvm_state(spapr_cpu_state(cpu)->icp, &local_err); |
415 | if (local_err) { | |
416 | goto fail; | |
417 | } | |
3f777abc CLG |
418 | } |
419 | ||
bf358b54 | 420 | return 0; |
11ad93f6 DG |
421 | |
422 | fail: | |
ab3d15fa | 423 | error_propagate(errp, local_err); |
4812f261 | 424 | xics_kvm_disconnect(spapr, NULL); |
2192a930 | 425 | return -1; |
11ad93f6 | 426 | } |
56b11587 CLG |
427 | |
428 | void xics_kvm_disconnect(SpaprMachineState *spapr, Error **errp) | |
429 | { | |
430 | /* The KVM XICS device is not in use */ | |
431 | if (kernel_xics_fd == -1) { | |
432 | return; | |
433 | } | |
434 | ||
435 | if (!kvm_enabled() || !kvm_check_extension(kvm_state, KVM_CAP_IRQ_XICS)) { | |
436 | error_setg(errp, | |
437 | "KVM and IRQ_XICS capability must be present for KVM XICS device"); | |
438 | return; | |
439 | } | |
440 | ||
441 | /* | |
442 | * Only on P9 using the XICS-on XIVE KVM device: | |
443 | * | |
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. | |
447 | */ | |
4812f261 GK |
448 | if (kernel_xics_fd != -1) { |
449 | close(kernel_xics_fd); | |
450 | kernel_xics_fd = -1; | |
451 | } | |
56b11587 | 452 | |
56b11587 CLG |
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"); | |
457 | ||
458 | kvm_kernel_irqchip = false; | |
459 | kvm_msi_via_irqfd_allowed = false; | |
460 | kvm_gsi_direct_mapping = false; | |
461 | ||
462 | /* Clear the presenter from the VCPUs */ | |
463 | kvm_disable_icps(); | |
464 | } | |
7abc0c6d GK |
465 | |
466 | /* | |
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. | |
470 | */ | |
471 | bool xics_kvm_has_broken_disconnect(SpaprMachineState *spapr) | |
472 | { | |
473 | int rc; | |
474 | ||
475 | rc = kvm_create_device(kvm_state, KVM_DEV_TYPE_XICS, false); | |
476 | if (rc < 0) { | |
477 | /* | |
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. | |
481 | */ | |
482 | return false; | |
483 | } | |
484 | ||
485 | close(rc); | |
486 | ||
487 | rc = kvm_create_device(kvm_state, KVM_DEV_TYPE_XICS, false); | |
488 | if (rc >= 0) { | |
489 | close(rc); | |
490 | return false; | |
491 | } | |
492 | ||
493 | return errno == EEXIST; | |
494 | } |