2
* s390host.c -- hosting zSeries kernel virtual machines
4
* Copyright IBM Corp. 2008,2009
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.
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>
16
#include <linux/compiler.h>
17
#include <linux/err.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>
30
#include <asm/system.h>
34
#define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU
36
struct kvm_stats_debugfs_item debugfs_entries[] = {
37
{ "userspace_handled", VCPU_STAT(exit_userspace) },
38
{ "exit_null", VCPU_STAT(exit_null) },
39
{ "exit_validity", VCPU_STAT(exit_validity) },
40
{ "exit_stop_request", VCPU_STAT(exit_stop_request) },
41
{ "exit_external_request", VCPU_STAT(exit_external_request) },
42
{ "exit_external_interrupt", VCPU_STAT(exit_external_interrupt) },
43
{ "exit_instruction", VCPU_STAT(exit_instruction) },
44
{ "exit_program_interruption", VCPU_STAT(exit_program_interruption) },
45
{ "exit_instr_and_program_int", VCPU_STAT(exit_instr_and_program) },
46
{ "instruction_lctlg", VCPU_STAT(instruction_lctlg) },
47
{ "instruction_lctl", VCPU_STAT(instruction_lctl) },
48
{ "deliver_emergency_signal", VCPU_STAT(deliver_emergency_signal) },
49
{ "deliver_external_call", VCPU_STAT(deliver_external_call) },
50
{ "deliver_service_signal", VCPU_STAT(deliver_service_signal) },
51
{ "deliver_virtio_interrupt", VCPU_STAT(deliver_virtio_interrupt) },
52
{ "deliver_stop_signal", VCPU_STAT(deliver_stop_signal) },
53
{ "deliver_prefix_signal", VCPU_STAT(deliver_prefix_signal) },
54
{ "deliver_restart_signal", VCPU_STAT(deliver_restart_signal) },
55
{ "deliver_program_interruption", VCPU_STAT(deliver_program_int) },
56
{ "exit_wait_state", VCPU_STAT(exit_wait_state) },
57
{ "instruction_stidp", VCPU_STAT(instruction_stidp) },
58
{ "instruction_spx", VCPU_STAT(instruction_spx) },
59
{ "instruction_stpx", VCPU_STAT(instruction_stpx) },
60
{ "instruction_stap", VCPU_STAT(instruction_stap) },
61
{ "instruction_storage_key", VCPU_STAT(instruction_storage_key) },
62
{ "instruction_stsch", VCPU_STAT(instruction_stsch) },
63
{ "instruction_chsc", VCPU_STAT(instruction_chsc) },
64
{ "instruction_stsi", VCPU_STAT(instruction_stsi) },
65
{ "instruction_stfl", VCPU_STAT(instruction_stfl) },
66
{ "instruction_tprot", VCPU_STAT(instruction_tprot) },
67
{ "instruction_sigp_sense", VCPU_STAT(instruction_sigp_sense) },
68
{ "instruction_sigp_sense_running", VCPU_STAT(instruction_sigp_sense_running) },
69
{ "instruction_sigp_external_call", VCPU_STAT(instruction_sigp_external_call) },
70
{ "instruction_sigp_emergency", VCPU_STAT(instruction_sigp_emergency) },
71
{ "instruction_sigp_stop", VCPU_STAT(instruction_sigp_stop) },
72
{ "instruction_sigp_set_arch", VCPU_STAT(instruction_sigp_arch) },
73
{ "instruction_sigp_set_prefix", VCPU_STAT(instruction_sigp_prefix) },
74
{ "instruction_sigp_restart", VCPU_STAT(instruction_sigp_restart) },
75
{ "diagnose_10", VCPU_STAT(diagnose_10) },
76
{ "diagnose_44", VCPU_STAT(diagnose_44) },
80
static unsigned long long *facilities;
82
/* Section: not file related */
83
int kvm_arch_hardware_enable(void *garbage)
85
/* every s390 is virtualization enabled ;-) */
89
void kvm_arch_hardware_disable(void *garbage)
93
int kvm_arch_hardware_setup(void)
98
void kvm_arch_hardware_unsetup(void)
102
void kvm_arch_check_processor_compat(void *rtn)
106
int kvm_arch_init(void *opaque)
111
void kvm_arch_exit(void)
115
/* Section: device related */
116
long kvm_arch_dev_ioctl(struct file *filp,
117
unsigned int ioctl, unsigned long arg)
119
if (ioctl == KVM_S390_ENABLE_SIE)
120
return s390_enable_sie();
124
int kvm_dev_ioctl_check_extension(long ext)
129
case KVM_CAP_S390_PSW:
130
case KVM_CAP_S390_GMAP:
131
case KVM_CAP_SYNC_MMU:
140
/* Section: vm related */
142
* Get (and clear) the dirty memory log for a memory slot.
144
int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
145
struct kvm_dirty_log *log)
150
long kvm_arch_vm_ioctl(struct file *filp,
151
unsigned int ioctl, unsigned long arg)
153
struct kvm *kvm = filp->private_data;
154
void __user *argp = (void __user *)arg;
158
case KVM_S390_INTERRUPT: {
159
struct kvm_s390_interrupt s390int;
162
if (copy_from_user(&s390int, argp, sizeof(s390int)))
164
r = kvm_s390_inject_vm(kvm, &s390int);
174
int kvm_arch_init_vm(struct kvm *kvm)
179
rc = s390_enable_sie();
185
kvm->arch.sca = (struct sca_block *) get_zeroed_page(GFP_KERNEL);
189
sprintf(debug_name, "kvm-%u", current->pid);
191
kvm->arch.dbf = debug_register(debug_name, 8, 2, 8 * sizeof(long));
195
spin_lock_init(&kvm->arch.float_int.lock);
196
INIT_LIST_HEAD(&kvm->arch.float_int.list);
198
debug_register_view(kvm->arch.dbf, &debug_sprintf_view);
199
VM_EVENT(kvm, 3, "%s", "vm created");
201
kvm->arch.gmap = gmap_alloc(current->mm);
207
debug_unregister(kvm->arch.dbf);
209
free_page((unsigned long)(kvm->arch.sca));
214
void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
216
VCPU_EVENT(vcpu, 3, "%s", "free cpu");
217
clear_bit(63 - vcpu->vcpu_id, (unsigned long *) &vcpu->kvm->arch.sca->mcn);
218
if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda ==
219
(__u64) vcpu->arch.sie_block)
220
vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0;
222
free_page((unsigned long)(vcpu->arch.sie_block));
223
kvm_vcpu_uninit(vcpu);
227
static void kvm_free_vcpus(struct kvm *kvm)
230
struct kvm_vcpu *vcpu;
232
kvm_for_each_vcpu(i, vcpu, kvm)
233
kvm_arch_vcpu_destroy(vcpu);
235
mutex_lock(&kvm->lock);
236
for (i = 0; i < atomic_read(&kvm->online_vcpus); i++)
237
kvm->vcpus[i] = NULL;
239
atomic_set(&kvm->online_vcpus, 0);
240
mutex_unlock(&kvm->lock);
243
void kvm_arch_sync_events(struct kvm *kvm)
247
void kvm_arch_destroy_vm(struct kvm *kvm)
250
free_page((unsigned long)(kvm->arch.sca));
251
debug_unregister(kvm->arch.dbf);
252
gmap_free(kvm->arch.gmap);
255
/* Section: vcpu related */
256
int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
258
vcpu->arch.gmap = vcpu->kvm->arch.gmap;
262
void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu)
267
void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
269
save_fp_regs(&vcpu->arch.host_fpregs);
270
save_access_regs(vcpu->arch.host_acrs);
271
vcpu->arch.guest_fpregs.fpc &= FPC_VALID_MASK;
272
restore_fp_regs(&vcpu->arch.guest_fpregs);
273
restore_access_regs(vcpu->arch.guest_acrs);
274
gmap_enable(vcpu->arch.gmap);
275
atomic_set_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
278
void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
280
atomic_clear_mask(CPUSTAT_RUNNING, &vcpu->arch.sie_block->cpuflags);
281
gmap_disable(vcpu->arch.gmap);
282
save_fp_regs(&vcpu->arch.guest_fpregs);
283
save_access_regs(vcpu->arch.guest_acrs);
284
restore_fp_regs(&vcpu->arch.host_fpregs);
285
restore_access_regs(vcpu->arch.host_acrs);
288
static void kvm_s390_vcpu_initial_reset(struct kvm_vcpu *vcpu)
290
/* this equals initial cpu reset in pop, but we don't switch to ESA */
291
vcpu->arch.sie_block->gpsw.mask = 0UL;
292
vcpu->arch.sie_block->gpsw.addr = 0UL;
293
vcpu->arch.sie_block->prefix = 0UL;
294
vcpu->arch.sie_block->ihcpu = 0xffff;
295
vcpu->arch.sie_block->cputm = 0UL;
296
vcpu->arch.sie_block->ckc = 0UL;
297
vcpu->arch.sie_block->todpr = 0;
298
memset(vcpu->arch.sie_block->gcr, 0, 16 * sizeof(__u64));
299
vcpu->arch.sie_block->gcr[0] = 0xE0UL;
300
vcpu->arch.sie_block->gcr[14] = 0xC2000000UL;
301
vcpu->arch.guest_fpregs.fpc = 0;
302
asm volatile("lfpc %0" : : "Q" (vcpu->arch.guest_fpregs.fpc));
303
vcpu->arch.sie_block->gbea = 1;
306
int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
308
atomic_set(&vcpu->arch.sie_block->cpuflags, CPUSTAT_ZARCH |
311
vcpu->arch.sie_block->ecb = 6;
312
vcpu->arch.sie_block->eca = 0xC1002001U;
313
vcpu->arch.sie_block->fac = (int) (long) facilities;
314
hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
315
tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet,
316
(unsigned long) vcpu);
317
vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup;
318
get_cpu_id(&vcpu->arch.cpu_id);
319
vcpu->arch.cpu_id.version = 0xff;
323
struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
326
struct kvm_vcpu *vcpu;
329
if (id >= KVM_MAX_VCPUS)
334
vcpu = kzalloc(sizeof(struct kvm_vcpu), GFP_KERNEL);
338
vcpu->arch.sie_block = (struct kvm_s390_sie_block *)
339
get_zeroed_page(GFP_KERNEL);
341
if (!vcpu->arch.sie_block)
344
vcpu->arch.sie_block->icpua = id;
345
BUG_ON(!kvm->arch.sca);
346
if (!kvm->arch.sca->cpu[id].sda)
347
kvm->arch.sca->cpu[id].sda = (__u64) vcpu->arch.sie_block;
348
vcpu->arch.sie_block->scaoh = (__u32)(((__u64)kvm->arch.sca) >> 32);
349
vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca;
350
set_bit(63 - id, (unsigned long *) &kvm->arch.sca->mcn);
352
spin_lock_init(&vcpu->arch.local_int.lock);
353
INIT_LIST_HEAD(&vcpu->arch.local_int.list);
354
vcpu->arch.local_int.float_int = &kvm->arch.float_int;
355
spin_lock(&kvm->arch.float_int.lock);
356
kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int;
357
init_waitqueue_head(&vcpu->arch.local_int.wq);
358
vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
359
spin_unlock(&kvm->arch.float_int.lock);
361
rc = kvm_vcpu_init(vcpu, kvm, id);
363
goto out_free_sie_block;
364
VM_EVENT(kvm, 3, "create cpu %d at %p, sie block at %p", id, vcpu,
365
vcpu->arch.sie_block);
369
free_page((unsigned long)(vcpu->arch.sie_block));
376
int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
378
/* kvm common code refers to this, but never calls it */
383
static int kvm_arch_vcpu_ioctl_initial_reset(struct kvm_vcpu *vcpu)
385
kvm_s390_vcpu_initial_reset(vcpu);
389
int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
391
memcpy(&vcpu->arch.guest_gprs, ®s->gprs, sizeof(regs->gprs));
395
int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
397
memcpy(®s->gprs, &vcpu->arch.guest_gprs, sizeof(regs->gprs));
401
int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
402
struct kvm_sregs *sregs)
404
memcpy(&vcpu->arch.guest_acrs, &sregs->acrs, sizeof(sregs->acrs));
405
memcpy(&vcpu->arch.sie_block->gcr, &sregs->crs, sizeof(sregs->crs));
406
restore_access_regs(vcpu->arch.guest_acrs);
410
int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
411
struct kvm_sregs *sregs)
413
memcpy(&sregs->acrs, &vcpu->arch.guest_acrs, sizeof(sregs->acrs));
414
memcpy(&sregs->crs, &vcpu->arch.sie_block->gcr, sizeof(sregs->crs));
418
int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
420
memcpy(&vcpu->arch.guest_fpregs.fprs, &fpu->fprs, sizeof(fpu->fprs));
421
vcpu->arch.guest_fpregs.fpc = fpu->fpc;
422
restore_fp_regs(&vcpu->arch.guest_fpregs);
426
int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu)
428
memcpy(&fpu->fprs, &vcpu->arch.guest_fpregs.fprs, sizeof(fpu->fprs));
429
fpu->fpc = vcpu->arch.guest_fpregs.fpc;
433
static int kvm_arch_vcpu_ioctl_set_initial_psw(struct kvm_vcpu *vcpu, psw_t psw)
437
if (!(atomic_read(&vcpu->arch.sie_block->cpuflags) & CPUSTAT_STOPPED))
440
vcpu->run->psw_mask = psw.mask;
441
vcpu->run->psw_addr = psw.addr;
446
int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
447
struct kvm_translation *tr)
449
return -EINVAL; /* not implemented yet */
452
int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu,
453
struct kvm_guest_debug *dbg)
455
return -EINVAL; /* not implemented yet */
458
int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu,
459
struct kvm_mp_state *mp_state)
461
return -EINVAL; /* not implemented yet */
464
int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
465
struct kvm_mp_state *mp_state)
467
return -EINVAL; /* not implemented yet */
470
static void __vcpu_run(struct kvm_vcpu *vcpu)
472
memcpy(&vcpu->arch.sie_block->gg14, &vcpu->arch.guest_gprs[14], 16);
477
if (test_thread_flag(TIF_MCCK_PENDING))
480
kvm_s390_deliver_pending_interrupts(vcpu);
482
vcpu->arch.sie_block->icptcode = 0;
486
VCPU_EVENT(vcpu, 6, "entering sie flags %x",
487
atomic_read(&vcpu->arch.sie_block->cpuflags));
488
if (sie64a(vcpu->arch.sie_block, vcpu->arch.guest_gprs)) {
489
VCPU_EVENT(vcpu, 3, "%s", "fault in sie instruction");
490
kvm_s390_inject_program_int(vcpu, PGM_ADDRESSING);
492
VCPU_EVENT(vcpu, 6, "exit sie icptcode %d",
493
vcpu->arch.sie_block->icptcode);
498
memcpy(&vcpu->arch.guest_gprs[14], &vcpu->arch.sie_block->gg14, 16);
501
int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
507
if (vcpu->sigset_active)
508
sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
510
atomic_clear_mask(CPUSTAT_STOPPED, &vcpu->arch.sie_block->cpuflags);
512
BUG_ON(vcpu->kvm->arch.float_int.local_int[vcpu->vcpu_id] == NULL);
514
switch (kvm_run->exit_reason) {
515
case KVM_EXIT_S390_SIEIC:
516
case KVM_EXIT_UNKNOWN:
518
case KVM_EXIT_S390_RESET:
524
vcpu->arch.sie_block->gpsw.mask = kvm_run->psw_mask;
525
vcpu->arch.sie_block->gpsw.addr = kvm_run->psw_addr;
531
rc = kvm_handle_sie_intercept(vcpu);
532
} while (!signal_pending(current) && !rc);
534
if (rc == SIE_INTERCEPT_RERUNVCPU)
537
if (signal_pending(current) && !rc) {
538
kvm_run->exit_reason = KVM_EXIT_INTR;
542
if (rc == -EOPNOTSUPP) {
543
/* intercept cannot be handled in-kernel, prepare kvm-run */
544
kvm_run->exit_reason = KVM_EXIT_S390_SIEIC;
545
kvm_run->s390_sieic.icptcode = vcpu->arch.sie_block->icptcode;
546
kvm_run->s390_sieic.ipa = vcpu->arch.sie_block->ipa;
547
kvm_run->s390_sieic.ipb = vcpu->arch.sie_block->ipb;
551
if (rc == -EREMOTE) {
552
/* intercept was handled, but userspace support is needed
553
* kvm_run has been prepared by the handler */
557
kvm_run->psw_mask = vcpu->arch.sie_block->gpsw.mask;
558
kvm_run->psw_addr = vcpu->arch.sie_block->gpsw.addr;
560
if (vcpu->sigset_active)
561
sigprocmask(SIG_SETMASK, &sigsaved, NULL);
563
vcpu->stat.exit_userspace++;
567
static int __guestcopy(struct kvm_vcpu *vcpu, u64 guestdest, void *from,
568
unsigned long n, int prefix)
571
return copy_to_guest(vcpu, guestdest, from, n);
573
return copy_to_guest_absolute(vcpu, guestdest, from, n);
577
* store status at address
578
* we use have two special cases:
579
* KVM_S390_STORE_STATUS_NOADDR: -> 0x1200 on 64 bit
580
* KVM_S390_STORE_STATUS_PREFIXED: -> prefix
582
int kvm_s390_vcpu_store_status(struct kvm_vcpu *vcpu, unsigned long addr)
584
unsigned char archmode = 1;
587
if (addr == KVM_S390_STORE_STATUS_NOADDR) {
588
if (copy_to_guest_absolute(vcpu, 163ul, &archmode, 1))
590
addr = SAVE_AREA_BASE;
592
} else if (addr == KVM_S390_STORE_STATUS_PREFIXED) {
593
if (copy_to_guest(vcpu, 163ul, &archmode, 1))
595
addr = SAVE_AREA_BASE;
600
if (__guestcopy(vcpu, addr + offsetof(struct save_area, fp_regs),
601
vcpu->arch.guest_fpregs.fprs, 128, prefix))
604
if (__guestcopy(vcpu, addr + offsetof(struct save_area, gp_regs),
605
vcpu->arch.guest_gprs, 128, prefix))
608
if (__guestcopy(vcpu, addr + offsetof(struct save_area, psw),
609
&vcpu->arch.sie_block->gpsw, 16, prefix))
612
if (__guestcopy(vcpu, addr + offsetof(struct save_area, pref_reg),
613
&vcpu->arch.sie_block->prefix, 4, prefix))
616
if (__guestcopy(vcpu,
617
addr + offsetof(struct save_area, fp_ctrl_reg),
618
&vcpu->arch.guest_fpregs.fpc, 4, prefix))
621
if (__guestcopy(vcpu, addr + offsetof(struct save_area, tod_reg),
622
&vcpu->arch.sie_block->todpr, 4, prefix))
625
if (__guestcopy(vcpu, addr + offsetof(struct save_area, timer),
626
&vcpu->arch.sie_block->cputm, 8, prefix))
629
if (__guestcopy(vcpu, addr + offsetof(struct save_area, clk_cmp),
630
&vcpu->arch.sie_block->ckc, 8, prefix))
633
if (__guestcopy(vcpu, addr + offsetof(struct save_area, acc_regs),
634
&vcpu->arch.guest_acrs, 64, prefix))
637
if (__guestcopy(vcpu,
638
addr + offsetof(struct save_area, ctrl_regs),
639
&vcpu->arch.sie_block->gcr, 128, prefix))
644
long kvm_arch_vcpu_ioctl(struct file *filp,
645
unsigned int ioctl, unsigned long arg)
647
struct kvm_vcpu *vcpu = filp->private_data;
648
void __user *argp = (void __user *)arg;
652
case KVM_S390_INTERRUPT: {
653
struct kvm_s390_interrupt s390int;
656
if (copy_from_user(&s390int, argp, sizeof(s390int)))
658
r = kvm_s390_inject_vcpu(vcpu, &s390int);
661
case KVM_S390_STORE_STATUS:
662
r = kvm_s390_vcpu_store_status(vcpu, arg);
664
case KVM_S390_SET_INITIAL_PSW: {
668
if (copy_from_user(&psw, argp, sizeof(psw)))
670
r = kvm_arch_vcpu_ioctl_set_initial_psw(vcpu, psw);
673
case KVM_S390_INITIAL_RESET:
674
r = kvm_arch_vcpu_ioctl_initial_reset(vcpu);
682
/* Section: memory related */
683
int kvm_arch_prepare_memory_region(struct kvm *kvm,
684
struct kvm_memory_slot *memslot,
685
struct kvm_memory_slot old,
686
struct kvm_userspace_memory_region *mem,
689
/* A few sanity checks. We can have exactly one memory slot which has
690
to start at guest virtual zero and which has to be located at a
691
page boundary in userland and which has to end at a page boundary.
692
The memory in userland is ok to be fragmented into various different
693
vmas. It is okay to mmap() and munmap() stuff in this slot after
694
doing this call at any time */
699
if (mem->guest_phys_addr)
702
if (mem->userspace_addr & 0xffffful)
705
if (mem->memory_size & 0xffffful)
714
void kvm_arch_commit_memory_region(struct kvm *kvm,
715
struct kvm_userspace_memory_region *mem,
716
struct kvm_memory_slot old,
722
rc = gmap_map_segment(kvm->arch.gmap, mem->userspace_addr,
723
mem->guest_phys_addr, mem->memory_size);
725
printk(KERN_WARNING "kvm-s390: failed to commit memory region\n");
729
void kvm_arch_flush_shadow(struct kvm *kvm)
733
static int __init kvm_s390_init(void)
736
ret = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE);
741
* guests can ask for up to 255+1 double words, we need a full page
742
* to hold the maximum amount of facilities. On the other hand, we
743
* only set facilities that are known to work in KVM.
745
facilities = (unsigned long long *) get_zeroed_page(GFP_KERNEL|GFP_DMA);
750
memcpy(facilities, S390_lowcore.stfle_fac_list, 16);
751
facilities[0] &= 0xff00fff3f47c0000ULL;
752
facilities[1] &= 0x201c000000000000ULL;
756
static void __exit kvm_s390_exit(void)
758
free_page((unsigned long) facilities);
762
module_init(kvm_s390_init);
763
module_exit(kvm_s390_exit);