1997-03-23 18:55:20 +00:00
|
|
|
/*
|
|
|
|
* top - a top users display for Unix
|
|
|
|
*
|
|
|
|
* 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
|
|
|
*
|
|
|
|
* AUTHOR: Christos Zoulas <christos@ee.cornell.edu>
|
2018-06-04 04:59:32 +00:00
|
|
|
* Steven Wallace <swallace@FreeBSD.org>
|
1997-03-23 18:55:20 +00:00
|
|
|
* Wolfram Schneider <wosch@FreeBSD.org>
|
2001-02-23 18:52:37 +00:00
|
|
|
* Thomas Moestl <tmoestl@gmx.net>
|
2018-06-04 04:59:32 +00:00
|
|
|
* Eitan Adler <eadler@FreeBSD.org>
|
1997-03-23 18:55:20 +00:00
|
|
|
*/
|
|
|
|
|
2023-05-26 19:14:21 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/cpuset.h>
|
1997-03-23 18:55:20 +00:00
|
|
|
#include <sys/errno.h>
|
2018-06-04 04:59:32 +00:00
|
|
|
#include <sys/fcntl.h>
|
|
|
|
#include <sys/priority.h>
|
1997-03-23 18:55:20 +00:00
|
|
|
#include <sys/proc.h>
|
1997-09-28 00:59:04 +00:00
|
|
|
#include <sys/resource.h>
|
2018-06-22 09:21:01 +00:00
|
|
|
#include <sys/sbuf.h>
|
2004-07-05 12:58:47 +00:00
|
|
|
#include <sys/sysctl.h>
|
|
|
|
#include <sys/time.h>
|
|
|
|
#include <sys/user.h>
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2018-05-21 00:53:42 +00:00
|
|
|
#include <assert.h>
|
2011-05-20 17:03:23 +00:00
|
|
|
#include <err.h>
|
2018-06-23 22:45:18 +00:00
|
|
|
#include <libgen.h>
|
2004-07-05 12:58:47 +00:00
|
|
|
#include <kvm.h>
|
|
|
|
#include <math.h>
|
2004-07-05 14:45:57 +00:00
|
|
|
#include <paths.h>
|
2004-07-05 12:58:47 +00:00
|
|
|
#include <stdio.h>
|
2018-06-02 03:25:15 +00:00
|
|
|
#include <stdbool.h>
|
2018-06-04 04:59:32 +00:00
|
|
|
#include <stdint.h>
|
1997-03-23 18:55:20 +00:00
|
|
|
#include <stdlib.h>
|
2005-04-04 21:19:48 +00:00
|
|
|
#include <string.h>
|
2018-06-04 04:59:32 +00:00
|
|
|
#include <time.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"
|
2018-05-21 01:16:26 +00:00
|
|
|
#include "display.h"
|
2018-05-21 04:02:45 +00:00
|
|
|
#include "machine.h"
|
|
|
|
#include "loadavg.h"
|
2000-11-29 23:03:02 +00:00
|
|
|
#include "screen.h"
|
2001-02-23 18:52:37 +00:00
|
|
|
#include "utils.h"
|
2008-01-18 01:43:14 +00:00
|
|
|
#include "layout.h"
|
2001-02-23 18:52:37 +00:00
|
|
|
|
|
|
|
#define GETSYSCTL(name, var) getsysctl(name, &(var), sizeof(var))
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2018-05-21 01:16:26 +00:00
|
|
|
extern struct timeval timeout;
|
1997-07-12 10:51:54 +00:00
|
|
|
static int smpmode;
|
2004-07-01 09:12:38 +00:00
|
|
|
enum displaymodes displaymode;
|
2018-06-22 09:21:01 +00:00
|
|
|
static const int namelength = 10;
|
2014-05-03 15:03:47 +00:00
|
|
|
/* TOP_JID_LEN based on max of 999999 */
|
2018-06-22 09:21:01 +00:00
|
|
|
#define TOP_JID_LEN 6
|
|
|
|
#define TOP_SWAP_LEN 5
|
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
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/* 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)
|
|
|
|
|
2014-05-30 21:18:53 +00:00
|
|
|
#define PCTCPU(pp) (pcpu[pp - pbase])
|
2004-07-01 09:12:38 +00:00
|
|
|
|
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 */
|
|
|
|
|
2018-06-02 07:44:50 +00:00
|
|
|
static const 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 */
|
|
|
|
|
2018-06-03 22:42:54 +00:00
|
|
|
static const 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
|
|
|
};
|
2018-06-03 23:40:54 +00:00
|
|
|
static int process_states[nitems(procstatenames)];
|
1997-03-23 18:55:20 +00:00
|
|
|
|
|
|
|
/* these are for detailing the cpu states */
|
|
|
|
|
2018-05-21 03:36:16 +00:00
|
|
|
static int cpu_states[CPUSTATES];
|
2018-06-03 22:42:54 +00:00
|
|
|
static const 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 */
|
|
|
|
|
2018-06-03 22:42:54 +00:00
|
|
|
static const char *memorynames[] = {
|
2016-11-10 19:55:45 +00:00
|
|
|
"K Active, ", "K Inact, ", "K Laundry, ", "K Wired, ", "K Buf, ",
|
2006-05-04 03:00:13 +00:00
|
|
|
"K Free", NULL
|
1997-03-23 18:55:20 +00:00
|
|
|
};
|
2018-06-03 23:40:54 +00:00
|
|
|
static int memory_stats[nitems(memorynames)];
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2018-06-03 22:42:54 +00:00
|
|
|
static const char *arcnames[] = {
|
2012-10-19 12:28:26 +00:00
|
|
|
"K Total, ", "K MFU, ", "K MRU, ", "K Anon, ", "K Header, ", "K Other",
|
2012-06-27 18:08:48 +00:00
|
|
|
NULL
|
|
|
|
};
|
2018-06-03 23:40:54 +00:00
|
|
|
static int arc_stats[nitems(arcnames)];
|
2012-06-27 18:08:48 +00:00
|
|
|
|
2018-06-03 22:42:54 +00:00
|
|
|
static const char *carcnames[] = {
|
2017-06-12 19:51:57 +00:00
|
|
|
"K Compressed, ", "K Uncompressed, ", ":1 Ratio, ",
|
Add ZFS compressed ARC stats to top(1)
Provides:
amount of compressed data
logical size of compressed data (how much it would have taken uncompressed)
compression ratio (logical size : total ARC size)
Overhead (space consumed for compression headers)
Example output:
ARC: 31G Total, 18G MFU, 9067M MRU, 2236K Anon, 615M Header, 2947M Other
25G Compressed, 54G Uncompressed, 1.76:1 Ratio, 2265M Overhead
Reviewed by: jpaetzel, smh, imp, jhb (previous version)
MFC after: 2 week
Relnotes: yes
Sponsored by: ScaleEngine Inc.
Differential Revision: https://reviews.freebsd.org/D9829
2017-03-17 00:46:50 +00:00
|
|
|
NULL
|
|
|
|
};
|
2018-06-03 23:40:54 +00:00
|
|
|
static int carc_stats[nitems(carcnames)];
|
Add ZFS compressed ARC stats to top(1)
Provides:
amount of compressed data
logical size of compressed data (how much it would have taken uncompressed)
compression ratio (logical size : total ARC size)
Overhead (space consumed for compression headers)
Example output:
ARC: 31G Total, 18G MFU, 9067M MRU, 2236K Anon, 615M Header, 2947M Other
25G Compressed, 54G Uncompressed, 1.76:1 Ratio, 2265M Overhead
Reviewed by: jpaetzel, smh, imp, jhb (previous version)
MFC after: 2 week
Relnotes: yes
Sponsored by: ScaleEngine Inc.
Differential Revision: https://reviews.freebsd.org/D9829
2017-03-17 00:46:50 +00:00
|
|
|
|
2018-06-03 22:42:54 +00:00
|
|
|
static const 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
|
|
|
};
|
2018-06-03 23:40:54 +00:00
|
|
|
static int swap_stats[nitems(swapnames)];
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2019-06-20 15:44:43 +00:00
|
|
|
static int has_swap;
|
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;
|
2014-05-30 21:18:53 +00:00
|
|
|
static int previous_thread;
|
|
|
|
|
|
|
|
/* data used for recalculating pctcpu */
|
|
|
|
static double *pcpu;
|
|
|
|
static struct timespec proc_uptime;
|
|
|
|
static struct timeval proc_wall_time;
|
|
|
|
static struct timeval previous_wall_time;
|
|
|
|
static uint64_t previous_interval = 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 */
|
|
|
|
|
2014-05-30 21:18:53 +00:00
|
|
|
static int arc_enabled;
|
Add ZFS compressed ARC stats to top(1)
Provides:
amount of compressed data
logical size of compressed data (how much it would have taken uncompressed)
compression ratio (logical size : total ARC size)
Overhead (space consumed for compression headers)
Example output:
ARC: 31G Total, 18G MFU, 9067M MRU, 2236K Anon, 615M Header, 2947M Other
25G Compressed, 54G Uncompressed, 1.76:1 Ratio, 2265M Overhead
Reviewed by: jpaetzel, smh, imp, jhb (previous version)
MFC after: 2 week
Relnotes: yes
Sponsored by: ScaleEngine Inc.
Differential Revision: https://reviews.freebsd.org/D9829
2017-03-17 00:46:50 +00:00
|
|
|
static int carc_enabled;
|
1997-03-23 18:55:20 +00:00
|
|
|
static int pageshift; /* log base 2 of the pagesize */
|
|
|
|
|
|
|
|
/* define pagetok in terms of pageshift */
|
|
|
|
|
|
|
|
#define pagetok(size) ((size) << pageshift)
|
|
|
|
|
2016-09-05 08:27:04 +00:00
|
|
|
/* swap usage */
|
|
|
|
#define ki_swap(kip) \
|
|
|
|
((kip)->ki_swrss > (kip)->ki_rssize ? (kip)->ki_swrss - (kip)->ki_rssize : 0)
|
|
|
|
|
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
|
|
|
*/
|
2018-06-03 05:07:39 +00:00
|
|
|
static const 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",
|
2016-09-05 08:27:04 +00:00
|
|
|
"jid", "swap", "pid", NULL
|
2004-07-08 16:45:55 +00:00
|
|
|
};
|
1998-08-12 09:58:15 +00:00
|
|
|
|
2008-01-18 01:43:14 +00:00
|
|
|
/* Per-cpu time states */
|
|
|
|
static int maxcpu;
|
|
|
|
static int maxid;
|
|
|
|
static int ncpus;
|
2023-05-26 19:14:21 +00:00
|
|
|
static cpuset_t cpumask;
|
2008-01-18 01:43:14 +00:00
|
|
|
static long *times;
|
|
|
|
static long *pcpu_cp_time;
|
|
|
|
static long *pcpu_cp_old;
|
|
|
|
static long *pcpu_cp_diff;
|
|
|
|
static int *pcpu_cpu_states;
|
|
|
|
|
2019-12-21 05:03:21 +00:00
|
|
|
/* Battery units and states */
|
|
|
|
static int battery_units;
|
|
|
|
static int battery_life;
|
|
|
|
|
2016-09-05 08:27:04 +00:00
|
|
|
static int compare_swap(const void *a, const void *b);
|
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);
|
2011-07-18 17:33:08 +00:00
|
|
|
static int compare_tid(const void *a, const void *b);
|
2006-05-04 03:56:31 +00:00
|
|
|
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);
|
2012-06-27 18:08:48 +00:00
|
|
|
static void update_layout(void);
|
2017-08-07 08:45:08 +00:00
|
|
|
static int find_uid(uid_t needle, int *haystack);
|
2021-06-16 19:40:21 +00:00
|
|
|
static int cmd_matches(struct kinfo_proc *, const char *);
|
2017-08-07 08:45:08 +00:00
|
|
|
|
|
|
|
static int
|
|
|
|
find_uid(uid_t needle, int *haystack)
|
|
|
|
{
|
|
|
|
size_t i = 0;
|
|
|
|
|
|
|
|
for (; i < TOP_MAX_UIDS; ++i)
|
|
|
|
if ((uid_t)haystack[i] == needle)
|
|
|
|
return 1;
|
2018-06-08 01:55:47 +00:00
|
|
|
return (0);
|
2017-08-07 08:45:08 +00:00
|
|
|
}
|
2006-05-04 03:56:31 +00:00
|
|
|
|
2011-07-11 16:48:52 +00:00
|
|
|
void
|
2011-07-18 21:15:47 +00:00
|
|
|
toggle_pcpustats(void)
|
2011-07-11 16:48:52 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
if (ncpus == 1)
|
|
|
|
return;
|
2012-06-27 18:08:48 +00:00
|
|
|
update_layout();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Adjust display based on ncpus and the ARC state. */
|
|
|
|
static void
|
|
|
|
update_layout(void)
|
|
|
|
{
|
|
|
|
|
|
|
|
y_mem = 3;
|
2012-07-02 20:08:11 +00:00
|
|
|
y_arc = 4;
|
Add ZFS compressed ARC stats to top(1)
Provides:
amount of compressed data
logical size of compressed data (how much it would have taken uncompressed)
compression ratio (logical size : total ARC size)
Overhead (space consumed for compression headers)
Example output:
ARC: 31G Total, 18G MFU, 9067M MRU, 2236K Anon, 615M Header, 2947M Other
25G Compressed, 54G Uncompressed, 1.76:1 Ratio, 2265M Overhead
Reviewed by: jpaetzel, smh, imp, jhb (previous version)
MFC after: 2 week
Relnotes: yes
Sponsored by: ScaleEngine Inc.
Differential Revision: https://reviews.freebsd.org/D9829
2017-03-17 00:46:50 +00:00
|
|
|
y_carc = 5;
|
2019-06-20 15:44:43 +00:00
|
|
|
y_swap = 3 + arc_enabled + carc_enabled + has_swap;
|
|
|
|
y_idlecursor = 4 + arc_enabled + carc_enabled + has_swap;
|
|
|
|
y_message = 4 + arc_enabled + carc_enabled + has_swap;
|
|
|
|
y_header = 5 + arc_enabled + carc_enabled + has_swap;
|
|
|
|
y_procs = 6 + arc_enabled + carc_enabled + has_swap;
|
|
|
|
Header_lines = 6 + arc_enabled + carc_enabled + has_swap;
|
2011-07-11 16:48:52 +00:00
|
|
|
|
|
|
|
if (pcpu_stats) {
|
2012-07-02 20:08:11 +00:00
|
|
|
y_mem += ncpus - 1;
|
|
|
|
y_arc += ncpus - 1;
|
Add ZFS compressed ARC stats to top(1)
Provides:
amount of compressed data
logical size of compressed data (how much it would have taken uncompressed)
compression ratio (logical size : total ARC size)
Overhead (space consumed for compression headers)
Example output:
ARC: 31G Total, 18G MFU, 9067M MRU, 2236K Anon, 615M Header, 2947M Other
25G Compressed, 54G Uncompressed, 1.76:1 Ratio, 2265M Overhead
Reviewed by: jpaetzel, smh, imp, jhb (previous version)
MFC after: 2 week
Relnotes: yes
Sponsored by: ScaleEngine Inc.
Differential Revision: https://reviews.freebsd.org/D9829
2017-03-17 00:46:50 +00:00
|
|
|
y_carc += ncpus - 1;
|
2012-06-27 18:08:48 +00:00
|
|
|
y_swap += ncpus - 1;
|
|
|
|
y_idlecursor += ncpus - 1;
|
|
|
|
y_message += ncpus - 1;
|
|
|
|
y_header += ncpus - 1;
|
|
|
|
y_procs += ncpus - 1;
|
|
|
|
Header_lines += ncpus - 1;
|
2011-07-11 16:48:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1997-03-23 18:55:20 +00:00
|
|
|
int
|
2018-05-20 23:19:09 +00:00
|
|
|
machine_init(struct statics *statics)
|
1997-03-23 18:55:20 +00:00
|
|
|
{
|
2011-07-11 16:48:52 +00:00
|
|
|
int i, j, empty, pagesize;
|
2012-06-27 18:08:48 +00:00
|
|
|
uint64_t arc_size;
|
2019-06-20 15:44:43 +00:00
|
|
|
int carc_en, nswapdev;
|
2011-07-11 16:48:52 +00:00
|
|
|
size_t size;
|
2004-07-05 13:12:16 +00:00
|
|
|
|
2011-07-11 16:48:52 +00:00
|
|
|
size = sizeof(smpmode);
|
2020-06-28 00:29:21 +00:00
|
|
|
if (sysctlbyname("kern.smp.active", &smpmode, &size, NULL, 0) != 0 ||
|
2011-07-11 16:48:52 +00:00
|
|
|
size != sizeof(smpmode))
|
2004-07-05 13:12:16 +00:00
|
|
|
smpmode = 0;
|
|
|
|
|
Add ZFS compressed ARC stats to top(1)
Provides:
amount of compressed data
logical size of compressed data (how much it would have taken uncompressed)
compression ratio (logical size : total ARC size)
Overhead (space consumed for compression headers)
Example output:
ARC: 31G Total, 18G MFU, 9067M MRU, 2236K Anon, 615M Header, 2947M Other
25G Compressed, 54G Uncompressed, 1.76:1 Ratio, 2265M Overhead
Reviewed by: jpaetzel, smh, imp, jhb (previous version)
MFC after: 2 week
Relnotes: yes
Sponsored by: ScaleEngine Inc.
Differential Revision: https://reviews.freebsd.org/D9829
2017-03-17 00:46:50 +00:00
|
|
|
size = sizeof(arc_size);
|
2012-06-27 18:08:48 +00:00
|
|
|
if (sysctlbyname("kstat.zfs.misc.arcstats.size", &arc_size, &size,
|
|
|
|
NULL, 0) == 0 && arc_size != 0)
|
|
|
|
arc_enabled = 1;
|
2017-07-21 23:53:48 +00:00
|
|
|
size = sizeof(carc_en);
|
|
|
|
if (arc_enabled &&
|
|
|
|
sysctlbyname("vfs.zfs.compressed_arc_enabled", &carc_en, &size,
|
|
|
|
NULL, 0) == 0 && carc_en == 1)
|
|
|
|
carc_enabled = 1;
|
2012-06-27 18:08:48 +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
|
|
|
|
2019-06-20 15:44:43 +00:00
|
|
|
size = sizeof(nswapdev);
|
|
|
|
if (sysctlbyname("vm.nswapdev", &nswapdev, &size, NULL,
|
|
|
|
0) == 0 && nswapdev != 0)
|
|
|
|
has_swap = 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;
|
2014-05-30 21:18:53 +00:00
|
|
|
pcpu = NULL;
|
2004-07-05 13:12:16 +00:00
|
|
|
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;
|
2012-06-27 18:08:48 +00:00
|
|
|
if (arc_enabled)
|
|
|
|
statics->arc_names = arcnames;
|
|
|
|
else
|
|
|
|
statics->arc_names = NULL;
|
Add ZFS compressed ARC stats to top(1)
Provides:
amount of compressed data
logical size of compressed data (how much it would have taken uncompressed)
compression ratio (logical size : total ARC size)
Overhead (space consumed for compression headers)
Example output:
ARC: 31G Total, 18G MFU, 9067M MRU, 2236K Anon, 615M Header, 2947M Other
25G Compressed, 54G Uncompressed, 1.76:1 Ratio, 2265M Overhead
Reviewed by: jpaetzel, smh, imp, jhb (previous version)
MFC after: 2 week
Relnotes: yes
Sponsored by: ScaleEngine Inc.
Differential Revision: https://reviews.freebsd.org/D9829
2017-03-17 00:46:50 +00:00
|
|
|
if (carc_enabled)
|
|
|
|
statics->carc_names = carcnames;
|
|
|
|
else
|
|
|
|
statics->carc_names = NULL;
|
2019-06-20 15:44:43 +00:00
|
|
|
if (has_swap)
|
|
|
|
statics->swap_names = swapnames;
|
|
|
|
else
|
|
|
|
statics->swap_names = NULL;
|
2004-08-16 07:51:22 +00:00
|
|
|
statics->order_names = ordernames;
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2011-07-11 16:48:52 +00:00
|
|
|
/* Allocate state for per-CPU stats. */
|
|
|
|
GETSYSCTL("kern.smp.maxcpus", maxcpu);
|
2018-06-03 02:58:53 +00:00
|
|
|
times = calloc(maxcpu * CPUSTATES, sizeof(long));
|
2011-07-11 16:48:52 +00:00
|
|
|
if (times == NULL)
|
2018-06-06 07:13:27 +00:00
|
|
|
err(1, "calloc for kern.smp.maxcpus");
|
2018-06-03 13:41:23 +00:00
|
|
|
size = sizeof(long) * maxcpu * CPUSTATES;
|
2011-07-11 16:48:52 +00:00
|
|
|
if (sysctlbyname("kern.cp_times", times, &size, NULL, 0) == -1)
|
|
|
|
err(1, "sysctlbyname kern.cp_times");
|
|
|
|
pcpu_cp_time = calloc(1, size);
|
2023-05-26 19:14:21 +00:00
|
|
|
maxid = MIN(size / CPUSTATES / sizeof(long) - 1, CPU_SETSIZE - 1);
|
|
|
|
CPU_ZERO(&cpumask);
|
2011-07-11 16:48:52 +00:00
|
|
|
for (i = 0; i <= maxid; i++) {
|
|
|
|
empty = 1;
|
|
|
|
for (j = 0; empty && j < CPUSTATES; j++) {
|
|
|
|
if (times[i * CPUSTATES + j] != 0)
|
|
|
|
empty = 0;
|
2008-01-18 01:43:14 +00:00
|
|
|
}
|
2023-05-26 19:14:21 +00:00
|
|
|
if (!empty)
|
|
|
|
CPU_SET(i, &cpumask);
|
2008-01-18 01:43:14 +00:00
|
|
|
}
|
2023-05-26 19:14:21 +00:00
|
|
|
ncpus = CPU_COUNT(&cpumask);
|
2018-06-03 02:58:53 +00:00
|
|
|
assert(ncpus > 0);
|
|
|
|
pcpu_cp_old = calloc(ncpus * CPUSTATES, sizeof(long));
|
|
|
|
pcpu_cp_diff = calloc(ncpus * CPUSTATES, sizeof(long));
|
|
|
|
pcpu_cpu_states = calloc(ncpus * CPUSTATES, sizeof(int));
|
2011-07-18 21:15:47 +00:00
|
|
|
statics->ncpus = ncpus;
|
2011-07-11 16:48:52 +00:00
|
|
|
|
2019-12-21 05:03:21 +00:00
|
|
|
/* Allocate state of battery units reported via ACPI. */
|
|
|
|
battery_units = 0;
|
|
|
|
size = sizeof(int);
|
|
|
|
sysctlbyname("hw.acpi.battery.units", &battery_units, &size, NULL, 0);
|
|
|
|
statics->nbatteries = battery_units;
|
|
|
|
|
2012-06-27 18:08:48 +00:00
|
|
|
update_layout();
|
2008-01-18 01:43:14 +00:00
|
|
|
|
2004-07-05 13:12:16 +00:00
|
|
|
/* all done! */
|
|
|
|
return (0);
|
1997-03-23 18:55:20 +00:00
|
|
|
}
|
|
|
|
|
2018-06-22 09:21:01 +00:00
|
|
|
char *
|
2018-06-03 22:42:54 +00:00
|
|
|
format_header(const char *uname_field)
|
1997-03-23 18:55:20 +00:00
|
|
|
{
|
2018-06-22 09:21:01 +00:00
|
|
|
static struct sbuf* header = NULL;
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2018-06-22 09:21:01 +00:00
|
|
|
/* clean up from last time. */
|
|
|
|
if (header != NULL) {
|
2018-06-23 22:45:20 +00:00
|
|
|
sbuf_clear(header);
|
|
|
|
} else {
|
|
|
|
header = sbuf_new_auto();
|
2018-06-22 09:21:01 +00:00
|
|
|
}
|
2016-09-05 08:27:04 +00:00
|
|
|
|
2004-07-05 13:12:16 +00:00
|
|
|
switch (displaymode) {
|
2018-06-22 09:21:01 +00:00
|
|
|
case DISP_CPU: {
|
|
|
|
sbuf_printf(header, " %s", ps.thread_id ? " THR" : "PID");
|
|
|
|
sbuf_printf(header, "%*s", ps.jail ? TOP_JID_LEN : 0,
|
|
|
|
ps.jail ? " JID" : "");
|
2018-06-23 22:45:22 +00:00
|
|
|
sbuf_printf(header, " %-*.*s ", namelength, namelength, uname_field);
|
2018-08-08 06:31:46 +00:00
|
|
|
if (!ps.thread) {
|
|
|
|
sbuf_cat(header, "THR ");
|
|
|
|
}
|
|
|
|
sbuf_cat(header, "PRI NICE SIZE RES ");
|
2018-06-23 22:45:22 +00:00
|
|
|
if (ps.swap) {
|
|
|
|
sbuf_printf(header, "%*s ", TOP_SWAP_LEN - 1, "SWAP");
|
|
|
|
}
|
|
|
|
sbuf_cat(header, "STATE ");
|
|
|
|
if (smpmode) {
|
|
|
|
sbuf_cat(header, "C ");
|
|
|
|
}
|
|
|
|
sbuf_cat(header, "TIME ");
|
2018-06-24 13:14:04 +00:00
|
|
|
sbuf_printf(header, " %6s ", ps.wcpu ? "WCPU" : "CPU");
|
2018-06-23 22:45:22 +00:00
|
|
|
sbuf_cat(header, "COMMAND");
|
2018-06-22 09:21:01 +00:00
|
|
|
sbuf_finish(header);
|
2004-07-05 13:12:16 +00:00
|
|
|
break;
|
2018-06-22 09:21:01 +00:00
|
|
|
}
|
|
|
|
case DISP_IO: {
|
2018-06-23 22:45:20 +00:00
|
|
|
sbuf_printf(header, " %s%*s %-*.*s",
|
2018-06-19 23:30:55 +00:00
|
|
|
ps.thread_id ? " THR" : "PID",
|
2018-06-22 09:21:01 +00:00
|
|
|
ps.jail ? TOP_JID_LEN : 0, ps.jail ? " JID" : "",
|
2005-05-18 13:30:08 +00:00
|
|
|
namelength, namelength, uname_field);
|
2018-06-23 22:45:20 +00:00
|
|
|
sbuf_cat(header, " VCSW IVCSW READ WRITE FAULT TOTAL PERCENT COMMAND");
|
2018-07-03 02:54:32 +00:00
|
|
|
sbuf_finish(header);
|
2004-07-05 13:12:16 +00:00
|
|
|
break;
|
2018-06-22 09:21:01 +00:00
|
|
|
}
|
2018-05-21 00:53:42 +00:00
|
|
|
case DISP_MAX:
|
|
|
|
assert("displaymode must not be set to DISP_MAX");
|
2004-07-05 13:12:16 +00:00
|
|
|
}
|
2018-06-22 09:21:01 +00:00
|
|
|
|
|
|
|
return sbuf_data(header);
|
1997-03-23 18:55:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int swappgsin = -1;
|
|
|
|
static int swappgsout = -1;
|
|
|
|
|
2008-01-18 01:43:14 +00:00
|
|
|
|
1997-03-23 18:55:20 +00:00
|
|
|
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
|
|
|
struct loadavg sysload;
|
|
|
|
int mib[2];
|
|
|
|
struct timeval boottime;
|
2012-06-27 18:08:48 +00:00
|
|
|
uint64_t arc_stat, arc_stat2;
|
2008-01-18 01:43:14 +00:00
|
|
|
int i, j;
|
|
|
|
size_t size;
|
2004-07-05 13:12:16 +00:00
|
|
|
|
2011-07-11 16:48:52 +00:00
|
|
|
/* get the CPU stats */
|
|
|
|
size = (maxid + 1) * CPUSTATES * sizeof(long);
|
|
|
|
if (sysctlbyname("kern.cp_times", pcpu_cp_time, &size, NULL, 0) == -1)
|
|
|
|
err(1, "sysctlbyname kern.cp_times");
|
|
|
|
GETSYSCTL("kern.cp_time", cp_time);
|
2004-07-05 13:12:16 +00:00
|
|
|
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
|
|
|
|
2011-07-11 16:48:52 +00:00
|
|
|
/* convert cp_time counts to percentages */
|
|
|
|
for (i = j = 0; i <= maxid; i++) {
|
2023-05-26 19:14:21 +00:00
|
|
|
if (!CPU_ISSET(i, &cpumask))
|
2011-07-11 16:48:52 +00:00
|
|
|
continue;
|
|
|
|
percentages(CPUSTATES, &pcpu_cpu_states[j * CPUSTATES],
|
|
|
|
&pcpu_cp_time[j * CPUSTATES],
|
|
|
|
&pcpu_cp_old[j * CPUSTATES],
|
|
|
|
&pcpu_cp_diff[j * CPUSTATES]);
|
|
|
|
j++;
|
2008-01-18 01:43:14 +00:00
|
|
|
}
|
2011-07-11 16:48:52 +00:00
|
|
|
percentages(CPUSTATES, cpu_states, cp_time, cp_old, cp_diff);
|
2004-07-05 13:12:16 +00:00
|
|
|
|
|
|
|
/* sum memory & swap statistics */
|
|
|
|
{
|
|
|
|
static unsigned int swap_delay = 0;
|
|
|
|
static int swapavail = 0;
|
|
|
|
static int swapfree = 0;
|
2009-03-10 15:25:19 +00:00
|
|
|
static long bufspace = 0;
|
- Remove 'struct vmmeter' from 'struct pcpu', leaving only global vmmeter
in place. To do per-cpu stats, convert all fields that previously were
maintained in the vmmeters that sit in pcpus to counter(9).
- Since some vmmeter stats may be touched at very early stages of boot,
before we have set up UMA and we can do counter_u64_alloc(), provide an
early counter mechanism:
o Leave one spare uint64_t in struct pcpu, named pc_early_dummy_counter.
o Point counter(9) fields of vmmeter to pcpu[0].pc_early_dummy_counter,
so that at early stages of boot, before counters are allocated we already
point to a counter that can be safely written to.
o For sparc64 that required a whole dummy pcpu[MAXCPU] array.
Further related changes:
- Don't include vmmeter.h into pcpu.h.
- vm.stats.vm.v_swappgsout and vm.stats.vm.v_swappgsin changed to 64-bit,
to match kernel representation.
- struct vmmeter hidden under _KERNEL, and only vmstat(1) is an exclusion.
This is based on benno@'s 4-year old patch:
https://lists.freebsd.org/pipermail/freebsd-arch/2013-July/014471.html
Reviewed by: kib, gallatin, marius, lidl
Differential Revision: https://reviews.freebsd.org/D10156
2017-04-17 17:34:47 +00:00
|
|
|
static uint64_t nspgsin, nspgsout;
|
2004-07-05 13:12:16 +00:00
|
|
|
|
|
|
|
GETSYSCTL("vfs.bufspace", bufspace);
|
|
|
|
GETSYSCTL("vm.stats.vm.v_active_count", memory_stats[0]);
|
|
|
|
GETSYSCTL("vm.stats.vm.v_inactive_count", memory_stats[1]);
|
2016-11-10 19:55:45 +00:00
|
|
|
GETSYSCTL("vm.stats.vm.v_laundry_count", memory_stats[2]);
|
|
|
|
GETSYSCTL("vm.stats.vm.v_wire_count", memory_stats[3]);
|
2004-07-05 13:12:16 +00:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2012-06-27 18:08:48 +00:00
|
|
|
if (arc_enabled) {
|
|
|
|
GETSYSCTL("kstat.zfs.misc.arcstats.size", arc_stat);
|
|
|
|
arc_stats[0] = arc_stat >> 10;
|
|
|
|
GETSYSCTL("vfs.zfs.mfu_size", arc_stat);
|
|
|
|
arc_stats[1] = arc_stat >> 10;
|
|
|
|
GETSYSCTL("vfs.zfs.mru_size", arc_stat);
|
|
|
|
arc_stats[2] = arc_stat >> 10;
|
|
|
|
GETSYSCTL("vfs.zfs.anon_size", arc_stat);
|
|
|
|
arc_stats[3] = arc_stat >> 10;
|
|
|
|
GETSYSCTL("kstat.zfs.misc.arcstats.hdr_size", arc_stat);
|
|
|
|
GETSYSCTL("kstat.zfs.misc.arcstats.l2_hdr_size", arc_stat2);
|
top(1): Quiesce several warnings
This is all warnings at level six (6) that are not
char-subscripts, incompatible-pointer-types,
sign-compare, switch, int-conversion,
missing-variable-declarations, cast-qual, cast-align
Some warnings that are fixed by this commit are:
shadow, strict-prototypes, missing-prototypes, pointer-arith,
unused-parameter, unused-const-variable, and several others
2018-05-20 02:14:27 +00:00
|
|
|
arc_stats[4] = (arc_stat + arc_stat2) >> 10;
|
2018-08-11 22:11:12 +00:00
|
|
|
GETSYSCTL("kstat.zfs.misc.arcstats.bonus_size", arc_stat);
|
2012-06-27 18:08:48 +00:00
|
|
|
arc_stats[5] = arc_stat >> 10;
|
2018-08-11 22:11:12 +00:00
|
|
|
GETSYSCTL("kstat.zfs.misc.arcstats.dnode_size", arc_stat);
|
|
|
|
arc_stats[5] += arc_stat >> 10;
|
|
|
|
GETSYSCTL("kstat.zfs.misc.arcstats.dbuf_size", arc_stat);
|
|
|
|
arc_stats[5] += arc_stat >> 10;
|
2012-06-27 18:08:48 +00:00
|
|
|
si->arc = arc_stats;
|
|
|
|
}
|
Add ZFS compressed ARC stats to top(1)
Provides:
amount of compressed data
logical size of compressed data (how much it would have taken uncompressed)
compression ratio (logical size : total ARC size)
Overhead (space consumed for compression headers)
Example output:
ARC: 31G Total, 18G MFU, 9067M MRU, 2236K Anon, 615M Header, 2947M Other
25G Compressed, 54G Uncompressed, 1.76:1 Ratio, 2265M Overhead
Reviewed by: jpaetzel, smh, imp, jhb (previous version)
MFC after: 2 week
Relnotes: yes
Sponsored by: ScaleEngine Inc.
Differential Revision: https://reviews.freebsd.org/D9829
2017-03-17 00:46:50 +00:00
|
|
|
if (carc_enabled) {
|
|
|
|
GETSYSCTL("kstat.zfs.misc.arcstats.compressed_size", arc_stat);
|
|
|
|
carc_stats[0] = arc_stat >> 10;
|
2017-06-12 19:51:57 +00:00
|
|
|
carc_stats[2] = arc_stat >> 10; /* For ratio */
|
Add ZFS compressed ARC stats to top(1)
Provides:
amount of compressed data
logical size of compressed data (how much it would have taken uncompressed)
compression ratio (logical size : total ARC size)
Overhead (space consumed for compression headers)
Example output:
ARC: 31G Total, 18G MFU, 9067M MRU, 2236K Anon, 615M Header, 2947M Other
25G Compressed, 54G Uncompressed, 1.76:1 Ratio, 2265M Overhead
Reviewed by: jpaetzel, smh, imp, jhb (previous version)
MFC after: 2 week
Relnotes: yes
Sponsored by: ScaleEngine Inc.
Differential Revision: https://reviews.freebsd.org/D9829
2017-03-17 00:46:50 +00:00
|
|
|
GETSYSCTL("kstat.zfs.misc.arcstats.uncompressed_size", arc_stat);
|
|
|
|
carc_stats[1] = arc_stat >> 10;
|
|
|
|
si->carc = carc_stats;
|
|
|
|
}
|
2017-01-09 00:29:23 +00:00
|
|
|
|
2004-07-05 13:12:16 +00:00
|
|
|
/* set arrays and strings */
|
2008-01-18 01:43:14 +00:00
|
|
|
if (pcpu_stats) {
|
|
|
|
si->cpustates = pcpu_cpu_states;
|
|
|
|
si->ncpus = ncpus;
|
|
|
|
} else {
|
|
|
|
si->cpustates = cpu_states;
|
|
|
|
si->ncpus = 1;
|
|
|
|
}
|
2004-07-05 13:12:16 +00:00
|
|
|
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;
|
2012-06-27 18:08:48 +00:00
|
|
|
size = sizeof(boottime);
|
2017-01-09 00:29:23 +00:00
|
|
|
if (sysctl(mib, nitems(mib), &boottime, &size, NULL, 0) != -1 &&
|
2004-07-05 13:12:16 +00:00
|
|
|
boottime.tv_sec != 0) {
|
|
|
|
si->boottime = boottime;
|
|
|
|
} else {
|
|
|
|
si->boottime.tv_sec = -1;
|
1997-03-23 18:55:20 +00:00
|
|
|
}
|
2019-12-21 05:03:21 +00:00
|
|
|
|
|
|
|
battery_life = 0;
|
|
|
|
if (battery_units > 0) {
|
|
|
|
GETSYSCTL("hw.acpi.battery.life", battery_life);
|
|
|
|
}
|
|
|
|
si->battery = battery_life;
|
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.
|
|
|
|
*/
|
2018-05-21 00:53:42 +00:00
|
|
|
static const struct kinfo_proc *
|
2004-07-01 09:12:38 +00:00
|
|
|
get_old_proc(struct kinfo_proc *pp)
|
|
|
|
{
|
2018-06-08 01:55:47 +00:00
|
|
|
const struct kinfo_proc * const *oldpp, *oldp;
|
2004-07-01 09:12:38 +00:00
|
|
|
|
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,
|
2011-07-18 17:33:08 +00:00
|
|
|
sizeof(*previous_pref), ps.thread ? compare_tid : 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;
|
2018-06-04 04:59:32 +00:00
|
|
|
if (memcmp(&oldp->ki_start, &pp->ki_start, sizeof(pp->ki_start)) != 0) {
|
2004-07-12 04:55:07 +00:00
|
|
|
pp->ki_udata = NOPROC;
|
2004-07-01 09:12:38 +00:00
|
|
|
return (NULL);
|
2004-07-12 04:55:07 +00:00
|
|
|
}
|
2019-02-10 13:31:08 +00:00
|
|
|
pp->ki_udata = __DECONST(void *, 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.
|
|
|
|
*/
|
2018-05-21 00:53:42 +00:00
|
|
|
static long
|
2018-06-03 22:42:54 +00:00
|
|
|
get_io_stats(const struct kinfo_proc *pp, long *inp, long *oup, long *flp,
|
2006-05-04 03:00:13 +00:00
|
|
|
long *vcsw, long *ivcsw)
|
2004-07-01 09:12:38 +00:00
|
|
|
{
|
|
|
|
const struct kinfo_proc *oldp;
|
|
|
|
static struct kinfo_proc dummy;
|
|
|
|
long ret;
|
|
|
|
|
2019-02-10 13:31:08 +00:00
|
|
|
oldp = get_old_proc(__DECONST(struct kinfo_proc *, pp));
|
2004-07-01 09:12:38 +00:00
|
|
|
if (oldp == NULL) {
|
2018-06-04 04:59:32 +00:00
|
|
|
memset(&dummy, 0, sizeof(dummy));
|
2004-07-01 09:12:38 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2014-05-30 21:18:53 +00:00
|
|
|
/*
|
|
|
|
* If there was a previous update, use the delta in ki_runtime over
|
|
|
|
* the previous interval to calculate pctcpu. Otherwise, fall back
|
|
|
|
* to using the kernel's ki_pctcpu.
|
|
|
|
*/
|
|
|
|
static double
|
|
|
|
proc_calc_pctcpu(struct kinfo_proc *pp)
|
|
|
|
{
|
|
|
|
const struct kinfo_proc *oldp;
|
|
|
|
|
|
|
|
if (previous_interval != 0) {
|
|
|
|
oldp = get_old_proc(pp);
|
|
|
|
if (oldp != NULL)
|
|
|
|
return ((double)(pp->ki_runtime - oldp->ki_runtime)
|
|
|
|
/ previous_interval);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If this process/thread was created during the previous
|
|
|
|
* interval, charge it's total runtime to the previous
|
|
|
|
* interval.
|
|
|
|
*/
|
|
|
|
else if (pp->ki_start.tv_sec > previous_wall_time.tv_sec ||
|
|
|
|
(pp->ki_start.tv_sec == previous_wall_time.tv_sec &&
|
|
|
|
pp->ki_start.tv_usec >= previous_wall_time.tv_usec))
|
|
|
|
return ((double)pp->ki_runtime / previous_interval);
|
|
|
|
}
|
|
|
|
return (pctdouble(pp->ki_pctcpu));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return true if this process has used any CPU time since the
|
|
|
|
* previous update.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
proc_used_cpu(struct kinfo_proc *pp)
|
|
|
|
{
|
|
|
|
const struct kinfo_proc *oldp;
|
|
|
|
|
|
|
|
oldp = get_old_proc(pp);
|
|
|
|
if (oldp == NULL)
|
|
|
|
return (PCTCPU(pp) != 0);
|
|
|
|
return (pp->ki_runtime != oldp->ki_runtime ||
|
|
|
|
RU(pp)->ru_nvcsw != RU(oldp)->ru_nvcsw ||
|
|
|
|
RU(pp)->ru_nivcsw != RU(oldp)->ru_nivcsw);
|
|
|
|
}
|
|
|
|
|
2004-08-01 09:19:41 +00:00
|
|
|
/*
|
|
|
|
* Return the total number of block in/out and faults by a process.
|
|
|
|
*/
|
2018-05-21 00:53:42 +00:00
|
|
|
static long
|
2018-06-03 22:42:54 +00:00
|
|
|
get_io_total(const struct kinfo_proc *pp)
|
2004-07-01 15:49:28 +00:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
2018-05-21 09:25:21 +00:00
|
|
|
void *
|
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;
|
2014-05-30 21:18:53 +00:00
|
|
|
long nsec;
|
2004-07-05 13:12:16 +00:00
|
|
|
int active_procs;
|
|
|
|
struct kinfo_proc **prefp;
|
|
|
|
struct kinfo_proc *pp;
|
2014-05-30 21:18:53 +00:00
|
|
|
struct timespec previous_proc_uptime;
|
2004-07-05 13:12:16 +00:00
|
|
|
|
2014-05-30 21:18:53 +00:00
|
|
|
/*
|
|
|
|
* If thread state was toggled, don't cache the previous processes.
|
|
|
|
*/
|
|
|
|
if (previous_thread != sel->thread)
|
|
|
|
nproc = 0;
|
|
|
|
previous_thread = sel->thread;
|
|
|
|
|
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);
|
2018-06-02 21:40:45 +00:00
|
|
|
previous_procs = calloc(nproc, sizeof(*previous_procs));
|
2004-07-05 13:12:16 +00:00
|
|
|
free(previous_pref);
|
2018-06-02 21:40:45 +00:00
|
|
|
previous_pref = calloc(nproc, sizeof(*previous_pref));
|
2004-07-05 13:12:16 +00:00
|
|
|
if (previous_procs == NULL || previous_pref == NULL) {
|
2018-06-02 21:40:45 +00:00
|
|
|
fprintf(stderr, "top: Out of memory.\n");
|
2018-06-02 15:52:18 +00:00
|
|
|
quit(TOP_EX_SYS_ERROR);
|
2004-07-05 13:12:16 +00:00
|
|
|
}
|
|
|
|
previous_proc_count_max = nproc;
|
|
|
|
}
|
|
|
|
if (nproc) {
|
|
|
|
for (i = 0; i < nproc; i++)
|
|
|
|
previous_pref[i] = &previous_procs[i];
|
2018-06-04 04:59:24 +00:00
|
|
|
memcpy(previous_procs, pbase, nproc * sizeof(*previous_procs));
|
2006-05-04 03:00:13 +00:00
|
|
|
qsort(previous_pref, nproc, sizeof(*previous_pref),
|
2011-07-18 17:33:08 +00:00
|
|
|
ps.thread ? compare_tid : compare_pid);
|
2004-07-05 13:12:16 +00:00
|
|
|
}
|
|
|
|
previous_proc_count = nproc;
|
2014-05-30 21:18:53 +00:00
|
|
|
previous_proc_uptime = proc_uptime;
|
|
|
|
previous_wall_time = proc_wall_time;
|
|
|
|
previous_interval = 0;
|
2004-07-05 13:12:16 +00:00
|
|
|
|
2011-07-15 17:23:45 +00:00
|
|
|
pbase = kvm_getprocs(kd, sel->thread ? KERN_PROC_ALL : KERN_PROC_PROC,
|
|
|
|
0, &nproc);
|
2018-06-08 02:03:51 +00:00
|
|
|
gettimeofday(&proc_wall_time, NULL);
|
2014-05-30 21:18:53 +00:00
|
|
|
if (clock_gettime(CLOCK_UPTIME, &proc_uptime) != 0)
|
|
|
|
memset(&proc_uptime, 0, sizeof(proc_uptime));
|
|
|
|
else if (previous_proc_uptime.tv_sec != 0 &&
|
|
|
|
previous_proc_uptime.tv_nsec != 0) {
|
|
|
|
previous_interval = (proc_uptime.tv_sec -
|
|
|
|
previous_proc_uptime.tv_sec) * 1000000;
|
|
|
|
nsec = proc_uptime.tv_nsec - previous_proc_uptime.tv_nsec;
|
|
|
|
if (nsec < 0) {
|
|
|
|
previous_interval -= 1000000;
|
|
|
|
nsec += 1000000000;
|
|
|
|
}
|
|
|
|
previous_interval += nsec / 1000;
|
|
|
|
}
|
|
|
|
if (nproc > onproc) {
|
|
|
|
pref = realloc(pref, sizeof(*pref) * nproc);
|
|
|
|
pcpu = realloc(pcpu, sizeof(*pcpu) * nproc);
|
|
|
|
onproc = nproc;
|
|
|
|
}
|
|
|
|
if (pref == NULL || pbase == NULL || pcpu == NULL) {
|
2018-06-08 02:03:51 +00:00
|
|
|
fprintf(stderr, "top: Out of memory.\n");
|
2018-06-02 15:52:18 +00:00
|
|
|
quit(TOP_EX_SYS_ERROR);
|
2004-07-05 13:12:16 +00:00
|
|
|
}
|
|
|
|
/* get a pointer to the states summary array */
|
|
|
|
si->procstates = process_states;
|
|
|
|
|
|
|
|
/* 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;
|
2018-06-02 04:20:42 +00:00
|
|
|
memset(process_states, 0, sizeof(process_states));
|
2004-07-05 13:12:16 +00:00
|
|
|
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
|
|
|
|
2018-06-09 23:08:02 +00:00
|
|
|
if (!sel->self && pp->ki_pid == mypid && sel->pid == -1)
|
2004-07-05 13:12:16 +00:00
|
|
|
/* skip self */
|
|
|
|
continue;
|
|
|
|
|
2018-06-09 23:08:02 +00:00
|
|
|
if (!sel->system && (pp->ki_flag & P_SYSTEM) && sel->pid == -1)
|
2004-07-05 13:12:16 +00:00
|
|
|
/* 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++;
|
2018-05-21 00:32:48 +00:00
|
|
|
process_states[(unsigned char)pp->ki_stat]++;
|
2004-07-05 13:12:16 +00:00
|
|
|
|
|
|
|
if (pp->ki_stat == SZOMB)
|
|
|
|
/* skip zombies */
|
|
|
|
continue;
|
|
|
|
|
2018-06-09 23:08:02 +00:00
|
|
|
if (!sel->kidle && pp->ki_tdflags & TDF_IDLETD && sel->pid == -1)
|
2011-07-07 13:37:46 +00:00
|
|
|
/* skip kernel idle process */
|
|
|
|
continue;
|
2014-05-30 21:18:53 +00:00
|
|
|
|
|
|
|
PCTCPU(pp) = proc_calc_pctcpu(pp);
|
Cap the percent CPU of individual threads at 100% to fix some of the
more obvious imprecision in the previous top changes.
Specifically, top uses a delta of clock_gettime() calls right after
invoking the kern.proc sysctl to fetch the process/thread list to
compute the time delta between the fetches. However, the kern.proc
sysctl handler does not run in constant time. It can spin on locks,
be preempted by an interrupt handler, etc. As a result, the time
between the gathering of stats for individual processes or threads
between subsequent kern.proc handlers can vary. If a "slow" kern.proc
run is followed by a "fast" kern.proc run, then the threads/processes
at the start of the "slow" run will have a longer time delta than the
threads/processes at the end. If the clock_gettime() time delta is
not itself skewed by preemption, then the delta may be too short for
a given thread/process resulting in a higher percent CPU than actual.
However, there is no good way to calculate the exact amount of overage,
nor to know which threads to subtract the overage from. Instead, just
punt and fix the definitely-wrong case of an individual thread having
more than 100% CPU.
Discussed with: zonk
2014-06-20 19:54:23 +00:00
|
|
|
if (sel->thread && PCTCPU(pp) > 1.0)
|
|
|
|
PCTCPU(pp) = 1.0;
|
2018-06-08 02:03:51 +00:00
|
|
|
if (displaymode == DISP_CPU && !sel->idle &&
|
2014-05-30 21:18:53 +00:00
|
|
|
(!proc_used_cpu(pp) ||
|
2006-06-11 19:18:39 +00:00
|
|
|
pp->ki_stat == SSTOP || pp->ki_stat == SIDL))
|
2004-07-05 13:12:16 +00:00
|
|
|
/* skip idle or non-running processes */
|
|
|
|
continue;
|
|
|
|
|
2018-06-08 02:03:51 +00:00
|
|
|
if (displaymode == DISP_IO && !sel->idle && p_io == 0)
|
2004-07-05 13:12:16 +00:00
|
|
|
/* skip processes that aren't doing I/O */
|
|
|
|
continue;
|
|
|
|
|
2018-06-08 02:03:51 +00:00
|
|
|
if (sel->jid != -1 && pp->ki_jid != sel->jid)
|
2014-05-02 23:30:39 +00:00
|
|
|
/* skip proc. that don't belong to the selected JID */
|
|
|
|
continue;
|
|
|
|
|
2018-06-08 02:03:51 +00:00
|
|
|
if (sel->uid[0] != -1 && !find_uid(pp->ki_ruid, 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;
|
|
|
|
|
2018-06-08 02:03:51 +00:00
|
|
|
if (sel->pid != -1 && pp->ki_pid != sel->pid)
|
2018-06-02 15:52:18 +00:00
|
|
|
continue;
|
|
|
|
|
2021-06-16 19:40:21 +00:00
|
|
|
if (!cmd_matches(pp, sel->command))
|
|
|
|
/* skip proc. that doesn't match grep string */
|
|
|
|
continue;
|
|
|
|
|
2011-07-15 17:23:45 +00:00
|
|
|
*prefp++ = pp;
|
|
|
|
active_procs++;
|
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;
|
2018-05-21 04:40:20 +00:00
|
|
|
si->p_pactive = pref_len = active_procs;
|
2004-07-05 13:12:16 +00:00
|
|
|
|
|
|
|
/* pass back a handle */
|
|
|
|
handle.next_proc = pref;
|
|
|
|
handle.remaining = active_procs;
|
2018-06-08 02:03:51 +00:00
|
|
|
return (&handle);
|
1997-03-23 18:55:20 +00:00
|
|
|
}
|
|
|
|
|
2021-06-16 19:40:21 +00:00
|
|
|
static int
|
|
|
|
cmd_matches(struct kinfo_proc *proc, const char *term)
|
|
|
|
{
|
|
|
|
char **args = NULL;
|
|
|
|
|
|
|
|
if (!term) {
|
|
|
|
/* No command filter set */
|
|
|
|
return 1;
|
|
|
|
} else {
|
|
|
|
/* Filter set, does process name contain term? */
|
|
|
|
if (strstr(proc->ki_comm, term))
|
|
|
|
return 1;
|
|
|
|
/* Search arguments only if arguments are displayed */
|
|
|
|
if (show_args) {
|
|
|
|
args = kvm_getargv(kd, proc, 1024);
|
|
|
|
if (args == NULL) {
|
|
|
|
/* Failed to get arguments so can't search them */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
while (*args != NULL) {
|
|
|
|
if (strstr(*args, term))
|
|
|
|
return 1;
|
|
|
|
args++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-06-30 04:19:23 +00:00
|
|
|
char *
|
2018-06-22 10:17:12 +00:00
|
|
|
format_next_process(struct handle * xhandle, 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;
|
2018-05-22 07:56:58 +00:00
|
|
|
char status[22];
|
2018-05-21 00:53:42 +00:00
|
|
|
size_t state;
|
2004-07-05 13:12:16 +00:00
|
|
|
struct rusage ru, *rup;
|
|
|
|
long p_tot, s_tot;
|
2007-04-14 10:16:52 +00:00
|
|
|
char *cmdbuf = NULL;
|
2018-06-03 23:40:54 +00:00
|
|
|
char **args;
|
2018-06-23 22:45:20 +00:00
|
|
|
static struct sbuf* procbuf = NULL;
|
|
|
|
|
|
|
|
/* clean up from last time. */
|
|
|
|
if (procbuf != NULL) {
|
|
|
|
sbuf_clear(procbuf);
|
|
|
|
} else {
|
|
|
|
procbuf = sbuf_new_auto();
|
|
|
|
}
|
|
|
|
|
2004-07-05 13:12:16 +00:00
|
|
|
|
|
|
|
/* find and remember the next proc structure */
|
2018-06-22 10:17:12 +00:00
|
|
|
pp = *(xhandle->next_proc++);
|
|
|
|
xhandle->remaining--;
|
2004-07-05 13:12:16 +00:00
|
|
|
|
|
|
|
/* get the process's command name */
|
2007-09-17 05:31:39 +00:00
|
|
|
if ((pp->ki_flag & P_INMEM) == 0) {
|
2004-07-05 13:12:16 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
|
|
|
/* generate "STATE" field */
|
|
|
|
switch (state = pp->ki_stat) {
|
1997-03-23 18:55:20 +00:00
|
|
|
case SRUN:
|
2014-10-29 19:21:19 +00:00
|
|
|
if (smpmode && pp->ki_oncpu != NOCPU)
|
2004-07-05 13:12:16 +00:00
|
|
|
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:
|
top(1): Quiesce several warnings
This is all warnings at level six (6) that are not
char-subscripts, incompatible-pointer-types,
sign-compare, switch, int-conversion,
missing-variable-declarations, cast-qual, cast-align
Some warnings that are fixed by this commit are:
shadow, strict-prototypes, missing-prototypes, pointer-arith,
unused-parameter, unused-const-variable, and several others
2018-05-20 02:14:27 +00:00
|
|
|
sprintf(status, "%.6s", pp->ki_wmesg);
|
|
|
|
break;
|
1997-03-23 18:55:20 +00:00
|
|
|
default:
|
1999-02-06 16:58:50 +00:00
|
|
|
|
2018-06-03 22:42:54 +00:00
|
|
|
if (state < nitems(state_abbrev)) {
|
2004-07-05 14:45:57 +00:00
|
|
|
sprintf(status, "%.6s", state_abbrev[state]);
|
2018-06-03 22:42:54 +00:00
|
|
|
} else {
|
2018-05-21 01:39:26 +00:00
|
|
|
sprintf(status, "?%5zu", state);
|
2018-06-03 22:42:54 +00:00
|
|
|
}
|
2004-07-05 13:12:16 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2018-07-06 12:07:06 +00:00
|
|
|
cmdbuf = calloc(screen_width + 1, 1);
|
2007-04-14 10:16:52 +00:00
|
|
|
if (cmdbuf == NULL) {
|
2018-07-06 12:07:06 +00:00
|
|
|
warn("calloc(%d)", screen_width + 1);
|
2007-04-14 10:16:52 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(flags & FMT_SHOWARGS)) {
|
2007-10-26 08:00:41 +00:00
|
|
|
if (ps.thread && pp->ki_flag & P_HADTHREADS &&
|
2011-07-18 20:06:15 +00:00
|
|
|
pp->ki_tdname[0]) {
|
2018-07-06 12:07:06 +00:00
|
|
|
snprintf(cmdbuf, screen_width, "%s{%s%s}", pp->ki_comm,
|
2016-12-07 15:04:22 +00:00
|
|
|
pp->ki_tdname, pp->ki_moretdname);
|
2007-10-26 08:00:41 +00:00
|
|
|
} else {
|
2018-07-06 12:07:06 +00:00
|
|
|
snprintf(cmdbuf, screen_width, "%s", pp->ki_comm);
|
2007-04-14 10:16:52 +00:00
|
|
|
}
|
2007-10-26 08:00:41 +00:00
|
|
|
} else {
|
|
|
|
if (pp->ki_flag & P_SYSTEM ||
|
2018-07-06 12:07:06 +00:00
|
|
|
(args = kvm_getargv(kd, pp, screen_width)) == NULL ||
|
2007-10-26 08:00:41 +00:00
|
|
|
!(*args)) {
|
|
|
|
if (ps.thread && pp->ki_flag & P_HADTHREADS &&
|
2011-07-18 20:06:15 +00:00
|
|
|
pp->ki_tdname[0]) {
|
2018-07-06 12:07:06 +00:00
|
|
|
snprintf(cmdbuf, screen_width,
|
2016-12-07 15:04:22 +00:00
|
|
|
"[%s{%s%s}]", pp->ki_comm, pp->ki_tdname,
|
|
|
|
pp->ki_moretdname);
|
2007-10-26 08:00:41 +00:00
|
|
|
} else {
|
2018-07-06 12:07:06 +00:00
|
|
|
snprintf(cmdbuf, screen_width,
|
2007-10-26 08:00:41 +00:00
|
|
|
"[%s]", pp->ki_comm);
|
|
|
|
}
|
|
|
|
} else {
|
2018-06-03 23:40:54 +00:00
|
|
|
const char *src;
|
|
|
|
char *dst, *argbuf;
|
|
|
|
const char *cmd;
|
2007-10-26 08:00:41 +00:00
|
|
|
size_t argbuflen;
|
|
|
|
size_t len;
|
|
|
|
|
2018-07-06 12:07:06 +00:00
|
|
|
argbuflen = screen_width * 4;
|
2018-06-02 21:40:45 +00:00
|
|
|
argbuf = calloc(argbuflen + 1, 1);
|
2007-10-26 08:00:41 +00:00
|
|
|
if (argbuf == NULL) {
|
2018-06-02 21:40:45 +00:00
|
|
|
warn("calloc(%zu)", argbuflen + 1);
|
2007-10-26 08:00:41 +00:00
|
|
|
free(cmdbuf);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
dst = argbuf;
|
|
|
|
|
|
|
|
/* Extract cmd name from argv */
|
2018-06-23 22:45:18 +00:00
|
|
|
cmd = basename(*args);
|
2007-10-26 08:00:41 +00:00
|
|
|
|
|
|
|
for (; (src = *args++) != NULL; ) {
|
|
|
|
if (*src == '\0')
|
|
|
|
continue;
|
|
|
|
len = (argbuflen - (dst - argbuf) - 1) / 4;
|
2018-07-10 03:49:48 +00:00
|
|
|
strvisx(dst, src,
|
|
|
|
MIN(strlen(src), len),
|
2020-07-14 22:43:40 +00:00
|
|
|
VIS_NL | VIS_TAB | VIS_CSTYLE | VIS_OCTAL);
|
2007-10-26 08:00:41 +00:00
|
|
|
while (*dst != '\0')
|
|
|
|
dst++;
|
|
|
|
if ((argbuflen - (dst - argbuf) - 1) / 4 > 0)
|
|
|
|
*dst++ = ' '; /* add delimiting space */
|
|
|
|
}
|
|
|
|
if (dst != argbuf && dst[-1] == ' ')
|
|
|
|
dst--;
|
|
|
|
*dst = '\0';
|
|
|
|
|
2012-11-19 08:03:40 +00:00
|
|
|
if (strcmp(cmd, pp->ki_comm) != 0) {
|
2011-07-18 20:57:43 +00:00
|
|
|
if (ps.thread && pp->ki_flag & P_HADTHREADS &&
|
|
|
|
pp->ki_tdname[0])
|
2018-07-06 12:07:06 +00:00
|
|
|
snprintf(cmdbuf, screen_width,
|
2016-12-07 15:04:22 +00:00
|
|
|
"%s (%s){%s%s}", argbuf,
|
|
|
|
pp->ki_comm, pp->ki_tdname,
|
|
|
|
pp->ki_moretdname);
|
2011-07-18 20:57:43 +00:00
|
|
|
else
|
2018-07-06 12:07:06 +00:00
|
|
|
snprintf(cmdbuf, screen_width,
|
2011-07-18 20:57:43 +00:00
|
|
|
"%s (%s)", argbuf, pp->ki_comm);
|
|
|
|
} else {
|
|
|
|
if (ps.thread && pp->ki_flag & P_HADTHREADS &&
|
|
|
|
pp->ki_tdname[0])
|
2018-07-06 12:07:06 +00:00
|
|
|
snprintf(cmdbuf, screen_width,
|
2016-12-07 15:04:22 +00:00
|
|
|
"%s{%s%s}", argbuf, pp->ki_tdname,
|
|
|
|
pp->ki_moretdname);
|
2011-07-18 20:57:43 +00:00
|
|
|
else
|
2018-07-06 12:07:06 +00:00
|
|
|
strlcpy(cmdbuf, argbuf, screen_width);
|
2011-07-18 20:57:43 +00:00
|
|
|
}
|
2007-10-26 08:00:41 +00:00
|
|
|
free(argbuf);
|
2007-04-14 10:16:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
2018-06-23 22:45:22 +00:00
|
|
|
sbuf_printf(procbuf, "%5d ", (ps.thread_id) ? pp->ki_tid : pp->ki_pid);
|
2005-04-14 15:02:03 +00:00
|
|
|
|
2018-06-23 22:45:22 +00:00
|
|
|
if (ps.jail) {
|
|
|
|
sbuf_printf(procbuf, "%*d ", TOP_JID_LEN - 1, pp->ki_jid);
|
|
|
|
}
|
|
|
|
sbuf_printf(procbuf, "%-*.*s", namelength, namelength, (*get_userid)(pp->ki_ruid));
|
|
|
|
sbuf_printf(procbuf, "%6ld ", rup->ru_nvcsw);
|
|
|
|
sbuf_printf(procbuf, "%6ld ", rup->ru_nivcsw);
|
|
|
|
sbuf_printf(procbuf, "%6ld ", rup->ru_inblock);
|
|
|
|
sbuf_printf(procbuf, "%6ld ", rup->ru_oublock);
|
|
|
|
sbuf_printf(procbuf, "%6ld ", rup->ru_majflt);
|
|
|
|
sbuf_printf(procbuf, "%6ld ", p_tot);
|
|
|
|
sbuf_printf(procbuf, "%6.2f%% ", s_tot == 0 ? 0.0 : (p_tot * 100.0 / s_tot));
|
2005-04-14 15:02:03 +00:00
|
|
|
|
2018-06-23 22:45:22 +00:00
|
|
|
} else {
|
|
|
|
sbuf_printf(procbuf, "%5d ", (ps.thread_id) ? pp->ki_tid : pp->ki_pid);
|
|
|
|
if (ps.jail) {
|
|
|
|
sbuf_printf(procbuf, "%*d ", TOP_JID_LEN - 1, pp->ki_jid);
|
|
|
|
}
|
|
|
|
sbuf_printf(procbuf, "%-*.*s ", namelength, namelength, (*get_userid)(pp->ki_ruid));
|
|
|
|
|
|
|
|
if (!ps.thread) {
|
|
|
|
sbuf_printf(procbuf, "%4d ", pp->ki_numthreads);
|
2018-08-25 15:59:51 +00:00
|
|
|
} else {
|
|
|
|
sbuf_printf(procbuf, " ");
|
2018-06-23 22:45:22 +00:00
|
|
|
}
|
1997-03-23 18:55:20 +00:00
|
|
|
|
2018-06-23 22:45:22 +00:00
|
|
|
sbuf_printf(procbuf, "%3d ", pp->ki_pri.pri_level - PZERO);
|
|
|
|
sbuf_printf(procbuf, "%4s", format_nice(pp));
|
2018-07-25 14:05:17 +00:00
|
|
|
sbuf_printf(procbuf, "%7s ", format_k(PROCSIZE(pp)));
|
|
|
|
sbuf_printf(procbuf, "%6s ", format_k(pagetok(pp->ki_rssize)));
|
2018-06-23 22:45:22 +00:00
|
|
|
if (ps.swap) {
|
|
|
|
sbuf_printf(procbuf, "%*s ",
|
|
|
|
TOP_SWAP_LEN - 1,
|
|
|
|
format_k(pagetok(ki_swap(pp))));
|
|
|
|
}
|
|
|
|
sbuf_printf(procbuf, "%-6.6s ", status);
|
|
|
|
if (smpmode) {
|
|
|
|
int cpu;
|
|
|
|
if (state == SRUN && pp->ki_oncpu != NOCPU) {
|
|
|
|
cpu = pp->ki_oncpu;
|
|
|
|
} else {
|
|
|
|
cpu = pp->ki_lastcpu;
|
|
|
|
}
|
|
|
|
sbuf_printf(procbuf, "%3d ", cpu);
|
|
|
|
}
|
2018-06-24 13:14:04 +00:00
|
|
|
sbuf_printf(procbuf, "%6s ", format_time(cputime));
|
2018-06-23 22:45:22 +00:00
|
|
|
sbuf_printf(procbuf, "%6.2f%% ", ps.wcpu ? 100.0 * weighted_cpu(PCTCPU(pp), pp) : 100.0 * PCTCPU(pp));
|
|
|
|
}
|
2019-09-20 17:37:23 +00:00
|
|
|
sbuf_printf(procbuf, "%s", cmdbuf);
|
2018-06-23 22:45:22 +00:00
|
|
|
free(cmdbuf);
|
2018-06-23 22:45:20 +00:00
|
|
|
return (sbuf_data(procbuf));
|
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));
|
2018-06-02 15:52:18 +00:00
|
|
|
quit(TOP_EX_SYS_ERROR);
|
2004-07-05 13:12:16 +00:00
|
|
|
}
|
|
|
|
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);
|
2018-06-02 15:52:18 +00:00
|
|
|
quit(TOP_EX_SYS_ERROR);
|
2004-07-05 13:12:16 +00:00
|
|
|
}
|
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
|
|
|
{
|
2016-02-09 18:35:37 +00:00
|
|
|
const char *fifo, *kproc;
|
2006-11-07 10:03:10 +00:00
|
|
|
int rtpri;
|
|
|
|
static char nicebuf[4 + 1];
|
|
|
|
|
|
|
|
fifo = PRI_NEED_RR(pp->ki_pri.pri_class) ? "" : "F";
|
2016-02-09 18:35:37 +00:00
|
|
|
kproc = (pp->ki_flag & P_KPROC) ? "k" : "";
|
2006-11-07 10:03:10 +00:00
|
|
|
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.
|
|
|
|
*/
|
2016-02-09 16:30:16 +00:00
|
|
|
rtpri = ((pp->ki_flag & P_KPROC) ? pp->ki_pri.pri_native :
|
2007-06-15 12:03:07 +00:00
|
|
|
pp->ki_pri.pri_user) - PRI_MIN_REALTIME;
|
2006-11-07 10:03:10 +00:00
|
|
|
snprintf(nicebuf, sizeof(nicebuf), "%sr%d%s",
|
2016-02-09 18:35:37 +00:00
|
|
|
kproc, rtpri, fifo);
|
2006-11-07 10:03:10 +00:00
|
|
|
break;
|
|
|
|
case PRI_TIMESHARE:
|
2016-02-09 16:30:16 +00:00
|
|
|
if (pp->ki_flag & P_KPROC)
|
2006-11-07 10:03:10 +00:00
|
|
|
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. */
|
2016-02-09 16:30:16 +00:00
|
|
|
rtpri = ((pp->ki_flag & P_KPROC) ? pp->ki_pri.pri_native :
|
2007-06-15 12:03:07 +00:00
|
|
|
pp->ki_pri.pri_user) - PRI_MIN_IDLE;
|
2006-11-07 10:03:10 +00:00
|
|
|
snprintf(nicebuf, sizeof(nicebuf), "%si%d%s",
|
2016-02-09 18:35:37 +00:00
|
|
|
kproc, rtpri, fifo);
|
2006-11-07 10:03:10 +00:00
|
|
|
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
|
|
|
|
2018-06-03 22:42:54 +00:00
|
|
|
assert((*pp2)->ki_pid >= 0 && (*pp1)->ki_pid >= 0);
|
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
|
|
|
}
|
|
|
|
|
2011-07-18 17:33:08 +00:00
|
|
|
static int
|
|
|
|
compare_tid(const void *p1, const void *p2)
|
|
|
|
{
|
|
|
|
const struct kinfo_proc * const *pp1 = p1;
|
|
|
|
const struct kinfo_proc * const *pp2 = p2;
|
|
|
|
|
2018-06-03 22:42:54 +00:00
|
|
|
assert((*pp2)->ki_tid >= 0 && (*pp1)->ki_tid >= 0);
|
2011-07-18 17:33:08 +00:00
|
|
|
|
|
|
|
return ((*pp1)->ki_tid - (*pp2)->ki_tid);
|
|
|
|
}
|
|
|
|
|
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
|
2023-06-19 15:57:00 +00:00
|
|
|
* to most important): run, zombie, idle, interrupt wait, stop, sleep.
|
|
|
|
* The array declaration below maps a process state index into a
|
|
|
|
* number that reflects this ordering.
|
1997-03-23 18:55:20 +00:00
|
|
|
*/
|
|
|
|
|
2023-06-19 13:49:19 +00:00
|
|
|
static const int sorted_state[] = {
|
2023-06-19 13:52:05 +00:00
|
|
|
[SIDL] = 3, /* being created */
|
|
|
|
[SRUN] = 1, /* running/runnable */
|
|
|
|
[SSLEEP] = 6, /* sleeping */
|
|
|
|
[SSTOP] = 5, /* stopped/suspended */
|
|
|
|
[SZOMB] = 2, /* zombie */
|
2023-06-21 05:43:11 +00:00
|
|
|
[SWAIT] = 4, /* intr */
|
2023-06-19 16:00:15 +00:00
|
|
|
[SLOCK] = 7, /* blocked on lock */
|
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 { \
|
2014-05-30 21:18:53 +00:00
|
|
|
double diff; \
|
2005-05-18 13:42:51 +00:00
|
|
|
if (ps.wcpu) \
|
2014-05-30 21:18:53 +00:00
|
|
|
diff = weighted_cpu(PCTCPU((b)), (b)) - \
|
|
|
|
weighted_cpu(PCTCPU((a)), (a)); \
|
2005-05-18 13:42:51 +00:00
|
|
|
else \
|
2014-05-30 21:18:53 +00:00
|
|
|
diff = PCTCPU((b)) - PCTCPU((a)); \
|
2005-05-18 13:42:51 +00:00
|
|
|
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 { \
|
2018-05-21 00:32:48 +00:00
|
|
|
int diff = sorted_state[(unsigned char)(b)->ki_stat] - sorted_state[(unsigned char)(a)->ki_stat]; \
|
2004-07-05 14:45:57 +00:00
|
|
|
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)
|
|
|
|
|
2016-09-05 08:27:04 +00:00
|
|
|
#define ORDERKEY_SWAP(a, b) do { \
|
|
|
|
int diff = (int)ki_swap(b) - (int)ki_swap(a); \
|
|
|
|
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 */
|
|
|
|
|
2018-05-21 00:53:42 +00:00
|
|
|
static int
|
|
|
|
compare_cpu(const void *arg1, const void *arg2)
|
1997-03-23 18:55:20 +00:00
|
|
|
{
|
2018-06-02 07:44:50 +00:00
|
|
|
const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
|
|
|
|
const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
|
2004-07-05 14:45:57 +00:00
|
|
|
|
|
|
|
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
|
|
|
/* compare_size - the comparison function for sorting by total memory usage */
|
|
|
|
|
2018-06-03 22:42:54 +00:00
|
|
|
static int
|
2018-05-21 00:53:42 +00:00
|
|
|
compare_size(const void *arg1, const void *arg2)
|
1998-08-12 09:58:15 +00:00
|
|
|
{
|
2018-06-02 07:44:50 +00:00
|
|
|
const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
|
|
|
|
const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
|
2004-07-05 14:45:57 +00:00
|
|
|
|
|
|
|
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 */
|
|
|
|
|
2018-06-03 22:42:54 +00:00
|
|
|
static int
|
2018-05-21 00:53:42 +00:00
|
|
|
compare_res(const void *arg1, const void *arg2)
|
1998-08-12 09:58:15 +00:00
|
|
|
{
|
2018-06-02 07:44:50 +00:00
|
|
|
const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
|
|
|
|
const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
|
2004-07-05 14:45:57 +00:00
|
|
|
|
|
|
|
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 */
|
|
|
|
|
2018-06-03 22:42:54 +00:00
|
|
|
static int
|
2018-05-21 00:53:42 +00:00
|
|
|
compare_time(const void *arg1, const void *arg2)
|
1998-08-12 09:58:15 +00:00
|
|
|
{
|
2018-06-02 07:44:50 +00:00
|
|
|
const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
|
|
|
|
const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *) arg2;
|
2004-07-05 14:45:57 +00:00
|
|
|
|
|
|
|
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
|
|
|
|
2018-06-03 22:42:54 +00:00
|
|
|
static int
|
2018-05-21 00:53:42 +00:00
|
|
|
compare_prio(const void *arg1, const void *arg2)
|
1998-08-12 09:58:15 +00:00
|
|
|
{
|
2018-06-02 07:44:50 +00:00
|
|
|
const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
|
|
|
|
const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
|
2004-07-05 14:45:57 +00:00
|
|
|
|
|
|
|
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 */
|
2018-05-21 00:53:42 +00:00
|
|
|
static int
|
|
|
|
compare_threads(const void *arg1, const void *arg2)
|
2005-04-14 15:02:03 +00:00
|
|
|
{
|
2018-06-02 07:44:50 +00:00
|
|
|
const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
|
|
|
|
const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
|
2005-04-14 15:02:03 +00:00
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
2018-06-02 07:44:50 +00:00
|
|
|
const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
|
|
|
|
const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
|
2007-04-17 03:12:39 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
2016-09-05 08:27:04 +00:00
|
|
|
|
|
|
|
/* compare_swap - the comparison function for sorting by swap */
|
|
|
|
static int
|
|
|
|
compare_swap(const void *arg1, const void *arg2)
|
|
|
|
{
|
2018-06-03 22:42:54 +00:00
|
|
|
const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
|
|
|
|
const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
|
2016-09-05 08:27:04 +00:00
|
|
|
|
|
|
|
ORDERKEY_SWAP(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);
|
|
|
|
}
|
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
|
|
|
|
2018-06-03 22:42:54 +00:00
|
|
|
static int
|
2018-05-21 00:53:42 +00:00
|
|
|
compare_iototal(const void *arg1, const void *arg2)
|
2004-07-01 09:12:38 +00:00
|
|
|
{
|
2018-06-03 22:42:54 +00:00
|
|
|
const struct kinfo_proc * const p1 = *(const struct kinfo_proc * const *)arg1;
|
|
|
|
const struct kinfo_proc * const p2 = *(const struct kinfo_proc * const *)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
|
|
|
|
2018-05-21 00:53:42 +00:00
|
|
|
static int
|
|
|
|
compare_ioread(const void *arg1, const void *arg2)
|
2004-07-08 16:45:55 +00:00
|
|
|
{
|
2018-06-03 22:42:54 +00:00
|
|
|
const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
|
|
|
|
const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
|
2004-07-08 16:45:55 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2018-05-21 00:53:42 +00:00
|
|
|
static int
|
|
|
|
compare_iowrite(const void *arg1, const void *arg2)
|
2004-07-08 16:45:55 +00:00
|
|
|
{
|
2018-06-03 22:42:54 +00:00
|
|
|
const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
|
|
|
|
const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
|
2004-07-08 16:45:55 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2018-05-21 00:53:42 +00:00
|
|
|
static int
|
|
|
|
compare_iofault(const void *arg1, const void *arg2)
|
2004-07-08 16:45:55 +00:00
|
|
|
{
|
2018-06-03 22:42:54 +00:00
|
|
|
const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
|
|
|
|
const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
|
2004-07-08 16:45:55 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2018-05-21 00:53:42 +00:00
|
|
|
static int
|
|
|
|
compare_vcsw(const void *arg1, const void *arg2)
|
2004-08-16 07:51:22 +00:00
|
|
|
{
|
2018-06-03 22:42:54 +00:00
|
|
|
const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
|
|
|
|
const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
|
2004-08-16 07:51:22 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2018-06-03 22:42:54 +00:00
|
|
|
static int
|
2018-05-21 00:53:42 +00:00
|
|
|
compare_ivcsw(const void *arg1, const void *arg2)
|
2004-08-16 07:51:22 +00:00
|
|
|
{
|
2018-06-03 22:42:54 +00:00
|
|
|
const struct kinfo_proc *p1 = *(const struct kinfo_proc * const *)arg1;
|
|
|
|
const struct kinfo_proc *p2 = *(const struct kinfo_proc * const *)arg2;
|
2004-08-16 07:51:22 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2018-06-03 22:42:54 +00:00
|
|
|
int (*compares[])(const void *arg1, const void *arg2) = {
|
|
|
|
compare_cpu,
|
|
|
|
compare_size,
|
|
|
|
compare_res,
|
|
|
|
compare_time,
|
|
|
|
compare_prio,
|
|
|
|
compare_threads,
|
|
|
|
compare_iototal,
|
|
|
|
compare_ioread,
|
|
|
|
compare_iowrite,
|
|
|
|
compare_iofault,
|
|
|
|
compare_vcsw,
|
|
|
|
compare_ivcsw,
|
|
|
|
compare_jid,
|
|
|
|
compare_swap,
|
2023-02-13 06:39:04 +00:00
|
|
|
compare_pid,
|
2018-06-03 22:42:54 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
struct kvm_swap swapary[1];
|
2017-10-25 11:44:46 +00:00
|
|
|
static int pagesize = 0;
|
2018-06-04 05:27:00 +00:00
|
|
|
static unsigned long swap_maxpages = 0;
|
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
|
|
|
|
2017-10-25 11:44:46 +00:00
|
|
|
if (pagesize == 0)
|
|
|
|
pagesize = getpagesize();
|
|
|
|
if (swap_maxpages == 0)
|
|
|
|
GETSYSCTL("vm.swap_maxpages", swap_maxpages);
|
|
|
|
|
|
|
|
/* ksw_total contains the total size of swap all devices which may
|
|
|
|
exceed the maximum swap size allocatable in the system */
|
|
|
|
if ( swapary[0].ksw_total > swap_maxpages )
|
|
|
|
swapary[0].ksw_total = swap_maxpages;
|
|
|
|
|
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
|
|
|
|
2018-06-23 22:45:22 +00:00
|
|
|
#undef CONVERT
|
|
|
|
|
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
|
|
|
}
|