1 //===-- PlatformAndroid.cpp -----------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "lldb/Core/Module.h"
10 #include "lldb/Core/PluginManager.h"
11 #include "lldb/Core/Section.h"
12 #include "lldb/Core/ValueObject.h"
13 #include "lldb/Host/HostInfo.h"
14 #include "lldb/Host/StringConvert.h"
15 #include "lldb/Utility/Log.h"
16 #include "lldb/Utility/Scalar.h"
17 #include "lldb/Utility/UriParser.h"
18
19 #include "AdbClient.h"
20 #include "PlatformAndroid.h"
21 #include "PlatformAndroidRemoteGDBServer.h"
22 #include "lldb/Target/Target.h"
23
24 using namespace lldb;
25 using namespace lldb_private;
26 using namespace lldb_private::platform_android;
27 using namespace std::chrono;
28
29 LLDB_PLUGIN_DEFINE(PlatformAndroid)
30
31 static uint32_t g_initialize_count = 0;
32 static const unsigned int g_android_default_cache_size =
33 2048; // Fits inside 4k adb packet.
34
Initialize()35 void PlatformAndroid::Initialize() {
36 PlatformLinux::Initialize();
37
38 if (g_initialize_count++ == 0) {
39 #if defined(__ANDROID__)
40 PlatformSP default_platform_sp(new PlatformAndroid(true));
41 default_platform_sp->SetSystemArchitecture(HostInfo::GetArchitecture());
42 Platform::SetHostPlatform(default_platform_sp);
43 #endif
44 PluginManager::RegisterPlugin(
45 PlatformAndroid::GetPluginNameStatic(false),
46 PlatformAndroid::GetPluginDescriptionStatic(false),
47 PlatformAndroid::CreateInstance);
48 }
49 }
50
Terminate()51 void PlatformAndroid::Terminate() {
52 if (g_initialize_count > 0) {
53 if (--g_initialize_count == 0) {
54 PluginManager::UnregisterPlugin(PlatformAndroid::CreateInstance);
55 }
56 }
57
58 PlatformLinux::Terminate();
59 }
60
CreateInstance(bool force,const ArchSpec * arch)61 PlatformSP PlatformAndroid::CreateInstance(bool force, const ArchSpec *arch) {
62 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
63 if (log) {
64 const char *arch_name;
65 if (arch && arch->GetArchitectureName())
66 arch_name = arch->GetArchitectureName();
67 else
68 arch_name = "<null>";
69
70 const char *triple_cstr =
71 arch ? arch->GetTriple().getTriple().c_str() : "<null>";
72
73 LLDB_LOGF(log, "PlatformAndroid::%s(force=%s, arch={%s,%s})", __FUNCTION__,
74 force ? "true" : "false", arch_name, triple_cstr);
75 }
76
77 bool create = force;
78 if (!create && arch && arch->IsValid()) {
79 const llvm::Triple &triple = arch->GetTriple();
80 switch (triple.getVendor()) {
81 case llvm::Triple::PC:
82 create = true;
83 break;
84
85 #if defined(__ANDROID__)
86 // Only accept "unknown" for the vendor if the host is android and if
87 // "unknown" wasn't specified (it was just returned because it was NOT
88 // specified).
89 case llvm::Triple::VendorType::UnknownVendor:
90 create = !arch->TripleVendorWasSpecified();
91 break;
92 #endif
93 default:
94 break;
95 }
96
97 if (create) {
98 switch (triple.getEnvironment()) {
99 case llvm::Triple::Android:
100 break;
101
102 #if defined(__ANDROID__)
103 // Only accept "unknown" for the OS if the host is android and it
104 // "unknown" wasn't specified (it was just returned because it was NOT
105 // specified)
106 case llvm::Triple::EnvironmentType::UnknownEnvironment:
107 create = !arch->TripleEnvironmentWasSpecified();
108 break;
109 #endif
110 default:
111 create = false;
112 break;
113 }
114 }
115 }
116
117 if (create) {
118 LLDB_LOGF(log, "PlatformAndroid::%s() creating remote-android platform",
119 __FUNCTION__);
120 return PlatformSP(new PlatformAndroid(false));
121 }
122
123 LLDB_LOGF(
124 log, "PlatformAndroid::%s() aborting creation of remote-android platform",
125 __FUNCTION__);
126
127 return PlatformSP();
128 }
129
PlatformAndroid(bool is_host)130 PlatformAndroid::PlatformAndroid(bool is_host)
131 : PlatformLinux(is_host), m_sdk_version(0) {}
132
~PlatformAndroid()133 PlatformAndroid::~PlatformAndroid() {}
134
GetPluginNameStatic(bool is_host)135 ConstString PlatformAndroid::GetPluginNameStatic(bool is_host) {
136 if (is_host) {
137 static ConstString g_host_name(Platform::GetHostPlatformName());
138 return g_host_name;
139 } else {
140 static ConstString g_remote_name("remote-android");
141 return g_remote_name;
142 }
143 }
144
GetPluginDescriptionStatic(bool is_host)145 const char *PlatformAndroid::GetPluginDescriptionStatic(bool is_host) {
146 if (is_host)
147 return "Local Android user platform plug-in.";
148 else
149 return "Remote Android user platform plug-in.";
150 }
151
GetPluginName()152 ConstString PlatformAndroid::GetPluginName() {
153 return GetPluginNameStatic(IsHost());
154 }
155
ConnectRemote(Args & args)156 Status PlatformAndroid::ConnectRemote(Args &args) {
157 m_device_id.clear();
158
159 if (IsHost()) {
160 return Status("can't connect to the host platform '%s', always connected",
161 GetPluginName().GetCString());
162 }
163
164 if (!m_remote_platform_sp)
165 m_remote_platform_sp = PlatformSP(new PlatformAndroidRemoteGDBServer());
166
167 int port;
168 llvm::StringRef scheme, host, path;
169 const char *url = args.GetArgumentAtIndex(0);
170 if (!url)
171 return Status("URL is null.");
172 if (!UriParser::Parse(url, scheme, host, port, path))
173 return Status("Invalid URL: %s", url);
174 if (host != "localhost")
175 m_device_id = std::string(host);
176
177 auto error = PlatformLinux::ConnectRemote(args);
178 if (error.Success()) {
179 AdbClient adb;
180 error = AdbClient::CreateByDeviceID(m_device_id, adb);
181 if (error.Fail())
182 return error;
183
184 m_device_id = adb.GetDeviceID();
185 }
186 return error;
187 }
188
GetFile(const FileSpec & source,const FileSpec & destination)189 Status PlatformAndroid::GetFile(const FileSpec &source,
190 const FileSpec &destination) {
191 if (IsHost() || !m_remote_platform_sp)
192 return PlatformLinux::GetFile(source, destination);
193
194 FileSpec source_spec(source.GetPath(false), FileSpec::Style::posix);
195 if (source_spec.IsRelative())
196 source_spec = GetRemoteWorkingDirectory().CopyByAppendingPathComponent(
197 source_spec.GetCString(false));
198
199 Status error;
200 auto sync_service = GetSyncService(error);
201 if (error.Fail())
202 return error;
203
204 uint32_t mode = 0, size = 0, mtime = 0;
205 error = sync_service->Stat(source_spec, mode, size, mtime);
206 if (error.Fail())
207 return error;
208
209 if (mode != 0)
210 return sync_service->PullFile(source_spec, destination);
211
212 auto source_file = source_spec.GetCString(false);
213
214 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
215 LLDB_LOGF(log, "Got mode == 0 on '%s': try to get file via 'shell cat'",
216 source_file);
217
218 if (strchr(source_file, '\'') != nullptr)
219 return Status("Doesn't support single-quotes in filenames");
220
221 // mode == 0 can signify that adbd cannot access the file due security
222 // constraints - try "cat ..." as a fallback.
223 AdbClient adb(m_device_id);
224
225 char cmd[PATH_MAX];
226 snprintf(cmd, sizeof(cmd), "cat '%s'", source_file);
227
228 return adb.ShellToFile(cmd, minutes(1), destination);
229 }
230
PutFile(const FileSpec & source,const FileSpec & destination,uint32_t uid,uint32_t gid)231 Status PlatformAndroid::PutFile(const FileSpec &source,
232 const FileSpec &destination, uint32_t uid,
233 uint32_t gid) {
234 if (IsHost() || !m_remote_platform_sp)
235 return PlatformLinux::PutFile(source, destination, uid, gid);
236
237 FileSpec destination_spec(destination.GetPath(false), FileSpec::Style::posix);
238 if (destination_spec.IsRelative())
239 destination_spec = GetRemoteWorkingDirectory().CopyByAppendingPathComponent(
240 destination_spec.GetCString(false));
241
242 // TODO: Set correct uid and gid on remote file.
243 Status error;
244 auto sync_service = GetSyncService(error);
245 if (error.Fail())
246 return error;
247 return sync_service->PushFile(source, destination_spec);
248 }
249
GetCacheHostname()250 const char *PlatformAndroid::GetCacheHostname() { return m_device_id.c_str(); }
251
DownloadModuleSlice(const FileSpec & src_file_spec,const uint64_t src_offset,const uint64_t src_size,const FileSpec & dst_file_spec)252 Status PlatformAndroid::DownloadModuleSlice(const FileSpec &src_file_spec,
253 const uint64_t src_offset,
254 const uint64_t src_size,
255 const FileSpec &dst_file_spec) {
256 if (src_offset != 0)
257 return Status("Invalid offset - %" PRIu64, src_offset);
258
259 return GetFile(src_file_spec, dst_file_spec);
260 }
261
DisconnectRemote()262 Status PlatformAndroid::DisconnectRemote() {
263 Status error = PlatformLinux::DisconnectRemote();
264 if (error.Success()) {
265 m_device_id.clear();
266 m_sdk_version = 0;
267 }
268 return error;
269 }
270
GetDefaultMemoryCacheLineSize()271 uint32_t PlatformAndroid::GetDefaultMemoryCacheLineSize() {
272 return g_android_default_cache_size;
273 }
274
GetSdkVersion()275 uint32_t PlatformAndroid::GetSdkVersion() {
276 if (!IsConnected())
277 return 0;
278
279 if (m_sdk_version != 0)
280 return m_sdk_version;
281
282 std::string version_string;
283 AdbClient adb(m_device_id);
284 Status error =
285 adb.Shell("getprop ro.build.version.sdk", seconds(5), &version_string);
286 version_string = llvm::StringRef(version_string).trim().str();
287
288 if (error.Fail() || version_string.empty()) {
289 Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM);
290 LLDB_LOGF(log, "Get SDK version failed. (error: %s, output: %s)",
291 error.AsCString(), version_string.c_str());
292 return 0;
293 }
294
295 m_sdk_version = StringConvert::ToUInt32(version_string.c_str());
296 return m_sdk_version;
297 }
298
DownloadSymbolFile(const lldb::ModuleSP & module_sp,const FileSpec & dst_file_spec)299 Status PlatformAndroid::DownloadSymbolFile(const lldb::ModuleSP &module_sp,
300 const FileSpec &dst_file_spec) {
301 // For oat file we can try to fetch additional debug info from the device
302 ConstString extension = module_sp->GetFileSpec().GetFileNameExtension();
303 if (extension != ".oat" && extension != ".odex")
304 return Status(
305 "Symbol file downloading only supported for oat and odex files");
306
307 // If we have no information about the platform file we can't execute oatdump
308 if (!module_sp->GetPlatformFileSpec())
309 return Status("No platform file specified");
310
311 // Symbolizer isn't available before SDK version 23
312 if (GetSdkVersion() < 23)
313 return Status("Symbol file generation only supported on SDK 23+");
314
315 // If we already have symtab then we don't have to try and generate one
316 if (module_sp->GetSectionList()->FindSectionByName(ConstString(".symtab")) !=
317 nullptr)
318 return Status("Symtab already available in the module");
319
320 AdbClient adb(m_device_id);
321 std::string tmpdir;
322 Status error = adb.Shell("mktemp --directory --tmpdir /data/local/tmp",
323 seconds(5), &tmpdir);
324 if (error.Fail() || tmpdir.empty())
325 return Status("Failed to generate temporary directory on the device (%s)",
326 error.AsCString());
327 tmpdir = llvm::StringRef(tmpdir).trim().str();
328
329 // Create file remover for the temporary directory created on the device
330 std::unique_ptr<std::string, std::function<void(std::string *)>>
331 tmpdir_remover(&tmpdir, [&adb](std::string *s) {
332 StreamString command;
333 command.Printf("rm -rf %s", s->c_str());
334 Status error = adb.Shell(command.GetData(), seconds(5), nullptr);
335
336 Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
337 if (log && error.Fail())
338 LLDB_LOGF(log, "Failed to remove temp directory: %s", error.AsCString());
339 });
340
341 FileSpec symfile_platform_filespec(tmpdir);
342 symfile_platform_filespec.AppendPathComponent("symbolized.oat");
343
344 // Execute oatdump on the remote device to generate a file with symtab
345 StreamString command;
346 command.Printf("oatdump --symbolize=%s --output=%s",
347 module_sp->GetPlatformFileSpec().GetCString(false),
348 symfile_platform_filespec.GetCString(false));
349 error = adb.Shell(command.GetData(), minutes(1), nullptr);
350 if (error.Fail())
351 return Status("Oatdump failed: %s", error.AsCString());
352
353 // Download the symbolfile from the remote device
354 return GetFile(symfile_platform_filespec, dst_file_spec);
355 }
356
GetRemoteOSVersion()357 bool PlatformAndroid::GetRemoteOSVersion() {
358 m_os_version = llvm::VersionTuple(GetSdkVersion());
359 return !m_os_version.empty();
360 }
361
362 llvm::StringRef
GetLibdlFunctionDeclarations(lldb_private::Process * process)363 PlatformAndroid::GetLibdlFunctionDeclarations(lldb_private::Process *process) {
364 SymbolContextList matching_symbols;
365 std::vector<const char *> dl_open_names = { "__dl_dlopen", "dlopen" };
366 const char *dl_open_name = nullptr;
367 Target &target = process->GetTarget();
368 for (auto name: dl_open_names) {
369 target.GetImages().FindFunctionSymbols(
370 ConstString(name), eFunctionNameTypeFull, matching_symbols);
371 if (matching_symbols.GetSize()) {
372 dl_open_name = name;
373 break;
374 }
375 }
376 // Older platform versions have the dl function symbols mangled
377 if (dl_open_name == dl_open_names[0])
378 return R"(
379 extern "C" void* dlopen(const char*, int) asm("__dl_dlopen");
380 extern "C" void* dlsym(void*, const char*) asm("__dl_dlsym");
381 extern "C" int dlclose(void*) asm("__dl_dlclose");
382 extern "C" char* dlerror(void) asm("__dl_dlerror");
383 )";
384
385 return PlatformPOSIX::GetLibdlFunctionDeclarations(process);
386 }
387
GetSyncService(Status & error)388 AdbClient::SyncService *PlatformAndroid::GetSyncService(Status &error) {
389 if (m_adb_sync_svc && m_adb_sync_svc->IsConnected())
390 return m_adb_sync_svc.get();
391
392 AdbClient adb(m_device_id);
393 m_adb_sync_svc = adb.GetSyncService(error);
394 return (error.Success()) ? m_adb_sync_svc.get() : nullptr;
395 }
396