tools/mm/slabinfo.c

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