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 28 #include "qemu/osdep.h" 29 #include "qapi/error.h" 30 #include "qemu-common.h" 31 #include "cpu.h" 32 #include "hw/hw.h" 33 #include "trace.h" 34 #include "sysemu/kvm.h" 35 #include "hw/ppc/spapr.h" 36 #include "hw/ppc/xics.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 43 static int kernel_xics_fd = -1; 44 45 /* 46 * ICP-KVM 47 */ 48 static void icp_get_kvm_state(ICPState *icp) 49 { 50 uint64_t state; 51 struct kvm_one_reg reg = { 52 .id = KVM_REG_PPC_ICP_STATE, 53 .addr = (uintptr_t)&state, 54 }; 55 int ret; 56 57 /* ICP for this CPU thread is not in use, exiting */ 58 if (!icp->cs) { 59 return; 60 } 61 62 ret = kvm_vcpu_ioctl(icp->cs, KVM_GET_ONE_REG, ®); 63 if (ret != 0) { 64 error_report("Unable to retrieve KVM interrupt controller state" 65 " for CPU %ld: %s", kvm_arch_vcpu_id(icp->cs), strerror(errno)); 66 exit(1); 67 } 68 69 icp->xirr = state >> KVM_REG_PPC_ICP_XISR_SHIFT; 70 icp->mfrr = (state >> KVM_REG_PPC_ICP_MFRR_SHIFT) 71 & KVM_REG_PPC_ICP_MFRR_MASK; 72 icp->pending_priority = (state >> KVM_REG_PPC_ICP_PPRI_SHIFT) 73 & KVM_REG_PPC_ICP_PPRI_MASK; 74 } 75 76 static int icp_set_kvm_state(ICPState *icp, int version_id) 77 { 78 uint64_t state; 79 struct kvm_one_reg reg = { 80 .id = KVM_REG_PPC_ICP_STATE, 81 .addr = (uintptr_t)&state, 82 }; 83 int ret; 84 85 /* ICP for this CPU thread is not in use, exiting */ 86 if (!icp->cs) { 87 return 0; 88 } 89 90 state = ((uint64_t)icp->xirr << KVM_REG_PPC_ICP_XISR_SHIFT) 91 | ((uint64_t)icp->mfrr << KVM_REG_PPC_ICP_MFRR_SHIFT) 92 | ((uint64_t)icp->pending_priority << KVM_REG_PPC_ICP_PPRI_SHIFT); 93 94 ret = kvm_vcpu_ioctl(icp->cs, KVM_SET_ONE_REG, ®); 95 if (ret != 0) { 96 error_report("Unable to restore KVM interrupt controller state (0x%" 97 PRIx64 ") for CPU %ld: %s", state, kvm_arch_vcpu_id(icp->cs), 98 strerror(errno)); 99 return ret; 100 } 101 102 return 0; 103 } 104 105 static void icp_kvm_reset(void *dev) 106 { 107 ICPState *icp = ICP(dev); 108 109 icp->xirr = 0; 110 icp->pending_priority = 0xff; 111 icp->mfrr = 0xff; 112 113 /* Make all outputs as deasserted only if the CPU thread is in use */ 114 if (icp->output) { 115 qemu_set_irq(icp->output, 0); 116 } 117 118 icp_set_kvm_state(icp, 1); 119 } 120 121 static void icp_kvm_cpu_setup(ICPState *icp, PowerPCCPU *cpu) 122 { 123 CPUState *cs = CPU(cpu); 124 int ret; 125 126 if (kernel_xics_fd == -1) { 127 abort(); 128 } 129 130 /* 131 * If we are reusing a parked vCPU fd corresponding to the CPU 132 * which was hot-removed earlier we don't have to renable 133 * KVM_CAP_IRQ_XICS capability again. 134 */ 135 if (icp->cap_irq_xics_enabled) { 136 return; 137 } 138 139 ret = kvm_vcpu_enable_cap(cs, KVM_CAP_IRQ_XICS, 0, kernel_xics_fd, 140 kvm_arch_vcpu_id(cs)); 141 if (ret < 0) { 142 error_report("Unable to connect CPU%ld to kernel XICS: %s", 143 kvm_arch_vcpu_id(cs), strerror(errno)); 144 exit(1); 145 } 146 icp->cap_irq_xics_enabled = true; 147 } 148 149 static void icp_kvm_realize(DeviceState *dev, Error **errp) 150 { 151 qemu_register_reset(icp_kvm_reset, dev); 152 } 153 154 static void icp_kvm_class_init(ObjectClass *klass, void *data) 155 { 156 DeviceClass *dc = DEVICE_CLASS(klass); 157 ICPStateClass *icpc = ICP_CLASS(klass); 158 159 dc->realize = icp_kvm_realize; 160 icpc->pre_save = icp_get_kvm_state; 161 icpc->post_load = icp_set_kvm_state; 162 icpc->cpu_setup = icp_kvm_cpu_setup; 163 } 164 165 static const TypeInfo icp_kvm_info = { 166 .name = TYPE_KVM_ICP, 167 .parent = TYPE_ICP, 168 .instance_size = sizeof(ICPState), 169 .class_init = icp_kvm_class_init, 170 .class_size = sizeof(ICPStateClass), 171 }; 172 173 /* 174 * ICS-KVM 175 */ 176 static void ics_get_kvm_state(ICSState *ics) 177 { 178 uint64_t state; 179 struct kvm_device_attr attr = { 180 .flags = 0, 181 .group = KVM_DEV_XICS_GRP_SOURCES, 182 .addr = (uint64_t)(uintptr_t)&state, 183 }; 184 int i; 185 186 for (i = 0; i < ics->nr_irqs; i++) { 187 ICSIRQState *irq = &ics->irqs[i]; 188 int ret; 189 190 attr.attr = i + ics->offset; 191 192 ret = ioctl(kernel_xics_fd, KVM_GET_DEVICE_ATTR, &attr); 193 if (ret != 0) { 194 error_report("Unable to retrieve KVM interrupt controller state" 195 " for IRQ %d: %s", i + ics->offset, strerror(errno)); 196 exit(1); 197 } 198 199 irq->server = state & KVM_XICS_DESTINATION_MASK; 200 irq->saved_priority = (state >> KVM_XICS_PRIORITY_SHIFT) 201 & KVM_XICS_PRIORITY_MASK; 202 /* 203 * To be consistent with the software emulation in xics.c, we 204 * split out the masked state + priority that we get from the 205 * kernel into 'current priority' (0xff if masked) and 206 * 'saved priority' (if masked, this is the priority the 207 * interrupt had before it was masked). Masking and unmasking 208 * are done with the ibm,int-off and ibm,int-on RTAS calls. 209 */ 210 if (state & KVM_XICS_MASKED) { 211 irq->priority = 0xff; 212 } else { 213 irq->priority = irq->saved_priority; 214 } 215 216 irq->status = 0; 217 if (state & KVM_XICS_PENDING) { 218 if (state & KVM_XICS_LEVEL_SENSITIVE) { 219 irq->status |= XICS_STATUS_ASSERTED; 220 } else { 221 /* 222 * A pending edge-triggered interrupt (or MSI) 223 * must have been rejected previously when we 224 * first detected it and tried to deliver it, 225 * so mark it as pending and previously rejected 226 * for consistency with how xics.c works. 227 */ 228 irq->status |= XICS_STATUS_MASKED_PENDING 229 | XICS_STATUS_REJECTED; 230 } 231 } 232 } 233 } 234 235 static int ics_set_kvm_state(ICSState *ics, int version_id) 236 { 237 uint64_t state; 238 struct kvm_device_attr attr = { 239 .flags = 0, 240 .group = KVM_DEV_XICS_GRP_SOURCES, 241 .addr = (uint64_t)(uintptr_t)&state, 242 }; 243 int i; 244 245 for (i = 0; i < ics->nr_irqs; i++) { 246 ICSIRQState *irq = &ics->irqs[i]; 247 int ret; 248 249 attr.attr = i + ics->offset; 250 251 state = irq->server; 252 state |= (uint64_t)(irq->saved_priority & KVM_XICS_PRIORITY_MASK) 253 << KVM_XICS_PRIORITY_SHIFT; 254 if (irq->priority != irq->saved_priority) { 255 assert(irq->priority == 0xff); 256 state |= KVM_XICS_MASKED; 257 } 258 259 if (ics->irqs[i].flags & XICS_FLAGS_IRQ_LSI) { 260 state |= KVM_XICS_LEVEL_SENSITIVE; 261 if (irq->status & XICS_STATUS_ASSERTED) { 262 state |= KVM_XICS_PENDING; 263 } 264 } else { 265 if (irq->status & XICS_STATUS_MASKED_PENDING) { 266 state |= KVM_XICS_PENDING; 267 } 268 } 269 270 ret = ioctl(kernel_xics_fd, KVM_SET_DEVICE_ATTR, &attr); 271 if (ret != 0) { 272 error_report("Unable to restore KVM interrupt controller state" 273 " for IRQs %d: %s", i + ics->offset, strerror(errno)); 274 return ret; 275 } 276 } 277 278 return 0; 279 } 280 281 static void ics_kvm_set_irq(void *opaque, int srcno, int val) 282 { 283 ICSState *ics = opaque; 284 struct kvm_irq_level args; 285 int rc; 286 287 args.irq = srcno + ics->offset; 288 if (ics->irqs[srcno].flags & XICS_FLAGS_IRQ_MSI) { 289 if (!val) { 290 return; 291 } 292 args.level = KVM_INTERRUPT_SET; 293 } else { 294 args.level = val ? KVM_INTERRUPT_SET_LEVEL : KVM_INTERRUPT_UNSET; 295 } 296 rc = kvm_vm_ioctl(kvm_state, KVM_IRQ_LINE, &args); 297 if (rc < 0) { 298 perror("kvm_irq_line"); 299 } 300 } 301 302 static void ics_kvm_reset(void *dev) 303 { 304 ICSState *ics = ICS_SIMPLE(dev); 305 int i; 306 uint8_t flags[ics->nr_irqs]; 307 308 for (i = 0; i < ics->nr_irqs; i++) { 309 flags[i] = ics->irqs[i].flags; 310 } 311 312 memset(ics->irqs, 0, sizeof(ICSIRQState) * ics->nr_irqs); 313 314 for (i = 0; i < ics->nr_irqs; i++) { 315 ics->irqs[i].priority = 0xff; 316 ics->irqs[i].saved_priority = 0xff; 317 ics->irqs[i].flags = flags[i]; 318 } 319 320 ics_set_kvm_state(ics, 1); 321 } 322 323 static void ics_kvm_realize(DeviceState *dev, Error **errp) 324 { 325 ICSState *ics = ICS_SIMPLE(dev); 326 327 if (!ics->nr_irqs) { 328 error_setg(errp, "Number of interrupts needs to be greater 0"); 329 return; 330 } 331 ics->irqs = g_malloc0(ics->nr_irqs * sizeof(ICSIRQState)); 332 ics->qirqs = qemu_allocate_irqs(ics_kvm_set_irq, ics, ics->nr_irqs); 333 334 qemu_register_reset(ics_kvm_reset, dev); 335 } 336 337 static void ics_kvm_class_init(ObjectClass *klass, void *data) 338 { 339 ICSStateClass *icsc = ICS_BASE_CLASS(klass); 340 341 icsc->realize = ics_kvm_realize; 342 icsc->pre_save = ics_get_kvm_state; 343 icsc->post_load = ics_set_kvm_state; 344 } 345 346 static const TypeInfo ics_kvm_info = { 347 .name = TYPE_ICS_KVM, 348 .parent = TYPE_ICS_SIMPLE, 349 .instance_size = sizeof(ICSState), 350 .class_init = ics_kvm_class_init, 351 }; 352 353 /* 354 * XICS-KVM 355 */ 356 357 static void rtas_dummy(PowerPCCPU *cpu, sPAPRMachineState *spapr, 358 uint32_t token, 359 uint32_t nargs, target_ulong args, 360 uint32_t nret, target_ulong rets) 361 { 362 error_report("pseries: %s must never be called for in-kernel XICS", 363 __func__); 364 } 365 366 int xics_kvm_init(sPAPRMachineState *spapr, Error **errp) 367 { 368 int rc; 369 struct kvm_create_device xics_create_device = { 370 .type = KVM_DEV_TYPE_XICS, 371 .flags = 0, 372 }; 373 374 if (!kvm_enabled() || !kvm_check_extension(kvm_state, KVM_CAP_IRQ_XICS)) { 375 error_setg(errp, 376 "KVM and IRQ_XICS capability must be present for in-kernel XICS"); 377 goto fail; 378 } 379 380 spapr_rtas_register(RTAS_IBM_SET_XIVE, "ibm,set-xive", rtas_dummy); 381 spapr_rtas_register(RTAS_IBM_GET_XIVE, "ibm,get-xive", rtas_dummy); 382 spapr_rtas_register(RTAS_IBM_INT_OFF, "ibm,int-off", rtas_dummy); 383 spapr_rtas_register(RTAS_IBM_INT_ON, "ibm,int-on", rtas_dummy); 384 385 rc = kvmppc_define_rtas_kernel_token(RTAS_IBM_SET_XIVE, "ibm,set-xive"); 386 if (rc < 0) { 387 error_setg(errp, "kvmppc_define_rtas_kernel_token: ibm,set-xive"); 388 goto fail; 389 } 390 391 rc = kvmppc_define_rtas_kernel_token(RTAS_IBM_GET_XIVE, "ibm,get-xive"); 392 if (rc < 0) { 393 error_setg(errp, "kvmppc_define_rtas_kernel_token: ibm,get-xive"); 394 goto fail; 395 } 396 397 rc = kvmppc_define_rtas_kernel_token(RTAS_IBM_INT_ON, "ibm,int-on"); 398 if (rc < 0) { 399 error_setg(errp, "kvmppc_define_rtas_kernel_token: ibm,int-on"); 400 goto fail; 401 } 402 403 rc = kvmppc_define_rtas_kernel_token(RTAS_IBM_INT_OFF, "ibm,int-off"); 404 if (rc < 0) { 405 error_setg(errp, "kvmppc_define_rtas_kernel_token: ibm,int-off"); 406 goto fail; 407 } 408 409 /* Create the kernel ICP */ 410 rc = kvm_vm_ioctl(kvm_state, KVM_CREATE_DEVICE, &xics_create_device); 411 if (rc < 0) { 412 error_setg_errno(errp, -rc, "Error on KVM_CREATE_DEVICE for XICS"); 413 goto fail; 414 } 415 416 kernel_xics_fd = xics_create_device.fd; 417 418 kvm_kernel_irqchip = true; 419 kvm_msi_via_irqfd_allowed = true; 420 kvm_gsi_direct_mapping = true; 421 422 return rc; 423 424 fail: 425 kvmppc_define_rtas_kernel_token(0, "ibm,set-xive"); 426 kvmppc_define_rtas_kernel_token(0, "ibm,get-xive"); 427 kvmppc_define_rtas_kernel_token(0, "ibm,int-on"); 428 kvmppc_define_rtas_kernel_token(0, "ibm,int-off"); 429 return -1; 430 } 431 432 static void xics_kvm_register_types(void) 433 { 434 type_register_static(&ics_kvm_info); 435 type_register_static(&icp_kvm_info); 436 } 437 438 type_init(xics_kvm_register_types) 439