Debuginfod.cpp | Explore in Territory

//===-- llvm/Debuginfod/Debuginfod.cpp - Debuginfod client library --------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
///
/// \file
///
/// This file contains several definitions for the debuginfod client and server.
/// For the client, this file defines the fetchInfo function. For the server,
/// this file defines the DebuginfodLogEntry and DebuginfodServer structs, as
/// well as the DebuginfodLog, DebuginfodCollection classes. The fetchInfo
/// function retrieves any of the three supported artifact types: (executable,
/// debuginfo, source file) associated with a build-id from debuginfod servers.
/// If a source file is to be fetched, its absolute path must be specified in
/// the Description argument to fetchInfo. The DebuginfodLogEntry,
/// DebuginfodLog, and DebuginfodCollection are used by the DebuginfodServer to
/// scan the local filesystem for binaries and serve the debuginfod protocol.
///
//===----------------------------------------------------------------------===//

#include "llvm/Debuginfod/Debuginfod.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/BinaryFormat/Magic.h"
#include "llvm/DebugInfo/DWARF/DWARFContext.h"
#include "llvm/DebugInfo/Symbolize/Symbolize.h"
#include "llvm/Debuginfod/HTTPClient.h"
#include "llvm/Object/BuildID.h"
#include "llvm/Object/ELFObjectFile.h"
#include "llvm/Support/CachePruning.h"
#include "llvm/Support/Caching.h"
#include "llvm/Support/Errc.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/FileUtilities.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/ThreadPool.h"
#include "llvm/Support/xxhash.h"

#include <atomic>
#include <optional>
#include <thread>

namespace llvm {

BuildIDRef;

namespace {
std::optional<SmallVector<StringRef>> DebuginfodUrls;
// Many Readers/Single Writer lock protecting the global debuginfod URL list.
llvm::sys::RWMutex UrlsMutex;
} // namespace

std::string getDebuginfodCacheKey(llvm::StringRef S) { … }

// Returns a binary BuildID as a normalized hex string.
// Uses lowercase for compatibility with common debuginfod servers.
static std::string buildIDToString(BuildIDRef ID) { … }

bool canUseDebuginfod() { … }

SmallVector<StringRef> getDefaultDebuginfodUrls() { … }

// Set the default debuginfod URL list, override the environment variable.
void setDefaultDebuginfodUrls(const SmallVector<StringRef> &URLs) { … }

/// Finds a default local file caching directory for the debuginfod client,
/// first checking DEBUGINFOD_CACHE_PATH.
Expected<std::string> getDefaultDebuginfodCacheDirectory() { … }

std::chrono::milliseconds getDefaultDebuginfodTimeout() { … }

/// The following functions fetch a debuginfod artifact to a file in a local
/// cache and return the cached file path. They first search the local cache,
/// followed by the debuginfod servers.

std::string getDebuginfodSourceUrlPath(BuildIDRef ID,
                                       StringRef SourceFilePath) { … }

Expected<std::string> getCachedOrDownloadSource(BuildIDRef ID,
                                                StringRef SourceFilePath) { … }

std::string getDebuginfodExecutableUrlPath(BuildIDRef ID) { … }

Expected<std::string> getCachedOrDownloadExecutable(BuildIDRef ID) { … }

std::string getDebuginfodDebuginfoUrlPath(BuildIDRef ID) { … }

Expected<std::string> getCachedOrDownloadDebuginfo(BuildIDRef ID) { … }

// General fetching function.
Expected<std::string> getCachedOrDownloadArtifact(StringRef UniqueKey,
                                                  StringRef UrlPath) { … }

namespace {

/// A simple handler which streams the returned data to a cache file. The cache
/// file is only created if a 200 OK status is observed.
class StreamedHTTPResponseHandler : public HTTPResponseHandler { … };

} // namespace

Error StreamedHTTPResponseHandler::handleBodyChunk(StringRef BodyChunk) { … }

// An over-accepting simplification of the HTTP RFC 7230 spec.
static bool isHeader(StringRef S) { … }

static SmallVector<std::string, 0> getHeaders() { … }

Expected<std::string> getCachedOrDownloadArtifact(
    StringRef UniqueKey, StringRef UrlPath, StringRef CacheDirectoryPath,
    ArrayRef<StringRef> DebuginfodUrls, std::chrono::milliseconds Timeout) { … }

DebuginfodLogEntry::DebuginfodLogEntry(const Twine &Message)
    : … { … }

void DebuginfodLog::push(const Twine &Message) { … }

void DebuginfodLog::push(DebuginfodLogEntry Entry) { … }

DebuginfodLogEntry DebuginfodLog::pop() { … }

DebuginfodCollection::DebuginfodCollection(ArrayRef<StringRef> PathsRef,
                                           DebuginfodLog &Log,
                                           ThreadPoolInterface &Pool,
                                           double MinInterval)
    : … { … }

Error DebuginfodCollection::update() { … }

Expected<bool> DebuginfodCollection::updateIfStale() { … }

Error DebuginfodCollection::updateForever(std::chrono::milliseconds Interval) { … }

static bool hasELFMagic(StringRef FilePath) { … }

Error DebuginfodCollection::findBinaries(StringRef Path) { … }

Expected<std::optional<std::string>>
DebuginfodCollection::getBinaryPath(BuildIDRef ID) { … }

Expected<std::optional<std::string>>
DebuginfodCollection::getDebugBinaryPath(BuildIDRef ID) { … }

Expected<std::string> DebuginfodCollection::findBinaryPath(BuildIDRef ID) { … }

Expected<std::string> DebuginfodCollection::findDebugBinaryPath(BuildIDRef ID) { … }

DebuginfodServer::DebuginfodServer(DebuginfodLog &Log,
                                   DebuginfodCollection &Collection)
    : … { … }

} // namespace llvm
llvm/llvm/lib/Debuginfod/Debuginfod.cpp
