Android Linker

__linker_init:
  ElfW(Addr) linker_addr = args.getauxval(AT_BASE);
  ElfW(Addr) entry_point = args.getauxval(AT_ENTRY);
  if (reinterpret_cast<ElfW(Addr)>(&_start) == entry_point):
    __libc_format_fd(STDOUT_FILENO,
                   "This is %s, the helper program\n",
                   args.argv[0]);
    exit(0)
  linker_so.base = linker_addr;
  linker_so.size = phdr_table_get_load_size(phdr, elf_hdr->e_phnum);
  /* load_bias 是 so 中的 vadd 与实际地址的偏移量 */
  linker_so.load_bias = get_elf_exec_load_bias(elf_hdr);
  linker_so.dynamic = nullptr;
  linker_so.phdr = phdr;
  linker_so.phnum = elf_hdr->e_phnum;
  linker_so.set_linker_flag();

get_elf_exec_load_bias:
  ElfW(Addr) offset = elf->e_phoff;
  const ElfW(Phdr)* phdr_table =
    reinterpret_cast<const ElfW(Phdr)*>(reinterpret_cast<uintptr_t>(elf) + offset);
  const ElfW(Phdr)* phdr_end = phdr_table + elf->e_phnum;

  for (const ElfW(Phdr)* phdr = phdr_table; phdr < phdr_end; phdr++):
    if (phdr->p_type == PT_LOAD):
      // elf_hdr + (phdr->p_offset) 是这个 segment 被映射的实际地址,
      // 与p_vaddr 的差即是 load_bias, 这一点只能第一个 PT_LOAD 有效:
      // 因为 elf_hdr 实际就是第一个 PT_LAOD 实际的映射地址, 而且它的
      // phdr->p_offset 为 0
      return reinterpret_cast<ElfW(Addr)>(elf) + phdr->p_offset - phdr->p_vaddr;

link_image:
  // relocate rel{a}.dyn
  relocate(version_tracker, plain_reloc_iterator(rela_, rela_count_), global_group, local_group)
  // relocate rel{a}.plt
  relocate(version_tracker, plain_reloc_iterator(plt_rela_, plt_rela_count_), global_group, local_group)
  // 参考 GNU_RELRO
  protect_relro()

plain_reloc_iterator:
  /* plain_reloc_iterator 用来遍历 {plt_}rel{a}_ (即 .rel{a}.{dyn,plt}) */
  #if defined(USE_RELA)
    typedef ElfW(Rela) rel_t;
  #else
    typedef ElfW(Rel) rel_t;
  #endif

  plain_reloc_iterator(rel_t* rel_array, size_t count)
    : begin_(rel_array), end_(begin_ + count), current_(begin_) {}

  rel_t* next()
    return current_++;

