?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
virtio: fix trivial build bug
[wrt350n-kernel.git] / Documentation / vm / slabinfo.c
blob488c1f31b99249b75a9686cf42f08329bea896c9
1 /*
2 * Slabinfo: Tool to get reports about slabs
3 *
4 * (C) 2007 sgi, Christoph Lameter <clameter@sgi.com>
5 *
6 * Compile by:
7 *
8 * gcc -o slabinfo slabinfo.c
9 */
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <sys/types.h>
13 #include <dirent.h>
14 #include <strings.h>
15 #include <string.h>
16 #include <unistd.h>
17 #include <stdarg.h>
18 #include <getopt.h>
19 #include <regex.h>
20 #include <errno.h>
21
22 #define MAX_SLABS 500
23 #define MAX_ALIASES 500
24 #define MAX_NODES 1024
25
26 struct slabinfo {
27 char *name;
28 int alias;
29 int refs;
30 int aliases, align, cache_dma, cpu_slabs, destroy_by_rcu;
31 int hwcache_align, object_size, objs_per_slab;
32 int sanity_checks, slab_size, store_user, trace;
33 int order, poison, reclaim_account, red_zone;
34 unsigned long partial, objects, slabs;
35 int numa[MAX_NODES];
36 int numa_partial[MAX_NODES];
37 } slabinfo[MAX_SLABS];
38
39 struct aliasinfo {
40 char *name;
41 char *ref;
42 struct slabinfo *slab;
43 } aliasinfo[MAX_ALIASES];
44
45 int slabs = 0;
46 int actual_slabs = 0;
47 int aliases = 0;
48 int alias_targets = 0;
49 int highest_node = 0;
50
51 char buffer[4096];
52
53 int show_empty = 0;
54 int show_report = 0;
55 int show_alias = 0;
56 int show_slab = 0;
57 int skip_zero = 1;
58 int show_numa = 0;
59 int show_track = 0;
60 int show_first_alias = 0;
61 int validate = 0;
62 int shrink = 0;
63 int show_inverted = 0;
64 int show_single_ref = 0;
65 int show_totals = 0;
66 int sort_size = 0;
67 int set_debug = 0;
68 int show_ops = 0;
69
70 /* Debug options */
71 int sanity = 0;
72 int redzone = 0;
73 int poison = 0;
74 int tracking = 0;
75 int tracing = 0;
76
77 int page_size;
78
79 regex_t pattern;
80
81 void fatal(const char *x, ...)
82 {
83 va_list ap;
84
85 va_start(ap, x);
86 vfprintf(stderr, x, ap);
87 va_end(ap);
88 exit(EXIT_FAILURE);
89 }
90
91 void usage(void)
92 {
93 printf("slabinfo 5/7/2007. (c) 2007 sgi. clameter@sgi.com\n\n"
94 "slabinfo [-ahnpvtsz] [-d debugopts] [slab-regexp]\n"
95 "-a|--aliases Show aliases\n"
96 "-d<options>|--debug=<options> Set/Clear Debug options\n"
97 "-e|--empty Show empty slabs\n"
98 "-f|--first-alias Show first alias\n"
99 "-h|--help Show usage information\n"
100 "-i|--inverted Inverted list\n"
101 "-l|--slabs Show slabs\n"
102 "-n|--numa Show NUMA information\n"
103 "-o|--ops Show kmem_cache_ops\n"
104 "-s|--shrink Shrink slabs\n"
105 "-r|--report Detailed report on single slabs\n"
106 "-S|--Size Sort by size\n"
107 "-t|--tracking Show alloc/free information\n"
108 "-T|--Totals Show summary information\n"
109 "-v|--validate Validate slabs\n"
110 "-z|--zero Include empty slabs\n"
111 "-1|--1ref Single reference\n"
112 "\nValid debug options (FZPUT may be combined)\n"
113 "a / A Switch on all debug options (=FZUP)\n"
114 "- Switch off all debug options\n"
115 "f / F Sanity Checks (SLAB_DEBUG_FREE)\n"
116 "z / Z Redzoning\n"
117 "p / P Poisoning\n"
118 "u / U Tracking\n"
119 "t / T Tracing\n"
120 );
121 }
122
123 unsigned long read_obj(const char *name)
124 {
125 FILE *f = fopen(name, "r");
126
127 if (!f)
128 buffer[0] = 0;
129 else {
130 if (!fgets(buffer, sizeof(buffer), f))
131 buffer[0] = 0;
132 fclose(f);
133 if (buffer[strlen(buffer)] == '\n')
134 buffer[strlen(buffer)] = 0;
135 }
136 return strlen(buffer);
137 }
138
139
140 /*
141 * Get the contents of an attribute
142 */
143 unsigned long get_obj(const char *name)
144 {
145 if (!read_obj(name))
146 return 0;
147
148 return atol(buffer);
149 }
150
151 unsigned long get_obj_and_str(const char *name, char **x)
152 {
153 unsigned long result = 0;
154 char *p;
155
156 *x = NULL;
157
158 if (!read_obj(name)) {
159 x = NULL;
160 return 0;
161 }
162 result = strtoul(buffer, &p, 10);
163 while (*p == ' ')
164 p++;
165 if (*p)
166 *x = strdup(p);
167 return result;
168 }
169
170 void set_obj(struct slabinfo *s, const char *name, int n)
171 {
172 char x[100];
173 FILE *f;
174
175 snprintf(x, 100, "%s/%s", s->name, name);
176 f = fopen(x, "w");
177 if (!f)
178 fatal("Cannot write to %s\n", x);
179
180 fprintf(f, "%d\n", n);
181 fclose(f);
182 }
183
184 unsigned long read_slab_obj(struct slabinfo *s, const char *name)
185 {
186 char x[100];
187 FILE *f;
188 size_t l;
189
190 snprintf(x, 100, "%s/%s", s->name, name);
191 f = fopen(x, "r");
192 if (!f) {
193 buffer[0] = 0;
194 l = 0;
195 } else {
196 l = fread(buffer, 1, sizeof(buffer), f);
197 buffer[l] = 0;
198 fclose(f);
199 }
200 return l;
201 }
202
203
204 /*
205 * Put a size string together
206 */
207 int store_size(char *buffer, unsigned long value)
208 {
209 unsigned long divisor = 1;
210 char trailer = 0;
211 int n;
212
213 if (value > 1000000000UL) {
214 divisor = 100000000UL;
215 trailer = 'G';
216 } else if (value > 1000000UL) {
217 divisor = 100000UL;
218 trailer = 'M';
219 } else if (value > 1000UL) {
220 divisor = 100;
221 trailer = 'K';
222 }
223
224 value /= divisor;
225 n = sprintf(buffer, "%ld",value);
226 if (trailer) {
227 buffer[n] = trailer;
228 n++;
229 buffer[n] = 0;
230 }
231 if (divisor != 1) {
232 memmove(buffer + n - 2, buffer + n - 3, 4);
233 buffer[n-2] = '.';
234 n++;
235 }
236 return n;
237 }
238
239 void decode_numa_list(int *numa, char *t)
240 {
241 int node;
242 int nr;
243
244 memset(numa, 0, MAX_NODES * sizeof(int));
245
246 if (!t)
247 return;
248
249 while (*t == 'N') {
250 t++;
251 node = strtoul(t, &t, 10);
252 if (*t == '=') {
253 t++;
254 nr = strtoul(t, &t, 10);
255 numa[node] = nr;
256 if (node > highest_node)
257 highest_node = node;
258 }
259 while (*t == ' ')
260 t++;
261 }
262 }
263
264 void slab_validate(struct slabinfo *s)
265 {
266 if (strcmp(s->name, "*") == 0)
267 return;
268
269 set_obj(s, "validate", 1);
270 }
271
272 void slab_shrink(struct slabinfo *s)
273 {
274 if (strcmp(s->name, "*") == 0)
275 return;
276
277 set_obj(s, "shrink", 1);
278 }
279
280 int line = 0;
281
282 void first_line(void)
283 {
284 printf("Name Objects Objsize Space "
285 "Slabs/Part/Cpu O/S O %%Fr %%Ef Flg\n");
286 }
287
288 /*
289 * Find the shortest alias of a slab
290 */
291 struct aliasinfo *find_one_alias(struct slabinfo *find)
292 {
293 struct aliasinfo *a;
294 struct aliasinfo *best = NULL;
295
296 for(a = aliasinfo;a < aliasinfo + aliases; a++) {
297 if (a->slab == find &&
298 (!best || strlen(best->name) < strlen(a->name))) {
299 best = a;
300 if (strncmp(a->name,"kmall", 5) == 0)
301 return best;
302 }
303 }
304 return best;
305 }
306
307 unsigned long slab_size(struct slabinfo *s)
308 {
309 return s->slabs * (page_size << s->order);
310 }
311
312 void slab_numa(struct slabinfo *s, int mode)
313 {
314 int node;
315
316 if (strcmp(s->name, "*") == 0)
317 return;
318
319 if (!highest_node) {
320 printf("\n%s: No NUMA information available.\n", s->name);
321 return;
322 }
323
324 if (skip_zero && !s->slabs)
325 return;
326
327 if (!line) {
328 printf("\n%-21s:", mode ? "NUMA nodes" : "Slab");
329 for(node = 0; node <= highest_node; node++)
330 printf(" %4d", node);
331 printf("\n----------------------");
332 for(node = 0; node <= highest_node; node++)
333 printf("-----");
334 printf("\n");
335 }
336 printf("%-21s ", mode ? "All slabs" : s->name);
337 for(node = 0; node <= highest_node; node++) {
338 char b[20];
339
340 store_size(b, s->numa[node]);
341 printf(" %4s", b);
342 }
343 printf("\n");
344 if (mode) {
345 printf("%-21s ", "Partial slabs");
346 for(node = 0; node <= highest_node; node++) {
347 char b[20];
348
349 store_size(b, s->numa_partial[node]);
350 printf(" %4s", b);
351 }
352 printf("\n");
353 }
354 line++;
355 }
356
357 void show_tracking(struct slabinfo *s)
358 {
359 printf("\n%s: Kernel object allocation\n", s->name);
360 printf("-----------------------------------------------------------------------\n");
361 if (read_slab_obj(s, "alloc_calls"))
362 printf(buffer);
363 else
364 printf("No Data\n");
365
366 printf("\n%s: Kernel object freeing\n", s->name);
367 printf("------------------------------------------------------------------------\n");
368 if (read_slab_obj(s, "free_calls"))
369 printf(buffer);
370 else
371 printf("No Data\n");
372
373 }
374
375 void ops(struct slabinfo *s)
376 {
377 if (strcmp(s->name, "*") == 0)
378 return;
379
380 if (read_slab_obj(s, "ops")) {
381 printf("\n%s: kmem_cache operations\n", s->name);
382 printf("--------------------------------------------\n");
383 printf(buffer);
384 } else
385 printf("\n%s has no kmem_cache operations\n", s->name);
386 }
387
388 const char *onoff(int x)
389 {
390 if (x)
391 return "On ";
392 return "Off";
393 }
394
395 void report(struct slabinfo *s)
396 {
397 if (strcmp(s->name, "*") == 0)
398 return;
399
400 printf("\nSlabcache: %-20s Aliases: %2d Order : %2d Objects: %lu\n",
401 s->name, s->aliases, s->order, s->objects);
402 if (s->hwcache_align)
403 printf("** Hardware cacheline aligned\n");
404 if (s->cache_dma)
405 printf("** Memory is allocated in a special DMA zone\n");
406 if (s->destroy_by_rcu)
407 printf("** Slabs are destroyed via RCU\n");
408 if (s->reclaim_account)
409 printf("** Reclaim accounting active\n");
410
411 printf("\nSizes (bytes) Slabs Debug Memory\n");
412 printf("------------------------------------------------------------------------\n");
413 printf("Object : %7d Total : %7ld Sanity Checks : %s Total: %7ld\n",
414 s->object_size, s->slabs, onoff(s->sanity_checks),
415 s->slabs * (page_size << s->order));
416 printf("SlabObj: %7d Full : %7ld Redzoning : %s Used : %7ld\n",
417 s->slab_size, s->slabs - s->partial - s->cpu_slabs,
418 onoff(s->red_zone), s->objects * s->object_size);
419 printf("SlabSiz: %7d Partial: %7ld Poisoning : %s Loss : %7ld\n",
420 page_size << s->order, s->partial, onoff(s->poison),
421 s->slabs * (page_size << s->order) - s->objects * s->object_size);
422 printf("Loss : %7d CpuSlab: %7d Tracking : %s Lalig: %7ld\n",
423 s->slab_size - s->object_size, s->cpu_slabs, onoff(s->store_user),
424 (s->slab_size - s->object_size) * s->objects);
425 printf("Align : %7d Objects: %7d Tracing : %s Lpadd: %7ld\n",
426 s->align, s->objs_per_slab, onoff(s->trace),
427 ((page_size << s->order) - s->objs_per_slab * s->slab_size) *
428 s->slabs);
429
430 ops(s);
431 show_tracking(s);
432 slab_numa(s, 1);
433 }
434
435 void slabcache(struct slabinfo *s)
436 {
437 char size_str[20];
438 char dist_str[40];
439 char flags[20];
440 char *p = flags;
441
442 if (strcmp(s->name, "*") == 0)
443 return;
444
445 if (actual_slabs == 1) {
446 report(s);
447 return;
448 }
449
450 if (skip_zero && !show_empty && !s->slabs)
451 return;
452
453 if (show_empty && s->slabs)
454 return;
455
456 store_size(size_str, slab_size(s));
457 snprintf(dist_str, 40, "%lu/%lu/%d", s->slabs, s->partial, s->cpu_slabs);
458
459 if (!line++)
460 first_line();
461
462 if (s->aliases)
463 *p++ = '*';
464 if (s->cache_dma)
465 *p++ = 'd';
466 if (s->hwcache_align)
467 *p++ = 'A';
468 if (s->poison)
469 *p++ = 'P';
470 if (s->reclaim_account)
471 *p++ = 'a';
472 if (s->red_zone)
473 *p++ = 'Z';
474 if (s->sanity_checks)
475 *p++ = 'F';
476 if (s->store_user)
477 *p++ = 'U';
478 if (s->trace)
479 *p++ = 'T';
480
481 *p = 0;
482 printf("%-21s %8ld %7d %8s %14s %4d %1d %3ld %3ld %s\n",
483 s->name, s->objects, s->object_size, size_str, dist_str,
484 s->objs_per_slab, s->order,
485 s->slabs ? (s->partial * 100) / s->slabs : 100,
486 s->slabs ? (s->objects * s->object_size * 100) /
487 (s->slabs * (page_size << s->order)) : 100,
488 flags);
489 }
490
491 /*
492 * Analyze debug options. Return false if something is amiss.
493 */
494 int debug_opt_scan(char *opt)
495 {
496 if (!opt || !opt[0] || strcmp(opt, "-") == 0)
497 return 1;
498
499 if (strcasecmp(opt, "a") == 0) {
500 sanity = 1;
501 poison = 1;
502 redzone = 1;
503 tracking = 1;
504 return 1;
505 }
506
507 for ( ; *opt; opt++)
508 switch (*opt) {
509 case 'F' : case 'f':
510 if (sanity)
511 return 0;
512 sanity = 1;
513 break;
514 case 'P' : case 'p':
515 if (poison)
516 return 0;
517 poison = 1;
518 break;
519
520 case 'Z' : case 'z':
521 if (redzone)
522 return 0;
523 redzone = 1;
524 break;
525
526 case 'U' : case 'u':
527 if (tracking)
528 return 0;
529 tracking = 1;
530 break;
531
532 case 'T' : case 't':
533 if (tracing)
534 return 0;
535 tracing = 1;
536 break;
537 default:
538 return 0;
539 }
540 return 1;
541 }
542
543 int slab_empty(struct slabinfo *s)
544 {
545 if (s->objects > 0)
546 return 0;
547
548 /*
549 * We may still have slabs even if there are no objects. Shrinking will
550 * remove them.
551 */
552 if (s->slabs != 0)
553 set_obj(s, "shrink", 1);
554
555 return 1;
556 }
557
558 void slab_debug(struct slabinfo *s)
559 {
560 if (strcmp(s->name, "*") == 0)
561 return;
562
563 if (sanity && !s->sanity_checks) {
564 set_obj(s, "sanity", 1);
565 }
566 if (!sanity && s->sanity_checks) {
567 if (slab_empty(s))
568 set_obj(s, "sanity", 0);
569 else
570 fprintf(stderr, "%s not empty cannot disable sanity checks\n", s->name);
571 }
572 if (redzone && !s->red_zone) {
573 if (slab_empty(s))
574 set_obj(s, "red_zone", 1);
575 else
576 fprintf(stderr, "%s not empty cannot enable redzoning\n", s->name);
577 }
578 if (!redzone && s->red_zone) {
579 if (slab_empty(s))
580 set_obj(s, "red_zone", 0);
581 else
582 fprintf(stderr, "%s not empty cannot disable redzoning\n", s->name);
583 }
584 if (poison && !s->poison) {
585 if (slab_empty(s))
586 set_obj(s, "poison", 1);
587 else
588 fprintf(stderr, "%s not empty cannot enable poisoning\n", s->name);
589 }
590 if (!poison && s->poison) {
591 if (slab_empty(s))
592 set_obj(s, "poison", 0);
593 else
594 fprintf(stderr, "%s not empty cannot disable poisoning\n", s->name);
595 }
596 if (tracking && !s->store_user) {
597 if (slab_empty(s))
598 set_obj(s, "store_user", 1);
599 else
600 fprintf(stderr, "%s not empty cannot enable tracking\n", s->name);
601 }
602 if (!tracking && s->store_user) {
603 if (slab_empty(s))
604 set_obj(s, "store_user", 0);
605 else
606 fprintf(stderr, "%s not empty cannot disable tracking\n", s->name);
607 }
608 if (tracing && !s->trace) {
609 if (slabs == 1)
610 set_obj(s, "trace", 1);
611 else
612 fprintf(stderr, "%s can only enable trace for one slab at a time\n", s->name);
613 }
614 if (!tracing && s->trace)
615 set_obj(s, "trace", 1);
616 }
617
618 void totals(void)
619 {
620 struct slabinfo *s;
621
622 int used_slabs = 0;
623 char b1[20], b2[20], b3[20], b4[20];
624 unsigned long long max = 1ULL << 63;
625
626 /* Object size */
627 unsigned long long min_objsize = max, max_objsize = 0, avg_objsize;
628
629 /* Number of partial slabs in a slabcache */
630 unsigned long long min_partial = max, max_partial = 0,
631 avg_partial, total_partial = 0;
632
633 /* Number of slabs in a slab cache */
634 unsigned long long min_slabs = max, max_slabs = 0,
635 avg_slabs, total_slabs = 0;
636
637 /* Size of the whole slab */
638 unsigned long long min_size = max, max_size = 0,
639 avg_size, total_size = 0;
640
641 /* Bytes used for object storage in a slab */
642 unsigned long long min_used = max, max_used = 0,
643 avg_used, total_used = 0;
644
645 /* Waste: Bytes used for alignment and padding */
646 unsigned long long min_waste = max, max_waste = 0,
647 avg_waste, total_waste = 0;
648 /* Number of objects in a slab */
649 unsigned long long min_objects = max, max_objects = 0,
650 avg_objects, total_objects = 0;
651 /* Waste per object */
652 unsigned long long min_objwaste = max,
653 max_objwaste = 0, avg_objwaste,
654 total_objwaste = 0;
655
656 /* Memory per object */
657 unsigned long long min_memobj = max,
658 max_memobj = 0, avg_memobj,
659 total_objsize = 0;
660
661 /* Percentage of partial slabs per slab */
662 unsigned long min_ppart = 100, max_ppart = 0,
663 avg_ppart, total_ppart = 0;
664
665 /* Number of objects in partial slabs */
666 unsigned long min_partobj = max, max_partobj = 0,
667 avg_partobj, total_partobj = 0;
668
669 /* Percentage of partial objects of all objects in a slab */
670 unsigned long min_ppartobj = 100, max_ppartobj = 0,
671 avg_ppartobj, total_ppartobj = 0;
672
673
674 for (s = slabinfo; s < slabinfo + slabs; s++) {
675 unsigned long long size;
676 unsigned long used;
677 unsigned long long wasted;
678 unsigned long long objwaste;
679 long long objects_in_partial_slabs;
680 unsigned long percentage_partial_slabs;
681 unsigned long percentage_partial_objs;
682
683 if (!s->slabs || !s->objects)
684 continue;
685
686 used_slabs++;
687
688 size = slab_size(s);
689 used = s->objects * s->object_size;
690 wasted = size - used;
691 objwaste = s->slab_size - s->object_size;
692
693 objects_in_partial_slabs = s->objects -
694 (s->slabs - s->partial - s ->cpu_slabs) *
695 s->objs_per_slab;
696
697 if (objects_in_partial_slabs < 0)
698 objects_in_partial_slabs = 0;
699
700 percentage_partial_slabs = s->partial * 100 / s->slabs;
701 if (percentage_partial_slabs > 100)
702 percentage_partial_slabs = 100;
703
704 percentage_partial_objs = objects_in_partial_slabs * 100
705 / s->objects;
706
707 if (percentage_partial_objs > 100)
708 percentage_partial_objs = 100;
709
710 if (s->object_size < min_objsize)
711 min_objsize = s->object_size;
712 if (s->partial < min_partial)
713 min_partial = s->partial;
714 if (s->slabs < min_slabs)
715 min_slabs = s->slabs;
716 if (size < min_size)
717 min_size = size;
718 if (wasted < min_waste)
719 min_waste = wasted;
720 if (objwaste < min_objwaste)
721 min_objwaste = objwaste;
722 if (s->objects < min_objects)
723 min_objects = s->objects;
724 if (used < min_used)
725 min_used = used;
726 if (objects_in_partial_slabs < min_partobj)
727 min_partobj = objects_in_partial_slabs;
728 if (percentage_partial_slabs < min_ppart)
729 min_ppart = percentage_partial_slabs;
730 if (percentage_partial_objs < min_ppartobj)
731 min_ppartobj = percentage_partial_objs;
732 if (s->slab_size < min_memobj)
733 min_memobj = s->slab_size;
734
735 if (s->object_size > max_objsize)
736 max_objsize = s->object_size;
737 if (s->partial > max_partial)
738 max_partial = s->partial;
739 if (s->slabs > max_slabs)
740 max_slabs = s->slabs;
741 if (size > max_size)
742 max_size = size;
743 if (wasted > max_waste)
744 max_waste = wasted;
745 if (objwaste > max_objwaste)
746 max_objwaste = objwaste;
747 if (s->objects > max_objects)
748 max_objects = s->objects;
749 if (used > max_used)
750 max_used = used;
751 if (objects_in_partial_slabs > max_partobj)
752 max_partobj = objects_in_partial_slabs;
753 if (percentage_partial_slabs > max_ppart)
754 max_ppart = percentage_partial_slabs;
755 if (percentage_partial_objs > max_ppartobj)
756 max_ppartobj = percentage_partial_objs;
757 if (s->slab_size > max_memobj)
758 max_memobj = s->slab_size;
759
760 total_partial += s->partial;
761 total_slabs += s->slabs;
762 total_size += size;
763 total_waste += wasted;
764
765 total_objects += s->objects;
766 total_used += used;
767 total_partobj += objects_in_partial_slabs;
768 total_ppart += percentage_partial_slabs;
769 total_ppartobj += percentage_partial_objs;
770
771 total_objwaste += s->objects * objwaste;
772 total_objsize += s->objects * s->slab_size;
773 }
774
775 if (!total_objects) {
776 printf("No objects\n");
777 return;
778 }
779 if (!used_slabs) {
780 printf("No slabs\n");
781 return;
782 }
783
784 /* Per slab averages */
785 avg_partial = total_partial / used_slabs;
786 avg_slabs = total_slabs / used_slabs;
787 avg_size = total_size / used_slabs;
788 avg_waste = total_waste / used_slabs;
789
790 avg_objects = total_objects / used_slabs;
791 avg_used = total_used / used_slabs;
792 avg_partobj = total_partobj / used_slabs;
793 avg_ppart = total_ppart / used_slabs;
794 avg_ppartobj = total_ppartobj / used_slabs;
795
796 /* Per object object sizes */
797 avg_objsize = total_used / total_objects;
798 avg_objwaste = total_objwaste / total_objects;
799 avg_partobj = total_partobj * 100 / total_objects;
800 avg_memobj = total_objsize / total_objects;
801
802 printf("Slabcache Totals\n");
803 printf("----------------\n");
804 printf("Slabcaches : %3d Aliases : %3d->%-3d Active: %3d\n",
805 slabs, aliases, alias_targets, used_slabs);
806
807 store_size(b1, total_size);store_size(b2, total_waste);
808 store_size(b3, total_waste * 100 / total_used);
809 printf("Memory used: %6s # Loss : %6s MRatio:%6s%%\n", b1, b2, b3);
810
811 store_size(b1, total_objects);store_size(b2, total_partobj);
812 store_size(b3, total_partobj * 100 / total_objects);
813 printf("# Objects : %6s # PartObj: %6s ORatio:%6s%%\n", b1, b2, b3);
814
815 printf("\n");
816 printf("Per Cache Average Min Max Total\n");
817 printf("---------------------------------------------------------\n");
818
819 store_size(b1, avg_objects);store_size(b2, min_objects);
820 store_size(b3, max_objects);store_size(b4, total_objects);
821 printf("#Objects %10s %10s %10s %10s\n",
822 b1, b2, b3, b4);
823
824 store_size(b1, avg_slabs);store_size(b2, min_slabs);
825 store_size(b3, max_slabs);store_size(b4, total_slabs);
826 printf("#Slabs %10s %10s %10s %10s\n",
827 b1, b2, b3, b4);
828
829 store_size(b1, avg_partial);store_size(b2, min_partial);
830 store_size(b3, max_partial);store_size(b4, total_partial);
831 printf("#PartSlab %10s %10s %10s %10s\n",
832 b1, b2, b3, b4);
833 store_size(b1, avg_ppart);store_size(b2, min_ppart);
834 store_size(b3, max_ppart);
835 store_size(b4, total_partial * 100 / total_slabs);
836 printf("%%PartSlab%10s%% %10s%% %10s%% %10s%%\n",
837 b1, b2, b3, b4);
838
839 store_size(b1, avg_partobj);store_size(b2, min_partobj);
840 store_size(b3, max_partobj);
841 store_size(b4, total_partobj);
842 printf("PartObjs %10s %10s %10s %10s\n",
843 b1, b2, b3, b4);
844
845 store_size(b1, avg_ppartobj);store_size(b2, min_ppartobj);
846 store_size(b3, max_ppartobj);
847 store_size(b4, total_partobj * 100 / total_objects);
848 printf("%% PartObj%10s%% %10s%% %10s%% %10s%%\n",
849 b1, b2, b3, b4);
850
851 store_size(b1, avg_size);store_size(b2, min_size);
852 store_size(b3, max_size);store_size(b4, total_size);
853 printf("Memory %10s %10s %10s %10s\n",
854 b1, b2, b3, b4);
855
856 store_size(b1, avg_used);store_size(b2, min_used);
857 store_size(b3, max_used);store_size(b4, total_used);
858 printf("Used %10s %10s %10s %10s\n",
859 b1, b2, b3, b4);
860
861 store_size(b1, avg_waste);store_size(b2, min_waste);
862 store_size(b3, max_waste);store_size(b4, total_waste);
863 printf("Loss %10s %10s %10s %10s\n",
864 b1, b2, b3, b4);
865
866 printf("\n");
867 printf("Per Object Average Min Max\n");
868 printf("---------------------------------------------\n");
869
870 store_size(b1, avg_memobj);store_size(b2, min_memobj);
871 store_size(b3, max_memobj);
872 printf("Memory %10s %10s %10s\n",
873 b1, b2, b3);
874 store_size(b1, avg_objsize);store_size(b2, min_objsize);
875 store_size(b3, max_objsize);
876 printf("User %10s %10s %10s\n",
877 b1, b2, b3);
878
879 store_size(b1, avg_objwaste);store_size(b2, min_objwaste);
880 store_size(b3, max_objwaste);
881 printf("Loss %10s %10s %10s\n",
882 b1, b2, b3);
883 }
884
885 void sort_slabs(void)
886 {
887 struct slabinfo *s1,*s2;
888
889 for (s1 = slabinfo; s1 < slabinfo + slabs; s1++) {
890 for (s2 = s1 + 1; s2 < slabinfo + slabs; s2++) {
891 int result;
892
893 if (sort_size)
894 result = slab_size(s1) < slab_size(s2);
895 else
896 result = strcasecmp(s1->name, s2->name);
897
898 if (show_inverted)
899 result = -result;
900
901 if (result > 0) {
902 struct slabinfo t;
903
904 memcpy(&t, s1, sizeof(struct slabinfo));
905 memcpy(s1, s2, sizeof(struct slabinfo));
906 memcpy(s2, &t, sizeof(struct slabinfo));
907 }
908 }
909 }
910 }
911
912 void sort_aliases(void)
913 {
914 struct aliasinfo *a1,*a2;
915
916 for (a1 = aliasinfo; a1 < aliasinfo + aliases; a1++) {
917 for (a2 = a1 + 1; a2 < aliasinfo + aliases; a2++) {
918 char *n1, *n2;
919
920 n1 = a1->name;
921 n2 = a2->name;
922 if (show_alias && !show_inverted) {
923 n1 = a1->ref;
924 n2 = a2->ref;
925 }
926 if (strcasecmp(n1, n2) > 0) {
927 struct aliasinfo t;
928
929 memcpy(&t, a1, sizeof(struct aliasinfo));
930 memcpy(a1, a2, sizeof(struct aliasinfo));
931 memcpy(a2, &t, sizeof(struct aliasinfo));
932 }
933 }
934 }
935 }
936
937 void link_slabs(void)
938 {
939 struct aliasinfo *a;
940 struct slabinfo *s;
941
942 for (a = aliasinfo; a < aliasinfo + aliases; a++) {
943
944 for (s = slabinfo; s < slabinfo + slabs; s++)
945 if (strcmp(a->ref, s->name) == 0) {
946 a->slab = s;
947 s->refs++;
948 break;
949 }
950 if (s == slabinfo + slabs)
951 fatal("Unresolved alias %s\n", a->ref);
952 }
953 }
954
955 void alias(void)
956 {
957 struct aliasinfo *a;
958 char *active = NULL;
959
960 sort_aliases();
961 link_slabs();
962
963 for(a = aliasinfo; a < aliasinfo + aliases; a++) {
964
965 if (!show_single_ref && a->slab->refs == 1)
966 continue;
967
968 if (!show_inverted) {
969 if (active) {
970 if (strcmp(a->slab->name, active) == 0) {
971 printf(" %s", a->name);
972 continue;
973 }
974 }
975 printf("\n%-12s <- %s", a->slab->name, a->name);
976 active = a->slab->name;
977 }
978 else
979 printf("%-20s -> %s\n", a->name, a->slab->name);
980 }
981 if (active)
982 printf("\n");
983 }
984
985
986 void rename_slabs(void)
987 {
988 struct slabinfo *s;
989 struct aliasinfo *a;
990
991 for (s = slabinfo; s < slabinfo + slabs; s++) {
992 if (*s->name != ':')
993 continue;
994
995 if (s->refs > 1 && !show_first_alias)
996 continue;
997
998 a = find_one_alias(s);
999
1000 if (a)
1001 s->name = a->name;
1002 else {
1003 s->name = "*";
1004 actual_slabs--;
1005 }
1006 }
1007 }
1008
1009 int slab_mismatch(char *slab)
1010 {
1011 return regexec(&pattern, slab, 0, NULL, 0);
1012 }
1013
1014 void read_slab_dir(void)
1015 {
1016 DIR *dir;
1017 struct dirent *de;
1018 struct slabinfo *slab = slabinfo;
1019 struct aliasinfo *alias = aliasinfo;
1020 char *p;
1021 char *t;
1022 int count;
1023
1024 if (chdir("/sys/kernel/slab"))
1025 fatal("SYSFS support for SLUB not active\n");
1026
1027 dir = opendir(".");
1028 while ((de = readdir(dir))) {
1029 if (de->d_name[0] == '.' ||
1030 (de->d_name[0] != ':' && slab_mismatch(de->d_name)))
1031 continue;
1032 switch (de->d_type) {
1033 case DT_LNK:
1034 alias->name = strdup(de->d_name);
1035 count = readlink(de->d_name, buffer, sizeof(buffer));
1036
1037 if (count < 0)
1038 fatal("Cannot read symlink %s\n", de->d_name);
1039
1040 buffer[count] = 0;
1041 p = buffer + count;
1042 while (p > buffer && p[-1] != '/')
1043 p--;
1044 alias->ref = strdup(p);
1045 alias++;
1046 break;
1047 case DT_DIR:
1048 if (chdir(de->d_name))
1049 fatal("Unable to access slab %s\n", slab->name);
1050 slab->name = strdup(de->d_name);
1051 slab->alias = 0;
1052 slab->refs = 0;
1053 slab->aliases = get_obj("aliases");
1054 slab->align = get_obj("align");
1055 slab->cache_dma = get_obj("cache_dma");
1056 slab->cpu_slabs = get_obj("cpu_slabs");
1057 slab->destroy_by_rcu = get_obj("destroy_by_rcu");
1058 slab->hwcache_align = get_obj("hwcache_align");
1059 slab->object_size = get_obj("object_size");
1060 slab->objects = get_obj("objects");
1061 slab->objs_per_slab = get_obj("objs_per_slab");
1062 slab->order = get_obj("order");
1063 slab->partial = get_obj("partial");
1064 slab->partial = get_obj_and_str("partial", &t);
1065 decode_numa_list(slab->numa_partial, t);
1066 free(t);
1067 slab->poison = get_obj("poison");
1068 slab->reclaim_account = get_obj("reclaim_account");
1069 slab->red_zone = get_obj("red_zone");
1070 slab->sanity_checks = get_obj("sanity_checks");
1071 slab->slab_size = get_obj("slab_size");
1072 slab->slabs = get_obj_and_str("slabs", &t);
1073 decode_numa_list(slab->numa, t);
1074 free(t);
1075 slab->store_user = get_obj("store_user");
1076 slab->trace = get_obj("trace");
1077 chdir("..");
1078 if (slab->name[0] == ':')
1079 alias_targets++;
1080 slab++;
1081 break;
1082 default :
1083 fatal("Unknown file type %lx\n", de->d_type);
1084 }
1085 }
1086 closedir(dir);
1087 slabs = slab - slabinfo;
1088 actual_slabs = slabs;
1089 aliases = alias - aliasinfo;
1090 if (slabs > MAX_SLABS)
1091 fatal("Too many slabs\n");
1092 if (aliases > MAX_ALIASES)
1093 fatal("Too many aliases\n");
1094 }
1095
1096 void output_slabs(void)
1097 {
1098 struct slabinfo *slab;
1099
1100 for (slab = slabinfo; slab < slabinfo + slabs; slab++) {
1101
1102 if (slab->alias)
1103 continue;
1104
1105
1106 if (show_numa)
1107 slab_numa(slab, 0);
1108 else if (show_track)
1109 show_tracking(slab);
1110 else if (validate)
1111 slab_validate(slab);
1112 else if (shrink)
1113 slab_shrink(slab);
1114 else if (set_debug)
1115 slab_debug(slab);
1116 else if (show_ops)
1117 ops(slab);
1118 else if (show_slab)
1119 slabcache(slab);
1120 else if (show_report)
1121 report(slab);
1122 }
1123 }
1124
1125 struct option opts[] = {
1126 { "aliases", 0, NULL, 'a' },
1127 { "debug", 2, NULL, 'd' },
1128 { "empty", 0, NULL, 'e' },
1129 { "first-alias", 0, NULL, 'f' },
1130 { "help", 0, NULL, 'h' },
1131 { "inverted", 0, NULL, 'i'},
1132 { "numa", 0, NULL, 'n' },
1133 { "ops", 0, NULL, 'o' },
1134 { "report", 0, NULL, 'r' },
1135 { "shrink", 0, NULL, 's' },
1136 { "slabs", 0, NULL, 'l' },
1137 { "track", 0, NULL, 't'},
1138 { "validate", 0, NULL, 'v' },
1139 { "zero", 0, NULL, 'z' },
1140 { "1ref", 0, NULL, '1'},
1141 { NULL, 0, NULL, 0 }
1142 };
1143
1144 int main(int argc, char *argv[])
1145 {
1146 int c;
1147 int err;
1148 char *pattern_source;
1149
1150 page_size = getpagesize();
1151
1152 while ((c = getopt_long(argc, argv, "ad::efhil1noprstvzTS",
1153 opts, NULL)) != -1)
1154 switch (c) {
1155 case '1':
1156 show_single_ref = 1;
1157 break;
1158 case 'a':
1159 show_alias = 1;
1160 break;
1161 case 'd':
1162 set_debug = 1;
1163 if (!debug_opt_scan(optarg))
1164 fatal("Invalid debug option '%s'\n", optarg);
1165 break;
1166 case 'e':
1167 show_empty = 1;
1168 break;
1169 case 'f':
1170 show_first_alias = 1;
1171 break;
1172 case 'h':
1173 usage();
1174 return 0;
1175 case 'i':
1176 show_inverted = 1;
1177 break;
1178 case 'n':
1179 show_numa = 1;
1180 break;
1181 case 'o':
1182 show_ops = 1;
1183 break;
1184 case 'r':
1185 show_report = 1;
1186 break;
1187 case 's':
1188 shrink = 1;
1189 break;
1190 case 'l':
1191 show_slab = 1;
1192 break;
1193 case 't':
1194 show_track = 1;
1195 break;
1196 case 'v':
1197 validate = 1;
1198 break;
1199 case 'z':
1200 skip_zero = 0;
1201 break;
1202 case 'T':
1203 show_totals = 1;
1204 break;
1205 case 'S':
1206 sort_size = 1;
1207 break;
1208
1209 default:
1210 fatal("%s: Invalid option '%c'\n", argv[0], optopt);
1211
1212 }
1213
1214 if (!show_slab && !show_alias && !show_track && !show_report
1215 && !validate && !shrink && !set_debug && !show_ops)
1216 show_slab = 1;
1217
1218 if (argc > optind)
1219 pattern_source = argv[optind];
1220 else
1221 pattern_source = ".*";
1222
1223 err = regcomp(&pattern, pattern_source, REG_ICASE|REG_NOSUB);
1224 if (err)
1225 fatal("%s: Invalid pattern '%s' code %d\n",
1226 argv[0], pattern_source, err);
1227 read_slab_dir();
1228 if (show_alias)
1229 alias();
1230 else
1231 if (show_totals)
1232 totals();
1233 else {
1234 link_slabs();
1235 rename_slabs();
1236 sort_slabs();
1237 output_slabs();
1238 }
1239 return 0;
1240 }
WRT350N Kernel Patches