contrib/llvm/tools/lldb/source/Host/openbsd/Host.cpp

   1 //===-- source/Host/openbsd/Host.cpp ----------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include <sys/types.h>
  11
  12 #include <sys/signal.h>
  13 #include <sys/exec.h>
  14 #include <sys/proc.h>
  15 #include <sys/ptrace.h>
  16 #include <sys/sysctl.h>
  17 #include <sys/user.h>
  18
  19 #include <stdio.h>
  20
  21 #include "lldb/Host/Host.h"
  22 #include "lldb/Host/HostInfo.h"
  23 #include "lldb/Target/Process.h"
  24 #include "lldb/Utility/DataBufferHeap.h"
  25 #include "lldb/Utility/DataExtractor.h"
  26 #include "lldb/Utility/Endian.h"
  27 #include "lldb/Utility/Log.h"
  28 #include "lldb/Utility/NameMatches.h"
  29 #include "lldb/Utility/Status.h"
  30 #include "lldb/Utility/StreamString.h"
  31
  32 #include "llvm/Support/Host.h"
  33
  34 extern "C" {
  35 extern char **environ;
  36 }
  37
  38 using namespace lldb;
  39 using namespace lldb_private;
  40
  41 Environment Host::GetEnvironment() {
  42   Environment env;
  43   char *v;
  44   char **var = environ;
  45   for (; var != NULL && *var != NULL; ++var) {
  46     v = strchr(*var, (int)'-');
  47     if (v == NULL)
  48       continue;
  49     env.insert(v);
  50   }
  51   return env;
  52 }
  53
  54 static bool
  55 GetOpenBSDProcessArgs(const ProcessInstanceInfoMatch *match_info_ptr,
  56                       ProcessInstanceInfo &process_info) {
  57   if (process_info.ProcessIDIsValid()) {
  58     int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_ARGS,
  59                   (int)process_info.GetProcessID()};
  60
  61     char arg_data[8192];
  62     size_t arg_data_size = sizeof(arg_data);
  63     if (::sysctl(mib, 4, arg_data, &arg_data_size, NULL, 0) == 0) {
  64       DataExtractor data(arg_data, arg_data_size, endian::InlHostByteOrder(),
  65                          sizeof(void *));
  66       lldb::offset_t offset = 0;
  67       const char *cstr;
  68
  69       cstr = data.GetCStr(&offset);
  70       if (cstr) {
  71         process_info.GetExecutableFile().SetFile(cstr, FileSpec::Style::native);
  72
  73         if (!(match_info_ptr == NULL ||
  74               NameMatches(
  75                   process_info.GetExecutableFile().GetFilename().GetCString(),
  76                   match_info_ptr->GetNameMatchType(),
  77                   match_info_ptr->GetProcessInfo().GetName())))
  78           return false;
  79
  80         Args &proc_args = process_info.GetArguments();
  81         while (1) {
  82           const uint8_t *p = data.PeekData(offset, 1);
  83           while ((p != NULL) && (*p == '\0') && offset < arg_data_size) {
  84             ++offset;
  85             p = data.PeekData(offset, 1);
  86           }
  87           if (p == NULL || offset >= arg_data_size)
  88             return true;
  89
  90           cstr = data.GetCStr(&offset);
  91           if (cstr)
  92             proc_args.AppendArgument(llvm::StringRef(cstr));
  93           else
  94             return true;
  95         }
  96       }
  97     }
  98   }
  99   return false;
 100 }
 101
 102 static bool GetOpenBSDProcessCPUType(ProcessInstanceInfo &process_info) {
 103   if (process_info.ProcessIDIsValid()) {
 104     process_info.GetArchitecture() =
 105         HostInfo::GetArchitecture(HostInfo::eArchKindDefault);
 106     return true;
 107   }
 108   process_info.GetArchitecture().Clear();
 109   return false;
 110 }
 111
 112 static bool GetOpenBSDProcessUserAndGroup(ProcessInstanceInfo &process_info) {
 113   struct kinfo_proc proc_kinfo;
 114   size_t proc_kinfo_size;
 115
 116   if (process_info.ProcessIDIsValid()) {
 117     int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID,
 118                   (int)process_info.GetProcessID()};
 119     proc_kinfo_size = sizeof(struct kinfo_proc);
 120
 121     if (::sysctl(mib, 4, &proc_kinfo, &proc_kinfo_size, NULL, 0) == 0) {
 122       if (proc_kinfo_size > 0) {
 123         process_info.SetParentProcessID(proc_kinfo.p_ppid);
 124         process_info.SetUserID(proc_kinfo.p_ruid);
 125         process_info.SetGroupID(proc_kinfo.p_rgid);
 126         process_info.SetEffectiveUserID(proc_kinfo.p_uid);
 127         process_info.SetEffectiveGroupID(proc_kinfo.p_gid);
 128         return true;
 129       }
 130     }
 131   }
 132   process_info.SetParentProcessID(LLDB_INVALID_PROCESS_ID);
 133   process_info.SetUserID(UINT32_MAX);
 134   process_info.SetGroupID(UINT32_MAX);
 135   process_info.SetEffectiveUserID(UINT32_MAX);
 136   process_info.SetEffectiveGroupID(UINT32_MAX);
 137   return false;
 138 }
 139
 140 uint32_t Host::FindProcesses(const ProcessInstanceInfoMatch &match_info,
 141                              ProcessInstanceInfoList &process_infos) {
 142   std::vector<struct kinfo_proc> kinfos;
 143
 144   int mib[3] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL};
 145
 146   size_t pid_data_size = 0;
 147   if (::sysctl(mib, 3, NULL, &pid_data_size, NULL, 0) != 0)
 148     return 0;
 149
 150   // Add a few extra in case a few more show up
 151   const size_t estimated_pid_count =
 152       (pid_data_size / sizeof(struct kinfo_proc)) + 10;
 153
 154   kinfos.resize(estimated_pid_count);
 155   pid_data_size = kinfos.size() * sizeof(struct kinfo_proc);
 156
 157   if (::sysctl(mib, 3, &kinfos[0], &pid_data_size, NULL, 0) != 0)
 158     return 0;
 159
 160   const size_t actual_pid_count = (pid_data_size / sizeof(struct kinfo_proc));
 161
 162   bool all_users = match_info.GetMatchAllUsers();
 163   const ::pid_t our_pid = getpid();
 164   const uid_t our_uid = getuid();
 165   for (size_t i = 0; i < actual_pid_count; i++) {
 166     const struct kinfo_proc &kinfo = kinfos[i];
 167     const bool kinfo_user_matches = (all_users || (kinfo.p_ruid == our_uid) ||
 168                                      // Special case, if lldb is being run as
 169                                      // root we can attach to anything.
 170                                      (our_uid == 0));
 171
 172     if (kinfo_user_matches == false || // Make sure the user is acceptable
 173         kinfo.p_pid == our_pid ||     // Skip this process
 174         kinfo.p_pid == 0 ||           // Skip kernel (kernel pid is zero)
 175         kinfo.p_stat == SZOMB ||      // Zombies are bad, they like brains...
 176         kinfo.p_psflags & PS_TRACED || // Being debugged?
 177         kinfo.p_flag & P_WEXIT)       // Working on exiting
 178       continue;
 179
 180     ProcessInstanceInfo process_info;
 181     process_info.SetProcessID(kinfo.p_pid);
 182     process_info.SetParentProcessID(kinfo.p_ppid);
 183     process_info.SetUserID(kinfo.p_ruid);
 184     process_info.SetGroupID(kinfo.p_rgid);
 185     process_info.SetEffectiveUserID(kinfo.p_svuid);
 186     process_info.SetEffectiveGroupID(kinfo.p_svgid);
 187
 188     // Make sure our info matches before we go fetch the name and cpu type
 189     if (match_info.Matches(process_info) &&
 190         GetOpenBSDProcessArgs(&match_info, process_info)) {
 191       GetOpenBSDProcessCPUType(process_info);
 192       if (match_info.Matches(process_info))
 193         process_infos.Append(process_info);
 194     }
 195   }
 196
 197   return process_infos.GetSize();
 198 }
 199
 200 bool Host::GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &process_info) {
 201   process_info.SetProcessID(pid);
 202
 203   if (GetOpenBSDProcessArgs(NULL, process_info)) {
 204     // should use libprocstat instead of going right into sysctl?
 205     GetOpenBSDProcessCPUType(process_info);
 206     GetOpenBSDProcessUserAndGroup(process_info);
 207     return true;
 208   }
 209
 210   process_info.Clear();
 211   return false;
 212 }
 213
 214 Status Host::ShellExpandArguments(ProcessLaunchInfo &launch_info) {
 215   return Status("unimplemented");
 216 }