Search for loaded modules recursively in all system library sub-directories on Android

[ovyalov]

Summary

Search for loaded modules recursively in all system lib sub-directories on Android.
Android native application may load modules from such directories: /system/lib, /system/lib/egl (libEGL_emulation.so,..), /system/lib/hw (gralloc.goldfish.so).

[labath]

How does the dynamic linker find the shared libraries to load? Does it also
perform this recursive directory search? Seems like an odd design choice...

[ovyalov]

In D8338#140925, @labath wrote:

How does the dynamic linker find the shared libraries to load? Does it also
perform this recursive directory search?

Number of subdirectories is pretty small and I believe it's acceptable strategy to traverse all child directories in order to find a match - if new library subdirectories will be added in future such logic will still work without need to change.

Seems like an odd design choice...

What approach would you suggest here?

[tberghammer]

Please abandon it as D8547 will fix this issue

source/Host/android/HostInfoAndroid.cpp

 //===-- HostInfoAndroid.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/android/HostInfoAndroid.h"
 #include "lldb/Host/linux/HostInfoLinux.h"
-#include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/StringRef.h"
+
+#include <sstream>
+#include <string>
+#include <vector>
 
 using namespace lldb_private;
 using namespace llvm;
 
+namespace {
+
+using StringVector = std::vector<std::string>;
+
+FileSpec::EnumerateDirectoryResult
+EnumerateDirectoryCallback(void *baton, FileSpec::FileType file_type, const FileSpec &spec);
+
+void
+EnumerateSubDirs(const char* root_dir, StringVector &paths)
+{
+    paths.push_back(root_dir);
+    FileSpec::EnumerateDirectory(root_dir,
+                                 true,
+                                 false,
+                                 false,
+                                 EnumerateDirectoryCallback,
+                                 &paths);
+}
+
+FileSpec::EnumerateDirectoryResult
+EnumerateDirectoryCallback(void *baton, FileSpec::FileType file_type, const FileSpec &spec)
+{
+    StringVector* paths = reinterpret_cast<StringVector*>(baton);
+    const auto file_path = spec.GetPath();
+    if (file_type == FileSpec::eFileTypeDirectory)
+        EnumerateSubDirs(file_path.c_str(), *paths);
+
+    return FileSpec::eEnumerateDirectoryResultNext;
+}
+
+}  // namespace
+
 void
 HostInfoAndroid::ComputeHostArchitectureSupport(ArchSpec &arch_32, ArchSpec &arch_64)
 {
     HostInfoLinux::ComputeHostArchitectureSupport(arch_32, arch_64);
 
     if (arch_32.IsValid())
     {
         arch_32.GetTriple().setEnvironment(llvm::Triple::Android);

 HostInfoAndroid::GetDefaultShell()
 {
     return FileSpec("/system/bin/sh", false);
 }
 
 FileSpec
 HostInfoAndroid::ResolveLibraryPath(const std::string& module_path, const ArchSpec& arch)
 {
-    static const char* const ld_library_path_separator = ":";
+    static const char ld_library_path_separator = ':';
     static const char* const default_lib32_path[] = {
         "/vendor/lib",
         "/system/lib",
         nullptr
     };
     static const char* const default_lib64_path[] = {
         "/vendor/lib64",
         "/system/lib64",
         nullptr
     };
 
     if (module_path.empty() || module_path[0] == '/')
         return FileSpec(module_path.c_str(), true);
 
-    SmallVector<StringRef, 4> ld_paths;
+    StringVector ld_paths;
 
     if (const char* ld_library_path = ::getenv("LD_LIBRARY_PATH"))
-        StringRef(ld_library_path).split(ld_paths, StringRef(ld_library_path_separator), -1, false);
+    {
+        std::istringstream ld_lib_stream(ld_library_path);
+        std::string lib_path;
+        while (std::getline(ld_lib_stream, lib_path, ld_library_path_separator))
+            ld_paths.push_back(lib_path);
+    }
 
     const char* const* default_lib_path = nullptr;
     switch (arch.GetAddressByteSize())
     {
         case 4:
             default_lib_path = default_lib32_path;
             break;
         case 8:
             default_lib_path = default_lib64_path;
             break;
         default:
             assert(false && "Unknown address byte size");
             return FileSpec();
     }
 
     for(const char* const* it = default_lib_path; *it; ++it)
-        ld_paths.push_back(StringRef(*it));
+        EnumerateSubDirs(*it, ld_paths);
 
-    for (const StringRef& path : ld_paths)
+    for (const auto& path : ld_paths)
     {
-        FileSpec file_candidate(path.str().c_str(), true);
+        FileSpec file_candidate(path.c_str(), true);
         file_candidate.AppendPathComponent(module_path.c_str());
 
         if (file_candidate.Exists())
             return file_candidate;
     }
 
     return FileSpec();
 }