1 //===-- PlatformDarwinDevice.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 "PlatformDarwinDevice.h"
10 #include "lldb/Core/Module.h"
11 #include "lldb/Core/ModuleList.h"
12 #include "lldb/Core/ModuleSpec.h"
13 #include "lldb/Host/HostInfo.h"
14 #include "lldb/Utility/FileSpec.h"
15 #include "lldb/Utility/LLDBLog.h"
16 #include "lldb/Utility/Log.h"
17 #include <optional>
18 
19 using namespace lldb;
20 using namespace lldb_private;
21 
22 PlatformDarwinDevice::~PlatformDarwinDevice() = default;
23 
24 FileSystem::EnumerateDirectoryResult
GetContainedFilesIntoVectorOfStringsCallback(void * baton,llvm::sys::fs::file_type ft,llvm::StringRef path)25 PlatformDarwinDevice::GetContainedFilesIntoVectorOfStringsCallback(
26     void *baton, llvm::sys::fs::file_type ft, llvm::StringRef path) {
27   ((PlatformDarwinDevice::SDKDirectoryInfoCollection *)baton)
28       ->push_back(PlatformDarwinDevice::SDKDirectoryInfo(FileSpec(path)));
29   return FileSystem::eEnumerateDirectoryResultNext;
30 }
31 
UpdateSDKDirectoryInfosIfNeeded()32 bool PlatformDarwinDevice::UpdateSDKDirectoryInfosIfNeeded() {
33   Log *log = GetLog(LLDBLog::Host);
34   std::lock_guard<std::mutex> guard(m_sdk_dir_mutex);
35   if (m_sdk_directory_infos.empty()) {
36     // A --sysroot option was supplied - add it to our list of SDKs to check
37     if (m_sdk_sysroot) {
38       FileSpec sdk_sysroot_fspec(m_sdk_sysroot.GetCString());
39       FileSystem::Instance().Resolve(sdk_sysroot_fspec);
40       const SDKDirectoryInfo sdk_sysroot_directory_info(sdk_sysroot_fspec);
41       m_sdk_directory_infos.push_back(sdk_sysroot_directory_info);
42       if (log) {
43         LLDB_LOGF(log,
44                   "PlatformDarwinDevice::UpdateSDKDirectoryInfosIfNeeded added "
45                   "--sysroot SDK directory %s",
46                   m_sdk_sysroot.GetCString());
47       }
48       return true;
49     }
50     const char *device_support_dir = GetDeviceSupportDirectory();
51     if (log) {
52       LLDB_LOGF(log,
53                 "PlatformDarwinDevice::UpdateSDKDirectoryInfosIfNeeded Got "
54                 "DeviceSupport directory %s",
55                 device_support_dir);
56     }
57     if (device_support_dir) {
58       const bool find_directories = true;
59       const bool find_files = false;
60       const bool find_other = false;
61 
62       SDKDirectoryInfoCollection builtin_sdk_directory_infos;
63       FileSystem::Instance().EnumerateDirectory(
64           m_device_support_directory, find_directories, find_files, find_other,
65           GetContainedFilesIntoVectorOfStringsCallback,
66           &builtin_sdk_directory_infos);
67 
68       // Only add SDK directories that have symbols in them, some SDKs only
69       // contain developer disk images and no symbols, so they aren't useful to
70       // us.
71       FileSpec sdk_symbols_symlink_fspec;
72       for (const auto &sdk_directory_info : builtin_sdk_directory_infos) {
73         sdk_symbols_symlink_fspec = sdk_directory_info.directory;
74         sdk_symbols_symlink_fspec.AppendPathComponent("Symbols");
75         if (FileSystem::Instance().Exists(sdk_symbols_symlink_fspec)) {
76           m_sdk_directory_infos.push_back(sdk_directory_info);
77           if (log) {
78             LLDB_LOGF(log,
79                       "PlatformDarwinDevice::UpdateSDKDirectoryInfosIfNeeded "
80                       "added builtin SDK directory %s",
81                       sdk_symbols_symlink_fspec.GetPath().c_str());
82           }
83         }
84       }
85 
86       const uint32_t num_installed = m_sdk_directory_infos.size();
87       llvm::StringRef dirname = GetDeviceSupportDirectoryName();
88       std::string local_sdk_cache_str = "~/Library/Developer/Xcode/";
89       local_sdk_cache_str += std::string(dirname);
90       FileSpec local_sdk_cache(local_sdk_cache_str.c_str());
91       FileSystem::Instance().Resolve(local_sdk_cache);
92       if (FileSystem::Instance().Exists(local_sdk_cache)) {
93         if (log) {
94           LLDB_LOGF(log,
95                     "PlatformDarwinDevice::UpdateSDKDirectoryInfosIfNeeded "
96                     "searching %s for additional SDKs",
97                     local_sdk_cache.GetPath().c_str());
98         }
99         char path[PATH_MAX];
100         if (local_sdk_cache.GetPath(path, sizeof(path))) {
101           FileSystem::Instance().EnumerateDirectory(
102               path, find_directories, find_files, find_other,
103               GetContainedFilesIntoVectorOfStringsCallback,
104               &m_sdk_directory_infos);
105           const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
106           // First try for an exact match of major, minor and update
107           for (uint32_t i = num_installed; i < num_sdk_infos; ++i) {
108             m_sdk_directory_infos[i].user_cached = true;
109             if (log) {
110               LLDB_LOGF(log,
111                         "PlatformDarwinDevice::"
112                         "UpdateSDKDirectoryInfosIfNeeded "
113                         "user SDK directory %s",
114                         m_sdk_directory_infos[i].directory.GetPath().c_str());
115             }
116           }
117         }
118       }
119 
120       const char *addtional_platform_dirs = getenv("PLATFORM_SDK_DIRECTORY");
121       if (addtional_platform_dirs) {
122         SDKDirectoryInfoCollection env_var_sdk_directory_infos;
123         FileSystem::Instance().EnumerateDirectory(
124             addtional_platform_dirs, find_directories, find_files, find_other,
125             GetContainedFilesIntoVectorOfStringsCallback,
126             &env_var_sdk_directory_infos);
127         FileSpec sdk_symbols_symlink_fspec;
128         for (const auto &sdk_directory_info : env_var_sdk_directory_infos) {
129           sdk_symbols_symlink_fspec = sdk_directory_info.directory;
130           sdk_symbols_symlink_fspec.AppendPathComponent("Symbols");
131           if (FileSystem::Instance().Exists(sdk_symbols_symlink_fspec)) {
132             m_sdk_directory_infos.push_back(sdk_directory_info);
133             if (log) {
134               LLDB_LOGF(log,
135                         "PlatformDarwinDevice::UpdateSDKDirectoryInfosIfNeeded "
136                         "added env var SDK directory %s",
137                         sdk_symbols_symlink_fspec.GetPath().c_str());
138             }
139           }
140         }
141       }
142     }
143   }
144   return !m_sdk_directory_infos.empty();
145 }
146 
147 const PlatformDarwinDevice::SDKDirectoryInfo *
GetSDKDirectoryForCurrentOSVersion()148 PlatformDarwinDevice::GetSDKDirectoryForCurrentOSVersion() {
149   uint32_t i;
150   if (UpdateSDKDirectoryInfosIfNeeded()) {
151     const uint32_t num_sdk_infos = m_sdk_directory_infos.size();
152     std::vector<bool> check_sdk_info(num_sdk_infos, true);
153 
154     // Prefer the user SDK build string.
155     ConstString build = GetSDKBuild();
156 
157     // Fall back to the platform's build string.
158     if (!build) {
159       if (std::optional<std::string> os_build_str = GetOSBuildString()) {
160         build = ConstString(*os_build_str);
161       }
162     }
163 
164     // If we have a build string, only check platforms for which the build
165     // string matches.
166     if (build) {
167       for (i = 0; i < num_sdk_infos; ++i)
168         check_sdk_info[i] = m_sdk_directory_infos[i].build == build;
169     }
170 
171     // If we are connected we can find the version of the OS the platform us
172     // running on and select the right SDK
173     llvm::VersionTuple version = GetOSVersion();
174     if (!version.empty()) {
175       if (UpdateSDKDirectoryInfosIfNeeded()) {
176         // First try for an exact match of major, minor and update.
177         for (i = 0; i < num_sdk_infos; ++i) {
178           if (check_sdk_info[i]) {
179             if (m_sdk_directory_infos[i].version == version)
180               return &m_sdk_directory_infos[i];
181           }
182         }
183         // Try for an exact match of major and minor.
184         for (i = 0; i < num_sdk_infos; ++i) {
185           if (check_sdk_info[i]) {
186             if (m_sdk_directory_infos[i].version.getMajor() ==
187                     version.getMajor() &&
188                 m_sdk_directory_infos[i].version.getMinor() ==
189                     version.getMinor()) {
190               return &m_sdk_directory_infos[i];
191             }
192           }
193         }
194         // Lastly try to match of major version only.
195         for (i = 0; i < num_sdk_infos; ++i) {
196           if (check_sdk_info[i]) {
197             if (m_sdk_directory_infos[i].version.getMajor() ==
198                 version.getMajor()) {
199               return &m_sdk_directory_infos[i];
200             }
201           }
202         }
203       }
204     } else if (build) {
205       // No version, just a build number, return the first one that matches.
206       for (i = 0; i < num_sdk_infos; ++i)
207         if (check_sdk_info[i])
208           return &m_sdk_directory_infos[i];
209     }
210   }
211   return nullptr;
212 }
213 
214 const PlatformDarwinDevice::SDKDirectoryInfo *
GetSDKDirectoryForLatestOSVersion()215 PlatformDarwinDevice::GetSDKDirectoryForLatestOSVersion() {
216   const PlatformDarwinDevice::SDKDirectoryInfo *result = nullptr;
217   if (UpdateSDKDirectoryInfosIfNeeded()) {
218     auto max = std::max_element(
219         m_sdk_directory_infos.begin(), m_sdk_directory_infos.end(),
220         [](const SDKDirectoryInfo &a, const SDKDirectoryInfo &b) {
221           return a.version < b.version;
222         });
223     if (max != m_sdk_directory_infos.end())
224       result = &*max;
225   }
226   return result;
227 }
228 
GetDeviceSupportDirectory()229 const char *PlatformDarwinDevice::GetDeviceSupportDirectory() {
230   std::string platform_dir =
231       ("/Platforms/" + GetPlatformName() + "/DeviceSupport").str();
232   if (m_device_support_directory.empty()) {
233     if (FileSpec fspec = HostInfo::GetXcodeDeveloperDirectory()) {
234       m_device_support_directory = fspec.GetPath();
235       m_device_support_directory.append(platform_dir.c_str());
236     } else {
237       // Assign a single NULL character so we know we tried to find the device
238       // support directory and we don't keep trying to find it over and over.
239       m_device_support_directory.assign(1, '\0');
240     }
241   }
242   // We should have put a single NULL character into m_device_support_directory
243   // or it should have a valid path if the code gets here
244   assert(m_device_support_directory.empty() == false);
245   if (m_device_support_directory[0])
246     return m_device_support_directory.c_str();
247   return nullptr;
248 }
249 
GetDeviceSupportDirectoryForOSVersion()250 const char *PlatformDarwinDevice::GetDeviceSupportDirectoryForOSVersion() {
251   if (m_sdk_sysroot)
252     return m_sdk_sysroot.GetCString();
253 
254   if (m_device_support_directory_for_os_version.empty()) {
255     const PlatformDarwinDevice::SDKDirectoryInfo *sdk_dir_info =
256         GetSDKDirectoryForCurrentOSVersion();
257     if (sdk_dir_info == nullptr)
258       sdk_dir_info = GetSDKDirectoryForLatestOSVersion();
259     if (sdk_dir_info) {
260       char path[PATH_MAX];
261       if (sdk_dir_info->directory.GetPath(path, sizeof(path))) {
262         m_device_support_directory_for_os_version = path;
263         return m_device_support_directory_for_os_version.c_str();
264       }
265     } else {
266       // Assign a single NULL character so we know we tried to find the device
267       // support directory and we don't keep trying to find it over and over.
268       m_device_support_directory_for_os_version.assign(1, '\0');
269     }
270   }
271   // We should have put a single NULL character into
272   // m_device_support_directory_for_os_version or it should have a valid path
273   // if the code gets here
274   assert(m_device_support_directory_for_os_version.empty() == false);
275   if (m_device_support_directory_for_os_version[0])
276     return m_device_support_directory_for_os_version.c_str();
277   return nullptr;
278 }
279 
280 static lldb_private::Status
MakeCacheFolderForFile(const FileSpec & module_cache_spec)281 MakeCacheFolderForFile(const FileSpec &module_cache_spec) {
282   FileSpec module_cache_folder =
283       module_cache_spec.CopyByRemovingLastPathComponent();
284   return llvm::sys::fs::create_directory(module_cache_folder.GetPath());
285 }
286 
287 static lldb_private::Status
BringInRemoteFile(Platform * platform,const lldb_private::ModuleSpec & module_spec,const FileSpec & module_cache_spec)288 BringInRemoteFile(Platform *platform,
289                   const lldb_private::ModuleSpec &module_spec,
290                   const FileSpec &module_cache_spec) {
291   MakeCacheFolderForFile(module_cache_spec);
292   Status err = platform->GetFile(module_spec.GetFileSpec(), module_cache_spec);
293   return err;
294 }
295 
GetSharedModuleWithLocalCache(const lldb_private::ModuleSpec & module_spec,lldb::ModuleSP & module_sp,const lldb_private::FileSpecList * module_search_paths_ptr,llvm::SmallVectorImpl<lldb::ModuleSP> * old_modules,bool * did_create_ptr)296 lldb_private::Status PlatformDarwinDevice::GetSharedModuleWithLocalCache(
297     const lldb_private::ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
298     const lldb_private::FileSpecList *module_search_paths_ptr,
299     llvm::SmallVectorImpl<lldb::ModuleSP> *old_modules, bool *did_create_ptr) {
300 
301   Log *log = GetLog(LLDBLog::Platform);
302   LLDB_LOGF(log,
303             "[%s] Trying to find module %s/%s - platform path %s/%s symbol "
304             "path %s/%s",
305             (IsHost() ? "host" : "remote"),
306             module_spec.GetFileSpec().GetDirectory().AsCString(),
307             module_spec.GetFileSpec().GetFilename().AsCString(),
308             module_spec.GetPlatformFileSpec().GetDirectory().AsCString(),
309             module_spec.GetPlatformFileSpec().GetFilename().AsCString(),
310             module_spec.GetSymbolFileSpec().GetDirectory().AsCString(),
311             module_spec.GetSymbolFileSpec().GetFilename().AsCString());
312 
313   Status err;
314 
315   if (CheckLocalSharedCache()) {
316     // When debugging on the host, we are most likely using the same shared
317     // cache as our inferior. The dylibs from the shared cache might not
318     // exist on the filesystem, so let's use the images in our own memory
319     // to create the modules.
320 
321     // Check if the requested image is in our shared cache.
322     SharedCacheImageInfo image_info =
323         HostInfo::GetSharedCacheImageInfo(module_spec.GetFileSpec().GetPath());
324 
325     // If we found it and it has the correct UUID, let's proceed with
326     // creating a module from the memory contents.
327     if (image_info.uuid &&
328         (!module_spec.GetUUID() || module_spec.GetUUID() == image_info.uuid)) {
329       ModuleSpec shared_cache_spec(module_spec.GetFileSpec(), image_info.uuid,
330                                    image_info.data_sp);
331       err = ModuleList::GetSharedModule(shared_cache_spec, module_sp,
332                                         module_search_paths_ptr, old_modules,
333                                         did_create_ptr);
334       if (module_sp) {
335         LLDB_LOGF(log, "[%s] module %s was found in the in-memory shared cache",
336                   (IsHost() ? "host" : "remote"),
337                   module_spec.GetFileSpec().GetPath().c_str());
338         return err;
339       }
340     }
341 
342     // We failed to find the module in our shared cache. Let's see if we have a
343     // copy in our device support directory.
344     FileSpec device_support_spec(GetDeviceSupportDirectoryForOSVersion());
345     device_support_spec.AppendPathComponent("Symbols");
346     device_support_spec.AppendPathComponent(
347         module_spec.GetFileSpec().GetPath());
348     FileSystem::Instance().Resolve(device_support_spec);
349     if (FileSystem::Instance().Exists(device_support_spec)) {
350       ModuleSpec local_spec(device_support_spec, module_spec.GetUUID());
351       err = ModuleList::GetSharedModule(local_spec, module_sp,
352                                         module_search_paths_ptr, old_modules,
353                                         did_create_ptr);
354       if (module_sp) {
355         LLDB_LOGF(log,
356                   "[%s] module %s was found in Device Support "
357                   "directory: %s",
358                   (IsHost() ? "host" : "remote"),
359                   module_spec.GetFileSpec().GetPath().c_str(),
360                   local_spec.GetFileSpec().GetPath().c_str());
361         return err;
362       }
363     }
364   }
365 
366   err = ModuleList::GetSharedModule(module_spec, module_sp,
367                                     module_search_paths_ptr, old_modules,
368                                     did_create_ptr);
369   if (module_sp)
370     return err;
371 
372   if (!IsHost()) {
373     std::string cache_path(GetLocalCacheDirectory());
374     // Only search for a locally cached file if we have a valid cache path
375     if (!cache_path.empty()) {
376       std::string module_path(module_spec.GetFileSpec().GetPath());
377       cache_path.append(module_path);
378       FileSpec module_cache_spec(cache_path);
379 
380       // if rsync is supported, always bring in the file - rsync will be very
381       // efficient when files are the same on the local and remote end of the
382       // connection
383       if (this->GetSupportsRSync()) {
384         err = BringInRemoteFile(this, module_spec, module_cache_spec);
385         if (err.Fail())
386           return err;
387         if (FileSystem::Instance().Exists(module_cache_spec)) {
388           Log *log = GetLog(LLDBLog::Platform);
389           LLDB_LOGF(log, "[%s] module %s/%s was rsynced and is now there",
390                     (IsHost() ? "host" : "remote"),
391                     module_spec.GetFileSpec().GetDirectory().AsCString(),
392                     module_spec.GetFileSpec().GetFilename().AsCString());
393           ModuleSpec local_spec(module_cache_spec,
394                                 module_spec.GetArchitecture());
395           module_sp = std::make_shared<Module>(local_spec);
396           module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
397           return Status();
398         }
399       }
400 
401       // try to find the module in the cache
402       if (FileSystem::Instance().Exists(module_cache_spec)) {
403         // get the local and remote MD5 and compare
404         if (m_remote_platform_sp) {
405           // when going over the *slow* GDB remote transfer mechanism we first
406           // check the hashes of the files - and only do the actual transfer if
407           // they differ
408           uint64_t high_local, high_remote, low_local, low_remote;
409           auto MD5 = llvm::sys::fs::md5_contents(module_cache_spec.GetPath());
410           if (!MD5)
411             return Status(MD5.getError());
412           std::tie(high_local, low_local) = MD5->words();
413 
414           m_remote_platform_sp->CalculateMD5(module_spec.GetFileSpec(),
415                                              low_remote, high_remote);
416           if (low_local != low_remote || high_local != high_remote) {
417             // bring in the remote file
418             Log *log = GetLog(LLDBLog::Platform);
419             LLDB_LOGF(log,
420                       "[%s] module %s/%s needs to be replaced from remote copy",
421                       (IsHost() ? "host" : "remote"),
422                       module_spec.GetFileSpec().GetDirectory().AsCString(),
423                       module_spec.GetFileSpec().GetFilename().AsCString());
424             Status err =
425                 BringInRemoteFile(this, module_spec, module_cache_spec);
426             if (err.Fail())
427               return err;
428           }
429         }
430 
431         ModuleSpec local_spec(module_cache_spec, module_spec.GetArchitecture());
432         module_sp = std::make_shared<Module>(local_spec);
433         module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
434         Log *log = GetLog(LLDBLog::Platform);
435         LLDB_LOGF(log, "[%s] module %s/%s was found in the cache",
436                   (IsHost() ? "host" : "remote"),
437                   module_spec.GetFileSpec().GetDirectory().AsCString(),
438                   module_spec.GetFileSpec().GetFilename().AsCString());
439         return Status();
440       }
441 
442       // bring in the remote module file
443       LLDB_LOGF(log, "[%s] module %s/%s needs to come in remotely",
444                 (IsHost() ? "host" : "remote"),
445                 module_spec.GetFileSpec().GetDirectory().AsCString(),
446                 module_spec.GetFileSpec().GetFilename().AsCString());
447       Status err = BringInRemoteFile(this, module_spec, module_cache_spec);
448       if (err.Fail())
449         return err;
450       if (FileSystem::Instance().Exists(module_cache_spec)) {
451         Log *log = GetLog(LLDBLog::Platform);
452         LLDB_LOGF(log, "[%s] module %s/%s is now cached and fine",
453                   (IsHost() ? "host" : "remote"),
454                   module_spec.GetFileSpec().GetDirectory().AsCString(),
455                   module_spec.GetFileSpec().GetFilename().AsCString());
456         ModuleSpec local_spec(module_cache_spec, module_spec.GetArchitecture());
457         module_sp = std::make_shared<Module>(local_spec);
458         module_sp->SetPlatformFileSpec(module_spec.GetFileSpec());
459         return Status();
460       } else
461         return Status("unable to obtain valid module file");
462     } else
463       return Status("no cache path");
464   } else
465     return Status("unable to resolve module");
466 }
467