1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Slabinfo: Tool to get reports about slabs 4 * 5 * (C) 2007 sgi, Christoph Lameter 6 * (C) 2011 Linux Foundation, Christoph Lameter 7 * 8 * Compile with: 9 * 10 * gcc -o slabinfo slabinfo.c 11 */ 12 #include <stdio.h> 13 #include <stdlib.h> 14 #include <sys/types.h> 15 #include <dirent.h> 16 #include <strings.h> 17 #include <string.h> 18 #include <unistd.h> 19 #include <stdarg.h> 20 #include <getopt.h> 21 #include <regex.h> 22 #include <errno.h> 23 24 #define MAX_SLABS 2000 25 #define MAX_ALIASES 500 26 #define MAX_NODES 1024 27 28 struct slabinfo { 29 char *name; 30 int alias; 31 int refs; 32 int aliases, align, cache_dma, cpu_slabs, destroy_by_rcu; 33 unsigned int hwcache_align, object_size, objs_per_slab; 34 unsigned int sanity_checks, slab_size, store_user, trace; 35 int order, poison, reclaim_account, red_zone; 36 unsigned long partial, objects, slabs, objects_partial, objects_total; 37 unsigned long alloc_fastpath, alloc_slowpath; 38 unsigned long free_fastpath, free_slowpath; 39 unsigned long free_frozen, free_add_partial, free_remove_partial; 40 unsigned long alloc_from_partial, alloc_slab, free_slab, alloc_refill; 41 unsigned long cpuslab_flush, deactivate_full, deactivate_empty; 42 unsigned long deactivate_to_head, deactivate_to_tail; 43 unsigned long deactivate_remote_frees, order_fallback; 44 unsigned long cmpxchg_double_cpu_fail, cmpxchg_double_fail; 45 unsigned long alloc_node_mismatch, deactivate_bypass; 46 unsigned long cpu_partial_alloc, cpu_partial_free; 47 int numa[MAX_NODES]; 48 int numa_partial[MAX_NODES]; 49 } slabinfo[MAX_SLABS]; 50 51 struct aliasinfo { 52 char *name; 53 char *ref; 54 struct slabinfo *slab; 55 } aliasinfo[MAX_ALIASES]; 56 57 int slabs; 58 int actual_slabs; 59 int aliases; 60 int alias_targets; 61 int highest_node; 62 63 char buffer[4096]; 64 65 int show_empty; 66 int show_report; 67 int show_alias; 68 int show_slab; 69 int skip_zero = 1; 70 int show_numa; 71 int show_track; 72 int show_first_alias; 73 int validate; 74 int shrink; 75 int show_inverted; 76 int show_single_ref; 77 int show_totals; 78 int sort_size; 79 int sort_active; 80 int set_debug; 81 int show_ops; 82 int sort_partial; 83 int show_activity; 84 int output_lines = -1; 85 int sort_loss; 86 int extended_totals; 87 int show_bytes; 88 int unreclaim_only; 89 90 /* Debug options */ 91 int sanity; 92 int redzone; 93 int poison; 94 int tracking; 95 int tracing; 96 97 int page_size; 98 99 regex_t pattern; 100 101 static void fatal(const char *x, ...) 102 { 103 va_list ap; 104 105 va_start(ap, x); 106 vfprintf(stderr, x, ap); 107 va_end(ap); 108 exit(EXIT_FAILURE); 109 } 110 111 static void usage(void) 112 { 113 printf("slabinfo 4/15/2011. (c) 2007 sgi/(c) 2011 Linux Foundation.\n\n" 114 "slabinfo [-aABDefhilLnoPrsStTUvXz1] [N=K] [-dafzput] [slab-regexp]\n" 115 "-a|--aliases Show aliases\n" 116 "-A|--activity Most active slabs first\n" 117 "-B|--Bytes Show size in bytes\n" 118 "-D|--display-active Switch line format to activity\n" 119 "-e|--empty Show empty slabs\n" 120 "-f|--first-alias Show first alias\n" 121 "-h|--help Show usage information\n" 122 "-i|--inverted Inverted list\n" 123 "-l|--slabs Show slabs\n" 124 "-L|--Loss Sort by loss\n" 125 "-n|--numa Show NUMA information\n" 126 "-N|--lines=K Show the first K slabs\n" 127 "-o|--ops Show kmem_cache_ops\n" 128 "-P|--partial Sort by number of partial slabs\n" 129 "-r|--report Detailed report on single slabs\n" 130 "-s|--shrink Shrink slabs\n" 131 "-S|--Size Sort by size\n" 132 "-t|--tracking Show alloc/free information\n" 133 "-T|--Totals Show summary information\n" 134 "-U|--Unreclaim Show unreclaimable slabs only\n" 135 "-v|--validate Validate slabs\n" 136 "-X|--Xtotals Show extended summary information\n" 137 "-z|--zero Include empty slabs\n" 138 "-1|--1ref Single reference\n" 139 140 "\n" 141 "-d | --debug Switch off all debug options\n" 142 "-da | --debug=a Switch on all debug options (--debug=FZPU)\n" 143 144 "\n" 145 "-d[afzput] | --debug=[afzput]\n" 146 " f | F Sanity Checks (SLAB_CONSISTENCY_CHECKS)\n" 147 " z | Z Redzoning\n" 148 " p | P Poisoning\n" 149 " u | U Tracking\n" 150 " t | T Tracing\n" 151 152 "\nSorting options (--Loss, --Size, --Partial) are mutually exclusive\n" 153 ); 154 } 155 156 static unsigned long read_obj(const char *name) 157 { 158 size_t len; 159 FILE *f = fopen(name, "r"); 160 161 if (!f) { 162 buffer[0] = 0; 163 if (errno == EACCES) 164 fatal("%s, Try using superuser\n", strerror(errno)); 165 } else { 166 if (!fgets(buffer, sizeof(buffer), f)) 167 buffer[0] = 0; 168 fclose(f); 169 len = strlen(buffer); 170 171 if (len > 0 && buffer[len - 1] == '\n') 172 buffer[len - 1] = 0; 173 } 174 return strlen(buffer); 175 } 176 177 178 /* 179 * Get the contents of an attribute 180 */ 181 static unsigned long get_obj(const char *name) 182 { 183 if (!read_obj(name)) 184 return 0; 185 186 return atol(buffer); 187 } 188 189 static unsigned long get_obj_and_str(const char *name, char **x) 190 { 191 unsigned long result = 0; 192 char *p; 193 194 *x = NULL; 195 196 if (!read_obj(name)) 197 return 0; 198 199 result = strtoul(buffer, &p, 10); 200 while (*p == ' ') 201 p++; 202 if (*p) 203 *x = strdup(p); 204 return result; 205 } 206 207 static void set_obj(struct slabinfo *s, const char *name, int n) 208 { 209 char x[100]; 210 FILE *f; 211 212 snprintf(x, 100, "%s/%s", s->name, name); 213 f = fopen(x, "w"); 214 if (!f) 215 fatal("Cannot write to %s\n", x); 216 217 fprintf(f, "%d\n", n); 218 fclose(f); 219 } 220 221 static unsigned long read_slab_obj(struct slabinfo *s, const char *name) 222 { 223 char x[100]; 224 FILE *f; 225 size_t l; 226 227 snprintf(x, 100, "%s/%s", s->name, name); 228 f = fopen(x, "r"); 229 if (!f) { 230 buffer[0] = 0; 231 l = 0; 232 } else { 233 l = fread(buffer, 1, sizeof(buffer), f); 234 buffer[l] = 0; 235 fclose(f); 236 } 237 return l; 238 } 239 240 static unsigned long read_debug_slab_obj(struct slabinfo *s, const char *name) 241 { 242 char x[128]; 243 FILE *f; 244 size_t l; 245 246 snprintf(x, 128, "/sys/kernel/debug/slab/%s/%s", s->name, name); 247 f = fopen(x, "r"); 248 if (!f) { 249 buffer[0] = 0; 250 l = 0; 251 } else { 252 l = fread(buffer, 1, sizeof(buffer), f); 253 buffer[l] = 0; 254 fclose(f); 255 } 256 return l; 257 } 258 259 /* 260 * Put a size string together 261 */ 262 static int store_size(char *buffer, unsigned long value) 263 { 264 unsigned long divisor = 1; 265 char trailer = 0; 266 int n; 267 268 if (!show_bytes) { 269 if (value > 1000000000UL) { 270 divisor = 100000000UL; 271 trailer = 'G'; 272 } else if (value > 1000000UL) { 273 divisor = 100000UL; 274 trailer = 'M'; 275 } else if (value > 1000UL) { 276 divisor = 100; 277 trailer = 'K'; 278 } 279 } 280 281 value /= divisor; 282 n = sprintf(buffer, "%ld",value); 283 if (trailer) { 284 buffer[n] = trailer; 285 n++; 286 buffer[n] = 0; 287 } 288 if (divisor != 1) { 289 memmove(buffer + n - 2, buffer + n - 3, 4); 290 buffer[n-2] = '.'; 291 n++; 292 } 293 return n; 294 } 295 296 static void decode_numa_list(int *numa, char *t) 297 { 298 int node; 299 int nr; 300 301 memset(numa, 0, MAX_NODES * sizeof(int)); 302 303 if (!t) 304 return; 305 306 while (*t == 'N') { 307 t++; 308 node = strtoul(t, &t, 10); 309 if (*t == '=') { 310 t++; 311 nr = strtoul(t, &t, 10); 312 numa[node] = nr; 313 if (node > highest_node) 314 highest_node = node; 315 } 316 while (*t == ' ') 317 t++; 318 } 319 } 320 321 static void slab_validate(struct slabinfo *s) 322 { 323 if (strcmp(s->name, "*") == 0) 324 return; 325 326 set_obj(s, "validate", 1); 327 } 328 329 static void slab_shrink(struct slabinfo *s) 330 { 331 if (strcmp(s->name, "*") == 0) 332 return; 333 334 set_obj(s, "shrink", 1); 335 } 336 337 int line = 0; 338 339 static void first_line(void) 340 { 341 if (show_activity) 342 printf("Name Objects Alloc Free" 343 " %%Fast Fallb O CmpX UL\n"); 344 else 345 printf("Name Objects Objsize %s " 346 "Slabs/Part/Cpu O/S O %%Fr %%Ef Flg\n", 347 sort_loss ? " Loss" : "Space"); 348 } 349 350 /* 351 * Find the shortest alias of a slab 352 */ 353 static struct aliasinfo *find_one_alias(struct slabinfo *find) 354 { 355 struct aliasinfo *a; 356 struct aliasinfo *best = NULL; 357 358 for(a = aliasinfo;a < aliasinfo + aliases; a++) { 359 if (a->slab == find && 360 (!best || strlen(best->name) < strlen(a->name))) { 361 best = a; 362 if (strncmp(a->name,"kmall", 5) == 0) 363 return best; 364 } 365 } 366 return best; 367 } 368 369 static unsigned long slab_size(struct slabinfo *s) 370 { 371 return s->slabs * (page_size << s->order); 372 } 373 374 static unsigned long slab_activity(struct slabinfo *s) 375 { 376 return s->alloc_fastpath + s->free_fastpath + 377 s->alloc_slowpath + s->free_slowpath; 378 } 379 380 static unsigned long slab_waste(struct slabinfo *s) 381 { 382 return slab_size(s) - s->objects * s->object_size; 383 } 384 385 static void slab_numa(struct slabinfo *s, int mode) 386 { 387 int node; 388 389 if (strcmp(s->name, "*") == 0) 390 return; 391 392 if (!highest_node) { 393 printf("\n%s: No NUMA information available.\n", s->name); 394 return; 395 } 396 397 if (skip_zero && !s->slabs) 398 return; 399 400 if (!line) { 401 printf("\n%-21s:", mode ? "NUMA nodes" : "Slab"); 402 for(node = 0; node <= highest_node; node++) 403 printf(" %4d", node); 404 printf("\n----------------------"); 405 for(node = 0; node <= highest_node; node++) 406 printf("-----"); 407 printf("\n"); 408 } 409 printf("%-21s ", mode ? "All slabs" : s->name); 410 for(node = 0; node <= highest_node; node++) { 411 char b[20]; 412 413 store_size(b, s->numa[node]); 414 printf(" %4s", b); 415 } 416 printf("\n"); 417 if (mode) { 418 printf("%-21s ", "Partial slabs"); 419 for(node = 0; node <= highest_node; node++) { 420 char b[20]; 421 422 store_size(b, s->numa_partial[node]); 423 printf(" %4s", b); 424 } 425 printf("\n"); 426 } 427 line++; 428 } 429 430 static void show_tracking(struct slabinfo *s) 431 { 432 printf("\n%s: Kernel object allocation\n", s->name); 433 printf("-----------------------------------------------------------------------\n"); 434 if (read_debug_slab_obj(s, "alloc_traces")) 435 printf("%s", buffer); 436 else if (read_slab_obj(s, "alloc_calls")) 437 printf("%s", buffer); 438 else 439 printf("No Data\n"); 440 441 printf("\n%s: Kernel object freeing\n", s->name); 442 printf("------------------------------------------------------------------------\n"); 443 if (read_debug_slab_obj(s, "free_traces")) 444 printf("%s", buffer); 445 else if (read_slab_obj(s, "free_calls")) 446 printf("%s", buffer); 447 else 448 printf("No Data\n"); 449 450 } 451 452 static void ops(struct slabinfo *s) 453 { 454 if (strcmp(s->name, "*") == 0) 455 return; 456 457 if (read_slab_obj(s, "ops")) { 458 printf("\n%s: kmem_cache operations\n", s->name); 459 printf("--------------------------------------------\n"); 460 printf("%s", buffer); 461 } else 462 printf("\n%s has no kmem_cache operations\n", s->name); 463 } 464 465 static const char *onoff(int x) 466 { 467 if (x) 468 return "On "; 469 return "Off"; 470 } 471 472 static void slab_stats(struct slabinfo *s) 473 { 474 unsigned long total_alloc; 475 unsigned long total_free; 476 unsigned long total; 477 478 if (!s->alloc_slab) 479 return; 480 481 total_alloc = s->alloc_fastpath + s->alloc_slowpath; 482 total_free = s->free_fastpath + s->free_slowpath; 483 484 if (!total_alloc) 485 return; 486 487 printf("\n"); 488 printf("Slab Perf Counter Alloc Free %%Al %%Fr\n"); 489 printf("--------------------------------------------------\n"); 490 printf("Fastpath %8lu %8lu %3lu %3lu\n", 491 s->alloc_fastpath, s->free_fastpath, 492 s->alloc_fastpath * 100 / total_alloc, 493 total_free ? s->free_fastpath * 100 / total_free : 0); 494 printf("Slowpath %8lu %8lu %3lu %3lu\n", 495 total_alloc - s->alloc_fastpath, s->free_slowpath, 496 (total_alloc - s->alloc_fastpath) * 100 / total_alloc, 497 total_free ? s->free_slowpath * 100 / total_free : 0); 498 printf("Page Alloc %8lu %8lu %3lu %3lu\n", 499 s->alloc_slab, s->free_slab, 500 s->alloc_slab * 100 / total_alloc, 501 total_free ? s->free_slab * 100 / total_free : 0); 502 printf("Add partial %8lu %8lu %3lu %3lu\n", 503 s->deactivate_to_head + s->deactivate_to_tail, 504 s->free_add_partial, 505 (s->deactivate_to_head + s->deactivate_to_tail) * 100 / total_alloc, 506 total_free ? s->free_add_partial * 100 / total_free : 0); 507 printf("Remove partial %8lu %8lu %3lu %3lu\n", 508 s->alloc_from_partial, s->free_remove_partial, 509 s->alloc_from_partial * 100 / total_alloc, 510 total_free ? s->free_remove_partial * 100 / total_free : 0); 511 512 printf("Cpu partial list %8lu %8lu %3lu %3lu\n", 513 s->cpu_partial_alloc, s->cpu_partial_free, 514 s->cpu_partial_alloc * 100 / total_alloc, 515 total_free ? s->cpu_partial_free * 100 / total_free : 0); 516 517 printf("RemoteObj/SlabFrozen %8lu %8lu %3lu %3lu\n", 518 s->deactivate_remote_frees, s->free_frozen, 519 s->deactivate_remote_frees * 100 / total_alloc, 520 total_free ? s->free_frozen * 100 / total_free : 0); 521 522 printf("Total %8lu %8lu\n\n", total_alloc, total_free); 523 524 if (s->cpuslab_flush) 525 printf("Flushes %8lu\n", s->cpuslab_flush); 526 527 total = s->deactivate_full + s->deactivate_empty + 528 s->deactivate_to_head + s->deactivate_to_tail + s->deactivate_bypass; 529 530 if (total) { 531 printf("\nSlab Deactivation Occurrences %%\n"); 532 printf("-------------------------------------------------\n"); 533 printf("Slab full %7lu %3lu%%\n", 534 s->deactivate_full, (s->deactivate_full * 100) / total); 535 printf("Slab empty %7lu %3lu%%\n", 536 s->deactivate_empty, (s->deactivate_empty * 100) / total); 537 printf("Moved to head of partial list %7lu %3lu%%\n", 538 s->deactivate_to_head, (s->deactivate_to_head * 100) / total); 539 printf("Moved to tail of partial list %7lu %3lu%%\n", 540 s->deactivate_to_tail, (s->deactivate_to_tail * 100) / total); 541 printf("Deactivation bypass %7lu %3lu%%\n", 542 s->deactivate_bypass, (s->deactivate_bypass * 100) / total); 543 printf("Refilled from foreign frees %7lu %3lu%%\n", 544 s->alloc_refill, (s->alloc_refill * 100) / total); 545 printf("Node mismatch %7lu %3lu%%\n", 546 s->alloc_node_mismatch, (s->alloc_node_mismatch * 100) / total); 547 } 548 549 if (s->cmpxchg_double_fail || s->cmpxchg_double_cpu_fail) { 550 printf("\nCmpxchg_double Looping\n------------------------\n"); 551 printf("Locked Cmpxchg Double redos %lu\nUnlocked Cmpxchg Double redos %lu\n", 552 s->cmpxchg_double_fail, s->cmpxchg_double_cpu_fail); 553 } 554 } 555 556 static void report(struct slabinfo *s) 557 { 558 if (strcmp(s->name, "*") == 0) 559 return; 560 561 printf("\nSlabcache: %-15s Aliases: %2d Order : %2d Objects: %lu\n", 562 s->name, s->aliases, s->order, s->objects); 563 if (s->hwcache_align) 564 printf("** Hardware cacheline aligned\n"); 565 if (s->cache_dma) 566 printf("** Memory is allocated in a special DMA zone\n"); 567 if (s->destroy_by_rcu) 568 printf("** Slabs are destroyed via RCU\n"); 569 if (s->reclaim_account) 570 printf("** Reclaim accounting active\n"); 571 572 printf("\nSizes (bytes) Slabs Debug Memory\n"); 573 printf("------------------------------------------------------------------------\n"); 574 printf("Object : %7d Total : %7ld Sanity Checks : %s Total: %7ld\n", 575 s->object_size, s->slabs, onoff(s->sanity_checks), 576 s->slabs * (page_size << s->order)); 577 printf("SlabObj: %7d Full : %7ld Redzoning : %s Used : %7ld\n", 578 s->slab_size, s->slabs - s->partial - s->cpu_slabs, 579 onoff(s->red_zone), s->objects * s->object_size); 580 printf("SlabSiz: %7d Partial: %7ld Poisoning : %s Loss : %7ld\n", 581 page_size << s->order, s->partial, onoff(s->poison), 582 s->slabs * (page_size << s->order) - s->objects * s->object_size); 583 printf("Loss : %7d CpuSlab: %7d Tracking : %s Lalig: %7ld\n", 584 s->slab_size - s->object_size, s->cpu_slabs, onoff(s->store_user), 585 (s->slab_size - s->object_size) * s->objects); 586 printf("Align : %7d Objects: %7d Tracing : %s Lpadd: %7ld\n", 587 s->align, s->objs_per_slab, onoff(s->trace), 588 ((page_size << s->order) - s->objs_per_slab * s->slab_size) * 589 s->slabs); 590 591 ops(s); 592 show_tracking(s); 593 slab_numa(s, 1); 594 slab_stats(s); 595 } 596 597 static void slabcache(struct slabinfo *s) 598 { 599 char size_str[20]; 600 char dist_str[40]; 601 char flags[20]; 602 char *p = flags; 603 604 if (strcmp(s->name, "*") == 0) 605 return; 606 607 if (unreclaim_only && s->reclaim_account) 608 return; 609 610 if (actual_slabs == 1) { 611 report(s); 612 return; 613 } 614 615 if (skip_zero && !show_empty && !s->slabs) 616 return; 617 618 if (show_empty && s->slabs) 619 return; 620 621 if (sort_loss == 0) 622 store_size(size_str, slab_size(s)); 623 else 624 store_size(size_str, slab_waste(s)); 625 snprintf(dist_str, 40, "%lu/%lu/%d", s->slabs - s->cpu_slabs, 626 s->partial, s->cpu_slabs); 627 628 if (!line++) 629 first_line(); 630 631 if (s->aliases) 632 *p++ = '*'; 633 if (s->cache_dma) 634 *p++ = 'd'; 635 if (s->hwcache_align) 636 *p++ = 'A'; 637 if (s->poison) 638 *p++ = 'P'; 639 if (s->reclaim_account) 640 *p++ = 'a'; 641 if (s->red_zone) 642 *p++ = 'Z'; 643 if (s->sanity_checks) 644 *p++ = 'F'; 645 if (s->store_user) 646 *p++ = 'U'; 647 if (s->trace) 648 *p++ = 'T'; 649 650 *p = 0; 651 if (show_activity) { 652 unsigned long total_alloc; 653 unsigned long total_free; 654 655 total_alloc = s->alloc_fastpath + s->alloc_slowpath; 656 total_free = s->free_fastpath + s->free_slowpath; 657 658 printf("%-21s %8ld %10ld %10ld %3ld %3ld %5ld %1d %4ld %4ld\n", 659 s->name, s->objects, 660 total_alloc, total_free, 661 total_alloc ? (s->alloc_fastpath * 100 / total_alloc) : 0, 662 total_free ? (s->free_fastpath * 100 / total_free) : 0, 663 s->order_fallback, s->order, s->cmpxchg_double_fail, 664 s->cmpxchg_double_cpu_fail); 665 } else { 666 printf("%-21s %8ld %7d %15s %14s %4d %1d %3ld %3ld %s\n", 667 s->name, s->objects, s->object_size, size_str, dist_str, 668 s->objs_per_slab, s->order, 669 s->slabs ? (s->partial * 100) / s->slabs : 100, 670 s->slabs ? (s->objects * s->object_size * 100) / 671 (s->slabs * (page_size << s->order)) : 100, 672 flags); 673 } 674 } 675 676 /* 677 * Analyze debug options. Return false if something is amiss. 678 */ 679 static int debug_opt_scan(char *opt) 680 { 681 if (!opt || !opt[0] || strcmp(opt, "-") == 0) 682 return 1; 683 684 if (strcasecmp(opt, "a") == 0) { 685 sanity = 1; 686 poison = 1; 687 redzone = 1; 688 tracking = 1; 689 return 1; 690 } 691 692 for ( ; *opt; opt++) 693 switch (*opt) { 694 case 'F' : case 'f': 695 if (sanity) 696 return 0; 697 sanity = 1; 698 break; 699 case 'P' : case 'p': 700 if (poison) 701 return 0; 702 poison = 1; 703 break; 704 705 case 'Z' : case 'z': 706 if (redzone) 707 return 0; 708 redzone = 1; 709 break; 710 711 case 'U' : case 'u': 712 if (tracking) 713 return 0; 714 tracking = 1; 715 break; 716 717 case 'T' : case 't': 718 if (tracing) 719 return 0; 720 tracing = 1; 721 break; 722 default: 723 return 0; 724 } 725 return 1; 726 } 727 728 static int slab_empty(struct slabinfo *s) 729 { 730 if (s->objects > 0) 731 return 0; 732 733 /* 734 * We may still have slabs even if there are no objects. Shrinking will 735 * remove them. 736 */ 737 if (s->slabs != 0) 738 set_obj(s, "shrink", 1); 739 740 return 1; 741 } 742 743 static void slab_debug(struct slabinfo *s) 744 { 745 if (strcmp(s->name, "*") == 0) 746 return; 747 748 if (sanity && !s->sanity_checks) { 749 set_obj(s, "sanity_checks", 1); 750 } 751 if (!sanity && s->sanity_checks) { 752 if (slab_empty(s)) 753 set_obj(s, "sanity_checks", 0); 754 else 755 fprintf(stderr, "%s not empty cannot disable sanity checks\n", s->name); 756 } 757 if (redzone && !s->red_zone) { 758 if (slab_empty(s)) 759 set_obj(s, "red_zone", 1); 760 else 761 fprintf(stderr, "%s not empty cannot enable redzoning\n", s->name); 762 } 763 if (!redzone && s->red_zone) { 764 if (slab_empty(s)) 765 set_obj(s, "red_zone", 0); 766 else 767 fprintf(stderr, "%s not empty cannot disable redzoning\n", s->name); 768 } 769 if (poison && !s->poison) { 770 if (slab_empty(s)) 771 set_obj(s, "poison", 1); 772 else 773 fprintf(stderr, "%s not empty cannot enable poisoning\n", s->name); 774 } 775 if (!poison && s->poison) { 776 if (slab_empty(s)) 777 set_obj(s, "poison", 0); 778 else 779 fprintf(stderr, "%s not empty cannot disable poisoning\n", s->name); 780 } 781 if (tracking && !s->store_user) { 782 if (slab_empty(s)) 783 set_obj(s, "store_user", 1); 784 else 785 fprintf(stderr, "%s not empty cannot enable tracking\n", s->name); 786 } 787 if (!tracking && s->store_user) { 788 if (slab_empty(s)) 789 set_obj(s, "store_user", 0); 790 else 791 fprintf(stderr, "%s not empty cannot disable tracking\n", s->name); 792 } 793 if (tracing && !s->trace) { 794 if (slabs == 1) 795 set_obj(s, "trace", 1); 796 else 797 fprintf(stderr, "%s can only enable trace for one slab at a time\n", s->name); 798 } 799 if (!tracing && s->trace) 800 set_obj(s, "trace", 0); 801 } 802 803 static void totals(void) 804 { 805 struct slabinfo *s; 806 807 int used_slabs = 0; 808 char b1[20], b2[20], b3[20], b4[20]; 809 unsigned long long max = 1ULL << 63; 810 811 /* Object size */ 812 unsigned long long min_objsize = max, max_objsize = 0, avg_objsize; 813 814 /* Number of partial slabs in a slabcache */ 815 unsigned long long min_partial = max, max_partial = 0, 816 avg_partial, total_partial = 0; 817 818 /* Number of slabs in a slab cache */ 819 unsigned long long min_slabs = max, max_slabs = 0, 820 avg_slabs, total_slabs = 0; 821 822 /* Size of the whole slab */ 823 unsigned long long min_size = max, max_size = 0, 824 avg_size, total_size = 0; 825 826 /* Bytes used for object storage in a slab */ 827 unsigned long long min_used = max, max_used = 0, 828 avg_used, total_used = 0; 829 830 /* Waste: Bytes used for alignment and padding */ 831 unsigned long long min_waste = max, max_waste = 0, 832 avg_waste, total_waste = 0; 833 /* Number of objects in a slab */ 834 unsigned long long min_objects = max, max_objects = 0, 835 avg_objects, total_objects = 0; 836 /* Waste per object */ 837 unsigned long long min_objwaste = max, 838 max_objwaste = 0, avg_objwaste, 839 total_objwaste = 0; 840 841 /* Memory per object */ 842 unsigned long long min_memobj = max, 843 max_memobj = 0, avg_memobj, 844 total_objsize = 0; 845 846 /* Percentage of partial slabs per slab */ 847 unsigned long min_ppart = 100, max_ppart = 0, 848 avg_ppart, total_ppart = 0; 849 850 /* Number of objects in partial slabs */ 851 unsigned long min_partobj = max, max_partobj = 0, 852 avg_partobj, total_partobj = 0; 853 854 /* Percentage of partial objects of all objects in a slab */ 855 unsigned long min_ppartobj = 100, max_ppartobj = 0, 856 avg_ppartobj, total_ppartobj = 0; 857 858 859 for (s = slabinfo; s < slabinfo + slabs; s++) { 860 unsigned long long size; 861 unsigned long used; 862 unsigned long long wasted; 863 unsigned long long objwaste; 864 unsigned long percentage_partial_slabs; 865 unsigned long percentage_partial_objs; 866 867 if (!s->slabs || !s->objects) 868 continue; 869 870 used_slabs++; 871 872 size = slab_size(s); 873 used = s->objects * s->object_size; 874 wasted = size - used; 875 objwaste = s->slab_size - s->object_size; 876 877 percentage_partial_slabs = s->partial * 100 / s->slabs; 878 if (percentage_partial_slabs > 100) 879 percentage_partial_slabs = 100; 880 881 percentage_partial_objs = s->objects_partial * 100 882 / s->objects; 883 884 if (percentage_partial_objs > 100) 885 percentage_partial_objs = 100; 886 887 if (s->object_size < min_objsize) 888 min_objsize = s->object_size; 889 if (s->partial < min_partial) 890 min_partial = s->partial; 891 if (s->slabs < min_slabs) 892 min_slabs = s->slabs; 893 if (size < min_size) 894 min_size = size; 895 if (wasted < min_waste) 896 min_waste = wasted; 897 if (objwaste < min_objwaste) 898 min_objwaste = objwaste; 899 if (s->objects < min_objects) 900 min_objects = s->objects; 901 if (used < min_used) 902 min_used = used; 903 if (s->objects_partial < min_partobj) 904 min_partobj = s->objects_partial; 905 if (percentage_partial_slabs < min_ppart) 906 min_ppart = percentage_partial_slabs; 907 if (percentage_partial_objs < min_ppartobj) 908 min_ppartobj = percentage_partial_objs; 909 if (s->slab_size < min_memobj) 910 min_memobj = s->slab_size; 911 912 if (s->object_size > max_objsize) 913 max_objsize = s->object_size; 914 if (s->partial > max_partial) 915 max_partial = s->partial; 916 if (s->slabs > max_slabs) 917 max_slabs = s->slabs; 918 if (size > max_size) 919 max_size = size; 920 if (wasted > max_waste) 921 max_waste = wasted; 922 if (objwaste > max_objwaste) 923 max_objwaste = objwaste; 924 if (s->objects > max_objects) 925 max_objects = s->objects; 926 if (used > max_used) 927 max_used = used; 928 if (s->objects_partial > max_partobj) 929 max_partobj = s->objects_partial; 930 if (percentage_partial_slabs > max_ppart) 931 max_ppart = percentage_partial_slabs; 932 if (percentage_partial_objs > max_ppartobj) 933 max_ppartobj = percentage_partial_objs; 934 if (s->slab_size > max_memobj) 935 max_memobj = s->slab_size; 936 937 total_partial += s->partial; 938 total_slabs += s->slabs; 939 total_size += size; 940 total_waste += wasted; 941 942 total_objects += s->objects; 943 total_used += used; 944 total_partobj += s->objects_partial; 945 total_ppart += percentage_partial_slabs; 946 total_ppartobj += percentage_partial_objs; 947 948 total_objwaste += s->objects * objwaste; 949 total_objsize += s->objects * s->slab_size; 950 } 951 952 if (!total_objects) { 953 printf("No objects\n"); 954 return; 955 } 956 if (!used_slabs) { 957 printf("No slabs\n"); 958 return; 959 } 960 961 /* Per slab averages */ 962 avg_partial = total_partial / used_slabs; 963 avg_slabs = total_slabs / used_slabs; 964 avg_size = total_size / used_slabs; 965 avg_waste = total_waste / used_slabs; 966 967 avg_objects = total_objects / used_slabs; 968 avg_used = total_used / used_slabs; 969 avg_partobj = total_partobj / used_slabs; 970 avg_ppart = total_ppart / used_slabs; 971 avg_ppartobj = total_ppartobj / used_slabs; 972 973 /* Per object object sizes */ 974 avg_objsize = total_used / total_objects; 975 avg_objwaste = total_objwaste / total_objects; 976 avg_partobj = total_partobj * 100 / total_objects; 977 avg_memobj = total_objsize / total_objects; 978 979 printf("Slabcache Totals\n"); 980 printf("----------------\n"); 981 printf("Slabcaches : %15d Aliases : %11d->%-3d Active: %3d\n", 982 slabs, aliases, alias_targets, used_slabs); 983 984 store_size(b1, total_size);store_size(b2, total_waste); 985 store_size(b3, total_waste * 100 / total_used); 986 printf("Memory used: %15s # Loss : %15s MRatio:%6s%%\n", b1, b2, b3); 987 988 store_size(b1, total_objects);store_size(b2, total_partobj); 989 store_size(b3, total_partobj * 100 / total_objects); 990 printf("# Objects : %15s # PartObj: %15s ORatio:%6s%%\n", b1, b2, b3); 991 992 printf("\n"); 993 printf("Per Cache Average " 994 "Min Max Total\n"); 995 printf("---------------------------------------" 996 "-------------------------------------\n"); 997 998 store_size(b1, avg_objects);store_size(b2, min_objects); 999 store_size(b3, max_objects);store_size(b4, total_objects); 1000 printf("#Objects %15s %15s %15s %15s\n", 1001 b1, b2, b3, b4); 1002 1003 store_size(b1, avg_slabs);store_size(b2, min_slabs); 1004 store_size(b3, max_slabs);store_size(b4, total_slabs); 1005 printf("#Slabs %15s %15s %15s %15s\n", 1006 b1, b2, b3, b4); 1007 1008 store_size(b1, avg_partial);store_size(b2, min_partial); 1009 store_size(b3, max_partial);store_size(b4, total_partial); 1010 printf("#PartSlab %15s %15s %15s %15s\n", 1011 b1, b2, b3, b4); 1012 store_size(b1, avg_ppart);store_size(b2, min_ppart); 1013 store_size(b3, max_ppart); 1014 store_size(b4, total_partial * 100 / total_slabs); 1015 printf("%%PartSlab%15s%% %15s%% %15s%% %15s%%\n", 1016 b1, b2, b3, b4); 1017 1018 store_size(b1, avg_partobj);store_size(b2, min_partobj); 1019 store_size(b3, max_partobj); 1020 store_size(b4, total_partobj); 1021 printf("PartObjs %15s %15s %15s %15s\n", 1022 b1, b2, b3, b4); 1023 1024 store_size(b1, avg_ppartobj);store_size(b2, min_ppartobj); 1025 store_size(b3, max_ppartobj); 1026 store_size(b4, total_partobj * 100 / total_objects); 1027 printf("%% PartObj%15s%% %15s%% %15s%% %15s%%\n", 1028 b1, b2, b3, b4); 1029 1030 store_size(b1, avg_size);store_size(b2, min_size); 1031 store_size(b3, max_size);store_size(b4, total_size); 1032 printf("Memory %15s %15s %15s %15s\n", 1033 b1, b2, b3, b4); 1034 1035 store_size(b1, avg_used);store_size(b2, min_used); 1036 store_size(b3, max_used);store_size(b4, total_used); 1037 printf("Used %15s %15s %15s %15s\n", 1038 b1, b2, b3, b4); 1039 1040 store_size(b1, avg_waste);store_size(b2, min_waste); 1041 store_size(b3, max_waste);store_size(b4, total_waste); 1042 printf("Loss %15s %15s %15s %15s\n", 1043 b1, b2, b3, b4); 1044 1045 printf("\n"); 1046 printf("Per Object Average " 1047 "Min Max\n"); 1048 printf("---------------------------------------" 1049 "--------------------\n"); 1050 1051 store_size(b1, avg_memobj);store_size(b2, min_memobj); 1052 store_size(b3, max_memobj); 1053 printf("Memory %15s %15s %15s\n", 1054 b1, b2, b3); 1055 store_size(b1, avg_objsize);store_size(b2, min_objsize); 1056 store_size(b3, max_objsize); 1057 printf("User %15s %15s %15s\n", 1058 b1, b2, b3); 1059 1060 store_size(b1, avg_objwaste);store_size(b2, min_objwaste); 1061 store_size(b3, max_objwaste); 1062 printf("Loss %15s %15s %15s\n", 1063 b1, b2, b3); 1064 } 1065 1066 static void sort_slabs(void) 1067 { 1068 struct slabinfo *s1,*s2; 1069 1070 for (s1 = slabinfo; s1 < slabinfo + slabs; s1++) { 1071 for (s2 = s1 + 1; s2 < slabinfo + slabs; s2++) { 1072 int result; 1073 1074 if (sort_size) { 1075 if (slab_size(s1) == slab_size(s2)) 1076 result = strcasecmp(s1->name, s2->name); 1077 else 1078 result = slab_size(s1) < slab_size(s2); 1079 } else if (sort_active) { 1080 if (slab_activity(s1) == slab_activity(s2)) 1081 result = strcasecmp(s1->name, s2->name); 1082 else 1083 result = slab_activity(s1) < slab_activity(s2); 1084 } else if (sort_loss) { 1085 if (slab_waste(s1) == slab_waste(s2)) 1086 result = strcasecmp(s1->name, s2->name); 1087 else 1088 result = slab_waste(s1) < slab_waste(s2); 1089 } else if (sort_partial) { 1090 if (s1->partial == s2->partial) 1091 result = strcasecmp(s1->name, s2->name); 1092 else 1093 result = s1->partial < s2->partial; 1094 } else 1095 result = strcasecmp(s1->name, s2->name); 1096 1097 if (show_inverted) 1098 result = -result; 1099 1100 if (result > 0) { 1101 struct slabinfo t; 1102 1103 memcpy(&t, s1, sizeof(struct slabinfo)); 1104 memcpy(s1, s2, sizeof(struct slabinfo)); 1105 memcpy(s2, &t, sizeof(struct slabinfo)); 1106 } 1107 } 1108 } 1109 } 1110 1111 static void sort_aliases(void) 1112 { 1113 struct aliasinfo *a1,*a2; 1114 1115 for (a1 = aliasinfo; a1 < aliasinfo + aliases; a1++) { 1116 for (a2 = a1 + 1; a2 < aliasinfo + aliases; a2++) { 1117 char *n1, *n2; 1118 1119 n1 = a1->name; 1120 n2 = a2->name; 1121 if (show_alias && !show_inverted) { 1122 n1 = a1->ref; 1123 n2 = a2->ref; 1124 } 1125 if (strcasecmp(n1, n2) > 0) { 1126 struct aliasinfo t; 1127 1128 memcpy(&t, a1, sizeof(struct aliasinfo)); 1129 memcpy(a1, a2, sizeof(struct aliasinfo)); 1130 memcpy(a2, &t, sizeof(struct aliasinfo)); 1131 } 1132 } 1133 } 1134 } 1135 1136 static void link_slabs(void) 1137 { 1138 struct aliasinfo *a; 1139 struct slabinfo *s; 1140 1141 for (a = aliasinfo; a < aliasinfo + aliases; a++) { 1142 1143 for (s = slabinfo; s < slabinfo + slabs; s++) 1144 if (strcmp(a->ref, s->name) == 0) { 1145 a->slab = s; 1146 s->refs++; 1147 break; 1148 } 1149 if (s == slabinfo + slabs) 1150 fatal("Unresolved alias %s\n", a->ref); 1151 } 1152 } 1153 1154 static void alias(void) 1155 { 1156 struct aliasinfo *a; 1157 char *active = NULL; 1158 1159 sort_aliases(); 1160 link_slabs(); 1161 1162 for(a = aliasinfo; a < aliasinfo + aliases; a++) { 1163 1164 if (!show_single_ref && a->slab->refs == 1) 1165 continue; 1166 1167 if (!show_inverted) { 1168 if (active) { 1169 if (strcmp(a->slab->name, active) == 0) { 1170 printf(" %s", a->name); 1171 continue; 1172 } 1173 } 1174 printf("\n%-12s <- %s", a->slab->name, a->name); 1175 active = a->slab->name; 1176 } 1177 else 1178 printf("%-15s -> %s\n", a->name, a->slab->name); 1179 } 1180 if (active) 1181 printf("\n"); 1182 } 1183 1184 1185 static void rename_slabs(void) 1186 { 1187 struct slabinfo *s; 1188 struct aliasinfo *a; 1189 1190 for (s = slabinfo; s < slabinfo + slabs; s++) { 1191 if (*s->name != ':') 1192 continue; 1193 1194 if (s->refs > 1 && !show_first_alias) 1195 continue; 1196 1197 a = find_one_alias(s); 1198 1199 if (a) 1200 s->name = a->name; 1201 else { 1202 s->name = "*"; 1203 actual_slabs--; 1204 } 1205 } 1206 } 1207 1208 static int slab_mismatch(char *slab) 1209 { 1210 return regexec(&pattern, slab, 0, NULL, 0); 1211 } 1212 1213 static void read_slab_dir(void) 1214 { 1215 DIR *dir; 1216 struct dirent *de; 1217 struct slabinfo *slab = slabinfo; 1218 struct aliasinfo *alias = aliasinfo; 1219 char *p; 1220 char *t; 1221 int count; 1222 1223 if (chdir("/sys/kernel/slab") && chdir("/sys/slab")) 1224 fatal("SYSFS support for SLUB not active\n"); 1225 1226 dir = opendir("."); 1227 while ((de = readdir(dir))) { 1228 if (de->d_name[0] == '.' || 1229 (de->d_name[0] != ':' && slab_mismatch(de->d_name))) 1230 continue; 1231 switch (de->d_type) { 1232 case DT_LNK: 1233 if (alias - aliasinfo == MAX_ALIASES) 1234 fatal("Too many aliases\n"); 1235 alias->name = strdup(de->d_name); 1236 count = readlink(de->d_name, buffer, sizeof(buffer)-1); 1237 1238 if (count < 0) 1239 fatal("Cannot read symlink %s\n", de->d_name); 1240 1241 buffer[count] = 0; 1242 p = buffer + count; 1243 while (p > buffer && p[-1] != '/') 1244 p--; 1245 alias->ref = strdup(p); 1246 alias++; 1247 break; 1248 case DT_DIR: 1249 if (slab - slabinfo == MAX_SLABS) 1250 fatal("Too many slabs\n"); 1251 if (chdir(de->d_name)) 1252 fatal("Unable to access slab %s\n", slab->name); 1253 slab->name = strdup(de->d_name); 1254 slab->alias = 0; 1255 slab->refs = 0; 1256 slab->aliases = get_obj("aliases"); 1257 slab->align = get_obj("align"); 1258 slab->cache_dma = get_obj("cache_dma"); 1259 slab->cpu_slabs = get_obj("cpu_slabs"); 1260 slab->destroy_by_rcu = get_obj("destroy_by_rcu"); 1261 slab->hwcache_align = get_obj("hwcache_align"); 1262 slab->object_size = get_obj("object_size"); 1263 slab->objects = get_obj("objects"); 1264 slab->objects_partial = get_obj("objects_partial"); 1265 slab->objects_total = get_obj("objects_total"); 1266 slab->objs_per_slab = get_obj("objs_per_slab"); 1267 slab->order = get_obj("order"); 1268 slab->partial = get_obj_and_str("partial", &t); 1269 decode_numa_list(slab->numa_partial, t); 1270 free(t); 1271 slab->poison = get_obj("poison"); 1272 slab->reclaim_account = get_obj("reclaim_account"); 1273 slab->red_zone = get_obj("red_zone"); 1274 slab->sanity_checks = get_obj("sanity_checks"); 1275 slab->slab_size = get_obj("slab_size"); 1276 slab->slabs = get_obj_and_str("slabs", &t); 1277 decode_numa_list(slab->numa, t); 1278 free(t); 1279 slab->store_user = get_obj("store_user"); 1280 slab->trace = get_obj("trace"); 1281 slab->alloc_fastpath = get_obj("alloc_fastpath"); 1282 slab->alloc_slowpath = get_obj("alloc_slowpath"); 1283 slab->free_fastpath = get_obj("free_fastpath"); 1284 slab->free_slowpath = get_obj("free_slowpath"); 1285 slab->free_frozen= get_obj("free_frozen"); 1286 slab->free_add_partial = get_obj("free_add_partial"); 1287 slab->free_remove_partial = get_obj("free_remove_partial"); 1288 slab->alloc_from_partial = get_obj("alloc_from_partial"); 1289 slab->alloc_slab = get_obj("alloc_slab"); 1290 slab->alloc_refill = get_obj("alloc_refill"); 1291 slab->free_slab = get_obj("free_slab"); 1292 slab->cpuslab_flush = get_obj("cpuslab_flush"); 1293 slab->deactivate_full = get_obj("deactivate_full"); 1294 slab->deactivate_empty = get_obj("deactivate_empty"); 1295 slab->deactivate_to_head = get_obj("deactivate_to_head"); 1296 slab->deactivate_to_tail = get_obj("deactivate_to_tail"); 1297 slab->deactivate_remote_frees = get_obj("deactivate_remote_frees"); 1298 slab->order_fallback = get_obj("order_fallback"); 1299 slab->cmpxchg_double_cpu_fail = get_obj("cmpxchg_double_cpu_fail"); 1300 slab->cmpxchg_double_fail = get_obj("cmpxchg_double_fail"); 1301 slab->cpu_partial_alloc = get_obj("cpu_partial_alloc"); 1302 slab->cpu_partial_free = get_obj("cpu_partial_free"); 1303 slab->alloc_node_mismatch = get_obj("alloc_node_mismatch"); 1304 slab->deactivate_bypass = get_obj("deactivate_bypass"); 1305 if (chdir("..")) 1306 fatal("Unable to chdir from slab ../%s\n", 1307 slab->name); 1308 if (slab->name[0] == ':') 1309 alias_targets++; 1310 slab++; 1311 break; 1312 default : 1313 fatal("Unknown file type %lx\n", de->d_type); 1314 } 1315 } 1316 closedir(dir); 1317 slabs = slab - slabinfo; 1318 actual_slabs = slabs; 1319 aliases = alias - aliasinfo; 1320 } 1321 1322 static void output_slabs(void) 1323 { 1324 struct slabinfo *slab; 1325 int lines = output_lines; 1326 1327 for (slab = slabinfo; (slab < slabinfo + slabs) && 1328 lines != 0; slab++) { 1329 1330 if (slab->alias) 1331 continue; 1332 1333 if (lines != -1) 1334 lines--; 1335 1336 if (show_numa) 1337 slab_numa(slab, 0); 1338 else if (show_track) 1339 show_tracking(slab); 1340 else if (validate) 1341 slab_validate(slab); 1342 else if (shrink) 1343 slab_shrink(slab); 1344 else if (set_debug) 1345 slab_debug(slab); 1346 else if (show_ops) 1347 ops(slab); 1348 else if (show_slab) 1349 slabcache(slab); 1350 else if (show_report) 1351 report(slab); 1352 } 1353 } 1354 1355 static void _xtotals(char *heading, char *underline, 1356 int loss, int size, int partial) 1357 { 1358 printf("%s%s", heading, underline); 1359 line = 0; 1360 sort_loss = loss; 1361 sort_size = size; 1362 sort_partial = partial; 1363 sort_slabs(); 1364 output_slabs(); 1365 } 1366 1367 static void xtotals(void) 1368 { 1369 char *heading, *underline; 1370 1371 totals(); 1372 1373 link_slabs(); 1374 rename_slabs(); 1375 1376 heading = "\nSlabs sorted by size\n"; 1377 underline = "--------------------\n"; 1378 _xtotals(heading, underline, 0, 1, 0); 1379 1380 heading = "\nSlabs sorted by loss\n"; 1381 underline = "--------------------\n"; 1382 _xtotals(heading, underline, 1, 0, 0); 1383 1384 heading = "\nSlabs sorted by number of partial slabs\n"; 1385 underline = "---------------------------------------\n"; 1386 _xtotals(heading, underline, 0, 0, 1); 1387 1388 printf("\n"); 1389 } 1390 1391 struct option opts[] = { 1392 { "aliases", no_argument, NULL, 'a' }, 1393 { "activity", no_argument, NULL, 'A' }, 1394 { "Bytes", no_argument, NULL, 'B'}, 1395 { "debug", optional_argument, NULL, 'd' }, 1396 { "display-activity", no_argument, NULL, 'D' }, 1397 { "empty", no_argument, NULL, 'e' }, 1398 { "first-alias", no_argument, NULL, 'f' }, 1399 { "help", no_argument, NULL, 'h' }, 1400 { "inverted", no_argument, NULL, 'i'}, 1401 { "slabs", no_argument, NULL, 'l' }, 1402 { "Loss", no_argument, NULL, 'L'}, 1403 { "numa", no_argument, NULL, 'n' }, 1404 { "lines", required_argument, NULL, 'N'}, 1405 { "ops", no_argument, NULL, 'o' }, 1406 { "partial", no_argument, NULL, 'P'}, 1407 { "report", no_argument, NULL, 'r' }, 1408 { "shrink", no_argument, NULL, 's' }, 1409 { "Size", no_argument, NULL, 'S'}, 1410 { "tracking", no_argument, NULL, 't'}, 1411 { "Totals", no_argument, NULL, 'T'}, 1412 { "Unreclaim", no_argument, NULL, 'U'}, 1413 { "validate", no_argument, NULL, 'v' }, 1414 { "Xtotals", no_argument, NULL, 'X'}, 1415 { "zero", no_argument, NULL, 'z' }, 1416 { "1ref", no_argument, NULL, '1'}, 1417 { NULL, 0, NULL, 0 } 1418 }; 1419 1420 int main(int argc, char *argv[]) 1421 { 1422 int c; 1423 int err; 1424 char *pattern_source; 1425 1426 page_size = getpagesize(); 1427 1428 while ((c = getopt_long(argc, argv, "aABd::DefhilLnN:oPrsStTUvXz1", 1429 opts, NULL)) != -1) 1430 switch (c) { 1431 case 'a': 1432 show_alias = 1; 1433 break; 1434 case 'A': 1435 sort_active = 1; 1436 break; 1437 case 'B': 1438 show_bytes = 1; 1439 break; 1440 case 'd': 1441 set_debug = 1; 1442 if (!debug_opt_scan(optarg)) 1443 fatal("Invalid debug option '%s'\n", optarg); 1444 break; 1445 case 'D': 1446 show_activity = 1; 1447 break; 1448 case 'e': 1449 show_empty = 1; 1450 break; 1451 case 'f': 1452 show_first_alias = 1; 1453 break; 1454 case 'h': 1455 usage(); 1456 return 0; 1457 case 'i': 1458 show_inverted = 1; 1459 break; 1460 case 'l': 1461 show_slab = 1; 1462 break; 1463 case 'L': 1464 sort_loss = 1; 1465 break; 1466 case 'n': 1467 show_numa = 1; 1468 break; 1469 case 'N': 1470 if (optarg) { 1471 output_lines = atoi(optarg); 1472 if (output_lines < 1) 1473 output_lines = 1; 1474 } 1475 break; 1476 case 'o': 1477 show_ops = 1; 1478 break; 1479 case 'r': 1480 show_report = 1; 1481 break; 1482 case 'P': 1483 sort_partial = 1; 1484 break; 1485 case 's': 1486 shrink = 1; 1487 break; 1488 case 'S': 1489 sort_size = 1; 1490 break; 1491 case 't': 1492 show_track = 1; 1493 break; 1494 case 'T': 1495 show_totals = 1; 1496 break; 1497 case 'U': 1498 unreclaim_only = 1; 1499 break; 1500 case 'v': 1501 validate = 1; 1502 break; 1503 case 'X': 1504 if (output_lines == -1) 1505 output_lines = 1; 1506 extended_totals = 1; 1507 show_bytes = 1; 1508 break; 1509 case 'z': 1510 skip_zero = 0; 1511 break; 1512 case '1': 1513 show_single_ref = 1; 1514 break; 1515 default: 1516 fatal("%s: Invalid option '%c'\n", argv[0], optopt); 1517 1518 } 1519 1520 if (!show_slab && !show_alias && !show_track && !show_report 1521 && !validate && !shrink && !set_debug && !show_ops) 1522 show_slab = 1; 1523 1524 if (argc > optind) 1525 pattern_source = argv[optind]; 1526 else 1527 pattern_source = ".*"; 1528 1529 err = regcomp(&pattern, pattern_source, REG_ICASE|REG_NOSUB); 1530 if (err) 1531 fatal("%s: Invalid pattern '%s' code %d\n", 1532 argv[0], pattern_source, err); 1533 read_slab_dir(); 1534 if (show_alias) { 1535 alias(); 1536 } else if (extended_totals) { 1537 xtotals(); 1538 } else if (show_totals) { 1539 totals(); 1540 } else { 1541 link_slabs(); 1542 rename_slabs(); 1543 sort_slabs(); 1544 output_slabs(); 1545 } 1546 return 0; 1547 } 1548