path: root/utils/ps.c

/* Show process information.

   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 <string.h>
#include <ctype.h>
#include <argp.h>
#include <hurd/ps.h>
#include <unistd.h>

#include "error.h"
#include "common.h"

/* ---------------------------------------------------------------- */

/* Long options without corresponding short ones.  -1 is EOF.  */
#define OPT_LOGIN	-2
#define OPT_SESS	-3
#define OPT_SORT	-4
#define OPT_FMT		-5
#define OPT_HELP	-6
#define OPT_PGRP	-7

#define OA OPTION_ARG_OPTIONAL

static struct argp_option options[] =
{
  {"all-users",  'a',     0,      0,  "List other users' processes"},
  {"fmt",        OPT_FMT, "FMT",  0,  "Use the output-format FMT FMT may be"
                                      " `default', `user', `vmem', `long',"
				      " `jobc', `full', `hurd', `hurd-long',"
				      " or a custom format-string"},
  {0,            'd',     0,      0,  "List all processes except process group"
                                      " leaders"},
  {"all",        'e',     0,      0,  "List all processes"},
  {0,            'f',     0,      0,  "Use the `full' output-format"},
  {0,            'g',     0,      0,  "Include session leaders"},
  {"no-header",  'H',     0,      0,  "Don't print a descriptive header line"},
  {0,            'j',     0,      0,  "Use the `jobc' output-format"},
  {0,            'l',     0,      0,  "Use the `long' output-format"},
  {"login",      OPT_LOGIN,"LID", OA, "Add the processes from the login"
                                      " collection LID (which defaults that of"
                                      " the current process)"},
  {"lid",        0,       0,      OPTION_ALIAS | OPTION_HIDDEN},
  {"no-msg-port",'M',     0,      0,  "Don't show info that uses a process's"
                                      " msg port"},
  {"nominal-fields",'n',  0,      0,  "Don't elide fields containing"
                                      " `uninteresting' data"},
  {"owner",      'o',     "USER", 0,  "Show only processes owned by USER"},
  {"not-owner",  'O',     "USER", 0,  "Show only processes not owned by USER"},
  {"pid",        'p',     "PID",  0,  "List the process PID"},
  {"pgrp",       OPT_PGRP,"PGRP", 0,  "List processes in process group PGRP"},
  {"no-parent",  'P',     0,      0,  "Include processes without parents"},
  {"all-fields", 'Q',     0,      0,  "Don't elide unusable fields (normally"
                                      " if there's some reason ps can't print"
                                      " a field for any process, it's removed"
                                      " from the output entirely)"},
  {"reverse",    'r',     0,      0,  "Reverse the order of any sort"},
  {"session",    OPT_SESS,"SID",  OA, "Add the processes from the session SID"
                                      " (which defaults to the sid of the"
                                      " current process)"},
  {"sid",        0,       0,      OPTION_ALIAS | OPTION_HIDDEN},
  {"sort",       OPT_SORT,"FIELD", 0, "Sort the output with respect to FIELD"},
  {"threads",    's',     0,      0,  "Show the threads for each process"},
  {"tty",        't',     "TTY",  OA, "Only show processes who's controlling"
                                      " terminal is TTY"},
  {0,            'u',     0,      0,  "Use the `user' output-format"},
  {0,            'v',     0,      0,  "Use the `vmem' output-format"},
  {0,            'w',     0,      0,  "(ignored)"},
  {0,            'x',     0,      0,  "Include orphaned processes"},
  {0, 0}
};

char *args_doc = "[PID...]";

char *doc = "The USER, LID, PID, PGRP, and SID arguments may also be comma \
separated lists.  The System V options -u and -g may be accessed with -o and \
--pgrp.";

int 
parse_enum(char *arg, char **choices, char *kind, bool allow_mismatches)
{
  int arglen = strlen(arg);
  char **p = choices;
  int partial_match = -1;

  while (*p != NULL)
    if (strcmp(*p, arg) == 0)
      return p - choices;
    else
      {
	if (strncmp(*p, arg, arglen) == 0)
	  if (partial_match >= 0)
	    argp_error (0, "%s: Ambiguous %s", arg, kind);
	  else
	    partial_match = p - choices;
	p++;
      }

  if (partial_match < 0 && !allow_mismatches)
    argp_error (0, "%s: Invalid %s", arg, kind);

  return partial_match;
}

