Use named asm parameters for _ASM_EXTABLE_HANDLER()

LTO builds need to know that ex_record_fault_{eax,edi} are referenced from
within asm, to avoid the functions being discarded.

Previously, this was done with an "X" parameter listing the function twice,
but this can lead to copy/paste mistakes.  Instead, use a named parameter and
the "p" type and "P" modifier, which works compatibly between GCC and Clang.

Signed-off-by: Andrew Cooper <andrew.cooper3@citrix.com>

diff --git a/arch/x86/include/arch/extable.h b/arch/x86/include/arch/extable.h
index 8e1baf946baf1a6bea396cf21ac4ceb24296e914..cdff01d85ffb2644c91b4ffda569a6b0a11442c5 100644 (file)
--- a/arch/x86/include/arch/extable.h
+++ b/arch/x86/include/arch/extable.h
@@ -17,8 +17,8 @@ struct extable_entry;
  * Sample usage:
  * <pre>
  *   asm volatile ("1: $INSN; 2:"
- *                 _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_eax)
- *                 : "=a" (fault) : "0" (0), "X" (ex_record_fault_eax));
+ *                 _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
+ *                 : "=a" (fault) : "0" (0), [rec] "p" (ex_record_fault_eax));
  * </pre>
  */
 bool ex_record_fault_eax(struct cpu_regs *regs, const struct extable_entry *ex);
@@ -29,8 +29,8 @@ bool ex_record_fault_eax(struct cpu_regs *regs, const struct extable_entry *ex);
  * Sample usage:
  * <pre>
  *   asm volatile ("1: $INSN; 2:"
- *                 _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
- *                 : "=D" (fault) : "0" (0), "X" (ex_record_fault_edi));
+ *                 _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
+ *                 : "=D" (fault) : "0" (0), [rec] "p" (ex_record_fault_edi));
  * </pre>
  */
 bool ex_record_fault_edi(struct cpu_regs *regs, const struct extable_entry *ex);

diff --git a/arch/x86/include/arch/lib.h b/arch/x86/include/arch/lib.h
index 4e62bf9a3d7d4c49772c91aab6c9d7d162feb7c0..e9857fa231a88dbc392a981780f7a21971a797db 100644 (file)
--- a/arch/x86/include/arch/lib.h
+++ b/arch/x86/include/arch/lib.h
@@ -281,10 +281,10 @@ static inline bool write_cr4_safe(unsigned long cr4)
     exinfo_t fault = 0;
 
     asm volatile ("1: mov %[cr4], %%cr4; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+D" (fault)
                   : [cr4] "r" (cr4),
-                    "X" (ex_record_fault_edi));
+                    [rec] "p" (ex_record_fault_edi));
 
     return fault;
 }

diff --git a/arch/x86/include/arch/msr.h b/arch/x86/include/arch/msr.h
index 9fdc236baa332e23b31551947db028a9b5c33233..7a74467db05fe3e37362a67ebfcd10a5ad9a3951 100644 (file)
--- a/arch/x86/include/arch/msr.h
+++ b/arch/x86/include/arch/msr.h
@@ -37,9 +37,9 @@ static inline bool rdmsr_safe(uint32_t idx, uint64_t *val)
     uint32_t lo, hi, new_idx;
 
     asm volatile ("1: rdmsr; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_rdmsr_safe)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[hnd])
                   : "=a" (lo), "=d" (hi), "=c" (new_idx)
-                  : "c" (idx), "X" (ex_rdmsr_safe));
+                  : "c" (idx), [hnd] "p" (ex_rdmsr_safe));
 
     bool fault = idx != new_idx;
 
@@ -71,11 +71,11 @@ static inline bool wrmsr_safe(uint32_t idx, uint64_t val)
     uint32_t new_idx;
 
     asm volatile ("1: wrmsr; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_wrmsr_safe)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[hnd])
                   : "=c" (new_idx)
                   : "c" (idx), "a" ((uint32_t)val),
                     "d" ((uint32_t)(val >> 32)),
-                    "X" (ex_wrmsr_safe));
+                    [hnd] "p" (ex_wrmsr_safe));
 
     return idx != new_idx;
 }

diff --git a/arch/x86/pv/traps.c b/arch/x86/pv/traps.c
index 6bb4e448323ec8a4eebe4c17b012170a55a34476..3ff6cefa5840492c4ec4d730f66ca0c121452c64 100644 (file)
--- a/arch/x86/pv/traps.c
+++ b/arch/x86/pv/traps.c
@@ -234,11 +234,11 @@ void arch_init_traps(void)
                       "jmp 3f;"
                       "2: ret;"
                       "3:"
-                      _ASM_EXTABLE_HANDLER(1b,    3b, ex_pf_user)
-                      _ASM_EXTABLE_HANDLER(0xfff, 2b, ex_pf_user)
+                      _ASM_EXTABLE_HANDLER(1b,    3b, %P[rec])
+                      _ASM_EXTABLE_HANDLER(0xfff, 2b, %P[rec])
                       : "+a" (leaked)
                       : [ptr] "r" (0xfff),
-                        "X" (ex_pf_user));
+                        [rec] "p" (ex_pf_user));
 
         if ( leaked )
             panic("Xen's SMEP/SMAP settings leaked into guest context.\n"

diff --git a/tests/cpuid-faulting/main.c b/tests/cpuid-faulting/main.c
index ecad92d2733e53ed537889a4d8ae09ed23765ac7..56ee49e54d5f8a7e5a614f5a36023908e757c775 100644 (file)
--- a/tests/cpuid-faulting/main.c
+++ b/tests/cpuid-faulting/main.c
@@ -30,9 +30,9 @@ unsigned long stub_cpuid(void)
     unsigned int fault = 0, tmp;
 
     asm volatile("1: cpuid; 2:"
-                 _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                 _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                  : "=a" (tmp), "+D" (fault)
-                 : "a" (0), "X" (ex_record_fault_edi)
+                 : "a" (0), [rec] "p" (ex_record_fault_edi)
                  : "ebx", "ecx", "edx");
 
     return fault;
@@ -44,9 +44,9 @@ unsigned long stub_fep_cpuid(void)
 
     asm volatile(_ASM_XEN_FEP
                  "1: cpuid; 2:"
-                 _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                 _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                  : "=a" (tmp), "+D" (fault)
-                 : "a" (0), "X" (ex_record_fault_edi)
+                 : "a" (0), [rec] "p" (ex_record_fault_edi)
                  : "ebx", "ecx", "edx");
 
     return fault;

diff --git a/tests/debug-regs/main.c b/tests/debug-regs/main.c
index 5f18feadee5bd66eb72a0fd831696dab584da12e..60c7c862d136015ffc5702cca26729b5a9fc6b08 100644 (file)
--- a/tests/debug-regs/main.c
+++ b/tests/debug-regs/main.c
@@ -101,10 +101,10 @@ static void test_pv_dr7_latch(void)
 
         asm volatile ("mov %[dr7], %%dr7;"
                       "movl $0, %[ptr]; 1:"
-                      _ASM_EXTABLE_HANDLER(1b, 1b, ex_record_fault_eax)
+                      _ASM_EXTABLE_HANDLER(1b, 1b, %P[rec])
                       : "+a" (fault),
                         [ptr] "=m" (dummy)
-                      : [dr7] "r" (dr7), "X" (ex_record_fault_eax));
+                      : [dr7] "r" (dr7), [rec] "p" (ex_record_fault_eax));
 
         /* Reset any latched %dr7 content. */
         write_dr7(0);
@@ -166,10 +166,10 @@ static void test_pv_dr7_io_breakpoints(void)
     /* Attempt to reload an IO breakpoint in %dr0, which should fail ... */
     exinfo_t fault = 0;
     asm volatile ("1: mov %[val], %%dr7; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_eax)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+a" (fault)
                   : [val] "r" (io0),
-                    "X" (ex_record_fault_eax));
+                    [rec] "p" (ex_record_fault_eax));
 
     if ( fault != EXINFO_SYM(GP, 0) )
         xtf_error("Error: Unexpected fault %pe\n", _p(fault));

diff --git a/tests/fpu-exception-emulation/main.c b/tests/fpu-exception-emulation/main.c
index bb4c688762daeb1f2e26f8edd97ea775ecbf08bf..d12b05a80e11f1f3a5ef4c1780db79c509ad35eb 100644 (file)
--- a/tests/fpu-exception-emulation/main.c
+++ b/tests/fpu-exception-emulation/main.c
@@ -72,10 +72,10 @@ exinfo_t probe_x87(bool force)
                   "jz 1f;"
                   _ASM_XEN_FEP
                   "1: fnop; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_eax)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+a" (fault)
                   : [fep] "q" (force),
-                    "X" (ex_record_fault_eax));
+                    [rec] "p" (ex_record_fault_eax));
 
     return fault;
 }
@@ -105,10 +105,10 @@ exinfo_t probe_x87_wait(bool force)
                   "jz 1f;"
                   _ASM_XEN_FEP
                   "1: wait; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_eax)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+a" (fault)
                   : [fep] "q" (force),
-                    "X" (ex_record_fault_eax));
+                    [rec] "p" (ex_record_fault_eax));
 
     return fault;
 }
@@ -137,10 +137,10 @@ exinfo_t probe_mmx(bool force)
                   "jz 1f;"
                   _ASM_XEN_FEP
                   "1: movq %%mm0, %%mm0; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_eax)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+a" (fault)
                   : [fep] "q" (force),
-                    "X" (ex_record_fault_eax));
+                    [rec] "p" (ex_record_fault_eax));
 
     return fault;
 }
@@ -153,10 +153,10 @@ exinfo_t probe_sse(bool force)
                   "jz 1f;"
                   _ASM_XEN_FEP
                   "1: movups %%xmm0, %%xmm0; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_eax)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+a" (fault)
                   : [fep] "q" (force),
-                    "X" (ex_record_fault_eax));
+                    [rec] "p" (ex_record_fault_eax));
 
     return fault;
 }
@@ -185,10 +185,10 @@ static exinfo_t probe_avx(bool force)
                   "jz 1f;"
                   _ASM_XEN_FEP
                   "1: vmovups %%xmm0, %%xmm0; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_eax)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+a" (fault)
                   : [fep] "q" (force),
-                    "X" (ex_record_fault_eax));
+                    [rec] "p" (ex_record_fault_eax));
 
     return fault;
 }

diff --git a/tests/invlpg/main.c b/tests/invlpg/main.c
index 943c7c2110948d18864cd7b9346826fbcb8c7683..b300f957b5e92ec7417d114bf865e576d0136e3d 100644 (file)
--- a/tests/invlpg/main.c
+++ b/tests/invlpg/main.c
@@ -119,7 +119,7 @@ static unsigned int invlpg_refill(void)
                   "andb $~%c[ad], %[pte2];\n\t"
                   _ASM_MAYBE_XEN_FEP
                   "1: invlpg 0x1000; 2:\n\t"   /* Invalidate one page only. */
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_fail)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[hnd])
                   "mov %[zero], 0x1000;\n\t"   /* Expect refill. */
                   "mov %[zero], 0x2000;\n\t"   /* Expect no refill. */
                   :
@@ -127,7 +127,7 @@ static unsigned int invlpg_refill(void)
                     [ad]   "i" (_PAGE_AD),
                     [pte1] "m" (pae_l1_identmap[1]),
                     [pte2] "m" (pae_l1_identmap[2]),
-                    "X" (ex_fail)
+                    [hnd] "p" (ex_fail)
                   : "memory");
 
     return ((test_ad(pae_l1_identmap[1]) << 0) |
@@ -142,7 +142,7 @@ static unsigned int invlpg_fs_refill(void)
                   "andb $~%c[ad], %[pte2];\n\t"
                   _ASM_MAYBE_XEN_FEP
                   "1: invlpg %%fs:0x1000; 2:\n\t" /* Invalidate one page only. */
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_fail)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[hnd])
                   "mov %[zero], 0x1000;\n\t"  /* Expect one TLB entry to refil, */
                   "mov %[zero], 0x2000;\n\t"  /* depending on %fs base.*/
                   :
@@ -150,7 +150,7 @@ static unsigned int invlpg_fs_refill(void)
                     [ad]   "i" (_PAGE_AD),
                     [pte1] "m" (pae_l1_identmap[1]),
                     [pte2] "m" (pae_l1_identmap[2]),
-                    "X" (ex_fail)
+                    [hnd] "p" (ex_fail)
                   : "memory");
 
     return ((test_ad(pae_l1_identmap[1]) << 0) |
@@ -244,16 +244,16 @@ static void invlpg_checked(unsigned long linear)
 {
     asm volatile (_ASM_MAYBE_XEN_FEP
                   "1: invlpg (%0); 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_fail)
-                  :: "r" (linear));
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[hnd])
+                  :: "r" (linear), [hnd] "p" (ex_fail));
 }
 
 static void invlpg_fs_checked(unsigned long linear)
 {
     asm volatile (_ASM_MAYBE_XEN_FEP
                   "1: invlpg %%fs:(%0); 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_fail)
-                  :: "r" (linear), "X" (ex_fail));
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[hnd])
+                  :: "r" (linear), [hnd] "p" (ex_fail));
 }
 
 static void test_no_fault(void)

