28c878aeb2
Applied modernize-use-default-member-init clang-tidy check over LLDB. It appears in many files we had already switched to in class member init but never updated the constructors to reflect that. This check is already present in the lldb/.clang-tidy config. Differential Revision: https://reviews.llvm.org/D121481
377 lines
11 KiB
C++
377 lines
11 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_arch() {}
|
|
|
|
ProcessInfo::ProcessInfo(const char *name, const ArchSpec &arch,
|
|
lldb::pid_t pid)
|
|
: m_executable(name), m_arguments(), m_environment(), 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;
|
|
}
|