Skip to contentSkip to conversation

x86/selftests: add clobbers for int80 on x86_64

PATCH Superseded Dmitry Safonov 2 participants 6 messages Feb 10, 2017

Subsystems (2)

v1 of 3 Superseded Latest is v3 →

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 x86/selftests: add clobbers for int80 on x86_64

Kernel erases R8..R11 registers prior returning to userspace from int80: https://lkml.org/lkml/2009/10/1/164

GCC can reuse this registers and doesn't expect them to change during syscall invocation. I met this kind of bug in CRIU once gcc 6.1 and clang stored local variables in those registers and the kernel zerofied them during syscall:
https://github.com/xemul/criu/commit/990d33f1a1cdd17bca6c2eb059ab3be2564f7fa2

By that reason I suggest to add those registers to clobbers in selftests.

Cc Shuah Khan <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Ingo Molnar <[email protected]>
Cc "H. Peter Anvin" <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
---
 tools/testing/selftests/x86/fsgsbase.c            |  2 +-
 tools/testing/selftests/x86/iopl.c                | 10 ++++++++--
 tools/testing/selftests/x86/ldt_gdt.c             | 16 +++++++++++-----
 tools/testing/selftests/x86/ptrace_syscall.c      |  3 ++-
 tools/testing/selftests/x86/single_step_syscall.c |  5 ++++-
 5 files changed, 26 insertions(+), 10 deletions(-)
tools/testing/selftests/x86/fsgsbase.c +1 -1
index 5b2b4b3c634c..059b06b2d81d 100644
@@ -245,7 +245,7 @@ void do_unexpected_base(void)
 		long ret;
 		asm volatile ("int $0x80"
 			      : "=a" (ret) : "a" (243), "b" (low_desc)
-			      : "flags");
+			      : "flags", "r8", "r9", "r10", "r11");
 		memcpy(&desc, low_desc, sizeof(desc));
 		munmap(low_desc, sizeof(desc));
 
tools/testing/selftests/x86/iopl.c +8 -2
index c496ca97bc18..98236a233db8 100644
@@ -19,6 +19,12 @@
 #include <sched.h>
 #include <sys/io.h>
 
+#ifdef __x86_64__
+# define INT80_CLOBBERS "r8", "r9", "r10", "r11"
+#else
+# define INT80_CLOBBERS
+#endif
+
 static int nerrs = 0;
 
 static void sethandler(int sig, void (*handler)(int, siginfo_t *, void *),
@@ -70,7 +76,7 @@ int main(void)
 			err(1, "iopl");
 
 		printf("[RUN]\tchild: write to 0x80\n");
-		asm volatile ("outb %%al, $0x80" : : "a" (0));
+		asm volatile ("outb %%al, $0x80" : : "a" (0) : INT80_CLOBBERS);
 
 		return 0;
 	} else {
@@ -93,7 +99,7 @@ int main(void)
 	if (sigsetjmp(jmpbuf, 1) != 0) {
 		printf("[OK]\twrite was denied\n");
 	} else {
-		asm volatile ("outb %%al, $0x80" : : "a" (0));
+		asm volatile ("outb %%al, $0x80" : : "a" (0) : INT80_CLOBBERS);
 		printf("[FAIL]\twrite was allowed\n");
 		nerrs++;
 	}
tools/testing/selftests/x86/ldt_gdt.c +11 -5
index 4af47079cf04..dfdabd1f3083 100644
@@ -45,6 +45,12 @@
 #define AR_DB			(1 << 22)
 #define AR_G			(1 << 23)
 
+#ifdef __x86_64__
+# define INT80_CLOBBERS "flags", "r8", "r9", "r10", "r11"
+#else
+# define INT80_CLOBBERS "flags"
+#endif
+
 static int nerrs;
 
 /* Points to an array of 1024 ints, each holding its own index. */
@@ -588,7 +594,7 @@ static int invoke_set_thread_area(void)
 	asm volatile ("int $0x80"
 		      : "=a" (ret), "+m" (low_user_desc) :
 			"a" (243), "b" (low_user_desc)
-		      : "flags");
+		      : INT80_CLOBBERS);
 	return ret;
 }
 
@@ -657,7 +663,7 @@ static void test_gdt_invalidation(void)
 			"+a" (eax)
 		      : "m" (low_user_desc_clear),
 			[arg1] "r" ((unsigned int)(unsigned long)low_user_desc_clear)