relocate:
  /* 遍历 .rel{a}.plt */
  for (size_t idx = 0; rel_iterator.has_next(); ++idx):
    // rel->r_info 包含了 relocation type 和 sym index
    // rel->r_offset 指示了需要 patch 的 got.plt 的位置
    ElfW(Word) type = ELFW(R_TYPE)(rel->r_info);
    ElfW(Word) sym = ELFW(R_SYM)(rel->r_info);

    ElfW(Addr) reloc = static_cast<ElfW(Addr)>(rel->r_offset + load_bias);
    ElfW(Addr) sym_addr = 0;
    const char* sym_name = nullptr;
    /* rel 和 rela 获得 addend 方式不同: rela 的 addend 直接保存在
     * rel->r_addend, 而 rel 的 addend 保存在 *relc 处 */
    ElfW(Addr) addend = get_addend(rel, reloc);

    /* relocate 时, 若 sym 不为空, 需要从其它地方 (so 或 executable)
     * 中查找 sym 的地址来 patch, 若 sym 为空, 则不需要查找, 直接根据
     * load_bias 之类的进行 patch 即可 */
    if (sym != 0):
      sym_name = get_string(symtab_[sym].st_name);
      soinfo_do_lookup(this, sym_name, vi, &lsi, global_group, local_group, &s)
      // sym_name 在所有的 so, executable 中都没有找到, undefined
      if (s == nullptr):
        s = &symtab_[sym];
        // 允许 undefined 的 weak symbol 存在, 参考 `weak_symbol`
        if (ELF_ST_BIND(s->st_info) != STB_WEAK):
          return false;
      // 找到一个 symbol: lsi 是 symbol 所在的 so, s 是 symbol 对应的
      // dynsym entry
      sym_addr = lsi->resolve_symbol_address(s);

    switch type:
      // R_GENERIC_JUMP_SLOT 是最常用的 relocation type, 例如调用 printf
      case R_GENERIC_JUMP_SLOT:
        *reinterpret_cast<ElfW(Addr)*>(reloc) = (sym_addr + addend);

      // R_GENERIC_GLOB_DAT 用来访问全局变量, 例如 extern int x
      case R_GENERIC_GLOB_DAT:
        *reinterpret_cast<ElfW(Addr)*>(reloc) = (sym_addr + addend);

      // 访问 pc relative: 例如访问当前 so 中的全局变量时会使用这种 relocation
      // [[file:PIC_PIE.org::*pic/no-pic%20%E7%9A%84%E5%8C%BA%E5%88%AB][pic/no-pic 的区别]]
      case R_GENERIC_RELATIVE:
        *reinterpret_cast<ElfW(Addr)*>(reloc) = (load_bias + addend);
      // ...

resolve_symbol_address:
  // st_value 是 dysym 的成员
  return static_cast<ElfW(Addr)>(s->st_value + load_bias);

__libc_init_main_thread:
  static pthread_internal_t main_thread;
  // pthread_create 通过 clone 时指定的 tls 参数来设置 tls
  __set_tls(main_thread.tls);
  main_thread.tid = __set_tid_address(&main_thread.tid);
  // 通过 pthread_create 创建的线程也需要调用 __init_tls
  __init_tls(&main_thread);
    thread->tls[TLS_SLOT_SELF] = thread->tls;
    thread->tls[TLS_SLOT_THREAD_ID] = thread;
  __init_alternate_signal_stack(&main_thread);

__libc_init_globals:
  __libc_auxv = args.auxv;
  __libc_globals.mutate([&args](libc_globals* globals) {
    /* 给 __libc_globals->vdso[] 赋值. 相当于以手工的方式完成了对 vdso
     * 中定义的函数 (gettimeofday, clock_gettime) 的重定位, 不仅仅
     * linker init, 应用自己的 __libc_preinit 也需要通过相同的方式给
     * vdso 赋值*/
    __libc_init_vdso(globals, args);
    __libc_init_setjmp_cookie(globals, args);
  });

call_constructors:
  // 对 linker 来说, 当前还没有 children
  get_children().for_each([] (soinfo* si) {
    si->call_constructors();
  });

  // 调用 init_func_, 类型为 linker_function_t (void (*T) ())
  call_function("DT_INIT", init_func_);
  // .init_array 是多个函数指针组成的数组, c++ 的 ctor 都是通过
  // .init_array 实现的
  call_array("DT_INIT_ARRAY", init_array_, init_array_count_, false);

