Skip to contentSkip to conversation

{hyper,multi}call: further limit arguments to just 5

PATCH In review Jan Beulich 3 participants 3 messages Apr 29, 2025 – May 1, 2025

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 {hyper,multi}call: further limit arguments to just 5

Multicall compat translation and hypercall continuation handling can also be shrunk to the processing of just (up to) 5 arguments.

Take the opportunity to
- make exceeding the limit noisy in hypercall_create_continuation(),
- use speculation-safe array access in hypercall_create_continuation(),
- avoid a Misra C:2012 Rule 19.1 violation in xlat_multicall_entry(),
- further tidy xlat_multicall_entry() and __trace_multicall_call() style-wise.

Amends: 2f531c122e95 ("x86: limit number of hypercall parameters to 5")

---
hypercall_xlat_continuation() uses BUG() when encountering too large an argument count in release builds, but I think that's too harsh. Hence in hypercall_create_continuation() I'm re-using the existing error path. Interestingly the multicall part of hypercall_xlat_continuation() has no check at all which would cover release builds.

With gcc14 code size grows according to my observation, due to the loops in xlat_multicall_entry() and __trace_multicall_call() both being unrolled now.

xen/arch/arm/domain.c +7 -3
@@ -392,7 +392,11 @@ unsigned long hypercall_create_continuat
     if ( mcs->flags & MCSF_in_multicall )
     {
         for ( i = 0; *p != '\0'; i++ )
-            mcs->call.args[i] = NEXT_ARG(p, args);
+        {
+            if ( i >= ARRAY_SIZE(mcs->call.args) )
+                goto bad_fmt;
+            array_access_nospec(mcs->call.args, i) = NEXT_ARG(p, args);
+        }
 
         /* Return value gets written back to mcs->call.result */
         rc = mcs->call.result;
@@ -417,7 +421,7 @@ unsigned long hypercall_create_continuat
                 case 2: regs->x2 = arg; break;
                 case 3: regs->x3 = arg; break;
                 case 4: regs->x4 = arg; break;
-                case 5: regs->x5 = arg; break;
+                default: goto bad_fmt;
                 }
             }
 
@@ -440,7 +444,7 @@ unsigned long hypercall_create_continuat
                 case 2: regs->r2 = arg; break;
                 case 3: regs->r3 = arg; break;
                 case 4: regs->r4 = arg; break;
-                case 5: regs->r5 = arg; break;
+                default: goto bad_fmt;
                 }
             }
 
xen/arch/x86/hypercall.c +7 -4
@@ -41,7 +41,11 @@ unsigned long hypercall_create_continuat
     if ( mcs->flags & MCSF_in_multicall )
     {
         for ( i = 0; *p != '\0'; i++ )
-            mcs->call.args[i] = NEXT_ARG(p, args);
+        {
+            if ( i >= ARRAY_SIZE(mcs->call.args) )
+                goto bad_fmt;
+            array_access_nospec(mcs->call.args, i) = NEXT_ARG(p, args);
+        }
     }
     else
     {
@@ -65,7 +69,7 @@ unsigned long hypercall_create_continuat
                 case 2: regs->rdx = arg; break;
                 case 3: regs->r10 = arg; break;
                 case 4: regs->r8  = arg; break;
-                case 5: regs->r9  = arg; break;
+                default: goto bad_fmt;
                 }
             }
         }
@@ -81,7 +85,7 @@ unsigned long hypercall_create_continuat
                 case 2: regs->rdx = arg; break;
                 case 3: regs->rsi = arg; break;
                 case 4: regs->rdi = arg; break;
-                case 5: regs->rbp = arg; break;
+                default: goto bad_fmt;
                 }
             }
         }
@@ -177,7 +181,6 @@ int hypercall_xlat_continuation(unsigned
             case 2: reg = &regs->rdx; break;
             case 3: reg = &regs->rsi; break;
             case 4: reg = &regs->rdi; break;
-            case 5: reg = &regs->rbp; break;
             default: BUG(); reg = NULL; break;
             }
             if ( (mask & 1) )
xen/common/compat/multicall.c +9 -5
@@ -14,9 +14,13 @@ typedef int ret_t;
 
 static inline void xlat_multicall_entry(struct mc_state *mcs)
 {
-    int i;
-    for (i=0; i<6; i++)
-        mcs->compat_call.args[i] = mcs->call.args[i];
+    unsigned int i;
+    typeof(mcs->compat_call.args[0]) args[ARRAY_SIZE(mcs->call.args)];
+
+    for ( i = 0; i < ARRAY_SIZE(args); i++ )
+        args[i] = mcs->call.args[i];
+
+    memcpy(mcs->compat_call.args, args, sizeof(args));
 }
 
 #define multicall_entry      compat_multicall_entry
