257e13ae9a
Adding the modules to the global module list eleminate issues in the case when a module is unloaded from the target but some object (e.g. breakpoint) still referencing them with weak pointers. It also speeds up the case when we load, unload, load the same shared library because the global module cache will keep the parsed debug info around between the 2 load (this scenario happens for some code on android). Differential revision: http://reviews.llvm.org/D15415 llvm-svn: 255260
323 lines
11 KiB
C++
323 lines
11 KiB
C++
//===--------------------- 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 ();
|
|
}
|