1 /* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include "private/bionic_globals.h" 18 #include "private/bionic_vdso.h" 19 20 #include <limits.h> 21 #include <link.h> 22 #include <string.h> 23 #include <sys/cdefs.h> 24 #include <sys/time.h> 25 #include <time.h> 26 #include <unistd.h> 27 #include "private/KernelArgumentBlock.h" 28 29 static inline int vdso_return(int result) { 30 if (__predict_true(result == 0)) return 0; 31 32 errno = -result; 33 return -1; 34 } 35 36 int clock_gettime(int clock_id, timespec* tp) { 37 auto vdso_clock_gettime = reinterpret_cast<decltype(&clock_gettime)>( 38 __libc_globals->vdso[VDSO_CLOCK_GETTIME].fn); 39 if (__predict_true(vdso_clock_gettime)) { 40 return vdso_return(vdso_clock_gettime(clock_id, tp)); 41 } 42 return __clock_gettime(clock_id, tp); 43 } 44 45 int clock_getres(int clock_id, timespec* tp) { 46 auto vdso_clock_getres = reinterpret_cast<decltype(&clock_getres)>( 47 __libc_globals->vdso[VDSO_CLOCK_GETRES].fn); 48 if (__predict_true(vdso_clock_getres)) { 49 return vdso_return(vdso_clock_getres(clock_id, tp)); 50 } 51 return __clock_getres(clock_id, tp); 52 } 53 54 int gettimeofday(timeval* tv, struct timezone* tz) { 55 auto vdso_gettimeofday = reinterpret_cast<decltype(&gettimeofday)>( 56 __libc_globals->vdso[VDSO_GETTIMEOFDAY].fn); 57 if (__predict_true(vdso_gettimeofday)) { 58 return vdso_return(vdso_gettimeofday(tv, tz)); 59 } 60 return __gettimeofday(tv, tz); 61 } 62 63 time_t time(time_t* t) { 64 auto vdso_time = reinterpret_cast<decltype(&time)>(__libc_globals->vdso[VDSO_TIME].fn); 65 if (__predict_true(vdso_time)) { 66 return vdso_time(t); 67 } 68 69 // We can't fallback to the time(2) system call because it doesn't exist for most architectures. 70 timeval tv; 71 if (gettimeofday(&tv, nullptr) == -1) return -1; 72 if (t) *t = tv.tv_sec; 73 return tv.tv_sec; 74 } 75 76 void __libc_init_vdso(libc_globals* globals, KernelArgumentBlock& args) { 77 auto&& vdso = globals->vdso; 78 vdso[VDSO_CLOCK_GETTIME] = { VDSO_CLOCK_GETTIME_SYMBOL, nullptr }; 79 vdso[VDSO_CLOCK_GETRES] = { VDSO_CLOCK_GETRES_SYMBOL, nullptr }; 80 vdso[VDSO_GETTIMEOFDAY] = { VDSO_GETTIMEOFDAY_SYMBOL, nullptr }; 81 vdso[VDSO_TIME] = { VDSO_TIME_SYMBOL, nullptr }; 82 83 // Do we have a vdso? 84 uintptr_t vdso_ehdr_addr = args.getauxval(AT_SYSINFO_EHDR); 85 ElfW(Ehdr)* vdso_ehdr = reinterpret_cast<ElfW(Ehdr)*>(vdso_ehdr_addr); 86 if (vdso_ehdr == nullptr) { 87 return; 88 } 89 90 // How many symbols does it have? 91 size_t symbol_count = 0; 92 ElfW(Shdr)* vdso_shdr = reinterpret_cast<ElfW(Shdr)*>(vdso_ehdr_addr + vdso_ehdr->e_shoff); 93 for (size_t i = 0; i < vdso_ehdr->e_shnum; ++i) { 94 if (vdso_shdr[i].sh_type == SHT_DYNSYM) { 95 symbol_count = vdso_shdr[i].sh_size / sizeof(ElfW(Sym)); 96 } 97 } 98 if (symbol_count == 0) { 99 return; 100 } 101 102 // Where's the dynamic table? 103 ElfW(Addr) vdso_addr = 0; 104 ElfW(Dyn)* vdso_dyn = nullptr; 105 ElfW(Phdr)* vdso_phdr = reinterpret_cast<ElfW(Phdr)*>(vdso_ehdr_addr + vdso_ehdr->e_phoff); 106 for (size_t i = 0; i < vdso_ehdr->e_phnum; ++i) { 107 if (vdso_phdr[i].p_type == PT_DYNAMIC) { 108 vdso_dyn = reinterpret_cast<ElfW(Dyn)*>(vdso_ehdr_addr + vdso_phdr[i].p_offset); 109 } else if (vdso_phdr[i].p_type == PT_LOAD) { 110 vdso_addr = vdso_ehdr_addr + vdso_phdr[i].p_offset - vdso_phdr[i].p_vaddr; 111 } 112 } 113 if (vdso_addr == 0 || vdso_dyn == nullptr) { 114 return; 115 } 116 117 // Where are the string and symbol tables? 118 const char* strtab = nullptr; 119 ElfW(Sym)* symtab = nullptr; 120 for (ElfW(Dyn)* d = vdso_dyn; d->d_tag != DT_NULL; ++d) { 121 if (d->d_tag == DT_STRTAB) { 122 strtab = reinterpret_cast<const char*>(vdso_addr + d->d_un.d_ptr); 123 } else if (d->d_tag == DT_SYMTAB) { 124 symtab = reinterpret_cast<ElfW(Sym)*>(vdso_addr + d->d_un.d_ptr); 125 } 126 } 127 if (strtab == nullptr || symtab == nullptr) { 128 return; 129 } 130 131 // Are there any symbols we want? 132 for (size_t i = 0; i < symbol_count; ++i) { 133 for (size_t j = 0; j < VDSO_END; ++j) { 134 if (strcmp(vdso[j].name, strtab + symtab[i].st_name) == 0) { 135 vdso[j].fn = reinterpret_cast<void*>(vdso_addr + symtab[i].st_value); 136 } 137 } 138 } 139 } 140
