{"id":217,"date":"2020-12-31T13:03:41","date_gmt":"2020-12-31T05:03:41","guid":{"rendered":"http:\/\/pareto.fun\/?p=217"},"modified":"2022-08-12T20:09:40","modified_gmt":"2022-08-12T12:09:40","slug":"android-linker%e8%a7%a3%e8%af%bb-2","status":"publish","type":"post","link":"http:\/\/pareto.fun\/?p=217","title":{"rendered":"android linker\u89e3\u8bfb\u2014\u20142"},"content":{"rendered":"\n

step 0\u9636\u6bb5\uff0c\u521b\u5efa\u4e00\u4e2a\u5217\u8868<\/h3>\n\n\n\n
  \/\/ Step 0: prepare.
  LoadTaskList load_tasks;
\u200b
  for (size_t i = 0; i < library_names_count; ++i) {
    const char* name = library_names[i];
    LD_LOG(kLogDlopen,\"[linker.cpp] step 1 ,so_name\",name);
\u200b
    load_tasks.push_back(LoadTask::create(name, start_with, ns, &readers_map));
  }
\u200b
  \/\/ If soinfos array is null allocate one on stack.
  \/\/ The array is needed in case of failure; for example
  \/\/ when library_names[] = {libone.so, libtwo.so} and libone.so
  \/\/ is loaded correctly but libtwo.so failed for some reason.
  \/\/ In this case libone.so should be unloaded on return.
  \/\/ See also implementation of failure_guard below.
\u200b
  if (soinfos == nullptr) {
    size_t soinfos_size = sizeof(soinfo*)*library_names_count;
    soinfos = reinterpret_cast<soinfo**>(alloca(soinfos_size));
    memset(soinfos, 0, soinfos_size);
  }
\u200b
  \/\/ list of libraries to link - see step 2.
  size_t soinfos_count = 0;
\u200b
  auto scope_guard = android::base::make_scope_guard([&]() {
    for (LoadTask* t : load_tasks) {
      LD_LOG(kLogDlopen,\"[linker.cpp] before call deleter %s\",t->get_name());
      LoadTask::deleter(t);
    }
  });
\u200b
  auto failure_guard = android::base::make_scope_guard([&]() {
    \/\/ Housekeeping
    soinfo_unload(soinfos, soinfos_count);
  });
\u200b
  ZipArchiveCache zip_archive_cache;
\u200b<\/pre>\n\n\n\n
\u6211\u4eec\u8ddf\u8e2a\u521b\u5efaLoadtask\u8fc7\u7a0b\u3002<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
\u8be5\u51fd\u6570\u8c03\u7528LoadTask\u7684\u91cd\u8f7d\u51fd\u6570\u3002<\/p>\n\n\n\n
  static LoadTask* create(const char* name,\n                          soinfo* needed_by,\n                          android_namespace_t* start_from,\n                          std::unordered_map<const soinfo*, ElfReader>* readers_map) {\n    LoadTask* ptr = TypeBasedAllocator<LoadTask>::alloc();\n    return new (ptr) LoadTask(name, needed_by, start_from, readers_map);\n  }<\/pre>\n\n\n\n
\u8be5\u51fd\u6570\u5b8c\u6210\u5404\u4e2a\u6210\u5458\u7684\u8d4b\u503c\uff0c\u7b80\u5355\u770b\u4e0b\u54ea\u4e9b\u6210\u5458\u88ab\u8d4b\u503c\uff0c\u540d\u79f0\uff0cneeded_by \uff0celf_reader_map_ , start_from.<\/p>\n\n\n\n
  LoadTask(const char* name,\n           soinfo* needed_by,\n           android_namespace_t* start_from,\n           std::unordered_map<const soinfo*, ElfReader>* readers_map)\n    : name_(name), needed_by_(needed_by), si_(nullptr),\n      fd_(-1), close_fd_(false), file_offset_(0), elf_readers_map_(readers_map),\n      is_dt_needed_(false), start_from_(start_from) {}<\/code><\/pre>\n\n\n\n
\u8ffd\u6eafneeded_by \u6765\u5386\u3002<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
\u67e5\u770b__builtin_return_address() \u7684\u8bf4\u660e , \u8fd4\u56de\u8c03\u7528\u51fd\u6570\u7684\u5730\u5740\uff0cg++\u7684\u5185\u5efa\u51fd\u6570 \uff0c\u53ef\u4ee5\u83b7\u53d6\u5230\u8c03\u7528\u51fd\u6570\u65f6\u7684ret\u5730\u5740\u3002<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
\u5728\u8be5\u51fd\u6570\u5c06\u5176\u8f6c\u6362\u4e3asoinfo \u3002<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
find_containing_library \u8fd4\u56de\u8c03\u7528\u51fd\u6570\u6240\u5728\u6a21\u5757\u7684soinfo<\/p>\n\n\n\n
soinfo* find_containing_library(const void* p) {\n  ElfW(Addr) address = reinterpret_cast<ElfW(Addr)>(p);\n  for (soinfo* si = solist_get_head(); si != nullptr; si = si->next) {\n    if (address >= si->base && address - si->base < si->size) {\n      return si;\n    }\n  }\n  return nullptr;\n}<\/pre>\n\n\n\n
Step 1 \u62d3\u5c55\u5217\u8868\u6765\u5305\u542b\u6240\u6709DT_NEEDED \u5e93<\/h3>\n\n\n\n
\u8be5\u6b65\u9aa4\u7ed9\u5217\u8868\u4e2d\u589e\u52a0so\u3002<\/p>\n\n\n\n
 \/\/ Step 1: expand the list of load_tasks to include
  \/\/ all DT_NEEDED libraries (do not load them just yet)
  for (size_t i = 0; i<load_tasks.size(); ++i) {
    LoadTask* task = load_tasks[i];
    soinfo* needed_by = task->get_needed_by();
    bool is_dt_needed = needed_by != nullptr && (needed_by != start_with || add_as_children);
    task->set_extinfo(is_dt_needed ? nullptr : extinfo);
    task->set_dt_needed(is_dt_needed);
\u200b
\/*
try to find the load.Note: start from the namespace that is stored in the LoadTask. This namespace is different from the current namespace when the LoadTask is for a transitive dependency and the lib that created the LoadTask is not found in the current namespace but in one of the linked namespace.
*\/
    if (!find_library_internal(const_cast<android_namespace_t*>(task->get_start_from()),
                               task,
                               &zip_archive_cache,
                               &load_tasks,
                               rtld_flags,
                               search_linked_namespaces || is_dt_needed)) {
      return false;
    }
\u200b
    soinfo* si = task->get_soinfo();
\u200b
    if (is_dt_needed) {
      needed_by->add_child(si);
\u200b
      if (si->is_linked()) {
        si->increment_ref_count();
      }
    }
\u200b
    \/\/ When ld_preloads is not null, the first
    \/\/ ld_preloads_count libs are in fact ld_preloads.
    if (ld_preloads != nullptr && soinfos_count < ld_preloads_count) {
      ld_preloads->push_back(si);
    }
\u200b
    if (soinfos_count < library_names_count) {
      soinfos[soinfos_count++] = si;
    }
  }
\u200b<\/pre>\n\n\n\n
\u7b5b\u9009\u8981\u8f7d\u5165\u7684load_list \u5e76\u89e3\u6790elf\u6587\u4ef6\u7684so<\/p>\n\n\n\n
  \/\/ Step 2: Load libraries in random order (see b\/24047022)
  LoadTaskList load_list;
  for (auto&& task : load_tasks) {
    soinfo* si = task->get_soinfo();
    auto pred = [&](const LoadTask* t) {
      return t->get_soinfo() == si;
    };
\u200b
    if (!si->is_linked() &&
        std::find_if(load_list.begin(), load_list.end(), pred) == load_list.end() ) {
      load_list.push_back(task);
    }
  }
  shuffle(&load_list);
\u200b
  for (auto&& task : load_list) {
      \/\/*** \u770b\u770b\u8fd9\u4e2aloda\u51fd\u6570
    if (!task->load()) {
      return false;
    }
  }<\/pre>\n\n\n\n
\u8fd9\u4e2aelf_reader \u5c31\u662f\u5bf9\u5e94so\u7528\u6765\u89e3\u6790elf\u6587\u4ef6\u7684\u3002<\/p>\n\n\n\n
  bool load() {
    ElfReader& elf_reader = get_elf_reader();
      \/\/\u5728elf_read.Load \u4e0b\u5b8c\u6210elf\u6587\u4ef6\u7a7a\u95f4\u7684\u5206\u914d\u548c\u89e3\u6790 \uff0c\u8fd8\u4e0d\u80fd\u7b97\u8f7d\u5165\u4e86so\u3002
    if (!elf_reader.Load(extinfo_)) {
      return false;
    }
    si_->base = elf_reader.load_start();
    si_->size = elf_reader.load_size();
    si_->set_mapped_by_caller(elf_reader.is_mapped_by_caller());
    si_->load_bias = elf_reader.load_bias();
    LD_LOG(kLogDlopen,\"[linker.cpp] Step2 load_bias %p \",si_->load_bias);
    si_->phnum = elf_reader.phdr_count();
    si_->phdr = elf_reader.loaded_phdr();
    return true;
  }<\/pre>\n\n\n\n
Step3 <\/h3>\n\n\n\n
Step3\u8fc7\u7a0b\u89e3\u6790ELF\u6587\u4ef6\u83b7\u53d6\u76f8\u5e94\u5b57\u6bb5\u7684\u503c<\/p>\n\n\n\n
\u9884\u8fde\u63a5\u6240\u6709DT_NEEDED \u5e93, \u903b\u8f91\u7b80\u5355\uff0c\u6ca1\u6709\u88ab\u8fde\u63a5\u8fc7\uff0c\u5219\u8c03\u7528prelink_image()\u3002<\/p>\n\n\n\n
  \/\/ Step 3: pre-link all DT_NEEDED libraries in breadth first order.
  for (auto&& task : load_tasks) {
    soinfo* si = task->get_soinfo();
    if (!si->is_linked() && !si->prelink_image()) {
      return false;
    }
  }<\/pre>\n\n\n\n
prelink_image\uff0c\u8bfb\u53d6\u5404\u7c7b\u578b\u7684\u6bb5 \uff0c \u4f9d\u6b21\u770b\u5168\u592a\u809d\u4e86 \uff0c \u540e\u671f\u5728\u8fd9\u91cc\u67e5\u5b57\u6bb5\u3002<\/p>\n\n\n\n
Step4<\/h3>\n\n\n\n
\u7565<\/p>\n\n\n\n
linkerStep5-linkerStep6<\/h1>\n\n\n\n
 \/\/ Step 5: link libraries that are not destined to this namespace.
  \/\/ Do this by recursively calling find_libraries on the namespace where the lib
  \/\/ was found during Step 1.
  for (auto&& task : load_tasks) {
    soinfo* si = task->get_soinfo();
    if (si->get_primary_namespace() != ns) {
      const char* name = task->get_name();
      if (find_libraries(si->get_primary_namespace(), task->get_needed_by(), &name, 1,
                         nullptr \/* soinfos *\/, nullptr \/* ld_preloads *\/, 0 \/* ld_preload_count *\/,
                         rtld_flags, nullptr \/* extinfo *\/, false \/* add_as_children *\/,
                         false \/* search_linked_namespaces *\/, readers_map, namespaces)) {
        \/\/ If this lib is directly needed by one of the libs in this namespace,
        \/\/ then increment the count
        soinfo* needed_by = task->get_needed_by();
        if (needed_by != nullptr && needed_by->get_primary_namespace() == ns && si->is_linked()) {
          si->increment_ref_count();
        }
      } else {
        return false;
      }
    }
  }
    \/\/\u8fde\u63a5\u8fd9\u4e2a\u547d\u540d\u7a7a\u95f4\u7684\u5e93\u6587\u4ef6
  \/\/ Step 6: link libraries in this namespace
  soinfo_list_t local_group;
  walk_dependencies_tree(
      (start_with != nullptr && add_as_children) ? &start_with : soinfos,
      (start_with != nullptr && add_as_children) ? 1 : soinfos_count,
      [&] (soinfo* si) {
    if (ns->is_accessible(si)) {
      local_group.push_back(si);
      return kWalkContinue;
    } else {
      return kWalkSkip;
    }
  });
  soinfo_list_t global_group = ns->get_global_group();
  bool linked = local_group.visit([&](soinfo* si) {
    if (!si->is_linked()) {
      LD_LOG(kLogDlopen,\"so %s is not linked , now try to link \",si->get_soname());
      if (!si->link_image(global_group, local_group, extinfo) ||
          !get_cfi_shadow()->AfterLoad(si, solist_get_head())) {
        return false;
      }
    }
\u200b
    return true;
  });
  if (linked) {
    local_group.for_each([](soinfo* si) {
      LD_LOG(kLogDlopen,\"travser local_group list %s\" , si->get_soname());
      if (!si->is_linked()) {
        si->set_linked();
      }
    });
\u200b
    failure_guard.Disable();
  }
\u200b
  return linked;<\/pre>\n\n\n\n
\u6d89\u53ca\u5230\u91cd\u5b9a\u4f4d\u7684\u955c\u50cf\u8fde\u63a5\u3002<\/p>\n\n\n\n
bool soinfo::link_image(const soinfo_list_t& global_group, const soinfo_list_t& local_group,
                        const android_dlextinfo* extinfo) {
\u200b
\u200b
\/\/ \u8fd9\u91cc\u4ec5\u4fdd\u7559\u4e86\u5927\u5bb6\u6bd4\u8f83\u719f\u6089\u7684\u7c7b\u578b\u3002\u5e38\u89c4\u90fd\u662frel\u3002
\u200b
#if defined(USE_RELA)
  if (rela_ != nullptr) {
    DEBUG(\"[ relocating %s ]\", get_realpath());
    if (!relocate(version_tracker,
            plain_reloc_iterator(rela_, rela_count_), global_group, local_group)) {
      return false;
    }
  }
  if (plt_rela_ != nullptr) {
    DEBUG(\"[ relocating %s plt ]\", get_realpath());
    if (!relocate(version_tracker,
            plain_reloc_iterator(plt_rela_, plt_rela_count_), global_group, local_group)) {
      return false;
    }
  }
#else
    \/\/\u628a\u91cd\u5fc3\u653e\u5728\u8fd9\u91cc 
    
  if ( != nullptr) {
    DEBUG(\"[ relocating %s ]\", get_realpath());
    if (!relocate(version_tracker,
            plain_reloc_iterator(rel_, rel_count_), global_group, local_group)) {
      return false;
    }
  }
  if (plt_rel_ != nullptr) {
    LD_LOG(kLogDlopen,\"[ relocating %s plt ]\", get_realpath());
    if (!relocate(version_tracker,
            plain_reloc_iterator(plt_rel_, plt_rel_count_), global_group, local_group)) {
      return false;
    }
  }
#endif
\u200b
\u200b<\/pre>\n\n\n\n
\u5728Step3\u4e2d\u627e\u8fd9rel_ \u548cplt_rel_ \u7684\u8d4b\u503c\uff0c\u5206\u522b\u4e3aDT_JMPREL \u548c DT_REL \u5bf9\u5e94.rel.plt \u548c.rel.dyn\u6bb5 \u3002<\/p>\n\n\n\n
      \/\/\u8be5\u8bb0\u5f55\u4fdd\u7559\u4ec5\u4e0e\u91cd\u5b9a\u4f4d\u76f8\u5173\u7684PLT\u8868\u7684\u5730\u5740
    \/* ...  *\/
      case DT_JMPREL:
#if defined(USE_RELA)
        plt_rela_ = reinterpret_cast<ElfW(Rela)*>(load_bias + d->d_un.d_ptr);
#else
        plt_rel_ = reinterpret_cast<ElfW(Rel)*>(load_bias + d->d_un.d_ptr);
#endif
        break;
        \/\/\u91cd\u5b9a\u4f4d\u76f8\u5173plt\u8868\u7684\u5927\u5c0f
      case DT_PLTRELSZ:
#if defined(USE_RELA)
        plt_rela_count_ = d->d_un.d_val \/ sizeof(ElfW(Rela));
#else
        plt_rel_count_ = d->d_un.d_val \/ sizeof(ElfW(Rel));
#endif
        break;
    \/* ...  *\/
      case DT_REL:
        rel_ = reinterpret_cast<ElfW(Rel)*>(load_bias + d->d_un.d_ptr);
        break;
\u200b
      case DT_RELSZ:
        rel_count_ = d->d_un.d_val \/ sizeof(ElfW(Rel));
        break;<\/pre>\n\n\n\n
\u53c2\u6570\u4e2d\u6709 plain_reloc_iterator \uff0c\u4f20\u5165rel\u7684\u8fed\u4ee3\u5668 \u3002<\/p>\n\n\n\n
relocate(version_tracker,plain_reloc_iterator(rel_, rel_count_), global_group, local_group) <\/pre>\n\n\n\n
Elf32_Rel\u7684\u7ed3\u6784\u4f53\u3002<\/p>\n\n\n\n
typedef struct
{
  Elf32_Addr    r_offset;       \/* Address *\/
  Elf32_Word    r_info;         \/* Relocation type and symbol index *\/
} Elf32_Rel;<\/pre>\n\n\n\n
\u5bf9\u4e8eDT_REL,\u8be5\u51fd\u6570\u83b7\u53d6\u5230rel.dyn \u6bb5, \u5230\u8fd9\u91cc\u91cd\u5b9a\u4f4d\u7684\u5185\u5bb9\u5c31\u5f88\u7b80\u5355\u4e86\u3002<\/p>\n\n\n\n
template<typename ElfRelIteratorT>
bool soinfo::relocate(const VersionTracker& version_tracker, ElfRelIteratorT&& rel_iterator,
                      const soinfo_list_t& global_group, const soinfo_list_t& local_group){
  for (size_t idx = 0; rel_iterator.has_next(); ++idx) {
    const auto rel = rel_iterator.next();
    if (rel == nullptr) {
      return false;
    }
    \/\/ \u83b7\u53d6rel \u7684\u7c7b\u578b \uff0c \u548c\u7b26\u53f7\u7d22\u5f15
    ElfW(Word) type = ELFW(R_TYPE)(rel->r_info);
    ElfW(Word) sym = ELFW(R_SYM)(rel->r_info);
    \/\/rel \u5185\u5b58\u5730\u5740
    ElfW(Addr) reloc = static_cast<ElfW(Addr)>(rel->r_offset + load_bias);
    ElfW(Addr) sym_addr = 0;
    const char* sym_name = nullptr;
      
    ElfW(Addr) addend = get_addend(rel, reloc);
\u200b
    DEBUG(\"Processing \\\"%s\\\" relocation at index %zd\", get_realpath(), idx);
    if (type == R_GENERIC_NONE) {
      continue;
    }
\u200b
    const ElfW(Sym)* s = nullptr;
    soinfo* lsi = nullptr;
\u200b
    if (sym != 0) {
      \/\/\u4ece\u7b26\u53f7\u8868\u4e2d\u83b7\u53d6\u5230\u7b26\u53f7\u540d\u79f0
      sym_name = get_string(symtab_[sym].st_name);
      const version_info* vi = nullptr;
\u200b
      if (!lookup_version_info(version_tracker, sym, sym_name, &vi)) {
        return false;
      }
    \/\/ \u8fd9\u4e2a\u51fd\u6570\u53ef\u4ee5\u89e3\u91caLD_PRELOAD \u5bf9\u4e8e\u76f8\u540c\u7b26\u53f7\u540d\u79f0linker\u7684\u5904\u7406\u65b9\u5f0f\u3002
      if (!soinfo_do_lookup(this, sym_name, vi, &lsi, global_group, local_group, &s)) {
        return false;
      }
\u200b
      if (s == nullptr) {
        \/\/ We only allow an undefined symbol if this is a weak reference...
        s = &symtab_[sym];
        if (ELF_ST_BIND(s->st_info) != STB_WEAK) {
          DL_ERR(\"cannot locate symbol \\\"%s\\\" referenced by \\\"%s\\\"...\", sym_name, get_realpath());
          return false;
        }
\u200b
\u200b
#elif defined(__arm__)
          case R_ARM_ABS32:
\u200b
#endif
            \/*
             * The sym_addr was initialized to be zero above, or the relocation
             * code below does not care about value of sym_addr.
             * No need to do anything.
             *\/
            break;
#if defined(__x86_64__)
          case R_X86_64_PC32:
            sym_addr = reloc;
            break;
#elif defined(__i386__)
          case R_386_PC32:
            sym_addr = reloc;
            break;
#endif
          default:
            DL_ERR(\"unknown weak reloc type %d @ %p (%zu)\", type, rel, idx);
            return false;
        }
      } else { \/\/ We got a definition.
    \/*
    .......
    *\/
      }
      count_relocation(kRelocSymbol);
    }
    \/\/ \u91cd\u5b9a\u4f4d\u8fd0\u7b97\u3002
    switch (type) {
      case R_GENERIC_JUMP_SLOT:
        count_relocation(kRelocAbsolute);
        MARK(rel->r_offset);
        TRACE_TYPE(RELO, \"RELO JMP_SLOT %16p <- %16p %s\\n\",
                   reinterpret_cast<void*>(reloc),
                   reinterpret_cast<void*>(sym_addr + addend), sym_name);
\u200b
        *reinterpret_cast<ElfW(Addr)*>(reloc) = (sym_addr + addend);
        break;
      case R_GENERIC_GLOB_DAT:
        count_relocation(kRelocAbsolute);
        MARK(rel->r_offset);
        TRACE_TYPE(RELO, \"RELO GLOB_DAT %16p <- %16p %s\\n\",
                   reinterpret_cast<void*>(reloc),
                   reinterpret_cast<void*>(sym_addr + addend), sym_name);
        *reinterpret_cast<ElfW(Addr)*>(reloc) = (sym_addr + addend);
        break;
      case R_GENERIC_RELATIVE:
        count_relocation(kRelocRelative);
        MARK(rel->r_offset);
        TRACE_TYPE(RELO, \"RELO RELATIVE %16p <- %16p\\n\",
                   reinterpret_cast<void*>(reloc),
                   reinterpret_cast<void*>(load_bias + addend));
        *reinterpret_cast<ElfW(Addr)*>(reloc) = (load_bias + addend);
        break;
      case R_GENERIC_IRELATIVE:
        count_relocation(kRelocRelative);
        MARK(rel->r_offset);
        TRACE_TYPE(RELO, \"RELO IRELATIVE %16p <- %16p\\n\",
                    reinterpret_cast<void*>(reloc),
                    reinterpret_cast<void*>(load_bias + addend));
        {
        \/* ... *\/
        \/* ... *\/
          *reinterpret_cast<ElfW(Addr)*>(reloc) = ifunc_addr;
        }
        break;
\u200b
\u200b
#elif defined(__arm__)
      case R_ARM_ABS32:
        count_relocation(kRelocAbsolute);
        MARK(rel->r_offset);
        TRACE_TYPE(RELO, \"RELO ABS %08x <- %08x %s\", reloc, sym_addr, sym_name);
        *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr;
        break;
      case R_ARM_REL32:
        count_relocation(kRelocRelative);
        MARK(rel->r_offset);
        TRACE_TYPE(RELO, \"RELO REL32 %08x <- %08x - %08x %s\",
                   reloc, sym_addr, rel->r_offset, sym_name);
        *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr - rel->r_offset;
        break;
      case R_ARM_COPY:
        \/*
         * ET_EXEC is not supported so this should not happen.
         *
         * http:\/\/infocenter.arm.com\/help\/topic\/com.arm.doc.ihi0044d\/IHI0044D_aaelf.pdf
         *
         * Section 4.6.1.10 \"Dynamic relocations\"
         * R_ARM_COPY may only appear in executable objects where e_type is
         * set to ET_EXEC.
         *\/
        DL_ERR(\"%s R_ARM_COPY relocations are not supported\", get_realpath());
        return false;
#endif
      default:
        DL_ERR(\"unknown reloc type %d @ %p (%zu)\", type, rel, idx);
        return false;
    }
  }
  return true;
}<\/pre>\n\n\n\n