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
48typedef void (*linker_dtor_function_t)();
49typedef void (*linker_ctor_function_t)(int, char**, char**);
50
51class 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
74struct 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.
83class VersionTracker;
84
85#if defined(__work_around_b_24465209__)
86#define SOINFO_NAME_LEN 128
87#endif
88
89struct 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);
341};
342
343// This function is used by dlvsym() to calculate hash of sym_ver
344uint32_t calculate_elf_hash(const char* name);
345
346const char* fix_dt_needed(const char* dt_needed, const char* sopath);
347
348template<typename F>
349void 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 */
358