@@ -29,8 +33,8 @@ static inline void xlat_multicall_entry(
 
 static void __trace_multicall_call(multicall_entry_t *call)
 {
-    xen_ulong_t args[6];
-    int i;
+    xen_ulong_t args[ARRAY_SIZE(call->args)];
+    unsigned int i;
 
     for ( i = 0; i < ARRAY_SIZE(args); i++ )
         args[i] = call->args[i];
xen/include/public/xen.h +4 -0
@@ -640,7 +640,11 @@ DEFINE_XEN_GUEST_HANDLE(mmu_update_t);
  */
 struct multicall_entry {
     xen_ulong_t op, result;
+#ifndef __XEN__
     xen_ulong_t args[6];
+#else /* Only 5 arguments are supported in reality. */
+    xen_ulong_t args[5], unused;
+#endif
 };
 typedef struct multicall_entry multicall_entry_t;
 DEFINE_XEN_GUEST_HANDLE(multicall_entry_t);
Acked-by on v1 1/1
#1 lore raw
Quoted 10 lines · Jan Beulich

Multicall compat translation and hypercall continuation handling can also be shrunk to the processing of just (up to) 5 arguments.

Take the opportunity to
- make exceeding the limit noisy in hypercall_create_continuation(),
- use speculation-safe array access in hypercall_create_continuation(),
- avoid a Misra C:2012 Rule 19.1 violation in xlat_multicall_entry(),
- further tidy xlat_multicall_entry() and __trace_multicall_call() style-wise.

Quoted 2 lines

Amends: 2f531c122e95 ("x86: limit number of hypercall parameters to 5")

Quoted 6 lines

---
hypercall_xlat_continuation() uses BUG() when encountering too large an argument count in release builds, but I think that's too harsh. Hence in hypercall_create_continuation() I'm re-using the existing error path. Interestingly the multicall part of hypercall_xlat_continuation() has no check at all which would cover release builds.

This has never been the best of code.  All we can do is improve it moving forward.

Quoted 4 lines

With gcc14 code size grows according to my observation, due to the loops in xlat_multicall_entry() and __trace_multicall_call() both being unrolled now.

With GCC-12, it gets marginally smaller.  The loops are unrolled and the instruction scheduling is rather odd.

mov    0x208(%r15),%rax
mov    0x228(%r15),%rdx
mov    %eax,0x1c(%rsp)
mov    0x210(%r15),%rax
mov    %edx,0x2c(%rsp)
mov    %eax,0x20(%rsp)
mov    0x218(%r15),%rax
mov    0x1c(%rsp),%rsi
mov    %edx,0x210(%r15)
mov    %eax,0x24(%rsp)
mov    0x220(%r15),%rax
mov    %rsi,0x200(%r15)
mov    %eax,0x28(%rsp)
mov    0x24(%rsp),%rsi
mov    %rsi,0x208(%r15)

This is the interleaved copy onto the stack, and back off.

Weirdly, we're doing 8 byte loads and 4 byte stores to copy on to the stack.  It's not wrong per say, but it's also not necessary.

Then, for the copy-off, there is an overlapping store:

mov    %edx,0x210(%r15)

and

mov    %rsi,0x208(%r15)

not to mention this:

mov    %eax,0x28(%rsp)
mov    0x24(%rsp),%rsi

using an overlapping store and wider load for the copy-off.

Anyway - it looks to function correctly, but I don't exactly feel as if the optimiser has done a great job.

~Andrew

#2 lore raw
Quoted 11 lines · Andrew Cooper
Quoted 10 lines · Jan Beulich

Multicall compat translation and hypercall continuation handling can also be shrunk to the processing of just (up to) 5 arguments.

Take the opportunity to
- make exceeding the limit noisy in hypercall_create_continuation(),
- use speculation-safe array access in hypercall_create_continuation(),
- avoid a Misra C:2012 Rule 19.1 violation in xlat_multicall_entry(),
- further tidy xlat_multicall_entry() and __trace_multicall_call() style-wise.

Quoted 4 lines
Quoted 2 lines

Amends: 2f531c122e95 ("x86: limit number of hypercall parameters to 5")

Arm side: