Change oat symbolization code for android to work on non-rooted devices

[tberghammer]

Summary

Change oat symbolization code for android to work on non-rooted devices

On android when debugging an apk we run lldb-server as application user
because the sell user (on non-rooted device) can't attach to an
application. The problem is that "adb pull" will run as a shell user
what can't access to files created by lldb-server because they will be
owned by the application user. This CL changes the oat symbolization
code to run "oatdump --symbolize" to generate an output what is owned
by the shell user.

[ovyalov]

Minor comments

source/Plugins/Platform/Android/AdbClient.cpp

231

Could you add checks for error and that n > 0?

source/Plugins/Platform/Android/PlatformAndroid.cpp

340

Could you reuse adb variable defined before - e.g., wrap with shared_ptr?

361

s/&output/nullptr ?

[tberghammer]

source/Plugins/Platform/Android/PlatformAndroid.cpp

340

Fixed with capturing adb from the parent scope by reference. The destructor of the unique_ptr will be called earlier then the destructor of the AdbClient so no need for a shared_ptr

[ovyalov]

source/Plugins/Platform/Android/PlatformAndroid.cpp

341

I tried this CL on my device and it's failing to download a symbol file - "Failed to pull file: No such file or directory". As I can see tmpdir isn't fully cleared from tail symbols, like \r\n

[tberghammer]

I haven't managed to reproduce the issue you reported (what OS and Android
version do you use?), but based on the description this change (not
committed in yet) might fix the issue: http://reviews.llvm.org/D13293. Can
you take a look?

Thanks,
Tamas

[ovyalov]

I tried Nexus 5 and 6P with Android M. Thanks for the new patch - it's fixing the problem.

source/Plugins/Platform/Android/AdbClient.h

public:
     PullFile (const FileSpec &remote_file, const FileSpec &local_file);
 
     Error
     PushFile (const FileSpec &local_file, const FileSpec &remote_file);
 
     Error
     Stat (const FileSpec &remote_file, uint32_t &mode, uint32_t &size, uint32_t &mtime);
 
+    Error
+    Shell (const char* command, uint32_t timeout_ms, std::string* output);
+
 private:
     Error
     Connect ();
 
     void
     SetDeviceID (const std::string &device_id);
 
     Error
     SendMessage (const std::string &packet, const bool reconnect = true);
 
     Error
     SendDeviceMessage (const std::string &packet);
 
     Error
     SendSyncRequest (const char *request_id, const uint32_t data_len, const void *data);
 
     Error
     ReadSyncHeader (std::string &response_id, uint32_t &data_len);
 
     Error
     ReadMessage (std::vector<char> &message);
 
     Error
+    ReadMessageStream (std::vector<char> &message, uint32_t timeout_ms);
+
+    Error
     GetResponseError (const char *response_id);
 
     Error
     ReadResponseStatus ();
 
     Error
     SwitchDeviceTransport ();
 

source/Plugins/Platform/Android/AdbClient.cpp

 //===-- AdbClient.cpp -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // Other libraries and framework includes
 #include "lldb/Core/DataBuffer.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/DataEncoder.h"
 #include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/StreamString.h"
 #include "lldb/Host/FileSpec.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/FileUtilities.h"
 
 // Project includes
 #include "AdbClient.h"
AdbClient::ReadMessage (std::vector<char> &message)
     error = ReadAllBytes (&message[0], packet_len);
     if (error.Fail ())
         message.clear ();
 
     return error;
 }
 
 Error
+AdbClient::ReadMessageStream (std::vector<char>& message, uint32_t timeout_ms)
+{
+    auto start = std::chrono::steady_clock::now();
+    message.clear();
+
+    Error error;
+    lldb::ConnectionStatus status = lldb::eConnectionStatusSuccess;
+    char buffer[1024];
+    while (error.Success() && status == lldb::eConnectionStatusSuccess)
+    {
+        auto end = std::chrono::steady_clock::now();
+        uint32_t elapsed_time = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
+        if (elapsed_time >= timeout_ms)
+            return Error("Timed out");
+
+        size_t n = m_conn.Read(buffer, sizeof(buffer), 1000 * (timeout_ms - elapsed_time), status, &error);
+        message.insert(message.end(), &buffer[0], &buffer[n]);
+    }
+    return error;
+}
+
+Error
 AdbClient::ReadResponseStatus()
 {
     char response_id[5];
 
     static const size_t packet_len = 4;
     response_id[packet_len] = 0;
 
     auto error = ReadAllBytes (response_id, packet_len);
AdbClient::Stat (const FileSpec &remote_file, uint32_t &mode, uint32_t &size, uint32_t &mtime)
     if (strncmp (command_str, kSTAT, stat_len))
         return Error ("Got invalid stat command: %s", command_str);
 
     mode = extractor.GetU32 (&offset);
     size = extractor.GetU32 (&offset);
     mtime = extractor.GetU32 (&offset);
     return Error ();
 }