diff --git a/tests/nested-vmx/util.c b/tests/nested-vmx/util.c
index 61611abb91afc8aff826f55368786c1b86fb2e1b..20d8378d1d11f92f6b5df243f9b1da195b5e8998 100644 (file)
--- a/tests/nested-vmx/util.c
+++ b/tests/nested-vmx/util.c
@@ -83,12 +83,12 @@ exinfo_t stub_vmxon(uint64_t paddr)
                   ASM_FLAG_OUT(, "setc %[fail_invalid];")
                   ASM_FLAG_OUT(, "setz %[fail_valid];")
                   "2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+D" (ex),
                     ASM_FLAG_OUT("=@ccc", [fail_invalid] "+rm") (fail_invalid),
                     ASM_FLAG_OUT("=@ccz", [fail_valid]   "+rm") (fail_valid)
                   : [paddr] "m" (paddr),
-                    "X" (ex_record_fault_edi));
+                    [rec] "p" (ex_record_fault_edi));
 
     if ( ex )
         return ex;
@@ -109,12 +109,12 @@ exinfo_t stub_vmptrld(uint64_t paddr)
                   ASM_FLAG_OUT(, "setc %[fail_invalid];")
                   ASM_FLAG_OUT(, "setz %[fail_valid];")
                   "2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+D" (ex),
                     ASM_FLAG_OUT("=@ccc", [fail_invalid] "+rm") (fail_invalid),
                     ASM_FLAG_OUT("=@ccz", [fail_valid]   "+rm") (fail_valid)
                   : [paddr] "m" (paddr),
-                    "X" (ex_record_fault_edi));
+                    [rec] "p" (ex_record_fault_edi));
 
     if ( ex )
         return ex;
@@ -135,12 +135,12 @@ exinfo_t __user_text stub_vmxon_user(uint64_t paddr)
                   ASM_FLAG_OUT(, "setc %[fail_invalid];")
                   ASM_FLAG_OUT(, "setz %[fail_valid];")
                   "2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+D" (ex),
                     ASM_FLAG_OUT("=@ccc", [fail_invalid] "+rm") (fail_invalid),
                     ASM_FLAG_OUT("=@ccz", [fail_valid]   "+rm") (fail_valid)
                   : [paddr] "m" (paddr),
-                    "X" (ex_record_fault_edi));
+                    [rec] "p" (ex_record_fault_edi));
 
     if ( ex )
         return ex;

diff --git a/tests/pv-fsgsbase/main.c b/tests/pv-fsgsbase/main.c
index a9c3bc1c35c1a7d08789b437eed45914a10212f2..d354238545d98bf4968714c067ff57086a1c9ed5 100644 (file)
--- a/tests/pv-fsgsbase/main.c
+++ b/tests/pv-fsgsbase/main.c
@@ -39,9 +39,9 @@ static exinfo_t stub_rdfsbase(unsigned long unused)
     exinfo_t fault = 0;
 
     asm volatile ("1: rdfsbase %[val]; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_eax)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+a" (fault), [val] "=r" (tmp)
-                  : "X" (ex_record_fault_eax));
+                  : [rec] "p" (ex_record_fault_eax));
 
     return fault;
 }
@@ -52,9 +52,9 @@ static exinfo_t stub_rdgsbase(unsigned long unused)
     exinfo_t fault = 0;
 
     asm volatile ("1: rdgsbase %[val]; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_eax)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+a" (fault), [val] "=r" (tmp)
-                  : "X" (ex_record_fault_eax));
+                  : [rec] "p" (ex_record_fault_eax));
 
     return fault;
 }
@@ -64,9 +64,9 @@ static exinfo_t stub_wrfsbase(unsigned long val)
     exinfo_t fault = 0;
 
     asm volatile ("1: wrfsbase %[val]; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_eax)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+a" (fault)
-                  : [val] "r" (val), "X" (ex_record_fault_eax));
+                  : [val] "r" (val), [rec] "p" (ex_record_fault_eax));
 
     return fault;
 }
