diff options
| -rw-r--r-- | libps/spec.c | 507 |
1 files changed, 295 insertions, 212 deletions
diff --git a/libps/spec.c b/libps/spec.c index 46d7500e..96390c4e 100644 --- a/libps/spec.c +++ b/libps/spec.c @@ -42,23 +42,23 @@ static char *get_rpc_name (mach_msg_id_t it) { return 0; } typedef void (*vf)(); static int -ps_get_pid(proc_stat_t ps) +ps_get_pid (struct proc_stat *ps) { - return proc_stat_pid(ps); + return proc_stat_pid (ps); } const struct ps_getter ps_pid_getter = {"pid", PSTAT_PID, (vf) ps_get_pid}; static int -ps_get_thread_index(proc_stat_t ps) +ps_get_thread_index (struct proc_stat *ps) { - return proc_stat_thread_index(ps); + return proc_stat_thread_index (ps); } const struct ps_getter ps_thread_index_getter = {"thread_index", PSTAT_THREAD, (vf) ps_get_thread_index}; -static ps_user_t -ps_get_owner(proc_stat_t ps) +static struct ps_user * +ps_get_owner (struct proc_stat *ps) { return proc_stat_owner (ps); } @@ -66,7 +66,7 @@ const struct ps_getter ps_owner_getter = {"owner", PSTAT_OWNER, (vf) ps_get_owner}; static int -ps_get_owner_uid (proc_stat_t ps) +ps_get_owner_uid (struct proc_stat *ps) { return proc_stat_owner_uid (ps); } @@ -74,64 +74,64 @@ const struct ps_getter ps_owner_uid_getter = {"uid", PSTAT_OWNER_UID, (vf) ps_get_owner_uid}; static int -ps_get_ppid(proc_stat_t ps) +ps_get_ppid (struct proc_stat *ps) { - return proc_stat_proc_info(ps)->ppid; + return proc_stat_proc_info (ps)->ppid; } const struct ps_getter ps_ppid_getter = {"ppid", PSTAT_PROC_INFO, (vf) ps_get_ppid}; static int -ps_get_pgrp(proc_stat_t ps) +ps_get_pgrp (struct proc_stat *ps) { - return proc_stat_proc_info(ps)->pgrp; + return proc_stat_proc_info (ps)->pgrp; } const struct ps_getter ps_pgrp_getter = {"pgrp", PSTAT_PROC_INFO, (vf) ps_get_pgrp}; static int -ps_get_session(proc_stat_t ps) +ps_get_session (struct proc_stat *ps) { - return proc_stat_proc_info(ps)->session; + return proc_stat_proc_info (ps)->session; } const struct ps_getter ps_session_getter = {"session", PSTAT_PROC_INFO, (vf) ps_get_session}; static int -ps_get_login_col(proc_stat_t ps) +ps_get_login_col (struct proc_stat *ps) { - return proc_stat_proc_info(ps)->logincollection; + return proc_stat_proc_info (ps)->logincollection; } const struct ps_getter ps_login_col_getter = {"login_col", PSTAT_PROC_INFO, (vf) ps_get_login_col}; static int -ps_get_num_threads(proc_stat_t ps) +ps_get_num_threads (struct proc_stat *ps) { - return proc_stat_num_threads(ps); + return proc_stat_num_threads (ps); } const 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) +ps_get_args (struct proc_stat *ps, char **args_p, int *args_len_p) { - *args_p = proc_stat_args(ps); - *args_len_p = proc_stat_args_len(ps); + *args_p = proc_stat_args (ps); + *args_len_p = proc_stat_args_len (ps); } const struct ps_getter ps_args_getter = {"args", PSTAT_ARGS, ps_get_args}; static int -ps_get_state(proc_stat_t ps) +ps_get_state (struct proc_stat *ps) { - return proc_stat_state(ps); + return proc_stat_state (ps); } const struct ps_getter ps_state_getter = {"state", PSTAT_STATE, (vf) ps_get_state}; static void -ps_get_wait (proc_stat_t ps, char **wait, int *rpc) +ps_get_wait (struct proc_stat *ps, char **wait, int *rpc) { *wait = ps->thread_wait; *rpc = ps->thread_rpc; @@ -140,47 +140,47 @@ const struct ps_getter ps_wait_getter = {"wait", PSTAT_THREAD_WAIT, ps_get_wait}; static int -ps_get_vsize(proc_stat_t ps) +ps_get_vsize (struct proc_stat *ps) { - return proc_stat_task_basic_info(ps)->virtual_size; + return proc_stat_task_basic_info (ps)->virtual_size; } const struct ps_getter ps_vsize_getter = {"vsize", PSTAT_TASK_BASIC, (vf) ps_get_vsize}; static int -ps_get_rsize(proc_stat_t ps) +ps_get_rsize (struct proc_stat *ps) { - return proc_stat_task_basic_info(ps)->resident_size; + return proc_stat_task_basic_info (ps)->resident_size; } const struct ps_getter ps_rsize_getter = {"rsize", PSTAT_TASK_BASIC, (vf) ps_get_rsize}; static int -ps_get_cur_priority(proc_stat_t ps) +ps_get_cur_priority (struct proc_stat *ps) { - return proc_stat_thread_basic_info(ps)->cur_priority; + return proc_stat_thread_basic_info (ps)->cur_priority; } const struct ps_getter ps_cur_priority_getter = {"cur_priority", PSTAT_THREAD_BASIC, (vf) ps_get_cur_priority}; static int -ps_get_base_priority(proc_stat_t ps) +ps_get_base_priority (struct proc_stat *ps) { - return proc_stat_thread_basic_info(ps)->base_priority; + return proc_stat_thread_basic_info (ps)->base_priority; } const struct ps_getter ps_base_priority_getter = {"base_priority", PSTAT_THREAD_BASIC, (vf) ps_get_base_priority}; static int -ps_get_max_priority(proc_stat_t ps) +ps_get_max_priority (struct proc_stat *ps) { - return proc_stat_thread_sched_info(ps)->max_priority; + return proc_stat_thread_sched_info (ps)->max_priority; } const struct ps_getter ps_max_priority_getter = {"max_priority", PSTAT_THREAD_SCHED, (vf) ps_get_max_priority}; static void -ps_get_usr_time (proc_stat_t ps, struct timeval *tv) +ps_get_usr_time (struct proc_stat *ps, struct timeval *tv) { time_value_t tvt = proc_stat_thread_basic_info (ps)->user_time; tv->tv_sec = tvt.seconds; @@ -190,7 +190,7 @@ const struct ps_getter ps_usr_time_getter = {"usr_time", PSTAT_THREAD_BASIC, ps_get_usr_time}; static void -ps_get_sys_time (proc_stat_t ps, struct timeval *tv) +ps_get_sys_time (struct proc_stat *ps, struct timeval *tv) { time_value_t tvt = proc_stat_thread_basic_info (ps)->system_time; tv->tv_sec = tvt.seconds; @@ -200,7 +200,7 @@ const struct ps_getter ps_sys_time_getter = {"sys_time", PSTAT_THREAD_BASIC, ps_get_sys_time}; static void -ps_get_tot_time (proc_stat_t ps, struct timeval *tv) +ps_get_tot_time (struct proc_stat *ps, struct timeval *tv) { time_value_t tvt = proc_stat_thread_basic_info (ps)->user_time; time_value_add (&tvt, &proc_stat_thread_basic_info (ps)->system_time); @@ -211,21 +211,21 @@ const struct ps_getter ps_tot_time_getter = {"tot_time", PSTAT_THREAD_BASIC, ps_get_tot_time}; static float -ps_get_rmem_frac(proc_stat_t ps) +ps_get_rmem_frac (struct proc_stat *ps) { static int mem_size = 0; if (mem_size == 0) { host_basic_info_t info; - error_t err = ps_host_basic_info(&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_task_basic_info(ps)->resident_size + (float)proc_stat_task_basic_info (ps)->resident_size / (float)mem_size; else return 0.0; @@ -234,98 +234,98 @@ const struct ps_getter ps_rmem_frac_getter = {"rmem_frac", PSTAT_TASK_BASIC, (vf) ps_get_rmem_frac}; static float -ps_get_cpu_frac(proc_stat_t ps) +ps_get_cpu_frac (struct proc_stat *ps) { - return (float) proc_stat_thread_basic_info(ps)->cpu_usage + return (float) proc_stat_thread_basic_info (ps)->cpu_usage / (float) TH_USAGE_SCALE; } const struct ps_getter ps_cpu_frac_getter = {"cpu_frac", PSTAT_THREAD_BASIC, (vf) ps_get_cpu_frac}; static int -ps_get_sleep(proc_stat_t ps) +ps_get_sleep (struct proc_stat *ps) { - return proc_stat_thread_basic_info(ps)->sleep_time; + return proc_stat_thread_basic_info (ps)->sleep_time; } const struct ps_getter ps_sleep_getter = {"sleep", PSTAT_THREAD_BASIC, (vf) ps_get_sleep}; static int -ps_get_susp_count(proc_stat_t ps) +ps_get_susp_count (struct proc_stat *ps) { - return proc_stat_suspend_count(ps); + return proc_stat_suspend_count (ps); } const struct ps_getter ps_susp_count_getter = {"susp_count", PSTAT_SUSPEND_COUNT, (vf) ps_get_susp_count}; static int -ps_get_proc_susp_count(proc_stat_t ps) +ps_get_proc_susp_count (struct proc_stat *ps) { - return proc_stat_task_basic_info(ps)->suspend_count; + return proc_stat_task_basic_info (ps)->suspend_count; } const struct ps_getter ps_proc_susp_count_getter = {"proc_susp_count", PSTAT_TASK_BASIC, (vf) ps_get_proc_susp_count}; static int -ps_get_thread_susp_count(proc_stat_t ps) +ps_get_thread_susp_count (struct proc_stat *ps) { - return proc_stat_thread_basic_info(ps)->suspend_count; + return proc_stat_thread_basic_info (ps)->suspend_count; } const struct ps_getter ps_thread_susp_count_getter = {"thread_susp_count", PSTAT_SUSPEND_COUNT, (vf) ps_get_thread_susp_count}; -static ps_tty_t -ps_get_tty(proc_stat_t ps) +static struct ps_tty * +ps_get_tty (struct proc_stat *ps) { - return proc_stat_tty(ps); + return proc_stat_tty (ps); } const struct ps_getter ps_tty_getter = {"tty", PSTAT_TTY, (vf)ps_get_tty}; static int -ps_get_page_faults(proc_stat_t ps) +ps_get_page_faults (struct proc_stat *ps) { - return proc_stat_task_events_info(ps)->faults; + return proc_stat_task_events_info (ps)->faults; } const struct ps_getter ps_page_faults_getter = {"page_faults", PSTAT_TASK_EVENTS, (vf) ps_get_page_faults}; static int -ps_get_cow_faults(proc_stat_t ps) +ps_get_cow_faults (struct proc_stat *ps) { - return proc_stat_task_events_info(ps)->cow_faults; + return proc_stat_task_events_info (ps)->cow_faults; } const struct ps_getter ps_cow_faults_getter = {"cow_faults", PSTAT_TASK_EVENTS, (vf) ps_get_cow_faults}; static int -ps_get_pageins(proc_stat_t ps) +ps_get_pageins (struct proc_stat *ps) { - return proc_stat_task_events_info(ps)->pageins; + return proc_stat_task_events_info (ps)->pageins; } const struct ps_getter ps_pageins_getter = {"pageins", PSTAT_TASK_EVENTS, (vf) ps_get_pageins}; static int -ps_get_msgs_sent(proc_stat_t ps) +ps_get_msgs_sent (struct proc_stat *ps) { - return proc_stat_task_events_info(ps)->messages_sent; + return proc_stat_task_events_info (ps)->messages_sent; } const struct ps_getter ps_msgs_sent_getter = {"msgs_sent", PSTAT_TASK_EVENTS, (vf) ps_get_msgs_sent}; static int -ps_get_msgs_rcvd(proc_stat_t ps) +ps_get_msgs_rcvd (struct proc_stat *ps) { - return proc_stat_task_events_info(ps)->messages_received; + return proc_stat_task_events_info (ps)->messages_received; } const struct ps_getter ps_msgs_rcvd_getter = {"msgs_rcvd", PSTAT_TASK_EVENTS, (vf) ps_get_msgs_rcvd}; static int -ps_get_zero_fills(proc_stat_t ps) +ps_get_zero_fills (struct proc_stat *ps) { - return proc_stat_task_events_info(ps)->zero_fills; + return proc_stat_task_events_info (ps)->zero_fills; } const struct ps_getter ps_zero_fills_getter = {"zero_fills", PSTAT_TASK_EVENTS, (vf) ps_get_zero_fills}; @@ -333,22 +333,25 @@ const struct ps_getter ps_zero_fills_getter = /* ---------------------------------------------------------------- */ /* some printing functions */ -/* G() is a helpful macro that just returns the getter G's access function +/* 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, ps_stream_t stream) +ps_emit_int (struct proc_stat *ps, + const struct ps_getter *getter, + int width, struct ps_stream *stream) { - return ps_stream_write_int_field (stream, G(getter, int)(ps), width); + return ps_stream_write_int_field (stream, G (getter, int)(ps), width); } error_t -ps_emit_nz_int (proc_stat_t ps, ps_getter_t getter, int width, - ps_stream_t stream) +ps_emit_nz_int (struct proc_stat *ps, + const struct ps_getter *getter, + int width, struct ps_stream *stream) { - int value = G(getter, int)(ps); + int value = G (getter, int)(ps); if (value) return ps_stream_write_int_field (stream, value, width); else @@ -356,26 +359,26 @@ ps_emit_nz_int (proc_stat_t ps, ps_getter_t getter, int width, } error_t -ps_emit_priority (proc_stat_t ps, ps_getter_t getter, int width, - ps_stream_t stream) +ps_emit_priority (struct proc_stat *ps, const struct ps_getter *getter, + int width, struct ps_stream *stream) { return ps_stream_write_int_field (stream, - MACH_PRIORITY_TO_NICE (G(getter, int)(ps)), + MACH_PRIORITY_TO_NICE (G (getter, int)(ps)), width); } error_t -ps_emit_num_blocks (proc_stat_t ps, ps_getter_t getter, int width, - ps_stream_t stream) +ps_emit_num_blocks (struct proc_stat *ps, const struct ps_getter *getter, + int width, struct ps_stream *stream) { char buf[20]; - sprintf(buf, "%d", G(getter, int)(ps) / 1024); + sprintf(buf, "%d", G (getter, int)(ps) / 1024); return ps_stream_write_field (stream, buf, width); } int -sprint_frac_value(char *buf, +sprint_frac_value (char *buf, int value, int min_value_len, int frac, int frac_scale, int width) @@ -399,37 +402,37 @@ sprint_frac_value(char *buf, frac /= 10; if (frac_len > 0) - sprintf(buf, "%d.%0*d", value, frac_len, frac); + sprintf (buf, "%d.%0*d", value, frac_len, frac); else - sprintf(buf, "%d", value); + sprintf (buf, "%d", value); - return strlen(buf); + return strlen (buf); } error_t -ps_emit_percent (proc_stat_t ps, ps_getter_t getter, int width, - ps_stream_t stream) +ps_emit_percent (struct proc_stat *ps, const struct ps_getter *getter, + int width, struct ps_stream *stream) { char buf[20]; - float perc = G(getter, float)(ps) * 100; + 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); + sprintf (buf, "%g", perc); + else if (ABS (width) > 3) + sprintf(buf, "%.*f", ABS (width) - 3, perc); else - sprintf(buf, "%d", (int) perc); + sprintf (buf, "%d", (int) perc); return ps_stream_write_field (stream, buf, width); } /* prints its value nicely */ error_t -ps_emit_nice_int (proc_stat_t ps, ps_getter_t getter, int width, - ps_stream_t stream) +ps_emit_nice_int (struct proc_stat *ps, const struct ps_getter *getter, + int width, struct ps_stream *stream) { char buf[20]; - int value = G(getter, int)(ps); + int value = G (getter, int)(ps); char *sfx = " KMG"; int frac = 0; @@ -440,20 +443,20 @@ ps_emit_nice_int (proc_stat_t ps, ps_getter_t getter, int width, sfx++; } - sprintf(buf + sprint_frac_value (buf, value, 1, frac, 3, ABS(width) - 1), + sprintf(buf + sprint_frac_value (buf, value, 1, frac, 3, ABS (width) - 1), "%c", *sfx); return ps_stream_write_field (stream, buf, width); } error_t -ps_emit_seconds (proc_stat_t ps, ps_getter_t getter, int width, - ps_stream_t stream) +ps_emit_seconds (struct proc_stat *ps, const struct ps_getter *getter, + int width, struct ps_stream *stream) { char buf[20]; struct timeval tv; - G(getter, void)(ps, &tv); + G (getter, void)(ps, &tv); fmt_seconds (&tv, ABS (width), buf, sizeof (buf)); @@ -461,13 +464,13 @@ ps_emit_seconds (proc_stat_t ps, ps_getter_t getter, int width, } error_t -ps_emit_minutes (proc_stat_t ps, ps_getter_t getter, - int width, ps_stream_t stream) +ps_emit_minutes (struct proc_stat *ps, const struct ps_getter *getter, + int width, struct ps_stream *stream) { char buf[20]; struct timeval tv; - G(getter, int)(ps, &tv); + G (getter, int)(ps, &tv); fmt_minutes (&tv, ABS (width), buf, sizeof (buf)); @@ -475,16 +478,17 @@ ps_emit_minutes (proc_stat_t ps, ps_getter_t getter, } error_t -ps_emit_past_time (proc_stat_t ps, ps_getter_t getter, - int width, ps_stream_t stream) +ps_emit_past_time (struct proc_stat *ps, const struct ps_getter *getter, + int width, struct ps_stream *stream) { } error_t -ps_emit_uid (proc_stat_t ps, ps_getter_t getter, int width, ps_stream_t stream) +ps_emit_uid (struct proc_stat *ps, const struct ps_getter *getter, + int width, struct ps_stream *stream) { - int uid = G(getter, int)(ps); + int uid = G (getter, int)(ps); if (uid < 0) return ps_stream_write_field (stream, "-", width); else @@ -492,15 +496,15 @@ ps_emit_uid (proc_stat_t ps, ps_getter_t getter, int width, ps_stream_t stream) } error_t -ps_emit_uname (proc_stat_t ps, ps_getter_t getter, int width, - ps_stream_t stream) +ps_emit_uname (struct proc_stat *ps, const struct ps_getter *getter, + int width, struct ps_stream *stream) { - ps_user_t u = G(getter, ps_user_t)(ps); + struct ps_user *u = G (getter, struct ps_user *)(ps); if (u) { struct passwd *pw = ps_user_passwd (u); if (pw == NULL) - return ps_stream_write_int_field (stream, ps_user_uid(u), width); + return ps_stream_write_int_field (stream, ps_user_uid (u), width); else return ps_stream_write_field (stream, pw->pw_name, width); } @@ -510,16 +514,16 @@ ps_emit_uname (proc_stat_t ps, ps_getter_t getter, int width, /* prints a string with embedded nuls as spaces */ error_t -ps_emit_string0 (proc_stat_t ps, ps_getter_t getter, int width, - ps_stream_t stream) +ps_emit_string0 (struct proc_stat *ps, const struct ps_getter *getter, + int width, struct ps_stream *stream) { char *s0, *p, *q; int s0len; - int fwidth = ABS(width); + int fwidth = ABS (width); char static_buf[200]; char *buf = static_buf; - G(getter, void)(ps, &s0, &s0len); + G (getter, void)(ps, &s0, &s0len); if (s0 == NULL) *buf = '\0'; @@ -549,19 +553,19 @@ ps_emit_string0 (proc_stat_t ps, ps_getter_t getter, int width, { error_t err = ps_stream_write_trunc_field (stream, buf, width); if (buf != static_buf) - free(buf); + free (buf); return err; } } error_t -ps_emit_string (proc_stat_t ps, ps_getter_t getter, int width, - ps_stream_t stream) +ps_emit_string (struct proc_stat *ps, const struct ps_getter *getter, + int width, struct ps_stream *stream) { char *str; int len; - G(getter, void)(ps, &str, &len); + G (getter, void)(ps, &str, &len); if (str == NULL) str = ""; @@ -570,15 +574,15 @@ ps_emit_string (proc_stat_t ps, ps_getter_t getter, int width, } error_t -ps_emit_tty_name (proc_stat_t ps, ps_getter_t getter, int width, - ps_stream_t stream) +ps_emit_tty_name (struct proc_stat *ps, const struct ps_getter *getter, + int width, struct ps_stream *stream) { - char *name = "-"; - ps_tty_t tty = G(getter, ps_tty_t)(ps); + const char *name = "-"; + struct ps_tty *tty = G (getter, struct ps_tty *)(ps); if (tty) { - name = ps_tty_short_name(tty); + name = ps_tty_short_name (tty); if (name == NULL || *name == '\0') name = "?"; } @@ -611,11 +615,11 @@ state_shadows[] = { }; error_t -ps_emit_state (proc_stat_t ps, ps_getter_t getter, int width, - ps_stream_t stream) +ps_emit_state (struct proc_stat *ps, const struct ps_getter *getter, + int width, struct ps_stream *stream) { char *tags; - int raw_state = G(getter, int)(ps); + int raw_state = G (getter, int)(ps); int state = raw_state; char buf[20], *p = buf; const struct state_shadow *shadow = state_shadows; @@ -639,14 +643,14 @@ ps_emit_state (proc_stat_t ps, ps_getter_t getter, int width, } error_t -ps_emit_wait (proc_stat_t ps, ps_getter_t getter, int width, - ps_stream_t stream) +ps_emit_wait (struct proc_stat *ps, const struct ps_getter *getter, + int width, struct ps_stream *stream) { int rpc; char *wait; char buf[80]; - G(getter, void)(ps, &wait, &rpc); + G (getter, void)(ps, &wait, &rpc); if (wait == 0) return ps_stream_write_field (stream, "?", width); @@ -714,57 +718,63 @@ ps_emit_wait (proc_stat_t ps, ps_getter_t getter, int width, ((s1) == NULL ? (((s2) == NULL) ? 0 : -1) : ((s2) == NULL ? 1 : (call))) int -ps_cmp_ints(proc_stat_t ps1, proc_stat_t ps2, ps_getter_t getter) +ps_cmp_ints (struct proc_stat *ps1, struct proc_stat *ps2, + const struct ps_getter *getter) { - int (*gf)() = G(getter, int); - int v1 = gf(ps1), v2 = gf(ps2); + 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) +ps_cmp_floats (struct proc_stat *ps1, struct proc_stat *ps2, + const struct ps_getter *getter) { - float (*gf)() = G(getter, float); - float v1 = gf(ps1), v2 = gf(ps2); + float (*gf)() = G (getter, float); + float v1 = gf(ps1), v2 = gf (ps2); return v1 == v2 ? 0 : v1 < v2 ? -1 : 1; } int -ps_cmp_uids(proc_stat_t ps1, proc_stat_t ps2, ps_getter_t getter) +ps_cmp_uids (struct proc_stat *ps1, struct proc_stat *ps2, + const struct ps_getter *getter) { - ps_user_t (*gf)() = G(getter, ps_user_t); - ps_user_t u1 = gf(ps1), u2 = gf(ps2); + struct ps_user *(*gf)() = G (getter, struct ps_user *); + struct ps_user *u1 = gf (ps1), *u2 = gf (ps2); return (u1 ? ps_user_uid (u1) : -1) - (u2 ? ps_user_uid (u2) : -1); } int -ps_cmp_unames(proc_stat_t ps1, proc_stat_t ps2, ps_getter_t getter) +ps_cmp_unames (struct proc_stat *ps1, struct proc_stat *ps2, + const struct ps_getter *getter) { - ps_user_t (*gf)() = G(getter, ps_user_t); - ps_user_t u1 = gf(ps1), u2 = gf(ps2); + struct ps_user *(*gf)() = G (getter, struct ps_user *); + struct ps_user *u1 = gf (ps1), *u2 = gf (ps2); struct passwd *pw1 = u1 ? ps_user_passwd (u1) : 0; struct passwd *pw2 = u2 ? ps_user_passwd (u2) : 0; return GUARDED_CMP (pw1, pw2, strcmp (pw1->pw_name, pw2->pw_name)); } int -ps_cmp_strings(proc_stat_t ps1, proc_stat_t ps2, ps_getter_t getter) +ps_cmp_strings (struct proc_stat *ps1, struct proc_stat *ps2, + const struct ps_getter *getter) { - void (*gf)() = G(getter, void); + void (*gf)() = G (getter, void); char *s1, *s2; int s1len, s2len; /* Get both strings */ - gf(ps1, &s1, &s1len); - gf(ps2, &s2, &s2len); + gf (ps1, &s1, &s1len); + gf (ps2, &s2, &s2len); - return GUARDED_CMP(s1, s2, strncmp(s1, s2, MIN(s1len, s2len))); + return GUARDED_CMP(s1, s2, strncmp(s1, s2, MIN (s1len, s2len))); } int -ps_cmp_times (proc_stat_t ps1, proc_stat_t ps2, ps_getter_t getter) +ps_cmp_times (struct proc_stat *ps1, struct proc_stat *ps2, + const struct ps_getter *getter) { - void (*g)() = G(getter, void); + void (*g)() = G (getter, void); struct timeval tv1, tv2; g (ps1, &tv1); @@ -782,112 +792,185 @@ ps_cmp_times (proc_stat_t ps1, proc_stat_t ps2, ps_getter_t getter) /* `Nominal' functions -- return true for `unexciting' values. */ /* For many things, zero is not so interesting. */ -bool -ps_nominal_zint (proc_stat_t ps, ps_getter_t getter) +int +ps_nominal_zint (struct proc_stat *ps, const struct ps_getter *getter) { - return G(getter, int)(ps) == 0; + return G (getter, int)(ps) == 0; } /* Priorities are similar, but have to be converted to the unix nice scale first. */ -bool -ps_nominal_pri (proc_stat_t ps, ps_getter_t getter) +int +ps_nominal_pri (struct proc_stat *ps, const struct ps_getter *getter) { - return MACH_PRIORITY_TO_NICE(G(getter, int)(ps)) == 0; + return MACH_PRIORITY_TO_NICE(G (getter, int)(ps)) == 0; } /* Hurd processes usually have 2 threads; XXX is there someplace we get get this number from? */ -bool -ps_nominal_nth (proc_stat_t ps, ps_getter_t getter) +int +ps_nominal_nth (struct proc_stat *ps, const struct ps_getter *getter) { - return G(getter, int)(ps) == 2; + return G (getter, int)(ps) == 2; } static int own_uid = -2; /* -1 means no uid at all. */ /* A user is nominal if it's the current user. */ -bool -ps_nominal_user (proc_stat_t ps, ps_getter_t getter) +int +ps_nominal_user (struct proc_stat *ps, const struct ps_getter *getter) { - ps_user_t u = G(getter, ps_user_t)(ps); + struct ps_user *u = G (getter, struct ps_user *)(ps); if (own_uid == -2) - own_uid = getuid(); + own_uid = getuid (); return own_uid >= 0 && u && u->uid == own_uid; } /* A uid is nominal if it's that of the current user. */ -bool -ps_nominal_uid (proc_stat_t ps, ps_getter_t getter) +int +ps_nominal_uid (struct proc_stat *ps, const struct ps_getter *getter) { - uid_t uid = G(getter, uid_t)(ps); + uid_t uid = G (getter, uid_t)(ps); if (own_uid == -2) own_uid = getuid (); return own_uid >= 0 && uid == own_uid; } - + /* ---------------------------------------------------------------- */ -ps_fmt_spec_t -ps_fmt_specs_find (ps_fmt_specs_t specs, char *name) +/* Returns the first entry called NAME in the vector of fmt_specs SPECS. If + the result is in fact an alias entry, returns in ALIASED_TO the name of + the desired source. */ +static const struct ps_fmt_spec * +specv_find (const struct ps_fmt_spec *specs, const char *name, + char **aliased_to) +{ + while (! ps_fmt_spec_is_end (specs)) + { + char *alias = index (specs->name, '='); + if (alias) + { + unsigned name_len = strlen (name); + + if (name_len == alias - specs->name + && strncasecmp (name, specs->name, name_len) == 0) + /* SPECS is an alias, lookup what it refs to. */ + { + *aliased_to = alias + 1; + return specs; + } + } + else + if (strcasecmp (specs->name, name) == 0) + return specs; + specs++; + } + + return 0; +} + +/* Adds a new alias expansion, using fields from ALIAS, where non-zero, + otherwise SRC, to SPECS. */ +struct ps_fmt_spec * +specs_add_alias (struct ps_fmt_specs *specs, + const struct ps_fmt_spec *alias, + const struct ps_fmt_spec *src) +{ + struct ps_fmt_spec *exp; + char *name_end = index (alias->name, '='); + size_t name_len = name_end ? name_end - alias->name : strlen (alias->name); + + if (specs->expansions == 0) + { + specs->expansions_alloced = 5; + specs->expansions = + malloc (sizeof (struct ps_fmt_spec) * specs->expansions_alloced); + exp = specs->expansions; + } + else + { + exp = specs->expansions; + while (! ps_fmt_spec_is_end (exp)) + exp++; + if (exp + 1 - specs->expansions == specs->expansions_alloced) + /* End marker's really at the end, so make room for some more. */ + { + size_t exp_offs = exp - specs->expansions; + size_t new_alloced = specs->expansions_alloced * 2; + struct ps_fmt_spec *new_exps = + realloc (specs->expansions, + sizeof (struct ps_fmt_spec) * new_alloced); + + if (! new_exps) + return 0; + + specs->expansions = new_exps; + specs->expansions_alloced = new_alloced; + exp = new_exps + exp_offs; + } + } + + /* EXP gets its name from ALIAS, but only the bit before the alias marker. */ + exp->name = malloc (name_len + 1); + if (! exp->name) + return 0; + bcopy ((char *)alias->name, (char *)exp->name, name_len); + ((char *)exp->name)[name_len] = '\0'; + + /* Copy the rest of the fields from ALIAS, but defaulting to SRC. */ + exp->title = alias->title ?: src->title; + exp->width = alias->width ?: src->width; + exp->getter = alias->getter ?: src->getter; + exp->output_fn = alias->output_fn ?: src->output_fn; + exp->cmp_fn = alias->cmp_fn ?: src->cmp_fn; + exp->nominal_fn = alias->nominal_fn ?: src->nominal_fn; + + /* Now add the list-end marker. */ + bzero (exp + 1, sizeof (*exp)); + + return exp; +} + +const struct ps_fmt_spec * +ps_fmt_specs_find (struct ps_fmt_specs *specs, const char *name) { if (specs) /* Allow NULL to make recursion more handy. */ { - ps_fmt_spec_t s = specs->specs; + char *aliased_to = 0; + const struct ps_fmt_spec *s = 0; + + if (specs->expansions) + /* If SPECS contains any alias expansions, look there first. */ + s = specv_find (specs->expansions, name, &aliased_to); + + if (! s) + /* Look in the local list of specs. */ + s = specv_find (specs->specs, name, &aliased_to); - while (! ps_fmt_spec_is_end (s)) + if (s) { - char *alias = index (s->name, '='); - if (alias) + if (aliased_to) { - unsigned name_len = strlen (name); - - if (name_len == alias - s->name - && strncasecmp (name, s->name, name_len) == 0) - /* S is an alias, lookup what it refs to. */ - { - ps_fmt_spec_t src; /* What S is an alias to. */ - - ++alias; /* Point at the alias name. */ - - if (strcasecmp (name, alias) == 0) - /* An alias to the same name (useful to just change some - property) -- start looking up in the parent. */ - src = ps_fmt_specs_find (specs->parent, alias); - else - src = ps_fmt_specs_find (specs, alias); - - if (! src) - return 0; - - /* Copy fields into the alias entry. */ - if (! s->title && src->title) - s->title = src->title; - if (! s->width && src->width) - s->width = src->width; - if (! s->getter && src->getter) - s->getter = src->getter; - if (! s->output_fn && src->output_fn) - s->output_fn = src->output_fn; - if (! s->cmp_fn && src->cmp_fn) - s->cmp_fn = src->cmp_fn; - if (! s->nominal_fn && src->nominal_fn) - s->nominal_fn = src->nominal_fn; - - /* Now make this not an alias. */ - *--alias = '\0'; - - return s; - } + const struct ps_fmt_spec *src; /* What S is an alias to. */ + + if (strcasecmp (name, aliased_to) == 0) + /* An alias to the same name (useful to just change some + property) -- start looking up in the parent. */ + src = ps_fmt_specs_find (specs->parent, aliased_to); + else + src = ps_fmt_specs_find (specs, aliased_to); + + if (! src) + return 0; + + s = specs_add_alias (specs, s, src); } - else - if (strcasecmp (s->name, name) == 0) - return s; - s++; } + else + /* Try again with our parent. */ + s = ps_fmt_specs_find (specs->parent, name); - /* Try again with our parent. */ - return ps_fmt_specs_find (specs->parent, name); + return s; } else return 0; @@ -968,4 +1051,4 @@ static const struct ps_fmt_spec specs[] = {0} }; -const struct ps_fmt_specs ps_std_fmt_specs = { (ps_fmt_spec_t)specs, 0 }; +struct ps_fmt_specs ps_std_fmt_specs = { specs, 0 }; |