__linker_init_post_relocation:
  __libc_init_AT_SECURE(args);
  __system_properties_init();
  debuggerd_init();
  const char* LD_DEBUG = getenv("LD_DEBUG");
  if (LD_DEBUG != nullptr):
    g_ld_debug_verbosity = atoi(LD_DEBUG);

  if (!getauxval(AT_SECURE)):
    ldpath_env = getenv("LD_LIBRARY_PATH");
    ldpreload_env = getenv("LD_PRELOAD");

  char* executable_path = get_executable_path();
  // executable 为 RTLD_GLOBAL
  soinfo* si = soinfo_alloc(&g_default_namespace, executable_path, &file_stat, 0, RTLD_GLOBAL);

  si->phdr = reinterpret_cast<ElfW(Phdr)*>(args.getauxval(AT_PHDR));
  si->phnum = args.getauxval(AT_PHNUM);
  si->entry = args.getauxval(AT_ENTRY);

  for (size_t i = 0; i < si->phnum; ++i):
    if (si->phdr[i].p_type == PT_PHDR):
      si->load_bias = reinterpret_cast<ElfW(Addr)>(si->phdr) - si->phdr[i].p_vaddr;
      si->base = reinterpret_cast<ElfW(Addr)>(si->phdr) - si->phdr[i].p_offset;
      break;

  ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(si->base);

  parse_LD_LIBRARY_PATH(ldpath_env);
  parse_LD_PRELOAD(ldpreload_env);

  for (const auto& ld_preload_name : g_ld_preload_names):
    needed_library_name_list.push_back(ld_preload_name.c_str());
    ++needed_libraries_count;
    ++ld_preloads_count;

  for_each_dt_needed(si, [&](const char* name):
    needed_library_name_list.push_back(name);
    ++needed_libraries_count;

  if (needed_libraries_count > 0):
    /* 1. 加载 exectuable 时 DT_NEEDED 引入的 so 默认为 RTLD_GLOBAL
    *  2. add_as_children 为 true, 与 dlopen 时不同 */
    find_libraries(&g_default_namespace, si, needed_library_names, needed_libraries_count,
                   nullptr, &g_ld_preloads, ld_preloads_count, RTLD_GLOBAL, nullptr,
                   /* add_as_children */ true))
  else if (needed_libraries_count == 0):
    si->link_image(g_empty_list, soinfo::soinfo_list_t::make_list(si), nullptr))
  /* vdso */
  add_vdso(args);
  si->call_constructors();
  return si->entry;

find_libraries:
  for (size_t i = 0; i < library_names_count; ++i):
    const char* name = library_names[i];
    load_tasks.push_back(LoadTask::create(name, start_with, &readers_map));

  /* step 1, expand load_tasks to include all DT_NEEDED libraries */

  for (size_t i = 0; i<load_tasks.size(); ++i):
    LoadTask* task = load_tasks[i];
    soinfo* needed_by = task->get_needed_by();
    find_library_internal(ns, task, &zip_archive_cache, &load_tasks, rtld_flags)

  /* step 2, load libraries in random order */
  shuffle(&load_list);
  for (auto&& task : load_list):
    task->load()

  /* 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()) {}

  /* step 4, link libraries. */
  soinfo::soinfo_list_t local_group;
  walk_dependencies_tree(
      /* 若 add_as_children 为 true, 表示非 dlopen 的情况, walk_dependencies_tree 的 root 为 start_with
       * 若 add_as_children 为 false, 表示 dlopen, 加载的 so 形成 disjoint tree, root 为 soinfos, 而不是 start_with */
      (start_with != nullptr && add_as_children) ? &start_with : soinfos,
      (start_with != nullptr && add_as_children) ? 1 : soinfos_count,
      [&] (soinfo* si) {
        local_group.push_back(si);
      });

  local_group.visit([&](soinfo* si) {
      if (!si->is_linked()) {
        if (!si->link_image(global_group, local_group, extinfo)) {
          return false;
        }
      }
      return true;
    });

LoadTask::load:
  /* elf_reader.Load 会 mmap so 中的 PTLOAD segments */
  elf_reader.Load(extinfo_)
  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();
  si_->phnum = elf_reader.phdr_count();
  si_->phdr = elf_reader.loaded_phdr();

ElfReader::Load:
  ReserveAddressSpace(extinfo)
  LoadSegments()
  FindPhdr()

void* dlopen(const char* filename, int flags):
  void* caller_addr = __builtin_return_address(0);
  dlopen_ext(filename, flags, nullptr, caller_addr);
    do_dlopen(filename, flags, extinfo, caller_addr);

