1997-03-23 18:55:20 +00:00
|
|
|
/*
|
|
|
|
* top - a top users display for Unix
|
|
|
|
*
|
1999-06-14 12:06:11 +00:00
|
|
|
* SYNOPSIS: For FreeBSD-2.x and later
|
1997-03-23 18:55:20 +00:00
|
|
|
*
|
|
|
|
* DESCRIPTION:
|
|
|
|
* Originally written for BSD4.4 system by Christos Zoulas.
|
|
|
|
* Ported to FreeBSD 2.x by Steven Wallace && Wolfram Schneider
|
1998-08-12 09:58:15 +00:00
|
|
|
* Order support hacked in from top-3.5beta6/machine/m_aix41.c
|
|
|
|
* by Monte Mitzelfelt (for latest top see http://www.groupsys.com/topinfo/)
|
1997-03-23 18:55:20 +00:00
|
|
|
*
|
|
|
|
* This is the machine-dependent module for FreeBSD 2.2
|
|
|
|
* Works for:
|
1999-06-14 12:06:11 +00:00
|
|
|
* FreeBSD 2.2.x, 3.x, 4.x, and probably FreeBSD 2.1.x
|
1997-03-23 18:55:20 +00:00
|
|
|
*
|
|
|
|
* LIBS: -lkvm
|
|
|
|
*
|
|
|
|
* AUTHOR: Christos Zoulas <christos@ee.cornell.edu>
|
|
|
|
* Steven Wallace <swallace@freebsd.org>
|
|
|
|
* Wolfram Schneider <wosch@FreeBSD.org>
|
2001-02-23 18:52:37 +00:00
|
|
|
* Thomas Moestl <tmoestl@gmx.net>
|
1997-03-23 18:55:20 +00:00
|
|
|
*
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1997-03-23 18:55:20 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/errno.h>
|
|
|
|
#include <sys/file.h>
|
|
|
|
#include <sys/proc.h>
|
1997-09-28 00:59:04 +00:00
|
|
|
#include <sys/resource.h>
|
|
|
|
#include <sys/rtprio.h>
|
2004-07-05 12:58:47 +00:00
|
|
|
#include <sys/signal.h>
|
|
|
|
#include <sys/sysctl.h>
|
|
|
|
#include <sys/time.h>
|
|
|
|
#include <sys/user.h>
|
|
|
|
#include <sys/vmmeter.h>
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2004-07-05 12:58:47 +00:00
|
|
|
#include <kvm.h>
|
|
|
|
#include <math.h>
|
|
|
|
#include <nlist.h>
|
2004-07-05 14:45:57 +00:00
|
|
|
#include <paths.h>
|
2004-07-05 12:58:47 +00:00
|
|
|
#include <pwd.h>
|
|
|
|
#include <stdio.h>
|
1997-03-23 18:55:20 +00:00
|
|
|
#include <stdlib.h>
|
2005-04-04 21:19:48 +00:00
|
|
|
#include <string.h>
|
|
|
|
#include <strings.h>
|
2001-02-23 18:52:37 +00:00
|
|
|
#include <unistd.h>
|
2007-04-14 10:16:52 +00:00
|
|
|
#include <vis.h>
|
1997-03-23 18:55:20 +00:00
|
|
|
|
|
|
|
#include "top.h"
|
|
|
|
#include "machine.h"
|
2000-11-29 23:03:02 +00:00
|
|
|
#include "screen.h"
|
2001-02-23 18:52:37 +00:00
|
|
|
#include "utils.h"
|
|
|
|
|
|
|
|
#define GETSYSCTL(name, var) getsysctl(name, &(var), sizeof(var))
|
2005-05-16 18:17:38 +00:00
|
|
|
#define SMPUNAMELEN 13
|
|
|
|
#define UPUNAMELEN 15
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2005-04-14 15:02:03 +00:00
|
|
|
extern struct process_select ps;
|
2002-03-22 01:42:45 +00:00
|
|
|
extern char* printable(char *);
|
1997-07-12 10:51:54 +00:00
|
|
|
static int smpmode;
|
2004-07-01 09:12:38 +00:00
|
|
|
enum displaymodes displaymode;
|
2005-05-16 18:17:38 +00:00
|
|
|
static int namelength = 8;
|
2000-11-29 23:03:02 +00:00
|
|
|
static int cmdlengthdelta;
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2001-02-23 18:52:37 +00:00
|
|
|
/* Prototypes for top internals */
|
2002-03-22 01:42:45 +00:00
|
|
|
void quit(int);
|
1997-03-23 18:55:20 +00:00
|
|
|
|
|
|
|
/* get_process_info passes back a handle. This is what it looks like: */
|
|
|
|
|
2006-05-04 03:00:13 +00:00
|
|
|
struct handle {
|
2004-07-05 13:12:16 +00:00
|
|
|
struct kinfo_proc **next_proc; /* points to next valid proc pointer */
|
|
|
|
int remaining; /* number of pointers remaining */
|
1997-03-23 18:55:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* declarations for load_avg */
|
|
|
|
#include "loadavg.h"
|
|
|
|
|
|
|
|
/* define what weighted cpu is. */
|
Change the proc information returned from the kernel so that it
no longer contains kernel specific data structures, but rather
only scalar values and structures that are already part of the
kernel/user interface, specifically rusage and rtprio. It no
longer contains proc, session, pcred, ucred, procsig, vmspace,
pstats, mtx, sigiolst, klist, callout, pasleep, or mdproc. If
any of these changed in size, ps, w, fstat, gcore, systat, and
top would all stop working. The new structure has over 200 bytes
of unassigned space for future values to be added, yet is nearly
100 bytes smaller per entry than the structure that it replaced.
2000-12-12 07:25:57 +00:00
|
|
|
#define weighted_cpu(pct, pp) ((pp)->ki_swtime == 0 ? 0.0 : \
|
|
|
|
((pct) / (1.0 - exp((pp)->ki_swtime * logcpu))))
|
1997-03-23 18:55:20 +00:00
|
|
|
|
|
|
|
/* what we consider to be process size: */
|
Change the proc information returned from the kernel so that it
no longer contains kernel specific data structures, but rather
only scalar values and structures that are already part of the
kernel/user interface, specifically rusage and rtprio. It no
longer contains proc, session, pcred, ucred, procsig, vmspace,
pstats, mtx, sigiolst, klist, callout, pasleep, or mdproc. If
any of these changed in size, ps, w, fstat, gcore, systat, and
top would all stop working. The new structure has over 200 bytes
of unassigned space for future values to be added, yet is nearly
100 bytes smaller per entry than the structure that it replaced.
2000-12-12 07:25:57 +00:00
|
|
|
#define PROCSIZE(pp) ((pp)->ki_size / 1024)
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2004-07-01 09:12:38 +00:00
|
|
|
#define RU(pp) (&(pp)->ki_rusage)
|
|
|
|
#define RUTOT(pp) \
|
|
|
|
(RU(pp)->ru_inblock + RU(pp)->ru_oublock + RU(pp)->ru_majflt)
|
|
|
|
|
|
|
|
|
1997-03-23 18:55:20 +00:00
|
|
|
/* definitions for indices in the nlist array */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* These definitions control the format of the per-process area
|
|
|
|
*/
|
|
|
|
|
2004-07-01 09:12:38 +00:00
|
|
|
static char io_header[] =
|
2007-04-17 03:12:39 +00:00
|
|
|
" PID%s %-*.*s VCSW IVCSW READ WRITE FAULT TOTAL PERCENT COMMAND";
|
2004-07-01 09:12:38 +00:00
|
|
|
|
|
|
|
#define io_Proc_format \
|
2007-04-17 03:12:39 +00:00
|
|
|
"%5d%s %-*.*s %6ld %6ld %6ld %6ld %6ld %6ld %6.2f%% %.*s"
|
2004-07-01 09:12:38 +00:00
|
|
|
|
2005-04-14 15:02:03 +00:00
|
|
|
static char smp_header_thr[] =
|
2007-04-17 03:12:39 +00:00
|
|
|
" PID%s %-*.*s THR PRI NICE SIZE RES STATE C TIME %6s COMMAND";
|
1997-07-12 10:51:54 +00:00
|
|
|
static char smp_header[] =
|
2007-04-17 03:12:39 +00:00
|
|
|
" PID%s %-*.*s " "PRI NICE SIZE RES STATE C TIME %6s COMMAND";
|
1997-03-23 18:55:20 +00:00
|
|
|
|
1997-07-12 10:51:54 +00:00
|
|
|
#define smp_Proc_format \
|
2007-04-17 03:12:39 +00:00
|
|
|
"%5d%s %-*.*s %s%3d %4s%7s %6s %-6.6s %1x%7s %5.2f%% %.*s"
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2005-04-14 15:02:03 +00:00
|
|
|
static char up_header_thr[] =
|
2007-04-17 03:12:39 +00:00
|
|
|
" PID%s %-*.*s THR PRI NICE SIZE RES STATE TIME %6s COMMAND";
|
1997-07-12 10:51:54 +00:00
|
|
|
static char up_header[] =
|
2007-04-17 03:12:39 +00:00
|
|
|
" PID%s %-*.*s " "PRI NICE SIZE RES STATE TIME %6s COMMAND";
|
1997-03-23 18:55:20 +00:00
|
|
|
|
1997-07-12 10:51:54 +00:00
|
|
|
#define up_Proc_format \
|
2007-04-17 03:12:39 +00:00
|
|
|
"%5d%s %-*.*s %s%3d %4s%7s %6s %-6.6s%.0d%7s %5.2f%% %.*s"
|
1997-03-23 18:55:20 +00:00
|
|
|
|
|
|
|
|
|
|
|
/* process state names for the "STATE" column of the display */
|
|
|
|
/* the extra nulls in the string "run" are for adding a slash and
|
|
|
|
the processor number when needed */
|
|
|
|
|
2006-05-04 03:00:13 +00:00
|
|
|
char *state_abbrev[] = {
|
2004-07-05 13:12:16 +00:00
|
|
|
"", "START", "RUN\0\0\0", "SLEEP", "STOP", "ZOMB", "WAIT", "LOCK"
|
1997-03-23 18:55:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static kvm_t *kd;
|
|
|
|
|
|
|
|
/* values that we stash away in _init and use in later routines */
|
|
|
|
|
|
|
|
static double logcpu;
|
|
|
|
|
|
|
|
/* these are retrieved from the kernel in _init */
|
|
|
|
|
|
|
|
static load_avg ccpu;
|
|
|
|
|
2001-02-23 18:52:37 +00:00
|
|
|
/* these are used in the get_ functions */
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2001-02-23 18:52:37 +00:00
|
|
|
static int lastpid;
|
1997-03-23 18:55:20 +00:00
|
|
|
|
|
|
|
/* these are for calculating cpu state percentages */
|
|
|
|
|
|
|
|
static long cp_time[CPUSTATES];
|
|
|
|
static long cp_old[CPUSTATES];
|
|
|
|
static long cp_diff[CPUSTATES];
|
|
|
|
|
|
|
|
/* these are for detailing the process states */
|
|
|
|
|
2000-09-07 01:33:02 +00:00
|
|
|
int process_states[8];
|
1997-03-23 18:55:20 +00:00
|
|
|
char *procstatenames[] = {
|
2004-07-05 13:12:16 +00:00
|
|
|
"", " starting, ", " running, ", " sleeping, ", " stopped, ",
|
|
|
|
" zombie, ", " waiting, ", " lock, ",
|
|
|
|
NULL
|
1997-03-23 18:55:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* these are for detailing the cpu states */
|
|
|
|
|
|
|
|
int cpu_states[CPUSTATES];
|
|
|
|
char *cpustatenames[] = {
|
2004-07-05 13:12:16 +00:00
|
|
|
"user", "nice", "system", "interrupt", "idle", NULL
|
1997-03-23 18:55:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* these are for detailing the memory statistics */
|
|
|
|
|
|
|
|
int memory_stats[7];
|
|
|
|
char *memorynames[] = {
|
2006-05-04 03:00:13 +00:00
|
|
|
"K Active, ", "K Inact, ", "K Wired, ", "K Cache, ", "K Buf, ",
|
|
|
|
"K Free", NULL
|
1997-03-23 18:55:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
int swap_stats[7];
|
|
|
|
char *swapnames[] = {
|
2004-07-05 13:12:16 +00:00
|
|
|
"K Total, ", "K Used, ", "K Free, ", "% Inuse, ", "K In, ", "K Out",
|
|
|
|
NULL
|
1997-03-23 18:55:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/* these are for keeping track of the proc array */
|
|
|
|
|
|
|
|
static int nproc;
|
|
|
|
static int onproc = -1;
|
|
|
|
static int pref_len;
|
|
|
|
static struct kinfo_proc *pbase;
|
|
|
|
static struct kinfo_proc **pref;
|
2004-07-01 09:12:38 +00:00
|
|
|
static struct kinfo_proc *previous_procs;
|
|
|
|
static struct kinfo_proc **previous_pref;
|
|
|
|
static int previous_proc_count = 0;
|
|
|
|
static int previous_proc_count_max = 0;
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2004-07-01 15:49:28 +00:00
|
|
|
/* total number of io operations */
|
|
|
|
static long total_inblock;
|
|
|
|
static long total_oublock;
|
|
|
|
static long total_majflt;
|
|
|
|
|
1997-03-23 18:55:20 +00:00
|
|
|
/* these are for getting the memory statistics */
|
|
|
|
|
|
|
|
static int pageshift; /* log base 2 of the pagesize */
|
|
|
|
|
|
|
|
/* define pagetok in terms of pageshift */
|
|
|
|
|
|
|
|
#define pagetok(size) ((size) << pageshift)
|
|
|
|
|
|
|
|
/* useful externals */
|
|
|
|
long percentages();
|
|
|
|
|
1998-08-12 09:58:15 +00:00
|
|
|
#ifdef ORDER
|
2004-07-08 16:45:55 +00:00
|
|
|
/*
|
2005-04-14 15:02:03 +00:00
|
|
|
* Sorting orders. The first element is the default.
|
2004-07-08 16:45:55 +00:00
|
|
|
*/
|
2004-08-16 07:51:22 +00:00
|
|
|
char *ordernames[] = {
|
2005-04-14 15:02:03 +00:00
|
|
|
"cpu", "size", "res", "time", "pri", "threads",
|
2007-04-17 03:12:39 +00:00
|
|
|
"total", "read", "write", "fault", "vcsw", "ivcsw",
|
|
|
|
"jid", NULL
|
2004-07-08 16:45:55 +00:00
|
|
|
};
|
1998-08-12 09:58:15 +00:00
|
|
|
#endif
|
|
|
|
|
2007-04-17 03:12:39 +00:00
|
|
|
static int compare_jid(const void *a, const void *b);
|
2006-05-04 03:56:31 +00:00
|
|
|
static int compare_pid(const void *a, const void *b);
|
|
|
|
static const char *format_nice(const struct kinfo_proc *pp);
|
|
|
|
static void getsysctl(const char *name, void *ptr, size_t len);
|
|
|
|
static int swapmode(int *retavail, int *retfree);
|
|
|
|
|
1997-03-23 18:55:20 +00:00
|
|
|
int
|
2004-07-05 13:03:35 +00:00
|
|
|
machine_init(struct statics *statics)
|
1997-03-23 18:55:20 +00:00
|
|
|
{
|
2004-07-05 13:12:16 +00:00
|
|
|
int pagesize;
|
|
|
|
size_t modelen;
|
|
|
|
struct passwd *pw;
|
|
|
|
|
|
|
|
modelen = sizeof(smpmode);
|
2006-05-04 03:00:13 +00:00
|
|
|
if ((sysctlbyname("machdep.smp_active", &smpmode, &modelen,
|
|
|
|
NULL, 0) != 0 &&
|
|
|
|
sysctlbyname("kern.smp.active", &smpmode, &modelen,
|
|
|
|
NULL, 0) != 0) ||
|
2004-07-05 13:12:16 +00:00
|
|
|
modelen != sizeof(smpmode))
|
|
|
|
smpmode = 0;
|
|
|
|
|
|
|
|
while ((pw = getpwent()) != NULL) {
|
|
|
|
if (strlen(pw->pw_name) > namelength)
|
|
|
|
namelength = strlen(pw->pw_name);
|
|
|
|
}
|
2005-05-16 18:17:38 +00:00
|
|
|
if (smpmode && namelength > SMPUNAMELEN)
|
|
|
|
namelength = SMPUNAMELEN;
|
|
|
|
else if (namelength > UPUNAMELEN)
|
|
|
|
namelength = UPUNAMELEN;
|
2004-07-05 13:12:16 +00:00
|
|
|
|
2004-07-05 14:45:57 +00:00
|
|
|
kd = kvm_open(NULL, _PATH_DEVNULL, NULL, O_RDONLY, "kvm_open");
|
|
|
|
if (kd == NULL)
|
|
|
|
return (-1);
|
2004-07-05 13:12:16 +00:00
|
|
|
|
|
|
|
GETSYSCTL("kern.ccpu", ccpu);
|
|
|
|
|
|
|
|
/* this is used in calculating WCPU -- calculate it ahead of time */
|
|
|
|
logcpu = log(loaddouble(ccpu));
|
|
|
|
|
|
|
|
pbase = NULL;
|
|
|
|
pref = NULL;
|
|
|
|
nproc = 0;
|
|
|
|
onproc = -1;
|
2006-05-04 03:00:13 +00:00
|
|
|
|
|
|
|
/* get the page size and calculate pageshift from it */
|
2004-07-05 13:12:16 +00:00
|
|
|
pagesize = getpagesize();
|
|
|
|
pageshift = 0;
|
2004-07-05 14:45:57 +00:00
|
|
|
while (pagesize > 1) {
|
2004-07-05 13:12:16 +00:00
|
|
|
pageshift++;
|
|
|
|
pagesize >>= 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* we only need the amount of log(2)1024 for our conversion */
|
|
|
|
pageshift -= LOG1024;
|
|
|
|
|
|
|
|
/* fill in the statics information */
|
|
|
|
statics->procstate_names = procstatenames;
|
|
|
|
statics->cpustate_names = cpustatenames;
|
|
|
|
statics->memory_names = memorynames;
|
|
|
|
statics->swap_names = swapnames;
|
1998-08-12 09:58:15 +00:00
|
|
|
#ifdef ORDER
|
2004-08-16 07:51:22 +00:00
|
|
|
statics->order_names = ordernames;
|
1998-08-12 09:58:15 +00:00
|
|
|
#endif
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2004-07-05 13:12:16 +00:00
|
|
|
/* all done! */
|
|
|
|
return (0);
|
1997-03-23 18:55:20 +00:00
|
|
|
}
|
|
|
|
|
2004-06-30 04:19:23 +00:00
|
|
|
char *
|
2004-07-05 13:03:35 +00:00
|
|
|
format_header(char *uname_field)
|
1997-03-23 18:55:20 +00:00
|
|
|
{
|
2004-07-05 13:12:16 +00:00
|
|
|
static char Header[128];
|
|
|
|
const char *prehead;
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2004-07-05 13:12:16 +00:00
|
|
|
switch (displaymode) {
|
|
|
|
case DISP_CPU:
|
2005-04-14 15:02:03 +00:00
|
|
|
/*
|
|
|
|
* The logic of picking the right header format seems reverse
|
|
|
|
* here because we only want to display a THR column when
|
|
|
|
* "thread mode" is off (and threads are not listed as
|
|
|
|
* separate lines).
|
|
|
|
*/
|
|
|
|
prehead = smpmode ?
|
|
|
|
(ps.thread ? smp_header : smp_header_thr) :
|
|
|
|
(ps.thread ? up_header : up_header_thr);
|
2005-05-18 13:30:08 +00:00
|
|
|
snprintf(Header, sizeof(Header), prehead,
|
2007-04-17 03:12:39 +00:00
|
|
|
ps.jail ? " JID" : "",
|
2005-05-18 13:30:08 +00:00
|
|
|
namelength, namelength, uname_field,
|
|
|
|
ps.wcpu ? "WCPU" : "CPU");
|
2004-07-05 13:12:16 +00:00
|
|
|
break;
|
|
|
|
case DISP_IO:
|
|
|
|
prehead = io_header;
|
2005-05-18 13:30:08 +00:00
|
|
|
snprintf(Header, sizeof(Header), prehead,
|
2007-04-17 03:12:39 +00:00
|
|
|
ps.jail ? " JID" : "",
|
2005-05-18 13:30:08 +00:00
|
|
|
namelength, namelength, uname_field);
|
2004-07-05 13:12:16 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
cmdlengthdelta = strlen(Header) - 7;
|
|
|
|
return (Header);
|
1997-03-23 18:55:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int swappgsin = -1;
|
|
|
|
static int swappgsout = -1;
|
|
|
|
extern struct timeval timeout;
|
|
|
|
|
|
|
|
void
|
2004-07-05 13:03:35 +00:00
|
|
|
get_system_info(struct system_info *si)
|
1997-03-23 18:55:20 +00:00
|
|
|
{
|
2004-07-05 13:12:16 +00:00
|
|
|
long total;
|
|
|
|
struct loadavg sysload;
|
|
|
|
int mib[2];
|
|
|
|
struct timeval boottime;
|
|
|
|
size_t bt_size;
|
2004-07-05 14:45:57 +00:00
|
|
|
int i;
|
2004-07-05 13:12:16 +00:00
|
|
|
|
|
|
|
/* get the cp_time array */
|
|
|
|
GETSYSCTL("kern.cp_time", cp_time);
|
|
|
|
GETSYSCTL("vm.loadavg", sysload);
|
|
|
|
GETSYSCTL("kern.lastpid", lastpid);
|
|
|
|
|
|
|
|
/* convert load averages to doubles */
|
2004-07-05 14:45:57 +00:00
|
|
|
for (i = 0; i < 3; i++)
|
|
|
|
si->load_avg[i] = (double)sysload.ldavg[i] / sysload.fscale;
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2004-07-05 13:12:16 +00:00
|
|
|
/* convert cp_time counts to percentages */
|
|
|
|
total = percentages(CPUSTATES, cpu_states, cp_time, cp_old, cp_diff);
|
|
|
|
|
|
|
|
/* sum memory & swap statistics */
|
|
|
|
{
|
|
|
|
static unsigned int swap_delay = 0;
|
|
|
|
static int swapavail = 0;
|
|
|
|
static int swapfree = 0;
|
|
|
|
static int bufspace = 0;
|
|
|
|
static int nspgsin, nspgsout;
|
|
|
|
|
|
|
|
GETSYSCTL("vfs.bufspace", bufspace);
|
|
|
|
GETSYSCTL("vm.stats.vm.v_active_count", memory_stats[0]);
|
|
|
|
GETSYSCTL("vm.stats.vm.v_inactive_count", memory_stats[1]);
|
|
|
|
GETSYSCTL("vm.stats.vm.v_wire_count", memory_stats[2]);
|
|
|
|
GETSYSCTL("vm.stats.vm.v_cache_count", memory_stats[3]);
|
|
|
|
GETSYSCTL("vm.stats.vm.v_free_count", memory_stats[5]);
|
|
|
|
GETSYSCTL("vm.stats.vm.v_swappgsin", nspgsin);
|
|
|
|
GETSYSCTL("vm.stats.vm.v_swappgsout", nspgsout);
|
|
|
|
/* convert memory stats to Kbytes */
|
|
|
|
memory_stats[0] = pagetok(memory_stats[0]);
|
|
|
|
memory_stats[1] = pagetok(memory_stats[1]);
|
|
|
|
memory_stats[2] = pagetok(memory_stats[2]);
|
|
|
|
memory_stats[3] = pagetok(memory_stats[3]);
|
|
|
|
memory_stats[4] = bufspace / 1024;
|
|
|
|
memory_stats[5] = pagetok(memory_stats[5]);
|
|
|
|
memory_stats[6] = -1;
|
|
|
|
|
|
|
|
/* first interval */
|
|
|
|
if (swappgsin < 0) {
|
|
|
|
swap_stats[4] = 0;
|
|
|
|
swap_stats[5] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* compute differences between old and new swap statistic */
|
|
|
|
else {
|
|
|
|
swap_stats[4] = pagetok(((nspgsin - swappgsin)));
|
|
|
|
swap_stats[5] = pagetok(((nspgsout - swappgsout)));
|
|
|
|
}
|
|
|
|
|
|
|
|
swappgsin = nspgsin;
|
|
|
|
swappgsout = nspgsout;
|
|
|
|
|
|
|
|
/* call CPU heavy swapmode() only for changes */
|
|
|
|
if (swap_stats[4] > 0 || swap_stats[5] > 0 || swap_delay == 0) {
|
|
|
|
swap_stats[3] = swapmode(&swapavail, &swapfree);
|
|
|
|
swap_stats[0] = swapavail;
|
|
|
|
swap_stats[1] = swapavail - swapfree;
|
|
|
|
swap_stats[2] = swapfree;
|
|
|
|
}
|
|
|
|
swap_delay = 1;
|
|
|
|
swap_stats[6] = -1;
|
1997-03-23 18:55:20 +00:00
|
|
|
}
|
|
|
|
|
2004-07-05 13:12:16 +00:00
|
|
|
/* set arrays and strings */
|
|
|
|
si->cpustates = cpu_states;
|
|
|
|
si->memory = memory_stats;
|
|
|
|
si->swap = swap_stats;
|
|
|
|
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2004-07-05 13:12:16 +00:00
|
|
|
if (lastpid > 0) {
|
|
|
|
si->last_pid = lastpid;
|
|
|
|
} else {
|
|
|
|
si->last_pid = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Print how long system has been up.
|
|
|
|
* (Found by looking getting "boottime" from the kernel)
|
|
|
|
*/
|
|
|
|
mib[0] = CTL_KERN;
|
|
|
|
mib[1] = KERN_BOOTTIME;
|
|
|
|
bt_size = sizeof(boottime);
|
|
|
|
if (sysctl(mib, 2, &boottime, &bt_size, NULL, 0) != -1 &&
|
|
|
|
boottime.tv_sec != 0) {
|
|
|
|
si->boottime = boottime;
|
|
|
|
} else {
|
|
|
|
si->boottime.tv_sec = -1;
|
1997-03-23 18:55:20 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-07-12 04:55:07 +00:00
|
|
|
#define NOPROC ((void *)-1)
|
|
|
|
|
2004-08-01 09:19:41 +00:00
|
|
|
/*
|
|
|
|
* We need to compare data from the old process entry with the new
|
|
|
|
* process entry.
|
|
|
|
* To facilitate doing this quickly we stash a pointer in the kinfo_proc
|
|
|
|
* structure to cache the mapping. We also use a negative cache pointer
|
|
|
|
* of NOPROC to avoid duplicate lookups.
|
|
|
|
* XXX: this could be done when the actual processes are fetched, we do
|
|
|
|
* it here out of laziness.
|
|
|
|
*/
|
2004-07-01 09:12:38 +00:00
|
|
|
const struct kinfo_proc *
|
|
|
|
get_old_proc(struct kinfo_proc *pp)
|
|
|
|
{
|
|
|
|
struct kinfo_proc **oldpp, *oldp;
|
|
|
|
|
2004-08-01 09:19:41 +00:00
|
|
|
/*
|
|
|
|
* If this is the first fetch of the kinfo_procs then we don't have
|
|
|
|
* any previous entries.
|
|
|
|
*/
|
2004-07-01 09:12:38 +00:00
|
|
|
if (previous_proc_count == 0)
|
|
|
|
return (NULL);
|
2004-08-01 09:19:41 +00:00
|
|
|
/* negative cache? */
|
2004-07-12 04:55:07 +00:00
|
|
|
if (pp->ki_udata == NOPROC)
|
|
|
|
return (NULL);
|
2004-08-01 09:19:41 +00:00
|
|
|
/* cached? */
|
2004-07-12 04:55:07 +00:00
|
|
|
if (pp->ki_udata != NULL)
|
|
|
|
return (pp->ki_udata);
|
2004-08-01 09:19:41 +00:00
|
|
|
/*
|
|
|
|
* Not cached,
|
|
|
|
* 1) look up based on pid.
|
|
|
|
* 2) compare process start.
|
|
|
|
* If we fail here, then setup a negative cache entry, otherwise
|
|
|
|
* cache it.
|
|
|
|
*/
|
2004-07-01 09:12:38 +00:00
|
|
|
oldpp = bsearch(&pp, previous_pref, previous_proc_count,
|
2004-07-05 14:45:57 +00:00
|
|
|
sizeof(*previous_pref), compare_pid);
|
2004-07-12 04:55:07 +00:00
|
|
|
if (oldpp == NULL) {
|
|
|
|
pp->ki_udata = NOPROC;
|
2004-07-01 09:12:38 +00:00
|
|
|
return (NULL);
|
2004-07-12 04:55:07 +00:00
|
|
|
}
|
2004-07-01 09:12:38 +00:00
|
|
|
oldp = *oldpp;
|
2004-07-12 04:55:07 +00:00
|
|
|
if (bcmp(&oldp->ki_start, &pp->ki_start, sizeof(pp->ki_start)) != 0) {
|
|
|
|
pp->ki_udata = NOPROC;
|
2004-07-01 09:12:38 +00:00
|
|
|
return (NULL);
|
2004-07-12 04:55:07 +00:00
|
|
|
}
|
|
|
|
pp->ki_udata = oldp;
|
2004-07-01 09:12:38 +00:00
|
|
|
return (oldp);
|
|
|
|
}
|
|
|
|
|
2004-08-01 09:19:41 +00:00
|
|
|
/*
|
|
|
|
* Return the total amount of IO done in blocks in/out and faults.
|
|
|
|
* store the values individually in the pointers passed in.
|
|
|
|
*/
|
2004-07-01 09:12:38 +00:00
|
|
|
long
|
2006-05-04 03:00:13 +00:00
|
|
|
get_io_stats(struct kinfo_proc *pp, long *inp, long *oup, long *flp,
|
|
|
|
long *vcsw, long *ivcsw)
|
2004-07-01 09:12:38 +00:00
|
|
|
{
|
|
|
|
const struct kinfo_proc *oldp;
|
|
|
|
static struct kinfo_proc dummy;
|
|
|
|
long ret;
|
|
|
|
|
|
|
|
oldp = get_old_proc(pp);
|
|
|
|
if (oldp == NULL) {
|
|
|
|
bzero(&dummy, sizeof(dummy));
|
|
|
|
oldp = &dummy;
|
|
|
|
}
|
2004-07-01 15:49:28 +00:00
|
|
|
*inp = RU(pp)->ru_inblock - RU(oldp)->ru_inblock;
|
|
|
|
*oup = RU(pp)->ru_oublock - RU(oldp)->ru_oublock;
|
|
|
|
*flp = RU(pp)->ru_majflt - RU(oldp)->ru_majflt;
|
2004-08-16 07:51:22 +00:00
|
|
|
*vcsw = RU(pp)->ru_nvcsw - RU(oldp)->ru_nvcsw;
|
|
|
|
*ivcsw = RU(pp)->ru_nivcsw - RU(oldp)->ru_nivcsw;
|
2004-07-01 09:12:38 +00:00
|
|
|
ret =
|
|
|
|
(RU(pp)->ru_inblock - RU(oldp)->ru_inblock) +
|
|
|
|
(RU(pp)->ru_oublock - RU(oldp)->ru_oublock) +
|
|
|
|
(RU(pp)->ru_majflt - RU(oldp)->ru_majflt);
|
|
|
|
return (ret);
|
|
|
|
}
|
|
|
|
|
2004-08-01 09:19:41 +00:00
|
|
|
/*
|
|
|
|
* Return the total number of block in/out and faults by a process.
|
|
|
|
*/
|
2004-07-01 15:49:28 +00:00
|
|
|
long
|
|
|
|
get_io_total(struct kinfo_proc *pp)
|
|
|
|
{
|
|
|
|
long dummy;
|
|
|
|
|
2004-08-16 07:51:22 +00:00
|
|
|
return (get_io_stats(pp, &dummy, &dummy, &dummy, &dummy, &dummy));
|
2004-07-01 15:49:28 +00:00
|
|
|
}
|
|
|
|
|
1997-03-23 18:55:20 +00:00
|
|
|
static struct handle handle;
|
|
|
|
|
2004-06-30 04:19:23 +00:00
|
|
|
caddr_t
|
2004-07-05 13:03:35 +00:00
|
|
|
get_process_info(struct system_info *si, struct process_select *sel,
|
2004-07-05 14:45:57 +00:00
|
|
|
int (*compare)(const void *, const void *))
|
1997-03-23 18:55:20 +00:00
|
|
|
{
|
2004-07-05 13:12:16 +00:00
|
|
|
int i;
|
|
|
|
int total_procs;
|
|
|
|
long p_io;
|
2004-08-16 07:51:22 +00:00
|
|
|
long p_inblock, p_oublock, p_majflt, p_vcsw, p_ivcsw;
|
2004-07-05 13:12:16 +00:00
|
|
|
int active_procs;
|
|
|
|
struct kinfo_proc **prefp;
|
|
|
|
struct kinfo_proc *pp;
|
|
|
|
struct kinfo_proc *prev_pp = NULL;
|
|
|
|
|
|
|
|
/* these are copied out of sel for speed */
|
|
|
|
int show_idle;
|
|
|
|
int show_self;
|
|
|
|
int show_system;
|
|
|
|
int show_uid;
|
|
|
|
int show_command;
|
2004-07-05 12:48:17 +00:00
|
|
|
|
|
|
|
/*
|
2004-07-05 13:12:16 +00:00
|
|
|
* Save the previous process info.
|
2004-07-05 12:48:17 +00:00
|
|
|
*/
|
2004-07-05 13:12:16 +00:00
|
|
|
if (previous_proc_count_max < nproc) {
|
|
|
|
free(previous_procs);
|
2004-07-05 14:45:57 +00:00
|
|
|
previous_procs = malloc(nproc * sizeof(*previous_procs));
|
2004-07-05 13:12:16 +00:00
|
|
|
free(previous_pref);
|
2004-07-05 14:45:57 +00:00
|
|
|
previous_pref = malloc(nproc * sizeof(*previous_pref));
|
2004-07-05 13:12:16 +00:00
|
|
|
if (previous_procs == NULL || previous_pref == NULL) {
|
|
|
|
(void) fprintf(stderr, "top: Out of memory.\n");
|
|
|
|
quit(23);
|
|
|
|
}
|
|
|
|
previous_proc_count_max = nproc;
|
|
|
|
}
|
|
|
|
if (nproc) {
|
|
|
|
for (i = 0; i < nproc; i++)
|
|
|
|
previous_pref[i] = &previous_procs[i];
|
2004-07-05 14:45:57 +00:00
|
|
|
bcopy(pbase, previous_procs, nproc * sizeof(*previous_procs));
|
2006-05-04 03:00:13 +00:00
|
|
|
qsort(previous_pref, nproc, sizeof(*previous_pref),
|
|
|
|
compare_pid);
|
2004-07-05 13:12:16 +00:00
|
|
|
}
|
|
|
|
previous_proc_count = nproc;
|
|
|
|
|
|
|
|
pbase = kvm_getprocs(kd, KERN_PROC_ALL, 0, &nproc);
|
|
|
|
if (nproc > onproc)
|
2004-07-05 14:45:57 +00:00
|
|
|
pref = realloc(pref, sizeof(*pref) * (onproc = nproc));
|
2004-07-05 13:12:16 +00:00
|
|
|
if (pref == NULL || pbase == NULL) {
|
|
|
|
(void) fprintf(stderr, "top: Out of memory.\n");
|
|
|
|
quit(23);
|
|
|
|
}
|
|
|
|
/* get a pointer to the states summary array */
|
|
|
|
si->procstates = process_states;
|
|
|
|
|
|
|
|
/* set up flags which define what we are going to select */
|
|
|
|
show_idle = sel->idle;
|
2004-07-12 08:22:32 +00:00
|
|
|
show_self = sel->self == -1;
|
2004-07-05 13:12:16 +00:00
|
|
|
show_system = sel->system;
|
|
|
|
show_uid = sel->uid != -1;
|
|
|
|
show_command = sel->command != NULL;
|
|
|
|
|
|
|
|
/* count up process states and get pointers to interesting procs */
|
|
|
|
total_procs = 0;
|
|
|
|
active_procs = 0;
|
|
|
|
total_inblock = 0;
|
|
|
|
total_oublock = 0;
|
|
|
|
total_majflt = 0;
|
|
|
|
memset((char *)process_states, 0, sizeof(process_states));
|
|
|
|
prefp = pref;
|
2004-07-05 14:45:57 +00:00
|
|
|
for (pp = pbase, i = 0; i < nproc; pp++, i++) {
|
2004-07-05 13:12:16 +00:00
|
|
|
|
|
|
|
if (pp->ki_stat == 0)
|
2004-07-12 08:22:32 +00:00
|
|
|
/* not in use */
|
|
|
|
continue;
|
2004-07-05 13:12:16 +00:00
|
|
|
|
|
|
|
if (!show_self && pp->ki_pid == sel->self)
|
|
|
|
/* skip self */
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!show_system && (pp->ki_flag & P_SYSTEM))
|
|
|
|
/* skip system process */
|
|
|
|
continue;
|
|
|
|
|
2006-05-04 03:00:13 +00:00
|
|
|
p_io = get_io_stats(pp, &p_inblock, &p_oublock, &p_majflt,
|
|
|
|
&p_vcsw, &p_ivcsw);
|
2004-07-05 13:12:16 +00:00
|
|
|
total_inblock += p_inblock;
|
|
|
|
total_oublock += p_oublock;
|
|
|
|
total_majflt += p_majflt;
|
|
|
|
total_procs++;
|
2004-07-05 14:45:57 +00:00
|
|
|
process_states[pp->ki_stat]++;
|
2004-07-05 13:12:16 +00:00
|
|
|
|
|
|
|
if (pp->ki_stat == SZOMB)
|
|
|
|
/* skip zombies */
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (displaymode == DISP_CPU && !show_idle &&
|
2006-06-11 19:18:39 +00:00
|
|
|
(pp->ki_pctcpu == 0 ||
|
|
|
|
pp->ki_stat == SSTOP || pp->ki_stat == SIDL))
|
2004-07-05 13:12:16 +00:00
|
|
|
/* skip idle or non-running processes */
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (displaymode == DISP_IO && !show_idle && p_io == 0)
|
|
|
|
/* skip processes that aren't doing I/O */
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (show_uid && pp->ki_ruid != (uid_t)sel->uid)
|
2006-05-04 03:00:13 +00:00
|
|
|
/* skip proc. that don't belong to the selected UID */
|
2004-07-05 13:12:16 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When not showing threads, take the first thread
|
|
|
|
* for output and add the fields that we can from
|
|
|
|
* the rest of the process's threads rather than
|
|
|
|
* using the system's mostly-broken KERN_PROC_PROC.
|
|
|
|
*/
|
2004-07-05 14:45:57 +00:00
|
|
|
if (sel->thread || prev_pp == NULL ||
|
|
|
|
prev_pp->ki_pid != pp->ki_pid) {
|
2004-07-05 13:12:16 +00:00
|
|
|
*prefp++ = pp;
|
|
|
|
active_procs++;
|
|
|
|
prev_pp = pp;
|
|
|
|
} else {
|
|
|
|
prev_pp->ki_pctcpu += pp->ki_pctcpu;
|
|
|
|
}
|
1997-03-23 18:55:20 +00:00
|
|
|
}
|
2004-07-05 13:12:16 +00:00
|
|
|
|
|
|
|
/* if requested, sort the "interesting" processes */
|
|
|
|
if (compare != NULL)
|
2004-07-05 14:45:57 +00:00
|
|
|
qsort(pref, active_procs, sizeof(*pref), compare);
|
2004-07-05 13:12:16 +00:00
|
|
|
|
|
|
|
/* remember active and total counts */
|
|
|
|
si->p_total = total_procs;
|
|
|
|
si->p_active = pref_len = active_procs;
|
|
|
|
|
|
|
|
/* pass back a handle */
|
|
|
|
handle.next_proc = pref;
|
|
|
|
handle.remaining = active_procs;
|
|
|
|
return ((caddr_t)&handle);
|
1997-03-23 18:55:20 +00:00
|
|
|
}
|
|
|
|
|
2004-07-05 14:45:57 +00:00
|
|
|
static char fmt[128]; /* static area where result is built */
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2004-06-30 04:19:23 +00:00
|
|
|
char *
|
2007-04-14 10:16:52 +00:00
|
|
|
format_next_process(caddr_t handle, char *(*get_userid)(int), int flags)
|
1997-03-23 18:55:20 +00:00
|
|
|
{
|
2004-07-05 13:12:16 +00:00
|
|
|
struct kinfo_proc *pp;
|
|
|
|
const struct kinfo_proc *oldp;
|
|
|
|
long cputime;
|
|
|
|
double pct;
|
|
|
|
struct handle *hp;
|
|
|
|
char status[16];
|
|
|
|
int state;
|
|
|
|
struct rusage ru, *rup;
|
|
|
|
long p_tot, s_tot;
|
2007-04-17 03:12:39 +00:00
|
|
|
char *proc_fmt, thr_buf[6], jid_buf[6];
|
2007-04-14 10:16:52 +00:00
|
|
|
char *cmdbuf = NULL;
|
|
|
|
char **args;
|
2004-07-05 13:12:16 +00:00
|
|
|
|
|
|
|
/* find and remember the next proc structure */
|
|
|
|
hp = (struct handle *)handle;
|
|
|
|
pp = *(hp->next_proc++);
|
|
|
|
hp->remaining--;
|
|
|
|
|
|
|
|
/* get the process's command name */
|
|
|
|
if ((pp->ki_sflag & PS_INMEM) == 0) {
|
|
|
|
/*
|
|
|
|
* Print swapped processes as <pname>
|
|
|
|
*/
|
2006-05-04 03:00:13 +00:00
|
|
|
size_t len;
|
|
|
|
|
|
|
|
len = strlen(pp->ki_comm);
|
2004-07-05 14:45:57 +00:00
|
|
|
if (len > sizeof(pp->ki_comm) - 3)
|
|
|
|
len = sizeof(pp->ki_comm) - 3;
|
|
|
|
memmove(pp->ki_comm + 1, pp->ki_comm, len);
|
|
|
|
pp->ki_comm[0] = '<';
|
|
|
|
pp->ki_comm[len + 1] = '>';
|
|
|
|
pp->ki_comm[len + 2] = '\0';
|
2004-07-05 13:12:16 +00:00
|
|
|
}
|
|
|
|
|
1997-03-23 18:55:20 +00:00
|
|
|
/*
|
2004-07-05 13:12:16 +00:00
|
|
|
* Convert the process's runtime from microseconds to seconds. This
|
|
|
|
* time includes the interrupt time although that is not wanted here.
|
|
|
|
* ps(1) is similarly sloppy.
|
1997-03-23 18:55:20 +00:00
|
|
|
*/
|
2004-07-05 13:12:16 +00:00
|
|
|
cputime = (pp->ki_runtime + 500000) / 1000000;
|
|
|
|
|
|
|
|
/* calculate the base for cpu percentages */
|
|
|
|
pct = pctdouble(pp->ki_pctcpu);
|
|
|
|
|
|
|
|
/* generate "STATE" field */
|
|
|
|
switch (state = pp->ki_stat) {
|
1997-03-23 18:55:20 +00:00
|
|
|
case SRUN:
|
2004-07-05 13:12:16 +00:00
|
|
|
if (smpmode && pp->ki_oncpu != 0xff)
|
|
|
|
sprintf(status, "CPU%d", pp->ki_oncpu);
|
|
|
|
else
|
|
|
|
strcpy(status, "RUN");
|
2004-07-05 12:51:35 +00:00
|
|
|
break;
|
2004-07-05 13:12:16 +00:00
|
|
|
case SLOCK:
|
|
|
|
if (pp->ki_kiflag & KI_LOCKBLOCK) {
|
|
|
|
sprintf(status, "*%.6s", pp->ki_lockname);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* fall through */
|
1997-03-23 18:55:20 +00:00
|
|
|
case SSLEEP:
|
2004-07-05 13:12:16 +00:00
|
|
|
if (pp->ki_wmesg != NULL) {
|
|
|
|
sprintf(status, "%.6s", pp->ki_wmesg);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* FALLTHROUGH */
|
1997-03-23 18:55:20 +00:00
|
|
|
default:
|
1999-02-06 16:58:50 +00:00
|
|
|
|
2004-07-05 13:12:16 +00:00
|
|
|
if (state >= 0 &&
|
|
|
|
state < sizeof(state_abbrev) / sizeof(*state_abbrev))
|
2004-07-05 14:45:57 +00:00
|
|
|
sprintf(status, "%.6s", state_abbrev[state]);
|
2004-07-05 13:12:16 +00:00
|
|
|
else
|
|
|
|
sprintf(status, "?%5d", state);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2007-04-14 10:16:52 +00:00
|
|
|
cmdbuf = (char *)malloc(cmdlengthdelta + 1);
|
|
|
|
if (cmdbuf == NULL) {
|
|
|
|
warn("malloc(%d)", cmdlengthdelta + 1);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(flags & FMT_SHOWARGS)) {
|
|
|
|
snprintf(cmdbuf, cmdlengthdelta, "%s", pp->ki_comm);
|
|
|
|
}
|
|
|
|
else if (pp->ki_args == NULL ||
|
|
|
|
(args = kvm_getargv(kd, pp, cmdlengthdelta)) == NULL || !(*args))
|
|
|
|
snprintf(cmdbuf, cmdlengthdelta, "[%s]", pp->ki_comm);
|
|
|
|
else {
|
|
|
|
char *src, *dst, *argbuf;
|
|
|
|
char *cmd;
|
|
|
|
size_t argbuflen;
|
|
|
|
size_t len;
|
|
|
|
|
|
|
|
argbuflen = cmdlengthdelta * 4;
|
|
|
|
argbuf = (char *)malloc(argbuflen + 1);
|
|
|
|
if (argbuf == NULL) {
|
|
|
|
warn("malloc(%d)", argbuflen + 1);
|
|
|
|
free(cmdbuf);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
dst = argbuf;
|
|
|
|
|
|
|
|
/* Extract cmd name from argv */
|
|
|
|
cmd = strrchr(*args, '/');
|
|
|
|
if (cmd == NULL)
|
|
|
|
cmd = *args;
|
|
|
|
else
|
|
|
|
cmd++;
|
|
|
|
|
|
|
|
for (; (src = *args++) != NULL; ) {
|
|
|
|
if (*src == '\0')
|
|
|
|
continue;
|
|
|
|
len = (argbuflen - (dst - argbuf) - 1) / 4;
|
|
|
|
strvisx(dst, src, strlen(src) < len ? strlen(src) : len,
|
|
|
|
VIS_NL | VIS_CSTYLE);
|
|
|
|
while (*dst != '\0')
|
|
|
|
dst++;
|
|
|
|
if ((argbuflen - (dst - argbuf) - 1) / 4 > 0)
|
|
|
|
*dst++ = ' '; /* add delimiting space */
|
|
|
|
}
|
|
|
|
if (dst != argbuf && dst[-1] == ' ')
|
|
|
|
dst--;
|
|
|
|
*dst = '\0';
|
|
|
|
|
|
|
|
if (strcmp(cmd, pp->ki_comm) != 0 )
|
|
|
|
snprintf(cmdbuf, cmdlengthdelta, "%s (%s)",argbuf, \
|
|
|
|
pp->ki_comm);
|
|
|
|
else
|
|
|
|
strlcpy(cmdbuf, argbuf, cmdlengthdelta);
|
|
|
|
|
|
|
|
free(argbuf);
|
|
|
|
}
|
|
|
|
|
2007-04-17 03:12:39 +00:00
|
|
|
if (ps.jail == 0)
|
|
|
|
jid_buf[0] = '\0';
|
|
|
|
else
|
|
|
|
snprintf(jid_buf, sizeof(jid_buf), " %*d",
|
|
|
|
sizeof(jid_buf) - 3, pp->ki_jid);
|
|
|
|
|
2004-07-05 13:12:16 +00:00
|
|
|
if (displaymode == DISP_IO) {
|
|
|
|
oldp = get_old_proc(pp);
|
|
|
|
if (oldp != NULL) {
|
2006-05-04 03:00:13 +00:00
|
|
|
ru.ru_inblock = RU(pp)->ru_inblock -
|
|
|
|
RU(oldp)->ru_inblock;
|
|
|
|
ru.ru_oublock = RU(pp)->ru_oublock -
|
|
|
|
RU(oldp)->ru_oublock;
|
2004-07-05 13:12:16 +00:00
|
|
|
ru.ru_majflt = RU(pp)->ru_majflt - RU(oldp)->ru_majflt;
|
2004-08-16 07:51:22 +00:00
|
|
|
ru.ru_nvcsw = RU(pp)->ru_nvcsw - RU(oldp)->ru_nvcsw;
|
|
|
|
ru.ru_nivcsw = RU(pp)->ru_nivcsw - RU(oldp)->ru_nivcsw;
|
2004-07-05 13:12:16 +00:00
|
|
|
rup = &ru;
|
|
|
|
} else {
|
|
|
|
rup = RU(pp);
|
|
|
|
}
|
|
|
|
p_tot = rup->ru_inblock + rup->ru_oublock + rup->ru_majflt;
|
|
|
|
s_tot = total_inblock + total_oublock + total_majflt;
|
|
|
|
|
|
|
|
sprintf(fmt, io_Proc_format,
|
|
|
|
pp->ki_pid,
|
2007-04-17 03:12:39 +00:00
|
|
|
jid_buf,
|
2006-05-04 03:00:13 +00:00
|
|
|
namelength, namelength, (*get_userid)(pp->ki_ruid),
|
2004-08-16 07:51:22 +00:00
|
|
|
rup->ru_nvcsw,
|
|
|
|
rup->ru_nivcsw,
|
2004-07-05 14:45:57 +00:00
|
|
|
rup->ru_inblock,
|
|
|
|
rup->ru_oublock,
|
|
|
|
rup->ru_majflt,
|
|
|
|
p_tot,
|
|
|
|
s_tot == 0 ? 0.0 : (p_tot * 100.0 / s_tot),
|
2004-07-05 13:12:16 +00:00
|
|
|
screen_width > cmdlengthdelta ?
|
|
|
|
screen_width - cmdlengthdelta : 0,
|
2007-04-14 10:16:52 +00:00
|
|
|
printable(cmdbuf));
|
|
|
|
|
|
|
|
free(cmdbuf);
|
|
|
|
|
2004-07-05 13:12:16 +00:00
|
|
|
return (fmt);
|
|
|
|
}
|
2005-04-14 15:02:03 +00:00
|
|
|
|
2004-07-05 13:12:16 +00:00
|
|
|
/* format this entry */
|
2005-04-14 15:02:03 +00:00
|
|
|
proc_fmt = smpmode ? smp_Proc_format : up_Proc_format;
|
|
|
|
if (ps.thread != 0)
|
|
|
|
thr_buf[0] = '\0';
|
|
|
|
else
|
|
|
|
snprintf(thr_buf, sizeof(thr_buf), "%*d ",
|
|
|
|
sizeof(thr_buf) - 2, pp->ki_numthreads);
|
|
|
|
|
|
|
|
sprintf(fmt, proc_fmt,
|
Change the proc information returned from the kernel so that it
no longer contains kernel specific data structures, but rather
only scalar values and structures that are already part of the
kernel/user interface, specifically rusage and rtprio. It no
longer contains proc, session, pcred, ucred, procsig, vmspace,
pstats, mtx, sigiolst, klist, callout, pasleep, or mdproc. If
any of these changed in size, ps, w, fstat, gcore, systat, and
top would all stop working. The new structure has over 200 bytes
of unassigned space for future values to be added, yet is nearly
100 bytes smaller per entry than the structure that it replaced.
2000-12-12 07:25:57 +00:00
|
|
|
pp->ki_pid,
|
2007-04-17 03:12:39 +00:00
|
|
|
jid_buf,
|
2006-05-04 03:00:13 +00:00
|
|
|
namelength, namelength, (*get_userid)(pp->ki_ruid),
|
2005-04-14 15:02:03 +00:00
|
|
|
thr_buf,
|
2001-02-12 00:21:38 +00:00
|
|
|
pp->ki_pri.pri_level - PZERO,
|
2006-05-04 03:56:31 +00:00
|
|
|
format_nice(pp),
|
1998-06-21 18:00:34 +00:00
|
|
|
format_k2(PROCSIZE(pp)),
|
Change the proc information returned from the kernel so that it
no longer contains kernel specific data structures, but rather
only scalar values and structures that are already part of the
kernel/user interface, specifically rusage and rtprio. It no
longer contains proc, session, pcred, ucred, procsig, vmspace,
pstats, mtx, sigiolst, klist, callout, pasleep, or mdproc. If
any of these changed in size, ps, w, fstat, gcore, systat, and
top would all stop working. The new structure has over 200 bytes
of unassigned space for future values to be added, yet is nearly
100 bytes smaller per entry than the structure that it replaced.
2000-12-12 07:25:57 +00:00
|
|
|
format_k2(pagetok(pp->ki_rssize)),
|
1997-03-23 18:55:20 +00:00
|
|
|
status,
|
Change the proc information returned from the kernel so that it
no longer contains kernel specific data structures, but rather
only scalar values and structures that are already part of the
kernel/user interface, specifically rusage and rtprio. It no
longer contains proc, session, pcred, ucred, procsig, vmspace,
pstats, mtx, sigiolst, klist, callout, pasleep, or mdproc. If
any of these changed in size, ps, w, fstat, gcore, systat, and
top would all stop working. The new structure has over 200 bytes
of unassigned space for future values to be added, yet is nearly
100 bytes smaller per entry than the structure that it replaced.
2000-12-12 07:25:57 +00:00
|
|
|
smpmode ? pp->ki_lastcpu : 0,
|
1997-03-23 18:55:20 +00:00
|
|
|
format_time(cputime),
|
2005-05-18 13:30:08 +00:00
|
|
|
ps.wcpu ? 100.0 * weighted_cpu(pct, pp) : 100.0 * pct,
|
2006-05-04 03:00:13 +00:00
|
|
|
screen_width > cmdlengthdelta ? screen_width - cmdlengthdelta : 0,
|
2007-04-14 10:16:52 +00:00
|
|
|
printable(cmdbuf));
|
|
|
|
|
|
|
|
free(cmdbuf);
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2004-07-05 13:12:16 +00:00
|
|
|
/* return the result */
|
|
|
|
return (fmt);
|
1997-03-23 18:55:20 +00:00
|
|
|
}
|
|
|
|
|
2004-06-30 04:19:23 +00:00
|
|
|
static void
|
2006-05-04 03:56:31 +00:00
|
|
|
getsysctl(const char *name, void *ptr, size_t len)
|
1997-03-23 18:55:20 +00:00
|
|
|
{
|
2004-07-05 13:12:16 +00:00
|
|
|
size_t nlen = len;
|
|
|
|
|
|
|
|
if (sysctlbyname(name, ptr, &nlen, NULL, 0) == -1) {
|
|
|
|
fprintf(stderr, "top: sysctl(%s...) failed: %s\n", name,
|
|
|
|
strerror(errno));
|
|
|
|
quit(23);
|
|
|
|
}
|
|
|
|
if (nlen != len) {
|
2006-05-04 03:00:13 +00:00
|
|
|
fprintf(stderr, "top: sysctl(%s...) expected %lu, got %lu\n",
|
|
|
|
name, (unsigned long)len, (unsigned long)nlen);
|
2004-07-05 13:12:16 +00:00
|
|
|
quit(23);
|
|
|
|
}
|
1997-03-23 18:55:20 +00:00
|
|
|
}
|
2001-02-23 18:52:37 +00:00
|
|
|
|
2006-11-07 10:03:10 +00:00
|
|
|
static const char *
|
|
|
|
format_nice(const struct kinfo_proc *pp)
|
2006-05-04 03:56:31 +00:00
|
|
|
{
|
2006-11-07 10:03:10 +00:00
|
|
|
const char *fifo, *kthread;
|
|
|
|
int rtpri;
|
|
|
|
static char nicebuf[4 + 1];
|
|
|
|
|
|
|
|
fifo = PRI_NEED_RR(pp->ki_pri.pri_class) ? "" : "F";
|
|
|
|
kthread = (pp->ki_flag & P_KTHREAD) ? "k" : "";
|
|
|
|
switch (PRI_BASE(pp->ki_pri.pri_class)) {
|
|
|
|
case PRI_ITHD:
|
|
|
|
return ("-");
|
|
|
|
case PRI_REALTIME:
|
2007-06-15 12:03:07 +00:00
|
|
|
/*
|
|
|
|
* XXX: the kernel doesn't tell us the original rtprio and
|
|
|
|
* doesn't really know what it was, so to recover it we
|
|
|
|
* must be more chummy with the implementation than the
|
|
|
|
* implementation is with itself. pri_user gives a
|
|
|
|
* constant "base" priority, but is only initialized
|
|
|
|
* properly for user threads. pri_native gives what the
|
|
|
|
* kernel calls the "base" priority, but it isn't constant
|
|
|
|
* since it is changed by priority propagation. pri_native
|
|
|
|
* also isn't properly initialized for all threads, but it
|
|
|
|
* is properly initialized for kernel realtime and idletime
|
|
|
|
* threads. Thus we use pri_user for the base priority of
|
|
|
|
* user threads (it is always correct) and pri_native for
|
|
|
|
* the base priority of kernel realtime and idletime threads
|
|
|
|
* (there is nothing better, and it is usually correct).
|
|
|
|
*
|
|
|
|
* The field width and thus the buffer are too small for
|
|
|
|
* values like "kr31F", but such values shouldn't occur,
|
|
|
|
* and if they do then the tailing "F" is not displayed.
|
|
|
|
*/
|
|
|
|
rtpri = ((pp->ki_flag & P_KTHREAD) ? pp->ki_pri.pri_native :
|
|
|
|
pp->ki_pri.pri_user) - PRI_MIN_REALTIME;
|
2006-11-07 10:03:10 +00:00
|
|
|
snprintf(nicebuf, sizeof(nicebuf), "%sr%d%s",
|
|
|
|
kthread, rtpri, fifo);
|
|
|
|
break;
|
|
|
|
case PRI_TIMESHARE:
|
|
|
|
if (pp->ki_flag & P_KTHREAD)
|
|
|
|
return ("-");
|
|
|
|
snprintf(nicebuf, sizeof(nicebuf), "%d", pp->ki_nice - NZERO);
|
|
|
|
break;
|
|
|
|
case PRI_IDLE:
|
2007-06-15 12:03:07 +00:00
|
|
|
/* XXX: as above. */
|
|
|
|
rtpri = ((pp->ki_flag & P_KTHREAD) ? pp->ki_pri.pri_native :
|
|
|
|
pp->ki_pri.pri_user) - PRI_MIN_IDLE;
|
2006-11-07 10:03:10 +00:00
|
|
|
snprintf(nicebuf, sizeof(nicebuf), "%si%d%s",
|
|
|
|
kthread, rtpri, fifo);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return ("?");
|
|
|
|
}
|
2006-05-04 03:56:31 +00:00
|
|
|
return (nicebuf);
|
|
|
|
}
|
|
|
|
|
1998-08-12 09:58:15 +00:00
|
|
|
/* comparison routines for qsort */
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2006-05-04 03:56:31 +00:00
|
|
|
static int
|
2004-07-05 13:03:35 +00:00
|
|
|
compare_pid(const void *p1, const void *p2)
|
2004-07-01 09:12:38 +00:00
|
|
|
{
|
2004-07-05 13:12:16 +00:00
|
|
|
const struct kinfo_proc * const *pp1 = p1;
|
|
|
|
const struct kinfo_proc * const *pp2 = p2;
|
2004-07-01 09:12:38 +00:00
|
|
|
|
2004-07-05 13:12:16 +00:00
|
|
|
if ((*pp2)->ki_pid < 0 || (*pp1)->ki_pid < 0)
|
|
|
|
abort();
|
2004-07-01 09:12:38 +00:00
|
|
|
|
2004-07-05 13:12:16 +00:00
|
|
|
return ((*pp1)->ki_pid - (*pp2)->ki_pid);
|
2004-07-01 09:12:38 +00:00
|
|
|
}
|
|
|
|
|
1997-03-23 18:55:20 +00:00
|
|
|
/*
|
|
|
|
* proc_compare - comparison function for "qsort"
|
|
|
|
* Compares the resource consumption of two processes using five
|
2004-07-05 12:51:35 +00:00
|
|
|
* distinct keys. The keys (in descending order of importance) are:
|
|
|
|
* percent cpu, cpu ticks, state, resident set size, total virtual
|
|
|
|
* memory usage. The process states are ordered as follows (from least
|
|
|
|
* to most important): WAIT, zombie, sleep, stop, start, run. The
|
|
|
|
* array declaration below maps a process state index into a number
|
|
|
|
* that reflects this ordering.
|
1997-03-23 18:55:20 +00:00
|
|
|
*/
|
|
|
|
|
2006-05-04 03:00:13 +00:00
|
|
|
static int sorted_state[] = {
|
2004-07-05 13:12:16 +00:00
|
|
|
0, /* not used */
|
|
|
|
3, /* sleep */
|
|
|
|
1, /* ABANDONED (WAIT) */
|
|
|
|
6, /* run */
|
|
|
|
5, /* start */
|
|
|
|
2, /* zombie */
|
|
|
|
4 /* stop */
|
1997-03-23 18:55:20 +00:00
|
|
|
};
|
2004-07-05 12:51:35 +00:00
|
|
|
|
1998-08-12 09:58:15 +00:00
|
|
|
|
2005-05-18 13:42:51 +00:00
|
|
|
#define ORDERKEY_PCTCPU(a, b) do { \
|
|
|
|
long diff; \
|
|
|
|
if (ps.wcpu) \
|
2006-05-04 03:00:13 +00:00
|
|
|
diff = floor(1.0E6 * weighted_cpu(pctdouble((b)->ki_pctcpu), \
|
|
|
|
(b))) - \
|
|
|
|
floor(1.0E6 * weighted_cpu(pctdouble((a)->ki_pctcpu), \
|
|
|
|
(a))); \
|
2005-05-18 13:42:51 +00:00
|
|
|
else \
|
|
|
|
diff = (long)(b)->ki_pctcpu - (long)(a)->ki_pctcpu; \
|
|
|
|
if (diff != 0) \
|
|
|
|
return (diff > 0 ? 1 : -1); \
|
2004-07-05 14:45:57 +00:00
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define ORDERKEY_CPTICKS(a, b) do { \
|
2004-07-05 14:55:58 +00:00
|
|
|
int64_t diff = (int64_t)(b)->ki_runtime - (int64_t)(a)->ki_runtime; \
|
2004-07-05 14:45:57 +00:00
|
|
|
if (diff != 0) \
|
|
|
|
return (diff > 0 ? 1 : -1); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define ORDERKEY_STATE(a, b) do { \
|
|
|
|
int diff = sorted_state[(b)->ki_stat] - sorted_state[(a)->ki_stat]; \
|
|
|
|
if (diff != 0) \
|
|
|
|
return (diff > 0 ? 1 : -1); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define ORDERKEY_PRIO(a, b) do { \
|
2004-07-05 14:55:58 +00:00
|
|
|
int diff = (int)(b)->ki_pri.pri_level - (int)(a)->ki_pri.pri_level; \
|
2004-07-05 14:45:57 +00:00
|
|
|
if (diff != 0) \
|
|
|
|
return (diff > 0 ? 1 : -1); \
|
|
|
|
} while (0)
|
|
|
|
|
2005-04-14 15:02:03 +00:00
|
|
|
#define ORDERKEY_THREADS(a, b) do { \
|
|
|
|
int diff = (int)(b)->ki_numthreads - (int)(a)->ki_numthreads; \
|
|
|
|
if (diff != 0) \
|
|
|
|
return (diff > 0 ? 1 : -1); \
|
|
|
|
} while (0)
|
|
|
|
|
2004-07-05 14:45:57 +00:00
|
|
|
#define ORDERKEY_RSSIZE(a, b) do { \
|
2004-07-05 14:55:58 +00:00
|
|
|
long diff = (long)(b)->ki_rssize - (long)(a)->ki_rssize; \
|
2004-07-05 14:45:57 +00:00
|
|
|
if (diff != 0) \
|
|
|
|
return (diff > 0 ? 1 : -1); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#define ORDERKEY_MEM(a, b) do { \
|
2004-07-05 14:55:58 +00:00
|
|
|
long diff = (long)PROCSIZE((b)) - (long)PROCSIZE((a)); \
|
2004-07-05 14:45:57 +00:00
|
|
|
if (diff != 0) \
|
|
|
|
return (diff > 0 ? 1 : -1); \
|
|
|
|
} while (0)
|
1998-08-12 09:58:15 +00:00
|
|
|
|
2007-04-17 03:12:39 +00:00
|
|
|
#define ORDERKEY_JID(a, b) do { \
|
|
|
|
int diff = (int)(b)->ki_jid - (int)(a)->ki_jid; \
|
|
|
|
if (diff != 0) \
|
|
|
|
return (diff > 0 ? 1 : -1); \
|
|
|
|
} while (0)
|
|
|
|
|
1998-08-12 09:58:15 +00:00
|
|
|
/* compare_cpu - the comparison function for sorting by cpu percentage */
|
|
|
|
|
1997-03-23 18:55:20 +00:00
|
|
|
int
|
1998-08-12 09:58:15 +00:00
|
|
|
#ifdef ORDER
|
2004-07-05 14:45:57 +00:00
|
|
|
compare_cpu(void *arg1, void *arg2)
|
1998-08-12 09:58:15 +00:00
|
|
|
#else
|
2004-07-05 14:45:57 +00:00
|
|
|
proc_compare(void *arg1, void *arg2)
|
1998-08-12 09:58:15 +00:00
|
|
|
#endif
|
1997-03-23 18:55:20 +00:00
|
|
|
{
|
2004-07-05 14:45:57 +00:00
|
|
|
struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
|
|
|
|
struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
|
|
|
|
|
|
|
|
ORDERKEY_PCTCPU(p1, p2);
|
|
|
|
ORDERKEY_CPTICKS(p1, p2);
|
|
|
|
ORDERKEY_STATE(p1, p2);
|
|
|
|
ORDERKEY_PRIO(p1, p2);
|
|
|
|
ORDERKEY_RSSIZE(p1, p2);
|
|
|
|
ORDERKEY_MEM(p1, p2);
|
|
|
|
|
|
|
|
return (0);
|
1997-03-23 18:55:20 +00:00
|
|
|
}
|
|
|
|
|
1998-08-12 09:58:15 +00:00
|
|
|
#ifdef ORDER
|
2006-05-04 03:00:13 +00:00
|
|
|
/* "cpu" compare routines */
|
|
|
|
int compare_size(), compare_res(), compare_time(), compare_prio(),
|
|
|
|
compare_threads();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* "io" compare routines. Context switches aren't i/o, but are displayed
|
|
|
|
* on the "io" display.
|
|
|
|
*/
|
|
|
|
int compare_iototal(), compare_ioread(), compare_iowrite(), compare_iofault(),
|
|
|
|
compare_vcsw(), compare_ivcsw();
|
1998-08-12 09:58:15 +00:00
|
|
|
|
2004-08-16 07:51:22 +00:00
|
|
|
int (*compares[])() = {
|
2004-07-05 13:12:16 +00:00
|
|
|
compare_cpu,
|
|
|
|
compare_size,
|
|
|
|
compare_res,
|
|
|
|
compare_time,
|
|
|
|
compare_prio,
|
2005-04-14 15:02:03 +00:00
|
|
|
compare_threads,
|
2004-08-16 07:51:22 +00:00
|
|
|
compare_iototal,
|
|
|
|
compare_ioread,
|
|
|
|
compare_iowrite,
|
|
|
|
compare_iofault,
|
|
|
|
compare_vcsw,
|
|
|
|
compare_ivcsw,
|
2007-04-17 03:12:39 +00:00
|
|
|
compare_jid,
|
2004-07-05 13:12:16 +00:00
|
|
|
NULL
|
1998-08-12 09:58:15 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* compare_size - the comparison function for sorting by total memory usage */
|
|
|
|
|
|
|
|
int
|
2004-07-05 14:45:57 +00:00
|
|
|
compare_size(void *arg1, void *arg2)
|
1998-08-12 09:58:15 +00:00
|
|
|
{
|
2004-07-05 14:45:57 +00:00
|
|
|
struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
|
|
|
|
struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
|
|
|
|
|
|
|
|
ORDERKEY_MEM(p1, p2);
|
|
|
|
ORDERKEY_RSSIZE(p1, p2);
|
|
|
|
ORDERKEY_PCTCPU(p1, p2);
|
|
|
|
ORDERKEY_CPTICKS(p1, p2);
|
|
|
|
ORDERKEY_STATE(p1, p2);
|
|
|
|
ORDERKEY_PRIO(p1, p2);
|
|
|
|
|
|
|
|
return (0);
|
1998-08-12 09:58:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* compare_res - the comparison function for sorting by resident set size */
|
|
|
|
|
|
|
|
int
|
2004-07-05 14:45:57 +00:00
|
|
|
compare_res(void *arg1, void *arg2)
|
1998-08-12 09:58:15 +00:00
|
|
|
{
|
2004-07-05 14:45:57 +00:00
|
|
|
struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
|
|
|
|
struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
|
|
|
|
|
|
|
|
ORDERKEY_RSSIZE(p1, p2);
|
|
|
|
ORDERKEY_MEM(p1, p2);
|
|
|
|
ORDERKEY_PCTCPU(p1, p2);
|
|
|
|
ORDERKEY_CPTICKS(p1, p2);
|
|
|
|
ORDERKEY_STATE(p1, p2);
|
|
|
|
ORDERKEY_PRIO(p1, p2);
|
|
|
|
|
|
|
|
return (0);
|
1998-08-12 09:58:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* compare_time - the comparison function for sorting by total cpu time */
|
|
|
|
|
|
|
|
int
|
2004-07-05 14:45:57 +00:00
|
|
|
compare_time(void *arg1, void *arg2)
|
1998-08-12 09:58:15 +00:00
|
|
|
{
|
2004-07-05 14:45:57 +00:00
|
|
|
struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
|
|
|
|
struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
|
|
|
|
|
|
|
|
ORDERKEY_CPTICKS(p1, p2);
|
|
|
|
ORDERKEY_PCTCPU(p1, p2);
|
|
|
|
ORDERKEY_STATE(p1, p2);
|
|
|
|
ORDERKEY_PRIO(p1, p2);
|
|
|
|
ORDERKEY_RSSIZE(p1, p2);
|
|
|
|
ORDERKEY_MEM(p1, p2);
|
|
|
|
|
|
|
|
return (0);
|
2004-07-05 13:12:16 +00:00
|
|
|
}
|
2004-06-30 04:19:23 +00:00
|
|
|
|
2004-07-05 14:45:57 +00:00
|
|
|
/* compare_prio - the comparison function for sorting by priority */
|
1998-08-12 09:58:15 +00:00
|
|
|
|
|
|
|
int
|
2004-07-05 14:45:57 +00:00
|
|
|
compare_prio(void *arg1, void *arg2)
|
1998-08-12 09:58:15 +00:00
|
|
|
{
|
2004-07-05 14:45:57 +00:00
|
|
|
struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
|
|
|
|
struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
|
|
|
|
|
|
|
|
ORDERKEY_PRIO(p1, p2);
|
|
|
|
ORDERKEY_CPTICKS(p1, p2);
|
|
|
|
ORDERKEY_PCTCPU(p1, p2);
|
|
|
|
ORDERKEY_STATE(p1, p2);
|
|
|
|
ORDERKEY_RSSIZE(p1, p2);
|
|
|
|
ORDERKEY_MEM(p1, p2);
|
|
|
|
|
|
|
|
return (0);
|
1998-08-12 09:58:15 +00:00
|
|
|
}
|
2005-04-14 15:02:03 +00:00
|
|
|
|
|
|
|
/* compare_threads - the comparison function for sorting by threads */
|
|
|
|
int
|
|
|
|
compare_threads(void *arg1, void *arg2)
|
|
|
|
{
|
|
|
|
struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
|
|
|
|
struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
|
|
|
|
|
|
|
|
ORDERKEY_THREADS(p1, p2);
|
|
|
|
ORDERKEY_PCTCPU(p1, p2);
|
|
|
|
ORDERKEY_CPTICKS(p1, p2);
|
|
|
|
ORDERKEY_STATE(p1, p2);
|
|
|
|
ORDERKEY_PRIO(p1, p2);
|
|
|
|
ORDERKEY_RSSIZE(p1, p2);
|
|
|
|
ORDERKEY_MEM(p1, p2);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
2007-04-17 03:12:39 +00:00
|
|
|
|
|
|
|
/* compare_jid - the comparison function for sorting by jid */
|
|
|
|
static int
|
|
|
|
compare_jid(const void *arg1, const void *arg2)
|
|
|
|
{
|
|
|
|
struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
|
|
|
|
struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
|
|
|
|
|
|
|
|
ORDERKEY_JID(p1, p2);
|
|
|
|
ORDERKEY_PCTCPU(p1, p2);
|
|
|
|
ORDERKEY_CPTICKS(p1, p2);
|
|
|
|
ORDERKEY_STATE(p1, p2);
|
|
|
|
ORDERKEY_PRIO(p1, p2);
|
|
|
|
ORDERKEY_RSSIZE(p1, p2);
|
|
|
|
ORDERKEY_MEM(p1, p2);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
2006-05-04 03:00:13 +00:00
|
|
|
#endif /* ORDER */
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2006-05-04 03:00:13 +00:00
|
|
|
/* assorted comparison functions for sorting by i/o */
|
2004-07-08 16:45:55 +00:00
|
|
|
|
2004-07-01 09:12:38 +00:00
|
|
|
int
|
2004-07-08 16:45:55 +00:00
|
|
|
#ifdef ORDER
|
|
|
|
compare_iototal(void *arg1, void *arg2)
|
|
|
|
#else
|
2004-07-05 14:45:57 +00:00
|
|
|
io_compare(void *arg1, void *arg2)
|
2004-07-08 16:45:55 +00:00
|
|
|
#endif
|
2004-07-01 09:12:38 +00:00
|
|
|
{
|
2004-07-05 14:45:57 +00:00
|
|
|
struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
|
|
|
|
struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
|
2004-07-01 09:12:38 +00:00
|
|
|
|
2004-07-05 14:45:57 +00:00
|
|
|
return (get_io_total(p2) - get_io_total(p1));
|
2004-07-01 09:12:38 +00:00
|
|
|
}
|
2004-07-08 16:45:55 +00:00
|
|
|
|
|
|
|
#ifdef ORDER
|
|
|
|
int
|
|
|
|
compare_ioread(void *arg1, void *arg2)
|
|
|
|
{
|
|
|
|
struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
|
|
|
|
struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
|
|
|
|
long dummy, inp1, inp2;
|
|
|
|
|
2004-08-16 07:51:22 +00:00
|
|
|
(void) get_io_stats(p1, &inp1, &dummy, &dummy, &dummy, &dummy);
|
|
|
|
(void) get_io_stats(p2, &inp2, &dummy, &dummy, &dummy, &dummy);
|
2004-07-08 16:45:55 +00:00
|
|
|
|
|
|
|
return (inp2 - inp1);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
compare_iowrite(void *arg1, void *arg2)
|
|
|
|
{
|
|
|
|
struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
|
|
|
|
struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
|
|
|
|
long dummy, oup1, oup2;
|
|
|
|
|
2004-08-16 07:51:22 +00:00
|
|
|
(void) get_io_stats(p1, &dummy, &oup1, &dummy, &dummy, &dummy);
|
|
|
|
(void) get_io_stats(p2, &dummy, &oup2, &dummy, &dummy, &dummy);
|
2004-07-08 16:45:55 +00:00
|
|
|
|
|
|
|
return (oup2 - oup1);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
compare_iofault(void *arg1, void *arg2)
|
|
|
|
{
|
|
|
|
struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
|
|
|
|
struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
|
|
|
|
long dummy, flp1, flp2;
|
|
|
|
|
2004-08-16 07:51:22 +00:00
|
|
|
(void) get_io_stats(p1, &dummy, &dummy, &flp1, &dummy, &dummy);
|
|
|
|
(void) get_io_stats(p2, &dummy, &dummy, &flp2, &dummy, &dummy);
|
|
|
|
|
|
|
|
return (flp2 - flp1);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
compare_vcsw(void *arg1, void *arg2)
|
|
|
|
{
|
|
|
|
struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
|
|
|
|
struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
|
|
|
|
long dummy, flp1, flp2;
|
|
|
|
|
|
|
|
(void) get_io_stats(p1, &dummy, &dummy, &dummy, &flp1, &dummy);
|
|
|
|
(void) get_io_stats(p2, &dummy, &dummy, &dummy, &flp2, &dummy);
|
|
|
|
|
|
|
|
return (flp2 - flp1);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
compare_ivcsw(void *arg1, void *arg2)
|
|
|
|
{
|
|
|
|
struct kinfo_proc *p1 = *(struct kinfo_proc **)arg1;
|
|
|
|
struct kinfo_proc *p2 = *(struct kinfo_proc **)arg2;
|
|
|
|
long dummy, flp1, flp2;
|
|
|
|
|
|
|
|
(void) get_io_stats(p1, &dummy, &dummy, &dummy, &dummy, &flp1);
|
|
|
|
(void) get_io_stats(p2, &dummy, &dummy, &dummy, &dummy, &flp2);
|
2004-07-08 16:45:55 +00:00
|
|
|
|
|
|
|
return (flp2 - flp1);
|
|
|
|
}
|
|
|
|
#endif /* ORDER */
|
|
|
|
|
1997-03-23 18:55:20 +00:00
|
|
|
/*
|
|
|
|
* proc_owner(pid) - returns the uid that owns process "pid", or -1 if
|
|
|
|
* the process does not exist.
|
|
|
|
* It is EXTREMLY IMPORTANT that this function work correctly.
|
|
|
|
* If top runs setuid root (as in SVR4), then this function
|
|
|
|
* is the only thing that stands in the way of a serious
|
|
|
|
* security problem. It validates requests for the "kill"
|
|
|
|
* and "renice" commands.
|
|
|
|
*/
|
|
|
|
|
2004-06-30 04:19:23 +00:00
|
|
|
int
|
2004-07-05 13:03:35 +00:00
|
|
|
proc_owner(int pid)
|
1997-03-23 18:55:20 +00:00
|
|
|
{
|
2004-07-05 13:12:16 +00:00
|
|
|
int cnt;
|
|
|
|
struct kinfo_proc **prefp;
|
|
|
|
struct kinfo_proc *pp;
|
|
|
|
|
|
|
|
prefp = pref;
|
|
|
|
cnt = pref_len;
|
2004-07-05 14:45:57 +00:00
|
|
|
while (--cnt >= 0) {
|
2004-07-05 13:12:16 +00:00
|
|
|
pp = *prefp++;
|
|
|
|
if (pp->ki_pid == (pid_t)pid)
|
|
|
|
return ((int)pp->ki_ruid);
|
1997-03-23 18:55:20 +00:00
|
|
|
}
|
2004-07-05 13:12:16 +00:00
|
|
|
return (-1);
|
1997-03-23 18:55:20 +00:00
|
|
|
}
|
|
|
|
|
2006-05-04 03:56:31 +00:00
|
|
|
static int
|
2004-07-05 13:03:35 +00:00
|
|
|
swapmode(int *retavail, int *retfree)
|
1997-03-23 18:55:20 +00:00
|
|
|
{
|
1999-01-22 11:09:41 +00:00
|
|
|
int n;
|
|
|
|
int pagesize = getpagesize();
|
|
|
|
struct kvm_swap swapary[1];
|
1997-03-23 18:55:20 +00:00
|
|
|
|
1999-01-22 11:09:41 +00:00
|
|
|
*retavail = 0;
|
|
|
|
*retfree = 0;
|
1997-03-23 18:55:20 +00:00
|
|
|
|
1999-01-22 11:09:41 +00:00
|
|
|
#define CONVERT(v) ((quad_t)(v) * pagesize / 1024)
|
1997-03-23 18:55:20 +00:00
|
|
|
|
1999-01-22 11:09:41 +00:00
|
|
|
n = kvm_getswapinfo(kd, swapary, 1, 0);
|
1999-02-06 06:33:55 +00:00
|
|
|
if (n < 0 || swapary[0].ksw_total == 0)
|
2004-07-05 13:12:16 +00:00
|
|
|
return (0);
|
1997-03-23 18:55:20 +00:00
|
|
|
|
1999-01-22 11:09:41 +00:00
|
|
|
*retavail = CONVERT(swapary[0].ksw_total);
|
|
|
|
*retfree = CONVERT(swapary[0].ksw_total - swapary[0].ksw_used);
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2004-07-05 14:45:57 +00:00
|
|
|
n = (int)(swapary[0].ksw_used * 100.0 / swapary[0].ksw_total);
|
2004-07-05 13:12:16 +00:00
|
|
|
return (n);
|
1997-03-23 18:55:20 +00:00
|
|
|
}
|