lldb/source/Utility/ModuleCache.cpp - toolchain/llvm-project - Gitiles

 //===--------------------- ModuleCache.cpp ----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

 #include "ModuleCache.h"

 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/File.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/LockFile.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FileUtilities.h"

 #include <assert.h>

 #include <cstdio>

 using namespace lldb;
 using namespace lldb_private;

 namespace {

 const char* kModulesSubdir = ".cache";
 const char* kLockDirName = ".lock";
 const char* kTempFileName = ".temp";
 const char* kTempSymFileName = ".symtemp";
 const char* kSymFileExtension = ".sym";

 class ModuleLock
 {
 private:
     File m_file;
     std::unique_ptr<lldb_private::LockFile> m_lock;
     FileSpec m_file_spec;

 public:
     ModuleLock (const FileSpec &root_dir_spec, const UUID &uuid, Error& error);
     void Delete ();
 };

 FileSpec
 JoinPath (const FileSpec &path1, const char* path2)
 {
     FileSpec result_spec (path1);
     result_spec.AppendPathComponent (path2);
     return result_spec;
 }

 Error
 MakeDirectory (const FileSpec &dir_path)
 {
     if (dir_path.Exists ())
     {
         if (!dir_path.IsDirectory ())
             return Error ("Invalid existing path");

         return Error ();
     }

     return FileSystem::MakeDirectory(dir_path, eFilePermissionsDirectoryDefault);
 }

 FileSpec
 GetModuleDirectory (const FileSpec &root_dir_spec, const UUID &uuid)
 {
     const auto modules_dir_spec = JoinPath (root_dir_spec, kModulesSubdir);
     return JoinPath (modules_dir_spec, uuid.GetAsString ().c_str ());
 }

 FileSpec
 GetSymbolFileSpec(const FileSpec& module_file_spec)
 {
     return FileSpec((module_file_spec.GetPath() + kSymFileExtension).c_str(), false);
 }

 void
 DeleteExistingModule (const FileSpec &root_dir_spec, const FileSpec &sysroot_module_path_spec)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_MODULES));
     UUID module_uuid;
     {
         auto module_sp = std::make_shared<Module>(ModuleSpec (sysroot_module_path_spec));
         module_uuid = module_sp->GetUUID ();
     }

     if (!module_uuid.IsValid ())
         return;

     Error error;
     ModuleLock lock (root_dir_spec,  module_uuid, error);
     if (error.Fail ())
     {
         if (log)
             log->Printf ("Failed to lock module %s: %s",
                          module_uuid.GetAsString ().c_str (),
                          error.AsCString ());
     }

     auto link_count = FileSystem::GetHardlinkCount (sysroot_module_path_spec);
     if (link_count == -1)
         return;

     if (link_count > 2)  // module is referred by other hosts.
         return;

     const auto module_spec_dir = GetModuleDirectory (root_dir_spec, module_uuid);
     FileSystem::DeleteDirectory (module_spec_dir, true);
     lock.Delete();
 }

 void
 DecrementRefExistingModule (const FileSpec &root_dir_spec, const FileSpec &sysroot_module_path_spec)
 {
     // Remove $platform/.cache/$uuid folder if nobody else references it.
     DeleteExistingModule (root_dir_spec, sysroot_module_path_spec);

     // Remove sysroot link.
     FileSystem::Unlink (sysroot_module_path_spec);

     FileSpec symfile_spec = GetSymbolFileSpec (sysroot_module_path_spec);
     if (symfile_spec.Exists ())  // delete module's symbol file if exists.
         FileSystem::Unlink (symfile_spec);
 }

 Error
 CreateHostSysRootModuleLink (const FileSpec &root_dir_spec, const char *hostname,
                              const FileSpec &platform_module_spec,
                              const FileSpec &local_module_spec,
                              bool delete_existing)
 {
     const auto sysroot_module_path_spec = JoinPath (
         JoinPath (root_dir_spec, hostname), platform_module_spec.GetPath ().c_str ());
     if (sysroot_module_path_spec.Exists())
     {
         if (!delete_existing)
             return Error ();

         DecrementRefExistingModule (root_dir_spec, sysroot_module_path_spec);
     }

     const auto error = MakeDirectory (FileSpec (sysroot_module_path_spec.GetDirectory ().AsCString (), false));
     if (error.Fail ())
         return error;

     return FileSystem::Hardlink(sysroot_module_path_spec, local_module_spec);
 }

 }  // namespace

 ModuleLock::ModuleLock (const FileSpec &root_dir_spec, const UUID &uuid, Error& error)
 {
     const auto lock_dir_spec = JoinPath (root_dir_spec, kLockDirName);
     error = MakeDirectory (lock_dir_spec);
     if (error.Fail ())
         return;

     m_file_spec = JoinPath (lock_dir_spec, uuid.GetAsString ().c_str ());
     m_file.Open (m_file_spec.GetCString (),
                  File::eOpenOptionWrite | File::eOpenOptionCanCreate | File::eOpenOptionCloseOnExec);
     if (!m_file)
     {
         error.SetErrorToErrno ();
         return;
     }

     m_lock.reset (new lldb_private::LockFile (m_file.GetDescriptor ()));
     error = m_lock->WriteLock (0, 1);
     if (error.Fail ())
         error.SetErrorStringWithFormat ("Failed to lock file: %s", error.AsCString ());
 }

 void ModuleLock::Delete ()
 {
     if (!m_file)
         return;

     m_file.Close ();
     FileSystem::Unlink (m_file_spec);
 }

 /////////////////////////////////////////////////////////////////////////

 Error
 ModuleCache::Put (const FileSpec &root_dir_spec,
                   const char *hostname,
                   const ModuleSpec &module_spec,
                   const FileSpec &tmp_file,
                   const FileSpec &target_file)
 {
     const auto module_spec_dir = GetModuleDirectory (root_dir_spec, module_spec.GetUUID ());
     const auto module_file_path = JoinPath (module_spec_dir, target_file.GetFilename ().AsCString ());

     const auto tmp_file_path = tmp_file.GetPath ();
     const auto err_code = llvm::sys::fs::rename (tmp_file_path.c_str (), module_file_path.GetPath ().c_str ());
     if (err_code)
         return Error ("Failed to rename file %s to %s: %s",
                       tmp_file_path.c_str (), module_file_path.GetPath ().c_str (), err_code.message ().c_str ());

     const auto error = CreateHostSysRootModuleLink(root_dir_spec, hostname, target_file, module_file_path, true);
     if (error.Fail ())
         return Error ("Failed to create link to %s: %s", module_file_path.GetPath ().c_str (), error.AsCString ());
     return Error ();
 }

 Error
 ModuleCache::Get (const FileSpec &root_dir_spec,
                   const char *hostname,
                   const ModuleSpec &module_spec,
                   ModuleSP &cached_module_sp,
                   bool *did_create_ptr)
 {
     const auto find_it = m_loaded_modules.find (module_spec.GetUUID ().GetAsString());
     if (find_it != m_loaded_modules.end ())
     {
         cached_module_sp = (*find_it).second.lock ();
         if (cached_module_sp)
             return Error ();
         m_loaded_modules.erase (find_it);
     }

     const auto module_spec_dir = GetModuleDirectory (root_dir_spec, module_spec.GetUUID ());
     const auto module_file_path = JoinPath (module_spec_dir, module_spec.GetFileSpec ().GetFilename ().AsCString ());

     if (!module_file_path.Exists ())
         return Error ("Module %s not found", module_file_path.GetPath ().c_str ());
     if (module_file_path.GetByteSize () != module_spec.GetObjectSize ())
         return Error ("Module %s has invalid file size", module_file_path.GetPath ().c_str ());

     // We may have already cached module but downloaded from an another host - in this case let's create a link to it.
     auto error = CreateHostSysRootModuleLink(root_dir_spec, hostname, module_spec.GetFileSpec(), module_file_path, false);
     if (error.Fail ())
         return Error ("Failed to create link to %s: %s", module_file_path.GetPath().c_str(), error.AsCString());

     auto cached_module_spec (module_spec);
     cached_module_spec.GetUUID ().Clear ();  // Clear UUID since it may contain md5 content hash instead of real UUID.
     cached_module_spec.GetFileSpec () = module_file_path;
     cached_module_spec.GetPlatformFileSpec () = module_spec.GetFileSpec ();

     error = ModuleList::GetSharedModule(cached_module_spec,
                                         cached_module_sp,
                                         nullptr,
                                         nullptr,
                                         did_create_ptr,
                                         false);
     if (error.Fail())
         return error;

     FileSpec symfile_spec = GetSymbolFileSpec(cached_module_sp->GetFileSpec ());
     if (symfile_spec.Exists ())
         cached_module_sp->SetSymbolFileFileSpec (symfile_spec);

     m_loaded_modules.insert (std::make_pair (module_spec.GetUUID ().GetAsString (), cached_module_sp));

     return Error ();
 }

 Error
 ModuleCache::GetAndPut (const FileSpec &root_dir_spec,
                         const char *hostname,
                         const ModuleSpec &module_spec,
                         const ModuleDownloader &module_downloader,
                         const SymfileDownloader &symfile_downloader,
                         lldb::ModuleSP &cached_module_sp,
                         bool *did_create_ptr)
 {
     const auto module_spec_dir = GetModuleDirectory (root_dir_spec, module_spec.GetUUID ());
     auto error = MakeDirectory (module_spec_dir);
     if (error.Fail ())
         return error;

     ModuleLock lock (root_dir_spec,  module_spec.GetUUID (), error);
     if (error.Fail ())
         return Error("Failed to lock module %s: %s", module_spec.GetUUID ().GetAsString().c_str(), error.AsCString ());

     // Check local cache for a module.
     error = Get (root_dir_spec, hostname, module_spec, cached_module_sp, did_create_ptr);
     if (error.Success ())
         return error;

     const auto tmp_download_file_spec = JoinPath (module_spec_dir, kTempFileName);
     error = module_downloader (module_spec, tmp_download_file_spec);
     llvm::FileRemover tmp_file_remover (tmp_download_file_spec.GetPath ().c_str ());
     if (error.Fail ())
         return Error("Failed to download module: %s", error.AsCString ());

     // Put downloaded file into local module cache.
     error = Put (root_dir_spec, hostname, module_spec, tmp_download_file_spec, module_spec.GetFileSpec ());
     if (error.Fail ())
         return Error ("Failed to put module into cache: %s", error.AsCString ());

     tmp_file_remover.releaseFile ();
     error = Get (root_dir_spec, hostname, module_spec, cached_module_sp, did_create_ptr);
     if (error.Fail ())
         return error;

     // Fetching a symbol file for the module
     const auto tmp_download_sym_file_spec = JoinPath (module_spec_dir, kTempSymFileName);
     error = symfile_downloader (cached_module_sp, tmp_download_sym_file_spec);
     llvm::FileRemover tmp_symfile_remover (tmp_download_sym_file_spec.GetPath ().c_str ());
     if (error.Fail ())
         // Failed to download a symfile but fetching the module was successful. The module might
         // contain the neccessary symbols and the debugging is also possible without a symfile.
         return Error ();

     error = Put (root_dir_spec, hostname, module_spec, tmp_download_sym_file_spec, GetSymbolFileSpec(module_spec.GetFileSpec ()));
     if (error.Fail ())
         return Error ("Failed to put symbol file into cache: %s", error.AsCString ());

     tmp_symfile_remover.releaseFile();

     FileSpec symfile_spec = GetSymbolFileSpec (cached_module_sp->GetFileSpec ());
     cached_module_sp->SetSymbolFileFileSpec (symfile_spec);
     return Error ();
 }
	//===--------------------- ModuleCache.cpp ----------------------- C++ --===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#include "ModuleCache.h"

	#include "lldb/Core/Log.h"
	#include "lldb/Core/Module.h"
	#include "lldb/Core/ModuleList.h"
	#include "lldb/Core/ModuleSpec.h"
	#include "lldb/Host/File.h"
	#include "lldb/Host/FileSystem.h"
	#include "lldb/Host/LockFile.h"
	#include "llvm/Support/FileSystem.h"
	#include "llvm/Support/FileUtilities.h"

	#include <assert.h>

	#include <cstdio>

	using namespace lldb;
	using namespace lldb_private;

	namespace {

	const char* kModulesSubdir = ".cache";
	const char* kLockDirName = ".lock";
	const char* kTempFileName = ".temp";
	const char* kTempSymFileName = ".symtemp";
	const char* kSymFileExtension = ".sym";

	class ModuleLock
	{
	private:
	File m_file;
	std::unique_ptr<lldb_private::LockFile> m_lock;
	FileSpec m_file_spec;

	public:
	ModuleLock (const FileSpec &root_dir_spec, const UUID &uuid, Error& error);
	void Delete ();
	};

	FileSpec
	JoinPath (const FileSpec &path1, const char* path2)
	{
	FileSpec result_spec (path1);
	result_spec.AppendPathComponent (path2);
	return result_spec;
	}

	Error
	MakeDirectory (const FileSpec &dir_path)
	{
	if (dir_path.Exists ())
	{
	if (!dir_path.IsDirectory ())
	return Error ("Invalid existing path");

	return Error ();
	}

	return FileSystem::MakeDirectory(dir_path, eFilePermissionsDirectoryDefault);
	}

	FileSpec
	GetModuleDirectory (const FileSpec &root_dir_spec, const UUID &uuid)
	{
	const auto modules_dir_spec = JoinPath (root_dir_spec, kModulesSubdir);
	return JoinPath (modules_dir_spec, uuid.GetAsString ().c_str ());
	}

	FileSpec
	GetSymbolFileSpec(const FileSpec& module_file_spec)
	{
	return FileSpec((module_file_spec.GetPath() + kSymFileExtension).c_str(), false);
	}

	void
	DeleteExistingModule (const FileSpec &root_dir_spec, const FileSpec &sysroot_module_path_spec)
	{
	Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_MODULES));
	UUID module_uuid;
	{
	auto module_sp = std::make_shared<Module>(ModuleSpec (sysroot_module_path_spec));
	module_uuid = module_sp->GetUUID ();
	}

	if (!module_uuid.IsValid ())
	return;

	Error error;
	ModuleLock lock (root_dir_spec, module_uuid, error);
	if (error.Fail ())
	{
	if (log)
	log->Printf ("Failed to lock module %s: %s",
	module_uuid.GetAsString ().c_str (),
	error.AsCString ());
	}

	auto link_count = FileSystem::GetHardlinkCount (sysroot_module_path_spec);
	if (link_count == -1)
	return;

	if (link_count > 2) // module is referred by other hosts.
	return;

	const auto module_spec_dir = GetModuleDirectory (root_dir_spec, module_uuid);
	FileSystem::DeleteDirectory (module_spec_dir, true);
	lock.Delete();
	}

	void
	DecrementRefExistingModule (const FileSpec &root_dir_spec, const FileSpec &sysroot_module_path_spec)
	{
	// Remove $platform/.cache/$uuid folder if nobody else references it.
	DeleteExistingModule (root_dir_spec, sysroot_module_path_spec);

	// Remove sysroot link.
	FileSystem::Unlink (sysroot_module_path_spec);

	FileSpec symfile_spec = GetSymbolFileSpec (sysroot_module_path_spec);
	if (symfile_spec.Exists ()) // delete module's symbol file if exists.
	FileSystem::Unlink (symfile_spec);
	}

	Error
	CreateHostSysRootModuleLink (const FileSpec &root_dir_spec, const char *hostname,
	const FileSpec &platform_module_spec,
	const FileSpec &local_module_spec,
	bool delete_existing)
	{
	const auto sysroot_module_path_spec = JoinPath (
	JoinPath (root_dir_spec, hostname), platform_module_spec.GetPath ().c_str ());
	if (sysroot_module_path_spec.Exists())
	{
	if (!delete_existing)
	return Error ();

	DecrementRefExistingModule (root_dir_spec, sysroot_module_path_spec);
	}

	const auto error = MakeDirectory (FileSpec (sysroot_module_path_spec.GetDirectory ().AsCString (), false));
	if (error.Fail ())
	return error;

	return FileSystem::Hardlink(sysroot_module_path_spec, local_module_spec);
	}

	} // namespace

	ModuleLock::ModuleLock (const FileSpec &root_dir_spec, const UUID &uuid, Error& error)
	{
	const auto lock_dir_spec = JoinPath (root_dir_spec, kLockDirName);
	error = MakeDirectory (lock_dir_spec);
	if (error.Fail ())
	return;

	m_file_spec = JoinPath (lock_dir_spec, uuid.GetAsString ().c_str ());
	m_file.Open (m_file_spec.GetCString (),
	File::eOpenOptionWrite \| File::eOpenOptionCanCreate \| File::eOpenOptionCloseOnExec);
	if (!m_file)
	{
	error.SetErrorToErrno ();
	return;
	}

	m_lock.reset (new lldb_private::LockFile (m_file.GetDescriptor ()));
	error = m_lock->WriteLock (0, 1);
	if (error.Fail ())
	error.SetErrorStringWithFormat ("Failed to lock file: %s", error.AsCString ());
	}

	void ModuleLock::Delete ()
	{
	if (!m_file)
	return;

	m_file.Close ();
	FileSystem::Unlink (m_file_spec);
	}

	/////////////////////////////////////////////////////////////////////////

	Error
	ModuleCache::Put (const FileSpec &root_dir_spec,
	const char *hostname,
	const ModuleSpec &module_spec,
	const FileSpec &tmp_file,
	const FileSpec &target_file)
	{
	const auto module_spec_dir = GetModuleDirectory (root_dir_spec, module_spec.GetUUID ());
	const auto module_file_path = JoinPath (module_spec_dir, target_file.GetFilename ().AsCString ());

	const auto tmp_file_path = tmp_file.GetPath ();
	const auto err_code = llvm::sys::fs::rename (tmp_file_path.c_str (), module_file_path.GetPath ().c_str ());
	if (err_code)
	return Error ("Failed to rename file %s to %s: %s",
	tmp_file_path.c_str (), module_file_path.GetPath ().c_str (), err_code.message ().c_str ());

	const auto error = CreateHostSysRootModuleLink(root_dir_spec, hostname, target_file, module_file_path, true);
	if (error.Fail ())
	return Error ("Failed to create link to %s: %s", module_file_path.GetPath ().c_str (), error.AsCString ());
	return Error ();
	}

	Error
	ModuleCache::Get (const FileSpec &root_dir_spec,
	const char *hostname,
	const ModuleSpec &module_spec,
	ModuleSP &cached_module_sp,
	bool *did_create_ptr)
	{
	const auto find_it = m_loaded_modules.find (module_spec.GetUUID ().GetAsString());
	if (find_it != m_loaded_modules.end ())
	{
	cached_module_sp = (*find_it).second.lock ();
	if (cached_module_sp)
	return Error ();
	m_loaded_modules.erase (find_it);
	}

	const auto module_spec_dir = GetModuleDirectory (root_dir_spec, module_spec.GetUUID ());
	const auto module_file_path = JoinPath (module_spec_dir, module_spec.GetFileSpec ().GetFilename ().AsCString ());

	if (!module_file_path.Exists ())
	return Error ("Module %s not found", module_file_path.GetPath ().c_str ());
	if (module_file_path.GetByteSize () != module_spec.GetObjectSize ())
	return Error ("Module %s has invalid file size", module_file_path.GetPath ().c_str ());

	// We may have already cached module but downloaded from an another host - in this case let's create a link to it.
	auto error = CreateHostSysRootModuleLink(root_dir_spec, hostname, module_spec.GetFileSpec(), module_file_path, false);
	if (error.Fail ())
	return Error ("Failed to create link to %s: %s", module_file_path.GetPath().c_str(), error.AsCString());

	auto cached_module_spec (module_spec);
	cached_module_spec.GetUUID ().Clear (); // Clear UUID since it may contain md5 content hash instead of real UUID.
	cached_module_spec.GetFileSpec () = module_file_path;
	cached_module_spec.GetPlatformFileSpec () = module_spec.GetFileSpec ();

	error = ModuleList::GetSharedModule(cached_module_spec,
	cached_module_sp,
	nullptr,
	nullptr,
	did_create_ptr,
	false);
	if (error.Fail())
	return error;

	FileSpec symfile_spec = GetSymbolFileSpec(cached_module_sp->GetFileSpec ());
	if (symfile_spec.Exists ())
	cached_module_sp->SetSymbolFileFileSpec (symfile_spec);

	m_loaded_modules.insert (std::make_pair (module_spec.GetUUID ().GetAsString (), cached_module_sp));

	return Error ();
	}

	Error
	ModuleCache::GetAndPut (const FileSpec &root_dir_spec,
	const char *hostname,
	const ModuleSpec &module_spec,
	const ModuleDownloader &module_downloader,
	const SymfileDownloader &symfile_downloader,
	lldb::ModuleSP &cached_module_sp,
	bool *did_create_ptr)
	{
	const auto module_spec_dir = GetModuleDirectory (root_dir_spec, module_spec.GetUUID ());
	auto error = MakeDirectory (module_spec_dir);
	if (error.Fail ())
	return error;

	ModuleLock lock (root_dir_spec, module_spec.GetUUID (), error);
	if (error.Fail ())
	return Error("Failed to lock module %s: %s", module_spec.GetUUID ().GetAsString().c_str(), error.AsCString ());

	// Check local cache for a module.
	error = Get (root_dir_spec, hostname, module_spec, cached_module_sp, did_create_ptr);
	if (error.Success ())
	return error;

	const auto tmp_download_file_spec = JoinPath (module_spec_dir, kTempFileName);
	error = module_downloader (module_spec, tmp_download_file_spec);
	llvm::FileRemover tmp_file_remover (tmp_download_file_spec.GetPath ().c_str ());
	if (error.Fail ())
	return Error("Failed to download module: %s", error.AsCString ());

	// Put downloaded file into local module cache.
	error = Put (root_dir_spec, hostname, module_spec, tmp_download_file_spec, module_spec.GetFileSpec ());
	if (error.Fail ())
	return Error ("Failed to put module into cache: %s", error.AsCString ());

	tmp_file_remover.releaseFile ();
	error = Get (root_dir_spec, hostname, module_spec, cached_module_sp, did_create_ptr);
	if (error.Fail ())
	return error;

	// Fetching a symbol file for the module
	const auto tmp_download_sym_file_spec = JoinPath (module_spec_dir, kTempSymFileName);
	error = symfile_downloader (cached_module_sp, tmp_download_sym_file_spec);
	llvm::FileRemover tmp_symfile_remover (tmp_download_sym_file_spec.GetPath ().c_str ());
	if (error.Fail ())
	// Failed to download a symfile but fetching the module was successful. The module might
	// contain the neccessary symbols and the debugging is also possible without a symfile.
	return Error ();

	error = Put (root_dir_spec, hostname, module_spec, tmp_download_sym_file_spec, GetSymbolFileSpec(module_spec.GetFileSpec ()));
	if (error.Fail ())
	return Error ("Failed to put symbol file into cache: %s", error.AsCString ());

	tmp_symfile_remover.releaseFile();

	FileSpec symfile_spec = GetSymbolFileSpec (cached_module_sp->GetFileSpec ());
	cached_module_sp->SetSymbolFileFileSpec (symfile_spec);
	return Error ();
	}