Commit 4ebbefd6 authored by Andy Lutomirski's avatar Andy Lutomirski Committed by H. Peter Anvin

x86/vdso/doc: Make vDSO examples more portable

This adds a new vdso_test.c that's written entirely in C.  It also
makes all of the vDSO examples work on 32-bit x86.

Cc: Stefani Seibold <stefani@seibold.net>
Signed-off-by: default avatarAndy Lutomirski <luto@amacapital.net>
Link: http://lkml.kernel.org/r/62b701fc44b79f118ac2b2d64d19965fc5c291fb.1402620737.git.luto@amacapital.netSigned-off-by: default avatarH. Peter Anvin <hpa@zytor.com>
parent 6e8f2158
/* /*
* parse_vdso.c: Linux reference vDSO parser * parse_vdso.c: Linux reference vDSO parser
* Written by Andrew Lutomirski, 2011. * Written by Andrew Lutomirski, 2011-2014.
* *
* This code is meant to be linked in to various programs that run on Linux. * This code is meant to be linked in to various programs that run on Linux.
* As such, it is available with as few restrictions as possible. This file * As such, it is available with as few restrictions as possible. This file
...@@ -11,13 +11,14 @@ ...@@ -11,13 +11,14 @@
* it starts a program. It works equally well in statically and dynamically * it starts a program. It works equally well in statically and dynamically
* linked binaries. * linked binaries.
* *
* This code is tested on x86_64. In principle it should work on any 64-bit * This code is tested on x86. In principle it should work on any
* architecture that has a vDSO. * architecture that has a vDSO.
*/ */
#include <stdbool.h> #include <stdbool.h>
#include <stdint.h> #include <stdint.h>
#include <string.h> #include <string.h>
#include <limits.h>
#include <elf.h> #include <elf.h>
/* /*
...@@ -45,11 +46,18 @@ extern void *vdso_sym(const char *version, const char *name); ...@@ -45,11 +46,18 @@ extern void *vdso_sym(const char *version, const char *name);
/* And here's the code. */ /* And here's the code. */
#ifndef ELF_BITS
#ifndef __x86_64__ # if ULONG_MAX > 0xffffffffUL
# error Not yet ported to non-x86_64 architectures # define ELF_BITS 64
# else
# define ELF_BITS 32
# endif
#endif #endif
#define ELF_BITS_XFORM2(bits, x) Elf##bits##_##x
#define ELF_BITS_XFORM(bits, x) ELF_BITS_XFORM2(bits, x)
#define ELF(x) ELF_BITS_XFORM(ELF_BITS, x)
static struct vdso_info static struct vdso_info
{ {
bool valid; bool valid;
...@@ -59,14 +67,14 @@ static struct vdso_info ...@@ -59,14 +67,14 @@ static struct vdso_info
uintptr_t load_offset; /* load_addr - recorded vaddr */ uintptr_t load_offset; /* load_addr - recorded vaddr */
/* Symbol table */ /* Symbol table */
Elf64_Sym *symtab; ELF(Sym) *symtab;
const char *symstrings; const char *symstrings;
Elf64_Word *bucket, *chain; ELF(Word) *bucket, *chain;
Elf64_Word nbucket, nchain; ELF(Word) nbucket, nchain;
/* Version table */ /* Version table */
Elf64_Versym *versym; ELF(Versym) *versym;
Elf64_Verdef *verdef; ELF(Verdef) *verdef;
} vdso_info; } vdso_info;
/* Straight from the ELF specification. */ /* Straight from the ELF specification. */
...@@ -92,9 +100,14 @@ void vdso_init_from_sysinfo_ehdr(uintptr_t base) ...@@ -92,9 +100,14 @@ void vdso_init_from_sysinfo_ehdr(uintptr_t base)
vdso_info.load_addr = base; vdso_info.load_addr = base;
Elf64_Ehdr *hdr = (Elf64_Ehdr*)base; ELF(Ehdr) *hdr = (ELF(Ehdr)*)base;
Elf64_Phdr *pt = (Elf64_Phdr*)(vdso_info.load_addr + hdr->e_phoff); if (hdr->e_ident[EI_CLASS] !=
Elf64_Dyn *dyn = 0; (ELF_BITS == 32 ? ELFCLASS32 : ELFCLASS64)) {
return; /* Wrong ELF class -- check ELF_BITS */
}
ELF(Phdr) *pt = (ELF(Phdr)*)(vdso_info.load_addr + hdr->e_phoff);
ELF(Dyn) *dyn = 0;
/* /*
* We need two things from the segment table: the load offset * We need two things from the segment table: the load offset
...@@ -108,7 +121,7 @@ void vdso_init_from_sysinfo_ehdr(uintptr_t base) ...@@ -108,7 +121,7 @@ void vdso_init_from_sysinfo_ehdr(uintptr_t base)
+ (uintptr_t)pt[i].p_offset + (uintptr_t)pt[i].p_offset
- (uintptr_t)pt[i].p_vaddr; - (uintptr_t)pt[i].p_vaddr;
} else if (pt[i].p_type == PT_DYNAMIC) { } else if (pt[i].p_type == PT_DYNAMIC) {
dyn = (Elf64_Dyn*)(base + pt[i].p_offset); dyn = (ELF(Dyn)*)(base + pt[i].p_offset);
} }
} }
...@@ -118,7 +131,7 @@ void vdso_init_from_sysinfo_ehdr(uintptr_t base) ...@@ -118,7 +131,7 @@ void vdso_init_from_sysinfo_ehdr(uintptr_t base)
/* /*
* Fish out the useful bits of the dynamic table. * Fish out the useful bits of the dynamic table.
*/ */
Elf64_Word *hash = 0; ELF(Word) *hash = 0;
vdso_info.symstrings = 0; vdso_info.symstrings = 0;
vdso_info.symtab = 0; vdso_info.symtab = 0;
vdso_info.versym = 0; vdso_info.versym = 0;
...@@ -131,22 +144,22 @@ void vdso_init_from_sysinfo_ehdr(uintptr_t base) ...@@ -131,22 +144,22 @@ void vdso_init_from_sysinfo_ehdr(uintptr_t base)
+ vdso_info.load_offset); + vdso_info.load_offset);
break; break;
case DT_SYMTAB: case DT_SYMTAB:
vdso_info.symtab = (Elf64_Sym *) vdso_info.symtab = (ELF(Sym) *)
((uintptr_t)dyn[i].d_un.d_ptr ((uintptr_t)dyn[i].d_un.d_ptr
+ vdso_info.load_offset); + vdso_info.load_offset);
break; break;
case DT_HASH: case DT_HASH:
hash = (Elf64_Word *) hash = (ELF(Word) *)
((uintptr_t)dyn[i].d_un.d_ptr ((uintptr_t)dyn[i].d_un.d_ptr
+ vdso_info.load_offset); + vdso_info.load_offset);
break; break;
case DT_VERSYM: case DT_VERSYM:
vdso_info.versym = (Elf64_Versym *) vdso_info.versym = (ELF(Versym) *)
((uintptr_t)dyn[i].d_un.d_ptr ((uintptr_t)dyn[i].d_un.d_ptr
+ vdso_info.load_offset); + vdso_info.load_offset);
break; break;
case DT_VERDEF: case DT_VERDEF:
vdso_info.verdef = (Elf64_Verdef *) vdso_info.verdef = (ELF(Verdef) *)
((uintptr_t)dyn[i].d_un.d_ptr ((uintptr_t)dyn[i].d_un.d_ptr
+ vdso_info.load_offset); + vdso_info.load_offset);
break; break;
...@@ -168,8 +181,8 @@ void vdso_init_from_sysinfo_ehdr(uintptr_t base) ...@@ -168,8 +181,8 @@ void vdso_init_from_sysinfo_ehdr(uintptr_t base)
vdso_info.valid = true; vdso_info.valid = true;
} }
static bool vdso_match_version(Elf64_Versym ver, static bool vdso_match_version(ELF(Versym) ver,
const char *name, Elf64_Word hash) const char *name, ELF(Word) hash)
{ {
/* /*
* This is a helper function to check if the version indexed by * This is a helper function to check if the version indexed by
...@@ -188,7 +201,7 @@ static bool vdso_match_version(Elf64_Versym ver, ...@@ -188,7 +201,7 @@ static bool vdso_match_version(Elf64_Versym ver,
/* First step: find the version definition */ /* First step: find the version definition */
ver &= 0x7fff; /* Apparently bit 15 means "hidden" */ ver &= 0x7fff; /* Apparently bit 15 means "hidden" */
Elf64_Verdef *def = vdso_info.verdef; ELF(Verdef) *def = vdso_info.verdef;
while(true) { while(true) {
if ((def->vd_flags & VER_FLG_BASE) == 0 if ((def->vd_flags & VER_FLG_BASE) == 0
&& (def->vd_ndx & 0x7fff) == ver) && (def->vd_ndx & 0x7fff) == ver)
...@@ -197,11 +210,11 @@ static bool vdso_match_version(Elf64_Versym ver, ...@@ -197,11 +210,11 @@ static bool vdso_match_version(Elf64_Versym ver,
if (def->vd_next == 0) if (def->vd_next == 0)
return false; /* No definition. */ return false; /* No definition. */
def = (Elf64_Verdef *)((char *)def + def->vd_next); def = (ELF(Verdef) *)((char *)def + def->vd_next);
} }
/* Now figure out whether it matches. */ /* Now figure out whether it matches. */
Elf64_Verdaux *aux = (Elf64_Verdaux*)((char *)def + def->vd_aux); ELF(Verdaux) *aux = (ELF(Verdaux)*)((char *)def + def->vd_aux);
return def->vd_hash == hash return def->vd_hash == hash
&& !strcmp(name, vdso_info.symstrings + aux->vda_name); && !strcmp(name, vdso_info.symstrings + aux->vda_name);
} }
...@@ -213,10 +226,10 @@ void *vdso_sym(const char *version, const char *name) ...@@ -213,10 +226,10 @@ void *vdso_sym(const char *version, const char *name)
return 0; return 0;
ver_hash = elf_hash(version); ver_hash = elf_hash(version);
Elf64_Word chain = vdso_info.bucket[elf_hash(name) % vdso_info.nbucket]; ELF(Word) chain = vdso_info.bucket[elf_hash(name) % vdso_info.nbucket];
for (; chain != STN_UNDEF; chain = vdso_info.chain[chain]) { for (; chain != STN_UNDEF; chain = vdso_info.chain[chain]) {
Elf64_Sym *sym = &vdso_info.symtab[chain]; ELF(Sym) *sym = &vdso_info.symtab[chain];
/* Check for a defined global or weak function w/ right name. */ /* Check for a defined global or weak function w/ right name. */
if (ELF64_ST_TYPE(sym->st_info) != STT_FUNC) if (ELF64_ST_TYPE(sym->st_info) != STT_FUNC)
...@@ -243,7 +256,7 @@ void *vdso_sym(const char *version, const char *name) ...@@ -243,7 +256,7 @@ void *vdso_sym(const char *version, const char *name)
void vdso_init_from_auxv(void *auxv) void vdso_init_from_auxv(void *auxv)
{ {
Elf64_auxv_t *elf_auxv = auxv; ELF(auxv_t) *elf_auxv = auxv;
for (int i = 0; elf_auxv[i].a_type != AT_NULL; i++) for (int i = 0; elf_auxv[i].a_type != AT_NULL; i++)
{ {
if (elf_auxv[i].a_type == AT_SYSINFO_EHDR) { if (elf_auxv[i].a_type == AT_SYSINFO_EHDR) {
......
/* /*
* vdso_test.c: Sample code to test parse_vdso.c on x86_64 * vdso_test.c: Sample code to test parse_vdso.c on x86
* Copyright (c) 2011 Andy Lutomirski * Copyright (c) 2011-2014 Andy Lutomirski
* Subject to the GNU General Public License, version 2 * Subject to the GNU General Public License, version 2
* *
* You can amuse yourself by compiling with: * You can amuse yourself by compiling with:
* gcc -std=gnu99 -nostdlib * gcc -std=gnu99 -nostdlib
* -Os -fno-asynchronous-unwind-tables -flto * -Os -fno-asynchronous-unwind-tables -flto -lgcc_s
* vdso_standalone_test_x86.c parse_vdso.c * vdso_standalone_test_x86.c parse_vdso.c
* to generate a small binary with no dependencies at all. * to generate a small binary. On x86_64, you can omit -lgcc_s
* if you want the binary to be completely standalone.
*/ */
#include <sys/syscall.h> #include <sys/syscall.h>
...@@ -35,21 +36,31 @@ int strcmp(const char *a, const char *b) ...@@ -35,21 +36,31 @@ int strcmp(const char *a, const char *b)
return 0; return 0;
} }
/* ...and two syscalls. This is x86_64-specific. */ /* ...and two syscalls. This is x86-specific. */
static inline long linux_write(int fd, const void *data, size_t len) static inline long x86_syscall3(long nr, long a0, long a1, long a2)
{ {
long ret; long ret;
asm volatile ("syscall" : "=a" (ret) : "a" (__NR_write), #ifdef __x86_64__
"D" (fd), "S" (data), "d" (len) : asm volatile ("syscall" : "=a" (ret) : "a" (nr),
"D" (a0), "S" (a1), "d" (a2) :
"cc", "memory", "rcx", "cc", "memory", "rcx",
"r8", "r9", "r10", "r11" ); "r8", "r9", "r10", "r11" );
#else
asm volatile ("int $0x80" : "=a" (ret) : "a" (nr),
"b" (a0), "c" (a1), "d" (a2) :
"cc", "memory" );
#endif
return ret; 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) static inline void linux_exit(int code)
{ {
asm volatile ("syscall" : : "a" (__NR_exit), "D" (code)); x86_syscall3(__NR_exit, code, 0, 0);
} }
void to_base10(char *lastdig, uint64_t n) void to_base10(char *lastdig, uint64_t n)
...@@ -106,6 +117,12 @@ asm ( ...@@ -106,6 +117,12 @@ asm (
".global _start\n" ".global _start\n"
".type _start,@function\n" ".type _start,@function\n"
"_start:\n\t" "_start:\n\t"
#ifdef __x86_64__
"mov %rsp,%rdi\n\t" "mov %rsp,%rdi\n\t"
"jmp c_main" "jmp c_main"
#else
"push %esp\n\t"
"call c_main\n\t"
"int $3"
#endif
); );
/*
* vdso_test.c: Sample code to test parse_vdso.c
* Copyright (c) 2014 Andy Lutomirski
* Subject to the GNU General Public License, version 2
*
* Compile with:
* gcc -std=gnu99 vdso_test.c parse_vdso.c
*
* Tested on x86, 32-bit and 64-bit. It may work on other architectures, too.
*/
#include <stdint.h>
#include <elf.h>
#include <stdio.h>
#include <sys/auxv.h>
#include <sys/time.h>
extern void *vdso_sym(const char *version, const char *name);
extern void vdso_init_from_sysinfo_ehdr(uintptr_t base);
extern void vdso_init_from_auxv(void *auxv);
int main(int argc, char **argv)
{
unsigned long sysinfo_ehdr = getauxval(AT_SYSINFO_EHDR);
if (!sysinfo_ehdr) {
printf("AT_SYSINFO_EHDR is not present!\n");
return 0;
}
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");
if (!gtod) {
printf("Could not find __vdso_gettimeofday\n");
return 1;
}
struct timeval tv;
long ret = gtod(&tv, 0);
if (ret == 0) {
printf("The time is %lld.%06lld\n",
(long long)tv.tv_sec, (long long)tv.tv_usec);
} else {
printf("__vdso_gettimeofday failed\n");
}
return 0;
}
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment