[net-next-2.6.git] / drivers / kvm / x86.c

/*
 * Kernel-based Virtual Machine driver for Linux
 *
 * derived from drivers/kvm/kvm_main.c
 *
 * Copyright (C) 2006 Qumranet, Inc.
 *
 * Authors:
 *   Avi Kivity   <avi@qumranet.com>
 *   Yaniv Kamay  <yaniv@qumranet.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2.  See
 * the COPYING file in the top-level directory.
 *
 */

#include "kvm.h"
#include "x86.h"
#include "segment_descriptor.h"
#include "irq.h"

#include <linux/kvm.h>
#include <linux/fs.h>
#include <linux/vmalloc.h>
#include <linux/module.h>

#include <asm/uaccess.h>

#define MAX_IO_MSRS 256

unsigned long segment_base(u16 selector)
{
	struct descriptor_table gdt;
	struct segment_descriptor *d;
	unsigned long table_base;
	unsigned long v;

	if (selector == 0)
		return 0;

	asm("sgdt %0" : "=m"(gdt));
	table_base = gdt.base;

	if (selector & 4) {           /* from ldt */
		u16 ldt_selector;

		asm("sldt %0" : "=g"(ldt_selector));
		table_base = segment_base(ldt_selector);
	}
	d = (struct segment_descriptor *)(table_base + (selector & ~7));
	v = d->base_low | ((unsigned long)d->base_mid << 16) |
		((unsigned long)d->base_high << 24);
#ifdef CONFIG_X86_64
	if (d->system == 0 && (d->type == 2 || d->type == 9 || d->type == 11))
		v |= ((unsigned long) \
		      ((struct segment_descriptor_64 *)d)->base_higher) << 32;
#endif
	return v;
}
EXPORT_SYMBOL_GPL(segment_base);

/*
 * List of msr numbers which we expose to userspace through KVM_GET_MSRS
 * and KVM_SET_MSRS, and KVM_GET_MSR_INDEX_LIST.
 *
 * This list is modified at module load time to reflect the
 * capabilities of the host cpu.
 */
static u32 msrs_to_save[] = {
	MSR_IA32_SYSENTER_CS, MSR_IA32_SYSENTER_ESP, MSR_IA32_SYSENTER_EIP,
	MSR_K6_STAR,
#ifdef CONFIG_X86_64
	MSR_CSTAR, MSR_KERNEL_GS_BASE, MSR_SYSCALL_MASK, MSR_LSTAR,
#endif
	MSR_IA32_TIME_STAMP_COUNTER,
};

static unsigned num_msrs_to_save;

static u32 emulated_msrs[] = {
	MSR_IA32_MISC_ENABLE,
};

/*
 * Adapt set_msr() to msr_io()'s calling convention
 */
static int do_set_msr(struct kvm_vcpu *vcpu, unsigned index, u64 *data)
{
	return kvm_set_msr(vcpu, index, *data);
}

/*
 * Read or write a bunch of msrs. All parameters are kernel addresses.
 *
 * @return number of msrs set successfully.
 */
static int __msr_io(struct kvm_vcpu *vcpu, struct kvm_msrs *msrs,
		    struct kvm_msr_entry *entries,
		    int (*do_msr)(struct kvm_vcpu *vcpu,
				  unsigned index, u64 *data))
{
	int i;

	vcpu_load(vcpu);

	for (i = 0; i < msrs->nmsrs; ++i)
		if (do_msr(vcpu, entries[i].index, &entries[i].data))
			break;

	vcpu_put(vcpu);

	return i;
}

/*
 * Read or write a bunch of msrs. Parameters are user addresses.
 *
 * @return number of msrs set successfully.
 */
static int msr_io(struct kvm_vcpu *vcpu, struct kvm_msrs __user *user_msrs,
		  int (*do_msr)(struct kvm_vcpu *vcpu,
				unsigned index, u64 *data),
		  int writeback)
{
	struct kvm_msrs msrs;
	struct kvm_msr_entry *entries;
	int r, n;
	unsigned size;

	r = -EFAULT;
	if (copy_from_user(&msrs, user_msrs, sizeof msrs))
		goto out;

	r = -E2BIG;
	if (msrs.nmsrs >= MAX_IO_MSRS)
		goto out;

	r = -ENOMEM;
	size = sizeof(struct kvm_msr_entry) * msrs.nmsrs;
	entries = vmalloc(size);
	if (!entries)
		goto out;

	r = -EFAULT;
	if (copy_from_user(entries, user_msrs->entries, size))
		goto out_free;

	r = n = __msr_io(vcpu, &msrs, entries, do_msr);
	if (r < 0)
		goto out_free;

	r = -EFAULT;
	if (writeback && copy_to_user(user_msrs->entries, entries, size))
		goto out_free;

	r = n;

out_free:
	vfree(entries);
out:
	return r;
}

long kvm_arch_dev_ioctl(struct file *filp,
			unsigned int ioctl, unsigned long arg)
{
	void __user *argp = (void __user *)arg;
	long r;

	switch (ioctl) {
	case KVM_GET_MSR_INDEX_LIST: {
		struct kvm_msr_list __user *user_msr_list = argp;
		struct kvm_msr_list msr_list;
		unsigned n;

		r = -EFAULT;
		if (copy_from_user(&msr_list, user_msr_list, sizeof msr_list))
			goto out;
		n = msr_list.nmsrs;
		msr_list.nmsrs = num_msrs_to_save + ARRAY_SIZE(emulated_msrs);
		if (copy_to_user(user_msr_list, &msr_list, sizeof msr_list))
			goto out;
		r = -E2BIG;
		if (n < num_msrs_to_save)
			goto out;
		r = -EFAULT;
		if (copy_to_user(user_msr_list->indices, &msrs_to_save,
				 num_msrs_to_save * sizeof(u32)))
			goto out;
		if (copy_to_user(user_msr_list->indices
				 + num_msrs_to_save * sizeof(u32),
				 &emulated_msrs,
				 ARRAY_SIZE(emulated_msrs) * sizeof(u32)))
			goto out;
		r = 0;
		break;
	}
	default:
		r = -EINVAL;
	}
out:
	return r;
}

void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
{
	kvm_x86_ops->vcpu_load(vcpu, cpu);
}

void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
{
	kvm_x86_ops->vcpu_put(vcpu);
}

static void cpuid_fix_nx_cap(struct kvm_vcpu *vcpu)
{
	u64 efer;
	int i;
	struct kvm_cpuid_entry *e, *entry;

	rdmsrl(MSR_EFER, efer);
	entry = NULL;
	for (i = 0; i < vcpu->cpuid_nent; ++i) {
		e = &vcpu->cpuid_entries[i];
		if (e->function == 0x80000001) {
			entry = e;
			break;
		}
	}
	if (entry && (entry->edx & (1 << 20)) && !(efer & EFER_NX)) {
		entry->edx &= ~(1 << 20);
		printk(KERN_INFO "kvm: guest NX capability removed\n");
	}
}

static int kvm_vcpu_ioctl_set_cpuid(struct kvm_vcpu *vcpu,
				    struct kvm_cpuid *cpuid,
				    struct kvm_cpuid_entry __user *entries)
{
	int r;

	r = -E2BIG;
	if (cpuid->nent > KVM_MAX_CPUID_ENTRIES)
		goto out;
	r = -EFAULT;
	if (copy_from_user(&vcpu->cpuid_entries, entries,
			   cpuid->nent * sizeof(struct kvm_cpuid_entry)))
		goto out;
	vcpu->cpuid_nent = cpuid->nent;
	cpuid_fix_nx_cap(vcpu);
	return 0;

out:
	return r;
}

static int kvm_vcpu_ioctl_get_lapic(struct kvm_vcpu *vcpu,
				    struct kvm_lapic_state *s)
{
	vcpu_load(vcpu);
	memcpy(s->regs, vcpu->apic->regs, sizeof *s);
	vcpu_put(vcpu);

	return 0;
}

static int kvm_vcpu_ioctl_set_lapic(struct kvm_vcpu *vcpu,
				    struct kvm_lapic_state *s)
{
	vcpu_load(vcpu);
	memcpy(vcpu->apic->regs, s->regs, sizeof *s);
	kvm_apic_post_state_restore(vcpu);
	vcpu_put(vcpu);

	return 0;
}

long kvm_arch_vcpu_ioctl(struct file *filp,
			 unsigned int ioctl, unsigned long arg)
{
	struct kvm_vcpu *vcpu = filp->private_data;
	void __user *argp = (void __user *)arg;
	int r;

	switch (ioctl) {
	case KVM_GET_LAPIC: {
		struct kvm_lapic_state lapic;

		memset(&lapic, 0, sizeof lapic);
		r = kvm_vcpu_ioctl_get_lapic(vcpu, &lapic);
		if (r)
			goto out;
		r = -EFAULT;
		if (copy_to_user(argp, &lapic, sizeof lapic))
			goto out;
		r = 0;
		break;
	}
	case KVM_SET_LAPIC: {
		struct kvm_lapic_state lapic;

		r = -EFAULT;
		if (copy_from_user(&lapic, argp, sizeof lapic))
			goto out;
		r = kvm_vcpu_ioctl_set_lapic(vcpu, &lapic);;
		if (r)
			goto out;
		r = 0;
		break;
	}
	case KVM_SET_CPUID: {
		struct kvm_cpuid __user *cpuid_arg = argp;
		struct kvm_cpuid cpuid;

		r = -EFAULT;
		if (copy_from_user(&cpuid, cpuid_arg, sizeof cpuid))
			goto out;
		r = kvm_vcpu_ioctl_set_cpuid(vcpu, &cpuid, cpuid_arg->entries);
		if (r)
			goto out;
		break;
	}
	case KVM_GET_MSRS:
		r = msr_io(vcpu, argp, kvm_get_msr, 1);
		break;
	case KVM_SET_MSRS:
		r = msr_io(vcpu, argp, do_set_msr, 0);
		break;
	default:
		r = -EINVAL;
	}
out:
	return r;
}

static int kvm_vm_ioctl_set_tss_addr(struct kvm *kvm, unsigned long addr)
{
	int ret;

	if (addr > (unsigned int)(-3 * PAGE_SIZE))
		return -1;
	ret = kvm_x86_ops->set_tss_addr(kvm, addr);
	return ret;
}

static int kvm_vm_ioctl_set_nr_mmu_pages(struct kvm *kvm,
					  u32 kvm_nr_mmu_pages)
{
	if (kvm_nr_mmu_pages < KVM_MIN_ALLOC_MMU_PAGES)
		return -EINVAL;

	mutex_lock(&kvm->lock);

	kvm_mmu_change_mmu_pages(kvm, kvm_nr_mmu_pages);
	kvm->n_requested_mmu_pages = kvm_nr_mmu_pages;

	mutex_unlock(&kvm->lock);
	return 0;
}

static int kvm_vm_ioctl_get_nr_mmu_pages(struct kvm *kvm)
{
	return kvm->n_alloc_mmu_pages;
}

/*
 * Set a new alias region.  Aliases map a portion of physical memory into
 * another portion.  This is useful for memory windows, for example the PC
 * VGA region.
 */
static int kvm_vm_ioctl_set_memory_alias(struct kvm *kvm,
					 struct kvm_memory_alias *alias)
{
	int r, n;
	struct kvm_mem_alias *p;

	r = -EINVAL;
	/* General sanity checks */
	if (alias->memory_size & (PAGE_SIZE - 1))
		goto out;
	if (alias->guest_phys_addr & (PAGE_SIZE - 1))
		goto out;
	if (alias->slot >= KVM_ALIAS_SLOTS)
		goto out;
	if (alias->guest_phys_addr + alias->memory_size
	    < alias->guest_phys_addr)
		goto out;
	if (alias->target_phys_addr + alias->memory_size
	    < alias->target_phys_addr)
		goto out;

	mutex_lock(&kvm->lock);

	p = &kvm->aliases[alias->slot];
	p->base_gfn = alias->guest_phys_addr >> PAGE_SHIFT;
	p->npages = alias->memory_size >> PAGE_SHIFT;
	p->target_gfn = alias->target_phys_addr >> PAGE_SHIFT;

	for (n = KVM_ALIAS_SLOTS; n > 0; --n)
		if (kvm->aliases[n - 1].npages)
			break;
	kvm->naliases = n;

	kvm_mmu_zap_all(kvm);

	mutex_unlock(&kvm->lock);

	return 0;

out:
	return r;
}

static int kvm_vm_ioctl_get_irqchip(struct kvm *kvm, struct kvm_irqchip *chip)
{
	int r;

	r = 0;
	switch (chip->chip_id) {
	case KVM_IRQCHIP_PIC_MASTER:
		memcpy(&chip->chip.pic,
			&pic_irqchip(kvm)->pics[0],
			sizeof(struct kvm_pic_state));
		break;
	case KVM_IRQCHIP_PIC_SLAVE:
		memcpy(&chip->chip.pic,
			&pic_irqchip(kvm)->pics[1],
			sizeof(struct kvm_pic_state));
		break;
	case KVM_IRQCHIP_IOAPIC:
		memcpy(&chip->chip.ioapic,
			ioapic_irqchip(kvm),
			sizeof(struct kvm_ioapic_state));
		break;
	default:
		r = -EINVAL;
		break;
	}
	return r;
}

static int kvm_vm_ioctl_set_irqchip(struct kvm *kvm, struct kvm_irqchip *chip)
{
	int r;

	r = 0;
	switch (chip->chip_id) {
	case KVM_IRQCHIP_PIC_MASTER:
		memcpy(&pic_irqchip(kvm)->pics[0],
			&chip->chip.pic,
			sizeof(struct kvm_pic_state));
		break;
	case KVM_IRQCHIP_PIC_SLAVE:
		memcpy(&pic_irqchip(kvm)->pics[1],
			&chip->chip.pic,
			sizeof(struct kvm_pic_state));
		break;
	case KVM_IRQCHIP_IOAPIC:
		memcpy(ioapic_irqchip(kvm),
			&chip->chip.ioapic,
			sizeof(struct kvm_ioapic_state));
		break;
	default:
		r = -EINVAL;
		break;
	}
	kvm_pic_update_irq(pic_irqchip(kvm));
	return r;
}