+
+Error
+AdbClient::Shell (const char* command, uint32_t timeout_ms, std::string* output)
+{
+    auto error = SwitchDeviceTransport ();
+    if (error.Fail ())
+        return Error ("Failed to switch to device transport: %s", error.AsCString ());
+
+    StreamString adb_command;
+    adb_command.Printf("shell:%s", command);
+    error = SendMessage (adb_command.GetData(), false);
+    if (error.Fail ())
+        return error;
+
+    error = ReadResponseStatus ();
+    if (error.Fail ())
+        return error;
+
+    std::vector<char> in_buffer;
+    error = ReadMessageStream (in_buffer, timeout_ms);
+    if (error.Fail())
+        return error;
+
+    if (output)
+        output->assign(in_buffer.begin(), in_buffer.end());
+    return error;
+}

source/Plugins/Platform/Android/PlatformAndroid.cpp

PlatformAndroid::DownloadSymbolFile (const lldb::ModuleSP& module_sp,
     // Symbolizer isn't available before SDK version 23
     if (GetSdkVersion() < 23)
         return Error("Symbol file generation only supported on SDK 23+");
 
     // If we already have symtab then we don't have to try and generate one
     if (module_sp->GetSectionList()->FindSectionByName(ConstString(".symtab")) != nullptr)
         return Error("Symtab already available in the module");
 
-    int status = 0;
-    std::string tmpdir;
-    StreamString command;
-    command.Printf("mktemp --directory --tmpdir %s", GetWorkingDirectory().GetCString());
-    Error error = RunShellCommand(command.GetData(),
-                                  GetWorkingDirectory(),
-                                  &status,
-                                  nullptr,
-                                  &tmpdir,
-                                  5 /* timeout (s) */);
+    AdbClient adb(m_device_id);
 
-    if (error.Fail() || status != 0 || tmpdir.empty())
+    std::string tmpdir;
+    Error error = adb.Shell("mktemp --directory --tmpdir /data/local/tmp", 5000 /* ms */, &tmpdir);
+    if (error.Fail() || tmpdir.empty())
         return Error("Failed to generate temporary directory on the device (%s)", error.AsCString());
     tmpdir.erase(tmpdir.size() - 1); // Remove trailing new line
 
     // Create file remover for the temporary directory created on the device
     std::unique_ptr<std::string, std::function<void(std::string*)>> tmpdir_remover(
         &tmpdir,
         [this](std::string* s) {
+            AdbClient adb(m_device_id);
+
             StreamString command;
             command.Printf("rm -rf %s", s->c_str());
-            Error error = this->RunShellCommand(command.GetData(),
-                                                GetWorkingDirectory(),
-                                                nullptr,
-                                                nullptr,
-                                                nullptr,
-                                                5 /* timeout (s) */);
+            Error error = adb.Shell(command.GetData(), 5000 /* ms */, nullptr);
 
             Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_PLATFORM));
             if (error.Fail())
                 log->Printf("Failed to remove temp directory: %s", error.AsCString());
         }
     );
 
     FileSpec symfile_platform_filespec(tmpdir.c_str(), false);
     symfile_platform_filespec.AppendPathComponent("symbolized.oat");
 
     // Execute oatdump on the remote device to generate a file with symtab
-    command.Clear();
+    StreamString command;
     command.Printf("oatdump --symbolize=%s --output=%s",
                    module_sp->GetPlatformFileSpec().GetCString(false),
                    symfile_platform_filespec.GetCString(false));
-    error = RunShellCommand(command.GetData(),
-                            GetWorkingDirectory(),
-                            &status,
-                            nullptr,
-                            nullptr,
-                            60 /* timeout (s) */);
-    if (error.Fail() || status != 0)
+    std::string output;
+    error = adb.Shell(command.GetData(), 60000 /* ms */, &output);
+    if (error.Fail())
         return Error("Oatdump failed: %s", error.AsCString());
 
     // Download the symbolfile from the remote device
     return GetFile(symfile_platform_filespec, dst_file_spec);
 }