1668 lines
54 KiB
C
1668 lines
54 KiB
C
/******************************************************************************
|
|
* hypercall.h
|
|
*
|
|
* KVM host <-> guest Linux-specific hypervisor handling.
|
|
*
|
|
* Copyright (c) 2011-2012, Salavat Gilyazov
|
|
*
|
|
* 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; or, when distributed
|
|
* separately from the Linux kernel or incorporated into other
|
|
* software packages, subject to the following license:
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this source file (the "Software"), to deal in the Software without
|
|
* restriction, including without limitation the rights to use, copy, modify,
|
|
* merge, publish, distribute, sublicense, and/or sell copies of the Software,
|
|
* and to permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
* IN THE SOFTWARE.
|
|
*/
|
|
|
|
#ifndef _ASM_E2K_HYPERCALL_H
|
|
#define _ASM_E2K_HYPERCALL_H
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/kvm_types.h>
|
|
|
|
#include <asm/e2k_api.h>
|
|
#include <asm/cpu_regs_types.h>
|
|
#include <asm/trap_def.h>
|
|
#include <asm/kvm/guest/cpu.h>
|
|
#include <asm/kvm/proc_context_types.h>
|
|
|
|
#ifdef CONFIG_KVM_GUEST_HW_HCALL
|
|
extern unsigned long light_hw_hypercall(unsigned long nr,
|
|
unsigned long arg1, unsigned long arg2,
|
|
unsigned long arg3, unsigned long arg4,
|
|
unsigned long arg5, unsigned long arg6);
|
|
extern unsigned long generic_hw_hypercall(unsigned long nr,
|
|
unsigned long arg1, unsigned long arg2,
|
|
unsigned long arg3, unsigned long arg4,
|
|
unsigned long arg5, unsigned long arg6,
|
|
unsigned long arg7);
|
|
#endif /* CONFIG_KVM_GUEST_HW_HCALL */
|
|
|
|
static inline unsigned long light_hypercall(unsigned long nr,
|
|
unsigned long arg1, unsigned long arg2,
|
|
unsigned long arg3, unsigned long arg4,
|
|
unsigned long arg5, unsigned long arg6)
|
|
{
|
|
unsigned long ret;
|
|
|
|
#ifdef CONFIG_KVM_GUEST_HW_HCALL
|
|
# ifdef CONFIG_KVM_GUEST_KERNEL
|
|
if (kvm_vcpu_host_support_hw_hc())
|
|
# endif /* CONFIG_KVM_GUEST_KERNEL */
|
|
return light_hw_hypercall(nr, arg1, arg2, arg3,
|
|
arg4, arg5, arg6);
|
|
#endif /* CONFIG_KVM_GUEST_HW_HCALL */
|
|
|
|
ret = E2K_SYSCALL(LIGHT_HYPERCALL_TRAPNUM, nr, 6,
|
|
arg1, arg2, arg3, arg4, arg5, arg6);
|
|
|
|
return ret;
|
|
}
|
|
static inline unsigned long light_hypercall0(unsigned long nr)
|
|
{
|
|
return light_hypercall(nr, 0, 0, 0, 0, 0, 0);
|
|
}
|
|
|
|
static inline unsigned long light_hypercall1(unsigned long nr,
|
|
unsigned long arg1)
|
|
{
|
|
return light_hypercall(nr, arg1, 0, 0, 0, 0, 0);
|
|
}
|
|
|
|
static inline unsigned long light_hypercall2(unsigned long nr,
|
|
unsigned long arg1, unsigned long arg2)
|
|
{
|
|
return light_hypercall(nr, arg1, arg2, 0, 0, 0, 0);
|
|
}
|
|
|
|
static inline unsigned long light_hypercall3(unsigned long nr,
|
|
unsigned long arg1, unsigned long arg2,
|
|
unsigned long arg3)
|
|
{
|
|
return light_hypercall(nr, arg1, arg2, arg3, 0, 0, 0);
|
|
}
|
|
|
|
static inline unsigned long light_hypercall4(unsigned long nr,
|
|
unsigned long arg1, unsigned long arg2,
|
|
unsigned long arg3, unsigned long arg4)
|
|
{
|
|
return light_hypercall(nr, arg1, arg2, arg3, arg4, 0, 0);
|
|
}
|
|
|
|
static inline unsigned long light_hypercall5(unsigned long nr,
|
|
unsigned long arg1, unsigned long arg2,
|
|
unsigned long arg3, unsigned long arg4,
|
|
unsigned long arg5)
|
|
{
|
|
return light_hypercall(nr, arg1, arg2, arg3, arg4, arg5, 0);
|
|
}
|
|
|
|
static inline unsigned long light_hypercall6(unsigned long nr,
|
|
unsigned long arg1, unsigned long arg2,
|
|
unsigned long arg3, unsigned long arg4,
|
|
unsigned long arg5, unsigned long arg6)
|
|
{
|
|
return light_hypercall(nr, arg1, arg2, arg3, arg4, arg5, arg6);
|
|
}
|
|
|
|
static inline unsigned long generic_hypercall(unsigned long nr,
|
|
unsigned long arg1, unsigned long arg2, unsigned long arg3,
|
|
unsigned long arg4, unsigned long arg5, unsigned long arg6,
|
|
unsigned long arg7)
|
|
{
|
|
unsigned long ret;
|
|
|
|
#ifdef CONFIG_KVM_GUEST_HW_HCALL
|
|
# ifdef CONFIG_KVM_GUEST_KERNEL
|
|
if (kvm_vcpu_host_support_hw_hc())
|
|
# endif /* CONFIG_KVM_GUEST_KERNEL */
|
|
return generic_hw_hypercall(nr,
|
|
arg1, arg2, arg3, arg4, arg5, arg6, arg7);
|
|
#endif /* CONFIG_KVM_GUEST_HW_HCALL */
|
|
|
|
ret = E2K_SYSCALL(GENERIC_HYPERCALL_TRAPNUM, nr, 7,
|
|
arg1, arg2, arg3, arg4, arg5, arg6, arg7);
|
|
return ret;
|
|
}
|
|
static inline unsigned long generic_hypercall0(unsigned long nr)
|
|
{
|
|
return generic_hypercall(nr, 0, 0, 0, 0, 0, 0, 0);
|
|
}
|
|
|
|
static inline unsigned long generic_hypercall1(unsigned long nr,
|
|
unsigned long arg1)
|
|
{
|
|
return generic_hypercall(nr, arg1, 0, 0, 0, 0, 0, 0);
|
|
}
|
|
|
|
static inline unsigned long generic_hypercall2(unsigned long nr,
|
|
unsigned long arg1, unsigned long arg2)
|
|
{
|
|
return generic_hypercall(nr, arg1, arg2, 0, 0, 0, 0, 0);
|
|
}
|
|
|
|
static inline unsigned long generic_hypercall3(unsigned long nr,
|
|
unsigned long arg1, unsigned long arg2,
|
|
unsigned long arg3)
|
|
{
|
|
return generic_hypercall(nr, arg1, arg2, arg3, 0, 0, 0, 0);
|
|
}
|
|
|
|
static inline unsigned long generic_hypercall4(unsigned long nr,
|
|
unsigned long arg1, unsigned long arg2,
|
|
unsigned long arg3, unsigned long arg4)
|
|
{
|
|
return generic_hypercall(nr, arg1, arg2, arg3, arg4, 0, 0, 0);
|
|
}
|
|
|
|
static inline unsigned long generic_hypercall5(unsigned long nr,
|
|
unsigned long arg1, unsigned long arg2,
|
|
unsigned long arg3, unsigned long arg4,
|
|
unsigned long arg5)
|
|
{
|
|
return generic_hypercall(nr, arg1, arg2, arg3, arg4, arg5, 0, 0);
|
|
}
|
|
|
|
static inline unsigned long generic_hypercall6(unsigned long nr,
|
|
unsigned long arg1, unsigned long arg2,
|
|
unsigned long arg3, unsigned long arg4,
|
|
unsigned long arg5, unsigned long arg6)
|
|
{
|
|
return generic_hypercall(nr, arg1, arg2, arg3, arg4, arg5, arg6, 0);
|
|
}
|
|
|
|
/*
|
|
* KVM hypervisor (host) <-> guest lite hypercalls list
|
|
*/
|
|
|
|
#define KVM_HCALL_COPY_STACKS_TO_MEMORY 1 /* copy (flush) hardware */
|
|
/* stacks to memory */
|
|
#define KVM_HCALL_SWITCH_GUEST_THREAD_STACKS 2 /* switch guest kernel thread */
|
|
/* stacks from current to new */
|
|
/* specified by GPID number */
|
|
#define KVM_HCALL_GET_ACTIVE_CR_MEM_ITEM 3 /* get current active */
|
|
/* procedure chain stack item */
|
|
#define KVM_HCALL_PUT_ACTIVE_CR_MEM_ITEM 4 /* put current active */
|
|
/* procedure chain stack item */
|
|
#define KVM_HCALL_GET_HOST_RUNSTATE_KTIME 5 /* get host kernel current */
|
|
/* time at terms of runstate */
|
|
/* time (cycles) */
|
|
#define KVM_HCALL_GET_GUEST_RUNNING_TIME 6 /* get running time of guest */
|
|
/* VCPU at cycles */
|
|
#define KVM_HCALL_GET_HOST_MMU_PPTB 7 /* get the host MMU PPTB register */
|
|
/* state */
|
|
#define KVM_HCALL_GET_TLB_SET_TAG 8 /* get tag of TLB line set */
|
|
#define KVM_HCALL_GET_TLB_SET_ENTRY 9 /* get entry of TLB line set */
|
|
#define KVM_HCALL_UPDATE_PSP_HI 10 /* write updated value to */
|
|
/* PSP_hi register */
|
|
#define KVM_HCALL_UPDATE_PCSP_HI 11 /* write updated value to */
|
|
/* PCSP_hi register */
|
|
#define KVM_HCALL_SETUP_IDLE_TASK 12 /* setup current task of */
|
|
/* guest as task */
|
|
#define KVM_HCALL_UPDATE_WD_PSIZE 13 /* write updated psize field */
|
|
/* to the WD register */
|
|
#define KVM_HCALL_GET_HOST_MMU_PID 14 /* get the host MMU PID register */
|
|
/* state */
|
|
#define KVM_HCALL_MOVE_TAGGED_DATA 15 /* move quad value from to */
|
|
#define KVM_HCALL_UNFREEZE_TRAPS 16 /* unfreeze TIRs & trap */
|
|
/* cellar */
|
|
#define KVM_HCALL_SWITCH_TO_INIT_MM 17 /* deactivate current guest */
|
|
/* mm, switch to init mm */
|
|
#define KVM_HCALL_EXTRACT_TAGS_32 19 /* extract tags from 32 bytes */
|
|
/* of data */
|
|
#define KVM_HCALL_INJECT_INTERRUPT 20 /* inject interrupt to handle */
|
|
/* pending VIRQs by guest */
|
|
#define KVM_HCALL_VIRQ_HANDLED 21 /* info host about all VIRQs */
|
|
/* were handled by guest */
|
|
#define KVM_HCALL_TEST_PENDING_VIRQ 22 /* test pending VIRQs on VCPU */
|
|
#define KVM_HCALL_READ_DTLB_REG 23 /* read DTLB entry for */
|
|
/* virtual address */
|
|
#define KVM_HCALL_GET_DAM 24 /* get current DAM state */
|
|
#define KVM_HCALL_FLUSH_DCACHE_LINE 25 /* flush DCACHE line */
|
|
#define KVM_HCALL_CLEAR_DCACHE_L1_SET 26 /* clear DCACHE L1 set */
|
|
#define KVM_HCALL_FLUSH_DCACHE_RANGE 27 /* flush DCACHE range of */
|
|
/* virtual addresses */
|
|
#define KVM_HCALL_CLEAR_DCACHE_L1_RANGE 28 /* flush DCACHE L1 range of */
|
|
/* virtual addresses */
|
|
#define KVM_HCALL_MMU_PROBE 29 /* probe MMU entry or */
|
|
/* address */
|
|
#define KVM_HCALL_FLUSH_ICACHE_ALL 30 /* flush all ICACHE */
|
|
/* notify host kernel aboout switch to updated procedure stack on guest */
|
|
#define KVM_HCALL_SWITCH_TO_EXPANDED_PROC_STACK 31
|
|
/* notify host kernel aboout switch to updated procedure chain stack on guest */
|
|
#define KVM_HCALL_SWITCH_TO_EXPANDED_CHAIN_STACK 32
|
|
/* return back to guest user from fast syscall handler */
|
|
#define KVM_HCALL_RETURN_FROM_FAST_SYSCALL 33
|
|
/* change return ip in user stack */
|
|
#define KVM_HCALL_SET_RETURN_USER_IP 34
|
|
/* fast guest kernel tagged memory copy */
|
|
#define KVM_HCALL_FAST_KERNEL_TAGGED_MEMORY_COPY 40
|
|
/* fast guest kernel tagged memory set */
|
|
#define KVM_HCALL_FAST_KERNEL_TAGGED_MEMORY_SET 41
|
|
/* update last 2 frmaes on guest kernel stack */
|
|
#define KVM_HCALL_UPDATE_GUEST_KERNEL_CRS 42
|
|
|
|
|
|
typedef struct kvm_hw_stacks_flush {
|
|
unsigned long psp_lo;
|
|
unsigned long psp_hi;
|
|
unsigned long pcsp_lo;
|
|
unsigned long pcsp_hi;
|
|
} kvm_hw_stacks_flush_t;
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_copy_stacks_to_memory(void)
|
|
{
|
|
return light_hypercall1(KVM_HCALL_COPY_STACKS_TO_MEMORY,
|
|
(unsigned long)NULL);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_flush_hw_stacks_to_memory(kvm_hw_stacks_flush_t __user *hw_stacks)
|
|
{
|
|
return light_hypercall1(KVM_HCALL_COPY_STACKS_TO_MEMORY,
|
|
(unsigned long)hw_stacks);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_switch_guest_thread_stacks(unsigned long gpid_nr,
|
|
unsigned long gmmid_nr)
|
|
{
|
|
return light_hypercall2(KVM_HCALL_SWITCH_GUEST_THREAD_STACKS,
|
|
gpid_nr, gmmid_nr);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_get_active_cr_mem_item(unsigned long __user *cr_value,
|
|
e2k_addr_t base, e2k_addr_t cr_ind,
|
|
e2k_addr_t cr_item)
|
|
{
|
|
return light_hypercall4(KVM_HCALL_GET_ACTIVE_CR_MEM_ITEM,
|
|
(unsigned long)cr_value,
|
|
base, cr_ind, cr_item);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_put_active_cr_mem_item(unsigned long cr_value,
|
|
e2k_addr_t base, e2k_addr_t cr_ind,
|
|
e2k_addr_t cr_item)
|
|
{
|
|
return light_hypercall4(KVM_HCALL_PUT_ACTIVE_CR_MEM_ITEM,
|
|
cr_value, base, cr_ind, cr_item);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_get_host_runstate_ktime(void)
|
|
{
|
|
return light_hypercall0(KVM_HCALL_GET_HOST_RUNSTATE_KTIME);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_get_guest_running_time(void)
|
|
{
|
|
return light_hypercall0(KVM_HCALL_GET_GUEST_RUNNING_TIME);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_get_tlb_set_tag(e2k_addr_t va, int set_no, bool huge)
|
|
{
|
|
return light_hypercall3(KVM_HCALL_GET_TLB_SET_TAG, va, set_no, huge);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_get_tlb_set_entry(e2k_addr_t va, int set_no, bool huge)
|
|
{
|
|
return light_hypercall3(KVM_HCALL_GET_TLB_SET_ENTRY, va, set_no, huge);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_get_host_mmu_pptb(void)
|
|
{
|
|
return light_hypercall0(KVM_HCALL_GET_HOST_MMU_PPTB);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_get_host_mmu_pid(void)
|
|
{
|
|
return light_hypercall0(KVM_HCALL_GET_HOST_MMU_PID);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_update_psp_hi(unsigned long psp_hi_value)
|
|
{
|
|
return light_hypercall1(KVM_HCALL_UPDATE_PSP_HI, psp_hi_value);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_update_wd_psize(unsigned long psize_value)
|
|
{
|
|
return light_hypercall1(KVM_HCALL_UPDATE_WD_PSIZE, psize_value);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_update_pcsp_hi(unsigned long pcsp_hi_value)
|
|
{
|
|
return light_hypercall1(KVM_HCALL_UPDATE_PCSP_HI, pcsp_hi_value);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_setup_idle_task(int cpu)
|
|
{
|
|
return light_hypercall1(KVM_HCALL_SETUP_IDLE_TASK, (unsigned long)cpu);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_unfreeze_guest_traps(void)
|
|
{
|
|
return light_hypercall0(KVM_HCALL_UNFREEZE_TRAPS);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_switch_to_guest_init_mm(void)
|
|
{
|
|
return light_hypercall0(KVM_HCALL_SWITCH_TO_INIT_MM);
|
|
}
|
|
|
|
union recovery_faulted_arg {
|
|
struct {
|
|
char vr;
|
|
char chan;
|
|
char qp;
|
|
char atomic;
|
|
u16 tag;
|
|
u16 tag_ext;
|
|
};
|
|
u64 entire;
|
|
};
|
|
static inline unsigned long
|
|
HYPERVISOR_move_tagged_data(int word_size,
|
|
e2k_addr_t addr_from, e2k_addr_t addr_to)
|
|
{
|
|
return light_hypercall3(KVM_HCALL_MOVE_TAGGED_DATA,
|
|
word_size, addr_from, addr_to);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_extract_tags_32(u16 *dst, const void *src)
|
|
{
|
|
return light_hypercall2(KVM_HCALL_EXTRACT_TAGS_32,
|
|
(unsigned long)dst, (unsigned long)src);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_inject_interrupt(void)
|
|
{
|
|
return light_hypercall0(KVM_HCALL_INJECT_INTERRUPT);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_virqs_handled(void)
|
|
{
|
|
return light_hypercall0(KVM_HCALL_VIRQ_HANDLED);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_test_pending_virqs(void)
|
|
{
|
|
return light_hypercall0(KVM_HCALL_TEST_PENDING_VIRQ);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_read_dtlb_reg(e2k_addr_t virt_addr)
|
|
{
|
|
return light_hypercall1(KVM_HCALL_READ_DTLB_REG, virt_addr);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_get_DAM(unsigned long long *dam, int dam_entries)
|
|
{
|
|
return light_hypercall2(KVM_HCALL_GET_DAM, (unsigned long)dam,
|
|
dam_entries);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_flush_dcache_line(e2k_addr_t virt_addr)
|
|
{
|
|
return light_hypercall1(KVM_HCALL_FLUSH_DCACHE_LINE, virt_addr);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_clear_dcache_l1_set(e2k_addr_t virt_addr, unsigned long set)
|
|
{
|
|
return light_hypercall2(KVM_HCALL_CLEAR_DCACHE_L1_SET, virt_addr, set);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_flush_dcache_range(void *addr, size_t len)
|
|
{
|
|
return light_hypercall2(KVM_HCALL_FLUSH_DCACHE_RANGE,
|
|
(unsigned long)addr, len);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_clear_dcache_l1_range(void *addr, size_t len)
|
|
{
|
|
return light_hypercall2(KVM_HCALL_CLEAR_DCACHE_L1_RANGE,
|
|
(unsigned long)addr, len);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_flush_icache_all(void)
|
|
{
|
|
return light_hypercall0(KVM_HCALL_FLUSH_ICACHE_ALL);
|
|
}
|
|
|
|
typedef enum kvm_mmu_probe {
|
|
KVM_MMU_PROBE_ENTRY,
|
|
KVM_MMU_PROBE_ADDRESS,
|
|
} kvm_mmu_probe_t;
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_mmu_probe(e2k_addr_t virt_address, kvm_mmu_probe_t what)
|
|
{
|
|
return light_hypercall2(KVM_HCALL_MMU_PROBE, virt_address, what);
|
|
}
|
|
|
|
static inline long
|
|
HYPERVISOR_switch_to_expanded_guest_proc_stack(long delta_size,
|
|
long delta_offset, bool decr_gk_ps)
|
|
{
|
|
return light_hypercall3(KVM_HCALL_SWITCH_TO_EXPANDED_PROC_STACK,
|
|
delta_size, delta_offset, (unsigned long)decr_gk_ps);
|
|
}
|
|
static inline long
|
|
HYPERVISOR_switch_to_expanded_guest_chain_stack(long delta_size,
|
|
long delta_offset, bool decr_gk_pcs)
|
|
{
|
|
return light_hypercall3(KVM_HCALL_SWITCH_TO_EXPANDED_CHAIN_STACK,
|
|
delta_size, delta_offset, (unsigned long)decr_gk_pcs);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_return_from_fast_syscall(long ret_val)
|
|
{
|
|
return light_hypercall1(KVM_HCALL_RETURN_FROM_FAST_SYSCALL, ret_val);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_set_return_user_ip(u64 gti, u64 ip, int flags)
|
|
{
|
|
return light_hypercall3(KVM_HCALL_SET_RETURN_USER_IP, gti,
|
|
ip, flags);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_fast_kernel_tagged_memory_copy(void *dst, const void *src, size_t len,
|
|
unsigned long strd_opcode, unsigned long ldrd_opcode,
|
|
int prefetch)
|
|
{
|
|
return light_hypercall6(KVM_HCALL_FAST_KERNEL_TAGGED_MEMORY_COPY,
|
|
(unsigned long)dst, (unsigned long)src,
|
|
len, strd_opcode, ldrd_opcode, prefetch);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_fast_kernel_tagged_memory_set(void *addr, u64 val, u64 tag, size_t len,
|
|
u64 strd_opcode)
|
|
{
|
|
return light_hypercall5(KVM_HCALL_FAST_KERNEL_TAGGED_MEMORY_SET,
|
|
(unsigned long)addr, val, tag, len, strd_opcode);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_update_guest_kernel_crs(e2k_mem_crs_t *crs, e2k_mem_crs_t *prev_crs,
|
|
e2k_mem_crs_t *p_prev_crs)
|
|
{
|
|
return light_hypercall3(KVM_HCALL_UPDATE_GUEST_KERNEL_CRS,
|
|
(unsigned long)crs, (unsigned long)prev_crs,
|
|
(unsigned long)p_prev_crs);
|
|
}
|
|
|
|
/*
|
|
* KVM hypervisor (host) <-> guest generic hypercalls list
|
|
*/
|
|
|
|
#define KVM_HCALL_PV_WAIT 1 /* suspend current vcpu until */
|
|
/* it will be woken up by */
|
|
/* call KVM_HCALL_PV_KICK */
|
|
#define KVM_HCALL_PV_KICK 2 /* wake up vcpu suspended by */
|
|
/* call KVM_HCALL_PV_WAIT */
|
|
#define KVM_HCALL_RELEASE_TASK_STRUCT 8 /* release task struct on */
|
|
/* host after task completion */
|
|
#define KVM_HCALL_SET_CLOCKEVENT 10 /* set clock event */
|
|
#define KVM_HCALL_COMPLETE_LONG_JUMP 12 /* long jump completion */
|
|
#define KVM_HCALL_LAUNCH_SIG_HANDLER 14 /* launch guest user signal */
|
|
/* handler */
|
|
#define KVM_HCALL_APPLY_USD_BOUNDS 15 /* update user data */
|
|
/* stack pointers after stack */
|
|
/* bounds handling */
|
|
#define KVM_HCALL_SWITCH_TO_VIRT_MODE 16 /* switch from physical to */
|
|
/* virtual addresses mode */
|
|
/* (enable paging, TLB, TLU) */
|
|
#define KVM_HCALL_APPLY_PSP_BOUNDS 17 /* update pending procedure */
|
|
/* stack pointers after stack */
|
|
/* bounds handling */
|
|
#define KVM_HCALL_APPLY_PCSP_BOUNDS 18 /* update pending chain */
|
|
/* stack pointers after stack */
|
|
/* bounds handling */
|
|
#define KVM_HCALL_CORRECT_TRAP_RETURN_IP 19 /* correct IP to return from */
|
|
/* guest trap */
|
|
#define KVM_HCALL_SWITCH_GUEST_KERNEL_STACKS 21 /* switch guest kernel thread */
|
|
/* to new stacks */
|
|
#define KVM_HCALL_COPY_GUEST_KERNEL_STACKS 22 /* copy guest kernel stacks */
|
|
/* for kernel thread creation */
|
|
#define KVM_HCALL_SWITCH_TO_GUEST_NEW_USER 28 /* end of execve() for guest */
|
|
/* switch to new user stacks */
|
|
/* start from user entry */
|
|
/* point */
|
|
#define KVM_HCALL_CLONE_GUEST_USER_STACKS 29 /* end of clone_user_stacks() */
|
|
/* create new process thread */
|
|
/* info agent on host and */
|
|
/* register guest kernel */
|
|
/* user local data stack */
|
|
#define KVM_HCALL_COPY_GUEST_USER_STACKS 30 /* end of clone_user_stacks() */
|
|
/* create new process thread */
|
|
/* info agent on host and */
|
|
/* register guest kernel */
|
|
/* user local data stack */
|
|
#define KVM_HCALL_UPDATE_HW_STACKS_FRAMES 36 /* update hardware stacks */
|
|
/* frames */
|
|
#define KVM_HCALL_PATCH_GUEST_DATA_AND_CHAIN_STACKS 38
|
|
/* patch guest kernel data */
|
|
/* chain stacks */
|
|
#define KVM_HCALL_COPY_HW_STACKS_FRAMES 39 /* copy guest hardware stacks */
|
|
/* (user<->kernel) on guest */
|
|
/* addresses */
|
|
#define KVM_HCALL_GET_GUEST_GLOB_REGS 40 /* get current state of */
|
|
/* global registers, except */
|
|
/* someones */
|
|
#define KVM_HCALL_SET_GUEST_GLOB_REGS 41 /* set current state of */
|
|
/* global registers, except */
|
|
/* someones */
|
|
#define KVM_HCALL_GET_GUEST_LOCAL_GLOB_REGS 42 /* get current state of */
|
|
/* local global registers */
|
|
#define KVM_HCALL_SET_GUEST_LOCAL_GLOB_REGS 43 /* set current state of */
|
|
/* local global registers */
|
|
#define KVM_HCALL_GET_ALL_GUEST_GLOB_REGS 44 /* get current state of all */
|
|
/* guest user global regs */
|
|
#define KVM_HCALL_BOOT_SPIN_LOCK_SLOW 47 /* slowpath of guest boot */
|
|
/* time spinlock locking */
|
|
#define KVM_HCALL_BOOT_SPIN_LOCKED_SLOW 48 /* slowpath of guest boot */
|
|
/* time spinlock locking */
|
|
/* is taken */
|
|
#define KVM_HCALL_BOOT_SPIN_UNLOCK_SLOW 49 /* slowpath of guest boot */
|
|
/* time spinlock unlocking */
|
|
#define KVM_HCALL_GUEST_SPIN_LOCK_SLOW 50 /* slowpath of guest spinlock */
|
|
/* locking */
|
|
#define KVM_HCALL_GUEST_SPIN_LOCKED_SLOW 51 /* slowpath of guest spinlock */
|
|
/* locking is taken */
|
|
#define KVM_HCALL_GUEST_SPIN_UNLOCK_SLOW 52 /* slowpath of guest spinlock */
|
|
/* unlocking */
|
|
#define KVM_HCALL_GUEST_CSD_LOCK_CTL 53 /* serialize access to */
|
|
/* per-cpu csd resources */
|
|
/* wait and wake up on host */
|
|
#define KVM_HCALL_GUEST_MM_DROP 63 /* drop host kernel agent */
|
|
/* for the guest process mm */
|
|
#define KVM_HCALL_ACTIVATE_GUEST_MM 64 /* activate host agent */
|
|
/* for the new guest mm */
|
|
#define KVM_HCALL_PT_ATOMIC_UPDATE 68 /* atomicaly update PT items */
|
|
#define KVM_HCALL_SWITCH_GUEST_MM 78 /* switch host agent to */
|
|
/* the next guest mm */
|
|
#define KVM_HCALL_VCPU_MMU_STATE 79 /* common hcall to control */
|
|
/* guest MMU state */
|
|
#define KVM_HCALL_GUEST_IOPORT_REQ 80 /* guest kernel IO ports */
|
|
/* in/out request */
|
|
#define KVM_HCALL_GUEST_IOPORT_STRING_REQ 81 /* guest kernel IO ports */
|
|
/* in/out string request */
|
|
#define KVM_HCALL_GUEST_MMIO_REQ 82 /* guest kernel MMIO */
|
|
/* read/write request */
|
|
#define KVM_HCALL_CONSOLE_IO 83 /* raw write/read to/from */
|
|
/* guest task console */
|
|
#define KVM_HCALL_NOTIFY_IO 84 /* notify host on IO request */
|
|
/* completion or starting */
|
|
#define KVM_HCALL_GUEST_INTR_HANDLER 85 /* create guest interrupt */
|
|
/* handler */
|
|
#define KVM_HCALL_GUEST_INTR_THREAD 86 /* create guest interrupt */
|
|
/* handler thread */
|
|
#define KVM_HCALL_GUEST_FREE_INTR_HANDLER 87 /* stop guest interrupt */
|
|
/* hansler thread */
|
|
#define KVM_HCALL_WAIT_FOR_VIRQ 88 /* wait for the VIRQ */
|
|
#define KVM_HCALL_GET_GUEST_DIRECT_VIRQ 90 /* register direct VIRQ */
|
|
#define KVM_HCALL_FREE_GUEST_DIRECT_VIRQ 91 /* free direct VIRQ */
|
|
#define KVM_HCALL_GUEST_VCPU_COMMON_IDLE 95 /* guest CPU on idle */
|
|
/* wait for some events on */
|
|
/* guest kernel */
|
|
#define KVM_HCALL_GUEST_VCPU_RELAX 96 /* guest VCPU is waiting for */
|
|
/* some event and relax real */
|
|
/* CPU to schedule other */
|
|
/* guest VCPU */
|
|
#define KVM_HCALL_ACTIVATE_GUEST_VCPU 97 /* activate the VCPU, which */
|
|
/* is waiting on idle mode */
|
|
#define KVM_HCALL_ACTIVATE_GUEST_ALL_VCPUS 98 /* activate all VCPUs, which */
|
|
/* is waiting on idle mode */
|
|
#define KVM_HCALL_RECOVERY_FAULTED_TAGGED_GUEST_STORE 110
|
|
/* recovery faulted store */
|
|
/* tagged value operations */
|
|
#define KVM_HCALL_RECOVERY_FAULTED_GUEST_LOAD 111
|
|
/* recovery faulted load */
|
|
/* value and tag */
|
|
#define KVM_HCALL_RECOVERY_FAULTED_GUEST_MOVE 112
|
|
/* recovery faulted move */
|
|
/* value and tag to register */
|
|
/* into procedure stack */
|
|
#define KVM_HCALL_RECOVERY_FAULTED_LOAD_TO_GUEST_GREG 113
|
|
/* recovery faulted load */
|
|
/* value and tag to global */
|
|
/* register */
|
|
#define KVM_HCALL_MOVE_TAGGED_GUEST_DATA 114 /* move data value from to */
|
|
#define KVM_HCALL_COPY_IN_USER_WITH_TAGS 115 /* tagged guest memory copy */
|
|
#define KVM_HCALL_FAST_TAGGED_MEMORY_COPY 117 /* fast tagged memory copy */
|
|
#define KVM_HCALL_FAST_TAGGED_MEMORY_SET 118 /* fast tagged memory set */
|
|
#define KVM_HCALL_SHUTDOWN 120 /* shutdown of guest */
|
|
#define KVM_HCALL_DUMP_GUEST_STACK 121 /* dump guest current stack */
|
|
#define KVM_HCALL_FTRACE_STOP 122 /* stop host's ftrace */
|
|
#define KVM_HCALL_FTRACE_DUMP 123 /* dump host's ftrace buffer */
|
|
#define KVM_HCALL_DUMP_COMPLETION 125 /* show state or dump all */
|
|
/* stacks is completed */
|
|
#define KVM_HCALL_FAST_TAGGED_MEMORY_COPY_USER 127 /* fast tagged memory copy */
|
|
/* to/from user */
|
|
#define KVM_HCALL_FAST_TAGGED_MEMORY_SET_USER 128 /* fast tagged memory set */
|
|
/* at user */
|
|
|
|
#define KVM_HCALL_HOST_PRINTK 130 /* guest printk() on host */
|
|
#define KVM_HCALL_PRINT_GUEST_KERNEL_PTES 131 /* dump guest kernel address */
|
|
/* page table entries */
|
|
#define KVM_HCALL_PRINT_GUEST_USER_ADDRESS_PTES 132 /* dump guest user */
|
|
/* address ptes on host */
|
|
#ifdef CONFIG_KVM_ASYNC_PF
|
|
#define KVM_HCALL_PV_ENABLE_ASYNC_PF 133 /* enable async pf */
|
|
/* on current vcpu */
|
|
#endif /* CONFIG_KVM_ASYNC_PF */
|
|
#define KVM_HCALL_MMU_PV_FLUSH_TLB 134 /* sync host's shadow PTs */
|
|
/* and flush tlb */
|
|
#define KVM_HCALL_SYNC_ADDR_RANGE 135 /* sync host's shadow PTs */
|
|
/* without flushing tlb */
|
|
#define KVM_HCALL_GET_SPT_TRANSLATION 137 /* get full translation of guest */
|
|
/* address at shadow PTs */
|
|
#define KVM_HCALL_RECOVERY_FAULTED_TAGGED_STORE 141
|
|
/* recovery faulted store */
|
|
/* tagged value operations */
|
|
#define KVM_HCALL_RECOVERY_FAULTED_LOAD 142 /* recovery faulted load */
|
|
/* value and tag */
|
|
#define KVM_HCALL_RECOVERY_FAULTED_MOVE 143
|
|
/* recovery faulted move */
|
|
/* value and tag to register */
|
|
/* into procedure stack */
|
|
#define KVM_HCALL_RECOVERY_FAULTED_LOAD_TO_GREG 144
|
|
/* recovery faulted load */
|
|
/* value and tag to global */
|
|
/* register */
|
|
#define KVM_HCALL_PREPARE_MKCTXT_HW_USER_STACKS 145
|
|
|
|
#define KVM_HCALL_ADD_CTX_SIGNAL_STACK 146
|
|
/* create separate */
|
|
/* signal stack for context */
|
|
/* on host side */
|
|
#define KVM_HCALL_REMOVE_CTX_SIGNAL_STACK 147
|
|
/* remove signal stack for */
|
|
/* context on host side */
|
|
|
|
|
|
/*
|
|
* KVM hypervisor (host) <-> guest hypercalls structures
|
|
*/
|
|
|
|
/* process and threads management */
|
|
typedef struct kvm_task_info {
|
|
unsigned long flags; /* various task flags see header */
|
|
/* asm/processor.h */
|
|
unsigned long us_base; /* local data (user) stack base */
|
|
unsigned long us_size; /* local data (user) stack size */
|
|
unsigned long sp_offset; /* offset of local data stack pointer */
|
|
/* SP from stack base */
|
|
unsigned long ps_base; /* Procedure stack: base, */
|
|
unsigned long ps_size; /* Procedure stack current: size, */
|
|
unsigned long ps_ind; /* index */
|
|
|
|
/* should be unsed { */
|
|
unsigned long ps_offset; /* current base offset, */
|
|
unsigned long ps_top; /* current top, */
|
|
unsigned long us_ps_size; /* user part of stack total size */
|
|
unsigned long init_ps_size; /* and initial size. */
|
|
unsigned long g_ps_size; /* guest kernel part of stack size, */
|
|
unsigned long ps_reserved; /* current reserved size of guest */
|
|
/* kernel */
|
|
/* } should be unsed */
|
|
|
|
unsigned long pcs_base; /* Procedure chain stack: base, */
|
|
unsigned long pcs_size; /* Chain stack current: size, */
|
|
unsigned long pcs_ind; /* index */
|
|
|
|
/* should be unsed { */
|
|
unsigned long pcs_offset; /* current base offset, */
|
|
unsigned long pcs_top; /* current top, */
|
|
unsigned long us_pcs_size; /* user part of stack total size */
|
|
unsigned long init_pcs_size; /* and initial size. */
|
|
unsigned long g_pcs_size; /* guest kernel part of stack size, */
|
|
unsigned long pcs_reserved; /* current reserved size of guest */
|
|
/* kernel part */
|
|
/* } should be unsed */
|
|
|
|
/* new: guest user stacks */
|
|
unsigned long u_us_base; /* local data (user) stack base */
|
|
unsigned long u_us_size; /* local data (user) stack size */
|
|
unsigned long u_sp_offset; /* offset of local data stack pointer */
|
|
/* SP from stack base */
|
|
unsigned long u_ps_base; /* Procedure stack: base, */
|
|
unsigned long u_ps_size; /* Procedure stack current: size, */
|
|
unsigned long u_ps_ind; /* index */
|
|
unsigned long u_pcs_base; /* Procedure chain stack: base, */
|
|
unsigned long u_pcs_size; /* Chain stack current: size, */
|
|
unsigned long u_pcs_ind; /* index */
|
|
|
|
unsigned long cr0_lo; /* Chain iregister #0 lo */
|
|
unsigned long cr0_hi; /* Chain iregister #0 hi */
|
|
unsigned long cr1_wd; /* Chain register which contains wbs */
|
|
unsigned long cr1_ussz; /* Chain register which contains */
|
|
/* user stack size */
|
|
unsigned long cud_base; /* OSCUD: base */
|
|
unsigned long cud_size; /* and size */
|
|
unsigned long gd_base; /* OSGD: base */
|
|
unsigned long gd_size; /* and size */
|
|
unsigned long cut_base; /* CUTD: base */
|
|
unsigned long cut_size; /* and size */
|
|
int cui; /* compilation unit index of code */
|
|
bool kernel; /* task in kernel mode */
|
|
unsigned long entry_point; /* entry point (address) of task */
|
|
unsigned long gregs; /* pointer to the global registers */
|
|
/* state of the new process */
|
|
} kvm_task_info_t;
|
|
|
|
/* hardware stack extention, update and change */
|
|
typedef struct kvm_hw_stack {
|
|
unsigned long flags; /* various task flags see header */
|
|
/* asm/processor.h */
|
|
unsigned long base; /* Procedure stack: base, */
|
|
unsigned long offset; /* current base offset, */
|
|
unsigned long top; /* current top, */
|
|
unsigned long us_size; /* user part of stack total size */
|
|
unsigned long size; /* Procedure stack current: size, */
|
|
unsigned long delta_ind; /* delta of index */
|
|
unsigned long reserved; /* current reserved size of guest */
|
|
/* kernel */
|
|
} kvm_hw_stack_t;
|
|
|
|
/* signal and signal handler management */
|
|
typedef struct kvm_sig_info {
|
|
int sig; /* signal # */
|
|
unsigned int protected; /* task is protected */
|
|
void *siginfo; /* siginfo structure pointer */
|
|
void *ucontext; /* ucontext structure pointer */
|
|
int si_size; /* size of siginfo structure */
|
|
int uc_size; /* size of ucontext structure */
|
|
unsigned long handler; /* user handler function entry point */
|
|
unsigned long sbr; /* user data stack */
|
|
unsigned long usd_lo; /* to handle */
|
|
unsigned long usd_hi; /* the signal */
|
|
} kvm_sig_info_t;
|
|
|
|
typedef struct kvm_stacks_info {
|
|
unsigned long top; /* top address (same as SBR pointer) */
|
|
unsigned long usd_lo; /* curent state of stack pointer */
|
|
unsigned long usd_hi; /* register: base & size */
|
|
unsigned long psp_lo; /* Procedure stack pointer: */
|
|
unsigned long psp_hi; /* base & index & size */
|
|
unsigned long pshtp;
|
|
unsigned long pcsp_lo; /* Procedure chain stack */
|
|
unsigned long pcsp_hi; /* pointer: base & index & size */
|
|
unsigned pcshtp;
|
|
unsigned long cr0_lo;
|
|
unsigned long cr0_hi;
|
|
unsigned long cr1_lo;
|
|
unsigned long cr1_hi;
|
|
} kvm_stacks_info_t;
|
|
typedef kvm_stacks_info_t kvm_long_jump_info_t;
|
|
|
|
/* guest kernel local data stack pointers update */
|
|
typedef struct kvm_data_stack_info {
|
|
bool protected; /* protected stack flag */
|
|
unsigned long top; /* top of the stack (register SBR) */
|
|
unsigned long usd_base; /* USD pointer: base */
|
|
unsigned long usd_size; /* size */
|
|
unsigned long usd_ind; /* index (only for protected stack) */
|
|
} kvm_data_stack_info_t;
|
|
|
|
/* patch of fields od chain stack registers to update */
|
|
typedef struct kvm_pcs_patch_info {
|
|
unsigned int ind; /* index of frame in bytes and */
|
|
/* relative PCS base: */
|
|
/* PCS_base + PCS_offset + PCSP.ind */
|
|
unsigned int update_flags; /* flags of updated fields */
|
|
/* see below */
|
|
unsigned long IP; /* new IP [63:0] */
|
|
unsigned int usd_size; /* data stack size in bytes */
|
|
/* to calculate ussz fields */
|
|
unsigned short wbs; /* quad registers number */
|
|
unsigned short wpsz; /* quad registers number */
|
|
} kvm_pcs_patch_info_t;
|
|
|
|
/* chain stack registers updating flags (see structure above) */
|
|
#define KVM_PCS_IP_UPDATE_FLAG 0x00000001
|
|
#define KVM_PCS_USSZ_UPDATE_FLAG 0x00000100
|
|
#define KVM_PCS_WBS_UPDATE_FLAG 0x00001000
|
|
#define KVM_PCS_WPSZ_UPDATE_FLAG 0x00002000
|
|
|
|
#define KVM_MAX_PCS_FRAME_NUM_TO_PATCH 4 /* max number of chain stack */
|
|
/* frames to can update */
|
|
/* at once */
|
|
|
|
/* hardware stacks updating interface */
|
|
#define KVM_MAX_PS_FRAME_NUM_TO_UPDATE 2 /* max number of procedure */
|
|
/* stack frame to can update */
|
|
/* one frame is 2 double-word */
|
|
/* registers with extentions */
|
|
#define KVM_MAX_PS_FRAME_SIZE_TO_UPDATE \
|
|
(KVM_MAX_PS_FRAME_NUM_TO_UPDATE * EXT_4_NR_SZ)
|
|
|
|
/*
|
|
* Common hypercal to get/set/control guest MMU state
|
|
*/
|
|
|
|
/* flags of operations on guest MMU */
|
|
#define INIT_STATE_GMMU_OPC 0x00000001UL
|
|
#define SET_OS_VAB_GMMU_OPC 0x00000010UL
|
|
#define CREATE_NEW_GMM_GMMU_OPC 0x00000100UL
|
|
|
|
typedef struct vcpu_gmmu_info {
|
|
unsigned long opcode; /* operations on guest MMU */
|
|
/* (see above) */
|
|
bool sep_virt_space; /* guest use separate PTs for */
|
|
/* OS and user virtual spaces */
|
|
bool pt_v6; /* guest PTs are of v6 format */
|
|
e2k_mmu_cr_t mmu_cr; /* MMU control register */
|
|
unsigned long pid; /* MMU PID (context) register */
|
|
unsigned long trap_cellar; /* MMU trap cellar base */
|
|
unsigned long u_pptb; /* physical base of user (for */
|
|
/* separate PT mode) or united PT */
|
|
unsigned long u_vptb; /* virtual base of user (for */
|
|
/* separate PT mode) or united PT */
|
|
unsigned long os_pptb; /* physical base of kernel PT */
|
|
/* (only for separate PT mode) */
|
|
unsigned long os_vptb; /* virtual base of kernel PT */
|
|
/* (only for separate PT mode) */
|
|
unsigned long os_vab; /* offset of kernel virtual space */
|
|
/* into common virtual addresses */
|
|
/* range */
|
|
unsigned long gmmid_nr; /* return to guest: ID (#) of host */
|
|
/* gmm struct created for new guest */
|
|
/* mm struct */
|
|
} vcpu_gmmu_info_t;
|
|
|
|
static inline void HYPERVISOR_pv_wait(void)
|
|
{
|
|
generic_hypercall0(KVM_HCALL_PV_WAIT);
|
|
}
|
|
|
|
static inline void HYPERVISOR_pv_kick(int cpu)
|
|
{
|
|
generic_hypercall1(KVM_HCALL_PV_KICK, cpu);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_release_task_struct(int gpid_nr)
|
|
{
|
|
return generic_hypercall1(KVM_HCALL_RELEASE_TASK_STRUCT, (long)gpid_nr);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_set_clockevent(unsigned long delta)
|
|
{
|
|
return generic_hypercall1(KVM_HCALL_SET_CLOCKEVENT, delta);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_complete_long_jump(kvm_long_jump_info_t *regs_state,
|
|
bool switch_stack, u64 to_key)
|
|
{
|
|
return generic_hypercall3(KVM_HCALL_COMPLETE_LONG_JUMP,
|
|
(unsigned long)regs_state,
|
|
(unsigned long)switch_stack,
|
|
(unsigned long)to_key);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_launch_sig_handler(kvm_stacks_info_t *regs_state,
|
|
unsigned long sigreturn_entry, long sys_rval)
|
|
{
|
|
return generic_hypercall3(KVM_HCALL_LAUNCH_SIG_HANDLER,
|
|
(unsigned long)regs_state, sigreturn_entry, sys_rval);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_apply_psp_bounds(unsigned long base, unsigned long size,
|
|
unsigned long start, unsigned long end, unsigned long delta)
|
|
{
|
|
return generic_hypercall5(KVM_HCALL_APPLY_PSP_BOUNDS,
|
|
base, size, start, end, delta);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_apply_pcsp_bounds(unsigned long base, unsigned long size,
|
|
unsigned long start, unsigned long end, unsigned long delta)
|
|
{
|
|
return generic_hypercall5(KVM_HCALL_APPLY_PCSP_BOUNDS,
|
|
base, size, start, end, delta);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_apply_usd_bounds(unsigned long top, unsigned long delta, bool incr)
|
|
{
|
|
return generic_hypercall3(KVM_HCALL_APPLY_USD_BOUNDS,
|
|
top, delta, incr);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_correct_trap_return_ip(unsigned long return_ip)
|
|
{
|
|
return generic_hypercall1(KVM_HCALL_CORRECT_TRAP_RETURN_IP, return_ip);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_guest_intr_handler(int irq, int virq_id,
|
|
int (*irq_handler)(int, void *), void *arg)
|
|
{
|
|
return generic_hypercall4(KVM_HCALL_GUEST_INTR_HANDLER, irq, virq_id,
|
|
(unsigned long)irq_handler,
|
|
(unsigned long)arg);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_guest_intr_thread(int vcpu_id, int irq, int virq_id, int gpid_nr,
|
|
int (*irq_fn)(int, void *), void *arg)
|
|
{
|
|
return generic_hypercall6(KVM_HCALL_GUEST_INTR_THREAD,
|
|
vcpu_id, irq, virq_id,
|
|
gpid_nr, (unsigned long)irq_fn,
|
|
(unsigned long)arg);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_guest_free_intr_handler(int irq, void *arg)
|
|
{
|
|
return generic_hypercall2(KVM_HCALL_GUEST_FREE_INTR_HANDLER, irq,
|
|
(unsigned long)arg);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_get_guest_direct_virq(int irq, int virq_id)
|
|
{
|
|
return generic_hypercall2(KVM_HCALL_GET_GUEST_DIRECT_VIRQ,
|
|
irq, virq_id);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_free_guest_direct_virq(int irq)
|
|
{
|
|
return generic_hypercall1(KVM_HCALL_FREE_GUEST_DIRECT_VIRQ, irq);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_switch_to_virt_mode(kvm_task_info_t *task_info,
|
|
void (*func)(void *data, void *arg1, void *arg2),
|
|
void *data, void *arg1, void *arg2)
|
|
{
|
|
return generic_hypercall5(KVM_HCALL_SWITCH_TO_VIRT_MODE,
|
|
(unsigned long)task_info,
|
|
(unsigned long)func,
|
|
(unsigned long)data,
|
|
(unsigned long)arg1,
|
|
(unsigned long)arg2);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_switch_guest_kernel_stacks(kvm_task_info_t *task_info,
|
|
char *entry_point, unsigned long *args, int args_num)
|
|
{
|
|
return generic_hypercall4(KVM_HCALL_SWITCH_GUEST_KERNEL_STACKS,
|
|
(unsigned long)task_info, (unsigned long)entry_point,
|
|
(unsigned long)args, (unsigned long)args_num);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_update_hw_stacks_frames(e2k_mem_crs_t *pcs_frame, int pcs_frame_ind,
|
|
kernel_mem_ps_t *ps_frame, int ps_frame_ind, int ps_frame_size)
|
|
{
|
|
return generic_hypercall5(KVM_HCALL_UPDATE_HW_STACKS_FRAMES,
|
|
(unsigned long)pcs_frame,
|
|
pcs_frame_ind,
|
|
(unsigned long)ps_frame,
|
|
ps_frame_ind, ps_frame_size);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_copy_hw_stacks_frames(void __user *dst, void __user *src,
|
|
long size, bool is_chain)
|
|
{
|
|
return generic_hypercall4(KVM_HCALL_COPY_HW_STACKS_FRAMES,
|
|
(unsigned long)dst, (unsigned long)src, size, is_chain);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_copy_guest_kernel_stacks(kvm_task_info_t *task_info)
|
|
{
|
|
return generic_hypercall1(KVM_HCALL_COPY_GUEST_KERNEL_STACKS,
|
|
(unsigned long)task_info);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_switch_to_guest_new_user(kvm_task_info_t *task_info)
|
|
{
|
|
return generic_hypercall1(KVM_HCALL_SWITCH_TO_GUEST_NEW_USER,
|
|
(unsigned long)task_info);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_clone_guest_user_stacks(kvm_task_info_t *task_info)
|
|
{
|
|
return generic_hypercall1(KVM_HCALL_CLONE_GUEST_USER_STACKS,
|
|
(unsigned long)task_info);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_copy_guest_user_stacks(kvm_task_info_t *task_info,
|
|
vcpu_gmmu_info_t *gmmu_info)
|
|
{
|
|
return generic_hypercall2(KVM_HCALL_COPY_GUEST_USER_STACKS,
|
|
(unsigned long)task_info, (unsigned long)gmmu_info);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_patch_guest_data_and_chain_stacks(kvm_data_stack_info_t *ds_patch,
|
|
kvm_pcs_patch_info_t pcs_patch[], int pcs_frames)
|
|
{
|
|
return generic_hypercall3(KVM_HCALL_PATCH_GUEST_DATA_AND_CHAIN_STACKS,
|
|
(unsigned long)ds_patch,
|
|
(unsigned long)pcs_patch, pcs_frames);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_get_guest_glob_regs(unsigned long *gregs[2],
|
|
unsigned long not_get_gregs_mask,
|
|
bool dirty_bgr, unsigned int *bgr)
|
|
{
|
|
return generic_hypercall4(KVM_HCALL_GET_GUEST_GLOB_REGS,
|
|
(unsigned long)gregs, not_get_gregs_mask,
|
|
(unsigned long)dirty_bgr, (unsigned long)bgr);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_set_guest_glob_regs(unsigned long *gregs[2],
|
|
unsigned long not_set_gregs_mask,
|
|
bool dirty_bgr, unsigned int *bgr)
|
|
{
|
|
return generic_hypercall4(KVM_HCALL_SET_GUEST_GLOB_REGS,
|
|
(unsigned long)gregs, not_set_gregs_mask,
|
|
(unsigned long)dirty_bgr, (unsigned long)bgr);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_set_guest_glob_regs_dirty_bgr(unsigned long *gregs[2],
|
|
unsigned long not_set_gregs_mask)
|
|
{
|
|
return generic_hypercall4(KVM_HCALL_SET_GUEST_GLOB_REGS,
|
|
(unsigned long)gregs, not_set_gregs_mask,
|
|
(unsigned long)false, (unsigned long)NULL);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_get_guest_local_glob_regs(unsigned long *l_gregs[2], bool is_signal)
|
|
{
|
|
return generic_hypercall2(KVM_HCALL_GET_GUEST_LOCAL_GLOB_REGS,
|
|
(unsigned long)l_gregs, is_signal);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_set_guest_local_glob_regs(unsigned long *l_gregs[2], bool is_signal)
|
|
{
|
|
return generic_hypercall2(KVM_HCALL_SET_GUEST_LOCAL_GLOB_REGS,
|
|
(unsigned long)l_gregs, is_signal);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_get_all_guest_glob_regs(unsigned long *gregs[2])
|
|
{
|
|
return generic_hypercall1(KVM_HCALL_GET_ALL_GUEST_GLOB_REGS,
|
|
(unsigned long)gregs);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_recovery_faulted_tagged_guest_store(e2k_addr_t address, u64 wr_data,
|
|
u32 data_tag, u64 st_rec_opc, u64 data_ext, u32 data_ext_tag,
|
|
u64 opc_ext, int chan, int qp_store, int atomic_store)
|
|
{
|
|
union recovery_faulted_arg arg = {
|
|
.chan = chan,
|
|
.qp = !!qp_store,
|
|
.atomic = !!atomic_store,
|
|
.tag = data_tag,
|
|
.tag_ext = data_ext_tag
|
|
};
|
|
return generic_hypercall6(KVM_HCALL_RECOVERY_FAULTED_TAGGED_GUEST_STORE,
|
|
address, wr_data, st_rec_opc, data_ext, opc_ext,
|
|
arg.entire);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_recovery_faulted_guest_load(e2k_addr_t address,
|
|
u64 *ld_val, u8 *data_tag, u64 ld_rec_opc, int chan)
|
|
{
|
|
return generic_hypercall5(KVM_HCALL_RECOVERY_FAULTED_GUEST_LOAD,
|
|
address, (unsigned long)ld_val,
|
|
(unsigned long)data_tag, ld_rec_opc, chan);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_recovery_faulted_guest_move(e2k_addr_t addr_from, e2k_addr_t addr_to,
|
|
e2k_addr_t addr_to_hi, int vr, u64 ld_rec_opc, int chan,
|
|
int qp_load, int atomic_load, u32 first_time)
|
|
{
|
|
union recovery_faulted_arg arg = {
|
|
.vr = vr,
|
|
.chan = chan,
|
|
.qp = !!qp_load,
|
|
.atomic = !!atomic_load
|
|
};
|
|
return generic_hypercall6(KVM_HCALL_RECOVERY_FAULTED_GUEST_MOVE,
|
|
addr_from, addr_to, addr_to_hi,
|
|
ld_rec_opc, arg.entire, first_time);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_recovery_faulted_load_to_guest_greg(e2k_addr_t address,
|
|
u32 greg_num_d, int vr, u64 ld_rec_opc, int chan,
|
|
int qp_load, int atomic_load,
|
|
void *saved_greg_lo, void *saved_greg_hi)
|
|
{
|
|
union recovery_faulted_arg arg = {
|
|
.vr = vr,
|
|
.chan = chan,
|
|
.qp = !!qp_load,
|
|
.atomic = !!atomic_load
|
|
};
|
|
return generic_hypercall6(KVM_HCALL_RECOVERY_FAULTED_LOAD_TO_GUEST_GREG,
|
|
address, greg_num_d, ld_rec_opc, arg.entire,
|
|
(unsigned long) saved_greg_lo,
|
|
(unsigned long) saved_greg_hi);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_recovery_faulted_tagged_store(e2k_addr_t address, u64 wr_data,
|
|
u32 data_tag, u64 st_rec_opc, u64 data_ext, u32 data_ext_tag,
|
|
u64 opc_ext, int chan, int qp_store, int atomic_store)
|
|
{
|
|
union recovery_faulted_arg arg = {
|
|
.chan = chan,
|
|
.qp = !!qp_store,
|
|
.atomic = !!atomic_store,
|
|
.tag = data_tag,
|
|
.tag_ext = data_ext_tag
|
|
};
|
|
return generic_hypercall6(KVM_HCALL_RECOVERY_FAULTED_TAGGED_STORE,
|
|
address, wr_data, st_rec_opc, data_ext, opc_ext,
|
|
arg.entire);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_recovery_faulted_load(e2k_addr_t address, u64 *ld_val,
|
|
u8 *data_tag, u64 ld_rec_opc, int chan)
|
|
{
|
|
return generic_hypercall5(KVM_HCALL_RECOVERY_FAULTED_LOAD,
|
|
address, (unsigned long)ld_val,
|
|
(unsigned long)data_tag, ld_rec_opc, chan);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_recovery_faulted_move(e2k_addr_t addr_from, e2k_addr_t addr_to,
|
|
e2k_addr_t addr_to_hi, int vr, u64 ld_rec_opc, int chan,
|
|
int qp_load, int atomic_load, u32 first_time)
|
|
{
|
|
union recovery_faulted_arg arg = {
|
|
.vr = vr,
|
|
.chan = chan,
|
|
.qp = !!qp_load,
|
|
.atomic = !!atomic_load
|
|
};
|
|
return generic_hypercall6(KVM_HCALL_RECOVERY_FAULTED_MOVE,
|
|
addr_from, addr_to, addr_to_hi,
|
|
ld_rec_opc, arg.entire, first_time);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_recovery_faulted_load_to_greg(e2k_addr_t address, u32 greg_num_d,
|
|
int vr, u64 ld_rec_opc, int chan, int qp_load,
|
|
int atomic_load, void *saved_greg_lo, void *saved_greg_hi)
|
|
{
|
|
union recovery_faulted_arg arg = {
|
|
.vr = vr,
|
|
.chan = chan,
|
|
.qp = !!qp_load,
|
|
.atomic = !!atomic_load
|
|
};
|
|
return generic_hypercall6(KVM_HCALL_RECOVERY_FAULTED_LOAD_TO_GREG,
|
|
address, greg_num_d, ld_rec_opc, arg.entire,
|
|
(unsigned long)saved_greg_lo,
|
|
(unsigned long)saved_greg_hi);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_move_tagged_guest_data(int word_size,
|
|
e2k_addr_t addr_from, e2k_addr_t addr_to)
|
|
{
|
|
return generic_hypercall3(KVM_HCALL_MOVE_TAGGED_GUEST_DATA,
|
|
word_size, addr_from, addr_to);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_copy_in_user_with_tags(void __user *dst, const void __user *src,
|
|
unsigned long size)
|
|
{
|
|
return generic_hypercall3(KVM_HCALL_COPY_IN_USER_WITH_TAGS,
|
|
(unsigned long)dst, (unsigned long)src, size);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_boot_spin_lock_slow(void *lock, bool check_unlock)
|
|
{
|
|
return generic_hypercall2(KVM_HCALL_BOOT_SPIN_LOCK_SLOW,
|
|
(unsigned long)lock,
|
|
(unsigned long)check_unlock);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_boot_spin_locked_slow(void *lock)
|
|
{
|
|
return generic_hypercall1(KVM_HCALL_BOOT_SPIN_LOCKED_SLOW,
|
|
(unsigned long)lock);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_boot_spin_unlock_slow(void *lock, bool add_to_unlock)
|
|
{
|
|
return generic_hypercall2(KVM_HCALL_BOOT_SPIN_UNLOCK_SLOW,
|
|
(unsigned long)lock,
|
|
(unsigned long)add_to_unlock);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_guest_spin_lock_slow(void *lock, bool check_unlock)
|
|
{
|
|
return generic_hypercall2(KVM_HCALL_GUEST_SPIN_LOCK_SLOW,
|
|
(unsigned long)lock,
|
|
(unsigned long)check_unlock);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_guest_spin_locked_slow(void *lock)
|
|
{
|
|
return generic_hypercall1(KVM_HCALL_GUEST_SPIN_LOCKED_SLOW,
|
|
(unsigned long)lock);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_guest_spin_unlock_slow(void *lock, bool add_to_unlock)
|
|
{
|
|
return generic_hypercall2(KVM_HCALL_GUEST_SPIN_UNLOCK_SLOW,
|
|
(unsigned long)lock,
|
|
(unsigned long)add_to_unlock);
|
|
}
|
|
|
|
typedef enum csd_ctl {
|
|
CSD_LOCK_CTL = 1, /* register csd lock wait */
|
|
CSD_UNLOCK_CTL, /* unlock csd lock wait and wake up */
|
|
/* waiting guest VCPU */
|
|
CSD_LOCK_WAIT_CTL, /* wait for csd lock will be unlocked */
|
|
CSD_LOCK_TRY_WAIT_CTL, /* try wait for asynchronous csd lock */
|
|
} csd_ctl_t;
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_guest_csd_lock_ctl(csd_ctl_t csd_ctl, void *lock)
|
|
{
|
|
return generic_hypercall2(KVM_HCALL_GUEST_CSD_LOCK_CTL,
|
|
(unsigned long)csd_ctl,
|
|
(unsigned long)lock);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_guest_csd_lock(void *lock)
|
|
{
|
|
return HYPERVISOR_guest_csd_lock_ctl(CSD_LOCK_CTL, lock);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_guest_csd_unlock(void *lock)
|
|
{
|
|
return HYPERVISOR_guest_csd_lock_ctl(CSD_UNLOCK_CTL, lock);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_guest_csd_lock_wait(void *lock)
|
|
{
|
|
return HYPERVISOR_guest_csd_lock_ctl(CSD_LOCK_WAIT_CTL, lock);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_guest_csd_lock_try_wait(void *lock)
|
|
{
|
|
return HYPERVISOR_guest_csd_lock_ctl(CSD_LOCK_TRY_WAIT_CTL, lock);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_pt_atomic_update(int gmmid_nr, unsigned long gpa,
|
|
void __user *old_gpte,
|
|
unsigned atomic_op, unsigned long prot_mask)
|
|
{
|
|
return generic_hypercall5(KVM_HCALL_PT_ATOMIC_UPDATE, (int)gmmid_nr,
|
|
gpa, (unsigned long)old_gpte, atomic_op, prot_mask);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_kvm_guest_mm_drop(unsigned long gmmid_nr)
|
|
{
|
|
return generic_hypercall1(KVM_HCALL_GUEST_MM_DROP, gmmid_nr);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_kvm_activate_guest_mm(unsigned long active_gmmid_nr,
|
|
unsigned long gmmid_nr, e2k_addr_t u_phys_ptb)
|
|
{
|
|
return generic_hypercall3(KVM_HCALL_ACTIVATE_GUEST_MM,
|
|
active_gmmid_nr, gmmid_nr, u_phys_ptb);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_kvm_switch_guest_mm(unsigned long gpid_nr, unsigned long gmmid_nr,
|
|
e2k_addr_t u_phys_ptb)
|
|
{
|
|
return generic_hypercall3(KVM_HCALL_SWITCH_GUEST_MM,
|
|
gpid_nr, gmmid_nr, u_phys_ptb);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_vcpu_guest_mmu_state(vcpu_gmmu_info_t *mmu_info)
|
|
{
|
|
return generic_hypercall1(KVM_HCALL_VCPU_MMU_STATE,
|
|
(unsigned long)mmu_info);
|
|
}
|
|
|
|
/* guest kernel memory attribytes to set/update */
|
|
typedef enum kvm_sma_mode {
|
|
KVM_SMA_RO,
|
|
KVM_SMA_RW,
|
|
KVM_SMA_NX,
|
|
KVM_SMA_X,
|
|
KVM_SMA_P,
|
|
KVM_SMA_NP,
|
|
} kvm_sma_mode_t;
|
|
|
|
/*
|
|
* IO control hypercalls
|
|
*/
|
|
|
|
/*
|
|
* Commands to HYPERVISOR_console_io().
|
|
*/
|
|
#define CONSOLEIO_write 0
|
|
#define CONSOLEIO_read 1
|
|
|
|
/*
|
|
* Some hypercalls return value
|
|
*/
|
|
#define RETURN_TO_HOST_APP_HCRET \
|
|
(((u64)'r' << 56) | ((u64)'e' << 48) | \
|
|
((u64)'t' << 40) | ((u64)'2' << 32) | \
|
|
((u64)'h' << 24) | ((u64)'o' << 16) | \
|
|
((u64)'s' << 8) | ((u64)'t' << 0))
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_guest_ioport_request(unsigned short port,
|
|
unsigned int __user *data, unsigned char size,
|
|
unsigned char is_out)
|
|
{
|
|
return generic_hypercall4(KVM_HCALL_GUEST_IOPORT_REQ, port,
|
|
(unsigned long)data,
|
|
size, is_out);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_guest_ioport_string_request(unsigned short port,
|
|
const void __user *data, unsigned char size, unsigned int count,
|
|
unsigned char is_out)
|
|
{
|
|
return generic_hypercall5(KVM_HCALL_GUEST_IOPORT_STRING_REQ, port,
|
|
(unsigned long)data,
|
|
size, count, is_out);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_guest_mmio_request(unsigned long mmio_addr,
|
|
unsigned long __user *data, unsigned char size,
|
|
unsigned char is_write)
|
|
{
|
|
return generic_hypercall4(KVM_HCALL_GUEST_MMIO_REQ, mmio_addr,
|
|
(unsigned long)data,
|
|
size, is_write);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_console_io(int io_cmd, int size, char __user *str)
|
|
{
|
|
return generic_hypercall3(KVM_HCALL_CONSOLE_IO, io_cmd, size,
|
|
(unsigned long)str);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_notify_io(unsigned int notifier_io)
|
|
{
|
|
return generic_hypercall1(KVM_HCALL_NOTIFY_IO, notifier_io);
|
|
}
|
|
|
|
/*
|
|
* Kernel VM shut-down and panicking reason
|
|
*/
|
|
#define KVM_SHUTDOWN_POWEROFF 0x01
|
|
#define KVM_SHUTDOWN_RESTART 0x02
|
|
#define KVM_SHUTDOWN_PANIC 0x03
|
|
|
|
extern void smp_send_refresh(void);
|
|
static inline unsigned long
|
|
HYPERVISOR_kvm_shutdown(void *msg, unsigned long reason)
|
|
{
|
|
#ifdef CONFIG_SMP
|
|
smp_send_refresh();
|
|
#endif
|
|
return generic_hypercall2(KVM_HCALL_SHUTDOWN, (unsigned long)msg,
|
|
reason);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_kvm_guest_vcpu_common_idle(long timeout, bool interruptable)
|
|
{
|
|
return generic_hypercall2(KVM_HCALL_GUEST_VCPU_COMMON_IDLE,
|
|
timeout, interruptable);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_kvm_guest_vcpu_relax(void)
|
|
{
|
|
return generic_hypercall0(KVM_HCALL_GUEST_VCPU_RELAX);
|
|
}
|
|
#ifdef CONFIG_SMP
|
|
static inline unsigned long
|
|
HYPERVISOR_kvm_activate_guest_vcpu(int vcpu_id)
|
|
{
|
|
return generic_hypercall1(KVM_HCALL_ACTIVATE_GUEST_VCPU, vcpu_id);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_kvm_activate_guest_all_vcpus(void)
|
|
{
|
|
return generic_hypercall0(KVM_HCALL_ACTIVATE_GUEST_ALL_VCPUS);
|
|
}
|
|
#endif /* CONFIG_SMP */
|
|
static inline unsigned long
|
|
HYPERVISOR_host_printk(char *msg, int size)
|
|
{
|
|
return generic_hypercall2(KVM_HCALL_HOST_PRINTK, (unsigned long)msg,
|
|
(unsigned long)size);
|
|
}
|
|
|
|
/*
|
|
* The guest virtual address info of full track of translation
|
|
* at the host shadow PTs
|
|
*/
|
|
|
|
typedef struct mmu_spt_trans {
|
|
int pt_levels; /* the last significant level of PT */
|
|
unsigned long pgd;
|
|
unsigned long pud;
|
|
unsigned long pmd;
|
|
unsigned long pte;
|
|
} mmu_spt_trans_t;
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_get_spt_translation(e2k_addr_t address,
|
|
mmu_spt_trans_t __user *trans_info)
|
|
{
|
|
return generic_hypercall2(KVM_HCALL_GET_SPT_TRANSLATION, address,
|
|
(unsigned long)trans_info);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_print_guest_kernel_ptes(e2k_addr_t address)
|
|
{
|
|
return generic_hypercall1(KVM_HCALL_PRINT_GUEST_KERNEL_PTES, address);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_print_guest_user_address_ptes(int gmmid_nr, e2k_addr_t address)
|
|
{
|
|
return generic_hypercall2(KVM_HCALL_PRINT_GUEST_USER_ADDRESS_PTES,
|
|
gmmid_nr, address);
|
|
}
|
|
static inline void
|
|
HYPERVISOR_dump_guest_stack(void)
|
|
{
|
|
generic_hypercall0(KVM_HCALL_DUMP_GUEST_STACK);
|
|
}
|
|
static inline void
|
|
HYPERVISOR_ftrace_stop(void)
|
|
{
|
|
generic_hypercall0(KVM_HCALL_FTRACE_STOP);
|
|
}
|
|
static inline void
|
|
HYPERVISOR_ftrace_dump(void)
|
|
{
|
|
generic_hypercall0(KVM_HCALL_FTRACE_DUMP);
|
|
}
|
|
static inline void
|
|
HYPERVISOR_vcpu_show_state_completion(void)
|
|
{
|
|
generic_hypercall0(KVM_HCALL_DUMP_COMPLETION);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_fast_tagged_memory_copy(void *dst, const void *src, size_t len,
|
|
unsigned long strd_opcode, unsigned long ldrd_opcode,
|
|
int prefetch)
|
|
{
|
|
return generic_hypercall6(KVM_HCALL_FAST_TAGGED_MEMORY_COPY,
|
|
(unsigned long)dst, (unsigned long)src,
|
|
len, strd_opcode, ldrd_opcode, prefetch);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_fast_tagged_memory_copy_user(void *dst, const void *src,
|
|
size_t len, size_t *copied,
|
|
unsigned long strd_opcode, unsigned long ldrd_opcode,
|
|
int prefetch)
|
|
{
|
|
return generic_hypercall6(KVM_HCALL_FAST_TAGGED_MEMORY_COPY_USER,
|
|
(unsigned long)dst, (unsigned long)src,
|
|
len, (unsigned long)copied,
|
|
strd_opcode |
|
|
LDST_PREFETCH_FLAG_SET((unsigned long)!!prefetch),
|
|
ldrd_opcode);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_fast_tagged_memory_set(void *addr, u64 val, u64 tag,
|
|
size_t len, u64 strd_opcode)
|
|
{
|
|
return generic_hypercall5(KVM_HCALL_FAST_TAGGED_MEMORY_SET,
|
|
(unsigned long)addr, val, tag, len, strd_opcode);
|
|
}
|
|
static inline unsigned long
|
|
HYPERVISOR_fast_tagged_memory_set_user(void *addr, u64 val, u64 tag,
|
|
size_t len, size_t *cleared, u64 strd_opcode)
|
|
{
|
|
return generic_hypercall6(KVM_HCALL_FAST_TAGGED_MEMORY_SET_USER,
|
|
(unsigned long)addr, val, tag, len,
|
|
(unsigned long)cleared, strd_opcode);
|
|
}
|
|
#ifdef CONFIG_KVM_ASYNC_PF
|
|
static inline int HYPERVISOR_pv_enable_async_pf(u64 apf_reason_gpa,
|
|
u64 apf_id_gpa, u32 apf_ready_vector, u32 irq_controller)
|
|
{
|
|
return generic_hypercall4(KVM_HCALL_PV_ENABLE_ASYNC_PF,
|
|
apf_reason_gpa, apf_id_gpa,
|
|
apf_ready_vector, irq_controller);
|
|
}
|
|
#endif /* CONFIG_KVM_ASYNC_PF */
|
|
static inline int
|
|
HYPERVISOR_prepare_mkctxt_hw_user_stacks(kvm_proc_ctxt_hw_stacks_t *hw_stacks)
|
|
{
|
|
return generic_hypercall1(KVM_HCALL_PREPARE_MKCTXT_HW_USER_STACKS,
|
|
(unsigned long)hw_stacks);
|
|
}
|
|
|
|
|
|
/*
|
|
* The structure to flush guest virtual space at the host shadow PTs
|
|
*/
|
|
|
|
typedef enum mmu_flush_tlb_op {
|
|
undefined_tlb_op = 0, /* undefined type of flush */
|
|
flush_all_tlb_op, /* flush all TLB */
|
|
flush_mm_page_tlb_op, /* flush a single page from TLB */
|
|
flush_mm_range_tlb_op, /* flush a range of pages */
|
|
flush_mm_tlb_op, /* flush a specified user mapping */
|
|
flush_pmd_range_tlb_op, /* same as a range of pages, but for pmd's */
|
|
flush_pt_range_tlb_op, /* flush a range of pages and page tables */
|
|
flush_kernel_range_tlb_op, /* flush a kernel range of pages */
|
|
} mmu_flush_tlb_op_t;
|
|
|
|
typedef struct mmu_spt_flush {
|
|
mmu_flush_tlb_op_t opc; /* flush type (see above) */
|
|
int gmm_id; /* gmm ID */
|
|
unsigned long start; /* affress or start of range */
|
|
unsigned long end; /* end address of range */
|
|
} mmu_spt_flush_t;
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_mmu_pv_flush_tlb(mmu_spt_flush_t *flush_info)
|
|
{
|
|
return generic_hypercall1(KVM_HCALL_MMU_PV_FLUSH_TLB,
|
|
(unsigned long)flush_info);
|
|
}
|
|
static inline void
|
|
HYPERVISOR_sync_addr_range(e2k_addr_t start_gva, e2k_addr_t end_gva)
|
|
{
|
|
generic_hypercall2(KVM_HCALL_SYNC_ADDR_RANGE,
|
|
start_gva, end_gva);
|
|
}
|
|
|
|
/*
|
|
* arguments:
|
|
* VIRQ number
|
|
* flag: "is VIRQ handling in progress and need wake up main VCPU thread, which
|
|
* can be on idle"
|
|
* results of waiting for VIRQ:
|
|
* > 0 : number of VIRQs waiting for handling
|
|
* = 0 : VIRQ handler should be stopped
|
|
* < 0 : if error detected
|
|
*/
|
|
#define KVM_VIRQ_RECEIVED(ret) ((ret) > 0)
|
|
#define KVM_VIRQ_STOPPED(ret) ((ret) == 0)
|
|
#define KVM_VIRQ_FAILED(ret) ((ret) < 0)
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_wait_for_virq(int virq, bool in_progress)
|
|
{
|
|
return generic_hypercall2(KVM_HCALL_WAIT_FOR_VIRQ, virq, in_progress);
|
|
}
|
|
|
|
static inline unsigned long
|
|
HYPERVISOR_add_ctx_signal_stack(u64 key, bool is_main)
|
|
{
|
|
return generic_hypercall2(KVM_HCALL_ADD_CTX_SIGNAL_STACK,
|
|
key, is_main);
|
|
}
|
|
|
|
static inline void
|
|
HYPERVISOR_remove_ctx_signal_stack(u64 key)
|
|
{
|
|
generic_hypercall1(KVM_HCALL_REMOVE_CTX_SIGNAL_STACK, key);
|
|
}
|
|
|
|
#endif /* _ASM_E2K_HYPERCALL_H */
|