From b75cc14b3435d57eb5d3648a203e137bae4052b2 Mon Sep 17 00:00:00 2001 From: Ian Campbell Date: Wed, 25 Jul 2012 17:39:20 +0100 Subject: [PATCH] arm: clobber only argument registers Previously it was declared that r1..r4 would all be clobbered by all hypercalls. Instead declare that only actually used hypercall argument registers are clobbered. This is more inline with generally expected conventions and allows for more optimal code in the caller in some cases. This is an ABI change, although an older guest which expects more things to be clobbered than we do now won't be adversely impacted. Signed-off-by: Ian Campbell Acked-by: Stefano Stabellini Committed-by: Ian Campbell --- xen/arch/arm/traps.c | 56 ++++++++++++++++++++++------------- xen/include/public/arch-arm.h | 6 ++-- 2 files changed, 40 insertions(+), 22 deletions(-) diff --git a/xen/arch/arm/traps.c b/xen/arch/arm/traps.c index f6e6807bc8..f2c25b5821 100644 --- a/xen/arch/arm/traps.c +++ b/xen/arch/arm/traps.c @@ -413,24 +413,31 @@ unsigned long do_arch_0(unsigned int cmd, unsigned long long value) return 0; } -typedef unsigned long arm_hypercall_t( +typedef unsigned long (*arm_hypercall_fn_t)( unsigned int, unsigned int, unsigned int, unsigned int, unsigned int); -#define HYPERCALL(x) \ - [ __HYPERVISOR_ ## x ] = (arm_hypercall_t *) do_ ## x - -static arm_hypercall_t *arm_hypercall_table[] = { - HYPERCALL(memory_op), - HYPERCALL(domctl), - HYPERCALL(arch_0), - HYPERCALL(sched_op), - HYPERCALL(console_io), - HYPERCALL(xen_version), - HYPERCALL(event_channel_op), - HYPERCALL(memory_op), - HYPERCALL(physdev_op), - HYPERCALL(sysctl), - HYPERCALL(hvm_op), +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, \ + } + +static arm_hypercall_t arm_hypercall_table[] = { + HYPERCALL(memory_op, 2), + HYPERCALL(domctl, 1), + HYPERCALL(arch_0, 2), + HYPERCALL(sched_op, 2), + HYPERCALL(console_io, 3), + HYPERCALL(xen_version, 2), + HYPERCALL(event_channel_op, 2), + HYPERCALL(physdev_op, 2), + HYPERCALL(sysctl, 2), + HYPERCALL(hvm_op, 2), }; static void do_debug_trap(struct cpu_user_regs *regs, unsigned int code) @@ -462,7 +469,7 @@ static void do_debug_trap(struct cpu_user_regs *regs, unsigned int code) static void do_trap_hypercall(struct cpu_user_regs *regs, unsigned long iss) { - arm_hypercall_t *call = NULL; + arm_hypercall_fn_t call = NULL; if ( iss != XEN_HYPERCALL_TAG ) { @@ -472,7 +479,7 @@ static void do_trap_hypercall(struct cpu_user_regs *regs, unsigned long iss) return; } - call = arm_hypercall_table[regs->r12]; + call = arm_hypercall_table[regs->r12].fn; if ( call == NULL ) { regs->r0 = -ENOSYS; @@ -482,8 +489,17 @@ static void do_trap_hypercall(struct cpu_user_regs *regs, unsigned long iss) regs->r0 = call(regs->r0, regs->r1, regs->r2, regs->r3, regs->r4); #ifndef NDEBUG - /* clobber registers */ - regs->r1 = regs->r2 = regs->r3 = regs->r4 = regs->r12 = 0xDEADBEEF; + /* Clobber argument registers */ + switch ( arm_hypercall_table[regs->r12].nr_args ) { + case 5: regs->r4 = 0xDEADBEEF; + case 4: regs->r3 = 0xDEADBEEF; + case 3: regs->r2 = 0xDEADBEEF; + case 2: regs->r1 = 0xDEADBEEF; + case 1: /* Don't clobber r0 -- it's the return value */ + break; + default: BUG(); + } + regs->r12 = 0xDEADBEEF; #endif } diff --git a/xen/include/public/arch-arm.h b/xen/include/public/arch-arm.h index eb1add95a1..f18bafa28f 100644 --- a/xen/include/public/arch-arm.h +++ b/xen/include/public/arch-arm.h @@ -42,8 +42,10 @@ * * The return value is in r0. * - * The hypercall will always clobber r0, r1, r2, r3, r4 and r12, - * regardless of how many arguments the particular hypercall takes. + * The hypercall will clobber r12 and the argument registers used by + * that hypercall (except r0 which is the return value) i.e. a 2 + * argument hypercall will clobber r1 and a 4 argument hypercall will + * clobber r1, r2 and r3. * */ -- 2.30.2