usr.bin/ktrdump/ktrdump.c

   1 /*-
   2  * Copyright (c) 2002 Jake Burkholder
   3  * Copyright (c) 2004 Robert Watson
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  * $FreeBSD: src/usr.bin/ktrdump/ktrdump.c,v 1.10 2005/05/21 09:55:06 ru Exp $
  28  * $DragonFly: src/usr.bin/ktrdump/ktrdump.c,v 1.3 2005/06/21 06:50:28 dillon Exp $
  29  */
  30
  31 #include <sys/cdefs.h>
  32
  33 #include <sys/types.h>
  34 #include <sys/ktr.h>
  35 #include <sys/mman.h>
  36 #include <sys/stat.h>
  37 #include <sys/queue.h>
  38
  39 #include <err.h>
  40 #include <fcntl.h>
  41 #include <kvm.h>
  42 #include <limits.h>
  43 #include <nlist.h>
  44 #include <stdint.h>
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <string.h>
  48 #include <unistd.h>
  49
  50 #define SBUFLEN 128
  51
  52 extern char *optarg;
  53 extern int optind;
  54
  55 static void usage(void);
  56 static void print_header(FILE *fo, int row);
  57 static void print_entry(FILE *fo, kvm_t *kd, int n, int i, struct ktr_entry *entry);
  58 static struct ktr_info *kvm_ktrinfo(kvm_t *kd, void *kptr);
  59 static const char *kvm_string(kvm_t *kd, const char *kptr);
  60 static const char *trunc_path(const char *str, int maxlen);
  61 static void read_symbols(const char *execfile);
  62 static const char *address_to_symbol(void *kptr);
  63
  64 static struct nlist nl[] = {
  65         { "_ktr_version" },
  66         { "_ktr_entries" },
  67         { "_ktr_idx" },
  68         { "_ktr_buf" },
  69         { "_ncpus" },
  70         { NULL }
  71 };
  72
  73 static int cflag;
  74 static int fflag;
  75 static int iflag;
  76 static int nflag;
  77 static int qflag;
  78 static int rflag;
  79 static int tflag;
  80 static int xflag;
  81 static int pflag;
  82 static int Mflag;
  83 static int Nflag;
  84 static int64_t last_timestamp;
  85
  86 static char corefile[PATH_MAX];
  87 static char execfile[PATH_MAX];
  88
  89 static char desc[SBUFLEN];
  90 static char errbuf[_POSIX2_LINE_MAX];
  91 static char fbuf[PATH_MAX];
  92 static char obuf[PATH_MAX];
  93
  94 /*
  95  * Reads the ktr trace buffer from kernel memory and prints the trace entries.
  96  */
  97 int
  98 main(int ac, char **av)
  99 {
 100         struct ktr_entry **ktr_buf;
 101         uintmax_t tlast, tnow;
 102         struct stat sb;
 103         kvm_t *kd;
 104         FILE *fo;
 105         char *p;
 106         int version;
 107         int entries;
 108         int *ktr_idx;
 109         int ncpus;
 110         int did_display_flag = 0;
 111         int in;
 112         int c;
 113         int i;
 114         int n;
 115
 116         /*
 117          * Parse commandline arguments.
 118          */
 119         fo = stdout;
 120         while ((c = getopt(ac, av, "acfiqrtxpN:M:o:")) != -1) {
 121                 switch (c) {
 122                 case 'a':
 123                         cflag = 1;
 124                         iflag = 1;
 125                         tflag = 1;
 126                         xflag = 1;
 127                         fflag = 1;
 128                         pflag = 1;
 129                         break;
 130                 case 'c':
 131                         cflag = 1;
 132                         break;
 133                 case 'N':
 134                         if (strlcpy(execfile, optarg, sizeof(execfile))
 135                             >= sizeof(execfile))
 136                                 errx(1, "%s: File name too long", optarg);
 137                         Nflag = 1;
 138                         break;
 139                 case 'f':
 140                         fflag = 1;
 141                         break;
 142                 case 'i':
 143                         iflag = 1;
 144                         break;
 145                 case 'M':
 146                         if (strlcpy(corefile, optarg, sizeof(corefile))
 147                             >= sizeof(corefile))
 148                                 errx(1, "%s: File name too long", optarg);
 149                         Mflag = 1;
 150                         break;
 151                 case 'n':
 152                         nflag = 1;
 153                         break;
 154                 case 'o':
 155                         if ((fo = fopen(optarg, "w")) == NULL)
 156                                 err(1, "%s", optarg);
 157                         break;
 158                 case 'p':
 159                         pflag++;
 160                         break;
 161                 case 'q':
 162                         qflag++;
 163                         break;
 164                 case 'r':
 165                         rflag = 1;
 166                         break;
 167                 case 't':
 168                         tflag = 1;
 169                         break;
 170                 case 'x':
 171                         xflag = 1;
 172                         break;
 173                 case '?':
 174                 default:
 175                         usage();
 176                 }
 177         }
 178         if (cflag + iflag + tflag + xflag + fflag + pflag == 0) {
 179                 cflag = 1;
 180                 iflag = 1;
 181                 tflag = 1;
 182                 fflag = 1;
 183                 pflag = 1;
 184         }
 185
 186         ac -= optind;
 187         av += optind;
 188         if (ac != 0)
 189                 usage();
 190
 191         /*
 192          * Open our execfile and corefile, resolve needed symbols and read in
 193          * the trace buffer.
 194          */
 195         if ((kd = kvm_openfiles(Nflag ? execfile : NULL,
 196             Mflag ? corefile : NULL, NULL, O_RDONLY, errbuf)) == NULL)
 197                 errx(1, "%s", errbuf);
 198         if (kvm_nlist(kd, nl) != 0)
 199                 errx(1, "%s", kvm_geterr(kd));
 200         if (kvm_read(kd, nl[0].n_value, &version, sizeof(version)) == -1)
 201                 errx(1, "%s", kvm_geterr(kd));
 202         if (kvm_read(kd, nl[4].n_value, &ncpus, sizeof(ncpus)) == -1)
 203                 errx(1, "%s", kvm_geterr(kd));
 204
 205         if (version != KTR_VERSION)
 206                 errx(1, "ktr version mismatch");
 207         if (kvm_read(kd, nl[1].n_value, &entries, sizeof(entries)) == -1)
 208                 errx(1, "%s", kvm_geterr(kd));
 209         ktr_buf = malloc(sizeof(*ktr_buf) * ncpus);
 210         ktr_idx = malloc(sizeof(*ktr_idx) * ncpus);
 211
 212         if (nflag == 0)
 213                 read_symbols(Nflag ? execfile : NULL);
 214
 215         if (kvm_read(kd, nl[2].n_value, ktr_idx, sizeof(*ktr_idx) * ncpus) == -1)
 216                 errx(1, "%s", kvm_geterr(kd));
 217         if (kvm_read(kd, nl[3].n_value, ktr_buf, sizeof(*ktr_buf) * ncpus) == -1)
 218                 errx(1, "%s", kvm_geterr(kd));
 219         for (n = 0; n < ncpus; ++n) {
 220                 void *kptr = ktr_buf[n];
 221                 ktr_buf[n] = malloc(sizeof(**ktr_buf) * entries);
 222                 if (kvm_read(kd, (uintptr_t)kptr, ktr_buf[n], sizeof(**ktr_buf) * entries) == -1)
 223                 errx(1, "%s", kvm_geterr(kd));
 224         }
 225
 226         /*
 227          * Now tear through the trace buffer.
 228          */
 229         for (n = 0; n < ncpus; ++n) {
 230                 last_timestamp = 0;
 231                 for (i = 0; i < entries; ++i) {
 232                         print_header(fo, i);
 233                         print_entry(fo, kd, n, i, &ktr_buf[n][i]);
 234                 }
 235         }
 236         return (0);
 237 }
 238
 239 static void
 240 print_header(FILE *fo, int row)
 241 {
 242         if (qflag == 0 && row % 20 == 0) {
 243                 fprintf(fo, "%-6s ", "index");
 244                 if (cflag)
 245                         fprintf(fo, "%-3s ", "cpu");
 246                 if (tflag || rflag)
 247                         fprintf(fo, "%-16s ", "timestamp");
 248                 if (xflag) {
 249                         if (nflag)
 250                             fprintf(fo, "%-10s %-10s", "caller2", "caller1");
 251                         else
 252                             fprintf(fo, "%-20s %-20s", "caller2", "caller1");
 253                 }
 254                 if (iflag)
 255                         fprintf(fo, "%-20s ", "ID");
 256                 if (fflag)
 257                         fprintf(fo, "%10s%-30s ", "", "file and line");
 258                 if (pflag)
 259                         fprintf(fo, "%s", "trace");
 260                 fprintf(fo, "\n");
 261         }
 262 }
 263
 264 static void
 265 print_entry(FILE *fo, kvm_t *kd, int n, int i, struct ktr_entry *entry)
 266 {
 267         struct ktr_info *info = NULL;
 268
 269         fprintf(fo, " %5d ", i);
 270         if (cflag)
 271                 fprintf(fo, "%-3d ", n);
 272         if (tflag || rflag) {
 273                 if (rflag)
 274                         fprintf(fo, "%-16lld ", entry->ktr_timestamp -
 275                                                 last_timestamp);
 276                 else
 277                         fprintf(fo, "%-16lld ", entry->ktr_timestamp);
 278         }
 279         if (xflag) {
 280                 if (nflag) {
 281                     fprintf(fo, "%p %p ",
 282                             entry->ktr_caller2, entry->ktr_caller1);
 283                 } else {
 284                     fprintf(fo, "%-20s ",
 285                             address_to_symbol(entry->ktr_caller2));
 286                     fprintf(fo, "%-20s ",
 287                             address_to_symbol(entry->ktr_caller1));
 288                 }
 289         }
 290         if (iflag) {
 291                 info = kvm_ktrinfo(kd, entry->ktr_info);
 292                 if (info)
 293                         fprintf(fo, "%-20s ", kvm_string(kd, info->kf_name));
 294                 else
 295                         fprintf(fo, "%-20s ", "<empty>");
 296         }
 297         if (fflag)
 298                 fprintf(fo, "%34s:%-4d ", trunc_path(kvm_string(kd, entry->ktr_file), 34), entry->ktr_line);
 299         if (pflag) {
 300                 if (info == NULL)
 301                         info = kvm_ktrinfo(kd, entry->ktr_info);
 302                 if (info) {
 303                         fprintf(fo, kvm_string(kd, info->kf_format),
 304                                 entry->ktr_data[0], entry->ktr_data[1],
 305                                 entry->ktr_data[2], entry->ktr_data[3],
 306                                 entry->ktr_data[4], entry->ktr_data[5],
 307                                 entry->ktr_data[6], entry->ktr_data[7],
 308                                 entry->ktr_data[8], entry->ktr_data[9]);
 309                 } else {
 310                         fprintf(fo, "");
 311                 }
 312         }
 313         fprintf(fo, "\n");
 314         last_timestamp = entry->ktr_timestamp;
 315 }
 316
 317 static
 318 struct ktr_info *
 319 kvm_ktrinfo(kvm_t *kd, void *kptr)
 320 {
 321         static struct ktr_info save_info;
 322         static void *save_kptr;
 323
 324         if (kptr == NULL)
 325                 return(NULL);
 326         if (save_kptr != kptr) {
 327                 if (kvm_read(kd, (uintptr_t)kptr, &save_info, sizeof(save_info)) == -1) {
 328                         bzero(&save_info, sizeof(save_info));
 329                 } else {
 330                         save_kptr = kptr;
 331                 }
 332         }
 333         return(&save_info);
 334 }
 335
 336 static
 337 const char *
 338 kvm_string(kvm_t *kd, const char *kptr)
 339 {
 340         static char save_str[128];
 341         static const char *save_kptr;
 342         int l;
 343         int n;
 344
 345         if (kptr == NULL)
 346                 return("?");
 347         if (save_kptr != kptr) {
 348                 save_kptr = kptr;
 349                 l = 0;
 350                 while (l < sizeof(save_str) - 1) {
 351                         n = 256 - ((intptr_t)(kptr + l) & 255);
 352                         if (n > sizeof(save_str) - l - 1)
 353                                 n = sizeof(save_str) - l - 1;
 354                         if (kvm_read(kd, (uintptr_t)(kptr + l), save_str + l, n) < 0)
 355                                 break;
 356                         while (l < sizeof(save_str) && n) {
 357                             if (save_str[l] == 0)
 358                                     break;
 359                             --n;
 360                             ++l;
 361                         }
 362                         if (n)
 363                             break;
 364                 }
 365                 save_str[l] = 0;
 366         }
 367         return(save_str);
 368 }
 369
 370 static
 371 const char *
 372 trunc_path(const char *str, int maxlen)
 373 {
 374         int len = strlen(str);
 375
 376         if (len > maxlen)
 377                 return(str + len - maxlen);
 378         else
 379                 return(str);
 380 }
 381
 382 struct symdata {
 383         TAILQ_ENTRY(symdata) link;
 384         const char *symname;
 385         char *symaddr;
 386         char symtype;
 387 };
 388
 389 static TAILQ_HEAD(symlist, symdata) symlist;
 390 static struct symdata *symcache;
 391 static char *symbegin;
 392 static char *symend;
 393
 394 static
 395 void
 396 read_symbols(const char *execfile)
 397 {
 398         char buf[256];
 399         char cmd[256];
 400         int buflen = sizeof(buf);
 401         FILE *fp;
 402         struct symdata *sym;
 403         char *s1;
 404         char *s2;
 405         char *s3;
 406
 407         TAILQ_INIT(&symlist);
 408
 409         if (execfile == NULL) {
 410                 if (sysctlbyname("kern.bootfile", buf, &buflen, NULL, 0) < 0)
 411                         execfile = "/kernel";
 412                 else
 413                         execfile = buf;
 414         }
 415         snprintf(cmd, sizeof(cmd), "nm -n %s", execfile);
 416         if ((fp = popen(cmd, "r")) != NULL) {
 417                 while (fgets(buf, sizeof(buf), fp) != NULL) {
 418                     s1 = strtok(buf, " \t\n");
 419                     s2 = strtok(NULL, " \t\n");
 420                     s3 = strtok(NULL, " \t\n");
 421                     if (s1 && s2 && s3) {
 422                         sym = malloc(sizeof(struct symdata));
 423                         sym->symaddr = (char *)strtoul(s1, NULL, 16);
 424                         sym->symtype = s2[0];
 425                         sym->symname = strdup(s3);
 426                         if (strcmp(s3, "kernbase") == 0)
 427                                 symbegin = sym->symaddr;
 428                         if (strcmp(s3, "end") == 0)
 429                                 symend = sym->symaddr;
 430                         TAILQ_INSERT_TAIL(&symlist, sym, link);
 431                     }
 432                 }
 433                 pclose(fp);
 434         }
 435         symcache = TAILQ_FIRST(&symlist);
 436 }
 437
 438 static
 439 const char *
 440 address_to_symbol(void *kptr)
 441 {
 442         static char buf[64];
 443
 444         if (symcache == NULL ||
 445            (char *)kptr < symbegin || (char *)kptr >= symend
 446         ) {
 447                 snprintf(buf, sizeof(buf), "%p", kptr);
 448                 return(buf);
 449         }
 450         while ((char *)symcache->symaddr < (char *)kptr) {
 451                 if (TAILQ_NEXT(symcache, link) == NULL)
 452                         break;
 453                 symcache = TAILQ_NEXT(symcache, link);
 454         }
 455         while ((char *)symcache->symaddr > (char *)kptr) {
 456                 if (symcache != TAILQ_FIRST(&symlist))
 457                         symcache = TAILQ_PREV(symcache, symlist, link);
 458         }
 459         snprintf(buf, sizeof(buf), "%s+%d", symcache->symname,
 460                 (int)((char *)kptr - symcache->symaddr));
 461         return(buf);
 462 }
 463
 464 static void
 465 usage(void)
 466 {
 467         fprintf(stderr, "usage: ktrdump [-acfinpqrtx] [-N execfile] "
 468                         "[-M corefile] [-o outfile]\n");
 469         exit(1);
 470 }