]>
Commit | Line | Data |
---|---|---|
90977732 EA |
1 | /* |
2 | * Copyright (C) 2015, 2016 ARM Ltd. | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify | |
5 | * it under the terms of the GNU General Public License version 2 as | |
6 | * published by the Free Software Foundation. | |
7 | * | |
8 | * This program is distributed in the hope that it will be useful, | |
9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
11 | * GNU General Public License for more details. | |
12 | * | |
13 | * You should have received a copy of the GNU General Public License | |
14 | * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
15 | */ | |
16 | ||
17 | #include <linux/uaccess.h> | |
18 | #include <linux/interrupt.h> | |
19 | #include <linux/cpu.h> | |
20 | #include <linux/kvm_host.h> | |
21 | #include <kvm/arm_vgic.h> | |
22 | #include <asm/kvm_mmu.h> | |
23 | #include "vgic.h" | |
24 | ||
ad275b8b EA |
25 | /* |
26 | * Initialization rules: there are multiple stages to the vgic | |
966e0149 CD |
27 | * initialization, both for the distributor and the CPU interfaces. The basic |
28 | * idea is that even though the VGIC is not functional or not requested from | |
29 | * user space, the critical path of the run loop can still call VGIC functions | |
30 | * that just won't do anything, without them having to check additional | |
31 | * initialization flags to ensure they don't look at uninitialized data | |
32 | * structures. | |
ad275b8b EA |
33 | * |
34 | * Distributor: | |
35 | * | |
36 | * - kvm_vgic_early_init(): initialization of static data that doesn't | |
37 | * depend on any sizing information or emulation type. No allocation | |
38 | * is allowed there. | |
39 | * | |
40 | * - vgic_init(): allocation and initialization of the generic data | |
41 | * structures that depend on sizing information (number of CPUs, | |
42 | * number of interrupts). Also initializes the vcpu specific data | |
43 | * structures. Can be executed lazily for GICv2. | |
44 | * | |
45 | * CPU Interface: | |
46 | * | |
966e0149 | 47 | * - kvm_vgic_vcpu_early_init(): initialization of static data that |
ad275b8b EA |
48 | * doesn't depend on any sizing information or emulation type. No |
49 | * allocation is allowed there. | |
50 | */ | |
51 | ||
52 | /* EARLY INIT */ | |
53 | ||
966e0149 CD |
54 | /** |
55 | * kvm_vgic_early_init() - Initialize static VGIC VCPU data structures | |
56 | * @kvm: The VM whose VGIC districutor should be initialized | |
57 | * | |
58 | * Only do initialization of static structures that don't require any | |
59 | * allocation or sizing information from userspace. vgic_init() called | |
60 | * kvm_vgic_dist_init() which takes care of the rest. | |
ad275b8b EA |
61 | */ |
62 | void kvm_vgic_early_init(struct kvm *kvm) | |
63 | { | |
966e0149 CD |
64 | struct vgic_dist *dist = &kvm->arch.vgic; |
65 | ||
66 | INIT_LIST_HEAD(&dist->lpi_list_head); | |
67 | spin_lock_init(&dist->lpi_list_lock); | |
ad275b8b EA |
68 | } |
69 | ||
966e0149 CD |
70 | /** |
71 | * kvm_vgic_vcpu_early_init() - Initialize static VGIC VCPU data structures | |
72 | * @vcpu: The VCPU whose VGIC data structures whould be initialized | |
73 | * | |
74 | * Only do initialization, but do not actually enable the VGIC CPU interface | |
75 | * yet. | |
76 | */ | |
ad275b8b EA |
77 | void kvm_vgic_vcpu_early_init(struct kvm_vcpu *vcpu) |
78 | { | |
966e0149 CD |
79 | struct vgic_cpu *vgic_cpu = &vcpu->arch.vgic_cpu; |
80 | int i; | |
81 | ||
82 | INIT_LIST_HEAD(&vgic_cpu->ap_list_head); | |
83 | spin_lock_init(&vgic_cpu->ap_list_lock); | |
84 | ||
85 | /* | |
86 | * Enable and configure all SGIs to be edge-triggered and | |
87 | * configure all PPIs as level-triggered. | |
88 | */ | |
89 | for (i = 0; i < VGIC_NR_PRIVATE_IRQS; i++) { | |
90 | struct vgic_irq *irq = &vgic_cpu->private_irqs[i]; | |
91 | ||
92 | INIT_LIST_HEAD(&irq->ap_list); | |
93 | spin_lock_init(&irq->irq_lock); | |
94 | irq->intid = i; | |
95 | irq->vcpu = NULL; | |
96 | irq->target_vcpu = vcpu; | |
97 | irq->targets = 1U << vcpu->vcpu_id; | |
98 | kref_init(&irq->refcount); | |
99 | if (vgic_irq_is_sgi(i)) { | |
100 | /* SGIs */ | |
101 | irq->enabled = 1; | |
102 | irq->config = VGIC_CONFIG_EDGE; | |
103 | } else { | |
104 | /* PPIs */ | |
105 | irq->config = VGIC_CONFIG_LEVEL; | |
106 | } | |
107 | } | |
ad275b8b EA |
108 | } |
109 | ||
5e6431da EA |
110 | /* CREATION */ |
111 | ||
112 | /** | |
113 | * kvm_vgic_create: triggered by the instantiation of the VGIC device by | |
114 | * user space, either through the legacy KVM_CREATE_IRQCHIP ioctl (v2 only) | |
115 | * or through the generic KVM_CREATE_DEVICE API ioctl. | |
116 | * irqchip_in_kernel() tells you if this function succeeded or not. | |
ad275b8b EA |
117 | * @kvm: kvm struct pointer |
118 | * @type: KVM_DEV_TYPE_ARM_VGIC_V[23] | |
5e6431da EA |
119 | */ |
120 | int kvm_vgic_create(struct kvm *kvm, u32 type) | |
121 | { | |
122 | int i, vcpu_lock_idx = -1, ret; | |
123 | struct kvm_vcpu *vcpu; | |
124 | ||
a28ebea2 CD |
125 | if (irqchip_in_kernel(kvm)) |
126 | return -EEXIST; | |
5e6431da EA |
127 | |
128 | /* | |
129 | * This function is also called by the KVM_CREATE_IRQCHIP handler, | |
130 | * which had no chance yet to check the availability of the GICv2 | |
131 | * emulation. So check this here again. KVM_CREATE_DEVICE does | |
132 | * the proper checks already. | |
133 | */ | |
134 | if (type == KVM_DEV_TYPE_ARM_VGIC_V2 && | |
a28ebea2 CD |
135 | !kvm_vgic_global_state.can_emulate_gicv2) |
136 | return -ENODEV; | |
5e6431da EA |
137 | |
138 | /* | |
139 | * Any time a vcpu is run, vcpu_load is called which tries to grab the | |
140 | * vcpu->mutex. By grabbing the vcpu->mutex of all VCPUs we ensure | |
141 | * that no other VCPUs are run while we create the vgic. | |
142 | */ | |
143 | ret = -EBUSY; | |
144 | kvm_for_each_vcpu(i, vcpu, kvm) { | |
145 | if (!mutex_trylock(&vcpu->mutex)) | |
146 | goto out_unlock; | |
147 | vcpu_lock_idx = i; | |
148 | } | |
149 | ||
150 | kvm_for_each_vcpu(i, vcpu, kvm) { | |
151 | if (vcpu->arch.has_run_once) | |
152 | goto out_unlock; | |
153 | } | |
154 | ret = 0; | |
155 | ||
156 | if (type == KVM_DEV_TYPE_ARM_VGIC_V2) | |
157 | kvm->arch.max_vcpus = VGIC_V2_MAX_CPUS; | |
158 | else | |
159 | kvm->arch.max_vcpus = VGIC_V3_MAX_CPUS; | |
160 | ||
161 | if (atomic_read(&kvm->online_vcpus) > kvm->arch.max_vcpus) { | |
162 | ret = -E2BIG; | |
163 | goto out_unlock; | |
164 | } | |
165 | ||
166 | kvm->arch.vgic.in_kernel = true; | |
167 | kvm->arch.vgic.vgic_model = type; | |
168 | ||
169 | /* | |
170 | * kvm_vgic_global_state.vctrl_base is set on vgic probe (kvm_arch_init) | |
171 | * it is stored in distributor struct for asm save/restore purpose | |
172 | */ | |
173 | kvm->arch.vgic.vctrl_base = kvm_vgic_global_state.vctrl_base; | |
174 | ||
175 | kvm->arch.vgic.vgic_dist_base = VGIC_ADDR_UNDEF; | |
176 | kvm->arch.vgic.vgic_cpu_base = VGIC_ADDR_UNDEF; | |
177 | kvm->arch.vgic.vgic_redist_base = VGIC_ADDR_UNDEF; | |
178 | ||
179 | out_unlock: | |
180 | for (; vcpu_lock_idx >= 0; vcpu_lock_idx--) { | |
181 | vcpu = kvm_get_vcpu(kvm, vcpu_lock_idx); | |
182 | mutex_unlock(&vcpu->mutex); | |
183 | } | |
5e6431da EA |
184 | return ret; |
185 | } | |
186 | ||
ad275b8b EA |
187 | /* INIT/DESTROY */ |
188 | ||
189 | /** | |
190 | * kvm_vgic_dist_init: initialize the dist data structures | |
191 | * @kvm: kvm struct pointer | |
192 | * @nr_spis: number of spis, frozen by caller | |
193 | */ | |
194 | static int kvm_vgic_dist_init(struct kvm *kvm, unsigned int nr_spis) | |
195 | { | |
196 | struct vgic_dist *dist = &kvm->arch.vgic; | |
197 | struct kvm_vcpu *vcpu0 = kvm_get_vcpu(kvm, 0); | |
198 | int i; | |
199 | ||
200 | dist->spis = kcalloc(nr_spis, sizeof(struct vgic_irq), GFP_KERNEL); | |
201 | if (!dist->spis) | |
202 | return -ENOMEM; | |
203 | ||
204 | /* | |
205 | * In the following code we do not take the irq struct lock since | |
206 | * no other action on irq structs can happen while the VGIC is | |
207 | * not initialized yet: | |
208 | * If someone wants to inject an interrupt or does a MMIO access, we | |
209 | * require prior initialization in case of a virtual GICv3 or trigger | |
210 | * initialization when using a virtual GICv2. | |
211 | */ | |
212 | for (i = 0; i < nr_spis; i++) { | |
213 | struct vgic_irq *irq = &dist->spis[i]; | |
214 | ||
215 | irq->intid = i + VGIC_NR_PRIVATE_IRQS; | |
216 | INIT_LIST_HEAD(&irq->ap_list); | |
217 | spin_lock_init(&irq->irq_lock); | |
218 | irq->vcpu = NULL; | |
219 | irq->target_vcpu = vcpu0; | |
5dd4b924 | 220 | kref_init(&irq->refcount); |
ad275b8b EA |
221 | if (dist->vgic_model == KVM_DEV_TYPE_ARM_VGIC_V2) |
222 | irq->targets = 0; | |
223 | else | |
224 | irq->mpidr = 0; | |
225 | } | |
226 | return 0; | |
227 | } | |
228 | ||
229 | /** | |
1aab6f46 CD |
230 | * kvm_vgic_vcpu_init() - Register VCPU-specific KVM iodevs |
231 | * @vcpu: pointer to the VCPU being created and initialized | |
ad275b8b | 232 | */ |
1aab6f46 CD |
233 | int kvm_vgic_vcpu_init(struct kvm_vcpu *vcpu) |
234 | { | |
235 | int ret = 0; | |
236 | struct vgic_dist *dist = &vcpu->kvm->arch.vgic; | |
237 | ||
238 | if (!irqchip_in_kernel(vcpu->kvm)) | |
239 | return 0; | |
240 | ||
241 | /* | |
242 | * If we are creating a VCPU with a GICv3 we must also register the | |
243 | * KVM io device for the redistributor that belongs to this VCPU. | |
244 | */ | |
552c9f47 CD |
245 | if (dist->vgic_model == KVM_DEV_TYPE_ARM_VGIC_V3) { |
246 | mutex_lock(&vcpu->kvm->lock); | |
1aab6f46 | 247 | ret = vgic_register_redist_iodev(vcpu); |
552c9f47 CD |
248 | mutex_unlock(&vcpu->kvm->lock); |
249 | } | |
1aab6f46 CD |
250 | return ret; |
251 | } | |
252 | ||
443c3a9e | 253 | static void kvm_vgic_vcpu_enable(struct kvm_vcpu *vcpu) |
ad275b8b | 254 | { |
ad275b8b EA |
255 | if (kvm_vgic_global_state.type == VGIC_V2) |
256 | vgic_v2_enable(vcpu); | |
257 | else | |
258 | vgic_v3_enable(vcpu); | |
259 | } | |
260 | ||
261 | /* | |
262 | * vgic_init: allocates and initializes dist and vcpu data structures | |
263 | * depending on two dimensioning parameters: | |
264 | * - the number of spis | |
265 | * - the number of vcpus | |
266 | * The function is generally called when nr_spis has been explicitly set | |
267 | * by the guest through the KVM DEVICE API. If not nr_spis is set to 256. | |
268 | * vgic_initialized() returns true when this function has succeeded. | |
269 | * Must be called with kvm->lock held! | |
270 | */ | |
271 | int vgic_init(struct kvm *kvm) | |
272 | { | |
273 | struct vgic_dist *dist = &kvm->arch.vgic; | |
274 | struct kvm_vcpu *vcpu; | |
275 | int ret = 0, i; | |
276 | ||
277 | if (vgic_initialized(kvm)) | |
278 | return 0; | |
279 | ||
280 | /* freeze the number of spis */ | |
281 | if (!dist->nr_spis) | |
282 | dist->nr_spis = VGIC_NR_IRQS_LEGACY - VGIC_NR_PRIVATE_IRQS; | |
283 | ||
284 | ret = kvm_vgic_dist_init(kvm, dist->nr_spis); | |
285 | if (ret) | |
286 | goto out; | |
287 | ||
f8f85dc0 CD |
288 | if (vgic_has_its(kvm)) { |
289 | ret = vgic_v4_init(kvm); | |
290 | if (ret) | |
291 | goto out; | |
292 | } | |
74fe55dc | 293 | |
ad275b8b | 294 | kvm_for_each_vcpu(i, vcpu, kvm) |
443c3a9e | 295 | kvm_vgic_vcpu_enable(vcpu); |
ad275b8b | 296 | |
180ae7b1 EA |
297 | ret = kvm_vgic_setup_default_irq_routing(kvm); |
298 | if (ret) | |
299 | goto out; | |
300 | ||
10f92c4c CD |
301 | vgic_debug_init(kvm); |
302 | ||
ad275b8b | 303 | dist->initialized = true; |
328e5664 CD |
304 | |
305 | /* | |
306 | * If we're initializing GICv2 on-demand when first running the VCPU | |
307 | * then we need to load the VGIC state onto the CPU. We can detect | |
308 | * this easily by checking if we are in between vcpu_load and vcpu_put | |
309 | * when we just initialized the VGIC. | |
310 | */ | |
311 | preempt_disable(); | |
312 | vcpu = kvm_arm_get_running_vcpu(); | |
313 | if (vcpu) | |
314 | kvm_vgic_load(vcpu); | |
315 | preempt_enable(); | |
ad275b8b EA |
316 | out: |
317 | return ret; | |
318 | } | |
319 | ||
320 | static void kvm_vgic_dist_destroy(struct kvm *kvm) | |
321 | { | |
322 | struct vgic_dist *dist = &kvm->arch.vgic; | |
323 | ||
ad275b8b EA |
324 | dist->ready = false; |
325 | dist->initialized = false; | |
326 | ||
327 | kfree(dist->spis); | |
ad275b8b | 328 | dist->nr_spis = 0; |
74fe55dc MZ |
329 | |
330 | if (vgic_supports_direct_msis(kvm)) | |
331 | vgic_v4_teardown(kvm); | |
ad275b8b EA |
332 | } |
333 | ||
334 | void kvm_vgic_vcpu_destroy(struct kvm_vcpu *vcpu) | |
335 | { | |
336 | struct vgic_cpu *vgic_cpu = &vcpu->arch.vgic_cpu; | |
337 | ||
338 | INIT_LIST_HEAD(&vgic_cpu->ap_list_head); | |
339 | } | |
340 | ||
1193e6ae MZ |
341 | /* To be called with kvm->lock held */ |
342 | static void __kvm_vgic_destroy(struct kvm *kvm) | |
ad275b8b EA |
343 | { |
344 | struct kvm_vcpu *vcpu; | |
345 | int i; | |
346 | ||
10f92c4c CD |
347 | vgic_debug_destroy(kvm); |
348 | ||
ad275b8b EA |
349 | kvm_vgic_dist_destroy(kvm); |
350 | ||
351 | kvm_for_each_vcpu(i, vcpu, kvm) | |
352 | kvm_vgic_vcpu_destroy(vcpu); | |
353 | } | |
354 | ||
1193e6ae MZ |
355 | void kvm_vgic_destroy(struct kvm *kvm) |
356 | { | |
357 | mutex_lock(&kvm->lock); | |
358 | __kvm_vgic_destroy(kvm); | |
359 | mutex_unlock(&kvm->lock); | |
360 | } | |
361 | ||
ad275b8b EA |
362 | /** |
363 | * vgic_lazy_init: Lazy init is only allowed if the GIC exposed to the guest | |
364 | * is a GICv2. A GICv3 must be explicitly initialized by the guest using the | |
365 | * KVM_DEV_ARM_VGIC_GRP_CTRL KVM_DEVICE group. | |
366 | * @kvm: kvm struct pointer | |
367 | */ | |
368 | int vgic_lazy_init(struct kvm *kvm) | |
369 | { | |
370 | int ret = 0; | |
371 | ||
372 | if (unlikely(!vgic_initialized(kvm))) { | |
373 | /* | |
374 | * We only provide the automatic initialization of the VGIC | |
375 | * for the legacy case of a GICv2. Any other type must | |
376 | * be explicitly initialized once setup with the respective | |
377 | * KVM device call. | |
378 | */ | |
379 | if (kvm->arch.vgic.vgic_model != KVM_DEV_TYPE_ARM_VGIC_V2) | |
380 | return -EBUSY; | |
381 | ||
382 | mutex_lock(&kvm->lock); | |
383 | ret = vgic_init(kvm); | |
384 | mutex_unlock(&kvm->lock); | |
385 | } | |
386 | ||
387 | return ret; | |
388 | } | |
389 | ||
b0442ee2 EA |
390 | /* RESOURCE MAPPING */ |
391 | ||
392 | /** | |
393 | * Map the MMIO regions depending on the VGIC model exposed to the guest | |
394 | * called on the first VCPU run. | |
395 | * Also map the virtual CPU interface into the VM. | |
396 | * v2/v3 derivatives call vgic_init if not already done. | |
397 | * vgic_ready() returns true if this function has succeeded. | |
398 | * @kvm: kvm struct pointer | |
399 | */ | |
400 | int kvm_vgic_map_resources(struct kvm *kvm) | |
401 | { | |
402 | struct vgic_dist *dist = &kvm->arch.vgic; | |
403 | int ret = 0; | |
404 | ||
405 | mutex_lock(&kvm->lock); | |
406 | if (!irqchip_in_kernel(kvm)) | |
407 | goto out; | |
408 | ||
409 | if (dist->vgic_model == KVM_DEV_TYPE_ARM_VGIC_V2) | |
410 | ret = vgic_v2_map_resources(kvm); | |
411 | else | |
412 | ret = vgic_v3_map_resources(kvm); | |
1193e6ae MZ |
413 | |
414 | if (ret) | |
415 | __kvm_vgic_destroy(kvm); | |
416 | ||
b0442ee2 EA |
417 | out: |
418 | mutex_unlock(&kvm->lock); | |
419 | return ret; | |
420 | } | |
421 | ||
90977732 EA |
422 | /* GENERIC PROBE */ |
423 | ||
15d7e3d3 | 424 | static int vgic_init_cpu_starting(unsigned int cpu) |
90977732 EA |
425 | { |
426 | enable_percpu_irq(kvm_vgic_global_state.maint_irq, 0); | |
15d7e3d3 | 427 | return 0; |
90977732 EA |
428 | } |
429 | ||
90977732 | 430 | |
15d7e3d3 AMG |
431 | static int vgic_init_cpu_dying(unsigned int cpu) |
432 | { | |
433 | disable_percpu_irq(kvm_vgic_global_state.maint_irq); | |
434 | return 0; | |
90977732 EA |
435 | } |
436 | ||
90977732 EA |
437 | static irqreturn_t vgic_maintenance_handler(int irq, void *data) |
438 | { | |
439 | /* | |
440 | * We cannot rely on the vgic maintenance interrupt to be | |
441 | * delivered synchronously. This means we can only use it to | |
442 | * exit the VM, and we perform the handling of EOIed | |
443 | * interrupts on the exit path (see vgic_process_maintenance). | |
444 | */ | |
445 | return IRQ_HANDLED; | |
446 | } | |
447 | ||
5b0d2cc2 CD |
448 | /** |
449 | * kvm_vgic_init_cpu_hardware - initialize the GIC VE hardware | |
450 | * | |
451 | * For a specific CPU, initialize the GIC VE hardware. | |
452 | */ | |
453 | void kvm_vgic_init_cpu_hardware(void) | |
454 | { | |
455 | BUG_ON(preemptible()); | |
456 | ||
457 | /* | |
458 | * We want to make sure the list registers start out clear so that we | |
459 | * only have the program the used registers. | |
460 | */ | |
461 | if (kvm_vgic_global_state.type == VGIC_V2) | |
462 | vgic_v2_init_lrs(); | |
463 | else | |
464 | kvm_call_hyp(__vgic_v3_init_lrs); | |
465 | } | |
466 | ||
90977732 EA |
467 | /** |
468 | * kvm_vgic_hyp_init: populates the kvm_vgic_global_state variable | |
469 | * according to the host GIC model. Accordingly calls either | |
470 | * vgic_v2/v3_probe which registers the KVM_DEVICE that can be | |
471 | * instantiated by a guest later on . | |
472 | */ | |
473 | int kvm_vgic_hyp_init(void) | |
474 | { | |
475 | const struct gic_kvm_info *gic_kvm_info; | |
476 | int ret; | |
477 | ||
478 | gic_kvm_info = gic_get_kvm_info(); | |
479 | if (!gic_kvm_info) | |
480 | return -ENODEV; | |
481 | ||
482 | if (!gic_kvm_info->maint_irq) { | |
483 | kvm_err("No vgic maintenance irq\n"); | |
484 | return -ENXIO; | |
485 | } | |
486 | ||
487 | switch (gic_kvm_info->type) { | |
488 | case GIC_V2: | |
489 | ret = vgic_v2_probe(gic_kvm_info); | |
490 | break; | |
491 | case GIC_V3: | |
492 | ret = vgic_v3_probe(gic_kvm_info); | |
5a7a8426 VM |
493 | if (!ret) { |
494 | static_branch_enable(&kvm_vgic_global_state.gicv3_cpuif); | |
495 | kvm_info("GIC system register CPU interface enabled\n"); | |
496 | } | |
90977732 EA |
497 | break; |
498 | default: | |
499 | ret = -ENODEV; | |
500 | }; | |
501 | ||
502 | if (ret) | |
503 | return ret; | |
504 | ||
505 | kvm_vgic_global_state.maint_irq = gic_kvm_info->maint_irq; | |
506 | ret = request_percpu_irq(kvm_vgic_global_state.maint_irq, | |
507 | vgic_maintenance_handler, | |
508 | "vgic", kvm_get_running_vcpus()); | |
509 | if (ret) { | |
510 | kvm_err("Cannot register interrupt %d\n", | |
511 | kvm_vgic_global_state.maint_irq); | |
512 | return ret; | |
513 | } | |
514 | ||
15d7e3d3 | 515 | ret = cpuhp_setup_state(CPUHP_AP_KVM_ARM_VGIC_INIT_STARTING, |
73c1b41e | 516 | "kvm/arm/vgic:starting", |
15d7e3d3 | 517 | vgic_init_cpu_starting, vgic_init_cpu_dying); |
90977732 EA |
518 | if (ret) { |
519 | kvm_err("Cannot register vgic CPU notifier\n"); | |
520 | goto out_free_irq; | |
521 | } | |
522 | ||
90977732 EA |
523 | kvm_info("vgic interrupt IRQ%d\n", kvm_vgic_global_state.maint_irq); |
524 | return 0; | |
525 | ||
526 | out_free_irq: | |
527 | free_percpu_irq(kvm_vgic_global_state.maint_irq, | |
528 | kvm_get_running_vcpus()); | |
529 | return ret; | |
530 | } |