[lldb][Android] Add platform.plugin.remote-android.package-name

[splhack]

Summary

When LLDB fails to pull file from a package directory due to security
constraint, user needs to set the package name to
'platform.plugin.remote-android.run-as' property to run shell commands
as the package user. (e.g. to get file with 'cat' and 'dd').

https://cs.android.com/android/platform/superproject/+/master:
system/core/run-as/run-as.cpp;l=39-61;
drc=4a77a84a55522a3b122f9c63ef0d0b8a6a131627

This supersedes D152494
Depends on D152855

[splhack]

rebase onto D152855

[splhack]

remove 'Depends on' from commit message

[splhack]

rebase

[splhack]

Fixed diff dependencies in order to fix CI
https://reviews.llvm.org/B238946

[clayborg]

I am wondering if the current proposed setting name "platform.plugin.remote-android.run-as" should actually be "platform.plugin.remote-android. package-name" to be a bit more clear. Not sure if we can use the package name in other places?

[bulbazord]

What happens if you do run-as with an empty package name?
I'm also not tied to the name "platform.plugin.remote-android.run-as" if others don't like it. platform.plugin.remote-android.package-name is fine too.

[splhack]

@clayborg

platform.plugin.remote-android.package-name

sure, sounds good. will update.

@bulbazord

What happens if you do run-as with an empty package name?

$ adb shell "run-as '' ls"; echo $?
run-as: unknown package:
1

which is the same as when specify non-existing package.

$ adb shell "run-as 'unknown' ls"; echo $?
run-as: unknown package: unknown
1

[splhack]

Rename it to platform.plugin.remote-android.package-name

[splhack]

update commit message

[clayborg]

lgtm now!

lldb/source/Plugins/Platform/Android/CMakeLists.txt

+lldb_tablegen(PlatformAndroidProperties.inc -gen-lldb-property-defs
+  SOURCE PlatformAndroidProperties.td
+  TARGET LLDBPluginPlatformAndroidPropertiesGen)
+
+lldb_tablegen(PlatformAndroidPropertiesEnum.inc -gen-lldb-property-enum-defs
+  SOURCE PlatformAndroidProperties.td
+  TARGET LLDBPluginPlatformAndroidPropertiesEnumGen)
+
 add_lldb_library(lldbPluginPlatformAndroid PLUGIN
   AdbClient.cpp
   PlatformAndroid.cpp
   PlatformAndroidRemoteGDBServer.cpp
 
   LINK_LIBS
     lldbCore
     lldbHost
     lldbPluginPlatformLinux
     lldbPluginPlatformGDB
   LINK_COMPONENTS
     Support
   )
+
+add_dependencies(lldbPluginPlatformAndroid
+  LLDBPluginPlatformAndroidPropertiesGen
+  LLDBPluginPlatformAndroidPropertiesEnumGen)

lldb/source/Plugins/Platform/Android/PlatformAndroid.h

public:
 
   static void Initialize();
 
   static void Terminate();
 
   // lldb_private::PluginInterface functions
   static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
 
+  static void DebuggerInitialize(lldb_private::Debugger &debugger);
+
   static llvm::StringRef GetPluginNameStatic(bool is_host) {
     return is_host ? Platform::GetHostPlatformName() : "remote-android";
   }
 
   static llvm::StringRef GetPluginDescriptionStatic(bool is_host);
 
   llvm::StringRef GetPluginName() override {
     return GetPluginNameStatic(IsHost());
Status DownloadSymbolFile(const lldb::ModuleSP &module_sp,
                             const FileSpec &dst_file_spec) override;
 
   llvm::StringRef
   GetLibdlFunctionDeclarations(lldb_private::Process *process) override;
 
   typedef std::unique_ptr<AdbClient> AdbClientSP;
   virtual AdbClientSP GetAdbClient();
 
+  virtual llvm::StringRef GetPropertyRunAs();
+
+  std::string GetRunAs();
+
 private:
   AdbClient::SyncService *GetSyncService(Status &error);
 
   std::unique_ptr<AdbClient::SyncService> m_adb_sync_svc;
   std::string m_device_id;
   uint32_t m_sdk_version;
 };
 
-} // namespace platofor_android
+} // namespace platform_android
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_ANDROID_PLATFORMANDROID_H