do_dlopen:
  soinfo* const caller = find_containing_library(caller_addr);
  android_namespace_t* ns = get_caller_namespace(caller);
    caller != nullptr ? caller->get_primary_namespace() : g_anonymous_namespace;
  /* 通过 system.loadLibrary() 发起的 dlopen 调用需要使用
   * classloader-namepsace, 指定在 extinfo 中 */
  if ((extinfo->flags & ANDROID_DLEXT_USE_NAMESPACE) != 0):
    ns = extinfo->library_namespace;

  /* dlopen 时指定的 flags (例如 RTLD_GLOBAL) 会影响因为它的 DT_NEEDED
   * 而加载的其它的 so 也使用相同的 flag */
  soinfo* si = find_library(ns, name, flags, extinfo, caller);
    /* find_library 会调用 find_libraries, 但 add_as_children 为
     * false, 则 dlopen load 的 so 并不会挂在 dependencies tree 中 (但
     * 还在 soinfo list), 这就导致了 dlopen 的 so 无法通过
     * walk_dependencies_tree 找到 (例如 link_image)*/
    find_libraries()
      // ...
      // dlopen 时 laod_tasks 初始只有一项, 即要 dlopen 的 so, start_with 为调用 dlopen
      // 的代码所在的 so
      for (size_t i = 0; i<load_tasks.size(); ++i):
        /* 初始时 load_tasks 中的 task->get_needed_by 均为 start_with  */
        soinfo* needed_by = task->get_needed_by();
        /* needed_by != start_with 的判断会导致 dlopen 最终会形成一棵
         * disjoint tree: 它的根是 load_tasks[0], 且 load_tasks[0] 并没
         * 有加到 start_with 所在的树中 */
        bool is_dt_needed = needed_by != nullptr && (needed_by != start_with || add_as_children);
        find_library_internal()
        if (is_dt_needed):
          needed_by->add_child(si);
        // ...

  si->call_constructors();
  return si->to_handle();

dlsym:
  void* caller_addr = __builtin_return_address(0);
  soinfo* caller = find_containing_library(caller_addr);
  android_namespace_t* ns = get_caller_namespace(caller);
  if (handle == RTLD_DEFAULT || handle == RTLD_NEXT):
    sym = dlsym_linear_lookup(ns, sym_name, vi, &found, caller, handle);
  else:
    soinfo* si = soinfo_from_handle(handle);
    sym = dlsym_handle_lookup(si, &found, sym_name, vi);

  if ((bind == STB_GLOBAL || bind == STB_WEAK) && sym->st_shndx != 0):
    *symbol = reinterpret_cast<void*>(found->resolve_symbol_address(sym));
    return true;
  return false;

dlsym_linear_lookup:
  /* 若 handle 为 RTLD_DEFAULT 或 RTLD_NEXT, 则进行线性查找, 即按照 so
   * 被加载的顺序还查找 */
  auto& soinfo_list = ns->soinfo_list();
  auto start = soinfo_list.begin();

  if (handle == RTLD_NEXT):
    auto it = soinfo_list.find(caller);
    /* RTLD_NEXT 是一个特殊的 handle: 从它的 `下一个` so 开始查找, `下
     * 一个` 在这里实际就是 so 被加载的顺序 (BFS)*/
    start = ++it;
  /* 若 RTLD_DEFAULT, 则从第一个 so 开始查找 */
  for (auto it = start, end = soinfo_list.end(); it != end; ++it):
    soinfo* si = *it;
    if ((si->get_rtld_flags() & RTLD_GLOBAL) == 0):
      continue;
    if (si->find_symbol_by_name(symbol_name, vi, &s)):
      *found = si
      break

