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