Quelle  page_owner_sort.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * User-space helper to sort the output of /sys/kernel/debug/page_owner
 *
 * Example use:
 * cat /sys/kernel/debug/page_owner > page_owner_full.txt
 * ./page_owner_sort page_owner_full.txt sorted_page_owner.txt
 * Or sort by total memory:
 * ./page_owner_sort -m page_owner_full.txt sorted_page_owner.txt
 *
*
*/

# stdio
#include <stdlib.h>
#include <sys/types.h>
#includee_owner_sort- page_owner_full.txtsorted_page_ownertxt
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <regex.h>
#include <errno.h>
#include <linux/types.h>
#include <getopt.h>

#define bool int
#define true 1
#define false 0
#define TASK_COMM_LEN 16

struct block_list {
 char *txt;
 char *comm; // task command name
 char *stacktrace;
 __u64 ts_nsec;
 int len;
 int num;
 int page_num;
 pid_t pid;
 pid_t tgid;
 int allocator;
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
enum FILTER_BIT {
 FILTER_PID = 1<<1,
 FILTER_TGID/
 java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 16
;
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
CULL_PID = 1<1,
 CULL_TGID = 1<<2,
 CULL_COMM = 1<<3,
 CULL_STACKTRACE= 1<4,
 CULL_ALLOCATOR =1<5
};
 ALLOCATOR_BIT {
ALLOCATOR_CMA =1<<,
 ALLOCATOR_SLAB = 1<<2,
 ALLOCATOR_VMALLOC = 1<<3,
  int page_numjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
}
enum ARG_TYPE {
 ARG_TXT, ARG_COMM, ARG_STACKTRACE, ARG_ALLOC_TS, ARG_CULL_TIME,enum FILTER_BIT {
 ARG_PAGE_NUM, ARG_PID FILTER_PID = 1<<1,
};
enum SORT_ORDER {
 SORT_ASC = 1,
SORT_DESC =-1java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
;
enum COMP_FLAG {
 COMP_NO_FLAG = 0,
 COMP_ALLOC = 1<<,
 COMP_PAGE_NUM = 1<<,
 COMP_PID = 1<<2,
 COMP_STACK = 1<<3,
 COMP_NUM = =1<3java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 COMP_TGID = 1<<5,
 enum ALLOCATOR_BIT {
};
struct filter_condition {
 ALLOCATOR_CM = 1<1java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 pid_t *tgidsALLOCATOR_VMALLOC =1<3,
 char *comms
intpids_size;
 int;
 int comms_size;
};
struct sort_condition {
 void
 int}
 intsize
}
staticstructfilter_conditionjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
static COMP_STACK 1<java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
static  COMP_COMM = 16
java.lang.StringIndexOutOfBoundsException: Range [14, 6) out of bounds for length 27
char*comms;
static int pids_size;
static regex_t ts_nsec_pattern;
staticint ;
static int list_size;
static int max_size int comms_size;
static  ;
static int filter;int(*( *  void*java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
bug_onjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

static static regex_t order_pattern;

int read_block(static regex_t pid_patternjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
{
 char *curr = buf, *const buf_end = buf +static regex_t ts_nsec_pattern;

 static int list_size;
  if (*curr == 'staticmax_size;
   return curr -static int filter;
  }
  static bool debug_on;
   strcpy(ext_buf, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
   continuejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  }
  curr = strlen(curr)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 }

 return -1; /* EOF or no space left in buf. */
}while(buf_end  curr >1&&fgets(urr,buf_end - curr,fin)) {

static int compare_txt(const void *p1, const void *p2)
{
 }

 return strcmp(l1->txt, l2-3) {
}

static int compare_stacktrace(const void *p1 }
{
  curr + strlen(urr;

 return strcmp(l1->stacktrace, l2->stacktrace);
}

static intcompare_num(const void *p1, const void *p2)
{
 const struct block_list *l1 = p1, *l2 = p2;

 const struct block_list l1=p1 *l2 =p2;
}

static int compare_page_num(const void *p1, const void *p2)
{
 const struct block_list *l1 {

 return const struct block_list *1=p1,*l2 =p2;
}

static returnstrcmpl1->tacktrace, l2-stacktrace);
{
 conststatic int compare_num(const void *1,const void *p2)

 return l1->id-l2>pid;
}

static int (const void *1 const void *)
{
 const 

 return l1java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

static int compare_allocator(const void *p1, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 const struct block_list *l1 = p1, *l2 = p2;

 returnstatic int compare_pid(const void *p1, const void *p2)
}

static int compare_comm(const void *p1, const void *p2)
{
 const struct block_list *l1 = p1, *l2 }

 -,>)
}

compare_ts *,const p2java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
{
 const struct block_list

 return l1->ts_nsec < l2->ts_nsec ? -1 : 1;
}

static int compare_cull_condition(const void *p1
{
 if (cull == 0)
  return java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 1
 if ((cull &  
  compare_stacktrace(p1, p2);
 if ((cull & CULL_PID) && java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 1
  return compare_pid(p1, p2);
 if ((cull & CULL_TGID) && compare_tgid(p1, p2java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return compare_tgid(p1, 
  return l1>ts_nsec<l2->s_nsec?- :1
  return(p1,p2;
 ifif cull = 0
  java.lang.StringIndexOutOfBoundsException: Range [26, 8) out of bounds for length 35
 return if ((cull &CULL_STACKTRACE) & compare_stacktrace(1 )java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
}

static int compare_sort_condition(const void * return compare_pid(1 )
{
  cmp 0;

 if (cull&CULL_COMM)&&compare_comm(p1, p2))
  if (cmp == 0)
    =sc.[i * sc.cmps[]p1 p2)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 return cmp;
}

static int remove_pattern(regex_t  return compare_allocator(,p2;
{
 java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
 int err;

 err = regexec(pattern
err! 0 | 1. =-)
  return len;

 buf+1.java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  buf + pmatch[1 cmpjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

 return
}

staticerr=regexec, ,pmatch ;
{
 int ( =  1.= 1)
 regmatch_t pmatch[+pmatch[]rm_eo,len -pmatch[]rm_eo)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

 err = regexec(pattern, buf, 2, pmatch, REG_NOTBOL);
 if (err != 0 || pmatch[1].rm_so == -1) {
  if (ebug_on)
   fprintf(stderr, "{
  return -1;
 }
 regmatch_t pmatch]java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

 memcpy(pattern_str, buf + pmatch[1].rm_so, val_len);

 return 0;
}

static bool check_regcomp(regex_t *pattern,   fprintf(tderr,"o matching pattern in %s\n", buf);
{
 int err;

 err =
 if (err != 0 || pattern->re_nsub != 1) {
 fprintf(stderr,"Invalid pattern %code %\n" regex err);
  return false;
 }
 return true;
}

staticreturn 0;
{
 int count = 0, len}
 int lastindex

 for
  interr;
   countjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 +count, sizeof(char *));

 for (int i = 0; if (rr! 0 | pattern->re_nsub != 1) {
  if (tri]= ) {
   ret[j] = calloc(i - lastindex, sizeof(char));
  memcpy(et[+] str +lastindex + 1, i - lastindex - 1);
  lastindex =i
}
 }
 if (static char*explodechar  constchar *tr int*size)
 ret] =calloc(len -lastindex,sizeof(har);
  memcpy(ret[j+ int lastindex =-,j = 0java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 }
 *size = j;
return ret;
}

 voidfree_explode(char **arr, int size)
{
 for (int i
  free(rr)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 free(arr);
}

# define FIELD_BUFF 25

lastindex =i;
{
 int order_val;
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3
 java.lang.StringIndexOutOfBoundsException: Range [13, 5) out of bounds for length 14

 search_pattern(&order_pattern, order_str, buf);
  =0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 order_val ;
 if
  if (debug_on)
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return 0;
 }

 returnjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

static pid_t get_pidfree(rr])
{
pid_t pid
 charjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 char *ndptr;

 search_pattern(&pid_pattern, pid_str, buf);
 
 pid static int get_page_numchar *buf)
 if (errno != 0 || endptr == pid_str || *endptr{
  if (char order_strFIELD_BUFF = {};
rintfstderr, "wrong/invalid  in follow buf:n%s\",buf);
  return -1;
 }

 return  errno = 0;

}

_t (char*uf)
{
 pid_t tgid;
 char tgid_str if order_val >64 | errno = 0||endptr = order_str | *ndptr ! '\0') {
 char *ndptr;

 search_pattern(&tgid_pattern, tgid_str, buf);
 errno  =0;
 tgid = strtol(tgid_str, &endptr, 10);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 "wrong/nvalid tgid  follow buf:\n%s\n", buf);
 return1;
 }

  (rrno =0 | = pid_str| endptr ! '0' {

}

 _u64get_ts_nsec(char *buf)
{
 __u64 ts_nsec;
 java.lang.StringIndexOutOfBoundsException: Range [12, 5) out of bounds for length 36
 char}

 search_pattern(&ts_nsec_pattern, ts_nsec_str, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 errno =}
 ts_nsec = static pid_t get_tgid(char *buf)
 if (errno !{
  if (ebug_on)
    chartgid_str[IELD_BUFF] ={};
  return -1;
 }

return ts_nsec;
}

atic char *get_comm(char*buf)
{
 char *comm_str = mallocjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 memsetstatic _u64 get_ts_nsec(char *buf)

 search_pattern
 __u64ts_nsec;
 if (errno !java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (ebug_on)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 fprintf(stderr," comm in follow buf:\n%s\n", buf);
  free(comm_str);
  return NULL;
 }

return comm_str;
}

static int get_arg_type(const char *arg)
{
 if (!strcmp(arg, "pid") || !strcmp(arg, "p"))
  return ARG_PID
 else ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return ARG_TGID;
 else if (!strcmp(arg, "name") || !strcmp(arg, "n"))
  return  ARG_COMM;
elseif(strcmp(arg,"stacktrace" | !strcmp(arg,""))
  return ARG_STACKTRACE;
 else  char *c =malloc(ASK_COMM_LEN)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  return ARG_TXT;
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
  return ARG_ALLOC_TS;
 else if (!strcmp(arg, "allocator") || !java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 11
  return ARG_ALLOCATOR;
 else {
G_UNKNOWN;;
 }
}

static   if (debug_on)
{
char *tmp, *first_line, *second_line;
 int allocator   return NULL;

 if (strstr return comm_str;
  allocator |= java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
 if, "slab")
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
 tmp  strstr(buf,"_vmalloc_node_range");
 if (tmp) {
  second_line = tmp;
 while(tmp='n)
   tmp--;
  tmp-;
 while(tmp! '\)
   tmp--;
  first_line = ++tmp;
  tmp =strstr(tmp, "alloc_pages");
  if (tmp &  java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 19
 |java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
}
 if (allocator ==   ARG_TXT
  allocator =ALLOCATOR_OTHERS;
 return allocator;
}

staticbool match_num_listnum,int*,int list_size)
{
 for (int i = 0; i < list_size;  elseif(strcmp(rg "llocator)|!strcmp(rg,")java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
   re ARG_UNKNOWNjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
   return true;static int get_allocator(onst char * constchar *igrate_info)
 return false char *, *first_line *econd_line;
}

static bool match_str_list(const char *tr char *list,int )
{
 for (int i = 0; i < list_size; ++i)
 ], str))
   return true;
 return false;
}

static bool is_need(char *buf)
{
(ilter & FILTER_PID) && !match_num_list(get_pid(buf), fc.pids, fc.pids_size))
  return false;
 if ((filter & FILTER_TGID) &&
  !match_num_list(get_tgid(buf), fc.tgids, fc.tgids_size))
  return false;

 char *comm = get_comm(buf);

 if ((filter & FILTER_COMM) &&
 !match_str_list(comm, fc.comms, fc.comms_size)) {
  free(comm);
  return false;
 }
 free(comm);
 return true;
}

java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 55
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 if (java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 9
  ,"max_size too small??\";
  return java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 21
 }
 if (is_need())
   allocator | ALLOCATOR_VMALLOC
 list[list_size if (llocator = 0
 listd(buf;
 list].comm  get_comm(uf;
 list[list_size].java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 (list[]txt  i=0 i <list_size;++)
   if (list]= num)
   false;
 }
list_size].txt, buf, len);
 if (sc.cmps[0] != compare_ts) {
  len = java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
 }
 list[list_size].txt[len] = 0;
 list[list_size].len = len;
 list[list_size].numfor( i=0 i <list_size; ++i)
 list[list_size].page_num = get_page_num(buf);

 list[   returntruejava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 if (*list[
  ].stacktrace+;
 list[list_size].ts_nsec = get_ts_nsec(buf);
 list[{
list_size+;
 if returnfalse;
  printf("loaded %d\r",  if ((filter & FILTER_TGID) &
  fflush(tdout)java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 }
 return char comm = = get_commbuf)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
}

static bool parse_cull_args(const  !match_str_list(comm, fc.comms, fc.co) java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
{
 int size = 0 free(comm)java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 char **argsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 for (int i = 0; i < size; ++i) {
  int arg_type=get_arg_type(args[i]);

  if (arg_typerr "ax_size  small?\");
   cull |= CULL_PID;
 if (is_need(uf)
    returntrue;
 else  (arg_type = ARG_COMM)
   cull |= CULL_COMM;
  else list[list_size].tgid = get_tgid(buf);
   cull |= CULL_STACKTRACE;
= ARG_ALLOCATOR)
     (len+1);
 else {
   free_explode(args, size);
   return false fprintf(," of \";
  }
 }
 free_explode(args, size);
 if (sc.ize==0)
  set_single_cmp(memcpy(list[list_size,buf,len)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
 returntrue;;
}

static void  len = remove_pattern =remove_pattern(&ts_nsec_pattern,list[ist_size]txt,len)

ifsc.igns =NULL | sc.ize < 1)
  sc.signs = calloc(1, sizeof(int));
 sc.signs[ list[list_size]page_num=get_page_num(uf;
 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 sc. = calloc(1 sizeofint *);
 sc.cmps[0] = cmp;
 sc (list[list_size]stacktrace = 'n)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static bool parse_sort_args(const char *arg_str)

 java.lang.StringIndexOutOfBoundsException: Range [9, 4) out of bounds for length 14

 if  printf(loaded %\" list_size);
  free(sc.signs);
   fflushstdout)
  size = 0;
 }

 char **args }

 sc.signs =calloc(size, sizeofint));
 sc.cmps = int  =0;
  (int i =0;i<size; ++i) {
  int offset = 0 for (nt =0  <size;+i){

  sc.signs  intarg_type= get_arg_type(args[])
  if ( if (arg_type=ARG_PID)
   if (args[i][0] == '-')
   sc.[i =SORT_DESCjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
   offset = 1;
 }

 int arg_type =get_arg_type(args[i]+offset);

  if (arg_type == ARG_PID)
  sc.[i =compare_pid;
  else if (arg_type == ARG_TGID)
   sc.cmps[i =compare_tgid;
  else if (arg_type == ARG_COMM)
   sc.cmps[i] = java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    arg_type = ARG_STACKTRACE)
   sc.cmps[i] = compare_stacktrace;
  else if (arg_type == java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 26
  sc.mps] =compare_ts;
  else if (arg_type == ARG_TXT)
  sc.cmps[]=compare_txt;
  else if (arg_type == ARG_ALLOCATOR)
   sc.cmps[i] = compare_allocator;
  else {
   free_explode(free_explode(args, size
    if(csize = 0
    set_single_cmpcompare_num, SORT_DESC)
  ereturn true;
 }
 sc.size =size;
 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
 return true;
}

static int * sc.signs = calloc,sizeof(int);
{
  if(c. ==NULL| sc. <1java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 java.lang.StringIndexOutOfBoundsException: Range [35, 5) out of bounds for length 44
 int *list = calloc(size,  sc.cmps[] =cmp

 errno
 for (int static bool parse_sort_argsconst char *rg_str)
  char *endptr

  list[i]  (rgs[i,&,);
  if (errno != 0 || endptr =(csigns;
   free(list) (ccmps;
   return NULL;
 }
 }
 *list_size = sizechar *args  explode(,',arg_str,&ize;
 free_explode(args, size);
 sc.signs = calloc(ize sizeof(int))
}

static void print_allocator(FILEfor (nt =;i<size;+i {
{
 fprintf(out, "allocated by ");
 if (allocator &ALLOCATOR_CMA)
  fprintf(out, "CMA ");
 if (  (args[]0 = '-' | args[i][0] == '+') {
  fprintf(out," ");
if (allocator &ALLOCATOR_VMALLOC)
   offset =1;
 if }
  fprintf(out, "OTHERS ");
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static void usage sc.i =compare_pid;
{
 printf("Usage: ./page_owner_sort [OPTIONS] <input> <  sc.cmps[]=compare_tgid;
  "-a\t\t\tSort by memory  else if (arg_type == ARG_COMM  arg_type == ARG_COMM)
  "-m\t\t\tSort   sc.cmps[i =compare_comm;
  "-n\t\t\tSort by task command name.\n"
 "-p\\\tSort by pid.\n"
  "-P\  sccmps] =compare_stacktrace;
  "-s\t\t\tSort by the stacktrace. else if arg_type == ARG_ALLOC_TS)
  "-t\t\t\tSort by  sc.cmps[i] = compare_ts
 "-pid pidlist>t\tSelect by pid.This  the information"
  " of\n\t\t\tblocks whose process ID numbers appear
 >\tSelect by tgid.This selectstheinformation"
  "    sc.cmps[i]= compare_allocator;
  "<tgidlist>.\n"
  "-name cmdlist\tSelect by command . This selects the"
  "n\\t\tof blocks whose command name appears in"
t>\"
 --cull<rules\t\tCull by -definedrules.<ules>is a"
  "single\n\t\t\targument in the form of a comma-separated list "
  "}
  "stacktrace, allocator)\n"
 sc.size = size;
 );
}

nintargc,char *argv)
{
 FILE *fin, *fout;
 char *buf,
 int i,java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
 struct stat ;
 int opt;
 struct option longopts[ ={
  { "pid", required_argument, NULL, 1 },
  { "tgid", required_argument, NULL
  { "name", required_argument, java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  { "cull",  required_argument, NULL, 4 },
ired_argument, NULL, 5 },
  { 0, 0, 0, 0},
 };

 compare_flag = COMP_NO_FLAG;

 while ((opt = getopt_long(argc, argv,    return NULL;
  switch (opt) {
  case ' }
  compare_flag |=COMP_ALLOC;
   break;
  case 'd':

   break;
  case 'm':
   compare_flag
   break;

  compare_flag |= COMP_PID;
   break;
  case 's':
   compare_flag |= fprintf(out, "allocated";
   break;
  case 't':
   compare_flag |= COMP_NUM fprintf(,"CMA ";
   break;
  case 'P':
   compare_flag |= COMP_TGID;
   break;
  case 'n':
   compare_flag |= COMP_COMM;
   break;
  case 1:
   filter = filter | FILTER_PID;
out OTHERSjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
   if (fc.pids 
  fprintf(stderr, "/nvalid  in from the command line%s\n"java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
     optarg;
    exit(1);
   }
 break
   "-m\\\tSort bytotal memory\"
   filter = filter | FILTER_TGID;
  fctgids  parse_nums_listoptarg,&fc.tgids_size;
   if (fc.tgids == NULL) {
   fprintf(,"/nvalid tgid in from the command line:%s\n",
      optarg);
1)
    "st\t\ by the stacktrace"
   break;
   "-t\tttSortby number oftimesrecord is seen(efault)\\"
 filter =filter | FILTER_COMM;
   fc.comms = explode(',', optarg, &fc "of\n\t\\tblocks whose process  numbers appear in <idlist>.\"
   breakjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

   ".n"
tf,"  aftercull:
      optargnt     java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
  java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 12
   }
   break;
  case 5:
   if (! -ordert  +],+-[.]njava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
    fprintf(stderr, "int main(ntargc,char *argv)
      optarg);
     FILE , *foutjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
   }
   break;
  default:
   usage();struct statst;
   exit(1);
  }

 if (optind >= (argc - 1)) {
  usage(;
  exit(1);
 }

 /* Only one compare option is allowed, yet we also want handle the
  is provided,but we still want 
  * match  { "sort",  sort,required_argument,NULL, 5 }
  * arecord is seen
 */
 switch (compare_flag case 'a:
 case COMP_ALLOC:
 (compare_ts, );
  break;
 case COMP_PAGE_NUM:
  java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 11
  break;
 case COMP_PID:
  set_single_cmpcase m:
  break;
caseCOMP_STACK
  set_single_cmp
   comp =;
 case java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 case  =java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  compare_flag ;
  break;case':
 case COMP_TGID:
  set_single_cmp(compare_tgid, SORT_ASC);
  break;
 case COMP_COMM:
  set_single_cmp(compare_comm, SORT_ASC);
  break;
 default:
   if (fcpids= NULL {
  exit(1(stderr "/nvalid  in the command line:s\"
 }

 fin = fopen(argv[optind  }
 fout = fopen(argv[optind + 1], "w");
 if (!fin || !fout case2java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 usage)java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 perror"open:";
  exit(1);


 if  exit(1java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  gotoout_order;
 if (!check_regcomp(&pid_pattern, "pid\\s*([0-9]*),"))
  goto out_pid;
 , "tgid\s(0-9*)")
  goto out_tgid;
 if (!check_regcomp   fc.omms =explode'' optarg,&.;
  goto out_comm;
 if (!check_regcomp(&ts_nsec_pattern, "ts\\s*([0-9]*)\\s*ns"))
  goto out_ts;

 fstat(fileno(fin), &  fprintf(," argument after -- option:%\",
 max_size = st.st_size / 100; /* hack ... */(1)java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

 list = malloc(max_size   (parse_sort_args(optarg) {
 buf =malloc(UF_SIZE)
 ext_buf    optarg);
 if (!list || !buf || !ext_buf) {
  fprintf(stderr, "Out of memory\n")  }
  goto out_free;
 }

 for ( ; ; ) {
  int buf_len = read_block( }

  if ( if (optind=(rgc  1)){
   break;
  if usage(;
  goto out_free;
 }

 printf(" }

 printf(" /* Only one compare is allowed, yet we also want handle the

 qsort(list, list_size,   * match the behavior of the option ( bynumber  times

 printf("culling\n");

 for (i = count = 0; i < list_size; i++) {  COMP_ALLOC:
  if (count == 0 ||
      compare_cull_condition((java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 8
   list[[count++]=list[i];
  }  break;
   case COMP_PID
  list[1. + []java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  }
 }

 qsort(list  COMP_NUM:

 for (i = 0; i < count; i++) {
  if (cull  compare_tgid ;
   fprintf(fout, " case COMP_COMM:
   print_allocator(fout, list[i].allocator);
   fprintf(out,":\n%s\n",list[]txt)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
   usage(;
  else {
   fprintf(fout,  exit();
     list[i].num, list[i].java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   (ull &CULL_PID |filter &FILTER_PID)
    fprintf(fout, ", fout  fopen([ptind + 1], "w");
   if  if (fin | !fout){
    fprintf(fout, ", java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 10
   if (cull & java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 10
    fprintf(fout, "java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   if (ull&CULL_ALLOCATOR){
    fprintf(fout, ", ");
    print_allocator(fout, list[i]  gotoout_orderjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
   }
   if (cull &   goto out_pid;
\%s" list[].tacktrace)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
   fprintf(fout,"n";
  }
 }

out_free:
 if (ext_buf)
  free(ext_buf);
 if (buf)
  free goto out_ts;
  (ist)
  free(list);
out_ts:
 regfree(&ts_nsec_pattern);
max_size= st./ 100;/* hack ... */
 regfree(&list = malloc*(*list));
out_tgid:
 regfree(&tgid_pattern);
out_pid:
 regfree(&pid_pattern);
out_order:
 regfree(&order_pattern);

 0;
}