long kvm_arch_vm_ioctl(struct file *filp,
		       unsigned int ioctl, unsigned long arg)
{
	struct kvm *kvm = filp->private_data;
	void __user *argp = (void __user *)arg;
	int r = -EINVAL;

	switch (ioctl) {
	case KVM_SET_TSS_ADDR:
		r = kvm_vm_ioctl_set_tss_addr(kvm, arg);
		if (r < 0)
			goto out;
		break;
	case KVM_SET_MEMORY_REGION: {
		struct kvm_memory_region kvm_mem;
		struct kvm_userspace_memory_region kvm_userspace_mem;

		r = -EFAULT;
		if (copy_from_user(&kvm_mem, argp, sizeof kvm_mem))
			goto out;
		kvm_userspace_mem.slot = kvm_mem.slot;
		kvm_userspace_mem.flags = kvm_mem.flags;
		kvm_userspace_mem.guest_phys_addr = kvm_mem.guest_phys_addr;
		kvm_userspace_mem.memory_size = kvm_mem.memory_size;
		r = kvm_vm_ioctl_set_memory_region(kvm, &kvm_userspace_mem, 0);
		if (r)
			goto out;
		break;
	}
	case KVM_SET_NR_MMU_PAGES:
		r = kvm_vm_ioctl_set_nr_mmu_pages(kvm, arg);
		if (r)
			goto out;
		break;
	case KVM_GET_NR_MMU_PAGES:
		r = kvm_vm_ioctl_get_nr_mmu_pages(kvm);
		break;
	case KVM_SET_MEMORY_ALIAS: {
		struct kvm_memory_alias alias;

		r = -EFAULT;
		if (copy_from_user(&alias, argp, sizeof alias))
			goto out;
		r = kvm_vm_ioctl_set_memory_alias(kvm, &alias);
		if (r)
			goto out;
		break;
	}
	case KVM_CREATE_IRQCHIP:
		r = -ENOMEM;
		kvm->vpic = kvm_create_pic(kvm);
		if (kvm->vpic) {
			r = kvm_ioapic_init(kvm);
			if (r) {
				kfree(kvm->vpic);
				kvm->vpic = NULL;
				goto out;
			}
		} else
			goto out;
		break;
	case KVM_IRQ_LINE: {
		struct kvm_irq_level irq_event;

		r = -EFAULT;
		if (copy_from_user(&irq_event, argp, sizeof irq_event))
			goto out;
		if (irqchip_in_kernel(kvm)) {
			mutex_lock(&kvm->lock);
			if (irq_event.irq < 16)
				kvm_pic_set_irq(pic_irqchip(kvm),
					irq_event.irq,
					irq_event.level);
			kvm_ioapic_set_irq(kvm->vioapic,
					irq_event.irq,
					irq_event.level);
			mutex_unlock(&kvm->lock);
			r = 0;
		}
		break;
	}
	case KVM_GET_IRQCHIP: {
		/* 0: PIC master, 1: PIC slave, 2: IOAPIC */
		struct kvm_irqchip chip;

		r = -EFAULT;
		if (copy_from_user(&chip, argp, sizeof chip))
			goto out;
		r = -ENXIO;
		if (!irqchip_in_kernel(kvm))
			goto out;
		r = kvm_vm_ioctl_get_irqchip(kvm, &chip);
		if (r)
			goto out;
		r = -EFAULT;
		if (copy_to_user(argp, &chip, sizeof chip))
			goto out;
		r = 0;
		break;
	}
	case KVM_SET_IRQCHIP: {
		/* 0: PIC master, 1: PIC slave, 2: IOAPIC */
		struct kvm_irqchip chip;

		r = -EFAULT;
		if (copy_from_user(&chip, argp, sizeof chip))
			goto out;
		r = -ENXIO;
		if (!irqchip_in_kernel(kvm))
			goto out;
		r = kvm_vm_ioctl_set_irqchip(kvm, &chip);
		if (r)
			goto out;
		r = 0;
		break;
	}
	default:
		;
	}
out:
	return r;
}

static __init void kvm_init_msr_list(void)
{
	u32 dummy[2];
	unsigned i, j;

	for (i = j = 0; i < ARRAY_SIZE(msrs_to_save); i++) {
		if (rdmsr_safe(msrs_to_save[i], &dummy[0], &dummy[1]) < 0)
			continue;
		if (j < i)
			msrs_to_save[j] = msrs_to_save[i];
		j++;
	}
	num_msrs_to_save = j;
}

__init void kvm_arch_init(void)
{
	kvm_init_msr_list();
}
Commit	Line	Data
043405e1 CO	1	/*
	2	* Kernel-based Virtual Machine driver for Linux
	3	*
	4	* derived from drivers/kvm/kvm_main.c
	5	*
	6	* Copyright (C) 2006 Qumranet, Inc.
	7	*
	8	* Authors:
	9	* Avi Kivity <avi@qumranet.com>
	10	* Yaniv Kamay <yaniv@qumranet.com>
	11	*
	12	* This work is licensed under the terms of the GNU GPL, version 2. See
	13	* the COPYING file in the top-level directory.
	14	*
	15	*/
	16
313a3dc7	17	#include "kvm.h"
043405e1	18	#include "x86.h"
5fb76f9b	19	#include "segment_descriptor.h"
313a3dc7 CO	20	#include "irq.h"
	21
	22	#include <linux/kvm.h>
	23	#include <linux/fs.h>
	24	#include <linux/vmalloc.h>
5fb76f9b	25	#include <linux/module.h>
043405e1 CO	26
	27	#include <asm/uaccess.h>
	28
