~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/s390/kvm/kvm-s390.c

Version: ~ [ linux-5.9 ] ~ [ linux-5.8.14 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.70 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.150 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.200 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.238 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.238 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * hosting zSeries kernel virtual machines
  3  *
  4  * Copyright IBM Corp. 2008, 2009
  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  *               Christian Ehrhardt <ehrhardt@de.ibm.com>
 14  */
 15 
 16 #include <linux/compiler.h>
 17 #include <linux/err.h>
 18 #include <linux/fs.h>
 19 #include <linux/hrtimer.h>
 20 #include <linux/init.h>
 21 #include <linux/kvm.h>
 22 #include <linux/kvm_host.h>
 23 #include <linux/module.h>
 24 #include <linux/slab.h>
 25 #include <linux/timer.h>
 26 #include <asm/asm-offsets.h>
 27 #include <asm/lowcore.h>
 28 #include <asm/pgtable.h>
 29 #include <asm/nmi.h>
 30 #include <asm/switch_to.h>
 31 #include <asm/sclp.h>
 32 #include "kvm-s390.h"
 33 #include "gaccess.h"
 34 
 35 #define CREATE_TRACE_POINTS
 36 #include "trace.h"
 37 #include "trace-s390.h"
 38 
 39 #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU
 40 
 41 struct kvm_stats_debugfs_item debugfs_entries[] = {
 42         { "userspace_handled", VCPU_STAT(exit_userspace) },
 43         { "exit_null", VCPU_STAT(exit_null) },
 44         { "exit_validity", VCPU_STAT(exit_validity) },
 45         { "exit_stop_request", VCPU_STAT(exit_stop_request) },
 46         { "exit_external_request", VCPU_STAT(exit_external_request) },
 47         { "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) },
 48         { "exit_instruction", VCPU_STAT(exit_instruction) },
 49         { "exit_program_interruption", VCPU_STAT(exit_program_interruption) },
 50         { "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) },
 51         { "instruction_lctlg", VCPU_STAT(instruction_lctlg) },
 52         { "instruction_lctl", VCPU_STAT(instruction_lctl) },
 53         { "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) },
 54         { "deliver_external_call", VCPU_STAT(deliver_external_call) },
 55         { "deliver_service_signal", VCPU_STAT(deliver_service_signal) },
 56         { "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) },
 57         { "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) },
 58         { "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) },
 59         { "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) },
 60         { "deliver_program_interruption", VCPU_STAT(deliver_program_int) },
 61         { "exit_wait_state", VCPU_STAT(exit_wait_state) },
 62         { "instruction_stidp", VCPU_STAT(instruction_stidp) },
 63         { "instruction_spx", VCPU_STAT(instruction_spx) },
 64         { "instruction_stpx", VCPU_STAT(instruction_stpx) },
 65         { "instruction_stap", VCPU_STAT(instruction_stap) },
 66         { "instruction_storage_key", VCPU_STAT(instruction_storage_key) },
 67         { "instruction_stsch", VCPU_STAT(instruction_stsch) },
 68         { "instruction_chsc", VCPU_STAT(instruction_chsc) },
 69         { "instruction_stsi", VCPU_STAT(instruction_stsi) },
 70         { "instruction_stfl", VCPU_STAT(instruction_stfl) },
 71         { "instruction_tprot", VCPU_STAT(instruction_tprot) },
 72         { "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) },
 73         { "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) },
 74         { "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) },
 75         { "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) },
 76         { "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) },
 77         { "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) },
 78         { "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) },
 79         { "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) },
 80         { "diagnose_10", VCPU_STAT(diagnose_10) },
 81         { "diagnose_44", VCPU_STAT(diagnose_44) },
 82         { "diagnose_9c", VCPU_STAT(diagnose_9c) },
 83         { NULL }
 84 };
 85 
 86 static unsigned long long *facilities;
 87 
 88 /* Section: not file related */
 89 int kvm_arch_hardware_enable(void *garbage)
 90 {
 91         /* every s390 is virtualization enabled ;-) */
 92         return 0;
 93 }
 94 
 95 void kvm_arch_hardware_disable(void *garbage)
 96 {
 97 }
 98 
 99 int kvm_arch_hardware_setup(void)
100 {
101         return 0;
102 }
103 
104 void kvm_arch_hardware_unsetup(void)
105 {
106 }
107 
108 void kvm_arch_check_processor_compat(void *rtn)
109 {
110 }
111 
112 int kvm_arch_init(void *opaque)
113 {
114         return 0;
115 }
116 
117 void kvm_arch_exit(void)
118 {
119 }
120 
121 /* Section: device related */
122 long kvm_arch_dev_ioctl(struct file *filp,
123                         unsigned int ioctl, unsigned long arg)
124 {
125         if (ioctl == KVM_S390_ENABLE_SIE)
126                 return s390_enable_sie();
127         return -EINVAL;
128 }
129 
130 int kvm_dev_ioctl_check_extension(long ext)
131 {
132         int r;
133 
134         switch (ext) {
135         case KVM_CAP_S390_PSW:
136         case KVM_CAP_S390_GMAP:
137         case KVM_CAP_SYNC_MMU:
138 #ifdef CONFIG_KVM_S390_UCONTROL
139         case KVM_CAP_S390_UCONTROL:
140 #endif
141         case KVM_CAP_SYNC_REGS:
142         case KVM_CAP_ONE_REG:
143         case KVM_CAP_ENABLE_CAP:
144         case KVM_CAP_S390_CSS_SUPPORT:
145         case KVM_CAP_IOEVENTFD:
146                 r = 1;
147                 break;
148         case KVM_CAP_NR_VCPUS:
149         case KVM_CAP_MAX_VCPUS:
150                 r = KVM_MAX_VCPUS;
151                 break;
152         case KVM_CAP_NR_MEMSLOTS:
153                 r = KVM_USER_MEM_SLOTS;
154                 break;
155         case KVM_CAP_S390_COW:
156                 r = MACHINE_HAS_ESOP;
157                 break;
158         default:
159                 r = 0;
160         }
161         return r;
162 }
163 
164 /* Section: vm related */
165 /*
166  * Get (and clear) the dirty memory log for a memory slot.
167  */
168 int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
169                                struct kvm_dirty_log *log)
170 {
171         return 0;
172 }
173 
174 long kvm_arch_vm_ioctl(struct file *filp,
175                        unsigned int ioctl, unsigned long arg)
176 {
177         struct kvm *kvm = filp->private_data;
178         void __user *argp = (void __user *)arg;
179         int r;
180 
181         switch (ioctl) {
182         case KVM_S390_INTERRUPT: {
183                 struct kvm_s390_interrupt s390int;
184 
185                 r = -EFAULT;
186                 if (copy_from_user(&s390int, argp, sizeof(s390int)))
187                         break;
188                 r = kvm_s390_inject_vm(kvm, &s390int);
189                 break;
190         }
191         default:
192                 r = -ENOTTY;
193         }
194 
195         return r;
196 }
197 
198 int kvm_arch_init_vm(struct kvm *kvm, unsigned long type)
199 {
200         int rc;
201         char debug_name[16];
202 
203         rc = -EINVAL;
204 #ifdef CONFIG_KVM_S390_UCONTROL
205         if (type & ~KVM_VM_S390_UCONTROL)
206                 goto out_err;
207         if ((type & KVM_VM_S390_UCONTROL) && (!capable(CAP_SYS_ADMIN)))
208                 goto out_err;
209 #else
210         if (type)
211                 goto out_err;
212 #endif
213 
214         rc = s390_enable_sie();
215         if (rc)
216                 goto out_err;
217 
218         rc = -ENOMEM;
219 
220         kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL);
221         if (!kvm->arch.sca)
222                 goto out_err;
223 
224         sprintf(debug_name, "kvm-%u", current->pid);
225 
226         kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long));
227         if (!kvm->arch.dbf)
228                 goto out_nodbf;
229 
230         spin_lock_init(&kvm->arch.float_int.lock);
231         INIT_LIST_HEAD(&kvm->arch.float_int.list);
232 
233         debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
234         VM_EVENT(kvm, 3, "%s", "vm created");
235 
236         if (type & KVM_VM_S390_UCONTROL) {
237                 kvm->arch.gmap = NULL;
238         } else {
239                 kvm->arch.gmap = gmap_alloc(current->mm);
240                 if (!kvm->arch.gmap)
241                         goto out_nogmap;
242         }
243 
244         kvm->arch.css_support = 0;
245 
246         return 0;
247 out_nogmap:
248         debug_unregister(kvm->arch.dbf);
249 out_nodbf:
250         free_page((unsigned long)(kvm->arch.sca));
251 out_err:
252         return rc;
253 }
254 
255 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
256 {
257         VCPU_EVENT(vcpu, 3, "%s", "free cpu");
258         trace_kvm_s390_destroy_vcpu(vcpu->vcpu_id);
259         if (!kvm_is_ucontrol(vcpu->kvm)) {
260                 clear_bit(63 - vcpu->vcpu_id,
261                           (unsigned long *) &vcpu->kvm->arch.sca->mcn);
262                 if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda ==
263                     (__u64) vcpu->arch.sie_block)
264                         vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0;
265         }
266         smp_mb();
267 
268         if (kvm_is_ucontrol(vcpu->kvm))
269                 gmap_free(vcpu->arch.gmap);
270 
271         free_page((unsigned long)(vcpu->arch.sie_block));
272         kvm_vcpu_uninit(vcpu);
273         kfree(vcpu);
274 }
275 
276 static void kvm_free_vcpus(struct kvm *kvm)
277 {
278         unsigned int i;
279         struct kvm_vcpu *vcpu;
280 
281         kvm_for_each_vcpu(i, vcpu, kvm)
282                 kvm_arch_vcpu_destroy(vcpu);
283 
284         mutex_lock(&kvm->lock);
285         for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
286                 kvm->vcpus[i] = NULL;
287 
288         atomic_set(&kvm->online_vcpus, 0);
289         mutex_unlock(&kvm->lock);
290 }
291 
292 void kvm_arch_sync_events(struct kvm *kvm)
293 {
294 }
295 
296 void kvm_arch_destroy_vm(struct kvm *kvm)
297 {
298         kvm_free_vcpus(kvm);
299         free_page((unsigned long)(kvm->arch.sca));
300         debug_unregister(kvm->arch.dbf);
301         if (!kvm_is_ucontrol(kvm))
302                 gmap_free(kvm->arch.gmap);
303 }
304 
305 /* Section: vcpu related */
306 int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
307 {
308         if (kvm_is_ucontrol(vcpu->kvm)) {
309                 vcpu->arch.gmap = gmap_alloc(current->mm);
310                 if (!vcpu->arch.gmap)
311                         return -ENOMEM;
312                 return 0;
313         }
314 
315         vcpu->arch.gmap = vcpu->kvm->arch.gmap;
316         vcpu->run->kvm_valid_regs = KVM_SYNC_PREFIX |
317                                     KVM_SYNC_GPRS |
318                                     KVM_SYNC_ACRS |
319                                     KVM_SYNC_CRS;
320         return 0;
321 }
322 
323 void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
324 {
325         /* Nothing todo */
326 }
327 
328 void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
329 {
330         save_fp_regs(&vcpu->arch.host_fpregs);
331         save_access_regs(vcpu->arch.host_acrs);
332         vcpu->arch.guest_fpregs.fpc &= FPC_VALID_MASK;
333         restore_fp_regs(&vcpu->arch.guest_fpregs);
334         restore_access_regs(vcpu->run->s.regs.acrs);
335         gmap_enable(vcpu->arch.gmap);
336         atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
337 }
338 
339 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
340 {
341         atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
342         gmap_disable(vcpu->arch.gmap);
343         save_fp_regs(&vcpu->arch.guest_fpregs);
344         save_access_regs(vcpu->run->s.regs.acrs);
345         restore_fp_regs(&vcpu->arch.host_fpregs);
346         restore_access_regs(vcpu->arch.host_acrs);
347 }
348 
349 static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
350 {
351         /* this equals initial cpu reset in pop, but we don't switch to ESA */
352         vcpu->arch.sie_block->gpsw.mask = 0UL;
353         vcpu->arch.sie_block->gpsw.addr = 0UL;
354         kvm_s390_set_prefix(vcpu, 0);
355         vcpu->arch.sie_block->cputm     = 0UL;
356         vcpu->arch.sie_block->ckc       = 0UL;
357         vcpu->arch.sie_block->todpr     = 0;
358         memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64));
359         vcpu->arch.sie_block->gcr[0]  = 0xE0UL;
360         vcpu->arch.sie_block->gcr[14] = 0xC2000000UL;
361         vcpu->arch.guest_fpregs.fpc = 0;
362         asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc));
363         vcpu->arch.sie_block->gbea = 1;
364         atomic_set_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
365 }
366 
367 int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
368 {
369         return 0;
370 }
371 
372 int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
373 {
374         atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH |
375                                                     CPUSTAT_SM |
376                                                     CPUSTAT_STOPPED);
377         vcpu->arch.sie_block->ecb   = 6;
378         vcpu->arch.sie_block->eca   = 0xC1002001U;
379         vcpu->arch.sie_block->fac   = (int) (long) facilities;
380         hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
381         tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet,
382                      (unsigned long) vcpu);
383         vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup;
384         get_cpu_id(&vcpu->arch.cpu_id);
385         vcpu->arch.cpu_id.version = 0xff;
386         return 0;
387 }
388 
389 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
390                                       unsigned int id)
391 {
392         struct kvm_vcpu *vcpu;
393         int rc = -EINVAL;
394 
395         if (id >= KVM_MAX_VCPUS)
396                 goto out;
397 
398         rc = -ENOMEM;
399 
400         vcpu = kzalloc(sizeof(struct kvm_vcpu), GFP_KERNEL);
401         if (!vcpu)
402                 goto out;
403 
404         vcpu->arch.sie_block = (struct kvm_s390_sie_block *)
405                                         get_zeroed_page(GFP_KERNEL);
406 
407         if (!vcpu->arch.sie_block)
408                 goto out_free_cpu;
409 
410         vcpu->arch.sie_block->icpua = id;
411         if (!kvm_is_ucontrol(kvm)) {
412                 if (!kvm->arch.sca) {
413                         WARN_ON_ONCE(1);
414                         goto out_free_cpu;
415                 }
416                 if (!kvm->arch.sca->cpu[id].sda)
417                         kvm->arch.sca->cpu[id].sda =
418                                 (__u64) vcpu->arch.sie_block;
419                 vcpu->arch.sie_block->scaoh =
420                         (__u32)(((__u64)kvm->arch.sca) >> 32);
421                 vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca;
422                 set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn);
423         }
424 
425         spin_lock_init(&vcpu->arch.local_int.lock);
426         INIT_LIST_HEAD(&vcpu->arch.local_int.list);
427         vcpu->arch.local_int.float_int = &kvm->arch.float_int;
428         spin_lock(&kvm->arch.float_int.lock);
429         kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int;
430         init_waitqueue_head(&vcpu->arch.local_int.wq);
431         vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
432         spin_unlock(&kvm->arch.float_int.lock);
433 
434         rc = kvm_vcpu_init(vcpu, kvm, id);
435         if (rc)
436                 goto out_free_sie_block;
437         VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu,
438                  vcpu->arch.sie_block);
439         trace_kvm_s390_create_vcpu(id, vcpu, vcpu->arch.sie_block);
440 
441         return vcpu;
442 out_free_sie_block:
443         free_page((unsigned long)(vcpu->arch.sie_block));
444 out_free_cpu:
445         kfree(vcpu);
446 out:
447         return ERR_PTR(rc);
448 }
449 
450 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
451 {
452         /* kvm common code refers to this, but never calls it */
453         BUG();
454         return 0;
455 }
456 
457 int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
458 {
459         /* kvm common code refers to this, but never calls it */
460         BUG();
461         return 0;
462 }
463 
464 static int kvm_arch_vcpu_ioctl_get_one_reg(struct kvm_vcpu *vcpu,
465                                            struct kvm_one_reg *reg)
466 {
467         int r = -EINVAL;
468 
469         switch (reg->id) {
470         case KVM_REG_S390_TODPR:
471                 r = put_user(vcpu->arch.sie_block->todpr,
472                              (u32 __user *)reg->addr);
473                 break;
474         case KVM_REG_S390_EPOCHDIFF:
475                 r = put_user(vcpu->arch.sie_block->epoch,
476                              (u64 __user *)reg->addr);
477                 break;
478         case KVM_REG_S390_CPU_TIMER:
479                 r = put_user(vcpu->arch.sie_block->cputm,
480                              (u64 __user *)reg->addr);
481                 break;
482         case KVM_REG_S390_CLOCK_COMP:
483                 r = put_user(vcpu->arch.sie_block->ckc,
484                              (u64 __user *)reg->addr);
485                 break;
486         default:
487                 break;
488         }
489 
490         return r;
491 }
492 
493 static int kvm_arch_vcpu_ioctl_set_one_reg(struct kvm_vcpu *vcpu,
494                                            struct kvm_one_reg *reg)
495 {
496         int r = -EINVAL;
497 
498         switch (reg->id) {
499         case KVM_REG_S390_TODPR:
500                 r = get_user(vcpu->arch.sie_block->todpr,
501                              (u32 __user *)reg->addr);
502                 break;
503         case KVM_REG_S390_EPOCHDIFF:
504                 r = get_user(vcpu->arch.sie_block->epoch,
505                              (u64 __user *)reg->addr);
506                 break;
507         case KVM_REG_S390_CPU_TIMER:
508                 r = get_user(vcpu->arch.sie_block->cputm,
509                              (u64 __user *)reg->addr);
510                 break;
511         case KVM_REG_S390_CLOCK_COMP:
512                 r = get_user(vcpu->arch.sie_block->ckc,
513                              (u64 __user *)reg->addr);
514                 break;
515         default:
516                 break;
517         }
518 
519         return r;
520 }
521 
522 static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
523 {
524         kvm_s390_vcpu_initial_reset(vcpu);
525         return 0;
526 }
527 
528 int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
529 {
530         memcpy(&vcpu->run->s.regs.gprs, &regs->gprs, sizeof(regs->gprs));
531         return 0;
532 }
533 
534 int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
535 {
536         memcpy(&regs->gprs, &vcpu->run->s.regs.gprs, sizeof(regs->gprs));
537         return 0;
538 }
539 
540 int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
541                                   struct kvm_sregs *sregs)
542 {
543         memcpy(&vcpu->run->s.regs.acrs, &sregs->acrs, sizeof(sregs->acrs));
544         memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
545         restore_access_regs(vcpu->run->s.regs.acrs);
546         return 0;
547 }
548 
549 int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
550                                   struct kvm_sregs *sregs)
551 {
552         memcpy(&sregs->acrs, &vcpu->run->s.regs.acrs, sizeof(sregs->acrs));
553         memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
554         return 0;
555 }
556 
557 int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
558 {
559         memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs));
560         vcpu->arch.guest_fpregs.fpc = fpu->fpc & FPC_VALID_MASK;
561         restore_fp_regs(&vcpu->arch.guest_fpregs);
562         return 0;
563 }
564 
565 int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
566 {
567         memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs));
568         fpu->fpc = vcpu->arch.guest_fpregs.fpc;
569         return 0;
570 }
571 
572 static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
573 {
574         int rc = 0;
575 
576         if (!(atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_STOPPED))
577                 rc = -EBUSY;
578         else {
579                 vcpu->run->psw_mask = psw.mask;
580                 vcpu->run->psw_addr = psw.addr;
581         }
582         return rc;
583 }
584 
585 int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
586                                   struct kvm_translation *tr)
587 {
588         return -EINVAL; /* not implemented yet */
589 }
590 
591 int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
592                                         struct kvm_guest_debug *dbg)
593 {
594         return -EINVAL; /* not implemented yet */
595 }
596 
597 int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
598                                     struct kvm_mp_state *mp_state)
599 {
600         return -EINVAL; /* not implemented yet */
601 }
602 
603 int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
604                                     struct kvm_mp_state *mp_state)
605 {
606         return -EINVAL; /* not implemented yet */
607 }
608 
609 static int __vcpu_run(struct kvm_vcpu *vcpu)
610 {
611         int rc;
612 
613         memcpy(&vcpu->arch.sie_block->gg14, &vcpu->run->s.regs.gprs[14], 16);
614 
615         if (need_resched())
616                 schedule();
617 
618         if (test_thread_flag(TIF_MCCK_PENDING))
619                 s390_handle_mcck();
620 
621         if (!kvm_is_ucontrol(vcpu->kvm))
622                 kvm_s390_deliver_pending_interrupts(vcpu);
623 
624         vcpu->arch.sie_block->icptcode = 0;
625         VCPU_EVENT(vcpu, 6, "entering sie flags %x",
626                    atomic_read(&vcpu->arch.sie_block->cpuflags));
627         trace_kvm_s390_sie_enter(vcpu,
628                                  atomic_read(&vcpu->arch.sie_block->cpuflags));
629 
630         /*
631          * As PF_VCPU will be used in fault handler, between guest_enter
632          * and guest_exit should be no uaccess.
633          */
634         preempt_disable();
635         kvm_guest_enter();
636         preempt_enable();
637         rc = sie64a(vcpu->arch.sie_block, vcpu->run->s.regs.gprs);
638         kvm_guest_exit();
639 
640         VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
641                    vcpu->arch.sie_block->icptcode);
642         trace_kvm_s390_sie_exit(vcpu, vcpu->arch.sie_block->icptcode);
643 
644         if (rc) {
645                 if (kvm_is_ucontrol(vcpu->kvm)) {
646                         rc = SIE_INTERCEPT_UCONTROL;
647                 } else {
648                         VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
649                         trace_kvm_s390_sie_fault(vcpu);
650                         rc = kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
651                 }
652         }
653 
654         memcpy(&vcpu->run->s.regs.gprs[14], &vcpu->arch.sie_block->gg14, 16);
655         return rc;
656 }
657 
658 int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
659 {
660         int rc;
661         sigset_t sigsaved;
662 
663 rerun_vcpu:
664         if (vcpu->sigset_active)
665                 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
666 
667         atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
668 
669         BUG_ON(vcpu->kvm->arch.float_int.local_int[vcpu->vcpu_id] == NULL);
670 
671         switch (kvm_run->exit_reason) {
672         case KVM_EXIT_S390_SIEIC:
673         case KVM_EXIT_UNKNOWN:
674         case KVM_EXIT_INTR:
675         case KVM_EXIT_S390_RESET:
676         case KVM_EXIT_S390_UCONTROL:
677         case KVM_EXIT_S390_TSCH:
678                 break;
679         default:
680                 BUG();
681         }
682 
683         vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
684         vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
685         if (kvm_run->kvm_dirty_regs & KVM_SYNC_PREFIX) {
686                 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_PREFIX;
687                 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
688         }
689         if (kvm_run->kvm_dirty_regs & KVM_SYNC_CRS) {
690                 kvm_run->kvm_dirty_regs &= ~KVM_SYNC_CRS;
691                 memcpy(&vcpu->arch.sie_block->gcr, &kvm_run->s.regs.crs, 128);
692                 kvm_s390_set_prefix(vcpu, kvm_run->s.regs.prefix);
693         }
694 
695         might_fault();
696 
697         do {
698                 rc = __vcpu_run(vcpu);
699                 if (rc)
700                         break;
701                 if (kvm_is_ucontrol(vcpu->kvm))
702                         rc = -EOPNOTSUPP;
703                 else
704                         rc = kvm_handle_sie_intercept(vcpu);
705         } while (!signal_pending(current) && !rc);
706 
707         if (rc == SIE_INTERCEPT_RERUNVCPU)
708                 goto rerun_vcpu;
709 
710         if (signal_pending(current) && !rc) {
711                 kvm_run->exit_reason = KVM_EXIT_INTR;
712                 rc = -EINTR;
713         }
714 
715 #ifdef CONFIG_KVM_S390_UCONTROL
716         if (rc == SIE_INTERCEPT_UCONTROL) {
717                 kvm_run->exit_reason = KVM_EXIT_S390_UCONTROL;
718                 kvm_run->s390_ucontrol.trans_exc_code =
719                         current->thread.gmap_addr;
720                 kvm_run->s390_ucontrol.pgm_code = 0x10;
721                 rc = 0;
722         }
723 #endif
724 
725         if (rc == -EOPNOTSUPP) {
726                 /* intercept cannot be handled in-kernel, prepare kvm-run */
727                 kvm_run->exit_reason         = KVM_EXIT_S390_SIEIC;
728                 kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
729                 kvm_run->s390_sieic.ipa      = vcpu->arch.sie_block->ipa;
730                 kvm_run->s390_sieic.ipb      = vcpu->arch.sie_block->ipb;
731                 rc = 0;
732         }
733 
734         if (rc == -EREMOTE) {
735                 /* intercept was handled, but userspace support is needed
736                  * kvm_run has been prepared by the handler */
737                 rc = 0;
738         }
739 
740         kvm_run->psw_mask     = vcpu->arch.sie_block->gpsw.mask;
741         kvm_run->psw_addr     = vcpu->arch.sie_block->gpsw.addr;
742         kvm_run->s.regs.prefix = vcpu->arch.sie_block->prefix;
743         memcpy(&kvm_run->s.regs.crs, &vcpu->arch.sie_block->gcr, 128);
744 
745         if (vcpu->sigset_active)
746                 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
747 
748         vcpu->stat.exit_userspace++;
749         return rc;
750 }
751 
752 static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, void *from,
753                        unsigned long n, int prefix)
754 {
755         if (prefix)
756                 return copy_to_guest(vcpu, guestdest, from, n);
757         else
758                 return copy_to_guest_absolute(vcpu, guestdest, from, n);
759 }
760 
761 /*
762  * store status at address
763  * we use have two special cases:
764  * KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
765  * KVM_S390_STORE_STATUS_PREFIXED: -> prefix
766  */
767 int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
768 {
769         unsigned char archmode = 1;
770         int prefix;
771 
772         if (addr == KVM_S390_STORE_STATUS_NOADDR) {
773                 if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1))
774                         return -EFAULT;
775                 addr = SAVE_AREA_BASE;
776                 prefix = 0;
777         } else if (addr == KVM_S390_STORE_STATUS_PREFIXED) {
778                 if (copy_to_guest(vcpu, 163ul, &archmode, 1))
779                         return -EFAULT;
780                 addr = SAVE_AREA_BASE;
781                 prefix = 1;
782         } else
783                 prefix = 0;
784 
785         /*
786          * The guest FPRS and ACRS are in the host FPRS/ACRS due to the lazy
787          * copying in vcpu load/put. Lets update our copies before we save
788          * it into the save area
789          */
790         save_fp_regs(&vcpu->arch.guest_fpregs);
791         save_access_regs(vcpu->run->s.regs.acrs);
792 
793         if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs),
794                         vcpu->arch.guest_fpregs.fprs, 128, prefix))
795                 return -EFAULT;
796 
797         if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs),
798                         vcpu->run->s.regs.gprs, 128, prefix))
799                 return -EFAULT;
800 
801         if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw),
802                         &vcpu->arch.sie_block->gpsw, 16, prefix))
803                 return -EFAULT;
804 
805         if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg),
806                         &vcpu->arch.sie_block->prefix, 4, prefix))
807                 return -EFAULT;
808 
809         if (__guestcopy(vcpu,
810                         addr + offsetof(struct save_area, fp_ctrl_reg),
811                         &vcpu->arch.guest_fpregs.fpc, 4, prefix))
812                 return -EFAULT;
813 
814         if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg),
815                         &vcpu->arch.sie_block->todpr, 4, prefix))
816                 return -EFAULT;
817 
818         if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer),
819                         &vcpu->arch.sie_block->cputm, 8, prefix))
820                 return -EFAULT;
821 
822         if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp),
823                         &vcpu->arch.sie_block->ckc, 8, prefix))
824                 return -EFAULT;
825 
826         if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs),
827                         &vcpu->run->s.regs.acrs, 64, prefix))
828                 return -EFAULT;
829 
830         if (__guestcopy(vcpu,
831                         addr + offsetof(struct save_area, ctrl_regs),
832                         &vcpu->arch.sie_block->gcr, 128, prefix))
833                 return -EFAULT;
834         return 0;
835 }
836 
837 static int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
838                                      struct kvm_enable_cap *cap)
839 {
840         int r;
841 
842         if (cap->flags)
843                 return -EINVAL;
844 
845         switch (cap->cap) {
846         case KVM_CAP_S390_CSS_SUPPORT:
847                 if (!vcpu->kvm->arch.css_support) {
848                         vcpu->kvm->arch.css_support = 1;
849                         trace_kvm_s390_enable_css(vcpu->kvm);
850                 }
851                 r = 0;
852                 break;
853         default:
854                 r = -EINVAL;
855                 break;
856         }
857         return r;
858 }
859 
860 long kvm_arch_vcpu_ioctl(struct file *filp,
861                          unsigned int ioctl, unsigned long arg)
862 {
863         struct kvm_vcpu *vcpu = filp->private_data;
864         void __user *argp = (void __user *)arg;
865         long r;
866 
867         switch (ioctl) {
868         case KVM_S390_INTERRUPT: {
869                 struct kvm_s390_interrupt s390int;
870 
871                 r = -EFAULT;
872                 if (copy_from_user(&s390int, argp, sizeof(s390int)))
873                         break;
874                 r = kvm_s390_inject_vcpu(vcpu, &s390int);
875                 break;
876         }
877         case KVM_S390_STORE_STATUS:
878                 r = kvm_s390_vcpu_store_status(vcpu, arg);
879                 break;
880         case KVM_S390_SET_INITIAL_PSW: {
881                 psw_t psw;
882 
883                 r = -EFAULT;
884                 if (copy_from_user(&psw, argp, sizeof(psw)))
885                         break;
886                 r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
887                 break;
888         }
889         case KVM_S390_INITIAL_RESET:
890                 r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
891                 break;
892         case KVM_SET_ONE_REG:
893         case KVM_GET_ONE_REG: {
894                 struct kvm_one_reg reg;
895                 r = -EFAULT;
896                 if (copy_from_user(&reg, argp, sizeof(reg)))
897                         break;
898                 if (ioctl == KVM_SET_ONE_REG)
899                         r = kvm_arch_vcpu_ioctl_set_one_reg(vcpu, &reg);
900                 else
901                         r = kvm_arch_vcpu_ioctl_get_one_reg(vcpu, &reg);
902                 break;
903         }
904 #ifdef CONFIG_KVM_S390_UCONTROL
905         case KVM_S390_UCAS_MAP: {
906                 struct kvm_s390_ucas_mapping ucasmap;
907 
908                 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
909                         r = -EFAULT;
910                         break;
911                 }
912 
913                 if (!kvm_is_ucontrol(vcpu->kvm)) {
914                         r = -EINVAL;
915                         break;
916                 }
917 
918                 r = gmap_map_segment(vcpu->arch.gmap, ucasmap.user_addr,
919                                      ucasmap.vcpu_addr, ucasmap.length);
920                 break;
921         }
922         case KVM_S390_UCAS_UNMAP: {
923                 struct kvm_s390_ucas_mapping ucasmap;
924 
925                 if (copy_from_user(&ucasmap, argp, sizeof(ucasmap))) {
926                         r = -EFAULT;
927                         break;
928                 }
929 
930                 if (!kvm_is_ucontrol(vcpu->kvm)) {
931                         r = -EINVAL;
932                         break;
933                 }
934 
935                 r = gmap_unmap_segment(vcpu->arch.gmap, ucasmap.vcpu_addr,
936                         ucasmap.length);
937                 break;
938         }
939 #endif
940         case KVM_S390_VCPU_FAULT: {
941                 r = gmap_fault(arg, vcpu->arch.gmap);
942                 if (!IS_ERR_VALUE(r))
943                         r = 0;
944                 break;
945         }
946         case KVM_ENABLE_CAP:
947         {
948                 struct kvm_enable_cap cap;
949                 r = -EFAULT;
950                 if (copy_from_user(&cap, argp, sizeof(cap)))
951                         break;
952                 r = kvm_vcpu_ioctl_enable_cap(vcpu, &cap);
953                 break;
954         }
955         default:
956                 r = -ENOTTY;
957         }
958         return r;
959 }
960 
961 int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf)
962 {
963 #ifdef CONFIG_KVM_S390_UCONTROL
964         if ((vmf->pgoff == KVM_S390_SIE_PAGE_OFFSET)
965                  && (kvm_is_ucontrol(vcpu->kvm))) {
966                 vmf->page = virt_to_page(vcpu->arch.sie_block);
967                 get_page(vmf->page);
968                 return 0;
969         }
970 #endif
971         return VM_FAULT_SIGBUS;
972 }
973 
974 void kvm_arch_free_memslot(struct kvm_memory_slot *free,
975                            struct kvm_memory_slot *dont)
976 {
977 }
978 
979 int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages)
980 {
981         return 0;
982 }
983 
984 /* Section: memory related */
985 int kvm_arch_prepare_memory_region(struct kvm *kvm,
986                                    struct kvm_memory_slot *memslot,
987                                    struct kvm_userspace_memory_region *mem,
988                                    enum kvm_mr_change change)
989 {
990         /* A few sanity checks. We can have memory slots which have to be
991            located/ended at a segment boundary (1MB). The memory in userland is
992            ok to be fragmented into various different vmas. It is okay to mmap()
993            and munmap() stuff in this slot after doing this call at any time */
994 
995         if (mem->userspace_addr & 0xffffful)
996                 return -EINVAL;
997 
998         if (mem->memory_size & 0xffffful)
999                 return -EINVAL;
1000 
1001         return 0;
1002 }
1003 
1004 void kvm_arch_commit_memory_region(struct kvm *kvm,
1005                                 struct kvm_userspace_memory_region *mem,
1006                                 const struct kvm_memory_slot *old,
1007                                 enum kvm_mr_change change)
1008 {
1009         int rc;
1010 
1011         /* If the basics of the memslot do not change, we do not want
1012          * to update the gmap. Every update causes several unnecessary
1013          * segment translation exceptions. This is usually handled just
1014          * fine by the normal fault handler + gmap, but it will also
1015          * cause faults on the prefix page of running guest CPUs.
1016          */
1017         if (old->userspace_addr == mem->userspace_addr &&
1018             old->base_gfn * PAGE_SIZE == mem->guest_phys_addr &&
1019             old->npages * PAGE_SIZE == mem->memory_size)
1020                 return;
1021 
1022         rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr,
1023                 mem->guest_phys_addr, mem->memory_size);
1024         if (rc)
1025                 printk(KERN_WARNING "kvm-s390: failed to commit memory region\n");
1026         return;
1027 }
1028 
1029 void kvm_arch_flush_shadow_all(struct kvm *kvm)
1030 {
1031 }
1032 
1033 void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
1034                                    struct kvm_memory_slot *slot)
1035 {
1036 }
1037 
1038 static int __init kvm_s390_init(void)
1039 {
1040         int ret;
1041         ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
1042         if (ret)
1043                 return ret;
1044 
1045         /*
1046          * guests can ask for up to 255+1 double words, we need a full page
1047          * to hold the maximum amount of facilities. On the other hand, we
1048          * only set facilities that are known to work in KVM.
1049          */
1050         facilities = (unsigned long long *) get_zeroed_page(GFP_KERNEL|GFP_DMA);
1051         if (!facilities) {
1052                 kvm_exit();
1053                 return -ENOMEM;
1054         }
1055         memcpy(facilities, S390_lowcore.stfle_fac_list, 16);
1056         facilities[0] &= 0xff00fff3f47c0000ULL;
1057         facilities[1] &= 0x001c000000000000ULL;
1058         return 0;
1059 }
1060 
1061 static void __exit kvm_s390_exit(void)
1062 {
1063         free_page((unsigned long) facilities);
1064         kvm_exit();
1065 }
1066 
1067 module_init(kvm_s390_init);
1068 module_exit(kvm_s390_exit);
1069 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp