326 lines · cpp
1//===-- DataFileCache.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-exception6//7//===----------------------------------------------------------------------===//8 9#include "lldb/Core/DataFileCache.h"10#include "lldb/Core/Module.h"11#include "lldb/Core/ModuleList.h"12#include "lldb/Host/FileSystem.h"13#include "lldb/Symbol/ObjectFile.h"14#include "lldb/Utility/DataEncoder.h"15#include "lldb/Utility/LLDBLog.h"16#include "lldb/Utility/Log.h"17#include "llvm/Support/CachePruning.h"18 19using namespace lldb_private;20 21 22llvm::CachePruningPolicy DataFileCache::GetLLDBIndexCachePolicy() {23 static llvm::CachePruningPolicy policy;24 static llvm::once_flag once_flag;25 26 llvm::call_once(once_flag, []() {27 // Prune the cache based off of the LLDB settings each time we create a28 // cache object.29 ModuleListProperties &properties =30 ModuleList::GetGlobalModuleListProperties();31 // Only scan once an hour. If we have lots of debug sessions we don't want32 // to scan this directory too often. A timestamp file is written to the33 // directory to ensure different processes don't scan the directory too34 // often. This setting doesn't mean that a thread will continually scan the35 // cache directory within this process.36 policy.Interval = std::chrono::hours(1);37 // Get the user settings for pruning.38 policy.MaxSizeBytes = properties.GetLLDBIndexCacheMaxByteSize();39 policy.MaxSizePercentageOfAvailableSpace =40 properties.GetLLDBIndexCacheMaxPercent();41 policy.Expiration =42 std::chrono::hours(properties.GetLLDBIndexCacheExpirationDays() * 24);43 });44 return policy;45}46 47DataFileCache::DataFileCache(llvm::StringRef path, llvm::CachePruningPolicy policy) {48 m_cache_dir.SetPath(path);49 pruneCache(path, policy);50 51 // This lambda will get called when the data is gotten from the cache and52 // also after the data was set for a given key. We only need to take53 // ownership of the data if we are geting the data, so we use the54 // m_take_ownership member variable to indicate if we need to take55 // ownership.56 57 auto add_buffer = [this](unsigned task, const llvm::Twine &moduleName,58 std::unique_ptr<llvm::MemoryBuffer> m) {59 if (m_take_ownership)60 m_mem_buff_up = std::move(m);61 };62 llvm::Expected<llvm::FileCache> cache_or_err =63 llvm::localCache("LLDBModuleCache", "lldb-module", path, add_buffer);64 if (cache_or_err)65 m_cache_callback = std::move(*cache_or_err);66 else {67 Log *log = GetLog(LLDBLog::Modules);68 LLDB_LOG_ERROR(log, cache_or_err.takeError(),69 "failed to create lldb index cache directory: {0}");70 }71}72 73std::unique_ptr<llvm::MemoryBuffer>74DataFileCache::GetCachedData(llvm::StringRef key) {75 std::lock_guard<std::mutex> guard(m_mutex);76 77 const unsigned task = 1;78 m_take_ownership = true;79 // If we call the "m_cache_callback" function and the data is cached, it will80 // call the "add_buffer" lambda function from the constructor which will in81 // turn take ownership of the member buffer that is passed to the callback and82 // put it into a member variable.83 llvm::Expected<llvm::AddStreamFn> add_stream_or_err =84 m_cache_callback(task, key, "");85 m_take_ownership = false;86 // At this point we either already called the "add_buffer" lambda with87 // the data or we haven't. We can tell if we got the cached data by checking88 // the add_stream function pointer value below.89 if (add_stream_or_err) {90 llvm::AddStreamFn &add_stream = *add_stream_or_err;91 // If the "add_stream" is nullptr, then the data was cached and we already92 // called the "add_buffer" lambda. If it is valid, then if we were to call93 // the add_stream function it would cause a cache file to get generated94 // and we would be expected to fill in the data. In this function we only95 // want to check if the data was cached, so we don't want to call96 // "add_stream" in this function.97 if (!add_stream)98 return std::move(m_mem_buff_up);99 } else {100 Log *log = GetLog(LLDBLog::Modules);101 LLDB_LOG_ERROR(log, add_stream_or_err.takeError(),102 "failed to get the cache add stream callback for key: {0}");103 }104 // Data was not cached.105 return std::unique_ptr<llvm::MemoryBuffer>();106}107 108bool DataFileCache::SetCachedData(llvm::StringRef key,109 llvm::ArrayRef<uint8_t> data) {110 std::lock_guard<std::mutex> guard(m_mutex);111 const unsigned task = 2;112 // If we call this function and the data is cached, it will call the113 // add_buffer lambda function from the constructor which will ignore the114 // data.115 llvm::Expected<llvm::AddStreamFn> add_stream_or_err =116 m_cache_callback(task, key, "");117 // If we reach this code then we either already called the callback with118 // the data or we haven't. We can tell if we had the cached data by checking119 // the CacheAddStream function pointer value below.120 if (add_stream_or_err) {121 llvm::AddStreamFn &add_stream = *add_stream_or_err;122 // If the "add_stream" is nullptr, then the data was cached. If it is123 // valid, then if we call the add_stream function with a task it will124 // cause the file to get generated, but we only want to check if the data125 // is cached here, so we don't want to call it here. Note that the126 // add_buffer will also get called in this case after the data has been127 // provided, but we won't take ownership of the memory buffer as we just128 // want to write the data.129 if (add_stream) {130 llvm::Expected<std::unique_ptr<llvm::CachedFileStream>> file_or_err =131 add_stream(task, "");132 if (file_or_err) {133 llvm::CachedFileStream *cfs = file_or_err->get();134 cfs->OS->write((const char *)data.data(), data.size());135 if (llvm::Error err = cfs->commit()) {136 Log *log = GetLog(LLDBLog::Modules);137 LLDB_LOG_ERROR(log, std::move(err),138 "failed to commit to the cache for key: {0}");139 }140 return true;141 } else {142 Log *log = GetLog(LLDBLog::Modules);143 LLDB_LOG_ERROR(log, file_or_err.takeError(),144 "failed to get the cache file stream for key: {0}");145 }146 }147 } else {148 Log *log = GetLog(LLDBLog::Modules);149 LLDB_LOG_ERROR(log, add_stream_or_err.takeError(),150 "failed to get the cache add stream callback for key: {0}");151 }152 return false;153}154 155FileSpec DataFileCache::GetCacheFilePath(llvm::StringRef key) {156 FileSpec cache_file(m_cache_dir);157 std::string filename("llvmcache-");158 filename += key.str();159 cache_file.AppendPathComponent(filename);160 return cache_file;161}162 163Status DataFileCache::RemoveCacheFile(llvm::StringRef key) {164 FileSpec cache_file = GetCacheFilePath(key);165 FileSystem &fs = FileSystem::Instance();166 if (!fs.Exists(cache_file))167 return Status();168 return fs.RemoveFile(cache_file);169}170 171CacheSignature::CacheSignature(lldb_private::Module *module) {172 Clear();173 UUID uuid = module->GetUUID();174 if (uuid.IsValid())175 m_uuid = uuid;176 177 std::time_t mod_time = 0;178 mod_time = llvm::sys::toTimeT(module->GetModificationTime());179 if (mod_time != 0)180 m_mod_time = mod_time;181 182 mod_time = llvm::sys::toTimeT(module->GetObjectModificationTime());183 if (mod_time != 0)184 m_obj_mod_time = mod_time;185}186 187CacheSignature::CacheSignature(lldb_private::ObjectFile *objfile) {188 Clear();189 UUID uuid = objfile->GetUUID();190 if (uuid.IsValid())191 m_uuid = uuid;192 193 std::time_t mod_time = 0;194 // Grab the modification time of the object file's file. It isn't always the195 // same as the module's file when you have a executable file as the main196 // executable, and you have a object file for a symbol file.197 FileSystem &fs = FileSystem::Instance();198 mod_time = llvm::sys::toTimeT(fs.GetModificationTime(objfile->GetFileSpec()));199 if (mod_time != 0)200 m_mod_time = mod_time;201 202 mod_time =203 llvm::sys::toTimeT(objfile->GetModule()->GetObjectModificationTime());204 if (mod_time != 0)205 m_obj_mod_time = mod_time;206}207 208enum SignatureEncoding {209 eSignatureUUID = 1u,210 eSignatureModTime = 2u,211 eSignatureObjectModTime = 3u,212 eSignatureEnd = 255u,213};214 215bool CacheSignature::Encode(DataEncoder &encoder) const {216 if (!IsValid())217 return false; // Invalid signature, return false!218 219 if (m_uuid) {220 llvm::ArrayRef<uint8_t> uuid_bytes = m_uuid->GetBytes();221 encoder.AppendU8(eSignatureUUID);222 encoder.AppendU8(uuid_bytes.size());223 encoder.AppendData(uuid_bytes);224 }225 if (m_mod_time) {226 encoder.AppendU8(eSignatureModTime);227 encoder.AppendU32(*m_mod_time);228 }229 if (m_obj_mod_time) {230 encoder.AppendU8(eSignatureObjectModTime);231 encoder.AppendU32(*m_obj_mod_time);232 }233 encoder.AppendU8(eSignatureEnd);234 return true;235}236 237bool CacheSignature::Decode(const lldb_private::DataExtractor &data,238 lldb::offset_t *offset_ptr) {239 Clear();240 while (uint8_t sig_encoding = data.GetU8(offset_ptr)) {241 switch (sig_encoding) {242 case eSignatureUUID: {243 const uint8_t length = data.GetU8(offset_ptr);244 const uint8_t *bytes = (const uint8_t *)data.GetData(offset_ptr, length);245 if (bytes != nullptr && length > 0)246 m_uuid = UUID(llvm::ArrayRef<uint8_t>(bytes, length));247 } break;248 case eSignatureModTime: {249 uint32_t mod_time = data.GetU32(offset_ptr);250 if (mod_time > 0)251 m_mod_time = mod_time;252 } break;253 case eSignatureObjectModTime: {254 uint32_t mod_time = data.GetU32(offset_ptr);255 if (mod_time > 0)256 m_obj_mod_time = mod_time;257 } break;258 case eSignatureEnd:259 // The definition of is valid changed to only be valid if the UUID is260 // valid so make sure that if we attempt to decode an old cache file261 // that we will fail to decode the cache file if the signature isn't262 // considered valid.263 return IsValid();264 default:265 break;266 }267 }268 return false;269}270 271uint32_t ConstStringTable::Add(ConstString s) {272 auto [pos, inserted] = m_string_to_offset.try_emplace(s, m_next_offset);273 if (inserted) {274 m_strings.push_back(s);275 m_next_offset += s.GetLength() + 1;276 }277 return pos->second;278}279 280static const llvm::StringRef kStringTableIdentifier("STAB");281 282bool ConstStringTable::Encode(DataEncoder &encoder) {283 // Write an 4 character code into the stream. This will help us when decoding284 // to make sure we find this identifier when decoding the string table to make285 // sure we have the rigth data. It also helps to identify the string table286 // when dumping the hex bytes in a cache file.287 encoder.AppendData(kStringTableIdentifier);288 size_t length_offset = encoder.GetByteSize();289 encoder.AppendU32(0); // Total length of all strings which will be fixed up.290 size_t strtab_offset = encoder.GetByteSize();291 encoder.AppendU8(0); // Start the string table with an empty string.292 for (auto s: m_strings) {293 // Make sure all of the offsets match up with what we handed out!294 assert(m_string_to_offset.find(s)->second ==295 encoder.GetByteSize() - strtab_offset);296 // Append the C string into the encoder297 encoder.AppendCString(s.GetStringRef());298 }299 // Fixup the string table length.300 encoder.PutU32(length_offset, encoder.GetByteSize() - strtab_offset);301 return true;302}303 304bool StringTableReader::Decode(const lldb_private::DataExtractor &data,305 lldb::offset_t *offset_ptr) {306 llvm::StringRef identifier((const char *)data.GetData(offset_ptr, 4), 4);307 if (identifier != kStringTableIdentifier)308 return false;309 const uint32_t length = data.GetU32(offset_ptr);310 // We always have at least one byte for the empty string at offset zero.311 if (length == 0)312 return false;313 const char *bytes = (const char *)data.GetData(offset_ptr, length);314 if (bytes == nullptr)315 return false;316 m_data = llvm::StringRef(bytes, length);317 return true;318}319 320llvm::StringRef StringTableReader::Get(uint32_t offset) const {321 if (offset >= m_data.size())322 return llvm::StringRef();323 return llvm::StringRef(m_data.data() + offset);324}325 326