The Android Open Source Project | e16cb84 | 2009-03-03 19:32:58 -0800 | [diff] [blame] | 1 | #include <stdlib.h> |
| 2 | #include <stdio.h> |
| 3 | #include <string.h> |
| 4 | #include <unistd.h> |
| 5 | #include <errno.h> |
| 6 | #include <ctype.h> |
| 7 | #include <limits.h> |
| 8 | |
| 9 | #define STRINGIFY_ARG(a) #a |
| 10 | #define STRINGIFY(a) STRINGIFY_ARG(a) |
| 11 | |
| 12 | #define DEF_SORT_FUNC sort_nr_objs |
| 13 | #define SLABINFO_LINE_LEN 512 /* size of longest line */ |
| 14 | #define SLABINFO_NAME_LEN 32 /* cache name size (will truncate) */ |
| 15 | #define SLABINFO_FILE "/proc/slabinfo" |
| 16 | #define DEF_NR_ROWS 15 /* default nr of caches to show */ |
| 17 | |
| 18 | /* object representing a slab cache (each line of slabinfo) */ |
| 19 | struct slab_info { |
| 20 | char name[SLABINFO_NAME_LEN]; /* name of this cache */ |
| 21 | struct slab_info *next; |
| 22 | unsigned long nr_pages; /* size of cache in pages */ |
| 23 | unsigned long nr_objs; /* number of objects in this cache */ |
| 24 | unsigned long nr_active_objs; /* number of active objects */ |
| 25 | unsigned long obj_size; /* size of each object */ |
| 26 | unsigned long objs_per_slab; /* number of objects per slab */ |
| 27 | unsigned long nr_slabs; /* number of slabs in this cache */ |
| 28 | unsigned long use; /* percent full: total / active */ |
| 29 | }; |
| 30 | |
| 31 | /* object representing system-wide statistics */ |
| 32 | struct slab_stat { |
| 33 | unsigned long total_size; /* size of all objects */ |
| 34 | unsigned long active_size; /* size of all active objects */ |
| 35 | unsigned long nr_objs; /* total number of objects */ |
| 36 | unsigned long nr_active_objs; /* total number of active objects */ |
| 37 | unsigned long nr_slabs; /* total number of slabs */ |
| 38 | unsigned long nr_active_slabs; /* total number of active slabs*/ |
| 39 | unsigned long nr_caches; /* number of caches */ |
| 40 | unsigned long nr_active_caches; /* number of active caches */ |
| 41 | unsigned long avg_obj_size; /* average object size */ |
| 42 | unsigned long min_obj_size; /* size of smallest object */ |
| 43 | unsigned long max_obj_size; /* size of largest object */ |
| 44 | }; |
| 45 | |
| 46 | typedef int (*sort_t)(const struct slab_info *, const struct slab_info *); |
| 47 | static sort_t sort_func; |
| 48 | |
| 49 | /* |
| 50 | * get_slabinfo - open, read, and parse a slabinfo 2.x file, which has the |
| 51 | * following format: |
| 52 | * |
| 53 | * slabinfo - version: 2.1 |
| 54 | * <name> <active_objs> <num_objs> <objsize> <objperslab> <pagesperslab> |
| 55 | * : tunables <limit> <batchcount> <sharedfactor> |
| 56 | * : slabdata <active_slabs> <num_slabs> <sharedavail> |
| 57 | * |
| 58 | * Returns the head of the new list of slab_info structures, or NULL on error. |
| 59 | */ |
| 60 | static struct slab_info * get_slabinfo(struct slab_stat *stats) |
| 61 | { |
| 62 | struct slab_info *head = NULL, *p = NULL, *prev = NULL; |
| 63 | FILE *slabfile; |
| 64 | char line[SLABINFO_LINE_LEN]; |
| 65 | unsigned int major, minor; |
| 66 | |
| 67 | slabfile = fopen(SLABINFO_FILE, "r"); |
| 68 | if (!slabfile) { |
| 69 | perror("fopen"); |
| 70 | return NULL; |
| 71 | } |
| 72 | |
| 73 | if (!fgets(line, SLABINFO_LINE_LEN, slabfile)) { |
| 74 | fprintf(stderr, "cannot read from " SLABINFO_FILE "\n"); |
| 75 | return NULL; |
| 76 | } |
| 77 | |
| 78 | if (sscanf(line, "slabinfo - version: %u.%u", &major, &minor) != 2) { |
| 79 | fprintf(stderr, "unable to parse slabinfo version!\n"); |
| 80 | return NULL; |
| 81 | } |
| 82 | |
| 83 | if (major != 2 || minor > 1) { |
| 84 | fprintf(stderr, "we only support slabinfo 2.0 and 2.1!\n"); |
| 85 | return NULL; |
| 86 | } |
| 87 | |
| 88 | stats->min_obj_size = INT_MAX; |
| 89 | |
| 90 | while (fgets(line, SLABINFO_LINE_LEN, slabfile)) { |
| 91 | unsigned long nr_active_slabs, pages_per_slab; |
| 92 | int ret; |
| 93 | |
| 94 | if (line[0] == '#') |
| 95 | continue; |
| 96 | |
| 97 | p = malloc(sizeof (struct slab_info)); |
| 98 | if (!p) { |
| 99 | perror("malloc"); |
| 100 | head = NULL; |
| 101 | break; |
| 102 | } |
| 103 | if (stats->nr_caches++ == 0) |
| 104 | head = prev = p; |
| 105 | |
| 106 | ret = sscanf(line, "%" STRINGIFY(SLABINFO_NAME_LEN) "s" |
| 107 | " %lu %lu %lu %lu %lu : tunables %*d %*d %*d : \ |
| 108 | slabdata %lu %lu %*d", p->name, |
| 109 | &p->nr_active_objs, &p->nr_objs, |
| 110 | &p->obj_size, &p->objs_per_slab, |
| 111 | &pages_per_slab, |
| 112 | &nr_active_slabs, |
| 113 | &p->nr_slabs); |
| 114 | |
| 115 | if (ret != 8) { |
| 116 | fprintf(stderr, "unrecognizable data in slabinfo!\n"); |
| 117 | head = NULL; |
| 118 | break; |
| 119 | } |
| 120 | |
| 121 | if (p->obj_size < stats->min_obj_size) |
| 122 | stats->min_obj_size = p->obj_size; |
| 123 | if (p->obj_size > stats->max_obj_size) |
| 124 | stats->max_obj_size = p->obj_size; |
| 125 | |
| 126 | p->nr_pages = p->nr_slabs * pages_per_slab; |
| 127 | |
| 128 | if (p->nr_objs) { |
| 129 | p->use = 100 * p->nr_active_objs / p->nr_objs; |
| 130 | stats->nr_active_caches++; |
| 131 | } else |
| 132 | p->use = 0; |
| 133 | |
| 134 | stats->nr_objs += p->nr_objs; |
| 135 | stats->nr_active_objs += p->nr_active_objs; |
| 136 | stats->total_size += p->nr_objs * p->obj_size; |
| 137 | stats->active_size += p->nr_active_objs * p->obj_size; |
| 138 | stats->nr_slabs += p->nr_slabs; |
| 139 | stats->nr_active_slabs += nr_active_slabs; |
| 140 | |
| 141 | prev->next = p; |
| 142 | prev = p; |
| 143 | } |
| 144 | |
| 145 | if (fclose(slabfile)) |
| 146 | perror("fclose"); |
| 147 | |
| 148 | if (p) |
| 149 | p->next = NULL; |
| 150 | if (stats->nr_objs) |
| 151 | stats->avg_obj_size = stats->total_size / stats->nr_objs; |
| 152 | |
| 153 | return head; |
| 154 | } |
| 155 | |
| 156 | /* |
| 157 | * free_slablist - deallocate the memory associated with each node in the |
| 158 | * provided slab_info linked list |
| 159 | */ |
| 160 | static void free_slablist(struct slab_info *list) |
| 161 | { |
| 162 | while (list) { |
| 163 | struct slab_info *temp = list->next; |
| 164 | free(list); |
| 165 | list = temp; |
| 166 | } |
| 167 | } |
| 168 | |
| 169 | static struct slab_info *merge_objs(struct slab_info *a, struct slab_info *b) |
| 170 | { |
| 171 | struct slab_info list; |
| 172 | struct slab_info *p = &list; |
| 173 | |
| 174 | while (a && b) { |
| 175 | if (sort_func(a, b)) { |
| 176 | p->next = a; |
| 177 | p = a; |
| 178 | a = a->next; |
| 179 | } else { |
| 180 | p->next = b; |
| 181 | p = b; |
| 182 | b = b->next; |
| 183 | } |
| 184 | } |
| 185 | |
| 186 | p->next = (a == NULL) ? b : a; |
| 187 | return list.next; |
| 188 | } |
| 189 | |
| 190 | /* |
| 191 | * slabsort - merge sort the slab_info linked list based on sort_func |
| 192 | */ |
| 193 | static struct slab_info *slabsort(struct slab_info *list) |
| 194 | { |
| 195 | struct slab_info *a, *b; |
| 196 | |
| 197 | if (!list || !list->next) |
| 198 | return list; |
| 199 | |
| 200 | a = list; |
| 201 | b = list->next; |
| 202 | |
| 203 | while (b && b->next) { |
| 204 | list = list->next; |
| 205 | b = b->next->next; |
| 206 | } |
| 207 | |
| 208 | b = list->next; |
| 209 | list->next = NULL; |
| 210 | |
| 211 | return merge_objs(slabsort(a), slabsort(b)); |
| 212 | } |
| 213 | |
| 214 | /* |
| 215 | * Sort Routines. Each of these should be associated with a command-line |
| 216 | * search option. The functions should fit the prototype: |
| 217 | * |
| 218 | * int sort_foo(const struct slab_info *a, const struct slab_info *b) |
| 219 | * |
| 220 | * They return zero if the first parameter is smaller than the second. |
| 221 | * Otherwise, they return nonzero. |
| 222 | */ |
| 223 | |
| 224 | static int sort_name(const struct slab_info *a, const struct slab_info *b) |
| 225 | { |
| 226 | return (strcmp(a->name, b->name) < 0 ) ? 1: 0; |
| 227 | } |
| 228 | |
| 229 | #define BUILD_SORT_FUNC(VAL) \ |
| 230 | static int sort_ ## VAL \ |
| 231 | (const struct slab_info *a, const struct slab_info *b) { \ |
| 232 | return (a-> VAL > b-> VAL); } |
| 233 | |
| 234 | BUILD_SORT_FUNC(nr_objs) |
| 235 | BUILD_SORT_FUNC(nr_active_objs) |
| 236 | BUILD_SORT_FUNC(obj_size) |
| 237 | BUILD_SORT_FUNC(objs_per_slab) |
| 238 | BUILD_SORT_FUNC(nr_slabs) |
| 239 | BUILD_SORT_FUNC(use) |
| 240 | BUILD_SORT_FUNC(nr_pages) |
| 241 | |
| 242 | /* |
| 243 | * set_sort_func - return the slab_sort_func that matches the given key. |
| 244 | * On unrecognizable key, the call returns NULL. |
| 245 | */ |
| 246 | static void * set_sort_func(char key) |
| 247 | { |
| 248 | switch (tolower(key)) { |
| 249 | case 'a': |
| 250 | return sort_nr_active_objs; |
| 251 | case 'c': |
| 252 | return sort_nr_pages; |
| 253 | case 'l': |
| 254 | return sort_nr_slabs; |
| 255 | case 'n': |
| 256 | return sort_name; |
| 257 | case 'o': |
| 258 | return sort_nr_objs; |
| 259 | case 'p': |
| 260 | return sort_objs_per_slab; |
| 261 | case 's': |
| 262 | return sort_obj_size; |
| 263 | case 'u': |
| 264 | return sort_use; |
| 265 | default: |
| 266 | return NULL; |
| 267 | } |
| 268 | } |
| 269 | |
| 270 | int main(int argc, char *argv[]) |
| 271 | { |
| 272 | struct slab_info *list, *p; |
| 273 | struct slab_stat stats = { .nr_objs = 0 }; |
| 274 | unsigned int page_size = getpagesize() / 1024, nr_rows = DEF_NR_ROWS, i; |
| 275 | |
| 276 | sort_func = DEF_SORT_FUNC; |
| 277 | |
| 278 | if (argc > 1) { |
| 279 | /* FIXME: Ugh. */ |
| 280 | if (argc == 3 && !strcmp(argv[1], "-n")) { |
| 281 | errno = 0; |
| 282 | nr_rows = (unsigned int) strtoul(argv[2], NULL, 0); |
| 283 | if (errno) { |
| 284 | perror("strtoul"); |
| 285 | exit(EXIT_FAILURE); |
| 286 | } |
| 287 | } |
| 288 | else if (argc == 3 && !strcmp(argv[1], "-s")) |
| 289 | sort_func = set_sort_func(argv[2][0]) ? : DEF_SORT_FUNC; |
| 290 | else { |
| 291 | fprintf(stderr, "usage: %s [options]\n\n", argv[0]); |
| 292 | fprintf(stderr, "options:\n"); |
| 293 | fprintf(stderr, " -s S specify sort criteria S\n"); |
| 294 | fprintf(stderr, " -h display this help\n\n"); |
| 295 | fprintf(stderr, "Valid sort criteria:\n"); |
| 296 | fprintf(stderr, " a: number of Active objects\n"); |
| 297 | fprintf(stderr, " c: Cache size\n"); |
| 298 | fprintf(stderr, " l: number of sLabs\n"); |
| 299 | fprintf(stderr, " n: Name\n"); |
| 300 | fprintf(stderr, " o: number of Objects\n"); |
| 301 | fprintf(stderr, " p: objects Per slab\n"); |
| 302 | fprintf(stderr, " s: object Size\n"); |
| 303 | fprintf(stderr, " u: cache Utilization\n"); |
| 304 | exit(EXIT_FAILURE); |
| 305 | } |
| 306 | } |
| 307 | |
| 308 | list = get_slabinfo (&stats); |
| 309 | if (!list) |
| 310 | exit(EXIT_FAILURE); |
| 311 | |
| 312 | printf(" Active / Total Objects (%% used) : %lu / %lu (%.1f%%)\n" |
| 313 | " Active / Total Slabs (%% used) : %lu / %lu (%.1f%%)\n" |
| 314 | " Active / Total Caches (%% used) : %lu / %lu (%.1f%%)\n" |
| 315 | " Active / Total Size (%% used) : %.2fK / %.2fK (%.1f%%)\n" |
| 316 | " Min / Avg / Max Object Size : %.2fK / %.2fK / %.2fK\n\n", |
| 317 | stats.nr_active_objs, |
| 318 | stats.nr_objs, |
| 319 | 100.0 * stats.nr_active_objs / stats.nr_objs, |
| 320 | stats.nr_active_slabs, |
| 321 | stats.nr_slabs, |
| 322 | 100.0 * stats.nr_active_slabs / stats.nr_slabs, |
| 323 | stats.nr_active_caches, |
| 324 | stats.nr_caches, |
| 325 | 100.0 * stats.nr_active_caches / stats.nr_caches, |
| 326 | stats.active_size / 1024.0, |
| 327 | stats.total_size / 1024.0, |
| 328 | 100.0 * stats.active_size / stats.total_size, |
| 329 | stats.min_obj_size / 1024.0, |
| 330 | stats.avg_obj_size / 1024.0, |
| 331 | stats.max_obj_size / 1024.0); |
| 332 | |
| 333 | printf("%6s %6s %4s %8s %6s %8s %10s %-23s\n", |
| 334 | "OBJS", "ACTIVE", "USE", "OBJ SIZE", "SLABS", |
| 335 | "OBJ/SLAB", "CACHE SIZE", "NAME"); |
| 336 | |
| 337 | p = list = slabsort(list); |
| 338 | for (i = 0; i < nr_rows && p; i++) { |
| 339 | printf("%6lu %6lu %3lu%% %7.2fK %6lu %8lu %9luK %-23s\n", |
| 340 | p->nr_objs, p->nr_active_objs, p->use, |
| 341 | p->obj_size / 1024.0, p->nr_slabs, |
| 342 | p->objs_per_slab, |
| 343 | p->nr_pages * page_size, |
| 344 | p->name); |
| 345 | p = p->next; |
| 346 | } |
| 347 | |
| 348 | free_slablist(list); |
| 349 | |
| 350 | return 0; |
| 351 | } |