selftests: vDSO: vdso_standalone_test_x86: Switch to nolibc

CFLAGS += $(TOOLS_INCLUDES)

CFLAGS_NOLIBC := -nostdlib -nostdinc -ffreestanding -fno-asynchronous-unwind-tables \

		 -fno-stack-protector -include $(top_srcdir)/tools/include/nolibc/nolibc.h \

		 -I$(top_srcdir)/tools/include/nolibc/ $(KHDR_INCLUDES)

$(OUTPUT)/vdso_test_gettimeofday: parse_vdso.c vdso_test_gettimeofday.c

$(OUTPUT)/vdso_test_getcpu: parse_vdso.c vdso_test_getcpu.c

$(OUTPUT)/vdso_test_abi: parse_vdso.c vdso_test_abi.c

$(OUTPUT)/vdso_test_clock_getres: vdso_test_clock_getres.c

$(OUTPUT)/vdso_standalone_test_x86: vdso_standalone_test_x86.c parse_vdso.c

$(OUTPUT)/vdso_standalone_test_x86: CFLAGS +=-nostdlib -fno-asynchronous-unwind-tables -fno-stack-protector

$(OUTPUT)/vdso_standalone_test_x86: vdso_standalone_test_x86.c parse_vdso.c | headers

$(OUTPUT)/vdso_standalone_test_x86: CFLAGS:=$(CFLAGS_NOLIBC) $(CFLAGS)

$(OUTPUT)/vdso_test_correctness: vdso_test_correctness.c

$(OUTPUT)/vdso_test_correctness: LDFLAGS += -ldl

// SPDX-License-Identifier: GPL-2.0-only

/*

 * vdso_test.c: Sample code to test parse_vdso.c on x86

 * Copyright (c) 2011-2014 Andy Lutomirski

 * vdso_test_gettimeofday.c: Sample code to test parse_vdso.c and

 *                           vDSO gettimeofday()

 * Copyright (c) 2014 Andy Lutomirski

 *

 * You can amuse yourself by compiling with:

 * gcc -std=gnu99 -nostdlib

 *     -Os -fno-asynchronous-unwind-tables -flto -lgcc_s

 *      vdso_standalone_test_x86.c parse_vdso.c

 * to generate a small binary.  On x86_64, you can omit -lgcc_s

 * if you want the binary to be completely standalone.

 * Compile with:

 * gcc -std=gnu99 vdso_test_gettimeofday.c parse_vdso_gettimeofday.c

 *

 * Tested on x86, 32-bit and 64-bit.  It may work on other architectures, too.

 */

#include <sys/syscall.h>

#include <stdio.h>

#ifndef NOLIBC

#include <sys/auxv.h>

#include <sys/time.h>

#include <unistd.h>

#include <stdint.h>

#include <linux/auxvec.h>

#include "parse_vdso.h"

/* We need some libc functions... */

int strcmp(const char *a, const char *b)

{

	/* This implementation is buggy: it never returns -1. */

	while (*a || *b) {

		if (*a != *b)

			return 1;

		if (*a == 0 || *b == 0)

			return 1;

		a++;

		b++;

	}

	return 0;

}

/*

 * The clang build needs this, although gcc does not.

 * Stolen from lib/string.c.

 */

void *memcpy(void *dest, const void *src, size_t count)

{

	char *tmp = dest;

	const char *s = src;

	while (count--)

		*tmp++ = *s++;

	return dest;

}

/* ...and two syscalls.  This is x86-specific. */

static inline long x86_syscall3(long nr, long a0, long a1, long a2)

{

	long ret;

#ifdef __x86_64__

	asm volatile ("syscall" : "=a" (ret) : "a" (nr),

		      "D" (a0), "S" (a1), "d" (a2) :

		      "cc", "memory", "rcx",

		      "r8", "r9", "r10", "r11" );

#else

	asm volatile ("int $0x80" : "=a" (ret) : "a" (nr),

		      "b" (a0), "c" (a1), "d" (a2) :

		      "cc", "memory" );

#endif

	return ret;

}

static inline long linux_write(int fd, const void *data, size_t len)

{

	return x86_syscall3(__NR_write, fd, (long)data, (long)len);

}

static inline void linux_exit(int code)

{

	x86_syscall3(__NR_exit, code, 0, 0);

}

void to_base10(char *lastdig, time_t n)

{

	while (n) {

		*lastdig = (n % 10) + '0';

		n /= 10;

		lastdig--;

	}

}

#include "../kselftest.h"

#include "parse_vdso.h"

#include "vdso_config.h"

#include "vdso_call.h"

unsigned long getauxval(const unsigned long *auxv, unsigned long type)

int main(int argc, char **argv)

{

	unsigned long ret;

	if (!auxv)

		return 0;

	while (1) {

		if (!auxv[0] && !auxv[1]) {

			ret = 0;

			break;

		}

		if (auxv[0] == type) {

			ret = auxv[1];

			break;

		}

	const char *version = versions[VDSO_VERSION];

	const char **name = (const char **)&names[VDSO_NAMES];

		auxv += 2;

	unsigned long sysinfo_ehdr = getauxval(AT_SYSINFO_EHDR);

	if (!sysinfo_ehdr) {

		printf("AT_SYSINFO_EHDR is not present!\n");

		return KSFT_SKIP;

	}

	return ret;

}

void c_main(void **stack)

{

	/* Parse the stack */

	long argc = (long)*stack;

	stack += argc + 2;

	/* Now we're pointing at the environment.  Skip it. */

	while(*stack)

		stack++;

	stack++;

	/* Now we're pointing at auxv.  Initialize the vDSO parser. */

	vdso_init_from_sysinfo_ehdr(getauxval((unsigned long *)stack, AT_SYSINFO_EHDR));

	vdso_init_from_sysinfo_ehdr(getauxval(AT_SYSINFO_EHDR));

	/* Find gettimeofday. */

	typedef long (*gtod_t)(struct timeval *tv, struct timezone *tz);

	gtod_t gtod = (gtod_t)vdso_sym("LINUX_2.6", "__vdso_gettimeofday");

	gtod_t gtod = (gtod_t)vdso_sym(version, name[0]);

	if (!gtod)

		linux_exit(1);

	if (!gtod) {

		printf("Could not find %s\n", name[0]);

		return KSFT_SKIP;

	}

	struct timeval tv;

	long ret = gtod(&tv, 0);

	long ret = VDSO_CALL(gtod, 2, &tv, 0);

	if (ret == 0) {

		char buf[] = "The time is                     .000000\n";

		to_base10(buf + 31, tv.tv_sec);

		to_base10(buf + 38, tv.tv_usec);

		linux_write(1, buf, sizeof(buf) - 1);

		printf("The time is %lld.%06lld\n",

		       (long long)tv.tv_sec, (long long)tv.tv_usec);

	} else {

		linux_exit(ret);

		printf("%s failed\n", name[0]);

		return KSFT_FAIL;

	}

	linux_exit(0);

	return 0;

}

/*

 * This is the real entry point.  It passes the initial stack into

 * the C entry point.

 */

asm (

	".text\n"

	".global _start\n"

	".type _start,@function\n"

	"_start:\n\t"

#ifdef __x86_64__

	"mov %rsp,%rdi\n\t"

	"and $-16,%rsp\n\t"

	"sub $8,%rsp\n\t"

	"jmp c_main"

#else

	"push %esp\n\t"

	"call c_main\n\t"

	"int $3"

#endif

	);