1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * User-space helper to sort the output of /sys/kernel/debug/page_owner 4 * 5 * Example use: 6 * cat /sys/kernel/debug/page_owner > page_owner_full.txt 7 * ./page_owner_sort page_owner_full.txt sorted_page_owner.txt 8 * Or sort by total memory: 9 * ./page_owner_sort -m page_owner_full.txt sorted_page_owner.txt 10 * 11 * See Documentation/mm/page_owner.rst 12 */ 13 14 #include <stdio.h> 15 #include <stdlib.h> 16 #include <sys/types.h> 17 #include <sys/stat.h> 18 #include <fcntl.h> 19 #include <unistd.h> 20 #include <string.h> 21 #include <regex.h> 22 #include <errno.h> 23 #include <linux/types.h> 24 #include <getopt.h> 25 26 #define bool int 27 #define true 1 28 #define false 0 29 #define TASK_COMM_LEN 16 30 31 struct block_list { 32 char *txt; 33 char *comm; // task command name 34 char *stacktrace; 35 __u64 ts_nsec; 36 __u64 free_ts_nsec; 37 int len; 38 int num; 39 int page_num; 40 pid_t pid; 41 pid_t tgid; 42 int allocator; 43 }; 44 enum FILTER_BIT { 45 FILTER_UNRELEASE = 1<<1, 46 FILTER_PID = 1<<2, 47 FILTER_TGID = 1<<3, 48 FILTER_COMM = 1<<4 49 }; 50 enum CULL_BIT { 51 CULL_UNRELEASE = 1<<1, 52 CULL_PID = 1<<2, 53 CULL_TGID = 1<<3, 54 CULL_COMM = 1<<4, 55 CULL_STACKTRACE = 1<<5, 56 CULL_ALLOCATOR = 1<<6 57 }; 58 enum ALLOCATOR_BIT { 59 ALLOCATOR_CMA = 1<<1, 60 ALLOCATOR_SLAB = 1<<2, 61 ALLOCATOR_VMALLOC = 1<<3, 62 ALLOCATOR_OTHERS = 1<<4 63 }; 64 enum ARG_TYPE { 65 ARG_TXT, ARG_COMM, ARG_STACKTRACE, ARG_ALLOC_TS, ARG_FREE_TS, 66 ARG_CULL_TIME, ARG_PAGE_NUM, ARG_PID, ARG_TGID, ARG_UNKNOWN, ARG_FREE, 67 ARG_ALLOCATOR 68 }; 69 enum SORT_ORDER { 70 SORT_ASC = 1, 71 SORT_DESC = -1, 72 }; 73 struct filter_condition { 74 pid_t *pids; 75 pid_t *tgids; 76 char **comms; 77 int pids_size; 78 int tgids_size; 79 int comms_size; 80 }; 81 struct sort_condition { 82 int (**cmps)(const void *, const void *); 83 int *signs; 84 int size; 85 }; 86 static struct filter_condition fc; 87 static struct sort_condition sc; 88 static regex_t order_pattern; 89 static regex_t pid_pattern; 90 static regex_t tgid_pattern; 91 static regex_t comm_pattern; 92 static regex_t ts_nsec_pattern; 93 static regex_t free_ts_nsec_pattern; 94 static struct block_list *list; 95 static int list_size; 96 static int max_size; 97 static int cull; 98 static int filter; 99 static bool debug_on; 100 101 static void set_single_cmp(int (*cmp)(const void *, const void *), int sign); 102 103 int read_block(char *buf, char *ext_buf, int buf_size, FILE *fin) 104 { 105 char *curr = buf, *const buf_end = buf + buf_size; 106 107 while (buf_end - curr > 1 && fgets(curr, buf_end - curr, fin)) { 108 if (*curr == '\n') { /* empty line */ 109 return curr - buf; 110 } 111 if (!strncmp(curr, "PFN", 3)) { 112 strcpy(ext_buf, curr); 113 continue; 114 } 115 curr += strlen(curr); 116 } 117 118 return -1; /* EOF or no space left in buf. */ 119 } 120 121 static int compare_txt(const void *p1, const void *p2) 122 { 123 const struct block_list *l1 = p1, *l2 = p2; 124 125 return strcmp(l1->txt, l2->txt); 126 } 127 128 static int compare_stacktrace(const void *p1, const void *p2) 129 { 130 const struct block_list *l1 = p1, *l2 = p2; 131 132 return strcmp(l1->stacktrace, l2->stacktrace); 133 } 134 135 static int compare_num(const void *p1, const void *p2) 136 { 137 const struct block_list *l1 = p1, *l2 = p2; 138 139 return l1->num - l2->num; 140 } 141 142 static int compare_page_num(const void *p1, const void *p2) 143 { 144 const struct block_list *l1 = p1, *l2 = p2; 145 146 return l1->page_num - l2->page_num; 147 } 148 149 static int compare_pid(const void *p1, const void *p2) 150 { 151 const struct block_list *l1 = p1, *l2 = p2; 152 153 return l1->pid - l2->pid; 154 } 155 156 static int compare_tgid(const void *p1, const void *p2) 157 { 158 const struct block_list *l1 = p1, *l2 = p2; 159 160 return l1->tgid - l2->tgid; 161 } 162 163 static int compare_allocator(const void *p1, const void *p2) 164 { 165 const struct block_list *l1 = p1, *l2 = p2; 166 167 return l1->allocator - l2->allocator; 168 } 169 170 static int compare_comm(const void *p1, const void *p2) 171 { 172 const struct block_list *l1 = p1, *l2 = p2; 173 174 return strcmp(l1->comm, l2->comm); 175 } 176 177 static int compare_ts(const void *p1, const void *p2) 178 { 179 const struct block_list *l1 = p1, *l2 = p2; 180 181 return l1->ts_nsec < l2->ts_nsec ? -1 : 1; 182 } 183 184 static int compare_free_ts(const void *p1, const void *p2) 185 { 186 const struct block_list *l1 = p1, *l2 = p2; 187 188 return l1->free_ts_nsec < l2->free_ts_nsec ? -1 : 1; 189 } 190 191 static int compare_release(const void *p1, const void *p2) 192 { 193 const struct block_list *l1 = p1, *l2 = p2; 194 195 if (!l1->free_ts_nsec && !l2->free_ts_nsec) 196 return 0; 197 if (l1->free_ts_nsec && l2->free_ts_nsec) 198 return 0; 199 return l1->free_ts_nsec ? 1 : -1; 200 } 201 202 static int compare_cull_condition(const void *p1, const void *p2) 203 { 204 if (cull == 0) 205 return compare_txt(p1, p2); 206 if ((cull & CULL_STACKTRACE) && compare_stacktrace(p1, p2)) 207 return compare_stacktrace(p1, p2); 208 if ((cull & CULL_PID) && compare_pid(p1, p2)) 209 return compare_pid(p1, p2); 210 if ((cull & CULL_TGID) && compare_tgid(p1, p2)) 211 return compare_tgid(p1, p2); 212 if ((cull & CULL_COMM) && compare_comm(p1, p2)) 213 return compare_comm(p1, p2); 214 if ((cull & CULL_UNRELEASE) && compare_release(p1, p2)) 215 return compare_release(p1, p2); 216 if ((cull & CULL_ALLOCATOR) && compare_allocator(p1, p2)) 217 return compare_allocator(p1, p2); 218 return 0; 219 } 220 221 static int compare_sort_condition(const void *p1, const void *p2) 222 { 223 int cmp = 0; 224 225 for (int i = 0; i < sc.size; ++i) 226 if (cmp == 0) 227 cmp = sc.signs[i] * sc.cmps[i](p1, p2); 228 return cmp; 229 } 230 231 static int search_pattern(regex_t *pattern, char *pattern_str, char *buf) 232 { 233 int err, val_len; 234 regmatch_t pmatch[2]; 235 236 err = regexec(pattern, buf, 2, pmatch, REG_NOTBOL); 237 if (err != 0 || pmatch[1].rm_so == -1) { 238 if (debug_on) 239 fprintf(stderr, "no matching pattern in %s\n", buf); 240 return -1; 241 } 242 val_len = pmatch[1].rm_eo - pmatch[1].rm_so; 243 244 memcpy(pattern_str, buf + pmatch[1].rm_so, val_len); 245 246 return 0; 247 } 248 249 static bool check_regcomp(regex_t *pattern, const char *regex) 250 { 251 int err; 252 253 err = regcomp(pattern, regex, REG_EXTENDED | REG_NEWLINE); 254 if (err != 0 || pattern->re_nsub != 1) { 255 fprintf(stderr, "Invalid pattern %s code %d\n", regex, err); 256 return false; 257 } 258 return true; 259 } 260 261 static char **explode(char sep, const char *str, int *size) 262 { 263 int count = 0, len = strlen(str); 264 int lastindex = -1, j = 0; 265 266 for (int i = 0; i < len; i++) 267 if (str[i] == sep) 268 count++; 269 char **ret = calloc(++count, sizeof(char *)); 270 271 for (int i = 0; i < len; i++) { 272 if (str[i] == sep) { 273 ret[j] = calloc(i - lastindex, sizeof(char)); 274 memcpy(ret[j++], str + lastindex + 1, i - lastindex - 1); 275 lastindex = i; 276 } 277 } 278 if (lastindex <= len - 1) { 279 ret[j] = calloc(len - lastindex, sizeof(char)); 280 memcpy(ret[j++], str + lastindex + 1, strlen(str) - 1 - lastindex); 281 } 282 *size = j; 283 return ret; 284 } 285 286 static void free_explode(char **arr, int size) 287 { 288 for (int i = 0; i < size; i++) 289 free(arr[i]); 290 free(arr); 291 } 292 293 # define FIELD_BUFF 25 294 295 static int get_page_num(char *buf) 296 { 297 int order_val; 298 char order_str[FIELD_BUFF] = {0}; 299 char *endptr; 300 301 search_pattern(&order_pattern, order_str, buf); 302 errno = 0; 303 order_val = strtol(order_str, &endptr, 10); 304 if (order_val > 64 || errno != 0 || endptr == order_str || *endptr != '\0') { 305 if (debug_on) 306 fprintf(stderr, "wrong order in follow buf:\n%s\n", buf); 307 return 0; 308 } 309 310 return 1 << order_val; 311 } 312 313 static pid_t get_pid(char *buf) 314 { 315 pid_t pid; 316 char pid_str[FIELD_BUFF] = {0}; 317 char *endptr; 318 319 search_pattern(&pid_pattern, pid_str, buf); 320 errno = 0; 321 pid = strtol(pid_str, &endptr, 10); 322 if (errno != 0 || endptr == pid_str || *endptr != '\0') { 323 if (debug_on) 324 fprintf(stderr, "wrong/invalid pid in follow buf:\n%s\n", buf); 325 return -1; 326 } 327 328 return pid; 329 330 } 331 332 static pid_t get_tgid(char *buf) 333 { 334 pid_t tgid; 335 char tgid_str[FIELD_BUFF] = {0}; 336 char *endptr; 337 338 search_pattern(&tgid_pattern, tgid_str, buf); 339 errno = 0; 340 tgid = strtol(tgid_str, &endptr, 10); 341 if (errno != 0 || endptr == tgid_str || *endptr != '\0') { 342 if (debug_on) 343 fprintf(stderr, "wrong/invalid tgid in follow buf:\n%s\n", buf); 344 return -1; 345 } 346 347 return tgid; 348 349 } 350 351 static __u64 get_ts_nsec(char *buf) 352 { 353 __u64 ts_nsec; 354 char ts_nsec_str[FIELD_BUFF] = {0}; 355 char *endptr; 356 357 search_pattern(&ts_nsec_pattern, ts_nsec_str, buf); 358 errno = 0; 359 ts_nsec = strtoull(ts_nsec_str, &endptr, 10); 360 if (errno != 0 || endptr == ts_nsec_str || *endptr != '\0') { 361 if (debug_on) 362 fprintf(stderr, "wrong ts_nsec in follow buf:\n%s\n", buf); 363 return -1; 364 } 365 366 return ts_nsec; 367 } 368 369 static __u64 get_free_ts_nsec(char *buf) 370 { 371 __u64 free_ts_nsec; 372 char free_ts_nsec_str[FIELD_BUFF] = {0}; 373 char *endptr; 374 375 search_pattern(&free_ts_nsec_pattern, free_ts_nsec_str, buf); 376 errno = 0; 377 free_ts_nsec = strtoull(free_ts_nsec_str, &endptr, 10); 378 if (errno != 0 || endptr == free_ts_nsec_str || *endptr != '\0') { 379 if (debug_on) 380 fprintf(stderr, "wrong free_ts_nsec in follow buf:\n%s\n", buf); 381 return -1; 382 } 383 384 return free_ts_nsec; 385 } 386 387 static char *get_comm(char *buf) 388 { 389 char *comm_str = malloc(TASK_COMM_LEN); 390 391 memset(comm_str, 0, TASK_COMM_LEN); 392 393 search_pattern(&comm_pattern, comm_str, buf); 394 errno = 0; 395 if (errno != 0) { 396 if (debug_on) 397 fprintf(stderr, "wrong comm in follow buf:\n%s\n", buf); 398 return NULL; 399 } 400 401 return comm_str; 402 } 403 404 static int get_arg_type(const char *arg) 405 { 406 if (!strcmp(arg, "pid") || !strcmp(arg, "p")) 407 return ARG_PID; 408 else if (!strcmp(arg, "tgid") || !strcmp(arg, "tg")) 409 return ARG_TGID; 410 else if (!strcmp(arg, "name") || !strcmp(arg, "n")) 411 return ARG_COMM; 412 else if (!strcmp(arg, "stacktrace") || !strcmp(arg, "st")) 413 return ARG_STACKTRACE; 414 else if (!strcmp(arg, "free") || !strcmp(arg, "f")) 415 return ARG_FREE; 416 else if (!strcmp(arg, "txt") || !strcmp(arg, "T")) 417 return ARG_TXT; 418 else if (!strcmp(arg, "free_ts") || !strcmp(arg, "ft")) 419 return ARG_FREE_TS; 420 else if (!strcmp(arg, "alloc_ts") || !strcmp(arg, "at")) 421 return ARG_ALLOC_TS; 422 else if (!strcmp(arg, "allocator") || !strcmp(arg, "ator")) 423 return ARG_ALLOCATOR; 424 else { 425 return ARG_UNKNOWN; 426 } 427 } 428 429 static int get_allocator(const char *buf, const char *migrate_info) 430 { 431 char *tmp, *first_line, *second_line; 432 int allocator = 0; 433 434 if (strstr(migrate_info, "CMA")) 435 allocator |= ALLOCATOR_CMA; 436 if (strstr(migrate_info, "slab")) 437 allocator |= ALLOCATOR_SLAB; 438 tmp = strstr(buf, "__vmalloc_node_range"); 439 if (tmp) { 440 second_line = tmp; 441 while (*tmp != '\n') 442 tmp--; 443 tmp--; 444 while (*tmp != '\n') 445 tmp--; 446 first_line = ++tmp; 447 tmp = strstr(tmp, "alloc_pages"); 448 if (tmp && first_line <= tmp && tmp < second_line) 449 allocator |= ALLOCATOR_VMALLOC; 450 } 451 if (allocator == 0) 452 allocator = ALLOCATOR_OTHERS; 453 return allocator; 454 } 455 456 static bool match_num_list(int num, int *list, int list_size) 457 { 458 for (int i = 0; i < list_size; ++i) 459 if (list[i] == num) 460 return true; 461 return false; 462 } 463 464 static bool match_str_list(const char *str, char **list, int list_size) 465 { 466 for (int i = 0; i < list_size; ++i) 467 if (!strcmp(list[i], str)) 468 return true; 469 return false; 470 } 471 472 static bool is_need(char *buf) 473 { 474 __u64 ts_nsec, free_ts_nsec; 475 476 ts_nsec = get_ts_nsec(buf); 477 free_ts_nsec = get_free_ts_nsec(buf); 478 479 if ((filter & FILTER_UNRELEASE) && free_ts_nsec != 0 && ts_nsec < free_ts_nsec) 480 return false; 481 if ((filter & FILTER_PID) && !match_num_list(get_pid(buf), fc.pids, fc.pids_size)) 482 return false; 483 if ((filter & FILTER_TGID) && 484 !match_num_list(get_tgid(buf), fc.tgids, fc.tgids_size)) 485 return false; 486 487 char *comm = get_comm(buf); 488 489 if ((filter & FILTER_COMM) && 490 !match_str_list(comm, fc.comms, fc.comms_size)) { 491 free(comm); 492 return false; 493 } 494 free(comm); 495 return true; 496 } 497 498 static bool add_list(char *buf, int len, char *ext_buf) 499 { 500 if (list_size != 0 && 501 len == list[list_size-1].len && 502 memcmp(buf, list[list_size-1].txt, len) == 0) { 503 list[list_size-1].num++; 504 list[list_size-1].page_num += get_page_num(buf); 505 return true; 506 } 507 if (list_size == max_size) { 508 fprintf(stderr, "max_size too small??\n"); 509 return false; 510 } 511 if (!is_need(buf)) 512 return true; 513 list[list_size].pid = get_pid(buf); 514 list[list_size].tgid = get_tgid(buf); 515 list[list_size].comm = get_comm(buf); 516 list[list_size].txt = malloc(len+1); 517 if (!list[list_size].txt) { 518 fprintf(stderr, "Out of memory\n"); 519 return false; 520 } 521 memcpy(list[list_size].txt, buf, len); 522 list[list_size].txt[len] = 0; 523 list[list_size].len = len; 524 list[list_size].num = 1; 525 list[list_size].page_num = get_page_num(buf); 526 527 list[list_size].stacktrace = strchr(list[list_size].txt, '\n') ?: ""; 528 if (*list[list_size].stacktrace == '\n') 529 list[list_size].stacktrace++; 530 list[list_size].ts_nsec = get_ts_nsec(buf); 531 list[list_size].free_ts_nsec = get_free_ts_nsec(buf); 532 list[list_size].allocator = get_allocator(buf, ext_buf); 533 list_size++; 534 if (list_size % 1000 == 0) { 535 printf("loaded %d\r", list_size); 536 fflush(stdout); 537 } 538 return true; 539 } 540 541 static bool parse_cull_args(const char *arg_str) 542 { 543 int size = 0; 544 char **args = explode(',', arg_str, &size); 545 546 for (int i = 0; i < size; ++i) { 547 int arg_type = get_arg_type(args[i]); 548 549 if (arg_type == ARG_PID) 550 cull |= CULL_PID; 551 else if (arg_type == ARG_TGID) 552 cull |= CULL_TGID; 553 else if (arg_type == ARG_COMM) 554 cull |= CULL_COMM; 555 else if (arg_type == ARG_STACKTRACE) 556 cull |= CULL_STACKTRACE; 557 else if (arg_type == ARG_FREE) 558 cull |= CULL_UNRELEASE; 559 else if (arg_type == ARG_ALLOCATOR) 560 cull |= CULL_ALLOCATOR; 561 else { 562 free_explode(args, size); 563 return false; 564 } 565 } 566 free_explode(args, size); 567 if (sc.size == 0) 568 set_single_cmp(compare_num, SORT_DESC); 569 return true; 570 } 571 572 static void set_single_cmp(int (*cmp)(const void *, const void *), int sign) 573 { 574 if (sc.signs == NULL || sc.size < 1) 575 sc.signs = calloc(1, sizeof(int)); 576 sc.signs[0] = sign; 577 if (sc.cmps == NULL || sc.size < 1) 578 sc.cmps = calloc(1, sizeof(int *)); 579 sc.cmps[0] = cmp; 580 sc.size = 1; 581 } 582 583 static bool parse_sort_args(const char *arg_str) 584 { 585 int size = 0; 586 587 if (sc.size != 0) { /* reset sort_condition */ 588 free(sc.signs); 589 free(sc.cmps); 590 size = 0; 591 } 592 593 char **args = explode(',', arg_str, &size); 594 595 sc.signs = calloc(size, sizeof(int)); 596 sc.cmps = calloc(size, sizeof(int *)); 597 for (int i = 0; i < size; ++i) { 598 int offset = 0; 599 600 sc.signs[i] = SORT_ASC; 601 if (args[i][0] == '-' || args[i][0] == '+') { 602 if (args[i][0] == '-') 603 sc.signs[i] = SORT_DESC; 604 offset = 1; 605 } 606 607 int arg_type = get_arg_type(args[i]+offset); 608 609 if (arg_type == ARG_PID) 610 sc.cmps[i] = compare_pid; 611 else if (arg_type == ARG_TGID) 612 sc.cmps[i] = compare_tgid; 613 else if (arg_type == ARG_COMM) 614 sc.cmps[i] = compare_comm; 615 else if (arg_type == ARG_STACKTRACE) 616 sc.cmps[i] = compare_stacktrace; 617 else if (arg_type == ARG_ALLOC_TS) 618 sc.cmps[i] = compare_ts; 619 else if (arg_type == ARG_FREE_TS) 620 sc.cmps[i] = compare_free_ts; 621 else if (arg_type == ARG_TXT) 622 sc.cmps[i] = compare_txt; 623 else if (arg_type == ARG_ALLOCATOR) 624 sc.cmps[i] = compare_allocator; 625 else { 626 free_explode(args, size); 627 sc.size = 0; 628 return false; 629 } 630 } 631 sc.size = size; 632 free_explode(args, size); 633 return true; 634 } 635 636 static int *parse_nums_list(char *arg_str, int *list_size) 637 { 638 int size = 0; 639 char **args = explode(',', arg_str, &size); 640 int *list = calloc(size, sizeof(int)); 641 642 errno = 0; 643 for (int i = 0; i < size; ++i) { 644 char *endptr = NULL; 645 646 list[i] = strtol(args[i], &endptr, 10); 647 if (errno != 0 || endptr == args[i] || *endptr != '\0') { 648 free(list); 649 return NULL; 650 } 651 } 652 *list_size = size; 653 free_explode(args, size); 654 return list; 655 } 656 657 static void print_allocator(FILE *out, int allocator) 658 { 659 fprintf(out, "allocated by "); 660 if (allocator & ALLOCATOR_CMA) 661 fprintf(out, "CMA "); 662 if (allocator & ALLOCATOR_SLAB) 663 fprintf(out, "SLAB "); 664 if (allocator & ALLOCATOR_VMALLOC) 665 fprintf(out, "VMALLOC "); 666 if (allocator & ALLOCATOR_OTHERS) 667 fprintf(out, "OTHERS "); 668 } 669 670 #define BUF_SIZE (128 * 1024) 671 672 static void usage(void) 673 { 674 printf("Usage: ./page_owner_sort [OPTIONS] <input> <output>\n" 675 "-m\t\tSort by total memory.\n" 676 "-s\t\tSort by the stack trace.\n" 677 "-t\t\tSort by times (default).\n" 678 "-p\t\tSort by pid.\n" 679 "-P\t\tSort by tgid.\n" 680 "-n\t\tSort by task command name.\n" 681 "-a\t\tSort by memory allocate time.\n" 682 "-r\t\tSort by memory release time.\n" 683 "-f\t\tFilter out the information of blocks whose memory has been released.\n" 684 "-d\t\tPrint debug information.\n" 685 "--pid <pidlist>\tSelect by pid. This selects the information of blocks whose process ID numbers appear in <pidlist>.\n" 686 "--tgid <tgidlist>\tSelect by tgid. This selects the information of blocks whose Thread Group ID numbers appear in <tgidlist>.\n" 687 "--name <cmdlist>\n\t\tSelect by command name. This selects the information of blocks whose command name appears in <cmdlist>.\n" 688 "--cull <rules>\tCull by user-defined rules.<rules> is a single argument in the form of a comma-separated list with some common fields predefined\n" 689 "--sort <order>\tSpecify sort order as: [+|-]key[,[+|-]key[,...]]\n" 690 ); 691 } 692 693 int main(int argc, char **argv) 694 { 695 FILE *fin, *fout; 696 char *buf, *ext_buf; 697 int i, count; 698 struct stat st; 699 int opt; 700 struct option longopts[] = { 701 { "pid", required_argument, NULL, 1 }, 702 { "tgid", required_argument, NULL, 2 }, 703 { "name", required_argument, NULL, 3 }, 704 { "cull", required_argument, NULL, 4 }, 705 { "sort", required_argument, NULL, 5 }, 706 { 0, 0, 0, 0}, 707 }; 708 709 while ((opt = getopt_long(argc, argv, "adfmnprstP", longopts, NULL)) != -1) 710 switch (opt) { 711 case 'a': 712 set_single_cmp(compare_ts, SORT_ASC); 713 break; 714 case 'd': 715 debug_on = true; 716 break; 717 case 'f': 718 filter = filter | FILTER_UNRELEASE; 719 break; 720 case 'm': 721 set_single_cmp(compare_page_num, SORT_DESC); 722 break; 723 case 'p': 724 set_single_cmp(compare_pid, SORT_ASC); 725 break; 726 case 'r': 727 set_single_cmp(compare_free_ts, SORT_ASC); 728 break; 729 case 's': 730 set_single_cmp(compare_stacktrace, SORT_ASC); 731 break; 732 case 't': 733 set_single_cmp(compare_num, SORT_DESC); 734 break; 735 case 'P': 736 set_single_cmp(compare_tgid, SORT_ASC); 737 break; 738 case 'n': 739 set_single_cmp(compare_comm, SORT_ASC); 740 break; 741 case 1: 742 filter = filter | FILTER_PID; 743 fc.pids = parse_nums_list(optarg, &fc.pids_size); 744 if (fc.pids == NULL) { 745 fprintf(stderr, "wrong/invalid pid in from the command line:%s\n", 746 optarg); 747 exit(1); 748 } 749 break; 750 case 2: 751 filter = filter | FILTER_TGID; 752 fc.tgids = parse_nums_list(optarg, &fc.tgids_size); 753 if (fc.tgids == NULL) { 754 fprintf(stderr, "wrong/invalid tgid in from the command line:%s\n", 755 optarg); 756 exit(1); 757 } 758 break; 759 case 3: 760 filter = filter | FILTER_COMM; 761 fc.comms = explode(',', optarg, &fc.comms_size); 762 break; 763 case 4: 764 if (!parse_cull_args(optarg)) { 765 fprintf(stderr, "wrong argument after --cull option:%s\n", 766 optarg); 767 exit(1); 768 } 769 break; 770 case 5: 771 if (!parse_sort_args(optarg)) { 772 fprintf(stderr, "wrong argument after --sort option:%s\n", 773 optarg); 774 exit(1); 775 } 776 break; 777 default: 778 usage(); 779 exit(1); 780 } 781 782 if (optind >= (argc - 1)) { 783 usage(); 784 exit(1); 785 } 786 787 fin = fopen(argv[optind], "r"); 788 fout = fopen(argv[optind + 1], "w"); 789 if (!fin || !fout) { 790 usage(); 791 perror("open: "); 792 exit(1); 793 } 794 795 if (!check_regcomp(&order_pattern, "order\\s*([0-9]*),")) 796 goto out_order; 797 if (!check_regcomp(&pid_pattern, "pid\\s*([0-9]*),")) 798 goto out_pid; 799 if (!check_regcomp(&tgid_pattern, "tgid\\s*([0-9]*) ")) 800 goto out_tgid; 801 if (!check_regcomp(&comm_pattern, "tgid\\s*[0-9]*\\s*\\((.*)\\),\\s*ts")) 802 goto out_comm; 803 if (!check_regcomp(&ts_nsec_pattern, "ts\\s*([0-9]*)\\s*ns,")) 804 goto out_ts; 805 if (!check_regcomp(&free_ts_nsec_pattern, "free_ts\\s*([0-9]*)\\s*ns")) 806 goto out_free_ts; 807 808 fstat(fileno(fin), &st); 809 max_size = st.st_size / 100; /* hack ... */ 810 811 list = malloc(max_size * sizeof(*list)); 812 buf = malloc(BUF_SIZE); 813 ext_buf = malloc(BUF_SIZE); 814 if (!list || !buf || !ext_buf) { 815 fprintf(stderr, "Out of memory\n"); 816 goto out_free; 817 } 818 819 for ( ; ; ) { 820 int buf_len = read_block(buf, ext_buf, BUF_SIZE, fin); 821 822 if (buf_len < 0) 823 break; 824 if (!add_list(buf, buf_len, ext_buf)) 825 goto out_free; 826 } 827 828 printf("loaded %d\n", list_size); 829 830 printf("sorting ....\n"); 831 832 qsort(list, list_size, sizeof(list[0]), compare_cull_condition); 833 834 printf("culling\n"); 835 836 for (i = count = 0; i < list_size; i++) { 837 if (count == 0 || 838 compare_cull_condition((void *)(&list[count-1]), (void *)(&list[i])) != 0) { 839 list[count++] = list[i]; 840 } else { 841 list[count-1].num += list[i].num; 842 list[count-1].page_num += list[i].page_num; 843 } 844 } 845 846 qsort(list, count, sizeof(list[0]), compare_sort_condition); 847 848 for (i = 0; i < count; i++) { 849 if (cull == 0) { 850 fprintf(fout, "%d times, %d pages, ", list[i].num, list[i].page_num); 851 print_allocator(fout, list[i].allocator); 852 fprintf(fout, ":\n%s\n", list[i].txt); 853 } 854 else { 855 fprintf(fout, "%d times, %d pages", 856 list[i].num, list[i].page_num); 857 if (cull & CULL_PID || filter & FILTER_PID) 858 fprintf(fout, ", PID %d", list[i].pid); 859 if (cull & CULL_TGID || filter & FILTER_TGID) 860 fprintf(fout, ", TGID %d", list[i].tgid); 861 if (cull & CULL_COMM || filter & FILTER_COMM) 862 fprintf(fout, ", task_comm_name: %s", list[i].comm); 863 if (cull & CULL_ALLOCATOR) { 864 fprintf(fout, ", "); 865 print_allocator(fout, list[i].allocator); 866 } 867 if (cull & CULL_UNRELEASE) 868 fprintf(fout, " (%s)", 869 list[i].free_ts_nsec ? "UNRELEASED" : "RELEASED"); 870 if (cull & CULL_STACKTRACE) 871 fprintf(fout, ":\n%s", list[i].stacktrace); 872 fprintf(fout, "\n"); 873 } 874 } 875 876 out_free: 877 if (ext_buf) 878 free(ext_buf); 879 if (buf) 880 free(buf); 881 if (list) 882 free(list); 883 out_free_ts: 884 regfree(&free_ts_nsec_pattern); 885 out_ts: 886 regfree(&ts_nsec_pattern); 887 out_comm: 888 regfree(&comm_pattern); 889 out_tgid: 890 regfree(&tgid_pattern); 891 out_pid: 892 regfree(&pid_pattern); 893 out_order: 894 regfree(&order_pattern); 895 896 return 0; 897 } 898