1 /*
2  * Copyright (C) 2015 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 #if !defined(__LP64__) && __mips_isa_rev >= 5
30 #include <sys/prctl.h>
31 #endif
32 
33 #include "linker.h"
34 #include "linker_debug.h"
35 #include "linker_phdr.h"
36 #include "linker_relocs.h"
37 #include "linker_reloc_iterators.h"
38 #include "linker_sleb128.h"
39 
40 template bool soinfo::relocate<plain_reloc_iterator>(const VersionTracker& version_tracker,
41                                                      plain_reloc_iterator&& rel_iterator,
42                                                      const soinfo_list_t& global_group,
43                                                      const soinfo_list_t& local_group);
44 
45 template bool soinfo::relocate<packed_reloc_iterator<sleb128_decoder>>(
46     const VersionTracker& version_tracker,
47     packed_reloc_iterator<sleb128_decoder>&& rel_iterator,
48     const soinfo_list_t& global_group,
49     const soinfo_list_t& local_group);
50 
51 template <typename ElfRelIteratorT>
relocate(const VersionTracker & version_tracker,ElfRelIteratorT && rel_iterator,const soinfo_list_t & global_group,const soinfo_list_t & local_group)52 bool soinfo::relocate(const VersionTracker& version_tracker,
53                       ElfRelIteratorT&& rel_iterator,
54                       const soinfo_list_t& global_group,
55                       const soinfo_list_t& local_group) {
56   for (size_t idx = 0; rel_iterator.has_next(); ++idx) {
57     const auto rel = rel_iterator.next();
58 
59     if (rel == nullptr) {
60       return false;
61     }
62 
63     ElfW(Word) type = ELFW(R_TYPE)(rel->r_info);
64     ElfW(Word) sym = ELFW(R_SYM)(rel->r_info);
65 
66     ElfW(Addr) reloc = static_cast<ElfW(Addr)>(rel->r_offset + load_bias);
67     ElfW(Addr) sym_addr = 0;
68     const char* sym_name = nullptr;
69 
70     DEBUG("Processing \"%s\" relocation at index %zd", get_realpath(), idx);
71     if (type == R_GENERIC_NONE) {
72       continue;
73     }
74 
75     const ElfW(Sym)* s = nullptr;
76     soinfo* lsi = nullptr;
77 
78     if (sym != 0) {
79       sym_name = get_string(symtab_[sym].st_name);
80       const version_info* vi = nullptr;
81 
82       if (!lookup_version_info(version_tracker, sym, sym_name, &vi)) {
83         return false;
84       }
85 
86       if (!soinfo_do_lookup(this, sym_name, vi, &lsi, global_group, local_group, &s)) {
87         return false;
88       }
89 
90       if (s == nullptr) {
91         // mips does not support relocation with weak-undefined symbols
92         DL_ERR("cannot locate symbol \"%s\" referenced by \"%s\"...",
93                sym_name, get_realpath());
94         return false;
95       } else {
96         // We got a definition.
97         sym_addr = lsi->resolve_symbol_address(s);
98       }
99       count_relocation(kRelocSymbol);
100     }
101 
102     switch (type) {
103       case R_MIPS_REL32:
104 #if defined(__LP64__)
105         // MIPS Elf64_Rel entries contain compound relocations
106         // We only handle the R_MIPS_NONE|R_MIPS_64|R_MIPS_REL32 case
107         if (ELF64_R_TYPE2(rel->r_info) != R_MIPS_64 ||
108             ELF64_R_TYPE3(rel->r_info) != R_MIPS_NONE) {
109           DL_ERR("Unexpected compound relocation type:%d type2:%d type3:%d @ %p (%zu)",
110                  type, static_cast<unsigned>(ELF64_R_TYPE2(rel->r_info)),
111                  static_cast<unsigned>(ELF64_R_TYPE3(rel->r_info)), rel, idx);
112           return false;
113         }
114 #endif
115         count_relocation(s == nullptr ? kRelocAbsolute : kRelocRelative);
116         MARK(rel->r_offset);
117         TRACE_TYPE(RELO, "RELO REL32 %08zx <- %08zx %s", static_cast<size_t>(reloc),
118                    static_cast<size_t>(sym_addr), sym_name ? sym_name : "*SECTIONHDR*");
119         if (s != nullptr) {
120           *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr;
121         } else {
122           *reinterpret_cast<ElfW(Addr)*>(reloc) += load_bias;
123         }
124         break;
125       default:
126         DL_ERR("unknown reloc type %d @ %p (%zu)", type, rel, idx);
127         return false;
128     }
129   }
130   return true;
131 }
132 
mips_relocate_got(const VersionTracker & version_tracker,const soinfo_list_t & global_group,const soinfo_list_t & local_group)133 bool soinfo::mips_relocate_got(const VersionTracker& version_tracker,
134                                const soinfo_list_t& global_group,
135                                const soinfo_list_t& local_group) {
136   ElfW(Addr)** got = plt_got_;
137   if (got == nullptr) {
138     return true;
139   }
140 
141   // got[0] is the address of the lazy resolver function.
142   // got[1] may be used for a GNU extension.
143   // Set it to a recognizable address in case someone calls it (should be _rtld_bind_start).
144   // FIXME: maybe this should be in a separate routine?
145   if ((flags_ & FLAG_LINKER) == 0) {
146     size_t g = 0;
147     got[g++] = reinterpret_cast<ElfW(Addr)*>(0xdeadbeef);
148     if (reinterpret_cast<intptr_t>(got[g]) < 0) {
149       got[g++] = reinterpret_cast<ElfW(Addr)*>(0xdeadfeed);
150     }
151     // Relocate the local GOT entries.
152     for (; g < mips_local_gotno_; g++) {
153       got[g] = reinterpret_cast<ElfW(Addr)*>(reinterpret_cast<uintptr_t>(got[g]) + load_bias);
154     }
155   }
156 
157   // Now for the global GOT entries...
158   got = plt_got_ + mips_local_gotno_;
159   for (ElfW(Word) sym = mips_gotsym_; sym < mips_symtabno_; sym++, got++) {
160     // This is an undefined reference... try to locate it.
161     const ElfW(Sym)* local_sym = symtab_ + sym;
162     const char* sym_name = get_string(local_sym->st_name);
163     soinfo* lsi = nullptr;
164     const ElfW(Sym)* s = nullptr;
165 
166     ElfW(Word) st_visibility = (local_sym->st_other & 0x3);
167 
168     if (st_visibility == STV_DEFAULT) {
169       const version_info* vi = nullptr;
170 
171       if (!lookup_version_info(version_tracker, sym, sym_name, &vi)) {
172         return false;
173       }
174 
175       if (!soinfo_do_lookup(this, sym_name, vi, &lsi, global_group, local_group, &s)) {
176         return false;
177       }
178     } else if (st_visibility == STV_PROTECTED) {
179       if (local_sym->st_value == 0) {
180         DL_ERR("%s: invalid symbol \"%s\" (PROTECTED/UNDEFINED) ",
181                get_realpath(), sym_name);
182         return false;
183       }
184       s = local_sym;
185       lsi = this;
186     } else {
187       DL_ERR("%s: invalid symbol \"%s\" visibility: 0x%x",
188              get_realpath(), sym_name, st_visibility);
189       return false;
190     }
191 
192     if (s == nullptr) {
193       // We only allow an undefined symbol if this is a weak reference.
194       if (ELF_ST_BIND(local_sym->st_info) != STB_WEAK) {
195         DL_ERR("%s: cannot locate \"%s\"...", get_realpath(), sym_name);
196         return false;
197       }
198       *got = 0;
199     } else {
200       // FIXME: is this sufficient?
201       // For reference see NetBSD link loader
202       // http://cvsweb.netbsd.org/bsdweb.cgi/src/libexec/ld.elf_so/arch/mips/mips_reloc.c?rev=1.53&content-type=text/x-cvsweb-markup
203       *got = reinterpret_cast<ElfW(Addr)*>(lsi->resolve_symbol_address(s));
204     }
205   }
206   return true;
207 }
208 
209 #if !defined(__LP64__)
210 
211 // Checks for mips32's various floating point abis.
212 // (Mips64 Android has a single floating point abi and doesn't need any checks)
213 
214 // Linux kernel has declarations similar to the following
215 //   in <linux>/arch/mips/include/asm/elf.h,
216 // but that non-uapi internal header file will never be imported
217 // into bionic's kernel headers.
218 
219 #define PT_MIPS_ABIFLAGS  0x70000003	// is .MIPS.abiflags segment
220 
221 struct mips_elf_abiflags_v0 {
222   uint16_t version;  // version of this structure
223   uint8_t  isa_level, isa_rev, gpr_size, cpr1_size, cpr2_size;
224   uint8_t  fp_abi;  // mips32 ABI variants for floating point
225   uint32_t isa_ext, ases, flags1, flags2;
226 };
227 
228 // Bits of flags1:
229 #define MIPS_AFL_FLAGS1_ODDSPREG 1  // Uses odd-numbered single-prec fp regs
230 
231 // Some values of fp_abi:        via compiler flag:
232 #define MIPS_ABI_FP_DOUBLE 1  // -mdouble-float
233 #define MIPS_ABI_FP_XX     5  // -mfpxx
234 #define MIPS_ABI_FP_64A    7  // -mips32r* -mfp64 -mno-odd-spreg
235 
236 #if __mips_isa_rev >= 5
237 static bool mips_fre_mode_on = false;  // have set FRE=1 mode for process
238 #endif
239 
mips_check_and_adjust_fp_modes()240 bool soinfo::mips_check_and_adjust_fp_modes() {
241   mips_elf_abiflags_v0* abiflags = nullptr;
242   int mips_fpabi;
243 
244   // Find soinfo's optional .MIPS.abiflags segment
245   for (size_t i = 0; i<phnum; ++i) {
246     const ElfW(Phdr)& ph = phdr[i];
247     if (ph.p_type == PT_MIPS_ABIFLAGS) {
248       if (ph.p_filesz < sizeof (mips_elf_abiflags_v0)) {
249         DL_ERR("Corrupt PT_MIPS_ABIFLAGS header found \"%s\"", get_realpath());
250         return false;
251       }
252       abiflags = reinterpret_cast<mips_elf_abiflags_v0*>(ph.p_vaddr + load_bias);
253       break;
254     }
255   }
256 
257   // FP ABI-variant compatibility checks for MIPS o32 ABI
258   if (abiflags == nullptr) {
259     // Old compilers and some translators don't emit the new abiflags section.
260     const char* filename = get_realpath();
261     size_t len = strlen(filename);
262     if (len > 4 && (strcmp(filename+len-4, ".dex") == 0 ||
263                     strcmp(filename+len-4, ".oat") == 0   )) {
264       // Assume dex2oat is compatible with target
265       mips_fpabi = MIPS_ABI_FP_XX;
266     } else {
267       // Old Android compilers used -mfp32 -mdouble-float -modd-spreg defaults,
268       //   ie FP32 aka DOUBLE, using FR=0 mode fpregs & odd single-prec fpregs
269       mips_fpabi = MIPS_ABI_FP_DOUBLE;
270     }
271   } else {
272     mips_fpabi = abiflags->fp_abi;
273     if ( (abiflags->flags1 & MIPS_AFL_FLAGS1_ODDSPREG)
274          && (mips_fpabi == MIPS_ABI_FP_XX ||
275              mips_fpabi == MIPS_ABI_FP_64A   ) ) {
276       // Android supports fewer cases than Linux
277       DL_ERR("Unsupported odd-single-prec FloatPt reg uses in \"%s\"",
278              get_realpath());
279       return false;
280     }
281   }
282   if (!(mips_fpabi == MIPS_ABI_FP_DOUBLE ||
283 #if __mips_isa_rev >= 5
284         mips_fpabi == MIPS_ABI_FP_64A    ||
285 #endif
286         mips_fpabi == MIPS_ABI_FP_XX       )) {
287     DL_ERR("Unsupported MIPS32 FloatPt ABI %d found in \"%s\"",
288            mips_fpabi, get_realpath());
289     return false;
290   }
291 
292 #if __mips_isa_rev >= 5
293   // Adjust process's FR Emulation mode, if needed
294   //
295   // On Mips R5 & R6, Android runs continuously in FR=1 64bit-fpreg mode.
296   // NDK mips32 apps compiled with old compilers generate FP32 code
297   //   which expects FR=0 32-bit fp registers.
298   // NDK mips32 apps compiled with newer compilers generate modeless
299   //   FPXX code which runs on both FR=0 and FR=1 modes.
300   // Android itself is compiled in FP64A which requires FR=1 mode.
301   // FP32, FPXX, and FP64A all interlink okay, without dynamic FR mode
302   //   changes during calls.  For details, see
303   //   http://dmz-portal.mips.com/wiki/MIPS_O32_ABI_-_FR0_and_FR1_Interlinking
304   // Processes containing FR32 FR=0 code are run via kernel software assist,
305   //   which maps all odd-numbered single-precision reg refs onto the
306   //   upper half of the paired even-numbered double-precision reg.
307   // FRE=1 triggers traps to the kernel's emulator on every single-precision
308   //   fp op (for both odd and even-numbered registers).
309   // Turning on FRE=1 traps is done at most once per process, simultanously
310   //   for all threads of that process, when dlopen discovers FP32 code.
311   // The kernel repacks threads' registers when FRE mode is turn on or off.
312   //   These asynchronous adjustments are wrong if any thread was executing
313   //   FPXX code using odd-numbered single-precision regs.
314   // Current Android compilers default to the -mno-oddspreg option,
315   //   and this requirement is checked by Android's dlopen.
316   //   So FRE can always be safely turned on for FP32, anytime.
317   // Deferred enhancement: Allow loading of odd-spreg FPXX modules.
318 
319   if (mips_fpabi == MIPS_ABI_FP_DOUBLE && !mips_fre_mode_on) {
320     // Turn on FRE mode, which emulates mode-sensitive FR=0 code on FR=1
321     //   register files, by trapping to kernel on refs to single-precision regs
322     if (prctl(PR_SET_FP_MODE, PR_FP_MODE_FR|PR_FP_MODE_FRE)) {
323       DL_ERR("Kernel or cpu failed to set FRE mode required for running \"%s\"",
324              get_realpath());
325       return false;
326     }
327     DL_WARN("Using FRE=1 mode to run \"%s\"", get_realpath());
328     mips_fre_mode_on = true;  // Avoid future redundant mode-switch calls
329     // FRE mode is never turned back off.
330     // Deferred enhancement:
331     //   Reset FRE mode when dlclose() removes all FP32 modules
332   }
333 #else
334   // Android runs continuously in FR=0 32bit-fpreg mode.
335 #endif  // __mips_isa_rev
336   return true;
337 }
338 
339 #endif  // __LP64___
340