Menu
▾
▴
[kvm-ia64-devel] [PATCH][07] Add kvm sal/pal virtulization support.
|
From: Zhang, X. <xia...@in...> - 2008-01-31 10:29:54
|
From: Zhang Xiantao <xia...@in...>
Date: Tue, 29 Jan 2008 13:15:05 +0800
Subject: [PATCH] kvm/ia64: Add kvm sal/pal virtulization support.
Some sal/pal calls would be traped to kvm for virtulization
from guest firmware.
Signed-off-by: Xiantao Zhang<xia...@in...>
---
arch/ia64/kvm/kvm_fw.c | 500
++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 500 insertions(+), 0 deletions(-)
create mode 100644 arch/ia64/kvm/kvm_fw.c
diff --git a/arch/ia64/kvm/kvm_fw.c b/arch/ia64/kvm/kvm_fw.c
new file mode 100644
index 0000000..e6f9f29
--- /dev/null
+++ b/arch/ia64/kvm/kvm_fw.c
@@ -0,0 +1,500 @@
+/*
+ * PAL/SAL call delegation
+ *
+ * Copyright (c) 2004 Li Susie <sus...@in...>
+ * Copyright (c) 2005 Yu Ke <ke...@in...>
+ * Copyright (c) 2007 Zhang Xiantao <xia...@in...>
+ *
+ * This program is free software; you can redistribute it and/or modify
it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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, Inc.,
59 Temple
+ * Place - Suite 330, Boston, MA 02111-1307 USA.
+ */
+
+#include <linux/kvm_host.h>
+#include <linux/smp.h>
+
+#include "vti.h"
+#include "misc.h"
+
+#include <asm/pal.h>
+#include <asm/sal.h>
+#include <asm/tlb.h>
+
+/*
+ * Handy macros to make sure that the PAL return values start out
+ * as something meaningful.
+ */
+#define INIT_PAL_STATUS_UNIMPLEMENTED(x) \
+ { \
+ x.status =3D PAL_STATUS_UNIMPLEMENTED; \
+ x.v0 =3D 0; \
+ x.v1 =3D 0; \
+ x.v2 =3D 0; \
+ }
+
+#define INIT_PAL_STATUS_SUCCESS(x) \
+ { \
+ x.status =3D PAL_STATUS_SUCCESS; \
+ x.v0 =3D 0; \
+ x.v1 =3D 0; \
+ x.v2 =3D 0; \
+ }
+
+static void kvm_get_pal_call_data(struct kvm_vcpu *vcpu,
+ u64 *gr28, u64 *gr29, u64 *gr30, u64 *gr31) {
+ struct exit_ctl_data *p;
+
+ if (vcpu) {
+ p =3D &vcpu->arch.exit_data;
+ if (p->exit_reason =3D=3D EXIT_REASON_PAL_CALL) {
+ *gr28 =3D p->u.pal_data.gr28;
+ *gr29 =3D p->u.pal_data.gr29;
+ *gr30 =3D p->u.pal_data.gr30;
+ *gr31 =3D p->u.pal_data.gr31;
+ return ;
+ }
+ }
+ printk(KERN_DEBUG"Error occurs in kvm_get_pal_call_data!!\n");
+}
+
+static void set_pal_result(struct kvm_vcpu *vcpu,
+ struct ia64_pal_retval result) {
+
+ struct exit_ctl_data *p;
+
+ p =3D kvm_get_exit_data(vcpu);
+ if (p && p->exit_reason =3D=3D EXIT_REASON_PAL_CALL) {
+ p->u.pal_data.ret =3D result;
+ return ;
+ }
+ INIT_PAL_STATUS_UNIMPLEMENTED(p->u.pal_data.ret);
+}
+
+static void set_sal_result(struct kvm_vcpu *vcpu,
+ struct sal_ret_values result) {
+ struct exit_ctl_data *p;
+
+ p =3D kvm_get_exit_data(vcpu);
+ if (p && p->exit_reason =3D=3D EXIT_REASON_SAL_CALL) {
+ p->u.sal_data.ret =3D result;
+ return ;
+ }
+ printk(KERN_WARNING"Error occurs!!!\n");
+}
+
+struct cache_flush_args {
+ u64 cache_type;
+ u64 operation;
+ u64 progress;
+ long status;
+};
+
+cpumask_t cpu_cache_coherent_map;
+
+static void remote_pal_cache_flush(void *data)
+{
+ struct cache_flush_args *args =3D data;
+ long status;
+ u64 progress =3D args->progress;
+
+ status =3D ia64_pal_cache_flush(args->cache_type, args->operation,
+ &progress, NULL);
+ if (status !=3D 0)
+ args->status =3D status;
+}
+
+static struct ia64_pal_retval pal_cache_flush(struct kvm_vcpu *vcpu)
+{
+ u64 gr28, gr29, gr30, gr31;
+ struct ia64_pal_retval result =3D {0, 0, 0, 0};
+ struct cache_flush_args args =3D {0, 0, 0, 0};
+ long psr;
+
+ gr28 =3D gr29 =3D gr30 =3D gr31 =3D 0;
+ kvm_get_pal_call_data(vcpu, &gr28, &gr29, &gr30, &gr31);
+
+ if (gr31 !=3D 0)
+ printk(KERN_ERR"vcpu:%p called cache_flush error!\n",
vcpu);
+
+ /* Always call Host Pal in int=3D1 */
+ gr30 &=3D ~PAL_CACHE_FLUSH_CHK_INTRS;
+ args.cache_type =3D gr29;
+ args.operation =3D gr30;
+ smp_call_function(remote_pal_cache_flush,
+ (void *)&args, 1, 1);
+ if (args.status !=3D 0)
+ printk(KERN_ERR"pal_cache_flush error!,"
+ "status:0x%lx\n", args.status);
+ /*
+ * Call Host PAL cache flush
+ * Clear psr.ic when call PAL_CACHE_FLUSH
+ */
+ local_irq_save(psr);
+ result.status =3D ia64_pal_cache_flush(gr29, gr30, &result.v1,
+ &result.v0);
+ local_irq_restore(psr);
+ if (result.status !=3D 0)
+ printk(KERN_ERR"vcpu:%p crashed due to cache_flush
err:%ld"
+ "in1:%lx,in2:%lx\n",
+ vcpu, result.status, gr29, gr30);
+
+#if 0
+ if (gr29 =3D=3D PAL_CACHE_TYPE_COHERENT) {
+ cpus_setall(vcpu->arch.cache_coherent_map);
+ cpu_clear(vcpu->cpu, vcpu->arch.cache_coherent_map);
+ cpus_setall(cpu_cache_coherent_map);
+ cpu_clear(vcpu->cpu, cpu_cache_coherent_map);
+ }
+#endif
+ return result;
+}
+
+struct ia64_pal_retval pal_cache_summary(struct kvm_vcpu *vcpu)
+{
+
+ struct ia64_pal_retval result;
+
+ PAL_CALL(result, PAL_CACHE_SUMMARY, 0, 0, 0);
+ return result;
+}
+
+static struct ia64_pal_retval pal_freq_base(struct kvm_vcpu *vcpu)
+{
+
+ struct ia64_pal_retval result;
+
+ PAL_CALL(result, PAL_FREQ_BASE, 0, 0, 0);
+
+ /*
+ * PAL_FREQ_BASE may not be implemented in some platforms,
+ * call SAL instead.
+ */
+ if (result.v0 =3D=3D 0) {
+ result.status =3D
ia64_sal_freq_base(SAL_FREQ_BASE_PLATFORM,
+ &result.v0,
+ &result.v1);
+ result.v2 =3D 0;
+ }
+
+ return result;
+}
+
+static struct ia64_pal_retval pal_freq_ratios(struct kvm_vcpu *vcpu)
+{
+
+ struct ia64_pal_retval result;
+
+ PAL_CALL(result, PAL_FREQ_RATIOS, 0, 0, 0);
+ return result;
+}
+
+static struct ia64_pal_retval pal_logical_to_physica(struct kvm_vcpu
*vcpu)
+{
+ struct ia64_pal_retval result;
+
+ INIT_PAL_STATUS_UNIMPLEMENTED(result);
+ return result;
+}
+
+static struct ia64_pal_retval pal_platform_addr(struct kvm_vcpu *vcpu)
+{
+
+ struct ia64_pal_retval result;
+
+ INIT_PAL_STATUS_SUCCESS(result);
+ return result;
+}
+
+static struct ia64_pal_retval pal_proc_get_features(struct kvm_vcpu
*vcpu)
+{
+
+ struct ia64_pal_retval result =3D {0, 0, 0, 0};
+ long in0, in1, in2, in3;
+
+ kvm_get_pal_call_data(vcpu, &in0, &in1, &in2, &in3);
+ result.status =3D ia64_pal_proc_get_features(&result.v0,
&result.v1,
+ &result.v2, in2);
+
+ return result;
+}
+
+static struct ia64_pal_retval pal_cache_info(struct kvm_vcpu *vcpu)
+{
+
+ pal_cache_config_info_t ci;
+ long status;
+ unsigned long in0, in1, in2, in3, r9, r10;
+
+ kvm_get_pal_call_data(vcpu, &in0, &in1, &in2, &in3);
+ status =3D ia64_pal_cache_config_info(in1, in2, &ci);
+ r9 =3D ci.pcci_info_1.pcci1_data;
+ r10 =3D ci.pcci_info_2.pcci2_data;
+ return ((struct ia64_pal_retval){status, r9, r10, 0});
+}
+
+#define GUEST_IMPL_VA_MSB 59
+#define GUEST_RID_BITS 18
+
+static struct ia64_pal_retval pal_vm_summary(struct kvm_vcpu *vcpu)
+{
+
+ pal_vm_info_1_u_t vminfo1;
+ pal_vm_info_2_u_t vminfo2;
+ struct ia64_pal_retval result;
+
+ PAL_CALL(result, PAL_VM_SUMMARY, 0, 0, 0);
+ if (!result.status) {
+ vminfo1.pvi1_val =3D result.v0;
+ vminfo1.pal_vm_info_1_s.max_itr_entry =3D 8;
+ vminfo1.pal_vm_info_1_s.max_dtr_entry =3D 8;
+ result.v0 =3D vminfo1.pvi1_val;
+ vminfo2.pal_vm_info_2_s.impl_va_msb =3D GUEST_IMPL_VA_MSB;
+ vminfo2.pal_vm_info_2_s.rid_size =3D GUEST_RID_BITS;
+ result.v1 =3D vminfo2.pvi2_val;
+ }
+
+ return result;
+}
+
+static struct ia64_pal_retval pal_vm_info(struct kvm_vcpu *vcpu)
+{
+ struct ia64_pal_retval result;
+
+ INIT_PAL_STATUS_UNIMPLEMENTED(result);
+
+ return result;
+}
+
+static u64 kvm_get_pal_call_index(struct kvm_vcpu *vcpu)
+{
+ u64 index =3D 0;
+ struct exit_ctl_data *p;
+
+ p =3D kvm_get_exit_data(vcpu);
+ if (p && (p->exit_reason =3D=3D EXIT_REASON_PAL_CALL)) {
+ index =3D p->u.pal_data.gr28;
+ }
+ return index;
+}
+
+int kvm_pal_emul(struct kvm_vcpu *vcpu, struct kvm_run *run)
+{
+
+ u64 gr28;
+ struct ia64_pal_retval result;
+ int ret =3D 1;
+
+ gr28 =3D kvm_get_pal_call_index(vcpu);
+ /*printk("pal_call index:%lx\n",gr28);*/
+ switch (gr28) {
+ case PAL_CACHE_FLUSH:
+ result =3D pal_cache_flush(vcpu);
+ break;
+ case PAL_CACHE_SUMMARY:
+ result =3D pal_cache_summary(vcpu);
+ break;
+ case PAL_HALT_LIGHT:
+ {
+ if (kvm_highest_pending_irq(vcpu) =3D=3D -1) {
+ ret =3D kvm_emulate_halt(vcpu);
+ }
+ vcpu->arch.timer_pending =3D 1;
+ INIT_PAL_STATUS_SUCCESS(result);
+ }
+ break;
+
+ case PAL_FREQ_RATIOS:
+ result =3D pal_freq_ratios(vcpu);
+ break;
+
+ case PAL_FREQ_BASE:
+ result =3D pal_freq_base(vcpu);
+ break;
+
+ case PAL_LOGICAL_TO_PHYSICAL :
+ result =3D pal_logical_to_physica(vcpu);
+ break;
+
+ case PAL_VM_SUMMARY :
+ result =3D pal_vm_summary(vcpu);
+ break;
+
+ case PAL_VM_INFO :
+ result =3D pal_vm_info(vcpu);
+ break;
+ case PAL_PLATFORM_ADDR :
+ result =3D pal_platform_addr(vcpu);
+ break;
+ case PAL_CACHE_INFO:
+ result =3D pal_cache_info(vcpu);
+ break;
+ case PAL_PTCE_INFO:
+ INIT_PAL_STATUS_SUCCESS(result);
+ result.v1 =3D (1L << 32) | 1L;
+ break;
+ case PAL_VM_PAGE_SIZE:
+ result.status =3D ia64_pal_vm_page_size(&result.v0,
+ &result.v1);
+ break;
+ case PAL_RSE_INFO:
+ result.status =3D ia64_pal_rse_info(&result.v0,
+ (pal_hints_u_t *)&result.v1);
+ break;
+ case PAL_PROC_GET_FEATURES:
+ result =3D pal_proc_get_features(vcpu);
+ break;
+ case PAL_DEBUG_INFO:
+ result.status =3D ia64_pal_debug_info(&result.v0,
+ &result.v1);
+ break;
+ case PAL_VERSION:
+ result.status =3D ia64_pal_version(
+ (pal_version_u_t *)&result.v0,
+ (pal_version_u_t *)&result.v1);
+
+ break;
+ case PAL_FIXED_ADDR:
+ result.status =3D PAL_STATUS_SUCCESS;
+ result.v0 =3D vcpu->vcpu_id;
+ break;
+ default:
+ INIT_PAL_STATUS_UNIMPLEMENTED(result);
+ printk(KERN_WARNING"kvm: Unsupported pal call,"
+ " index:0x%lx\n", gr28);
+ }
+ set_pal_result(vcpu, result);
+ return ret;
+}
+
+static struct sal_ret_values sal_emulator(struct kvm *kvm,
+ long index, unsigned long in1,
+ unsigned long in2, unsigned long in3,
+ unsigned long in4, unsigned long in5,
+ unsigned long in6, unsigned long in7)
+{
+ unsigned long r9 =3D 0;
+ unsigned long r10 =3D 0;
+ long r11 =3D 0;
+ long status;
+
+ status =3D 0;
+ switch (index) {
+ case SAL_FREQ_BASE:
+ status =3D ia64_sal_freq_base(in1, &r9, &r10);
+ break;
+ case SAL_PCI_CONFIG_READ:
+ printk(KERN_WARNING"kvm: Not allowed to call here!"
+ " SAL_PCI_CONFIG_READ\n");
+ break;
+ case SAL_PCI_CONFIG_WRITE:
+ printk(KERN_WARNING"kvm: Not allowed to call here!"
+ " SAL_PCI_CONFIG_WRITE\n");
+ break;
+ case SAL_SET_VECTORS:
+ if (in1 =3D=3D SAL_VECTOR_OS_BOOT_RENDEZ) {
+ if (in4 !=3D 0 || in5 !=3D 0 || in6 !=3D 0 || in7 !=3D
0) {
+ status =3D -2;
+ } else {
+ kvm->arch.rdv_sal_data.boot_ip =3D in2;
+ kvm->arch.rdv_sal_data.boot_gp =3D in3;
+ }
+ printk("Rendvous called! iip:%lx\n\n", in2);
+ } else
+ printk(KERN_WARNING"kvm: CALLED SAL_SET_VECTORS
%lu."
+ "ignored...\n",
in1);
+ break;
+ case SAL_GET_STATE_INFO:
+ /* No more info. */
+ status =3D -5;
+ r9 =3D 0;
+ break;
+ case SAL_GET_STATE_INFO_SIZE:
+ /* Return a dummy size. */
+ status =3D 0;
+ r9 =3D 128;
+ break;
+ case SAL_CLEAR_STATE_INFO:
+ /* Noop. */
+ break;
+ case SAL_MC_RENDEZ:
+ printk(KERN_WARNING
+ "kvm: called SAL_MC_RENDEZ. ignored...\n");
+ break;
+ case SAL_MC_SET_PARAMS:
+ printk(KERN_WARNING
+ "kvm: called SAL_MC_SET_PARAMS.ignored!\n");
+ break;
+ case SAL_CACHE_FLUSH:
+ if (1) {
+ /*Flush using SAL.
+ This method is faster but has a side
+ effect on other vcpu running on
+ this cpu. */
+ status =3D ia64_sal_cache_flush(in1);
+ } else {
+ /*Maybe need to implement the method
+ without side effect!*/
+ status =3D 0;
+ }
+ break;
+ case SAL_CACHE_INIT:
+ printk(KERN_WARNING
+ "kvm: called SAL_CACHE_INIT. ignored...\n");
+ break;
+ case SAL_UPDATE_PAL:
+ printk(KERN_WARNING
+ "kvm: CALLED SAL_UPDATE_PAL. ignored...\n");
+ break;
+ default:
+ printk(KERN_WARNING"kvm: called SAL_CALL with unknown
index."
+ " index:%ld\n", index);
+ status =3D -1;
+ break;
+ }
+ return ((struct sal_ret_values) {status, r9, r10, r11});
+}
+
+static void kvm_get_sal_call_data(struct kvm_vcpu *vcpu, u64 *in0, u64
*in1,
+ u64 *in2, u64 *in3, u64 *in4, u64 *in5, u64 *in6, u64
*in7){
+
+ struct exit_ctl_data *p;
+
+ p =3D kvm_get_exit_data(vcpu);
+
+ if (p) {
+ if (p->exit_reason =3D=3D EXIT_REASON_SAL_CALL) {
+ *in0 =3D p->u.sal_data.in0;
+ *in1 =3D p->u.sal_data.in1;
+ *in2 =3D p->u.sal_data.in2;
+ *in3 =3D p->u.sal_data.in3;
+ *in4 =3D p->u.sal_data.in4;
+ *in5 =3D p->u.sal_data.in5;
+ *in6 =3D p->u.sal_data.in6;
+ *in7 =3D p->u.sal_data.in7;
+ return ;
+ }
+ }
+ *in0 =3D 0;
+}
+
+void kvm_sal_emul(struct kvm_vcpu *vcpu)
+{
+
+ struct sal_ret_values result;
+ u64 index, in1, in2, in3, in4, in5, in6, in7;
+
+ kvm_get_sal_call_data(vcpu, &index, &in1, &in2,
+ &in3, &in4, &in5, &in6, &in7);
+ result =3D sal_emulator(vcpu->kvm, index, in1, in2, in3,
+ in4, in5, in6, in7);
+ set_sal_result(vcpu, result);
+}
--=20
1.5.1
|
