/* * * Copyright 1994-1998 Charles Blake and Michael K. Johnson * This file is distributable under the conditions of the * GNU Library General Public License. See the * file ../COPYING.LIB for details. * */ /* ** Modified on 27 Nov 2003 by Moreno 'baro' Baricevic ** Added sort handling for openMosix infos (where, nmigs, lock, cantmove). ** Modified or added sections are delimited by "OMINFO" comments. */ #include /* for strcmp */ #include /* for parse error output */ #include "readproc.h" /* for proc_t */ #include "tree.h" /* for struct tree_node */ /* This module was written by Charles Blake for procps. mult_lvl_cmp: slick general purpose multi-level compare function I invented. sort_depth: the number of levels of functions *to use*. This means many more levels can be defined than mult_lvl_cmp tres out. If this is 1 then mult_lvl_cmp is just a trivial wrapper around (*sort_function[0]). sort_direction: multiplicative factor for the output of cmp_whatever. 1 ==> default order, -1 ==> reverse order, 0 ==> forced equality The 0 bit is the neat part. Since a value of zero is the code for equality multiplying the output of cmp_foo(a,b) forces a==b to be true. This is a convenient way to turn sorting off in middle levels of a multi-level sort. If time is a problem, reforming the whole sort_function array to not include these unsorted middle levels will be faster since then cmp_foo won't even be called. It might simplify some code depending upon how you organize it. sort_function[]: array of function pointers that points to our family of comparison functions (I have named them cmp_* but mult_lvl_cmp doesn't care what they're named). This may be declared and initialized like so: int (*sort_function[])(void* a, void* b)={&cmp_foo, &cmp_bar, &cmp_hiho}; You could also use my command line '-O' parser below. Note that we only descend levels until the order is determined. If we descend all levels, that means that the items are equal at all levels, so we return 0. Otherwise we return whatever the level's cmp_foo function would have returned. This allows whatever default behavior you want for cmp_foo. sort_direction[] reverses this default behavior, but mult_lvl_cmp doesn't decide that ascending or descending is the default. That is the job of your cmp_foo's. */ /* the only reason these are global is because qsort(3) likes it that way. It's also a little more efficient if mult_lvl_cmp() is called many times. */ typedef int (*cmp_t)(void*,void*); /* for function pointer casts */ int sort_depth = 0; int sort_direction[10]; /* storage for 10 levels, but 4 would be plenty!*/ int (*sort_function[10])(void* a, void* b); int mult_lvl_cmp(void* a, void* b) { int i, cmp_val; for(i = 0; i < sort_depth; i++) { cmp_val = sort_direction[i] * (*sort_function[i])(a,b); if (cmp_val != 0) return cmp_val; } return 0; } int node_mult_lvl_cmp(void* a, void* b) { int i, cmp_val; for(i = 0; i < sort_depth; i++) { cmp_val = sort_direction[i] * (*sort_function[i])(&(((struct tree_node *)a)->proc),&(((struct tree_node *)b)->proc)); if (cmp_val != 0) return cmp_val; } return 0; } /* qsort(3) compliant comparison functions for all members of the ps_proc structure (in the same order in which they appear in the proc_t declaration) return is {-1,0,1} as {ab} default ordering is ascending for all members. (flip 1,-1 to reverse) */ /* pre-processor macros to cut down on source size (and typing!) Note the use of the string concatenation operator ## */ #define CMP_STR(NAME) \ int cmp_ ## NAME(proc_t** P, proc_t** Q) { \ return strcmp((*P)->NAME, (*Q)->NAME); \ } #define CMP_INT(NAME) \ int cmp_ ## NAME (proc_t** P, proc_t** Q) { \ if ((*P)->NAME < (*Q)->NAME) return -1; \ if ((*P)->NAME > (*Q)->NAME) return 1; \ return 0; \ } /* Define the (46!) cmp_ functions with the above macros for every element of proc_t. If the binary gets too big, we could nuke inessentials. */ /* CMP_STR(cmdline) */ CMP_STR(user) CMP_STR(cmd) /* CMP_INT(state) */ /* CMP_STR(ttyc) */ CMP_INT(uid) CMP_INT(pid) CMP_INT(ppid) CMP_INT(pgrp) CMP_INT(session) CMP_INT(tty) CMP_INT(tpgid) CMP_INT(utime) CMP_INT(stime) CMP_INT(cutime) CMP_INT(cstime) /* CMP_INT(priority) */ CMP_INT(nice) CMP_INT(start_time) /* CMP_INT(signal) */ /* CMP_INT(blocked) */ /* CMP_INT(sigignore) */ /* CMP_INT(sigcatch) */ CMP_INT(flags) CMP_INT(min_flt) CMP_INT(cmin_flt) CMP_INT(maj_flt) CMP_INT(cmaj_flt) /* CMP_INT(timeout) */ CMP_INT(vsize) CMP_INT(rss) /* CMP_INT(rss_rlim) */ /* CMP_INT(start_code) */ /* CMP_INT(end_code) */ /* CMP_INT(start_stack) */ /* CMP_INT(kstk_esp) */ /* CMP_INT(kstk_eip) */ /* CMP_INT(wchan) */ CMP_INT(pcpu) CMP_INT(size) CMP_INT(resident) CMP_INT(share) /* CMP_INT(trs) */ /* CMP_INT(lrs) */ /* CMP_INT(drs) */ /* CMP_INT(dt) */ /* OMINFO { */ CMP_INT(where) CMP_INT(nmigs) CMP_INT(lock) CMP_STR(cantmove) /* } OMINFO */ /* define user interface to sort keys. Fairly self-explanatory. */ struct cmp_fun_struct { char letter; /* single option-letter for key */ char name[15]; /* long option name for key */ int (*fun)(proc_t**, proc_t**); /* pointer to cmp_key */ } cmp[] = { /* { '?', "cmdline", &cmp_cmdline }, */ { 'u', "user", &cmp_user }, { 'c', "cmd", &cmp_cmd }, /* { '?', "state", &cmp_state }, */ /* { '?', "ttyc", &cmp_ttyc }, */ { 'U', "uid", &cmp_uid }, { 'p', "pid", &cmp_pid }, { 'P', "ppid", &cmp_ppid }, { 'g', "pgrp", &cmp_pgrp }, { 'o', "session", &cmp_session }, { 't', "tty", &cmp_tty }, { 'G', "tpgid", &cmp_tpgid }, { 'k', "utime", &cmp_utime }, { 'K', "stime", &cmp_stime }, { 'j', "cutime", &cmp_cutime }, { 'J', "cstime", &cmp_cstime }, /* { '?', "counter", &cmp_counter }, */ { 'y', "priority", &cmp_nice }, { 'T', "start_time", &cmp_start_time }, /* { '?', "signal", &cmp_signal }, */ /* { '?', "blocked", &cmp_blocked }, */ /* { '?', "sigignore", &cmp_sigignore }, */ /* { '?', "sigcatch", &cmp_sigcatch }, */ { 'f', "flags", &cmp_flags }, { 'm', "min_flt", &cmp_min_flt }, { 'n', "cmin_flt", &cmp_cmin_flt }, { 'M', "maj_flt", &cmp_maj_flt }, { 'N', "cmaj_flt", &cmp_cmaj_flt }, /* { 'C', "timeout", &cmp_timeout }, */ { 'v', "vsize", &cmp_vsize }, { 'r', "rss", &cmp_rss }, /* { '?', "rss_rlim", &cmp_rss_rlim }, */ /* { '?', "start_code", &cmp_start_code }, */ /* { '?', "end_code", &cmp_end_code }, */ /* { '?', "start_stack", &cmp_start_stack }, */ /* { '?', "kstk_esp", &cmp_kstk_esp }, */ /* { '?', "kstk_eip", &cmp_kstk_eip }, */ /* { '?', "wchan", &cmp_wchan }, */ { 'C', "pcpu", &cmp_pcpu }, { 's', "size", &cmp_size }, { 'R', "resident", &cmp_resident }, { 'S', "share", &cmp_share }, /* { '?', "trs", &cmp_trs }, */ /* { '?', "lrs", &cmp_lrs }, */ /* { '?', "drs", &cmp_drs }, */ /* { '?', "dt", &cmp_dt }, */ /* OMINFO {*/ /* ** free letters are: aA bB dD eE F hH iI lL O qQ V wW xX Y zZ ** numbers and punct are all free */ #define USE_OM_LABEL /* print oM label before oM fields ? */ #ifdef USE_OM_LABEL # define DUMMY '\1' /* unprintable, couldn't be passed by user on cmdline (hopefully) */ { DUMMY , "dummy" , NULL }, #endif { 'w', "where", &cmp_where }, { 'w', "node", &cmp_where }, /* alias for 'where' */ { '#', "nmigs", &cmp_nmigs }, { 'l', "lock", &cmp_lock }, { 'L', "cantmove", &cmp_cantmove }, { 'L', "cant", &cmp_cantmove }, /* short alias for 'cantmove' */ /* } OMINFO */ { '\0',"terminator", NULL } }; /* OMINFO {*/ #ifdef USE_OM_LABEL # define SPACES " " # define EMPTY "" # define NL "\n" void dump_keys(void) { int i , j; for( i = 0 , j = 0 ; cmp[i].letter ; i++ , j++ ) if ( cmp[i].letter == DUMMY ) fprintf( stderr , "%s" SPACES "* openMosix related *\n" , ( i % 2 ) ? NL : EMPTY ) , j = 1 ; else fprintf( stderr , "%s-O%c , --sort:%-15.15s%s" , ( j % 2 ) ? EMPTY : SPACES /* what are we living for, abandoned places ... */ , cmp[i].letter, cmp[i].name , ( j % 2 ) ? NL : EMPTY ); if ( j % 2 ) fprintf(stderr, "\n"); } # undef SPACES # undef EMPTY # undef NL #else /* old (sane) */ void dump_keys(void) { int i; for(i=0; cmp[i].letter; i++) fprintf(stderr, "%s-O%c , --sort:%-15.15s%s", i%2?"":" ", cmp[i].letter, cmp[i].name, i%2?"\n":""); if (i%2) fprintf(stderr, "\n"); } #endif /* } OMINFO */ /* command line option parsing. Assign sort_{depth,direction[],function[]} based upon a string of the form: [+-]a[+-]b[+-]c... with a,b,c,... being letter flags corresponding to a particular sort key and the optional '-' specifying a reverse sort on that key. + doesn't mean anything, but it keeps things looking balanced... */ int parse_sort_opt(char* opt) { int i, next_dir=1; for(; *opt ; ++opt) { if (*opt == '-' || *opt == '+') { if (*opt == '-') next_dir = -1; /* OMINFO {*/ #if 0 /* (old) why opt++ ? opt++ OR continue, NOT both... */ opt++; #endif /* } OMINFO */ continue; } for (i = 0; cmp[i].letter; i++) if (*opt == cmp[i].letter) break; if (!cmp[i].letter) { fprintf(stderr, "ps: no such sort key -- %c. Possibilities are:\n", *opt); dump_keys(); return -1; } else { #ifdef DEBUG fprintf(stderr, "sort level %d: key %s, direction % d\n", sort_depth, cmp[i].name, next_dir); #endif sort_function[sort_depth] = (cmp_t)cmp[i].fun; sort_direction[sort_depth++] = next_dir; next_dir = 1; } } return 0; } int parse_long_sort(char* opt) { char* comma; int i, more_keys, next_dir=1; do { if (*opt == '-' || *opt == '+') { if (*opt == '-') next_dir = -1; more_keys = 1; opt++; continue; } more_keys = ((comma=index(opt,',')) != NULL); /* keys are ',' delimited */ if (more_keys) *comma='\0'; /* terminate for strcmp() */ for(i = 0; cmp[i].letter; ++i) if (strcmp(opt, cmp[i].name) == 0) break; if (!cmp[i].letter) { fprintf(stderr, "ps: no such sort key -- %s. Possibilities are:\n", opt); dump_keys(); return -1; } else { #ifdef DEBUG fprintf(stderr, "sort level %d: key %s, direction % d\n", sort_depth, cmp[i].name, next_dir); #endif sort_function[sort_depth] = (cmp_t)cmp[i].fun; sort_direction[sort_depth++] = next_dir; next_dir = 1; } opt = comma + 1; /* do next loop on next key, if more keys, else done*/ } while (more_keys); return 0; } void reset_sort_options (void) { int i; sort_depth=0; for (i=0;i<10;i++){ sort_direction[i]=0; sort_function[i]=(cmp_t)NULL; } } void register_sort_function (int dir, cmp_t func) { sort_function[sort_depth] = func; sort_direction[sort_depth++] = dir; }