@@ -76,9 +76,9 @@ static exinfo_t stub_wrgsbase(unsigned long val)
     exinfo_t fault = 0;
 
     asm volatile ("1: wrgsbase %[val]; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_eax)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+a" (fault)
-                  : [val] "r" (val), "X" (ex_record_fault_eax));
+                  : [val] "r" (val), [rec] "p" (ex_record_fault_eax));
 
     return fault;
 }

diff --git a/tests/selftest/main.c b/tests/selftest/main.c
index 31dcda160c5e23fa135d74eabc0e6ced286b9588..e39f1e795a7b0106b64f343faa192b561bbf0b55 100644 (file)
--- a/tests/selftest/main.c
+++ b/tests/selftest/main.c
@@ -240,9 +240,8 @@ static void test_extable_handler(void)
     printk("Test: Exception Table Handler\n");
 
     asm volatile ("1: ud2a; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b,
-                                       test_extable_handler_handler)
-                  :: "X" (test_extable_handler_handler));
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[hnd])
+                  :: [hnd] "p" (test_extable_handler_handler));
 
     if ( !test_extable_handler_handler_run )
         xtf_failure("Fail: Custom handler didn't run\n");

diff --git a/tests/umip/main.c b/tests/umip/main.c
index 3b8e17c9ef7f2afb9279ee950e24418ad5cf139d..40ebc710cd2e78725db945f9f43595e85bec4987 100644 (file)
--- a/tests/umip/main.c
+++ b/tests/umip/main.c
@@ -26,10 +26,10 @@ static unsigned long stub_sgdt(unsigned long force)
                  "jz 1f;"
                  _ASM_XEN_FEP
                  "1: sgdt %[tmp]; 2:"
-                 _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                 _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                  : "+D" (fault), [tmp] "=m" (tmp)
                  : [fep] "q" (force),
-                   "X" (ex_record_fault_edi));
+                   [rec] "p" (ex_record_fault_edi));
 
     return fault;
 }
@@ -42,10 +42,10 @@ static unsigned long stub_sidt(unsigned long force)
                  "jz 1f;"
                  _ASM_XEN_FEP
                  "1: sidt %[tmp]; 2:"
-                 _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                 _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                  : "+D" (fault), [tmp] "=m" (tmp)
                  : [fep] "q" (force),
-                   "X" (ex_record_fault_edi));
+                   [rec] "p" (ex_record_fault_edi));
 
     return fault;
 }
@@ -59,10 +59,10 @@ static unsigned long stub_sldt(unsigned long force)
                  "jz 1f;"
                  _ASM_XEN_FEP
                  "1: sldt %[tmp]; 2:"
-                 _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                 _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                  : "+D" (fault), [tmp] "=r" (tmp)
                  : [fep] "q" (force),
-                   "X" (ex_record_fault_edi));
+                   [rec] "p" (ex_record_fault_edi));
 
     return fault;
 }
@@ -76,10 +76,10 @@ static unsigned long stub_str(unsigned long force)
                  "jz 1f;"
                  _ASM_XEN_FEP
                  "1: str %[tmp]; 2:"
-                 _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                 _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                  : "+D" (fault), [tmp] "=r" (tmp)
                  : [fep] "q" (force),
-                   "X" (ex_record_fault_edi));
+                   [rec] "p" (ex_record_fault_edi));
 
     return fault;
 }
@@ -93,10 +93,10 @@ static unsigned long stub_smsw(unsigned long force)
                  "jz 1f;"
                  _ASM_XEN_FEP
                  "1: smsw %[tmp]; 2:"
-                 _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                 _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                  : "+D" (fault), [tmp] "=r" (tmp)
                  : [fep] "q" (force),
-                   "X" (ex_record_fault_edi));
+                   [rec] "p" (ex_record_fault_edi));
 
     return fault;
 }

diff --git a/tests/xsa-186/main.c b/tests/xsa-186/main.c
index 96a72bed66c9bc327b5162065ae06b84bcce3e2d..cafcf16e27e4d39539355fde6f24e44d2698899b 100644 (file)
--- a/tests/xsa-186/main.c
+++ b/tests/xsa-186/main.c
@@ -174,11 +174,11 @@ void test_main(void)
      * instructions don't get lost.
      */
     asm volatile ("call *%[ptr];"
-                  _ASM_EXTABLE_HANDLER(-1, 0, ex_fault)
+                  _ASM_EXTABLE_HANDLER(-1, 0, %P[hnd])
                   : "=a" (res)
                   : "0" (0),
                     [ptr] "r" (stub),
-                    "X" (ex_fault)
+                    [hnd] "p" (ex_fault)
                   : "memory");
 
     if ( res != 0xc0de )

