Support for unpacked ARM packed relocations.

third_party/android_crazy_linker/src/src/crazy_linker_elf_relocations.cpp

 // Copyright 2014 The Chromium 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 "crazy_linker_elf_relocations.h"
 
 #include <errno.h>
 
 #include "crazy_linker_debug.h"
 #include "crazy_linker_elf_symbols.h"
 #include "crazy_linker_elf_view.h"
 #include "crazy_linker_error.h"
+#include "crazy_linker_system.h"
 #include "crazy_linker_util.h"
 #include "linker_phdr.h"
 
 #define DEBUG_RELOCATIONS 0
 
 #define RLOG(...) LOG_IF(DEBUG_RELOCATIONS, __VA_ARGS__)
 #define RLOG_ERRNO(...) LOG_ERRNO_IF(DEBUG_RELOCATIONS, __VA_ARGS__)
 
 #ifndef DF_SYMBOLIC
 #define DF_SYMBOLIC 2
@@ skipping 35 matching lines @@
 
 /* i386 relocations */
 #define R_386_32 1
 #define R_386_PC32 2
 #define R_386_GLOB_DAT 6
 #define R_386_JMP_SLOT 7
 #define R_386_RELATIVE 8
 
 #endif  // __i386__
 
+// Processor-specific extension dynamic tags for packed relocations.
+#ifdef __arm__
+
+#define DT_ANDROID_ARM_REL_OFFSET (DT_LOPROC)
+#define DT_ANDROID_ARM_REL_SIZE (DT_LOPROC + 1)

[rmcilroy, 2014/06/18 10:56:05]

nit - just move this up to the preceding ifdef __arm__ with the comment
mentioning these are for packed relocations support?

[simonb1, 2014/06/18 15:41:28]

Moved to crazy_linker_shared_library.cpp in patch set 4.

