src/runtime/vdso_linux_amd64.c - go - Git at Google

 // Copyright 2012 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 #include "runtime.h"
 #include "textflag.h"

 // Look up symbols in the Linux vDSO.

 // This code was originally based on the sample Linux vDSO parser at
 // https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/tree/Documentation/vDSO/parse_vdso.c

 // This implements the ELF dynamic linking spec at
 // http://sco.com/developers/gabi/latest/ch5.dynamic.html

 // The version section is documented at
 // http://refspecs.linuxfoundation.org/LSB_3.2.0/LSB-Core-generic/LSB-Core-generic/symversion.html

 #define AT_RANDOM 25
 #define AT_SYSINFO_EHDR 33
 #define AT_NULL	0    /* End of vector */
 #define PT_LOAD	1    /* Loadable program segment */
 #define PT_DYNAMIC 2 /* Dynamic linking information */
 #define DT_NULL 0    /* Marks end of dynamic section */
 #define DT_HASH 4    /* Dynamic symbol hash table */
 #define DT_STRTAB 5  /* Address of string table */
 #define DT_SYMTAB 6  /* Address of symbol table */
 #define DT_VERSYM 0x6ffffff0
 #define	DT_VERDEF 0x6ffffffc

 #define VER_FLG_BASE 0x1 /* Version definition of file itself */
 #define SHN_UNDEF 0      /* Undefined section */
 #define SHT_DYNSYM 11    /* Dynamic linker symbol table */
 #define STT_FUNC 2       /* Symbol is a code object */
 #define STB_GLOBAL 1     /* Global symbol */
 #define STB_WEAK 2       /* Weak symbol */

 /* How to extract and insert information held in the st_info field.  */
 #define ELF64_ST_BIND(val) (((byte) (val)) >> 4)
 #define ELF64_ST_TYPE(val) ((val) & 0xf)

 #define EI_NIDENT (16)

 typedef uint16 Elf64_Half;
 typedef uint32 Elf64_Word;
 typedef	int32  Elf64_Sword;
 typedef uint64 Elf64_Xword;
 typedef	int64  Elf64_Sxword;
 typedef uint64 Elf64_Addr;
 typedef uint64 Elf64_Off;
 typedef uint16 Elf64_Section;
 typedef Elf64_Half Elf64_Versym;


 typedef struct Elf64_Sym
 {
 	Elf64_Word st_name;
 	byte st_info;
 	byte st_other;
 	Elf64_Section st_shndx;
 	Elf64_Addr st_value;
 	Elf64_Xword st_size;
 } Elf64_Sym;

 typedef struct Elf64_Verdef
 {
 	Elf64_Half vd_version; /* Version revision */
 	Elf64_Half vd_flags;   /* Version information */
 	Elf64_Half vd_ndx;     /* Version Index */
 	Elf64_Half vd_cnt;     /* Number of associated aux entries */
 	Elf64_Word vd_hash;    /* Version name hash value */
 	Elf64_Word vd_aux;     /* Offset in bytes to verdaux array */
 	Elf64_Word vd_next;    /* Offset in bytes to next verdef entry */
 } Elf64_Verdef;

 typedef struct Elf64_Ehdr
 {
 	byte e_ident[EI_NIDENT]; /* Magic number and other info */
 	Elf64_Half e_type;       /* Object file type */
 	Elf64_Half e_machine;    /* Architecture */
 	Elf64_Word e_version;    /* Object file version */
 	Elf64_Addr e_entry;      /* Entry point virtual address */
 	Elf64_Off e_phoff;       /* Program header table file offset */
 	Elf64_Off e_shoff;       /* Section header table file offset */
 	Elf64_Word e_flags;      /* Processor-specific flags */
 	Elf64_Half e_ehsize;     /* ELF header size in bytes */
 	Elf64_Half e_phentsize;  /* Program header table entry size */
 	Elf64_Half e_phnum;      /* Program header table entry count */
 	Elf64_Half e_shentsize;  /* Section header table entry size */
 	Elf64_Half e_shnum;      /* Section header table entry count */
 	Elf64_Half e_shstrndx;   /* Section header string table index */
 } Elf64_Ehdr;

 typedef struct Elf64_Phdr
 {
 	Elf64_Word p_type;    /* Segment type */
 	Elf64_Word p_flags;   /* Segment flags */
 	Elf64_Off p_offset;   /* Segment file offset */
 	Elf64_Addr p_vaddr;   /* Segment virtual address */
 	Elf64_Addr p_paddr;   /* Segment physical address */
 	Elf64_Xword p_filesz; /* Segment size in file */
 	Elf64_Xword p_memsz;  /* Segment size in memory */
 	Elf64_Xword p_align;  /* Segment alignment */
 } Elf64_Phdr;

 typedef struct Elf64_Shdr
 {
 	Elf64_Word sh_name;       /* Section name (string tbl index) */
 	Elf64_Word sh_type;       /* Section type */
 	Elf64_Xword sh_flags;     /* Section flags */
 	Elf64_Addr sh_addr;       /* Section virtual addr at execution */
 	Elf64_Off sh_offset;      /* Section file offset */
 	Elf64_Xword sh_size;      /* Section size in bytes */
 	Elf64_Word sh_link;       /* Link to another section */
 	Elf64_Word sh_info;       /* Additional section information */
 	Elf64_Xword sh_addralign; /* Section alignment */
 	Elf64_Xword sh_entsize;   /* Entry size if section holds table */
 } Elf64_Shdr;

 typedef struct Elf64_Dyn
 {
 	Elf64_Sxword d_tag; /* Dynamic entry type */
 	union
 	{
 		Elf64_Xword d_val;  /* Integer value */
 		Elf64_Addr d_ptr;   /* Address value */
 	} d_un;
 } Elf64_Dyn;

 typedef struct Elf64_Verdaux
 {
 	Elf64_Word vda_name; /* Version or dependency names */
 	Elf64_Word vda_next; /* Offset in bytes to next verdaux entry */
 } Elf64_Verdaux;

 typedef struct Elf64_auxv_t
 {
 	uint64 a_type;        /* Entry type */
 	union
 	{
 		uint64 a_val; /* Integer value */
 	} a_un;
 } Elf64_auxv_t;


 typedef struct symbol_key {
 	byte* name;
 	int32 sym_hash;
 	void** var_ptr;
 } symbol_key;

 typedef struct version_key {
 	byte* version;
 	int32 ver_hash;
 } version_key;

 struct vdso_info {
 	bool valid;

 	/* Load information */
 	uintptr load_addr;
 	uintptr load_offset;  /* load_addr - recorded vaddr */

 	/* Symbol table */
 	Elf64_Sym *symtab;
 	const byte *symstrings;
 	Elf64_Word *bucket, *chain;
 	Elf64_Word nbucket, nchain;

 	/* Version table */
 	Elf64_Versym *versym;
 	Elf64_Verdef *verdef;
 };

 #pragma dataflag NOPTR
 static version_key linux26 = { (byte*)"LINUX_2.6", 0x3ae75f6 };

 // initialize with vsyscall fallbacks
 #pragma dataflag NOPTR
 void* runtime·__vdso_time_sym = (void*)0xffffffffff600400ULL;
 #pragma dataflag NOPTR
 void* runtime·__vdso_gettimeofday_sym = (void*)0xffffffffff600000ULL;
 #pragma dataflag NOPTR
 void* runtime·__vdso_clock_gettime_sym = (void*)0;

 #pragma dataflag NOPTR
 static symbol_key sym_keys[] = {
 	{ (byte*)"__vdso_time", 0xa33c485, &runtime·__vdso_time_sym },
 	{ (byte*)"__vdso_gettimeofday", 0x315ca59, &runtime·__vdso_gettimeofday_sym },
 	{ (byte*)"__vdso_clock_gettime", 0xd35ec75, &runtime·__vdso_clock_gettime_sym },
 };

 static void
 vdso_init_from_sysinfo_ehdr(struct vdso_info *vdso_info, Elf64_Ehdr* hdr)
 {
 	uint64 i;
 	bool found_vaddr = false;
 	Elf64_Phdr *pt;
 	Elf64_Dyn *dyn;
 	Elf64_Word *hash;

 	vdso_info->valid = false;
 	vdso_info->load_addr = (uintptr) hdr;

 	pt = (Elf64_Phdr*)(vdso_info->load_addr + hdr->e_phoff);
 	dyn = nil;

 	// We need two things from the segment table: the load offset
 	// and the dynamic table.
 	for(i=0; i<hdr->e_phnum; i++) {
 		if(pt[i].p_type == PT_LOAD && found_vaddr == false) {
 			found_vaddr = true;
 			vdso_info->load_offset =	(uintptr)hdr
 				+ (uintptr)pt[i].p_offset
 				- (uintptr)pt[i].p_vaddr;
 		} else if(pt[i].p_type == PT_DYNAMIC) {
 			dyn = (Elf64_Dyn*)((uintptr)hdr + pt[i].p_offset);
 		}
 	}

 	if(found_vaddr == false || dyn == nil)
 		return;  // Failed

 	// Fish out the useful bits of the dynamic table.
 	hash = nil;
 	vdso_info->symstrings = nil;
 	vdso_info->symtab = nil;
 	vdso_info->versym = nil;
 	vdso_info->verdef = nil;
 	for(i=0; dyn[i].d_tag!=DT_NULL; i++) {
 		switch(dyn[i].d_tag) {
 		case DT_STRTAB:
 			vdso_info->symstrings = (const byte *)
 				((uintptr)dyn[i].d_un.d_ptr
 				 + vdso_info->load_offset);
 			break;
 		case DT_SYMTAB:
 			vdso_info->symtab = (Elf64_Sym *)
 				((uintptr)dyn[i].d_un.d_ptr
 				 + vdso_info->load_offset);
 			break;
 		case DT_HASH:
 			hash = (Elf64_Word *)
 			  ((uintptr)dyn[i].d_un.d_ptr
 			   + vdso_info->load_offset);
 			break;
 		case DT_VERSYM:
 			vdso_info->versym = (Elf64_Versym *)
 				((uintptr)dyn[i].d_un.d_ptr
 				 + vdso_info->load_offset);
 			break;
 		case DT_VERDEF:
 			vdso_info->verdef = (Elf64_Verdef *)
 				((uintptr)dyn[i].d_un.d_ptr
 				 + vdso_info->load_offset);
 			break;
 		}
 	}
 	if(vdso_info->symstrings == nil || vdso_info->symtab == nil || hash == nil)
 		return;  // Failed

 	if(vdso_info->verdef == nil)
 		vdso_info->versym = 0;

 	// Parse the hash table header.
 	vdso_info->nbucket = hash[0];
 	vdso_info->nchain = hash[1];
 	vdso_info->bucket = &hash[2];
 	vdso_info->chain = &hash[vdso_info->nbucket + 2];

 	// That's all we need.
 	vdso_info->valid = true;
 }

 static int32
 vdso_find_version(struct vdso_info *vdso_info, version_key* ver)
 {
 	if(vdso_info->valid == false) {
 		return 0;
 	}
 	Elf64_Verdef *def = vdso_info->verdef;
 	while(true) {
 		if((def->vd_flags & VER_FLG_BASE) == 0) {
 			Elf64_Verdaux *aux = (Elf64_Verdaux*)((byte *)def + def->vd_aux);
 			if(def->vd_hash == ver->ver_hash &&
 				runtime·strcmp(ver->version, vdso_info->symstrings + aux->vda_name) == 0) {
 				return def->vd_ndx & 0x7fff;
 			}
 		}

 		if(def->vd_next == 0) {
 			break;
 		}
 		def = (Elf64_Verdef *)((byte *)def + def->vd_next);
 	}
 	return -1; // can not match any version
 }

 static void
 vdso_parse_symbols(struct vdso_info *vdso_info, int32 version)
 {
 	int32 i;
 	Elf64_Word chain;
 	Elf64_Sym *sym;

 	if(vdso_info->valid == false)
 		return;

 	for(i=0; i<nelem(sym_keys); i++) {
 		for(chain = vdso_info->bucket[sym_keys[i].sym_hash % vdso_info->nbucket];
 			chain != 0; chain = vdso_info->chain[chain]) {

 			sym = &vdso_info->symtab[chain];
 			if(ELF64_ST_TYPE(sym->st_info) != STT_FUNC)
 				continue;
 			if(ELF64_ST_BIND(sym->st_info) != STB_GLOBAL &&
 				 ELF64_ST_BIND(sym->st_info) != STB_WEAK)
 				continue;
 			if(sym->st_shndx == SHN_UNDEF)
 				continue;
 			if(runtime·strcmp(sym_keys[i].name, vdso_info->symstrings + sym->st_name) != 0)
 				continue;

 			// Check symbol version.
 			if(vdso_info->versym != nil && version != 0
 				&& vdso_info->versym[chain] & 0x7fff != version)
 				continue;

 			*sym_keys[i].var_ptr = (void *)(vdso_info->load_offset + sym->st_value);
 			break;
 		}
 	}
 }

 static void
 runtime·linux_setup_vdso(int32 argc, uint8** argv)
 {
 	struct vdso_info vdso_info;

 	// skip argvc
 	byte **p = argv;
 	p = &p[argc+1];

 	// skip envp to get to ELF auxiliary vector.
 	for(; *p!=0; p++) {}

 	// skip NULL separator
 	p++;

 	// now, p points to auxv
 	Elf64_auxv_t *elf_auxv = (Elf64_auxv_t*) p;

 	for(int32 i=0; elf_auxv[i].a_type!=AT_NULL; i++) {
 		if(elf_auxv[i].a_type == AT_SYSINFO_EHDR) {
 			if(elf_auxv[i].a_un.a_val == 0) {
 				// Something went wrong
 				continue;
 			}
 			vdso_init_from_sysinfo_ehdr(&vdso_info, (Elf64_Ehdr*)elf_auxv[i].a_un.a_val);
 			vdso_parse_symbols(&vdso_info, vdso_find_version(&vdso_info, &linux26));
 			continue;
 		}
 		if(elf_auxv[i].a_type == AT_RANDOM) {
 		        runtime·startup_random_data = (byte*)elf_auxv[i].a_un.a_val;
 		        runtime·startup_random_data_len = 16;
 			continue;
 		}
 	}
 }

 void (*runtime·sysargs)(int32, uint8**) = runtime·linux_setup_vdso;
	// Copyright 2012 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	#include "runtime.h"
	#include "textflag.h"

	// Look up symbols in the Linux vDSO.

	// This code was originally based on the sample Linux vDSO parser at
	// https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/tree/Documentation/vDSO/parse_vdso.c

	// This implements the ELF dynamic linking spec at
	// http://sco.com/developers/gabi/latest/ch5.dynamic.html

	// The version section is documented at
	// http://refspecs.linuxfoundation.org/LSB_3.2.0/LSB-Core-generic/LSB-Core-generic/symversion.html

	#define AT_RANDOM 25
	#define AT_SYSINFO_EHDR 33
	#define AT_NULL 0 /* End of vector */
	#define PT_LOAD 1 /* Loadable program segment */
	#define PT_DYNAMIC 2 /* Dynamic linking information */
	#define DT_NULL 0 /* Marks end of dynamic section */
	#define DT_HASH 4 /* Dynamic symbol hash table */
	#define DT_STRTAB 5 /* Address of string table */
	#define DT_SYMTAB 6 /* Address of symbol table */
	#define DT_VERSYM 0x6ffffff0
	#define DT_VERDEF 0x6ffffffc

	#define VER_FLG_BASE 0x1 /* Version definition of file itself */
	#define SHN_UNDEF 0 /* Undefined section */
	#define SHT_DYNSYM 11 /* Dynamic linker symbol table */
	#define STT_FUNC 2 /* Symbol is a code object */
	#define STB_GLOBAL 1 /* Global symbol */
	#define STB_WEAK 2 /* Weak symbol */

	/* How to extract and insert information held in the st_info field. */
	#define ELF64_ST_BIND(val) (((byte) (val)) >> 4)
	#define ELF64_ST_TYPE(val) ((val) & 0xf)

	#define EI_NIDENT (16)

	typedef uint16 Elf64_Half;
	typedef uint32 Elf64_Word;
	typedef int32 Elf64_Sword;
	typedef uint64 Elf64_Xword;
	typedef int64 Elf64_Sxword;
	typedef uint64 Elf64_Addr;
	typedef uint64 Elf64_Off;
	typedef uint16 Elf64_Section;
	typedef Elf64_Half Elf64_Versym;


	typedef struct Elf64_Sym
	{
	Elf64_Word st_name;
	byte st_info;
	byte st_other;
	Elf64_Section st_shndx;
	Elf64_Addr st_value;
	Elf64_Xword st_size;
	} Elf64_Sym;

	typedef struct Elf64_Verdef
	{
	Elf64_Half vd_version; /* Version revision */
	Elf64_Half vd_flags; /* Version information */
	Elf64_Half vd_ndx; /* Version Index */
	Elf64_Half vd_cnt; /* Number of associated aux entries */
	Elf64_Word vd_hash; /* Version name hash value */
	Elf64_Word vd_aux; /* Offset in bytes to verdaux array */
	Elf64_Word vd_next; /* Offset in bytes to next verdef entry */
	} Elf64_Verdef;

	typedef struct Elf64_Ehdr
	{
	byte e_ident[EI_NIDENT]; /* Magic number and other info */
	Elf64_Half e_type; /* Object file type */
	Elf64_Half e_machine; /* Architecture */
	Elf64_Word e_version; /* Object file version */
	Elf64_Addr e_entry; /* Entry point virtual address */
	Elf64_Off e_phoff; /* Program header table file offset */
	Elf64_Off e_shoff; /* Section header table file offset */
	Elf64_Word e_flags; /* Processor-specific flags */
	Elf64_Half e_ehsize; /* ELF header size in bytes */
	Elf64_Half e_phentsize; /* Program header table entry size */
	Elf64_Half e_phnum; /* Program header table entry count */
	Elf64_Half e_shentsize; /* Section header table entry size */
	Elf64_Half e_shnum; /* Section header table entry count */
	Elf64_Half e_shstrndx; /* Section header string table index */
	} Elf64_Ehdr;

	typedef struct Elf64_Phdr
	{
	Elf64_Word p_type; /* Segment type */
	Elf64_Word p_flags; /* Segment flags */
	Elf64_Off p_offset; /* Segment file offset */
	Elf64_Addr p_vaddr; /* Segment virtual address */
	Elf64_Addr p_paddr; /* Segment physical address */
	Elf64_Xword p_filesz; /* Segment size in file */
	Elf64_Xword p_memsz; /* Segment size in memory */
	Elf64_Xword p_align; /* Segment alignment */
	} Elf64_Phdr;

	typedef struct Elf64_Shdr
	{
	Elf64_Word sh_name; /* Section name (string tbl index) */
	Elf64_Word sh_type; /* Section type */
	Elf64_Xword sh_flags; /* Section flags */
	Elf64_Addr sh_addr; /* Section virtual addr at execution */
	Elf64_Off sh_offset; /* Section file offset */
	Elf64_Xword sh_size; /* Section size in bytes */
	Elf64_Word sh_link; /* Link to another section */
	Elf64_Word sh_info; /* Additional section information */
	Elf64_Xword sh_addralign; /* Section alignment */
	Elf64_Xword sh_entsize; /* Entry size if section holds table */
	} Elf64_Shdr;

	typedef struct Elf64_Dyn
	{
	Elf64_Sxword d_tag; /* Dynamic entry type */
	union
	{
	Elf64_Xword d_val; /* Integer value */
	Elf64_Addr d_ptr; /* Address value */
	} d_un;
	} Elf64_Dyn;

	typedef struct Elf64_Verdaux
	{
	Elf64_Word vda_name; /* Version or dependency names */
	Elf64_Word vda_next; /* Offset in bytes to next verdaux entry */
	} Elf64_Verdaux;

	typedef struct Elf64_auxv_t
	{
	uint64 a_type; /* Entry type */
	union
	{
	uint64 a_val; /* Integer value */
	} a_un;
	} Elf64_auxv_t;


	typedef struct symbol_key {
	byte* name;
	int32 sym_hash;
	void** var_ptr;
	} symbol_key;

	typedef struct version_key {
	byte* version;
	int32 ver_hash;
	} version_key;

	struct vdso_info {
	bool valid;

	/* Load information */
	uintptr load_addr;
	uintptr load_offset; /* load_addr - recorded vaddr */

	/* Symbol table */
	Elf64_Sym *symtab;
	const byte *symstrings;
	Elf64_Word bucket, chain;
	Elf64_Word nbucket, nchain;

	/* Version table */
	Elf64_Versym *versym;
	Elf64_Verdef *verdef;
	};

	#pragma dataflag NOPTR
	static version_key linux26 = { (byte*)"LINUX_2.6", 0x3ae75f6 };

	// initialize with vsyscall fallbacks
	#pragma dataflag NOPTR
	void* runtime·__vdso_time_sym = (void*)0xffffffffff600400ULL;
	#pragma dataflag NOPTR
	void* runtime·__vdso_gettimeofday_sym = (void*)0xffffffffff600000ULL;
	#pragma dataflag NOPTR
	void* runtime·__vdso_clock_gettime_sym = (void*)0;

	#pragma dataflag NOPTR
	static symbol_key sym_keys[] = {
	{ (byte*)"__vdso_time", 0xa33c485, &runtime·__vdso_time_sym },
	{ (byte*)"__vdso_gettimeofday", 0x315ca59, &runtime·__vdso_gettimeofday_sym },
	{ (byte*)"__vdso_clock_gettime", 0xd35ec75, &runtime·__vdso_clock_gettime_sym },
	};

	static void
	vdso_init_from_sysinfo_ehdr(struct vdso_info vdso_info, Elf64_Ehdr hdr)
	{
	uint64 i;
	bool found_vaddr = false;
	Elf64_Phdr *pt;
	Elf64_Dyn *dyn;
	Elf64_Word *hash;

	vdso_info->valid = false;
	vdso_info->load_addr = (uintptr) hdr;

	pt = (Elf64_Phdr*)(vdso_info->load_addr + hdr->e_phoff);
	dyn = nil;

	// We need two things from the segment table: the load offset
	// and the dynamic table.
	for(i=0; i<hdr->e_phnum; i++) {
	if(pt[i].p_type == PT_LOAD && found_vaddr == false) {
	found_vaddr = true;
	vdso_info->load_offset = (uintptr)hdr
	+ (uintptr)pt[i].p_offset
	- (uintptr)pt[i].p_vaddr;
	} else if(pt[i].p_type == PT_DYNAMIC) {
	dyn = (Elf64_Dyn*)((uintptr)hdr + pt[i].p_offset);
	}
	}

	if(found_vaddr == false \|\| dyn == nil)
	return; // Failed

	// Fish out the useful bits of the dynamic table.
	hash = nil;
	vdso_info->symstrings = nil;
	vdso_info->symtab = nil;
	vdso_info->versym = nil;
	vdso_info->verdef = nil;
	for(i=0; dyn[i].d_tag!=DT_NULL; i++) {
	switch(dyn[i].d_tag) {
	case DT_STRTAB:
	vdso_info->symstrings = (const byte *)
	((uintptr)dyn[i].d_un.d_ptr
	+ vdso_info->load_offset);
	break;
	case DT_SYMTAB:
	vdso_info->symtab = (Elf64_Sym *)
	((uintptr)dyn[i].d_un.d_ptr
	+ vdso_info->load_offset);
	break;
	case DT_HASH:
	hash = (Elf64_Word *)
	((uintptr)dyn[i].d_un.d_ptr
	+ vdso_info->load_offset);
	break;
	case DT_VERSYM:
	vdso_info->versym = (Elf64_Versym *)
	((uintptr)dyn[i].d_un.d_ptr
	+ vdso_info->load_offset);
	break;
	case DT_VERDEF:
	vdso_info->verdef = (Elf64_Verdef *)
	((uintptr)dyn[i].d_un.d_ptr
	+ vdso_info->load_offset);
	break;
	}
	}
	if(vdso_info->symstrings == nil \|\| vdso_info->symtab == nil \|\| hash == nil)
	return; // Failed

	if(vdso_info->verdef == nil)
	vdso_info->versym = 0;

	// Parse the hash table header.
	vdso_info->nbucket = hash[0];
	vdso_info->nchain = hash[1];
	vdso_info->bucket = &hash[2];
	vdso_info->chain = &hash[vdso_info->nbucket + 2];

	// That's all we need.
	vdso_info->valid = true;
	}

	static int32
	vdso_find_version(struct vdso_info vdso_info, version_key ver)
	{
	if(vdso_info->valid == false) {
	return 0;
	}
	Elf64_Verdef *def = vdso_info->verdef;
	while(true) {
	if((def->vd_flags & VER_FLG_BASE) == 0) {
	Elf64_Verdaux aux = (Elf64_Verdaux)((byte *)def + def->vd_aux);
	if(def->vd_hash == ver->ver_hash &&
	runtime·strcmp(ver->version, vdso_info->symstrings + aux->vda_name) == 0) {
	return def->vd_ndx & 0x7fff;
	}
	}

	if(def->vd_next == 0) {
	break;
	}
	def = (Elf64_Verdef )((byte )def + def->vd_next);
	}
	return -1; // can not match any version
	}

	static void
	vdso_parse_symbols(struct vdso_info *vdso_info, int32 version)
	{
	int32 i;
	Elf64_Word chain;
	Elf64_Sym *sym;

	if(vdso_info->valid == false)
	return;

	for(i=0; i<nelem(sym_keys); i++) {
	for(chain = vdso_info->bucket[sym_keys[i].sym_hash % vdso_info->nbucket];
	chain != 0; chain = vdso_info->chain[chain]) {

	sym = &vdso_info->symtab[chain];
	if(ELF64_ST_TYPE(sym->st_info) != STT_FUNC)
	continue;
	if(ELF64_ST_BIND(sym->st_info) != STB_GLOBAL &&
	ELF64_ST_BIND(sym->st_info) != STB_WEAK)
	continue;
	if(sym->st_shndx == SHN_UNDEF)
	continue;
	if(runtime·strcmp(sym_keys[i].name, vdso_info->symstrings + sym->st_name) != 0)
	continue;

	// Check symbol version.
	if(vdso_info->versym != nil && version != 0
	&& vdso_info->versym[chain] & 0x7fff != version)
	continue;

	sym_keys[i].var_ptr = (void )(vdso_info->load_offset + sym->st_value);
	break;
	}
	}
	}

	static void
	runtime·linux_setup_vdso(int32 argc, uint8** argv)
	{
	struct vdso_info vdso_info;

	// skip argvc
	byte **p = argv;
	p = &p[argc+1];

	// skip envp to get to ELF auxiliary vector.
	for(; *p!=0; p++) {}

	// skip NULL separator
	p++;

	// now, p points to auxv
	Elf64_auxv_t elf_auxv = (Elf64_auxv_t) p;

	for(int32 i=0; elf_auxv[i].a_type!=AT_NULL; i++) {
	if(elf_auxv[i].a_type == AT_SYSINFO_EHDR) {
	if(elf_auxv[i].a_un.a_val == 0) {
	// Something went wrong
	continue;
	}
	vdso_init_from_sysinfo_ehdr(&vdso_info, (Elf64_Ehdr*)elf_auxv[i].a_un.a_val);
	vdso_parse_symbols(&vdso_info, vdso_find_version(&vdso_info, &linux26));
	continue;
	}
	if(elf_auxv[i].a_type == AT_RANDOM) {
	runtime·startup_random_data = (byte*)elf_auxv[i].a_un.a_val;
	runtime·startup_random_data_len = 16;
	continue;
	}
	}
	}

	void (runtime·sysargs)(int32, uint8*) = runtime·linux_setup_vdso;