1 | //===-- Platform.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 <algorithm> |
10 | #include <csignal> |
11 | #include <fstream> |
12 | #include <memory> |
13 | #include <optional> |
14 | #include <vector> |
15 | |
16 | #include "lldb/Breakpoint/BreakpointIDList.h" |
17 | #include "lldb/Breakpoint/BreakpointLocation.h" |
18 | #include "lldb/Core/Debugger.h" |
19 | #include "lldb/Core/Module.h" |
20 | #include "lldb/Core/ModuleSpec.h" |
21 | #include "lldb/Core/PluginManager.h" |
22 | #include "lldb/Host/FileCache.h" |
23 | #include "lldb/Host/FileSystem.h" |
24 | #include "lldb/Host/Host.h" |
25 | #include "lldb/Host/HostInfo.h" |
26 | #include "lldb/Host/OptionParser.h" |
27 | #include "lldb/Interpreter/OptionValueFileSpec.h" |
28 | #include "lldb/Interpreter/OptionValueProperties.h" |
29 | #include "lldb/Interpreter/Property.h" |
30 | #include "lldb/Symbol/ObjectFile.h" |
31 | #include "lldb/Target/ModuleCache.h" |
32 | #include "lldb/Target/Platform.h" |
33 | #include "lldb/Target/Process.h" |
34 | #include "lldb/Target/Target.h" |
35 | #include "lldb/Target/UnixSignals.h" |
36 | #include "lldb/Utility/DataBufferHeap.h" |
37 | #include "lldb/Utility/FileSpec.h" |
38 | #include "lldb/Utility/LLDBLog.h" |
39 | #include "lldb/Utility/Log.h" |
40 | #include "lldb/Utility/Status.h" |
41 | #include "lldb/Utility/StructuredData.h" |
42 | #include "llvm/ADT/STLExtras.h" |
43 | #include "llvm/Support/FileSystem.h" |
44 | #include "llvm/Support/Path.h" |
45 | |
46 | // Define these constants from POSIX mman.h rather than include the file so |
47 | // that they will be correct even when compiled on Linux. |
48 | #define MAP_PRIVATE 2 |
49 | #define MAP_ANON 0x1000 |
50 | |
51 | using namespace lldb; |
52 | using namespace lldb_private; |
53 | |
54 | // Use a singleton function for g_local_platform_sp to avoid init constructors |
55 | // since LLDB is often part of a shared library |
56 | static PlatformSP &GetHostPlatformSP() { |
57 | static PlatformSP g_platform_sp; |
58 | return g_platform_sp; |
59 | } |
60 | |
61 | const char *Platform::GetHostPlatformName() { return "host"; } |
62 | |
63 | namespace { |
64 | |
65 | #define LLDB_PROPERTIES_platform |
66 | #include "TargetProperties.inc" |
67 | |
68 | enum { |
69 | #define LLDB_PROPERTIES_platform |
70 | #include "TargetPropertiesEnum.inc" |
71 | }; |
72 | |
73 | } // namespace |
74 | |
75 | llvm::StringRef PlatformProperties::GetSettingName() { |
76 | static constexpr llvm::StringLiteral g_setting_name("platform"); |
77 | return g_setting_name; |
78 | } |
79 | |
80 | PlatformProperties::PlatformProperties() { |
81 | m_collection_sp = std::make_shared<OptionValueProperties>(args: GetSettingName()); |
82 | m_collection_sp->Initialize(setting_definitions: g_platform_properties); |
83 | |
84 | auto module_cache_dir = GetModuleCacheDirectory(); |
85 | if (module_cache_dir) |
86 | return; |
87 | |
88 | llvm::SmallString<64> user_home_dir; |
89 | if (!FileSystem::Instance().GetHomeDirectory(path&: user_home_dir)) |
90 | return; |
91 | |
92 | module_cache_dir = FileSpec(user_home_dir.c_str()); |
93 | module_cache_dir.AppendPathComponent(component: ".lldb"); |
94 | module_cache_dir.AppendPathComponent(component: "module_cache"); |
95 | SetDefaultModuleCacheDirectory(module_cache_dir); |
96 | SetModuleCacheDirectory(module_cache_dir); |
97 | } |
98 | |
99 | bool PlatformProperties::GetUseModuleCache() const { |
100 | const auto idx = ePropertyUseModuleCache; |
101 | return GetPropertyAtIndexAs<bool>( |
102 | idx, g_platform_properties[idx].default_uint_value != 0); |
103 | } |
104 | |
105 | bool PlatformProperties::SetUseModuleCache(bool use_module_cache) { |
106 | return SetPropertyAtIndex(ePropertyUseModuleCache, use_module_cache); |
107 | } |
108 | |
109 | FileSpec PlatformProperties::GetModuleCacheDirectory() const { |
110 | return GetPropertyAtIndexAs<FileSpec>(ePropertyModuleCacheDirectory, {}); |
111 | } |
112 | |
113 | bool PlatformProperties::SetModuleCacheDirectory(const FileSpec &dir_spec) { |
114 | return m_collection_sp->SetPropertyAtIndex(ePropertyModuleCacheDirectory, |
115 | dir_spec); |
116 | } |
117 | |
118 | void PlatformProperties::SetDefaultModuleCacheDirectory( |
119 | const FileSpec &dir_spec) { |
120 | auto f_spec_opt = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpec( |
121 | ePropertyModuleCacheDirectory); |
122 | assert(f_spec_opt); |
123 | f_spec_opt->SetDefaultValue(dir_spec); |
124 | } |
125 | |
126 | /// Get the native host platform plug-in. |
127 | /// |
128 | /// There should only be one of these for each host that LLDB runs |
129 | /// upon that should be statically compiled in and registered using |
130 | /// preprocessor macros or other similar build mechanisms. |
131 | /// |
132 | /// This platform will be used as the default platform when launching |
133 | /// or attaching to processes unless another platform is specified. |
134 | PlatformSP Platform::GetHostPlatform() { return GetHostPlatformSP(); } |
135 | |
136 | void Platform::Initialize() {} |
137 | |
138 | void Platform::Terminate() {} |
139 | |
140 | PlatformProperties &Platform::GetGlobalPlatformProperties() { |
141 | static PlatformProperties g_settings; |
142 | return g_settings; |
143 | } |
144 | |
145 | void Platform::SetHostPlatform(const lldb::PlatformSP &platform_sp) { |
146 | // The native platform should use its static void Platform::Initialize() |
147 | // function to register itself as the native platform. |
148 | GetHostPlatformSP() = platform_sp; |
149 | } |
150 | |
151 | Status Platform::GetFileWithUUID(const FileSpec &platform_file, |
152 | const UUID *uuid_ptr, FileSpec &local_file) { |
153 | // Default to the local case |
154 | local_file = platform_file; |
155 | return Status(); |
156 | } |
157 | |
158 | FileSpecList |
159 | Platform::LocateExecutableScriptingResources(Target *target, Module &module, |
160 | Stream &feedback_stream) { |
161 | return FileSpecList(); |
162 | } |
163 | |
164 | Status Platform::GetSharedModule( |
165 | const ModuleSpec &module_spec, Process *process, ModuleSP &module_sp, |
166 | const FileSpecList *module_search_paths_ptr, |
167 | llvm::SmallVectorImpl<lldb::ModuleSP> *old_modules, bool *did_create_ptr) { |
168 | if (IsHost()) |
169 | return ModuleList::GetSharedModule(module_spec, module_sp, |
170 | module_search_paths_ptr, old_modules, |
171 | did_create_ptr, always_create: false); |
172 | |
173 | // Module resolver lambda. |
174 | auto resolver = [&](const ModuleSpec &spec) { |
175 | Status error(eErrorTypeGeneric); |
176 | ModuleSpec resolved_spec; |
177 | // Check if we have sysroot set. |
178 | if (!m_sdk_sysroot.empty()) { |
179 | // Prepend sysroot to module spec. |
180 | resolved_spec = spec; |
181 | resolved_spec.GetFileSpec().PrependPathComponent(component: m_sdk_sysroot); |
182 | // Try to get shared module with resolved spec. |
183 | error = ModuleList::GetSharedModule(module_spec: resolved_spec, module_sp, |
184 | module_search_paths_ptr, old_modules, |
185 | did_create_ptr, always_create: false); |
186 | } |
187 | // If we don't have sysroot or it didn't work then |
188 | // try original module spec. |
189 | if (!error.Success()) { |
190 | resolved_spec = spec; |
191 | error = ModuleList::GetSharedModule(module_spec: resolved_spec, module_sp, |
192 | module_search_paths_ptr, old_modules, |
193 | did_create_ptr, always_create: false); |
194 | } |
195 | if (error.Success() && module_sp) |
196 | module_sp->SetPlatformFileSpec(resolved_spec.GetFileSpec()); |
197 | return error; |
198 | }; |
199 | |
200 | return GetRemoteSharedModule(module_spec, process, module_sp, module_resolver: resolver, |
201 | did_create_ptr); |
202 | } |
203 | |
204 | bool Platform::GetModuleSpec(const FileSpec &module_file_spec, |
205 | const ArchSpec &arch, ModuleSpec &module_spec) { |
206 | ModuleSpecList module_specs; |
207 | if (ObjectFile::GetModuleSpecifications(file: module_file_spec, file_offset: 0, file_size: 0, |
208 | specs&: module_specs) == 0) |
209 | return false; |
210 | |
211 | ModuleSpec matched_module_spec; |
212 | return module_specs.FindMatchingModuleSpec(module_spec: ModuleSpec(module_file_spec, arch), |
213 | match_module_spec&: module_spec); |
214 | } |
215 | |
216 | PlatformSP Platform::Create(llvm::StringRef name) { |
217 | lldb::PlatformSP platform_sp; |
218 | if (name == GetHostPlatformName()) |
219 | return GetHostPlatform(); |
220 | |
221 | if (PlatformCreateInstance create_callback = |
222 | PluginManager::GetPlatformCreateCallbackForPluginName(name)) |
223 | return create_callback(true, nullptr); |
224 | return nullptr; |
225 | } |
226 | |
227 | ArchSpec Platform::GetAugmentedArchSpec(Platform *platform, llvm::StringRef triple) { |
228 | if (platform) |
229 | return platform->GetAugmentedArchSpec(triple); |
230 | return HostInfo::GetAugmentedArchSpec(triple); |
231 | } |
232 | |
233 | /// Default Constructor |
234 | Platform::Platform(bool is_host) |
235 | : m_is_host(is_host), m_os_version_set_while_connected(false), |
236 | m_system_arch_set_while_connected(false), m_max_uid_name_len(0), |
237 | m_max_gid_name_len(0), m_supports_rsync(false), m_rsync_opts(), |
238 | m_rsync_prefix(), m_supports_ssh(false), m_ssh_opts(), |
239 | m_ignores_remote_hostname(false), m_trap_handlers(), |
240 | m_calculated_trap_handlers(false), |
241 | m_module_cache(std::make_unique<ModuleCache>()) { |
242 | Log *log = GetLog(mask: LLDBLog::Object); |
243 | LLDB_LOGF(log, "%p Platform::Platform()", static_cast<void *>(this)); |
244 | } |
245 | |
246 | Platform::~Platform() = default; |
247 | |
248 | void Platform::GetStatus(Stream &strm) { |
249 | strm.Format(format: " Platform: {0}\n", args: GetPluginName()); |
250 | |
251 | ArchSpec arch(GetSystemArchitecture()); |
252 | if (arch.IsValid()) { |
253 | if (!arch.GetTriple().str().empty()) { |
254 | strm.Printf(format: " Triple: "); |
255 | arch.DumpTriple(s&: strm.AsRawOstream()); |
256 | strm.EOL(); |
257 | } |
258 | } |
259 | |
260 | llvm::VersionTuple os_version = GetOSVersion(); |
261 | if (!os_version.empty()) { |
262 | strm.Format(format: "OS Version: {0}", args: os_version.getAsString()); |
263 | |
264 | if (std::optional<std::string> s = GetOSBuildString()) |
265 | strm.Format(format: " ({0})", args&: *s); |
266 | |
267 | strm.EOL(); |
268 | } |
269 | |
270 | if (IsHost()) { |
271 | strm.Printf(format: " Hostname: %s\n", GetHostname()); |
272 | } else { |
273 | const bool is_connected = IsConnected(); |
274 | if (is_connected) |
275 | strm.Printf(format: " Hostname: %s\n", GetHostname()); |
276 | strm.Printf(format: " Connected: %s\n", is_connected ? "yes": "no"); |
277 | } |
278 | |
279 | if (const std::string &sdk_root = GetSDKRootDirectory(); !sdk_root.empty()) |
280 | strm.Format(format: " Sysroot: {0}\n", args: sdk_root); |
281 | |
282 | if (GetWorkingDirectory()) { |
283 | strm.Printf(format: "WorkingDir: %s\n", GetWorkingDirectory().GetPath().c_str()); |
284 | } |
285 | if (!IsConnected()) |
286 | return; |
287 | |
288 | std::string specific_info(GetPlatformSpecificConnectionInformation()); |
289 | |
290 | if (!specific_info.empty()) |
291 | strm.Printf(format: "Platform-specific connection: %s\n", specific_info.c_str()); |
292 | |
293 | if (std::optional<std::string> s = GetOSKernelDescription()) |
294 | strm.Format(format: " Kernel: {0}\n", args&: *s); |
295 | } |
296 | |
297 | llvm::VersionTuple Platform::GetOSVersion(Process *process) { |
298 | std::lock_guard<std::mutex> guard(m_mutex); |
299 | |
300 | if (IsHost()) { |
301 | if (m_os_version.empty()) { |
302 | // We have a local host platform |
303 | m_os_version = HostInfo::GetOSVersion(); |
304 | m_os_version_set_while_connected = !m_os_version.empty(); |
305 | } |
306 | } else { |
307 | // We have a remote platform. We can only fetch the remote |
308 | // OS version if we are connected, and we don't want to do it |
309 | // more than once. |
310 | |
311 | const bool is_connected = IsConnected(); |
312 | |
313 | bool fetch = false; |
314 | if (!m_os_version.empty()) { |
315 | // We have valid OS version info, check to make sure it wasn't manually |
316 | // set prior to connecting. If it was manually set prior to connecting, |
317 | // then lets fetch the actual OS version info if we are now connected. |
318 | if (is_connected && !m_os_version_set_while_connected) |
319 | fetch = true; |
320 | } else { |
321 | // We don't have valid OS version info, fetch it if we are connected |
322 | fetch = is_connected; |
323 | } |
324 | |
325 | if (fetch) |
326 | m_os_version_set_while_connected = GetRemoteOSVersion(); |
327 | } |
328 | |
329 | if (!m_os_version.empty()) |
330 | return m_os_version; |
331 | if (process) { |
332 | // Check with the process in case it can answer the question if a process |
333 | // was provided |
334 | return process->GetHostOSVersion(); |
335 | } |
336 | return llvm::VersionTuple(); |
337 | } |
338 | |
339 | std::optional<std::string> Platform::GetOSBuildString() { |
340 | if (IsHost()) |
341 | return HostInfo::GetOSBuildString(); |
342 | return GetRemoteOSBuildString(); |
343 | } |
344 | |
345 | std::optional<std::string> Platform::GetOSKernelDescription() { |
346 | if (IsHost()) |
347 | return HostInfo::GetOSKernelDescription(); |
348 | return GetRemoteOSKernelDescription(); |
349 | } |
350 | |
351 | void Platform::AddClangModuleCompilationOptions( |
352 | Target *target, std::vector<std::string> &options) { |
353 | std::vector<std::string> default_compilation_options = { |
354 | "-x", "c++", "-Xclang", "-nostdsysteminc", "-Xclang", "-nostdsysteminc"}; |
355 | |
356 | options.insert(position: options.end(), first: default_compilation_options.begin(), |
357 | last: default_compilation_options.end()); |
358 | } |
359 | |
360 | FileSpec Platform::GetWorkingDirectory() { |
361 | if (IsHost()) { |
362 | llvm::SmallString<64> cwd; |
363 | if (llvm::sys::fs::current_path(result&: cwd)) |
364 | return {}; |
365 | else { |
366 | FileSpec file_spec(cwd); |
367 | FileSystem::Instance().Resolve(file_spec); |
368 | return file_spec; |
369 | } |
370 | } else { |
371 | if (!m_working_dir) |
372 | m_working_dir = GetRemoteWorkingDirectory(); |
373 | return m_working_dir; |
374 | } |
375 | } |
376 | |
377 | struct RecurseCopyBaton { |
378 | const FileSpec &dst; |
379 | Platform *platform_ptr; |
380 | Status error; |
381 | }; |
382 | |
383 | static FileSystem::EnumerateDirectoryResult |
384 | RecurseCopy_Callback(void *baton, llvm::sys::fs::file_type ft, |
385 | llvm::StringRef path) { |
386 | RecurseCopyBaton *rc_baton = (RecurseCopyBaton *)baton; |
387 | FileSpec src(path); |
388 | namespace fs = llvm::sys::fs; |
389 | switch (ft) { |
390 | case fs::file_type::fifo_file: |
391 | case fs::file_type::socket_file: |
392 | // we have no way to copy pipes and sockets - ignore them and continue |
393 | return FileSystem::eEnumerateDirectoryResultNext; |
394 | break; |
395 | |
396 | case fs::file_type::directory_file: { |
397 | // make the new directory and get in there |
398 | FileSpec dst_dir = rc_baton->dst; |
399 | if (!dst_dir.GetFilename()) |
400 | dst_dir.SetFilename(src.GetFilename()); |
401 | Status error = rc_baton->platform_ptr->MakeDirectory( |
402 | file_spec: dst_dir, permissions: lldb::eFilePermissionsDirectoryDefault); |
403 | if (error.Fail()) { |
404 | rc_baton->error = Status::FromErrorStringWithFormatv( |
405 | format: "unable to setup directory {0} on remote end", args: dst_dir.GetPath()); |
406 | return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out |
407 | } |
408 | |
409 | // now recurse |
410 | std::string src_dir_path(src.GetPath()); |
411 | |
412 | // Make a filespec that only fills in the directory of a FileSpec so when |
413 | // we enumerate we can quickly fill in the filename for dst copies |
414 | FileSpec recurse_dst; |
415 | recurse_dst.SetDirectory(dst_dir.GetPathAsConstString()); |
416 | RecurseCopyBaton rc_baton2 = {.dst: recurse_dst, .platform_ptr: rc_baton->platform_ptr, |
417 | .error: Status()}; |
418 | FileSystem::Instance().EnumerateDirectory(path: src_dir_path, find_directories: true, find_files: true, find_other: true, |
419 | callback: RecurseCopy_Callback, callback_baton: &rc_baton2); |
420 | if (rc_baton2.error.Fail()) { |
421 | rc_baton->error = Status::FromErrorString(str: rc_baton2.error.AsCString()); |
422 | return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out |
423 | } |
424 | return FileSystem::eEnumerateDirectoryResultNext; |
425 | } break; |
426 | |
427 | case fs::file_type::symlink_file: { |
428 | // copy the file and keep going |
429 | FileSpec dst_file = rc_baton->dst; |
430 | if (!dst_file.GetFilename()) |
431 | dst_file.SetFilename(src.GetFilename()); |
432 | |
433 | FileSpec src_resolved; |
434 | |
435 | rc_baton->error = FileSystem::Instance().Readlink(src, dst&: src_resolved); |
436 | |
437 | if (rc_baton->error.Fail()) |
438 | return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out |
439 | |
440 | rc_baton->error = |
441 | rc_baton->platform_ptr->CreateSymlink(src: dst_file, dst: src_resolved); |
442 | |
443 | if (rc_baton->error.Fail()) |
444 | return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out |
445 | |
446 | return FileSystem::eEnumerateDirectoryResultNext; |
447 | } break; |
448 | |
449 | case fs::file_type::regular_file: { |
450 | // copy the file and keep going |
451 | FileSpec dst_file = rc_baton->dst; |
452 | if (!dst_file.GetFilename()) |
453 | dst_file.SetFilename(src.GetFilename()); |
454 | Status err = rc_baton->platform_ptr->PutFile(source: src, destination: dst_file); |
455 | if (err.Fail()) { |
456 | rc_baton->error = Status::FromErrorString(str: err.AsCString()); |
457 | return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out |
458 | } |
459 | return FileSystem::eEnumerateDirectoryResultNext; |
460 | } break; |
461 | |
462 | default: |
463 | rc_baton->error = Status::FromErrorStringWithFormat( |
464 | format: "invalid file detected during copy: %s", src.GetPath().c_str()); |
465 | return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out |
466 | break; |
467 | } |
468 | llvm_unreachable("Unhandled file_type!"); |
469 | } |
470 | |
471 | Status Platform::Install(const FileSpec &src, const FileSpec &dst) { |
472 | Status error; |
473 | |
474 | Log *log = GetLog(mask: LLDBLog::Platform); |
475 | LLDB_LOGF(log, "Platform::Install (src='%s', dst='%s')", |
476 | src.GetPath().c_str(), dst.GetPath().c_str()); |
477 | FileSpec fixed_dst(dst); |
478 | |
479 | if (!fixed_dst.GetFilename()) |
480 | fixed_dst.SetFilename(src.GetFilename()); |
481 | |
482 | FileSpec working_dir = GetWorkingDirectory(); |
483 | |
484 | if (dst) { |
485 | if (dst.GetDirectory()) { |
486 | const char first_dst_dir_char = dst.GetDirectory().GetCString()[0]; |
487 | if (first_dst_dir_char == '/' || first_dst_dir_char == '\\') { |
488 | fixed_dst.SetDirectory(dst.GetDirectory()); |
489 | } |
490 | // If the fixed destination file doesn't have a directory yet, then we |
491 | // must have a relative path. We will resolve this relative path against |
492 | // the platform's working directory |
493 | if (!fixed_dst.GetDirectory()) { |
494 | FileSpec relative_spec; |
495 | if (working_dir) { |
496 | relative_spec = working_dir; |
497 | relative_spec.AppendPathComponent(component: dst.GetPath()); |
498 | fixed_dst.SetDirectory(relative_spec.GetDirectory()); |
499 | } else { |
500 | error = Status::FromErrorStringWithFormat( |
501 | format: "platform working directory must be valid for relative path '%s'", |
502 | dst.GetPath().c_str()); |
503 | return error; |
504 | } |
505 | } |
506 | } else { |
507 | if (working_dir) { |
508 | fixed_dst.SetDirectory(working_dir.GetPathAsConstString()); |
509 | } else { |
510 | error = Status::FromErrorStringWithFormat( |
511 | format: "platform working directory must be valid for relative path '%s'", |
512 | dst.GetPath().c_str()); |
513 | return error; |
514 | } |
515 | } |
516 | } else { |
517 | if (working_dir) { |
518 | fixed_dst.SetDirectory(working_dir.GetPathAsConstString()); |
519 | } else { |
520 | error = |
521 | Status::FromErrorString(str: "platform working directory must be valid " |
522 | "when destination directory is empty"); |
523 | return error; |
524 | } |
525 | } |
526 | |
527 | LLDB_LOGF(log, "Platform::Install (src='%s', dst='%s') fixed_dst='%s'", |
528 | src.GetPath().c_str(), dst.GetPath().c_str(), |
529 | fixed_dst.GetPath().c_str()); |
530 | |
531 | if (GetSupportsRSync()) { |
532 | error = PutFile(source: src, destination: dst); |
533 | } else { |
534 | namespace fs = llvm::sys::fs; |
535 | switch (fs::get_file_type(Path: src.GetPath(), Follow: false)) { |
536 | case fs::file_type::directory_file: { |
537 | llvm::sys::fs::remove(path: fixed_dst.GetPath()); |
538 | uint32_t permissions = FileSystem::Instance().GetPermissions(file_spec: src); |
539 | if (permissions == 0) |
540 | permissions = eFilePermissionsDirectoryDefault; |
541 | error = MakeDirectory(file_spec: fixed_dst, permissions); |
542 | if (error.Success()) { |
543 | // Make a filespec that only fills in the directory of a FileSpec so |
544 | // when we enumerate we can quickly fill in the filename for dst copies |
545 | FileSpec recurse_dst; |
546 | recurse_dst.SetDirectory(fixed_dst.GetPathAsConstString()); |
547 | std::string src_dir_path(src.GetPath()); |
548 | RecurseCopyBaton baton = {.dst: recurse_dst, .platform_ptr: this, .error: Status()}; |
549 | FileSystem::Instance().EnumerateDirectory( |
550 | path: src_dir_path, find_directories: true, find_files: true, find_other: true, callback: RecurseCopy_Callback, callback_baton: &baton); |
551 | return std::move(baton.error); |
552 | } |
553 | } break; |
554 | |
555 | case fs::file_type::regular_file: |
556 | llvm::sys::fs::remove(path: fixed_dst.GetPath()); |
557 | error = PutFile(source: src, destination: fixed_dst); |
558 | break; |
559 | |
560 | case fs::file_type::symlink_file: { |
561 | llvm::sys::fs::remove(path: fixed_dst.GetPath()); |
562 | FileSpec src_resolved; |
563 | error = FileSystem::Instance().Readlink(src, dst&: src_resolved); |
564 | if (error.Success()) |
565 | error = CreateSymlink(src: dst, dst: src_resolved); |
566 | } break; |
567 | case fs::file_type::fifo_file: |
568 | error = Status::FromErrorString(str: "platform install doesn't handle pipes"); |
569 | break; |
570 | case fs::file_type::socket_file: |
571 | error = |
572 | Status::FromErrorString(str: "platform install doesn't handle sockets"); |
573 | break; |
574 | default: |
575 | error = Status::FromErrorString( |
576 | str: "platform install doesn't handle non file or directory items"); |
577 | break; |
578 | } |
579 | } |
580 | return error; |
581 | } |
582 | |
583 | bool Platform::SetWorkingDirectory(const FileSpec &file_spec) { |
584 | if (IsHost()) { |
585 | Log *log = GetLog(mask: LLDBLog::Platform); |
586 | LLDB_LOG(log, "{0}", file_spec); |
587 | if (std::error_code ec = llvm::sys::fs::set_current_path(file_spec.GetPath())) { |
588 | LLDB_LOG(log, "error: {0}", ec.message()); |
589 | return false; |
590 | } |
591 | return true; |
592 | } else { |
593 | m_working_dir.Clear(); |
594 | return SetRemoteWorkingDirectory(file_spec); |
595 | } |
596 | } |
597 | |
598 | Status Platform::MakeDirectory(const FileSpec &file_spec, |
599 | uint32_t permissions) { |
600 | if (IsHost()) |
601 | return llvm::sys::fs::create_directory(path: file_spec.GetPath(), IgnoreExisting: permissions); |
602 | else { |
603 | Status error; |
604 | return Status::FromErrorStringWithFormatv( |
605 | format: "remote platform {0} doesn't support {1}", args: GetPluginName(), |
606 | LLVM_PRETTY_FUNCTION); |
607 | return error; |
608 | } |
609 | } |
610 | |
611 | Status Platform::GetFilePermissions(const FileSpec &file_spec, |
612 | uint32_t &file_permissions) { |
613 | if (IsHost()) { |
614 | auto Value = llvm::sys::fs::getPermissions(Path: file_spec.GetPath()); |
615 | if (Value) |
616 | file_permissions = Value.get(); |
617 | return Status(Value.getError()); |
618 | } else { |
619 | Status error; |
620 | return Status::FromErrorStringWithFormatv( |
621 | format: "remote platform {0} doesn't support {1}", args: GetPluginName(), |
622 | LLVM_PRETTY_FUNCTION); |
623 | return error; |
624 | } |
625 | } |
626 | |
627 | Status Platform::SetFilePermissions(const FileSpec &file_spec, |
628 | uint32_t file_permissions) { |
629 | if (IsHost()) { |
630 | auto Perms = static_cast<llvm::sys::fs::perms>(file_permissions); |
631 | return llvm::sys::fs::setPermissions(Path: file_spec.GetPath(), Permissions: Perms); |
632 | } else { |
633 | Status error; |
634 | return Status::FromErrorStringWithFormatv( |
635 | format: "remote platform {0} doesn't support {1}", args: GetPluginName(), |
636 | LLVM_PRETTY_FUNCTION); |
637 | return error; |
638 | } |
639 | } |
640 | |
641 | user_id_t Platform::OpenFile(const FileSpec &file_spec, |
642 | File::OpenOptions flags, uint32_t mode, |
643 | Status &error) { |
644 | if (IsHost()) |
645 | return FileCache::GetInstance().OpenFile(file_spec, flags, mode, error); |
646 | return UINT64_MAX; |
647 | } |
648 | |
649 | bool Platform::CloseFile(user_id_t fd, Status &error) { |
650 | if (IsHost()) |
651 | return FileCache::GetInstance().CloseFile(fd, error); |
652 | return false; |
653 | } |
654 | |
655 | user_id_t Platform::GetFileSize(const FileSpec &file_spec) { |
656 | if (!IsHost()) |
657 | return UINT64_MAX; |
658 | |
659 | uint64_t Size; |
660 | if (llvm::sys::fs::file_size(Path: file_spec.GetPath(), Result&: Size)) |
661 | return 0; |
662 | return Size; |
663 | } |
664 | |
665 | uint64_t Platform::ReadFile(lldb::user_id_t fd, uint64_t offset, void *dst, |
666 | uint64_t dst_len, Status &error) { |
667 | if (IsHost()) |
668 | return FileCache::GetInstance().ReadFile(fd, offset, dst, dst_len, error); |
669 | error = Status::FromErrorStringWithFormatv( |
670 | format: "Platform::ReadFile() is not supported in the {0} platform", |
671 | args: GetPluginName()); |
672 | return -1; |
673 | } |
674 | |
675 | uint64_t Platform::WriteFile(lldb::user_id_t fd, uint64_t offset, |
676 | const void *src, uint64_t src_len, Status &error) { |
677 | if (IsHost()) |
678 | return FileCache::GetInstance().WriteFile(fd, offset, src, src_len, error); |
679 | error = Status::FromErrorStringWithFormatv( |
680 | format: "Platform::WriteFile() is not supported in the {0} platform", |
681 | args: GetPluginName()); |
682 | return -1; |
683 | } |
684 | |
685 | UserIDResolver &Platform::GetUserIDResolver() { |
686 | if (IsHost()) |
687 | return HostInfo::GetUserIDResolver(); |
688 | return UserIDResolver::GetNoopResolver(); |
689 | } |
690 | |
691 | const char *Platform::GetHostname() { |
692 | if (IsHost()) |
693 | return "127.0.0.1"; |
694 | |
695 | if (m_hostname.empty()) |
696 | return nullptr; |
697 | return m_hostname.c_str(); |
698 | } |
699 | |
700 | ConstString Platform::GetFullNameForDylib(ConstString basename) { |
701 | return basename; |
702 | } |
703 | |
704 | bool Platform::SetRemoteWorkingDirectory(const FileSpec &working_dir) { |
705 | Log *log = GetLog(mask: LLDBLog::Platform); |
706 | LLDB_LOGF(log, "Platform::SetRemoteWorkingDirectory('%s')", |
707 | working_dir.GetPath().c_str()); |
708 | m_working_dir = working_dir; |
709 | return true; |
710 | } |
711 | |
712 | bool Platform::SetOSVersion(llvm::VersionTuple version) { |
713 | if (IsHost()) { |
714 | // We don't need anyone setting the OS version for the host platform, we |
715 | // should be able to figure it out by calling HostInfo::GetOSVersion(...). |
716 | return false; |
717 | } else { |
718 | // We have a remote platform, allow setting the target OS version if we |
719 | // aren't connected, since if we are connected, we should be able to |
720 | // request the remote OS version from the connected platform. |
721 | if (IsConnected()) |
722 | return false; |
723 | else { |
724 | // We aren't connected and we might want to set the OS version ahead of |
725 | // time before we connect so we can peruse files and use a local SDK or |
726 | // PDK cache of support files to disassemble or do other things. |
727 | m_os_version = version; |
728 | return true; |
729 | } |
730 | } |
731 | return false; |
732 | } |
733 | |
734 | Status |
735 | Platform::ResolveExecutable(const ModuleSpec &module_spec, |
736 | lldb::ModuleSP &exe_module_sp, |
737 | const FileSpecList *module_search_paths_ptr) { |
738 | |
739 | // We may connect to a process and use the provided executable (Don't use |
740 | // local $PATH). |
741 | ModuleSpec resolved_module_spec(module_spec); |
742 | |
743 | // Resolve any executable within a bundle on MacOSX |
744 | Host::ResolveExecutableInBundle(file&: resolved_module_spec.GetFileSpec()); |
745 | |
746 | if (!FileSystem::Instance().Exists(file_spec: resolved_module_spec.GetFileSpec()) && |
747 | !module_spec.GetUUID().IsValid()) |
748 | return Status::FromErrorStringWithFormatv( |
749 | format: "'{0}' does not exist", args&: resolved_module_spec.GetFileSpec()); |
750 | |
751 | if (resolved_module_spec.GetArchitecture().IsValid() || |
752 | resolved_module_spec.GetUUID().IsValid()) { |
753 | Status error = |
754 | ModuleList::GetSharedModule(module_spec: resolved_module_spec, module_sp&: exe_module_sp, |
755 | module_search_paths_ptr, old_modules: nullptr, did_create_ptr: nullptr); |
756 | |
757 | if (exe_module_sp && exe_module_sp->GetObjectFile()) |
758 | return error; |
759 | exe_module_sp.reset(); |
760 | } |
761 | // No valid architecture was specified or the exact arch wasn't found. |
762 | // Ask the platform for the architectures that we should be using (in the |
763 | // correct order) and see if we can find a match that way. |
764 | StreamString arch_names; |
765 | llvm::ListSeparator LS; |
766 | ArchSpec process_host_arch; |
767 | Status error; |
768 | for (const ArchSpec &arch : GetSupportedArchitectures(process_host_arch)) { |
769 | resolved_module_spec.GetArchitecture() = arch; |
770 | error = |
771 | ModuleList::GetSharedModule(module_spec: resolved_module_spec, module_sp&: exe_module_sp, |
772 | module_search_paths_ptr, old_modules: nullptr, did_create_ptr: nullptr); |
773 | if (error.Success()) { |
774 | if (exe_module_sp && exe_module_sp->GetObjectFile()) |
775 | break; |
776 | error = Status::FromErrorString(str: "no exe object file"); |
777 | } |
778 | |
779 | arch_names << LS << arch.GetArchitectureName(); |
780 | } |
781 | |
782 | if (exe_module_sp && error.Success()) |
783 | return {}; |
784 | |
785 | if (!FileSystem::Instance().Readable(file_spec: resolved_module_spec.GetFileSpec())) |
786 | return Status::FromErrorStringWithFormatv( |
787 | format: "'{0}' is not readable", args&: resolved_module_spec.GetFileSpec()); |
788 | |
789 | if (!ObjectFile::IsObjectFile(file_spec: resolved_module_spec.GetFileSpec())) |
790 | return Status::FromErrorStringWithFormatv( |
791 | format: "'{0}' is not a valid executable", args&: resolved_module_spec.GetFileSpec()); |
792 | |
793 | return Status::FromErrorStringWithFormatv( |
794 | format: "'{0}' doesn't contain any '{1}' platform architectures: {2}", |
795 | args&: resolved_module_spec.GetFileSpec(), args: GetPluginName(), |
796 | args: arch_names.GetData()); |
797 | } |
798 | |
799 | Status Platform::ResolveSymbolFile(Target &target, const ModuleSpec &sym_spec, |
800 | FileSpec &sym_file) { |
801 | Status error; |
802 | if (FileSystem::Instance().Exists(file_spec: sym_spec.GetSymbolFileSpec())) |
803 | sym_file = sym_spec.GetSymbolFileSpec(); |
804 | else |
805 | error = Status::FromErrorString(str: "unable to resolve symbol file"); |
806 | return error; |
807 | } |
808 | |
809 | bool Platform::ResolveRemotePath(const FileSpec &platform_path, |
810 | FileSpec &resolved_platform_path) { |
811 | resolved_platform_path = platform_path; |
812 | FileSystem::Instance().Resolve(file_spec&: resolved_platform_path); |
813 | return true; |
814 | } |
815 | |
816 | const ArchSpec &Platform::GetSystemArchitecture() { |
817 | if (IsHost()) { |
818 | if (!m_system_arch.IsValid()) { |
819 | // We have a local host platform |
820 | m_system_arch = HostInfo::GetArchitecture(); |
821 | m_system_arch_set_while_connected = m_system_arch.IsValid(); |
822 | } |
823 | } else { |
824 | // We have a remote platform. We can only fetch the remote system |
825 | // architecture if we are connected, and we don't want to do it more than |
826 | // once. |
827 | |
828 | const bool is_connected = IsConnected(); |
829 | |
830 | bool fetch = false; |
831 | if (m_system_arch.IsValid()) { |
832 | // We have valid OS version info, check to make sure it wasn't manually |
833 | // set prior to connecting. If it was manually set prior to connecting, |
834 | // then lets fetch the actual OS version info if we are now connected. |
835 | if (is_connected && !m_system_arch_set_while_connected) |
836 | fetch = true; |
837 | } else { |
838 | // We don't have valid OS version info, fetch it if we are connected |
839 | fetch = is_connected; |
840 | } |
841 | |
842 | if (fetch) { |
843 | m_system_arch = GetRemoteSystemArchitecture(); |
844 | m_system_arch_set_while_connected = m_system_arch.IsValid(); |
845 | } |
846 | } |
847 | return m_system_arch; |
848 | } |
849 | |
850 | ArchSpec Platform::GetAugmentedArchSpec(llvm::StringRef triple) { |
851 | if (triple.empty()) |
852 | return ArchSpec(); |
853 | llvm::Triple normalized_triple(llvm::Triple::normalize(Str: triple)); |
854 | if (!ArchSpec::ContainsOnlyArch(normalized_triple)) |
855 | return ArchSpec(triple); |
856 | |
857 | if (auto kind = HostInfo::ParseArchitectureKind(kind: triple)) |
858 | return HostInfo::GetArchitecture(arch_kind: *kind); |
859 | |
860 | ArchSpec compatible_arch; |
861 | ArchSpec raw_arch(triple); |
862 | if (!IsCompatibleArchitecture(arch: raw_arch, process_host_arch: {}, match: ArchSpec::CompatibleMatch, |
863 | compatible_arch_ptr: &compatible_arch)) |
864 | return raw_arch; |
865 | |
866 | if (!compatible_arch.IsValid()) |
867 | return ArchSpec(normalized_triple); |
868 | |
869 | const llvm::Triple &compatible_triple = compatible_arch.GetTriple(); |
870 | if (normalized_triple.getVendorName().empty()) |
871 | normalized_triple.setVendor(compatible_triple.getVendor()); |
872 | if (normalized_triple.getOSName().empty()) |
873 | normalized_triple.setOS(compatible_triple.getOS()); |
874 | if (normalized_triple.getEnvironmentName().empty()) |
875 | normalized_triple.setEnvironment(compatible_triple.getEnvironment()); |
876 | return ArchSpec(normalized_triple); |
877 | } |
878 | |
879 | Status Platform::ConnectRemote(Args &args) { |
880 | Status error; |
881 | if (IsHost()) |
882 | return Status::FromErrorStringWithFormatv( |
883 | format: "The currently selected platform ({0}) is " |
884 | "the host platform and is always connected.", |
885 | args: GetPluginName()); |
886 | else |
887 | return Status::FromErrorStringWithFormatv( |
888 | format: "Platform::ConnectRemote() is not supported by {0}", args: GetPluginName()); |
889 | return error; |
890 | } |
891 | |
892 | Status Platform::DisconnectRemote() { |
893 | Status error; |
894 | if (IsHost()) |
895 | return Status::FromErrorStringWithFormatv( |
896 | format: "The currently selected platform ({0}) is " |
897 | "the host platform and is always connected.", |
898 | args: GetPluginName()); |
899 | else |
900 | return Status::FromErrorStringWithFormatv( |
901 | format: "Platform::DisconnectRemote() is not supported by {0}", |
902 | args: GetPluginName()); |
903 | return error; |
904 | } |
905 | |
906 | bool Platform::GetProcessInfo(lldb::pid_t pid, |
907 | ProcessInstanceInfo &process_info) { |
908 | // Take care of the host case so that each subclass can just call this |
909 | // function to get the host functionality. |
910 | if (IsHost()) |
911 | return Host::GetProcessInfo(pid, proc_info&: process_info); |
912 | return false; |
913 | } |
914 | |
915 | uint32_t Platform::FindProcesses(const ProcessInstanceInfoMatch &match_info, |
916 | ProcessInstanceInfoList &process_infos) { |
917 | // Take care of the host case so that each subclass can just call this |
918 | // function to get the host functionality. |
919 | uint32_t match_count = 0; |
920 | if (IsHost()) |
921 | match_count = Host::FindProcesses(match_info, proc_infos&: process_infos); |
922 | return match_count; |
923 | } |
924 | |
925 | ProcessInstanceInfoList Platform::GetAllProcesses() { |
926 | ProcessInstanceInfoList processes; |
927 | ProcessInstanceInfoMatch match; |
928 | assert(match.MatchAllProcesses()); |
929 | FindProcesses(match_info: match, process_infos&: processes); |
930 | return processes; |
931 | } |
932 | |
933 | Status Platform::LaunchProcess(ProcessLaunchInfo &launch_info) { |
934 | Status error; |
935 | Log *log = GetLog(mask: LLDBLog::Platform); |
936 | LLDB_LOGF(log, "Platform::%s()", __FUNCTION__); |
937 | |
938 | // Take care of the host case so that each subclass can just call this |
939 | // function to get the host functionality. |
940 | if (IsHost()) { |
941 | if (::getenv(name: "LLDB_LAUNCH_FLAG_LAUNCH_IN_TTY")) |
942 | launch_info.GetFlags().Set(eLaunchFlagLaunchInTTY); |
943 | |
944 | if (launch_info.GetFlags().Test(bit: eLaunchFlagLaunchInShell)) { |
945 | const bool will_debug = launch_info.GetFlags().Test(bit: eLaunchFlagDebug); |
946 | const bool first_arg_is_full_shell_command = false; |
947 | uint32_t num_resumes = GetResumeCountForLaunchInfo(launch_info); |
948 | if (log) { |
949 | const FileSpec &shell = launch_info.GetShell(); |
950 | std::string shell_str = (shell) ? shell.GetPath() : "<null>"; |
951 | LLDB_LOGF(log, |
952 | "Platform::%s GetResumeCountForLaunchInfo() returned %"PRIu32 |
953 | ", shell is '%s'", |
954 | __FUNCTION__, num_resumes, shell_str.c_str()); |
955 | } |
956 | |
957 | if (!launch_info.ConvertArgumentsForLaunchingInShell( |
958 | error, will_debug, first_arg_is_full_shell_command, num_resumes)) |
959 | return error; |
960 | } else if (launch_info.GetFlags().Test(bit: eLaunchFlagShellExpandArguments)) { |
961 | error = ShellExpandArguments(launch_info); |
962 | if (error.Fail()) { |
963 | error = Status::FromErrorStringWithFormat( |
964 | format: "shell expansion failed (reason: %s). " |
965 | "consider launching with 'process " |
966 | "launch'.", |
967 | error.AsCString(default_error_str: "unknown")); |
968 | return error; |
969 | } |
970 | } |
971 | |
972 | LLDB_LOGF(log, "Platform::%s final launch_info resume count: %"PRIu32, |
973 | __FUNCTION__, launch_info.GetResumeCount()); |
974 | |
975 | error = Host::LaunchProcess(launch_info); |
976 | } else |
977 | error = Status::FromErrorString( |
978 | str: "base lldb_private::Platform class can't launch remote processes"); |
979 | return error; |
980 | } |
981 | |
982 | Status Platform::ShellExpandArguments(ProcessLaunchInfo &launch_info) { |
983 | if (IsHost()) |
984 | return Host::ShellExpandArguments(launch_info); |
985 | return Status::FromErrorString( |
986 | str: "base lldb_private::Platform class can't expand arguments"); |
987 | } |
988 | |
989 | Status Platform::KillProcess(const lldb::pid_t pid) { |
990 | Log *log = GetLog(mask: LLDBLog::Platform); |
991 | LLDB_LOGF(log, "Platform::%s, pid %"PRIu64, __FUNCTION__, pid); |
992 | |
993 | if (!IsHost()) { |
994 | return Status::FromErrorString( |
995 | str: "base lldb_private::Platform class can't kill remote processes"); |
996 | } |
997 | Host::Kill(pid, SIGKILL); |
998 | return Status(); |
999 | } |
1000 | |
1001 | lldb::ProcessSP Platform::DebugProcess(ProcessLaunchInfo &launch_info, |
1002 | Debugger &debugger, Target &target, |
1003 | Status &error) { |
1004 | Log *log = GetLog(mask: LLDBLog::Platform); |
1005 | LLDB_LOG(log, "target = {0}", &target); |
1006 | |
1007 | ProcessSP process_sp; |
1008 | // Make sure we stop at the entry point |
1009 | launch_info.GetFlags().Set(eLaunchFlagDebug); |
1010 | // We always launch the process we are going to debug in a separate process |
1011 | // group, since then we can handle ^C interrupts ourselves w/o having to |
1012 | // worry about the target getting them as well. |
1013 | launch_info.SetLaunchInSeparateProcessGroup(true); |
1014 | |
1015 | // Allow any StructuredData process-bound plugins to adjust the launch info |
1016 | // if needed |
1017 | size_t i = 0; |
1018 | bool iteration_complete = false; |
1019 | // Note iteration can't simply go until a nullptr callback is returned, as it |
1020 | // is valid for a plugin to not supply a filter. |
1021 | auto get_filter_func = PluginManager::GetStructuredDataFilterCallbackAtIndex; |
1022 | for (auto filter_callback = get_filter_func(i, iteration_complete); |
1023 | !iteration_complete; |
1024 | filter_callback = get_filter_func(++i, iteration_complete)) { |
1025 | if (filter_callback) { |
1026 | // Give this ProcessLaunchInfo filter a chance to adjust the launch info. |
1027 | error = (*filter_callback)(launch_info, &target); |
1028 | if (!error.Success()) { |
1029 | LLDB_LOGF(log, |
1030 | "Platform::%s() StructuredDataPlugin launch " |
1031 | "filter failed.", |
1032 | __FUNCTION__); |
1033 | return process_sp; |
1034 | } |
1035 | } |
1036 | } |
1037 | |
1038 | error = LaunchProcess(launch_info); |
1039 | if (error.Success()) { |
1040 | LLDB_LOGF(log, |
1041 | "Platform::%s LaunchProcess() call succeeded (pid=%"PRIu64 ")", |
1042 | __FUNCTION__, launch_info.GetProcessID()); |
1043 | if (launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID) { |
1044 | ProcessAttachInfo attach_info(launch_info); |
1045 | process_sp = Attach(attach_info, debugger, target: &target, error); |
1046 | if (process_sp) { |
1047 | LLDB_LOG(log, "Attach() succeeded, Process plugin: {0}", |
1048 | process_sp->GetPluginName()); |
1049 | launch_info.SetHijackListener(attach_info.GetHijackListener()); |
1050 | |
1051 | // Since we attached to the process, it will think it needs to detach |
1052 | // if the process object just goes away without an explicit call to |
1053 | // Process::Kill() or Process::Detach(), so let it know to kill the |
1054 | // process if this happens. |
1055 | process_sp->SetShouldDetach(false); |
1056 | |
1057 | // If we didn't have any file actions, the pseudo terminal might have |
1058 | // been used where the secondary side was given as the file to open for |
1059 | // stdin/out/err after we have already opened the primary so we can |
1060 | // read/write stdin/out/err. |
1061 | int pty_fd = launch_info.GetPTY().ReleasePrimaryFileDescriptor(); |
1062 | if (pty_fd != PseudoTerminal::invalid_fd) { |
1063 | process_sp->SetSTDIOFileDescriptor(pty_fd); |
1064 | } |
1065 | } else { |
1066 | LLDB_LOGF(log, "Platform::%s Attach() failed: %s", __FUNCTION__, |
1067 | error.AsCString()); |
1068 | } |
1069 | } else { |
1070 | LLDB_LOGF(log, |
1071 | "Platform::%s LaunchProcess() returned launch_info with " |
1072 | "invalid process id", |
1073 | __FUNCTION__); |
1074 | } |
1075 | } else { |
1076 | LLDB_LOGF(log, "Platform::%s LaunchProcess() failed: %s", __FUNCTION__, |
1077 | error.AsCString()); |
1078 | } |
1079 | |
1080 | return process_sp; |
1081 | } |
1082 | |
1083 | std::vector<ArchSpec> |
1084 | Platform::CreateArchList(llvm::ArrayRef<llvm::Triple::ArchType> archs, |
1085 | llvm::Triple::OSType os) { |
1086 | std::vector<ArchSpec> list; |
1087 | for(auto arch : archs) { |
1088 | llvm::Triple triple; |
1089 | triple.setArch(Kind: arch); |
1090 | triple.setOS(os); |
1091 | list.push_back(x: ArchSpec(triple)); |
1092 | } |
1093 | return list; |
1094 | } |
1095 | |
1096 | /// Lets a platform answer if it is compatible with a given |
1097 | /// architecture and the target triple contained within. |
1098 | bool Platform::IsCompatibleArchitecture(const ArchSpec &arch, |
1099 | const ArchSpec &process_host_arch, |
1100 | ArchSpec::MatchType match, |
1101 | ArchSpec *compatible_arch_ptr) { |
1102 | // If the architecture is invalid, we must answer true... |
1103 | if (arch.IsValid()) { |
1104 | ArchSpec platform_arch; |
1105 | for (const ArchSpec &platform_arch : |
1106 | GetSupportedArchitectures(process_host_arch)) { |
1107 | if (arch.IsMatch(rhs: platform_arch, match)) { |
1108 | if (compatible_arch_ptr) |
1109 | *compatible_arch_ptr = platform_arch; |
1110 | return true; |
1111 | } |
1112 | } |
1113 | } |
1114 | if (compatible_arch_ptr) |
1115 | compatible_arch_ptr->Clear(); |
1116 | return false; |
1117 | } |
1118 | |
1119 | Status Platform::PutFile(const FileSpec &source, const FileSpec &destination, |
1120 | uint32_t uid, uint32_t gid) { |
1121 | Log *log = GetLog(mask: LLDBLog::Platform); |
1122 | LLDB_LOGF(log, "[PutFile] Using block by block transfer....\n"); |
1123 | |
1124 | auto source_open_options = |
1125 | File::eOpenOptionReadOnly | File::eOpenOptionCloseOnExec; |
1126 | namespace fs = llvm::sys::fs; |
1127 | if (fs::is_symlink_file(Path: source.GetPath())) |
1128 | source_open_options |= File::eOpenOptionDontFollowSymlinks; |
1129 | |
1130 | auto source_file = FileSystem::Instance().Open(file_spec: source, options: source_open_options, |
1131 | permissions: lldb::eFilePermissionsUserRW); |
1132 | if (!source_file) |
1133 | return Status::FromError(error: source_file.takeError()); |
1134 | Status error; |
1135 | |
1136 | bool requires_upload = true; |
1137 | llvm::ErrorOr<llvm::MD5::MD5Result> remote_md5 = CalculateMD5(file_spec: destination); |
1138 | if (std::error_code ec = remote_md5.getError()) { |
1139 | LLDB_LOG(log, "[PutFile] couldn't get md5 sum of destination: {0}", |
1140 | ec.message()); |
1141 | } else { |
1142 | llvm::ErrorOr<llvm::MD5::MD5Result> local_md5 = |
1143 | llvm::sys::fs::md5_contents(Path: source.GetPath()); |
1144 | if (std::error_code ec = local_md5.getError()) { |
1145 | LLDB_LOG(log, "[PutFile] couldn't get md5 sum of source: {0}", |
1146 | ec.message()); |
1147 | } else { |
1148 | LLDB_LOGF(log, "[PutFile] destination md5: %016"PRIx64 "%016"PRIx64, |
1149 | remote_md5->high(), remote_md5->low()); |
1150 | LLDB_LOGF(log, "[PutFile] local md5: %016"PRIx64 "%016"PRIx64, |
1151 | local_md5->high(), local_md5->low()); |
1152 | requires_upload = *remote_md5 != *local_md5; |
1153 | } |
1154 | } |
1155 | |
1156 | if (!requires_upload) { |
1157 | LLDB_LOGF(log, "[PutFile] skipping PutFile because md5sums match"); |
1158 | return error; |
1159 | } |
1160 | |
1161 | uint32_t permissions = source_file.get()->GetPermissions(error); |
1162 | if (permissions == 0) |
1163 | permissions = lldb::eFilePermissionsUserRWX; |
1164 | |
1165 | lldb::user_id_t dest_file = OpenFile( |
1166 | file_spec: destination, flags: File::eOpenOptionCanCreate | File::eOpenOptionWriteOnly | |
1167 | File::eOpenOptionTruncate | File::eOpenOptionCloseOnExec, |
1168 | mode: permissions, error); |
1169 | LLDB_LOGF(log, "dest_file = %"PRIu64 "\n", dest_file); |
1170 | |
1171 | if (error.Fail()) |
1172 | return error; |
1173 | if (dest_file == UINT64_MAX) |
1174 | return Status::FromErrorString(str: "unable to open target file"); |
1175 | lldb::WritableDataBufferSP buffer_sp(new DataBufferHeap(1024 * 16, 0)); |
1176 | uint64_t offset = 0; |
1177 | for (;;) { |
1178 | size_t bytes_read = buffer_sp->GetByteSize(); |
1179 | error = source_file.get()->Read(buf: buffer_sp->GetBytes(), num_bytes&: bytes_read); |
1180 | if (error.Fail() || bytes_read == 0) |
1181 | break; |
1182 | |
1183 | const uint64_t bytes_written = |
1184 | WriteFile(fd: dest_file, offset, src: buffer_sp->GetBytes(), src_len: bytes_read, error); |
1185 | if (error.Fail()) |
1186 | break; |
1187 | |
1188 | offset += bytes_written; |
1189 | if (bytes_written != bytes_read) { |
1190 | // We didn't write the correct number of bytes, so adjust the file |
1191 | // position in the source file we are reading from... |
1192 | source_file.get()->SeekFromStart(offset); |
1193 | } |
1194 | } |
1195 | CloseFile(fd: dest_file, error); |
1196 | |
1197 | if (uid == UINT32_MAX && gid == UINT32_MAX) |
1198 | return error; |
1199 | |
1200 | // TODO: ChownFile? |
1201 | |
1202 | return error; |
1203 | } |
1204 | |
1205 | Status Platform::GetFile(const FileSpec &source, const FileSpec &destination) { |
1206 | return Status::FromErrorString(str: "unimplemented"); |
1207 | } |
1208 | |
1209 | Status |
1210 | Platform::CreateSymlink(const FileSpec &src, // The name of the link is in src |
1211 | const FileSpec &dst) // The symlink points to dst |
1212 | { |
1213 | if (IsHost()) |
1214 | return FileSystem::Instance().Symlink(src, dst); |
1215 | return Status::FromErrorString(str: "unimplemented"); |
1216 | } |
1217 | |
1218 | bool Platform::GetFileExists(const lldb_private::FileSpec &file_spec) { |
1219 | if (IsHost()) |
1220 | return FileSystem::Instance().Exists(file_spec); |
1221 | return false; |
1222 | } |
1223 | |
1224 | Status Platform::Unlink(const FileSpec &path) { |
1225 | if (IsHost()) |
1226 | return llvm::sys::fs::remove(path: path.GetPath()); |
1227 | return Status::FromErrorString(str: "unimplemented"); |
1228 | } |
1229 | |
1230 | MmapArgList Platform::GetMmapArgumentList(const ArchSpec &arch, addr_t addr, |
1231 | addr_t length, unsigned prot, |
1232 | unsigned flags, addr_t fd, |
1233 | addr_t offset) { |
1234 | uint64_t flags_platform = 0; |
1235 | if (flags & eMmapFlagsPrivate) |
1236 | flags_platform |= MAP_PRIVATE; |
1237 | if (flags & eMmapFlagsAnon) |
1238 | flags_platform |= MAP_ANON; |
1239 | |
1240 | MmapArgList args({addr, length, prot, flags_platform, fd, offset}); |
1241 | return args; |
1242 | } |
1243 | |
1244 | lldb_private::Status Platform::RunShellCommand( |
1245 | llvm::StringRef command, |
1246 | const FileSpec & |
1247 | working_dir, // Pass empty FileSpec to use the current working directory |
1248 | int *status_ptr, // Pass nullptr if you don't want the process exit status |
1249 | int *signo_ptr, // Pass nullptr if you don't want the signal that caused the |
1250 | // process to exit |
1251 | std::string |
1252 | *command_output, // Pass nullptr if you don't want the command output |
1253 | const Timeout<std::micro> &timeout) { |
1254 | return RunShellCommand(shell: llvm::StringRef(), command, working_dir, status_ptr, |
1255 | signo_ptr, command_output, timeout); |
1256 | } |
1257 | |
1258 | lldb_private::Status Platform::RunShellCommand( |
1259 | llvm::StringRef shell, // Pass empty if you want to use the default |
1260 | // shell interpreter |
1261 | llvm::StringRef command, // Shouldn't be empty |
1262 | const FileSpec & |
1263 | working_dir, // Pass empty FileSpec to use the current working directory |
1264 | int *status_ptr, // Pass nullptr if you don't want the process exit status |
1265 | int *signo_ptr, // Pass nullptr if you don't want the signal that caused the |
1266 | // process to exit |
1267 | std::string |
1268 | *command_output, // Pass nullptr if you don't want the command output |
1269 | const Timeout<std::micro> &timeout) { |
1270 | if (IsHost()) |
1271 | return Host::RunShellCommand(shell, command, working_dir, status_ptr, |
1272 | signo_ptr, command_output, timeout); |
1273 | return Status::FromErrorString( |
1274 | str: "unable to run a remote command without a platform"); |
1275 | } |
1276 | |
1277 | llvm::ErrorOr<llvm::MD5::MD5Result> |
1278 | Platform::CalculateMD5(const FileSpec &file_spec) { |
1279 | if (!IsHost()) |
1280 | return std::make_error_code(e: std::errc::not_supported); |
1281 | return llvm::sys::fs::md5_contents(Path: file_spec.GetPath()); |
1282 | } |
1283 | |
1284 | void Platform::SetLocalCacheDirectory(const char *local) { |
1285 | m_local_cache_directory.assign(s: local); |
1286 | } |
1287 | |
1288 | const char *Platform::GetLocalCacheDirectory() { |
1289 | return m_local_cache_directory.c_str(); |
1290 | } |
1291 | |
1292 | static constexpr OptionDefinition g_rsync_option_table[] = { |
1293 | {LLDB_OPT_SET_ALL, .required: false, .long_option: "rsync", .short_option: 'r', .option_has_arg: OptionParser::eNoArgument, .validator: nullptr, |
1294 | .enum_values: {}, .completion_type: 0, .argument_type: eArgTypeNone, .usage_text: "Enable rsync."}, |
1295 | {LLDB_OPT_SET_ALL, .required: false, .long_option: "rsync-opts", .short_option: 'R', |
1296 | .option_has_arg: OptionParser::eRequiredArgument, .validator: nullptr, .enum_values: {}, .completion_type: 0, .argument_type: eArgTypeCommandName, |
1297 | .usage_text: "Platform-specific options required for rsync to work."}, |
1298 | {LLDB_OPT_SET_ALL, .required: false, .long_option: "rsync-prefix", .short_option: 'P', |
1299 | .option_has_arg: OptionParser::eRequiredArgument, .validator: nullptr, .enum_values: {}, .completion_type: 0, .argument_type: eArgTypeCommandName, |
1300 | .usage_text: "Platform-specific rsync prefix put before the remote path."}, |
1301 | {LLDB_OPT_SET_ALL, .required: false, .long_option: "ignore-remote-hostname", .short_option: 'i', |
1302 | .option_has_arg: OptionParser::eNoArgument, .validator: nullptr, .enum_values: {}, .completion_type: 0, .argument_type: eArgTypeNone, |
1303 | .usage_text: "Do not automatically fill in the remote hostname when composing the " |
1304 | "rsync command."}, |
1305 | }; |
1306 | |
1307 | static constexpr OptionDefinition g_ssh_option_table[] = { |
1308 | {LLDB_OPT_SET_ALL, .required: false, .long_option: "ssh", .short_option: 's', .option_has_arg: OptionParser::eNoArgument, .validator: nullptr, |
1309 | .enum_values: {}, .completion_type: 0, .argument_type: eArgTypeNone, .usage_text: "Enable SSH."}, |
1310 | {LLDB_OPT_SET_ALL, .required: false, .long_option: "ssh-opts", .short_option: 'S', .option_has_arg: OptionParser::eRequiredArgument, |
1311 | .validator: nullptr, .enum_values: {}, .completion_type: 0, .argument_type: eArgTypeCommandName, |
1312 | .usage_text: "Platform-specific options required for SSH to work."}, |
1313 | }; |
1314 | |
1315 | static constexpr OptionDefinition g_caching_option_table[] = { |
1316 | {LLDB_OPT_SET_ALL, .required: false, .long_option: "local-cache-dir", .short_option: 'c', |
1317 | .option_has_arg: OptionParser::eRequiredArgument, .validator: nullptr, .enum_values: {}, .completion_type: 0, .argument_type: eArgTypePath, |
1318 | .usage_text: "Path in which to store local copies of files."}, |
1319 | }; |
1320 | |
1321 | llvm::ArrayRef<OptionDefinition> OptionGroupPlatformRSync::GetDefinitions() { |
1322 | return llvm::ArrayRef(g_rsync_option_table); |
1323 | } |
1324 | |
1325 | void OptionGroupPlatformRSync::OptionParsingStarting( |
1326 | ExecutionContext *execution_context) { |
1327 | m_rsync = false; |
1328 | m_rsync_opts.clear(); |
1329 | m_rsync_prefix.clear(); |
1330 | m_ignores_remote_hostname = false; |
1331 | } |
1332 | |
1333 | lldb_private::Status |
1334 | OptionGroupPlatformRSync::SetOptionValue(uint32_t option_idx, |
1335 | llvm::StringRef option_arg, |
1336 | ExecutionContext *execution_context) { |
1337 | Status error; |
1338 | char short_option = (char)GetDefinitions()[option_idx].short_option; |
1339 | switch (short_option) { |
1340 | case 'r': |
1341 | m_rsync = true; |
1342 | break; |
1343 | |
1344 | case 'R': |
1345 | m_rsync_opts.assign(str: std::string(option_arg)); |
1346 | break; |
1347 | |
1348 | case 'P': |
1349 | m_rsync_prefix.assign(str: std::string(option_arg)); |
1350 | break; |
1351 | |
1352 | case 'i': |
1353 | m_ignores_remote_hostname = true; |
1354 | break; |
1355 | |
1356 | default: |
1357 | error = Status::FromErrorStringWithFormat(format: "unrecognized option '%c'", |
1358 | short_option); |
1359 | break; |
1360 | } |
1361 | |
1362 | return error; |
1363 | } |
1364 | |
1365 | lldb::BreakpointSP |
1366 | Platform::SetThreadCreationBreakpoint(lldb_private::Target &target) { |
1367 | return lldb::BreakpointSP(); |
1368 | } |
1369 | |
1370 | llvm::ArrayRef<OptionDefinition> OptionGroupPlatformSSH::GetDefinitions() { |
1371 | return llvm::ArrayRef(g_ssh_option_table); |
1372 | } |
1373 | |
1374 | void OptionGroupPlatformSSH::OptionParsingStarting( |
1375 | ExecutionContext *execution_context) { |
1376 | m_ssh = false; |
1377 | m_ssh_opts.clear(); |
1378 | } |
1379 | |
1380 | lldb_private::Status |
1381 | OptionGroupPlatformSSH::SetOptionValue(uint32_t option_idx, |
1382 | llvm::StringRef option_arg, |
1383 | ExecutionContext *execution_context) { |
1384 | Status error; |
1385 | char short_option = (char)GetDefinitions()[option_idx].short_option; |
1386 | switch (short_option) { |
1387 | case 's': |
1388 | m_ssh = true; |
1389 | break; |
1390 | |
1391 | case 'S': |
1392 | m_ssh_opts.assign(str: std::string(option_arg)); |
1393 | break; |
1394 | |
1395 | default: |
1396 | error = Status::FromErrorStringWithFormat(format: "unrecognized option '%c'", |
1397 | short_option); |
1398 | break; |
1399 | } |
1400 | |
1401 | return error; |
1402 | } |
1403 | |
1404 | llvm::ArrayRef<OptionDefinition> OptionGroupPlatformCaching::GetDefinitions() { |
1405 | return llvm::ArrayRef(g_caching_option_table); |
1406 | } |
1407 | |
1408 | void OptionGroupPlatformCaching::OptionParsingStarting( |
1409 | ExecutionContext *execution_context) { |
1410 | m_cache_dir.clear(); |
1411 | } |
1412 | |
1413 | lldb_private::Status OptionGroupPlatformCaching::SetOptionValue( |
1414 | uint32_t option_idx, llvm::StringRef option_arg, |
1415 | ExecutionContext *execution_context) { |
1416 | Status error; |
1417 | char short_option = (char)GetDefinitions()[option_idx].short_option; |
1418 | switch (short_option) { |
1419 | case 'c': |
1420 | m_cache_dir.assign(str: std::string(option_arg)); |
1421 | break; |
1422 | |
1423 | default: |
1424 | error = Status::FromErrorStringWithFormat(format: "unrecognized option '%c'", |
1425 | short_option); |
1426 | break; |
1427 | } |
1428 | |
1429 | return error; |
1430 | } |
1431 | |
1432 | Environment Platform::GetEnvironment() { |
1433 | if (IsHost()) |
1434 | return Host::GetEnvironment(); |
1435 | return Environment(); |
1436 | } |
1437 | |
1438 | const std::vector<ConstString> &Platform::GetTrapHandlerSymbolNames() { |
1439 | if (!m_calculated_trap_handlers) { |
1440 | std::lock_guard<std::mutex> guard(m_mutex); |
1441 | if (!m_calculated_trap_handlers) { |
1442 | CalculateTrapHandlerSymbolNames(); |
1443 | m_calculated_trap_handlers = true; |
1444 | } |
1445 | } |
1446 | return m_trap_handlers; |
1447 | } |
1448 | |
1449 | Status |
1450 | Platform::GetCachedExecutable(ModuleSpec &module_spec, |
1451 | lldb::ModuleSP &module_sp, |
1452 | const FileSpecList *module_search_paths_ptr) { |
1453 | FileSpec platform_spec = module_spec.GetFileSpec(); |
1454 | Status error = GetRemoteSharedModule( |
1455 | module_spec, process: nullptr, module_sp, |
1456 | module_resolver: [&](const ModuleSpec &spec) { |
1457 | return Platform::ResolveExecutable(module_spec: spec, exe_module_sp&: module_sp, |
1458 | module_search_paths_ptr); |
1459 | }, |
1460 | did_create_ptr: nullptr); |
1461 | if (error.Success()) { |
1462 | module_spec.GetFileSpec() = module_sp->GetFileSpec(); |
1463 | module_spec.GetPlatformFileSpec() = platform_spec; |
1464 | } |
1465 | |
1466 | return error; |
1467 | } |
1468 | |
1469 | Status Platform::GetRemoteSharedModule(const ModuleSpec &module_spec, |
1470 | Process *process, |
1471 | lldb::ModuleSP &module_sp, |
1472 | const ModuleResolver &module_resolver, |
1473 | bool *did_create_ptr) { |
1474 | // Get module information from a target. |
1475 | ModuleSpec resolved_module_spec; |
1476 | ArchSpec process_host_arch; |
1477 | bool got_module_spec = false; |
1478 | if (process) { |
1479 | process_host_arch = process->GetSystemArchitecture(); |
1480 | // Try to get module information from the process |
1481 | if (process->GetModuleSpec(module_file_spec: module_spec.GetFileSpec(), |
1482 | arch: module_spec.GetArchitecture(), |
1483 | module_spec&: resolved_module_spec)) { |
1484 | if (!module_spec.GetUUID().IsValid() || |
1485 | module_spec.GetUUID() == resolved_module_spec.GetUUID()) { |
1486 | got_module_spec = true; |
1487 | } |
1488 | } |
1489 | } |
1490 | |
1491 | if (!module_spec.GetArchitecture().IsValid()) { |
1492 | Status error; |
1493 | // No valid architecture was specified, ask the platform for the |
1494 | // architectures that we should be using (in the correct order) and see if |
1495 | // we can find a match that way |
1496 | ModuleSpec arch_module_spec(module_spec); |
1497 | for (const ArchSpec &arch : GetSupportedArchitectures(process_host_arch)) { |
1498 | arch_module_spec.GetArchitecture() = arch; |
1499 | error = ModuleList::GetSharedModule(module_spec: arch_module_spec, module_sp, module_search_paths_ptr: nullptr, |
1500 | old_modules: nullptr, did_create_ptr: nullptr); |
1501 | // Did we find an executable using one of the |
1502 | if (error.Success() && module_sp) |
1503 | break; |
1504 | } |
1505 | if (module_sp) { |
1506 | resolved_module_spec = arch_module_spec; |
1507 | got_module_spec = true; |
1508 | } |
1509 | } |
1510 | |
1511 | if (!got_module_spec) { |
1512 | // Get module information from a target. |
1513 | if (GetModuleSpec(module_file_spec: module_spec.GetFileSpec(), arch: module_spec.GetArchitecture(), |
1514 | module_spec&: resolved_module_spec)) { |
1515 | if (!module_spec.GetUUID().IsValid() || |
1516 | module_spec.GetUUID() == resolved_module_spec.GetUUID()) { |
1517 | got_module_spec = true; |
1518 | } |
1519 | } |
1520 | } |
1521 | |
1522 | if (!got_module_spec) { |
1523 | // Fall back to the given module resolver, which may have its own |
1524 | // search logic. |
1525 | return module_resolver(module_spec); |
1526 | } |
1527 | |
1528 | // If we are looking for a specific UUID, make sure resolved_module_spec has |
1529 | // the same one before we search. |
1530 | if (module_spec.GetUUID().IsValid()) { |
1531 | resolved_module_spec.GetUUID() = module_spec.GetUUID(); |
1532 | } |
1533 | |
1534 | // Call locate module callback if set. This allows users to implement their |
1535 | // own module cache system. For example, to leverage build system artifacts, |
1536 | // to bypass pulling files from remote platform, or to search symbol files |
1537 | // from symbol servers. |
1538 | FileSpec symbol_file_spec; |
1539 | CallLocateModuleCallbackIfSet(module_spec: resolved_module_spec, module_sp, |
1540 | symbol_file_spec, did_create_ptr); |
1541 | if (module_sp) { |
1542 | // The module is loaded. |
1543 | if (symbol_file_spec) { |
1544 | // 1. module_sp:loaded, symbol_file_spec:set |
1545 | // The callback found a module file and a symbol file for this |
1546 | // resolved_module_spec. Set the symbol file to the module. |
1547 | module_sp->SetSymbolFileFileSpec(symbol_file_spec); |
1548 | } else { |
1549 | // 2. module_sp:loaded, symbol_file_spec:empty |
1550 | // The callback only found a module file for this |
1551 | // resolved_module_spec. |
1552 | } |
1553 | return Status(); |
1554 | } |
1555 | |
1556 | // The module is not loaded by CallLocateModuleCallbackIfSet. |
1557 | // 3. module_sp:empty, symbol_file_spec:set |
1558 | // The callback only found a symbol file for the module. We continue to |
1559 | // find a module file for this resolved_module_spec. and we will call |
1560 | // module_sp->SetSymbolFileFileSpec with the symbol_file_spec later. |
1561 | // 4. module_sp:empty, symbol_file_spec:empty |
1562 | // The callback is not set. Or the callback did not find any module |
1563 | // files nor any symbol files. Or the callback failed, or something |
1564 | // went wrong. We continue to find a module file for this |
1565 | // resolved_module_spec. |
1566 | |
1567 | // Trying to find a module by UUID on local file system. |
1568 | Status error = module_resolver(resolved_module_spec); |
1569 | if (error.Success()) { |
1570 | if (module_sp && symbol_file_spec) { |
1571 | // Set the symbol file to the module if the locate modudle callback was |
1572 | // called and returned only a symbol file. |
1573 | module_sp->SetSymbolFileFileSpec(symbol_file_spec); |
1574 | } |
1575 | return error; |
1576 | } |
1577 | |
1578 | // Fallback to call GetCachedSharedModule on failure. |
1579 | if (GetCachedSharedModule(module_spec: resolved_module_spec, module_sp, did_create_ptr)) { |
1580 | if (module_sp && symbol_file_spec) { |
1581 | // Set the symbol file to the module if the locate modudle callback was |
1582 | // called and returned only a symbol file. |
1583 | module_sp->SetSymbolFileFileSpec(symbol_file_spec); |
1584 | } |
1585 | return Status(); |
1586 | } |
1587 | |
1588 | return Status::FromErrorStringWithFormat( |
1589 | format: "Failed to call GetCachedSharedModule"); |
1590 | } |
1591 | |
1592 | void Platform::CallLocateModuleCallbackIfSet(const ModuleSpec &module_spec, |
1593 | lldb::ModuleSP &module_sp, |
1594 | FileSpec &symbol_file_spec, |
1595 | bool *did_create_ptr) { |
1596 | if (!m_locate_module_callback) { |
1597 | // Locate module callback is not set. |
1598 | return; |
1599 | } |
1600 | |
1601 | FileSpec module_file_spec; |
1602 | Status error = |
1603 | m_locate_module_callback(module_spec, module_file_spec, symbol_file_spec); |
1604 | |
1605 | // Locate module callback is set and called. Check the error. |
1606 | Log *log = GetLog(mask: LLDBLog::Platform); |
1607 | if (error.Fail()) { |
1608 | LLDB_LOGF(log, "%s: locate module callback failed: %s", |
1609 | LLVM_PRETTY_FUNCTION, error.AsCString()); |
1610 | return; |
1611 | } |
1612 | |
1613 | // The locate module callback was succeeded. |
1614 | // Check the module_file_spec and symbol_file_spec values. |
1615 | // 1. module:empty symbol:empty -> Failure |
1616 | // - The callback did not return any files. |
1617 | // 2. module:exists symbol:exists -> Success |
1618 | // - The callback returned a module file and a symbol file. |
1619 | // 3. module:exists symbol:empty -> Success |
1620 | // - The callback returned only a module file. |
1621 | // 4. module:empty symbol:exists -> Success |
1622 | // - The callback returned only a symbol file. |
1623 | // For example, a breakpad symbol text file. |
1624 | if (!module_file_spec && !symbol_file_spec) { |
1625 | // This is '1. module:empty symbol:empty -> Failure' |
1626 | // The callback did not return any files. |
1627 | LLDB_LOGF(log, |
1628 | "%s: locate module callback did not set both " |
1629 | "module_file_spec and symbol_file_spec", |
1630 | LLVM_PRETTY_FUNCTION); |
1631 | return; |
1632 | } |
1633 | |
1634 | // If the callback returned a module file, it should exist. |
1635 | if (module_file_spec && !FileSystem::Instance().Exists(file_spec: module_file_spec)) { |
1636 | LLDB_LOGF(log, |
1637 | "%s: locate module callback set a non-existent file to " |
1638 | "module_file_spec: %s", |
1639 | LLVM_PRETTY_FUNCTION, module_file_spec.GetPath().c_str()); |
1640 | // Clear symbol_file_spec for the error. |
1641 | symbol_file_spec.Clear(); |
1642 | return; |
1643 | } |
1644 | |
1645 | // If the callback returned a symbol file, it should exist. |
1646 | if (symbol_file_spec && !FileSystem::Instance().Exists(file_spec: symbol_file_spec)) { |
1647 | LLDB_LOGF(log, |
1648 | "%s: locate module callback set a non-existent file to " |
1649 | "symbol_file_spec: %s", |
1650 | LLVM_PRETTY_FUNCTION, symbol_file_spec.GetPath().c_str()); |
1651 | // Clear symbol_file_spec for the error. |
1652 | symbol_file_spec.Clear(); |
1653 | return; |
1654 | } |
1655 | |
1656 | if (!module_file_spec && symbol_file_spec) { |
1657 | // This is '4. module:empty symbol:exists -> Success' |
1658 | // The locate module callback returned only a symbol file. For example, |
1659 | // a breakpad symbol text file. GetRemoteSharedModule will use this returned |
1660 | // symbol_file_spec. |
1661 | LLDB_LOGF(log, "%s: locate module callback succeeded: symbol=%s", |
1662 | LLVM_PRETTY_FUNCTION, symbol_file_spec.GetPath().c_str()); |
1663 | return; |
1664 | } |
1665 | |
1666 | // This is one of the following. |
1667 | // - 2. module:exists symbol:exists -> Success |
1668 | // - The callback returned a module file and a symbol file. |
1669 | // - 3. module:exists symbol:empty -> Success |
1670 | // - The callback returned Only a module file. |
1671 | // Load the module file. |
1672 | auto cached_module_spec(module_spec); |
1673 | cached_module_spec.GetUUID().Clear(); // Clear UUID since it may contain md5 |
1674 | // content hash instead of real UUID. |
1675 | cached_module_spec.GetFileSpec() = module_file_spec; |
1676 | cached_module_spec.GetPlatformFileSpec() = module_spec.GetFileSpec(); |
1677 | cached_module_spec.SetObjectOffset(0); |
1678 | |
1679 | error = ModuleList::GetSharedModule(module_spec: cached_module_spec, module_sp, module_search_paths_ptr: nullptr, |
1680 | old_modules: nullptr, did_create_ptr, always_create: false); |
1681 | if (error.Success() && module_sp) { |
1682 | // Succeeded to load the module file. |
1683 | LLDB_LOGF(log, "%s: locate module callback succeeded: module=%s symbol=%s", |
1684 | LLVM_PRETTY_FUNCTION, module_file_spec.GetPath().c_str(), |
1685 | symbol_file_spec.GetPath().c_str()); |
1686 | } else { |
1687 | LLDB_LOGF(log, |
1688 | "%s: locate module callback succeeded but failed to load: " |
1689 | "module=%s symbol=%s", |
1690 | LLVM_PRETTY_FUNCTION, module_file_spec.GetPath().c_str(), |
1691 | symbol_file_spec.GetPath().c_str()); |
1692 | // Clear module_sp and symbol_file_spec for the error. |
1693 | module_sp.reset(); |
1694 | symbol_file_spec.Clear(); |
1695 | } |
1696 | } |
1697 | |
1698 | bool Platform::GetCachedSharedModule(const ModuleSpec &module_spec, |
1699 | lldb::ModuleSP &module_sp, |
1700 | bool *did_create_ptr) { |
1701 | if (IsHost() || !GetGlobalPlatformProperties().GetUseModuleCache() || |
1702 | !GetGlobalPlatformProperties().GetModuleCacheDirectory()) |
1703 | return false; |
1704 | |
1705 | Log *log = GetLog(mask: LLDBLog::Platform); |
1706 | |
1707 | // Check local cache for a module. |
1708 | auto error = m_module_cache->GetAndPut( |
1709 | root_dir_spec: GetModuleCacheRoot(), hostname: GetCacheHostname(), module_spec, |
1710 | module_downloader: [this](const ModuleSpec &module_spec, |
1711 | const FileSpec &tmp_download_file_spec) { |
1712 | return DownloadModuleSlice( |
1713 | src_file_spec: module_spec.GetFileSpec(), src_offset: module_spec.GetObjectOffset(), |
1714 | src_size: module_spec.GetObjectSize(), dst_file_spec: tmp_download_file_spec); |
1715 | |
1716 | }, |
1717 | symfile_downloader: [this](const ModuleSP &module_sp, |
1718 | const FileSpec &tmp_download_file_spec) { |
1719 | return DownloadSymbolFile(module_sp, dst_file_spec: tmp_download_file_spec); |
1720 | }, |
1721 | cached_module_sp&: module_sp, did_create_ptr); |
1722 | if (error.Success()) |
1723 | return true; |
1724 | |
1725 | LLDB_LOGF(log, "Platform::%s - module %s not found in local cache: %s", |
1726 | __FUNCTION__, module_spec.GetUUID().GetAsString().c_str(), |
1727 | error.AsCString()); |
1728 | return false; |
1729 | } |
1730 | |
1731 | Status Platform::DownloadModuleSlice(const FileSpec &src_file_spec, |
1732 | const uint64_t src_offset, |
1733 | const uint64_t src_size, |
1734 | const FileSpec &dst_file_spec) { |
1735 | Status error; |
1736 | |
1737 | std::error_code EC; |
1738 | llvm::raw_fd_ostream dst(dst_file_spec.GetPath(), EC, llvm::sys::fs::OF_None); |
1739 | if (EC) { |
1740 | error = Status::FromErrorStringWithFormat( |
1741 | format: "unable to open destination file: %s", dst_file_spec.GetPath().c_str()); |
1742 | return error; |
1743 | } |
1744 | |
1745 | auto src_fd = OpenFile(file_spec: src_file_spec, flags: File::eOpenOptionReadOnly, |
1746 | mode: lldb::eFilePermissionsFileDefault, error); |
1747 | |
1748 | if (error.Fail()) { |
1749 | error = Status::FromErrorStringWithFormat(format: "unable to open source file: %s", |
1750 | error.AsCString()); |
1751 | return error; |
1752 | } |
1753 | |
1754 | std::vector<char> buffer(512 * 1024); |
1755 | auto offset = src_offset; |
1756 | uint64_t total_bytes_read = 0; |
1757 | while (total_bytes_read < src_size) { |
1758 | const auto to_read = std::min(a: static_cast<uint64_t>(buffer.size()), |
1759 | b: src_size - total_bytes_read); |
1760 | const uint64_t n_read = |
1761 | ReadFile(fd: src_fd, offset, dst: &buffer[0], dst_len: to_read, error); |
1762 | if (error.Fail()) |
1763 | break; |
1764 | if (n_read == 0) { |
1765 | error = Status::FromErrorString(str: "read 0 bytes"); |
1766 | break; |
1767 | } |
1768 | offset += n_read; |
1769 | total_bytes_read += n_read; |
1770 | dst.write(Ptr: &buffer[0], Size: n_read); |
1771 | } |
1772 | |
1773 | Status close_error; |
1774 | CloseFile(fd: src_fd, error&: close_error); // Ignoring close error. |
1775 | |
1776 | return error; |
1777 | } |
1778 | |
1779 | Status Platform::DownloadSymbolFile(const lldb::ModuleSP &module_sp, |
1780 | const FileSpec &dst_file_spec) { |
1781 | return Status::FromErrorString( |
1782 | str: "Symbol file downloading not supported by the default platform."); |
1783 | } |
1784 | |
1785 | FileSpec Platform::GetModuleCacheRoot() { |
1786 | auto dir_spec = GetGlobalPlatformProperties().GetModuleCacheDirectory(); |
1787 | dir_spec.AppendPathComponent(component: GetPluginName()); |
1788 | return dir_spec; |
1789 | } |
1790 | |
1791 | const char *Platform::GetCacheHostname() { return GetHostname(); } |
1792 | |
1793 | const UnixSignalsSP &Platform::GetRemoteUnixSignals() { |
1794 | static const auto s_default_unix_signals_sp = std::make_shared<UnixSignals>(); |
1795 | return s_default_unix_signals_sp; |
1796 | } |
1797 | |
1798 | UnixSignalsSP Platform::GetUnixSignals() { |
1799 | if (IsHost()) |
1800 | return UnixSignals::CreateForHost(); |
1801 | return GetRemoteUnixSignals(); |
1802 | } |
1803 | |
1804 | uint32_t Platform::LoadImage(lldb_private::Process *process, |
1805 | const lldb_private::FileSpec &local_file, |
1806 | const lldb_private::FileSpec &remote_file, |
1807 | lldb_private::Status &error) { |
1808 | if (local_file && remote_file) { |
1809 | // Both local and remote file was specified. Install the local file to the |
1810 | // given location. |
1811 | if (IsRemote() || local_file != remote_file) { |
1812 | error = Install(src: local_file, dst: remote_file); |
1813 | if (error.Fail()) |
1814 | return LLDB_INVALID_IMAGE_TOKEN; |
1815 | } |
1816 | return DoLoadImage(process, remote_file, paths: nullptr, error); |
1817 | } |
1818 | |
1819 | if (local_file) { |
1820 | // Only local file was specified. Install it to the current working |
1821 | // directory. |
1822 | FileSpec target_file = GetWorkingDirectory(); |
1823 | target_file.AppendPathComponent(component: local_file.GetFilename().AsCString()); |
1824 | if (IsRemote() || local_file != target_file) { |
1825 | error = Install(src: local_file, dst: target_file); |
1826 | if (error.Fail()) |
1827 | return LLDB_INVALID_IMAGE_TOKEN; |
1828 | } |
1829 | return DoLoadImage(process, remote_file: target_file, paths: nullptr, error); |
1830 | } |
1831 | |
1832 | if (remote_file) { |
1833 | // Only remote file was specified so we don't have to do any copying |
1834 | return DoLoadImage(process, remote_file, paths: nullptr, error); |
1835 | } |
1836 | |
1837 | error = |
1838 | Status::FromErrorString(str: "Neither local nor remote file was specified"); |
1839 | return LLDB_INVALID_IMAGE_TOKEN; |
1840 | } |
1841 | |
1842 | uint32_t Platform::DoLoadImage(lldb_private::Process *process, |
1843 | const lldb_private::FileSpec &remote_file, |
1844 | const std::vector<std::string> *paths, |
1845 | lldb_private::Status &error, |
1846 | lldb_private::FileSpec *loaded_image) { |
1847 | error = Status::FromErrorString( |
1848 | str: "LoadImage is not supported on the current platform"); |
1849 | return LLDB_INVALID_IMAGE_TOKEN; |
1850 | } |
1851 | |
1852 | uint32_t Platform::LoadImageUsingPaths(lldb_private::Process *process, |
1853 | const lldb_private::FileSpec &remote_filename, |
1854 | const std::vector<std::string> &paths, |
1855 | lldb_private::Status &error, |
1856 | lldb_private::FileSpec *loaded_path) |
1857 | { |
1858 | FileSpec file_to_use; |
1859 | if (remote_filename.IsAbsolute()) |
1860 | file_to_use = FileSpec(remote_filename.GetFilename().GetStringRef(), |
1861 | |
1862 | remote_filename.GetPathStyle()); |
1863 | else |
1864 | file_to_use = remote_filename; |
1865 | |
1866 | return DoLoadImage(process, remote_file: file_to_use, paths: &paths, error, loaded_image: loaded_path); |
1867 | } |
1868 | |
1869 | Status Platform::UnloadImage(lldb_private::Process *process, |
1870 | uint32_t image_token) { |
1871 | return Status::FromErrorString( |
1872 | str: "UnloadImage is not supported on the current platform"); |
1873 | } |
1874 | |
1875 | lldb::ProcessSP Platform::ConnectProcess(llvm::StringRef connect_url, |
1876 | llvm::StringRef plugin_name, |
1877 | Debugger &debugger, Target *target, |
1878 | Status &error) { |
1879 | return DoConnectProcess(connect_url, plugin_name, debugger, stream: nullptr, target, |
1880 | error); |
1881 | } |
1882 | |
1883 | lldb::ProcessSP Platform::ConnectProcessSynchronous( |
1884 | llvm::StringRef connect_url, llvm::StringRef plugin_name, |
1885 | Debugger &debugger, Stream &stream, Target *target, Status &error) { |
1886 | return DoConnectProcess(connect_url, plugin_name, debugger, stream: &stream, target, |
1887 | error); |
1888 | } |
1889 | |
1890 | lldb::ProcessSP Platform::DoConnectProcess(llvm::StringRef connect_url, |
1891 | llvm::StringRef plugin_name, |
1892 | Debugger &debugger, Stream *stream, |
1893 | Target *target, Status &error) { |
1894 | error.Clear(); |
1895 | |
1896 | if (!target) { |
1897 | ArchSpec arch = Target::GetDefaultArchitecture(); |
1898 | |
1899 | const char *triple = |
1900 | arch.IsValid() ? arch.GetTriple().getTriple().c_str() : ""; |
1901 | |
1902 | TargetSP new_target_sp; |
1903 | error = debugger.GetTargetList().CreateTarget( |
1904 | debugger, user_exe_path: "", triple_str: triple, get_dependent_modules: eLoadDependentsNo, platform_options: nullptr, target_sp&: new_target_sp); |
1905 | |
1906 | target = new_target_sp.get(); |
1907 | if (!target || error.Fail()) { |
1908 | return nullptr; |
1909 | } |
1910 | } |
1911 | |
1912 | lldb::ProcessSP process_sp = |
1913 | target->CreateProcess(listener_sp: debugger.GetListener(), plugin_name, crash_file: nullptr, can_connect: true); |
1914 | |
1915 | if (!process_sp) |
1916 | return nullptr; |
1917 | |
1918 | // If this private method is called with a stream we are synchronous. |
1919 | const bool synchronous = stream != nullptr; |
1920 | |
1921 | ListenerSP listener_sp( |
1922 | Listener::MakeListener(name: "lldb.Process.ConnectProcess.hijack")); |
1923 | if (synchronous) |
1924 | process_sp->HijackProcessEvents(listener_sp); |
1925 | |
1926 | error = process_sp->ConnectRemote(remote_url: connect_url); |
1927 | if (error.Fail()) { |
1928 | if (synchronous) |
1929 | process_sp->RestoreProcessEvents(); |
1930 | return nullptr; |
1931 | } |
1932 | |
1933 | if (synchronous) { |
1934 | EventSP event_sp; |
1935 | process_sp->WaitForProcessToStop(timeout: std::nullopt, event_sp_ptr: &event_sp, wait_always: true, hijack_listener: listener_sp, |
1936 | stream: nullptr); |
1937 | process_sp->RestoreProcessEvents(); |
1938 | bool pop_process_io_handler = false; |
1939 | // This is a user-level stop, so we allow recognizers to select frames. |
1940 | Process::HandleProcessStateChangedEvent( |
1941 | event_sp, stream, select_most_relevant: SelectMostRelevantFrame, pop_process_io_handler); |
1942 | } |
1943 | |
1944 | return process_sp; |
1945 | } |
1946 | |
1947 | size_t Platform::ConnectToWaitingProcesses(lldb_private::Debugger &debugger, |
1948 | lldb_private::Status &error) { |
1949 | error.Clear(); |
1950 | return 0; |
1951 | } |
1952 | |
1953 | size_t Platform::GetSoftwareBreakpointTrapOpcode(Target &target, |
1954 | BreakpointSite *bp_site) { |
1955 | ArchSpec arch = target.GetArchitecture(); |
1956 | assert(arch.IsValid()); |
1957 | const uint8_t *trap_opcode = nullptr; |
1958 | size_t trap_opcode_size = 0; |
1959 | |
1960 | switch (arch.GetMachine()) { |
1961 | case llvm::Triple::aarch64_32: |
1962 | case llvm::Triple::aarch64: { |
1963 | static const uint8_t g_aarch64_opcode[] = {0x00, 0x00, 0x20, 0xd4}; |
1964 | trap_opcode = g_aarch64_opcode; |
1965 | trap_opcode_size = sizeof(g_aarch64_opcode); |
1966 | } break; |
1967 | |
1968 | case llvm::Triple::arc: { |
1969 | static const uint8_t g_hex_opcode[] = { 0xff, 0x7f }; |
1970 | trap_opcode = g_hex_opcode; |
1971 | trap_opcode_size = sizeof(g_hex_opcode); |
1972 | } break; |
1973 | |
1974 | // TODO: support big-endian arm and thumb trap codes. |
1975 | case llvm::Triple::arm: { |
1976 | // The ARM reference recommends the use of 0xe7fddefe and 0xdefe but the |
1977 | // linux kernel does otherwise. |
1978 | static const uint8_t g_arm_breakpoint_opcode[] = {0xf0, 0x01, 0xf0, 0xe7}; |
1979 | static const uint8_t g_thumb_breakpoint_opcode[] = {0x01, 0xde}; |
1980 | |
1981 | lldb::BreakpointLocationSP bp_loc_sp(bp_site->GetConstituentAtIndex(idx: 0)); |
1982 | AddressClass addr_class = AddressClass::eUnknown; |
1983 | |
1984 | if (bp_loc_sp) { |
1985 | addr_class = bp_loc_sp->GetAddress().GetAddressClass(); |
1986 | if (addr_class == AddressClass::eUnknown && |
1987 | (bp_loc_sp->GetAddress().GetFileAddress() & 1)) |
1988 | addr_class = AddressClass::eCodeAlternateISA; |
1989 | } |
1990 | |
1991 | if (addr_class == AddressClass::eCodeAlternateISA) { |
1992 | trap_opcode = g_thumb_breakpoint_opcode; |
1993 | trap_opcode_size = sizeof(g_thumb_breakpoint_opcode); |
1994 | } else { |
1995 | trap_opcode = g_arm_breakpoint_opcode; |
1996 | trap_opcode_size = sizeof(g_arm_breakpoint_opcode); |
1997 | } |
1998 | } break; |
1999 | |
2000 | case llvm::Triple::avr: { |
2001 | static const uint8_t g_hex_opcode[] = {0x98, 0x95}; |
2002 | trap_opcode = g_hex_opcode; |
2003 | trap_opcode_size = sizeof(g_hex_opcode); |
2004 | } break; |
2005 | |
2006 | case llvm::Triple::mips: |
2007 | case llvm::Triple::mips64: { |
2008 | static const uint8_t g_hex_opcode[] = {0x00, 0x00, 0x00, 0x0d}; |
2009 | trap_opcode = g_hex_opcode; |
2010 | trap_opcode_size = sizeof(g_hex_opcode); |
2011 | } break; |
2012 | |
2013 | case llvm::Triple::mipsel: |
2014 | case llvm::Triple::mips64el: { |
2015 | static const uint8_t g_hex_opcode[] = {0x0d, 0x00, 0x00, 0x00}; |
2016 | trap_opcode = g_hex_opcode; |
2017 | trap_opcode_size = sizeof(g_hex_opcode); |
2018 | } break; |
2019 | |
2020 | case llvm::Triple::msp430: { |
2021 | static const uint8_t g_msp430_opcode[] = {0x43, 0x43}; |
2022 | trap_opcode = g_msp430_opcode; |
2023 | trap_opcode_size = sizeof(g_msp430_opcode); |
2024 | } break; |
2025 | |
2026 | case llvm::Triple::systemz: { |
2027 | static const uint8_t g_hex_opcode[] = {0x00, 0x01}; |
2028 | trap_opcode = g_hex_opcode; |
2029 | trap_opcode_size = sizeof(g_hex_opcode); |
2030 | } break; |
2031 | |
2032 | case llvm::Triple::hexagon: { |
2033 | static const uint8_t g_hex_opcode[] = {0x0c, 0xdb, 0x00, 0x54}; |
2034 | trap_opcode = g_hex_opcode; |
2035 | trap_opcode_size = sizeof(g_hex_opcode); |
2036 | } break; |
2037 | |
2038 | case llvm::Triple::ppc: |
2039 | case llvm::Triple::ppc64: { |
2040 | static const uint8_t g_ppc_opcode[] = {0x7f, 0xe0, 0x00, 0x08}; |
2041 | trap_opcode = g_ppc_opcode; |
2042 | trap_opcode_size = sizeof(g_ppc_opcode); |
2043 | } break; |
2044 | |
2045 | case llvm::Triple::ppc64le: { |
2046 | static const uint8_t g_ppc64le_opcode[] = {0x08, 0x00, 0xe0, 0x7f}; // trap |
2047 | trap_opcode = g_ppc64le_opcode; |
2048 | trap_opcode_size = sizeof(g_ppc64le_opcode); |
2049 | } break; |
2050 | |
2051 | case llvm::Triple::x86: |
2052 | case llvm::Triple::x86_64: { |
2053 | static const uint8_t g_i386_opcode[] = {0xCC}; |
2054 | trap_opcode = g_i386_opcode; |
2055 | trap_opcode_size = sizeof(g_i386_opcode); |
2056 | } break; |
2057 | |
2058 | case llvm::Triple::riscv32: |
2059 | case llvm::Triple::riscv64: { |
2060 | static const uint8_t g_riscv_opcode[] = {0x73, 0x00, 0x10, 0x00}; // ebreak |
2061 | static const uint8_t g_riscv_opcode_c[] = {0x02, 0x90}; // c.ebreak |
2062 | if (arch.GetFlags() & ArchSpec::eRISCV_rvc) { |
2063 | trap_opcode = g_riscv_opcode_c; |
2064 | trap_opcode_size = sizeof(g_riscv_opcode_c); |
2065 | } else { |
2066 | trap_opcode = g_riscv_opcode; |
2067 | trap_opcode_size = sizeof(g_riscv_opcode); |
2068 | } |
2069 | } break; |
2070 | |
2071 | case llvm::Triple::loongarch32: |
2072 | case llvm::Triple::loongarch64: { |
2073 | static const uint8_t g_loongarch_opcode[] = {0x05, 0x00, 0x2a, |
2074 | 0x00}; // break 0x5 |
2075 | trap_opcode = g_loongarch_opcode; |
2076 | trap_opcode_size = sizeof(g_loongarch_opcode); |
2077 | } break; |
2078 | |
2079 | default: |
2080 | return 0; |
2081 | } |
2082 | |
2083 | assert(bp_site); |
2084 | if (bp_site->SetTrapOpcode(trap_opcode, trap_opcode_size)) |
2085 | return trap_opcode_size; |
2086 | |
2087 | return 0; |
2088 | } |
2089 | |
2090 | CompilerType Platform::GetSiginfoType(const llvm::Triple& triple) { |
2091 | return CompilerType(); |
2092 | } |
2093 | |
2094 | Args Platform::GetExtraStartupCommands() { |
2095 | return {}; |
2096 | } |
2097 | |
2098 | void Platform::SetLocateModuleCallback(LocateModuleCallback callback) { |
2099 | m_locate_module_callback = callback; |
2100 | } |
2101 | |
2102 | Platform::LocateModuleCallback Platform::GetLocateModuleCallback() const { |
2103 | return m_locate_module_callback; |
2104 | } |
2105 | |
2106 | PlatformSP PlatformList::GetOrCreate(llvm::StringRef name) { |
2107 | std::lock_guard<std::recursive_mutex> guard(m_mutex); |
2108 | for (const PlatformSP &platform_sp : m_platforms) { |
2109 | if (platform_sp->GetName() == name) |
2110 | return platform_sp; |
2111 | } |
2112 | return Create(name); |
2113 | } |
2114 | |
2115 | PlatformSP PlatformList::GetOrCreate(const ArchSpec &arch, |
2116 | const ArchSpec &process_host_arch, |
2117 | ArchSpec *platform_arch_ptr, |
2118 | Status &error) { |
2119 | std::lock_guard<std::recursive_mutex> guard(m_mutex); |
2120 | // First try exact arch matches across all platforms already created |
2121 | for (const auto &platform_sp : m_platforms) { |
2122 | if (platform_sp->IsCompatibleArchitecture( |
2123 | arch, process_host_arch, match: ArchSpec::ExactMatch, compatible_arch_ptr: platform_arch_ptr)) |
2124 | return platform_sp; |
2125 | } |
2126 | |
2127 | // Next try compatible arch matches across all platforms already created |
2128 | for (const auto &platform_sp : m_platforms) { |
2129 | if (platform_sp->IsCompatibleArchitecture(arch, process_host_arch, |
2130 | match: ArchSpec::CompatibleMatch, |
2131 | compatible_arch_ptr: platform_arch_ptr)) |
2132 | return platform_sp; |
2133 | } |
2134 | |
2135 | PlatformCreateInstance create_callback; |
2136 | // First try exact arch matches across all platform plug-ins |
2137 | uint32_t idx; |
2138 | for (idx = 0; |
2139 | (create_callback = PluginManager::GetPlatformCreateCallbackAtIndex(idx)); |
2140 | ++idx) { |
2141 | PlatformSP platform_sp = create_callback(false, &arch); |
2142 | if (platform_sp && |
2143 | platform_sp->IsCompatibleArchitecture( |
2144 | arch, process_host_arch, match: ArchSpec::ExactMatch, compatible_arch_ptr: platform_arch_ptr)) { |
2145 | m_platforms.push_back(x: platform_sp); |
2146 | return platform_sp; |
2147 | } |
2148 | } |
2149 | // Next try compatible arch matches across all platform plug-ins |
2150 | for (idx = 0; |
2151 | (create_callback = PluginManager::GetPlatformCreateCallbackAtIndex(idx)); |
2152 | ++idx) { |
2153 | PlatformSP platform_sp = create_callback(false, &arch); |
2154 | if (platform_sp && platform_sp->IsCompatibleArchitecture( |
2155 | arch, process_host_arch, match: ArchSpec::CompatibleMatch, |
2156 | compatible_arch_ptr: platform_arch_ptr)) { |
2157 | m_platforms.push_back(x: platform_sp); |
2158 | return platform_sp; |
2159 | } |
2160 | } |
2161 | if (platform_arch_ptr) |
2162 | platform_arch_ptr->Clear(); |
2163 | return nullptr; |
2164 | } |
2165 | |
2166 | PlatformSP PlatformList::GetOrCreate(const ArchSpec &arch, |
2167 | const ArchSpec &process_host_arch, |
2168 | ArchSpec *platform_arch_ptr) { |
2169 | Status error; |
2170 | if (arch.IsValid()) |
2171 | return GetOrCreate(arch, process_host_arch, platform_arch_ptr, error); |
2172 | return nullptr; |
2173 | } |
2174 | |
2175 | PlatformSP PlatformList::GetOrCreate(llvm::ArrayRef<ArchSpec> archs, |
2176 | const ArchSpec &process_host_arch, |
2177 | std::vector<PlatformSP> &candidates) { |
2178 | candidates.clear(); |
2179 | candidates.reserve(n: archs.size()); |
2180 | |
2181 | if (archs.empty()) |
2182 | return nullptr; |
2183 | |
2184 | PlatformSP host_platform_sp = Platform::GetHostPlatform(); |
2185 | |
2186 | // Prefer the selected platform if it matches at least one architecture. |
2187 | if (m_selected_platform_sp) { |
2188 | for (const ArchSpec &arch : archs) { |
2189 | if (m_selected_platform_sp->IsCompatibleArchitecture( |
2190 | arch, process_host_arch, match: ArchSpec::CompatibleMatch, compatible_arch_ptr: nullptr)) |
2191 | return m_selected_platform_sp; |
2192 | } |
2193 | } |
2194 | |
2195 | // Prefer the host platform if it matches at least one architecture. |
2196 | if (host_platform_sp) { |
2197 | for (const ArchSpec &arch : archs) { |
2198 | if (host_platform_sp->IsCompatibleArchitecture( |
2199 | arch, process_host_arch, match: ArchSpec::CompatibleMatch, compatible_arch_ptr: nullptr)) |
2200 | return host_platform_sp; |
2201 | } |
2202 | } |
2203 | |
2204 | // Collect a list of candidate platforms for the architectures. |
2205 | for (const ArchSpec &arch : archs) { |
2206 | if (PlatformSP platform = GetOrCreate(arch, process_host_arch, platform_arch_ptr: nullptr)) |
2207 | candidates.push_back(x: platform); |
2208 | } |
2209 | |
2210 | // The selected or host platform didn't match any of the architectures. If |
2211 | // the same platform supports all architectures then that's the obvious next |
2212 | // best thing. |
2213 | if (candidates.size() == archs.size()) { |
2214 | if (llvm::all_of(Range&: candidates, P: [&](const PlatformSP &p) -> bool { |
2215 | return p->GetName() == candidates.front()->GetName(); |
2216 | })) { |
2217 | return candidates.front(); |
2218 | } |
2219 | } |
2220 | |
2221 | // At this point we either have no platforms that match the given |
2222 | // architectures or multiple platforms with no good way to disambiguate |
2223 | // between them. |
2224 | return nullptr; |
2225 | } |
2226 | |
2227 | PlatformSP PlatformList::Create(llvm::StringRef name) { |
2228 | std::lock_guard<std::recursive_mutex> guard(m_mutex); |
2229 | PlatformSP platform_sp = Platform::Create(name); |
2230 | m_platforms.push_back(x: platform_sp); |
2231 | return platform_sp; |
2232 | } |
2233 | |
2234 | bool PlatformList::LoadPlatformBinaryAndSetup(Process *process, |
2235 | lldb::addr_t addr, bool notify) { |
2236 | std::lock_guard<std::recursive_mutex> guard(m_mutex); |
2237 | |
2238 | PlatformCreateInstance create_callback; |
2239 | for (int idx = 0; |
2240 | (create_callback = PluginManager::GetPlatformCreateCallbackAtIndex(idx)); |
2241 | ++idx) { |
2242 | ArchSpec arch; |
2243 | PlatformSP platform_sp = create_callback(true, &arch); |
2244 | if (platform_sp) { |
2245 | if (platform_sp->LoadPlatformBinaryAndSetup(process, addr, notify)) |
2246 | return true; |
2247 | } |
2248 | } |
2249 | return false; |
2250 | } |
2251 |
Definitions
- GetHostPlatformSP
- GetHostPlatformName
- GetSettingName
- PlatformProperties
- GetUseModuleCache
- SetUseModuleCache
- GetModuleCacheDirectory
- SetModuleCacheDirectory
- SetDefaultModuleCacheDirectory
- GetHostPlatform
- Initialize
- Terminate
- GetGlobalPlatformProperties
- SetHostPlatform
- GetFileWithUUID
- LocateExecutableScriptingResources
- GetSharedModule
- GetModuleSpec
- Create
- GetAugmentedArchSpec
- Platform
- ~Platform
- GetStatus
- GetOSVersion
- GetOSBuildString
- GetOSKernelDescription
- AddClangModuleCompilationOptions
- GetWorkingDirectory
- RecurseCopyBaton
- RecurseCopy_Callback
- Install
- SetWorkingDirectory
- MakeDirectory
- GetFilePermissions
- SetFilePermissions
- OpenFile
- CloseFile
- GetFileSize
- ReadFile
- WriteFile
- GetUserIDResolver
- GetHostname
- GetFullNameForDylib
- SetRemoteWorkingDirectory
- SetOSVersion
- ResolveExecutable
- ResolveSymbolFile
- ResolveRemotePath
- GetSystemArchitecture
- GetAugmentedArchSpec
- ConnectRemote
- DisconnectRemote
- GetProcessInfo
- FindProcesses
- GetAllProcesses
- LaunchProcess
- ShellExpandArguments
- KillProcess
- DebugProcess
- CreateArchList
- IsCompatibleArchitecture
- PutFile
- GetFile
- CreateSymlink
- GetFileExists
- Unlink
- GetMmapArgumentList
- RunShellCommand
- RunShellCommand
- CalculateMD5
- SetLocalCacheDirectory
- GetLocalCacheDirectory
- g_rsync_option_table
- g_ssh_option_table
- g_caching_option_table
- GetDefinitions
- OptionParsingStarting
- SetOptionValue
- SetThreadCreationBreakpoint
- GetDefinitions
- OptionParsingStarting
- SetOptionValue
- GetDefinitions
- OptionParsingStarting
- SetOptionValue
- GetEnvironment
- GetTrapHandlerSymbolNames
- GetCachedExecutable
- GetRemoteSharedModule
- CallLocateModuleCallbackIfSet
- GetCachedSharedModule
- DownloadModuleSlice
- DownloadSymbolFile
- GetModuleCacheRoot
- GetCacheHostname
- GetRemoteUnixSignals
- GetUnixSignals
- LoadImage
- DoLoadImage
- LoadImageUsingPaths
- UnloadImage
- ConnectProcess
- ConnectProcessSynchronous
- DoConnectProcess
- ConnectToWaitingProcesses
- GetSoftwareBreakpointTrapOpcode
- GetSiginfoType
- GetExtraStartupCommands
- SetLocateModuleCallback
- GetLocateModuleCallback
- GetOrCreate
- GetOrCreate
- GetOrCreate
- GetOrCreate
- Create
Learn to use CMake with our Intro Training
Find out more