lldb/source/Plugins/Platform/Android/PlatformAndroid.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::platform_android;
 using namespace std::chrono;
 
 LLDB_PLUGIN_DEFINE(PlatformAndroid)
 
-static uint32_t g_initialize_count = 0;
-static const unsigned int g_android_default_cache_size =
+namespace {
+
+#define LLDB_PROPERTIES_android
+#include "PlatformAndroidProperties.inc"
+
+enum {
+#define LLDB_PROPERTIES_android
+#include "PlatformAndroidPropertiesEnum.inc"
+};
+
+class PluginProperties : public Properties {
+public:
+  PluginProperties() {
+    m_collection_sp = std::make_shared<OptionValueProperties>(
+        ConstString(PlatformAndroid::GetPluginNameStatic(false)));
+    m_collection_sp->Initialize(g_android_properties);
+  }
+};
+
+static PluginProperties &GetGlobalProperties() {
+  static PluginProperties g_settings;
+  return g_settings;
+}
+
+uint32_t g_initialize_count = 0;
+const unsigned int g_android_default_cache_size =
     2048; // Fits inside 4k adb packet.
 
+} // end of anonymous namespace
+
 void PlatformAndroid::Initialize() {
   PlatformLinux::Initialize();
 
   if (g_initialize_count++ == 0) {
 #if defined(__ANDROID__)
     PlatformSP default_platform_sp(new PlatformAndroid(true));
     default_platform_sp->SetSystemArchitecture(HostInfo::GetArchitecture());
     Platform::SetHostPlatform(default_platform_sp);
 #endif
     PluginManager::RegisterPlugin(
         PlatformAndroid::GetPluginNameStatic(false),
         PlatformAndroid::GetPluginDescriptionStatic(false),
-        PlatformAndroid::CreateInstance);
+        PlatformAndroid::CreateInstance, PlatformAndroid::DebuggerInitialize);
   }
 }
 
 void PlatformAndroid::Terminate() {
   if (g_initialize_count > 0) {
     if (--g_initialize_count == 0) {
       PluginManager::UnregisterPlugin(PlatformAndroid::CreateInstance);
     }
#endif
 
   LLDB_LOGF(
       log, "PlatformAndroid::%s() aborting creation of remote-android platform",
       __FUNCTION__);
 
   return PlatformSP();
 }
 
+void PlatformAndroid::DebuggerInitialize(Debugger &debugger) {
+  if (!PluginManager::GetSettingForPlatformPlugin(
+          debugger, ConstString(GetPluginNameStatic(false)))) {
+    PluginManager::CreateSettingForPlatformPlugin(
+        debugger, GetGlobalProperties().GetValueProperties(),
+        "Properties for the Android platform plugin.",
+        /*is_global_property=*/true);
+  }
+}
+
 PlatformAndroid::PlatformAndroid(bool is_host)
     : PlatformLinux(is_host), m_sdk_version(0) {}
 
 llvm::StringRef PlatformAndroid::GetPluginDescriptionStatic(bool is_host) {
   if (is_host)
     return "Local Android user platform plug-in.";
   return "Remote Android user platform plug-in.";
 }
Status PlatformAndroid::GetFile(const FileSpec &source,
   if (strchr(source_file.c_str(), '\'') != nullptr)
     return Status("Doesn't support single-quotes in filenames");
 
   // mode == 0 can signify that adbd cannot access the file due security
   // constraints - try "cat ..." as a fallback.
   AdbClientSP adb(GetAdbClient());
 
   char cmd[PATH_MAX];
-  snprintf(cmd, sizeof(cmd), "cat '%s'", source_file.c_str());
+  snprintf(cmd, sizeof(cmd), "%scat '%s'", GetRunAs().c_str(),
+           source_file.c_str());
 
   return adb->ShellToFile(cmd, minutes(1), destination);
 }
 
 Status PlatformAndroid::PutFile(const FileSpec &source,
                                 const FileSpec &destination, uint32_t uid,
                                 uint32_t gid) {
   if (IsHost() || !m_remote_platform_sp)
Status PlatformAndroid::DownloadModuleSlice(const FileSpec &src_file_spec,
   if (pos != std::string::npos)
     source_file = source_file.substr(0, pos);
 
   AdbClientSP adb(GetAdbClient());
 
   // Use 'shell dd' to download the file slice with the offset and size.
   char cmd[PATH_MAX];
   snprintf(cmd, sizeof(cmd),
-           "dd if='%s' iflag=skip_bytes,count_bytes "
+           "%sdd if='%s' iflag=skip_bytes,count_bytes "
            "skip=%" PRIu64 " count=%" PRIu64 " status=none",
-           source_file.c_str(), src_offset, src_size);
+           GetRunAs().c_str(), source_file.c_str(), src_offset, src_size);
 
   return adb->ShellToFile(cmd, minutes(1), dst_file_spec);
 }
 
 Status PlatformAndroid::DisconnectRemote() {
   Status error = PlatformLinux::DisconnectRemote();
   if (error.Success()) {
     m_device_id.clear();
Status PlatformAndroid::DownloadSymbolFile(const lldb::ModuleSP &module_sp,
   // If we already have symtab then we don't have to try and generate one
   if (module_sp->GetSectionList()->FindSectionByName(ConstString(".symtab")) !=
       nullptr)
     return Status("Symtab already available in the module");
 
   AdbClientSP adb(GetAdbClient());
   std::string tmpdir;
   Status error = adb->Shell("mktemp --directory --tmpdir /data/local/tmp",
                             seconds(5), &tmpdir);
   if (error.Fail() || tmpdir.empty())
     return Status("Failed to generate temporary directory on the device (%s)",
                   error.AsCString());
   tmpdir = llvm::StringRef(tmpdir).trim().str();
 
   // Create file remover for the temporary directory created on the device
   std::unique_ptr<std::string, std::function<void(std::string *)>>
       tmpdir_remover(&tmpdir, [&adb](std::string *s) {
PlatformAndroid::GetLibdlFunctionDeclarations(lldb_private::Process *process) {
 
   return PlatformPOSIX::GetLibdlFunctionDeclarations(process);
 }
 
 PlatformAndroid::AdbClientSP PlatformAndroid::GetAdbClient() {
   return std::make_unique<AdbClient>(m_device_id);
 }
 
+llvm::StringRef PlatformAndroid::GetPropertyRunAs() {
+  return GetGlobalProperties().GetPropertyAtIndexAs<llvm::StringRef>(
+      ePropertyPlatformRunAs, "");
+}
+
+std::string PlatformAndroid::GetRunAs() {
+  llvm::StringRef run_as = GetPropertyRunAs();
+  if (!run_as.empty()) {
+    // When LLDB fails to pull file from a package directory due to security
+    // constraint, user needs to set the package name to
+    // 'platform.plugin.remote-android.run-as' property in order to run shell
+    // commands as the package user. (e.g. to get file with 'cat' and 'dd').
+    // https://cs.android.com/android/platform/superproject/+/master:
+    // system/core/run-as/run-as.cpp;l=39-61;
+    // drc=4a77a84a55522a3b122f9c63ef0d0b8a6a131627
+    return std::string("run-as '") + run_as.str() + "' ";
+  }
+  return run_as.str();
+}
+
 AdbClient::SyncService *PlatformAndroid::GetSyncService(Status &error) {
   if (m_adb_sync_svc && m_adb_sync_svc->IsConnected())
     return m_adb_sync_svc.get();
 
   AdbClientSP adb(GetAdbClient());
   m_adb_sync_svc = adb->GetSyncService(error);
   return (error.Success()) ? m_adb_sync_svc.get() : nullptr;
 }

lldb/source/Plugins/Platform/Android/PlatformAndroidProperties.td

+include "../../../../include/lldb/Core/PropertiesBase.td"
+
+let Definition = "android" in {
+  def PlatformRunAs: Property<"run-as", "String">,
+    Global,
+    DefaultStringValue<"">,
+    Desc<"Specify package name to run adb shell command with 'run-as' as the "
+         "package user when necessary (e.g. to get file with 'cat' and 'dd').">;
+}

lldb/unittests/Platform/Android/PlatformAndroidTest.cpp

 
 class PlatformAndroidTest : public PlatformAndroid, public ::testing::Test {
 public:
   PlatformAndroidTest() : PlatformAndroid(false) {
     m_remote_platform_sp = PlatformSP(new PlatformAndroidRemoteGDBServer());
   }
 
   MOCK_METHOD0(GetAdbClient, AdbClientSP());
+  MOCK_METHOD0(GetPropertyRunAs, llvm::StringRef());
 };
 
 } // namespace
 
 TEST_F(PlatformAndroidTest, DownloadModuleSliceWithNormalFile) {
   auto sync_service = new MockSyncService();
   EXPECT_CALL(*sync_service, Stat(FileSpec("/system/lib64/libc.so"), _, _, _))
       .Times(1)
TEST_F(PlatformAndroidTest, DownloadModuleSliceWithZipFile) {
 
   EXPECT_TRUE(
       DownloadModuleSlice(
           FileSpec("/system/app/Test/Test.apk!/lib/arm64-v8a/libtest.so"), 4096,
           3600, FileSpec())
           .Success());
 }
 
+TEST_F(PlatformAndroidTest, DownloadModuleSliceWithZipFileAndRunAs) {
+  auto adb_client = new MockAdbClient();
+  EXPECT_CALL(*adb_client,
+              ShellToFile(StrEq("run-as 'com.example.test' "
+                                "dd if='/system/app/Test/Test.apk' "
+                                "iflag=skip_bytes,count_bytes "
+                                "skip=4096 count=3600 status=none"),
+                          _, _))
+      .Times(1)
+      .WillOnce(Return(Status()));
+
+  EXPECT_CALL(*this, GetPropertyRunAs())
+      .Times(1)
+      .WillOnce(Return(llvm::StringRef("com.example.test")));
+
+  EXPECT_CALL(*this, GetAdbClient())
+      .Times(1)
+      .WillOnce(Return(ByMove(std::move(AdbClientSP(adb_client)))));
+
+  EXPECT_TRUE(
+      DownloadModuleSlice(
+          FileSpec("/system/app/Test/Test.apk!/lib/arm64-v8a/libtest.so"), 4096,
+          3600, FileSpec())
+          .Success());
+}
+
 TEST_F(PlatformAndroidTest, GetFileWithNormalFile) {
   auto sync_service = new MockSyncService();
   EXPECT_CALL(*sync_service, Stat(FileSpec("/data/local/tmp/test"), _, _, _))
       .Times(1)
       .WillOnce(DoAll(SetArgReferee<1>(1), Return(Status())));
   EXPECT_CALL(*sync_service, PullFile(FileSpec("/data/local/tmp/test"), _))
       .Times(1)
       .WillOnce(Return(Status()));
EXPECT_CALL(*this, GetAdbClient())
       .WillOnce(Return(ByMove(std::move(AdbClientSP(adb_client0)))))
       .WillOnce(Return(ByMove(std::move(AdbClientSP(adb_client1)))));
 
   EXPECT_TRUE(
       GetFile(FileSpec("/data/data/com.example.app/lib-main/libtest.so"),
               FileSpec())
           .Success());
 }
+
+TEST_F(PlatformAndroidTest, GetFileWithCatFallbackAndRunAs) {
+  auto sync_service = new MockSyncService();
+  EXPECT_CALL(
+      *sync_service,
+      Stat(FileSpec("/data/data/com.example.app/lib-main/libtest.so"), _, _, _))
+      .Times(1)
+      .WillOnce(DoAll(SetArgReferee<1>(0), Return(Status())));
+
+  auto adb_client0 = new MockAdbClient();
+  EXPECT_CALL(*adb_client0, GetSyncService(_))
+      .Times(1)
+      .WillOnce(Return(ByMove(std::move(SyncServiceSP(sync_service)))));
+
+  auto adb_client1 = new MockAdbClient();
+  EXPECT_CALL(
+      *adb_client1,
+      ShellToFile(StrEq("run-as 'com.example.app' "
+                        "cat '/data/data/com.example.app/lib-main/libtest.so'"),
+                  _, _))
+      .Times(1)
+      .WillOnce(Return(Status()));
+
+  EXPECT_CALL(*this, GetPropertyRunAs())
+      .Times(1)
+      .WillOnce(Return(llvm::StringRef("com.example.app")));
+
+  EXPECT_CALL(*this, GetAdbClient())
+      .Times(2)
+      .WillOnce(Return(ByMove(std::move(AdbClientSP(adb_client0)))))
+      .WillOnce(Return(ByMove(std::move(AdbClientSP(adb_client1)))));
+
+  EXPECT_TRUE(
+      GetFile(FileSpec("/data/data/com.example.app/lib-main/libtest.so"),
+              FileSpec())
+          .Success());
+}