[v3,1/8] ARM: KVM: Initial skeleton to compile KVM support

Message ID	20110603150318.17011.82777.stgit@ubuntu (mailing list archive)
State	New, archived
Headers	show Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by demeter1.kernel.org (8.14.4/8.14.3) with ESMTP id p53F3aaQ023792 for <patchwork-kvm@patchwork.kernel.org>; Fri, 3 Jun 2011 15:03:36 GMT Subject: [PATCH v3 1/8] ARM: KVM: Initial skeleton to compile KVM support To: catalin.marinas@arm.com, android-virt@lists.cs.columbia.edu From: Christoffer Dall <cdall@cs.columbia.edu> Cc: s.raho@virtualopensystems.com, a.motakis@virtualopensystems.com, c.dall@virtualopensystems.com, kvm@vger.kernel.org, a.costa@virtualopensystems.com Date: Fri, 03 Jun 2011 17:03:19 +0200 Message-ID: <20110603150318.17011.82777.stgit@ubuntu> User-Agent: StGit/0.15 MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 7bit Sender: kvm-owner@vger.kernel.org Precedence: bulk

On 06/03/2011 06:03 PM, Christoffer Dall wrote: > Targets KVM support for Cortex A-15 processors. > > Contains no real functionality but all the framework components, > make files, header files and some tracing functionality. > > + > +struct kvm_regs { > + __u32 regs0_7[8]; /* Unbanked regs. (r0 - r7) */ > + __u32 fiq_regs8_12[5]; /* Banked fiq regs. (r8 - r12) */ > + __u32 usr_regs8_12[5]; /* Banked usr registers (r8 - r12) */ > + __u32 reg13[6]; /* Banked r13, indexed by MODE_ */ > + __u32 reg14[6]; /* Banked r13, indexed by MODE_ */ > + __u32 reg15; > + __u32 cpsr; > + __u32 spsr[5]; /* Banked SPSR, indexed by MODE_ */ > + struct { > + __u32 c2_base0; > + __u32 c2_base1; > + __u32 c3_dacr; > + } cp15; > + > +}; > + > +struct kvm_sregs { > +}; > + > +struct kvm_fpu { > +}; > + > +struct kvm_guest_debug_arch { > +}; > + > +struct kvm_debug_exit_arch { > +}; Presumably, to be filled in later? > + > +/* Get vcpu register for current mode */ > +#define vcpu_reg(_vcpu, _reg_num) \ > + (*kvm_vcpu_reg((_vcpu), _reg_num, vcpu_mode(_vcpu))) > + > +/* Get vcpu register for specific mode */ > +#define vcpu_reg_m(_vcpu, _reg_num, _mode) \ > + (*kvm_vcpu_reg(_vcpu, _reg_num, _mode)) > + > +#define vcpu_cpsr(_vcpu) \ > + (_vcpu->arch.regs.cpsr) > + > +/* Get vcpu SPSR for current mode */ > +#define vcpu_spsr(_vcpu) \ > + kvm_vcpu_spsr(_vcpu, vcpu_mode(_vcpu)) > + > +/* Get vcpu SPSR for specific mode */ > +#define vcpu_spsr_m(_vcpu, _mode) \ > + kvm_vcpu_spsr(_vcpu, _mode) > + > +#define MODE_HAS_SPSR(_vcpu) \ > + ((vcpu_mode(_vcpu))< MODE_USR) > + > +#define VCPU_MODE_PRIV(_vcpu) \ > + (((vcpu_mode(_vcpu)) == MODE_USR) ? 0 : 1) Please use static inlines. Yes, you'll need more helpers to set registers, but it's worth it, especially as some macros evaluate an argument multiple times. > +if VIRTUALIZATION > + > +config KVM > + bool "Kernel-based Virtual Machine (KVM) support" > + select PREEMPT_NOTIFIERS > + select ANON_INODES > + select KVM_ARM_HOST > + select KVM_MMIO > + ---help--- > + Support hosting virtualized guest machines. You will also > + need to select one or more of the processor modules below. > + > + This module provides access to the hardware capabilities through > + a character device node named /dev/kvm. > + > + If unsure, say N. I see you can't support a modular build, which is a pity. > + > +static int k_show(struct seq_file *m, void *v) > +{ > + print_kvm_debug_info(&seq_printf, m); > + return 0; > +} > + > +static void *k_start(struct seq_file *m, loff_t *pos) > +{ > + return *pos< 1 ? (void *)1 : NULL; > +} > + > +static void *k_next(struct seq_file *m, void *v, loff_t *pos) > +{ > + ++*pos; > + return NULL; > +} > + > +static void k_stop(struct seq_file *m, void *v) > +{ > +} > + > +static const struct seq_operations kvmproc_op = { > + .start = k_start, > + .next = k_next, > + .stop = k_stop, > + .show = k_show > +}; > + > +static int kvm_open(struct inode *inode, struct file *file) > +{ > + return seq_open(file,&kvmproc_op); > +} > + > +static const struct file_operations proc_kvm_operations = { > + .open = kvm_open, > + .read = seq_read, > + .llseek = seq_lseek, > + .release = seq_release, > +}; > + > +static int arm_init(void) > +{ > + int rc = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE); > + if (rc == 0) > + proc_create("kvm", 0, NULL,&proc_kvm_operations); > + return rc; > +} /proc is frowned upon these days. Is there no better place for this?+ > +/* > + * Return a pointer to the register number valid in the specified mode of > + * the virtual CPU. > + */ > +u32* kvm_vcpu_reg(struct kvm_vcpu *vcpu, u8 reg_num, u32 mode) > +{ > + struct kvm_vcpu_regs *regs; > + u8 reg_idx; > + BUG_ON(reg_num> 15); > + > + regs =&vcpu->arch.regs; > + > + /* The PC is trivial */ > + if (reg_num == 15) > + return&(regs->pc); > + > + /* Non-banked registers */ > + if (reg_num< 8) > + return&(regs->usr_regs[reg_num]); > + > + /* Banked registers r13 and r14 */ > + if (reg_num>= 13) { > + reg_idx = reg_num - 13; /* 0=r13 and 1=r14 */ > + switch (mode) { > + case MODE_FIQ: > + return&(regs->fiq_regs[reg_idx + 5]); > + case MODE_IRQ: > + return&(regs->irq_regs[reg_idx]); > + case MODE_SVC: > + return&(regs->svc_regs[reg_idx]); > + case MODE_ABT: > + return&(regs->abt_regs[reg_idx]); > + case MODE_UND: > + return&(regs->und_regs[reg_idx]); > + case MODE_USR: > + case MODE_SYS: > + return&(regs->usr_regs[reg_idx]); > + } > + } > + > + /* Banked FIQ registers r8-r12 */ > + if (reg_num>= 8&& reg_num<= 12) { > + if (mode == MODE_FIQ) { > + reg_idx = reg_num - 8; /* 0=r8, ..., 4=r12 */ > + return&(regs->fiq_regs[reg_idx]); > + } else > + return&(regs->usr_regs[reg_num]); > + } You could have a static 2D array indexed by mode and register number, returning an offsetof() into the vcpu structure. > + > + BUG(); > + return NULL; > +} > > diff --git a/arch/arm/kvm/trace.c b/arch/arm/kvm/trace.c > new file mode 100644 > index 0000000..8ea1155 > --- /dev/null > +++ b/arch/arm/kvm/trace.c > @@ -0,0 +1,436 @@ > +/* > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License, version 2, as > + * published by the Free Software Foundation. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + * > + * You should have received a copy of the GNU General Public License > + * along with this program; if not, write to the Free Software > + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. > + * > + */ > +#include<linux/types.h> > +#include<linux/kvm_types.h> > +#include<linux/kvm_host.h> > + > +#include<asm/kvm_emulate.h> > +#include "trace.h" > + > + > +/****************************************************************************** > + * Simple event counting > + */ > + > +struct kvm_event { > + unsigned long long cnt; > + char *descr; > +}; > + > +static struct kvm_event kvm_eventc_log[KVM_EVENTC_ITEMS] = > +{ > + { 0, "switch to guest" }, > + { 0, "exit from guest" }, > + { 0, "Block VCPU" }, > + { 0, "Exit to QEMU for IRQ window" }, > + { 0, "Switch VCPU mode" }, > + { 0, "VCPU IRQs on" }, > + { 0, "VCPU IRQs off" }, > + { 0, "Wait-for-interrupts" }, > + { 0, "Flush shadow page table" }, > + { 0, "Virtual TTBR change" }, > + { 0, "Read guest page table entry" }, > + { 0, "Map GVA to GFN" }, > + { 0, "Virtual DACR change" }, > + { 0, "VCPU switch to privileged mode" }, > + { 0, "VCPU switch from privileged mode" }, > + { 0, "VCPU process ID registers change" }, > + { 0, "Emulate Load/Store with translation" }, > + { 0, "Emulate MRS" }, > + { 0, "Emulate MSR" }, > + { 0, "Emulate CPS" }, > + { 0, "Need reschedule in execution loop" }, > + { 0, "MCR 7, 5, 0 - Invalidate entire I-cache" }, > + { 0, "MCR 7, 5, 1 - Invalidate line in I-cache MVA" }, > + { 0, "MCR 7, 5, 2 - Invalidate line in I-cache set/way" }, > + { 0, "MCR 7, 5, 7 - Flush branch target cache - MVA" }, > + { 0, "MCR 7, 6, 0 - Invalidate entire data cache" }, > + { 0, "MCR 7, 6, 1 - Invalidate data cache line - MVA" }, > + { 0, "MCR 7, 6, 2 - Invalidate data cache line - set/way" }, > + { 0, "MCR 7, 7, 0 - Invalidate D- and I-cache" }, > + { 0, "MCR 7, 10, 0 - Clean entire data cache" }, > + { 0, "MCR 7, 10, 1 - Clean data cache line - MVA" }, > + { 0, "MCR 7, 10, 4 - Data Synchronization Barrier (DSB)" }, > + { 0, "MCR 7, 14, 0 - Clean and invalidate entire D-cache" }, > + { 0, "MCR 7, 14, 1 - Clean and invalidate D-cache line - MVA" }, > + { 0, "MCR 7, 15, 0 - Clean and invalidate unified cache" }, > + { 0, "MCR 8, 5, 0 - Invalidate instruction TLB" }, > + { 0, "MCR 8, 6, 0 - Invalidate data TLB" }, > + { 0, "MCR 8, 7, 0 - Invalidate unified TLB" }, > + { 0, "Emulate Load-Store multiple" }, > +}; > + > +void kvm_arm_count_event(unsigned int event) > +{ > + if (event>= KVM_EVENTC_ITEMS) > + return; > + > + kvm_eventc_log[event].cnt++; > +} We've switched to ftrace for this sort of thing. Simply add a tracepoint for each interesting event, and the kernel can provide you with - a count of events ('perf stat') - a log of events ('trace-cmd record/report'), possibly with other kernel events interspersed - a running histogram ('kvm_stat') with near-zero impact when disabled. See include/trace/events/kvm.h, arch/x86/kvm/trace.h.

diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig index b410049..b2a2b65 100644 --- a/arch/arm/Kconfig +++ b/arch/arm/Kconfig @@ -1951,3 +1951,5 @@ source "security/Kconfig" source "crypto/Kconfig" source "lib/Kconfig" + +source "arch/arm/kvm/Kconfig" diff --git a/arch/arm/Makefile b/arch/arm/Makefile index 6f7b292..72335fc 100644 --- a/arch/arm/Makefile +++ b/arch/arm/Makefile @@ -254,6 +254,7 @@ core-$(CONFIG_VFP) += arch/arm/vfp/ # If we have a machine-specific directory, then include it in the build. core-y += arch/arm/kernel/ arch/arm/mm/ arch/arm/common/ +core-$(CONFIG_KVM) += arch/arm/kvm/ core-y += $(machdirs) $(platdirs) drivers-$(CONFIG_OPROFILE) += arch/arm/oprofile/ diff --git a/arch/arm/include/asm/kvm.h b/arch/arm/include/asm/kvm.h new file mode 100644 index 0000000..8311198 --- /dev/null +++ b/arch/arm/include/asm/kvm.h @@ -0,0 +1,65 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 2, as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef __ARM_KVM_H__ +#define __ARM_KVM_H__ + +#include <asm/types.h> + +/* + * Modes used for short-hand mode determinition in the world-switch code and + * in emulation code. + * + * Note: These indices do NOT correspond to the value of the CPSR mode bits! + */ +#define MODE_FIQ 0 +#define MODE_IRQ 1 +#define MODE_SVC 2 +#define MODE_ABT 3 +#define MODE_UND 4 +#define MODE_USR 5 +#define MODE_SYS 6 + +struct kvm_regs { + __u32 regs0_7[8]; /* Unbanked regs. (r0 - r7) */ + __u32 fiq_regs8_12[5]; /* Banked fiq regs. (r8 - r12) */ + __u32 usr_regs8_12[5]; /* Banked usr registers (r8 - r12) */ + __u32 reg13[6]; /* Banked r13, indexed by MODE_ */ + __u32 reg14[6]; /* Banked r13, indexed by MODE_ */ + __u32 reg15; + __u32 cpsr; + __u32 spsr[5]; /* Banked SPSR, indexed by MODE_ */ + struct { + __u32 c2_base0; + __u32 c2_base1; + __u32 c3_dacr; + } cp15; + +}; + +struct kvm_sregs { +}; + +struct kvm_fpu { +}; + +struct kvm_guest_debug_arch { +}; + +struct kvm_debug_exit_arch { +}; + +#endif /* __ARM_KVM_H__ */ diff --git a/arch/arm/include/asm/kvm_asm.h b/arch/arm/include/asm/kvm_asm.h new file mode 100644 index 0000000..c3d4458 --- /dev/null +++ b/arch/arm/include/asm/kvm_asm.h @@ -0,0 +1,28 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 2, as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef __ARM_KVM_ASM_H__ +#define __ARM_KVM_ASM_H__ + +#define ARM_EXCEPTION_RESET 0 +#define ARM_EXCEPTION_UNDEFINED 1 +#define ARM_EXCEPTION_SOFTWARE 2 +#define ARM_EXCEPTION_PREF_ABORT 3 +#define ARM_EXCEPTION_DATA_ABORT 4 +#define ARM_EXCEPTION_IRQ 5 +#define ARM_EXCEPTION_FIQ 6 + +#endif /* __ARM_KVM_ASM_H__ */ diff --git a/arch/arm/include/asm/kvm_emulate.h b/arch/arm/include/asm/kvm_emulate.h new file mode 100644 index 0000000..8eed752 --- /dev/null +++ b/arch/arm/include/asm/kvm_emulate.h @@ -0,0 +1,89 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 2, as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef __ARM_KVM_EMULATE_H__ +#define __ARM_KVM_EMULATE_H__ + +#include <linux/kvm_host.h> +#include <asm/kvm_asm.h> + +u32* kvm_vcpu_reg(struct kvm_vcpu *vcpu, u8 reg_num, u32 mode); + +static inline unsigned char vcpu_mode(struct kvm_vcpu *vcpu) +{ + u8 modes_table[16] = { + MODE_USR, // 0x0 + MODE_FIQ, // 0x1 + MODE_IRQ, // 0x2 + MODE_SVC, // 0x3 + 0xf, 0xf, 0xf, + MODE_ABT, // 0x7 + 0xf, 0xf, 0xf, + MODE_UND, // 0xb + 0xf, 0xf, 0xf, + MODE_SYS}; // 0xf + + BUG_ON(modes_table[vcpu->arch.regs.cpsr & 0xf] == 0xf); + return modes_table[vcpu->arch.regs.cpsr & 0xf]; +} + +/* + * Return the SPSR for the specified mode of the virtual CPU. + */ +static inline u32 kvm_vcpu_spsr(struct kvm_vcpu *vcpu, u32 mode) +{ + switch (mode) { + case MODE_SVC: + return vcpu->arch.regs.svc_regs[2]; + case MODE_ABT: + return vcpu->arch.regs.svc_regs[2]; + case MODE_UND: + return vcpu->arch.regs.svc_regs[2]; + case MODE_IRQ: + return vcpu->arch.regs.svc_regs[2]; + case MODE_FIQ: + return vcpu->arch.regs.fiq_regs[7]; + default: + BUG(); + } +} + +/* Get vcpu register for current mode */ +#define vcpu_reg(_vcpu, _reg_num) \ + (*kvm_vcpu_reg((_vcpu), _reg_num, vcpu_mode(_vcpu))) + +/* Get vcpu register for specific mode */ +#define vcpu_reg_m(_vcpu, _reg_num, _mode) \ + (*kvm_vcpu_reg(_vcpu, _reg_num, _mode)) + +#define vcpu_cpsr(_vcpu) \ + (_vcpu->arch.regs.cpsr) + +/* Get vcpu SPSR for current mode */ +#define vcpu_spsr(_vcpu) \ + kvm_vcpu_spsr(_vcpu, vcpu_mode(_vcpu)) + +/* Get vcpu SPSR for specific mode */ +#define vcpu_spsr_m(_vcpu, _mode) \ + kvm_vcpu_spsr(_vcpu, _mode) + +#define MODE_HAS_SPSR(_vcpu) \ + ((vcpu_mode(_vcpu)) < MODE_USR) + +#define VCPU_MODE_PRIV(_vcpu) \ + (((vcpu_mode(_vcpu)) == MODE_USR) ? 0 : 1) + +#endif /* __ARM_KVM_EMULATE_H__ */ diff --git a/arch/arm/include/asm/kvm_host.h b/arch/arm/include/asm/kvm_host.h new file mode 100644 index 0000000..6e8a08d --- /dev/null +++ b/arch/arm/include/asm/kvm_host.h @@ -0,0 +1,114 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 2, as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef __ARM_KVM_HOST_H__ +#define __ARM_KVM_HOST_H__ + +#define KVM_MAX_VCPUS 1 +#define KVM_MEMORY_SLOTS 32 +#define KVM_PRIVATE_MEM_SLOTS 4 +#define KVM_COALESCED_MMIO_PAGE_OFFSET 1 + +/* We don't currently support large pages. */ +#define KVM_HPAGE_GFN_SHIFT(x) 0 +#define KVM_NR_PAGE_SIZES 1 +#define KVM_PAGES_PER_HPAGE(x) (1UL<<31) + +struct kvm_vcpu; +u32* kvm_vcpu_reg(struct kvm_vcpu *vcpu, u8 reg_num, u32 mode); + +struct kvm_arch { +}; + +#define EXCEPTION_NONE 0 +#define EXCEPTION_RESET 0x80 +#define EXCEPTION_UNDEFINED 0x40 +#define EXCEPTION_SOFTWARE 0x20 +#define EXCEPTION_PREFETCH 0x10 +#define EXCEPTION_DATA 0x08 +#define EXCEPTION_IMPRECISE 0x04 +#define EXCEPTION_IRQ 0x02 +#define EXCEPTION_FIQ 0x01 + +struct kvm_vcpu_regs { + u32 usr_regs[15]; /* R0_usr - R14_usr */ + u32 svc_regs[3]; /* SP_svc, LR_svc, SPSR_svc */ + u32 abt_regs[3]; /* SP_abt, LR_abt, SPSR_abt */ + u32 und_regs[3]; /* SP_und, LR_und, SPSR_und */ + u32 irq_regs[3]; /* SP_irq, LR_irq, SPSR_irq */ + u32 fiq_regs[8]; /* R8_fiq - R14_fiq, SPSR_fiq */ + u32 pc; /* The program counter (r15) */ + u32 cpsr; /* Guest emulated CPSR */ +} __packed; + +struct kvm_vcpu_arch { + /* Pointer to regs struct on shared page */ + struct kvm_vcpu_regs regs; + + /* Pointer to cached mode on shared page */ + unsigned long *mode; + + /* System control coprocessor (cp15) */ + struct { + u32 c1_SCTLR; /* System Control Register */ + u32 c1_ACTLR; /* Auxilliary Control Register */ + u32 c1_CPACR; /* Coprocessor Access Control Register */ + u64 c2_TTBR0; /* Translation Table Base Register 0 */ + u64 c2_TTBR1; /* Translation Table Base Register 1 */ + u32 c2_TTBCR; /* Translation Table Base Control Register */ + u32 c3_DACR; /* Domain Access Control Register */ + } cp15; + + u32 exception_pending; /* Exception to raise after emulation */ + + /* Exception Information */ + u32 hsr; /* Hyp Syndrom Register */ + u32 hdfar; /* Hyp Data Fault Address Register */ + u32 hifar; /* Hyp Inst. Fault Address Register */ + u32 hpfar; /* Hyp IPA Fault Address Register */ + + /* IO related fields */ + u32 mmio_rd; + + /* Misc. fields */ + u32 wait_for_interrupts; +}; + +struct kvm_vm_stat { + u32 remote_tlb_flush; +}; + +struct kvm_vcpu_stat { + u32 sum_exits; + u32 mmio_exits; + u32 dcr_exits; + u32 signal_exits; + u32 light_exits; + /* Account for special types of light exits: */ + u32 itlb_real_miss_exits; + u32 itlb_virt_miss_exits; + u32 dtlb_real_miss_exits; + u32 dtlb_virt_miss_exits; + u32 syscall_exits; + u32 isi_exits; + u32 dsi_exits; + u32 emulated_inst_exits; + u32 dec_exits; + u32 ext_intr_exits; + u32 halt_wakeup; +}; + +#endif /* __ARM_KVM_HOST_H__ */ diff --git a/arch/arm/include/asm/kvm_para.h b/arch/arm/include/asm/kvm_para.h new file mode 100644 index 0000000..7ce5f1c --- /dev/null +++ b/arch/arm/include/asm/kvm_para.h @@ -0,0 +1,9 @@ +#ifndef _ASM_X86_KVM_PARA_H +#define _ASM_X86_KVM_PARA_H + +static inline unsigned int kvm_arch_para_features(void) +{ + return 0; +} + +#endif /* _ASM_X86_KVM_PARA_H */ diff --git a/arch/arm/include/asm/unified.h b/arch/arm/include/asm/unified.h index bc63116..14ad6bb 100644 --- a/arch/arm/include/asm/unified.h +++ b/arch/arm/include/asm/unified.h @@ -54,6 +54,18 @@ #endif /* CONFIG_THUMB2_KERNEL */ +#ifdef CONFIG_KVM +#ifdef __ASSEMBLY__ +.arch_extension sec +.arch_extension virt +#else +__asm__( +" .arch_extension sec\n" +" .arch_extension virt\n" +); +#endif +#endif + #ifndef CONFIG_ARM_ASM_UNIFIED /* diff --git a/arch/arm/kvm/Kconfig b/arch/arm/kvm/Kconfig new file mode 100644 index 0000000..1806a6d --- /dev/null +++ b/arch/arm/kvm/Kconfig @@ -0,0 +1,44 @@ +# +# KVM configuration +# + +source "virt/kvm/Kconfig" + +menuconfig VIRTUALIZATION + bool "Virtualization" + ---help--- + Say Y here to get to see options for using your Linux host to run + other operating systems inside virtual machines (guests). + This option alone does not add any kernel code. + + If you say N, all options in this submenu will be skipped and + disabled. + +if VIRTUALIZATION + +config KVM + bool "Kernel-based Virtual Machine (KVM) support" + select PREEMPT_NOTIFIERS + select ANON_INODES + select KVM_ARM_HOST + select KVM_MMIO + ---help--- + Support hosting virtualized guest machines. You will also + need to select one or more of the processor modules below. + + This module provides access to the hardware capabilities through + a character device node named /dev/kvm. + + If unsure, say N. + +config KVM_ARM_HOST + bool "KVM host support for ARM cpus." + depends on KVM + depends on MMU + depends on CPU_V7 || ARM_VIRT_EXT + ---help--- + Provides host support for ARM processors. + +source drivers/virtio/Kconfig + +endif # VIRTUALIZATION diff --git a/arch/arm/kvm/Makefile b/arch/arm/kvm/Makefile new file mode 100644 index 0000000..4ff905d --- /dev/null +++ b/arch/arm/kvm/Makefile @@ -0,0 +1,13 @@ +# +# Makefile for Kernel-based Virtual Machine module +# + +EXTRA_CFLAGS += -Ivirt/kvm -Iarch/arm/kvm +AFLAGS_arm_interrupts.o := -I$(obj) + +kvm-arm-y += $(addprefix ../../../virt/kvm/, kvm_main.o coalesced_mmio.o) + +kvm-arm-y += arm.o arm_guest.o arm_interrupts.o arm_mmu.o arm_emulate.o \ + trace.o + +obj-$(CONFIG_KVM) += kvm-arm.o diff --git a/arch/arm/kvm/arm.c b/arch/arm/kvm/arm.c new file mode 100644 index 0000000..2157c1e --- /dev/null +++ b/arch/arm/kvm/arm.c @@ -0,0 +1,363 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 2, as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include <linux/errno.h> +#include <linux/err.h> +#include <linux/kvm_host.h> +#include <linux/module.h> +#include <linux/vmalloc.h> +#include <linux/fs.h> +#include <linux/proc_fs.h> +#include <linux/seq_file.h> +#include <linux/mman.h> +#include <asm/uaccess.h> +#include <asm/ptrace.h> +#include <asm/mman.h> + +#include "trace.h" + +int kvm_arch_hardware_enable(void *garbage) +{ + return 0; +} + +void kvm_arch_hardware_disable(void *garbage) +{ +} + +int kvm_arch_hardware_setup(void) +{ + return 0; +} + +void kvm_arch_hardware_unsetup(void) +{ +} + +void kvm_arch_check_processor_compat(void *rtn) +{ + *(int *)rtn = 0; +} + +void kvm_arch_sync_events(struct kvm *kvm) +{ +} + +int kvm_arch_init_vm(struct kvm *kvm) +{ + return 0; +} + +void kvm_arch_destroy_vm(struct kvm *kvm) +{ + int i; + + for (i = 0; i < KVM_MAX_VCPUS; ++i) { + if (kvm->vcpus[i]) { + kvm_arch_vcpu_free(kvm->vcpus[i]); + kvm->vcpus[i] = NULL; + } + } +} + +int kvm_dev_ioctl_check_extension(long ext) +{ + int r; + switch (ext) { + case KVM_CAP_USER_MEMORY: + case KVM_CAP_DESTROY_MEMORY_REGION_WORKS: + r = 1; + break; + case KVM_CAP_COALESCED_MMIO: + r = KVM_COALESCED_MMIO_PAGE_OFFSET; + break; + default: + r = 0; + break; + } + return r; +} + +long kvm_arch_dev_ioctl(struct file *filp, + unsigned int ioctl, unsigned long arg) +{ + int ret = 0; + + switch (ioctl) { + default: + ret = -EINVAL; + } + + if (ret < 0) + printk(KERN_ERR "error processing ARM ioct: %d", ret); + return ret; +} + +int kvm_arch_set_memory_region(struct kvm *kvm, + struct kvm_userspace_memory_region *mem, + struct kvm_memory_slot old, + int user_alloc) +{ + return 0; +} + +int kvm_arch_prepare_memory_region(struct kvm *kvm, + struct kvm_memory_slot *memslot, + struct kvm_memory_slot old, + struct kvm_userspace_memory_region *mem, + int user_alloc) +{ + return 0; +} + +void kvm_arch_commit_memory_region(struct kvm *kvm, + struct kvm_userspace_memory_region *mem, + struct kvm_memory_slot old, + int user_alloc) +{ +} + +void kvm_arch_flush_shadow(struct kvm *kvm) +{ + // XXX What should this do? +} + +struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id) +{ + int err; + struct kvm_vcpu *vcpu; + + vcpu = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL); + if (!vcpu) { + err = -ENOMEM; + goto out; + } + + err = kvm_vcpu_init(vcpu, kvm, id); + if (err) + goto free_vcpu; + + return vcpu; +free_vcpu: + kmem_cache_free(kvm_vcpu_cache, vcpu); +out: + return ERR_PTR(err); +} + +void kvm_arch_vcpu_free(struct kvm_vcpu *vcpu) +{ + KVMARM_NOT_IMPLEMENTED(); +} + +void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) +{ + kvm_arch_vcpu_free(vcpu); +} + +int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu) +{ + return 0; +} + +int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu) +{ + KVMARM_NOT_IMPLEMENTED(); + return 0; +} + +void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) +{ +} + +void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu) +{ +} + +void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) +{ +} + +int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, + struct kvm_guest_debug *dbg) +{ + return -EINVAL; +} + + +int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu *vcpu, + struct kvm_mp_state *mp_state) +{ + return -EINVAL; +} + +int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu, + struct kvm_mp_state *mp_state) +{ + return -EINVAL; +} + +int kvm_arch_vcpu_runnable(struct kvm_vcpu *v) +{ + return 0; +} + +int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run) +{ + KVMARM_NOT_IMPLEMENTED(); + return -EINVAL; +} + +static int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu, + struct kvm_interrupt *intr) +{ + u32 mask; + + switch (intr->irq) { + case EXCEPTION_IRQ: + /* IRQ */ + mask = EXCEPTION_IRQ; + break; + case EXCEPTION_FIQ: + /* FIQ */ + mask = EXCEPTION_FIQ; + break; + default: + /* Only async exceptions are supported here */ + return -EINVAL; + } + + if (intr->raise) { + if (mask == EXCEPTION_IRQ) + kvm_trace_activity(101, "raise IRQ"); + else if (mask == EXCEPTION_FIQ) + kvm_trace_activity(102, "raise FIQ"); + vcpu->arch.exception_pending |= mask; + vcpu->arch.wait_for_interrupts = 0; + } else { + if (mask == EXCEPTION_IRQ) + kvm_trace_activity(103, "lower IRQ"); + else if (mask == EXCEPTION_FIQ) + kvm_trace_activity(104, "lower FIQ"); + + vcpu->arch.exception_pending &= ~mask; + } + + 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_S390_STORE_STATUS: { + return -EINVAL; + } + case KVM_INTERRUPT: { + struct kvm_interrupt intr; + + r = -EFAULT; + if (copy_from_user(&intr, argp, sizeof intr)) + break; + r = kvm_vcpu_ioctl_interrupt(vcpu, &intr); + break; + } + default: + r = -EINVAL; + } + + return r; +} + +int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm, struct kvm_dirty_log *log) +{ + return -ENOTSUPP; +} + +long kvm_arch_vm_ioctl(struct file *filp, + unsigned int ioctl, unsigned long arg) +{ + printk(KERN_ERR "kvm_arch_vm_ioctl: Unsupported ioctl (%d)\n", ioctl); + return -EINVAL; +} + +int kvm_arch_init(void *opaque) +{ + return 0; +} + +void kvm_arch_exit(void) +{ +} + +static int k_show(struct seq_file *m, void *v) +{ + print_kvm_debug_info(&seq_printf, m); + return 0; +} + +static void *k_start(struct seq_file *m, loff_t *pos) +{ + return *pos < 1 ? (void *)1 : NULL; +} + +static void *k_next(struct seq_file *m, void *v, loff_t *pos) +{ + ++*pos; + return NULL; +} + +static void k_stop(struct seq_file *m, void *v) +{ +} + +static const struct seq_operations kvmproc_op = { + .start = k_start, + .next = k_next, + .stop = k_stop, + .show = k_show +}; + +static int kvm_open(struct inode *inode, struct file *file) +{ + return seq_open(file, &kvmproc_op); +} + +static const struct file_operations proc_kvm_operations = { + .open = kvm_open, + .read = seq_read, + .llseek = seq_lseek, + .release = seq_release, +}; + +static int arm_init(void) +{ + int rc = kvm_init(NULL, sizeof(struct kvm_vcpu), 0, THIS_MODULE); + if (rc == 0) + proc_create("kvm", 0, NULL, &proc_kvm_operations); + return rc; +} + +static void __exit arm_exit(void) +{ + kvm_exit(); +} + +module_init(arm_init); +module_exit(arm_exit) diff --git a/arch/arm/kvm/arm_emulate.c b/arch/arm/kvm/arm_emulate.c new file mode 100644 index 0000000..3dd4f08 --- /dev/null +++ b/arch/arm/kvm/arm_emulate.c @@ -0,0 +1,70 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 2, as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include <asm/kvm_emulate.h> + +/* + * Return a pointer to the register number valid in the specified mode of + * the virtual CPU. + */ +u32* kvm_vcpu_reg(struct kvm_vcpu *vcpu, u8 reg_num, u32 mode) +{ + struct kvm_vcpu_regs *regs; + u8 reg_idx; + BUG_ON(reg_num > 15); + + regs = &vcpu->arch.regs; + + /* The PC is trivial */ + if (reg_num == 15) + return &(regs->pc); + + /* Non-banked registers */ + if (reg_num < 8) + return &(regs->usr_regs[reg_num]); + + /* Banked registers r13 and r14 */ + if (reg_num >= 13) { + reg_idx = reg_num - 13; /* 0=r13 and 1=r14 */ + switch (mode) { + case MODE_FIQ: + return &(regs->fiq_regs[reg_idx + 5]); + case MODE_IRQ: + return &(regs->irq_regs[reg_idx]); + case MODE_SVC: + return &(regs->svc_regs[reg_idx]); + case MODE_ABT: + return &(regs->abt_regs[reg_idx]); + case MODE_UND: + return &(regs->und_regs[reg_idx]); + case MODE_USR: + case MODE_SYS: + return &(regs->usr_regs[reg_idx]); + } + } + + /* Banked FIQ registers r8-r12 */ + if (reg_num >= 8 && reg_num <= 12) { + if (mode == MODE_FIQ) { + reg_idx = reg_num - 8; /* 0=r8, ..., 4=r12 */ + return &(regs->fiq_regs[reg_idx]); + } else + return &(regs->usr_regs[reg_num]); + } + + BUG(); + return NULL; +} diff --git a/arch/arm/kvm/arm_guest.c b/arch/arm/kvm/arm_guest.c new file mode 100644 index 0000000..646f60c --- /dev/null +++ b/arch/arm/kvm/arm_guest.c @@ -0,0 +1,142 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 2, as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include <linux/errno.h> +#include <linux/err.h> +#include <linux/kvm_host.h> +#include <linux/module.h> +#include <linux/vmalloc.h> +#include <linux/fs.h> +#include <asm/uaccess.h> +#include <asm/kvm_asm.h> +#include <asm/kvm_emulate.h> + + +#define VM_STAT(x) offsetof(struct kvm, stat.x), KVM_STAT_VM +#define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU + +struct kvm_stats_debugfs_item debugfs_entries[] = { +}; + +int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu) +{ + return 0; +} + +int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) +{ + struct kvm_vcpu_regs *vcpu_regs = &vcpu->arch.regs; + + /* + * GPRs and PSRs + */ + memcpy(regs->regs0_7, &(vcpu_regs->usr_regs[0]), sizeof(u32) * 8); + memcpy(regs->usr_regs8_12, &(vcpu_regs->usr_regs[8]), sizeof(u32) * 5); + memcpy(regs->fiq_regs8_12, &(vcpu_regs->fiq_regs[0]), sizeof(u32) * 5); + regs->reg13[MODE_FIQ] = vcpu_regs->fiq_regs[5]; + regs->reg14[MODE_FIQ] = vcpu_regs->fiq_regs[6]; + regs->reg13[MODE_IRQ] = vcpu_regs->irq_regs[0]; + regs->reg14[MODE_IRQ] = vcpu_regs->irq_regs[1]; + regs->reg13[MODE_SVC] = vcpu_regs->svc_regs[0]; + regs->reg14[MODE_SVC] = vcpu_regs->svc_regs[1]; + regs->reg13[MODE_ABT] = vcpu_regs->abt_regs[0]; + regs->reg14[MODE_ABT] = vcpu_regs->abt_regs[1]; + regs->reg13[MODE_UND] = vcpu_regs->und_regs[0]; + regs->reg14[MODE_UND] = vcpu_regs->und_regs[1]; + regs->reg13[MODE_USR] = vcpu_regs->usr_regs[0]; + regs->reg14[MODE_USR] = vcpu_regs->usr_regs[1]; + + regs->spsr[MODE_FIQ] = vcpu_regs->fiq_regs[7]; + regs->spsr[MODE_IRQ] = vcpu_regs->irq_regs[2]; + regs->spsr[MODE_SVC] = vcpu_regs->svc_regs[2]; + regs->spsr[MODE_ABT] = vcpu_regs->abt_regs[2]; + regs->spsr[MODE_UND] = vcpu_regs->und_regs[2]; + + regs->reg15 = vcpu_regs->pc; + regs->cpsr = vcpu_regs->cpsr; + + + /* + * Co-processor registers. + */ + regs->cp15.c2_base0 = vcpu->arch.cp15.c2_TTBR0; + regs->cp15.c2_base1 = vcpu->arch.cp15.c2_TTBR1; + regs->cp15.c3_dacr = vcpu->arch.cp15.c3_DACR; + + return 0; +} + +int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs) +{ + struct kvm_vcpu_regs *vcpu_regs = &vcpu->arch.regs; + + memcpy(&(vcpu_regs->usr_regs[0]), regs->regs0_7, sizeof(u32) * 8); + memcpy(&(vcpu_regs->usr_regs[8]), regs->usr_regs8_12, sizeof(u32) * 5); + memcpy(&(vcpu_regs->fiq_regs[0]), regs->fiq_regs8_12, sizeof(u32) * 5); + + vcpu_regs->fiq_regs[5] = regs->reg13[MODE_FIQ]; + vcpu_regs->fiq_regs[6] = regs->reg14[MODE_FIQ]; + vcpu_regs->irq_regs[0] = regs->reg13[MODE_IRQ]; + vcpu_regs->irq_regs[1] = regs->reg14[MODE_IRQ]; + vcpu_regs->svc_regs[0] = regs->reg13[MODE_SVC]; + vcpu_regs->svc_regs[1] = regs->reg14[MODE_SVC]; + vcpu_regs->abt_regs[0] = regs->reg13[MODE_ABT]; + vcpu_regs->abt_regs[1] = regs->reg14[MODE_ABT]; + vcpu_regs->und_regs[0] = regs->reg13[MODE_UND]; + vcpu_regs->und_regs[1] = regs->reg14[MODE_UND]; + vcpu_regs->usr_regs[0] = regs->reg13[MODE_USR]; + vcpu_regs->usr_regs[1] = regs->reg14[MODE_USR]; + + vcpu_regs->fiq_regs[7] = regs->spsr[MODE_FIQ]; + vcpu_regs->irq_regs[2] = regs->spsr[MODE_IRQ]; + vcpu_regs->svc_regs[2] = regs->spsr[MODE_SVC]; + vcpu_regs->abt_regs[2] = regs->spsr[MODE_ABT]; + vcpu_regs->und_regs[2] = regs->spsr[MODE_UND]; + + vcpu_regs->pc = regs->reg15; + vcpu_regs->cpsr = regs->cpsr; + + return 0; +} + +int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu, + struct kvm_sregs *sregs) +{ + return -ENOTSUPP; +} + +int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu, + struct kvm_sregs *sregs) +{ + return -ENOTSUPP; +} + +int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) +{ + return -ENOTSUPP; +} + +int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu *vcpu, struct kvm_fpu *fpu) +{ + return -ENOTSUPP; +} + +/* 'linear_address' is actually an encoding of AS|PID|EADDR . */ +int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu, + struct kvm_translation *tr) +{ + return 0; +} diff --git a/arch/arm/kvm/arm_interrupts.S b/arch/arm/kvm/arm_interrupts.S new file mode 100644 index 0000000..073a494 --- /dev/null +++ b/arch/arm/kvm/arm_interrupts.S @@ -0,0 +1,17 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 2, as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ +#include <asm/asm-offsets.h> +#include <asm/kvm_asm.h> diff --git a/arch/arm/kvm/arm_mmu.c b/arch/arm/kvm/arm_mmu.c new file mode 100644 index 0000000..e69de29 diff --git a/arch/arm/kvm/trace.c b/arch/arm/kvm/trace.c new file mode 100644 index 0000000..8ea1155 --- /dev/null +++ b/arch/arm/kvm/trace.c @@ -0,0 +1,436 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 2, as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ +#include <linux/types.h> +#include <linux/kvm_types.h> +#include <linux/kvm_host.h> + +#include <asm/kvm_emulate.h> +#include "trace.h" + + +/****************************************************************************** + * Simple event counting + */ + +struct kvm_event { + unsigned long long cnt; + char *descr; +}; + +static struct kvm_event kvm_eventc_log[KVM_EVENTC_ITEMS] = +{ + { 0, "switch to guest" }, + { 0, "exit from guest" }, + { 0, "Block VCPU" }, + { 0, "Exit to QEMU for IRQ window" }, + { 0, "Switch VCPU mode" }, + { 0, "VCPU IRQs on" }, + { 0, "VCPU IRQs off" }, + { 0, "Wait-for-interrupts" }, + { 0, "Flush shadow page table" }, + { 0, "Virtual TTBR change" }, + { 0, "Read guest page table entry" }, + { 0, "Map GVA to GFN" }, + { 0, "Virtual DACR change" }, + { 0, "VCPU switch to privileged mode" }, + { 0, "VCPU switch from privileged mode" }, + { 0, "VCPU process ID registers change" }, + { 0, "Emulate Load/Store with translation" }, + { 0, "Emulate MRS" }, + { 0, "Emulate MSR" }, + { 0, "Emulate CPS" }, + { 0, "Need reschedule in execution loop" }, + { 0, "MCR 7, 5, 0 - Invalidate entire I-cache" }, + { 0, "MCR 7, 5, 1 - Invalidate line in I-cache MVA" }, + { 0, "MCR 7, 5, 2 - Invalidate line in I-cache set/way" }, + { 0, "MCR 7, 5, 7 - Flush branch target cache - MVA" }, + { 0, "MCR 7, 6, 0 - Invalidate entire data cache" }, + { 0, "MCR 7, 6, 1 - Invalidate data cache line - MVA" }, + { 0, "MCR 7, 6, 2 - Invalidate data cache line - set/way" }, + { 0, "MCR 7, 7, 0 - Invalidate D- and I-cache" }, + { 0, "MCR 7, 10, 0 - Clean entire data cache" }, + { 0, "MCR 7, 10, 1 - Clean data cache line - MVA" }, + { 0, "MCR 7, 10, 4 - Data Synchronization Barrier (DSB)" }, + { 0, "MCR 7, 14, 0 - Clean and invalidate entire D-cache" }, + { 0, "MCR 7, 14, 1 - Clean and invalidate D-cache line - MVA" }, + { 0, "MCR 7, 15, 0 - Clean and invalidate unified cache" }, + { 0, "MCR 8, 5, 0 - Invalidate instruction TLB" }, + { 0, "MCR 8, 6, 0 - Invalidate data TLB" }, + { 0, "MCR 8, 7, 0 - Invalidate unified TLB" }, + { 0, "Emulate Load-Store multiple" }, +}; + +void kvm_arm_count_event(unsigned int event) +{ + if (event >= KVM_EVENTC_ITEMS) + return; + + kvm_eventc_log[event].cnt++; +} + +void kvm_arm_init_eventc(void) +{ + unsigned int i; + + for (i = 0; i < KVM_EVENTC_ITEMS; i++) + kvm_eventc_log[i].cnt = 0; +} + +struct kvm_event_order { + struct kvm_event *event; + struct kvm_event_order *next; + struct kvm_event_order *prev; +}; +static struct kvm_event_order event_order[KVM_EVENTC_ITEMS]; + +static struct kvm_event_order *sort_kvm_event_log(void) +{ + unsigned int i; + struct kvm_event_order *ptr; + struct kvm_event_order head = + { .event = NULL, .next = &head, .prev = &head }; + + for (i = 0; i < KVM_EVENTC_ITEMS; i++) { + event_order[i].event = &kvm_eventc_log[i]; + ptr = head.next; + while (ptr->event != NULL && + ptr->event->cnt > kvm_eventc_log[i].cnt) { + ptr = ptr->next; + } + ptr->prev->next = &event_order[i]; + event_order[i].prev = ptr->prev; + event_order[i].next = ptr; + ptr->prev = &event_order[i]; + } + + head.prev->next = NULL; /* Mark end of linked list */ + return head.next; +} + +/****************************************************************************** + * Trace ring-buffer local to KVM/ARM + */ + +#define KVM_TRACE_ACTIVITY +#ifndef KVM_TRACE_ACTIVITY +void kvm_trace_activity(unsigned int activity, char *fmt, ...) +{ +} +#else + +#define ACTIVITY_TRACE_ITEMS 50 +#define TRACE_DESCR_LEN 80 +static u32 activity_trace[ACTIVITY_TRACE_ITEMS]; +static u32 activity_trace_cnt[ACTIVITY_TRACE_ITEMS]; +static char activity_trace_descr[ACTIVITY_TRACE_ITEMS][TRACE_DESCR_LEN]; +static int activity_trace_index = 0; +static bool trace_init = false; + +void kvm_trace_activity(unsigned int activity, char *fmt, ...) +{ + va_list ap; + unsigned int i; + char *ptr; + + if (!trace_init) { + for (i = 0; i < ACTIVITY_TRACE_ITEMS; i++) + activity_trace_descr[i][0] = '\0'; + trace_init = true; + } + + if (activity_trace[activity_trace_index] == activity) { + activity_trace_cnt[activity_trace_index]++; + } else { + activity_trace_index = (activity_trace_index + 1) + % ACTIVITY_TRACE_ITEMS; + activity_trace[activity_trace_index] = activity; + activity_trace_cnt[activity_trace_index] = 0; + + ptr = activity_trace_descr[activity_trace_index]; + va_start(ap, fmt); + vsnprintf(ptr, TRACE_DESCR_LEN, fmt, ap); + va_end(ap); + } +} +#endif + +/****************************************************************************** + * World-switch ring-buffer + */ + +#define WS_TRACE_ITEMS 10 +static u32 ws_trace_enter[WS_TRACE_ITEMS]; +static int ws_trace_enter_index = 0; +static u32 ws_trace_exit[WS_TRACE_ITEMS]; +static int ws_trace_exit_index = 0; +static u32 ws_trace_exit_codes[WS_TRACE_ITEMS]; +DEFINE_MUTEX(ws_trace_mutex); + +void trace_ws_enter(u32 guest_pc) +{ + mutex_lock(&ws_trace_mutex); + ws_trace_enter[ws_trace_enter_index++] = guest_pc; + if (ws_trace_enter_index >= WS_TRACE_ITEMS) + ws_trace_enter_index = 0; + mutex_unlock(&ws_trace_mutex); +} + +void trace_ws_exit(u32 guest_pc, u32 exit_code) +{ + mutex_lock(&ws_trace_mutex); + ws_trace_exit[ws_trace_exit_index] = guest_pc; + ws_trace_exit_codes[ws_trace_exit_index++] = exit_code; + if (ws_trace_exit_index >= WS_TRACE_ITEMS) + ws_trace_exit_index = 0; + mutex_unlock(&ws_trace_mutex); +} + +void print_ws_trace(void) +{ + int i; + mutex_lock(&ws_trace_mutex); + + if (ws_trace_enter_index != ws_trace_exit_index) { + kvm_msg("enter and exit WS trace count differ"); + mutex_unlock(&ws_trace_mutex); + return; + } + + /* Avoid potential endless loop */ + if (ws_trace_enter_index < 0 || ws_trace_enter_index >= WS_TRACE_ITEMS) { + kvm_msg("ws_trace_enter_index out of bounds: %d", + ws_trace_enter_index); + mutex_unlock(&ws_trace_mutex); + return; + } + + for (i = ws_trace_enter_index - 1; i != ws_trace_enter_index; i--) { + if (i < 0) { + i = WS_TRACE_ITEMS; + continue; + } + + printk(KERN_ERR "Enter: %08x Exit: %08x (%d)\n", + ws_trace_enter[i], + ws_trace_exit[i], + ws_trace_exit_codes[i]); + } + mutex_unlock(&ws_trace_mutex); +} + +/****************************************************************************** + * Dump total debug info, or write to /proc/kvm + */ + +struct kvm_vcpu *latest_vcpu = NULL; + +void print_kvm_debug_info(int (*print_fn)(print_fn_args), struct seq_file *m) +{ + int i; + struct kvm_vcpu_regs *regs; + char *mode = NULL; + char *exceptions[7]; + struct kvm_vcpu *vcpu = latest_vcpu; + struct kvm_event_order *ptr; + + print_fn(m, "KVM/ARM runtime info\n"); + print_fn(m, "======================================================"); + print_fn(m, "\n\n"); + + if (vcpu == NULL) { + print_fn(m, "No registered VCPU\n"); + goto print_ws_hist; + } + + + switch (vcpu_mode(vcpu)) { + case MODE_USR: mode = "USR"; break; + case MODE_FIQ: mode = "FIQ"; break; + case MODE_IRQ: mode = "IRQ"; break; + case MODE_SVC: mode = "SVC"; break; + case MODE_ABT: mode = "ABT"; break; + case MODE_UND: mode = "UND"; break; + case MODE_SYS: mode = "SYS"; break; + } + + vcpu_load(vcpu); + regs = &vcpu->arch.regs; + + print_fn(m, "Virtual CPU state:\n\n"); + print_fn(m, "PC is at: \t%08x\n", vcpu_reg(vcpu, 15)); + print_fn(m, "CPSR: \t%08x\n(Mode: %s) (IRQs: %s) (FIQs: %s) " + " (Vec: %s)\n", + regs->cpsr, mode, + (regs->cpsr & PSR_I_BIT) ? "off" : "on", + (regs->cpsr & PSR_F_BIT) ? "off" : "on", + (regs->cpsr & PSR_V_BIT) ? "high" : "low"); + + for (i = 0; i <= 12; i++) { + if ((i % 4) == 0) + print_fn(m, "\nregs[%u]: ", i); + + print_fn(m, "\t0x%08x", vcpu_reg_m(vcpu, i, MODE_USR)); + } + + print_fn(m, "\n\n"); + print_fn(m, "Banked registers: \tr13\t\tr14\t\tspsr\n"); + print_fn(m, "-------------------\t--------\t--------\t--------\n"); + print_fn(m, " USR: \t%08x\t%08x\t////////\n", + vcpu_reg_m(vcpu, 13, MODE_USR), + vcpu_reg_m(vcpu, 14, MODE_USR)); + print_fn(m, " SVC: \t%08x\t%08x\t%08x\n", + vcpu_reg_m(vcpu, 13, MODE_SVC), + vcpu_reg_m(vcpu, 14, MODE_SVC), + vcpu_spsr_m(vcpu, MODE_SVC)); + print_fn(m, " ABT: \t%08x\t%08x\t%08x\n", + vcpu_reg_m(vcpu, 13, MODE_ABT), + vcpu_reg_m(vcpu, 14, MODE_ABT), + vcpu_spsr_m(vcpu, MODE_ABT)); + print_fn(m, " UND: \t%08x\t%08x\t%08x\n", + vcpu_reg_m(vcpu, 13, MODE_UND), + vcpu_reg_m(vcpu, 14, MODE_UND), + vcpu_spsr_m(vcpu, MODE_UND)); + print_fn(m, " IRQ: \t%08x\t%08x\t%08x\n", + vcpu_reg_m(vcpu, 13, MODE_IRQ), + vcpu_reg_m(vcpu, 14, MODE_IRQ), + vcpu_spsr_m(vcpu, MODE_IRQ)); + print_fn(m, " FIQ: \t%08x\t%08x\t%08x\n", + vcpu_reg_m(vcpu, 13, MODE_FIQ), + vcpu_reg_m(vcpu, 14, MODE_FIQ), + vcpu_spsr_m(vcpu, MODE_FIQ)); + + print_fn(m, "\n"); + print_fn(m, "fiq regs:\t%08x\t%08x\t%08x\t%08x\n" + " \t%08x\n", + vcpu_reg_m(vcpu, 8, MODE_FIQ), + vcpu_reg_m(vcpu, 9, MODE_FIQ), + vcpu_reg_m(vcpu, 10, MODE_FIQ), + vcpu_reg_m(vcpu, 11, MODE_FIQ), + vcpu_reg_m(vcpu, 12, MODE_FIQ)); + +print_ws_hist: + /* + * Print world-switch trace circular buffer + */ + print_fn(m, "\n\nWorld switch history:\n"); + print_fn(m, "---------------------\n"); + mutex_lock(&ws_trace_mutex); + + if (ws_trace_enter_index != ws_trace_exit_index || + ws_trace_enter_index < 0 || + ws_trace_enter_index >= WS_TRACE_ITEMS) + { + mutex_unlock(&ws_trace_mutex); + goto print_trace_activity; + } + + exceptions[0] = "reset"; + exceptions[1] = "undefined"; + exceptions[2] = "software"; + exceptions[3] = "prefetch abort"; + exceptions[4] = "data abort"; + exceptions[5] = "irq"; + exceptions[6] = "fiq"; + + for (i = ws_trace_enter_index - 1; i != ws_trace_enter_index; i--) { + if (i < 0) { + i = WS_TRACE_ITEMS; + continue; + } + + print_fn(m, "Enter: %08x Exit: %08x (%s)\n", + ws_trace_enter[i], ws_trace_exit[i], + exceptions[ws_trace_exit_codes[i]]); + } + mutex_unlock(&ws_trace_mutex); + +print_trace_activity: +#ifdef KVM_TRACE_ACTIVITY + /* + * Print activity trace + */ + print_fn(m, "\n\nActivity circular buffer:\n"); + print_fn(m, "-----------------------------\n"); + for (i = activity_trace_index - 1; i != activity_trace_index; i--) { + if (i < 0) { + i = ACTIVITY_TRACE_ITEMS; + continue; + } + + print_fn(m, "%lu: \t %s\n", + activity_trace_cnt[i], + activity_trace_descr[i]); + } +#endif + + /* + * Print event counters sorted + */ + print_fn(m, "\n\nEvent counters:\n"); + print_fn(m, "-----------------------------\n"); + ptr = sort_kvm_event_log(); + while (ptr != NULL) { + if (ptr->event->cnt > 0) { + print_fn(m, "%12llu # %s\n", ptr->event->cnt, + ptr->event->descr); + } + ptr = ptr->next; + } + + if (vcpu != NULL) { + vcpu_put(vcpu); + } +} + +static int __printk_relay(struct seq_file *m, const char *fmt, ...) +{ + va_list ap; + va_start(ap, fmt); + vprintk(fmt, ap); + va_end(ap); + return 0; +} + +void kvm_dump_vcpu_state(void) +{ + print_kvm_debug_info(&__printk_relay, NULL); +} + +/****************************************************************************** + * Printk-log-wrapping functionality + */ + +#define TMP_LOG_LEN 512 +static char __tmp_log_data[TMP_LOG_LEN]; +DEFINE_MUTEX(__tmp_log_lock); +void __kvm_print_msg(char *fmt, ...) +{ + va_list ap; + unsigned int size; + + mutex_lock(&__tmp_log_lock); + + va_start(ap, fmt); + size = vsnprintf(__tmp_log_data, TMP_LOG_LEN, fmt, ap); + va_end(ap); + + if (size >= TMP_LOG_LEN) + printk("Message exceeded log length!\n"); + else + printk("%s", __tmp_log_data); + + mutex_unlock(&__tmp_log_lock); +} diff --git a/arch/arm/kvm/trace.h b/arch/arm/kvm/trace.h new file mode 100644 index 0000000..020240a --- /dev/null +++ b/arch/arm/kvm/trace.h @@ -0,0 +1,108 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License, version 2, as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * + * + * This file contains debugging and tracing functions and definitions for KVM/ARM. + * + */ +#ifndef __ARM_KVM_TRACE_H__ +#define __ARM_KVM_TRACE_H__ + +#include <linux/types.h> +#include <linux/kvm_types.h> +#include <linux/kvm_host.h> + +#define EVENT_GUEST_ENTER 0 +#define EVENT_GUEST_EXIT 1 +#define EVENT_VCPU_BLOCK 2 +#define EVENT_IRQ_WINDOW 3 +#define EVENT_SWITCH_MODE 4 +#define EVENT_VCPU_IRQS_ON 5 +#define EVENT_VCPU_IRQS_OFF 6 +#define EVENT_WFI 7 +#define EVENT_FLUSH_SHADOW 8 +#define EVENT_MOD_TTBR 9 +#define EVENT_READ_GUEST_ENTRY 10 +#define EVENT_MAP_GVA_TO_GFN 11 +#define EVENT_DACR_CHANGE 12 +#define EVENT_SWITCH_PRIV 13 +#define EVENT_SWITCH_USER 14 +#define EVENT_VCPU_ASID 15 +#define EVENT_LS_TRANS 16 +#define EVENT_EMUL_MRS 17 +#define EVENT_EMUL_MSR 18 +#define EVENT_EMUL_CPS 19 +#define EVENT_NEED_RESCHED 20 +#define EVENT_MCR_7_5_0 21 +#define EVENT_MCR_7_5_1 22 +#define EVENT_MCR_7_5_2 23 +#define EVENT_MCR_7_5_7 24 +#define EVENT_MCR_7_6_0 25 +#define EVENT_MCR_7_6_1 26 +#define EVENT_MCR_7_6_2 27 +#define EVENT_MCR_7_7_0 28 +#define EVENT_MCR_7_10_0 29 +#define EVENT_MCR_7_10_1 30 +#define EVENT_MCR_7_10_4 31 +#define EVENT_MCR_7_14_0 32 +#define EVENT_MCR_7_14_1 33 +#define EVENT_MCR_7_15_0 34 +#define EVENT_MCR_8_5_X 35 +#define EVENT_MCR_8_6_X 36 +#define EVENT_MCR_8_7_X 37 +#define EVENT_EMUL_LSMULT 38 + +#define KVM_EVENTC_ITEMS 39 + +void kvm_arm_init_eventc(void); +void kvm_arm_count_event(unsigned int event); +void kvm_dump_vcpu_state(void); + +void trace_ws_enter(u32 guest_pc); +void trace_ws_exit(u32 guest_pc, u32 exit_code); + + +#define print_fn_args struct seq_file *, const char *, ... +void print_kvm_debug_info(int (*print_fn)(print_fn_args), struct seq_file *m); + + +void __kvm_print_msg(char *_fmt, ...); + +#define kvm_err(err, fmt, args...) do { \ + __kvm_print_msg(KERN_ERR "KVM error [%s:%d]: (%d) ", \ + __FUNCTION__, __LINE__, err); \ + __kvm_print_msg(fmt "\n", ##args); \ +} while (0) + +#define __kvm_msg(fmt, args...) do { \ + __kvm_print_msg(KERN_ERR "KVM [%s:%d]: ", __FUNCTION__, __LINE__); \ + __kvm_print_msg(fmt, ##args); \ +} while (0) + +#define kvm_msg(__fmt, __args...) __kvm_msg(__fmt "\n", ##__args) + + +#define KVMARM_NOT_IMPLEMENTED() \ + { \ + printk(KERN_ERR "KVM not implemented [%s:%d] in %s \n", \ + __FILE__, __LINE__, __FUNCTION__); \ + } + +extern bool trace_gva_to_gfn; +void print_shadow_mapping(struct kvm_vcpu *vcpu, gva_t gva); +void print_ws_trace(void); +void kvm_trace_activity(unsigned int activity, char *fmt, ...); + +#endif /* __ARM_KVM_TRACE_H__ */ diff --git a/arch/arm/mach-vexpress/Kconfig b/arch/arm/mach-vexpress/Kconfig index cfbc0f1..5b00905 100644 --- a/arch/arm/mach-vexpress/Kconfig +++ b/arch/arm/mach-vexpress/Kconfig @@ -33,6 +33,7 @@ config ARCH_VEXPRESS_CA15X4 bool "Versatile Express Cortex-A15x4 tile" depends on VEXPRESS_EXTENDED_MEMORY_MAP select CPU_V7 + select ARM_VIRT_EXT select ARM_GIC select HAVE_ARCH_TIMERS diff --git a/arch/arm/mm/Kconfig b/arch/arm/mm/Kconfig index 04de742..ad77805 100644 --- a/arch/arm/mm/Kconfig +++ b/arch/arm/mm/Kconfig @@ -628,6 +628,13 @@ config ARM_LPAE Say Y if you have an ARMv7 processor supporting the LPAE page table format and you would like to access memory beyond the 4GB limit. +config ARM_VIRT_EXT + bool "Support for ARM Virtualization Extensions" + depends on ARM_LPAE + help + Say Y if you have an ARMv7 processor supporting the ARM hardware + Virtualization extensions. + config ARCH_PHYS_ADDR_T_64BIT def_bool ARM_LPAE diff --git a/include/linux/kvm.h b/include/linux/kvm.h index ea2dc1a..d2ab07e 100644 --- a/include/linux/kvm.h +++ b/include/linux/kvm.h @@ -310,6 +310,7 @@ struct kvm_translation { struct kvm_interrupt { /* in */ __u32 irq; + __u8 raise; }; /* for KVM_GET_DIRTY_LOG */

[v3,1/8] ARM: KVM: Initial skeleton to compile KVM support

Commit Message

Comments

Patch