/* * PAL/SAL call delegation * * Copyright (c) 2004 Li Susie * Copyright (c) 2005 Yu Ke * Copyright (c) 2007 Xiantao Zhang * * 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 #include #include #include #include #include "vti.h" #include "misc.h" #include #include #include /* * Handy macros to make sure that the PAL return values start out * as something meaningful. */ #define INIT_PAL_STATUS_UNIMPLEMENTED(x) \ { \ x.status = PAL_STATUS_UNIMPLEMENTED; \ x.v0 = 0; \ x.v1 = 0; \ x.v2 = 0; \ } #define INIT_PAL_STATUS_SUCCESS(x) \ { \ x.status = PAL_STATUS_SUCCESS; \ x.v0 = 0; \ x.v1 = 0; \ x.v2 = 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 = &vcpu->arch.exit_data; if (p->exit_reason == EXIT_REASON_PAL_CALL) { *gr28 = p->u.pal_data.gr28; *gr29 = p->u.pal_data.gr29; *gr30 = p->u.pal_data.gr30; *gr31 = p->u.pal_data.gr31; return ; } } printk(KERN_DEBUG"Failed to get vcpu pal data!!!\n"); } static void set_pal_result(struct kvm_vcpu *vcpu, struct ia64_pal_retval result) { struct exit_ctl_data *p; p = kvm_get_exit_data(vcpu); if (p && p->exit_reason == EXIT_REASON_PAL_CALL) { p->u.pal_data.ret = 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 = kvm_get_exit_data(vcpu); if (p && p->exit_reason == EXIT_REASON_SAL_CALL) { p->u.sal_data.ret = result; return ; } printk(KERN_WARNING"Failed to set sal result!!\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 = data; long status; u64 progress = args->progress; status = ia64_pal_cache_flush(args->cache_type, args->operation, &progress, NULL); if (status != 0) args->status = status; } static struct ia64_pal_retval pal_cache_flush(struct kvm_vcpu *vcpu) { u64 gr28, gr29, gr30, gr31; struct ia64_pal_retval result = {0, 0, 0, 0}; struct cache_flush_args args = {0, 0, 0, 0}; long psr; gr28 = gr29 = gr30 = gr31 = 0; kvm_get_pal_call_data(vcpu, &gr28, &gr29, &gr30, &gr31); if (gr31 != 0) printk(KERN_ERR"vcpu:%p called cache_flush error!\n", vcpu); /* Always call Host Pal in int=1 */ gr30 &= ~PAL_CACHE_FLUSH_CHK_INTRS; args.cache_type = gr29; args.operation = gr30; smp_call_function(remote_pal_cache_flush, (void *)&args, 1); if (args.status != 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 = ia64_pal_cache_flush(gr29, gr30, &result.v1, &result.v0); local_irq_restore(psr); if (result.status != 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 == 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 == 0) { result.status = ia64_sal_freq_base(SAL_FREQ_BASE_PLATFORM, &result.v0, &result.v1); result.v2 = 0; } return result; } /* * On the SGI SN2, the ITC isn't stable. Emulation backed by the SN2 * RTC is used instead. This function patches the ratios from SAL * to match the RTC before providing them to the guest. */ static void sn2_patch_itc_freq_ratios(struct ia64_pal_retval *result) { struct pal_freq_ratio *ratio; unsigned long sal_freq, sal_drift, factor; result->status = ia64_sal_freq_base(SAL_FREQ_BASE_PLATFORM, &sal_freq, &sal_drift); ratio = (struct pal_freq_ratio *)&result->v2; factor = ((sal_freq * 3) + (sn_rtc_cycles_per_second / 2)) / sn_rtc_cycles_per_second; ratio->num = 3; ratio->den = factor; } 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); if (vcpu->kvm->arch.is_sn2) sn2_patch_itc_freq_ratios(&result); 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 = {0, 0, 0, 0}; long in0, in1, in2, in3; kvm_get_pal_call_data(vcpu, &in0, &in1, &in2, &in3); result.status = ia64_pal_proc_get_features(&result.v0, &result.v1, &result.v2, in2); return result; } static struct ia64_pal_retval pal_register_info(struct kvm_vcpu *vcpu) { struct ia64_pal_retval result = {0, 0, 0, 0}; long in0, in1, in2, in3; kvm_get_pal_call_data(vcpu, &in0, &in1, &in2, &in3); result.status = ia64_pal_register_info(in1, &result.v1, &result.v2); 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 = ia64_pal_cache_config_info(in1, in2, &ci); r9 = ci.pcci_info_1.pcci1_data; r10 = 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 = result.v0; vminfo1.pal_vm_info_1_s.max_itr_entry = 8; vminfo1.pal_vm_info_1_s.max_dtr_entry = 8; result.v0 = vminfo1.pvi1_val; vminfo2.pal_vm_info_2_s.impl_va_msb = GUEST_IMPL_VA_MSB; vminfo2.pal_vm_info_2_s.rid_size = GUEST_RID_BITS; result.v1 = vminfo2.pvi2_val; } return result; } static struct ia64_pal_retval pal_vm_info(struct kvm_vcpu *vcpu) { struct ia64_pal_retval result; unsigned long in0, in1, in2, in3; kvm_get_pal_call_data(vcpu, &in0, &in1, &in2, &in3); result.status = ia64_pal_vm_info(in1, in2, (pal_tc_info_u_t *)&result.v1, &result.v2); return result; } static u64 kvm_get_pal_call_index(struct kvm_vcpu *vcpu) { u64 index = 0; struct exit_ctl_data *p; p = kvm_get_exit_data(vcpu); if (p && (p->exit_reason == EXIT_REASON_PAL_CALL)) index = p->u.pal_data.gr28; return index; } static void prepare_for_halt(struct kvm_vcpu *vcpu) { vcpu->arch.timer_pending = 1; vcpu->arch.timer_fired = 0; } static struct ia64_pal_retval pal_perf_mon_info(struct kvm_vcpu *vcpu) { long status; unsigned long in0, in1, in2, in3, r9; unsigned long pm_buffer[16]; kvm_get_pal_call_data(vcpu, &in0, &in1, &in2, &in3); status = ia64_pal_perf_mon_info(pm_buffer, (pal_perf_mon_info_u_t *) &r9); if (status != 0) { printk(KERN_DEBUG"PAL_PERF_MON_INFO fails ret=%ld\n", status); } else { if (in1) memcpy((void *)in1, pm_buffer, sizeof(pm_buffer)); else { status = PAL_STATUS_EINVAL; printk(KERN_WARNING"Invalid parameters " "for PAL call:0x%lx!\n", in0); } } return (struct ia64_pal_retval){status, r9, 0, 0}; } static struct ia64_pal_retval pal_halt_info(struct kvm_vcpu *vcpu) { unsigned long in0, in1, in2, in3; long status; unsigned long res = 1000UL | (1000UL << 16) | (10UL << 32) | (1UL << 61) | (1UL << 60); kvm_get_pal_call_data(vcpu, &in0, &in1, &in2, &in3); if (in1) { memcpy((void *)in1, &res, sizeof(res)); status = 0; } else{ status = PAL_STATUS_EINVAL; printk(KERN_WARNING"Invalid parameters " "for PAL call:0x%lx!\n", in0); } return (struct ia64_pal_retval){status, 0, 0, 0}; } static struct ia64_pal_retval pal_mem_attrib(struct kvm_vcpu *vcpu) { unsigned long r9; long status; status = ia64_pal_mem_attrib(&r9); return (struct ia64_pal_retval){status, r9, 0, 0}; } static void remote_pal_prefetch_visibility(void *v) { s64 trans_type = (s64)v; ia64_pal_prefetch_visibility(trans_type); } static struct ia64_pal_retval pal_prefetch_visibility(struct kvm_vcpu *vcpu) { struct ia64_pal_retval result = {0, 0, 0, 0}; unsigned long in0, in1, in2, in3; kvm_get_pal_call_data(vcpu, &in0, &in1, &in2, &in3); result.status = ia64_pal_prefetch_visibility(in1); if (result.status == 0) { /* Must be performed on all remote processors in the coherence domain. */ smp_call_function(remote_pal_prefetch_visibility, (void *)in1, 1); /* Unnecessary on remote processor for other vcpus!*/ result.status = 1; } return result; } static void remote_pal_mc_drain(void *v) { ia64_pal_mc_drain(); } static struct ia64_pal_retval pal_get_brand_info(struct kvm_vcpu *vcpu) { struct ia64_pal_retval result = {0, 0, 0, 0}; unsigned long in0, in1, in2, in3; kvm_get_pal_call_data(vcpu, &in0, &in1, &in2, &in3); if (in1 == 0 && in2) { char brand_info[128]; result.status = ia64_pal_get_brand_info(brand_info); if (result.status == PAL_STATUS_SUCCESS) memcpy((void *)in2, brand_info, 128); } else { result.status = PAL_STATUS_REQUIRES_MEMORY; printk(KERN_WARNING"Invalid parameters for " "PAL call:0x%lx!\n", in0); } return result; } int kvm_pal_emul(struct kvm_vcpu *vcpu, struct kvm_run *run) { u64 gr28; struct ia64_pal_retval result; int ret = 1; gr28 = kvm_get_pal_call_index(vcpu); switch (gr28) { case PAL_CACHE_FLUSH: result = pal_cache_flush(vcpu); break; case PAL_MEM_ATTRIB: result = pal_mem_attrib(vcpu); break; case PAL_CACHE_SUMMARY: result = pal_cache_summary(vcpu); break; case PAL_PERF_MON_INFO: result = pal_perf_mon_info(vcpu); break; case PAL_HALT_INFO: result = pal_halt_info(vcpu); break; case PAL_HALT_LIGHT: { INIT_PAL_STATUS_SUCCESS(result); prepare_for_halt(vcpu); if (kvm_highest_pending_irq(vcpu) == -1) ret = kvm_emulate_halt(vcpu); } break; case PAL_PREFETCH_VISIBILITY: result = pal_prefetch_visibility(vcpu); break; case PAL_MC_DRAIN: result.status = ia64_pal_mc_drain(); /* FIXME: All vcpus likely call PAL_MC_DRAIN. That causes the congestion. */ smp_call_function(remote_pal_mc_drain, NULL, 1); break; case PAL_FREQ_RATIOS: result = pal_freq_ratios(vcpu); break; case PAL_FREQ_BASE: result = pal_freq_base(vcpu); break; case PAL_LOGICAL_TO_PHYSICAL : result = pal_logical_to_physica(vcpu); break; case PAL_VM_SUMMARY : result = pal_vm_summary(vcpu); break; case PAL_VM_INFO : result = pal_vm_info(vcpu); break; case PAL_PLATFORM_ADDR : result = pal_platform_addr(vcpu); break; case PAL_CACHE_INFO: result = pal_cache_info(vcpu); break; case PAL_PTCE_INFO: INIT_PAL_STATUS_SUCCESS(result); result.v1 = (1L << 32) | 1L; break; case PAL_REGISTER_INFO: result = pal_register_info(vcpu); break; case PAL_VM_PAGE_SIZE: result.status = ia64_pal_vm_page_size(&result.v0, &result.v1); break; case PAL_RSE_INFO: result.status = ia64_pal_rse_info(&result.v0, (pal_hints_u_t *)&result.v1); break; case PAL_PROC_GET_FEATURES: result = pal_proc_get_features(vcpu); break; case PAL_DEBUG_INFO: result.status = ia64_pal_debug_info(&result.v0, &result.v1); break; case PAL_VERSION: result.status = ia64_pal_version( (pal_version_u_t *)&result.v0, (pal_version_u_t *)&result.v1); break; case PAL_FIXED_ADDR: result.status = PAL_STATUS_SUCCESS; result.v0 = vcpu->vcpu_id; break; case PAL_BRAND_INFO: result = pal_get_brand_info(vcpu); break; case PAL_GET_PSTATE: case PAL_CACHE_SHARED_INFO: INIT_PAL_STATUS_UNIMPLEMENTED(result); 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 = 0; unsigned long r10 = 0; long r11 = 0; long status; status = 0; switch (index) { case SAL_FREQ_BASE: status = 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 == SAL_VECTOR_OS_BOOT_RENDEZ) { if (in4 != 0 || in5 != 0 || in6 != 0 || in7 != 0) { status = -2; } else { kvm->arch.rdv_sal_data.boot_ip = in2; kvm->arch.rdv_sal_data.boot_gp = 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 = -5; r9 = 0; break; case SAL_GET_STATE_INFO_SIZE: /* Return a dummy size. */ status = 0; r9 = 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 = ia64_sal_cache_flush(in1); } else { /*Maybe need to implement the method without side effect!*/ status = 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 = -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 = kvm_get_exit_data(vcpu); if (p) { if (p->exit_reason == EXIT_REASON_SAL_CALL) { *in0 = p->u.sal_data.in0; *in1 = p->u.sal_data.in1; *in2 = p->u.sal_data.in2; *in3 = p->u.sal_data.in3; *in4 = p->u.sal_data.in4; *in5 = p->u.sal_data.in5; *in6 = p->u.sal_data.in6; *in7 = p->u.sal_data.in7; return ; } } *in0 = 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 = sal_emulator(vcpu->kvm, index, in1, in2, in3, in4, in5, in6, in7); set_sal_result(vcpu, result); }