Remove unused modules from module cache

[ovyalov]

Summary

When putting a new module into module cache sysroot folder may contain existing hard link for an existing module with the same name but different build-id.
Use hard link counter to find out whether anybody else references an old module - if not, we can proceed with deleting unused module directory from $platform/.cache.
Move lock file location to $platform/.lock directory so we can create/delete module's directory while holding a lock.

[zturner]

source/Host/windows/FileSystem.cpp

130

GENERIC_READ is too strong if all you want to do is call GetFileInformationByHandle. I think all you need is FILE_READ_ATTRIBUTES. Can you try with FILE_READ_ATTRIBUTES and see if GetFileInformationByHandle succeeds? If so, just use that.

source/Utility/ModuleCache.cpp

110

Shouldn't this be >= 2?

[clayborg]

Flow looks good, take care of Zachs issues and this is good to go.

[ovyalov]

Replaced GENERIC_READ with FILE_READ_ATTRIBUTES when using ::CreateFile.

[ovyalov]

source/Host/windows/FileSystem.cpp

130

Thanks for suggestion - it does work. Fixed.

source/Utility/ModuleCache.cpp

110

If link counter == 2, it's okay to delete a module because in this case a counter includes following files: $platform/.cache/$uuid and its sysroot link.

[zturner]

Ok, lgtm then

[ovyalov]

Files:

/lldb/trunk/include/lldb/Host/FileSystem.h
/lldb/trunk/source/Host/posix/FileSystem.cpp
/lldb/trunk/source/Host/windows/FileSystem.cpp
/lldb/trunk/source/Utility/ModuleCache.cpp

Users:

ovyalov (Author)

http://reviews.llvm.org/rL248017

include/lldb/Host/FileSystem.h

public:
     static Error GetFilePermissions(const FileSpec &file_spec,
                                     uint32_t &file_permissions);
     static Error SetFilePermissions(const FileSpec &file_spec,
                                     uint32_t file_permissions);
     static lldb::user_id_t GetFileSize(const FileSpec &file_spec);
     static bool GetFileExists(const FileSpec &file_spec);
 
     static Error Hardlink(const FileSpec &src, const FileSpec &dst);
+    static int GetHardlinkCount(const FileSpec &file_spec);
     static Error Symlink(const FileSpec &src, const FileSpec &dst);
     static Error Readlink(const FileSpec &src, FileSpec &dst);
     static Error Unlink(const FileSpec &file_spec);
 
     static bool CalculateMD5(const FileSpec &file_spec, uint64_t &low, uint64_t &high);
     static bool CalculateMD5(const FileSpec &file_spec,
                              uint64_t offset,
                              uint64_t length,

source/Host/posix/FileSystem.cpp

 FileSystem::Hardlink(const FileSpec &src, const FileSpec &dst)
 {
     Error error;
     if (::link(dst.GetCString(), src.GetCString()) == -1)
         error.SetErrorToErrno();
     return error;
 }
 
+int
+FileSystem::GetHardlinkCount(const FileSpec &file_spec)
+{
+    struct stat file_stat;
+    if (::stat(file_spec.GetCString(), &file_stat) == 0)
+        return file_stat.st_nlink;
+
+    return -1;
+}
+
 Error
 FileSystem::Symlink(const FileSpec &src, const FileSpec &dst)
 {
     Error error;
     if (::symlink(dst.GetCString(), src.GetCString()) == -1)
         error.SetErrorToErrno();
     return error;
 }

source/Host/windows/FileSystem.cpp

 //===-- FileSystem.cpp ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/windows/windows.h"
 
 #include <shellapi.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 
 #include "lldb/Host/FileSystem.h"
+#include "lldb/Host/windows/AutoHandle.h"
 #include "llvm/Support/FileSystem.h"
 
 using namespace lldb_private;
 
 FileSpec::PathSyntax
 FileSystem::GetNativePathSyntax()
 {
     return FileSpec::ePathSyntaxWindows;

 FileSystem::Hardlink(const FileSpec &src, const FileSpec &dst)
 {
     Error error;
     if (!::CreateHardLink(src.GetCString(), dst.GetCString(), nullptr))
         error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
     return error;
 }
 
+int
+FileSystem::GetHardlinkCount(const FileSpec &file_spec)
+{
+    HANDLE file_handle = ::CreateFile(file_spec.GetCString(),
+                                      FILE_READ_ATTRIBUTES,
+                                      FILE_SHARE_READ,
+                                      nullptr,
+                                      OPEN_EXISTING,
+                                      FILE_ATTRIBUTE_NORMAL,
+                                      nullptr);
+
+    if (file_handle == INVALID_HANDLE_VALUE)
+      return -1;
+
+    AutoHandle auto_file_handle(file_handle);
+    BY_HANDLE_FILE_INFORMATION file_info;
+    if (::GetFileInformationByHandle(file_handle, &file_info))
+        return file_info.nNumberOfLinks;
+
+    return -1;
+}
+
 Error
 FileSystem::Symlink(const FileSpec &src, const FileSpec &dst)
 {
     Error error;
     DWORD attrib = ::GetFileAttributes(dst.GetCString());
     if (attrib == INVALID_FILE_ATTRIBUTES)
     {
         error.SetError(::GetLastError(), lldb::eErrorTypeWin32);

source/Utility/ModuleCache.cpp

 //===--------------------- 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/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* kLockFileName = ".lock";
+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;
 }
 

 
 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)
+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);
 }
 
-FileSpec
-GetSymbolFileSpec(const FileSpec& module_file_spec)
+}  // namespace
+
+ModuleLock::ModuleLock (const FileSpec &root_dir_spec, const UUID &uuid, Error& error)
 {
-    return FileSpec((module_file_spec.GetPath() + kSymFileExtension).c_str(), false);
+    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;
     }
 
-}  // namespace
+    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);
+    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,
ModuleCache::Get (const FileSpec &root_dir_spec,
     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.
-    const auto error = CreateHostSysRootModuleLink(root_dir_spec, hostname, module_spec.GetFileSpec(), module_file_path);
+    const 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 ();
     cached_module_sp.reset (new Module (cached_module_spec));
ModuleCache::GetAndPut (const FileSpec &root_dir_spec,
                         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;
 
-    // Open lock file.
-    const auto lock_file_spec = JoinPath (module_spec_dir, kLockFileName);
-    File lock_file (lock_file_spec, File::eOpenOptionWrite | File::eOpenOptionCanCreate | File::eOpenOptionCloseOnExec);
-    if (!lock_file)
-    {
-        error.SetErrorToErrno ();
-        return Error("Failed to open lock file %s: %s", lock_file_spec.GetPath ().c_str (), error.AsCString ());
-    }
-    LockFile lock (lock_file.GetDescriptor ());
-    error = lock.WriteLock (0, 1);
+    ModuleLock lock (root_dir_spec,  module_spec.GetUUID (), error);
     if (error.Fail ())
-        return Error("Failed to lock file %s:%s", lock_file_spec.GetPath ().c_str (), error.AsCString ());
+        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);