usr.bin/kcollect/kcollect.c

   1 /*
   2  * Copyright (c) 2017 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@backplane.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  21  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  22  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  24  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  26  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  27  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  28  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include "kcollect.h"
  33
  34 #include <ndbm.h>
  35 #include <fcntl.h>
  36 #include <errno.h>
  37
  38 #define SLEEP_INTERVAL  60      /* minimum is KCOLLECT_INTERVAL */
  39
  40 #define DISPLAY_TIME_ONLY "%H:%M:%S"
  41 #define DISPLAY_FULL_DATE "%F %H:%M:%S"
  42 #define HDR_FMT "HEADER0"
  43 #define HDR_TITLE "HEADER1"
  44
  45 static void format_output(uintmax_t value,char fmt,uintmax_t scale, char* ret);
  46 static void dump_text(kcollect_t *ary, size_t count,
  47                         size_t total_count, const char* display_fmt);
  48 static void dump_dbm(kcollect_t *ary, size_t count, const char *datafile);
  49 static int str2unix(const char* str, const char* fmt);
  50 static int rec_comparator(const void *c1, const void *c2);
  51 static void load_dbm(const char *datafile,
  52                         kcollect_t **ret_ary, size_t *counter);
  53 static void dump_fields(kcollect_t *ary);
  54 static void adjust_fields(kcollect_t *ent, const char *fields);
  55 static void restore_headers(kcollect_t *ary, const char *datafile);
  56
  57 FILE *OutFP;
  58 int UseGMT;
  59 int OutputWidth = 1024;
  60 int OutputHeight = 1024;
  61 int SmoothOpt;
  62 int LoadedFromDB = 0;
  63
  64 int
  65 main(int ac, char **av)
  66 {
  67         kcollect_t *ary;
  68         size_t bytes = 0;
  69         size_t count;
  70         size_t total_count;
  71         const char *datafile = NULL;
  72         const char *fields = NULL;
  73         int cmd = 't';
  74         int ch;
  75         int keepalive = 0;
  76         int last_ticks;
  77         int loops = 0;
  78         int maxtime = 0;
  79
  80         kcollect_t *dbmAry = NULL;
  81         const char *dbmFile = NULL;
  82         int fromFile = 0;
  83
  84         OutFP = stdout;
  85
  86         sysctlbyname("kern.collect_data", NULL, &bytes, NULL, 0);
  87         if (bytes == 0) {
  88                 fprintf(stderr, "kern.collect_data not available\n");
  89                 exit(1);
  90         }
  91
  92         while ((ch = getopt(ac, av, "o:b:d:r:flsgt:xw:GW:H:")) != -1) {
  93                 char *suffix;
  94
  95                 switch(ch) {
  96                 case 'o':
  97                         fields = optarg;
  98                         break;
  99                 case 'b':
 100                         datafile = optarg;
 101                         cmd = 'b';
 102                         break;
 103                 case 'd':
 104                         dbmFile = optarg;
 105                         fromFile = 1;
 106                         break;
 107                 case 'r':
 108                         datafile = optarg;
 109                         cmd = 'r';
 110                         break;
 111                 case 'f':
 112                         keepalive = 1;
 113                         break;
 114                 case 'l':
 115                         cmd = 'l';
 116                         break;
 117                 case 's':
 118                         SmoothOpt = 1;
 119                         break;
 120                 case 'w':
 121                         datafile = optarg;
 122                         cmd = 'w';
 123                         break;
 124                 case 'g':
 125                         cmd = 'g';
 126                         break;
 127                 case 'x':
 128                         cmd = 'x';
 129                         break;
 130                 case 't':
 131                         maxtime = strtol(optarg, &suffix, 0);
 132                         switch(*suffix) {
 133                         case 'd':
 134                                 maxtime *= 24;
 135                                 /* fall through */
 136                         case 'h':
 137                                 maxtime *= 60;
 138                                 /* fall through */
 139                         case 'm':
 140                                 maxtime *= 60;
 141                                 break;
 142                         case 0:
 143                                 break;
 144                         default:
 145                                 fprintf(stderr,
 146                                         "Illegal suffix in -t option\n");
 147                                 exit(1);
 148                         }
 149                         break;
 150                 case 'G':
 151                         UseGMT = 1;
 152                         break;
 153                 case 'W':
 154                         OutputWidth = strtol(optarg, NULL, 0);
 155                         break;
 156                 case 'H':
 157                         OutputHeight = strtol(optarg, NULL, 0);
 158                         break;
 159                 default:
 160                         fprintf(stderr, "Unknown option %c\n", ch);
 161                         exit(1);
 162                         /* NOT REACHED */
 163                 }
 164         }
 165         if (cmd != 'x' && ac != optind) {
 166                 fprintf(stderr, "Unknown argument %s\n", av[optind]);
 167                 exit(1);
 168                 /* NOT REACHED */
 169         }
 170
 171         total_count = 0;
 172         last_ticks = 0;
 173
 174         if (cmd == 'x' || cmd == 'w')
 175                 start_gnuplot(ac - optind, av + optind, datafile);
 176
 177         do {
 178                 /*
 179                  * Snarf as much data as we can.  If we are looping,
 180                  * snarf less (no point snarfing stuff we already have).
 181                  */
 182                 bytes = 0;
 183                 sysctlbyname("kern.collect_data", NULL, &bytes, NULL, 0);
 184                 if (cmd == 'l')
 185                         bytes = sizeof(kcollect_t) * 2;
 186
 187                 if (loops) {
 188                         size_t loop_bytes;
 189
 190                         loop_bytes = sizeof(kcollect_t) *
 191                                      (4 + SLEEP_INTERVAL / KCOLLECT_INTERVAL);
 192                         if (bytes > loop_bytes)
 193                                 bytes = loop_bytes;
 194                 }
 195
 196                 ary = malloc(bytes);
 197                 sysctlbyname("kern.collect_data", ary, &bytes, NULL, 0);
 198                 count = bytes / sizeof(kcollect_t);
 199
 200                 /*
 201                  * If we got specified a file to load from: replace the data
 202                  * array and counter
 203                  */
 204                 if (fromFile) {
 205                         load_dbm(dbmFile, &dbmAry, &count);
 206                         free(ary);
 207                         ary = dbmAry;
 208
 209                 }
 210                 if (fields)
 211                         adjust_fields(&ary[1], fields);
 212
 213
 214                 /*
 215                  * Delete duplicate entries when looping
 216                  */
 217                 if (loops) {
 218                         while (count > 2) {
 219                                 if ((int)(ary[count-1].ticks - last_ticks) > 0)
 220                                         break;
 221                                 --count;
 222                         }
 223                 }
 224
 225                 /*
 226                  * Delete any entries beyond the time limit
 227                  */
 228                 if (maxtime) {
 229                         maxtime *= ary[0].hz;
 230                         while (count > 2) {
 231                                 if ((int)(ary[0].ticks - ary[count-1].ticks) <
 232                                     maxtime) {
 233                                         break;
 234                                 }
 235                                 --count;
 236                         }
 237                 }
 238
 239                 switch(cmd) {
 240                 case 't':
 241                         if (count > 2) {
 242                                 dump_text(ary, count, total_count,
 243                                           (fromFile ? DISPLAY_FULL_DATE :
 244                                                       DISPLAY_TIME_ONLY));
 245                         }
 246                         break;
 247                 case 'b':
 248                         if (count > 2)
 249                                 dump_dbm(ary, count, datafile);
 250                         break;
 251                 case 'r':
 252                         if (count >= 2)
 253                                 restore_headers(ary, datafile);
 254                         break;
 255                 case 'l':
 256                         dump_fields(ary);
 257                         exit(0);
 258                         break;          /* NOT REACHED */
 259                 case 'g':
 260                         if (count > 2)
 261                                 dump_gnuplot(ary, count);
 262                         break;
 263                 case 'w':
 264                         if (count >= 2)
 265                                 dump_gnuplot(ary, count);
 266                         break;
 267                 case 'x':
 268                         if (count > 2)
 269                                 dump_gnuplot(ary, count);
 270                         break;
 271                 }
 272                 if (keepalive && !fromFile) {
 273                         fflush(OutFP);
 274                         fflush(stdout);
 275                         switch(cmd) {
 276                         case 't':
 277                                 sleep(1);
 278                                 break;
 279                         case 'x':
 280                         case 'g':
 281                         case 'w':
 282                                 sleep(60);
 283                                 break;
 284                         default:
 285                                 sleep(10);
 286                                 break;
 287                         }
 288                 }
 289                 last_ticks = ary[2].ticks;
 290                 if (count >= 2)
 291                         total_count += count - 2;
 292
 293                 /*
 294                  * Loop for incremental aquisition.  When outputting to
 295                  * gunplot, we have to send the whole data-set again so
 296                  * do not increment loops in that case.
 297                  */
 298                 if (cmd != 'g' && cmd != 'x' && cmd != 'w')
 299                         ++loops;
 300
 301                 free(ary);
 302         } while (keepalive);
 303
 304         if (cmd == 'x')
 305                 pclose(OutFP);
 306 }
 307
 308 static
 309 void
 310 format_output(uintmax_t value,char fmt,uintmax_t scale, char* ret)
 311 {
 312         char buf[9];
 313
 314         switch(fmt) {
 315         case '2':
 316                 /*
 317                  * fractional x100
 318                  */
 319                 sprintf(ret, "%5ju.%02ju",
 320                         value / 100, value % 100);
 321                 break;
 322         case 'p':
 323                 /*
 324                  * Percentage fractional x100 (100% = 10000)
 325                  */
 326                 sprintf(ret,"%4ju.%02ju%%",
 327                         value / 100, value % 100);
 328                 break;
 329         case 'm':
 330                 /*
 331                  * Megabytes
 332                  */
 333                 humanize_number(buf, sizeof(buf), value, "",
 334                                 2,
 335                                 HN_FRACTIONAL |
 336                                 HN_NOSPACE);
 337                 sprintf(ret,"%8.8s", buf);
 338                 break;
 339         case 'c':
 340                 /*
 341                  * Raw count over period (this is not total)
 342                  */
 343                 humanize_number(buf, sizeof(buf), value, "",
 344                                 HN_AUTOSCALE,
 345                                 HN_FRACTIONAL |
 346                                 HN_NOSPACE |
 347                                 HN_DIVISOR_1000);
 348                 sprintf(ret,"%8.8s", buf);
 349                 break;
 350         case 'b':
 351                 /*
 352                  * Total bytes (this is a total), output
 353                  * in megabytes.
 354                  */
 355                 if (scale > 100000000) {
 356                         humanize_number(buf, sizeof(buf),
 357                                         value, "",
 358                                         3,
 359                                         HN_FRACTIONAL |
 360                                         HN_NOSPACE);
 361                 } else {
 362                         humanize_number(buf, sizeof(buf),
 363                                         value, "",
 364                                         2,
 365                                         HN_FRACTIONAL |
 366                                         HN_NOSPACE);
 367                 }
 368                 sprintf(ret,"%8.8s", buf);
 369                 break;
 370         default:
 371                 sprintf(ret,"%s","        ");
 372                 break;
 373         }
 374 }
 375
 376 static
 377 void
 378 dump_text(kcollect_t *ary, size_t count, size_t total_count,
 379           const char* display_fmt)
 380 {
 381         int j;
 382         int i;
 383         uintmax_t scale;
 384         uintmax_t value;
 385         char fmt;
 386         char sbuf[20];
 387         struct tm *tmv;
 388         time_t t;
 389
 390         for (i = count - 1; i >= 2; --i) {
 391                 if ((total_count & 15) == 0) {
 392                         if (!strcmp(display_fmt, DISPLAY_FULL_DATE)) {
 393                                 printf("%20s", "timestamp ");
 394                         } else {
 395                                 printf("%8.8s", "time");
 396                         }
 397                         for (j = 0; j < KCOLLECT_ENTRIES; ++j) {
 398                                 if (ary[1].data[j]) {
 399                                         printf(" %8.8s",
 400                                                 (char *)&ary[1].data[j]);
 401                                 }
 402                         }
 403                         printf("\n");
 404                 }
 405
 406                 /*
 407                  * Timestamp
 408                  */
 409                 t = ary[i].realtime.tv_sec;
 410                 if (UseGMT)
 411                         tmv = gmtime(&t);
 412                 else
 413                         tmv = localtime(&t);
 414                 strftime(sbuf, sizeof(sbuf), display_fmt, tmv);
 415                 printf("%8s", sbuf);
 416
 417                 for (j = 0; j < KCOLLECT_ENTRIES; ++j) {
 418                         if (ary[1].data[j] == 0)
 419                                 continue;
 420
 421                         /*
 422                          * NOTE: kernel does not have to provide the scale
 423                          *       (that is, the highest likely value), nor
 424                          *       does it make sense in all cases.
 425                          *
 426                          *       Example scale - kernel provides total amount
 427                          *       of memory available for memory related
 428                          *       statistics in the scale field.
 429                          */
 430                         value = ary[i].data[j];
 431                         scale = KCOLLECT_GETSCALE(ary[0].data[j]);
 432                         fmt = KCOLLECT_GETFMT(ary[0].data[j]);
 433
 434                         printf(" ");
 435
 436                         format_output(value, fmt, scale, sbuf);
 437                         printf("%s",sbuf);
 438                 }
 439
 440                 printf("\n");
 441                 ++total_count;
 442         }
 443 }
 444
 445 /* restores the DBM database header records to current machine */
 446 static
 447 void
 448 restore_headers(kcollect_t *ary, const char *datafile)
 449 {
 450         DBM *db;
 451         char hdr_fmt[] = HDR_FMT;
 452         char hdr_title[] = HDR_TITLE;
 453         datum key, value;
 454
 455         db = dbm_open(datafile, (O_RDWR),
 456                       (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP));
 457
 458         if (db == NULL) {
 459                 switch (errno) {
 460                 case EACCES:
 461                         fprintf(stderr,
 462                                 "[ERR] database file \"%s\" is read-only, "
 463                                 "check permissions. (%i)\n",
 464                                 datafile, errno);
 465                         break;
 466                 default:
 467                         fprintf(stderr,
 468                                 "[ERR] opening our database file \"%s\" "
 469                                 "produced an error. (%i)\n",
 470                                 datafile, errno);
 471                 }
 472                 exit(EXIT_FAILURE);
 473         } else {
 474                 key.dptr = hdr_fmt;
 475                 key.dsize = sizeof(HDR_FMT);
 476                 value.dptr = &ary[0].data;
 477                 value.dsize = sizeof(uint64_t) * KCOLLECT_ENTRIES;
 478                 if (dbm_store(db,key,value,DBM_REPLACE) == -1) {
 479                         fprintf(stderr,
 480                                 "[ERR] error storing the value in "
 481                                 "the database file \"%s\" (%i)\n",
 482                                 datafile, errno);
 483                         dbm_close(db);
 484                         exit(EXIT_FAILURE);
 485                 }
 486
 487                 key.dptr = hdr_title;
 488                 key.dsize = sizeof(HDR_FMT);
 489                 value.dptr = &ary[1].data;
 490                 value.dsize = sizeof(uint64_t) * KCOLLECT_ENTRIES;
 491                 if (dbm_store(db,key,value,DBM_REPLACE) == -1) {
 492                         fprintf(stderr,
 493                                 "[ERR] error storing the value in "
 494                                 "the database file \"%s\" (%i)\n",
 495                                 datafile, errno);
 496                         dbm_close(db);
 497                         exit(EXIT_FAILURE);
 498                 }
 499         }
 500         dbm_close(db);
 501 }
 502
 503
 504 /*
 505  * Store the array of kcollect_t records in a dbm db database,
 506  * path passed in datafile
 507  */
 508 static
 509 void
 510 dump_dbm(kcollect_t *ary, size_t count, const char *datafile)
 511 {
 512         DBM * db;
 513
 514         db = dbm_open(datafile, (O_RDWR | O_CREAT),
 515                       (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP));
 516         if (db == NULL) {
 517                 switch (errno) {
 518                 case EACCES:
 519                         fprintf(stderr,
 520                                 "[ERR] database file \"%s\" is read-only, "
 521                                 "check permissions. (%i)\n",
 522                                 datafile, errno);
 523                         break;
 524                 default:
 525                         fprintf(stderr,
 526                                 "[ERR] opening our database file \"%s\" "
 527                                 "produced an error. (%i)\n",
 528                                 datafile, errno);
 529                 }
 530                 exit(EXIT_FAILURE);
 531         } else {
 532                 struct tm *tmv;
 533                 char buf[20];
 534                 datum key;
 535                 datum value;
 536                 time_t t;
 537                 uint i;
 538                 char hdr_fmt[] = HDR_FMT;
 539                 char hdr_title[] = HDR_TITLE;
 540
 541                 for (i = 0; i < (count); ++i) {
 542                         /* first 2 INFO records are special and get 0|1 */
 543
 544                         if (i < 2) {
 545                                 if (i == 0)
 546                                         key.dptr = hdr_fmt;
 547                                 else
 548                                         key.dptr = hdr_title;
 549                                 key.dsize = sizeof(HDR_FMT);
 550                         } else {
 551                                 t = ary[i].realtime.tv_sec;
 552                                 if (LoadedFromDB)
 553                                         tmv = localtime(&t);
 554                                 else
 555                                         tmv = gmtime(&t);
 556                                 strftime(buf, sizeof(buf),
 557                                          DISPLAY_FULL_DATE, tmv);
 558                                 key.dptr = buf;
 559                                 key.dsize = sizeof(buf);
 560                         }
 561                         value.dptr = ary[i].data;
 562                         value.dsize = sizeof(uint64_t) * KCOLLECT_ENTRIES;
 563                         if (dbm_store(db, key, value, DBM_INSERT) == -1) {
 564                                 fprintf(stderr,
 565                                         "[ERR] error storing the value in "
 566                                         "the database file \"%s\" (%i)\n",
 567                                         datafile, errno);
 568                                 dbm_close(db);
 569                                 exit(EXIT_FAILURE);
 570                         }
 571
 572                 }
 573                 dbm_close(db);
 574         }
 575 }
 576
 577 /*
 578  * Transform a string (str) matching a format string (fmt) into a unix
 579  * timestamp and return it used by load_dbm()
 580  */
 581 static
 582 int
 583 str2unix(const char* str, const char* fmt){
 584         struct tm tm;
 585         time_t ts;
 586
 587         /*
 588          * Reset all the fields because strptime only sets what it
 589          * finds, which may lead to undefined members
 590          */
 591         memset(&tm, 0, sizeof(struct tm));
 592         strptime(str, fmt, &tm);
 593         ts = timegm(&tm);
 594
 595         return (int)ts;
 596 }
 597
 598 /*
 599  * Sorts the ckollect_t records by time, to put youngest first,
 600  * so desc by timestamp used by load_dbm()
 601  */
 602 static
 603 int
 604 rec_comparator(const void *c1, const void *c2)
 605 {
 606         const kcollect_t *k1 = (const kcollect_t*)c1;
 607         const kcollect_t *k2 = (const kcollect_t*)c2;
 608
 609         if (k1->realtime.tv_sec < k2->realtime.tv_sec)
 610                 return -1;
 611         if (k1->realtime.tv_sec > k2->realtime.tv_sec)
 612                 return 1;
 613         return 0;
 614 }
 615
 616 /*
 617  * Loads the ckollect records from a dbm DB database specified in datafile.
 618  * returns the resulting array in ret_ary and the array counter in counter
 619  */
 620 static
 621 void
 622 load_dbm(const char* datafile, kcollect_t **ret_ary,
 623          size_t *counter)
 624 {
 625         DBM * db = dbm_open(datafile,(O_RDONLY),(S_IRUSR|S_IRGRP));
 626         datum key;
 627         datum value;
 628         size_t recCounter = 0;
 629         int headersFound = 0;
 630
 631         if (db == NULL) {
 632                 fprintf(stderr,
 633                         "[ERR] opening our database \"%s\" produced "
 634                         "an error! (%i)\n",
 635                         datafile, errno);
 636                 exit(EXIT_FAILURE);
 637         } else {
 638                 /* counting loop */
 639                 for (key = dbm_firstkey(db); key.dptr; key = dbm_nextkey(db)) {
 640                         value = dbm_fetch(db, key);
 641                         if (value.dptr != NULL)
 642                                 recCounter++;
 643                 }
 644
 645                 /* with the count allocate enough memory */
 646                 if (*ret_ary)
 647                         free(*ret_ary);
 648                 *ret_ary = malloc(sizeof(kcollect_t) * recCounter);
 649                 bzero(*ret_ary, sizeof(kcollect_t) * recCounter);
 650                 if (*ret_ary == NULL) {
 651                         fprintf(stderr,
 652                                 "[ERR] failed to allocate enough memory to "
 653                                 "hold the database! Aborting.\n");
 654                         dbm_close(db);
 655                         exit(EXIT_FAILURE);
 656                 } else {
 657                         uint c;
 658                         uint sc;
 659                         /*
 660                          * Actual data retrieval  but only of recCounter
 661                          * records
 662                          */
 663                         c = 2;
 664                         key = dbm_firstkey(db);
 665                         while (key.dptr && c < recCounter) {
 666                                 value = dbm_fetch(db, key);
 667                                 if (value.dptr != NULL) {
 668                                         if (!strcmp(key.dptr, HDR_FMT)) {
 669                                                 sc = 0;
 670                                                 headersFound |= 1;
 671                                         }
 672                                         else if (!strcmp(key.dptr, HDR_TITLE)) {
 673                                                 sc = 1;
 674                                                 headersFound |= 2;
 675                                         }
 676                                         else {
 677                                                 sc = c;
 678                                                 c++;
 679                                         }
 680
 681                                         memcpy((*ret_ary)[sc].data,
 682                                                value.dptr,
 683                                            sizeof(uint64_t) * KCOLLECT_ENTRIES);
 684                                         (*ret_ary)[sc].realtime.tv_sec =
 685                                             str2unix(key.dptr,
 686                                                      DISPLAY_FULL_DATE);
 687                                 }
 688                                 key = dbm_nextkey(db);
 689                         }
 690                 }
 691         }
 692
 693         /*
 694          * Set the counter,
 695          * and sort the non-header records.
 696          */
 697         *counter = recCounter;
 698         qsort(&(*ret_ary)[2], recCounter - 2, sizeof(kcollect_t), rec_comparator);
 699         dbm_close(db);
 700
 701         if (headersFound != 3) {
 702                 fprintf(stderr, "We could not retrieve all necessary headers, might be the database file is corrupted? (%i)\n", headersFound);
 703                 exit(EXIT_FAILURE);
 704         }
 705         LoadedFromDB = 1;
 706 }
 707
 708 static void
 709 dump_fields(kcollect_t *ary)
 710 {
 711         int j;
 712
 713         for (j = 0; j < KCOLLECT_ENTRIES; ++j) {
 714                 if (ary[1].data[j] == 0)
 715                         continue;
 716                 printf("%8.8s %c\n",
 717                        (char *)&ary[1].data[j],
 718                        KCOLLECT_GETFMT(ary[0].data[j]));
 719         }
 720 }
 721
 722 static void
 723 adjust_fields(kcollect_t *ent, const char *fields)
 724 {
 725         char *copy = strdup(fields);
 726         char *word;
 727         int selected[KCOLLECT_ENTRIES];
 728         int j;
 729
 730         bzero(selected, sizeof(selected));
 731
 732         word = strtok(copy, ", \t");
 733         while (word) {
 734                 for (j = 0; j < KCOLLECT_ENTRIES; ++j) {
 735                         if (strncmp(word, (char *)&ent->data[j], 8) == 0) {
 736                                 selected[j] = 1;
 737                                 break;
 738                         }
 739                 }
 740                 word = strtok(NULL, ", \t");
 741         }
 742         free(copy);
 743         for (j = 0; j < KCOLLECT_ENTRIES; ++j) {
 744                 if (!selected[j])
 745                         ent->data[j] = 0;
 746         }
 747 }