/*

 * linux_vdso_myclockgettime1.c - use Linux VDSO

 * shortcut for |clock_gettime()|, even if userland (g)libc

 * does not have support for VDSO

 *

 * Compile with:

 * $ clang -std=c99 -g -m32 -Wall -Wextra linux_vdso_myclockgettime1.c \

 * 	-lpthread -o linux_vdso_myclockgettime1

 *

 * Written by Roland Mainz <roland.mainz@nrubsig.org>

 *

 */

#define _XOPEN_SOURCE 600

#include <stdio.h>

#include <stddef.h>

#include <stdlib.h>

#include <string.h>

#include <elf.h>

#include <time.h>

#include <pthread.h>

#include <sys/auxv.h>

#if (_XOPEN_SOURCE < 600)

#error _XOPEN_SOURCE wrong version

#endif

/* debug */

#if 0

#define D(x) x

#else

#define D(x)

#endif

	/*

	 */

		if (strcmp(name, ".dynstr") == 0) {

			dynstr = (const char *)(vdso_addr + s->sh_offset);

			break;

		}

	}

	for (i=0L; i < elf_header->e_shnum; i++) {

		/* Not .dynsym ? Then look at next section... */

		if (strcmp(name, ".dynsym"))

			continue;

		for (si=0L; si < (s->sh_size/s->sh_entsize); si++) {

			sym = &(((ElfXX_Sym*)(vdso_addr + s->sh_offset))[si]);

			name = dynstr + sym->st_name;

			D((void)fprintf(stderr, "get_linux_vdso_sym: symbol=|%s| vs. |%s|\n",

				funcname, name));

			if (!strcmp(name, funcname)) {

				ret = (void *)(vdso_addr + sym->st_value);

				break;

			}

		}

		if (ret)

			break;

	}

	return ret;

}

static pthread_once_t my_clock_gettime_func_is_initialized = PTHREAD_ONCE_INIT;

void my_clock_gettime_func_init(void)

{

	my_clock_gettime_func = (clock_gettime_func_t *)get_linux_vdso_sym("clock_gettime");

	if (!my_clock_gettime_func)

		my_clock_gettime_func = (clock_gettime_func_t *)get_linux_vdso_sym("__vdso_clock_gettime");

	D((void)fprintf(stderr, "my_clock_gettime_func_init: "

		"my_clock_gettime_func = 0x%lx (%s)\n",

		(long)my_clock_gettime_func,

		(my_clock_gettime_func?

			"Using fast codepath":

			"Using slow codepath")));

	if (!my_clock_gettime_func) {

		(void)fprintf(stderr, "my_clock_gettime_func_init: "

			"WARNING: aux symbol for clock_gettime not found"

			", using slow libc codepath.\n");

	}

}

/*

 *

 * Notes:

 * - The first call might be slower because the call to

 * |my_clock_gettime_func_init()|

 */

int my_clock_gettime(clockid_t clk_id, struct timespec *tp)

{

	(void)pthread_once(&my_clock_gettime_func_is_initialized,

		my_clock_gettime_func_init);

	if (my_clock_gettime_func) {

		return (*my_clock_gettime_func)(clk_id, tp);

	}

	else

	{

		/* libc codepath, whatever they use - might be VDSO, might be syscall */

		return clock_gettime(clk_id, tp);

	}

}

	/*

	 */

	struct timespec dummy;

	(void)my_clock_gettime(CLOCK_REALTIME, &dummy);

#define PRINT_CLOCK(clock) \

	{ \

		struct timespec tp1, tp2; \

		/* \

		 * first libc implementation, then our implementation, \

		 * so that the difference is the call time of our \

		 * codepath. Requires |my_clock_gettime_func_init()| \

		 * to run before this sequence!! \

		 */ \

		(void)clock_gettime((clock), &tp1); \

		(void)my_clock_gettime((clock), &tp2); \

		(void)printf( \

			"%-20s libc_impl = \t(%-10ld\t%-10ld), " \

			"our_impl = \t(%-10ld\t%-10ld)\n", \

			#clock ":", \

			(long)tp1.tv_sec, (long)tp1.tv_nsec, \

			(long)tp2.tv_sec, (long)tp2.tv_nsec); \

	}

	PRINT_CLOCK(CLOCK_REALTIME);

	PRINT_CLOCK(CLOCK_MONOTONIC);

}

int main(int ac, char *av[])

{

	(void)ac;

	(void)av;

	test_my_clock_gettime1();

	return EXIT_SUCCESS;

}