313a3dc7 CO	29	#define MAX_IO_MSRS 256
313a3dc7 CO	30
5fb76f9b CO	31	unsigned long segment_base(u16 selector)
	32	{
	33	struct descriptor_table gdt;
	34	struct segment_descriptor *d;
	35	unsigned long table_base;
	36	unsigned long v;
	37
	38	if (selector == 0)
	39	return 0;
	40
	41	asm("sgdt %0" : "=m"(gdt));
	42	table_base = gdt.base;
	43
	44	if (selector & 4) { /* from ldt */
	45	u16 ldt_selector;
	46
	47	asm("sldt %0" : "=g"(ldt_selector));
	48	table_base = segment_base(ldt_selector);
	49	}
	50	d = (struct segment_descriptor *)(table_base + (selector & ~7));
	51	v = d->base_low \| ((unsigned long)d->base_mid << 16) \|
	52	((unsigned long)d->base_high << 24);
	53	#ifdef CONFIG_X86_64
	54	if (d->system == 0 && (d->type == 2 \|\| d->type == 9 \|\| d->type == 11))
	55	v \|= ((unsigned long) \
	56	((struct segment_descriptor_64 *)d)->base_higher) << 32;
	57	#endif
	58	return v;
	59	}
	60	EXPORT_SYMBOL_GPL(segment_base);
	61
043405e1 CO	62	/*
	63	* List of msr numbers which we expose to userspace through KVM_GET_MSRS
	64	* and KVM_SET_MSRS, and KVM_GET_MSR_INDEX_LIST.
	65	*
	66	* This list is modified at module load time to reflect the
	67	* capabilities of the host cpu.
	68	*/
	69	static u32 msrs_to_save[] = {
	70	MSR_IA32_SYSENTER_CS, MSR_IA32_SYSENTER_ESP, MSR_IA32_SYSENTER_EIP,
	71	MSR_K6_STAR,
	72	#ifdef CONFIG_X86_64
	73	MSR_CSTAR, MSR_KERNEL_GS_BASE, MSR_SYSCALL_MASK, MSR_LSTAR,
	74	#endif
	75	MSR_IA32_TIME_STAMP_COUNTER,
	76	};
	77
	78	static unsigned num_msrs_to_save;
	79
	80	static u32 emulated_msrs[] = {
	81	MSR_IA32_MISC_ENABLE,
	82	};
	83
313a3dc7 CO	84	/*
	85	* Adapt set_msr() to msr_io()'s calling convention
	86	*/
	87	static int do_set_msr(struct kvm_vcpu vcpu, unsigned index, u64 data)
	88	{
	89	return kvm_set_msr(vcpu, index, *data);
	90	}
	91
	92	/*
	93	* Read or write a bunch of msrs. All parameters are kernel addresses.
	94	*
	95	* @return number of msrs set successfully.
	96	*/
	97	static int __msr_io(struct kvm_vcpu vcpu, struct kvm_msrs msrs,
	98	struct kvm_msr_entry *entries,
	99	int (do_msr)(struct kvm_vcpu vcpu,
	100	unsigned index, u64 *data))
	101	{
	102	int i;
	103
	104	vcpu_load(vcpu);
	105
	106	for (i = 0; i < msrs->nmsrs; ++i)
	107	if (do_msr(vcpu, entries[i].index, &entries[i].data))
	108	break;
	109
	110	vcpu_put(vcpu);
	111
	112	return i;
	113	}
	114
	115	/*
	116	* Read or write a bunch of msrs. Parameters are user addresses.
	117	*
	118	* @return number of msrs set successfully.
	119	*/
	120	static int msr_io(struct kvm_vcpu vcpu, struct kvm_msrs __user user_msrs,
	121	int (do_msr)(struct kvm_vcpu vcpu,
	122	unsigned index, u64 *data),
	123	int writeback)
	124	{
	125	struct kvm_msrs msrs;
	126	struct kvm_msr_entry *entries;
	127	int r, n;
	128	unsigned size;
	129
	130	r = -EFAULT;
	131	if (copy_from_user(&msrs, user_msrs, sizeof msrs))
	132	goto out;
	133
	134	r = -E2BIG;
	135	if (msrs.nmsrs >= MAX_IO_MSRS)
	136	goto out;
	137
	138	r = -ENOMEM;
	139	size = sizeof(struct kvm_msr_entry) * msrs.nmsrs;
	140	entries = vmalloc(size);
	141	if (!entries)
	142	goto out;
	143
	144	r = -EFAULT;
	145	if (copy_from_user(entries, user_msrs->entries, size))
	146	goto out_free;
	147
148	r = n = __msr_io(vcpu, &msrs, entries, do_msr);
149	if (r < 0)
150	goto out_free;
151
152	r = -EFAULT;
153	if (writeback && copy_to_user(user_msrs->entries, entries, size))
154	goto out_free;
155
156	r = n;
157
158	out_free:
159	vfree(entries);
160	out:
161	return r;
162	}
163
043405e1 CO	164	long kvm_arch_dev_ioctl(struct file *filp,
	165	unsigned int ioctl, unsigned long arg)
	166	{
	167	void __user argp = (void __user )arg;
	168	long r;
	169
	170	switch (ioctl) {
	171	case KVM_GET_MSR_INDEX_LIST: {
	172	struct kvm_msr_list __user *user_msr_list = argp;
	173	struct kvm_msr_list msr_list;
	174	unsigned n;
	175
	176	r = -EFAULT;
	177	if (copy_from_user(&msr_list, user_msr_list, sizeof msr_list))
	178	goto out;
	179	n = msr_list.nmsrs;
	180	msr_list.nmsrs = num_msrs_to_save + ARRAY_SIZE(emulated_msrs);
	181	if (copy_to_user(user_msr_list, &msr_list, sizeof msr_list))
	182	goto out;
	183	r = -E2BIG;
	184	if (n < num_msrs_to_save)
	185	goto out;
	186	r = -EFAULT;
	187	if (copy_to_user(user_msr_list->indices, &msrs_to_save,
	188	num_msrs_to_save * sizeof(u32)))
	189	goto out;
	190	if (copy_to_user(user_msr_list->indices
	191	+ num_msrs_to_save * sizeof(u32),
	192	&emulated_msrs,
	193	ARRAY_SIZE(emulated_msrs) * sizeof(u32)))
	194	goto out;
	195	r = 0;
	196	break;
	197	}
	198	default:
	199	r = -EINVAL;
	200	}
	201	out:
	202	return r;
	203	}
	204