diff --git a/tests/xsa-191/main.c b/tests/xsa-191/main.c
index d3b2c02375b9469d6808e362f66f30b010ce5c3d..f360148e1cf5049585972b930e140da9e09204ed 100644 (file)
--- a/tests/xsa-191/main.c
+++ b/tests/xsa-191/main.c
@@ -39,11 +39,11 @@ void test_main(void)
     write_fs(0);
     asm volatile (_ASM_XEN_FEP
                   "1: mov %%fs:0, %[dst]; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "=D" (fault),
                     [dst] "=r" (tmp)
                   : "D" (0),
-                    "X" (ex_record_fault_edi));
+                    [rec] "p" (ex_record_fault_edi));
 
     switch ( fault )
     {
@@ -71,11 +71,11 @@ void test_main(void)
 
     asm volatile (_ASM_XEN_FEP
                   "1: mov %[sel], %%fs; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_eax)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "=a" (fault)
                   : "a" (0),
                     [sel] "r" (4),
-                    "X" (ex_record_fault_eax));
+                    [rec] "p" (ex_record_fault_eax));
 
     switch ( fault )
     {

diff --git a/tests/xsa-192/main.c b/tests/xsa-192/main.c
index 0fee916fded2e6f1370f124c378157a20bbf9988..f94fac8f0b26d260138f8debf577a60667f7fbba 100644 (file)
--- a/tests/xsa-192/main.c
+++ b/tests/xsa-192/main.c
@@ -65,10 +65,10 @@ unsigned long user_ldt_use(void)
 
     /* Attempt to load %fs from the LDT. */
     asm volatile ("1: mov %[sel], %%fs; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_eax)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+a" (fault)
                   : [sel] "r" (LDT_SEL),
-                    "X" (ex_record_fault_eax));
+                    [rec] "p" (ex_record_fault_eax));
 
     return fault;
 }

diff --git a/tests/xsa-196/main.c b/tests/xsa-196/main.c
index 504ea692a6d74c6fe966ad751799d6de18374319..0c40729f4b9acd8e3137a4583c06e1aa91bf2828 100644 (file)
--- a/tests/xsa-196/main.c
+++ b/tests/xsa-196/main.c
@@ -51,7 +51,7 @@ unsigned long compat_userspace(void)
                   "start_32bit:;"
                   _ASM_XEN_FEP
                   "1: int $%c[df]; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_eax)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
 
                   /* Return to 64bit. */
                   "ljmpl $%c[cs], $1f;"
@@ -62,7 +62,7 @@ unsigned long compat_userspace(void)
                   : [df]   "i" (X86_EXC_DF),
                     [cs32] "i" (__USER_CS32),
                     [cs]   "i" (__USER_CS),
-                    "X" (ex_record_fault_eax));
+                    [rec] "p" (ex_record_fault_eax));
 
     return fault;
 }

diff --git a/tests/xsa-200/main.c b/tests/xsa-200/main.c
index b3e75b007dcd08e6b5dbf977df38eee5c81caf71..79737771bd4a8840396b6344301b87fa3f21371f 100644 (file)
--- a/tests/xsa-200/main.c
+++ b/tests/xsa-200/main.c
@@ -43,10 +43,10 @@ void test_main(void)
     {
         /* Poke the emulator. */
         asm volatile (_ASM_XEN_FEP "1: .byte 0x66; cmpxchg8b %[ptr]; 2:"
-                      _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                      _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                       : "=A" (prev), [ptr] "+m" (mem), "+D" (fault)
                       : "c" ((uint32_t)(new >> 32)), "b" ((uint32_t)new),
-                        "0" (old), "X" (ex_record_fault_edi));
+                        "0" (old), [rec] "p" (ex_record_fault_edi));
 
         if ( fault == EXINFO_SYM(UD, 0) )
             return xtf_success("Success: Not vulnerable to XSA-200\n");

