test/debug/psinfo.c

   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
  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
 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
 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 }