#define FILTER_OWNER		0x01
#define FILTER_NSESSLDR		0x02
#define FILTER_CTTY    		0x04
#define FILTER_UNORPHANED	0x08
#define FILTER_PARENTED		0x10

enum procsets
{
  PROCSET_ALL, PROCSET_SESSION, PROCSET_LOGIN
};
char *procset_names[] =
{"all", "session", "login", 0};

/* The names of various predefined output formats.  */
char *fmt_names[] =
  {"default",	"user",	"vmem",	"long",	"jobc",	"full",	"hurd",	"hurd-long",0};
/* How each of those formats should be sorted; */
char *fmt_sortkeys[] =
  {"pid",	"%cpu",	"%mem",	"pid",	"pid",	"pid",	"pid",	"pid"};
/* and whether the sort should be backwards or forwards; */ 
bool fmt_sortrev[] =
  {FALSE,	TRUE,	TRUE,	FALSE,	FALSE,	FALSE,	FALSE,	FALSE};
/* and the actual format strings.  */
char *fmts[] =
{
  /* default */
  "~PID ~TH# ~TT=tty ~SC=susp ~STAT=state ~TIME ~COMMAND=args",
  /* user (-u) */
  "~USER ~PID ~TH# ~%CPU ~%MEM ~SZ=vsize ~RSS=rsize ~TT=tty ~SC=susp ~STAT=state ~COMMAND=args",
  /* vmem (-v) */
  "~PID ~TH# ~STAT=state ~SL=sleep ~PAGEIN=pgins ~FAULTS=pgflts ~COWFLT=cowflts ~ZFILLS ~SIZE=vsize ~RSS=rsize ~%CPU ~%MEM ~COMMAND=args",
  /* long (-l) */
  "~UID ~PID ~TH# ~PPID ~PRI ~NI=bpri ~TH=nth ~MSGI=msgin ~MSGO=msgout ~SZ=vsize ~RSS=rsize ~SC=susp ~RPC ~STAT=state ~TT=tty ~TIME ~COMMAND=args",
  /* jobc (-j) */
  "~USER ~PID ~TH# ~PPID ~PGRP ~SESS ~LCOLL ~SC=susp ~STAT=state ~TT=tty ~TIME ~COMMAND=args",
  /* full (-f) (from sysv) */
  "~-USER ~PID ~PPID ~TTY ~TIME ~COMMAND=args",
  /* hurd */
  "~PID ~Th# ~UID ~NTh ~VMem=vsize ~RSS=rsize ~User=utime ~System=stime ~Args",
  /* hurd-long */
  "~PID ~Th# ~UID ~PPID ~PGRP ~Sess ~NTh ~VMem=vsize ~RSS=rsize ~%CPU ~User=utime ~System=stime ~Args"
};

/* ---------------------------------------------------------------- */

/* For each string in the comma-separated list in ARG, call ADD_FN; if ARG is
   empty and DEFAULT_ADD_FN isn't NULL, then call DEFAULT_ADD_FN instead. */
static void
_parse_strlist (char *arg,
		void (*add_fn)(char *str), void (*default_add_fn)(),
			   char *type_name)
{
  if (arg)
    while (isspace(*arg))
      arg++;

  if (arg == NULL || *arg == '\0')
    if (default_add_fn)
      (*default_add_fn)();
    else
      error(7, 0, "No %s specified", type_name);
  else
    {
      char *end = arg;

      void mark_end()
	{
	  *end++ = '\0';
	  while (isspace(*end))
	    end++;
	}
      void parse_element()
	{
	  if (*arg == '\0')
	    error(7, 0, "Empty element in %s list", type_name);
	  (*add_fn)(arg);
	  arg = end;
	}

      while (*end != '\0')
	switch (*end)
	  {
	  case ' ': case '\t':
	    mark_end();
	    if (*end == ',')
	      mark_end();
	    parse_element();
	    break;
	  case ',':
	    mark_end();
	    parse_element();
	    break;
	  default:
	    end++;
	  }

      parse_element();
    }
}

/* ---------------------------------------------------------------- */

/* For each string in the comma-separated list in ARG, call ADD_FN; if ARG is
   empty and DEFAULT_FN isn't NULL, then call ADD_FN on the resutl of calling
   DEFAULT_FN instead, otherwise signal an error.  */
static void
parse_strlist (char *arg,
	       void (*add_fn)(char *str),
	       char *(*default_fn)(),
	       char *type_name)
{
  void default_str_add() { (*add_fn)((*default_fn)()); }
  _parse_strlist(arg, add_fn, default_str_add, type_name);
}

/* For each numeric string in the comma-separated list in ARG, call ADD_FN;
   if ARG is empty and DEFAULT_FN isn't NULL, then call DEF_FN to get a number,
   and call ADD_FN on that, otherwise signal an error.  If any member of the
   list isn't a number, and LOOKUP_FN isn't NULL, then it is called to return
   an integer for the string.  LOOKUP_FN should signal an error itself it
   there's some problem parsing the string.  */
static void
parse_numlist (char *arg,
	       void (*add_fn)(unsigned num),
	       int (*default_fn)(),
	       int (*lookup_fn)(char *str),
	       char *type_name)
{
  void default_num_add() { (*add_fn)((*default_fn)()); }
  void add_num_str(char *str)
    {
      char *p;
      for (p = str; *p != '\0'; p++)
	if (!isdigit(*p))
	  {
	    (*add_fn)((*lookup_fn)(str));
	    return;
	  }
      (*add_fn)(atoi(str));
    }
  _parse_strlist(arg, add_num_str, default_num_add, type_name);
}

/* ---------------------------------------------------------------- */

static process_t proc_server;

/* Returns our session id.  */
static pid_t
current_sid()
{
  pid_t sid;
  error_t err = proc_getsid(proc_server, getpid(), &sid);
  if (err)
    error(2, err, "Couldn't get current session id");
  return sid;
}

/* Returns our login collection id.  */
static pid_t
current_lid()
{
  pid_t lid;
  error_t err = proc_getloginid(proc_server, getpid(), &lid);
  if (err)
    error(2, err, "Couldn't get current login collection") ;
  return lid;
}

/* Returns the UID for the user called NAME.  */
static int
lookup_user(char *name)
{
  struct passwd *pw = getpwnam(name);
  if (pw == NULL)
    error(2, 0, "%s: Unknown user", name);
  return pw->pw_uid;
}

/* ---------------------------------------------------------------- */

typedef unsigned id_t;

struct ids 
{
  id_t *ids;
  unsigned num, alloced;
};

struct
ids *make_ids ()
{
  struct ids *ids = malloc (sizeof (struct ids));
  if (!ids)
    error(8, ENOMEM, "Can't allocate id list");
  ids->ids = 0;
  ids->num = ids->alloced = 0;
  return ids;
}

void
ids_add (struct ids *ids, id_t id)
{
  if (ids->alloced == ids->num)
    {
      ids->alloced = ids->alloced * 2 + 1;
      ids->ids = realloc (ids->ids, ids->alloced * sizeof (id_t));
      if (ids->ids == NULL)
	error(8, ENOMEM, "Can't allocate id list");
    }

  ids->ids[ids->num++] = id;
}

int
ids_contains (struct ids *ids, id_t id)
{
  unsigned i;
  for (i = 0; i < ids->num; i++)
    if (ids->ids[i] == id)
      return 1;
  return 0;
}

/* ---------------------------------------------------------------- */

