fs_usage.tproj/fs_usage.c

   1 /*
   2  * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * "Portions Copyright (c) 1999 Apple Computer, Inc.  All Rights
   7  * Reserved.  This file contains Original Code and/or Modifications of
   8  * Original Code as defined in and that are subject to the Apple Public
   9  * Source License Version 1.0 (the 'License').  You may not use this file
  10  * except in compliance with the License.  Please obtain a copy of the
  11  * License at http://www.apple.com/publicsource and read it before using
  12  * this file.
  13  *
  14  * The Original Code and all software distributed under the License are
  15  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  16  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  17  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  19  * License for the specific language governing rights and limitations
  20  * under the License."
  21  *
  22  * @APPLE_LICENSE_HEADER_END@
  23  */
  24
  25 /*
  26 cc -I. -DKERNEL_PRIVATE -O -o fs_usage fs_usage.c
  27 */
  28
  29 #define Default_DELAY   1       /* default delay interval */
  30
  31 #include <stdlib.h>
  32 #include <stdio.h>
  33 #include <signal.h>
  34 #include <strings.h>
  35 #include <nlist.h>
  36 #include <fcntl.h>
  37 #include <string.h>
  38
  39 #include <sys/types.h>
  40 #include <sys/param.h>
  41 #include <sys/time.h>
  42
  43 #include <libc.h>
  44 #include <termios.h>
  45 #include <bsd/curses.h>
  46 #include <sys/ioctl.h>
  47
  48 #ifndef KERNEL_PRIVATE
  49 #define KERNEL_PRIVATE
  50 #include <sys/kdebug.h>
  51 #undef KERNEL_PRIVATE
  52 #else
  53 #include <sys/kdebug.h>
  54 #endif /*KERNEL_PRIVATE*/
  55
  56 #include <sys/sysctl.h>
  57 #include <errno.h>
  58 #import <mach/clock_types.h>
  59 #include <err.h>
  60
  61 extern int errno;
  62
  63
  64 struct th_info {
  65         int  in_filemgr;
  66         int  thread;
  67         int  type;
  68         int  arg1;
  69         int  arg2;
  70         int  arg3;
  71         int  arg4;
  72         int  vfslookup;
  73         int  child_thread;
  74         int  waited;
  75         double stime;
  76         char pathname[32];
  77 };
  78
  79 #define MAX_THREADS 512
  80 struct th_info th_state[MAX_THREADS];
  81
  82
  83 int  cur_max = 0;
  84 int  need_new_map = 1;
  85 int  bias_secs;
  86 int  wideflag = 0;
  87 int  select_pid_mode = 0;  /* Flag set indicates that output is restricted
  88                               to selected pids or commands */
  89
  90 int  one_good_pid = 0;    /* Used to fail gracefully when bad pids given */
  91
  92
  93 #define DBG_ZERO_FILL_FAULT   1
  94 #define DBG_PAGEIN_FAULT      2
  95 #define DBG_COW_FAULT         3
  96 #define DBG_CACHE_HIT_FAULT   4
  97
  98 #define TRACE_DATA_NEWTHREAD   0x07000004
  99 #define TRACE_STRING_NEWTHREAD 0x07010004
 100 #define TRACE_STRING_EXEC      0x07010008
 101
 102 #define MACH_vmfault    0x01300000
 103 #define MACH_sched      0x01400000
 104 #define MACH_stkhandoff 0x01400008
 105 #define VFS_LOOKUP      0x03010090
 106 #define BSC_exit        0x040C0004
 107
 108 #define MSC_map_fd   0x010c00ac
 109 #define BSC_recvmsg  0x040C006C
 110 #define BSC_sendmsg  0x040C0070
 111 #define BSC_recvfrom 0x040C0074
 112 #define BSC_sendto   0x040C0214
 113
 114 #define BSC_read     0x040C000C
 115 #define BSC_write    0x040C0010
 116 #define BSC_open     0x040C0014
 117 #define BSC_close    0x040C0018
 118 #define BSC_link     0x040C0024
 119 #define BSC_unlink   0x040C0028
 120 #define BSC_mknod    0x040C0038
 121 #define BSC_chmod    0x040C003C
 122 #define BSC_chown    0x040C0040
 123 #define BSC_access   0x040C0084
 124 #define BSC_chflags  0x040C0088
 125 #define BSC_fchflags 0x040C008C
 126 #define BSC_sync     0x040C0090
 127 #define BSC_symlink  0x040C00E4
 128 #define BSC_readlink 0x040C00E8
 129 #define BSC_fsync    0x040C017C
 130 #define BSC_readv    0x040C01E0
 131 #define BSC_writev   0x040C01E4
 132 #define BSC_fchown   0x040C01EC
 133 #define BSC_fchmod   0x040C01F0
 134 #define BSC_rename   0x040C0200
 135 #define BSC_mkdir    0x040C0220
 136 #define BSC_rmdir    0x040C0224
 137 #define BSC_statfs   0x040C0274
 138 #define BSC_fstatfs  0x040C0278
 139 #define BSC_stat     0x040C02F0
 140 #define BSC_fstat    0x040C02F4
 141 #define BSC_lstat    0x040C02F8
 142 #define BSC_pathconf 0x040C02FC
 143 #define BSC_fpathconf     0x040C0300
 144 #define BSC_getdirentries 0x040C0310
 145 #define BSC_mmap     0x040c0314
 146 #define BSC_lseek    0x040c031c
 147 #define BSC_truncate 0x040C0320
 148 #define BSC_ftruncate     0x040C0324
 149 #define BSC_statv    0x040C0364
 150 #define BSC_lstatv   0x040C0368
 151 #define BSC_fstatv   0x040C036C
 152 #define BSC_mkcomplex     0x040C0360
 153 #define BSC_getattrlist 0x040C0370
 154 #define BSC_setattrlist 0x040C0374
 155 #define BSC_getdirentriesattr 0x040C0378
 156 #define BSC_exchangedata  0x040C037C
 157 #define BSC_checkuseraccess   0x040C0380
 158 #define BSC_searchfs    0x040C0384
 159
 160 // Carbon File Manager support
 161 #define FILEMGR_PBGETCATALOGINFO                 0x1e000020
 162 #define FILEMGR_PBGETCATALOGINFOBULK     0x1e000024
 163 #define FILEMGR_PBCREATEFILEUNICODE              0x1e000028
 164 #define FILEMGR_PBCREATEDIRECTORYUNICODE 0x1e00002c
 165 #define FILEMGR_PBCREATEFORK                     0x1e000030
 166 #define FILEMGR_PBDELETEFORK                     0x1e000034
 167 #define FILEMGR_PBITERATEFORK                    0x1e000038
 168 #define FILEMGR_PBOPENFORK                               0x1e00003c
 169 #define FILEMGR_PBREADFORK                               0x1e000040
 170 #define FILEMGR_PBWRITEFORK                              0x1e000044
 171 #define FILEMGR_PBALLOCATEFORK                   0x1e000048
 172 #define FILEMGR_PBDELETEOBJECT                   0x1e00004c
 173 #define FILEMGR_PBEXCHANGEOBJECT                 0x1e000050
 174 #define FILEMGR_PBGETFORKCBINFO                  0x1e000054
 175 #define FILEMGR_PBGETVOLUMEINFO                  0x1e000058
 176 #define FILEMGR_PBMAKEFSREF                              0x1e00005c
 177 #define FILEMGR_PBMAKEFSREFUNICODE               0x1e000060
 178 #define FILEMGR_PBMOVEOBJECT                     0x1e000064
 179 #define FILEMGR_PBOPENITERATOR                   0x1e000068
 180 #define FILEMGR_PBRENAMEUNICODE                  0x1e00006c
 181 #define FILEMGR_PBSETCATALOGINFO                 0x1e000070
 182 #define FILEMGR_PBSETVOLUMEINFO                  0x1e000074
 183 #define FILEMGR_FSREFMAKEPATH                    0x1e000078
 184 #define FILEMGR_FSPATHMAKEREF                    0x1e00007c
 185
 186 #define FILEMGR_PBGETCATINFO                     0x1e010000
 187 #define FILEMGR_PBGETCATINFOLITE                 0x1e010004
 188 #define FILEMGR_PBHGETFINFO                              0x1e010008
 189 #define FILEMGR_PBXGETVOLINFO                    0x1e01000c
 190 #define FILEMGR_PBHCREATE                                0x1e010010
 191 #define FILEMGR_PBHOPENDF                                0x1e010014
 192 #define FILEMGR_PBHOPENRF                                0x1e010018
 193 #define FILEMGR_PBHGETDIRACCESS                  0x1e01001c
 194 #define FILEMGR_PBHSETDIRACCESS                  0x1e010020
 195 #define FILEMGR_PBHMAPID                                 0x1e010024
 196 #define FILEMGR_PBHMAPNAME                               0x1e010028
 197 #define FILEMGR_PBCLOSE                                  0x1e01002c
 198 #define FILEMGR_PBFLUSHFILE                              0x1e010030
 199 #define FILEMGR_PBGETEOF                                 0x1e010034
 200 #define FILEMGR_PBSETEOF                                 0x1e010038
 201 #define FILEMGR_PBGETFPOS                                0x1e01003c
 202 #define FILEMGR_PBREAD                                   0x1e010040
 203 #define FILEMGR_PBWRITE                                  0x1e010044
 204 #define FILEMGR_PBGETFCBINFO                     0x1e010048
 205 #define FILEMGR_PBSETFINFO                               0x1e01004c
 206 #define FILEMGR_PBALLOCATE                               0x1e010050
 207 #define FILEMGR_PBALLOCCONTIG                    0x1e010054
 208 #define FILEMGR_PBSETFPOS                                0x1e010058
 209 #define FILEMGR_PBSETCATINFO                     0x1e01005c
 210 #define FILEMGR_PBGETVOLPARMS                    0x1e010060
 211 #define FILEMGR_PBSETVINFO                               0x1e010064
 212 #define FILEMGR_PBMAKEFSSPEC                     0x1e010068
 213 #define FILEMGR_PBHGETVINFO                              0x1e01006c
 214 #define FILEMGR_PBCREATEFILEIDREF                0x1e010070
 215 #define FILEMGR_PBDELETEFILEIDREF                0x1e010074
 216 #define FILEMGR_PBRESOLVEFILEIDREF               0x1e010078
 217 #define FILEMGR_PBFLUSHVOL                               0x1e01007c
 218 #define FILEMGR_PBHRENAME                                0x1e010080
 219 #define FILEMGR_PBCATMOVE                                0x1e010084
 220 #define FILEMGR_PBEXCHANGEFILES                  0x1e010088
 221 #define FILEMGR_PBHDELETE                                0x1e01008c
 222 #define FILEMGR_PBDIRCREATE                              0x1e010090
 223 #define FILEMGR_PBCATSEARCH                              0x1e010094
 224 #define FILEMGR_PBHSETFLOCK                              0x1e010098
 225 #define FILEMGR_PBHRSTFLOCK                              0x1e01009c
 226 #define FILEMGR_PBLOCKRANGE                              0x1e0100a0
 227 #define FILEMGR_PBUNLOCKRANGE                    0x1e0100a4
 228
 229
 230 #define FILEMGR_CLASS   0x1e
 231
 232 #define MAX_PIDS 32
 233 int    pids[MAX_PIDS];
 234
 235 int    num_of_pids = 0;
 236 int    exclude_pids = 0;
 237
 238 struct kinfo_proc *kp_buffer = 0;
 239 int kp_nentries = 0;
 240
 241 #define SAMPLE_SIZE 60000
 242
 243 #define DBG_ZERO_FILL_FAULT   1
 244 #define DBG_PAGEIN_FAULT      2
 245 #define DBG_COW_FAULT         3
 246 #define DBG_CACHE_HIT_FAULT   4
 247
 248 #define DBG_FUNC_ALL    (DBG_FUNC_START | DBG_FUNC_END)
 249 #define DBG_FUNC_MASK   0xfffffffc
 250
 251 /* Default divisor */
 252 #define DIVISOR 16.6666        /* Trace divisor converts to microseconds */
 253 double divisor = DIVISOR;
 254
 255 int mib[6];
 256 size_t needed;
 257 char  *my_buffer;
 258
 259 kbufinfo_t bufinfo = {0, 0, 0, 0};
 260
 261 int total_threads = 0;
 262 kd_threadmap *mapptr = 0;
 263
 264 int trace_enabled = 0;
 265 int set_remove_flag = 1;
 266
 267 void set_numbufs();
 268 void set_init();
 269 void set_enable();
 270 void sample_sc();
 271 int quit();
 272
 273 /*
 274  *  signal handlers
 275  */
 276
 277 void leave()                    /* exit under normal conditions -- INT handler */
 278 {
 279         int i;
 280         void set_enable();
 281         void set_pidcheck();
 282         void set_pidexclude();
 283         void set_remove();
 284
 285         set_enable(0);
 286
 287         if (exclude_pids == 0) {
 288                 for (i = 0; i < num_of_pids; i++)
 289                         set_pidcheck(pids[i], 0);
 290         }
 291         else {
 292                 for (i = 0; i < num_of_pids; i++)
 293                         set_pidexclude(pids[i], 0);
 294         }
 295         set_remove();
 296         exit(0);
 297 }
 298
 299
 300 void sigwinch()
 301 {
 302         initscr();
 303 }
 304
 305 int
 306 exit_usage(myname) {
 307
 308         fprintf(stderr, "Usage: %s [-e] [-w] [pid | cmd [pid | cmd]....]\n", myname);
 309         fprintf(stderr, "  -e    exclude the pids specified from the sample\n");
 310         fprintf(stderr, "  -w    force wider, detailed, output\n");
 311         fprintf(stderr, "  pid   selects process(s) to sample\n");
 312         fprintf(stderr, "  cmd   selects process(s) matching command string to sample\n");
 313
 314         exit(1);
 315 }
 316
 317
 318 main(argc, argv)
 319         int     argc;
 320         char    *argv[];
 321 {
 322         char    *myname = "fs_usage";
 323         int     i;
 324         char    ch;
 325         void getdivisor();
 326         void argtopid();
 327         void set_remove();
 328         void set_pidcheck();
 329         void set_pidexclude();
 330         int quit();
 331
 332         if ( geteuid() != 0 ) {
 333             printf("'fs_usage' must be run as root...\n");
 334             exit(1);
 335         }
 336
 337         initscr();
 338
 339         /* get our name */
 340         if (argc > 0) {
 341                 if ((myname = rindex(argv[0], '/')) == 0) {
 342                         myname = argv[0];
 343                 }
 344                 else {
 345                         myname++;
 346                 }
 347         }
 348
 349        while ((ch = getopt(argc, argv, "ew")) != EOF) {
 350                switch(ch) {
 351                 case 'e':
 352                     exclude_pids = 1;
 353                     break;
 354                 case 'w':
 355                     wideflag = 1;
 356                     break;
 357                default:
 358                  exit_usage(myname);
 359                }
 360        }
 361
 362         argc -= optind;
 363         argv += optind;
 364
 365         while (argc > 0 && num_of_pids < (MAX_PIDS - 1)) {
 366           select_pid_mode++;
 367           argtopid(argv[0]);
 368           argc--;
 369           argv++;
 370         }
 371
 372         if (exclude_pids)
 373                 pids[num_of_pids++] = getpid();
 374
 375 #if 0
 376         for (i = 0; i < num_of_pids; i++)
 377           {
 378             if (exclude_pids)
 379               printf("exclude pid %d\n", pids[i]);
 380             else
 381               printf("pid %d\n", pids[i]);
 382           }
 383 #endif
 384
 385         /* set up signal handlers */
 386         signal(SIGINT, leave);
 387         signal(SIGQUIT, leave);
 388         signal(SIGTERM, leave);
 389         signal(SIGWINCH, sigwinch);
 390
 391         if ((my_buffer = malloc(SAMPLE_SIZE * sizeof(kd_buf))) == (char *)0)
 392             quit("can't allocate memory for tracing info\n");
 393
 394         set_remove();
 395         set_numbufs(SAMPLE_SIZE);
 396         set_init();
 397
 398         if (exclude_pids == 0) {
 399                 for (i = 0; i < num_of_pids; i++)
 400                         set_pidcheck(pids[i], 1);
 401         } else {
 402                 for (i = 0; i < num_of_pids; i++)
 403                         set_pidexclude(pids[i], 1);
 404         }
 405
 406         if (select_pid_mode && !one_good_pid)
 407           {
 408             /*
 409                An attempt to restrict output to a given
 410                pid or command has failed. Exit gracefully
 411             */
 412             set_remove();
 413             exit_usage(myname);
 414           }
 415
 416         set_enable(1);
 417         getdivisor();
 418
 419
 420         /* main loop */
 421
 422         while (1) {
 423                 usleep(1000 * 50);
 424
 425                 sample_sc();
 426         }
 427 }
 428
 429 void
 430 find_proc_names()
 431 {
 432         size_t                  bufSize = 0;
 433         struct kinfo_proc       *kp;
 434         int quit();
 435
 436         mib[0] = CTL_KERN;
 437         mib[1] = KERN_PROC;
 438         mib[2] = KERN_PROC_ALL;
 439         mib[3] = 0;
 440
 441         if (sysctl(mib, 4, NULL, &bufSize, NULL, 0) < 0)
 442                 quit("trace facility failure, KERN_PROC_ALL\n");
 443
 444         if((kp = (struct kinfo_proc *)malloc(bufSize)) == (struct kinfo_proc *)0)
 445             quit("can't allocate memory for proc buffer\n");
 446
 447         if (sysctl(mib, 4, kp, &bufSize, NULL, 0) < 0)
 448                 quit("trace facility failure, KERN_PROC_ALL\n");
 449
 450         kp_nentries = bufSize/ sizeof(struct kinfo_proc);
 451         kp_buffer = kp;
 452 }
 453
 454
 455 struct th_info *find_thread(int thread, int type) {
 456        struct th_info *ti;
 457
 458        for (ti = th_state; ti < &th_state[cur_max]; ti++) {
 459                if (ti->thread == thread) {
 460                        if (type == ti->type)
 461                                return(ti);
 462                        if (ti->in_filemgr) {
 463                                if (type == -1)
 464                                        return(ti);
 465                                continue;
 466                        }
 467                        if (type == 0)
 468                                return(ti);
 469                }
 470        }
 471        return ((struct th_info *)0);
 472 }
 473
 474 void
 475 set_enable(int val)
 476 {
 477         mib[0] = CTL_KERN;
 478         mib[1] = KERN_KDEBUG;
 479         mib[2] = KERN_KDENABLE;         /* protocol */
 480         mib[3] = val;
 481         mib[4] = 0;
 482         mib[5] = 0;                     /* no flags */
 483         if (sysctl(mib, 4, NULL, &needed, NULL, 0) < 0)
 484                 quit("trace facility failure, KERN_KDENABLE\n");
 485
 486         if (val)
 487           trace_enabled = 1;
 488         else
 489           trace_enabled = 0;
 490 }
 491
 492 void
 493 set_numbufs(int nbufs)
 494 {
 495         mib[0] = CTL_KERN;
 496         mib[1] = KERN_KDEBUG;
 497         mib[2] = KERN_KDSETBUF;
 498         mib[3] = nbufs;
 499         mib[4] = 0;
 500         mib[5] = 0;                     /* no flags */
 501         if (sysctl(mib, 4, NULL, &needed, NULL, 0) < 0)
 502                 quit("trace facility failure, KERN_KDSETBUF\n");
 503
 504         mib[0] = CTL_KERN;
 505         mib[1] = KERN_KDEBUG;
 506         mib[2] = KERN_KDSETUP;
 507         mib[3] = 0;
 508         mib[4] = 0;
 509         mib[5] = 0;                     /* no flags */
 510         if (sysctl(mib, 3, NULL, &needed, NULL, 0) < 0)
 511                 quit("trace facility failure, KERN_KDSETUP\n");
 512 }
 513
 514 void
 515 set_pidcheck(int pid, int on_off)
 516 {
 517         kd_regtype kr;
 518
 519         kr.type = KDBG_TYPENONE;
 520         kr.value1 = pid;
 521         kr.value2 = on_off;
 522         needed = sizeof(kd_regtype);
 523         mib[0] = CTL_KERN;
 524         mib[1] = KERN_KDEBUG;
 525         mib[2] = KERN_KDPIDTR;
 526         mib[3] = 0;
 527         mib[4] = 0;
 528         mib[5] = 0;
 529
 530         if (sysctl(mib, 3, &kr, &needed, NULL, 0) < 0) {
 531                 if (on_off == 1)
 532                         printf("pid %d does not exist\n", pid);
 533         }
 534         else {
 535           one_good_pid++;
 536         }
 537 }
 538
 539 /*
 540    on_off == 0 turns off pid exclusion
 541    on_off == 1 turns on pid exclusion
 542 */
 543 void
 544 set_pidexclude(int pid, int on_off)
 545 {
 546         kd_regtype kr;
 547
 548         one_good_pid++;
 549
 550         kr.type = KDBG_TYPENONE;
 551         kr.value1 = pid;
 552         kr.value2 = on_off;
 553         needed = sizeof(kd_regtype);
 554         mib[0] = CTL_KERN;
 555         mib[1] = KERN_KDEBUG;
 556         mib[2] = KERN_KDPIDEX;
 557         mib[3] = 0;
 558         mib[4] = 0;
 559         mib[5] = 0;
 560
 561         if (sysctl(mib, 3, &kr, &needed, NULL, 0) < 0) {
 562                 if (on_off == 1)
 563                           printf("pid %d does not exist\n", pid);
 564         }
 565 }
 566
 567 void
 568 get_bufinfo(kbufinfo_t *val)
 569 {
 570         needed = sizeof (*val);
 571         mib[0] = CTL_KERN;
 572         mib[1] = KERN_KDEBUG;
 573         mib[2] = KERN_KDGETBUF;
 574         mib[3] = 0;
 575         mib[4] = 0;
 576         mib[5] = 0;             /* no flags */
 577
 578         if (sysctl(mib, 3, val, &needed, 0, 0) < 0)
 579                 quit("trace facility failure, KERN_KDGETBUF\n");
 580
 581 }
 582
 583 void
 584 set_remove()
 585 {
 586         extern int errno;
 587
 588         errno = 0;
 589
 590         mib[0] = CTL_KERN;
 591         mib[1] = KERN_KDEBUG;
 592         mib[2] = KERN_KDREMOVE;         /* protocol */
 593         mib[3] = 0;
 594         mib[4] = 0;
 595         mib[5] = 0;             /* no flags */
 596         if (sysctl(mib, 3, NULL, &needed, NULL, 0) < 0)
 597           {
 598             set_remove_flag = 0;
 599
 600             if (errno == EBUSY)
 601                 quit("the trace facility is currently in use...\n          fs_usage, sc_usage, and latency use this feature.\n\n");
 602             else
 603                 quit("trace facility failure, KERN_KDREMOVE\n");
 604           }
 605 }
 606
 607 void
 608 set_init()
 609 {       kd_regtype kr;
 610
 611         kr.type = KDBG_RANGETYPE;
 612         kr.value1 = 0;
 613         kr.value2 = -1;
 614         needed = sizeof(kd_regtype);
 615         mib[0] = CTL_KERN;
 616         mib[1] = KERN_KDEBUG;
 617         mib[2] = KERN_KDSETREG;
 618         mib[3] = 0;
 619         mib[4] = 0;
 620         mib[5] = 0;             /* no flags */
 621
 622         if (sysctl(mib, 3, &kr, &needed, NULL, 0) < 0)
 623                 quit("trace facility failure, KERN_KDSETREG\n");
 624
 625         mib[0] = CTL_KERN;
 626         mib[1] = KERN_KDEBUG;
 627         mib[2] = KERN_KDSETUP;
 628         mib[3] = 0;
 629         mib[4] = 0;
 630         mib[5] = 0;             /* no flags */
 631
 632         if (sysctl(mib, 3, NULL, &needed, NULL, 0) < 0)
 633                 quit("trace facility failure, KERN_KDSETUP\n");
 634 }
 635
 636 void
 637 sample_sc()
 638 {
 639         kd_buf *kd;
 640         int i, count;
 641         void read_command_map();
 642         void create_map_entry();
 643
 644         /* Get kernel buffer information */
 645         get_bufinfo(&bufinfo);
 646
 647         if (need_new_map) {
 648                 read_command_map();
 649                 need_new_map = 0;
 650         }
 651         needed = bufinfo.nkdbufs * sizeof(kd_buf);
 652         mib[0] = CTL_KERN;
 653         mib[1] = KERN_KDEBUG;
 654         mib[2] = KERN_KDREADTR;
 655         mib[3] = 0;
 656         mib[4] = 0;
 657         mib[5] = 0;             /* no flags */
 658
 659         if (sysctl(mib, 3, my_buffer, &needed, NULL, 0) < 0)
 660                 quit("trace facility failure, KERN_KDREADTR\n");
 661         count = needed;
 662
 663         if (bufinfo.flags & KDBG_WRAPPED) {
 664                 printf("buffer wrapped  count = %d\n", count);
 665
 666                 for (i = 0; i < cur_max; i++) {
 667                         th_state[i].thread = 0;
 668                         th_state[i].vfslookup = 0;
 669                         th_state[i].pathname[0] = 0;
 670                 }
 671                 cur_max = 0;
 672                 need_new_map = 1;
 673
 674                 set_enable(0);
 675                 set_enable(1);
 676         }
 677         kd = (kd_buf *)my_buffer;
 678 #if 0
 679         printf("READTR returned %d items\n", count);
 680 #endif
 681         for (i = 0; i < count; i++) {
 682                 int debugid, thread;
 683                 int type, n;
 684                 long *sargptr;
 685                 unsigned long long now;
 686                 struct th_info *ti;
 687                 void enter_syscall();
 688                 void exit_syscall();
 689                 void kill_thread_map();
 690
 691                 thread  = kd[i].arg5 & KDBG_THREAD_MASK;
 692                 debugid = kd[i].debugid;
 693                 type    = kd[i].debugid & DBG_FUNC_MASK;
 694
 695                 switch (type) {
 696
 697                 case TRACE_DATA_NEWTHREAD:
 698
 699                     for (n = 0, ti = th_state; ti < &th_state[MAX_THREADS]; ti++, n++) {
 700                         if (ti->thread == 0)
 701                            break;
 702                     }
 703                     if (ti == &th_state[MAX_THREADS])
 704                         continue;
 705                     if (n >= cur_max)
 706                         cur_max = n + 1;
 707
 708                     ti->thread = thread;
 709                     ti->child_thread = kd[i].arg1;
 710                     continue;
 711
 712                 case TRACE_STRING_NEWTHREAD:
 713                     if ((ti = find_thread(thread, 0)) == (struct th_info *)0)
 714                             continue;
 715                     if (ti->child_thread == 0)
 716                             continue;
 717                     create_map_entry(ti->child_thread, (char *)&kd[i].arg1);
 718
 719                     if (ti == &th_state[cur_max - 1])
 720                         cur_max--;
 721                     ti->child_thread = 0;
 722                     ti->thread = 0;
 723                     continue;
 724
 725                 case TRACE_STRING_EXEC:
 726                     create_map_entry(thread, (char *)&kd[i].arg1);
 727                     continue;
 728
 729                 case BSC_exit:
 730                     kill_thread_map(thread);
 731                     continue;
 732
 733                 case MACH_sched:
 734                 case MACH_stkhandoff:
 735                     if (ti = find_thread(thread, 0))
 736                             ti->waited = 1;
 737                     continue;
 738
 739                 case VFS_LOOKUP:
 740                     if ((ti = find_thread(thread, 0)) == (struct th_info *)0)
 741                             continue;
 742
 743                     if (ti->vfslookup == 0) {
 744                             ti->vfslookup = 1;
 745                             memset(&ti->pathname[0], 0, 32);
 746                             sargptr = (long *)&ti->pathname[0];
 747
 748                             *sargptr++ = kd[i].arg2;
 749                             *sargptr++ = kd[i].arg3;
 750                             *sargptr++ = kd[i].arg4;
 751
 752                     } else if (ti->vfslookup == 1) {
 753                             ti->vfslookup = 2;
 754
 755                             sargptr = (long *)&ti->pathname[12];
 756                             *sargptr++ = kd[i].arg1;
 757                             *sargptr++ = kd[i].arg2;
 758                             *sargptr++ = kd[i].arg3;
 759                             *sargptr++ = kd[i].arg4;
 760                     }
 761                     continue;
 762                 }
 763                 now = (((unsigned long long)kd[i].timestamp.tv_sec) << 32) |
 764                         (unsigned long long)((unsigned int)(kd[i].timestamp.tv_nsec));
 765
 766                 if (debugid & DBG_FUNC_START) {
 767                        char *p;
 768
 769                        switch (type) {
 770                            case FILEMGR_PBGETCATALOGINFO:
 771                                         p = "GetCatalogInfo";
 772                                         break;
 773                            case FILEMGR_PBGETCATALOGINFOBULK:
 774                                         p = "GetCatalogInfoBulk";
 775                                         break;
 776                            case FILEMGR_PBCREATEFILEUNICODE:
 777                                         p = "CreateFileUnicode";
 778                                         break;
 779                            case FILEMGR_PBCREATEDIRECTORYUNICODE:
 780                                         p = "CreateDirectoryUnicode";
 781                                         break;
 782                            case FILEMGR_PBCREATEFORK:
 783                                         p = "PBCreateFork";
 784                                         break;
 785                            case FILEMGR_PBDELETEFORK:
 786                                         p = "PBDeleteFork";
 787                                         break;
 788                            case FILEMGR_PBITERATEFORK:
 789                                         p = "PBIterateFork";
 790                                         break;
 791                            case FILEMGR_PBOPENFORK:
 792                                         p = "PBOpenFork";
 793                                         break;
 794                            case FILEMGR_PBREADFORK:
 795                                         p = "PBReadFork";
 796                                         break;
 797                            case FILEMGR_PBWRITEFORK:
 798                                         p = "PBWriteFork";
 799                                         break;
 800                            case FILEMGR_PBALLOCATEFORK:
 801                                         p = "PBAllocateFork";
 802                                         break;
 803                            case FILEMGR_PBDELETEOBJECT:
 804                                         p = "PBDeleteObject";
 805                                         break;
 806                            case FILEMGR_PBEXCHANGEOBJECT:
 807                                         p = "PBExchangeObject";
 808                                         break;
 809                            case FILEMGR_PBGETFORKCBINFO:
 810                                         p = "PBGetForkCBInfo";
 811                                         break;
 812                            case FILEMGR_PBGETVOLUMEINFO:
 813                                         p = "PBGetVolumeInfo";
 814                                         break;
 815                            case FILEMGR_PBMAKEFSREF:
 816                                         p = "PBMakeFSRef";
 817                                         break;
 818                            case FILEMGR_PBMAKEFSREFUNICODE:
 819                                         p = "PBMakeFSRefUnicode";
 820                                         break;
 821                            case FILEMGR_PBMOVEOBJECT:
 822                                         p = "PBMoveObject";
 823                                         break;
 824                            case FILEMGR_PBOPENITERATOR:
 825                                         p = "PBOpenIterator";
 826                                         break;
 827                            case FILEMGR_PBRENAMEUNICODE:
 828                                         p = "PBRenameUnicode";
 829                                         break;
 830                            case FILEMGR_PBSETCATALOGINFO:
 831                                         p = "SetCatalogInfo";
 832                                         break;
 833                            case FILEMGR_PBSETVOLUMEINFO:
 834                                         p = "SetVolumeInfo";
 835                                         break;
 836                            case FILEMGR_FSREFMAKEPATH:
 837                                         p = "FSRefMakePath";
 838                                         break;
 839                            case FILEMGR_FSPATHMAKEREF:
 840                                         p = "FSPathMakeRef";
 841                                         break;
 842                            // SPEC based calls
 843                            case FILEMGR_PBGETCATINFO:
 844                                         p = "GetCatInfo";
 845                                         break;
 846                            case FILEMGR_PBGETCATINFOLITE:
 847                                         p = "GetCatInfoLite";
 848                                         break;
 849                            case FILEMGR_PBHGETFINFO:
 850                                         p = "PBHGetFInfo";
 851                                         break;
 852                            case FILEMGR_PBXGETVOLINFO:
 853                                         p = "PBXGetVolInfo";
 854                                         break;
 855                            case FILEMGR_PBHCREATE:
 856                                         p = "PBHCreate";
 857                                         break;
 858                            case FILEMGR_PBHOPENDF:
 859                                         p = "PBHOpenDF";
 860                                         break;
 861                            case FILEMGR_PBHOPENRF:
 862                                         p = "PBHOpenRF";
 863                                         break;
 864                            case FILEMGR_PBHGETDIRACCESS:
 865                                         p = "PBHGetDirAccess";
 866                                         break;
 867                            case FILEMGR_PBHSETDIRACCESS:
 868                                         p = "PBHSetDirAccess";
 869                                         break;
 870                            case FILEMGR_PBHMAPID:
 871                                         p = "PBHMapID";
 872                                         break;
 873                            case FILEMGR_PBHMAPNAME:
 874                                         p = "PBHMapName";
 875                                         break;
 876                            case FILEMGR_PBCLOSE:
 877                                         p = "PBClose";
 878                                         break;
 879                            case FILEMGR_PBFLUSHFILE:
 880                                         p = "PBFlushFile";
 881                                         break;
 882                            case FILEMGR_PBGETEOF:
 883                                         p = "PBGetEOF";
 884                                         break;
 885                            case FILEMGR_PBSETEOF:
 886                                         p = "PBSetEOF";
 887                                         break;
 888                            case FILEMGR_PBGETFPOS:
 889                                         p = "PBGetFPos";
 890                                         break;
 891                            case FILEMGR_PBREAD:
 892                                         p = "PBRead";
 893                                         break;
 894                            case FILEMGR_PBWRITE:
 895                                         p = "PBWrite";
 896                                         break;
 897                            case FILEMGR_PBGETFCBINFO:
 898                                         p = "PBGetFCBInfo";
 899                                         break;
 900                            case FILEMGR_PBSETFINFO:
 901                                         p = "PBSetFInfo";
 902                                         break;
 903                            case FILEMGR_PBALLOCATE:
 904                                         p = "PBAllocate";
 905                                         break;
 906                            case FILEMGR_PBALLOCCONTIG:
 907                                         p = "PBAllocContig";
 908                                         break;
 909                            case FILEMGR_PBSETFPOS:
 910                                         p = "PBSetFPos";
 911                                         break;
 912                            case FILEMGR_PBSETCATINFO:
 913                                         p = "PBSetCatInfo";
 914                                         break;
 915                            case FILEMGR_PBGETVOLPARMS:
 916                                         p = "PBGetVolParms";
 917                                         break;
 918                            case FILEMGR_PBSETVINFO:
 919                                         p = "PBSetVInfo";
 920                                         break;
 921                            case FILEMGR_PBMAKEFSSPEC:
 922                                         p = "PBMakeFSSpec";
 923                                         break;
 924                            case FILEMGR_PBHGETVINFO:
 925                                         p = "PBHGetVInfo";
 926                                         break;
 927                            case FILEMGR_PBCREATEFILEIDREF:
 928                                         p = "PBCreateFileIDRef";
 929                                         break;
 930                            case FILEMGR_PBDELETEFILEIDREF:
 931                                         p = "PBDeleteFileIDRef";
 932                                         break;
 933                            case FILEMGR_PBRESOLVEFILEIDREF:
 934                                         p = "PBResolveFileIDRef";
 935                                         break;
 936                            case FILEMGR_PBFLUSHVOL:
 937                                         p = "PBFlushVol";
 938                                         break;
 939                            case FILEMGR_PBHRENAME:
 940                                         p = "PBHRename";
 941                                         break;
 942                            case FILEMGR_PBCATMOVE:
 943                                         p = "PBCatMove";
 944                                         break;
 945                            case FILEMGR_PBEXCHANGEFILES:
 946                                         p = "PBExchangeFiles";
 947                                         break;
 948                            case FILEMGR_PBHDELETE:
 949                                         p = "PBHDelete";
 950                                         break;
 951                            case FILEMGR_PBDIRCREATE:
 952                                         p = "PBDirCreate";
 953                                         break;
 954                            case FILEMGR_PBCATSEARCH:
 955                                         p = "PBCatSearch";
 956                                         break;
 957                            case FILEMGR_PBHSETFLOCK:
 958                                         p = "PBHSetFlock";
 959                                         break;
 960                            case FILEMGR_PBHRSTFLOCK:
 961                                         p = "PBHRstFLock";
 962                                         break;
 963                            case FILEMGR_PBLOCKRANGE:
 964                                         p = "PBLockRange";
 965                                         break;
 966                            case FILEMGR_PBUNLOCKRANGE:
 967                                         p = "PBUnlockRange";
 968                                         break;
 969                            default:
 970                                         p = (char *)0;
 971                                         break;
 972                         }
 973                         enter_syscall(thread, type, &kd[i], p, (double)now);
 974                         continue;
 975                 }
 976                 switch (type) {
 977
 978                 case MACH_vmfault:
 979                     if (kd[i].arg2 == DBG_PAGEIN_FAULT)
 980                             exit_syscall("PAGE_IN", thread, type, 0, kd[i].arg1, 0, 2, (double)now);
 981                     else {
 982                             if (ti = find_thread(thread, type)) {
 983                                     if (ti == &th_state[cur_max - 1])
 984                                             cur_max--;
 985                                     ti->thread = 0;
 986                             }
 987                     }
 988                     break;
 989
 990                 case MSC_map_fd:
 991                     exit_syscall("map_fd", thread, type, kd[i].arg1, kd[i].arg2, 1, 0, (double)now);
 992                     break;
 993
 994                 case BSC_mmap:
 995                     exit_syscall("mmap", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
 996                     break;
 997
 998                 case BSC_recvmsg:
 999                     exit_syscall("recvmsg", thread, type, kd[i].arg1, kd[i].arg2, 1, 1, (double)now);
1000                     break;
1001
1002                 case BSC_sendmsg:
1003                     exit_syscall("sendmsg", thread, type, kd[i].arg1, kd[i].arg2, 1, 1, (double)now);
1004                     break;
1005
1006                 case BSC_recvfrom:
1007                     exit_syscall("recvfrom", thread, type, kd[i].arg1, kd[i].arg2, 1, 1, (double)now);
1008                     break;
1009
1010                 case BSC_sendto:
1011                     exit_syscall("sendto", thread, type, kd[i].arg1, kd[i].arg2, 1, 1, (double)now);
1012                     break;
1013
1014                 case BSC_stat:
1015                     exit_syscall("stat", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1016                     break;
1017
1018                 case BSC_open:
1019                     exit_syscall("open", thread, type, kd[i].arg1, kd[i].arg2, 2, 0, (double)now);
1020                     break;
1021
1022                 case BSC_close:
1023                     exit_syscall("close", thread, type, kd[i].arg1, kd[i].arg2, 1, 0, (double)now);
1024                     break;
1025
1026                 case BSC_read:
1027                     exit_syscall("read", thread, type, kd[i].arg1, kd[i].arg2, 1, 1, (double)now);
1028                     break;
1029
1030                 case BSC_write:
1031                     exit_syscall("write", thread, type, kd[i].arg1, kd[i].arg2, 1, 1, (double)now);
1032                     break;
1033
1034                 case BSC_fstat:
1035                     exit_syscall("fstat", thread, type, kd[i].arg1, kd[i].arg2, 1, 0, (double)now);
1036                     break;
1037
1038                 case BSC_lstat:
1039                     exit_syscall("lstat", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1040                     break;
1041
1042                 case BSC_link:
1043                     exit_syscall("link", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1044                     break;
1045
1046                 case BSC_unlink:
1047                     exit_syscall("unlink", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1048                     break;
1049
1050                 case BSC_mknod:
1051                     exit_syscall("mknod", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1052                     break;
1053
1054                 case BSC_chmod:
1055                     exit_syscall("chmod", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1056                     break;
1057
1058                 case BSC_chown:
1059                     exit_syscall("chown", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1060                     break;
1061
1062                 case BSC_access:
1063                     exit_syscall("access", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1064                     break;
1065
1066                 case BSC_chflags:
1067                     exit_syscall("chflags", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1068                     break;
1069
1070                 case BSC_fchflags:
1071                     exit_syscall("fchflags", thread, type, kd[i].arg1, kd[i].arg2, 1, 0, (double)now);
1072                     break;
1073
1074                 case BSC_sync:
1075                     exit_syscall("sync", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1076                     break;
1077
1078                 case BSC_symlink:
1079                     exit_syscall("symlink", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1080                     break;
1081
1082                 case BSC_readlink:
1083                     exit_syscall("readlink", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1084                     break;
1085
1086                 case BSC_fsync:
1087                     exit_syscall("fsync", thread, type, kd[i].arg1, kd[i].arg2, 1, 0, (double)now);
1088                     break;
1089
1090                 case BSC_readv:
1091                     exit_syscall("readv", thread, type, kd[i].arg1, kd[i].arg2, 1, 1, (double)now);
1092                     break;
1093
1094                 case BSC_writev:
1095                     exit_syscall("writev", thread, type, kd[i].arg1, kd[i].arg2, 1, 1, (double)now);
1096                     break;
1097
1098                 case BSC_fchown:
1099                     exit_syscall("fchown", thread, type, kd[i].arg1, kd[i].arg2, 1, 0, (double)now);
1100                     break;
1101
1102                 case BSC_fchmod:
1103                     exit_syscall("fchmod", thread, type, kd[i].arg1, kd[i].arg2, 1, 0, (double)now);
1104                     break;
1105
1106                 case BSC_rename:
1107                     exit_syscall("rename", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1108                     break;
1109
1110                 case BSC_mkdir:
1111                     exit_syscall("mkdir", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1112                     break;
1113
1114                 case BSC_rmdir:
1115                     exit_syscall("rmdir", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1116                     break;
1117
1118                 case BSC_statfs:
1119                     exit_syscall("statfs", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1120                     break;
1121
1122                 case BSC_fstatfs:
1123                     exit_syscall("fstatfs", thread, type, kd[i].arg1, kd[i].arg2, 1, 0, (double)now);
1124                     break;
1125
1126                 case BSC_pathconf:
1127                     exit_syscall("pathconf", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1128                     break;
1129
1130                 case BSC_fpathconf:
1131                     exit_syscall("fpathconf", thread, type, kd[i].arg1, kd[i].arg2, 1, 0, (double)now);
1132                     break;
1133
1134                 case BSC_getdirentries:
1135                     exit_syscall("getdirentries", thread, type, kd[i].arg1, kd[i].arg2, 1, 1, (double)now);
1136                     break;
1137
1138                 case BSC_lseek:
1139                     exit_syscall("lseek", thread, type, kd[i].arg1, kd[i].arg3, 1, 5, (double)now);
1140                     break;
1141
1142                 case BSC_truncate:
1143                     exit_syscall("truncate", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1144                     break;
1145
1146                 case BSC_ftruncate:
1147                     exit_syscall("ftruncate", thread, type, kd[i].arg1, kd[i].arg2, 1, 3, (double)now);
1148                     break;
1149
1150                 case BSC_statv:
1151                     exit_syscall("statv", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1152                     break;
1153
1154                 case BSC_lstatv:
1155                     exit_syscall("lstatv", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1156                     break;
1157
1158                 case BSC_fstatv:
1159                     exit_syscall("fstatv", thread, type, kd[i].arg1, kd[i].arg2, 1, 0, (double)now);
1160                     break;
1161
1162                 case BSC_mkcomplex:
1163                     exit_syscall("mkcomplex", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1164                     break;
1165
1166                 case BSC_getattrlist:
1167                     exit_syscall("getattrlist", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1168                     break;
1169
1170                 case BSC_setattrlist:
1171                     exit_syscall("setattrlist", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1172                     break;
1173
1174                 case BSC_getdirentriesattr:
1175                     exit_syscall("getdirentriesattr", thread, type, kd[i].arg1, kd[i].arg2, 0, 1, (double)now);
1176                     break;
1177
1178                 case BSC_exchangedata:
1179                     exit_syscall("exchangedata", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1180                     break;
1181
1182                 case BSC_checkuseraccess:
1183                     exit_syscall("checkuseraccess", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1184                     break;
1185
1186                 case BSC_searchfs:
1187                     exit_syscall("searchfs", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1188                     break;
1189
1190            case FILEMGR_PBGETCATALOGINFO:
1191                     exit_syscall("GetCatalogInfo", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1192                     break;
1193            case FILEMGR_PBGETCATALOGINFOBULK:
1194                     exit_syscall("GetCatalogInfoBulk", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1195                     break;
1196            case FILEMGR_PBCREATEFILEUNICODE:
1197                     exit_syscall("CreateFileUnicode", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1198                     break;
1199            case FILEMGR_PBCREATEDIRECTORYUNICODE:
1200                     exit_syscall("CreateDirectoryUnicode", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1201                     break;
1202            case FILEMGR_PBCREATEFORK:
1203                     exit_syscall("PBCreateFork", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1204                     break;
1205            case FILEMGR_PBDELETEFORK:
1206                     exit_syscall("PBDeleteFork", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1207                     break;
1208            case FILEMGR_PBITERATEFORK:
1209                     exit_syscall("PBIterateFork", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1210                     break;
1211            case FILEMGR_PBOPENFORK:
1212                     exit_syscall("PBOpenFork", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1213                     break;
1214            case FILEMGR_PBREADFORK:
1215                     exit_syscall("PBReadFork", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1216                     break;
1217            case FILEMGR_PBWRITEFORK:
1218                     exit_syscall("PBWriteFork", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1219                     break;
1220            case FILEMGR_PBALLOCATEFORK:
1221                     exit_syscall("PBAllocateFork", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1222                     break;
1223            case FILEMGR_PBDELETEOBJECT:
1224                     exit_syscall("PBDeleteObject", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1225                     break;
1226            case FILEMGR_PBEXCHANGEOBJECT:
1227                     exit_syscall("PBExchangeObject", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1228                     break;
1229            case FILEMGR_PBGETFORKCBINFO:
1230                     exit_syscall("PBGetForkCBInfo", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1231                     break;
1232            case FILEMGR_PBGETVOLUMEINFO:
1233                     exit_syscall("PBGetVolumeInfo", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1234                     break;
1235            case FILEMGR_PBMAKEFSREF:
1236                     exit_syscall("PBMakeFSRef", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1237                     break;
1238            case FILEMGR_PBMAKEFSREFUNICODE:
1239                     exit_syscall("PBMakeFSRefUnicode", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1240                     break;
1241            case FILEMGR_PBMOVEOBJECT:
1242                     exit_syscall("PBMoveObject", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1243                     break;
1244            case FILEMGR_PBOPENITERATOR:
1245                     exit_syscall("PBOpenIterator", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1246                     break;
1247            case FILEMGR_PBRENAMEUNICODE:
1248                     exit_syscall("PBRenameUnicode", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1249                     break;
1250            case FILEMGR_PBSETCATALOGINFO:
1251                     exit_syscall("PBSetCatalogInfo", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1252                     break;
1253            case FILEMGR_PBSETVOLUMEINFO:
1254                     exit_syscall("PBSetVolumeInfo", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1255                     break;
1256            case FILEMGR_FSREFMAKEPATH:
1257                     exit_syscall("FSRefMakePath", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1258                     break;
1259            case FILEMGR_FSPATHMAKEREF:
1260                     exit_syscall("FSPathMakeRef", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1261                     break;
1262            case FILEMGR_PBGETCATINFO:
1263                     exit_syscall("GetCatInfo", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1264                     break;
1265            case FILEMGR_PBGETCATINFOLITE:
1266                     exit_syscall("GetCatInfoLite", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1267                     break;
1268            case FILEMGR_PBHGETFINFO:
1269                     exit_syscall("PBHGetFInfo", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1270                     break;
1271            case FILEMGR_PBXGETVOLINFO:
1272                     exit_syscall("PBXGetVolInfo", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1273                     break;
1274            case FILEMGR_PBHCREATE:
1275                     exit_syscall("PBHCreate", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1276                     break;
1277            case FILEMGR_PBHOPENDF:
1278                     exit_syscall("PBHOpenDF", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1279                     break;
1280            case FILEMGR_PBHOPENRF:
1281                     exit_syscall("PBHOpenRF", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1282                     break;
1283            case FILEMGR_PBHGETDIRACCESS:
1284                     exit_syscall("PBHGetDirAccess", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1285                     break;
1286            case FILEMGR_PBHSETDIRACCESS:
1287                     exit_syscall("PBHSetDirAccess", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1288                     break;
1289            case FILEMGR_PBHMAPID:
1290                     exit_syscall("PBHMapID", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1291                     break;
1292            case FILEMGR_PBHMAPNAME:
1293                     exit_syscall("PBHMapName", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1294                     break;
1295            case FILEMGR_PBCLOSE:
1296                     exit_syscall("PBClose", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1297                     break;
1298            case FILEMGR_PBFLUSHFILE:
1299                     exit_syscall("PBFlushFile", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1300                     break;
1301            case FILEMGR_PBGETEOF:
1302                     exit_syscall("PBGetEOF", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1303                     break;
1304            case FILEMGR_PBSETEOF:
1305                     exit_syscall("PBSetEOF", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1306                     break;
1307            case FILEMGR_PBGETFPOS:
1308                     exit_syscall("PBGetFPos", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1309                     break;
1310            case FILEMGR_PBREAD:
1311                     exit_syscall("PBRead", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1312                     break;
1313            case FILEMGR_PBWRITE:
1314                     exit_syscall("PBWrite", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1315                     break;
1316            case FILEMGR_PBGETFCBINFO:
1317                     exit_syscall("PBGetFCBInfo", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1318                     break;
1319            case FILEMGR_PBSETFINFO:
1320                     exit_syscall("PBSetFInfo", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1321                     break;
1322            case FILEMGR_PBALLOCATE:
1323                     exit_syscall("PBAllocate", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1324                     break;
1325            case FILEMGR_PBALLOCCONTIG:
1326                     exit_syscall("PBAllocContig", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1327                     break;
1328            case FILEMGR_PBSETFPOS:
1329                     exit_syscall("PBSetFPos", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1330                     break;
1331            case FILEMGR_PBSETCATINFO:
1332                     exit_syscall("PBSetCatInfo", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1333                     break;
1334            case FILEMGR_PBGETVOLPARMS:
1335                     exit_syscall("PBGetVolParms", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1336                     break;
1337            case FILEMGR_PBSETVINFO:
1338                     exit_syscall("PBSetVInfo", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1339                     break;
1340            case FILEMGR_PBMAKEFSSPEC:
1341                     exit_syscall("PBMakeFSSpec", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1342                     break;
1343            case FILEMGR_PBHGETVINFO:
1344                     exit_syscall("PBHGetVInfo", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1345                     break;
1346            case FILEMGR_PBCREATEFILEIDREF:
1347                     exit_syscall("PBCreateFileIDRef", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1348                     break;
1349            case FILEMGR_PBDELETEFILEIDREF:
1350                     exit_syscall("PBDeleteFileIDRef", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1351                     break;
1352            case FILEMGR_PBRESOLVEFILEIDREF:
1353                     exit_syscall("PBResolveFileIDRef", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1354                     break;
1355            case FILEMGR_PBFLUSHVOL:
1356                     exit_syscall("PBFlushVol", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1357                     break;
1358            case FILEMGR_PBHRENAME:
1359                     exit_syscall("PBHRename", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1360                     break;
1361            case FILEMGR_PBCATMOVE:
1362                     exit_syscall("PBCatMove", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1363                     break;
1364            case FILEMGR_PBEXCHANGEFILES:
1365                     exit_syscall("PBExchangeFiles", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1366                     break;
1367            case FILEMGR_PBHDELETE:
1368                     exit_syscall("PBHDelete", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1369                     break;
1370            case FILEMGR_PBDIRCREATE:
1371                     exit_syscall("PBDirCreate", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1372                     break;
1373            case FILEMGR_PBCATSEARCH:
1374                     exit_syscall("PBCatSearch", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1375                     break;
1376            case FILEMGR_PBHSETFLOCK:
1377                     exit_syscall("PBHSetFLock", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1378                     break;
1379            case FILEMGR_PBHRSTFLOCK:
1380                     exit_syscall("PBHRstFLock", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1381                     break;
1382            case FILEMGR_PBLOCKRANGE:
1383                     exit_syscall("PBLockRange", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1384                     break;
1385            case FILEMGR_PBUNLOCKRANGE:
1386                     exit_syscall("PBUnlockRange", thread, type, kd[i].arg1, kd[i].arg2, 0, 0, (double)now);
1387                     break;
1388                 default:
1389                     break;
1390                 }
1391         }
1392         fflush(0);
1393 }
1394
1395 void
1396 enter_syscall(int thread, int type, kd_buf *kd, char *name, double now)
1397 {
1398        struct th_info *ti;
1399        int    i;
1400        int    secs;
1401        int    usecs;
1402        long long l_usecs;
1403        long curr_time;
1404            kd_threadmap *map;
1405            kd_threadmap *find_thread_map();
1406
1407        switch (type) {
1408
1409        case MACH_vmfault:
1410        case MSC_map_fd:
1411        case BSC_mmap:
1412        case BSC_recvmsg:
1413        case BSC_sendmsg:
1414        case BSC_recvfrom:
1415        case BSC_sendto:
1416        case BSC_stat:
1417        case BSC_open:
1418        case BSC_close:
1419        case BSC_read:
1420        case BSC_write:
1421        case BSC_fstat:
1422        case BSC_lstat:
1423        case BSC_link:
1424        case BSC_unlink:
1425        case BSC_mknod:
1426        case BSC_chmod:
1427        case BSC_chown:
1428        case BSC_access:
1429        case BSC_chflags:
1430        case BSC_fchflags:
1431        case BSC_sync:
1432        case BSC_symlink:
1433        case BSC_readlink:
1434        case BSC_fsync:
1435        case BSC_readv:
1436        case BSC_writev:
1437        case BSC_fchown:
1438        case BSC_fchmod:
1439        case BSC_rename:
1440        case BSC_mkdir:
1441        case BSC_rmdir:
1442        case BSC_statfs:
1443        case BSC_fstatfs:
1444        case BSC_pathconf:
1445        case BSC_fpathconf:
1446        case BSC_getdirentries:
1447        case BSC_lseek:
1448        case BSC_truncate:
1449        case BSC_ftruncate:
1450        case BSC_statv:
1451        case BSC_lstatv:
1452        case BSC_fstatv:
1453        case BSC_mkcomplex:
1454        case BSC_getattrlist:
1455        case BSC_setattrlist:
1456        case BSC_getdirentriesattr:
1457        case BSC_exchangedata:
1458        case BSC_checkuseraccess:
1459        case BSC_searchfs:
1460            case FILEMGR_PBGETCATALOGINFO:
1461            case FILEMGR_PBGETCATALOGINFOBULK:
1462            case FILEMGR_PBCREATEFILEUNICODE:
1463            case FILEMGR_PBCREATEDIRECTORYUNICODE:
1464            case FILEMGR_PBCREATEFORK:
1465            case FILEMGR_PBDELETEFORK:
1466            case FILEMGR_PBITERATEFORK:
1467            case FILEMGR_PBOPENFORK:
1468            case FILEMGR_PBREADFORK:
1469            case FILEMGR_PBWRITEFORK:
1470            case FILEMGR_PBALLOCATEFORK:
1471            case FILEMGR_PBDELETEOBJECT:
1472            case FILEMGR_PBEXCHANGEOBJECT:
1473            case FILEMGR_PBGETFORKCBINFO:
1474            case FILEMGR_PBGETVOLUMEINFO:
1475            case FILEMGR_PBMAKEFSREF:
1476            case FILEMGR_PBMAKEFSREFUNICODE:
1477            case FILEMGR_PBMOVEOBJECT:
1478            case FILEMGR_PBOPENITERATOR:
1479            case FILEMGR_PBRENAMEUNICODE:
1480            case FILEMGR_PBSETCATALOGINFO:
1481            case FILEMGR_PBSETVOLUMEINFO:
1482            case FILEMGR_FSREFMAKEPATH:
1483            case FILEMGR_FSPATHMAKEREF:
1484
1485            case FILEMGR_PBGETCATINFO:
1486            case FILEMGR_PBGETCATINFOLITE:
1487            case FILEMGR_PBHGETFINFO:
1488            case FILEMGR_PBXGETVOLINFO:
1489            case FILEMGR_PBHCREATE:
1490            case FILEMGR_PBHOPENDF:
1491            case FILEMGR_PBHOPENRF:
1492            case FILEMGR_PBHGETDIRACCESS:
1493            case FILEMGR_PBHSETDIRACCESS:
1494            case FILEMGR_PBHMAPID:
1495            case FILEMGR_PBHMAPNAME:
1496            case FILEMGR_PBCLOSE:
1497            case FILEMGR_PBFLUSHFILE:
1498            case FILEMGR_PBGETEOF:
1499            case FILEMGR_PBSETEOF:
1500            case FILEMGR_PBGETFPOS:
1501            case FILEMGR_PBREAD:
1502            case FILEMGR_PBWRITE:
1503            case FILEMGR_PBGETFCBINFO:
1504            case FILEMGR_PBSETFINFO:
1505            case FILEMGR_PBALLOCATE:
1506            case FILEMGR_PBALLOCCONTIG:
1507            case FILEMGR_PBSETFPOS:
1508            case FILEMGR_PBSETCATINFO:
1509            case FILEMGR_PBGETVOLPARMS:
1510            case FILEMGR_PBSETVINFO:
1511            case FILEMGR_PBMAKEFSSPEC:
1512            case FILEMGR_PBHGETVINFO:
1513            case FILEMGR_PBCREATEFILEIDREF:
1514            case FILEMGR_PBDELETEFILEIDREF:
1515            case FILEMGR_PBRESOLVEFILEIDREF:
1516            case FILEMGR_PBFLUSHVOL:
1517            case FILEMGR_PBHRENAME:
1518            case FILEMGR_PBCATMOVE:
1519            case FILEMGR_PBEXCHANGEFILES:
1520            case FILEMGR_PBHDELETE:
1521            case FILEMGR_PBDIRCREATE:
1522            case FILEMGR_PBCATSEARCH:
1523            case FILEMGR_PBHSETFLOCK:
1524            case FILEMGR_PBHRSTFLOCK:
1525            case FILEMGR_PBLOCKRANGE:
1526            case FILEMGR_PBUNLOCKRANGE:
1527
1528
1529            for (i = 0, ti = th_state; ti < &th_state[MAX_THREADS]; ti++, i++) {
1530                    if (ti->thread == 0)
1531                            break;
1532            }
1533            if (ti == &th_state[MAX_THREADS])
1534                    return;
1535            if (i >= cur_max)
1536                    cur_max = i + 1;
1537
1538            if ((type >> 24) == FILEMGR_CLASS) {
1539                    ti->in_filemgr = 1;
1540
1541                    l_usecs = (long long)(now / divisor);
1542                    secs = l_usecs / 1000000;
1543
1544                    if (bias_secs == 0) {
1545                            curr_time = time((long *)0);
1546                            bias_secs = curr_time - secs;
1547                    }
1548                    curr_time = bias_secs + secs;
1549                    printf("%-8.8s", &(ctime(&curr_time)[11]));
1550
1551                    if (COLS > 110 || wideflag) {
1552                            usecs = l_usecs - (long long)((long long)secs * 1000000);
1553                            printf(".%03ld", (long)usecs / 1000);
1554                    }
1555                    map = find_thread_map(thread);
1556                    if (map) {
1557                        char buf[128];
1558                        int  clen;
1559
1560                        sprintf(buf, "  %s", name);
1561                        clen = strlen(buf);
1562
1563                        if (clen > 25)
1564                            clen = 25;
1565                        memset(&buf[clen], ' ', 26 - clen);
1566
1567                        sprintf(&buf[25], "(%d, 0x%x, 0x%x, 0x%x)", (short)kd->arg1, kd->arg2, kd->arg3, kd->arg4);
1568                        clen = strlen(&buf[25]) + 25;
1569                        memset(&buf[clen], ' ', 128 - clen);
1570
1571                        if (COLS > 110 || wideflag)
1572                            sprintf(&buf[81], "%s\n", map->command);
1573                        else
1574                            sprintf(&buf[60], "%.12s\n", map->command);
1575
1576                        printf(buf);
1577
1578                    } else
1579                            printf("  %-24.24s (%5d, %#x, 0x%x, 0x%x)\n",         name, (short)kd->arg1, kd->arg2, kd->arg3, kd->arg4);
1580
1581            } else {
1582                            ti->in_filemgr = 0;
1583            }
1584            ti->thread = thread;
1585            ti->vfslookup = 0;
1586            ti->waited = 0;
1587            ti->type   = type;
1588            ti->stime  = now;
1589            ti->arg1   = kd->arg1;
1590            ti->arg2   = kd->arg2;
1591            ti->arg3   = kd->arg3;
1592            ti->arg4   = kd->arg4;
1593            ti->pathname[0] = 0;
1594
1595            break;
1596
1597        default:
1598            break;
1599        }
1600 }
1601
1602
1603 void
1604 exit_syscall(char *sc_name, int thread, int type, int error, int retval,
1605                             int has_fd, int has_ret, double now)
1606 {
1607        struct th_info *ti;
1608        int secs;
1609        int usecs;
1610        int nopadding;
1611        long long l_usecs;
1612        long curr_time;
1613        kd_threadmap *map;
1614        kd_threadmap *find_thread_map();
1615
1616        if ((ti = find_thread(thread, type)) == (struct th_info *)0)
1617                return;
1618        map = find_thread_map(thread);
1619        l_usecs = (long long)(now / divisor);
1620        secs = l_usecs / 1000000;
1621
1622        if (bias_secs == 0) {
1623                curr_time = time((long *)0);
1624                bias_secs = curr_time - secs;
1625        }
1626        curr_time = bias_secs + secs;
1627        printf("%-8.8s", &(ctime(&curr_time)[11]));
1628
1629
1630        if (COLS > 110 || wideflag) {
1631                nopadding = 0;
1632                usecs = l_usecs - (long long)((long long)secs * 1000000);
1633                printf(".%03ld", (long)usecs / 1000);
1634
1635                if ((type >> 24) != FILEMGR_CLASS) {
1636                    if (find_thread(thread, -1)) {
1637                        printf("   ");
1638                        nopadding = 1;
1639                    }
1640                }
1641        } else
1642                nopadding = 1;
1643
1644        if (((type >> 24) == FILEMGR_CLASS) && (COLS > 110 || wideflag))
1645                printf("  %-18.18s", sc_name);
1646        else
1647                printf("  %-15.15s", sc_name);
1648
1649        if (COLS > 110 || wideflag) {
1650                if (has_fd == 2 && error == 0)
1651                        printf(" F=%-3d", retval);
1652                else if (has_fd == 1)
1653                        printf(" F=%-3d", ti->arg1);
1654                else if (has_ret != 2)
1655                        printf("      ");
1656
1657                if (error)
1658                        printf("[%3d]       ", error);
1659                else if (has_ret == 3)
1660                        printf("O=0x%8.8x", ti->arg3);
1661                else if (has_ret == 5)
1662                        printf("O=0x%8.8x", retval);
1663                else if (has_ret == 2)
1664                        printf(" A=0x%8.8x     ", retval);
1665                else if (has_ret == 1)
1666                        printf("  B=0x%-6x", retval);
1667                else if (has_ret == 4)
1668                        printf("R=0x%-8x", retval);
1669                else
1670                        printf("            ");
1671        }
1672        printf(" %-28.28s ",  ti->pathname);
1673
1674        usecs = (unsigned long)(((double)now - ti->stime) / divisor);
1675        secs = usecs / 1000000;
1676        usecs -= secs * 1000000;
1677
1678        if ((type >> 24) != FILEMGR_CLASS && !nopadding)
1679                printf("   ");
1680
1681        printf(" %2ld.%06ld", (long)secs, (long)usecs);
1682        if (ti->waited)
1683                printf(" W");
1684        else
1685                printf("  ");
1686
1687        if (map) {
1688                if (COLS > 110 || wideflag)
1689                        printf(" %s", map->command);
1690                else
1691                        printf(" %.12s", map->command);
1692        }
1693        printf("\n");
1694
1695        if (ti == &th_state[cur_max - 1])
1696                  cur_max--;
1697        ti->thread = 0;
1698 }
1699
1700 int
1701 quit(s)
1702 char *s;
1703 {
1704         if (trace_enabled)
1705                set_enable(0);
1706
1707         /*
1708            This flag is turned off when calling
1709            quit() due to a set_remove() failure.
1710         */
1711         if (set_remove_flag)
1712                 set_remove();
1713
1714         printf("fs_usage: ");
1715         if (s)
1716                 printf("%s", s);
1717
1718         exit(1);
1719 }
1720
1721
1722 void getdivisor()
1723 {
1724
1725     unsigned int delta;
1726     unsigned int abs_to_ns_num;
1727     unsigned int abs_to_ns_denom;
1728     unsigned int proc_to_abs_num;
1729     unsigned int proc_to_abs_denom;
1730
1731         extern void MKGetTimeBaseInfo(unsigned int *, unsigned int *, unsigned int *, unsigned int *, unsigned int *);
1732
1733     MKGetTimeBaseInfo (&delta, &abs_to_ns_num, &abs_to_ns_denom,
1734                        &proc_to_abs_num,  &proc_to_abs_denom);
1735
1736     divisor = ((double)abs_to_ns_denom / (double)abs_to_ns_num) * 1000;
1737 }
1738
1739
1740 void read_command_map()
1741 {
1742     size_t size;
1743     int mib[6];
1744
1745     if (mapptr) {
1746         free(mapptr);
1747         mapptr = 0;
1748     }
1749     total_threads = bufinfo.nkdthreads;
1750     size = bufinfo.nkdthreads * sizeof(kd_threadmap);
1751
1752     if (size)
1753     {
1754         if (mapptr = (kd_threadmap *) malloc(size))
1755              bzero (mapptr, size);
1756         else
1757         {
1758             printf("Thread map is not initialized -- this is not fatal\n");
1759             return;
1760         }
1761     }
1762
1763     /* Now read the threadmap */
1764     mib[0] = CTL_KERN;
1765     mib[1] = KERN_KDEBUG;
1766     mib[2] = KERN_KDTHRMAP;
1767     mib[3] = 0;
1768     mib[4] = 0;
1769     mib[5] = 0;         /* no flags */
1770     if (sysctl(mib, 3, mapptr, &size, NULL, 0) < 0)
1771     {
1772         /* This is not fatal -- just means I cant map command strings */
1773
1774         printf("Can't read the thread map -- this is not fatal\n");
1775         free(mapptr);
1776         mapptr = 0;
1777         return;
1778     }
1779     return;
1780 }
1781
1782
1783 void create_map_entry(int thread, char *command)
1784 {
1785     int i, n;
1786     kd_threadmap *map;
1787
1788     if (!mapptr)
1789         return;
1790
1791     for (i = 0, map = 0; !map && i < total_threads; i++)
1792     {
1793         if (mapptr[i].thread == thread )
1794             map = &mapptr[i];   /* Reuse this entry, the thread has been reassigned */
1795     }
1796
1797     if (!map)   /* look for invalid entries that I can reuse*/
1798     {
1799         for (i = 0, map = 0; !map && i < total_threads; i++)
1800         {
1801             if (mapptr[i].valid == 0 )
1802                 map = &mapptr[i];   /* Reuse this invalid entry */
1803         }
1804     }
1805
1806     if (!map)
1807     {
1808         /* If reach here, then this is a new thread and
1809          * there are no invalid entries to reuse
1810          * Double the size of the thread map table.
1811          */
1812
1813         n = total_threads * 2;
1814         mapptr = (kd_threadmap *) realloc(mapptr, n * sizeof(kd_threadmap));
1815         bzero(&mapptr[total_threads], total_threads*sizeof(kd_threadmap));
1816         map = &mapptr[total_threads];
1817         total_threads = n;
1818     }
1819
1820     map->valid = 1;
1821     map->thread = thread;
1822     (void)strncpy (map->command, command, sizeof(map->command));
1823     map->command[sizeof(map->command)-1] = '\0';
1824 }
1825
1826
1827 kd_threadmap *find_thread_map(int thread)
1828 {
1829     int i;
1830     kd_threadmap *map;
1831
1832     if (!mapptr)
1833         return((kd_threadmap *)0);
1834
1835     for (i = 0; i < total_threads; i++)
1836     {
1837         map = &mapptr[i];
1838         if (map->valid && (map->thread == thread))
1839         {
1840             return(map);
1841         }
1842     }
1843     return ((kd_threadmap *)0);
1844 }
1845
1846
1847 void
1848 kill_thread_map(int thread)
1849 {
1850     kd_threadmap *map;
1851
1852     if (map = find_thread_map(thread)) {
1853         map->valid = 0;
1854         map->thread = 0;
1855         map->command[0] = '\0';
1856     }
1857 }
1858
1859 void
1860 argtopid(str)
1861         char *str;
1862 {
1863         char *cp;
1864         int ret;
1865         int i;
1866
1867         ret = (int)strtol(str, &cp, 10);
1868         if (cp == str || *cp) {
1869           /* Assume this is a command string and find matching pids */
1870                 if (!kp_buffer)
1871                         find_proc_names();
1872
1873                 for (i=0; i < kp_nentries && num_of_pids < (MAX_PIDS - 1); i++) {
1874                       if(kp_buffer[i].kp_proc.p_stat == 0)
1875                           continue;
1876                       else {
1877                           if(!strcmp(str, kp_buffer[i].kp_proc.p_comm))
1878                             pids[num_of_pids++] = kp_buffer[i].kp_proc.p_pid;
1879                       }
1880                 }
1881         }
1882         else if (num_of_pids < (MAX_PIDS - 1))
1883                 pids[num_of_pids++] = ret;
1884
1885         return;
1886 }
1887
1888