mirror of
https://github.com/intel/llvm.git
synced 2026-01-15 12:25:46 +08:00
bb894b9782
Extract all the provider related logic from Reproducer.h and move it into its own header ReproducerProvider.h. These classes are seeing most of the development these days and this reorganization reduces incremental compilation from ~520 to ~110 files when making changes to the new header.
378 lines
12 KiB
C++
378 lines
12 KiB
C++
//===-- ProcessInfo.cpp ---------------------------------------------------===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Utility/ProcessInfo.h"
|
|
|
|
#include "lldb/Utility/ArchSpec.h"
|
|
#include "lldb/Utility/ReproducerProvider.h"
|
|
#include "lldb/Utility/Stream.h"
|
|
#include "lldb/Utility/StreamString.h"
|
|
#include "lldb/Utility/UserIDResolver.h"
|
|
#include "llvm/ADT/SmallString.h"
|
|
|
|
#include <climits>
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
using namespace lldb_private::repro;
|
|
|
|
ProcessInfo::ProcessInfo()
|
|
: m_executable(), m_arguments(), m_environment(), m_uid(UINT32_MAX),
|
|
m_gid(UINT32_MAX), m_arch(), m_pid(LLDB_INVALID_PROCESS_ID) {}
|
|
|
|
ProcessInfo::ProcessInfo(const char *name, const ArchSpec &arch,
|
|
lldb::pid_t pid)
|
|
: m_executable(name), m_arguments(), m_environment(), m_uid(UINT32_MAX),
|
|
m_gid(UINT32_MAX), m_arch(arch), m_pid(pid) {}
|
|
|
|
void ProcessInfo::Clear() {
|
|
m_executable.Clear();
|
|
m_arguments.Clear();
|
|
m_environment.clear();
|
|
m_uid = UINT32_MAX;
|
|
m_gid = UINT32_MAX;
|
|
m_arch.Clear();
|
|
m_pid = LLDB_INVALID_PROCESS_ID;
|
|
}
|
|
|
|
const char *ProcessInfo::GetName() const {
|
|
return m_executable.GetFilename().GetCString();
|
|
}
|
|
|
|
llvm::StringRef ProcessInfo::GetNameAsStringRef() const {
|
|
return m_executable.GetFilename().GetStringRef();
|
|
}
|
|
|
|
void ProcessInfo::Dump(Stream &s, Platform *platform) const {
|
|
s << "Executable: " << GetName() << "\n";
|
|
s << "Triple: ";
|
|
m_arch.DumpTriple(s.AsRawOstream());
|
|
s << "\n";
|
|
|
|
s << "Arguments:\n";
|
|
m_arguments.Dump(s);
|
|
|
|
s.Format("Environment:\n{0}", m_environment);
|
|
}
|
|
|
|
void ProcessInfo::SetExecutableFile(const FileSpec &exe_file,
|
|
bool add_exe_file_as_first_arg) {
|
|
if (exe_file) {
|
|
m_executable = exe_file;
|
|
if (add_exe_file_as_first_arg) {
|
|
llvm::SmallString<128> filename;
|
|
exe_file.GetPath(filename);
|
|
if (!filename.empty())
|
|
m_arguments.InsertArgumentAtIndex(0, filename);
|
|
}
|
|
} else {
|
|
m_executable.Clear();
|
|
}
|
|
}
|
|
|
|
llvm::StringRef ProcessInfo::GetArg0() const { return m_arg0; }
|
|
|
|
void ProcessInfo::SetArg0(llvm::StringRef arg) { m_arg0 = std::string(arg); }
|
|
|
|
void ProcessInfo::SetArguments(char const **argv,
|
|
bool first_arg_is_executable) {
|
|
m_arguments.SetArguments(argv);
|
|
|
|
// Is the first argument the executable?
|
|
if (first_arg_is_executable) {
|
|
const char *first_arg = m_arguments.GetArgumentAtIndex(0);
|
|
if (first_arg) {
|
|
// Yes the first argument is an executable, set it as the executable in
|
|
// the launch options. Don't resolve the file path as the path could be a
|
|
// remote platform path
|
|
m_executable.SetFile(first_arg, FileSpec::Style::native);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ProcessInfo::SetArguments(const Args &args, bool first_arg_is_executable) {
|
|
// Copy all arguments
|
|
m_arguments = args;
|
|
|
|
// Is the first argument the executable?
|
|
if (first_arg_is_executable) {
|
|
const char *first_arg = m_arguments.GetArgumentAtIndex(0);
|
|
if (first_arg) {
|
|
// Yes the first argument is an executable, set it as the executable in
|
|
// the launch options. Don't resolve the file path as the path could be a
|
|
// remote platform path
|
|
m_executable.SetFile(first_arg, FileSpec::Style::native);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ProcessInstanceInfo::Dump(Stream &s, UserIDResolver &resolver) const {
|
|
if (m_pid != LLDB_INVALID_PROCESS_ID)
|
|
s.Printf(" pid = %" PRIu64 "\n", m_pid);
|
|
|
|
if (m_parent_pid != LLDB_INVALID_PROCESS_ID)
|
|
s.Printf(" parent = %" PRIu64 "\n", m_parent_pid);
|
|
|
|
if (m_executable) {
|
|
s.Printf(" name = %s\n", m_executable.GetFilename().GetCString());
|
|
s.PutCString(" file = ");
|
|
m_executable.Dump(s.AsRawOstream());
|
|
s.EOL();
|
|
}
|
|
const uint32_t argc = m_arguments.GetArgumentCount();
|
|
if (argc > 0) {
|
|
for (uint32_t i = 0; i < argc; i++) {
|
|
const char *arg = m_arguments.GetArgumentAtIndex(i);
|
|
if (i < 10)
|
|
s.Printf(" arg[%u] = %s\n", i, arg);
|
|
else
|
|
s.Printf("arg[%u] = %s\n", i, arg);
|
|
}
|
|
}
|
|
|
|
s.Format("{0}", m_environment);
|
|
|
|
if (m_arch.IsValid()) {
|
|
s.Printf(" arch = ");
|
|
m_arch.DumpTriple(s.AsRawOstream());
|
|
s.EOL();
|
|
}
|
|
|
|
if (UserIDIsValid()) {
|
|
s.Format(" uid = {0,-5} ({1})\n", GetUserID(),
|
|
resolver.GetUserName(GetUserID()).getValueOr(""));
|
|
}
|
|
if (GroupIDIsValid()) {
|
|
s.Format(" gid = {0,-5} ({1})\n", GetGroupID(),
|
|
resolver.GetGroupName(GetGroupID()).getValueOr(""));
|
|
}
|
|
if (EffectiveUserIDIsValid()) {
|
|
s.Format(" euid = {0,-5} ({1})\n", GetEffectiveUserID(),
|
|
resolver.GetUserName(GetEffectiveUserID()).getValueOr(""));
|
|
}
|
|
if (EffectiveGroupIDIsValid()) {
|
|
s.Format(" egid = {0,-5} ({1})\n", GetEffectiveGroupID(),
|
|
resolver.GetGroupName(GetEffectiveGroupID()).getValueOr(""));
|
|
}
|
|
}
|
|
|
|
void ProcessInstanceInfo::DumpTableHeader(Stream &s, bool show_args,
|
|
bool verbose) {
|
|
const char *label;
|
|
if (show_args || verbose)
|
|
label = "ARGUMENTS";
|
|
else
|
|
label = "NAME";
|
|
|
|
if (verbose) {
|
|
s.Printf("PID PARENT USER GROUP EFF USER EFF GROUP TRIPLE "
|
|
" %s\n",
|
|
label);
|
|
s.PutCString(
|
|
"====== ====== ========== ========== ========== ========== "
|
|
"============================== ============================\n");
|
|
} else {
|
|
s.Printf("PID PARENT USER TRIPLE %s\n",
|
|
label);
|
|
s.PutCString("====== ====== ========== ============================== "
|
|
"============================\n");
|
|
}
|
|
}
|
|
|
|
void ProcessInstanceInfo::DumpAsTableRow(Stream &s, UserIDResolver &resolver,
|
|
bool show_args, bool verbose) const {
|
|
if (m_pid != LLDB_INVALID_PROCESS_ID) {
|
|
s.Printf("%-6" PRIu64 " %-6" PRIu64 " ", m_pid, m_parent_pid);
|
|
|
|
StreamString arch_strm;
|
|
if (m_arch.IsValid())
|
|
m_arch.DumpTriple(arch_strm.AsRawOstream());
|
|
|
|
auto print = [&](bool (ProcessInstanceInfo::*isValid)() const,
|
|
uint32_t (ProcessInstanceInfo::*getID)() const,
|
|
llvm::Optional<llvm::StringRef> (UserIDResolver::*getName)(
|
|
UserIDResolver::id_t id)) {
|
|
const char *format = "{0,-10} ";
|
|
if (!(this->*isValid)()) {
|
|
s.Format(format, "");
|
|
return;
|
|
}
|
|
uint32_t id = (this->*getID)();
|
|
if (auto name = (resolver.*getName)(id))
|
|
s.Format(format, *name);
|
|
else
|
|
s.Format(format, id);
|
|
};
|
|
if (verbose) {
|
|
print(&ProcessInstanceInfo::UserIDIsValid,
|
|
&ProcessInstanceInfo::GetUserID, &UserIDResolver::GetUserName);
|
|
print(&ProcessInstanceInfo::GroupIDIsValid,
|
|
&ProcessInstanceInfo::GetGroupID, &UserIDResolver::GetGroupName);
|
|
print(&ProcessInstanceInfo::EffectiveUserIDIsValid,
|
|
&ProcessInstanceInfo::GetEffectiveUserID,
|
|
&UserIDResolver::GetUserName);
|
|
print(&ProcessInstanceInfo::EffectiveGroupIDIsValid,
|
|
&ProcessInstanceInfo::GetEffectiveGroupID,
|
|
&UserIDResolver::GetGroupName);
|
|
|
|
s.Printf("%-30s ", arch_strm.GetData());
|
|
} else {
|
|
print(&ProcessInstanceInfo::EffectiveUserIDIsValid,
|
|
&ProcessInstanceInfo::GetEffectiveUserID,
|
|
&UserIDResolver::GetUserName);
|
|
s.Printf("%-30s ", arch_strm.GetData());
|
|
}
|
|
|
|
if (verbose || show_args) {
|
|
s.PutCString(m_arg0);
|
|
const uint32_t argc = m_arguments.GetArgumentCount();
|
|
for (uint32_t i = 0; i < argc; i++) {
|
|
s.PutChar(' ');
|
|
s.PutCString(m_arguments.GetArgumentAtIndex(i));
|
|
}
|
|
} else {
|
|
s.PutCString(GetName());
|
|
}
|
|
|
|
s.EOL();
|
|
}
|
|
}
|
|
|
|
bool ProcessInstanceInfoMatch::ArchitectureMatches(
|
|
const ArchSpec &arch_spec) const {
|
|
return !m_match_info.GetArchitecture().IsValid() ||
|
|
m_match_info.GetArchitecture().IsCompatibleMatch(arch_spec);
|
|
}
|
|
|
|
bool ProcessInstanceInfoMatch::NameMatches(const char *process_name) const {
|
|
if (m_name_match_type == NameMatch::Ignore)
|
|
return true;
|
|
const char *match_name = m_match_info.GetName();
|
|
if (!match_name)
|
|
return true;
|
|
|
|
return lldb_private::NameMatches(process_name, m_name_match_type, match_name);
|
|
}
|
|
|
|
bool ProcessInstanceInfoMatch::ProcessIDsMatch(
|
|
const ProcessInstanceInfo &proc_info) const {
|
|
if (m_match_info.ProcessIDIsValid() &&
|
|
m_match_info.GetProcessID() != proc_info.GetProcessID())
|
|
return false;
|
|
|
|
if (m_match_info.ParentProcessIDIsValid() &&
|
|
m_match_info.GetParentProcessID() != proc_info.GetParentProcessID())
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool ProcessInstanceInfoMatch::UserIDsMatch(
|
|
const ProcessInstanceInfo &proc_info) const {
|
|
if (m_match_info.UserIDIsValid() &&
|
|
m_match_info.GetUserID() != proc_info.GetUserID())
|
|
return false;
|
|
|
|
if (m_match_info.GroupIDIsValid() &&
|
|
m_match_info.GetGroupID() != proc_info.GetGroupID())
|
|
return false;
|
|
|
|
if (m_match_info.EffectiveUserIDIsValid() &&
|
|
m_match_info.GetEffectiveUserID() != proc_info.GetEffectiveUserID())
|
|
return false;
|
|
|
|
if (m_match_info.EffectiveGroupIDIsValid() &&
|
|
m_match_info.GetEffectiveGroupID() != proc_info.GetEffectiveGroupID())
|
|
return false;
|
|
return true;
|
|
}
|
|
bool ProcessInstanceInfoMatch::Matches(
|
|
const ProcessInstanceInfo &proc_info) const {
|
|
return ArchitectureMatches(proc_info.GetArchitecture()) &&
|
|
ProcessIDsMatch(proc_info) && UserIDsMatch(proc_info) &&
|
|
NameMatches(proc_info.GetName());
|
|
}
|
|
|
|
bool ProcessInstanceInfoMatch::MatchAllProcesses() const {
|
|
if (m_name_match_type != NameMatch::Ignore)
|
|
return false;
|
|
|
|
if (m_match_info.ProcessIDIsValid())
|
|
return false;
|
|
|
|
if (m_match_info.ParentProcessIDIsValid())
|
|
return false;
|
|
|
|
if (m_match_info.UserIDIsValid())
|
|
return false;
|
|
|
|
if (m_match_info.GroupIDIsValid())
|
|
return false;
|
|
|
|
if (m_match_info.EffectiveUserIDIsValid())
|
|
return false;
|
|
|
|
if (m_match_info.EffectiveGroupIDIsValid())
|
|
return false;
|
|
|
|
if (m_match_info.GetArchitecture().IsValid())
|
|
return false;
|
|
|
|
if (m_match_all_users)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void ProcessInstanceInfoMatch::Clear() {
|
|
m_match_info.Clear();
|
|
m_name_match_type = NameMatch::Ignore;
|
|
m_match_all_users = false;
|
|
}
|
|
|
|
void llvm::yaml::MappingTraits<ProcessInstanceInfo>::mapping(
|
|
IO &io, ProcessInstanceInfo &Info) {
|
|
io.mapRequired("executable", Info.m_executable);
|
|
io.mapRequired("arg0", Info.m_arg0);
|
|
io.mapRequired("args", Info.m_arguments);
|
|
io.mapRequired("arch", Info.m_arch);
|
|
io.mapRequired("uid", Info.m_uid);
|
|
io.mapRequired("gid", Info.m_gid);
|
|
io.mapRequired("pid", Info.m_pid);
|
|
io.mapRequired("effective-uid", Info.m_euid);
|
|
io.mapRequired("effective-gid", Info.m_egid);
|
|
io.mapRequired("parent-pid", Info.m_parent_pid);
|
|
}
|
|
|
|
|
|
llvm::Optional<ProcessInstanceInfoList>
|
|
repro::GetReplayProcessInstanceInfoList() {
|
|
static std::unique_ptr<repro::MultiLoader<repro::ProcessInfoProvider>>
|
|
loader = repro::MultiLoader<repro::ProcessInfoProvider>::Create(
|
|
repro::Reproducer::Instance().GetLoader());
|
|
|
|
if (!loader)
|
|
return {};
|
|
|
|
llvm::Optional<std::string> nextfile = loader->GetNextFile();
|
|
if (!nextfile)
|
|
return {};
|
|
|
|
auto error_or_file = llvm::MemoryBuffer::getFile(*nextfile);
|
|
if (std::error_code err = error_or_file.getError())
|
|
return {};
|
|
|
|
ProcessInstanceInfoList infos;
|
|
llvm::yaml::Input yin((*error_or_file)->getBuffer());
|
|
yin >> infos;
|
|
|
|
if (auto err = yin.error())
|
|
return {};
|
|
|
|
return infos;
|
|
}
|