313a3dc7 CO	205	void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
	206	{
	207	kvm_x86_ops->vcpu_load(vcpu, cpu);
	208	}
	209
	210	void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
	211	{
	212	kvm_x86_ops->vcpu_put(vcpu);
	213	}
	214
	215	static void cpuid_fix_nx_cap(struct kvm_vcpu *vcpu)
	216	{
	217	u64 efer;
	218	int i;
	219	struct kvm_cpuid_entry e, entry;
	220
	221	rdmsrl(MSR_EFER, efer);
	222	entry = NULL;
	223	for (i = 0; i < vcpu->cpuid_nent; ++i) {
	224	e = &vcpu->cpuid_entries[i];
	225	if (e->function == 0x80000001) {
	226	entry = e;
	227	break;
	228	}
	229	}
	230	if (entry && (entry->edx & (1 << 20)) && !(efer & EFER_NX)) {
	231	entry->edx &= ~(1 << 20);
	232	printk(KERN_INFO "kvm: guest NX capability removed\n");
	233	}
	234	}
	235
	236	static int kvm_vcpu_ioctl_set_cpuid(struct kvm_vcpu *vcpu,
	237	struct kvm_cpuid *cpuid,
	238	struct kvm_cpuid_entry __user *entries)
	239	{
	240	int r;
	241
	242	r = -E2BIG;
	243	if (cpuid->nent > KVM_MAX_CPUID_ENTRIES)
	244	goto out;
	245	r = -EFAULT;
	246	if (copy_from_user(&vcpu->cpuid_entries, entries,
	247	cpuid->nent * sizeof(struct kvm_cpuid_entry)))
	248	goto out;
	249	vcpu->cpuid_nent = cpuid->nent;
	250	cpuid_fix_nx_cap(vcpu);
	251	return 0;
	252
	253	out:
	254	return r;
	255	}
	256
	257	static int kvm_vcpu_ioctl_get_lapic(struct kvm_vcpu *vcpu,
	258	struct kvm_lapic_state *s)
	259	{
	260	vcpu_load(vcpu);
	261	memcpy(s->regs, vcpu->apic->regs, sizeof *s);
	262	vcpu_put(vcpu);
	263
	264	return 0;
	265	}
	266
	267	static int kvm_vcpu_ioctl_set_lapic(struct kvm_vcpu *vcpu,
	268	struct kvm_lapic_state *s)
