1 /* 2 * s390host.c -- hosting zSeries kernel virtual machines 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 * Christian Borntraeger <borntraeger@de.ibm.com> 12 * Heiko Carstens <heiko.carstens@de.ibm.com> 13 */ 14 15 #include <linux/compiler.h> 16 #include <linux/err.h> 17 #include <linux/fs.h> 18 #include <linux/init.h> 19 #include <linux/kvm.h> 20 #include <linux/kvm_host.h> 21 #include <linux/module.h> 22 #include <linux/slab.h> 23 #include <linux/timer.h> 24 #include <asm/lowcore.h> 25 #include <asm/pgtable.h> 26 27 #include "kvm-s390.h" 28 #include "gaccess.h" 29 30 #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU 31 32 struct kvm_stats_debugfs_item debugfs_entries[] = { 33 { "userspace_handled", VCPU_STAT(exit_userspace) }, 34 { "exit_null", VCPU_STAT(exit_null) }, 35 { "exit_validity", VCPU_STAT(exit_validity) }, 36 { "exit_stop_request", VCPU_STAT(exit_stop_request) }, 37 { "exit_external_request", VCPU_STAT(exit_external_request) }, 38 { "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) }, 39 { "exit_instruction", VCPU_STAT(exit_instruction) }, 40 { "exit_program_interruption", VCPU_STAT(exit_program_interruption) }, 41 { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) }, 42 { "instruction_lctlg", VCPU_STAT(instruction_lctlg) }, 43 { "instruction_lctl", VCPU_STAT(instruction_lctl) }, 44 { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) }, 45 { "deliver_service_signal", VCPU_STAT(deliver_service_signal) }, 46 { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) }, 47 { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) }, 48 { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) }, 49 { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) }, 50 { "deliver_program_interruption", VCPU_STAT(deliver_program_int) }, 51 { "exit_wait_state", VCPU_STAT(exit_wait_state) }, 52 { "instruction_stidp", VCPU_STAT(instruction_stidp) }, 53 { "instruction_spx", VCPU_STAT(instruction_spx) }, 54 { "instruction_stpx", VCPU_STAT(instruction_stpx) }, 55 { "instruction_stap", VCPU_STAT(instruction_stap) }, 56 { "instruction_storage_key", VCPU_STAT(instruction_storage_key) }, 57 { "instruction_stsch", VCPU_STAT(instruction_stsch) }, 58 { "instruction_chsc", VCPU_STAT(instruction_chsc) }, 59 { "instruction_stsi", VCPU_STAT(instruction_stsi) }, 60 { "instruction_stfl", VCPU_STAT(instruction_stfl) }, 61 { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) }, 62 { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) }, 63 { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) }, 64 { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) }, 65 { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) }, 66 { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) }, 67 { "diagnose_44", VCPU_STAT(diagnose_44) }, 68 { NULL } 69 }; 70 71 72 /* Section: not file related */ 73 void kvm_arch_hardware_enable(void *garbage) 74 { 75 /* every s390 is virtualization enabled ;-) */ 76 } 77 78 void kvm_arch_hardware_disable(void *garbage) 79 { 80 } 81 82 int kvm_arch_hardware_setup(void) 83 { 84 return 0; 85 } 86 87 void kvm_arch_hardware_unsetup(void) 88 { 89 } 90 91 void kvm_arch_check_processor_compat(void *rtn) 92 { 93 } 94 95 int kvm_arch_init(void *opaque) 96 { 97 return 0; 98 } 99 100 void kvm_arch_exit(void) 101 { 102 } 103 104 /* Section: device related */ 105 long kvm_arch_dev_ioctl(struct file *filp, 106 unsigned int ioctl, unsigned long arg) 107 { 108 if (ioctl == KVM_S390_ENABLE_SIE) 109 return s390_enable_sie(); 110 return -EINVAL; 111 } 112 113 int kvm_dev_ioctl_check_extension(long ext) 114 { 115 switch (ext) { 116 case KVM_CAP_USER_MEMORY: 117 return 1; 118 default: 119 return 0; 120 } 121 } 122 123 /* Section: vm related */ 124 /* 125 * Get (and clear) the dirty memory log for a memory slot. 126 */ 127 int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, 128 struct kvm_dirty_log *log) 129 { 130 return 0; 131 } 132 133 long kvm_arch_vm_ioctl(struct file *filp, 134 unsigned int ioctl, unsigned long arg) 135 { 136 struct kvm *kvm = filp->private_data; 137 void __user *argp = (void __user *)arg; 138 int r; 139 140 switch (ioctl) { 141 case KVM_S390_INTERRUPT: { 142 struct kvm_s390_interrupt s390int; 143 144 r = -EFAULT; 145 if (copy_from_user(&s390int, argp, sizeof(s390int))) 146 break; 147 r = kvm_s390_inject_vm(kvm, &s390int); 148 break; 149 } 150 default: 151 r = -EINVAL; 152 } 153 154 return r; 155 } 156 157 struct kvm *kvm_arch_create_vm(void) 158 { 159 struct kvm *kvm; 160 int rc; 161 char debug_name[16]; 162 163 rc = s390_enable_sie(); 164 if (rc) 165 goto out_nokvm; 166 167 rc = -ENOMEM; 168 kvm = kzalloc(sizeof(struct kvm), GFP_KERNEL); 169 if (!kvm) 170 goto out_nokvm; 171 172 kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL); 173 if (!kvm->arch.sca) 174 goto out_nosca; 175 176 sprintf(debug_name, "kvm-%u", current->pid); 177 178 kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long)); 179 if (!kvm->arch.dbf) 180 goto out_nodbf; 181 182 spin_lock_init(&kvm->arch.float_int.lock); 183 INIT_LIST_HEAD(&kvm->arch.float_int.list); 184 185 debug_register_view(kvm->arch.dbf, &debug_sprintf_view); 186 VM_EVENT(kvm, 3, "%s", "vm created"); 187 188 try_module_get(THIS_MODULE); 189 190 return kvm; 191 out_nodbf: 192 free_page((unsigned long)(kvm->arch.sca)); 193 out_nosca: 194 kfree(kvm); 195 out_nokvm: 196 return ERR_PTR(rc); 197 } 198 199 void kvm_arch_destroy_vm(struct kvm *kvm) 200 { 201 debug_unregister(kvm->arch.dbf); 202 kvm_free_physmem(kvm); 203 free_page((unsigned long)(kvm->arch.sca)); 204 kfree(kvm); 205 module_put(THIS_MODULE); 206 } 207 208 /* Section: vcpu related */ 209 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) 210 { 211 return 0; 212 } 213 214 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) 215 { 216 /* kvm common code refers to this, but does'nt call it */ 217 BUG(); 218 } 219 220 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) 221 { 222 save_fp_regs(&vcpu->arch.host_fpregs); 223 save_access_regs(vcpu->arch.host_acrs); 224 vcpu->arch.guest_fpregs.fpc &= FPC_VALID_MASK; 225 restore_fp_regs(&vcpu->arch.guest_fpregs); 226 restore_access_regs(vcpu->arch.guest_acrs); 227 } 228 229 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) 230 { 231 save_fp_regs(&vcpu->arch.guest_fpregs); 232 save_access_regs(vcpu->arch.guest_acrs); 233 restore_fp_regs(&vcpu->arch.host_fpregs); 234 restore_access_regs(vcpu->arch.host_acrs); 235 } 236 237 static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu) 238 { 239 /* this equals initial cpu reset in pop, but we don't switch to ESA */ 240 vcpu->arch.sie_block->gpsw.mask = 0UL; 241 vcpu->arch.sie_block->gpsw.addr = 0UL; 242 vcpu->arch.sie_block->prefix = 0UL; 243 vcpu->arch.sie_block->ihcpu = 0xffff; 244 vcpu->arch.sie_block->cputm = 0UL; 245 vcpu->arch.sie_block->ckc = 0UL; 246 vcpu->arch.sie_block->todpr = 0; 247 memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64)); 248 vcpu->arch.sie_block->gcr[0] = 0xE0UL; 249 vcpu->arch.sie_block->gcr[14] = 0xC2000000UL; 250 vcpu->arch.guest_fpregs.fpc = 0; 251 asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc)); 252 vcpu->arch.sie_block->gbea = 1; 253 } 254 255 /* The current code can have up to 256 pages for virtio */ 256 #define VIRTIODESCSPACE (256ul * 4096ul) 257 258 int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) 259 { 260 atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH); 261 vcpu->arch.sie_block->gmslm = vcpu->kvm->arch.guest_memsize + 262 vcpu->kvm->arch.guest_origin + 263 VIRTIODESCSPACE - 1ul; 264 vcpu->arch.sie_block->gmsor = vcpu->kvm->arch.guest_origin; 265 vcpu->arch.sie_block->ecb = 2; 266 vcpu->arch.sie_block->eca = 0xC1002001U; 267 setup_timer(&vcpu->arch.ckc_timer, kvm_s390_idle_wakeup, 268 (unsigned long) vcpu); 269 get_cpu_id(&vcpu->arch.cpu_id); 270 vcpu->arch.cpu_id.version = 0xfe; 271 return 0; 272 } 273 274 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, 275 unsigned int id) 276 { 277 struct kvm_vcpu *vcpu = kzalloc(sizeof(struct kvm_vcpu), GFP_KERNEL); 278 int rc = -ENOMEM; 279 280 if (!vcpu) 281 goto out_nomem; 282 283 vcpu->arch.sie_block = (struct kvm_s390_sie_block *) 284 get_zeroed_page(GFP_KERNEL); 285 286 if (!vcpu->arch.sie_block) 287 goto out_free_cpu; 288 289 vcpu->arch.sie_block->icpua = id; 290 BUG_ON(!kvm->arch.sca); 291 BUG_ON(kvm->arch.sca->cpu[id].sda); 292 kvm->arch.sca->cpu[id].sda = (__u64) vcpu->arch.sie_block; 293 vcpu->arch.sie_block->scaoh = (__u32)(((__u64)kvm->arch.sca) >> 32); 294 vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca; 295 296 spin_lock_init(&vcpu->arch.local_int.lock); 297 INIT_LIST_HEAD(&vcpu->arch.local_int.list); 298 vcpu->arch.local_int.float_int = &kvm->arch.float_int; 299 spin_lock_bh(&kvm->arch.float_int.lock); 300 kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int; 301 init_waitqueue_head(&vcpu->arch.local_int.wq); 302 vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags; 303 spin_unlock_bh(&kvm->arch.float_int.lock); 304 305 rc = kvm_vcpu_init(vcpu, kvm, id); 306 if (rc) 307 goto out_free_cpu; 308 VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu, 309 vcpu->arch.sie_block); 310 311 try_module_get(THIS_MODULE); 312 313 return vcpu; 314 out_free_cpu: 315 kfree(vcpu); 316 out_nomem: 317 return ERR_PTR(rc); 318 } 319 320 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) 321 { 322 VCPU_EVENT(vcpu, 3, "%s", "destroy cpu"); 323 free_page((unsigned long)(vcpu->arch.sie_block)); 324 kfree(vcpu); 325 module_put(THIS_MODULE); 326 } 327 328 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu) 329 { 330 /* kvm common code refers to this, but never calls it */ 331 BUG(); 332 return 0; 333 } 334 335 static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu) 336 { 337 vcpu_load(vcpu); 338 kvm_s390_vcpu_initial_reset(vcpu); 339 vcpu_put(vcpu); 340 return 0; 341 } 342 343 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 344 { 345 vcpu_load(vcpu); 346 memcpy(&vcpu->arch.guest_gprs, ®s->gprs, sizeof(regs->gprs)); 347 vcpu_put(vcpu); 348 return 0; 349 } 350 351 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) 352 { 353 vcpu_load(vcpu); 354 memcpy(®s->gprs, &vcpu->arch.guest_gprs, sizeof(regs->gprs)); 355 vcpu_put(vcpu); 356 return 0; 357 } 358 359 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, 360 struct kvm_sregs *sregs) 361 { 362 vcpu_load(vcpu); 363 memcpy(&vcpu->arch.guest_acrs, &sregs->acrs, sizeof(sregs->acrs)); 364 memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs)); 365 vcpu_put(vcpu); 366 return 0; 367 } 368 369 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, 370 struct kvm_sregs *sregs) 371 { 372 vcpu_load(vcpu); 373 memcpy(&sregs->acrs, &vcpu->arch.guest_acrs, sizeof(sregs->acrs)); 374 memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs)); 375 vcpu_put(vcpu); 376 return 0; 377 } 378 379 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 380 { 381 vcpu_load(vcpu); 382 memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs)); 383 vcpu->arch.guest_fpregs.fpc = fpu->fpc; 384 vcpu_put(vcpu); 385 return 0; 386 } 387 388 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) 389 { 390 vcpu_load(vcpu); 391 memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs)); 392 fpu->fpc = vcpu->arch.guest_fpregs.fpc; 393 vcpu_put(vcpu); 394 return 0; 395 } 396 397 static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw) 398 { 399 int rc = 0; 400 401 vcpu_load(vcpu); 402 if (atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_RUNNING) 403 rc = -EBUSY; 404 else 405 vcpu->arch.sie_block->gpsw = psw; 406 vcpu_put(vcpu); 407 return rc; 408 } 409 410 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu, 411 struct kvm_translation *tr) 412 { 413 return -EINVAL; /* not implemented yet */ 414 } 415 416 int kvm_arch_vcpu_ioctl_debug_guest(struct kvm_vcpu *vcpu, 417 struct kvm_debug_guest *dbg) 418 { 419 return -EINVAL; /* not implemented yet */ 420 } 421 422 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, 423 struct kvm_mp_state *mp_state) 424 { 425 return -EINVAL; /* not implemented yet */ 426 } 427 428 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, 429 struct kvm_mp_state *mp_state) 430 { 431 return -EINVAL; /* not implemented yet */ 432 } 433 434 extern void s390_handle_mcck(void); 435 436 static void __vcpu_run(struct kvm_vcpu *vcpu) 437 { 438 memcpy(&vcpu->arch.sie_block->gg14, &vcpu->arch.guest_gprs[14], 16); 439 440 if (need_resched()) 441 schedule(); 442 443 if (test_thread_flag(TIF_MCCK_PENDING)) 444 s390_handle_mcck(); 445 446 kvm_s390_deliver_pending_interrupts(vcpu); 447 448 vcpu->arch.sie_block->icptcode = 0; 449 local_irq_disable(); 450 kvm_guest_enter(); 451 local_irq_enable(); 452 VCPU_EVENT(vcpu, 6, "entering sie flags %x", 453 atomic_read(&vcpu->arch.sie_block->cpuflags)); 454 if (sie64a(vcpu->arch.sie_block, vcpu->arch.guest_gprs)) { 455 VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction"); 456 kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING); 457 } 458 VCPU_EVENT(vcpu, 6, "exit sie icptcode %d", 459 vcpu->arch.sie_block->icptcode); 460 local_irq_disable(); 461 kvm_guest_exit(); 462 local_irq_enable(); 463 464 memcpy(&vcpu->arch.guest_gprs[14], &vcpu->arch.sie_block->gg14, 16); 465 } 466 467 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run) 468 { 469 int rc; 470 sigset_t sigsaved; 471 472 vcpu_load(vcpu); 473 474 if (vcpu->sigset_active) 475 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved); 476 477 atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags); 478 479 BUG_ON(vcpu->kvm->arch.float_int.local_int[vcpu->vcpu_id] == NULL); 480 481 switch (kvm_run->exit_reason) { 482 case KVM_EXIT_S390_SIEIC: 483 vcpu->arch.sie_block->gpsw.mask = kvm_run->s390_sieic.mask; 484 vcpu->arch.sie_block->gpsw.addr = kvm_run->s390_sieic.addr; 485 break; 486 case KVM_EXIT_UNKNOWN: 487 case KVM_EXIT_S390_RESET: 488 break; 489 default: 490 BUG(); 491 } 492 493 might_sleep(); 494 495 do { 496 __vcpu_run(vcpu); 497 rc = kvm_handle_sie_intercept(vcpu); 498 } while (!signal_pending(current) && !rc); 499 500 if (signal_pending(current) && !rc) 501 rc = -EINTR; 502 503 if (rc == -ENOTSUPP) { 504 /* intercept cannot be handled in-kernel, prepare kvm-run */ 505 kvm_run->exit_reason = KVM_EXIT_S390_SIEIC; 506 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode; 507 kvm_run->s390_sieic.mask = vcpu->arch.sie_block->gpsw.mask; 508 kvm_run->s390_sieic.addr = vcpu->arch.sie_block->gpsw.addr; 509 kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa; 510 kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb; 511 rc = 0; 512 } 513 514 if (rc == -EREMOTE) { 515 /* intercept was handled, but userspace support is needed 516 * kvm_run has been prepared by the handler */ 517 rc = 0; 518 } 519 520 if (vcpu->sigset_active) 521 sigprocmask(SIG_SETMASK, &sigsaved, NULL); 522 523 vcpu_put(vcpu); 524 525 vcpu->stat.exit_userspace++; 526 return rc; 527 } 528 529 static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, const void *from, 530 unsigned long n, int prefix) 531 { 532 if (prefix) 533 return copy_to_guest(vcpu, guestdest, from, n); 534 else 535 return copy_to_guest_absolute(vcpu, guestdest, from, n); 536 } 537 538 /* 539 * store status at address 540 * we use have two special cases: 541 * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit 542 * KVM_S390_STORE_STATUS_PREFIXED: -> prefix 543 */ 544 int __kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr) 545 { 546 const unsigned char archmode = 1; 547 int prefix; 548 549 if (addr == KVM_S390_STORE_STATUS_NOADDR) { 550 if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1)) 551 return -EFAULT; 552 addr = SAVE_AREA_BASE; 553 prefix = 0; 554 } else if (addr == KVM_S390_STORE_STATUS_PREFIXED) { 555 if (copy_to_guest(vcpu, 163ul, &archmode, 1)) 556 return -EFAULT; 557 addr = SAVE_AREA_BASE; 558 prefix = 1; 559 } else 560 prefix = 0; 561 562 if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, fp_regs), 563 vcpu->arch.guest_fpregs.fprs, 128, prefix)) 564 return -EFAULT; 565 566 if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, gp_regs), 567 vcpu->arch.guest_gprs, 128, prefix)) 568 return -EFAULT; 569 570 if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, psw), 571 &vcpu->arch.sie_block->gpsw, 16, prefix)) 572 return -EFAULT; 573 574 if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, pref_reg), 575 &vcpu->arch.sie_block->prefix, 4, prefix)) 576 return -EFAULT; 577 578 if (__guestcopy(vcpu, 579 addr + offsetof(struct save_area_s390x, fp_ctrl_reg), 580 &vcpu->arch.guest_fpregs.fpc, 4, prefix)) 581 return -EFAULT; 582 583 if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, tod_reg), 584 &vcpu->arch.sie_block->todpr, 4, prefix)) 585 return -EFAULT; 586 587 if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, timer), 588 &vcpu->arch.sie_block->cputm, 8, prefix)) 589 return -EFAULT; 590 591 if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, clk_cmp), 592 &vcpu->arch.sie_block->ckc, 8, prefix)) 593 return -EFAULT; 594 595 if (__guestcopy(vcpu, addr + offsetof(struct save_area_s390x, acc_regs), 596 &vcpu->arch.guest_acrs, 64, prefix)) 597 return -EFAULT; 598 599 if (__guestcopy(vcpu, 600 addr + offsetof(struct save_area_s390x, ctrl_regs), 601 &vcpu->arch.sie_block->gcr, 128, prefix)) 602 return -EFAULT; 603 return 0; 604 } 605 606 static int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr) 607 { 608 int rc; 609 610 vcpu_load(vcpu); 611 rc = __kvm_s390_vcpu_store_status(vcpu, addr); 612 vcpu_put(vcpu); 613 return rc; 614 } 615 616 long kvm_arch_vcpu_ioctl(struct file *filp, 617 unsigned int ioctl, unsigned long arg) 618 { 619 struct kvm_vcpu *vcpu = filp->private_data; 620 void __user *argp = (void __user *)arg; 621 622 switch (ioctl) { 623 case KVM_S390_INTERRUPT: { 624 struct kvm_s390_interrupt s390int; 625 626 if (copy_from_user(&s390int, argp, sizeof(s390int))) 627 return -EFAULT; 628 return kvm_s390_inject_vcpu(vcpu, &s390int); 629 } 630 case KVM_S390_STORE_STATUS: 631 return kvm_s390_vcpu_store_status(vcpu, arg); 632 case KVM_S390_SET_INITIAL_PSW: { 633 psw_t psw; 634 635 if (copy_from_user(&psw, argp, sizeof(psw))) 636 return -EFAULT; 637 return kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw); 638 } 639 case KVM_S390_INITIAL_RESET: 640 return kvm_arch_vcpu_ioctl_initial_reset(vcpu); 641 default: 642 ; 643 } 644 return -EINVAL; 645 } 646 647 /* Section: memory related */ 648 int kvm_arch_set_memory_region(struct kvm *kvm, 649 struct kvm_userspace_memory_region *mem, 650 struct kvm_memory_slot old, 651 int user_alloc) 652 { 653 /* A few sanity checks. We can have exactly one memory slot which has 654 to start at guest virtual zero and which has to be located at a 655 page boundary in userland and which has to end at a page boundary. 656 The memory in userland is ok to be fragmented into various different 657 vmas. It is okay to mmap() and munmap() stuff in this slot after 658 doing this call at any time */ 659 660 if (mem->slot) 661 return -EINVAL; 662 663 if (mem->guest_phys_addr) 664 return -EINVAL; 665 666 if (mem->userspace_addr & (PAGE_SIZE - 1)) 667 return -EINVAL; 668 669 if (mem->memory_size & (PAGE_SIZE - 1)) 670 return -EINVAL; 671 672 kvm->arch.guest_origin = mem->userspace_addr; 673 kvm->arch.guest_memsize = mem->memory_size; 674 675 /* FIXME: we do want to interrupt running CPUs and update their memory 676 configuration now to avoid race conditions. But hey, changing the 677 memory layout while virtual CPUs are running is usually bad 678 programming practice. */ 679 680 return 0; 681 } 682 683 void kvm_arch_flush_shadow(struct kvm *kvm) 684 { 685 } 686 687 gfn_t unalias_gfn(struct kvm *kvm, gfn_t gfn) 688 { 689 return gfn; 690 } 691 692 static int __init kvm_s390_init(void) 693 { 694 return kvm_init(NULL, sizeof(struct kvm_vcpu), THIS_MODULE); 695 } 696 697 static void __exit kvm_s390_exit(void) 698 { 699 kvm_exit(); 700 } 701 702 module_init(kvm_s390_init); 703 module_exit(kvm_s390_exit); 704