diff options
Diffstat (limited to 'libps/spec.c')
| -rw-r--r-- | libps/spec.c | 756 |
1 files changed, 756 insertions, 0 deletions
diff --git a/libps/spec.c b/libps/spec.c new file mode 100644 index 00000000..c3e68f95 --- /dev/null +++ b/libps/spec.c @@ -0,0 +1,756 @@ +/* Access, formatting, & comparison routines for printing process info. + + Copyright (C) 1995 Free Software Foundation, Inc. + + Written by Miles Bader <miles@gnu.ai.mit.edu> + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2, or (at + your option) any later version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <hurd.h> +#include <stdio.h> +#include <stdlib.h> +#include <assert.h> +#include <pwd.h> + +#include "ps.h" +#include "pshost.h" +#include "common.h" + +/* ---------------------------------------------------------------- */ +/* Getter definitions */ + +typedef void (*vf)(); + +static int +ps_get_pid(proc_stat_t ps) +{ + return proc_stat_pid(ps); +} +struct ps_getter ps_pid_getter = +{"pid", PSTAT_PID, (vf) ps_get_pid}; + +static int +ps_get_thread_index(proc_stat_t ps) +{ + return proc_stat_thread_index(ps); +} +struct ps_getter ps_thread_index_getter = +{"thread_index", PSTAT_THREAD, (vf) ps_get_thread_index}; + +static int +ps_get_owner(proc_stat_t ps) +{ + return proc_stat_info(ps)->owner; +} +struct ps_getter ps_owner_getter = +{"owner", PSTAT_INFO, (vf) ps_get_owner}; + +static int +ps_get_ppid(proc_stat_t ps) +{ + return proc_stat_info(ps)->ppid; +} +struct ps_getter ps_ppid_getter = +{"ppid", PSTAT_INFO, (vf) ps_get_ppid}; + +static int +ps_get_pgrp(proc_stat_t ps) +{ + return proc_stat_info(ps)->pgrp; +} +struct ps_getter ps_pgrp_getter = +{"pgrp", PSTAT_INFO, (vf) ps_get_pgrp}; + +static int +ps_get_session(proc_stat_t ps) +{ + return proc_stat_info(ps)->session; +} +struct ps_getter ps_session_getter = +{"session", PSTAT_INFO, (vf) ps_get_session}; + +static int +ps_get_login_col(proc_stat_t ps) +{ + return proc_stat_info(ps)->logincollection; +} +struct ps_getter ps_login_col_getter = +{"login_col", PSTAT_INFO, (vf) ps_get_login_col}; + +static int +ps_get_num_threads(proc_stat_t ps) +{ + return proc_stat_num_threads(ps); +} +struct ps_getter ps_num_threads_getter = +{"num_threads", PSTAT_NUM_THREADS, (vf)ps_get_num_threads}; + +static void +ps_get_args(proc_stat_t ps, char **args_p, int *args_len_p) +{ + *args_p = proc_stat_args(ps); + *args_len_p = proc_stat_args_len(ps); +} +struct ps_getter ps_args_getter = +{"args", PSTAT_ARGS, ps_get_args}; + +static int +ps_get_state(proc_stat_t ps) +{ + return proc_stat_state(ps); +} +struct ps_getter ps_state_getter = +{"state", PSTAT_STATE, (vf) ps_get_state}; + +static int +ps_get_vsize(proc_stat_t ps) +{ + return proc_stat_info(ps)->taskinfo.virtual_size; +} +struct ps_getter ps_vsize_getter = +{"vsize", PSTAT_INFO, (vf) ps_get_vsize}; + +static int +ps_get_rsize(proc_stat_t ps) +{ + return proc_stat_info(ps)->taskinfo.resident_size; +} +struct ps_getter ps_rsize_getter = +{"rsize", PSTAT_INFO, (vf) ps_get_rsize}; + +static int +ps_get_cur_priority(proc_stat_t ps) +{ + return proc_stat_thread_sched_info(ps)->cur_priority; +} +struct ps_getter ps_cur_priority_getter = +{"cur_priority", PSTAT_THREAD_INFO, (vf) ps_get_cur_priority}; + +static int +ps_get_base_priority(proc_stat_t ps) +{ + return proc_stat_thread_sched_info(ps)->base_priority; +} +struct ps_getter ps_base_priority_getter = +{"base_priority", PSTAT_THREAD_INFO, (vf) ps_get_base_priority}; + +static int +ps_get_max_priority(proc_stat_t ps) +{ + return proc_stat_thread_sched_info(ps)->max_priority; +} +struct ps_getter ps_max_priority_getter = +{"max_priority", PSTAT_THREAD_INFO, (vf) ps_get_max_priority}; + +static void +ps_get_usr_time(proc_stat_t ps, time_value_t * tv_out) +{ + *tv_out = proc_stat_thread_basic_info(ps)->user_time; +} +struct ps_getter ps_usr_time_getter = +{"usr_time", PSTAT_THREAD_INFO, ps_get_usr_time}; + +static void +ps_get_sys_time(proc_stat_t ps, time_value_t * tv_out) +{ + *tv_out = proc_stat_thread_basic_info(ps)->system_time; +} +struct ps_getter ps_sys_time_getter = +{"sys_time", PSTAT_THREAD_INFO, ps_get_sys_time}; + +static void +ps_get_tot_time(proc_stat_t ps, time_value_t * tv_out) +{ + *tv_out = proc_stat_thread_basic_info(ps)->user_time; + time_value_add(tv_out, &proc_stat_thread_basic_info(ps)->system_time); +} +struct ps_getter ps_tot_time_getter = +{"tot_time", PSTAT_THREAD_INFO, ps_get_tot_time}; + +static float +ps_get_rmem_frac(proc_stat_t ps) +{ + static int mem_size = 0; + + if (mem_size == 0) + { + host_basic_info_t info; + error_t err = ps_host_basic_info(&info); + if (err == 0) + mem_size = info->memory_size; + } + + if (mem_size > 0) + return (float)proc_stat_info(ps)->taskinfo.resident_size / (float)mem_size; + else + return 0.0; +} +struct ps_getter ps_rmem_frac_getter = +{"rmem_frac", PSTAT_INFO, (vf) ps_get_rmem_frac}; + +static float +ps_get_cpu_frac(proc_stat_t ps) +{ + return (float) proc_stat_thread_basic_info(ps)->cpu_usage + / (float) TH_USAGE_SCALE; +} +struct ps_getter ps_cpu_frac_getter = +{"cpu_frac", PSTAT_THREAD_INFO, (vf) ps_get_cpu_frac}; + +static int +ps_get_sleep(proc_stat_t ps) +{ + return proc_stat_thread_basic_info(ps)->sleep_time; +} +struct ps_getter ps_sleep_getter = +{"sleep", PSTAT_THREAD_INFO, (vf) ps_get_sleep}; + +static void +ps_get_tty_name(proc_stat_t ps, char **str_p, int *len_p) +{ + *str_p = proc_stat_tty_name(ps); + if (*str_p != NULL) + *len_p = strlen(*str_p) + 1; +} +struct ps_getter ps_tty_name_getter = +{"tty_name", PSTAT_TTY_NAME, ps_get_tty_name}; + +static int +ps_get_page_faults(proc_stat_t ps) +{ + return proc_stat_task_events_info(ps)->faults; +} +struct ps_getter ps_page_faults_getter = +{"page_faults", PSTAT_TASK_EVENTS_INFO, (vf) ps_get_page_faults}; + +static int +ps_get_cow_faults(proc_stat_t ps) +{ + return proc_stat_task_events_info(ps)->cow_faults; +} +struct ps_getter ps_cow_faults_getter = +{"cow_faults", PSTAT_TASK_EVENTS_INFO, (vf) ps_get_cow_faults}; + +static int +ps_get_pageins(proc_stat_t ps) +{ + return proc_stat_task_events_info(ps)->pageins; +} +struct ps_getter ps_pageins_getter = +{"pageins", PSTAT_TASK_EVENTS_INFO, (vf) ps_get_pageins}; + +static int +ps_get_msgs_sent(proc_stat_t ps) +{ + return proc_stat_task_events_info(ps)->messages_sent; +} +struct ps_getter ps_msgs_sent_getter = +{"msgs_sent", PSTAT_TASK_EVENTS_INFO, (vf) ps_get_msgs_sent}; + +static int +ps_get_msgs_rcvd(proc_stat_t ps) +{ + return proc_stat_task_events_info(ps)->messages_received; +} +struct ps_getter ps_msgs_rcvd_getter = +{"msgs_rcvd", PSTAT_TASK_EVENTS_INFO, (vf) ps_get_msgs_rcvd}; + +static int +ps_get_zero_fills(proc_stat_t ps) +{ + return proc_stat_task_events_info(ps)->zero_fills; +} +struct ps_getter ps_zero_fills_getter = +{"zero_fills", PSTAT_TASK_EVENTS_INFO, (vf) ps_get_zero_fills}; + +/* ---------------------------------------------------------------- */ +/* some printing functions */ + +/* G() is a helpful macro that just returns the getter G's access function + cast into a function pointer returning TYPE, as how the function should be + called varies depending on the getter */ +#define G(g,type)((type (*)())ps_getter_function(g)) + +error_t +ps_emit_int(proc_stat_t ps, ps_getter_t getter, int width, FILE *stream, int *count) +{ + return ps_write_int_field(G(getter, int)(ps), width, stream, count); +} + +error_t +ps_emit_num_blocks(proc_stat_t ps, ps_getter_t getter, int width, FILE + *stream, int *count) +{ + char buf[20]; + sprintf(buf, "%ld", G(getter, int)(ps) / 1024); + return ps_write_field(buf, width, stream, count); +} + +int +sprint_frac_value(char *buf, + int value, int min_value_len, + int frac, int frac_scale, + int width) +{ + int value_len; + int frac_len; + + if (value >= 100) /* the integer part */ + value_len = 3; + else if (value >= 10) + value_len = 2; + else + value_len = 1; + + while (value_len < min_value_len--) + *buf++ = '0'; + + for (frac_len = frac_scale + ; frac_len > 0 && (width < value_len + 1 + frac_len || frac % 10 == 0) + ; frac_len--) + frac /= 10; + + if (frac_len > 0) + sprintf(buf, "%ld.%0*ld", value, frac_len, frac); + else + sprintf(buf, "%ld", value); + + return strlen(buf); +} + +error_t +ps_emit_percent(proc_stat_t ps, ps_getter_t getter, + int width, FILE *stream, int *count) +{ + char buf[20]; + float perc = G(getter, float)(ps) * 100; + + if (width == 0) + sprintf(buf, "%g", perc); + else if (ABS(width) > 3) + sprintf(buf, "%.*f", ABS(width) - 3, perc); + else + sprintf(buf, "%d", (int) perc); + + return ps_write_field(buf, width, stream, count); +} + +/* prints its value nicely */ +error_t +ps_emit_nice_int(proc_stat_t ps, ps_getter_t getter, + int width, FILE *stream, int *count) +{ + char buf[20]; + int value = G(getter, int)(ps); + char *sfx = " KMG"; + int frac = 0; + + while (value >= 1024) + { + frac = ((value & 0x3FF) * 1000) >> 10; + value >>= 10; + sfx++; + } + + sprintf(buf + sprint_frac_value(buf, value, 1, frac, 3, ABS(width) - 1), + "%c", *sfx); + + return ps_write_field(buf, width, stream, count); +} + +#define MINUTE 60 +#define HOUR (60*MINUTE) +#define DAY (24*HOUR) +#define WEEK (7*DAY) + +static int +sprint_long_time(char *buf, int seconds, int width) +{ + char *p = buf; + struct tscale + { + int length; + char *sfx; + char *short_sfx; + } + time_scales[] = + { + { WEEK, " week", "wk"} , + { DAY, " day", "dy"} , + { HOUR, " hour", "hr"} , + { MINUTE," min", "m"} , + { 0} + }; + struct tscale *ts = time_scales; + + while (ts->length > 0 && width > 0) + { + if (ts->length < seconds) + { + int len; + int num = seconds / ts->length; + seconds %= ts->length; + sprintf(p, "%d%s", num, ts->sfx); + len = strlen(p); + width -= len; + if (width < 0 && p > buf) + break; + p += len; + } + ts++; + } + + *p = '\0'; + + return p - buf; +} + +error_t +ps_emit_nice_seconds(proc_stat_t ps, ps_getter_t getter, + int width, FILE *stream, int *count) +{ + char buf[20]; + time_value_t tv; + + G(getter, int)(ps, &tv); + + if (tv.seconds == 0) + { + if (tv.microseconds < 500) + sprintf(buf, "%dus", tv.microseconds); + else + strcpy(buf + + sprint_frac_value(buf, + tv.microseconds / 1000, 1, + tv.microseconds % 1000, 3, + ABS(width) - 2), + "ms"); + } + else if (tv.seconds < MINUTE) + sprint_frac_value(buf, tv.seconds, 1, tv.microseconds, 6, ABS(width)); + else if (tv.seconds < HOUR) + { + /* 0:00.00... */ + int min_len; + sprintf(buf, "%d:", tv.seconds / 60); + min_len = strlen(buf); + sprint_frac_value(buf + min_len, + tv.seconds % 60, 2, + tv.microseconds, 6, + ABS(width) - min_len); + } + else + sprint_long_time(buf, tv.seconds, width); + + return ps_write_field(buf, width, stream, count); +} + +static int +append_fraction(char *buf, int frac, int digits, int width) +{ + int slen = strlen(buf); + int left = width - strlen(buf); + if (left > 1) + { + buf[slen] = '.'; + left--; + while (digits > left) + frac /= 10, digits--; + sprintf(buf + slen + 1, "%0*d", digits, frac); + return slen + 1 + digits; + } + else + return slen; +} + +error_t +ps_emit_seconds(proc_stat_t ps, ps_getter_t getter, int width, FILE *stream, + int *count) +{ + int max = (width == 0 ? 999 : ABS(width)); + char buf[20]; + time_value_t tv; + + G(getter, void)(ps, &tv); + + if (tv.seconds > DAY) + sprint_long_time(buf, tv.seconds, max); + else if (tv.seconds > HOUR) + if (max >= 8) + { + /* 0:00:00.00... */ + sprintf(buf, "%2d:%02d:%02d", + tv.seconds / HOUR, + (tv.seconds % HOUR) / MINUTE, (tv.seconds % MINUTE)); + append_fraction(buf, tv.microseconds, 6, max); + } + else + sprint_long_time(buf, tv.seconds, max); + else if (max >= 5 || tv.seconds > MINUTE) + { + /* 0:00.00... */ + sprintf(buf, "%2d:%02d", tv.seconds / MINUTE, tv.seconds % MINUTE); + append_fraction(buf, tv.microseconds, 6, max); + } + else + sprint_frac_value(buf, tv.seconds, 1, tv.microseconds, 6, max); + + return ps_write_field(buf, width, stream, count); +} + +error_t +ps_emit_user(proc_stat_t ps, ps_getter_t getter, int width, FILE *stream, int *count) +{ + int uid = G(getter, int)(ps); + if (uid < 0) + return ps_write_padding(0, width, stream, count); + else + { + struct passwd *pw = getpwuid(uid); + if (pw == NULL) + return ps_write_int_field(uid, width, stream, count); + else + return ps_write_field(pw->pw_name, width, stream, count); + } +} + +/* prints a string with embedded nuls as spaces */ +error_t +ps_emit_string0(proc_stat_t ps, ps_getter_t getter, + int width, FILE *stream, int *count) +{ + char *s0, *p, *q; + int s0len; + int fwidth = ABS(width); + char static_buf[200]; + char *buf = static_buf; + + G(getter, void)(ps, &s0, &s0len); + + if (s0 == NULL) + *buf = '\0'; + else + { + if (s0len > sizeof static_buf) + { + buf = malloc(s0len + 1); + if (buf == NULL) + return ENOMEM; + } + + if (fwidth == 0 || fwidth > s0len) + fwidth = s0len; + + for (p = buf, q = s0; fwidth-- > 0; p++, q++) + { + int ch = *q; + *p = (ch == '\0' ? ' ' : ch); + } + if (q > s0 && *(q - 1) == '\0') + *--p = '\0'; + else + *p = '\0'; + } + + { + error_t err = ps_write_field(buf, width, stream, count); + if (buf != static_buf) + free(buf); + return err; + } +} + +error_t +ps_emit_string(proc_stat_t ps, ps_getter_t getter, + int width, FILE *stream, int *count) +{ + char *str; + int len; + + G(getter, void)(ps, &str, &len); + + if (str == NULL) + str = ""; + else if (width != 0 && len > ABS(width)) + str[ABS(width)] = '\0'; + + return ps_write_field(str, width, stream, count); +} + +error_t +ps_emit_tty_name(proc_stat_t ps, ps_getter_t getter, + int width, FILE *stream, int *count) +{ + struct tty_abbrev + { + char *pfx, *subst; + } + abbrevs[] = + { + { "/tmp/console", "oc" }, /* temp hack */ + { "/dev/console", "co"}, + { "/dev/tty", ""}, + { "/dev/pty", ""}, + { "/dev/", ""}, + { 0 } + }; + char buf[20]; + char *str; + int len; + + G(getter, void)(ps, &str, &len); + + if (str == NULL || len == 0) + str = "-"; + else + { + struct tty_abbrev *abbrev = abbrevs; + while (abbrev->pfx != NULL) + { + int pfx_len = strlen(abbrev->pfx); + if (strncmp(str, abbrev->pfx, pfx_len) == 0) + { + strcpy(buf, abbrev->subst); + strcat(buf, str + pfx_len); + str = buf; + break; + } + else + abbrev++; + } + } + + return ps_write_field(str, width, stream, count); +} + +error_t +ps_emit_state(proc_stat_t ps, ps_getter_t getter, + int width, FILE *stream, int *count) +{ + char *tags; + int state = G(getter, int)(ps); + char buf[20], *p = buf; + + /* turn off seemingly bogus or annoying flags */ + state &= ~PSTAT_STATE_SWAPPED; + + /* If any thread is running, don't mention sleeping or idle threads -- + presumably *some* work is getting done... */ + if (state & PSTAT_STATE_RUNNING) + state &= ~(PSTAT_STATE_SLEEPING | PSTAT_STATE_IDLE); + if (state & PSTAT_STATE_IDLE) + state &= ~PSTAT_STATE_SLEEPING; + + for (tags = proc_stat_state_tags + ; state != 0 && *tags != '\0' + ; state >>= 1, tags++) + if (state & 1) + *p++ = *tags; + + *p = '\0'; + + return ps_write_field(buf, width, stream, count); +} + +/* ---------------------------------------------------------------- */ +/* comparison functions */ + +int +ps_cmp_ints(proc_stat_t ps1, proc_stat_t ps2, ps_getter_t getter) +{ + int (*gf)() = G(getter, int); + int v1 = gf(ps1), v2 = gf(ps2); + return v1 == v2 ? 0 : v1 < v2 ? -1 : 1; +} + +int +ps_cmp_floats(proc_stat_t ps1, proc_stat_t ps2, ps_getter_t getter) +{ + float (*gf)() = G(getter, float); + float v1 = gf(ps1), v2 = gf(ps2); + return v1 == v2 ? 0 : v1 < v2 ? -1 : 1; +} + +int +ps_cmp_strings(proc_stat_t ps1, proc_stat_t ps2, ps_getter_t getter) +{ + void (*gf)() = G(getter, void); + char *s1, *s2; + int s1len, s2len; + + /* Get both strings */ + gf(ps1, &s1, &s1len); + gf(ps2, &s2, &s2len); + + if (s1 == NULL) + if (s2 == NULL) + return 0; + else + return -1; + else + if (s2 == NULL) + return 1; + else + return strncmp(s1, s2, MIN(s1len, s2len)); +} + +/* ---------------------------------------------------------------- */ + +ps_fmt_spec_t +find_ps_fmt_spec(char *name, ps_fmt_spec_t specs) +{ + while (!ps_fmt_spec_is_end(specs)) + if (strcasecmp(ps_fmt_spec_name(specs), name) == 0) + return specs; + else + specs++; + return NULL; +} + +/* ---------------------------------------------------------------- */ + +struct ps_fmt_spec ps_std_fmt_specs[] = +{ + {"PID", &ps_pid_getter, ps_emit_int, ps_cmp_ints, -5}, + {"TH#", &ps_thread_index_getter,ps_emit_int, ps_cmp_ints, -2}, + {"PPID", &ps_ppid_getter, ps_emit_int, ps_cmp_ints, -5}, + {"UID", &ps_owner_getter, ps_emit_int, ps_cmp_ints, -5}, + {"NTh", &ps_num_threads_getter, ps_emit_int, ps_cmp_ints, -2}, + {"PGrp", &ps_pgrp_getter, ps_emit_int, ps_cmp_ints, -5}, + {"User", &ps_owner_getter, ps_emit_user, ps_cmp_ints, 6}, + {"Sess", &ps_session_getter, ps_emit_int, ps_cmp_ints, -5}, + {"LColl", &ps_login_col_getter, ps_emit_int, ps_cmp_ints, -5}, + {"Args", &ps_args_getter, ps_emit_string0, ps_cmp_strings, 0}, + {"Time", &ps_tot_time_getter, ps_emit_seconds, ps_cmp_ints, -8}, + {"UTime", &ps_usr_time_getter, ps_emit_seconds, ps_cmp_ints, -8}, + {"STime", &ps_sys_time_getter, ps_emit_seconds, ps_cmp_ints, -8}, + {"VSize", &ps_vsize_getter, ps_emit_nice_int, ps_cmp_ints, -5}, + {"RSize", &ps_rsize_getter, ps_emit_nice_int, ps_cmp_ints, -5}, + {"Pri", &ps_cur_priority_getter,ps_emit_int, ps_cmp_ints, -2}, + {"BPri", &ps_base_priority_getter,ps_emit_int, ps_cmp_ints, -2}, + {"MPri", &ps_max_priority_getter,ps_emit_int, ps_cmp_ints, -2}, + {"%Mem", &ps_rmem_frac_getter, ps_emit_percent, ps_cmp_floats, -4}, + {"%CPU", &ps_cpu_frac_getter, ps_emit_percent, ps_cmp_floats, -4}, + {"State", &ps_state_getter, ps_emit_state, NULL, 4}, + {"Sleep", &ps_sleep_getter, ps_emit_int, ps_cmp_ints, -2}, + {"TTY", &ps_tty_name_getter, ps_emit_tty_name, ps_cmp_strings, 2}, + {"PgFlts", &ps_page_faults_getter, ps_emit_int, ps_cmp_ints, -5}, + {"COWFlts",&ps_cow_faults_getter, ps_emit_int, ps_cmp_ints, -5}, + {"PgIns", &ps_pageins_getter, ps_emit_int, ps_cmp_ints, -5}, + {"MsgsIn", &ps_msgs_rcvd_getter, ps_emit_int, ps_cmp_ints, -5}, + {"MsgsOut",&ps_msgs_sent_getter, ps_emit_int, ps_cmp_ints, -5}, + {"ZFills", &ps_zero_fills_getter, ps_emit_int, ps_cmp_ints, -5}, + {0} +}; |