Support for unpacked ARM packed relocations.

third_party/android_crazy_linker/src/src/crazy_linker_shared_library.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_shared_library.h"
 
 #include <dlfcn.h>
 #include <stdlib.h>
 #include <sys/mman.h>
 #include <elf.h>
@@ skipping 40 matching lines @@
 #endif
 
 #ifndef DT_PREINIT_ARRAY
 #define DT_PREINIT_ARRAY 32
 #endif
 
 #ifndef DT_PREINIT_ARRAYSZ
 #define DT_PREINIT_ARRAYSZ 33
 #endif
 
+// 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)
+
+#endif  // __arm__
+
 namespace crazy {
 
 namespace {
 
 typedef SharedLibrary::linker_function_t linker_function_t;
 typedef int (*JNI_OnLoadFunctionPtr)(void* vm, void* reserved);
 typedef void (*JNI_OnUnloadFunctionPtr)(void* vm, void* reserved);
 
 // Call a constructor or destructor function pointer. Ignore
 // NULL and -1 values intentionally. They correspond to markers
@@ skipping 70 matching lines @@
 
     // Nothing found here.
     return NULL;
   }
 
  private:
   SharedLibrary* lib_;
   Vector<LibraryView*>* dependencies_;
 };
 
+#ifdef __arm__
+
+// Read an .android.rel.dyn ARM packed relocations section.
+// Returns an allocated buffer holding the data, or NULL on error.
+uint8_t* ReadArmPackedRelocs(const char* full_path,
+                             off_t offset,
+                             size_t bytes,
+                             Error* error) {
+  uint8_t* packed_data = new uint8_t[bytes];
+
+  FileDescriptor fd;
+  if (!fd.OpenReadOnly(full_path)) {
+    error->Format("Error opening file '%s'", full_path);
+    delete [] packed_data;
+    return NULL;
+  }
+  if (fd.SeekTo(offset) == -1) {
+    error->Format("Error seeking to %d in file '%s'", offset, full_path);
+    delete [] packed_data;
+    return NULL;
+  }
+  const ssize_t bytes_read = fd.Read(packed_data, bytes);
+  if (bytes_read != bytes) {
+    error->Format("Error reading %d bytes from file '%s'", bytes, full_path);
+    delete [] packed_data;
+    return NULL;
+  }
+  fd.Close();
+
+  return packed_data;
+}
+
+#endif  // __arm__
+
 }  // namespace
 
 SharedLibrary::SharedLibrary() { ::memset(this, 0, sizeof(*this)); }
 
 SharedLibrary::~SharedLibrary() {
   // Ensure the library is unmapped on destruction.
   if (view_.load_address())
     munmap(reinterpret_cast<void*>(view_.load_address()), view_.load_size());
+
+#ifdef __arm__
+  delete [] arm_packed_relocs_;

[rmcilroy, 2014/06/19 10:49:44]

I think you could still use your ScopedBuffer class to avoid having to call
"delete [] packed_data both here and in ReadArmPackedRelocs, and using a
release() operation to get it out of ReadArmPackedRelocs - WDYT?

[simonb (inactive), 2014/06/23 14:51:32]

Done.

+#endif
 }
 
 bool SharedLibrary::Load(const char* full_path,
                          size_t load_address,
                          size_t file_offset,
                          Error* error) {
   // First, record the path.
   LOG("%s: full path '%s'\n", __FUNCTION__, full_path);
 
   size_t full_path_len = strlen(full_path);
@@ skipping 33 matching lines @@
                                 &relro_start_,
                                 &relro_size_) < 0) {
     relro_start_ = 0;
     relro_size_ = 0;
   }
 
 #ifdef __arm__
   LOG("%s: Extracting ARM.exidx table for %s\n", __FUNCTION__, base_name_);
   (void)phdr_table_get_arm_exidx(
       phdr(), phdr_count(), load_bias(), &arm_exidx_, &arm_exidx_count_);