diff --git a/tests/xsa-212/main.c b/tests/xsa-212/main.c
index c4293ff9f45ffb25154b1ab8dd38333226bfdda8..50cc13a953dc26c5264196dae44053e06692c280 100644 (file)
--- a/tests/xsa-212/main.c
+++ b/tests/xsa-212/main.c
@@ -82,9 +82,9 @@ void test_main(void)
         printk("Attempting to confirm...\n");
 
         asm volatile ("1: div %%ecx; 2:"
-                      _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                      _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                       : "+&a" (low), "+&d" (hi), "+D" (fault)
-                      : "c" (0), "X" (ex_record_fault_edi));
+                      : "c" (0), [rec] "p" (ex_record_fault_edi));
 
         if ( fault == EXINFO_SYM(DE, 0) )
         {

diff --git a/tests/xsa-227/main.c b/tests/xsa-227/main.c
index 8bec92b1c76ae53f08a2ae1539b87df372f195ad..a32ec66617c9f498181057fd8cdd8604bcd0aebe 100644 (file)
--- a/tests/xsa-227/main.c
+++ b/tests/xsa-227/main.c
@@ -86,11 +86,11 @@ void test_main(void)
      * Try to use the linear address which was clobbered by the map call.
      */
     asm volatile ("1: mov %[ptr], %[res]; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_eax)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+a" (fault),
                     [res] "=q" (discard)
                   : [ptr] "m" (*(char *)KB(4)),
-                    "X" (ex_record_fault_eax));
+                    [rec] "p" (ex_record_fault_eax));
 
     switch ( fault )
     {

diff --git a/tests/xsa-259/main.c b/tests/xsa-259/main.c
index 2cf073353721204cc4103449c009f894ca37daec..0432c1320547277c540fc53072e6a4fb5462ebee 100644 (file)
--- a/tests/xsa-259/main.c
+++ b/tests/xsa-259/main.c
@@ -25,9 +25,9 @@ void test_main(void)
     exinfo_t fault = 0;
 
     asm volatile ("1: int $0x80; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_eax)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+a" (fault)
-                  : "X" (ex_record_fault_eax));
+                  : [rec] "p" (ex_record_fault_eax));
 
     /*
      * If Xen is vulnerable, it should have crashed.  If Xen is not

diff --git a/tests/xsa-260/main.c b/tests/xsa-260/main.c
index 51e73848a0e456a5e2fd7e51fadc83431103d7ef..2ffd7a29b48e7d786edfa23083c68b544c60336a 100644 (file)
--- a/tests/xsa-260/main.c
+++ b/tests/xsa-260/main.c
@@ -84,11 +84,11 @@ static void __user_text user_syscall(void)
                   "btc $%c[bit], %%" _ASM_SP ";"
                   "mov %[ss], %%ss;"
                   "1: syscall; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_check_UD)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[hnd])
                   :
                   : [bit] "i" (BITS_PER_LONG - 1),
                     [ss]  "m" (user_ss),
-                    "X" (ex_check_UD)
+                    [hnd] "p" (ex_check_UD)
 #ifdef __x86_64__
                   : "rbx", "rcx", "r11"
 #else
@@ -118,7 +118,7 @@ static void __user_text user_syscall_compat(void)
                    */
                   "mov (%k[ss_ptr]), %%ss;"
                   "1: syscall; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_check_UD)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[hnd])
 
                   /* Return to 64bit mode. */
                   "ljmpl $%c[cs64], $1f; 1:"
@@ -127,7 +127,7 @@ static void __user_text user_syscall_compat(void)
                   : [cs32]   "i" (__USER_CS32),
                     [ss_ptr] "R" (&user_ss),
                     [cs64]   "i" (__USER_CS),
-                    "X" (ex_check_UD)
+                    [hnd] "p" (ex_check_UD)
 #ifdef __x86_64__
                   : "rbx", "rcx", "r11"
 #else
@@ -152,9 +152,9 @@ void test_main(void)
 
     /* Sanity check that breakpoints are working. */
     asm volatile ("mov %[ss], %%ss; nop; 1:"
-                  _ASM_EXTABLE_HANDLER(1b, 1b, ex_record_fault_eax)
+                  _ASM_EXTABLE_HANDLER(1b, 1b, %P[rec])
                   : "+a" (fault)
-                  : [ss] "m" (ss), "X" (ex_record_fault_eax));
+                  : [ss] "m" (ss), [rec] "p" (ex_record_fault_eax));
 
     if ( fault != exp )
         return xtf_error("Error checking breakpoint\n"

diff --git a/tests/xsa-278/main.c b/tests/xsa-278/main.c
index c23cf657f78231c46fc93896fff24ead0836ece3..919654c2b9b086b546c81472250783b8498e5667 100644 (file)
--- a/tests/xsa-278/main.c
+++ b/tests/xsa-278/main.c
@@ -31,10 +31,10 @@ static exinfo_t stub_vmclear(void)
     uint64_t addr = 0;
 
     asm volatile ("1: vmclear %[ptr]; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+D" (ex)
                   : [ptr] "m" (addr),
-                    "X" (ex_record_fault_edi));
+                    [rec] "p" (ex_record_fault_edi));
 
     return ex;
 }