-		      : "flags");
+		      : INT80_CLOBBERS);
 
 	if (sel != 0) {
 		result = "FAIL";
@@ -688,7 +694,7 @@ static void test_gdt_invalidation(void)
 			"+a" (eax)
 		      : "m" (low_user_desc_clear),
 			[arg1] "r" ((unsigned int)(unsigned long)low_user_desc_clear)
-		      : "flags");
+		      : INT80_CLOBBERS);
 
 	if (sel != 0) {
 		result = "FAIL";
@@ -721,7 +727,7 @@ static void test_gdt_invalidation(void)
 			"+a" (eax)
 		      : "m" (low_user_desc_clear),
 			[arg1] "r" ((unsigned int)(unsigned long)low_user_desc_clear)
-		      : "flags");
+		      : INT80_CLOBBERS);
 
 #ifdef __x86_64__
 	syscall(SYS_arch_prctl, ARCH_GET_FS, &new_base);
@@ -774,7 +780,7 @@ static void test_gdt_invalidation(void)
 			"+a" (eax)
 		      : "m" (low_user_desc_clear),
 			[arg1] "r" ((unsigned int)(unsigned long)low_user_desc_clear)
-		      : "flags");
+		      : INT80_CLOBBERS);
 
 #ifdef __x86_64__
 	syscall(SYS_arch_prctl, ARCH_GET_GS, &new_base);
tools/testing/selftests/x86/ptrace_syscall.c +2 -1
index b037ce9cf116..eaea92439708 100644
@@ -58,7 +58,8 @@ static void do_full_int80(struct syscall_args32 *args)
 	asm volatile ("int $0x80"
 		      : "+a" (args->nr),
 			"+b" (args->arg0), "+c" (args->arg1), "+d" (args->arg2),
-			"+S" (args->arg3), "+D" (args->arg4), "+r" (bp));
+			"+S" (args->arg3), "+D" (args->arg4), "+r" (bp)
+			: : "r8", "r9", "r10", "r11");
 	args->arg5 = bp;
 #else
 	sys32_helper(args, int80_and_ret);
tools/testing/selftests/x86/single_step_syscall.c +4 -1
index 50c26358e8b7..a48da95c18fd 100644
@@ -56,9 +56,11 @@ static volatile sig_atomic_t sig_traps;
 #ifdef __x86_64__
 # define REG_IP REG_RIP
 # define WIDTH "q"
+# define INT80_CLOBBERS "r8", "r9", "r10", "r11"
 #else
 # define REG_IP REG_EIP
 # define WIDTH "l"
+# define INT80_CLOBBERS
 #endif
 
 static unsigned long get_eflags(void)
@@ -140,7 +142,8 @@ int main()
 
 	printf("[RUN]\tSet TF and check int80\n");
 	set_eflags(get_eflags() | X86_EFLAGS_TF);
