linker/linker_soinfo.h

   1 /*
   2  * Copyright (C) 2016 The Android Open Source Project
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *  * Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  *  * Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in
  12  *    the documentation and/or other materials provided with the
  13  *    distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  17  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  18  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  19  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  20  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  21  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  22  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  23  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  24  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  25  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #ifndef __LINKER_SOINFO_H
  30 #define __LINKER_SOINFO_H
  31
  32 #include <link.h>
  33
  34 #include <string>
  35
  36 #include "linker_namespaces.h"
  37
  38 #define FLAG_LINKED           0x00000001
  39 #define FLAG_EXE              0x00000004 // The main executable
  40 #define FLAG_LINKER           0x00000010 // The linker itself
  41 #define FLAG_GNU_HASH         0x00000040 // uses gnu hash
  42 #define FLAG_MAPPED_BY_CALLER 0x00000080 // the map is reserved by the caller
  43                                          // and should not be unmapped
  44 #define FLAG_NEW_SOINFO       0x40000000 // new soinfo format
  45
  46 #define SOINFO_VERSION 3
  47
  48 typedef void (*linker_dtor_function_t)();
  49 typedef void (*linker_ctor_function_t)(int, char**, char**);
  50
  51 class SymbolName {
  52  public:
  53   explicit SymbolName(const char* name)
  54       : name_(name), has_elf_hash_(false), has_gnu_hash_(false),
  55         elf_hash_(0), gnu_hash_(0) { }
  56
  57   const char* get_name() {
  58     return name_;
  59   }
  60
  61   uint32_t elf_hash();
  62   uint32_t gnu_hash();
  63
  64  private:
  65   const char* name_;
  66   bool has_elf_hash_;
  67   bool has_gnu_hash_;
  68   uint32_t elf_hash_;
  69   uint32_t gnu_hash_;
  70
  71   DISALLOW_IMPLICIT_CONSTRUCTORS(SymbolName);
  72 };
  73
  74 struct version_info {
  75   constexpr version_info() : elf_hash(0), name(nullptr), target_si(nullptr) {}
  76
  77   uint32_t elf_hash;
  78   const char* name;
  79   const soinfo* target_si;
  80 };
  81
  82 // TODO(dimitry): remove reference from soinfo member functions to this class.
  83 class VersionTracker;
  84
  85 #if defined(__work_around_b_24465209__)
  86 #define SOINFO_NAME_LEN 128
  87 #endif
  88
  89 struct soinfo {
  90 #if defined(__work_around_b_24465209__)
  91  private:
  92   char old_name_[SOINFO_NAME_LEN];
  93 #endif
  94  public:
  95   const ElfW(Phdr)* phdr;
  96   size_t phnum;
  97 #if defined(__work_around_b_24465209__)
  98   ElfW(Addr) unused0; // DO NOT USE, maintained for compatibility.
  99 #endif
 100   ElfW(Addr) base;
 101   size_t size;
 102
 103 #if defined(__work_around_b_24465209__)
 104   uint32_t unused1;  // DO NOT USE, maintained for compatibility.
 105 #endif
 106
 107   ElfW(Dyn)* dynamic;
 108
 109 #if defined(__work_around_b_24465209__)
 110   uint32_t unused2; // DO NOT USE, maintained for compatibility
 111   uint32_t unused3; // DO NOT USE, maintained for compatibility
 112 #endif
 113
 114   soinfo* next;
 115  private:
 116   uint32_t flags_;
 117
 118   const char* strtab_;
 119   ElfW(Sym)* symtab_;
 120
 121   size_t nbucket_;
 122   size_t nchain_;
 123   uint32_t* bucket_;
 124   uint32_t* chain_;
 125
 126 #if defined(__mips__) || !defined(__LP64__)
 127   // This is only used by mips and mips64, but needs to be here for
 128   // all 32-bit architectures to preserve binary compatibility.
 129   ElfW(Addr)** plt_got_;
 130 #endif
 131
 132 #if defined(USE_RELA)
 133   ElfW(Rela)* plt_rela_;
 134   size_t plt_rela_count_;
 135
 136   ElfW(Rela)* rela_;
 137   size_t rela_count_;
 138 #else
 139   ElfW(Rel)* plt_rel_;
 140   size_t plt_rel_count_;
 141
 142   ElfW(Rel)* rel_;
 143   size_t rel_count_;
 144 #endif
 145
 146   linker_ctor_function_t* preinit_array_;
 147   size_t preinit_array_count_;
 148
 149   linker_ctor_function_t* init_array_;
 150   size_t init_array_count_;
 151   linker_dtor_function_t* fini_array_;
 152   size_t fini_array_count_;
 153
 154   linker_ctor_function_t init_func_;
 155   linker_dtor_function_t fini_func_;
 156
 157 #if defined(__arm__)
 158  public:
 159   // ARM EABI section used for stack unwinding.
 160   uint32_t* ARM_exidx;
 161   size_t ARM_exidx_count;
 162  private:
 163 #elif defined(__mips__)
 164   uint32_t mips_symtabno_;
 165   uint32_t mips_local_gotno_;
 166   uint32_t mips_gotsym_;
 167   bool mips_relocate_got(const VersionTracker& version_tracker,
 168                          const soinfo_list_t& global_group,
 169                          const soinfo_list_t& local_group);
 170 #if !defined(__LP64__)
 171   bool mips_check_and_adjust_fp_modes();
 172 #endif
 173 #endif
 174   size_t ref_count_;
 175  public:
 176   link_map link_map_head;
 177
 178   bool constructors_called;
 179
 180   // When you read a virtual address from the ELF file, add this
 181   // value to get the corresponding address in the process' address space.
 182   ElfW(Addr) load_bias;
 183
 184 #if !defined(__LP64__)
 185   bool has_text_relocations;
 186 #endif
 187   bool has_DT_SYMBOLIC;
 188
 189  public:
 190   soinfo(android_namespace_t* ns, const char* name, const struct stat* file_stat,
 191          off64_t file_offset, int rtld_flags);
 192   ~soinfo();
 193
 194   void call_constructors();
 195   void call_destructors();
 196   void call_pre_init_constructors();
 197   bool prelink_image();
 198   bool link_image(const soinfo_list_t& global_group, const soinfo_list_t& local_group,
 199                   const android_dlextinfo* extinfo);
 200   bool protect_relro();
 201
 202   void add_child(soinfo* child);
 203   void remove_all_links();
 204
 205   ino_t get_st_ino() const;
 206   dev_t get_st_dev() const;
 207   off64_t get_file_offset() const;
 208
 209   uint32_t get_rtld_flags() const;
 210   uint32_t get_dt_flags_1() const;
 211   void set_dt_flags_1(uint32_t dt_flags_1);
 212
 213   soinfo_list_t& get_children();
 214   const soinfo_list_t& get_children() const;
 215
 216   soinfo_list_t& get_parents();
 217
 218   bool find_symbol_by_name(SymbolName& symbol_name,
 219                            const version_info* vi,
 220                            const ElfW(Sym)** symbol) const;
 221
 222   ElfW(Sym)* find_symbol_by_address(const void* addr);
 223   ElfW(Addr) resolve_symbol_address(const ElfW(Sym)* s) const;
 224
 225   const char* get_string(ElfW(Word) index) const;
 226   bool can_unload() const;
 227   bool is_gnu_hash() const;
 228
 229   bool inline has_min_version(uint32_t min_version __unused) const {
 230 #if defined(__work_around_b_24465209__)
 231     return (flags_ & FLAG_NEW_SOINFO) != 0 && version_ >= min_version;
 232 #else
 233     return true;
 234 #endif
 235   }
 236
 237   bool is_linked() const;
 238   bool is_linker() const;
 239   bool is_main_executable() const;
 240
 241   void set_linked();
 242   void set_linker_flag();
 243   void set_main_executable();
 244   void set_nodelete();
 245
 246   void increment_ref_count();
 247   size_t decrement_ref_count();
 248
 249   soinfo* get_local_group_root() const;
 250
 251   void set_soname(const char* soname);
 252   const char* get_soname() const;
 253   const char* get_realpath() const;
 254   const ElfW(Versym)* get_versym(size_t n) const;
 255   ElfW(Addr) get_verneed_ptr() const;
 256   size_t get_verneed_cnt() const;
 257   ElfW(Addr) get_verdef_ptr() const;
 258   size_t get_verdef_cnt() const;
 259
 260   uint32_t get_target_sdk_version() const;
 261
 262   void set_dt_runpath(const char *);
 263   const std::vector<std::string>& get_dt_runpath() const;
 264   android_namespace_t* get_primary_namespace();
 265   void add_secondary_namespace(android_namespace_t* secondary_ns);
 266   android_namespace_list_t& get_secondary_namespaces();
 267
 268   void set_mapped_by_caller(bool reserved_map);
 269   bool is_mapped_by_caller() const;
 270
 271   uintptr_t get_handle() const;
 272   void generate_handle();
 273   void* to_handle();
 274
 275  private:
 276   bool elf_lookup(SymbolName& symbol_name, const version_info* vi, uint32_t* symbol_index) const;
 277   ElfW(Sym)* elf_addr_lookup(const void* addr);
 278   bool gnu_lookup(SymbolName& symbol_name, const version_info* vi, uint32_t* symbol_index) const;
 279   ElfW(Sym)* gnu_addr_lookup(const void* addr);
 280
 281   bool lookup_version_info(const VersionTracker& version_tracker, ElfW(Word) sym,
 282                            const char* sym_name, const version_info** vi);
 283
 284   template<typename ElfRelIteratorT>
 285   bool relocate(const VersionTracker& version_tracker, ElfRelIteratorT&& rel_iterator,
 286                 const soinfo_list_t& global_group, const soinfo_list_t& local_group);
 287
 288  private:
 289   // This part of the structure is only available
 290   // when FLAG_NEW_SOINFO is set in this->flags.
 291   uint32_t version_;
 292
 293   // version >= 0
 294   dev_t st_dev_;
 295   ino_t st_ino_;
 296
 297   // dependency graph
 298   soinfo_list_t children_;
 299   soinfo_list_t parents_;
 300
 301   // version >= 1
 302   off64_t file_offset_;
 303   uint32_t rtld_flags_;
 304   uint32_t dt_flags_1_;
 305   size_t strtab_size_;
 306
 307   // version >= 2
 308
 309   size_t gnu_nbucket_;
 310   uint32_t* gnu_bucket_;
 311   uint32_t* gnu_chain_;
 312   uint32_t gnu_maskwords_;
 313   uint32_t gnu_shift2_;
 314   ElfW(Addr)* gnu_bloom_filter_;
 315
 316   soinfo* local_group_root_;
 317
 318   uint8_t* android_relocs_;
 319   size_t android_relocs_size_;
 320
 321   const char* soname_;
 322   std::string realpath_;
 323
 324   const ElfW(Versym)* versym_;
 325
 326   ElfW(Addr) verdef_ptr_;
 327   size_t verdef_cnt_;
 328
 329   ElfW(Addr) verneed_ptr_;
 330   size_t verneed_cnt_;
 331
 332   uint32_t target_sdk_version_;
 333
 334   // version >= 3
 335   std::vector<std::string> dt_runpath_;
 336   android_namespace_t* primary_namespace_;
 337   android_namespace_list_t secondary_namespaces_;
 338   uintptr_t handle_;
 339
 340   friend soinfo* get_libdl_info(const char* linker_path, const link_map& linker_map);
 341 };
 342
 343 // This function is used by dlvsym() to calculate hash of sym_ver
 344 uint32_t calculate_elf_hash(const char* name);
 345
 346 const char* fix_dt_needed(const char* dt_needed, const char* sopath);
 347
 348 template<typename F>
 349 void for_each_dt_needed(const soinfo* si, F action) {
 350   for (const ElfW(Dyn)* d = si->dynamic; d->d_tag != DT_NULL; ++d) {
 351     if (d->d_tag == DT_NEEDED) {
 352       action(fix_dt_needed(si->get_string(d->d_un.d_val), si->get_realpath()));
 353     }
 354   }
 355 }
 356
 357 #endif  /* __LINKER_SOINFO_H */