1 /* 2 * interrupt.c - handling kvm guest interrupts 3 * 4 * Copyright IBM Corp. 2008 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License (version 2 only) 8 * as published by the Free Software Foundation. 9 * 10 * Author(s): Carsten Otte <cotte@de.ibm.com> 11 */ 12 13 #include <asm/lowcore.h> 14 #include <asm/uaccess.h> 15 #include <linux/kvm_host.h> 16 #include "kvm-s390.h" 17 #include "gaccess.h" 18 19 static int psw_extint_disabled(struct kvm_vcpu *vcpu) 20 { 21 return !(vcpu->arch.sie_block->gpsw.mask & PSW_MASK_EXT); 22 } 23 24 static int psw_interrupts_disabled(struct kvm_vcpu *vcpu) 25 { 26 if ((vcpu->arch.sie_block->gpsw.mask & PSW_MASK_PER) || 27 (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_IO) || 28 (vcpu->arch.sie_block->gpsw.mask & PSW_MASK_EXT)) 29 return 0; 30 return 1; 31 } 32 33 static int __interrupt_is_deliverable(struct kvm_vcpu *vcpu, 34 struct interrupt_info *inti) 35 { 36 switch (inti->type) { 37 case KVM_S390_INT_EMERGENCY: 38 if (psw_extint_disabled(vcpu)) 39 return 0; 40 if (vcpu->arch.sie_block->gcr[0] & 0x4000ul) 41 return 1; 42 return 0; 43 case KVM_S390_INT_SERVICE: 44 if (psw_extint_disabled(vcpu)) 45 return 0; 46 if (vcpu->arch.sie_block->gcr[0] & 0x200ul) 47 return 1; 48 return 0; 49 case KVM_S390_INT_VIRTIO: 50 if (psw_extint_disabled(vcpu)) 51 return 0; 52 if (vcpu->arch.sie_block->gcr[0] & 0x200ul) 53 return 1; 54 return 0; 55 case KVM_S390_PROGRAM_INT: 56 case KVM_S390_SIGP_STOP: 57 case KVM_S390_SIGP_SET_PREFIX: 58 case KVM_S390_RESTART: 59 return 1; 60 default: 61 BUG(); 62 } 63 return 0; 64 } 65 66 static void __set_cpu_idle(struct kvm_vcpu *vcpu) 67 { 68 BUG_ON(vcpu->vcpu_id > KVM_MAX_VCPUS - 1); 69 atomic_set_mask(CPUSTAT_WAIT, &vcpu->arch.sie_block->cpuflags); 70 set_bit(vcpu->vcpu_id, vcpu->arch.local_int.float_int->idle_mask); 71 } 72 73 static void __unset_cpu_idle(struct kvm_vcpu *vcpu) 74 { 75 BUG_ON(vcpu->vcpu_id > KVM_MAX_VCPUS - 1); 76 atomic_clear_mask(CPUSTAT_WAIT, &vcpu->arch.sie_block->cpuflags); 77 clear_bit(vcpu->vcpu_id, vcpu->arch.local_int.float_int->idle_mask); 78 } 79 80 static void __reset_intercept_indicators(struct kvm_vcpu *vcpu) 81 { 82 atomic_clear_mask(CPUSTAT_ECALL_PEND | 83 CPUSTAT_IO_INT | CPUSTAT_EXT_INT | CPUSTAT_STOP_INT, 84 &vcpu->arch.sie_block->cpuflags); 85 vcpu->arch.sie_block->lctl = 0x0000; 86 } 87 88 static void __set_cpuflag(struct kvm_vcpu *vcpu, u32 flag) 89 { 90 atomic_set_mask(flag, &vcpu->arch.sie_block->cpuflags); 91 } 92 93 static void __set_intercept_indicator(struct kvm_vcpu *vcpu, 94 struct interrupt_info *inti) 95 { 96 switch (inti->type) { 97 case KVM_S390_INT_EMERGENCY: 98 case KVM_S390_INT_SERVICE: 99 case KVM_S390_INT_VIRTIO: 100 if (psw_extint_disabled(vcpu)) 101 __set_cpuflag(vcpu, CPUSTAT_EXT_INT); 102 else 103 vcpu->arch.sie_block->lctl |= LCTL_CR0; 104 break; 105 case KVM_S390_SIGP_STOP: 106 __set_cpuflag(vcpu, CPUSTAT_STOP_INT); 107 break; 108 default: 109 BUG(); 110 } 111 } 112 113 static void __do_deliver_interrupt(struct kvm_vcpu *vcpu, 114 struct interrupt_info *inti) 115 { 116 const unsigned short table[] = { 2, 4, 4, 6 }; 117 int rc, exception = 0; 118 119 switch (inti->type) { 120 case KVM_S390_INT_EMERGENCY: 121 VCPU_EVENT(vcpu, 4, "%s", "interrupt: sigp emerg"); 122 vcpu->stat.deliver_emergency_signal++; 123 rc = put_guest_u16(vcpu, __LC_EXT_INT_CODE, 0x1201); 124 if (rc == -EFAULT) 125 exception = 1; 126 127 rc = copy_to_guest(vcpu, __LC_EXT_OLD_PSW, 128 &vcpu->arch.sie_block->gpsw, sizeof(psw_t)); 129 if (rc == -EFAULT) 130 exception = 1; 131 132 rc = copy_from_guest(vcpu, &vcpu->arch.sie_block->gpsw, 133 __LC_EXT_NEW_PSW, sizeof(psw_t)); 134 if (rc == -EFAULT) 135 exception = 1; 136 break; 137 138 case KVM_S390_INT_SERVICE: 139 VCPU_EVENT(vcpu, 4, "interrupt: sclp parm:%x", 140 inti->ext.ext_params); 141 vcpu->stat.deliver_service_signal++; 142 rc = put_guest_u16(vcpu, __LC_EXT_INT_CODE, 0x2401); 143 if (rc == -EFAULT) 144 exception = 1; 145 146 rc = copy_to_guest(vcpu, __LC_EXT_OLD_PSW, 147 &vcpu->arch.sie_block->gpsw, sizeof(psw_t)); 148 if (rc == -EFAULT) 149 exception = 1; 150 151 rc = copy_from_guest(vcpu, &vcpu->arch.sie_block->gpsw, 152 __LC_EXT_NEW_PSW, sizeof(psw_t)); 153 if (rc == -EFAULT) 154 exception = 1; 155 156 rc = put_guest_u32(vcpu, __LC_EXT_PARAMS, inti->ext.ext_params); 157 if (rc == -EFAULT) 158 exception = 1; 159 break; 160 161 case KVM_S390_INT_VIRTIO: 162 VCPU_EVENT(vcpu, 4, "interrupt: virtio parm:%x,parm64:%lx", 163 inti->ext.ext_params, inti->ext.ext_params2); 164 vcpu->stat.deliver_virtio_interrupt++; 165 rc = put_guest_u16(vcpu, __LC_EXT_INT_CODE, 0x2603); 166 if (rc == -EFAULT) 167 exception = 1; 168 169 rc = put_guest_u16(vcpu, __LC_CPU_ADDRESS, 0x0d00); 170 if (rc == -EFAULT) 171 exception = 1; 172 173 rc = copy_to_guest(vcpu, __LC_EXT_OLD_PSW, 174 &vcpu->arch.sie_block->gpsw, sizeof(psw_t)); 175 if (rc == -EFAULT) 176 exception = 1; 177 178 rc = copy_from_guest(vcpu, &vcpu->arch.sie_block->gpsw, 179 __LC_EXT_NEW_PSW, sizeof(psw_t)); 180 if (rc == -EFAULT) 181 exception = 1; 182 183 rc = put_guest_u32(vcpu, __LC_EXT_PARAMS, inti->ext.ext_params); 184 if (rc == -EFAULT) 185 exception = 1; 186 187 rc = put_guest_u64(vcpu, __LC_PFAULT_INTPARM, 188 inti->ext.ext_params2); 189 if (rc == -EFAULT) 190 exception = 1; 191 break; 192 193 case KVM_S390_SIGP_STOP: 194 VCPU_EVENT(vcpu, 4, "%s", "interrupt: cpu stop"); 195 vcpu->stat.deliver_stop_signal++; 196 __set_intercept_indicator(vcpu, inti); 197 break; 198 199 case KVM_S390_SIGP_SET_PREFIX: 200 VCPU_EVENT(vcpu, 4, "interrupt: set prefix to %x", 201 inti->prefix.address); 202 vcpu->stat.deliver_prefix_signal++; 203 vcpu->arch.sie_block->prefix = inti->prefix.address; 204 vcpu->arch.sie_block->ihcpu = 0xffff; 205 break; 206 207 case KVM_S390_RESTART: 208 VCPU_EVENT(vcpu, 4, "%s", "interrupt: cpu restart"); 209 vcpu->stat.deliver_restart_signal++; 210 rc = copy_to_guest(vcpu, offsetof(struct _lowcore, 211 restart_old_psw), &vcpu->arch.sie_block->gpsw, sizeof(psw_t)); 212 if (rc == -EFAULT) 213 exception = 1; 214 215 rc = copy_from_guest(vcpu, &vcpu->arch.sie_block->gpsw, 216 offsetof(struct _lowcore, restart_psw), sizeof(psw_t)); 217 if (rc == -EFAULT) 218 exception = 1; 219 break; 220 221 case KVM_S390_PROGRAM_INT: 222 VCPU_EVENT(vcpu, 4, "interrupt: pgm check code:%x, ilc:%x", 223 inti->pgm.code, 224 table[vcpu->arch.sie_block->ipa >> 14]); 225 vcpu->stat.deliver_program_int++; 226 rc = put_guest_u16(vcpu, __LC_PGM_INT_CODE, inti->pgm.code); 227 if (rc == -EFAULT) 228 exception = 1; 229 230 rc = put_guest_u16(vcpu, __LC_PGM_ILC, 231 table[vcpu->arch.sie_block->ipa >> 14]); 232 if (rc == -EFAULT) 233 exception = 1; 234 235 rc = copy_to_guest(vcpu, __LC_PGM_OLD_PSW, 236 &vcpu->arch.sie_block->gpsw, sizeof(psw_t)); 237 if (rc == -EFAULT) 238 exception = 1; 239 240 rc = copy_from_guest(vcpu, &vcpu->arch.sie_block->gpsw, 241 __LC_PGM_NEW_PSW, sizeof(psw_t)); 242 if (rc == -EFAULT) 243 exception = 1; 244 break; 245 246 default: 247 BUG(); 248 } 249 250 if (exception) { 251 VCPU_EVENT(vcpu, 1, "%s", "program exception while delivering" 252 " interrupt"); 253 kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING); 254 if (inti->type == KVM_S390_PROGRAM_INT) { 255 printk(KERN_WARNING "kvm: recursive program check\n"); 256 BUG(); 257 } 258 } 259 } 260 261 static int __try_deliver_ckc_interrupt(struct kvm_vcpu *vcpu) 262 { 263 int rc, exception = 0; 264 265 if (psw_extint_disabled(vcpu)) 266 return 0; 267 if (!(vcpu->arch.sie_block->gcr[0] & 0x800ul)) 268 return 0; 269 rc = put_guest_u16(vcpu, __LC_EXT_INT_CODE, 0x1004); 270 if (rc == -EFAULT) 271 exception = 1; 272 rc = copy_to_guest(vcpu, __LC_EXT_OLD_PSW, 273 &vcpu->arch.sie_block->gpsw, sizeof(psw_t)); 274 if (rc == -EFAULT) 275 exception = 1; 276 rc = copy_from_guest(vcpu, &vcpu->arch.sie_block->gpsw, 277 __LC_EXT_NEW_PSW, sizeof(psw_t)); 278 if (rc == -EFAULT) 279 exception = 1; 280 281 if (exception) { 282 VCPU_EVENT(vcpu, 1, "%s", "program exception while delivering" \ 283 " ckc interrupt"); 284 kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING); 285 return 0; 286 } 287 288 return 1; 289 } 290 291 int kvm_cpu_has_interrupt(struct kvm_vcpu *vcpu) 292 { 293 struct local_interrupt *li = &vcpu->arch.local_int; 294 struct float_interrupt *fi = vcpu->arch.local_int.float_int; 295 struct interrupt_info *inti; 296 int rc = 0; 297 298 if (atomic_read(&li->active)) { 299 spin_lock_bh(&li->lock); 300 list_for_each_entry(inti, &li->list, list) 301 if (__interrupt_is_deliverable(vcpu, inti)) { 302 rc = 1; 303 break; 304 } 305 spin_unlock_bh(&li->lock); 306 } 307 308 if ((!rc) && atomic_read(&fi->active)) { 309 spin_lock_bh(&fi->lock); 310 list_for_each_entry(inti, &fi->list, list) 311 if (__interrupt_is_deliverable(vcpu, inti)) { 312 rc = 1; 313 break; 314 } 315 spin_unlock_bh(&fi->lock); 316 } 317 318 if ((!rc) && (vcpu->arch.sie_block->ckc < 319 get_clock() + vcpu->arch.sie_block->epoch)) { 320 if ((!psw_extint_disabled(vcpu)) && 321 (vcpu->arch.sie_block->gcr[0] & 0x800ul)) 322 rc = 1; 323 } 324 325 return rc; 326 } 327 328 int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu) 329 { 330 return 0; 331 } 332 333 int kvm_s390_handle_wait(struct kvm_vcpu *vcpu) 334 { 335 u64 now, sltime; 336 DECLARE_WAITQUEUE(wait, current); 337 338 vcpu->stat.exit_wait_state++; 339 if (kvm_cpu_has_interrupt(vcpu)) 340 return 0; 341 342 if (psw_interrupts_disabled(vcpu)) { 343 VCPU_EVENT(vcpu, 3, "%s", "disabled wait"); 344 __unset_cpu_idle(vcpu); 345 return -ENOTSUPP; /* disabled wait */ 346 } 347 348 if (psw_extint_disabled(vcpu) || 349 (!(vcpu->arch.sie_block->gcr[0] & 0x800ul))) { 350 VCPU_EVENT(vcpu, 3, "%s", "enabled wait w/o timer"); 351 goto no_timer; 352 } 353 354 now = get_clock() + vcpu->arch.sie_block->epoch; 355 if (vcpu->arch.sie_block->ckc < now) { 356 __unset_cpu_idle(vcpu); 357 return 0; 358 } 359 360 sltime = (vcpu->arch.sie_block->ckc - now) / (0xf4240000ul / HZ) + 1; 361 362 vcpu->arch.ckc_timer.expires = jiffies + sltime; 363 364 add_timer(&vcpu->arch.ckc_timer); 365 VCPU_EVENT(vcpu, 5, "enabled wait timer:%lx jiffies", sltime); 366 no_timer: 367 spin_lock_bh(&vcpu->arch.local_int.float_int->lock); 368 spin_lock_bh(&vcpu->arch.local_int.lock); 369 __set_cpu_idle(vcpu); 370 vcpu->arch.local_int.timer_due = 0; 371 add_wait_queue(&vcpu->arch.local_int.wq, &wait); 372 while (list_empty(&vcpu->arch.local_int.list) && 373 list_empty(&vcpu->arch.local_int.float_int->list) && 374 (!vcpu->arch.local_int.timer_due) && 375 !signal_pending(current)) { 376 set_current_state(TASK_INTERRUPTIBLE); 377 spin_unlock_bh(&vcpu->arch.local_int.lock); 378 spin_unlock_bh(&vcpu->arch.local_int.float_int->lock); 379 vcpu_put(vcpu); 380 schedule(); 381 vcpu_load(vcpu); 382 spin_lock_bh(&vcpu->arch.local_int.float_int->lock); 383 spin_lock_bh(&vcpu->arch.local_int.lock); 384 } 385 __unset_cpu_idle(vcpu); 386 __set_current_state(TASK_RUNNING); 387 remove_wait_queue(&vcpu->wq, &wait); 388 spin_unlock_bh(&vcpu->arch.local_int.lock); 389 spin_unlock_bh(&vcpu->arch.local_int.float_int->lock); 390 del_timer(&vcpu->arch.ckc_timer); 391 return 0; 392 } 393 394 void kvm_s390_idle_wakeup(unsigned long data) 395 { 396 struct kvm_vcpu *vcpu = (struct kvm_vcpu *)data; 397 398 spin_lock_bh(&vcpu->arch.local_int.lock); 399 vcpu->arch.local_int.timer_due = 1; 400 if (waitqueue_active(&vcpu->arch.local_int.wq)) 401 wake_up_interruptible(&vcpu->arch.local_int.wq); 402 spin_unlock_bh(&vcpu->arch.local_int.lock); 403 } 404 405 406 void kvm_s390_deliver_pending_interrupts(struct kvm_vcpu *vcpu) 407 { 408 struct local_interrupt *li = &vcpu->arch.local_int; 409 struct float_interrupt *fi = vcpu->arch.local_int.float_int; 410 struct interrupt_info *n, *inti = NULL; 411 int deliver; 412 413 __reset_intercept_indicators(vcpu); 414 if (atomic_read(&li->active)) { 415 do { 416 deliver = 0; 417 spin_lock_bh(&li->lock); 418 list_for_each_entry_safe(inti, n, &li->list, list) { 419 if (__interrupt_is_deliverable(vcpu, inti)) { 420 list_del(&inti->list); 421 deliver = 1; 422 break; 423 } 424 __set_intercept_indicator(vcpu, inti); 425 } 426 if (list_empty(&li->list)) 427 atomic_set(&li->active, 0); 428 spin_unlock_bh(&li->lock); 429 if (deliver) { 430 __do_deliver_interrupt(vcpu, inti); 431 kfree(inti); 432 } 433 } while (deliver); 434 } 435 436 if ((vcpu->arch.sie_block->ckc < 437 get_clock() + vcpu->arch.sie_block->epoch)) 438 __try_deliver_ckc_interrupt(vcpu); 439 440 if (atomic_read(&fi->active)) { 441 do { 442 deliver = 0; 443 spin_lock_bh(&fi->lock); 444 list_for_each_entry_safe(inti, n, &fi->list, list) { 445 if (__interrupt_is_deliverable(vcpu, inti)) { 446 list_del(&inti->list); 447 deliver = 1; 448 break; 449 } 450 __set_intercept_indicator(vcpu, inti); 451 } 452 if (list_empty(&fi->list)) 453 atomic_set(&fi->active, 0); 454 spin_unlock_bh(&fi->lock); 455 if (deliver) { 456 __do_deliver_interrupt(vcpu, inti); 457 kfree(inti); 458 } 459 } while (deliver); 460 } 461 } 462 463 int kvm_s390_inject_program_int(struct kvm_vcpu *vcpu, u16 code) 464 { 465 struct local_interrupt *li = &vcpu->arch.local_int; 466 struct interrupt_info *inti; 467 468 inti = kzalloc(sizeof(*inti), GFP_KERNEL); 469 if (!inti) 470 return -ENOMEM; 471 472 inti->type = KVM_S390_PROGRAM_INT;; 473 inti->pgm.code = code; 474 475 VCPU_EVENT(vcpu, 3, "inject: program check %d (from kernel)", code); 476 spin_lock_bh(&li->lock); 477 list_add(&inti->list, &li->list); 478 atomic_set(&li->active, 1); 479 BUG_ON(waitqueue_active(&li->wq)); 480 spin_unlock_bh(&li->lock); 481 return 0; 482 } 483 484 int kvm_s390_inject_vm(struct kvm *kvm, 485 struct kvm_s390_interrupt *s390int) 486 { 487 struct local_interrupt *li; 488 struct float_interrupt *fi; 489 struct interrupt_info *inti; 490 int sigcpu; 491 492 inti = kzalloc(sizeof(*inti), GFP_KERNEL); 493 if (!inti) 494 return -ENOMEM; 495 496 switch (s390int->type) { 497 case KVM_S390_INT_VIRTIO: 498 VM_EVENT(kvm, 5, "inject: virtio parm:%x,parm64:%lx", 499 s390int->parm, s390int->parm64); 500 inti->type = s390int->type; 501 inti->ext.ext_params = s390int->parm; 502 inti->ext.ext_params2 = s390int->parm64; 503 break; 504 case KVM_S390_INT_SERVICE: 505 VM_EVENT(kvm, 5, "inject: sclp parm:%x", s390int->parm); 506 inti->type = s390int->type; 507 inti->ext.ext_params = s390int->parm; 508 break; 509 case KVM_S390_PROGRAM_INT: 510 case KVM_S390_SIGP_STOP: 511 case KVM_S390_INT_EMERGENCY: 512 default: 513 kfree(inti); 514 return -EINVAL; 515 } 516 517 mutex_lock(&kvm->lock); 518 fi = &kvm->arch.float_int; 519 spin_lock_bh(&fi->lock); 520 list_add_tail(&inti->list, &fi->list); 521 atomic_set(&fi->active, 1); 522 sigcpu = find_first_bit(fi->idle_mask, KVM_MAX_VCPUS); 523 if (sigcpu == KVM_MAX_VCPUS) { 524 do { 525 sigcpu = fi->next_rr_cpu++; 526 if (sigcpu == KVM_MAX_VCPUS) 527 sigcpu = fi->next_rr_cpu = 0; 528 } while (fi->local_int[sigcpu] == NULL); 529 } 530 li = fi->local_int[sigcpu]; 531 spin_lock_bh(&li->lock); 532 atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags); 533 if (waitqueue_active(&li->wq)) 534 wake_up_interruptible(&li->wq); 535 spin_unlock_bh(&li->lock); 536 spin_unlock_bh(&fi->lock); 537 mutex_unlock(&kvm->lock); 538 return 0; 539 } 540 541 int kvm_s390_inject_vcpu(struct kvm_vcpu *vcpu, 542 struct kvm_s390_interrupt *s390int) 543 { 544 struct local_interrupt *li; 545 struct interrupt_info *inti; 546 547 inti = kzalloc(sizeof(*inti), GFP_KERNEL); 548 if (!inti) 549 return -ENOMEM; 550 551 switch (s390int->type) { 552 case KVM_S390_PROGRAM_INT: 553 if (s390int->parm & 0xffff0000) { 554 kfree(inti); 555 return -EINVAL; 556 } 557 inti->type = s390int->type; 558 inti->pgm.code = s390int->parm; 559 VCPU_EVENT(vcpu, 3, "inject: program check %d (from user)", 560 s390int->parm); 561 break; 562 case KVM_S390_SIGP_STOP: 563 case KVM_S390_RESTART: 564 case KVM_S390_SIGP_SET_PREFIX: 565 case KVM_S390_INT_EMERGENCY: 566 VCPU_EVENT(vcpu, 3, "inject: type %x", s390int->type); 567 inti->type = s390int->type; 568 break; 569 case KVM_S390_INT_VIRTIO: 570 case KVM_S390_INT_SERVICE: 571 default: 572 kfree(inti); 573 return -EINVAL; 574 } 575 576 mutex_lock(&vcpu->kvm->lock); 577 li = &vcpu->arch.local_int; 578 spin_lock_bh(&li->lock); 579 if (inti->type == KVM_S390_PROGRAM_INT) 580 list_add(&inti->list, &li->list); 581 else 582 list_add_tail(&inti->list, &li->list); 583 atomic_set(&li->active, 1); 584 if (inti->type == KVM_S390_SIGP_STOP) 585 li->action_bits |= ACTION_STOP_ON_STOP; 586 atomic_set_mask(CPUSTAT_EXT_INT, li->cpuflags); 587 if (waitqueue_active(&li->wq)) 588 wake_up_interruptible(&vcpu->arch.local_int.wq); 589 spin_unlock_bh(&li->lock); 590 mutex_unlock(&vcpu->kvm->lock); 591 return 0; 592 } 593