-	asm volatile ("int $0x80" : "=a" (tmp) : "a" (SYS_getpid));
+	asm volatile ("int $0x80" : "=a" (tmp) : "a" (SYS_getpid)
+			: INT80_CLOBBERS);
 	check_result();
 
 	/*
Signature · 1 line
2.11.1
#1 lore raw
Quoted 21 lines · Dmitry Safonov

Kernel erases R8..R11 registers prior returning to userspace from int80: https://lkml.org/lkml/2009/10/1/164

GCC can reuse this registers and doesn't expect them to change during syscall invocation. I met this kind of bug in CRIU once gcc 6.1 and clang stored local variables in those registers and the kernel zerofied them during syscall:
https://github.com/xemul/criu/commit/990d33f1a1cdd17bca6c2eb059ab3be2564f7fa2

By that reason I suggest to add those registers to clobbers in selftests.

Cc Shuah Khan <[email protected]>
Cc Thomas Gleixner <[email protected]>
Cc Ingo Molnar <[email protected]>
Cc "H. Peter Anvin" <[email protected]>
Cc Andy Lutomirski <[email protected]>
Cc Borislav Petkov <[email protected]>
Quoted 3 lines
---
 tools/testing/selftests/x86/fsgsbase.c            |  2 +-
 tools/testing/selftests/x86/iopl.c                | 10 ++++++++--

Drop this one: iopl doesn't do int80 - it's my failure in grepping. Will resend.

Quoted 5 lines
 tools/testing/selftests/x86/ldt_gdt.c             | 16 +++++++++++-----
 tools/testing/selftests/x86/ptrace_syscall.c      |  3 ++-
 tools/testing/selftests/x86/single_step_syscall.c |  5 ++++-
 5 files changed, 26 insertions(+), 10 deletions(-)
Signature · 1 line
             Dmitry
#2 lore raw
In reply to Dmitry Safonov
Quoted 11 lines · Dmitry Safonov

Kernel erases R8..R11 registers prior returning to userspace from int80: https://lkml.org/lkml/2009/10/1/164

GCC can reuse this registers and doesn't expect them to change during syscall invocation. I met this kind of bug in CRIU once gcc 6.1 and clang stored local variables in those registers and the kernel zerofied them during syscall:
https://github.com/xemul/criu/commit/990d33f1a1cdd17bca6c2eb059ab3be2564f7fa2

By that reason I suggest to add those registers to clobbers in selftests.

Seems reasonable, but presumably INT80_CLOBBERS should be defined the same way in all the tests. IOW, if the "flags" clobber is actually needed, it should be "flags", INT80_CLOBBERS (possibly without the comma if it's problematic).

#3 lore raw
Quoted 10 lines · Andy Lutomirski
Quoted 9 lines · Dmitry Safonov

Kernel erases R8..R11 registers prior returning to userspace from int80: https://lkml.org/lkml/2009/10/1/164

GCC can reuse this registers and doesn't expect them to change during syscall invocation. I met this kind of bug in CRIU once gcc 6.1 and clang stored local variables in those registers and the kernel zerofied them during syscall:
https://github.com/xemul/criu/commit/990d33f1a1cdd17bca6c2eb059ab3be2564f7fa2

Quoted 8 lines
Quoted 2 lines

By that reason I suggest to add those registers to clobbers in selftests.

Seems reasonable, but presumably INT80_CLOBBERS should be defined the same way in all the tests. IOW, if the "flags" clobber is actually needed, it should be "flags", INT80_CLOBBERS (possibly without the comma if it's problematic).

Well, that was my initial attempt: I've defined it as:
+# define INT80_CLOBBERS , "r8", "r9", "r10", "r11"

But that hanging comma looks awful, so I added "flags" there. And if I do define it without coma and leave it in asm statement, 32-bit version would be unhappy.
So, I found that it's easier to define it with flags included.

Signature · 1 line
             Dmitry
#4 lore raw
Quoted 25 lines · Dmitry Safonov
Quoted 14 lines · Andy Lutomirski
Quoted 11 lines · Dmitry Safonov

Kernel erases R8..R11 registers prior returning to userspace from int80: https://lkml.org/lkml/2009/10/1/164

GCC can reuse this registers and doesn't expect them to change during syscall invocation. I met this kind of bug in CRIU once gcc 6.1 and clang stored local variables in those registers and the kernel zerofied them during syscall:

https://github.com/xemul/criu/commit/990d33f1a1cdd17bca6c2eb059ab3be2564f7fa2

Quoted 9 lines
Quoted 2 lines

By that reason I suggest to add those registers to clobbers in selftests.

Seems reasonable, but presumably INT80_CLOBBERS should be defined the same way in all the tests. IOW, if the "flags" clobber is actually needed, it should be "flags", INT80_CLOBBERS (possibly without the comma if it's problematic).

Quoted 8 lines

Well, that was my initial attempt: I've defined it as:
+# define INT80_CLOBBERS , "r8", "r9", "r10", "r11"

But that hanging comma looks awful, so I added "flags" there. And if I do define it without coma and leave it in asm statement, 32-bit version would be unhappy.
So, I found that it's easier to define it with flags included.

Woudl the right answer be to get rid of "flags" in the test where it appears? I'm not sure it's needed in the first place.

#5 lore raw
Quoted 29 lines · Andy Lutomirski
Quoted 28 lines · Dmitry Safonov
Quoted 14 lines · Andy Lutomirski
Quoted 11 lines · Dmitry Safonov

Kernel erases R8..R11 registers prior returning to userspace from int80: https://lkml.org/lkml/2009/10/1/164

GCC can reuse this registers and doesn't expect them to change during syscall invocation. I met this kind of bug in CRIU once gcc 6.1 and clang stored local variables in those registers and the kernel zerofied them during syscall:

https://github.com/xemul/criu/commit/990d33f1a1cdd17bca6c2eb059ab3be2564f7fa2

Quoted 9 lines
Quoted 2 lines

By that reason I suggest to add those registers to clobbers in selftests.

Seems reasonable, but presumably INT80_CLOBBERS should be defined the same way in all the tests. IOW, if the "flags" clobber is actually needed, it should be "flags", INT80_CLOBBERS (possibly without the comma if it's problematic).

Well, that was my initial attempt: I've defined it as:
+# define INT80_CLOBBERS , "r8", "r9", "r10", "r11"

Quoted 9 lines
Quoted 5 lines

But that hanging comma looks awful, so I added "flags" there. And if I do define it without coma and leave it in asm statement, 32-bit version would be unhappy.
So, I found that it's easier to define it with flags included.

Woudl the right answer be to get rid of "flags" in the test where it appears? I'm not sure it's needed in the first place.

I think it can live without it.
But I didn't want to change it in the same patch and wasn't sure if I fail to see the reason for it.
So, I'll resend with flags removing, thanks.

Signature · 1 line
             Dmitry