dlsym_handle_lookup:
  /* root 为 handle 代表的 soinfo */
  walk_dependencies_tree(&root, 1, [&](soinfo* current_soinfo) {
    if (!current_soinfo->find_symbol_by_name(symbol_name, vi, &result)):
      result = nullptr;
      return false;

    if (result != nullptr):
      *found = current_soinfo;
      return false;
    }

struct android_namespace_t {
  const char* name_;
  bool is_isolated_;
  std::vector<std::string> ld_library_paths_;
  std::vector<std::string> default_library_paths_;
  std::vector<std::string> permitted_paths_;
  soinfo::soinfo_list_t soinfo_list_;
}

JNI_CreateJavaVM:
  android::InitializeNativeLoader();
    g_namespaces->Initialize();
      /* 读取 /system/etc/public.libraries.txt */
      ReadConfig(public_native_libraries_system_config, &sonames)
      /* 确保 public_libraries_ 都已经被 load 到 g_default_namespace,
       * 后面会用到这一点 */
      for (const auto& soname : sonames):
        dlopen(soname.c_str(), RTLD_NOW | RTLD_NODELETE);
      public_libraries_ = base::Join(sonames, ':');

PathClassLoaderFactory:createClassLoader (librarySearchPath, libraryPermittedPath):
  /* librarySearchPath 一般是 /data/app/xxx/lib 这种形式,
   * libraryPermittedPath 一般是 /data */

  /* 创建出来的 namespace 会与 classloader 绑定在一起 */
  createClassloaderNamespace(pathClassloader,
                               librarySearchPath,
                               libraryPermittedPath,
                               isNamespaceShared);

    g_namespaces->Create(env,class_loader, is_shared, library_path, permitted_path);

android_namespace_t* Create(JNIEnv* env,
                            jobject class_loader,
                            bool is_shared,
                            jstring java_library_path,
                            jstring java_permitted_path):

  /* init g_public_namespace */
  !initialized_ && !InitPublicNamespace(library_path.c_str())



InitPublicNamespace(library_path.c_str():
    /* public_libraries_ 保存在 /system/etc/public.libraries.txt */
    android_init_namespaces(public_libraries_.c_str(), library_path)
      init_namespaces(public_ns_sonames, anon_ns_library_path)
        for (const auto& soname : sonames):
          /* 前面 InitializeNativeLoader 可以确保 public_libraries_ 都
           * 已经被 load 到 g_default_namespace 中了 */
          find_loaded_library_by_soname(&g_default_namespace, soname.c_str(), &candidate);
          g_public_namespace.push_back(candidate);
        /* 在这里初始化了 g_anonymous_namespace, 可见它的 library_path
         * 是 /dat/app/xxx/lib, 它会从 g_default_namespace copy 那些已
         * 经 load 进来的 GLOBAL 的 so (参考 create_namespace) */
        anon_ns = create_namespace(nullptr, "(anonymous)", nullptr, anon_ns_library_path, ANDROID_NAMESPACE_TYPE_REGULAR, nullptr, &g_default_namespace);

find_library:
  find_libraries(ns, needed_by, &name, 1, &si, nullptr, 0, rtld_flags, extinfo, /* add_as_children */ false)
    // ...
    find_library_internal(ns, task, &zip_archive_cache, &load_tasks, rtld_flags)
    /* 由于 ns 创建时从 parent copy 了一批 soinfo, 所以这里有可能直接
     * 返回前面已经加载过的 so (可能是从 parent copy 过来的) */
    if (find_loaded_library_by_soname(ns, task->get_name(), &candidate)):
      task->set_soinfo(candidate);
      return true;

    // 是否属于 g_public_namespace
    if (ns != &g_default_namespace):
      candidate = g_public_namespace.find_if([&](soinfo* si) {
          return strcmp(task->get_name(), si->get_soname()) == 0;
        });

      if (candidate != nullptr):
        ns->add_soinfo(candidate);
        task->set_soinfo(candidate);
        return true;

    load_library(ns, task, zip_archive_cache, load_tasks, rtld_flags)
      open_library(ns, zip_archive_cache, name, needed_by, &file_offset, &realpath)
      /* open_library 找到这个 so, 但不是 is_accessible, 例如通过绝对
       * 路径指定了一个 so, 但 so 并不在 permitted_paths 中 */
      if (!ns->is_accessible(realpath)):
        return false;
      // ...