void 
main(int argc, char *argv[])
{
  error_t err;
  /* A buffer used for rewriting old-style ps command line arguments that
     need a dash prepended for the parser to understand them.  It gets
     realloced for each successive arg that needs it, on the assumption that
     args don't get parsed multiple times.  */
  char *arg_hack_buf = 0;
  struct ids *only_uids = make_ids (), *not_uids = make_ids ();
  char **tty_names = 0;
  unsigned num_tty_names = 0, tty_names_alloced = 0;
  proc_stat_list_t procset;
  ps_context_t context;
  ps_fmt_t fmt;
  char *fmt_string = "default", *sort_key_name = NULL;
  unsigned filter_mask =
    FILTER_OWNER | FILTER_NSESSLDR | FILTER_UNORPHANED | FILTER_PARENTED;
  bool sort_reverse = FALSE, print_heading = TRUE;
  bool squash_bogus_fields = TRUE, squash_nominal_fields = TRUE;
  bool show_threads = FALSE, no_msg_port = FALSE;

  /* Add a specific process to be printed out.  */
  void add_pid (unsigned pid)
    {
      err = proc_stat_list_add_pid(procset, pid);
      if (err)
	error(3, err, "%d: Can't add process id", pid);
      /* If explicit processes are specified, we probably don't want to
	 filter them out later.  This implicit turning off of filtering might
	 be confusing in the case where a login-collection or session is
	 specified along with some pids, but it's probably not worth worrying
	 about.  */
      filter_mask = 0;
    }
  /* Print out all process from the given session.  */
  void add_sid(unsigned sid)
    {
      err = proc_stat_list_add_session(procset, sid);
      if (err)
	error(2, err, "Couldn't add session");
    }
  /* Print out all process from the given login collection.  */
  void add_lid(unsigned lid)
    {
      error_t err = proc_stat_list_add_login_coll(procset, lid);
      if (err)
	error(2, err, "Couldn't add login collection");
    }
  /* Print out all process from the given process group.  */
  void add_pgrp(unsigned pgrp)
    {
      error_t err = proc_stat_list_add_pgrp(procset, pgrp);
      if (err)
	error(2, err, "Couldn't add process group");
    }
    
  /* Add a user who's processes should be printed out.  */
  void add_uid (id_t uid)
    {
      ids_add (only_uids, uid);
    }
  /* Add a user who's processes should not be printed out.  */
  void add_not_uid (id_t uid)
    {
      ids_add (not_uids, uid);
    }
  /* Returns TRUE if PS is owned by any of the users in ONLY_UIDS, and none
     in NOT_UIDS.  */
  bool proc_stat_owner_ok(struct proc_stat *ps)
    {
      id_t uid = proc_stat_proc_info (ps)->owner;
      if (only_uids->num > 0 && !ids_contains (only_uids, uid))
	return 0;
      if (not_uids->num > 0 && ids_contains (not_uids, uid))
	return 0;
      return 1;
    }

  /* Add TTY_NAME to the list for which processes with those controlling
     terminals will be printed.  */
  void add_tty_name (char *tty_name)
    {
      if (tty_names_alloced == num_tty_names)
	{
	  tty_names_alloced *= 2;
	  tty_names = realloc(tty_names, tty_names_alloced * sizeof(int));
	  if (tty_names == NULL)
	    error(8, ENOMEM, "Can't allocate tty_name list");
	}
      tty_names[num_tty_names++] = tty_name;
    }
  bool proc_stat_has_ctty(struct proc_stat *ps)
    {
      if (proc_stat_has(ps, PSTAT_TTY))
	/* Only match processes whose tty we can figure out.  */
	{
	  ps_tty_t tty = proc_stat_tty(ps);
	  if (tty)
	    {
	      unsigned i;
	      char *name = ps_tty_name(tty);
	      char *short_name = ps_tty_short_name(tty);

	      for (i = 0; i < num_tty_names; i++)
		if ((name && strcmp (tty_names[i], name) == 0)
		    || (short_name && strcmp (tty_names[i], short_name) == 0))
		  return TRUE;
	    }
	}
      return FALSE;
    }

  /* Returns the name of the current controlling terminal.  */
  static char *current_tty_name()
    {
      error_t err;
      ps_tty_t tty;
      mach_port_t cttyid = getcttyid();

      if (cttyid == MACH_PORT_NULL)
	error(2, 0, "No controlling terminal");

      err = ps_context_find_tty_by_cttyid(context, cttyid, &tty);
      if (err)
	error(2, err, "Can't get controlling terminal");

      return ps_tty_name(tty);
    }

  error_t parse_opt (int key, char *arg, struct argp_state *state)
    {
      switch (key)
	{
	case ARGP_KEY_ARG:			/* Non-option argument.  */
	  if (!isdigit (*arg))
	    /* Old-fashioned `ps' syntax takes options without the leading
	       dash.  Prepend a dash and feed back to getopt.  */
	    {
	      size_t len = strlen (arg) + 1;
	      arg_hack_buf = realloc (arg_hack_buf, 1 + len);
	      state->argv[--state->index] = arg_hack_buf;
	      state->argv[state->index][0] = '-';
	      memcpy (&state->argv[state->index][1], arg, len);
	      break;
	    }
	  /* Otherwise, fall through and treat the arg as a process id.  */
	case 'p':
	  parse_numlist(arg, add_pid, NULL, NULL, "PID");
	  break;

	case 'a':
	  filter_mask &= ~(FILTER_OWNER | FILTER_NSESSLDR); break;
	case 'd':
	  filter_mask &= ~(FILTER_OWNER | FILTER_UNORPHANED); break;
	case 'e':
	  filter_mask = 0; break;
	case 'g':
	  filter_mask &= ~FILTER_NSESSLDR; break;
	case 'x':
	  filter_mask &= ~FILTER_UNORPHANED; break;
	case 'P':
	  filter_mask &= ~FILTER_PARENTED; break;
	case 'f':
	  fmt_string = "full"; break;
	case 'u':
	  fmt_string = "user"; break;
	case 'v':
	  fmt_string = "vmem"; break;
	case 'j':
	  fmt_string = "jobc"; break;
	case 'l':
	  fmt_string = "long"; break;
	case 'M':
	  no_msg_port = TRUE; break;
	case 'H':
	  print_heading = FALSE; break;
	case 'Q':
	  squash_bogus_fields = squash_nominal_fields = FALSE; break;
	case 'n':
	  squash_nominal_fields = FALSE; break;
	case 's':
	  show_threads = TRUE; break;
	case OPT_FMT:
	  fmt_string = arg; break;
	case OPT_SORT:
	  sort_key_name = arg; break;
	case 'r':
	  sort_reverse = TRUE; break;

	case 't':
	  parse_strlist(arg, add_tty_name, current_tty_name, "tty");
	  break;
	case 'o':
	  parse_numlist(arg, add_uid, NULL, lookup_user, "user");
	  break;
	case 'O':
	  parse_numlist (arg, add_not_uid, NULL, lookup_user, "user");
	  break;
	case OPT_SESS:
	  parse_numlist(arg, add_sid, current_sid, NULL, "session id");
	  break;
	case OPT_LOGIN:
	  parse_numlist(arg, add_lid, current_lid, NULL, "login collection");
	  break;
	case OPT_PGRP:
	  parse_numlist(arg, add_pgrp, NULL, NULL, "process group");
	  break;

	case 'w':
	  /* Ignored; just here to make BSD users less unhappy.  */
	  break;

	default:
	  return EINVAL;
	}
      return 0;
    }

  struct argp argp = { options, parse_opt, args_doc, doc};

  proc_server = getproc();

  err = ps_context_create(proc_server, &context);
  if (err)
    error(1, err, "ps_context_create");

  err = proc_stat_list_create(context, &procset);
  if (err)
    error(1, err, "proc_stat_list_create");

  /* Parse our command line.  This shouldn't ever return an error.  */
  argp_parse (&argp, argc, argv, 0, 0);

  if (only_uids->num == 0 && (filter_mask & FILTER_OWNER))
    add_uid (getuid ());

  {
    int fmt_index = parse_enum(fmt_string, fmt_names, "format type", 1);
    if (fmt_index >= 0)
      {
	fmt_string = fmts[fmt_index];
	if (sort_key_name == NULL)
	  {
	    sort_key_name = fmt_sortkeys[fmt_index];
	    sort_reverse = fmt_sortrev[fmt_index];
	  }
      }
  }

  if (proc_stat_list_num_procs(procset) == 0)
    {
      err = proc_stat_list_add_all(procset);
      if (err)
	error(2, err, "Couldn't get process list");
    }

  if (no_msg_port)
    proc_stat_list_set_flags(procset, PSTAT_NO_MSGPORT);

  /* Filter out any processes that we don't want to show.  */
  if (only_uids->num || not_uids->num)
    proc_stat_list_filter1 (procset, proc_stat_owner_ok,
			    PSTAT_PROC_INFO, FALSE);
  if (num_tty_names > 0)
    {
      /* We set the PSTAT_TTY flag separately so that our filter function
	 can look at any procs that fail to set it.  */
      proc_stat_list_set_flags(procset, PSTAT_TTY);
      proc_stat_list_filter1(procset, proc_stat_has_ctty, 0, FALSE);
    }
  if (filter_mask & FILTER_NSESSLDR)
    proc_stat_list_filter(procset, &ps_not_sess_leader_filter, FALSE);
  if (filter_mask & FILTER_UNORPHANED)
    proc_stat_list_filter(procset, &ps_unorphaned_filter, FALSE);
  if (filter_mask & FILTER_PARENTED)
    proc_stat_list_filter(procset, &ps_parent_filter, FALSE);

  err = ps_fmt_create(fmt_string, ps_std_fmt_specs, &fmt);
  if (err)
    error(4, err, "Can't create output format");

  if (show_threads)
    proc_stat_list_add_threads(procset);

  if (sort_key_name != NULL)
    /* Sort on the given field; we look in both the user-named fields and
       the system named fields for the name given, as the user may only know
       the printed title and not the official name. */
    {
      ps_fmt_spec_t sort_key = NULL;
      unsigned nfields = ps_fmt_num_fields(fmt);
      ps_fmt_field_t field = ps_fmt_fields(fmt);

      /* first, look at the actual printed titles in the current format */
      while (nfields-- > 0)
	if (strcasecmp(sort_key_name, ps_fmt_field_title(field)) == 0)
	  {
	    sort_key = ps_fmt_field_fmt_spec(field);
	    break;
	  }
	else
	  field++;

      /* Then, if not there, look at the actual ps_fmt_spec names (this way
	 the user can sort on a key that's not actually displayed). */
      if (sort_key == NULL)
	{
	  sort_key = find_ps_fmt_spec(sort_key_name, ps_std_fmt_specs);
	  if (sort_key == NULL)
	    error(3, 0, "%s: bad sort key", sort_key_name);
	}

      err = proc_stat_list_sort(procset, sort_key, sort_reverse);
      if (err)
	/* Give an error message, but don't exit.  */
	error(0, err, "Couldn't sort processes");
    }

  if (squash_bogus_fields)
    /* Remove any fields that we can't print anyway (because of system
       bugs/protection violations?).  */
    {
      ps_flags_t bogus_flags = ps_fmt_needs(fmt);

      err = proc_stat_list_find_bogus_flags(procset, &bogus_flags);
      if (err)
	error(0, err, "Couldn't remove bogus fields");
      else
	ps_fmt_squash_flags (fmt, bogus_flags);
    }

  if (squash_nominal_fields)
    /* Remove any fields that contain only `uninteresting' information.  */
    {
      bool nominal (ps_fmt_spec_t spec)
	{
	  return proc_stat_list_spec_nominal (procset, spec);
	}
      ps_fmt_squash (fmt, nominal);
    }

  if (print_heading)
    if (proc_stat_list_num_procs(procset) > 0)
      {
	err = ps_fmt_write_titles(fmt, stdout, NULL);
	if (err)
	  error(0, err, "Can't print titles");
	putc('\n', stdout);
      }
    else
      error(0, 0, "No applicable processes");

  err = proc_stat_list_fmt(procset, fmt, stdout, NULL);
  if (err)
    error(5, err, "Couldn't output process status");

  exit(0);
}