+
+  off_t arm_packed_relocs_offset = 0;
+  size_t arm_packed_relocs_size = 0;
 #endif
 
   LOG("%s: Parsing dynamic table for %s\n", __FUNCTION__, base_name_);
   ElfView::DynamicIterator dyn(&view_);
   for (; dyn.HasNext(); dyn.GetNext()) {
     ELF::Addr dyn_value = dyn.GetValue();
     uintptr_t dyn_addr = dyn.GetAddress(load_bias());
     switch (dyn.GetTag()) {
       case DT_DEBUG:
         if (view_.dynamic_flags() & PF_W) {
@@ skipping 40 matching lines @@
             preinit_array_count_);
         break;
       case DT_SYMBOLIC:
         LOG("  DT_SYMBOLIC\n");
         has_DT_SYMBOLIC_ = true;
         break;
       case DT_FLAGS:
         if (dyn_value & DF_SYMBOLIC)
           has_DT_SYMBOLIC_ = true;
         break;
+#if defined(__arm__)
+      case DT_ANDROID_ARM_REL_OFFSET:
+        arm_packed_relocs_offset = dyn.GetOffset();
+        LOG("  DT_ANDROID_ARM_REL_OFFSET addr=%p\n", arm_packed_relocs_offset);
+        break;
+      case DT_ANDROID_ARM_REL_SIZE:
+        arm_packed_relocs_size = dyn.GetValue();
+        LOG("  DT_ANDROID_ARM_REL_SIZE=%d\n", arm_packed_relocs_size);
+        break;
+#endif
 #if defined(__mips__)
       case DT_MIPS_RLD_MAP:
         *dyn.GetValuePointer() =
             reinterpret_cast<ELF::Addr>(Globals::GetRDebug()->GetAddress());
         break;
 #endif
       default:
         ;
     }
   }
 
+#ifdef __arm__
+  // If ARM packed relocations are present in the target library, read the
+  // section data and save it in arm_packed_relocs_.
+  if (arm_packed_relocs_offset && arm_packed_relocs_size) {
+    LOG("%s: ARM packed relocations found at offset %d, %d bytes\n",
+        __FUNCTION__,
+        arm_packed_relocs_offset,
+        arm_packed_relocs_size);
+
+    arm_packed_relocs_ =
+        ReadArmPackedRelocs(full_path,
+                            arm_packed_relocs_offset + file_offset,
+                            arm_packed_relocs_size,
+                            error);
+    if (!arm_packed_relocs_)
+      return false;
+
+    LOG("%s: ARM packed relocations stored at %p\n",
+        __FUNCTION__,
+        arm_packed_relocs_);
+  }
+#endif
+
   LOG("%s: Load complete for %s\n", __FUNCTION__, base_name_);
   return true;
 }
 
 bool SharedLibrary::Relocate(LibraryList* lib_list,
                              Vector<LibraryView*>* dependencies,
                              Error* error) {
   // Apply relocations.
   LOG("%s: Applying relocations to %s\n", __FUNCTION__, base_name_);
 
   ElfRelocations relocations;
 
   if (!relocations.Init(&view_, error))
     return false;
 
   SharedLibraryResolver resolver(this, lib_list, dependencies);
   if (!relocations.ApplyAll(&symbols_, &resolver, error))
     return false;
 
+#ifdef __arm__
+  // If present, also apply ARM packed relocations.
+  if (arm_packed_relocs_ &&
+      !relocations.ApplyArmPackedRelocs(arm_packed_relocs_, error))
+    return false;

[rmcilroy, 2014/06/19 10:49:43]

I'm not sure the PackedRelocs really fits well in ElfRelocations since it is
doing the relocations in a completely different way.  How about moving all the
packed relocation processing to a separate class (ArmPackedRelocations) which
takes in the arm_packed_relocs_ and applies the relocations, e.g., here it would
be:
  if (arm_packed_relocs_) {
    ArmPackedRelocations packedRelocations;
    
    if (!packedRelocations.Init(&packed_relocations_, error)) {
       return false;
  
    if (!packedRelocations.ApplyAll(error))
     return false;	
  }

This would keep all the packed relocation processing in a single place, WDYT?

[simonb (inactive), 2014/06/23 14:51:32]

Addressed by moving ApplyArmPackedRelocs() inside of ApplyAll() and adding
RegisterArmPackedRelocs() as a way to indicate that there are packed relocations
to apply.  See if you like this better.

+#endif
+
   LOG("%s: Relocations applied for %s\n", __FUNCTION__, base_name_);
   return true;
 }
 
 const ELF::Sym* SharedLibrary::LookupSymbolEntry(const char* symbol_name) {
   return symbols_.LookupByName(symbol_name);
 }
 
 void* SharedLibrary::FindAddressForSymbol(const char* symbol_name) {
   return symbols_.LookupAddressByName(symbol_name, view_.load_bias());
@@ skipping 129 matching lines @@
     if (iter_.GetTag() == DT_NEEDED) {
       dep_name_ = symbols_->GetStringById(iter_.GetValue());
       iter_.GetNext();
       return true;
     }
   }
   return false;
 }
 
 }  // namespace crazy