269	{
270	vcpu_load(vcpu);
271	memcpy(vcpu->apic->regs, s->regs, sizeof *s);
272	kvm_apic_post_state_restore(vcpu);
273	vcpu_put(vcpu);
274
275	return 0;
276	}
277
278	long kvm_arch_vcpu_ioctl(struct file *filp,
279	unsigned int ioctl, unsigned long arg)
280	{
281	struct kvm_vcpu *vcpu = filp->private_data;
282	void __user argp = (void __user )arg;
283	int r;
284
285	switch (ioctl) {
286	case KVM_GET_LAPIC: {
287	struct kvm_lapic_state lapic;
288
289	memset(&lapic, 0, sizeof lapic);
290	r = kvm_vcpu_ioctl_get_lapic(vcpu, &lapic);
291	if (r)
292	goto out;
293	r = -EFAULT;
294	if (copy_to_user(argp, &lapic, sizeof lapic))
295	goto out;
296	r = 0;
297	break;
298	}
299	case KVM_SET_LAPIC: {
300	struct kvm_lapic_state lapic;
301
302	r = -EFAULT;
303	if (copy_from_user(&lapic, argp, sizeof lapic))
304	goto out;
305	r = kvm_vcpu_ioctl_set_lapic(vcpu, &lapic);;
306	if (r)
307	goto out;
308	r = 0;
309	break;
310	}
311	case KVM_SET_CPUID: {
312	struct kvm_cpuid __user *cpuid_arg = argp;
313	struct kvm_cpuid cpuid;
314
315	r = -EFAULT;
316	if (copy_from_user(&cpuid, cpuid_arg, sizeof cpuid))
317	goto out;
318	r = kvm_vcpu_ioctl_set_cpuid(vcpu, &cpuid, cpuid_arg->entries);
319	if (r)
320	goto out;
321	break;
322	}
323	case KVM_GET_MSRS:
324	r = msr_io(vcpu, argp, kvm_get_msr, 1);
325	break;
326	case KVM_SET_MSRS:
327	r = msr_io(vcpu, argp, do_set_msr, 0);
328	break;
329	default:
330	r = -EINVAL;
331	}
332	out:
333	return r;
334	}
335
1fe779f8 CO	336	static int kvm_vm_ioctl_set_tss_addr(struct kvm *kvm, unsigned long addr)
	337	{
	338	int ret;
	339
	340	if (addr > (unsigned int)(-3 * PAGE_SIZE))
	341	return -1;
	342	ret = kvm_x86_ops->set_tss_addr(kvm, addr);
	343	return ret;
	344	}
	345
	346	static int kvm_vm_ioctl_set_nr_mmu_pages(struct kvm *kvm,
	347	u32 kvm_nr_mmu_pages)
	348	{
	349	if (kvm_nr_mmu_pages < KVM_MIN_ALLOC_MMU_PAGES)
	350	return -EINVAL;
	351
	352	mutex_lock(&kvm->lock);
	353
	354	kvm_mmu_change_mmu_pages(kvm, kvm_nr_mmu_pages);
	355	kvm->n_requested_mmu_pages = kvm_nr_mmu_pages;
	356
	357	mutex_unlock(&kvm->lock);
	358	return 0;
	359	}
	360
	361	static int kvm_vm_ioctl_get_nr_mmu_pages(struct kvm *kvm)
	362	{
	363	return kvm->n_alloc_mmu_pages;
	364	}
	365
	366	/*
	367	* Set a new alias region. Aliases map a portion of physical memory into
	368	* another portion. This is useful for memory windows, for example the PC
	369	* VGA region.
	370	*/
	371	static int kvm_vm_ioctl_set_memory_alias(struct kvm *kvm,
	372	struct kvm_memory_alias *alias)
	373	{
	374	int r, n;
	375	struct kvm_mem_alias *p;
	376
	377	r = -EINVAL;
	378	/* General sanity checks */
	379	if (alias->memory_size & (PAGE_SIZE - 1))
	380	goto out;
	381	if (alias->guest_phys_addr & (PAGE_SIZE - 1))
	382	goto out;
	383	if (alias->slot >= KVM_ALIAS_SLOTS)
	384	goto out;
	385	if (alias->guest_phys_addr + alias->memory_size
	386	< alias->guest_phys_addr)
	387	goto out;
	388	if (alias->target_phys_addr + alias->memory_size
	389	< alias->target_phys_addr)
	390	goto out;
	391
	392	mutex_lock(&kvm->lock);
	393
	394	p = &kvm->aliases[alias->slot];
	395	p->base_gfn = alias->guest_phys_addr >> PAGE_SHIFT;
	396	p->npages = alias->memory_size >> PAGE_SHIFT;
	397	p->target_gfn = alias->target_phys_addr >> PAGE_SHIFT;
	398
	399	for (n = KVM_ALIAS_SLOTS; n > 0; --n)
400	if (kvm->aliases[n - 1].npages)
401	break;
402	kvm->naliases = n;
403
404	kvm_mmu_zap_all(kvm);
405
406	mutex_unlock(&kvm->lock);
407
408	return 0;
409
410	out:
411	return r;
412	}
413
414	static int kvm_vm_ioctl_get_irqchip(struct kvm kvm, struct kvm_irqchip chip)
415	{
416	int r;
417
418	r = 0;
419	switch (chip->chip_id) {
420	case KVM_IRQCHIP_PIC_MASTER:
421	memcpy(&chip->chip.pic,
422	&pic_irqchip(kvm)->pics[0],
423	sizeof(struct kvm_pic_state));
424	break;
425	case KVM_IRQCHIP_PIC_SLAVE:
426	memcpy(&chip->chip.pic,
427	&pic_irqchip(kvm)->pics[1],
428	sizeof(struct kvm_pic_state));
429	break;
430	case KVM_IRQCHIP_IOAPIC:
431	memcpy(&chip->chip.ioapic,
432	ioapic_irqchip(kvm),
433	sizeof(struct kvm_ioapic_state));
434	break;
435	default:
436	r = -EINVAL;
437	break;
438	}
439	return r;
440	}
441
442	static int kvm_vm_ioctl_set_irqchip(struct kvm kvm, struct kvm_irqchip chip)
443	{
444	int r;
445
446	r = 0;
447	switch (chip->chip_id) {
448	case KVM_IRQCHIP_PIC_MASTER:
449	memcpy(&pic_irqchip(kvm)->pics[0],
450	&chip->chip.pic,
451	sizeof(struct kvm_pic_state));
452	break;
453	case KVM_IRQCHIP_PIC_SLAVE:
454	memcpy(&pic_irqchip(kvm)->pics[1],
455	&chip->chip.pic,
456	sizeof(struct kvm_pic_state));
457	break;
458	case KVM_IRQCHIP_IOAPIC:
459	memcpy(ioapic_irqchip(kvm),
460	&chip->chip.ioapic,
461	sizeof(struct kvm_ioapic_state));
462	break;
463	default:
464	r = -EINVAL;
465	break;
466	}
467	kvm_pic_update_irq(pic_irqchip(kvm));
468	return r;
469	}
470
471	long kvm_arch_vm_ioctl(struct file *filp,
472	unsigned int ioctl, unsigned long arg)
473	{
474	struct kvm *kvm = filp->private_data;
475	void __user argp = (void __user )arg;
476	int r = -EINVAL;
477
478	switch (ioctl) {
479	case KVM_SET_TSS_ADDR:
480	r = kvm_vm_ioctl_set_tss_addr(kvm, arg);
481	if (r < 0)
482	goto out;
483	break;
484	case KVM_SET_MEMORY_REGION: {
485	struct kvm_memory_region kvm_mem;
486	struct kvm_userspace_memory_region kvm_userspace_mem;
487
488	r = -EFAULT;
489	if (copy_from_user(&kvm_mem, argp, sizeof kvm_mem))
490	goto out;
491	kvm_userspace_mem.slot = kvm_mem.slot;
492	kvm_userspace_mem.flags = kvm_mem.flags;
493	kvm_userspace_mem.guest_phys_addr = kvm_mem.guest_phys_addr;
494	kvm_userspace_mem.memory_size = kvm_mem.memory_size;
495	r = kvm_vm_ioctl_set_memory_region(kvm, &kvm_userspace_mem, 0);
496	if (r)
497	goto out;
498	break;
499	}
500	case KVM_SET_NR_MMU_PAGES:
501	r = kvm_vm_ioctl_set_nr_mmu_pages(kvm, arg);
502	if (r)
503	goto out;
504	break;
505	case KVM_GET_NR_MMU_PAGES:
506	r = kvm_vm_ioctl_get_nr_mmu_pages(kvm);
507	break;
508	case KVM_SET_MEMORY_ALIAS: {
509	struct kvm_memory_alias alias;
510
511	r = -EFAULT;
512	if (copy_from_user(&alias, argp, sizeof alias))
513	goto out;
514	r = kvm_vm_ioctl_set_memory_alias(kvm, &alias);
515	if (r)
516	goto out;
517	break;
518	}
519	case KVM_CREATE_IRQCHIP:
520	r = -ENOMEM;
521	kvm->vpic = kvm_create_pic(kvm);
522	if (kvm->vpic) {
523	r = kvm_ioapic_init(kvm);
524	if (r) {
525	kfree(kvm->vpic);
526	kvm->vpic = NULL;
527	goto out;
528	}
529	} else
530	goto out;
531	break;
532	case KVM_IRQ_LINE: {
533	struct kvm_irq_level irq_event;
534
535	r = -EFAULT;
536	if (copy_from_user(&irq_event, argp, sizeof irq_event))
537	goto out;
538	if (irqchip_in_kernel(kvm)) {
539	mutex_lock(&kvm->lock);
540	if (irq_event.irq < 16)
541	kvm_pic_set_irq(pic_irqchip(kvm),
542	irq_event.irq,
543	irq_event.level);
544	kvm_ioapic_set_irq(kvm->vioapic,
545	irq_event.irq,
546	irq_event.level);
547	mutex_unlock(&kvm->lock);
548	r = 0;
549	}
550	break;
551	}
552	case KVM_GET_IRQCHIP: {
553	/* 0: PIC master, 1: PIC slave, 2: IOAPIC */
554	struct kvm_irqchip chip;
555
556	r = -EFAULT;
557	if (copy_from_user(&chip, argp, sizeof chip))
558	goto out;
559	r = -ENXIO;
560	if (!irqchip_in_kernel(kvm))
561	goto out;
562	r = kvm_vm_ioctl_get_irqchip(kvm, &chip);
563	if (r)
564	goto out;
565	r = -EFAULT;
566	if (copy_to_user(argp, &chip, sizeof chip))
567	goto out;
568	r = 0;
569	break;
570	}
571	case KVM_SET_IRQCHIP: {
572	/* 0: PIC master, 1: PIC slave, 2: IOAPIC */
573	struct kvm_irqchip chip;
574
575	r = -EFAULT;
576	if (copy_from_user(&chip, argp, sizeof chip))
577	goto out;
578	r = -ENXIO;
579	if (!irqchip_in_kernel(kvm))
580	goto out;
581	r = kvm_vm_ioctl_set_irqchip(kvm, &chip);
582	if (r)
583	goto out;
584	r = 0;
585	break;
586	}
587	default:
588	;
589	}
590	out:
591	return r;
592	}
593
043405e1 CO	594	static __init void kvm_init_msr_list(void)
	595	{
	596	u32 dummy[2];
	597	unsigned i, j;
	598
	599	for (i = j = 0; i < ARRAY_SIZE(msrs_to_save); i++) {
	600	if (rdmsr_safe(msrs_to_save[i], &dummy[0], &dummy[1]) < 0)
	601	continue;
	602	if (j < i)
	603	msrs_to_save[j] = msrs_to_save[i];
	604	j++;
	605	}
	606	num_msrs_to_save = j;
	607	}
	608
	609	__init void kvm_arch_init(void)
	610	{
	611	kvm_init_msr_list();
	612	}