tools/testing/selftests/x86/test_syscall_vdso.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0-only
 /*
  * 32-bit syscall ABI conformance test.
  *
  * Copyright (c) 2015 Denys Vlasenko
  */
 /*
  * Can be built statically:
  * gcc -Os -Wall -static -m32 test_syscall_vdso.c thunks_32.S
  */
 #undef _GNU_SOURCE
 #define _GNU_SOURCE 1
 #undef __USE_GNU
 #define __USE_GNU 1
 #include <unistd.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <signal.h>
 #include <sys/types.h>
 #include <sys/select.h>
 #include <sys/time.h>
 #include <elf.h>
 #include <sys/ptrace.h>
 #include <sys/wait.h>

 #if !defined(__i386__)
 int main(int argc, char **argv, char **envp)
 {
 	printf("[SKIP]\tNot a 32-bit x86 userspace\n");
 	return 0;
 }
 #else

 long syscall_addr;
 long get_syscall(char **envp)
 {
 	Elf32_auxv_t *auxv;
 	while (*envp++ != NULL)
 		continue;
 	for (auxv = (void *)envp; auxv->a_type != AT_NULL; auxv++)
 		if (auxv->a_type == AT_SYSINFO)
 			return auxv->a_un.a_val;
 	printf("[WARN]\tAT_SYSINFO not supplied\n");
 	return 0;
 }

 asm (
 	"	.pushsection .text\n"
 	"	.global	int80\n"
 	"int80:\n"
 	"	int	$0x80\n"
 	"	ret\n"
 	"	.popsection\n"
 );
 extern char int80;

 struct regs64 {
 	uint64_t rax, rbx, rcx, rdx;
 	uint64_t rsi, rdi, rbp, rsp;
 	uint64_t r8,  r9,  r10, r11;
 	uint64_t r12, r13, r14, r15;
 };
 struct regs64 regs64;
 int kernel_is_64bit;

 asm (
 	"	.pushsection .text\n"
 	"	.code64\n"
 	"get_regs64:\n"
 	"	push	%rax\n"
 	"	mov	$regs64, %eax\n"
 	"	pop	0*8(%rax)\n"
 	"	movq	%rbx, 1*8(%rax)\n"
 	"	movq	%rcx, 2*8(%rax)\n"
 	"	movq	%rdx, 3*8(%rax)\n"
 	"	movq	%rsi, 4*8(%rax)\n"
 	"	movq	%rdi, 5*8(%rax)\n"
 	"	movq	%rbp, 6*8(%rax)\n"
 	"	movq	%rsp, 7*8(%rax)\n"
 	"	movq	%r8,  8*8(%rax)\n"
 	"	movq	%r9,  9*8(%rax)\n"
 	"	movq	%r10, 10*8(%rax)\n"
 	"	movq	%r11, 11*8(%rax)\n"
 	"	movq	%r12, 12*8(%rax)\n"
 	"	movq	%r13, 13*8(%rax)\n"
 	"	movq	%r14, 14*8(%rax)\n"
 	"	movq	%r15, 15*8(%rax)\n"
 	"	ret\n"
 	"poison_regs64:\n"
 	"	movq	$0x7f7f7f7f, %r8\n"
 	"	shl	$32, %r8\n"
 	"	orq	$0x7f7f7f7f, %r8\n"
 	"	movq	%r8, %r9\n"
 	"	incq	%r9\n"
 	"	movq	%r9, %r10\n"
 	"	incq	%r10\n"
 	"	movq	%r10, %r11\n"
 	"	incq	%r11\n"
 	"	movq	%r11, %r12\n"
 	"	incq	%r12\n"
 	"	movq	%r12, %r13\n"
 	"	incq	%r13\n"
 	"	movq	%r13, %r14\n"
 	"	incq	%r14\n"
 	"	movq	%r14, %r15\n"
 	"	incq	%r15\n"
 	"	ret\n"
 	"	.code32\n"
 	"	.popsection\n"
 );
 extern void get_regs64(void);
 extern void poison_regs64(void);
 extern unsigned long call64_from_32(void (*function)(void));
 void print_regs64(void)
 {
 	if (!kernel_is_64bit)
 		return;
 	printf("ax:%016llx bx:%016llx cx:%016llx dx:%016llx\n", regs64.rax,  regs64.rbx,  regs64.rcx,  regs64.rdx);
 	printf("si:%016llx di:%016llx bp:%016llx sp:%016llx\n", regs64.rsi,  regs64.rdi,  regs64.rbp,  regs64.rsp);
 	printf(" 8:%016llx  9:%016llx 10:%016llx 11:%016llx\n", regs64.r8 ,  regs64.r9 ,  regs64.r10,  regs64.r11);
 	printf("12:%016llx 13:%016llx 14:%016llx 15:%016llx\n", regs64.r12,  regs64.r13,  regs64.r14,  regs64.r15);
 }

 int check_regs64(void)
 {
 	int err = 0;
 	int num = 8;
 	uint64_t *r64 = &regs64.r8;
 	uint64_t expected = 0x7f7f7f7f7f7f7f7fULL;

 	if (!kernel_is_64bit)
 		return 0;

 	do {
 		if (*r64 == expected++)
 			continue; /* register did not change */
 		if (syscall_addr != (long)&int80) {
 			/*
 			 * Non-INT80 syscall entrypoints are allowed to clobber R8+ regs:
 			 * either clear them to 0, or for R11, load EFLAGS.
 			 */
 			if (*r64 == 0)
 				continue;
 			if (num == 11) {
 				printf("[NOTE]\tR11 has changed:%016llx - assuming clobbered by SYSRET insn\n", *r64);
 				continue;
 			}
 		} else {
 			/*
 			 * INT80 syscall entrypoint can be used by
 			 * 64-bit programs too, unlike SYSCALL/SYSENTER.
 			 * Therefore it must preserve R12+
 			 * (they are callee-saved registers in 64-bit C ABI).
 			 *
 			 * Starting in Linux 4.17 (and any kernel that
 			 * backports the change), R8..11 are preserved.
 			 * Historically (and probably unintentionally), they
 			 * were clobbered or zeroed.
 			 */
 		}
 		printf("[FAIL]\tR%d has changed:%016llx\n", num, *r64);
 		err++;
 	} while (r64++, ++num < 16);

 	if (!err)
 		printf("[OK]\tR8..R15 did not leak kernel data\n");
 	return err;
 }

 int nfds;
 fd_set rfds;
 fd_set wfds;
 fd_set efds;
 struct timespec timeout;
 sigset_t sigmask;
 struct {
 	sigset_t *sp;
 	int sz;
 } sigmask_desc;

 void prep_args()
 {
 	nfds = 42;
 	FD_ZERO(&rfds);
 	FD_ZERO(&wfds);
 	FD_ZERO(&efds);
 	FD_SET(0, &rfds);
 	FD_SET(1, &wfds);
 	FD_SET(2, &efds);
 	timeout.tv_sec = 0;
 	timeout.tv_nsec = 123;
 	sigemptyset(&sigmask);
 	sigaddset(&sigmask, SIGINT);
 	sigaddset(&sigmask, SIGUSR2);
 	sigaddset(&sigmask, SIGRTMAX);
 	sigmask_desc.sp = &sigmask;
 	sigmask_desc.sz = 8; /* bytes */
 }

 static void print_flags(const char *name, unsigned long r)
 {
 	static const char *bitarray[] = {
 	"\n" ,"c\n" ,/* Carry Flag */
 	"0 " ,"1 "  ,/* Bit 1 - always on */
 	""   ,"p "  ,/* Parity Flag */
 	"0 " ,"3? " ,
 	""   ,"a "  ,/* Auxiliary carry Flag */
 	"0 " ,"5? " ,
 	""   ,"z "  ,/* Zero Flag */
 	""   ,"s "  ,/* Sign Flag */
 	""   ,"t "  ,/* Trap Flag */
 	""   ,"i "  ,/* Interrupt Flag */
 	""   ,"d "  ,/* Direction Flag */
 	""   ,"o "  ,/* Overflow Flag */
 	"0 " ,"1 "  ,/* I/O Privilege Level (2 bits) */
 	"0"  ,"1"   ,/* I/O Privilege Level (2 bits) */
 	""   ,"n "  ,/* Nested Task */
 	"0 " ,"15? ",
 	""   ,"r "  ,/* Resume Flag */
 	""   ,"v "  ,/* Virtual Mode */
 	""   ,"ac " ,/* Alignment Check/Access Control */
 	""   ,"vif ",/* Virtual Interrupt Flag */
 	""   ,"vip ",/* Virtual Interrupt Pending */
 	""   ,"id " ,/* CPUID detection */
 	NULL
 	};
 	const char **bitstr;
 	int bit;

 	printf("%s=%016lx ", name, r);
 	bitstr = bitarray + 42;
 	bit = 21;
 	if ((r >> 22) != 0)
 		printf("(extra bits are set) ");
 	do {
 		if (bitstr[(r >> bit) & 1][0])
 			fputs(bitstr[(r >> bit) & 1], stdout);
 		bitstr -= 2;
 		bit--;
 	} while (bit >= 0);
 }

 int run_syscall(void)
 {
 	long flags, bad_arg;

 	prep_args();

 	if (kernel_is_64bit)
 		call64_from_32(poison_regs64);
 	/*print_regs64();*/

 	asm("\n"
 	/* Try 6-arg syscall: pselect. It should return quickly */
 	"	push	%%ebp\n"
 	"	mov	$308, %%eax\n"     /* PSELECT */
 	"	mov	nfds, %%ebx\n"     /* ebx  arg1 */
 	"	mov	$rfds, %%ecx\n"    /* ecx  arg2 */
 	"	mov	$wfds, %%edx\n"    /* edx  arg3 */
 	"	mov	$efds, %%esi\n"    /* esi  arg4 */
 	"	mov	$timeout, %%edi\n" /* edi  arg5 */
 	"	mov	$sigmask_desc, %%ebp\n" /* %ebp arg6 */
 	"	push	$0x200ed7\n"      /* set almost all flags */
 	"	popf\n"		/* except TF, IOPL, NT, RF, VM, AC, VIF, VIP */
 	"	call	*syscall_addr\n"
 	/* Check that registers are not clobbered */
 	"	pushf\n"
 	"	pop	%%eax\n"
 	"	cld\n"
 	"	cmp	nfds, %%ebx\n"     /* ebx  arg1 */
 	"	mov	$1, %%ebx\n"
 	"	jne	1f\n"
 	"	cmp	$rfds, %%ecx\n"    /* ecx  arg2 */
 	"	mov	$2, %%ebx\n"
 	"	jne	1f\n"
 	"	cmp	$wfds, %%edx\n"    /* edx  arg3 */
 	"	mov	$3, %%ebx\n"
 	"	jne	1f\n"
 	"	cmp	$efds, %%esi\n"    /* esi  arg4 */
 	"	mov	$4, %%ebx\n"
 	"	jne	1f\n"
 	"	cmp	$timeout, %%edi\n" /* edi  arg5 */
 	"	mov	$5, %%ebx\n"
 	"	jne	1f\n"
 	"	cmpl	$sigmask_desc, %%ebp\n" /* %ebp arg6 */
 	"	mov	$6, %%ebx\n"
 	"	jne	1f\n"
 	"	mov	$0, %%ebx\n"
 	"1:\n"
 	"	pop	%%ebp\n"
 	: "=a" (flags), "=b" (bad_arg)
 	:
 	: "cx", "dx", "si", "di"
 	);

 	if (kernel_is_64bit) {
 		memset(&regs64, 0x77, sizeof(regs64));
 		call64_from_32(get_regs64);
 		/*print_regs64();*/
 	}

 	/*
 	 * On paravirt kernels, flags are not preserved across syscalls.
 	 * Thus, we do not consider it a bug if some are changed.
 	 * We just show ones which do.
 	 */
 	if ((0x200ed7 ^ flags) != 0) {
 		print_flags("[WARN]\tFlags before", 0x200ed7);
 		print_flags("[WARN]\tFlags  after", flags);
 		print_flags("[WARN]\tFlags change", (0x200ed7 ^ flags));
 	}

 	if (bad_arg) {
 		printf("[FAIL]\targ#%ld clobbered\n", bad_arg);
 		return 1;
 	}
 	printf("[OK]\tArguments are preserved across syscall\n");

 	return check_regs64();
 }

 int run_syscall_twice()
 {
 	int exitcode = 0;
 	long sv;

 	if (syscall_addr) {
 		printf("[RUN]\tExecuting 6-argument 32-bit syscall via VDSO\n");
 		exitcode = run_syscall();
 	}
 	sv = syscall_addr;
 	syscall_addr = (long)&int80;
 	printf("[RUN]\tExecuting 6-argument 32-bit syscall via INT 80\n");
 	exitcode += run_syscall();
 	syscall_addr = sv;
 	return exitcode;
 }

 void ptrace_me()
 {
 	pid_t pid;

 	fflush(NULL);
 	pid = fork();
 	if (pid < 0)
 		exit(1);
 	if (pid == 0) {
 		/* child */
 		if (ptrace(PTRACE_TRACEME, 0L, 0L, 0L) != 0)
 			exit(0);
 		raise(SIGSTOP);
 		return;
 	}
 	/* parent */
 	printf("[RUN]\tRunning tests under ptrace\n");
 	while (1) {
 		int status;
 		pid = waitpid(-1, &status, __WALL);
 		if (WIFEXITED(status))
 			exit(WEXITSTATUS(status));
 		if (WIFSIGNALED(status))
 			exit(WTERMSIG(status));
 		if (pid <= 0 || !WIFSTOPPED(status)) /* paranoia */
 			exit(255);
 		/*
 		 * Note: we do not inject sig = WSTOPSIG(status).
 		 * We probably should, but careful: do not inject SIGTRAP
 		 * generated by syscall entry/exit stops.
 		 * That kills the child.
 		 */
 		ptrace(PTRACE_SYSCALL, pid, 0L, 0L /*sig*/);
 	}
 }

 int main(int argc, char **argv, char **envp)
 {
 	int exitcode = 0;
 	int cs;

 	asm("\n"
 	"	movl	%%cs, %%eax\n"
 	: "=a" (cs)
 	);
 	kernel_is_64bit = (cs == 0x23);
 	if (!kernel_is_64bit)
 		printf("[NOTE]\tNot a 64-bit kernel, won't test R8..R15 leaks\n");

 	/* This only works for non-static builds:
 	 * syscall_addr = dlsym(dlopen("linux-gate.so.1", RTLD_NOW), "__kernel_vsyscall");
 	 */
 	syscall_addr = get_syscall(envp);

 	exitcode += run_syscall_twice();
 	ptrace_me();
 	exitcode += run_syscall_twice();

 	return exitcode;
 }
 #endif
	// SPDX-License-Identifier: GPL-2.0-only
	/*
	* 32-bit syscall ABI conformance test.
	*
	* Copyright (c) 2015 Denys Vlasenko
	*/
	/*
	* Can be built statically:
	* gcc -Os -Wall -static -m32 test_syscall_vdso.c thunks_32.S
	*/
	#undef _GNU_SOURCE
	#define _GNU_SOURCE 1
	#undef __USE_GNU
	#define __USE_GNU 1
	#include <unistd.h>
	#include <stdlib.h>
	#include <string.h>
	#include <stdio.h>
	#include <signal.h>
	#include <sys/types.h>
	#include <sys/select.h>
	#include <sys/time.h>
	#include <elf.h>
	#include <sys/ptrace.h>
	#include <sys/wait.h>

	#if !defined(__i386__)
	int main(int argc, char argv, char envp)
	{
	printf("[SKIP]\tNot a 32-bit x86 userspace\n");
	return 0;
	}
	#else

	long syscall_addr;
	long get_syscall(char **envp)
	{
	Elf32_auxv_t *auxv;
	while (*envp++ != NULL)
	continue;
	for (auxv = (void *)envp; auxv->a_type != AT_NULL; auxv++)
	if (auxv->a_type == AT_SYSINFO)
	return auxv->a_un.a_val;
	printf("[WARN]\tAT_SYSINFO not supplied\n");
	return 0;
	}

	asm (
	" .pushsection .text\n"
	" .global int80\n"
	"int80:\n"
	" int $0x80\n"
	" ret\n"
	" .popsection\n"
	);
	extern char int80;

	struct regs64 {
	uint64_t rax, rbx, rcx, rdx;
	uint64_t rsi, rdi, rbp, rsp;
	uint64_t r8, r9, r10, r11;
	uint64_t r12, r13, r14, r15;
	};
	struct regs64 regs64;
	int kernel_is_64bit;

	asm (
	" .pushsection .text\n"
	" .code64\n"
	"get_regs64:\n"
	" push %rax\n"
	" mov $regs64, %eax\n"
	" pop 0*8(%rax)\n"
	" movq %rbx, 1*8(%rax)\n"
	" movq %rcx, 2*8(%rax)\n"
	" movq %rdx, 3*8(%rax)\n"
	" movq %rsi, 4*8(%rax)\n"
	" movq %rdi, 5*8(%rax)\n"
	" movq %rbp, 6*8(%rax)\n"
	" movq %rsp, 7*8(%rax)\n"
	" movq %r8, 8*8(%rax)\n"
	" movq %r9, 9*8(%rax)\n"
	" movq %r10, 10*8(%rax)\n"
	" movq %r11, 11*8(%rax)\n"
	" movq %r12, 12*8(%rax)\n"
	" movq %r13, 13*8(%rax)\n"
	" movq %r14, 14*8(%rax)\n"
	" movq %r15, 15*8(%rax)\n"
	" ret\n"
	"poison_regs64:\n"
	" movq $0x7f7f7f7f, %r8\n"
	" shl $32, %r8\n"
	" orq $0x7f7f7f7f, %r8\n"
	" movq %r8, %r9\n"
	" incq %r9\n"
	" movq %r9, %r10\n"
	" incq %r10\n"
	" movq %r10, %r11\n"
	" incq %r11\n"
	" movq %r11, %r12\n"
	" incq %r12\n"
	" movq %r12, %r13\n"
	" incq %r13\n"
	" movq %r13, %r14\n"
	" incq %r14\n"
	" movq %r14, %r15\n"
	" incq %r15\n"
	" ret\n"
	" .code32\n"
	" .popsection\n"
	);
	extern void get_regs64(void);
	extern void poison_regs64(void);
	extern unsigned long call64_from_32(void (*function)(void));
	void print_regs64(void)
	{
	if (!kernel_is_64bit)
	return;
	printf("ax:%016llx bx:%016llx cx:%016llx dx:%016llx\n", regs64.rax, regs64.rbx, regs64.rcx, regs64.rdx);
	printf("si:%016llx di:%016llx bp:%016llx sp:%016llx\n", regs64.rsi, regs64.rdi, regs64.rbp, regs64.rsp);
	printf(" 8:%016llx 9:%016llx 10:%016llx 11:%016llx\n", regs64.r8 , regs64.r9 , regs64.r10, regs64.r11);
	printf("12:%016llx 13:%016llx 14:%016llx 15:%016llx\n", regs64.r12, regs64.r13, regs64.r14, regs64.r15);
	}

	int check_regs64(void)
	{
	int err = 0;
	int num = 8;
	uint64_t *r64 = &regs64.r8;
	uint64_t expected = 0x7f7f7f7f7f7f7f7fULL;

	if (!kernel_is_64bit)
	return 0;

	do {
	if (*r64 == expected++)
	continue; /* register did not change */
	if (syscall_addr != (long)&int80) {
	/*
	* Non-INT80 syscall entrypoints are allowed to clobber R8+ regs:
	* either clear them to 0, or for R11, load EFLAGS.
	*/
	if (*r64 == 0)
	continue;
	if (num == 11) {
	printf("[NOTE]\tR11 has changed:%016llx - assuming clobbered by SYSRET insn\n", *r64);
	continue;
	}
	} else {
	/*
	* INT80 syscall entrypoint can be used by
	* 64-bit programs too, unlike SYSCALL/SYSENTER.
	* Therefore it must preserve R12+
	* (they are callee-saved registers in 64-bit C ABI).
	*
	* Starting in Linux 4.17 (and any kernel that
	* backports the change), R8..11 are preserved.
	* Historically (and probably unintentionally), they
	* were clobbered or zeroed.
	*/
	}
	printf("[FAIL]\tR%d has changed:%016llx\n", num, *r64);
	err++;
	} while (r64++, ++num < 16);

	if (!err)
	printf("[OK]\tR8..R15 did not leak kernel data\n");
	return err;
	}

	int nfds;
	fd_set rfds;
	fd_set wfds;
	fd_set efds;
	struct timespec timeout;
	sigset_t sigmask;
	struct {
	sigset_t *sp;
	int sz;
	} sigmask_desc;

	void prep_args()
	{
	nfds = 42;
	FD_ZERO(&rfds);
	FD_ZERO(&wfds);
	FD_ZERO(&efds);
	FD_SET(0, &rfds);
	FD_SET(1, &wfds);
	FD_SET(2, &efds);
	timeout.tv_sec = 0;
	timeout.tv_nsec = 123;
	sigemptyset(&sigmask);
	sigaddset(&sigmask, SIGINT);
	sigaddset(&sigmask, SIGUSR2);
	sigaddset(&sigmask, SIGRTMAX);
	sigmask_desc.sp = &sigmask;
	sigmask_desc.sz = 8; /* bytes */
	}

	static void print_flags(const char *name, unsigned long r)
	{
	static const char *bitarray[] = {
	"\n" ,"c\n" ,/* Carry Flag */
	"0 " ,"1 " ,/* Bit 1 - always on */
	"" ,"p " ,/* Parity Flag */
	"0 " ,"3? " ,
	"" ,"a " ,/* Auxiliary carry Flag */
	"0 " ,"5? " ,
	"" ,"z " ,/* Zero Flag */
	"" ,"s " ,/* Sign Flag */
	"" ,"t " ,/* Trap Flag */
	"" ,"i " ,/* Interrupt Flag */
	"" ,"d " ,/* Direction Flag */
	"" ,"o " ,/* Overflow Flag */
	"0 " ,"1 " ,/* I/O Privilege Level (2 bits) */
	"0" ,"1" ,/* I/O Privilege Level (2 bits) */
	"" ,"n " ,/* Nested Task */
	"0 " ,"15? ",
	"" ,"r " ,/* Resume Flag */
	"" ,"v " ,/* Virtual Mode */
	"" ,"ac " ,/* Alignment Check/Access Control */
	"" ,"vif ",/* Virtual Interrupt Flag */
	"" ,"vip ",/* Virtual Interrupt Pending */
	"" ,"id " ,/* CPUID detection */
	NULL
	};
	const char **bitstr;
	int bit;

	printf("%s=%016lx ", name, r);
	bitstr = bitarray + 42;
	bit = 21;
	if ((r >> 22) != 0)
	printf("(extra bits are set) ");
	do {
	if (bitstr[(r >> bit) & 1][0])
	fputs(bitstr[(r >> bit) & 1], stdout);
	bitstr -= 2;
	bit--;
	} while (bit >= 0);
	}

	int run_syscall(void)
	{
	long flags, bad_arg;

	prep_args();

	if (kernel_is_64bit)
	call64_from_32(poison_regs64);
	/print_regs64();/

	asm("\n"
	/* Try 6-arg syscall: pselect. It should return quickly */
	" push %%ebp\n"
	" mov $308, %%eax\n" /* PSELECT */
	" mov nfds, %%ebx\n" /* ebx arg1 */
	" mov $rfds, %%ecx\n" /* ecx arg2 */
	" mov $wfds, %%edx\n" /* edx arg3 */
	" mov $efds, %%esi\n" /* esi arg4 */
	" mov $timeout, %%edi\n" /* edi arg5 */
	" mov $sigmask_desc, %%ebp\n" /* %ebp arg6 */
	" push $0x200ed7\n" /* set almost all flags */
	" popf\n" /* except TF, IOPL, NT, RF, VM, AC, VIF, VIP */
	" call *syscall_addr\n"
	/* Check that registers are not clobbered */
	" pushf\n"
	" pop %%eax\n"
	" cld\n"
	" cmp nfds, %%ebx\n" /* ebx arg1 */
	" mov $1, %%ebx\n"
	" jne 1f\n"
	" cmp $rfds, %%ecx\n" /* ecx arg2 */
	" mov $2, %%ebx\n"
	" jne 1f\n"
	" cmp $wfds, %%edx\n" /* edx arg3 */
	" mov $3, %%ebx\n"
	" jne 1f\n"
	" cmp $efds, %%esi\n" /* esi arg4 */
	" mov $4, %%ebx\n"
	" jne 1f\n"
	" cmp $timeout, %%edi\n" /* edi arg5 */
	" mov $5, %%ebx\n"
	" jne 1f\n"
	" cmpl $sigmask_desc, %%ebp\n" /* %ebp arg6 */
	" mov $6, %%ebx\n"
	" jne 1f\n"
	" mov $0, %%ebx\n"
	"1:\n"
	" pop %%ebp\n"
	: "=a" (flags), "=b" (bad_arg)
	:
	: "cx", "dx", "si", "di"
	);

	if (kernel_is_64bit) {
	memset(&regs64, 0x77, sizeof(regs64));
	call64_from_32(get_regs64);
	/print_regs64();/
	}

	/*
	* On paravirt kernels, flags are not preserved across syscalls.
	* Thus, we do not consider it a bug if some are changed.
	* We just show ones which do.
	*/
	if ((0x200ed7 ^ flags) != 0) {
	print_flags("[WARN]\tFlags before", 0x200ed7);
	print_flags("[WARN]\tFlags after", flags);
	print_flags("[WARN]\tFlags change", (0x200ed7 ^ flags));
	}

	if (bad_arg) {
	printf("[FAIL]\targ#%ld clobbered\n", bad_arg);
	return 1;
	}
	printf("[OK]\tArguments are preserved across syscall\n");

	return check_regs64();
	}

	int run_syscall_twice()
	{
	int exitcode = 0;
	long sv;

	if (syscall_addr) {
	printf("[RUN]\tExecuting 6-argument 32-bit syscall via VDSO\n");
	exitcode = run_syscall();
	}
	sv = syscall_addr;
	syscall_addr = (long)&int80;
	printf("[RUN]\tExecuting 6-argument 32-bit syscall via INT 80\n");
	exitcode += run_syscall();
	syscall_addr = sv;
	return exitcode;
	}

	void ptrace_me()
	{
	pid_t pid;

	fflush(NULL);
	pid = fork();
	if (pid < 0)
	exit(1);
	if (pid == 0) {
	/* child */
	if (ptrace(PTRACE_TRACEME, 0L, 0L, 0L) != 0)
	exit(0);
	raise(SIGSTOP);
	return;
	}
	/* parent */
	printf("[RUN]\tRunning tests under ptrace\n");
	while (1) {
	int status;
	pid = waitpid(-1, &status, __WALL);
	if (WIFEXITED(status))
	exit(WEXITSTATUS(status));
	if (WIFSIGNALED(status))
	exit(WTERMSIG(status));
	if (pid <= 0 \|\| !WIFSTOPPED(status)) /* paranoia */
	exit(255);
	/*
	* Note: we do not inject sig = WSTOPSIG(status).
	* We probably should, but careful: do not inject SIGTRAP
	* generated by syscall entry/exit stops.
	* That kills the child.
	*/
	ptrace(PTRACE_SYSCALL, pid, 0L, 0L /sig/);
	}
	}

	int main(int argc, char argv, char envp)
	{
	int exitcode = 0;
	int cs;

	asm("\n"
	" movl %%cs, %%eax\n"
	: "=a" (cs)
	);
	kernel_is_64bit = (cs == 0x23);
	if (!kernel_is_64bit)
	printf("[NOTE]\tNot a 64-bit kernel, won't test R8..R15 leaks\n");

	/* This only works for non-static builds:
	* syscall_addr = dlsym(dlopen("linux-gate.so.1", RTLD_NOW), "__kernel_vsyscall");
	*/
	syscall_addr = get_syscall(envp);

	exitcode += run_syscall_twice();
	ptrace_me();
	exitcode += run_syscall_twice();

	return exitcode;
	}
	#endif