+
+#endif  // __arm__
+
 namespace crazy {
 
 namespace {
 
 // List of known relocation types the relocator knows about.
 enum RelocationType {
   RELOCATION_TYPE_UNKNOWN = 0,
   RELOCATION_TYPE_ABSOLUTE = 1,
   RELOCATION_TYPE_RELATIVE = 2,
   RELOCATION_TYPE_PC_RELATIVE = 3,
@@ skipping 136 matching lines @@
         break;
       case DT_FLAGS:
         if (dyn_value & DF_TEXTREL)
           has_text_relocations_ = true;
         if (dyn_value & DF_SYMBOLIC)
           has_symbolic_ = true;
         RLOG(" DT_FLAGS has_text_relocations=%s has_symbolic=%s\n",
              has_text_relocations_ ? "true" : "false",
              has_symbolic_ ? "true" : "false");
         break;
+#if defined(__arm__)
+      case DT_ANDROID_ARM_REL_OFFSET:
+        arm_packed_relocations_ = dyn.GetOffset();
+        RLOG("  DT_ANDROID_ARM_REL_OFFSET addr=%p\n", arm_packed_relocations_);
+        break;
+      case DT_ANDROID_ARM_REL_SIZE:
+        arm_packed_relocations_size_ = dyn.GetValue();
+        RLOG("  DT_ANDROID_ARM_REL_SIZE=%d\n", arm_packed_relocations_size_);
+        break;
+#endif
 #if defined(__mips__)
       case DT_MIPS_SYMTABNO:
         RLOG("  DT_MIPS_SYMTABNO value=%d\n", dyn_value);
         mips_symtab_count_ = dyn_value;
         break;
 
       case DT_MIPS_LOCAL_GOTNO:
         RLOG("  DT_MIPS_LOCAL_GOTNO value=%d\n", dyn_value);
         mips_local_got_count_ = dyn_value;
         break;
@@ skipping 20 matching lines @@
   if (relocations_type_ == DT_RELA && has_rel_relocations) {
     *error = "Found DT_REL in dyn section, but DT_PLTREL is DT_RELA";
     return false;
   }
 
   return true;
 }
 
 bool ElfRelocations::ApplyAll(const ElfSymbols* symbols,
                               SymbolResolver* resolver,
+                              const char* full_path CRAZY_UNUSED,

[rmcilroy, 2014/06/18 10:56:05]

Rather than passing the full path here, and having to re-open the file to get
the packed relocations, how about just extracting the packed relocations (if
they exist) in SharedLibrary::Load()?  This would be cleaner and more consistent
with the other relocations IMO.

[simonb1, 2014/06/18 15:41:28]

Done.  It's a bit more diffuse, so greater occurrence of #ifdef __arm__.

It also doesn't remove the re-open file niggle.  The loader class is the only
thing that opens the file, and only briefly, and it doesn't parse the dynamic
section.  So we only find out that we have a .android.rel.dyn a fair while after
the loader has closed the file.  Shouldn't be a noticeable perf issue though;
loading a library is lengthy enough that one added open() ought to be
immaterial.

                               Error* error) {
   LOG("%s: Enter\n", __FUNCTION__);
 
   if (has_text_relocations_) {
     if (phdr_table_unprotect_segments(phdr_, phdr_count_, load_bias_) < 0) {
       error->Format("Can't unprotect loadable segments: %s", strerror(errno));
       return false;
     }
   }
 
   if (relocations_type_ == DT_REL) {
     if (!ApplyRelRelocs(reinterpret_cast<ELF::Rel*>(plt_relocations_),
                         plt_relocations_size_ / sizeof(ELF::Rel),
                         symbols,
                         resolver,
                         error))
       return false;
     if (!ApplyRelRelocs(reinterpret_cast<ELF::Rel*>(relocations_),
                         relocations_size_ / sizeof(ELF::Rel),
                         symbols,
                         resolver,
                         error))
       return false;
   }
 
-  else if (relocations_type_ == DT_RELA) {
+  if (relocations_type_ == DT_RELA) {
     if (!ApplyRelaRelocs(reinterpret_cast<ELF::Rela*>(plt_relocations_),
                          plt_relocations_size_ / sizeof(ELF::Rela),
                          symbols,
                          resolver,
                          error))
       return false;
     if (!ApplyRelaRelocs(reinterpret_cast<ELF::Rela*>(relocations_),
                          relocations_size_ / sizeof(ELF::Rela),
                          symbols,
                          resolver,
                          error))
       return false;
   }
 
+#ifdef __arm__
+  if (!ApplyArmPackedRelocs(full_path, error))
+    return false;
+#endif
+
 #ifdef __mips__
   if (!RelocateMipsGot(symbols, resolver, error))
     return false;
 #endif
 
   if (has_text_relocations_) {
     if (phdr_table_protect_segments(phdr_, phdr_count_, load_bias_) < 0) {
       error->Format("Can't reprotect loadable segments: %s", strerror(errno));
       return false;
     }
@@ skipping 320 matching lines @@
                                error);
     }
 
     if (!ApplyRelaReloc(rela, sym_addr, resolved, error))
       return false;
   }
 
   return true;
 }
 
+#ifdef __arm__
+
+// Helper class for decoding packed ARM relocation data.
+// http://en.wikipedia.org/wiki/LEB128
+class Leb128Decoder {
+ public:
+  explicit Leb128Decoder(const uint8_t* encoding)
+      : encoding_(encoding), cursor_(0) { }
+
+  uint32_t Dequeue() {
+    size_t extent = cursor_;
+    while (encoding_[extent] >> 7)
+      extent++;
+
+    uint32_t value = 0;
+    for (size_t i = extent; i > cursor_; --i) {
+      value = (value << 7) | (encoding_[i] & 127);
+    }
+    value = (value << 7) | (encoding_[cursor_] & 127);
+
+    cursor_ = extent + 1;
+    return value;
+  }
+
+ private:
+  const uint8_t* encoding_;
+  size_t cursor_;
+};
+
+// Helper class to provide a simple scoped buffer.  ScopedPtr is not
+// usable here because it calls delete, not delete [].
+class ScopedBuffer {
+ public:
+  explicit ScopedBuffer(size_t bytes) : buffer_(new uint8_t[bytes]) { }
+  ~ScopedBuffer() { delete [] buffer_; }
+
+  uint8_t* Get() { return buffer_; }
+
+ private:
+  uint8_t* buffer_;
+};
+
+bool ElfRelocations::ApplyArmPackedRelocs(const char* full_path,
+                                          Error* error) {
+  RLOG("%s: packed_relocations=%p, packed_relocations_size=%d\n",
+       __FUNCTION__,
+       arm_packed_relocations_,
+       arm_packed_relocations_size_);
+
+  if (arm_packed_relocations_size_ == 0)
+    return true;
+
+  // Allocate and then read the packed relocations section.
+  ScopedBuffer scoped_packed_data(arm_packed_relocations_size_);
+  uint8_t* packed_data = scoped_packed_data.Get();
+
+  FileDescriptor fd;
+  if (!fd.OpenReadOnly(full_path)) {
+    error->Format("Error opening file '%s'", full_path);
+    return false;
+  }
+  if (fd.SeekTo(arm_packed_relocations_) == -1) {
+    error->Format("Error seeking to %d in file '%s'",
+                  arm_packed_relocations_,
+                  full_path);
+    return false;
+  }
+  const ssize_t bytes = fd.Read(packed_data, arm_packed_relocations_size_);
+  if (bytes != arm_packed_relocations_size_) {
+    error->Format("Error reading %d bytes from file '%s'",
+                  arm_packed_relocations_size_,
+                  full_path);
+    return false;
+  }
+  fd.Close();
+
+  Leb128Decoder decoder(packed_data);
+
+  // Check for the initial APR1 header.
+  if (decoder.Dequeue() != 'A' || decoder.Dequeue() != 'P' ||
+      decoder.Dequeue() != 'R' || decoder.Dequeue() != '1') {
+    error->Format("Bad packed relocations ident, expected APR1");
+    return false;
+  }
+
+  // Find the count of pairs and the start address.
+  size_t pairs = decoder.Dequeue();
+  const Elf32_Addr start_address = decoder.Dequeue();
+
+  // Emit initial R_ARM_RELATIVE relocation.
+  Elf32_Rel relocation = {start_address, R_ARM_RELATIVE};
+  const ELF::Addr sym_addr = 0;
+  const bool resolved = false;
+  if (!ApplyRelReloc(&relocation, sym_addr, resolved, error))
+    return false;
+
+  size_t unpacked_count = 1;
+
+  // Emit relocations for each count-delta pair.
+  while (pairs) {
+    size_t count = decoder.Dequeue();
+    const size_t delta = decoder.Dequeue();
+
+    // Emit count R_ARM_RELATIVE relocations with delta offset.
+    while (count) {
+      relocation.r_offset += delta;
+      if (!ApplyRelReloc(&relocation, sym_addr, resolved, error))
+        return false;
+      unpacked_count++;
+      count--;
+    }
+    pairs--;
+  }
+
+  RLOG("%s: unpacked_count=%d\n", __FUNCTION__, unpacked_count);
+  return true;
+}
+
+#endif  // __arm__
+
 #ifdef __mips__
 bool ElfRelocations::RelocateMipsGot(const ElfSymbols* symbols,
                                      SymbolResolver* resolver,
                                      Error* error) {
   if (!plt_got_)
     return true;
 
   // Handle the local GOT entries.
   // This mimics what the system linker does.
   // Note from the system linker:
@@ skipping 166 matching lines @@
       if (got_addr < src_addr || got_addr >= src_addr + size)
         continue;
       ELF::Addr* dst_ptr = reinterpret_cast<ELF::Addr*>(got_addr + dst_delta);
       *dst_ptr += map_delta;
     }
   }
 #endif
 }
 
 }  // namespace crazy