projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
remove umask
[unix-history] / usr / src / bin / ps / ps.c
diff --git a/usr/src/bin/ps/ps.c b/usr/src/bin/ps/ps.c
index 31b8aac..3ac08b8 100644 (file)
--- a/usr/src/bin/ps/ps.c
+++ b/usr/src/bin/ps/ps.c
@@ -1,32 +1,23 @@
-/*
- * Copyright (c) 1989 The Regents of the University of California.
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
  * All rights reserved.
  *
  * All rights reserved.
  *
- * Redistribution and use in source and binary forms is permitted
- * provided that all copyright information, including this notice,
- * is retained in all such forms, and that any documentation,
- * advertising or other materials related to such distribution and
- * use acknowledge that the software was
- * developed by the University of California, Berkeley.  The name
- * of the University may not be used to endorse or promote products
- * derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ * %sccs.include.redist.c%
  */
 
 #ifndef lint
 char copyright[] =
  */
 
 #ifndef lint
 char copyright[] =
-"@(#) Copyright (c) 1989 The Regents of the University of California.\n\
+"@(#) Copyright (c) 1990 The Regents of the University of California.\n\
  All rights reserved.\n";
 #endif /* not lint */
 
 #ifndef lint
  All rights reserved.\n";
 #endif /* not lint */
 
 #ifndef lint
-static char sccsid[] = "@(#)ps.c       1.8 (Berkeley) 2/16/90";
+static char sccsid[] = "@(#)ps.c       5.30 (Berkeley) %G%";
 #endif /* not lint */
 #endif /* not lint */
+
+#include <machine/pte.h>
+
 #include <sys/param.h>
 #include <sys/param.h>
-#include <sys/types.h>
 #include <sys/ioctl.h>
 #include <sys/tty.h>
 #include <sys/user.h>
 #include <sys/ioctl.h>
 #include <sys/tty.h>
 #include <sys/user.h>
@@ -35,31 +26,34 @@ static char sccsid[] = "@(#)ps.c    1.8 (Berkeley) 2/16/90";
 #include <sys/text.h>
 #include <sys/stat.h>
 #include <sys/mbuf.h>
 #include <sys/text.h>
 #include <sys/stat.h>
 #include <sys/mbuf.h>
-#include <machine/pte.h>
 #include <nlist.h>
 #include <pwd.h>
 #include <math.h>
 #include <errno.h>
 #include <nlist.h>
 #include <pwd.h>
 #include <math.h>
 #include <errno.h>
+#include <stddef.h>
 #include <stdio.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #include <ctype.h>
 #include <ctype.h>
+#include <varargs.h>
 #include <kvm.h>
 #include <kvm.h>
+#include "pathnames.h"
 
 struct usave {
        struct  proc *u_procp;
        struct  timeval u_start;
        struct  rusage u_ru;
        struct  rusage u_cru;
 
 struct usave {
        struct  proc *u_procp;
        struct  timeval u_start;
        struct  rusage u_ru;
        struct  rusage u_cru;
-       short   u_cmask;
        char    u_acflag;
 };
 
 /*
  * to compute offset in common structures
  */
        char    u_acflag;
 };
 
 /*
  * to compute offset in common structures
  */
-#define        POFF(x)         ((int)&((struct proc *)0)->x)
-#define        EOFF(x)         ((int)&((struct eproc *)0)->x)
-#define        UOFF(x)         ((int)&((struct usave *)0)->x)
-#define        ROFF(x)         ((int)&((struct rusage *)0)->x)
+#define        POFF(x)         offsetof(struct proc, x)
+#define        EOFF(x)         offsetof(struct eproc, x)
+#define        UOFF(x)         offsetof(struct usave, x)
+#define        ROFF(x)         offsetof(struct rusage, x)
 
 enum type      { CHAR, UCHAR, SHORT, USHORT, LONG, ULONG, KPTR };
 
 
 enum type      { CHAR, UCHAR, SHORT, USHORT, LONG, ULONG, KPTR };
 
@@ -71,26 +65,25 @@ enum type   { CHAR, UCHAR, SHORT, USHORT, LONG, ULONG, KPTR };
 
 int needuser, needcomm, neednlist;
 
 
 int needuser, needcomm, neednlist;
 
-int    command(), ucomm(), logname(), pvar(), evar(), uvar(), rvar(), uname(), 
+int    command(), ucomm(), logname(), pvar(), evar(), uvar(), rvar(), uname(),
        runame(), state(), pri(), tdev(), tname(), longtname(), started(),
        runame(), state(), pri(), tdev(), tname(), longtname(), started(),
-       lstarted(), wchan(), vsize(), rssize(), p_rssize(), cputime(), 
+       lstarted(), wchan(), vsize(), rssize(), p_rssize(), cputime(),
        pmem(), pcpu(), pagein(), maxrss(), tsize(), trss();
        /**
        utime(), stime(), ixrss(), idrss(), isrss();
        **/
 
        pmem(), pcpu(), pagein(), maxrss(), tsize(), trss();
        /**
        utime(), stime(), ixrss(), idrss(), isrss();
        **/
 
-struct usave *saveuser();
-char   *saveargs();
+uid_t  getuid();
+char   *ttyname();
 
 struct var {
 
 struct var {
-       char    *name[8];       /* name(s) of variable */
+       char    *name[4];       /* name(s) of variable */
        char    *header;        /* default header */
        int     flag;
 #define        USER    0x01    /* requires user structure */
        char    *header;        /* default header */
        int     flag;
 #define        USER    0x01    /* requires user structure */
-#define        TEXT    0x02    /* requires text table */
-#define        LJUST   0x04    /* right adjust on output */
-#define        COMM    0x08    /* requires exec arguments and environment (XXX) */
-#define        NLIST   0x10    /* requires nlist to get extra variables */
+#define        LJUST   0x02    /* left adjust on output (trailing blanks) */
+#define        COMM    0x04    /* requires exec arguments and environment (XXX) */
+#define        NLIST   0x08    /* requires nlist to get extra variables */
        int     (*oproc)();     /* output routine */
        short   width;          /* printing width */
        /*
        int     (*oproc)();     /* output routine */
        short   width;          /* printing width */
        /*
@@ -106,11 +99,11 @@ struct var {
         */
        struct  var *next;
 }  var[] = {
         */
        struct  var *next;
 }  var[] = {
-       {{"command", "comm", "args"}, "COMMAND", USER|LJUST|COMM, 
-               command, 16}, 
+       {{"command", "comm", "args"}, "COMMAND", USER|LJUST|COMM,
+               command, 16},
        {{"ucomm"}, "COMMAND",  LJUST, ucomm, MAXCOMLEN},
        {{"logname"}, "LOGNAME", LJUST, logname, MAXLOGNAME},
        {{"ucomm"}, "COMMAND",  LJUST, ucomm, MAXCOMLEN},
        {{"logname"}, "LOGNAME", LJUST, logname, MAXLOGNAME},
-       {{"flag"}, "F", 0, pvar, 7, POFF(p_flag), LONG, "x"},
+       {{"flag", "f"}, "F", 0, pvar, 7, POFF(p_flag), LONG, "x"},
        {{"uid"}, "UID", 0, pvar, UIDLEN, POFF(p_uid),USHORT, UIDFMT},
        {{"ruid"}, "RUID", 0, pvar, UIDLEN, POFF(p_ruid), USHORT, UIDFMT},
        {{"svuid"}, "SVUID", 0, pvar, UIDLEN, POFF(p_svuid), USHORT, UIDFMT},
        {{"uid"}, "UID", 0, pvar, UIDLEN, POFF(p_uid),USHORT, UIDFMT},
        {{"ruid"}, "RUID", 0, pvar, UIDLEN, POFF(p_ruid), USHORT, UIDFMT},
        {{"svuid"}, "SVUID", 0, pvar, UIDLEN, POFF(p_svuid), USHORT, UIDFMT},
@@ -128,8 +121,6 @@ struct var {
                0, pvar, 8, POFF(p_traceflag), LONG, "x"},
        {{"ktracep", "tracep"}, "KTRACEP",
                0, pvar, 8, POFF(p_tracep), LONG, "x"},
                0, pvar, 8, POFF(p_traceflag), LONG, "x"},
        {{"ktracep", "tracep"}, "KTRACEP",
                0, pvar, 8, POFF(p_tracep), LONG, "x"},
-       {{"cursig"}, "CURSIG",
-               0, pvar, 2, POFF(p_cursig), CHAR, "d"},
        {{"sig", "pending"}, "PENDING",
                0, pvar, 8, POFF(p_sig), LONG, "x"},
        {{"sigmask", "blocked"}, "BLOCKED",
        {{"sig", "pending"}, "PENDING",
                0, pvar, 8, POFF(p_sig), LONG, "x"},
        {{"sigmask", "blocked"}, "BLOCKED",
@@ -144,29 +135,27 @@ struct var {
        {{"jobc"}, "JOBC", 0, evar, 4, EOFF(e_jobc), SHORT, "d"},
        {{"sess", "session"}, "SESS", 0, evar, 6, EOFF(e_sess), KPTR, "x"},
        {{"tdev", "dev"}, "TDEV", 0, tdev, 4},
        {{"jobc"}, "JOBC", 0, evar, 4, EOFF(e_jobc), SHORT, "d"},
        {{"sess", "session"}, "SESS", 0, evar, 6, EOFF(e_sess), KPTR, "x"},
        {{"tdev", "dev"}, "TDEV", 0, tdev, 4},
-       {{"tname", "tty", "tt"}, "TT", LJUST, tname, 2},
+       {{"tname", "tty", "tt"}, "TT", LJUST, tname, 3},
        {{"longtname", "longtty"}, "TT", LJUST, longtname, 8},
        {{"tpgid"}, "TPGID", 0, evar, 4, EOFF(e_tpgid), USHORT, PIDFMT},
        {{"longtname", "longtty"}, "TT", LJUST, longtname, 8},
        {{"tpgid"}, "TPGID", 0, evar, 4, EOFF(e_tpgid), USHORT, PIDFMT},
-       {{"tsession", "tsess"}, "TSESS", 
+       {{"tsession", "tsess"}, "TSESS",
                0, evar, 6, EOFF(e_tsess), KPTR, "x"},
        {{"paddr", "procaddr"}, "PADDR",
                0, evar, 6, EOFF(e_paddr), KPTR, "x"},
                0, evar, 6, EOFF(e_tsess), KPTR, "x"},
        {{"paddr", "procaddr"}, "PADDR",
                0, evar, 6, EOFF(e_paddr), KPTR, "x"},
-       {{"state", "stat"}, "STAT", 0, state, 3},
+       {{"state", "stat"}, "STAT", 0, state, 4},
        {{"pri"}, "PRI", 0, pri, 3},
        {{"usrpri"}, "UPR", 0, pvar, 3, POFF(p_usrpri), CHAR, "d"},
        {{"pri"}, "PRI", 0, pri, 3},
        {{"usrpri"}, "UPR", 0, pvar, 3, POFF(p_usrpri), CHAR, "d"},
-       {{"nice", "ni"}, "NI", 0, pvar, 2, POFF(p_nice), CHAR, "d"}, 
+       {{"nice", "ni"}, "NI", 0, pvar, 2, POFF(p_nice), CHAR, "d"},
        {{"vsize", "vsz"}, "VSZ", 0, vsize, 5},
        {{"rssize", "rsz"}, "RSZ", 0, rssize, 4},
        {{"rss", "p_rss"}, "RSS", 0, p_rssize, 4},
        {{"u_procp", "uprocp"}, "UPROCP",
                USER, uvar, 6, UOFF(u_procp), KPTR, "x"},
        {{"vsize", "vsz"}, "VSZ", 0, vsize, 5},
        {{"rssize", "rsz"}, "RSZ", 0, rssize, 4},
        {{"rss", "p_rss"}, "RSS", 0, p_rssize, 4},
        {{"u_procp", "uprocp"}, "UPROCP",
                USER, uvar, 6, UOFF(u_procp), KPTR, "x"},
-       {{"umask", "u_cmask"}, "UMASK",
-               USER, uvar, 3, UOFF(u_cmask), CHAR, "o"},
        {{"acflag", "acflg"}, "ACFLG",
                USER, uvar, 3, UOFF(u_acflag), SHORT, "x"},
        {{"start"}, "STARTED", USER|LJUST, started, 8},
        {{"lstart"}, "STARTED", USER|LJUST, lstarted, 28},
        {{"acflag", "acflg"}, "ACFLG",
                USER, uvar, 3, UOFF(u_acflag), SHORT, "x"},
        {{"start"}, "STARTED", USER|LJUST, started, 8},
        {{"lstart"}, "STARTED", USER|LJUST, lstarted, 28},
-       {{"cputime", "time"}, "TIME", USER, cputime, 6},
+       {{"cputime", "time"}, "TIME", USER, cputime, 9},
        {{"p_ru"}, "P_RU", 0, pvar, 6, POFF(p_ru), KPTR, "x"},
        {{"pcpu", "%cpu"}, "%CPU", NLIST, pcpu, 4},
        {{"pmem", "%mem"}, "%MEM", NLIST, pmem, 4},
        {{"p_ru"}, "P_RU", 0, pvar, 6, POFF(p_ru), KPTR, "x"},
        {{"pcpu", "%cpu"}, "%CPU", NLIST, pcpu, 4},
        {{"pmem", "%mem"}, "%MEM", NLIST, pmem, 4},
@@ -185,31 +174,31 @@ struct var {
        {{"idrss"}, "IDRSS", USER, idrss, 4},
        {{"isrss"}, "ISRSS", USER, isrss, 4},
        ***/
        {{"idrss"}, "IDRSS", USER, idrss, 4},
        {{"isrss"}, "ISRSS", USER, isrss, 4},
        ***/
-       {{"minflt"}, "MINFLT", 
+       {{"minflt"}, "MINFLT",
                USER, rvar, 4, ROFF(ru_minflt), LONG, "d"},
                USER, rvar, 4, ROFF(ru_minflt), LONG, "d"},
-       {{"majflt"}, "MAJFLT", 
+       {{"majflt"}, "MAJFLT",
                USER, rvar, 4, ROFF(ru_majflt), LONG, "d"},
                USER, rvar, 4, ROFF(ru_majflt), LONG, "d"},
-       {{"nswap"}, "NSWAP",    
+       {{"nswap"}, "NSWAP",
                USER, rvar, 4, ROFF(ru_nswap), LONG, "d"},
                USER, rvar, 4, ROFF(ru_nswap), LONG, "d"},
-       {{"inblock", "inblk"}, "INBLK",         
+       {{"inblock", "inblk"}, "INBLK",
                USER, rvar, 4, ROFF(ru_inblock), LONG, "d"},
                USER, rvar, 4, ROFF(ru_inblock), LONG, "d"},
-       {{"oublock", "oublk"}, "OUBLK", 
+       {{"oublock", "oublk"}, "OUBLK",
                USER, rvar, 4, ROFF(ru_oublock), LONG, "d"},
                USER, rvar, 4, ROFF(ru_oublock), LONG, "d"},
-       {{"msgsnd"}, "MSGSND", 
+       {{"msgsnd"}, "MSGSND",
                USER, rvar, 4, ROFF(ru_msgsnd), LONG, "d"},
                USER, rvar, 4, ROFF(ru_msgsnd), LONG, "d"},
-       {{"msgrcv"}, "MSGRCV", 
+       {{"msgrcv"}, "MSGRCV",
                USER, rvar, 4, ROFF(ru_msgrcv), LONG, "d"},
                USER, rvar, 4, ROFF(ru_msgrcv), LONG, "d"},
-       {{"nsignals", "nsigs"}, "NSIGS", 
+       {{"nsignals", "nsigs"}, "NSIGS",
                USER, rvar, 4, ROFF(ru_nsignals), LONG, "d"},
                USER, rvar, 4, ROFF(ru_nsignals), LONG, "d"},
-       {{"nvcsw", "vcsw"}, "VCSW", 
+       {{"nvcsw", "vcsw"}, "VCSW",
                USER, rvar, 5, ROFF(ru_nvcsw), LONG, "d"},
                USER, rvar, 5, ROFF(ru_nvcsw), LONG, "d"},
-       {{"nivcsw", "ivcsw"}, "IVCSW", 
+       {{"nivcsw", "ivcsw"}, "IVCSW",
                USER, rvar, 5, ROFF(ru_nivcsw), LONG, "d"},
        NULL
 };
 
                USER, rvar, 5, ROFF(ru_nivcsw), LONG, "d"},
        NULL
 };
 
-/* 
- * combination variables 
+/*
+ * combination variables
  */
 struct combovar {
        char *name;
  */
 struct combovar {
        char *name;
@@ -219,15 +208,15 @@ struct combovar {
                msgsnd msgrcv nsigs nvcsw nivcsw",
        0, 0
 };
                msgsnd msgrcv nsigs nvcsw nivcsw",
        0, 0
 };
-#define DFMT   "pid tname stat cputime comm"
+#define DFMT   "pid tname state cputime comm"
 #define LFMT \
 #define LFMT \
-       "flag uid pid ppid cp pri nice vsz rss wchan stat tname cputime comm"
-#define        JFMT    "user pid ppid pgid sess jobc stat tname cputime comm"
-#define        SFMT    "user pid cursig sig sigmask sigignore sigcatch tname comm"
+       "uid pid ppid cp pri nice vsz rss wchan state tname cputime comm"
+#define        JFMT    "user pid ppid pgid sess jobc state tname cputime comm"
+#define        SFMT    "uid pid sig sigmask sigignore sigcatch stat tname comm"
 #define        VFMT \
 #define        VFMT \
-       "pid tt stat time sl re pagein vsz rss lim tsiz trs %cpu %mem comm"
+       "pid tt state time sl re pagein vsz rss lim tsiz trs %cpu %mem comm"
 #define UFMT \
 #define UFMT \
-       "uname pid %cpu %mem vsz rss tt stat start time comm"
+       "uname pid %cpu %mem vsz rss tt state start time comm"
 
 struct kinfo {
        struct proc *ki_p;      /* proc structure */
 
 struct kinfo {
        struct proc *ki_p;      /* proc structure */
@@ -273,26 +262,26 @@ fixpt_t   ccpu;
 
 #define USAGE  "ps [ -(o|O) fmt ] [ -wlvujnsaxSCLmcr ] [ -p pid ] [ -t tty ]"
 
 
 #define USAGE  "ps [ -(o|O) fmt ] [ -wlvujnsaxSCLmcr ] [ -p pid ] [ -t tty ]"
 
-main (argc, argv) 
+main(argc, argv)
+       int argc;
        char *argv[];
 {
        extern char *optarg;
        extern int optind;
        char *argv[];
 {
        extern char *optarg;
        extern int optind;
-       int ch; 
-       register i;
+       int ch;
+       register int i;
        register struct var *v;
        register struct proc *p;
        struct winsize ws;
        register struct var *v;
        register struct proc *p;
        struct winsize ws;
-       struct kinfo_proc *kprocs;
-       int nentries;
+       size_t nentries;
        int fmt = 0;
        int pscomp();
        int what, flag;
        char *kludge_oldps_options();
 
        int fmt = 0;
        int pscomp();
        int what, flag;
        char *kludge_oldps_options();
 
-       if ((ioctl(1, TIOCGWINSZ, &ws) == -1 && 
-            ioctl(2, TIOCGWINSZ, &ws) == -1 &&
-            ioctl(0, TIOCGWINSZ, &ws) == -1) ||
+       if ((ioctl(1, TIOCGWINSZ, (char *)&ws) == -1 &&
+            ioctl(2, TIOCGWINSZ, (char *)&ws) == -1 &&
+            ioctl(0, TIOCGWINSZ, (char *)&ws) == -1) ||
             ws.ws_col == 0)
                termwidth = 79;
        else
             ws.ws_col == 0)
                termwidth = 79;
        else
@@ -300,7 +289,7 @@ main (argc, argv)
        if (argc > 1)
                argv[1] = kludge_oldps_options(argv[1]);
 
        if (argc > 1)
                argv[1] = kludge_oldps_options(argv[1]);
 
-       while ((ch = getopt(argc, argv, "o:O:wlvujnsaxt:p:SCLmchT")) != EOF)
+       while ((ch = getopt(argc, argv, "o:O:wlvujnsaxt:p:SCLmrhTg")) != EOF)
                switch((char)ch) {
                case 'o':
                        parsefmt(optarg);
                switch((char)ch) {
                case 'o':
                        parsefmt(optarg);
@@ -309,7 +298,7 @@ main (argc, argv)
                case 'O':
                        parsefmt("pid");
                        parsefmt(optarg);
                case 'O':
                        parsefmt("pid");
                        parsefmt(optarg);
-                       parsefmt("stat tt time command");
+                       parsefmt("state tt time command");
                        fmt++;
                        break;
                case 'w':
                        fmt++;
                        break;
                case 'w':
@@ -341,37 +330,31 @@ main (argc, argv)
                        fmt++;
                        break;
                case 'T':
                        fmt++;
                        break;
                case 'T':
+                       if ((optarg = ttyname(0)) == NULL)
+                               error("<stdin>: not a terminal");
+                       /* FALLTHROUGH */
                case 't': {
                case 't': {
+                       char *ttypath;
                        struct stat stbuf;
                        struct stat stbuf;
-                       char *tname, *ttyname();
-                       char termname[MAXPATHLEN+1];
-
-                       if (ch == 'T') {
-                               if ((tname = ttyname(0)) == NULL)
-                                       error("<stdin>: not a terminal");
-                       } else 
-                               tname = optarg;
-                       if (strlen(tname) == 2) {
-                               if (strcmp(tname, "co") == 0)
-                                       strcpy(termname, "/dev/console");
-                               else {
-                                       strcpy(termname, "/dev/tty");
-                                       strcat(termname, tname);
-                               }
-                       } else if (*tname != '/') {
-                               strcpy(termname, "/dev/");
-                               strcat(termname, tname);
-                       } else
-                               strcpy(termname, tname);
-                       if (stat(termname, &stbuf) == -1)
-                               syserror(termname);
-                       if ((stbuf.st_mode&S_IFMT) != S_IFCHR)
-                               error("%s: not a terminal", termname);
+                       char pathbuf[MAXPATHLEN];
+
+                       if (strcmp(optarg, "co") == 0)
+                               ttypath = _PATH_CONSOLE;
+                       else if (*optarg != '/')
+                               (void) sprintf(ttypath = pathbuf, "%s%s",
+                                   _PATH_TTY, optarg);
+                       else
+                               ttypath = optarg;
+                       if (stat(ttypath, &stbuf) == -1)
+                               syserror(ttypath);
+                       if ((stbuf.st_mode & S_IFMT) != S_IFCHR)
+                               error("%s: not a terminal", ttypath);
                        ttydev = stbuf.st_rdev;
                        break;
                }
                case 'p':
                        pid = atoi(optarg);
                        ttydev = stbuf.st_rdev;
                        break;
                }
                case 'p':
                        pid = atoi(optarg);
+                       xflg++;
                        break;
                case 'S':
                        sumrusage++;
                        break;
                case 'S':
                        sumrusage++;
@@ -380,26 +363,23 @@ main (argc, argv)
                        rawcpu++;
                        break;
                case 'L': {
                        rawcpu++;
                        break;
                case 'L': {
-                       int i = 0;
                        struct combovar *cb = &combovar[0];
                        struct combovar *cb = &combovar[0];
-                       char *cp;
-
-                       v = &var[0];
-                       for (;;) {
-                               if (v->name[0] != NULL) {
-                                       cp = v->name[0];
-                                       v++;
-                               } else if (cb->name != NULL) {
-                                       cp = cb->name;
-                                       cb++;
-                               } else
+                       char *cp, *sep = "";
+
+                       for (i = 0, v = &var[0];;) {
+                               if (v->name[0] != NULL)
+                                       cp = v++->name[0];
+                               else if (cb->name != NULL)
+                                       cp = cb++->name;
+                               else
                                        break;
                                        break;
-                               if (termwidth && 
-                                  (i += strlen(cp)+1) > termwidth)
-                                       i = strlen(cp), printf("\n");
-                               printf("%s ", cp);
+                               if (termwidth &&
+                                   (i += strlen(cp) + 1) > termwidth)
+                                       i = strlen(cp), sep = "\n";
+                               (void) printf("%s%s", sep, cp);
+                               sep = " ";
                        }
                        }
-                       printf("\n");
+                       (void) printf("\n");
                        exit(0);
                }
                case 'a':
                        exit(0);
                }
                case 'a':
@@ -411,20 +391,22 @@ main (argc, argv)
                case 'm':
                        sortby = SORTMEM;
                        break;
                case 'm':
                        sortby = SORTMEM;
                        break;
-               case 'c':
+               case 'r':
                        sortby = SORTCPU;
                        break;
                case 'h':
                        prtheader = ws.ws_row > 5 ? ws.ws_row : 22;
                        break;
                        sortby = SORTCPU;
                        break;
                case 'h':
                        prtheader = ws.ws_row > 5 ? ws.ws_row : 22;
                        break;
+               case 'g':
+                       break;  /* no-op */
                case '?':
                default:
                case '?':
                default:
-                       fprintf(stderr, "usage: %s\n", USAGE);
+                       (void) fprintf(stderr, "usage: %s\n", USAGE);
                        exit(1);
                }
        argc -= optind;
        argv += optind;
                        exit(1);
                }
        argc -= optind;
        argv += optind;
-       
+
        if (*argv) {
                char *nlistf, *memf = NULL, *swapf = NULL;
 
        if (*argv) {
                char *nlistf, *memf = NULL, *swapf = NULL;
 
@@ -465,12 +447,11 @@ main (argc, argv)
        } else if (pid != -1) {
                what = KINFO_PROC_PID;
                flag = pid;
        } else if (pid != -1) {
                what = KINFO_PROC_PID;
                flag = pid;
-       }
        /*
         * select procs
         */
        if ((nentries = kvm_getprocs(what, flag)) == -1) {
        /*
         * select procs
         */
        if ((nentries = kvm_getprocs(what, flag)) == -1) {
-               fprintf(stderr, "ps: %s\n", kvm_geterr());
+               (void) fprintf(stderr, "ps: %s\n", kvm_geterr());
                exit(1);
        }
        kinfo = (struct kinfo *)malloc(nentries * sizeof (struct kinfo));
                exit(1);
        }
        kinfo = (struct kinfo *)malloc(nentries * sizeof (struct kinfo));
@@ -494,21 +475,22 @@ main (argc, argv)
        /*
         * sort proc list
         */
        /*
         * sort proc list
         */
-       qsort(kinfo, nentries, sizeof (struct kinfo), pscomp);
+       qsort((void *)kinfo, nentries, sizeof (struct kinfo), pscomp);
        /*
         * for each proc, call each variable output function.
         */
        for (i = 0; i < nentries; i++) {
        /*
         * for each proc, call each variable output function.
         */
        for (i = 0; i < nentries; i++) {
-               if (xflg == 0 && kinfo[i].ki_e->e_tdev == NODEV)
+               if (xflg == 0 && (kinfo[i].ki_e->e_tdev == NODEV ||
+                   (kinfo[i].ki_p->p_flag & SCTTY ) == 0))
                        continue;
                for (v = vhead; v != NULL; v = v->next) {
                        (*v->oproc)(&kinfo[i], v);
                        if (v->next != NULL)
                        continue;
                for (v = vhead; v != NULL; v = v->next) {
                        (*v->oproc)(&kinfo[i], v);
                        if (v->next != NULL)
-                               putchar(' ');
+                               (void) putchar(' ');
                }
                }
-               putchar('\n');
+               (void) putchar('\n');
                if (prtheader && lineno++ == prtheader-4) {
                if (prtheader && lineno++ == prtheader-4) {
-                       putchar('\n');
+                       (void) putchar('\n');
                        printheader();
                        lineno = 0;
                }
                        printheader();
                        lineno = 0;
                }
@@ -522,43 +504,28 @@ main (argc, argv)
 parsefmt(fmt)
        char *fmt;
 {
 parsefmt(fmt)
        char *fmt;
 {
-       register char *f = fmt, *cp, *hp;
+       register char *cp, *hp;
        struct var *v;
        struct var *v;
-       char *strtok(), *index();
-       char newbuf[1024], *nb = newbuf; /* XXX */
        char *lookupcombo();
        struct var *lookupvar();
        char *lookupcombo();
        struct var *lookupvar();
-       
-       /*
-        * strtok is not &^%^& re-entrant, so we have
-        * only one level of expansion, looking for combo
-        * variables once here, and expanding the string
-        * before really parsing it.  With strtok_r,
-        * you would move the expansion to before the
-        * lookupvar inside the 2nd while loop with a
-        * recursive call to parsefmt.
-        */
-       while ((cp = strtok(f, FMTSEP)) != NULL) {
-               if ((hp = lookupcombo(cp)) == NULL);
-                       hp = cp;
-               if (((nb + strlen(hp)) - newbuf) >= 1024)
-                       error("format too large");
-               strcpy(nb, hp);
-               while (*nb)
-                       nb++;
-               *nb++ = ' ';
-               *nb =  '\0';
-               f = NULL;
-       }
-       f = newbuf;
-       while ((cp = strtok(f, FMTSEP)) != NULL) {
-               if (hp = index(cp, '='))
+
+       while (fmt) {
+               while ((cp = strsep(&fmt, FMTSEP)) != NULL && *cp == '\0')
+                       /* void */;
+               if ((hp = lookupcombo(cp)) != NULL) {
+                       parsefmt(hp);
+                       continue;
+               }
+               if ((hp = index(cp, '=')) != NULL)
                        *hp++ = '\0';
                v = lookupvar(cp);
                if (v == NULL)
                        error("unknown variable in format: %s", cp);
                        *hp++ = '\0';
                v = lookupvar(cp);
                if (v == NULL)
                        error("unknown variable in format: %s", cp);
-               if (v->next != NULL || vtail == v)
-                       error("can't specify a variable twice: %s", cp);
+               if (v->next != NULL || vtail == v) {
+                       (void) fprintf(stderr,
+                           "ps: can't specify a variable twice: %s\n", cp);
+                       continue;
+               }
                if (hp)
                        v->header = hp;
                if (vhead == NULL)
                if (hp)
                        v->header = hp;
                if (vhead == NULL)
@@ -567,9 +534,7 @@ parsefmt(fmt)
                        vtail->next = v;
                        vtail = v;
                }
                        vtail->next = v;
                        vtail = v;
                }
-               f = NULL;       /* for strtok */
        }
        }
-
 }
 
 scanvars()
 }
 
 scanvars()
@@ -591,6 +556,7 @@ scanvars()
        }
        totwidth--;
 }
        }
        totwidth--;
 }
+
 printheader()
 {
        register struct var *v;
 printheader()
 {
        register struct var *v;
@@ -598,63 +564,64 @@ printheader()
        for (v = vhead; v != NULL; v = v->next) {
                if (v->flag & LJUST) {
                        if (v->next == NULL)    /* last one */
        for (v = vhead; v != NULL; v = v->next) {
                if (v->flag & LJUST) {
                        if (v->next == NULL)    /* last one */
-                               printf("%s", v->header);
+                               (void) printf("%s", v->header);
                        else
                        else
-                               printf("%-*s",v->width, v->header);
+                               (void) printf("%-*s", v->width, v->header);
                } else
                } else
-                       printf("%*s",v->width, v->header);
+                       (void) printf("%*s", v->width, v->header);
                if (v->next != NULL)
                if (v->next != NULL)
-                       putchar(' ');
+                       (void) putchar(' ');
        }
        }
-       putchar('\n');
+       (void) putchar('\n');
 }
 
 }
 
-command(k, v) 
+command(k, v)
        struct kinfo *k;
        struct var *v;
 {
 
        struct kinfo *k;
        struct var *v;
 {
 
-       if (v->next == NULL) {          
+       if (v->next == NULL) {
                /* last field */
                if (termwidth == UNLIMITED)
                /* last field */
                if (termwidth == UNLIMITED)
-                       printf("%s", k->ki_args);
+                       (void) printf("%s", k->ki_args);
                else {
                else {
-                       register left = termwidth - (totwidth - v->width);
+                       register int left = termwidth - (totwidth - v->width);
                        register char *cp = k->ki_args;
 
                        register char *cp = k->ki_args;
 
-                       if (left < 1)   /* already wrapped, just use std width */
+                       if (left < 1) /* already wrapped, just use std width */
                                left = v->width;
                                left = v->width;
-                       while (left-- && *cp)
-                               putchar(*cp++);
+                       while (--left >= 0 && *cp)
+                               (void) putchar(*cp++);
                }
        } else
                }
        } else
-               printf("%-*.*s", v->width, v->width, k->ki_args);
-               
+               (void) printf("%-*.*s", v->width, v->width, k->ki_args);
+
 }
 
 }
 
-ucomm(k, v) 
+ucomm(k, v)
        struct kinfo *k;
        struct var *v;
 {
 
        struct kinfo *k;
        struct var *v;
 {
 
-       printf("%-*s", v->width, k->ki_p->p_comm);
+       (void) printf("%-*s", v->width, k->ki_p->p_comm);
 }
 
 }
 
-logname(k, v) 
+logname(k, v)
        struct kinfo *k;
        struct var *v;
 {
 
        struct kinfo *k;
        struct var *v;
 {
 
-       printf("%-*s", v->width, k->ki_p->p_logname);
+       (void) printf("%-*s", v->width, k->ki_p->p_logname);
 }
 
 state(k, v)
        struct kinfo *k;
        struct var *v;
 {
 }
 
 state(k, v)
        struct kinfo *k;
        struct var *v;
 {
-       char buf[6];
-       char *cp = buf;
-       struct proc *p = k->ki_p;
+       char buf[16];
+       register char *cp = buf;
+       register struct proc *p = k->ki_p;
+       register flag = p->p_flag;
 
        switch (p->p_stat) {
 
 
        switch (p->p_stat) {
 
@@ -663,18 +630,12 @@ state(k, v)
                break;
 
        case SSLEEP:
                break;
 
        case SSLEEP:
-               if (p->p_pri > PZERO)
-                       if (p->p_slptime >= MAXSLP)
-                               *cp = 'I';
-                       else
-                               *cp = 'S';
-               else if (p->p_flag & SPAGE)
-                       *cp = 'P';
+               if (flag & SSINTR)      /* interuptable (long) */
+                       *cp = p->p_slptime >= MAXSLP ? 'I' : 'S';
                else
                else
-                       *cp = 'D';
+                       *cp = (flag & SPAGE) ? 'P' : 'D';
                break;
 
                break;
 
-       case SWAIT:
        case SRUN:
        case SIDL:
                *cp = 'R';
        case SRUN:
        case SIDL:
                *cp = 'R';
@@ -688,7 +649,7 @@ state(k, v)
                *cp = '?';
        }
        cp++;
                *cp = '?';
        }
        cp++;
-       if (p->p_flag & SLOAD) {
+       if (flag & SLOAD) {
                if (p->p_rssize > p->p_maxrss)
                        *cp++ = '>';
        } else
                if (p->p_rssize > p->p_maxrss)
                        *cp++ = '>';
        } else
@@ -697,14 +658,24 @@ state(k, v)
                *cp++ = '<';
        else if (p->p_nice > NZERO)
                *cp++ = 'N';
                *cp++ = '<';
        else if (p->p_nice > NZERO)
                *cp++ = 'N';
-       if (p->p_flag & SUANOM)
+       if (flag & SUANOM)
                *cp++ = 'A';
                *cp++ = 'A';
-       else if (p->p_flag & SSEQL)
+       else if (flag & SSEQL)
                *cp++ = 'S';
                *cp++ = 'S';
-       if (p->p_flag&SCTTY && k->ki_e->e_tpgid == k->ki_e->e_pgid)
+       if (flag & STRC)
+               *cp++ = 'X';
+       if (flag & SWEXIT)
+               *cp++ = 'E';
+       if (flag & SVFORK)
+               *cp++ = 'V';
+       if (flag & (SSYS|SLOCK|SULOCK|SKEEP|SPHYSIO))
+               *cp++ = 'L';
+       if (k->ki_e->e_flag & EPROC_SLEADER)
+               *cp++ = 's';
+       if ((flag & SCTTY) && k->ki_e->e_pgid == k->ki_e->e_tpgid)
                *cp++ = '+';
        *cp = '\0';
                *cp++ = '+';
        *cp = '\0';
-       printf("%-*s", v->width, buf);
+       (void) printf("%-*s", v->width, buf);
 }
 
 pri(k, v)
 }
 
 pri(k, v)
@@ -712,7 +683,7 @@ pri(k, v)
        struct var *v;
 {
 
        struct var *v;
 {
 
-       printf("%*d", v->width, k->ki_p->p_pri - PZERO);
+       (void) printf("%*d", v->width, k->ki_p->p_pri - PZERO);
 }
 
 uname(k, v)
 }
 
 uname(k, v)
@@ -720,7 +691,7 @@ uname(k, v)
        struct var *v;
 {
 
        struct var *v;
 {
 
-       printf("%-*s", v->width, user_from_uid(k->ki_p->p_uid, 0));
+       (void) printf("%-*s", v->width, user_from_uid(k->ki_p->p_uid, 0));
 }
 
 runame(k, v)
 }
 
 runame(k, v)
@@ -728,7 +699,7 @@ runame(k, v)
        struct var *v;
 {
 
        struct var *v;
 {
 
-       printf("%-*s", v->width, user_from_uid(k->ki_p->p_ruid, 0));
+       (void) printf("%-*s", v->width, user_from_uid(k->ki_p->p_ruid, 0));
 }
 
 tdev(k, v)
 }
 
 tdev(k, v)
@@ -738,30 +709,31 @@ tdev(k, v)
        dev_t dev = k->ki_e->e_tdev;
 
        if (dev == NODEV)
        dev_t dev = k->ki_e->e_tdev;
 
        if (dev == NODEV)
-               printf("%*s", v->width, "??");
+               (void) printf("%*s", v->width, "??");
        else {
                char buff[16];
 
        else {
                char buff[16];
 
-               sprintf(buff, "%d/%d", major(dev), minor(dev));
-               printf("%*s", v->width, buff);
+               (void) sprintf(buff, "%d/%d", major(dev), minor(dev));
+               (void) printf("%*s", v->width, buff);
        }
 }
 
        }
 }
 
-char *devname();
+extern char *devname();
 
 tname(k, v)
        struct kinfo *k;
        struct var *v;
 {
        dev_t dev = k->ki_e->e_tdev;
 
 tname(k, v)
        struct kinfo *k;
        struct var *v;
 {
        dev_t dev = k->ki_e->e_tdev;
-       char *tname;
+       char *ttname;
 
 
-       if (dev == NODEV || (tname = devname(dev, 1)) == NULL)
-               printf("%-*s", v->width, "??");
+       if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL)
+               (void) printf("%-*s", v->width, "??");
        else {
        else {
-               if (strncmp(tname, "tty", 3) == 0)
-                       tname += 3;
-               printf("%-*.*s", v->width, v->width, tname);
+               if (strncmp(ttname, "tty", 3) == 0)
+                       ttname += 3;
+               (void) printf("%*.*s%c", v->width-1, v->width-1, ttname,
+                       k->ki_e->e_flag & EPROC_CTTY ? ' ' : '-');
        }
 }
 
        }
 }
 
@@ -770,12 +742,12 @@ longtname(k, v)
        struct var *v;
 {
        dev_t dev = k->ki_e->e_tdev;
        struct var *v;
 {
        dev_t dev = k->ki_e->e_tdev;
-       char *tname;
+       char *ttname;
 
 
-       if (dev == NODEV || (tname = devname(dev, 1)) == NULL)
-               printf("%-*s", v->width, "??");
+       if (dev == NODEV || (ttname = devname(dev, S_IFCHR)) == NULL)
+               (void) printf("%-*s", v->width, "??");
        else
        else
-               printf("%-*s", v->width, tname);
+               (void) printf("%-*s", v->width, ttname);
 }
 
 #include <sys/time.h>
 }
 
 #include <sys/time.h>
@@ -786,9 +758,9 @@ started(k, v)
 {
        extern char *attime();
 
 {
        extern char *attime();
 
-       printf("%-*s", v->width, k->ki_u ? 
+       (void) printf("%-*s", v->width, k->ki_u ?
                attime(&k->ki_u->u_start.tv_sec) : "-");
                attime(&k->ki_u->u_start.tv_sec) : "-");
-               
+
 }
 
 lstarted(k, v)
 }
 
 lstarted(k, v)
@@ -796,13 +768,13 @@ lstarted(k, v)
        struct var *v;
 {
        extern char *ctime();
        struct var *v;
 {
        extern char *ctime();
-       char *tp; 
+       char *tp;
 
        if (k->ki_u)
                (tp = ctime(&k->ki_u->u_start.tv_sec))[24] = '\0';
        else
                tp = "-";
 
        if (k->ki_u)
                (tp = ctime(&k->ki_u->u_start.tv_sec))[24] = '\0';
        else
                tp = "-";
-       printf("%-*s", v->width, tp);
+       (void) printf("%-*s", v->width, tp);
 }
 
 wchan(k, v)
 }
 
 wchan(k, v)
@@ -812,22 +784,21 @@ wchan(k, v)
 
        if (k->ki_p->p_wchan) {
                if (k->ki_p->p_pri > PZERO)
 
        if (k->ki_p->p_wchan) {
                if (k->ki_p->p_pri > PZERO)
-                       printf("%-*.*s", v->width, v->width, k->ki_e->e_wmesg);
+                       (void) printf("%-*.*s", v->width, v->width, k->ki_e->e_wmesg);
                else
                else
-                       printf("%*x", v->width, 
+                       (void) printf("%*x", v->width,
                                (int)k->ki_p->p_wchan &~ KERNBASE);
        } else
                                (int)k->ki_p->p_wchan &~ KERNBASE);
        } else
-               printf("%-*s", v->width, "-");
+               (void) printf("%-*s", v->width, "-");
 }
 
 }
 
-#define pgtok(a)        ((a)/(1024/NBPG))
 
 vsize(k, v)
        struct kinfo *k;
        struct var *v;
 {
 
 
 vsize(k, v)
        struct kinfo *k;
        struct var *v;
 {
 
-       printf("%*d", v->width, 
+       (void) printf("%*d", v->width,
                pgtok(k->ki_p->p_dsize + k->ki_p->p_ssize + k->ki_e->e_xsize));
 }
 
                pgtok(k->ki_p->p_dsize + k->ki_p->p_ssize + k->ki_e->e_xsize));
 }
 
@@ -836,8 +807,8 @@ rssize(k, v)
        struct var *v;
 {
 
        struct var *v;
 {
 
-       printf("%*d", v->width, 
-               pgtok(k->ki_p->p_rssize + (k->ki_e->e_xccount ? 
+       (void) printf("%*d", v->width,
+               pgtok(k->ki_p->p_rssize + (k->ki_e->e_xccount ?
                      (k->ki_e->e_xrssize / k->ki_e->e_xccount) : 0)));
 }
 
                      (k->ki_e->e_xrssize / k->ki_e->e_xccount) : 0)));
 }
 
@@ -846,7 +817,7 @@ p_rssize(k, v)              /* doesn't account for text */
        struct var *v;
 {
 
        struct var *v;
 {
 
-       printf("%*d", v->width, pgtok(k->ki_p->p_rssize));
+       (void) printf("%*d", v->width, pgtok(k->ki_p->p_rssize));
 }
 
 cputime(k, v)
 }
 
 cputime(k, v)
@@ -854,19 +825,34 @@ cputime(k, v)
        struct var *v;
 {
        long secs;
        struct var *v;
 {
        long secs;
-       char obuff[8];
+       long psecs;     /* "parts" of a second. first micro, then centi */
+       char obuff[128];
 
 
-       if (k->ki_p->p_stat == SZOMB || k->ki_u == NULL)
+       if (k->ki_p->p_stat == SZOMB || k->ki_u == NULL) {
                secs = 0;
                secs = 0;
-       else {
-               secs = k->ki_u->u_ru.ru_utime.tv_sec + 
-                       k->ki_u->u_ru.ru_stime.tv_sec;
-               if (sumrusage)
-                       secs += k->ki_u->u_cru.ru_utime.tv_sec + 
+               psecs = 0;
+       } else {
+               secs = k->ki_p->p_utime.tv_sec +
+                       k->ki_p->p_stime.tv_sec;
+               psecs = k->ki_p->p_utime.tv_usec +
+                       k->ki_p->p_stime.tv_usec;
+               if (sumrusage) {
+                       secs += k->ki_u->u_cru.ru_utime.tv_sec +
                                k->ki_u->u_cru.ru_stime.tv_sec;
                                k->ki_u->u_cru.ru_stime.tv_sec;
+                       psecs += k->ki_u->u_cru.ru_utime.tv_usec +
+                               k->ki_u->u_cru.ru_stime.tv_usec;
+               }
+               /*
+                * round and scale to 100's
+                */
+               psecs = (psecs + 5000) / 10000;
+               if (psecs >= 100) {
+                       psecs -= 100;
+                       secs++;
+               }
        }
        }
-       sprintf(obuff, "%3ld:%02ld", secs/60, secs%60);
-       printf("%*s", v->width, obuff);
+       (void) sprintf(obuff, "%3ld:%02ld.%02ld", secs/60, secs%60, psecs);
+       (void) printf("%*s", v->width, obuff);
 }
 
 double
 }
 
 double
@@ -882,7 +868,7 @@ getpcpu(k)
        struct proc *p = k->ki_p;
 #define        fxtofl(fixpt)   ((double)(fixpt) / fscale)
 
        struct proc *p = k->ki_p;
 #define        fxtofl(fixpt)   ((double)(fixpt) / fscale)
 
-       if (p->p_time == 0 || (p->p_flag&SLOAD) == 0)
+       if (p->p_time == 0 || (p->p_flag & SLOAD) == 0) /* XXX - I don't like this */
                return (0.0);
        if (rawcpu)
                return (100.0 * fxtofl(p->p_pctcpu));
                return (0.0);
        if (rawcpu)
                return (100.0 * fxtofl(p->p_pctcpu));
@@ -895,13 +881,12 @@ pcpu(k, v)
        struct var *v;
 {
 
        struct var *v;
 {
 
-       printf("%*.1f", v->width, getpcpu(k));
+       (void) printf("%*.1f", v->width, getpcpu(k));
 }
 
 double
 }
 
 double
-getpmem(k, v)
+getpmem(k)
        struct kinfo *k;
        struct kinfo *k;
-       struct var *v;
 {
        struct proc *p = k->ki_p;
        struct eproc *e = k->ki_e;
 {
        struct proc *p = k->ki_p;
        struct eproc *e = k->ki_e;
@@ -914,7 +899,7 @@ getpmem(k, v)
         * gets set.
         */
 
         * gets set.
         */
 
-       if (p->p_flag&SLOAD == 0)
+       if ((p->p_flag & SLOAD) == 0)
                return (0.0);
        szptudot = UPAGES + clrnd(ctopt(p->p_dsize + p->p_ssize + e->e_xsize));
        fracmem = ((float)p->p_rssize + szptudot)/CLSIZE/ecmx;
                return (0.0);
        szptudot = UPAGES + clrnd(ctopt(p->p_dsize + p->p_ssize + e->e_xsize));
        fracmem = ((float)p->p_rssize + szptudot)/CLSIZE/ecmx;
@@ -928,7 +913,7 @@ pmem(k, v)
        struct var *v;
 {
 
        struct var *v;
 {
 
-       printf("%*.1f", v->width, getpmem(k));
+       (void) printf("%*.1f", v->width, getpmem(k));
 }
 
 pagein(k, v)
 }
 
 pagein(k, v)
@@ -936,7 +921,7 @@ pagein(k, v)
        struct var *v;
 {
 
        struct var *v;
 {
 
-       printf("%*d", v->width, k->ki_u ? k->ki_u->u_ru.ru_majflt : 0);
+       (void) printf("%*d", v->width, k->ki_u ? k->ki_u->u_ru.ru_majflt : 0);
 }
 
 maxrss(k, v)
 }
 
 maxrss(k, v)
@@ -945,17 +930,17 @@ maxrss(k, v)
 {
 
        if (k->ki_p->p_maxrss != (RLIM_INFINITY/NBPG))
 {
 
        if (k->ki_p->p_maxrss != (RLIM_INFINITY/NBPG))
-               printf("%*d", v->width, pgtok(k->ki_p->p_maxrss));
+               (void) printf("%*d", v->width, pgtok(k->ki_p->p_maxrss));
        else
        else
-               printf("%*s", v->width, "-");
+               (void) printf("%*s", v->width, "-");
 }
 
 tsize(k, v)
        struct kinfo *k;
        struct var *v;
 {
 }
 
 tsize(k, v)
        struct kinfo *k;
        struct var *v;
 {
-       
-       printf("%*d", v->width, pgtok(k->ki_e->e_xsize));
+
+       (void) printf("%*d", v->width, pgtok(k->ki_e->e_xsize));
 }
 
 trss(k, v)
 }
 
 trss(k, v)
@@ -963,49 +948,49 @@ trss(k, v)
        struct var *v;
 {
 
        struct var *v;
 {
 
-       printf("%*d", v->width, pgtok(k->ki_e->e_xrssize));
+       (void) printf("%*d", v->width, pgtok(k->ki_e->e_xrssize));
 }
 
 /*
  * Generic output routines.  Print fields from various prototype
  * structures.
  */
 }
 
 /*
  * Generic output routines.  Print fields from various prototype
  * structures.
  */
-pvar(k, v) 
+pvar(k, v)
        struct kinfo *k;
        struct var *v;
 {
        struct kinfo *k;
        struct var *v;
 {
- 
+
        printval((char *)((char *)k->ki_p + v->off), v);
 }
 
        printval((char *)((char *)k->ki_p + v->off), v);
 }
 
-evar(k, v) 
+evar(k, v)
        struct kinfo *k;
        struct var *v;
 {
        struct kinfo *k;
        struct var *v;
 {
- 
+
        printval((char *)((char *)k->ki_e + v->off), v);
 }
 
        printval((char *)((char *)k->ki_e + v->off), v);
 }
 
-uvar(k, v) 
+uvar(k, v)
        struct kinfo *k;
        struct var *v;
 {
        struct kinfo *k;
        struct var *v;
 {
- 
+
        if (k->ki_u)
                printval((char *)((char *)k->ki_u + v->off), v);
        else
        if (k->ki_u)
                printval((char *)((char *)k->ki_u + v->off), v);
        else
-               printf("%*s", v->width, "-");
+               (void) printf("%*s", v->width, "-");
 }
 
 rvar(k, v)
        struct kinfo *k;
        struct var *v;
 {
 }
 
 rvar(k, v)
        struct kinfo *k;
        struct var *v;
 {
-       
+
        if (k->ki_u)
                printval((char *)((char *)(&k->ki_u->u_ru) + v->off), v);
        else
        if (k->ki_u)
                printval((char *)((char *)(&k->ki_u->u_ru) + v->off), v);
        else
-               printf("%*s", v->width, "-");
+               (void) printf("%*s", v->width, "-");
 }
 
 char *
 }
 
 char *
@@ -1037,42 +1022,42 @@ printval(bp, v)
        char *bp;
        struct var *v;
 {
        char *bp;
        struct var *v;
 {
-       static char ofmt[16] = "%";
-       char *cp = ofmt+1;
+       static char ofmt[32] = "%";
+       register char *cp = ofmt+1, *fcp = v->fmt;
 
        if (v->flag & LJUST)
                *cp++ = '-';
        *cp++ = '*';
 
        if (v->flag & LJUST)
                *cp++ = '-';
        *cp++ = '*';
-       *cp++ = *v->fmt;
-       *cp++ = '\0';
+       while (*cp++ = *fcp++)
+               ;
 
        switch (v->type) {
        case CHAR:
 
        switch (v->type) {
        case CHAR:
-               printf(ofmt, v->width, *(char *)bp);
+               (void) printf(ofmt, v->width, *(char *)bp);
                break;
 
        case UCHAR:
                break;
 
        case UCHAR:
-               printf(ofmt, v->width, *(u_char *)bp);
+               (void) printf(ofmt, v->width, *(u_char *)bp);
                break;
 
        case SHORT:
                break;
 
        case SHORT:
-               printf(ofmt, v->width, *(short *)bp);
+               (void) printf(ofmt, v->width, *(short *)bp);
                break;
 
        case USHORT:
                break;
 
        case USHORT:
-               printf(ofmt, v->width, *(u_short *)bp);
+               (void) printf(ofmt, v->width, *(u_short *)bp);
                break;
 
        case LONG:
                break;
 
        case LONG:
-               printf(ofmt, v->width, *(long *)bp);
+               (void) printf(ofmt, v->width, *(long *)bp);
                break;
 
        case ULONG:
                break;
 
        case ULONG:
-               printf(ofmt, v->width, *(u_long *)bp);
+               (void) printf(ofmt, v->width, *(u_long *)bp);
                break;
 
        case KPTR:
                break;
 
        case KPTR:
-               printf(ofmt, v->width, *(u_long *)bp &~ KERNBASE);
+               (void) printf(ofmt, v->width, *(u_long *)bp &~ KERNBASE);
                break;
 
        default:
                break;
 
        default:
@@ -1081,15 +1066,14 @@ printval(bp, v)
 }
 
 /* XXX - redo */
 }
 
 /* XXX - redo */
-struct usave *
-saveuser(ki) 
+saveuser(ki)
        struct kinfo *ki;
 {
        register struct usave *usp;
        register struct user *up;
        struct kinfo *ki;
 {
        register struct usave *usp;
        register struct user *up;
-       
+
        if ((usp = (struct usave *)calloc(1, sizeof (struct usave))) == NULL) {
        if ((usp = (struct usave *)calloc(1, sizeof (struct usave))) == NULL) {
-               fprintf(stderr, "ps: out of memory\n");
+               (void) fprintf(stderr, "ps: out of memory\n");
                exit(1);
        }
        ki->ki_u = usp;
                exit(1);
        }
        ki->ki_u = usp;
@@ -1098,10 +1082,10 @@ saveuser(ki)
         * save arguments if needed
         */
        if (needcomm)
         * save arguments if needed
         */
        if (needcomm)
-               ki->ki_args = saveargs(ki->ki_p, up);
+               ki->ki_args = strdup(kvm_getargs(ki->ki_p, up));
        else
                ki->ki_args = NULL;
        else
                ki->ki_args = NULL;
-       if (up != NULL) { 
+       if (up != NULL) {
                /*
                 * save important fields
                 */
                /*
                 * save important fields
                 */
@@ -1109,22 +1093,10 @@ saveuser(ki)
                usp->u_start = up->u_start;
                usp->u_ru = up->u_ru;
                usp->u_cru = up->u_cru;
                usp->u_start = up->u_start;
                usp->u_ru = up->u_ru;
                usp->u_cru = up->u_cru;
-               usp->u_cmask = up->u_cmask;
                usp->u_acflag = up->u_acflag;
        }
                usp->u_acflag = up->u_acflag;
        }
-       return;
 }
 
 }
 
-char *
-saveargs(p, up)
-       struct proc *p;
-       struct user *up;
-{
-       char *savestr();
-
-       return(savestr(kvm_getargs(p, up)));
-}
-       
 
 pscomp(k1, k2)
        struct kinfo *k1, *k2;
 
 pscomp(k1, k2)
        struct kinfo *k1, *k2;
@@ -1134,6 +1106,10 @@ pscomp(k1, k2)
 
        if (sortby == SORTCPU)
                return (getpcpu(k2) - getpcpu(k1));
 
        if (sortby == SORTCPU)
                return (getpcpu(k2) - getpcpu(k1));
+#ifdef notdef
+       if (sortby == SORTRUN)
+               return (proc_compare(k1->ki_p, k2->ki_p));
+#endif
        if (sortby == SORTMEM)
                return (VSIZE(k2) - VSIZE(k1));
        i =  k1->ki_e->e_tdev - k2->ki_e->e_tdev;
        if (sortby == SORTMEM)
                return (VSIZE(k2) - VSIZE(k1));
        i =  k1->ki_e->e_tdev - k2->ki_e->e_tdev;
@@ -1144,40 +1120,38 @@ pscomp(k1, k2)
 
 donlist()
 {
 
 donlist()
 {
+#define kread(x, v) \
+       kvm_read(psnl[x].n_value, (char *)&v, sizeof v) != sizeof(v)
+
        if (kvm_nlist(psnl) != 0)
                error("can't get namelist");
        if (kvm_nlist(psnl) != 0)
                error("can't get namelist");
-       if (kvm_read(psnl[X_FSCALE].n_value, &fscale, sizeof(int)) !=
-           sizeof (int))
+       if (kread(X_FSCALE, fscale))
                error("error reading fscale: %s", kvm_geterr());
                error("error reading fscale: %s", kvm_geterr());
-       if (kvm_read(psnl[X_ECMX].n_value, &ecmx, sizeof(int)) !=
-           sizeof (int))
+       if (kread(X_ECMX, ecmx))
                error("error reading ecmx: %s", kvm_geterr());
                error("error reading ecmx: %s", kvm_geterr());
-       if (kvm_read(psnl[X_CCPU].n_value, &ccpu, sizeof(fixpt_t)) !=
-           sizeof (fixpt_t))
+       if (kread(X_CCPU, ccpu))
                error("error reading ccpu: %s", kvm_geterr());
                error("error reading ccpu: %s", kvm_geterr());
+#undef kread
 }
 
 }
 
-char *
-savestr(cp)
-       char *cp;
+#ifdef lint
+/* VARARGS1 */
+error(fmt) char *fmt; { (void) fputs(fmt, stderr); exit(1); /* NOTREACHED */ }
+#else
+error(va_alist)
+       va_dcl
 {
 {
-       register unsigned len;
-       register char *dp;
-
-       len = strlen(cp);
-       dp = (char *)calloc(len+1, sizeof (char));
-       (void) strcpy(dp, cp);
-       return (dp);
-}
+       char *fmt;
+       va_list ap;
 
 
-error(a, b, c, d, e)
-       char *a, *b, *c, *d, *e;
-{
-       fprintf(stderr, "ps: ");
-       fprintf(stderr, a, b, c, d, e);
-       fprintf(stderr, "\n");
+       va_start(ap);
+       fmt = va_arg(ap, char *);
+       (void) fprintf(stderr, "ps: ");
+       (void) vfprintf(stderr, fmt, ap);
+       (void) fprintf(stderr, "\n");
        exit(1);
 }
        exit(1);
 }
+#endif
 
 syserror(a)
        char *a;
 
 syserror(a)
        char *a;
@@ -1202,10 +1176,10 @@ char *
 kludge_oldps_options(s)
        char *s;
 {
 kludge_oldps_options(s)
        char *s;
 {
-       int len = strlen(s), numlen = 0;
+       size_t len = strlen(s);
        char *newopts, *ns, *cp;
 
        char *newopts, *ns, *cp;
 
-       if ((newopts = ns = (char *)malloc(len+2)) == NULL)
+       if ((newopts = ns = malloc(len + 2)) == NULL)
                error("out of memory");
        /*
         * options begin with '-'
                error("out of memory");
        /*
         * options begin with '-'
@@ -1219,7 +1193,7 @@ kludge_oldps_options(s)
        /*
         * if last letter is a 't' flag with no argument (in the context
         * of the oldps options -- option string NOT starting with a '-' --
        /*
         * if last letter is a 't' flag with no argument (in the context
         * of the oldps options -- option string NOT starting with a '-' --
-        * then convert to 'T' (meaning *this* terminal, i.e. ttyname(0).
+        * then convert to 'T' (meaning *this* terminal, i.e. ttyname(0)).
         */
        if (*cp == 't' && *s != '-')
                *cp = 'T';
         */
        if (*cp == 't' && *s != '-')
                *cp = 'T';
@@ -1228,23 +1202,20 @@ kludge_oldps_options(s)
                 * otherwise check for trailing number, which *may* be a
                 * pid.
                 */
                 * otherwise check for trailing number, which *may* be a
                 * pid.
                 */
-               while (isdigit(*cp)) {
+               while (cp >= s && isdigit(*cp))
                        --cp;
                        --cp;
-                       numlen++;
-               }
        }
        cp++;
        }
        cp++;
-       bcopy(s, ns, cp - s);   /* copy everything up to trailing number */
-       while (*ns)
-               ns++;
+       bcopy(s, ns, (size_t)(cp - s)); /* copy up to trailing number */
+       ns += cp - s;
        /*
         * if there's a trailing number, and not a preceding 'p' (pid) or
         * 't' (tty) flag, then assume it's a pid and insert a 'p' flag.
         */
        /*
         * if there's a trailing number, and not a preceding 'p' (pid) or
         * 't' (tty) flag, then assume it's a pid and insert a 'p' flag.
         */
-       if (isdigit(*cp) && (cp == s || *(cp-1) != 't' && *(cp-1) != 'p' &&
-          ((cp-1) == s || *(cp-2) != 't')))
+       if (isdigit(*cp) && (cp == s || cp[-1] != 't' && cp[-1] != 'p' &&
+           (cp - 1 == s || cp[-2] != 't')))
                *ns++ = 'p';
                *ns++ = 'p';
-       strcat(ns, cp);         /* and append the number */
+       (void) strcpy(ns, cp);          /* and append the number */
 
        return (newopts);
 }
 
        return (newopts);
 }
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.