xen: drop hypercall function tables
v2 cover xen: drop hypercall function tables
In order to avoid indirect function calls on the hypercall path as much as possible this series is removing the hypercall function tables and is replacing the hypercall handler calls via the function array by automatically generated call macros.
Another by-product of generating the call macros is the automatic generating of the hypercall handler prototypes from the same data base which is used to generate the macros.
This has the additional advantage of using type safe calls of the handlers and to ensure related handler (e.g. PV and HVM ones) share the same prototypes.
A very brief performance test (parallel build of the Xen hypervisor in a 6 vcpu guest) showed a very slim improvement (less than 1%) of the performance with the patches applied. The test was performed using a PV and a PVH guest.
Changes in V2:
- new patches 6, 14, 15
- patch 7: support hypercall priorities for faster code
- comments addressed
Juergen Gross (15):
xen: limit number of hypercall parameters to 5
xen: move do_vcpu_op() to arch specific code
xen: harmonize return types of hypercall handlers xen/x86: modify hvm_memory_op() prototype
xen: don't include asm/hypercall.h from C sources
add .gitignore entries for *.[is] below xen
xen: generate hypercall interface related code
xen: use generated prototypes for hypercall handlers x86/pv-shim: don't modify hypercall table
xen/x86: don't use hypercall table for calling compat hypercalls xen/x86: call hypercall handlers via generated macro xen/arm: call hypercall handlers via generated macro xen/x86: add hypercall performance counters for hvm, correct pv
xen: drop calls_to_multicall performance counter tools/xenperf: update hypercall names
.gitignore | 5 +- tools/misc/xenperf.c | 5 + xen/Makefile | 10 + xen/arch/arm/domain.c | 15 +- xen/arch/arm/hvm.c | 3 +- xen/arch/arm/physdev.c | 2 +- xen/arch/arm/platform_hypercall.c | 1 + xen/arch/arm/traps.c | 124 ++------- xen/arch/x86/compat.c | 14 +- xen/arch/x86/cpu/vpmu.c | 1 + xen/arch/x86/domain.c | 11 +- xen/arch/x86/domctl.c | 4 +- xen/arch/x86/hvm/hypercall.c | 176 ++----------- xen/arch/x86/hypercall.c | 59 ----- xen/arch/x86/mm.c | 1 - xen/arch/x86/mm/paging.c | 3 +- xen/arch/x86/platform_hypercall.c | 1 + xen/arch/x86/pv/callback.c | 20 +- xen/arch/x86/pv/emul-priv-op.c | 2 +- xen/arch/x86/pv/hypercall.c | 192 ++------------ xen/arch/x86/pv/iret.c | 5 +- xen/arch/x86/pv/misc-hypercalls.c | 14 +- xen/arch/x86/pv/shim.c | 54 ++-- xen/arch/x86/traps.c | 2 +- xen/arch/x86/x86_64/compat.c | 1 - xen/arch/x86/x86_64/compat/mm.c | 1 + xen/arch/x86/x86_64/domain.c | 16 +- xen/arch/x86/x86_64/mm.c | 2 - xen/arch/x86/x86_64/platform_hypercall.c | 3 +- xen/common/argo.c | 12 +- xen/common/compat/domain.c | 14 +- xen/common/compat/grant_table.c | 1 + xen/common/compat/multicall.c | 2 +- xen/common/domain.c | 11 +- xen/common/event_channel.c | 10 + xen/common/grant_table.c | 10 + xen/common/kexec.c | 6 +- xen/common/multicall.c | 2 +- xen/common/trace.c | 2 +- xen/include/asm-arm/hypercall.h | 7 +- xen/include/asm-x86/hypercall.h | 204 ++++----------- xen/include/asm-x86/paging.h | 3 - xen/include/asm-x86/pv/shim.h | 3 + xen/include/hypercall-defs.c | 285 +++++++++++++++++++++ xen/include/xen/hypercall.h | 181 +------------- xen/include/xen/perfc_defn.h | 1 - xen/scripts/gen_hypercall.awk | 306 +++++++++++++++++++++++ 47 files changed, 870 insertions(+), 937 deletions(-) create mode 100644 xen/include/hypercall-defs.c create mode 100644 xen/scripts/gen_hypercall.awk
Signature · 1 line
2.26.2
PATCH v2 4/15 xen/x86: modify hvm_memory_op() prototype
hvm_memory_op() should take an unsigned long as cmd, like do_memory_op().
As hvm_memory_op() is basically just calling do_memory_op() (or compat_memory_op()) passing through the parameters the cmd parameter should have no smaller size than that of the called functions.
--- xen/arch/x86/hvm/hypercall.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
xen/arch/x86/hvm/hypercall.c +1 -1
@@ -31,7 +31,7 @@#include <public/hvm/hvm_op.h> #include <public/hvm/params.h> -static long hvm_memory_op (int cmd,XEN_GUEST_HANDLE_PARAM (void ) arg) +static long hvm_memory_op (unsigned long cmd,XEN_GUEST_HANDLE_PARAM (void ) arg) {long rc;
Signature · 1 line
2.26.2
PATCH v2 1/15 xen: limit number of hypercall parameters to 5
In reply to Juergen GrossToday there is no hypercall with more than 5 parameters, while the ABI allows up to 6 parameters. Especially for the X86 32-bit case using 6 parameters would require to run without frame pointer, which isn't very fortunate. Note that for Arm the limit is 5 parameters already.
So limit the maximum number of parameters to 5 for x86, too.
--- xen/arch/x86/hvm/hypercall.c | 28 ++++++++++------------------ xen/arch/x86/pv/hypercall.c | 22 ++++++++-------------- xen/common/trace.c | 2 +- xen/include/asm-x86/hypercall.h | 2 +- 4 files changed, 20 insertions(+), 34 deletions(-)
xen/arch/x86/hvm/hypercall.c +10 -18
@@ -239,10 +239,9 @@ int hvm_hypercall(struct cpu_user_regs *regs)unsigned long rdx = regs->rdx;unsigned long r10 = regs->r10;unsigned long r8 = regs->r8; -unsigned long r9 = regs->r9; -HVM_DBG_LOG (DBG_LEVEL_HCALL ,"hcall%lu(%lx, %lx, %lx, %lx, %lx, %lx)" , - eax, rdi, rsi, rdx, r10, r8, r9); +HVM_DBG_LOG (DBG_LEVEL_HCALL ,"hcall%lu(%lx, %lx, %lx, %lx, %lx)" , + eax, rdi, rsi, rdx, r10, r8);#ifndef NDEBUG /* Deliberately corrupt parameter regs not used by this hypercall. */
@@ -252,13 +251,11 @@ int hvm_hypercall(struct cpu_user_regs *regs)case 1 : rsi =0xdeadbeefdeadf00dUL ; fallthrough;case 2 : rdx =0xdeadbeefdeadf00dUL ; fallthrough;case 3 : r10 =0xdeadbeefdeadf00dUL ; fallthrough; -case 4 : r8 =0xdeadbeefdeadf00dUL ; fallthrough; - case 5: r9 = 0xdeadbeefdeadf00dUL; + case 4: r8 = 0xdeadbeefdeadf00dUL; }#endif - regs->rax = hvm_hypercall_table[eax].native (rdi, rsi, rdx, r10, r8, - r9); + regs->rax = hvm_hypercall_table[eax].native (rdi, rsi, rdx, r10, r8);#ifndef NDEBUG if ( !curr->hcall_preempted )
@@ -266,7 +263,6 @@ int hvm_hypercall(struct cpu_user_regs *regs)/* Deliberately corrupt parameter regs used by this hypercall. */ switch ( hypercall_args_table[eax].native ) { -case 6 : regs->r9 =0xdeadbeefdeadf00dUL ; fallthrough;case 5 : regs->r8 =0xdeadbeefdeadf00dUL ; fallthrough;case 4 : regs->r10 =0xdeadbeefdeadf00dUL ; fallthrough;case 3 : regs->rdx =0xdeadbeefdeadf00dUL ; fallthrough;
@@ -283,10 +279,9 @@ int hvm_hypercall(struct cpu_user_regs *regs)unsigned int edx = regs->edx;unsigned int esi = regs->esi;unsigned int edi = regs->edi; -unsigned int ebp = regs->ebp; -HVM_DBG_LOG (DBG_LEVEL_HCALL ,"hcall%lu(%x, %x, %x, %x, %x, %x)" , eax, - ebx, ecx, edx, esi, edi, ebp); +HVM_DBG_LOG (DBG_LEVEL_HCALL ,"hcall%lu(%x, %x, %x, %x, %x)" , eax, + ebx, ecx, edx, esi, edi);#ifndef NDEBUG /* Deliberately corrupt parameter regs not used by this hypercall. */
@@ -296,14 +291,12 @@ int hvm_hypercall(struct cpu_user_regs *regs)case 1 : ecx =0xdeadf00d ; fallthrough;case 2 : edx =0xdeadf00d ; fallthrough;case 3 : esi =0xdeadf00d ; fallthrough; -case 4 : edi =0xdeadf00d ; fallthrough; - case 5: ebp = 0xdeadf00d; + case 4: edi = 0xdeadf00d; }#endif curr->hcall_compat = true; - regs->rax = hvm_hypercall_table[eax].compat (ebx, ecx, edx, esi, edi, - ebp); + regs->rax = hvm_hypercall_table[eax].compat (ebx, ecx, edx, esi, edi); curr->hcall_compat = false;#ifndef NDEBUG
@@ -312,7 +305,6 @@ int hvm_hypercall(struct cpu_user_regs *regs)/* Deliberately corrupt parameter regs used by this hypercall. */ switch ( hypercall_args_table[eax].compat ) { -case 6 : regs->rbp =0xdeadf00d ; fallthrough;case 5 : regs->rdi =0xdeadf00d ; fallthrough;case 4 : regs->rsi =0xdeadf00d ; fallthrough;case 3 : regs->rdx =0xdeadf00d ; fallthrough;
@@ -349,7 +341,7 @@ enum mc_disposition hvm_do_multicall_call(struct mc_state *state) func =array_access_nospec (hvm_hypercall_table, call->op).native;if ( func ) call->result =func (call->args[0 ], call->args[1 ], call->args[2 ], - call->args[3 ], call->args[4 ], call->args[5 ]); + call->args[3 ], call->args[4 ]);else call->result = -ENOSYS ; }
@@ -361,7 +353,7 @@ enum mc_disposition hvm_do_multicall_call(struct mc_state *state) func =array_access_nospec (hvm_hypercall_table, call->op).compat;if ( func ) call->result =func (call->args[0 ], call->args[1 ], call->args[2 ], - call->args[3 ], call->args[4 ], call->args[5 ]); + call->args[3 ], call->args[4 ]);else call->result = -ENOSYS ; }
xen/arch/x86/pv/hypercall.c +8 -14
@@ -145,7 +145,6 @@ _pv_hypercall(struct cpu_user_regs *regs, bool compat)unsigned long rdx = regs->rdx;unsigned long r10 = regs->r10;unsigned long r8 = regs->r8; -unsigned long r9 = regs->r9;#ifndef NDEBUG /* Deliberately corrupt parameter regs not used by this hypercall. */
@@ -155,18 +154,17 @@ _pv_hypercall(struct cpu_user_regs *regs, bool compat)case 1 : rsi =0xdeadbeefdeadf00dUL ; fallthrough;case 2 : rdx =0xdeadbeefdeadf00dUL ; fallthrough;case 3 : r10 =0xdeadbeefdeadf00dUL ; fallthrough; -case 4 : r8 =0xdeadbeefdeadf00dUL ; fallthrough; - case 5: r9 = 0xdeadbeefdeadf00dUL; + case 4: r8 = 0xdeadbeefdeadf00dUL; }#endif if (unlikely (tb_init_done) ) { -unsigned long args[6 ] = { rdi, rsi, rdx, r10, r8, r9 }; +unsigned long args[5 ] = { rdi, rsi, rdx, r10, r8 };__trace_hypercall (TRC_PV_HYPERCALL_V2 , eax, args); } - regs->rax = pv_hypercall_table[eax].native (rdi, rsi, rdx, r10, r8, r9); + regs->rax = pv_hypercall_table[eax].native (rdi, rsi, rdx, r10, r8);#ifndef NDEBUG if ( !curr->hcall_preempted )
@@ -174,7 +172,6 @@ _pv_hypercall(struct cpu_user_regs *regs, bool compat)/* Deliberately corrupt parameter regs used by this hypercall. */ switch ( hypercall_args_table[eax].native ) { -case 6 : regs->r9 =0xdeadbeefdeadf00dUL ; fallthrough;case 5 : regs->r8 =0xdeadbeefdeadf00dUL ; fallthrough;case 4 : regs->r10 =0xdeadbeefdeadf00dUL ; fallthrough;case 3 : regs->rdx =0xdeadbeefdeadf00dUL ; fallthrough;
@@ -192,7 +189,6 @@ _pv_hypercall(struct cpu_user_regs *regs, bool compat)unsigned int edx = regs->edx;unsigned int esi = regs->esi;unsigned int edi = regs->edi; -unsigned int ebp = regs->ebp;#ifndef NDEBUG /* Deliberately corrupt parameter regs not used by this hypercall. */
@@ -202,20 +198,19 @@ _pv_hypercall(struct cpu_user_regs *regs, bool compat)case 1 : ecx =0xdeadf00d ; fallthrough;case 2 : edx =0xdeadf00d ; fallthrough;case 3 : esi =0xdeadf00d ; fallthrough; -case 4 : edi =0xdeadf00d ; fallthrough; - case 5: ebp = 0xdeadf00d; + case 4: edi = 0xdeadf00d; }#endif if (unlikely (tb_init_done) ) { -unsigned long args[6 ] = { ebx, ecx, edx, esi, edi, ebp }; +unsigned long args[5 ] = { ebx, ecx, edx, esi, edi };__trace_hypercall (TRC_PV_HYPERCALL_V2 , eax, args); } curr->hcall_compat = true; - regs->eax = pv_hypercall_table[eax].compat (ebx, ecx, edx, esi, edi, ebp); + regs->eax = pv_hypercall_table[eax].compat (ebx, ecx, edx, esi, edi); curr->hcall_compat = false;#ifndef NDEBUG
@@ -224,7 +219,6 @@ _pv_hypercall(struct cpu_user_regs *regs, bool compat)/* Deliberately corrupt parameter regs used by this hypercall. */ switch ( hypercall_args_table[eax].compat ) { -case 6 : regs->ebp =0xdeadf00d ; fallthrough;case 5 : regs->edi =0xdeadf00d ; fallthrough;case 4 : regs->esi =0xdeadf00d ; fallthrough;case 3 : regs->edx =0xdeadf00d ; fallthrough;
@@ -262,7 +256,7 @@ enum mc_disposition pv_do_multicall_call(struct mc_state *state) pv_hypercall_table[op].compat ) call->result = pv_hypercall_table[op].compat ( call->args[0 ], call->args[1 ], call->args[2 ], - call->args[3 ], call->args[4 ], call->args[5 ]); + call->args[3 ], call->args[4 ]); else call->result = -ENOSYS; }
@@ -276,7 +270,7 @@ enum mc_disposition pv_do_multicall_call(struct mc_state *state) pv_hypercall_table[op].native ) call->result = pv_hypercall_table[op].native ( call->args[0 ], call->args[1 ], call->args[2 ], - call->args[3 ], call->args[4 ], call->args[5 ]); + call->args[3 ], call->args[4 ]); else call->result = -ENOSYS; }
xen/common/trace.c +1 -1
@@ -822,7 +822,7 @@ void __trace_hypercall(uint32_t event, unsigned long op, {struct {uint32_t op; -uint32_t args[6 ]; +uint32_t args[5 ]; } d;uint32_t *a = d.args;
xen/include/asm-x86/hypercall.h +1 -1
@@ -13,7 +13,7 @@typedef unsigned long hypercall_fn_t (unsigned long ,unsigned long ,unsigned long , -unsigned long ,unsigned long ,unsigned long ); +unsigned long ,unsigned long ); typedef struct { hypercall_fn_t *native;
Signature · 1 line
2.26.2
PATCH v2 2/15 xen: move do_vcpu_op() to arch specific code
In reply to Juergen GrossToday Arm is using another entry point for the vcpu_op hypercall as x86, as some of the common sub-ops are not supported on Arm. The Arm specific handler filetrs out the not supported sub-ops and then calls the common handler. This leads to the weird call hierarchy:
do_arm_vcpu_op()
do_vcpu_op()
arch_do_vcpu_op()Clean this up by renaming do_vcpu_op() to common_vcpu_op() and arch_do_vcpu_op() in each architecture to do_vcpu_op(). This way one of above calls can be avoided without restricting any potential future use of common sub-ops for Arm.
Additionally the single user of HYPERCALL_ARM() can be modified and HYPERCALL_ARM() can be removed.
--- xen/arch/arm/domain.c | 15 ++++++++------- xen/arch/arm/traps.c | 7 +------ xen/arch/x86/domain.c | 11 +++++++---- xen/arch/x86/x86_64/domain.c | 16 ++++++++++++---- xen/common/compat/domain.c | 14 ++++++-------- xen/common/domain.c | 11 ++++------- xen/include/asm-arm/hypercall.h | 2 -- xen/include/asm-x86/hypercall.h | 2 +- xen/include/xen/hypercall.h | 2 +- 9 files changed, 40 insertions(+), 40 deletions(-)
xen/arch/arm/domain.c +8 -7
@@ -1074,23 +1074,24 @@ void arch_dump_domain_info(struct domain *d) } -long do_arm_vcpu_op (int cmd,unsigned int vcpuid,XEN_GUEST_HANDLE_PARAM (void ) arg) +long do_vcpu_op (int cmd,unsigned int vcpuid,XEN_GUEST_HANDLE_PARAM (void ) arg) { +struct domain *d = current->domain; +struct vcpu *v; + +if ( (v =domain_vcpu (d, vcpuid)) ==NULL ) +return -ENOENT ; +switch ( cmd ) {case VCPUOP_register_vcpu_info:case VCPUOP_register_runstate_memory_area: -return do_vcpu_op (cmd, vcpuid, arg); +return common_vcpu_op (cmd, v, arg);default :return -EINVAL ; } } -long arch_do_vcpu_op (int cmd,struct vcpu *v,XEN_GUEST_HANDLE_PARAM (void ) arg) -{ -return -ENOSYS ; -} -void arch_dump_vcpu_info (struct vcpu *v) {gic_dump_info (v);
xen/arch/arm/traps.c +1 -6
@@ -1351,11 +1351,6 @@ typedef struct { .nr_args = _nr_args, \ } -#define HYPERCALL_ARM (_name, _nr_args) \ - [ __HYPERVISOR_ ## _name ] = { \ - .fn = (arm_hypercall_fn_t) &do_arm_ ## _name, \ - .nr_args = _nr_args, \ - }/* * Only use this for hypercalls which were deprecated (i.e. replaced * by something else) before Xen on ARM was created, i.e. *not* for
@@ -1386,7 +1381,7 @@ static arm_hypercall_t arm_hypercall_table[] = {#endif HYPERCALL (multicall,2 ),HYPERCALL (platform_op,1 ), -HYPERCALL_ARM (vcpu_op,3 ), +HYPERCALL (vcpu_op,3 ),HYPERCALL (vm_assist,2 ), #ifdef CONFIG_ARGO HYPERCALL(argo_op, 5),
xen/arch/x86/domain.c +7 -4
@@ -1488,11 +1488,14 @@ int arch_vcpu_reset(struct vcpu *v)return 0 ; } -long -arch_do_vcpu_op ( -int cmd,struct vcpu *v,XEN_GUEST_HANDLE_PARAM (void ) arg) +long do_vcpu_op (int cmd,unsigned int vcpuid,XEN_GUEST_HANDLE_PARAM (void ) arg) {long rc =0 ; +struct domain *d = current->domain; +struct vcpu *v; + +if ( (v =domain_vcpu (d, vcpuid)) ==NULL ) +return -ENOENT ;switch ( cmd ) {
@@ -1544,7 +1547,7 @@ arch_do_vcpu_op( }default : - rc = -ENOSYS ; + rc =common_vcpu_op (cmd, v, arg);break ; }
xen/arch/x86/x86_64/domain.c +12 -4
@@ -13,10 +13,14 @@ CHECK_vcpu_get_physid;#undef xen_vcpu_get_physidint -arch_compat_vcpu_op ( -int cmd,struct vcpu *v,XEN_GUEST_HANDLE_PARAM (void ) arg) +compat_vcpu_op (int cmd,unsigned int vcpuid,XEN_GUEST_HANDLE_PARAM (void ) arg) { -int rc = -ENOSYS ; +int rc; +struct domain *d = current->domain; +struct vcpu *v; + +if ( (v =domain_vcpu (d, vcpuid)) ==NULL ) +return -ENOENT ;switch ( cmd ) {
@@ -55,7 +59,11 @@ arch_compat_vcpu_op( }case VCPUOP_get_physid: - rc =arch_do_vcpu_op (cmd, v, arg); + rc =do_vcpu_op (cmd, vcpuid, arg); +break ; + +default : + rc =compat_common_vcpu_op (cmd, v, arg);break ; }
xen/common/compat/domain.c +6 -8
@@ -38,14 +38,12 @@ CHECK_vcpu_hvm_context;#endif -int compat_vcpu_op (int cmd,unsigned int vcpuid,XEN_GUEST_HANDLE_PARAM (void ) arg) +int compat_common_vcpu_op (int cmd,struct vcpu *v, +XEN_GUEST_HANDLE_PARAM (void ) arg) { -struct domain *d = current->domain; -struct vcpu *v;int rc =0 ; - -if ( (v =domain_vcpu (d, vcpuid)) ==NULL ) -return -ENOENT ; +struct domain *d = current->domain; +unsigned int vcpuid = v->vcpu_id;switch ( cmd ) {
@@ -102,7 +100,7 @@ int compat_vcpu_op(int cmd, unsigned int vcpuid, XEN_GUEST_HANDLE_PARAM(void) arcase VCPUOP_stop_singleshot_timer:case VCPUOP_register_vcpu_info:case VCPUOP_send_nmi: - rc =do_vcpu_op (cmd, vcpuid, arg); + rc =common_vcpu_op (cmd, v, arg);break ;case VCPUOP_get_runstate_info:
@@ -133,7 +131,7 @@ int compat_vcpu_op(int cmd, unsigned int vcpuid, XEN_GUEST_HANDLE_PARAM(void) ar }default : - rc =arch_compat_vcpu_op (cmd, v, arg); + rc = -ENOSYS ;break ; }
xen/common/domain.c +4 -7
@@ -1559,14 +1559,11 @@ int default_initialise_vcpu(struct vcpu *v, XEN_GUEST_HANDLE_PARAM(void) arg)return rc; } -long do_vcpu_op (int cmd,unsigned int vcpuid,XEN_GUEST_HANDLE_PARAM (void ) arg) +long common_vcpu_op (int cmd,struct vcpu *v,XEN_GUEST_HANDLE_PARAM (void ) arg) { -struct domain *d = current->domain; -struct vcpu *v;long rc =0 ; - -if ( (v =domain_vcpu (d, vcpuid)) ==NULL ) -return -ENOENT ; +struct domain *d = current->domain; +unsigned int vcpuid = v->vcpu_id;switch ( cmd ) {
@@ -1736,7 +1733,7 @@ long do_vcpu_op(int cmd, unsigned int vcpuid, XEN_GUEST_HANDLE_PARAM(void) arg) }default : - rc =arch_do_vcpu_op (cmd, v, arg); + rc = -ENOSYS ;break ; }
xen/include/asm-arm/hypercall.h +0 -2
@@ -4,8 +4,6 @@#include <public/domctl.h> /* for arch_do_domctl */ int do_physdev_op (int cmd,XEN_GUEST_HANDLE_PARAM (void ) arg); -long do_arm_vcpu_op (int cmd,unsigned int vcpuid,XEN_GUEST_HANDLE_PARAM (void ) arg); -long subarch_do_domctl (struct xen_domctl *domctl,struct domain *d,XEN_GUEST_HANDLE_PARAM (xen_domctl_t) u_domctl);
xen/include/asm-x86/hypercall.h +1 -1
@@ -152,7 +152,7 @@ compat_physdev_op( XEN_GUEST_HANDLE_PARAM(void) arg);extern int -arch_compat_vcpu_op ( +compat_common_vcpu_op (int cmd,struct vcpu *v,XEN_GUEST_HANDLE_PARAM (void ) arg); extern int compat_mmuext_op(
xen/include/xen/hypercall.h +1 -1
@@ -110,7 +110,7 @@ do_vcpu_op(struct vcpu ;extern long -arch_do_vcpu_op (int cmd, +common_vcpu_op (int cmd,struct vcpu *v,XEN_GUEST_HANDLE_PARAM (void ) arg);
Signature · 1 line
2.26.2
PATCH v2 7/15 xen: generate hypercall interface related code
In reply to Juergen GrossInstead of repeating similar data multiple times use a single source file and a generator script for producing prototypes and call sequences of the hypercalls.
As the script already knows the number of parameters used add generating a macro for populating an array with the number of parameters per hypercall.
---
V2:
- split platform_op for doe and compat prefixes (Jan Beulich)
- add "addline:" directive
- add priorities to handlers (Jan Beulich)
--- .gitignore | 1 + xen/Makefile | 10 ++ xen/include/hypercall-defs.c | 285 +++++++++++++++++++++++++++++++ xen/scripts/gen_hypercall.awk | 306 ++++++++++++++++++++++++++++++++++ 4 files changed, 602 insertions(+) create mode 100644 xen/include/hypercall-defs.c create mode 100644 xen/scripts/gen_hypercall.awk
.gitignore +1 -0
@@ -336,6 +336,7 @@ xen/include/public/public xen/include/xen/*.new xen/include/xen/acm_policy.h xen/include/xen/compile.h +xen/include/xen/hypercall-defs.h xen/include/xen/lib/x86/cpuid-autogen.h xen/test/livepatch/config.h xen/test/livepatch/expect_config.h
xen/Makefile +10 -0
@@ -383,6 +383,7 @@ _clean: delete-unfresh-files -o -name "*.gcno" -o -name ".*.cmd" -o -name "lib.a" \) -exec rm -f {} \; rm -f include/asm $(TARGET) $(TARGET).gz $(TARGET).efi $(TARGET).efi.map $(TARGET)-syms $(TARGET)-syms.map *~ core rm -f asm-offsets.s include/asm-*/asm-offsets.h + rm -f include/xen/hypercall-defs.h include/hypercall-defs.i rm -f .banner .allconfig.tmp .PHONY: _distclean
@@ -405,6 +406,7 @@ $(TARGET): delete-unfresh-files $(MAKE) -f $(BASEDIR)/Rules.mk -C include $(MAKE) -f $(BASEDIR)/Rules.mk -C arch/$(TARGET_ARCH) include $(MAKE) -f $(BASEDIR)/Rules.mk include/asm-$(TARGET_ARCH)/asm-offsets.h + $(MAKE) -f $(BASEDIR)/Rules.mk include/xen/hypercall-defs.h $(MAKE) -f $(BASEDIR)/Rules.mk -C arch/$(TARGET_ARCH) $@ # drivers/char/console.o contains static banner/compile info. Blow it away.
@@ -466,6 +468,14 @@ include/asm-$(TARGET_ARCH)/asm-offsets.h: asm-offsets.s echo ""; \ echo "#endif") <$< >$@ +quiet_cmd_genhyp = GEN $@ +define cmd_genhyp + awk -f scripts/gen_hypercall.awk <$< >$@ +endef + +include/xen/hypercall-defs.h: include/hypercall-defs.i scripts/gen_hypercall.awk FORCE + $(call if_changed,genhyp) + SUBDIRS = xsm arch/$(TARGET_ARCH) common drivers lib test define all_sources ( find include/asm-$(TARGET_ARCH) -name '*.h' -print; \
xen/include/hypercall-defs.c new file +285 -0
285 lines not on this page · raw message
xen/scripts/gen_hypercall.awk new file +306 -0
306 lines not on this page · raw message
Signature · 1 line
2.26.2
PATCH v2 8/15 xen: use generated prototypes for hypercall handlers
In reply to Juergen GrossRemove the hypercall handler's prototypes in the related header files and use the generated ones instead.
Some handlers having been static before need to be made globally visible.
--- xen/arch/x86/hvm/hypercall.c | 6 +- xen/include/asm-x86/hypercall.h | 133 ------------------------ xen/include/xen/hypercall.h | 179 +------------------------------- 3 files changed, 5 insertions(+), 313 deletions(-)
xen/arch/x86/hvm/hypercall.c +3 -3
@@ -31,7 +31,7 @@#include <public/hvm/hvm_op.h> #include <public/hvm/params.h> -static long hvm_memory_op (unsigned long cmd,XEN_GUEST_HANDLE_PARAM (void ) arg) +long hvm_memory_op (unsigned long cmd,XEN_GUEST_HANDLE_PARAM (void ) arg) {long rc;
@@ -51,7 +51,7 @@ static long hvm_memory_op(unsigned long cmd, XEN_GUEST_HANDLE_PARAM(void) arg) }#ifdef CONFIG_GRANT_TABLE -static long hvm_grant_table_op ( +long hvm_grant_table_op (unsigned int cmd,XEN_GUEST_HANDLE_PARAM (void ) uop,unsigned int count) { switch ( cmd )
@@ -77,7 +77,7 @@ static long hvm_grant_table_op( }#endif -static long hvm_physdev_op (int cmd,XEN_GUEST_HANDLE_PARAM (void ) arg) +long hvm_physdev_op (int cmd,XEN_GUEST_HANDLE_PARAM (void ) arg) {const struct vcpu *curr = current;const struct domain *currd = curr->domain;
xen/include/asm-x86/hypercall.h +0 -133
145 lines not on this page · raw message
xen/include/xen/hypercall.h +2 -177
207 lines not on this page · raw message
Signature · 1 line
2.26.2
PATCH v2 9/15 x86/pv-shim: don't modify hypercall table
In reply to Juergen GrossWhen running as pv-shim the hypercall is modified today in order to replace the functions for __HYPERVISOR_event_channel_op and __HYPERVISOR_grant_table_op hypercalls.
Change this to call the related functions from the normal handlers instead when running as shim. The performance implications are not really relevant, as a normal production hypervisor will not be configured to support shim mode, so the related calls will be dropped due to optimization of the compiler.
Note that for the CONFIG_PV_SHIM_EXCLUSIVE case there is a dummy wrapper do_grant_table_op() needed, as in this case grant_table.c isn't being built.
---
V2:
- add test for pv_shim to wrappers (Jan Beulich)
- add grant_table_op to hypercall table if CONFIG_PV_SHIM (Jan Beulich)
--- xen/arch/x86/pv/hypercall.c | 2 +- xen/arch/x86/pv/shim.c | 54 +++++++++++++++++------------------ xen/common/event_channel.c | 9 ++++++ xen/common/grant_table.c | 9 ++++++ xen/include/asm-x86/pv/shim.h | 3 ++ 5 files changed, 49 insertions(+), 28 deletions(-)
xen/arch/x86/pv/hypercall.c +1 -1
@@ -62,7 +62,7 @@ const pv_hypercall_table_t pv_hypercall_table[] = {COMPAT_CALL (xen_version),HYPERCALL (console_io ),COMPAT_CALL (physdev_op_compat ), -#ifdef CONFIG_GRANT_TABLE +#if defined(CONFIG_GRANT_TABLE) || defined(CONFIG_PV_SHIM)COMPAT_CALL (grant_table_op ), #endif HYPERCALL(vm_assist),
xen/arch/x86/pv/shim.c +27 -27
90 lines not on this page · raw message
xen/common/event_channel.c +9 -0
@@ -32,6 +32,10 @@#include <public/event_channel.h> #include <xsm/xsm.h> +#ifdef CONFIG_PV_SHIM +#include <asm/guest.h> +#endif +#define ERROR_EXIT (_errno) \ do { \ gdprintk(XENLOG_WARNING, \
@@ -1190,6 +1194,11 @@ long do_event_channel_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) {int rc; +#ifdef CONFIG_PV_SHIM +if ( pv_shim ) +return pv_shim_event_channel_op (cmd, arg); +#endif +switch ( cmd ) {case EVTCHNOP_alloc_unbound: {
xen/common/grant_table.c +9 -0
@@ -45,6 +45,10 @@#include <asm/flushtlb.h> #include <asm/guest_atomics.h> +#ifdef CONFIG_PV_SHIM +#include <asm/guest.h> +#endif +/* Per-domain grant information. */ struct grant_table {/*
@@ -3526,6 +3530,11 @@ do_grant_table_op(long rc;unsigned int opaque_in = cmd &GNTTABOP_ARG_MASK , opaque_out =0 ; +#ifdef CONFIG_PV_SHIM +if ( pv_shim ) +return pv_shim_grant_table_op (cmd, uop, count); +#endif +if ( (int )count <0 )return -EINVAL ;
xen/include/asm-x86/pv/shim.h +3 -0
@@ -19,6 +19,7 @@#ifndef __X86_PV_SHIM_H__#define __X86_PV_SHIM_H__ +#include <xen/hypercall.h> #include <xen/types.h> #if defined(CONFIG_PV_SHIM_EXCLUSIVE )
@@ -45,6 +46,8 @@ domid_t get_initial_domain_id(void);uint64_t pv_shim_mem (uint64_t avail);void pv_shim_fixup_e820 (struct e820map *e820);const struct platform_bad_page *pv_shim_reserved_pages (unsigned int *size); +typeof (do_event_channel_op) pv_shim_event_channel_op; +typeof (do_grant_table_op) pv_shim_grant_table_op;#else
Signature · 1 line
2.26.2
PATCH v2 5/15 xen: don't include asm/hypercall.h from C sources
In reply to Juergen GrossInstead of including asm/hypercall.h always use xen/hypercall.h. Additionally include xen/hypercall.h from all sources containing a hypercall handler.
This prepares for generating the handlers' prototypes at build time.
Add a guard in asm/hypercall.h to catch direct inclusion.
---
V2:
- remove platform_op hunk (Jan Beulich)
- remove including of xen/hypervisor.h from arch/x86/x86_64/mm.c (Jan Beulich)
- fix include order in common/compat/grant_table.c (Jan Beulich)
--- xen/arch/arm/hvm.c | 3 +-- xen/arch/arm/platform_hypercall.c | 1 + xen/arch/x86/cpu/vpmu.c | 1 + xen/arch/x86/mm.c | 1 - xen/arch/x86/platform_hypercall.c | 1 + xen/arch/x86/pv/iret.c | 1 + xen/arch/x86/traps.c | 2 +- xen/arch/x86/x86_64/compat/mm.c | 1 + xen/arch/x86/x86_64/mm.c | 2 -- xen/common/compat/grant_table.c | 1 + xen/common/compat/multicall.c | 2 +- xen/common/event_channel.c | 1 + xen/common/grant_table.c | 1 + xen/common/multicall.c | 1 + xen/include/asm-arm/hypercall.h | 4 ++++ xen/include/asm-x86/hypercall.h | 4 ++++ 16 files changed, 20 insertions(+), 7 deletions(-)
xen/arch/arm/hvm.c +1 -2
@@ -20,6 +20,7 @@#include <xen/lib.h> #include <xen/errno.h> #include <xen/guest_access.h> +#include <xen/hypercall.h> #include <xen/sched.h> #include <xen/monitor.h>
@@ -29,8 +30,6 @@#include <public/hvm/params.h> #include <public/hvm/hvm_op.h> -#include <asm/hypercall.h> -static int hvm_allow_set_param (const struct domain *d,unsigned int param) { switch ( param )
xen/arch/arm/platform_hypercall.c +1 -0
@@ -9,6 +9,7 @@#include <xen/types.h> #include <xen/sched.h> #include <xen/guest_access.h> +#include <xen/hypercall.h> #include <xen/spinlock.h> #include <public/platform.h> #include <xsm/xsm.h>
xen/arch/x86/cpu/vpmu.c +1 -0
@@ -21,6 +21,7 @@#include <xen/xenoprof.h> #include <xen/event.h> #include <xen/guest_access.h> +#include <xen/hypercall.h> #include <xen/cpu.h> #include <xen/param.h> #include <asm/regs.h>
xen/arch/x86/mm.c +0 -1
@@ -129,7 +129,6 @@#include <asm/ldt.h> #include <asm/x86_emulate.h> #include <asm/e820.h> -#include <asm/hypercall.h> #include <asm/shared.h> #include <asm/mem_sharing.h> #include <public/memory.h>
xen/arch/x86/platform_hypercall.c +1 -0
@@ -17,6 +17,7 @@#include <xen/console.h> #include <xen/iocap.h> #include <xen/guest_access.h> +#include <xen/hypercall.h> #include <xen/acpi.h> #include <xen/efi.h> #include <xen/cpu.h>
xen/arch/x86/pv/iret.c +1 -0
@@ -18,6 +18,7 @@*/ #include <xen/guest_access.h> +#include <xen/hypercall.h> #include <xen/lib.h> #include <xen/sched.h>
xen/arch/x86/traps.c +1 -1
@@ -29,6 +29,7 @@#include <xen/lib.h> #include <xen/err.h> #include <xen/errno.h> +#include <xen/hypercall.h> #include <xen/mm.h> #include <xen/param.h> #include <xen/console.h>
@@ -70,7 +71,6 @@#include <asm/x86_emulate.h> #include <asm/traps.h> #include <asm/hvm/vpt.h> -#include <asm/hypercall.h> #include <asm/mce.h> #include <asm/apic.h> #include <asm/mc146818rtc.h>
xen/arch/x86/x86_64/compat/mm.c +1 -0
@@ -1,4 +1,5 @@#include <xen/event.h> +#include <xen/hypercall.h> #include <xen/mem_access.h> #include <xen/multicall.h> #include <compat/memory.h>
xen/arch/x86/x86_64/mm.c +0 -2
@@ -25,14 +25,12 @@ EMIT_FILE;#include <xen/numa.h> #include <xen/nodemask.h> #include <xen/guest_access.h> -#include <xen/hypercall.h> #include <xen/mem_access.h> #include <asm/current.h> #include <asm/asm_defns.h> #include <asm/page.h> #include <asm/flushtlb.h> #include <asm/fixmap.h> -#include <asm/hypercall.h> #include <asm/msr.h> #include <asm/pv/domain.h> #include <asm/setup.h>
xen/common/compat/grant_table.c +1 -0
@@ -3,6 +3,7 @@* */ +#include <xen/hypercall.h> #include <compat/grant_table.h> #define xen_grant_entry_v1 grant_entry_v1
xen/common/compat/multicall.c +1 -1
@@ -4,6 +4,7 @@EMIT_FILE ; +#include <xen/hypercall.h> #include <xen/types.h> #include <xen/multicall.h> #include <xen/trace.h>
@@ -19,7 +20,6 @@ static inline void xlat_multicall_entry(struct mc_state *mcs) mcs->compat_call.args[i] = mcs->call.args[i]; } -DEFINE_XEN_GUEST_HANDLE (multicall_entry_compat_t);#define multicall_entry compat_multicall_entry#define multicall_entry_t multicall_entry_compat_t#define do_multicall_call compat_multicall_call
xen/common/event_channel.c +1 -0
@@ -24,6 +24,7 @@#include <xen/iocap.h> #include <xen/compat.h> #include <xen/guest_access.h> +#include <xen/hypercall.h> #include <xen/keyhandler.h> #include <asm/current.h>
xen/common/grant_table.c +1 -0
@@ -33,6 +33,7 @@#include <xen/trace.h> #include <xen/grant_table.h> #include <xen/guest_access.h> +#include <xen/hypercall.h> #include <xen/domain_page.h> #include <xen/iommu.h> #include <xen/paging.h>
xen/common/multicall.c +1 -0
@@ -9,6 +9,7 @@#include <xen/event.h> #include <xen/multicall.h> #include <xen/guest_access.h> +#include <xen/hypercall.h> #include <xen/perfc.h> #include <xen/trace.h> #include <asm/current.h>
xen/include/asm-arm/hypercall.h +4 -0
@@ -1,3 +1,7 @@ +#ifndef __XEN_HYPERCALL_H__ +#error "asm/hypercall.h should not be included directly - include xen/hypercall.h instead" +#endif +#ifndef __ASM_ARM_HYPERCALL_H__#define __ASM_ARM_HYPERCALL_H__
xen/include/asm-x86/hypercall.h +4 -0
@@ -2,6 +2,10 @@* asm-x86/hypercall.h */ +#ifndef __XEN_HYPERCALL_H__ +#error "asm/hypercall.h should not be included directly - include xen/hypercall.h instead" +#endif +#ifndef __ASM_X86_HYPERCALL_H__#define __ASM_X86_HYPERCALL_H__
Signature · 1 line
2.26.2
PATCH v2 14/15 xen: drop calls_to_multicall performance counter
In reply to Juergen GrossThe calls_to_multicall performance counter is basically redundant to the multicall hypercall counter. The only difference is the counting of continuation calls, which isn't really that interesting.
Drop the calls_to_multicall performance counter.
---
V2:
- new patch
--- xen/common/multicall.c | 1 - xen/include/xen/perfc_defn.h | 1 - 2 files changed, 2 deletions(-)
xen/common/multicall.c +0 -1
@@ -114,7 +114,6 @@ do_multicall(if (unlikely (disp == mc_preempt) && i < nr_calls ) goto preempted; -perfc_incr (calls_to_multicall);perfc_add (calls_from_multicall, i); mcs->flags =0 ;return rc;
xen/include/xen/perfc_defn.h +0 -1
@@ -6,7 +6,6 @@ PERFCOUNTER_ARRAY(hypercalls, "hypercalls", NR_hypercalls) -PERFCOUNTER(calls_to_multicall, "calls to multicall") PERFCOUNTER(calls_from_multicall, "calls from multicall")PERFCOUNTER (irqs,"#interrupts" )
Signature · 1 line
2.26.2
PATCH v2 6/15 add .gitignore entries for *.[is] below xen
In reply to Juergen GrossInstead of listing each single file with .s or .i suffixes in .gitignore use pattern based entries. Restrict those to the xen directory as we have e.g. tools/libs/stat/bindings/swig/xenstat.i in our tree.
Below xen the pattern based entries are fine, as we have pattern rules for creating *.s and *.i files in xen/Rules.mk.
---
V2:
- new patch
--- .gitignore | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
.gitignore +2 -2
@@ -301,12 +301,13 @@ tools/xentrace/xentrace_setsize tools/xentrace/tbctl tools/xentrace/xenctx tools/xentrace/xentrace +xen/**/*.i +xen/**/*.s xen/.banner xen/.config xen/.config.old xen/.xen.elf32 xen/System.map -xen/arch/x86/asm-macros.i xen/arch/x86/boot/mkelf32 xen/arch/x86/boot/cmdline.S xen/arch/x86/boot/reloc.S
@@ -322,7 +323,6 @@ xen/arch/*/efi/ebmalloc.c xen/arch/*/efi/efi.h xen/arch/*/efi/pe.c xen/arch/*/efi/runtime.c -xen/asm-offsets.s xen/common/config_data.S xen/common/config.gz xen/include/headers*.chk
Signature · 1 line
2.26.2
PATCH v2 15/15 tools/xenperf: update hypercall names
In reply to Juergen GrossThe hypercall names need some update.
---
V2:
- new patch
--- tools/misc/xenperf.c | 5 +++++ 1 file changed, 5 insertions(+)
tools/misc/xenperf.c +5 -0
@@ -57,6 +57,11 @@ const char *hypercall_name_table[64] =X (sysctl),X (domctl),X (kexec_op), +X (tmem_op), +X (argo_op), +X (xenpmu_op), +X (dm_op), +X (hypfs_op),X (arch_0),X (arch_1), X(arch_2),
Signature · 1 line
2.26.2
PATCH v2 3/15 xen: harmonize return types of hypercall handlers
In reply to Juergen GrossToday most hypercall handlers have a return type of long, while the compat ones return an int. There are a few exceptions from that rule, however.
Get rid of the exceptions by letting compat handlers always return int and others always return long.
For the compat hvm case use eax instead of rax for the stored result as it should have been from the beginning.
Additionally move some prototypes to include/asm-x86/hypercall.h as they are x86 specific. Move the do_physdev_op() prototype from both architecture dependant headers to the common one. Move the compat_platform_op() prototype to the common header.
Switch some non style compliant types (u32, s32, s64) to style compliant ones.
Rename paging_domctl_continuation() to do_paging_domctl_cont() and add a matching define for the associated hypercall.
Make do_callback_op() and compat_callback_op() more similar by adding the const attribute to compat_callback_op()'s 2nd parameter.
Change the type of the cmd parameter for [do|compat]_kexec_op() to unsigned int, as this is more appropriate for the compat case.
---
V2:
- rework platform_op compat handling (Jan Beulich)
--- xen/arch/arm/physdev.c | 2 +- xen/arch/x86/domctl.c | 4 +-- xen/arch/x86/hvm/hypercall.c | 8 ++--- xen/arch/x86/hypercall.c | 2 +- xen/arch/x86/mm/paging.c | 3 +- xen/arch/x86/pv/callback.c | 20 +++++------ xen/arch/x86/pv/emul-priv-op.c | 2 +- xen/arch/x86/pv/hypercall.c | 5 +-- xen/arch/x86/pv/iret.c | 4 +-- xen/arch/x86/pv/misc-hypercalls.c | 14 +++++--- xen/arch/x86/x86_64/platform_hypercall.c | 3 +- xen/common/argo.c | 12 +++---- xen/common/kexec.c | 6 ++-- xen/include/asm-arm/hypercall.h | 1 - xen/include/asm-x86/hypercall.h | 43 +++++++++++------------- xen/include/asm-x86/paging.h | 3 -- xen/include/xen/hypercall.h | 26 +++++++------- 17 files changed, 75 insertions(+), 83 deletions(-)
xen/arch/arm/physdev.c +1 -1
@@ -11,7 +11,7 @@#include <xen/hypercall.h> -int do_physdev_op (int cmd,XEN_GUEST_HANDLE_PARAM (void ) arg) +long do_physdev_op (int cmd,XEN_GUEST_HANDLE_PARAM (void ) arg) {#ifdef CONFIG_HAS_PCI return pci_physdev_op (cmd, arg);
xen/arch/x86/domctl.c +2 -2
@@ -221,8 +221,8 @@ long arch_do_domctl(case XEN_DOMCTL_shadow_op: ret =paging_domctl (d, &domctl->u.shadow_op, u_domctl,0 );if ( ret == -ERESTART ) -return hypercall_create_continuation (__HYPERVISOR_arch_1, -"h" , u_domctl); +return hypercall_create_continuation ( + __HYPERVISOR_paging_domctl_cont,"h" , u_domctl); copyback = true;break ;
xen/arch/x86/hvm/hypercall.c +2 -6
@@ -120,8 +120,6 @@ static long hvm_physdev_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) [ __HYPERVISOR_ ## x ] = { (hypercall_fn_t *) do_ ## x, \ (hypercall_fn_t *) compat_ ## x } -#define do_arch_1 paging_domctl_continuation -static const struct {hypercall_fn_t *native, *compat; } hvm_hypercall_table[] = {
@@ -154,11 +152,9 @@ static const struct {#ifdef CONFIG_HYPFS HYPERCALL (hypfs_op), #endif -HYPERCALL (arch_1) +HYPERCALL (paging_domctl_cont) }; -#undef do_arch_1 -#undef HYPERCALL#undef HVM_CALL#undef COMPAT_CALL
@@ -296,7 +292,7 @@ int hvm_hypercall(struct cpu_user_regs *regs)#endif curr->hcall_compat = true; - regs->rax = hvm_hypercall_table[eax].compat (ebx, ecx, edx, esi, edi); + regs->eax = hvm_hypercall_table[eax].compat (ebx, ecx, edx, esi, edi); curr->hcall_compat = false;#ifndef NDEBUG
xen/arch/x86/hypercall.c +1 -1
@@ -75,7 +75,7 @@ const hypercall_args_t hypercall_args_table[NR_hypercalls] =ARGS (dm_op,3 ),ARGS (hypfs_op,5 ),ARGS (mca,1 ), - ARGS(arch_1, 1), + ARGS(paging_domctl_cont, 1), };#undef COMP
xen/arch/x86/mm/paging.c +2 -1
@@ -21,6 +21,7 @@#include <xen/init.h> #include <xen/guest_access.h> +#include <xen/hypercall.h> #include <asm/paging.h> #include <asm/shadow.h> #include <asm/p2m.h>
@@ -756,7 +757,7 @@ int paging_domctl(struct domain *d, struct xen_domctl_shadow_op *sc,return shadow_domctl (d, sc, u_domctl); } -long paging_domctl_continuation (XEN_GUEST_HANDLE_PARAM (xen_domctl_t) u_domctl) +long do_paging_domctl_cont (XEN_GUEST_HANDLE_PARAM (xen_domctl_t) u_domctl) {struct xen_domctl op;struct domain *d;
xen/arch/x86/pv/callback.c +10 -10
@@ -207,9 +207,9 @@ long do_set_callbacks(unsigned long event_address,#include <compat/callback.h> #include <compat/nmi.h> -static long compat_register_guest_callback (struct compat_callback_register *reg) +static int compat_register_guest_callback (struct compat_callback_register *reg) { -long ret =0 ; +int ret =0 ;struct vcpu *curr = current;fixup_guest_code_selector (curr->domain, reg->address.cs);
@@ -256,10 +256,10 @@ static long compat_register_guest_callback(struct compat_callback_register *reg)return ret; } -static long compat_unregister_guest_callback ( +static int compat_unregister_guest_callback (struct compat_callback_unregister *unreg) { -long ret; +int ret;switch ( unreg->type ) {
@@ -283,9 +283,9 @@ static long compat_unregister_guest_callback(return ret; } -long compat_callback_op (int cmd,XEN_GUEST_HANDLE (void ) arg) +int compat_callback_op (int cmd,XEN_GUEST_HANDLE (const_void) arg) { -long ret; +int ret;switch ( cmd ) {
@@ -321,10 +321,10 @@ long compat_callback_op(int cmd, XEN_GUEST_HANDLE(void) arg)return ret; } -long compat_set_callbacks (unsigned long event_selector, -unsigned long event_address, -unsigned long failsafe_selector, -unsigned long failsafe_address) +int compat_set_callbacks (unsigned long event_selector, +unsigned long event_address, +unsigned long failsafe_selector, +unsigned long failsafe_address) {struct compat_callback_register event = { .type = CALLBACKTYPE_event,
xen/arch/x86/pv/emul-priv-op.c +1 -1
@@ -22,12 +22,12 @@#include <xen/domain_page.h> #include <xen/event.h> #include <xen/guest_access.h> +#include <xen/hypercall.h> #include <xen/iocap.h> #include <asm/amd.h> #include <asm/debugreg.h> #include <asm/hpet.h> -#include <asm/hypercall.h> #include <asm/mc146818rtc.h> #include <asm/pv/domain.h> #include <asm/pv/trace.h>
xen/arch/x86/pv/hypercall.c +1 -4
@@ -40,8 +40,6 @@#define COMPAT_CALL (x) HYPERCALL(x)#endif -#define do_arch_1 paging_domctl_continuation -const pv_hypercall_table_t pv_hypercall_table[] = {COMPAT_CALL (set_trap_table),HYPERCALL (mmu_update),
@@ -102,11 +100,10 @@ const pv_hypercall_table_t pv_hypercall_table[] = {#endif HYPERCALL(mca), #ifndef CONFIG_PV_SHIM_EXCLUSIVE - HYPERCALL(arch_1), + HYPERCALL(paging_domctl_cont), #endif }; -#undef do_arch_1#undef COMPAT_CALL#undef HYPERCALL
xen/arch/x86/pv/iret.c +2 -2
@@ -48,7 +48,7 @@ static void async_exception_cleanup(struct vcpu *curr) curr->arch.async_exception_state (trap).old_mask; } -unsigned long do_iret (void ) +long do_iret (void ) {struct cpu_user_regs *regs =guest_cpu_user_regs ();struct iret_context iret_saved;
@@ -105,7 +105,7 @@ unsigned long do_iret(void) }#ifdef CONFIG_PV32 -unsigned int compat_iret (void ) +int compat_iret (void ) {struct cpu_user_regs *regs =guest_cpu_user_regs ();struct vcpu *v = current;
xen/arch/x86/pv/misc-hypercalls.c +9 -5
@@ -28,12 +28,16 @@ long do_set_debugreg(int reg, unsigned long value)return set_debugreg (current, reg, value); } -unsigned long do_get_debugreg (int reg) +long do_get_debugreg (int reg) { -unsigned long val; -int res =x86emul_read_dr (reg, &val,NULL ); - -return res ==X86EMUL_OKAY ? val : -ENODEV ; +/* Avoid implementation defined behavior casting unsigned long to long. */ +union { +unsigned long val; +long ret; + } u; +int res =x86emul_read_dr (reg, &u.val,NULL ); + +return res ==X86EMUL_OKAY ? u.ret : -ENODEV ; }long do_fpu_taskswitch (int set)
xen/arch/x86/x86_64/platform_hypercall.c +2 -1
@@ -4,10 +4,11 @@EMIT_FILE ; +#include <xen/hypercall.h> +#include <xen/types.h> #include <xen/lib.h> #include <compat/platform.h> -DEFINE_XEN_GUEST_HANDLE (compat_platform_op_t);#define xen_platform_op compat_platform_op#define xen_platform_op_t compat_platform_op_t#define do_platform_op (x) compat_platform_op(_##x)
xen/common/argo.c +6 -6
@@ -2207,13 +2207,13 @@ do_argo_op(unsigned int cmd, XEN_GUEST_HANDLE_PARAM(void) arg1, }#ifdef CONFIG_COMPAT -long -compat_argo_op (unsigned int cmd,XEN_GUEST_HANDLE_PARAM (void ) arg1, -XEN_GUEST_HANDLE_PARAM (void ) arg2,unsigned long arg3, -unsigned long arg4) +int compat_argo_op (unsigned int cmd, +XEN_GUEST_HANDLE_PARAM (void ) arg1, +XEN_GUEST_HANDLE_PARAM (void ) arg2, +unsigned long arg3,unsigned long arg4) {struct domain *currd = current->domain; -long rc; +int rc;xen_argo_send_addr_t send_addr;xen_argo_iov_t iovs[XEN_ARGO_MAXIOV ];compat_argo_iov_t compat_iovs[XEN_ARGO_MAXIOV ];
@@ -2267,7 +2267,7 @@ compat_argo_op(unsigned int cmd, XEN_GUEST_HANDLE_PARAM(void) arg1, rc =sendv (currd, &send_addr.src, &send_addr.dst, iovs, niov, arg4); out: -argo_dprintk ("<-compat_argo_op(%u)=%ld\n" , cmd, rc); +argo_dprintk ("<-compat_argo_op(%u)=%d\n" , cmd, rc);return rc; }
xen/common/kexec.c +3 -3
@@ -1213,7 +1213,7 @@ static int kexec_status(XEN_GUEST_HANDLE_PARAM(void) uarg)return !!test_bit (bit, &kexec_flags); } -static int do_kexec_op_internal (unsigned long op, +static int do_kexec_op_internal (unsigned int op,XEN_GUEST_HANDLE_PARAM (void ) uarg,bool_t compat) {
@@ -1265,13 +1265,13 @@ static int do_kexec_op_internal(unsigned long op,return ret; } -long do_kexec_op (unsigned long op,XEN_GUEST_HANDLE_PARAM (void ) uarg) +long do_kexec_op (unsigned int op,XEN_GUEST_HANDLE_PARAM (void ) uarg) {return do_kexec_op_internal (op, uarg,0 ); }#ifdef CONFIG_COMPAT -int compat_kexec_op (unsigned long op,XEN_GUEST_HANDLE_PARAM (void ) uarg) +int compat_kexec_op (unsigned int op,XEN_GUEST_HANDLE_PARAM (void ) uarg) {return do_kexec_op_internal (op, uarg,1 ); }
xen/include/asm-arm/hypercall.h +0 -1
@@ -2,7 +2,6 @@#define __ASM_ARM_HYPERCALL_H__#include <public/domctl.h> /* for arch_do_domctl */ -int do_physdev_op (int cmd,XEN_GUEST_HANDLE_PARAM (void ) arg);long subarch_do_domctl (struct xen_domctl *domctl,struct domain *d,XEN_GUEST_HANDLE_PARAM (xen_domctl_t) u_domctl);
xen/include/asm-x86/hypercall.h +20 -23
103 lines not on this page · raw message
xen/include/asm-x86/paging.h +0 -3
@@ -236,9 +236,6 @@ int paging_domctl(struct domain *d, struct xen_domctl_shadow_op *sc,XEN_GUEST_HANDLE_PARAM (xen_domctl_t) u_domctl, bool_t resuming); -/* Helper hypercall for dealing with continuations. */ -long paging_domctl_continuation (XEN_GUEST_HANDLE_PARAM (xen_domctl_t )); -/* Call when destroying a vcpu/domain */ void paging_vcpu_teardown (struct vcpu *v);int paging_teardown (struct domain *d);
xen/include/xen/hypercall.h +13 -13
@@ -114,11 +114,6 @@ common_vcpu_op(int cmd, struct vcpu *v, XEN_GUEST_HANDLE_PARAM(void) arg); -extern long -do_nmi_op ( -unsigned int cmd, -XEN_GUEST_HANDLE_PARAM (void ) arg); - extern long do_hvm_op( unsigned long op,
@@ -126,13 +121,15 @@ do_hvm_op(extern long do_kexec_op ( -unsigned long op, +unsigned int op,XEN_GUEST_HANDLE_PARAM (void ) uarg);extern long do_xsm_op (XEN_GUEST_HANDLE_PARAM (void ) u_xsm_op); +long do_physdev_op (int cmd,XEN_GUEST_HANDLE_PARAM (void ) arg); +#ifdef CONFIG_ARGO extern long do_argo_op( unsigned int cmd,
@@ -145,9 +142,6 @@ extern long do_argo_op(extern long do_xenoprof_op (int op,XEN_GUEST_HANDLE_PARAM (void ) arg); -extern long -do_xenpmu_op (unsigned int op,XEN_GUEST_HANDLE_PARAM (xen_pmu_params_t) arg); - extern long do_dm_op( domid_t domid,
@@ -198,21 +192,27 @@ compat_sched_op(extern int compat_set_timer_op ( -u32 lo, -s32 hi); +uint32_t lo, +int32_t hi);extern int compat_xsm_op (XEN_GUEST_HANDLE_PARAM (void ) op); -extern int compat_kexec_op (unsigned long op,XEN_GUEST_HANDLE_PARAM (void ) uarg); +extern int compat_kexec_op (unsigned int op,XEN_GUEST_HANDLE_PARAM (void ) uarg);DEFINE_XEN_GUEST_HANDLE (multicall_entry_compat_t);extern int compat_multicall (XEN_GUEST_HANDLE_PARAM (multicall_entry_compat_t) call_list,uint32_t nr_calls); +int compat_physdev_op (int cmd,XEN_GUEST_HANDLE_PARAM (void ) arg); + +typedef struct compat_platform_op compat_platform_op_t ; +DEFINE_XEN_GUEST_HANDLE (compat_platform_op_t); +int compat_platform_op (XEN_GUEST_HANDLE_PARAM (compat_platform_op_t) u_xenpf_op); +#ifdef CONFIG_ARGO -extern long compat_argo_op( +extern int compat_argo_op( unsigned int cmd, XEN_GUEST_HANDLE_PARAM(void) arg1, XEN_GUEST_HANDLE_PARAM(void) arg2,
Signature · 1 line
2.26.2
PATCH v2 12/15 xen/arm: call hypercall handlers via generated macro
In reply to Juergen GrossInstead of using a function table use the generated macros for calling the appropriate hypercall handlers.
This makes the calls of the handlers type safe.
For deprecated hypercalls define stub functions.
---
V2:
- make hypercall_args[] const (Jan Beulich)
--- xen/arch/arm/traps.c | 119 ++++++++++--------------------------------- 1 file changed, 26 insertions(+), 93 deletions(-)
xen/arch/arm/traps.c +26 -93
@@ -1337,62 +1337,20 @@ static register_t do_deprecated_hypercall(void)return -ENOSYS ; } -typedef register_t (*arm_hypercall_fn_t )( -register_t ,register_t ,register_t ,register_t ,register_t ); - -typedef struct { -arm_hypercall_fn_t fn; -int nr_args; -}arm_hypercall_t ; - -#define HYPERCALL (_name, _nr_args) \ - [ __HYPERVISOR_ ## _name ] = { \ - .fn = (arm_hypercall_fn_t) &do_ ## _name, \ - .nr_args = _nr_args, \ - } +long dep_sched_op_compat (int cmd,unsigned long arg) +{ +return do_deprecated_hypercall (); +} -/* -* Only use this for hypercalls which were deprecated (i.e. replaced -* by something else) before Xen on ARM was created, i.e. *not* for -* hypercalls which are simply not yet used on ARM. -*/ -#define HYPERCALL_DEPRECATED (_name, _nr_args) \ - [ __HYPERVISOR_##_name ] = { \ - .fn = (arm_hypercall_fn_t) &do_deprecated_hypercall, \ - .nr_args = _nr_args, \ - } +long dep_event_channel_op_compat (XEN_GUEST_HANDLE_PARAM (evtchn_op_t) uop) +{ +return do_deprecated_hypercall (); +} -static arm_hypercall_t arm_hypercall_table[] = { -HYPERCALL (memory_op,2 ), -HYPERCALL (domctl,1 ), -HYPERCALL (sched_op,2 ), -HYPERCALL_DEPRECATED (sched_op_compat,2 ), -HYPERCALL (console_io,3 ), -HYPERCALL (xen_version,2 ), -HYPERCALL (xsm_op,1 ), -HYPERCALL (event_channel_op,2 ), -HYPERCALL_DEPRECATED (event_channel_op_compat,1 ), -HYPERCALL (physdev_op,2 ), -HYPERCALL_DEPRECATED (physdev_op_compat,1 ), -HYPERCALL (sysctl,2 ), -HYPERCALL (hvm_op,2 ), -#ifdef CONFIG_GRANT_TABLE -HYPERCALL (grant_table_op,3 ), -#endif -HYPERCALL (multicall,2 ), -HYPERCALL (platform_op,1 ), -HYPERCALL (vcpu_op,3 ), -HYPERCALL (vm_assist,2 ), -#ifdef CONFIG_ARGO -HYPERCALL (argo_op,5 ), -#endif -#ifdef CONFIG_HYPFS -HYPERCALL (hypfs_op,5 ), -#endif -#ifdef CONFIG_IOREQ_SERVER -HYPERCALL (dm_op,3 ), -#endif -}; +long dep_physdev_op_compat (XEN_GUEST_HANDLE_PARAM (physdev_op_t) uop) +{ +return do_deprecated_hypercall (); +}#ifndef NDEBUG static void do_debug_trap (struct cpu_user_regs *regs,unsigned int code)
@@ -1431,7 +1389,6 @@ static void do_debug_trap(struct cpu_user_regs *regs, unsigned int code)#define HYPERCALL_ARG3 (r) (r)->x2#define HYPERCALL_ARG4 (r) (r)->x3#define HYPERCALL_ARG5 (r) (r)->x4 -#define HYPERCALL_ARGS (r) (r)->x0, (r)->x1, (r)->x2, (r)->x3, (r)->x4#else #define HYPERCALL_RESULT_REG (r) (r)->r0#define HYPERCALL_ARG1 (r) (r)->r0
@@ -1439,52 +1396,40 @@ static void do_debug_trap(struct cpu_user_regs *regs, unsigned int code)#define HYPERCALL_ARG3 (r) (r)->r2#define HYPERCALL_ARG4 (r) (r)->r3#define HYPERCALL_ARG5 (r) (r)->r4 -#define HYPERCALL_ARGS (r) (r)->r0, (r)->r1, (r)->r2, (r)->r3, (r)->r4#endif +static const unsigned char hypercall_args[] = hypercall_args_arm; +static void do_trap_hypercall (struct cpu_user_regs *regs,register_t *nr,const union hsr hsr) { -arm_hypercall_fn_t call =NULL ;struct vcpu *curr = current; -BUILD_BUG_ON (NR_hypercalls <ARRAY_SIZE (arm_hypercall_table) ); -if ( hsr.iss !=XEN_HYPERCALL_TAG ) {gprintk (XENLOG_WARNING ,"Invalid HVC imm 0x%x\n" , hsr.iss);return inject_undef_exception (regs, hsr); } -if ( *nr >=ARRAY_SIZE (arm_hypercall_table) ) - { -perfc_incr (invalid_hypercalls); -HYPERCALL_RESULT_REG (regs) = -ENOSYS ; -return ; - } - curr->hcall_preempted = false;perfc_incra (hypercalls, *nr); - call = arm_hypercall_table[*nr].fn; -if ( call ==NULL ) - { -HYPERCALL_RESULT_REG (regs) = -ENOSYS ; -return ; - } -HYPERCALL_RESULT_REG (regs) =call (HYPERCALL_ARGS (regs)); +call_handlers_arm (*nr,HYPERCALL_RESULT_REG (regs),HYPERCALL_ARG1 (regs), +HYPERCALL_ARG2 (regs),HYPERCALL_ARG3 (regs), +HYPERCALL_ARG4 (regs),HYPERCALL_ARG5 (regs));#ifndef NDEBUG -if ( !curr->hcall_preempted ) +if ( !curr->hcall_preempted &&HYPERCALL_RESULT_REG (regs) != -ENOSYS ) {/* Deliberately corrupt parameter regs used by this hypercall. */ -switch ( arm_hypercall_table[*nr].nr_args ) { +switch ( hypercall_args[*nr] ) {case 5 :HYPERCALL_ARG5 (regs) =0xDEADBEEF ;case 4 :HYPERCALL_ARG4 (regs) =0xDEADBEEF ;case 3 :HYPERCALL_ARG3 (regs) =0xDEADBEEF ;case 2 :HYPERCALL_ARG2 (regs) =0xDEADBEEF ;case 1 :/* Don't clobber x0/r0 -- it's the return value */ +case 0 :/* -ENOSYS case */ break ;default :BUG (); }
@@ -1521,7 +1466,10 @@ static bool check_multicall_32bit_clean(struct multicall_entry *multi) {int i; -for ( i =0 ; i < arm_hypercall_table[multi->op].nr_args; i++ ) +if ( multi->op >=ARRAY_SIZE (hypercall_args) ) +return true; + +for ( i =0 ; i < hypercall_args[multi->op]; i++ ) {if (unlikely (multi->args[i] &0xffffffff00000000ULL ) ) {
@@ -1538,28 +1486,13 @@ static bool check_multicall_32bit_clean(struct multicall_entry *multi)enum mc_disposition arch_do_multicall_call (struct mc_state *state) {struct multicall_entry *multi = &state->call; -arm_hypercall_fn_t call =NULL ; - -if ( multi->op >=ARRAY_SIZE (arm_hypercall_table) ) - { - multi->result = -ENOSYS ; -return mc_continue; - } - - call = arm_hypercall_table[multi->op].fn; -if ( call ==NULL ) - { - multi->result = -ENOSYS ; -return mc_continue; - }if (is_32bit_domain (current->domain) && !check_multicall_32bit_clean (multi) )return mc_continue; - multi->result =call (multi->args[0 ], multi->args[1 ], - multi->args[2 ], multi->args[3 ], - multi->args[4 ]); +call_handlers_arm (multi->op, multi->result, multi->args[0 ], multi->args[1 ], + multi->args[2 ], multi->args[3 ], multi->args[4 ]);return likely (!psr_mode_is_user (guest_cpu_user_regs ())) ? mc_continue : mc_preempt;
Signature · 1 line
2.26.2
PATCH v2 13/15 xen/x86: add hypercall performance counters for hvm, correct pv
In reply to Juergen GrossThe HVM hypercall handler is missing incrementing the per hypercall counters. Add that.
The counters for PV are handled wrong, as they are not using perf_incra() with the number of the hypercall as index, but are incrementing the first hypercall entry (set_trap_table) for each hypercall. Fix that.
--- xen/arch/x86/hvm/hypercall.c | 2 ++ xen/arch/x86/pv/hypercall.c | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-)
xen/arch/x86/hvm/hypercall.c +2 -0
@@ -210,6 +210,8 @@ int hvm_hypercall(struct cpu_user_regs *regs)ioreq_signal_mapcache_invalidate (); } +perfc_incra (hypercalls, eax); +return curr->hcall_preempted ? HVM_HCALL_preempted : HVM_HCALL_completed; }
xen/arch/x86/pv/hypercall.c +1 -1
@@ -102,7 +102,7 @@ _pv_hypercall(struct cpu_user_regs *regs, bool compat)if ( curr->hcall_preempted ) regs->rip -=2 ; -perfc_incr (hypercalls); +perfc_incra (hypercalls, eax); }enum mc_disposition pv_do_multicall_call (struct mc_state *state)
Signature · 1 line
2.26.2
PATCH v2 10/15 xen/x86: don't use hypercall table for calling compat hypercalls
In reply to Juergen GrossToday the *_op_compat hypercalls call the modern handler functions by using the entries from the hypercall table. This is resulting in a not needed indirect function call which can be avoided by using the correct handler function directly. This is basically a revert of commit 1252e282311734 ("86/pv: Export pv_hypercall_table[] rather than working around it in several ways"), which reasoning no longer applies, as shim no longer modifies the hypercall table.
The hypercall table can now be made static as there is no external reference to it any longer.
Commit 834cb8761051f7 ("x86/PV32: fix physdev_op_compat handling") can be reverted, too, as using the direct call of the correct handler is already handled fine without that patch.
--- xen/arch/x86/compat.c | 14 ++++---------- xen/arch/x86/pv/hypercall.c | 9 ++++++++- xen/arch/x86/x86_64/compat.c | 1 - xen/include/asm-x86/hypercall.h | 8 -------- 4 files changed, 12 insertions(+), 20 deletions(-)
xen/arch/x86/compat.c +4 -10
@@ -17,14 +17,12 @@ typedef long ret_t;/* Legacy hypercall (as of 0x00030202). */ ret_t do_physdev_op_compat (XEN_GUEST_HANDLE_PARAM (physdev_op_t) uop) { -typeof (do_physdev_op) *fn = - (void *)pv_hypercall_table[__HYPERVISOR_physdev_op].native;struct physdev_op op;if (unlikely (copy_from_guest (&op, uop,1 ) !=0 ) )return -EFAULT ; -return fn (op.cmd,guest_handle_from_ptr (&uop.p->u, void)); +return do_physdev_op (op.cmd,guest_handle_from_ptr (&uop.p->u, void)); }#ifndef COMPAT
@@ -32,14 +30,11 @@ ret_t do_physdev_op_compat(XEN_GUEST_HANDLE_PARAM(physdev_op_t) uop)/* Legacy hypercall (as of 0x00030101). */ long do_sched_op_compat (int cmd,unsigned long arg) { -typeof (do_sched_op) *fn = - (void *)pv_hypercall_table[__HYPERVISOR_sched_op].native; -switch ( cmd ) {case SCHEDOP_yield:case SCHEDOP_block: -return fn (cmd,guest_handle_from_ptr (NULL , void)); +return do_sched_op (cmd,guest_handle_from_ptr (NULL , void));case SCHEDOP_shutdown: TRACE_3D(TRC_SCHED_SHUTDOWN,
@@ -57,8 +52,6 @@ long do_sched_op_compat(int cmd, unsigned long arg)/* Legacy hypercall (as of 0x00030202). */ long do_event_channel_op_compat (XEN_GUEST_HANDLE_PARAM (evtchn_op_t) uop) { -typeof (do_event_channel_op) *fn = - (void *)pv_hypercall_table[__HYPERVISOR_event_channel_op].native;struct evtchn_op op;if (unlikely (copy_from_guest (&op, uop,1 ) !=0 ) )
@@ -76,7 +69,8 @@ long do_event_channel_op_compat(XEN_GUEST_HANDLE_PARAM(evtchn_op_t) uop)case EVTCHNOP_bind_ipi:case EVTCHNOP_bind_vcpu:case EVTCHNOP_unmask: -return fn (op.cmd,guest_handle_from_ptr (&uop.p->u, void)); +return do_event_channel_op (op.cmd, +guest_handle_from_ptr (&uop.p->u, void));default :return -ENOSYS ;
xen/arch/x86/pv/hypercall.c +8 -1
@@ -27,6 +27,13 @@#include <asm/multicall.h> #include <irq_vectors.h> +typedef struct { +hypercall_fn_t *native; +#ifdef CONFIG_PV32 +hypercall_fn_t *compat; +#endif +}pv_hypercall_table_t ; +#ifdef CONFIG_PV32 #define HYPERCALL (x) \ [ __HYPERVISOR_ ## x ] = { (hypercall_fn_t *) do_ ## x, \
@@ -40,7 +47,7 @@#define COMPAT_CALL (x) HYPERCALL(x)#endif -const pv_hypercall_table_t pv_hypercall_table[] = { +static const pv_hypercall_table_t pv_hypercall_table[] = {COMPAT_CALL (set_trap_table),HYPERCALL (mmu_update),COMPAT_CALL (set_gdt),
xen/arch/x86/x86_64/compat.c +0 -1
@@ -12,7 +12,6 @@ EMIT_FILE;#define physdev_op_t physdev_op_compat_t#define do_physdev_op compat_physdev_op#define do_physdev_op_compat (x) compat_physdev_op_compat(_##x) -#define native compat#define COMPAT #define _XEN_GUEST_HANDLE (t) XEN_GUEST_HANDLE(t)
xen/include/asm-x86/hypercall.h +0 -8
@@ -21,13 +21,6 @@ typedef unsigned long hypercall_fn_t( unsigned long, unsigned long, unsigned long, unsigned long, unsigned long); -typedef struct { -hypercall_fn_t *native; -#ifdef CONFIG_PV32 -hypercall_fn_t *compat; -#endif -}pv_hypercall_table_t ; - typedef struct { uint8_t native; #ifdef CONFIG_COMPAT
@@ -38,7 +31,6 @@ typedef struct {extern const hypercall_args_t hypercall_args_table[NR_hypercalls];#ifdef CONFIG_PV -extern const pv_hypercall_table_t pv_hypercall_table[];void pv_hypercall (struct cpu_user_regs *regs);#endif
Signature · 1 line
2.26.2
PATCH v2 11/15 xen/x86: call hypercall handlers via generated macro
In reply to Juergen GrossInstead of using a function table use the generated macros for calling the appropriate hypercall handlers.
This is beneficial to performance and avoids speculation issues.
With calling the handlers using the correct number of parameters now it is possible to do the parameter register clobbering in the NDEBUG case after returning from the handler. With the additional generated data the hard coded hypercall_args_table[] can be replaced by tables using the generated number of parameters.
Note that this change modifies behavior of clobbering registers in a minor way: in case a hypercall is returning -ENOSYS for any reason the parameter registers will no longer be clobbered. This should be of no real concern, as those cases ought to be extremely rare and reuse of the registers in those cases seems rather far fetched.
---
V2:
- make hypercall_args_*[] const (Jan Beulich)
- make clobber_regs*() independent from NDEBUG (Jan Beulich)
- drop "L" suffix for 32-bit register clobber value (Jan Beulich)
--- xen/arch/x86/hvm/hypercall.c | 148 +++---------------------- xen/arch/x86/hypercall.c | 59 ---------- xen/arch/x86/pv/hypercall.c | 184 +++----------------------------- xen/include/asm-x86/hypercall.h | 54 +++++++--- 4 files changed, 71 insertions(+), 374 deletions(-)
xen/arch/x86/hvm/hypercall.c +13 -135
@@ -108,56 +108,10 @@ long hvm_physdev_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg)return compat_physdev_op (cmd, arg); } -#define HYPERCALL (x) \ - [ __HYPERVISOR_ ## x ] = { (hypercall_fn_t *) do_ ## x, \ - (hypercall_fn_t *) do_ ## x } - -#define HVM_CALL (x) \ - [ __HYPERVISOR_ ## x ] = { (hypercall_fn_t *) hvm_ ## x, \ - (hypercall_fn_t *) hvm_ ## x } - -#define COMPAT_CALL (x) \ - [ __HYPERVISOR_ ## x ] = { (hypercall_fn_t *) do_ ## x, \ - (hypercall_fn_t *) compat_ ## x } - -static const struct { -hypercall_fn_t *native, *compat; -} hvm_hypercall_table[] = { -HVM_CALL (memory_op), -COMPAT_CALL (multicall), -#ifdef CONFIG_GRANT_TABLE -HVM_CALL (grant_table_op), -#endif -HYPERCALL (vm_assist), -COMPAT_CALL (vcpu_op), -HVM_CALL (physdev_op), -COMPAT_CALL (xen_version), -HYPERCALL (console_io), -HYPERCALL (event_channel_op), -COMPAT_CALL (sched_op), -COMPAT_CALL (set_timer_op), -COMPAT_CALL (xsm_op), -HYPERCALL (hvm_op), -HYPERCALL (sysctl), -HYPERCALL (domctl), -#ifdef CONFIG_ARGO -COMPAT_CALL (argo_op), -#endif -COMPAT_CALL (platform_op), -#ifdef CONFIG_PV -COMPAT_CALL (mmuext_op), -#endif -HYPERCALL (xenpmu_op), -COMPAT_CALL (dm_op), -#ifdef CONFIG_HYPFS -HYPERCALL (hypfs_op), +#ifndef NDEBUG +static const unsigned char hypercall_args_64[] = hypercall_args_hvm64; +static const unsigned char hypercall_args_32[] = hypercall_args_hvm32;#endif -HYPERCALL (paging_domctl_cont) -}; - -#undef HYPERCALL -#undef HVM_CALL -#undef COMPAT_CALLint hvm_hypercall (struct cpu_user_regs *regs) {
@@ -203,23 +157,6 @@ int hvm_hypercall(struct cpu_user_regs *regs)return ret; } -BUILD_BUG_ON (ARRAY_SIZE (hvm_hypercall_table) > -ARRAY_SIZE (hypercall_args_table)); - -if ( eax >=ARRAY_SIZE (hvm_hypercall_table) ) - { - regs->rax = -ENOSYS ; -return HVM_HCALL_completed; - } - - eax =array_index_nospec (eax,ARRAY_SIZE (hvm_hypercall_table)); - -if ( !hvm_hypercall_table[eax].native ) - { - regs->rax = -ENOSYS ; -return HVM_HCALL_completed; - } -/* * Caching is intended for instruction emulation only. Disable it * for any accesses by hypercall argument copy-in / copy-out.
@@ -239,34 +176,10 @@ int hvm_hypercall(struct cpu_user_regs *regs)HVM_DBG_LOG (DBG_LEVEL_HCALL ,"hcall%lu(%lx, %lx, %lx, %lx, %lx)" , eax, rdi, rsi, rdx, r10, r8); -#ifndef NDEBUG -/* Deliberately corrupt parameter regs not used by this hypercall. */ -switch ( hypercall_args_table[eax].native ) - { -case 0 : rdi =0xdeadbeefdeadf00dUL ; fallthrough; -case 1 : rsi =0xdeadbeefdeadf00dUL ; fallthrough; -case 2 : rdx =0xdeadbeefdeadf00dUL ; fallthrough; -case 3 : r10 =0xdeadbeefdeadf00dUL ; fallthrough; -case 4 : r8 =0xdeadbeefdeadf00dUL ; - } -#endif - - regs->rax = hvm_hypercall_table[eax].native (rdi, rsi, rdx, r10, r8); +call_handlers_hvm64 (eax, regs->rax, rdi, rsi, rdx, r10, r8); -#ifndef NDEBUG -if ( !curr->hcall_preempted ) - { -/* Deliberately corrupt parameter regs used by this hypercall. */ -switch ( hypercall_args_table[eax].native ) - { -case 5 : regs->r8 =0xdeadbeefdeadf00dUL ; fallthrough; -case 4 : regs->r10 =0xdeadbeefdeadf00dUL ; fallthrough; -case 3 : regs->rdx =0xdeadbeefdeadf00dUL ; fallthrough; -case 2 : regs->rsi =0xdeadbeefdeadf00dUL ; fallthrough; -case 1 : regs->rdi =0xdeadbeefdeadf00dUL ; - } - } -#endif +if ( !curr->hcall_preempted && regs->rax != -ENOSYS ) +clobber_regs (regs,get_nargs (hypercall_args_64, eax)); }else {
@@ -279,36 +192,12 @@ int hvm_hypercall(struct cpu_user_regs *regs)HVM_DBG_LOG (DBG_LEVEL_HCALL ,"hcall%lu(%x, %x, %x, %x, %x)" , eax, ebx, ecx, edx, esi, edi); -#ifndef NDEBUG -/* Deliberately corrupt parameter regs not used by this hypercall. */ -switch ( hypercall_args_table[eax].compat ) - { -case 0 : ebx =0xdeadf00d ; fallthrough; -case 1 : ecx =0xdeadf00d ; fallthrough; -case 2 : edx =0xdeadf00d ; fallthrough; -case 3 : esi =0xdeadf00d ; fallthrough; -case 4 : edi =0xdeadf00d ; - } -#endif - curr->hcall_compat = true; - regs->eax = hvm_hypercall_table[eax].compat (ebx, ecx, edx, esi, edi); +call_handlers_hvm32 (eax, regs->eax, ebx, ecx, edx, esi, edi); curr->hcall_compat = false; -#ifndef NDEBUG -if ( !curr->hcall_preempted ) - { -/* Deliberately corrupt parameter regs used by this hypercall. */ -switch ( hypercall_args_table[eax].compat ) - { -case 5 : regs->rdi =0xdeadf00d ; fallthrough; -case 4 : regs->rsi =0xdeadf00d ; fallthrough; -case 3 : regs->rdx =0xdeadf00d ; fallthrough; -case 2 : regs->rcx =0xdeadf00d ; fallthrough; -case 1 : regs->rbx =0xdeadf00d ; - } - } -#endif +if ( !curr->hcall_preempted && regs->eax != -ENOSYS ) +clobber_regs32 (regs,get_nargs (hypercall_args_32, eax)); }hvmemul_cache_restore (curr, token);
@@ -327,31 +216,20 @@ int hvm_hypercall(struct cpu_user_regs *regs)enum mc_disposition hvm_do_multicall_call (struct mc_state *state) {struct vcpu *curr = current; -hypercall_fn_t *func =NULL ;if (hvm_guest_x86_mode (curr) ==8 ) {struct multicall_entry *call = &state->call; -if ( call->op <ARRAY_SIZE (hvm_hypercall_table) ) - func =array_access_nospec (hvm_hypercall_table, call->op).native; -if ( func ) - call->result =func (call->args[0 ], call->args[1 ], call->args[2 ], - call->args[3 ], call->args[4 ]); -else - call->result = -ENOSYS ; +call_handlers_hvm64 (call->op, call->result, call->args[0 ], call->args[1 ], + call->args[2 ], call->args[3 ], call->args[4 ]); }else {struct compat_multicall_entry *call = &state->compat_call; -if ( call->op <ARRAY_SIZE (hvm_hypercall_table) ) - func =array_access_nospec (hvm_hypercall_table, call->op).compat; -if ( func ) - call->result =func (call->args[0 ], call->args[1 ], call->args[2 ], - call->args[3 ], call->args[4 ]); -else - call->result = -ENOSYS ; +call_handlers_hvm32 (call->op, call->result, call->args[0 ], call->args[1 ], + call->args[2 ], call->args[3 ], call->args[4 ]); }return !hvm_get_cpl (curr) ? mc_continue : mc_preempt;
xen/arch/x86/hypercall.c +0 -59
65 lines not on this page · raw message
xen/arch/x86/pv/hypercall.c +17 -167
241 lines not on this page · raw message
xen/include/asm-x86/hypercall.h +41 -13
64 lines not on this page · raw message
Signature · 1 line
2.26.2
Re: [PATCH v2 07/15] xen: generate hypercall interface related code
In reply to Juergen GrossQuoted 23 lines · Juergen Gross
Instead of repeating similar data multiple times use a single source file and a generator script for producing prototypes and call sequences of the hypercalls.
As the script already knows the number of parameters used add generating a macro for populating an array with the number of parameters per hypercall.
Signed-off-by Juergen Gross <[email protected]>---
V2:
- splitplatform_opfor doe and compat prefixes (Jan Beulich)
- add "addline:" directive
- add priorities to handlers (Jan Beulich)--- .gitignore | 1 + xen/Makefile | 10 ++ xen/include/hypercall-defs.c | 285 +++++++++++++++++++++++++++++++ xen/scripts/gen_hypercall.awk | 306 ++++++++++++++++++++++++++++++++++ 4 files changed, 602 insertions(+)create mode 100644
xen/include/hypercall-defs.ccreate mode 100644xen/scripts/gen_hypercall.awk
...
Quoted 5 lines
xen/scripts/gen_hypercall.awk new file +0
-0
...
Quoted 17 lines
xen/scripts/gen_hypercall.awk new file +17
-0+ # Generate call sequences and args array contents + for (ca in caller) { + if (caller[ca] != 1) + continue; + for (pl = 1; pl <= n_prios[ca]; pl++) + p_list[pl] = prio_list[ca, pl]; + asort(p_list, p_list, "@val_num_asc"); + need_mask = 0; + # If any prio but the default one has more than 1 entry we need "mask" + for (pl = 1; pl < n_prios[ca]; pl++) { + if (prios[ca, p_list[pl]] > 1) + need_mask = 1; + } + printf("\n"); + printf("#define call_handlers_%s(num, ret, a1, a2, a3, a4, a5) \\\n", ca); + printf("{ \\\n"); + if (need_mask)
xen/scripts/gen_hypercall.awk line 280
Quoted 10 lines
xen/scripts/gen_hypercall.awk new file +10
-0+ printf(" uint64_t mask = 1ULL << num; \\\n"); + for (pl = 1; pl <= n_prios[ca]; pl++) { + if (prios[ca, p_list[pl]] > 1) { + if (pl < n_prios[ca]) { + printf("if ( likely(mask & (%s)) ) \\\n", prio_mask[ca, p_list[pl]]); + printf(" { \\\n"); + } + do_switch(ca, p_list[pl]); + if (pl < n_prios[ca]) + printf(" } \\\n");
I've found another optimization for the case of 2 hypercalls with the same priority: in this case "if ( ) ... else ..." is the better choice.
Quoted 7 lines
xen/scripts/gen_hypercall.awk new file +7
-0+ } else { + for (i = 1; i <= nc; i++) + if (call[i] == ca && call_prio[i] == p_list[pl]) { + printf("if ( likely(num == __HYPERVISOR_%s) ) \\\n", fn[call_fn[i]]); + printf(" { \\\n"); + do_call(call_fn[i], call_p[i]); + printf(" } \\\n");
xen/scripts/gen_hypercall.awk line 297
Quoted 10 lines
xen/scripts/gen_hypercall.awk new file +10
-0+ } + } + if (pl < n_prios[ca] || prios[ca, pl] == 1) + printf(" else "); + } + if (prios[ca, p_list[n_prios[ca]]] == 1) { + printf("\\\n"); + printf(" ret = -ENOSYS; \\\n"); + } + printf("}\n");
Here a "delete p_list;" is missing in order to avoid stale array elements in the next round.
I'll send an update of this patch.
Juergen
Re: [PATCH v2 07/15] xen: generate hypercall interface related code
In reply to Juergen GrossHi Juergen,
Quoted 617 lines · Juergen Gross
Instead of repeating similar data multiple times use a single source file and a generator script for producing prototypes and call sequences of the hypercalls.
As the script already knows the number of parameters used add generating a macro for populating an array with the number of parameters per hypercall.
Signed-off-by Juergen Gross <[email protected]>---
V2:
- splitplatform_opfor doe and compat prefixes (Jan Beulich)
- add "addline:" directive
- add priorities to handlers (Jan Beulich)--- .gitignore | 1 + xen/Makefile | 10 ++ xen/include/hypercall-defs.c | 285 +++++++++++++++++++++++++++++++ xen/scripts/gen_hypercall.awk | 306 ++++++++++++++++++++++++++++++++++ 4 files changed, 602 insertions(+) create mode 100644 xen/include/hypercall-defs.c create mode 100644 xen/scripts/gen_hypercall.awk.gitignore +1
-0@@ -336,6 +336,7 @@ xen/include/public/public xen/include/xen/*.new xen/include/xen/acm_policy.h xen/include/xen/compile.h +xen/include/xen/hypercall-defs.h xen/include/xen/lib/x86/cpuid-autogen.h xen/test/livepatch/config.h xen/test/livepatch/expect_config.hxen/Makefile +10
-0@@ -383,6 +383,7 @@ _clean: delete-unfresh-files -o -name "*.gcno" -o -name ".*.cmd" -o -name "lib.a" \) -exec rm -f {} \; rm -f include/asm $(TARGET) $(TARGET).gz $(TARGET).efi $(TARGET).efi.map $(TARGET)-syms $(TARGET)-syms.map *~ core rm -f asm-offsets.s include/asm-*/asm-offsets.h + rm -f include/xen/hypercall-defs.h include/hypercall-defs.i rm -f .banner .allconfig.tmp .PHONY: _distclean@@ -405,6 +406,7 @@ $(TARGET): delete-unfresh-files $(MAKE) -f $(BASEDIR)/Rules.mk -C include $(MAKE) -f $(BASEDIR)/Rules.mk -C arch/$(TARGET_ARCH) include $(MAKE) -f $(BASEDIR)/Rules.mk include/asm-$(TARGET_ARCH)/asm-offsets.h + $(MAKE) -f $(BASEDIR)/Rules.mk include/xen/hypercall-defs.h $(MAKE) -f $(BASEDIR)/Rules.mk -C arch/$(TARGET_ARCH) $@ # drivers/char/console.o contains static banner/compile info. Blow it away.@@ -466,6 +468,14 @@ include/asm-$(TARGET_ARCH)/asm-offsets.h: asm-offsets.s echo ""; \ echo "#endif") <$< >$@ +quiet_cmd_genhyp = GEN $@ +define cmd_genhyp + awk -f scripts/gen_hypercall.awk <$< >$@ +endef + +include/xen/hypercall-defs.h: include/hypercall-defs.i scripts/gen_hypercall.awk FORCE + $(call if_changed,genhyp) + SUBDIRS = xsm arch/$(TARGET_ARCH) common drivers lib test define all_sources ( find include/asm-$(TARGET_ARCH) -name '*.h' -print; \xen/include/hypercall-defs.c new file +285
-0@@ -0,0 +1,285 @@ +/* +* Hypercall interface description: +* Used by scripts/gen_hypercall.awk to generate hypercall prototypes and call +* sequences. +* +* Syntax is like a prototype, but without return type and without the ";" at +* the end. Pointer types will be automatically converted to use the +* XEN_GUEST_HANDLE_PARAM() macro. Handlers with no parameters just use a +* definition like "fn()". +* Hypercall/function names are without the leading "__HYPERVISOR_"/"do_" +* strings. +* +* The return type of a class of prototypes using the same prefix is set via: +* rettype: <prefix> <type> +* Default return type is "long". A return type for a prefix can be set only +* once and it needs to be set before that prefix is being used via the +* "prefix:" directive. +* +* The prefix of the prototypes is set via a line: +* prefix: <prefix> ... +* Multiple prefixes are possible (restriction see below). Prefixes are without +* a trailing "_". The current prefix settings are active until a new "prefix:" +* line. +* +* Caller macros are suffixed with a selectable name via lines like: +* caller: <suffix> +* When a caller suffix is active, there is only one active prefix allowed. +* +* With a "defhandle:" line it is possible to add a DEFINE_XEN_GUEST_HANDLE() +* to the generated header: +* defhandle: <handle-type> [<type>] +* Without specifying <type> only a DEFINE_XEN_GUEST_HANDLE(<handle-type>) +* will be generated, otherwise it will be a +* __DEFINE_XEN_GUEST_HANDLE(<handle-type>, <type>) being generated. Note that +* the latter will include the related "const" handle "const_<handle-type>". +* +* In order to support using coding style compliant pointers in the +* prototypes it is possible to add translation entries to generate the correct +* handle types: +* handle: <handle-type> <type> +* This will result in the prototype translation from "<type> *" to +* "XEN_GUEST_HANDLE_PARAM(<handle-type>)". +* +* A verbatim line can be added via: +* addline: <line-contents> +* Its position is kept in regard of other "handle:" and "defhandle:" lines. +* +* The hypercall handler calling code will be generated from a final table in +* the source file, which is started via the line: +* table: <caller> <caller> ... +* with the <caller>s specifying the designated caller macro of each column of +* the table. Any column of a <caller> not having been set via a "caller:" +* line will be ignored. +* The first column of the table contains the hypercall/prototype, each +* <caller> column contains the prefix for the function to use for that caller. +* A function prefix can be annotated with a priority by adding ":<prio>" to it +* ("1" being the highest priority, higher numbers mean lower priority, no +* priority specified is the lowest priority). The generated code will try to +* achieve better performance for calling high priority handlers. +* A column not being supported by a <caller> is marked with "-". Lines with all +* entries being "-" after removal of inactive <caller> columns are ignored. +* +* This file is being preprocessed using $(CPP), so #ifdef CONFIG_* conditionals +* are possible. +*/ + +#ifdef CONFIG_HVM +#define PREFIX_hvm hvm +#else +#define PREFIX_hvm +#endif + +#ifdef CONFIG_COMPAT +#define PREFIX_compat compat +rettype: compat int +#else +#define PREFIX_compat +#endif + +#ifdef CONFIG_ARM +#define PREFIX_dep dep +#else +#define PREFIX_dep +#endif + +handle: uint unsigned int +handle: const_void const void +handle: const_char const char + +#ifdef CONFIG_COMPAT +defhandle: multicall_entry_compat_t +#ifndef CONFIG_PV_SHIM_EXCLUSIVE +addline: typedef struct compat_platform_op compat_platform_op_t; +defhandle: compat_platform_op_t +#endif +#endif +#ifdef CONFIG_PV32 +defhandle:trap_info_compat_t +defhandle: physdev_op_compat_t +#endif + +prefix: do PREFIX_hvm PREFIX_compat +physdev_op(int cmd, void *arg) +#if defined(CONFIG_GRANT_TABLE) || defined(CONFIG_PV_SHIM) +grant_table_op(unsigned int cmd, void *uop, unsigned int count) +#endif + +prefix: do PREFIX_hvm +memory_op(unsigned long cmd, void *arg) + +prefix: do PREFIX_compat +xen_version(int cmd, void *arg) +vcpu_op(int cmd, unsigned int vcpuid, void *arg) +sched_op(int cmd, void *arg) +xsm_op(void *op) +callback_op(int cmd, const void *arg) +#ifdef CONFIG_ARGO +argo_op(unsigned int cmd, void *arg1, void *arg2, unsigned long arg3, unsigned long arg4) +#endif +#ifdef CONFIG_KEXEC +kexec_op(unsigned int op, void *uarg) +#endif +#ifdef CONFIG_PV +iret() +nmi_op(unsigned int cmd, void *arg) +#ifdef CONFIG_XENOPROF +xenoprof_op(int op, void *arg) +#endif +#endif /* CONFIG_PV */ + +#ifdef CONFIG_COMPAT +prefix: compat +set_timer_op(uint32_t lo, int32_t hi) +multicall(multicall_entry_compat_t *call_list, uint32_t nr_calls) +memory_op(unsigned int cmd, void *arg) +#ifdef CONFIG_IOREQ_SERVER +dm_op(domid_t domid, unsigned int nr_bufs, void *bufs) +#endif +mmuext_op(void *arg, unsigned int count, uint *pdone, unsigned int foreigndom) +#ifdef CONFIG_PV32 +set_trap_table(trap_info_compat_t *traps) +set_gdt(unsigned int *frame_list, unsigned int entries) +set_callbacks(unsigned long event_selector, unsigned long event_address, unsigned long failsafe_selector, unsigned long failsafe_address) +update_descriptor(uint32_t pa_lo, uint32_t pa_hi, uint32_t desc_lo, uint32_t desc_hi) +update_va_mapping(unsigned int va, uint32_t lo, uint32_t hi, unsigned int flags) +physdev_op_compat(physdev_op_compat_t *uop) +update_va_mapping_otherdomain(unsigned int va, uint32_t lo, uint32_t hi, unsigned int flags, domid_t domid) +#endif +#ifndef CONFIG_PV_SHIM_EXCLUSIVE +platform_op(compat_platform_op_t *u_xenpf_op) +#endif +#endif /* CONFIG_COMPAT */ + +#if defined(CONFIG_PV) || defined(CONFIG_ARM) +prefix: do PREFIX_dep +event_channel_op_compat(evtchn_op_t *uop) +physdev_op_compat(physdev_op_t *uop) +/* Legacy hypercall (as of 0x00030101). */ +sched_op_compat(int cmd, unsigned long arg) +#endif + +prefix: do +set_timer_op(s_time_t timeout) +console_io(unsigned int cmd, unsigned int count, char *buffer) +vm_assist(unsigned int cmd, unsigned int type) +event_channel_op(int cmd, void *arg) +mmuext_op(mmuext_op_t *uops, unsigned int count, unsigned int *pdone, unsigned int foreigndom) +multicall(multicall_entry_t *call_list, unsigned int nr_calls) +#ifdef CONFIG_PV +mmu_update(mmu_update_t *ureqs, unsigned int count, unsigned int *pdone, unsigned int foreigndom) +stack_switch(unsigned long ss, unsigned long esp) +fpu_taskswitch(int set) +set_debugreg(int reg, unsigned long value) +get_debugreg(int reg) +set_segment_base(unsigned int which, unsigned long base) +mca(xen_mc_t *u_xen_mc) +set_trap_table(const_trap_info_t *traps) +set_gdt(xen_ulong_t *frame_list, unsigned int entries) +set_callbacks(unsigned long event_address, unsigned long failsafe_address, unsigned long syscall_address) +update_descriptor(uint64_t gaddr, seg_desc_t desc) +update_va_mapping(unsigned long va, uint64_t val64, unsigned long flags) +update_va_mapping_otherdomain(unsigned long va, uint64_t val64, unsigned long flags, domid_t domid) +#endif +#ifdef CONFIG_IOREQ_SERVER +dm_op(domid_t domid, unsigned int nr_bufs, xen_dm_op_buf_t *bufs) +#endif +#ifndef CONFIG_PV_SHIM_EXCLUSIVE +sysctl(xen_sysctl_t *u_sysctl) +domctl(xen_domctl_t *u_domctl) +paging_domctl_cont(xen_domctl_t *u_domctl) +platform_op(xen_platform_op_t *u_xenpf_op) +#endif +#ifdef CONFIG_HVM +hvm_op(unsigned long op, void *arg) +#endif +#ifdef CONFIG_HYPFS +hypfs_op(unsigned int cmd, const char *arg1, unsigned long arg2, void *arg3, unsigned long arg4) +#endif +#ifdef CONFIG_X86 +xenpmu_op(unsigned int op, xen_pmu_params_t *arg) +#endif + +#ifdef CONFIG_PV +caller: pv64 +#ifdef CONFIG_PV32 +caller: pv32 +#endif +#endif +#if defined(CONFIG_HVM) && defined(CONFIG_X86) +caller: hvm64 +#ifdef CONFIG_COMPAT +caller: hvm32 +#endif +#endif +#ifdef CONFIG_ARM +caller: arm +#endif + +table: pv32 pv64 hvm32 hvm64 arm +set_trap_table compat do - - - +mmu_update do:1 do:1 - - - +set_gdt compat do - - - +stack_switch do:2 do:2 - - - +set_callbacks compat do - - - +fpu_taskswitch do do - - - +sched_op_compat do do - - dep +#ifndef CONFIG_PV_SHIM_EXCLUSIVE +platform_op compat do compat do do +#endif +set_debugreg do do - - - +get_debugreg do do - - - +update_descriptor compat do - - - +memory_op compat do hvm hvm do +multicall compat:2 do:2 compat do do +update_va_mapping compat do - - - +set_timer_op compat do compat do - +event_channel_op_compat do do - - dep +xen_version compat do compat do do +console_io do do do do do +physdev_op_compat compat do - - dep +#if defined(CONFIG_GRANT_TABLE) || defined(CONFIG_PV_SHIM) +grant_table_op compat do hvm hvm do +#endif +vm_assist do do do do do +update_va_mapping_otherdomain compat do - - - +iret compat:1 do:1 - - - +vcpu_op compat do compat:1 do:1 do +set_segment_base do:2 do:2 - - - +#ifdef CONFIG_PV +mmuext_op compat:2 do:2 compat do - +#endif +xsm_op compat do compat do do +nmi_op compat do - - - +sched_op compat do compat do do +callback_op compat do - - - +#ifdef CONFIG_XENOPROF +xenoprof_op compat do - - - +#endif +event_channel_op do do do:1 do:1 do +physdev_op compat do hvm hvm do +#ifdef CONFIG_HVM +hvm_op do do do do do +#endif +#ifndef CONFIG_PV_SHIM_EXCLUSIVE +sysctl do do do do do +domctl do do do do do +#endif +#ifdef CONFIG_KEXEC +kexec_op compat do - - - +#endif +tmem_op - - - - - +#ifdef CONFIG_ARGO +argo_op compat do compat do do +#endif +xenpmu_op do do do do - +#ifdef CONFIG_IOREQ_SERVER +dm_op compat do compat do do +#endif +#ifdef CONFIG_HYPFS +hypfs_op do do do do do +#endif +mca do do - - - +#ifndef CONFIG_PV_SHIM_EXCLUSIVE +paging_domctl_cont do do do do - +#endifxen/scripts/gen_hypercall.awk new file +250
-0@@ -0,0 +1,306 @@ +# awk script to generate hypercall handler prototypes and a macro for doing +# the calls of the handlers inside a switch() statement. + +BEGIN { + printf("/* Generated file, do not edit! */\n\n"); + e = 0; + n = 0; + p = 0; + nc = 0; +} + +# Issue error to stderr +function do_err(msg) { + print "Error: "msg": "$0 >"/dev/stderr"; + exit 1; +} + +# Generate handler call +function do_call(f, p, i) { + printf(" ret = %s_%s(", pre[f, p], fn[f]); + for (i = 1; i <= n_args[f]; i++) { + if (i > 1) + printf(", "); + if (ptr[f, i]) + printf("(XEN_GUEST_HANDLE_PARAM(%s)){ _p(a%d) }", typ[f, i], i); + else + printf("(%s)(a%d)", typ[f, i], i); + } + printf("); \\\n"); +} + +# Generate case statement for call +function do_case(f, p) { + printf(" case __HYPERVISOR_%s: \\\n", fn[f]); + do_call(f, p); + printf(" break; \\\n"); +} + +# Generate switch statement for calling handlers +function do_switch(ca, p, i) { + printf(" switch ( num ) \\\n"); + printf(" { \\\n"); + for (i = 1; i <= nc; i++) + if (call[i] == ca && call_prio[i] == p) + do_case(call_fn[i], call_p[i]); + printf(" default: \\\n"); + printf(" ret = -ENOSYS; \\\n"); + printf(" break; \\\n"); + printf(" } \\\n"); +} + +function rest_of_line(par, i, val) { + val = $(par); + for (i = par + 1; i <= NF; i++) + val = val " " $(i); + return val; +} + +# Handle comments (multi- and single line) +$1 == "/*" { + comment = 1; +} +comment == 1 { + if ($(NF) == "*/") comment = 0; + next; +} + +# Skip preprocessing artefacts +$1 == "extern" { + next; +} +/^#/ { + next; +} + +# Drop empty lines +NF == 0 { + next; +} + +# Handle "handle:" line +$1 == "handle:" { + if (NF < 3) + do_err("\"handle:\" requires at least two parameters"); + val = rest_of_line(3); + xlate[val] = $2; + next; +} + +# Handle "defhandle:" line +$1 == "defhandle:" { + if (NF < 2) + do_err("\"defhandle:\" requires at least one parameter"); + e++; + if (NF == 2) { + emit[e] = sprintf("DEFINE_XEN_GUEST_HANDLE(%s);", $2); + } else { + val = rest_of_line(3); + emit[e] = sprintf("__DEFINE_XEN_GUEST_HANDLE(%s, %s);", $2, val); + xlate[val] = $2; + } + next; +} + +# Handle "addline:" line +$1 == "addline:" { + if (NF < 2) + do_err("\"addline:\" requires at least one parameter"); + e++; + emit[e] = rest_of_line(2); + next; +} + +# Handle "rettype:" line +$1 == "rettype:" { + if (NF < 3) + do_err("\"rettype:\" requires at least two parameters"); + if ($2 in rettype) + do_err("rettype can be set only once for each prefix"); + rettype[$2] = rest_of_line(3); + next; +} + +# Handle "caller:" line +$1 == "caller:" { + caller[$2] = 1; + next; +} + +# Handle "prefix:" line +$1 == "prefix:" { + p = NF - 1; + for (i = 2; i <= NF; i++) { + prefix[i - 1] = $(i); + if (!(prefix[i - 1] in rettype)) + rettype[prefix[i - 1]] = "long"; + } + next; +} + +# Handle "table:" line +$1 == "table:" { + table = 1; + for (i = 2; i <= NF; i++) + col[i - 1] = $(i); + n_cols = NF - 1; + next; +} + +# Handle table definition line +table == 1 { + if (NF != n_cols + 1) + do_err("Table definition line has wrong number of fields"); + for (c = 1; c <= n_cols; c++) { + if (caller[col[c]] != 1) + continue; + if ($(c + 1) == "-") + continue; + pref = $(c + 1); + idx = index(pref, ":"); + if (idx == 0) + prio = 100; + else { + prio = substr(pref, idx + 1) + 0; + pref = substr(pref, 1, idx - 1); + if (prio >= 100 || prio < 1) + do_err("Priority must be in the range 1..99"); + } + fnd = 0; + for (i = 1; i <= n; i++) { + if (fn[i] != $1) + continue; + for (j = 1; j <= n_pre[i]; j++) { + if (pre[i, j] == pref) { + prios[col[c], prio]++; + if (prios[col[c], prio] == 1) { + n_prios[col[c]]++; + prio_list[col[c], n_prios[col[c]]] = prio; + prio_mask[col[c], prio] = "(1ULL << __HYPERVISOR_"$1")"; + } else + prio_mask[col[c], prio] = prio_mask[col[c], prio] " | (1ULL << __HYPERVISOR_"$1")"; + nc++; + call[nc] = col[c]; + call_fn[nc] = i; + call_p[nc] = j; + call_prio[nc] = prio; + fnd = 1; + } + } + } + if (fnd == 0) + do_err("No prototype for prefix/hypercall combination"); + } + next; +} + +# Prototype line +{ + bro = index($0, "("); + brc = index($0, ")"); + if (bro < 2 || brc < bro) + do_err("No valid prototype line"); + n++; + fn[n] = substr($0, 1, bro - 1); + n_pre[n] = p; + for (i = 1; i <= p; i++) + pre[n, i] = prefix[i]; + args = substr($0, bro + 1, brc - bro - 1); + n_args[n] = split(args, a, ","); + if (n_args[n] > 5) + do_err("Too many parameters"); + for (i = 1; i <= n_args[n]; i++) { + sub("^ *", "", a[i]); # Remove leading white space + sub(" +", " ", a[i]); # Replace multiple spaces with single ones + sub(" *$", "", a[i]); # Remove trailing white space + ptr[n, i] = index(a[i], "*"); # Is it a pointer type? + sub("[*]", "", a[i]); # Remove "*" + if (index(a[i], " ") == 0) + do_err("Parameter with no type or no name"); + typ[n, i] = a[i]; + sub(" [^ ]+$", "", typ[n, i]); # Remove parameter name + if (ptr[n, i] && (typ[n, i] in xlate)) + typ[n, i] = xlate[typ[n, i]]; + arg[n, i] = a[i]; + sub("^([^ ]+ )+", "", arg[n, i]); # Remove parameter type + } +} + +# Generate the output +END { + # Verbatim generated lines + for (i = 1; i <= e; i++) + printf("%s\n", emit[i]); + printf("\n"); + # Generate prototypes + for (i = 1; i <= n; i++) { + for (p = 1; p <= n_pre[i]; p++) { + printf("%s %s_%s(", rettype[pre[i, p]], pre[i, p], fn[i]); + if (n_args[i] == 0) + printf("void"); + else + for (j = 1; j <= n_args[i]; j++) { + if (j > 1) + printf(", "); + if (ptr[i, j]) + printf("XEN_GUEST_HANDLE_PARAM(%s)", typ[i, j]); + else + printf("%s", typ[i, j]); + printf(" %s", arg[i, j]); + }
xen/scripts/gen_hypercall.awk line 260
Quoted 10 lines
xen/scripts/gen_hypercall.awk new file +10
-0+ printf(");\n"); + } + } + # Generate call sequences and args array contents + for (ca in caller) { + if (caller[ca] != 1) + continue; + for (pl = 1; pl <= n_prios[ca]; pl++) + p_list[pl] = prio_list[ca, pl]; + asort(p_list, p_list, "@val_num_asc");
Just to let you know:
asort is a gawk built-in. I was trying to build your changes on my aarch64 chroot environment. I did not have gawk installed and I got an error when building xen:
make[4]: Leaving directory '/home/micorz01/xen_main/xen/include'
GEN include/xen/hypercall-defs.h
awk: scripts/gen_hypercall.awk: line 308: function asort never defined Makefile:477: recipe for target 'include/xen/hypercall-defs.h' failed
During configure step I did not get any failure that gawk is not installed. If you are making use of gawk built-ins, shouldn't configure test for it?
Quoted 37 lines
xen/scripts/gen_hypercall.awk new file +36
-0+ need_mask = 0; + # If any prio but the default one has more than 1 entry we need "mask" + for (pl = 1; pl < n_prios[ca]; pl++) { + if (prios[ca, p_list[pl]] > 1) + need_mask = 1; + } + printf("\n"); + printf("#define call_handlers_%s(num, ret, a1, a2, a3, a4, a5) \\\n", ca); + printf("{ \\\n"); + if (need_mask) + printf(" uint64_t mask = 1ULL << num; \\\n"); + for (pl = 1; pl <= n_prios[ca]; pl++) { + if (prios[ca, p_list[pl]] > 1) { + if (pl < n_prios[ca]) { + printf("if ( likely(mask & (%s)) ) \\\n", prio_mask[ca, p_list[pl]]); + printf(" { \\\n"); + } + do_switch(ca, p_list[pl]); + if (pl < n_prios[ca]) + printf(" } \\\n"); + } else { + for (i = 1; i <= nc; i++) + if (call[i] == ca && call_prio[i] == p_list[pl]) { + printf("if ( likely(num == __HYPERVISOR_%s) ) \\\n", fn[call_fn[i]]); + printf(" { \\\n"); + do_call(call_fn[i], call_p[i]); + printf(" } \\\n"); + } + } + if (pl < n_prios[ca] || prios[ca, pl] == 1) + printf(" else "); + } + if (prios[ca, p_list[n_prios[ca]]] == 1) { + printf("\\\n"); + printf(" ret = -ENOSYS; \\\n"); + }
xen/scripts/gen_hypercall.awk line 306
Quoted 10 lines
xen/scripts/gen_hypercall.awk new file +10
-0+ printf("}\n"); + printf("\n"); + printf("#define hypercall_args_%s \\\n", ca); + printf("{ \\\n"); + for (i = 1; i <= nc; i++) + if (call[i] == ca) + printf("[__HYPERVISOR_%s] = %d, \\\n", fn[call_fn[i]], n_args[call_fn[i]]); + printf("}\n"); + } +}
Cheers,
Michal
Re: [PATCH v2 07/15] xen: generate hypercall interface related code
Quoted 12 lines · Michal Orzel
Hi Juergen,
Quoted 9 lines · Juergen Gross
Instead of repeating similar data multiple times use a single source file and a generator script for producing prototypes and call sequences of the hypercalls.
As the script already knows the number of parameters used add generating a macro for populating an array with the number of parameters per hypercall.
Signed-off-by Juergen Gross <[email protected]>
...
Quoted 12 lines
xen/scripts/gen_hypercall.awk line 260
Quoted 7 lines
xen/scripts/gen_hypercall.awk new file +7
-0+ # Generate call sequences and args array contents + for (ca in caller) { + if (caller[ca] != 1) + continue; + for (pl = 1; pl <= n_prios[ca]; pl++) + p_list[pl] = prio_list[ca, pl]; + asort(p_list, p_list, "@val_num_asc");Just to let you know:
asort is a gawk built-in. I was trying to build your changes on my aarch64 chroot environment. I did not have gawk installed and I got an error when building xen:
Quoted 7 lines
make[4]: Leaving directory '
/home/micorz01/xen_main/xen/include'
GENinclude/xen/hypercall-defs.h
awk:scripts/gen_hypercall.awk: line 308: function asort never defined Makefile:477: recipe for target 'include/xen/hypercall-defs.h' failedDuring configure step I did not get any failure that gawk is not installed. If you are making use of gawk built-ins, shouldn't configure test for it?
I just checked again and I think this is the only gawk specific feature I'm using.
I'll replace asort() with a manual sort in order to drop the gawk dependency.
Thanks for the notice,
Juergen
Hi Juergen,
Quoted 18 lines · Juergen Gross
In order to avoid indirect function calls on the hypercall path as much as possible this series is removing the hypercall function tables and is replacing the hypercall handler calls via the function array by automatically generated call macros.
Another by-product of generating the call macros is the automatic generating of the hypercall handler prototypes from the same data base which is used to generate the macros.
This has the additional advantage of using type safe calls of the handlers and to ensure related handler (e.g. PV and HVM ones) share the same prototypes.
A very brief performance test (parallel build of the Xen hypervisor in a 6 vcpu guest) showed a very slim improvement (less than 1%) of the performance with the patches applied. The test was performed using a PV and a PVH guest.
Quoted 4 lines
Changes in V2:
- new patches 6, 14, 15
- patch 7: support hypercall priorities for faster code
- comments addressed
For the ARM part:
Apart from the issue I found and reported in patch 7/15, the build was successful. I tested the following basics also successfully:
-booting a dom0
-booting domUs
-networking between guest and dom0 using NAT
-stressing hypercall xen_version
so,
Cheers,
Michal
Quoted 34 lines · Michal Orzel
Hi Juergen,
Quoted 18 lines · Juergen Gross
In order to avoid indirect function calls on the hypercall path as much as possible this series is removing the hypercall function tables and is replacing the hypercall handler calls via the function array by automatically generated call macros.
Another by-product of generating the call macros is the automatic generating of the hypercall handler prototypes from the same data base which is used to generate the macros.
This has the additional advantage of using type safe calls of the handlers and to ensure related handler (e.g. PV and HVM ones) share the same prototypes.
A very brief performance test (parallel build of the Xen hypervisor in a 6 vcpu guest) showed a very slim improvement (less than 1%) of the performance with the patches applied. The test was performed using a PV and a PVH guest.
Quoted 4 lines
Changes in V2:
- new patches 6, 14, 15
- patch 7: support hypercall priorities for faster code
- comments addressedFor the ARM part:
Apart from the issue I found and reported in patch 7/15, the build was successful. I tested the following basics also successfully:(quoted diff) +0
-4-booting a dom0 -booting domUs -networking between guest and dom0 using NAT -stressing hypercall xen_version
Quoted 3 lines
so,
Tested-by Michal Orzel <[email protected]>
Thanks, much appreciated!
Juergen
Re: [PATCH v2 03/15] xen: harmonize return types of hypercall handlers
In reply to Juergen GrossQuoted 18 lines · Juergen Gross
Today most hypercall handlers have a return type of long, while the compat ones return an int. There are a few exceptions from that rule, however.
Get rid of the exceptions by letting compat handlers always return int and others always return long.
For the compat hvm case use eax instead of rax for the stored result as it should have been from the beginning.
Additionally move some prototypes to
include/asm-x86/hypercall.has they are x86 specific. Move thedo_physdev_op()prototype from both architecture dependant headers to the common one. Move thecompat_platform_op()prototype to the common header.Switch some non style compliant types (u32, s32, s64) to style compliant ones.
Quoted 8 lines
Rename
paging_domctl_continuation()todo_paging_domctl_cont()and add a matching define for the associated hypercall.Make
do_callback_op()andcompat_callback_op()more similar by adding the const attribute to compat_callback_op()'s 2nd parameter.Change the type of the cmd parameter for [do|compat]_kexec_op() to unsigned int, as this is more appropriate for the compat case.
I continue to have reservations here, but I'll leave ack-ing of this to the kexec maintainer.
Quoted 1 line
Signed-off-by Juergen Gross <[email protected]>
with one further nit:
xen/arch/x86/x86_64/platform_hypercall.c line 10
Quoted 10 lines
xen/arch/x86/x86_64/platform_hypercall.c +2
-0@@ -4,10 +4,11 @@EMIT_FILE ; +#include <xen/hypercall.h> +#include <xen/types.h> #include <xen/lib.h> #include <compat/platform.h>
Would have been nice if the addition was done such that the result was properly sorted; one way to do that would be to simply omit xen/types.h which already gets included by xen/lib.h (and very likely always will be).
Also I'm not convinced the do_get_debugreg() hoops are really useful to retain if one way or another we need to rely on implementation defined behavior anyway.
Jan
Re: [PATCH v2 05/15] xen: don't include asm/hypercall.h from C sources
In reply to Juergen GrossQuoted 9 lines · Juergen Gross
Instead of including
asm/hypercall.halways usexen/hypercall.h. Additionally includexen/hypercall.hfrom all sources containing a hypercall handler.This prepares for generating the handlers' prototypes at build time.
Add a guard in
asm/hypercall.hto catch direct inclusion.Signed-off-by Juergen Gross <[email protected]>
Re: [PATCH v2 06/15] add .gitignore entries for *.[is] below xen
In reply to Juergen GrossQuoted 10 lines · Juergen Gross
Instead of listing each single file with .s or .i suffixes in .gitignore use pattern based entries. Restrict those to the xen directory as we have e.g.
tools/libs/stat/bindings/swig/xenstat.iin our tree.Below xen the pattern based entries are fine, as we have pattern rules for creating *.s and *.i files in
xen/Rules.mk.Suggested-by Jan Beulich <[email protected]>Signed-off-by Juergen Gross <[email protected]>
Re: [PATCH v2 09/15] x86/pv-shim: don't modify hypercall table
In reply to Juergen GrossQuoted 10 lines · Juergen Gross
When running as pv-shim the hypercall is modified today in order to replace the functions for
__HYPERVISOR_event_channel_opand__HYPERVISOR_grant_table_ophypercalls.Change this to call the related functions from the normal handlers instead when running as shim. The performance implications are not really relevant, as a normal production hypervisor will not be configured to support shim mode, so the related calls will be dropped due to optimization of the compiler.
Quoted 5 lines
Note that for the
CONFIG_PV_SHIM_EXCLUSIVEcase there is a dummy wrapperdo_grant_table_op()needed, as in this casegrant_table.cisn't being built.Signed-off-by Juergen Gross <[email protected]>
albeit with a remark:
xen/common/event_channel.c long do_event_channel_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) · line 1200
Quoted 8 lines
xen/common/event_channel.c +4
-0@@ -1190,6 +1194,11 @@ long do_event_channel_op(int cmd, XEN_GUEST_HANDLE_PARAM(void) arg) {int rc; +#ifdef CONFIG_PV_SHIM +if ( pv_shim ) +return pv_shim_event_channel_op (cmd, arg); +#endif
At the example of this, this is sub-optimal: In !PV_SHIM_EXCLUSIVE this would imo better be unlikely(pv_shim). If it was just for the positive forms, the annotation could actually be included in pv_shim itself:
extern bool pv_shim;
#define pv_shim unlikely(pv_shim)
but this wouldn't necessarily play well with e.g. "if ( !pv_shim )".
As I would hope compilers don't mind constructs like "unlikely(1)", I'd like to suggest considering to add likely() / unlikely() on this and similar paths you add here.
Jan
Re: [PATCH v2 11/15] xen/x86: call hypercall handlers via generated macro
In reply to Juergen GrossQuoted 11 lines · Juergen Gross
Instead of using a function table use the generated macros for calling the appropriate hypercall handlers.
This is beneficial to performance and avoids speculation issues.
With calling the handlers using the correct number of parameters now it is possible to do the parameter register clobbering in the NDEBUG case after returning from the handler. With the additional generated data the hard coded hypercall_args_table[] can be replaced by tables using the generated number of parameters.
Quoted 5 lines
Note that this change modifies behavior of clobbering registers in a minor way: in case a hypercall is returning
-ENOSYSfor any reason the parameter registers will no longer be clobbered. This should be of no real concern, as those cases ought to be extremely rare and reuse of the registers in those cases seems rather far fetched.
Considering mem-op where certain sub-ops can return huge positive values, may I suggest to amend -ENOSYS by "(or the unsigned equivalent thereof)" to make clear that this case was also recognized/considered?
xen/include/asm-x86/hypercall.h compat_common_vcpu_op( · line 48
Quoted 8 lines
xen/include/asm-x86/hypercall.h +4
-0@@ -55,4 +42,45 @@ compat_common_vcpu_op(#endif /* CONFIG_COMPAT */ +#ifndef NDEBUG +static inline unsigned int get_nargs (const unsigned char *tbl,unsigned int c) +{ +return tbl[c];
While maybe not overly relevant in debug builds, it doesn't cost us much to use array_access_nospec() here, so I'd like to ask for that to be switched to (replacing the original array_index_nospec() that you remove). Preferably with this adjustment
Jan
[4.16?] Re: [PATCH v2 13/15] xen/x86: add hypercall performance counters for hvm, correct pv
In reply to Juergen GrossIan,
Quoted 10 lines · Juergen Gross
The HVM hypercall handler is missing incrementing the per hypercall counters. Add that.
The counters for PV are handled wrong, as they are not using
perf_incra()with the number of the hypercall as index, but are incrementing the first hypercall entry (set_trap_table) for each hypercall. Fix that.Signed-off-by Juergen Gross <[email protected]>Reviewed-by Jan Beulich <[email protected]>
this looks to be independent of all earlier patches in this series, and I'd like to suggest to at least consider taking this as a low- risk bug fix for 4.16. Thoughts?
Jan
Quoted 32 lines
--- xen/arch/x86/hvm/hypercall.c | 2 ++ xen/arch/x86/pv/hypercall.c | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-)xen/arch/x86/hvm/hypercall.c +2
-0@@ -210,6 +210,8 @@ int hvm_hypercall(struct cpu_user_regs *regs)ioreq_signal_mapcache_invalidate (); } +perfc_incra (hypercalls, eax); +return curr->hcall_preempted ? HVM_HCALL_preempted : HVM_HCALL_completed; }xen/arch/x86/pv/hypercall.c +1
-1@@ -102,7 +102,7 @@ _pv_hypercall(struct cpu_user_regs *regs, bool compat)if ( curr->hcall_preempted ) regs->rip -=2 ; -perfc_incr (hypercalls); +perfc_incra (hypercalls, eax); }enum mc_disposition pv_do_multicall_call (struct mc_state *state)
Re: [PATCH v2 14/15] xen: drop calls_to_multicall performance counter
In reply to Juergen GrossQuoted 8 lines · Juergen Gross
The
calls_to_multicallperformance counter is basically redundant to the multicall hypercall counter. The only difference is the counting of continuation calls, which isn't really that interesting.Drop the
calls_to_multicallperformance counter.Suggested-by Jan Beulich <[email protected]>Signed-off-by Juergen Gross <[email protected]>
Re: [PATCH v2 15/15] tools/xenperf: update hypercall names
In reply to Juergen GrossQuoted 3 lines · Juergen Gross
The hypercall names need some update.
Signed-off-by Juergen Gross <[email protected]>
In the context of reviewing v1 of this series I came to make an almost identical patch (sole difference being that I took the opportunity and also switched the table itself to "static const char *const"), so
Quoted 15 lines
tools/misc/xenperf.c +5
-0@@ -57,6 +57,11 @@ const char *hypercall_name_table[64] =X (sysctl),X (domctl),X (kexec_op), +X (tmem_op), +X (argo_op), +X (xenpmu_op), +X (dm_op), +X (hypfs_op),X (arch_0),X (arch_1), X(arch_2),
Quoted 23 lines · Juergen Gross
In order to avoid indirect function calls on the hypercall path as much as possible this series is removing the hypercall function tables and is replacing the hypercall handler calls via the function array by automatically generated call macros.
Another by-product of generating the call macros is the automatic generating of the hypercall handler prototypes from the same data base which is used to generate the macros.
This has the additional advantage of using type safe calls of the handlers and to ensure related handler (e.g. PV and HVM ones) share the same prototypes.
A very brief performance test (parallel build of the Xen hypervisor in a 6 vcpu guest) showed a very slim improvement (less than 1%) of the performance with the patches applied. The test was performed using a PV and a PVH guest.
Changes in V2:
- new patches 6, 14, 15
- patch 7: support hypercall priorities for faster code
- comments addressed
Quoted 16 lines
Juergen Gross (15):
xen: limit number of hypercall parameters to 5
xen: movedo_vcpu_op()to arch specific code
xen: harmonize return types of hypercall handlers xen/x86: modifyhvm_memory_op()prototype
xen: don't includeasm/hypercall.hfrom C sources
add .gitignore entries for *.[is] below xen
xen: generate hypercall interface related code
xen: use generated prototypes for hypercall handlers x86/pv-shim: don't modify hypercall table
xen/x86: don't use hypercall table for calling compat hypercalls xen/x86: call hypercall handlers via generated macro xen/arm: call hypercall handlers via generated macro xen/x86: add hypercall performance counters for hvm, correct pv
xen: dropcalls_to_multicallperformance countertools/xenperf: update hypercall names
https://gitlab.com/xen-project/people/andyhhp/xen/-/jobs/1752237172
Something here causes
hypercall.c: In function 'hvm_hypercall':
hypercall.c:174:23: error: unused variable 'r8' [-Werror=unused-variable] 174 | unsigned long r8 = regs->r8;
| ^~
hypercall.c:190:22: error: unused variable 'edi' [-Werror=unused-variable] 190 | unsigned int edi = regs->edi;
| ^~~
cc1: all warnings being treated as errors
I suspect it will be "call hypercall handlers via generated macro", but I haven't investigated further.
~Andrew
Quoted 54 lines · Andrew Cooper
Quoted 23 lines · Juergen Gross
In order to avoid indirect function calls on the hypercall path as much as possible this series is removing the hypercall function tables and is replacing the hypercall handler calls via the function array by automatically generated call macros.
Another by-product of generating the call macros is the automatic generating of the hypercall handler prototypes from the same data base which is used to generate the macros.
This has the additional advantage of using type safe calls of the handlers and to ensure related handler (e.g. PV and HVM ones) share the same prototypes.
A very brief performance test (parallel build of the Xen hypervisor in a 6 vcpu guest) showed a very slim improvement (less than 1%) of the performance with the patches applied. The test was performed using a PV and a PVH guest.
Changes in V2:
- new patches 6, 14, 15
- patch 7: support hypercall priorities for faster code
- comments addressedQuoted 16 lines
Juergen Gross (15):
xen: limit number of hypercall parameters to 5
xen: movedo_vcpu_op()to arch specific code
xen: harmonize return types of hypercall handlers xen/x86: modifyhvm_memory_op()prototype
xen: don't includeasm/hypercall.hfrom C sources
add .gitignore entries for *.[is] below xen
xen: generate hypercall interface related code
xen: use generated prototypes for hypercall handlers x86/pv-shim: don't modify hypercall table
xen/x86: don't use hypercall table for calling compat hypercalls xen/x86: call hypercall handlers via generated macro xen/arm: call hypercall handlers via generated macro xen/x86: add hypercall performance counters for hvm, correct pv
xen: dropcalls_to_multicallperformance countertools/xenperf: update hypercall nameshttps://gitlab.com/xen-project/people/andyhhp/xen/-/jobs/1752237172
Something here causes
hypercall.c: In function 'hvm_hypercall':
hypercall.c:174:23: error: unused variable 'r8' [-Werror=unused-variable] 174 | unsigned long r8 =regs->r8;
| ^~
hypercall.c:190:22: error: unused variable 'edi' [-Werror=unused-variable] 190 | unsigned int edi =regs->edi;
| ^~~
cc1: all warnings being treated as errors
Quoted 2 lines
I suspect it will be "call hypercall handlers via generated macro", but I haven't investigated further.
I suspect that's a randconfig build with !HYPFS + !ARGO. The hypfs and argo hypercalls are the only ones with 5 parameters that HVM wires up. A similar issue ought to exist in PV hypercall handling though, as the compat form of update_va_mapping_otherdomain is the only other one taking 5 arguments.
As to possible solutions - besides maybe adding (void)r8 to the -ENOSYS path, I was wondering anyway in how far the local variables are still warranted to retain.
Jan
Quoted 64 lines · Jan Beulich
Quoted 54 lines · Andrew Cooper
Quoted 23 lines · Juergen Gross
In order to avoid indirect function calls on the hypercall path as much as possible this series is removing the hypercall function tables and is replacing the hypercall handler calls via the function array by automatically generated call macros.
Another by-product of generating the call macros is the automatic generating of the hypercall handler prototypes from the same data base which is used to generate the macros.
This has the additional advantage of using type safe calls of the handlers and to ensure related handler (e.g. PV and HVM ones) share the same prototypes.
A very brief performance test (parallel build of the Xen hypervisor in a 6 vcpu guest) showed a very slim improvement (less than 1%) of the performance with the patches applied. The test was performed using a PV and a PVH guest.
Changes in V2:
- new patches 6, 14, 15
- patch 7: support hypercall priorities for faster code
- comments addressedQuoted 16 lines
Juergen Gross (15):
xen: limit number of hypercall parameters to 5
xen: movedo_vcpu_op()to arch specific code
xen: harmonize return types of hypercall handlers xen/x86: modifyhvm_memory_op()prototype
xen: don't includeasm/hypercall.hfrom C sources
add .gitignore entries for *.[is] below xen
xen: generate hypercall interface related code
xen: use generated prototypes for hypercall handlers x86/pv-shim: don't modify hypercall table
xen/x86: don't use hypercall table for calling compat hypercalls xen/x86: call hypercall handlers via generated macro xen/arm: call hypercall handlers via generated macro xen/x86: add hypercall performance counters for hvm, correct pv
xen: dropcalls_to_multicallperformance countertools/xenperf: update hypercall nameshttps://gitlab.com/xen-project/people/andyhhp/xen/-/jobs/1752237172
Something here causes
hypercall.c: In function 'hvm_hypercall':
hypercall.c:174:23: error: unused variable 'r8' [-Werror=unused-variable]
174 | unsigned long r8 =regs->r8;
| ^~
hypercall.c:190:22: error: unused variable 'edi' [-Werror=unused-variable]
190 | unsigned int edi =regs->edi;
| ^~~
cc1: all warnings being treated as errorsQuoted 2 lines
I suspect it will be "call hypercall handlers via generated macro", but I haven't investigated further.
I suspect that's a randconfig build with !HYPFS + !ARGO. The hypfs and argo hypercalls are the only ones with 5 parameters that HVM wires up. A similar issue ought to exist in PV hypercall handling though, as the compat form of
update_va_mapping_otherdomainis the only other one taking 5 arguments.
Quoted 3 lines
As to possible solutions - besides maybe adding (void)r8 to the
-ENOSYSpath, I was wondering anyway in how far the local variables are still warranted to retain.
I think dropping those local variables is the easiest solution. And I think this applies to the PV variant, too.
Juergen