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  */
  29
  30 #include <sys/types.h>
  31 #include <sys/ktr.h>
  32 #include <sys/mman.h>
  33 #include <sys/stat.h>
  34 #include <sys/queue.h>
  35
  36 #include <ctype.h>
  37 #include <devinfo.h>
  38 #include <err.h>
  39 #include <fcntl.h>
  40 #include <kvm.h>
  41 #include <limits.h>
  42 #include <nlist.h>
  43 #include <stdint.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <unistd.h>
  48 #include <evtr.h>
  49 #include <stdarg.h>
  50
  51 struct ktr_buffer {
  52         struct ktr_entry *ents;
  53         int modified;
  54         int reset;
  55         int beg_idx;            /* Beginning index */
  56         int end_idx;            /* Ending index */
  57 };
  58
  59 static struct nlist nl1[] = {
  60         { .n_name = "_ktr_version" },
  61         { .n_name = "_ktr_entries" },
  62         { .n_name = "_ncpus" },
  63         { .n_name = NULL }
  64 };
  65
  66 static struct nlist nl2[] = {
  67         { .n_name = "_tsc_frequency" },
  68         { .n_name = NULL }
  69 };
  70
  71 static struct nlist nl_version_ktr_idx[] = {
  72         { .n_name = "_ktr_idx" },
  73         { .n_name = "_ktr_buf" },
  74         { .n_name = NULL }
  75 };
  76
  77 static struct nlist nl_version_ktr_cpu[] = {
  78         { .n_name = "_ktr_cpu" },
  79         { .n_name = NULL }
  80 };
  81
  82 struct save_ctx {
  83         char save_buf[512];
  84         const void *save_kptr;
  85 };
  86
  87 typedef void (*ktr_iter_cb_t)(void *, int, int, struct ktr_entry *, uint64_t *);
  88
  89 #ifdef __x86_64__
  90 /* defined according to the x86_64 ABI spec */
  91 struct my_va_list {
  92         uint32_t gp_offset;     /* offset to next available gpr in reg_save_area */
  93         uint32_t fp_offset;     /* offset to next available fpr in reg_save_area */
  94         void *overflow_arg_area;        /* args that are passed on the stack */
  95         struct reg_save_area *reg_save_area;            /* register args */
  96         /*
  97          * NOT part of the ABI. ->overflow_arg_area gets advanced when code
  98          * iterates over the arguments with va_arg(). That means we need to
  99          * keep a copy in order to free the allocated memory (if any)
 100          */
 101         void *overflow_arg_area_save;
 102 } __attribute__((packed));
 103
 104 typedef struct my_va_list *machine_va_list;
 105
 106 struct reg_save_area {
 107         uint64_t rdi, rsi, rdx, rcx, r8, r9;
 108         /* XMM registers follow, but we don't use them */
 109 };
 110 #endif
 111
 112 static int cflag;
 113 static int dflag;
 114 static int fflag;
 115 static int iflag;
 116 static int lflag;
 117 static int nflag;
 118 static int qflag;
 119 static int rflag;
 120 static int sflag;
 121 static int tflag;
 122 static int xflag;
 123 static int pflag;
 124 static int Mflag;
 125 static int Nflag;
 126 static double tsc_frequency;
 127 static double correction_factor = 0.0;
 128
 129 static char corefile[PATH_MAX];
 130 static char execfile[PATH_MAX];
 131
 132 static char errbuf[_POSIX2_LINE_MAX];
 133 static int ncpus;
 134 static kvm_t *kd;
 135 static int entries_per_buf;
 136 static int fifo_mask;
 137 static int ktr_version;
 138
 139 static void usage(void);
 140 static int earliest_ts(struct ktr_buffer *);
 141 static void dump_machine_info(evtr_t);
 142 static void dump_device_info(evtr_t);
 143 static void print_header(FILE *, int);
 144 static void print_entry(FILE *, int, int, struct ktr_entry *, u_int64_t *);
 145 static void print_callback(void *, int, int, struct ktr_entry *, uint64_t *);
 146 static void dump_callback(void *, int, int, struct ktr_entry *, uint64_t *);
 147 static struct ktr_info *kvm_ktrinfo(void *, struct save_ctx *);
 148 static const char *kvm_string(const char *, struct save_ctx *);
 149 static const char *trunc_path(const char *, int);
 150 static void read_symbols(const char *);
 151 static const char *address_to_symbol(void *, struct save_ctx *);
 152 static struct ktr_buffer *ktr_bufs_init(void);
 153 static void get_indices(struct ktr_entry **, int *);
 154 static void load_bufs(struct ktr_buffer *, struct ktr_entry **, int *);
 155 static void iterate_buf(FILE *, struct ktr_buffer *, int, u_int64_t *, ktr_iter_cb_t);
 156 static void iterate_bufs_timesorted(FILE *, struct ktr_buffer *, u_int64_t *, ktr_iter_cb_t);
 157 static void kvmfprintf(FILE *fp, const char *ctl, va_list va);
 158 static int va_list_from_blob(machine_va_list *valist, const char *fmt, char *blob, size_t blobsize);
 159 static void va_list_cleanup(machine_va_list *valist);
 160 /*
 161  * Reads the ktr trace buffer from kernel memory and prints the trace entries.
 162  */
 163 int
 164 main(int ac, char **av)
 165 {
 166         struct ktr_buffer *ktr_bufs;
 167         struct ktr_entry **ktr_kbuf;
 168         ktr_iter_cb_t callback = &print_callback;
 169         int *ktr_idx;
 170         FILE *fo;
 171         void *ctx;
 172         int64_t tts;
 173         int *ktr_start_index;
 174         int c;
 175         int n;
 176
 177         /*
 178          * Parse commandline arguments.
 179          */
 180         fo = stdout;
 181         while ((c = getopt(ac, av, "acfinqrtxpslA:N:M:o:d")) != -1) {
 182                 switch (c) {
 183                 case 'a':
 184                         cflag = 1;
 185                         iflag = 1;
 186                         rflag = 1;
 187                         xflag = 1;
 188                         pflag = 1;
 189                         sflag = 1;
 190                         break;
 191                 case 'c':
 192                         cflag = 1;
 193                         break;
 194                 case 'd':
 195                         dflag = 1;
 196                         sflag = 1;
 197                         callback = &dump_callback;
 198                         break;
 199                 case 'N':
 200                         if (strlcpy(execfile, optarg, sizeof(execfile))
 201                             >= sizeof(execfile))
 202                                 errx(1, "%s: File name too long", optarg);
 203                         Nflag = 1;
 204                         break;
 205                 case 'f':
 206                         fflag = 1;
 207                         break;
 208                 case 'l':
 209                         lflag = 1;
 210                         break;
 211                 case 'i':
 212                         iflag = 1;
 213                         break;
 214                 case 'A':
 215                         correction_factor = strtod(optarg, NULL);
 216                         break;
 217                 case 'M':
 218                         if (strlcpy(corefile, optarg, sizeof(corefile))
 219                             >= sizeof(corefile))
 220                                 errx(1, "%s: File name too long", optarg);
 221                         Mflag = 1;
 222                         break;
 223                 case 'n':
 224                         nflag = 1;
 225                         break;
 226                 case 'o':
 227                         if ((fo = fopen(optarg, "w")) == NULL)
 228                                 err(1, "%s", optarg);
 229                         break;
 230                 case 'p':
 231                         pflag++;
 232                         break;
 233                 case 'q':
 234                         qflag++;
 235                         break;
 236                 case 'r':
 237                         rflag = 1;
 238                         break;
 239                 case 's':
 240                         sflag = 1;      /* sort across the cpus */
 241                         break;
 242                 case 't':
 243                         tflag = 1;
 244                         break;
 245                 case 'x':
 246                         xflag = 1;
 247                         break;
 248                 case '?':
 249                 default:
 250                         usage();
 251                 }
 252         }
 253         ctx = fo;
 254         if (dflag) {
 255                 ctx = evtr_open_write(fo);
 256                 if (!ctx) {
 257                         err(1, "Can't create event stream");
 258                 }
 259         }
 260         if (cflag + iflag + tflag + xflag + fflag + pflag == 0) {
 261                 cflag = 1;
 262                 iflag = 1;
 263                 tflag = 1;
 264                 pflag = 1;
 265         }
 266         if (correction_factor != 0.0 && (rflag == 0 || nflag)) {
 267                 fprintf(stderr, "Correction factor can only be applied with -r and without -n\n");
 268                 exit(1);
 269         }
 270         ac -= optind;
 271         av += optind;
 272         if (ac != 0)
 273                 usage();
 274
 275         /*
 276          * Open our execfile and corefile, resolve needed symbols and read in
 277          * the trace buffer.
 278          */
 279         if ((kd = kvm_openfiles(Nflag ? execfile : NULL,
 280             Mflag ? corefile : NULL, NULL, O_RDONLY, errbuf)) == NULL)
 281                 errx(1, "%s", errbuf);
 282         if (kvm_nlist(kd, nl1) != 0)
 283                 errx(1, "%s", kvm_geterr(kd));
 284         if (kvm_read(kd, nl1[0].n_value, &ktr_version, sizeof(ktr_version)) == -1)
 285                 errx(1, "%s", kvm_geterr(kd));
 286         if (kvm_read(kd, nl1[2].n_value, &ncpus, sizeof(ncpus)) == -1)
 287                 errx(1, "%s", kvm_geterr(kd));
 288         ktr_start_index = malloc(sizeof(*ktr_start_index) * ncpus);
 289         if (ktr_version >= KTR_VERSION_WITH_FREQ && kvm_nlist(kd, nl2) == 0) {
 290                 if (kvm_read(kd, nl2[0].n_value, &tts, sizeof(tts)) == -1)
 291                         errx(1, "%s", kvm_geterr(kd));
 292                 tsc_frequency = (double)tts;
 293         }
 294         if (ktr_version > KTR_VERSION)
 295                 errx(1, "ktr version too high for us to handle");
 296         if (kvm_read(kd, nl1[1].n_value, &entries_per_buf,
 297                                 sizeof(entries_per_buf)) == -1)
 298                 errx(1, "%s", kvm_geterr(kd));
 299         fifo_mask = entries_per_buf - 1;
 300
 301         printf("TSC frequency is %6.3f MHz\n", tsc_frequency / 1000000.0);
 302
 303         if (dflag) {
 304                 dump_machine_info((evtr_t)ctx);
 305                 dump_device_info((evtr_t)ctx);
 306         }
 307         ktr_kbuf = calloc(ncpus, sizeof(*ktr_kbuf));
 308         ktr_idx = calloc(ncpus, sizeof(*ktr_idx));
 309
 310         if (nflag == 0)
 311                 read_symbols(Nflag ? execfile : NULL);
 312
 313         if (ktr_version < KTR_VERSION_KTR_CPU) {
 314                 if (kvm_nlist(kd, nl_version_ktr_idx))
 315                         errx(1, "%s", kvm_geterr(kd));
 316         } else {
 317                 if (kvm_nlist(kd, nl_version_ktr_cpu))
 318                         errx(1, "%s", kvm_geterr(kd));
 319         }
 320
 321         get_indices(ktr_kbuf, ktr_idx);
 322
 323         ktr_bufs = ktr_bufs_init();
 324
 325         if (sflag) {
 326                 u_int64_t last_timestamp = 0;
 327                 do {
 328                         load_bufs(ktr_bufs, ktr_kbuf, ktr_idx);
 329                         iterate_bufs_timesorted(ctx, ktr_bufs, &last_timestamp,
 330                                                 callback);
 331                         if (lflag)
 332                                 usleep(1000000 / 10);
 333                 } while (lflag);
 334         } else {
 335                 u_int64_t *last_timestamp = calloc(sizeof(u_int64_t), ncpus);
 336                 do {
 337                         load_bufs(ktr_bufs, ktr_kbuf, ktr_idx);
 338                         for (n = 0; n < ncpus; ++n)
 339                                 iterate_buf(ctx, ktr_bufs, n, &last_timestamp[n],
 340                                         callback);
 341                         if (lflag)
 342                                 usleep(1000000 / 10);
 343                 } while (lflag);
 344         }
 345         if (dflag)
 346                 evtr_close(ctx);
 347         return (0);
 348 }
 349
 350 static
 351 int
 352 dump_devinfo(struct devinfo_dev *dev, void *arg)
 353 {
 354         struct evtr_event ev;
 355         evtr_t evtr = (evtr_t)arg;
 356         const char *fmt = "#devicenames[\"%s\"] = %#lx";
 357         char fmtdatabuf[sizeof(char *) + sizeof(devinfo_handle_t)];
 358         char *fmtdata = fmtdatabuf;
 359
 360         if (!dev->dd_name[0])
 361                 return 0;
 362         ev.type = EVTR_TYPE_PROBE;
 363         ev.ts = 0;
 364         ev.line = 0;
 365         ev.file = NULL;
 366         ev.cpu = -1;
 367         ev.func = NULL;
 368         ev.fmt = fmt;
 369         ((char **)fmtdata)[0] = &dev->dd_name[0];
 370         fmtdata += sizeof(char *);
 371         ((devinfo_handle_t *)fmtdata)[0] = dev->dd_handle;
 372         ev.fmtdata = fmtdatabuf;
 373         ev.fmtdatalen = sizeof(fmtdatabuf);
 374
 375         if (evtr_dump_event(evtr, &ev)) {
 376                 err(1, "%s", evtr_errmsg(evtr));
 377         }
 378
 379         return devinfo_foreach_device_child(dev, dump_devinfo, evtr);
 380 }
 381
 382 static
 383 void
 384 dump_device_info(evtr_t evtr)
 385 {
 386         struct devinfo_dev *root;
 387         if (devinfo_init())
 388                 return;
 389         if (!(root = devinfo_handle_to_device(DEVINFO_ROOT_DEVICE))) {
 390                 warn("can't find root device");
 391                 return;
 392         }
 393         devinfo_foreach_device_child(root, dump_devinfo, evtr);
 394 }
 395
 396 static
 397 void
 398 dump_machine_info(evtr_t evtr)
 399 {
 400         struct evtr_event ev;
 401         int i;
 402
 403         bzero(&ev, sizeof(ev));
 404         ev.type = EVTR_TYPE_SYSINFO;
 405         ev.ncpus = ncpus;
 406         evtr_dump_event(evtr, &ev);
 407         if (evtr_error(evtr)) {
 408                 err(1, "%s", evtr_errmsg(evtr));
 409         }
 410
 411         for (i = 0; i < ncpus; ++i) {
 412                 bzero(&ev, sizeof(ev));
 413                 ev.type = EVTR_TYPE_CPUINFO;
 414                 ev.cpu = i;
 415                 ev.cpuinfo.freq = tsc_frequency;
 416                 evtr_dump_event(evtr, &ev);
 417                 if (evtr_error(evtr)) {
 418                         err(1, "%s", evtr_errmsg(evtr));
 419                 }
 420         }
 421 }
 422
 423 static void
 424 print_header(FILE *fo, int row)
 425 {
 426         if (qflag == 0 && (u_int32_t)row % 20 == 0) {
 427                 fprintf(fo, "%-6s ", "index");
 428                 if (cflag)
 429                         fprintf(fo, "%-3s ", "cpu");
 430                 if (tflag || rflag)
 431                         fprintf(fo, "%-16s ", "timestamp");
 432                 if (xflag) {
 433                         if (nflag)
 434                             fprintf(fo, "%-10s %-10s", "caller2", "caller1");
 435                         else
 436                             fprintf(fo, "%-20s %-20s", "caller2", "caller1");
 437                 }
 438                 if (iflag)
 439                         fprintf(fo, "%-20s ", "ID");
 440                 if (fflag)
 441                         fprintf(fo, "%10s%-30s ", "", "file and line");
 442                 if (pflag)
 443                         fprintf(fo, "%s", "trace");
 444                 fprintf(fo, "\n");
 445         }
 446 }
 447
 448 static void
 449 print_entry(FILE *fo, int n, int row, struct ktr_entry *entry,
 450             u_int64_t *last_timestamp)
 451 {
 452         struct ktr_info *info = NULL;
 453         static struct save_ctx nctx, pctx, fmtctx, symctx, infoctx;
 454
 455         fprintf(fo, "%06x ", row & 0x00FFFFFF);
 456         if (cflag)
 457                 fprintf(fo, "%-3d ", n);
 458         if (tflag || rflag) {
 459                 if (rflag && !nflag && tsc_frequency != 0.0) {
 460                         fprintf(fo, "%13.3f uS ",
 461                                 (double)(entry->ktr_timestamp - *last_timestamp) * 1000000.0 / tsc_frequency - correction_factor);
 462                 } else if (rflag) {
 463                         fprintf(fo, "%-16ju ",
 464                             (uintmax_t)(entry->ktr_timestamp - *last_timestamp));
 465                 } else {
 466                         fprintf(fo, "%-16ju ",
 467                             (uintmax_t)entry->ktr_timestamp);
 468                 }
 469         }
 470         if (xflag) {
 471                 if (nflag) {
 472                     fprintf(fo, "%p %p ",
 473                             entry->ktr_caller2, entry->ktr_caller1);
 474                 } else {
 475                     fprintf(fo, "%-25s ",
 476                             address_to_symbol(entry->ktr_caller2, &symctx));
 477                     fprintf(fo, "%-25s ",
 478                             address_to_symbol(entry->ktr_caller1, &symctx));
 479                 }
 480         }
 481         if (iflag) {
 482                 info = kvm_ktrinfo(entry->ktr_info, &infoctx);
 483                 if (info)
 484                         fprintf(fo, "%-20s ", kvm_string(info->kf_name, &nctx));
 485                 else
 486                         fprintf(fo, "%-20s ", "<empty>");
 487         }
 488         if (fflag)
 489                 fprintf(fo, "%34s:%-4d ",
 490                         trunc_path(kvm_string(entry->ktr_file, &pctx), 34),
 491                         entry->ktr_line);
 492         if (pflag) {
 493                 if (info == NULL)
 494                         info = kvm_ktrinfo(entry->ktr_info, &infoctx);
 495                 if (info) {
 496                         machine_va_list ap;
 497                         const char *fmt;
 498                         fmt = kvm_string(info->kf_format, &fmtctx);
 499                         if (va_list_from_blob(&ap, fmt,
 500                                               (char *)&entry->ktr_data,
 501                                               info->kf_data_size))
 502                                 err(2, "Can't generate va_list from %s", fmt);
 503                         kvmfprintf(fo, kvm_string(info->kf_format, &fmtctx),
 504                                    (void *)ap);
 505                         va_list_cleanup(&ap);
 506                 }
 507         }
 508         fprintf(fo, "\n");
 509         *last_timestamp = entry->ktr_timestamp;
 510 }
 511
 512 static
 513 void
 514 print_callback(void *ctx, int n, int row, struct ktr_entry *entry, uint64_t *last_ts)
 515 {
 516         FILE *fo = (FILE *)ctx;
 517         print_header(fo, row);
 518         print_entry(fo, n, row, entry, last_ts);
 519 }
 520
 521 /*
 522  * If free == 0, replace all (kvm) string pointers in fmtdata with pointers
 523  * to user-allocated copies of the strings.
 524  * If free != 0, free those pointers.
 525  */
 526 static
 527 int
 528 mangle_string_ptrs(const char *fmt, uint8_t *fmtdata, int dofree)
 529 {
 530         const char *f, *p;
 531         size_t skipsize, intsz;
 532         static struct save_ctx strctx;
 533         int ret = 0;
 534
 535         for (f = fmt; f[0] != '\0'; ++f) {
 536                 if (f[0] != '%')
 537                         continue;
 538                 ++f;
 539                 skipsize = 0;
 540                 for (p = f; p[0]; ++p) {
 541                         int again = 0;
 542                         /*
 543                          * Eat flags. Notice this will accept duplicate
 544                          * flags.
 545                          */
 546                         switch (p[0]) {
 547                         case '#':
 548                         case '0':
 549                         case '-':
 550                         case ' ':
 551                         case '+':
 552                         case '\'':
 553                                 again = !0;
 554                                 break;
 555                         }
 556                         if (!again)
 557                                 break;
 558                 }
 559                 /* Eat minimum field width, if any */
 560                 for (; isdigit(p[0]); ++p)
 561                         ;
 562                 if (p[0] == '.')
 563                         ++p;
 564                 /* Eat precision, if any */
 565                 for (; isdigit(p[0]); ++p)
 566                         ;
 567                 intsz = 0;
 568                 switch (p[0]) {
 569                 case 'l':
 570                         if (p[1] == 'l') {
 571                                 ++p;
 572                                 intsz = sizeof(long long);
 573                         } else {
 574                                 intsz = sizeof(long);
 575                         }
 576                         break;
 577                 case 'j':
 578                         intsz = sizeof(intmax_t);
 579                         break;
 580                 case 't':
 581                         intsz = sizeof(ptrdiff_t);
 582                         break;
 583                 case 'z':
 584                         intsz = sizeof(size_t);
 585                         break;
 586                 default:
 587                         break;
 588                 }
 589                 if (intsz != 0)
 590                         ++p;
 591                 else
 592                         intsz = sizeof(int);
 593
 594                 switch (p[0]) {
 595                 case 'd':
 596                 case 'i':
 597                 case 'o':
 598                 case 'u':
 599                 case 'x':
 600                 case 'X':
 601                 case 'c':
 602                         skipsize = intsz;
 603                         break;
 604                 case 'p':
 605                         skipsize = sizeof(void *);
 606                         break;
 607                 case 'f':
 608                         if (p[-1] == 'l')
 609                                 skipsize = sizeof(double);
 610                         else
 611                                 skipsize = sizeof(float);
 612                         break;
 613                 case 's':
 614                         if (dofree) {
 615                           char *t = ((char **)fmtdata)[0];
 616                           free(t);
 617                           skipsize = sizeof(char *);
 618                         } else {
 619                           char *t = strdup(kvm_string(((char **)fmtdata)[0],
 620                                                           &strctx));
 621                           ((const char **)fmtdata)[0] = t;
 622
 623                                 skipsize = sizeof(char *);
 624                         }
 625                         ++ret;
 626                         break;
 627                 default:
 628                         fprintf(stderr, "Unknown conversion specifier %c "
 629                                 "in fmt starting with %s\n", p[0], f - 1);
 630                         return -1;
 631                 }
 632                 fmtdata += skipsize;
 633         }
 634         return ret;
 635 }
 636
 637 static
 638 void
 639 dump_callback(void *ctx, int n, int row __unused, struct ktr_entry *entry,
 640               uint64_t *last_ts __unused)
 641 {
 642         evtr_t evtr = (evtr_t)ctx;
 643         struct evtr_event ev;
 644         static struct save_ctx pctx, fmtctx, infoctx;
 645         struct ktr_info *ki;
 646         int conv = 0;   /* pointless */
 647
 648         ev.ts = entry->ktr_timestamp;
 649         ev.type = EVTR_TYPE_PROBE;
 650         ev.line = entry->ktr_line;
 651         ev.file = kvm_string(entry->ktr_file, &pctx);
 652         ev.func = NULL;
 653         ev.cpu = n;
 654         if ((ki = kvm_ktrinfo(entry->ktr_info, &infoctx))) {
 655                 ev.fmt = kvm_string(ki->kf_format, &fmtctx);
 656                 ev.fmtdata = entry->ktr_data;
 657                 if ((conv = mangle_string_ptrs(ev.fmt,
 658                                                __DECONST(uint8_t *, ev.fmtdata),
 659                                                0)) < 0)
 660                         errx(1, "Can't parse format string");
 661                 ev.fmtdatalen = ki->kf_data_size;
 662         } else {
 663                 ev.fmt = ev.fmtdata = NULL;
 664                 ev.fmtdatalen = 0;
 665         }
 666         if (evtr_dump_event(evtr, &ev)) {
 667                 err(1, "%s", evtr_errmsg(evtr));
 668         }
 669         if (ev.fmtdata && conv) {
 670                 mangle_string_ptrs(ev.fmt, __DECONST(uint8_t *, ev.fmtdata),
 671                                    !0);
 672         }
 673 }
 674
 675 static
 676 struct ktr_info *
 677 kvm_ktrinfo(void *kptr, struct save_ctx *ctx)
 678 {
 679         struct ktr_info *ki = (void *)ctx->save_buf;
 680
 681         if (kptr == NULL)
 682                 return(NULL);
 683         if (ctx->save_kptr != kptr) {
 684                 if (kvm_read(kd, (uintptr_t)kptr, ki, sizeof(*ki)) == -1) {
 685                         bzero(&ki, sizeof(*ki));
 686                 } else {
 687                         ctx->save_kptr = kptr;
 688                 }
 689         }
 690         return(ki);
 691 }
 692
 693 static
 694 const char *
 695 kvm_string(const char *kptr, struct save_ctx *ctx)
 696 {
 697         u_int l;
 698         u_int n;
 699
 700         if (kptr == NULL)
 701                 return("?");
 702         if (ctx->save_kptr != (const void *)kptr) {
 703                 ctx->save_kptr = (const void *)kptr;
 704                 l = 0;
 705                 while (l < sizeof(ctx->save_buf) - 1) {
 706                         n = 256 - ((intptr_t)(kptr + l) & 255);
 707                         if (n > sizeof(ctx->save_buf) - l - 1)
 708                                 n = sizeof(ctx->save_buf) - l - 1;
 709                         if (kvm_read(kd, (uintptr_t)(kptr + l), ctx->save_buf + l, n) < 0)
 710                                 break;
 711                         while (l < sizeof(ctx->save_buf) && n) {
 712                             if (ctx->save_buf[l] == 0)
 713                                     break;
 714                             --n;
 715                             ++l;
 716                         }
 717                         if (n)
 718                             break;
 719                 }
 720                 ctx->save_buf[l] = 0;
 721         }
 722         return(ctx->save_buf);
 723 }
 724
 725 static
 726 const char *
 727 trunc_path(const char *str, int maxlen)
 728 {
 729         int len = strlen(str);
 730
 731         if (len > maxlen)
 732                 return(str + len - maxlen);
 733         else
 734                 return(str);
 735 }
 736
 737 struct symdata {
 738         TAILQ_ENTRY(symdata) link;
 739         const char *symname;
 740         char *symaddr;
 741         char symtype;
 742 };
 743
 744 static TAILQ_HEAD(symlist, symdata) symlist;
 745 static struct symdata *symcache;
 746 static char *symbegin;
 747 static char *symend;
 748
 749 static
 750 void
 751 read_symbols(const char *file)
 752 {
 753         char buf[256];
 754         char cmd[256];
 755         size_t buflen = sizeof(buf);
 756         FILE *fp;
 757         struct symdata *sym = NULL;
 758         char *s1;
 759         char *s2;
 760         char *s3;
 761
 762         TAILQ_INIT(&symlist);
 763
 764         if (file == NULL) {
 765                 if (sysctlbyname("kern.bootfile", buf, &buflen, NULL, 0) < 0)
 766                         file = "/boot/kernel/kernel";
 767                 else
 768                         file = buf;
 769         }
 770         snprintf(cmd, sizeof(cmd), "nm -n %s", file);
 771         if ((fp = popen(cmd, "r")) != NULL) {
 772                 while (fgets(buf, sizeof(buf), fp) != NULL) {
 773                     s1 = strtok(buf, " \t\n");
 774                     s2 = strtok(NULL, " \t\n");
 775                     s3 = strtok(NULL, " \t\n");
 776                     if (s1 && s2 && s3) {
 777                         sym = malloc(sizeof(struct symdata));
 778                         sym->symaddr = (char *)strtoul(s1, NULL, 16);
 779                         sym->symtype = s2[0];
 780                         sym->symname = strdup(s3);
 781                         if (strcmp(s3, "kernbase") == 0)
 782                                 symbegin = sym->symaddr;
 783                         if (strcmp(s3, "end") == 0 || strcmp(s3, "_end") == 0)
 784                                 symend = sym->symaddr;
 785                         TAILQ_INSERT_TAIL(&symlist, sym, link);
 786                     }
 787                 }
 788                 pclose(fp);
 789         }
 790         if (symend == NULL) {
 791                 if (sym != NULL)
 792                         symend = sym->symaddr;
 793                 else
 794                         symend = (char *)-1;
 795         }
 796         symcache = TAILQ_FIRST(&symlist);
 797 }
 798
 799 static
 800 const char *
 801 address_to_symbol(void *kptr, struct save_ctx *ctx)
 802 {
 803         char *buf = ctx->save_buf;
 804         int size = sizeof(ctx->save_buf);
 805
 806         if (symcache == NULL ||
 807            (char *)kptr < symbegin || (char *)kptr >= symend
 808         ) {
 809                 snprintf(buf, size, "%p", kptr);
 810                 return(buf);
 811         }
 812         while ((char *)symcache->symaddr < (char *)kptr) {
 813                 if (TAILQ_NEXT(symcache, link) == NULL)
 814                         break;
 815                 symcache = TAILQ_NEXT(symcache, link);
 816         }
 817         while ((char *)symcache->symaddr > (char *)kptr) {
 818                 if (symcache != TAILQ_FIRST(&symlist))
 819                         symcache = TAILQ_PREV(symcache, symlist, link);
 820         }
 821         snprintf(buf, size, "%s+%d", symcache->symname,
 822                 (int)((char *)kptr - symcache->symaddr));
 823         return(buf);
 824 }
 825
 826 static
 827 struct ktr_buffer *
 828 ktr_bufs_init(void)
 829 {
 830         struct ktr_buffer *ktr_bufs, *it;
 831         int i;
 832
 833         ktr_bufs = malloc(sizeof(*ktr_bufs) * ncpus);
 834         if (!ktr_bufs)
 835                 err(1, "can't allocate data structures");
 836         for (i = 0; i < ncpus; ++i) {
 837                 it = ktr_bufs + i;
 838                 it->ents = malloc(sizeof(struct ktr_entry) * entries_per_buf);
 839                 if (it->ents == NULL)
 840                         err(1, "can't allocate data structures");
 841                 it->reset = 1;
 842                 it->beg_idx = -1;
 843                 it->end_idx = -1;
 844         }
 845         return ktr_bufs;
 846 }
 847
 848 static
 849 void
 850 get_indices(struct ktr_entry **ktr_kbuf, int *ktr_idx)
 851 {
 852         static struct ktr_cpu *ktr_cpus;
 853         int i;
 854
 855         if (ktr_cpus == NULL)
 856                 ktr_cpus = malloc(sizeof(*ktr_cpus) * ncpus);
 857
 858         if (ktr_version < KTR_VERSION_KTR_CPU) {
 859                 if (kvm_read(kd, nl_version_ktr_idx[0].n_value, ktr_idx,
 860                     sizeof(*ktr_idx) * ncpus) == -1) {
 861                         errx(1, "%s", kvm_geterr(kd));
 862                 }
 863                 if (ktr_kbuf[0] == NULL) {
 864                         if (kvm_read(kd, nl_version_ktr_idx[1].n_value,
 865                             ktr_kbuf, sizeof(*ktr_kbuf) * ncpus) == -1) {
 866                                 errx(1, "%s", kvm_geterr(kd));
 867                         }
 868                 }
 869         } else {
 870                 if (kvm_read(kd, nl_version_ktr_cpu[0].n_value,
 871                              ktr_cpus, sizeof(*ktr_cpus) * ncpus) == -1) {
 872                                 errx(1, "%s", kvm_geterr(kd));
 873                 }
 874                 for (i = 0; i < ncpus; ++i) {
 875                         ktr_idx[i] = ktr_cpus[i].core.ktr_idx;
 876                         ktr_kbuf[i] = ktr_cpus[i].core.ktr_buf;
 877                 }
 878         }
 879 }
 880
 881 /*
 882  * Get the trace buffer data from the kernel
 883  */
 884 static
 885 void
 886 load_bufs(struct ktr_buffer *ktr_bufs, struct ktr_entry **kbufs, int *ktr_idx)
 887 {
 888         struct ktr_buffer *kbuf;
 889         int i;
 890
 891         get_indices(kbufs, ktr_idx);
 892         for (i = 0; i < ncpus; ++i) {
 893                 kbuf = &ktr_bufs[i];
 894                 if (ktr_idx[i] == kbuf->end_idx)
 895                         continue;
 896                 kbuf->end_idx = ktr_idx[i];
 897
 898                 /*
 899                  * If we do not have a notion of the beginning index, assume
 900                  * it is entries_per_buf before the ending index.  Don't
 901                  * worry about underflows/negative numbers, the indices will
 902                  * be masked.
 903                  */
 904                 if (kbuf->reset) {
 905                         kbuf->beg_idx = kbuf->end_idx - entries_per_buf + 1;
 906                         kbuf->reset = 0;
 907                 }
 908                 if (kvm_read(kd, (uintptr_t)kbufs[i], ktr_bufs[i].ents,
 909                                 sizeof(struct ktr_entry) * entries_per_buf)
 910                                                                         == -1)
 911                         errx(1, "%s", kvm_geterr(kd));
 912                 kbuf->modified = 1;
 913                 kbuf->beg_idx = earliest_ts(kbuf);
 914         }
 915
 916 }
 917
 918 /*
 919  * Locate the earliest timestamp iterating backwards from end_idx, but
 920  * not going further back then beg_idx.  We have to do this because
 921  * the kernel uses a circulating buffer.
 922  */
 923 static
 924 int
 925 earliest_ts(struct ktr_buffer *buf)
 926 {
 927         struct ktr_entry *save;
 928         int count, scan, i, earliest;
 929
 930         count = 0;
 931         earliest = buf->end_idx - 1;
 932         save = &buf->ents[earliest & fifo_mask];
 933         for (scan = buf->end_idx - 1; scan != buf->beg_idx -1; --scan) {
 934                 i = scan & fifo_mask;
 935                 if (buf->ents[i].ktr_timestamp <= save->ktr_timestamp &&
 936                     buf->ents[i].ktr_timestamp > 0)
 937                         earliest = scan;
 938                 /*
 939                  * We may have gotten so far behind that beg_idx wrapped
 940                  * more then once around the buffer.  Just stop
 941                  */
 942                 if (++count == entries_per_buf)
 943                         break;
 944         }
 945         return earliest;
 946 }
 947
 948 static
 949 void
 950 iterate_buf(FILE *fo, struct ktr_buffer *ktr_bufs, int cpu,
 951             u_int64_t *last_timestamp, ktr_iter_cb_t cb)
 952 {
 953         struct ktr_buffer *buf = ktr_bufs + cpu;
 954
 955         if (buf->modified == 0)
 956                 return;
 957         if (*last_timestamp == 0) {
 958                 *last_timestamp =
 959                         buf->ents[buf->beg_idx & fifo_mask].ktr_timestamp;
 960         }
 961         while (buf->beg_idx != buf->end_idx) {
 962                 cb(fo, cpu, buf->beg_idx,
 963                    &buf->ents[buf->beg_idx & fifo_mask],
 964                    last_timestamp);
 965                 ++buf->beg_idx;
 966         }
 967         buf->modified = 0;
 968 }
 969
 970 static
 971 void
 972 iterate_bufs_timesorted(FILE *fo, struct ktr_buffer *ktr_bufs,
 973                         u_int64_t *last_timestamp, ktr_iter_cb_t cb)
 974 {
 975         struct ktr_entry *ent;
 976         struct ktr_buffer *buf;
 977         int n, bestn;
 978         u_int64_t ts;
 979         static int row = 0;
 980
 981         for (;;) {
 982                 ts = 0;
 983                 bestn = -1;
 984                 for (n = 0; n < ncpus; ++n) {
 985                         buf = ktr_bufs + n;
 986                         if (buf->beg_idx == buf->end_idx)
 987                                 continue;
 988                         ent = &buf->ents[buf->beg_idx & fifo_mask];
 989                         if (ts == 0 || (ts >= ent->ktr_timestamp)) {
 990                                 ts = ent->ktr_timestamp;
 991                                 bestn = n;
 992                         }
 993                 }
 994                 if ((bestn < 0) || (ts < *last_timestamp))
 995                         break;
 996                 buf = ktr_bufs + bestn;
 997                 cb(fo, bestn, row,
 998                    &buf->ents[buf->beg_idx & fifo_mask],
 999                    last_timestamp);
1000                 ++buf->beg_idx;
1001                 *last_timestamp = ts;
1002                 ++row;
1003         }
1004 }
1005
1006 static
1007 void
1008 kvmfprintf(FILE *fp, const char *ctl, va_list va)
1009 {
1010         int n;
1011         int is_long;
1012         int is_done;
1013         char fmt[256];
1014         static struct save_ctx strctx;
1015         const char *s;
1016
1017         while (*ctl) {
1018                 for (n = 0; ctl[n]; ++n) {
1019                         fmt[n] = ctl[n];
1020                         if (ctl[n] == '%')
1021                                 break;
1022                 }
1023                 if (n == 0) {
1024                         is_long = 0;
1025                         is_done = 0;
1026                         n = 1;
1027                         while (n < (int)sizeof(fmt)) {
1028                                 fmt[n] = ctl[n];
1029                                 fmt[n+1] = 0;
1030
1031                                 switch(ctl[n]) {
1032                                 case 'p':
1033                                         is_long = 1;
1034                                         /* fall through */
1035                                 case 'd':
1036                                 case 'u':
1037                                 case 'x':
1038                                 case 'o':
1039                                 case 'X':
1040                                         /*
1041                                          * Integral
1042                                          */
1043                                         switch(is_long) {
1044                                         case 0:
1045                                                 fprintf(fp, fmt,
1046                                                         va_arg(va, int));
1047                                                 break;
1048                                         case 1:
1049                                                 fprintf(fp, fmt,
1050                                                         va_arg(va, long));
1051                                                 break;
1052                                         case 2:
1053                                                 fprintf(fp, fmt,
1054                                                     va_arg(va, long long));
1055                                                 break;
1056                                         case 3:
1057                                                 fprintf(fp, fmt,
1058                                                     va_arg(va, size_t));
1059                                                 break;
1060                                         }
1061                                         ++n;
1062                                         is_done = 1;
1063                                         break;
1064                                 case 'c':
1065                                         fprintf(fp, "%c", va_arg(va, int));
1066                                         ++n;
1067                                         is_done = 1;
1068                                         break;
1069                                 case 's':
1070                                         /*
1071                                          * String
1072                                          */
1073                                         s = kvm_string(va_arg(va, char *), &strctx);
1074                                         fwrite(s, 1, strlen(s), fp);
1075                                         ++n;
1076                                         is_done = 1;
1077                                         break;
1078                                 case 'f':
1079                                         /*
1080                                          * Floating
1081                                          */
1082                                         fprintf(fp, fmt,
1083                                                 va_arg(va, double));
1084                                         ++n;
1085                                         break;
1086                                 case 'j':
1087                                         is_long = 2;
1088                                         break;
1089                                 case 'z':
1090                                         is_long = 3;
1091                                         break;
1092                                 case 'l':
1093                                         if (is_long)
1094                                                 is_long = 2;
1095                                         else
1096                                                 is_long = 1;
1097                                         break;
1098                                 case '.':
1099                                 case '-':
1100                                 case '+':
1101                                 case '0':
1102                                 case '1':
1103                                 case '2':
1104                                 case '3':
1105                                 case '4':
1106                                 case '5':
1107                                 case '6':
1108                                 case '7':
1109                                 case '8':
1110                                 case '9':
1111                                         break;
1112                                 default:
1113                                         is_done = 1;
1114                                         break;
1115                                 }
1116                                 if (is_done)
1117                                         break;
1118                                 ++n;
1119                         }
1120                 } else {
1121                         fmt[n] = 0;
1122                         fprintf(fp, fmt, NULL);
1123                 }
1124                 ctl += n;
1125         }
1126 }
1127
1128 static void
1129 usage(void)
1130 {
1131         fprintf(stderr, "usage: ktrdump [-acfilnpqrstx] [-A factor] "
1132                         "[-N execfile] [-M corefile] [-o outfile]\n");
1133         exit(1);
1134 }
1135
1136 enum argument_class {
1137         ARGCLASS_NONE,
1138         ARGCLASS_INTEGER,
1139         ARGCLASS_FP,
1140         ARGCLASS_MEMORY,
1141         ARGCLASS_ERR,
1142 };
1143 static size_t
1144 conversion_size(const char *fmt, enum argument_class *argclass)
1145 {
1146         const char *p;
1147         size_t convsize, intsz;
1148
1149         *argclass = ARGCLASS_ERR;
1150         if (fmt[0] != '%')
1151                 return -1;
1152
1153         convsize = -1;
1154         for (p = fmt + 1; p[0]; ++p) {
1155                 int again = 0;
1156                 /*
1157                  * Eat flags. Notice this will accept duplicate
1158                  * flags.
1159                  */
1160                 switch (p[0]) {
1161                 case '#':
1162                 case '0':
1163                 case '-':
1164                 case ' ':
1165                 case '+':
1166                 case '\'':
1167                         again = !0;
1168                         break;
1169                 }
1170                 if (!again)
1171                         break;
1172         }
1173         /* Eat minimum field width, if any */
1174         for (; isdigit(p[0]); ++p)
1175                         ;
1176         if (p[0] == '.')
1177                 ++p;
1178         /* Eat precision, if any */
1179         for (; isdigit(p[0]); ++p)
1180                 ;
1181         intsz = 0;
1182         switch (p[0]) {
1183         case 'h':
1184                 if (p[1] == 'h') {
1185                         ++p;
1186                         intsz = sizeof(char);
1187                 } else {
1188                         intsz = sizeof(short);
1189                 }
1190                 break;
1191         case 'l':
1192                 if (p[1] == 'l') {
1193                         ++p;
1194                         intsz = sizeof(long long);
1195                 } else {
1196                         intsz = sizeof(long);
1197                 }
1198                 break;
1199         case 'j':
1200                 intsz = sizeof(intmax_t);
1201                 break;
1202         case 't':
1203                 intsz = sizeof(ptrdiff_t);
1204                 break;
1205         case 'z':
1206                 intsz = sizeof(size_t);
1207                 break;
1208         default:
1209                 p--;    /* Anticipate the ++p that follows. Yes, I know. Eeek. */
1210                 break;
1211         }
1212         if (intsz == 0)
1213                 intsz = sizeof(int);
1214         ++p;
1215
1216         switch (p[0]) {
1217         case 'c':
1218                 /* for %c, we only store 1 byte in the ktr entry */
1219                 convsize = sizeof(char);
1220                 *argclass = ARGCLASS_INTEGER;
1221                 break;
1222         case 'd':
1223         case 'i':
1224         case 'o':
1225         case 'u':
1226         case 'x':
1227         case 'X':
1228                 convsize = intsz;
1229                 *argclass = ARGCLASS_INTEGER;
1230                 break;
1231         case 'p':
1232                 convsize = sizeof(void *);
1233                 *argclass = ARGCLASS_INTEGER;
1234                 break;
1235         case 'f':
1236                 if (p[-1] == 'l')
1237                         convsize = sizeof(double);
1238                 else
1239                         convsize = sizeof(float);
1240                 break;
1241                 *argclass = ARGCLASS_FP;
1242         case 's':
1243                 convsize = sizeof(char *);
1244                 *argclass = ARGCLASS_INTEGER;
1245                 break;
1246         case '%':
1247                 convsize = 0;
1248                 *argclass = ARGCLASS_NONE;
1249                 break;
1250         default:
1251                 fprintf(stderr, "Unknown conversion specifier %c "
1252                         "in fmt starting with %s\n", p[0], fmt - 1);
1253                 return -2;
1254         }
1255         return convsize;
1256 }
1257
1258 #ifdef __x86_64__
1259 static int
1260 va_list_push_integral(struct my_va_list *valist, void *val, size_t valsize,
1261                      size_t *stacksize)
1262 {
1263         uint64_t r;
1264
1265         switch (valsize) {
1266         case 1:
1267                 r = *(uint8_t *)val; break;
1268         case 2:
1269                 r = *(uint32_t *)val; break;
1270         case 4:
1271                 r = (*(uint32_t *)val); break;
1272         case 8:
1273                 r = *(uint64_t *)val; break;
1274         default:
1275                 err(1, "WTF");
1276         }
1277         /* we always need to push the full 8 bytes */
1278         if ((valist->gp_offset + valsize) <= 48) {      /* got a free reg */
1279
1280                 memcpy(((char *)valist->reg_save_area + valist->gp_offset),
1281                        &r, sizeof(r));
1282                 valist->gp_offset += sizeof(r);
1283                 return 0;
1284         }
1285         /* push to "stack" */
1286         if (!(valist->overflow_arg_area = realloc(valist->overflow_arg_area,
1287                                                   *stacksize + sizeof(r))))
1288                 return -1;
1289         /*
1290          * Keep a pointer to the start of the allocated memory block so
1291          * we can free it later. We need to update it after every realloc().
1292          */
1293         valist->overflow_arg_area_save = valist->overflow_arg_area;
1294         memcpy((char *)valist->overflow_arg_area + *stacksize, &r, sizeof(r));
1295         *stacksize += sizeof(r);
1296         return 0;
1297 }
1298
1299 static void
1300 va_list_rewind(struct my_va_list *valist)
1301 {
1302         valist->gp_offset = 0;
1303 }
1304
1305 static void
1306 va_list_cleanup(machine_va_list *_valist)
1307 {
1308         machine_va_list valist;
1309         if (!_valist || !*_valist)
1310                 return;
1311         valist = *_valist;
1312         if (valist->reg_save_area)
1313                 free(valist->reg_save_area);
1314         if (valist->overflow_arg_area_save)
1315                 free(valist->overflow_arg_area_save);
1316         free(valist);
1317 }
1318
1319 static int
1320 va_list_from_blob(machine_va_list *_valist, const char *fmt, char *blob, size_t blobsize)
1321 {
1322         machine_va_list valist;
1323         struct reg_save_area *regs;
1324         const char *f;
1325         size_t sz;
1326
1327         if (!(valist = malloc(sizeof(*valist))))
1328                 return -1;
1329         if (!(regs = malloc(sizeof(*regs))))
1330                 goto free_valist;
1331         *valist = (struct my_va_list) {
1332                 .gp_offset = 0,
1333                 .fp_offset = 0,
1334                 .overflow_arg_area = NULL,
1335                 .reg_save_area = regs,
1336                 .overflow_arg_area_save = NULL,
1337         };
1338         enum argument_class argclass;
1339         size_t stacksize = 0;
1340
1341         for (f = fmt; *f != '\0'; ++f) {
1342                 if (*f != '%')
1343                         continue;
1344                 sz = conversion_size(f, &argclass);
1345                 if (argclass == ARGCLASS_INTEGER) {
1346                         if (blobsize < sz) {
1347                                 fprintf(stderr, "not enough data available "
1348                                         "for format: %s\n", fmt);
1349                                 goto free_areas;
1350                         }
1351                         if (va_list_push_integral(valist, blob, sz, &stacksize))
1352                                 goto free_areas;
1353                         blob += sz;
1354                         blobsize -= sz;
1355                 } else if (argclass != ARGCLASS_NONE)
1356                         goto free_areas;
1357                 /* walk past the '%' */
1358                 ++f;
1359         }
1360         if (blobsize) {
1361                 fprintf(stderr, "Couldn't consume all data for format %s "
1362                         "(%zd bytes left over)\n", fmt, blobsize);
1363                 goto free_areas;
1364         }
1365         va_list_rewind(valist);
1366         *_valist = valist;
1367         return 0;
1368 free_areas:
1369         if (valist->reg_save_area)
1370                 free(valist->reg_save_area);
1371         if (valist->overflow_arg_area_save)
1372                 free(valist->overflow_arg_area_save);
1373 free_valist:
1374         free(valist);
1375         *_valist = NULL;
1376         return -1;
1377 }
1378
1379 #else
1380 #error "Don't know how to get a va_list on this platform"
1381 #endif