1 /* 2 * Copyright (c) 2017-2019 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 #define DATA_BASE_INDEX 8 /* up to 8 headers */ 40 41 #define DISPLAY_TIME_ONLY "%H:%M:%S" 42 #define DISPLAY_FULL_DATE "%F %H:%M:%S" 43 #define HDR_BASE "HEADER" 44 #define HDR_STRLEN 6 45 46 #define HDR_FMT_INDEX 0 47 #define HDR_FMT_TITLE 1 48 #define HDR_FMT_HOST 2 49 50 #define HOST_NAME_MAX sysconf(_SC_HOST_NAME_MAX) 51 52 static void format_output(uintmax_t, char, uintmax_t, char *); 53 static void dump_text(kcollect_t *, size_t, size_t, const char *); 54 static const char *get_influx_series(const char *); 55 static void dump_influxdb(kcollect_t *, size_t, size_t, const char *); 56 57 static void (*dumpfn)(kcollect_t *, size_t, size_t, const char *); 58 59 static void dump_dbm(kcollect_t *, size_t, const char *); 60 static void load_dbm(const char *datafile, kcollect_t **, size_t *); 61 static int rec_comparator(const void *, const void *); 62 static void dump_fields(kcollect_t *); 63 static void adjust_fields(kcollect_t *, const char *); 64 static void restore_headers(kcollect_t *, const char *); 65 static int str2unix(const char *, const char*); 66 static kcollect_t *load_kernel(kcollect_t *, kcollect_t *, size_t *); 67 68 FILE *OutFP; 69 int UseGMT; 70 int OutputWidth = 1024; 71 int OutputHeight = 1024; 72 int SmoothOpt; 73 static int LoadedFromDB; 74 static int HostnameMismatch; 75 static int Fflag; 76 77 int 78 main(int ac, char **av) 79 { 80 kcollect_t *ary_base; 81 kcollect_t *ary; 82 size_t bytes = 0; 83 size_t count; 84 size_t total_count; 85 const char *datafile = NULL; 86 const char *fields = NULL; 87 int cmd = 't'; 88 int ch; 89 int keepalive = 0; 90 int last_ticks; 91 int loops = 0; 92 int maxtime = 0; 93 const char *dbmFile = NULL; 94 int fromFile = 0; 95 96 OutFP = stdout; 97 dumpfn = dump_text; 98 99 sysctlbyname("kern.collect_data", NULL, &bytes, NULL, 0); 100 if (bytes == 0) { 101 fprintf(stderr, "kern.collect_data not available\n"); 102 exit(1); 103 } 104 105 while ((ch = getopt(ac, av, "o:O:b:d:r:fFlsgt:xw:GW:H:")) != -1) { 106 char *suffix; 107 108 switch(ch) { 109 case 'o': 110 fields = optarg; 111 break; 112 case 'O': 113 if ((strncasecmp("influxdb", optarg, 16) == 0)) { 114 dumpfn = dump_influxdb; 115 } else if (strncasecmp("text", optarg, 16) == 0) { 116 dumpfn = dump_text; 117 } else { 118 fprintf(stderr, "Bad output text format %s\n", optarg); 119 exit(1); 120 } 121 break; 122 case 'b': 123 datafile = optarg; 124 cmd = 'b'; 125 break; 126 case 'd': 127 dbmFile = optarg; 128 fromFile = 1; 129 break; 130 case 'r': 131 datafile = optarg; 132 cmd = 'r'; 133 break; 134 case 'f': 135 keepalive = 1; 136 break; 137 case 'F': 138 Fflag = 1; 139 keepalive = 1; 140 break; 141 case 'l': 142 cmd = 'l'; 143 break; 144 case 's': 145 SmoothOpt = 1; 146 break; 147 case 'w': 148 datafile = optarg; 149 cmd = 'w'; 150 break; 151 case 'g': 152 cmd = 'g'; 153 break; 154 case 'x': 155 cmd = 'x'; 156 break; 157 case 't': 158 maxtime = strtol(optarg, &suffix, 0); 159 switch(*suffix) { 160 case 'd': 161 maxtime *= 24; 162 /* fall through */ 163 case 'h': 164 maxtime *= 60; 165 /* fall through */ 166 case 'm': 167 maxtime *= 60; 168 break; 169 case 0: 170 break; 171 default: 172 fprintf(stderr, 173 "Illegal suffix in -t option\n"); 174 exit(1); 175 } 176 break; 177 case 'G': 178 UseGMT = 1; 179 break; 180 case 'W': 181 OutputWidth = strtol(optarg, NULL, 0); 182 break; 183 case 'H': 184 OutputHeight = strtol(optarg, NULL, 0); 185 break; 186 default: 187 fprintf(stderr, "Unknown option %c\n", ch); 188 exit(1); 189 /* NOT REACHED */ 190 } 191 } 192 if (cmd != 'x' && ac != optind) { 193 fprintf(stderr, "Unknown argument %s\n", av[optind]); 194 exit(1); 195 /* NOT REACHED */ 196 } 197 198 total_count = 0; 199 last_ticks = 0; 200 201 if (cmd == 'x' || cmd == 'w') 202 start_gnuplot(ac - optind, av + optind, datafile); 203 204 do { 205 /* 206 * We do not allow keepalive if there is a hostname 207 * mismatch, there is no point in showing data for the 208 * current host after dumping the data from another one. 209 */ 210 if (HostnameMismatch) { 211 fprintf(stderr, 212 "Hostname mismatch, can't show live data\n"); 213 exit(1); 214 } 215 216 /* 217 * Snarf as much data as we can. If we are looping, 218 * snarf less (no point snarfing stuff we already have). 219 */ 220 bytes = 0; 221 sysctlbyname("kern.collect_data", NULL, &bytes, NULL, 0); 222 if (cmd == 'l') 223 bytes = sizeof(kcollect_t) * 2; 224 225 /* Skip to the newest entries */ 226 if (Fflag && loops == 0) 227 loops++; 228 229 if (loops) { 230 size_t loop_bytes; 231 232 loop_bytes = sizeof(kcollect_t) * 233 (4 + SLEEP_INTERVAL / KCOLLECT_INTERVAL); 234 if (bytes > loop_bytes) 235 bytes = loop_bytes; 236 } 237 238 /* 239 * If we got specified a file to load from: replace the data 240 * array and counter 241 */ 242 if (fromFile) { 243 kcollect_t *dbmAry = NULL; 244 245 load_dbm(dbmFile, &dbmAry, &count); 246 ary = ary_base = dbmAry; 247 } else { 248 kcollect_t scaleid[2]; 249 250 ary_base = malloc(bytes + 251 DATA_BASE_INDEX * sizeof(kcollect_t)); 252 ary = ary_base + DATA_BASE_INDEX; 253 sysctlbyname("kern.collect_data", ary, &bytes, NULL, 0); 254 count = bytes / sizeof(kcollect_t); 255 if (count < 2) { 256 fprintf(stderr, 257 "[ERR] kern.collect_data failed\n"); 258 exit(1); 259 } 260 scaleid[0] = ary[0]; 261 scaleid[1] = ary[1]; 262 count -= 2; 263 ary = load_kernel(scaleid, ary + 2, &count); 264 } 265 if (fields) 266 adjust_fields(&ary[1], fields); 267 268 269 /* 270 * Delete duplicate entries when looping 271 */ 272 if (loops) { 273 while (count > DATA_BASE_INDEX) { 274 if ((int)(ary[count-1].ticks - last_ticks) > 0) 275 break; 276 --count; 277 } 278 } 279 280 /* 281 * Delete any entries beyond the time limit 282 */ 283 if (maxtime) { 284 maxtime *= ary[0].hz; 285 while (count > DATA_BASE_INDEX) { 286 if ((int)(ary[0].ticks - ary[count-1].ticks) < 287 maxtime) { 288 break; 289 } 290 --count; 291 } 292 } 293 294 switch(cmd) { 295 case 't': 296 if (count > DATA_BASE_INDEX) { 297 dumpfn(ary, count, total_count, 298 (fromFile ? DISPLAY_FULL_DATE : 299 DISPLAY_TIME_ONLY)); 300 } 301 break; 302 case 'b': 303 if (HostnameMismatch) { 304 fprintf(stderr, 305 "Hostname mismatch, cannot save to DB\n"); 306 exit(1); 307 } else { 308 if (count > DATA_BASE_INDEX) 309 dump_dbm(ary, count, datafile); 310 } 311 break; 312 case 'r': 313 if (count >= DATA_BASE_INDEX) 314 restore_headers(ary, datafile); 315 break; 316 case 'l': 317 dump_fields(ary); 318 exit(0); 319 break; /* NOT REACHED */ 320 case 'g': 321 if (count > DATA_BASE_INDEX) 322 dump_gnuplot(ary, count); 323 break; 324 case 'w': 325 if (count >= DATA_BASE_INDEX) 326 dump_gnuplot(ary, count); 327 break; 328 case 'x': 329 if (count > DATA_BASE_INDEX) 330 dump_gnuplot(ary, count); 331 break; 332 } 333 if (keepalive && !fromFile) { 334 fflush(OutFP); 335 fflush(stdout); 336 switch(cmd) { 337 case 't': 338 sleep(1); 339 break; 340 case 'x': 341 case 'g': 342 case 'w': 343 sleep(60); 344 break; 345 default: 346 sleep(10); 347 break; 348 } 349 } 350 last_ticks = ary[DATA_BASE_INDEX].ticks; 351 if (count >= DATA_BASE_INDEX) 352 total_count += count - DATA_BASE_INDEX; 353 354 /* 355 * Loop for incremental aquisition. When outputting to 356 * gunplot, we have to send the whole data-set again so 357 * do not increment loops in that case. 358 */ 359 if (cmd != 'g' && cmd != 'x' && cmd != 'w') 360 ++loops; 361 362 free(ary_base); 363 } while (keepalive); 364 365 if (cmd == 'x') 366 pclose(OutFP); 367 } 368 369 static 370 void 371 format_output(uintmax_t value,char fmt,uintmax_t scale, char* ret) 372 { 373 char buf[9]; 374 375 switch(fmt) { 376 case '2': 377 /* 378 * fractional x100 379 */ 380 sprintf(ret, "%5ju.%02ju", 381 value / 100, value % 100); 382 break; 383 case 'p': 384 /* 385 * Percentage fractional x100 (100% = 10000) 386 */ 387 sprintf(ret,"%4ju.%02ju%%", 388 value / 100, value % 100); 389 break; 390 case 'm': 391 /* 392 * Megabytes 393 */ 394 humanize_number(buf, sizeof(buf), value, "", 395 2, 396 HN_FRACTIONAL | 397 HN_NOSPACE); 398 sprintf(ret,"%8.8s", buf); 399 break; 400 case 'c': 401 /* 402 * Raw count over period (this is not total) 403 */ 404 humanize_number(buf, sizeof(buf), value, "", 405 HN_AUTOSCALE, 406 HN_FRACTIONAL | 407 HN_NOSPACE | 408 HN_DIVISOR_1000); 409 sprintf(ret,"%8.8s", buf); 410 break; 411 case 'b': 412 /* 413 * Total bytes (this is a total), output 414 * in megabytes. 415 */ 416 if (scale > 100000000) { 417 humanize_number(buf, sizeof(buf), 418 value, "", 419 3, 420 HN_FRACTIONAL | 421 HN_NOSPACE); 422 } else { 423 humanize_number(buf, sizeof(buf), 424 value, "", 425 2, 426 HN_FRACTIONAL | 427 HN_NOSPACE); 428 } 429 sprintf(ret,"%8.8s", buf); 430 break; 431 default: 432 sprintf(ret,"%s"," "); 433 break; 434 } 435 } 436 437 static 438 const char * 439 get_influx_series(const char *val) 440 { 441 /* cpu values (user, idle, syst) */ 442 if ((strncmp("user", val, 8) == 0) || 443 (strncmp("idle", val, 8) == 0 ) || 444 (strncmp("syst", val, 8) == 0)) 445 return "cpu_value"; 446 447 /* load value (load) */ 448 if (strncmp("load", val, 8) == 0) 449 return "load_value"; 450 451 /* swap values (swapuse, swapano, swapcac) */ 452 if ((strncmp("swapuse", val, 8) == 0) || 453 (strncmp("swapano", val, 8) == 0 ) || 454 (strncmp("swapcac", val, 8) == 0)) 455 return "swap_value"; 456 457 /* vm values (fault, cow, zfill) */ 458 if ((strncmp("fault", val, 8) == 0) || 459 (strncmp("cow", val, 8) == 0 ) || 460 (strncmp("zfill", val, 8) == 0)) 461 return "vm_value"; 462 463 /* memory values (fault, cow, zfill) */ 464 if ((strncmp("cache", val, 8) == 0) || 465 (strncmp("inact", val, 8) == 0 ) || 466 (strncmp("act", val, 8) == 0) || 467 (strncmp("wired", val, 8) == 0) || 468 (strncmp("free", val, 8) == 0)) 469 return "memory_value"; 470 471 /* misc values (syscalls, nlookup, intr, ipi, timer) */ 472 if ((strncmp("syscalls", val, 8) == 0) || 473 (strncmp("nlookup", val, 8) == 0 ) || 474 (strncmp("intr", val, 8) == 0) || 475 (strncmp("ipi", val, 8) == 0) || 476 (strncmp("timer", val, 8) == 0)) 477 return "misc_value"; 478 479 return "misc_value"; 480 481 } 482 483 static 484 void 485 dump_influxdb(kcollect_t *ary, size_t count, size_t total_count, 486 __unused const char* display_fmt) 487 { 488 int j; 489 int i; 490 uintmax_t value; 491 size_t ts_nsec; 492 char hostname[HOST_NAME_MAX]; 493 char *colname; 494 495 if (LoadedFromDB) { 496 snprintf(hostname, HOST_NAME_MAX, "%s", (char *)ary[2].data); 497 } else { 498 if (gethostname(hostname, HOST_NAME_MAX) != 0) { 499 fprintf(stderr, "Failed to get hostname\n"); 500 exit(1); 501 } 502 } 503 504 for (i = count - 1; i >= DATA_BASE_INDEX; --i) { 505 /* 506 * Timestamp 507 */ 508 ts_nsec = (ary[i].realtime.tv_sec 509 * 1000 /* ms */ 510 * 1000 /* usec */ 511 * 1000 /* nsec */ 512 + 123 /* add a few ns since due to missing precision */); 513 ts_nsec += (ary[i].realtime.tv_usec * 1000); 514 515 for (j = 0; j < KCOLLECT_ENTRIES; ++j) { 516 if (ary[1].data[j] == 0) 517 continue; 518 519 /* 520 * NOTE: kernel does not have to provide the scale 521 * (that is, the highest likely value), nor 522 * does it make sense in all cases. 523 * 524 * But should we since we're using raw values? 525 */ 526 value = ary[i].data[j]; 527 colname = (char *)&ary[1].data[j]; 528 529 printf("%s,host=%s,type=%.8s value=%jd %jd\n", 530 get_influx_series(colname), 531 hostname, colname, value, ts_nsec); 532 } 533 printf("\n"); 534 ++total_count; 535 } 536 537 } 538 539 static 540 void 541 dump_text(kcollect_t *ary, size_t count, size_t total_count, 542 const char* display_fmt) 543 { 544 int j; 545 int i; 546 uintmax_t scale; 547 uintmax_t value; 548 char fmt; 549 char sbuf[20]; 550 struct tm *tmv; 551 time_t t; 552 553 for (i = count - 1; i >= DATA_BASE_INDEX; --i) { 554 if ((total_count & 15) == 0) { 555 if (!strcmp(display_fmt, DISPLAY_FULL_DATE)) { 556 printf("%20s", "timestamp "); 557 } else { 558 printf("%8.8s", "time"); 559 } 560 for (j = 0; j < KCOLLECT_ENTRIES; ++j) { 561 if (ary[1].data[j]) { 562 printf(" %8.8s", 563 (char *)&ary[1].data[j]); 564 } 565 } 566 printf("\n"); 567 } 568 569 /* 570 * Timestamp 571 */ 572 t = ary[i].realtime.tv_sec; 573 if (UseGMT) 574 tmv = gmtime(&t); 575 else 576 tmv = localtime(&t); 577 strftime(sbuf, sizeof(sbuf), display_fmt, tmv); 578 printf("%8s", sbuf); 579 580 for (j = 0; j < KCOLLECT_ENTRIES; ++j) { 581 if (ary[1].data[j] == 0) 582 continue; 583 584 /* 585 * NOTE: kernel does not have to provide the scale 586 * (that is, the highest likely value), nor 587 * does it make sense in all cases. 588 * 589 * Example scale - kernel provides total amount 590 * of memory available for memory related 591 * statistics in the scale field. 592 */ 593 value = ary[i].data[j]; 594 scale = KCOLLECT_GETSCALE(ary[0].data[j]); 595 fmt = KCOLLECT_GETFMT(ary[0].data[j]); 596 597 printf(" "); 598 599 format_output(value, fmt, scale, sbuf); 600 printf("%s",sbuf); 601 } 602 603 printf("\n"); 604 ++total_count; 605 } 606 } 607 608 /* restores the DBM database header records to current machine */ 609 static 610 void 611 restore_headers(kcollect_t *ary, const char *datafile) 612 { 613 DBM *db; 614 char hdr[32]; 615 datum key, value; 616 int i; 617 618 db = dbm_open(datafile, (O_RDWR), 619 (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP)); 620 621 if (db == NULL) { 622 switch (errno) { 623 case EACCES: 624 fprintf(stderr, 625 "[ERR] database file \"%s\" is read-only, " 626 "check permissions. (%i)\n", 627 datafile, errno); 628 break; 629 default: 630 fprintf(stderr, 631 "[ERR] opening our database file \"%s\" " 632 "produced an error. (%i)\n", 633 datafile, errno); 634 } 635 exit(EXIT_FAILURE); 636 } else { 637 for (i = 0; i < DATA_BASE_INDEX; ++i) { 638 snprintf(hdr, sizeof(hdr), "%s%d", HDR_BASE, i); 639 key.dptr = hdr; 640 key.dsize = strlen(key.dptr) + 1; 641 value.dptr = &ary[i].data; 642 value.dsize = sizeof(uint64_t) * KCOLLECT_ENTRIES; 643 if (dbm_store(db,key,value,DBM_REPLACE) == -1) { 644 fprintf(stderr, 645 "[ERR] error storing the value in " 646 "the database file \"%s\" (%i)\n", 647 datafile, errno); 648 dbm_close(db); 649 exit(EXIT_FAILURE); 650 } 651 } 652 } 653 dbm_close(db); 654 } 655 656 657 /* 658 * Store the array of kcollect_t records in a dbm db database, 659 * path passed in datafile 660 */ 661 static 662 void 663 dump_dbm(kcollect_t *ary, size_t count, const char *datafile) 664 { 665 DBM * db; 666 667 db = dbm_open(datafile, (O_RDWR | O_CREAT), 668 (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP)); 669 if (db == NULL) { 670 switch (errno) { 671 case EACCES: 672 fprintf(stderr, 673 "[ERR] database file \"%s\" is read-only, " 674 "check permissions. (%i)\n", 675 datafile, errno); 676 break; 677 default: 678 fprintf(stderr, 679 "[ERR] opening our database file \"%s\" " 680 "produced an error. (%i)\n", 681 datafile, errno); 682 } 683 exit(EXIT_FAILURE); 684 } else { 685 struct tm *tmv; 686 char buf[20]; 687 datum key; 688 datum value; 689 time_t t; 690 uint i; 691 int cmd; 692 char hdr[32]; 693 694 for (i = 0; i < count; ++i) { 695 /* 696 * The first DATA_BASE_INDEX records are special. 697 */ 698 cmd = DBM_INSERT; 699 if (i < DATA_BASE_INDEX) { 700 snprintf(hdr, sizeof(hdr), "%s%d", HDR_BASE, i); 701 key.dptr = hdr; 702 key.dsize = strlen(hdr) + 1; 703 704 value = dbm_fetch(db, key); 705 if (value.dptr == NULL || 706 bcmp(ary[i].data, value.dptr, 707 sizeof(uint64_t) * KCOLLECT_ENTRIES)) { 708 cmd = DBM_REPLACE; 709 if (value.dptr != NULL) { 710 fprintf(stderr, 711 "Header %d changed " 712 "in database, " 713 "updating\n", 714 i); 715 } 716 } 717 } else { 718 t = ary[i].realtime.tv_sec; 719 if (LoadedFromDB) 720 tmv = localtime(&t); 721 else 722 tmv = gmtime(&t); 723 strftime(buf, sizeof(buf), 724 DISPLAY_FULL_DATE, tmv); 725 key.dptr = buf; 726 key.dsize = sizeof(buf); 727 } 728 value.dptr = ary[i].data; 729 value.dsize = sizeof(uint64_t) * KCOLLECT_ENTRIES; 730 if (dbm_store(db, key, value, cmd) == -1) { 731 fprintf(stderr, 732 "[ERR] error storing the value in " 733 "the database file \"%s\" (%i)\n", 734 datafile, errno); 735 dbm_close(db); 736 exit(EXIT_FAILURE); 737 } 738 739 } 740 dbm_close(db); 741 } 742 } 743 744 /* 745 * Transform a string (str) matching a format string (fmt) into a unix 746 * timestamp and return it used by load_dbm() 747 */ 748 static 749 int 750 str2unix(const char* str, const char* fmt){ 751 struct tm tm; 752 time_t ts; 753 754 /* 755 * Reset all the fields because strptime only sets what it 756 * finds, which may lead to undefined members 757 */ 758 memset(&tm, 0, sizeof(struct tm)); 759 strptime(str, fmt, &tm); 760 ts = timegm(&tm); 761 762 return (int)ts; 763 } 764 765 /* 766 * Sorts the ckollect_t records by time, to put youngest first, 767 * so desc by timestamp used by load_dbm() 768 */ 769 static 770 int 771 rec_comparator(const void *c1, const void *c2) 772 { 773 const kcollect_t *k1 = (const kcollect_t*)c1; 774 const kcollect_t *k2 = (const kcollect_t*)c2; 775 776 if (k1->realtime.tv_sec < k2->realtime.tv_sec) 777 return -1; 778 if (k1->realtime.tv_sec > k2->realtime.tv_sec) 779 return 1; 780 return 0; 781 } 782 783 /* 784 * Normalizes kcollect records from the kernel. We reserve the first 785 * DATA_BASE_INDEX elements for specific headers. 786 */ 787 static 788 kcollect_t * 789 load_kernel(kcollect_t *scaleid, kcollect_t *ary, size_t *counter) 790 { 791 ary -= DATA_BASE_INDEX; 792 bzero(ary, sizeof(*ary) * DATA_BASE_INDEX); 793 ary[0] = scaleid[0]; 794 ary[1] = scaleid[1]; 795 796 /* 797 * Add host field 798 */ 799 gethostname((char *)ary[2].data, 800 sizeof(uint64_t) * KCOLLECT_ENTRIES - 1); 801 802 *counter += DATA_BASE_INDEX; 803 804 return ary; 805 } 806 807 /* 808 * Loads the kcollect records from a dbm DB database specified in datafile. 809 * returns the resulting array in ret_ary and the array counter in counter 810 */ 811 static 812 void 813 load_dbm(const char* datafile, kcollect_t **ret_ary, 814 size_t *counter) 815 { 816 char hostname[sizeof(uint64_t) * KCOLLECT_ENTRIES]; 817 DBM *db = dbm_open(datafile,(O_RDONLY),(S_IRUSR|S_IRGRP)); 818 datum key; 819 datum value; 820 size_t recCounter = DATA_BASE_INDEX; 821 int headersFound = 0; 822 uint c; 823 uint sc; 824 825 if (db == NULL) { 826 fprintf(stderr, 827 "[ERR] opening our database \"%s\" produced " 828 "an error! (%i)\n", 829 datafile, errno); 830 exit(EXIT_FAILURE); 831 } 832 833 /* counting loop */ 834 for (key = dbm_firstkey(db); key.dptr; key = dbm_nextkey(db)) { 835 value = dbm_fetch(db, key); 836 if (value.dptr == NULL) 837 continue; 838 if (strncmp(key.dptr, HDR_BASE, HDR_STRLEN) == 0) 839 continue; 840 recCounter++; 841 } 842 843 /* with the count allocate enough memory */ 844 if (*ret_ary) 845 free(*ret_ary); 846 847 *ret_ary = malloc(sizeof(kcollect_t) * recCounter); 848 849 if (*ret_ary == NULL) { 850 fprintf(stderr, 851 "[ERR] failed to allocate enough memory to " 852 "hold the database! Aborting.\n"); 853 dbm_close(db); 854 exit(EXIT_FAILURE); 855 } 856 bzero(*ret_ary, sizeof(kcollect_t) * recCounter); 857 858 /* 859 * Actual data retrieval but only of recCounter 860 * records 861 */ 862 c = DATA_BASE_INDEX; 863 key = dbm_firstkey(db); 864 while (key.dptr && c < recCounter) { 865 value = dbm_fetch(db, key); 866 if (value.dptr == NULL) { 867 key = dbm_nextkey(db); 868 continue; 869 } 870 if (!strncmp(key.dptr, HDR_BASE, HDR_STRLEN)) { 871 /* 872 * Ignore unsupported header indices 873 */ 874 sc = strtoul((char *)key.dptr + 875 HDR_STRLEN, NULL, 10); 876 if (sc >= DATA_BASE_INDEX) { 877 key = dbm_nextkey(db); 878 continue; 879 } 880 headersFound |= 1 << sc; 881 } else { 882 sc = c++; 883 (*ret_ary)[sc].realtime.tv_sec = 884 str2unix(key.dptr, 885 DISPLAY_FULL_DATE); 886 } 887 memcpy((*ret_ary)[sc].data, 888 value.dptr, 889 sizeof(uint64_t) * KCOLLECT_ENTRIES); 890 891 key = dbm_nextkey(db); 892 } 893 894 /* 895 * HEADER2 - hostname (must match) 896 */ 897 if ((headersFound & 4) && *(char *)(*ret_ary)[2].data == 0) 898 headersFound &= ~4; 899 900 bzero(hostname, sizeof(hostname)); 901 gethostname(hostname, sizeof(hostname) - 1); 902 903 if (headersFound & 0x0004) { 904 if (*(char *)(*ret_ary)[2].data && 905 strcmp(hostname, (char *)(*ret_ary)[2].data) != 0) { 906 HostnameMismatch = 1; /* Disable certain options */ 907 } 908 } 909 910 /* 911 * Set the counter, 912 * and sort the non-header records. 913 */ 914 *counter = recCounter; 915 qsort(&(*ret_ary)[DATA_BASE_INDEX], recCounter - DATA_BASE_INDEX, 916 sizeof(kcollect_t), rec_comparator); 917 dbm_close(db); 918 919 if ((headersFound & 3) != 3) { 920 fprintf(stderr, "We could not retrieve all necessary headers, " 921 "might be the database file is corrupted? (%i)\n", 922 headersFound); 923 exit(EXIT_FAILURE); 924 } 925 LoadedFromDB = 1; 926 } 927 928 static void 929 dump_fields(kcollect_t *ary) 930 { 931 int j; 932 933 for (j = 0; j < KCOLLECT_ENTRIES; ++j) { 934 if (ary[1].data[j] == 0) 935 continue; 936 printf("%8.8s %c\n", 937 (char *)&ary[1].data[j], 938 KCOLLECT_GETFMT(ary[0].data[j])); 939 } 940 } 941 942 static void 943 adjust_fields(kcollect_t *ent, const char *fields) 944 { 945 char *copy = strdup(fields); 946 char *word; 947 int selected[KCOLLECT_ENTRIES]; 948 int j; 949 950 bzero(selected, sizeof(selected)); 951 952 word = strtok(copy, ", \t"); 953 while (word) { 954 for (j = 0; j < KCOLLECT_ENTRIES; ++j) { 955 if (strncmp(word, (char *)&ent->data[j], 8) == 0) { 956 selected[j] = 1; 957 break; 958 } 959 } 960 word = strtok(NULL, ", \t"); 961 } 962 free(copy); 963 for (j = 0; j < KCOLLECT_ENTRIES; ++j) { 964 if (!selected[j]) 965 ent->data[j] = 0; 966 } 967 } 968