1 /*
2 * PSINFO.C
3 *
4 * cc -I/usr/src/sys psinfo.c -o ~/bin/psinfo -lkvm
5 *
6 * Dump information about processes and threads in the system.
7 *
8 * Copyright (c) 2019 The DragonFly Project. All rights reserved.
9 *
10 * This code is derived from software contributed to The DragonFly Project
11 * by Matthew Dillon <dillon@backplane.com>
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
15 * are met:
16 *
17 * 1. Redistributions of source code must retain the above copyright
18 * notice, this list of conditions and the following disclaimer.
19 * 2. Redistributions in binary form must reproduce the above copyright
20 * notice, this list of conditions and the following disclaimer in
21 * the documentation and/or other materials provided with the
22 * distribution.
23 * 3. Neither the name of The DragonFly Project nor the names of its
24 * contributors may be used to endorse or promote products derived
25 * from this software without specific, prior written permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
29 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
30 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
31 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
32 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
33 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
34 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
35 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
36 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
37 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38 * SUCH DAMAGE.
39 */
40
41 #define _KERNEL_STRUCTURES_
42 #include <sys/param.h>
43 #include <sys/user.h>
44 #include <sys/malloc.h>
45 #include <sys/signalvar.h>
46 #include <sys/vnode.h>
47 #include <sys/namecache.h>
48 #include <sys/sysctl.h>
49 #include <sys/thread.h>
50 #include <sys/proc.h>
51
52 #include <vm/vm.h>
53 #include <vm/vm_page.h>
54 #include <vm/vm_kern.h>
55 #include <vm/vm_object.h>
56 #include <vm/vm_map.h>
57 #include <vm/swap_pager.h>
58 #include <vm/vnode_pager.h>
59
60 #include <stdio.h>
61 #include <stdlib.h>
62 #include <string.h>
63 #include <fcntl.h>
64 #include <kvm.h>
65 #include <nlist.h>
66 #include <getopt.h>
67
68 struct nlist Nl[] = {
69 { "_kernel_map" },
70 { NULL }
71 };
72
73 int debugopt;
74 int verboseopt;
75 struct vm_map kmap;
76 vm_offset_t total_empty;
77 vm_offset_t total_used;
78 vm_offset_t total_used_byid[VM_SUBSYS_LIMIT];
79
80 #if 0
81 static const char *formatnum(int64_t value);
82 static const char *entryid(vm_subsys_t id);
83 static void mapscan(kvm_t *kd, vm_map_entry_t kptr, vm_map_entry_t ken,
84 vm_offset_t *lastp);
85 #endif
86 static void kkread(kvm_t *kd, u_long addr, void *buf, size_t nbytes);
87
88 static void dumpproc(kvm_t *kd, struct kinfo_proc *kp);
89
90 int
main(int ac,char ** av)91 main(int ac, char **av)
92 {
93 const char *corefile = NULL;
94 const char *sysfile = NULL;
95 kvm_t *kd;
96 int ch;
97 int i;
98 int count;
99 vm_offset_t last;
100 struct vm_map_entry entry;
101 struct vm_map_entry *kptr;
102 struct kinfo_proc *kp;
103
104 while ((ch = getopt(ac, av, "M:N:dv")) != -1) {
105 switch(ch) {
106 case 'd':
107 ++debugopt;
108 break;
109 case 'v':
110 ++verboseopt;
111 break;
112 case 'M':
113 corefile = optarg;
114 break;
115 case 'N':
116 sysfile = optarg;
117 break;
118 default:
119 fprintf(stderr, "%s [-M core] [-N system]\n", av[0]);
120 exit(1);
121 }
122 }
123 ac -= optind;
124 av += optind;
125
126 if ((kd = kvm_open(sysfile, corefile, NULL, O_RDONLY, "kvm:")) == NULL) {
127 perror("kvm_open");
128 exit(1);
129 }
130 if (kvm_nlist(kd, Nl) != 0) {
131 perror("kvm_nlist");
132 exit(1);
133 }
134
135 kp = kvm_getprocs(kd, KERN_PROC_ALL, 0, &count);
136 for (i = 0; i < count; ++i) {
137 dumpproc(kd, &kp[i]);
138 }
139 return 0;
140 }
141
142 /*
143 * kp_paddr
144 *
145 * kp_flags
146 * kp_stat
147 * kp_lock
148 * kp_acflag
149 * kp_traceflag
150 *
151 * kp_fd
152 *
153 * kp_comm
154 *
155 * kp_uid
156 * kp_oud
157 * kp_vm_rssize
158 * kp_vm_swrss
159 *
160 * kp_lwp
161 *
162 */
163 static void
dumpproc(kvm_t * kd,struct kinfo_proc * kp)164 dumpproc(kvm_t *kd, struct kinfo_proc *kp)
165 {
166 struct proc p;
167 struct vmspace vms;
168 struct vm_map_entry entry;
169 struct vm_map_backing *ba;
170 struct vm_object obj;
171 vm_map_entry_t kptr;
172 int bacount;
173
174 printf("Process %6d:%-3d %6.6s (%s)",
175 kp->kp_pid, kp->kp_lwp.kl_tid,
176 kp->kp_lwp.kl_wmesg, kp->kp_comm);
177
178 if ((int)kp->kp_pid <= 0) {
179 printf("\n");
180 return;
181 }
182 kkread(kd, (u_long)kp->kp_paddr, &p, sizeof(p));
183 kkread(kd, (u_long)p.p_vmspace, &vms, sizeof(vms));
184
185 printf(" (%6.2fM resident, %6.2f wired)\n",
186 vms.vm_pmap.pm_stats.resident_count * 4096.0 / 1048576.0,
187 vms.vm_pmap.pm_stats.wired_count * 4096.0 / 1048576.0);
188
189 kptr = kvm_vm_map_entry_first(kd, &vms.vm_map, &entry);
190 while (kptr) {
191 bacount = 0;
192 printf(" entry %016jx-%016jx eflags=%04x prot=%02x max_prot=%02x",
193 entry.ba.start, entry.ba.end,
194 entry.eflags, entry.protection, entry.max_protection);
195 ba = &entry.ba;
196 bacount = 2;
197 for (;;) {
198 if (++bacount == 3) {
199 printf("\n\t\t");
200 bacount = 0;
201 }
202 printf(" [obj=%016jx,off=%016jx",
203 (uintptr_t)ba->object, ba->offset);
204 if (ba->object) {
205 kkread(kd, (u_long)ba->object, &obj, sizeof(obj));
206 if (obj.flags & OBJ_DEAD)
207 printf(",DEAD");
208 }
209 printf("]");
210
211 if (ba->backing_ba == NULL)
212 break;
213 kkread(kd, (u_long)ba->backing_ba, ba, sizeof(*ba));
214 }
215 printf("\n");
216 kptr = kvm_vm_map_entry_next(kd, kptr, &entry);
217 }
218 }
219
220 #if 0
221
222
223 kkread(kd, Nl[0].n_value, &kmap, sizeof(kmap));
224 last = kmap.min_addr;
225
226 kptr = kvm_vm_map_entry_first(kd, &kmap, &entry);
227 while (kptr) {
228 mapscan(kd, kptr, &entry, &last);
229 kptr = kvm_vm_map_entry_next(kd, kptr, &entry);
230 }
231
232 printf("%4ldM 0x%016jx %08lx-%08lx (%6s) EMPTY\n",
233 total_used / 1024 / 1024,
234 (intmax_t)NULL,
235 last, kmap.max_addr,
236 formatnum(kmap.max_addr - last));
237 total_empty += kmap.max_addr - last;
238
239 printf("-----------------------------------------------\n");
240 for (i = 0; i < VM_SUBSYS_LIMIT; ++i)
241 printf("Total-id: %9s %s\n", entryid(i), formatnum(total_used_byid[i]));
242
243 printf("-----------------------------------------------\n");
244 printf("Total empty space: %s\n", formatnum(total_empty));
245 printf("Total used space: %s\n", formatnum(total_used));
246 }
247
248 static const char *
249 formatnum(int64_t value)
250 {
251 static char buf[64];
252 const char *neg;
253 const char *suffix;
254 int64_t div = 1;
255
256 if (value < 0) {
257 value = -value;
258 neg = "-";
259 } else {
260 neg = "";
261 }
262 if (value < 100000) {
263 div = 1;
264 suffix = "";
265 } else if (value < 1 * 1024 * 1024) {
266 div = 1024;
267 suffix = "K";
268 } else if (value < 1024 * 1024 * 1024) {
269 div = 1024 * 1024;
270 suffix = "M";
271 } else if (value < 1024LL * 1024 * 1024 * 1024) {
272 div = 1024 * 1024 * 1024;
273 suffix = "G";
274 } else {
275 div = 1024LL * 1024 * 1024 * 1024;
276 suffix = "T";
277 }
278 if (value == 0) {
279 snprintf(buf, sizeof(buf), "");
280 } else if (div == 1) {
281 snprintf(buf, sizeof(buf), "%s%7.0f%s",
282 neg,
283 (double)value / (double)div,
284 suffix);
285 } else {
286 snprintf(buf, sizeof(buf), "%s%6.2f%s",
287 neg,
288 (double)value / (double)div,
289 suffix);
290 }
291 return buf;
292 }
293
294 static void
295 mapscan(kvm_t *kd, vm_map_entry_t kptr, vm_map_entry_t ken, vm_offset_t *lastp)
296 {
297 if (*lastp != ken->ba.start) {
298 printf("%4ldM %p %08lx-%08lx (%s) EMPTY\n",
299 total_used / 1024 / 1024,
300 kptr,
301 *lastp, ken->ba.start,
302 formatnum(ken->ba.start - *lastp));
303 total_empty += ken->ba.start - *lastp;
304 }
305 printf("%4ldM %p %08lx-%08lx (%6ldK) id=%-8s object=%p\n",
306 total_used / 1024 / 1024,
307 kptr,
308 ken->ba.start, ken->ba.end,
309 (ken->ba.end - ken->ba.start) / 1024,
310 entryid(ken->id),
311 ken->object.map_object);
312 total_used += ken->ba.end - ken->ba.start;
313 if (ken->id < VM_SUBSYS_LIMIT)
314 total_used_byid[ken->id] += ken->ba.end - ken->ba.start;
315 else
316 total_used_byid[0] += ken->ba.end - ken->ba.start;
317 *lastp = ken->ba.end;
318 }
319
320 static
321 const char *
322 entryid(vm_subsys_t id)
323 {
324 static char buf[32];
325
326 switch(id) {
327 case VM_SUBSYS_UNKNOWN:
328 return("UNKNOWN");
329 case VM_SUBSYS_KMALLOC:
330 return("KMALLOC");
331 case VM_SUBSYS_STACK:
332 return("STACK");
333 case VM_SUBSYS_IMGACT:
334 return("IMGACT");
335 case VM_SUBSYS_EFI:
336 return("EFI");
337 case VM_SUBSYS_RESERVED:
338 return("RESERVED");
339 case VM_SUBSYS_INIT:
340 return("INIT");
341 case VM_SUBSYS_PIPE:
342 return("PIPE");
343 case VM_SUBSYS_PROC:
344 return("PROC");
345 case VM_SUBSYS_SHMEM:
346 return("SHMEM");
347 case VM_SUBSYS_SYSMAP:
348 return("SYSMAP");
349 case VM_SUBSYS_MMAP:
350 return("MMAP");
351 case VM_SUBSYS_BRK:
352 return("BRK");
353 case VM_SUBSYS_BOGUS:
354 return("BOGUS");
355 case VM_SUBSYS_BUF:
356 return("BUF");
357 case VM_SUBSYS_BUFDATA:
358 return("BUFDATA");
359 case VM_SUBSYS_GD:
360 return("GD");
361 case VM_SUBSYS_IPIQ:
362 return("IPIQ");
363 case VM_SUBSYS_PVENTRY:
364 return("PVENTRY");
365 case VM_SUBSYS_PML4:
366 return("PML4");
367 case VM_SUBSYS_MAPDEV:
368 return("MAPDEV");
369 case VM_SUBSYS_ZALLOC:
370 return("ZALLOC");
371
372 case VM_SUBSYS_DM:
373 return("DM");
374 case VM_SUBSYS_CONTIG:
375 return("CONTIG");
376 case VM_SUBSYS_DRM:
377 return("DRM");
378 case VM_SUBSYS_DRM_GEM:
379 return("DRM_GEM");
380 case VM_SUBSYS_DRM_SCAT:
381 return("DRM_SCAT");
382 case VM_SUBSYS_DRM_VMAP:
383 return("DRM_VMAP");
384 case VM_SUBSYS_DRM_TTM:
385 return("DRM_TTM");
386 case VM_SUBSYS_HAMMER:
387 return("HAMMER");
388 case VM_SUBSYS_VMPGHASH:
389 return("VMPGHASH");
390 default:
391 break;
392 }
393 snprintf(buf, sizeof(buf), "%d", (int)id);
394
395 return buf;
396 }
397
398 #endif
399
400 static void
kkread(kvm_t * kd,u_long addr,void * buf,size_t nbytes)401 kkread(kvm_t *kd, u_long addr, void *buf, size_t nbytes)
402 {
403 if (kvm_read(kd, addr, buf, nbytes) != nbytes) {
404 perror("kvm_read");
405 exit(1);
406 }
407 }
408