1 //===-- source/Host/netbsd/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 <dlfcn.h>
11 #include <execinfo.h>
12 #include <stdio.h>
13 #include <sys/proc.h>
14 #include <sys/sysctl.h>
15 #include <sys/types.h>
16 
17 #include <limits.h>
18 
19 #include <elf.h>
20 #include <kvm.h>
21 #include <sys/exec.h>
22 #include <sys/ptrace.h>
23 
24 #include "lldb/Host/Host.h"
25 #include "lldb/Host/HostInfo.h"
26 #include "lldb/Target/Process.h"
27 #include "lldb/Utility/DataBufferHeap.h"
28 #include "lldb/Utility/DataExtractor.h"
29 #include "lldb/Utility/Endian.h"
30 #include "lldb/Utility/Log.h"
31 #include "lldb/Utility/NameMatches.h"
32 #include "lldb/Utility/Status.h"
33 #include "lldb/Utility/StreamString.h"
34 
35 #include "llvm/Support/Host.h"
36 
37 extern "C" {
38 extern char **environ;
39 }
40 
41 using namespace lldb;
42 using namespace lldb_private;
43 
44 Environment Host::GetEnvironment() { return Environment(environ); }
45 
46 static bool GetNetBSDProcessArgs(const ProcessInstanceInfoMatch *match_info_ptr,
47                                  ProcessInstanceInfo &process_info) {
48   if (!process_info.ProcessIDIsValid())
49     return false;
50 
51   int pid = process_info.GetProcessID();
52 
53   int mib[4] = {CTL_KERN, KERN_PROC_ARGS, pid, KERN_PROC_ARGV};
54 
55   char arg_data[8192];
56   size_t arg_data_size = sizeof(arg_data);
57   if (::sysctl(mib, 4, arg_data, &arg_data_size, NULL, 0) != 0)
58     return false;
59 
60   DataExtractor data(arg_data, arg_data_size, endian::InlHostByteOrder(),
61                      sizeof(void *));
62   lldb::offset_t offset = 0;
63   const char *cstr;
64 
65   cstr = data.GetCStr(&offset);
66   if (!cstr)
67     return false;
68 
69   process_info.GetExecutableFile().SetFile(cstr,
70                                            FileSpec::Style::native);
71 
72   if (!(match_info_ptr == NULL ||
73         NameMatches(process_info.GetExecutableFile().GetFilename().GetCString(),
74                     match_info_ptr->GetNameMatchType(),
75                     match_info_ptr->GetProcessInfo().GetName())))
76     return false;
77 
78   Args &proc_args = process_info.GetArguments();
79   while (1) {
80     const uint8_t *p = data.PeekData(offset, 1);
81     while ((p != NULL) && (*p == '\0') && offset < arg_data_size) {
82       ++offset;
83       p = data.PeekData(offset, 1);
84     }
85     if (p == NULL || offset >= arg_data_size)
86       break;
87 
88     cstr = data.GetCStr(&offset);
89     if (!cstr)
90       break;
91 
92     proc_args.AppendArgument(llvm::StringRef(cstr));
93   }
94 
95   return true;
96 }
97 
98 static bool GetNetBSDProcessCPUType(ProcessInstanceInfo &process_info) {
99   if (process_info.ProcessIDIsValid()) {
100     process_info.GetArchitecture() =
101         HostInfo::GetArchitecture(HostInfo::eArchKindDefault);
102     return true;
103   }
104   process_info.GetArchitecture().Clear();
105   return false;
106 }
107 
108 static bool GetNetBSDProcessUserAndGroup(ProcessInstanceInfo &process_info) {
109   ::kvm_t *kdp;
110   char errbuf[_POSIX2_LINE_MAX]; /* XXX: error string unused */
111 
112   struct ::kinfo_proc2 *proc_kinfo;
113   const int pid = process_info.GetProcessID();
114   int nproc;
115 
116   if (!process_info.ProcessIDIsValid())
117     goto error;
118 
119   if ((kdp = ::kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, errbuf)) == NULL)
120     goto error;
121 
122   if ((proc_kinfo = ::kvm_getproc2(kdp, KERN_PROC_PID, pid,
123                                    sizeof(struct ::kinfo_proc2), &nproc)) ==
124       NULL) {
125     ::kvm_close(kdp);
126     goto error;
127   }
128 
129   if (nproc < 1) {
130     ::kvm_close(kdp); /* XXX: we don't check for error here */
131     goto error;
132   }
133 
134   process_info.SetParentProcessID(proc_kinfo->p_ppid);
135   process_info.SetUserID(proc_kinfo->p_ruid);
136   process_info.SetGroupID(proc_kinfo->p_rgid);
137   process_info.SetEffectiveUserID(proc_kinfo->p_uid);
138   process_info.SetEffectiveGroupID(proc_kinfo->p_gid);
139 
140   ::kvm_close(kdp); /* XXX: we don't check for error here */
141 
142   return true;
143 
144 error:
145   process_info.SetParentProcessID(LLDB_INVALID_PROCESS_ID);
146   process_info.SetUserID(UINT32_MAX);
147   process_info.SetGroupID(UINT32_MAX);
148   process_info.SetEffectiveUserID(UINT32_MAX);
149   process_info.SetEffectiveGroupID(UINT32_MAX);
150   return false;
151 }
152 
153 uint32_t Host::FindProcesses(const ProcessInstanceInfoMatch &match_info,
154                              ProcessInstanceInfoList &process_infos) {
155   const ::pid_t our_pid = ::getpid();
156   const ::uid_t our_uid = ::getuid();
157 
158   const bool all_users =
159       match_info.GetMatchAllUsers() ||
160       // Special case, if lldb is being run as root we can attach to anything
161       (our_uid == 0);
162 
163   kvm_t *kdp;
164   char errbuf[_POSIX2_LINE_MAX]; /* XXX: error string unused */
165   if ((kdp = ::kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, errbuf)) == NULL)
166     return 0;
167 
168   struct ::kinfo_proc2 *proc_kinfo;
169   int nproc;
170   if ((proc_kinfo = ::kvm_getproc2(kdp, KERN_PROC_ALL, 0,
171                                    sizeof(struct ::kinfo_proc2), &nproc)) ==
172       NULL) {
173     ::kvm_close(kdp);
174     return 0;
175   }
176 
177   for (int i = 0; i < nproc; i++) {
178     if (proc_kinfo[i].p_pid < 1)
179       continue; /* not valid */
180     /* Make sure the user is acceptable */
181     if (!all_users && proc_kinfo[i].p_ruid != our_uid)
182       continue;
183 
184     if (proc_kinfo[i].p_pid == our_pid ||  // Skip this process
185         proc_kinfo[i].p_pid == 0 ||        // Skip kernel (kernel pid is 0)
186         proc_kinfo[i].p_stat == LSZOMB ||  // Zombies are bad
187         proc_kinfo[i].p_flag & P_TRACED || // Being debugged?
188         proc_kinfo[i].p_flag & P_WEXIT)    // Working on exiting
189       continue;
190 
191     // Every thread is a process in NetBSD, but all the threads of a single
192     // process have the same pid. Do not store the process info in the result
193     // list if a process with given identifier is already registered there.
194     if (proc_kinfo[i].p_nlwps > 1) {
195       bool already_registered = false;
196       for (size_t pi = 0; pi < process_infos.GetSize(); pi++) {
197         if (process_infos.GetProcessIDAtIndex(pi) == proc_kinfo[i].p_pid) {
198           already_registered = true;
199           break;
200         }
201       }
202 
203       if (already_registered)
204         continue;
205     }
206     ProcessInstanceInfo process_info;
207     process_info.SetProcessID(proc_kinfo[i].p_pid);
208     process_info.SetParentProcessID(proc_kinfo[i].p_ppid);
209     process_info.SetUserID(proc_kinfo[i].p_ruid);
210     process_info.SetGroupID(proc_kinfo[i].p_rgid);
211     process_info.SetEffectiveUserID(proc_kinfo[i].p_uid);
212     process_info.SetEffectiveGroupID(proc_kinfo[i].p_gid);
213     // Make sure our info matches before we go fetch the name and cpu type
214     if (match_info.Matches(process_info) &&
215         GetNetBSDProcessArgs(&match_info, process_info)) {
216       GetNetBSDProcessCPUType(process_info);
217       if (match_info.Matches(process_info))
218         process_infos.Append(process_info);
219     }
220   }
221 
222   kvm_close(kdp); /* XXX: we don't check for error here */
223 
224   return process_infos.GetSize();
225 }
226 
227 bool Host::GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &process_info) {
228   process_info.SetProcessID(pid);
229 
230   if (GetNetBSDProcessArgs(NULL, process_info)) {
231     GetNetBSDProcessCPUType(process_info);
232     GetNetBSDProcessUserAndGroup(process_info);
233     return true;
234   }
235 
236   process_info.Clear();
237   return false;
238 }
239 
240 Status Host::ShellExpandArguments(ProcessLaunchInfo &launch_info) {
241   return Status("unimplemented");
242 }
243