@@ -45,10 +45,10 @@ static exinfo_t stub_vmptrld(void)
     uint64_t addr = 0;
 
     asm volatile ("1: vmptrld %[ptr]; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+D" (ex)
                   : [ptr] "m" (addr),
-                    "X" (ex_record_fault_edi));
+                    [rec] "p" (ex_record_fault_edi));
 
     return ex;
 }
@@ -59,9 +59,9 @@ static exinfo_t stub_vmptrst(void)
     uint64_t addr;
 
     asm volatile ("1: vmptrst %[ptr]; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+D" (ex), [ptr] "=m" (addr)
-                  : "X" (ex_record_fault_edi));
+                  : [rec] "p" (ex_record_fault_edi));
 
     return ex;
 }
@@ -72,10 +72,10 @@ static exinfo_t stub_vmread(void)
     unsigned long tmp;
 
     asm volatile ("1: vmread %[field], %[value]; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+D" (ex), [value] "=rm" (tmp)
                   : [field] "r" (0l),
-                    "X" (ex_record_fault_edi));
+                    [rec] "p" (ex_record_fault_edi));
 
     return ex;
 }
@@ -85,10 +85,10 @@ static exinfo_t stub_vmwrite(void)
     exinfo_t ex = 0;
 
     asm volatile ("1: vmwrite %[value], %[field]; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+D" (ex)
                   : [field] "r" (0l), [value] "rm" (0l),
-                    "X" (ex_record_fault_edi));
+                    [rec] "p" (ex_record_fault_edi));
 
     return ex;
 }
@@ -98,9 +98,9 @@ static exinfo_t stub_vmlaunch(void)
     exinfo_t ex = 0;
 
     asm volatile ("1: vmlaunch; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+D" (ex)
-                  : "X" (ex_record_fault_edi));
+                  : [rec] "p" (ex_record_fault_edi));
 
     return ex;
 }
@@ -110,9 +110,9 @@ static exinfo_t stub_vmresume(void)
     exinfo_t ex = 0;
 
     asm volatile ("1: vmresume; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+D" (ex)
-                  : "X" (ex_record_fault_edi));
+                  : [rec] "p" (ex_record_fault_edi));
 
     return ex;
 }
@@ -122,9 +122,9 @@ static exinfo_t stub_vmxoff(void)
     exinfo_t ex = 0;
 
     asm volatile ("1: vmxoff; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+D" (ex)
-                  : "X" (ex_record_fault_edi));
+                  : [rec] "p" (ex_record_fault_edi));
 
     return ex;
 }
@@ -135,10 +135,10 @@ static exinfo_t stub_vmxon(void)
     uint64_t addr = ~0ull;
 
     asm volatile ("1: vmxon %[ptr]; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+D" (ex)
                   : [ptr] "m" (addr),
-                    "X" (ex_record_fault_edi));
+                    [rec] "p" (ex_record_fault_edi));
 
     return ex;
 }
@@ -149,10 +149,10 @@ static exinfo_t stub_invept(void)
     struct { uint64_t eptp, rsvd; } desc;
 
     asm volatile ("1: invept %[desc], %[type]; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+D" (ex)
                   : [type] "r" (0l), [desc] "m" (desc),
-                    "X" (ex_record_fault_edi));
+                    [rec] "p" (ex_record_fault_edi));
 
     return ex;
 }
@@ -163,10 +163,10 @@ static exinfo_t stub_invvpid(void)
     struct { uint64_t vpid, linear; } desc;
 
     asm volatile ("1: invvpid %[desc], %[type]; 2:"
-                  _ASM_EXTABLE_HANDLER(1b, 2b, ex_record_fault_edi)
+                  _ASM_EXTABLE_HANDLER(1b, 2b, %P[rec])
                   : "+D" (ex)
                   : [type] "r" (0l), [desc] "m" (desc),
-                    "X" (ex_record_fault_edi));
+                    [rec] "p" (ex_record_fault_edi));
 
     return ex;
 }