diff options
author | Benoît Dejean <benoit@placenet.org> | 2007-02-18 01:10:53 +0000 |
---|---|---|
committer | Benoît Dejean <bdejean@src.gnome.org> | 2007-02-18 01:10:53 +0000 |
commit | 5a15e409cf8ec0d66691aedfb403b25995d026b5 (patch) | |
tree | 18a73bee52f688b8fdd39f0db80fc7fbde595a15 /sysdeps/freebsd | |
parent | 747438e3340c2eb7eddfa3f32aa2a176edb34b14 (diff) | |
download | libgtop-5a15e409cf8ec0d66691aedfb403b25995d026b5.tar.gz |
Huge (k)FreeBSD update. (k)FreeBSD support is freebsd/ Other BSD are in
2007-02-18 Benoît Dejean <benoit@placenet.org>
* configure.in:
* libgtop-sysdeps.m4:
* sysdeps/Makefile.am:
Huge (k)FreeBSD update.
(k)FreeBSD support is freebsd/
Other BSD are in bsd/
Patch by Joe Marcus Clarke <marcus@freebsd.org>
Alexander Nedotsukov <bland@FreeBSD.org>
Closes #407693.
svn path=/trunk/; revision=2557
Diffstat (limited to 'sysdeps/freebsd')
31 files changed, 1062 insertions, 2219 deletions
diff --git a/sysdeps/freebsd/AUTHORS b/sysdeps/freebsd/AUTHORS index 9da8aceb..e274ce59 100644 --- a/sysdeps/freebsd/AUTHORS +++ b/sysdeps/freebsd/AUTHORS @@ -1,2 +1,3 @@ Martin Baulig (martin@home-of-linux.org) Josh Sled (jsled@scam.XCF.Berkeley.EDU) +Joe Marcus Clarke (marcus@FreeBSD.org) diff --git a/sysdeps/freebsd/ChangeLog b/sysdeps/freebsd/ChangeLog index b3876d89..dcff7cc5 100644 --- a/sysdeps/freebsd/ChangeLog +++ b/sysdeps/freebsd/ChangeLog @@ -1,3 +1,52 @@ +2007-02-18 Benoît Dejean <benoit@placenet.org> + + * AUTHORS: + * Makefile.am: + * NOTES: + * cpu.c: (glibtop_init_cpu_s), (glibtop_get_cpu_s): + * fsusage.c: (_glibtop_freebsd_get_fsusage_read_write): + * glibtop_machine.h: + * glibtop_server.h: + * init.c: + * loadavg.c: (glibtop_init_loadavg_s), (glibtop_get_loadavg_s): + * mem.c: (glibtop_init_mem_s), (glibtop_get_mem_s): + * msg_limits.c: (glibtop_init_msg_limits_s), + (glibtop_get_msg_limits_s): + * netload.c: (glibtop_init_netload_p), (glibtop_get_netload_p): + * open.c: (glibtop_open_p): + * ppp.c: (glibtop_init_ppp_p), (glibtop_get_ppp_p): + * procargs.c: (glibtop_get_proc_args_p): + * procdata.c: + * prockernel.c: (glibtop_init_proc_kernel_p), + (glibtop_get_proc_kernel_p): + * proclist.c: (glibtop_get_proclist_p): + * procmap.c: (_glibtop_sysdeps_freebsd_dev_inode), + (glibtop_get_proc_map_p): + * procmem.c: (glibtop_init_proc_mem_p), (glibtop_get_proc_mem_p): + * procsegment.c: (glibtop_init_proc_segment_p), + (glibtop_get_proc_segment_p): + * procsignal.c: (glibtop_get_proc_signal_p): + * procstate.c: (glibtop_init_proc_state_p), + (glibtop_get_proc_state_p): + * proctime.c: (glibtop_get_proc_time_p): + * procuid.c: (glibtop_init_proc_uid_p), (glibtop_get_proc_uid_p): + * sem_limits.c: (glibtop_init_sem_limits_s), + (glibtop_get_sem_limits_s): + * shm_limits.c: (glibtop_init_shm_limits_s), + (glibtop_get_shm_limits_s): + * swap.c: (glibtop_init_swap_p), (glibtop_get_swap_p): + * sysinfo.c: (init_sysinfo): + * uptime.c: (glibtop_init_uptime_s), (glibtop_get_uptime_s): + + Huge (k)FreeBSD update. + (k)FreeBSD support is freebsd/ + Other BSD are in bsd/ + + Patch by Joe Marcus Clarke <marcus@freebsd.org> + Alexander Nedotsukov <bland@FreeBSD.org> + + Closes #407693. + 2007-01-31 Benoît Dejean <benoit@placenet.org> * fsusage.c: (_glibtop_freebsd_get_fsusage_read_write): diff --git a/sysdeps/freebsd/Makefile.am b/sysdeps/freebsd/Makefile.am index 9ec00a3c..ee18d5c8 100644 --- a/sysdeps/freebsd/Makefile.am +++ b/sysdeps/freebsd/Makefile.am @@ -3,17 +3,18 @@ INCLUDES = @INCLUDES@ noinst_LTLIBRARIES = libgtop_sysdeps-2.0.la libgtop_sysdeps_suid-2.0.la -libgtop_sysdeps_2_0_la_SOURCES = nosuid.c siglist.c sysinfo.c +libgtop_sysdeps_2_0_la_SOURCES = nosuid.c siglist.c sysinfo.c shm_limits.c \ + cpu.c msg_limits.c sem_limits.c loadavg.c \ + uptime.c netlist.c fsusage.c mem.c libgtop_sysdeps_2_0_la_LDFLAGS = $(LT_VERSION_INFO) -libgtop_sysdeps_suid_2_0_la_LIBADD = $(KVM_LIBS) -libgtop_sysdeps_suid_2_0_la_SOURCES = open.c close.c cpu.c mem.c swap.c \ - uptime.c loadavg.c shm_limits.c msg_limits.c \ - sem_limits.c proclist.c procstate.c procuid.c \ - proctime.c procmem.c procsignal.c prockernel.c \ - procsegment.c procargs.c procmap.c netlist.c \ - netload.c ppp.c procopenfiles.c fsusage.c +libgtop_sysdeps_suid_2_0_la_LIBADD = $(KVM_LIBS) $(EXTRA_SYSDEPS_LIBS) +libgtop_sysdeps_suid_2_0_la_SOURCES = open.c close.c swap.c \ + proclist.c procstate.c procuid.c \ + proctime.c procmem.c procsignal.c \ + prockernel.c procsegment.c procargs.c \ + procmap.c netload.c ppp.c procopenfiles.c libgtop_sysdeps_suid_2_0_la_LDFLAGS = $(LT_VERSION_INFO) diff --git a/sysdeps/freebsd/NOTES b/sysdeps/freebsd/NOTES deleted file mode 100644 index 82bbbc4b..00000000 --- a/sysdeps/freebsd/NOTES +++ /dev/null @@ -1,10 +0,0 @@ -sysctl (3) -/usr/include/sys/vmmeter.h : VM stats -kvm (3) - -CPU stats: /usr/include/sys/dkstat.h -cp_time_offset = kvm_nlist(...)["_cp_time"].n_value; - -"systemwide main memory usage structure" -sysctl(...) - diff --git a/sysdeps/freebsd/cpu.c b/sysdeps/freebsd/cpu.c index 3d4098b3..7c8f807e 100644 --- a/sysdeps/freebsd/cpu.c +++ b/sysdeps/freebsd/cpu.c @@ -28,91 +28,52 @@ #include <glibtop_suid.h> -#ifdef __NetBSD__ -#include <sys/sched.h> -#endif - static const unsigned long _glibtop_sysdeps_cpu = (1L << GLIBTOP_CPU_TOTAL) + (1L << GLIBTOP_CPU_USER) + (1L << GLIBTOP_CPU_NICE) + (1L << GLIBTOP_CPU_SYS) + (1L << GLIBTOP_CPU_IDLE) + (1L << GLIBTOP_CPU_FREQUENCY) + -(1L << GLIBTOP_CPU_IOWAIT); - -#ifndef KERN_CP_TIME -/* nlist structure for kernel access */ -static struct nlist nlst [] = { -#ifdef __bsdi__ - { "_cpustats" }, -#else - { "_cp_time" }, -#endif - { 0 } -}; -#endif - -/* MIB array for sysctl */ -static int mib_length=2; -static int mib [] = { CTL_KERN, KERN_CLOCKRATE }; -#ifdef KERN_CP_TIME -static int mib2 [] = { CTL_KERN, KERN_CP_TIME }; -#endif +(1L << GLIBTOP_CPU_IRQ); + +static const unsigned long _glibtop_sysdeps_cpu_smp = +(1L << GLIBTOP_XCPU_TOTAL) + (1L << GLIBTOP_XCPU_USER) + +(1L << GLIBTOP_XCPU_NICE) + (1L << GLIBTOP_XCPU_SYS) + +(1L << GLIBTOP_XCPU_IDLE) + (1L << GLIBTOP_XCPU_IRQ); /* Init function. */ void -glibtop_init_cpu_p (glibtop *server) +glibtop_init_cpu_s (glibtop *server) { -#ifndef KERN_CP_TIME - if (kvm_nlist (server->machine.kd, nlst) < 0) { - glibtop_warn_io_r (server, "kvm_nlist (cpu)"); - return; - } -#endif - - /* Set this only if kvm_nlist () succeeded. */ server->sysdeps.cpu = _glibtop_sysdeps_cpu; + + if (server->ncpu) + server->sysdeps.cpu |= _glibtop_sysdeps_cpu_smp; } /* Provides information about cpu usage. */ void -glibtop_get_cpu_p (glibtop *server, glibtop_cpu *buf) +glibtop_get_cpu_s (glibtop *server, glibtop_cpu *buf) { -#ifdef KERN_CP_TIME - guint64 cpts [CPUSTATES]; -#else long cpts [CPUSTATES]; -#endif - /* sysctl vars*/ struct clockinfo ci; size_t length; + int ncpu, i; - glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_CPU), 0); + glibtop_init_s (&server, GLIBTOP_SYSDEPS_CPU, 0); memset (buf, 0, sizeof (glibtop_cpu)); - /* If this fails, the nlist may not be valid. */ - if (server->sysdeps.cpu == 0) - return; - -#ifdef KERN_CP_TIME length = sizeof (cpts); - if (sysctl (mib2, mib_length, cpts, &length, NULL, 0)) { - glibtop_warn_io_r (server, "sysctl"); - return; - } -#else - if (kvm_read (server->machine.kd, nlst [0].n_value, - &cpts, sizeof (cpts)) != sizeof (cpts)) { - glibtop_warn_io_r (server, "kvm_read (cp_time)"); + if (sysctlbyname ("kern.cp_time", cpts, &length, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.cp_time)"); return; } -#endif /* Get the clockrate data */ - length = sizeof (struct clockinfo); - if (sysctl (mib, mib_length, &ci, &length, NULL, 0)) { - glibtop_warn_io_r (server, "sysctl"); + length = sizeof (ci); + if (sysctlbyname ("kern.clockrate", &ci, &length, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.cockrate)"); return; } @@ -124,21 +85,32 @@ glibtop_get_cpu_p (glibtop *server, glibtop_cpu *buf) buf->sys = cpts [CP_SYS]; /* set idle time */ buf->idle = cpts [CP_IDLE]; - /* set iowait (really just interrupt) time */ - buf->iowait = cpts [CP_INTR]; + /* set irq */ + buf->irq = cpts [CP_INTR]; /* set frequency */ - /* - FIXME -- is hz, tick, profhz or stathz wanted? - buf->frequency = sysctl("kern.clockrate", ...); - - struct clockinfo - */ - buf->frequency = ci.hz; + buf->frequency = (ci.stathz ? ci.stathz : ci.hz); /* set total */ buf->total = cpts [CP_USER] + cpts [CP_NICE] - + cpts [CP_SYS] + cpts [CP_IDLE]; + + cpts [CP_SYS] + cpts [CP_IDLE] + cpts [CP_INTR]; + + ncpu = server->ncpu + 1; + + for (i = 0; i < ncpu; i++) { + buf->xcpu_user[i] = cpts [CP_USER] / ncpu; + buf->xcpu_nice[i] = cpts [CP_NICE] / ncpu; + buf->xcpu_sys[i] = cpts [CP_SYS] / ncpu; + buf->xcpu_idle[i] = cpts [CP_IDLE] / ncpu; + buf->xcpu_irq[i] = cpts [CP_INTR] / ncpu; + buf->xcpu_total[i] = buf->xcpu_user[i] + buf->xcpu_nice[i] \ + + buf->xcpu_sys[i] + buf->xcpu_idle[i] \ + + buf->xcpu_irq[i]; + } /* Set the flags last. */ buf->flags = _glibtop_sysdeps_cpu; + + if (ncpu > 1) { + buf->flags |= _glibtop_sysdeps_cpu_smp; + } } diff --git a/sysdeps/freebsd/fsusage.c b/sysdeps/freebsd/fsusage.c index 3103e22c..8b12edac 100644 --- a/sysdeps/freebsd/fsusage.c +++ b/sysdeps/freebsd/fsusage.c @@ -1,11 +1,4 @@ #include <config.h> - -/* Although FreeBSD ships with statvfs it seems incomplete, so prefer statfs */ -#if defined (__FreeBSD__) || defined (__FreeBSD_kernel__) -#undef HAVE_SYS_STATVFS_H -#undef STAT_STATVFS -#endif - #include <glibtop.h> #include <glibtop/error.h> #include <glibtop/fsusage.h> @@ -16,10 +9,12 @@ #include <unistd.h> #include <sys/param.h> -#if defined (HAVE_SYS_STATVFS_H) -#include <sys/statvfs.h> -#else #include <sys/mount.h> +#if __FreeBSD_version >= 600000 || defined(__FreeBSD_kernel__) +#include <libgeom.h> +#include <sys/resource.h> +#include <devstat.h> +#include <sys/devicestat.h> #endif #include <stdio.h> @@ -29,32 +24,115 @@ void G_GNUC_INTERNAL _glibtop_freebsd_get_fsusage_read_write(glibtop *server, - glibtop_fsusage *buf, - const char *path); + glibtop_fsusage *buf, + const char *path); void G_GNUC_INTERNAL _glibtop_freebsd_get_fsusage_read_write(glibtop *server, - glibtop_fsusage *buf, - const char *path) + glibtop_fsusage *buf, + const char *path) { - int result; -#if defined (STAT_STATVFS) - struct statvfs sfs; -#else - struct statfs sfs; + int result; + struct statfs sfs; +#if __FreeBSD_version >= 600000 || defined(__FreeBSD_kernel__) + struct devstat *ds; + void *sc; + struct timespec ts; + struct gprovider *gp; + struct gident *gid; + struct gmesh gmp; + double etime; + uint64_t ld[2]; #endif -#if defined (STAT_STATVFS) - result = statvfs (path, &sfs); -#else - result = statfs (path, &sfs); -#endif + result = statfs (path, &sfs); + + if (result == -1) { + glibtop_warn_io_r (server, "statfs"); + return; + } +#if __FreeBSD_version >= 600000 || defined(__FreeBSD_kernel__) + ld[0] = 0; + ld[1] = 0; + result = geom_gettree (&gmp); + if (result != 0) { + glibtop_warn_io_r (server, "geom_gettree = %d", result); + return; + } + + result = geom_stats_open (); + if (result != 0) { + glibtop_warn_io_r (server, "geom_stats_open()"); + geom_deletetree (&gmp); + return; + } - if (result == -1) { - return; - } + sc = NULL; + sc = geom_stats_snapshot_get (); + if (sc == NULL) { + glibtop_warn_io_r (server, "geom_stats_snapshot_get()"); + geom_stats_close (); + geom_deletetree (&gmp); + return; + } + geom_stats_snapshot_timestamp (sc, &ts); + etime = ts.tv_sec + (ts.tv_nsec * 1e-9); + geom_stats_snapshot_reset (sc); - buf->read = sfs.f_syncreads + sfs.f_asyncreads; - buf->write = sfs.f_syncwrites + sfs.f_asyncwrites; - buf->flags |= (1 << GLIBTOP_FSUSAGE_READ) | (1 << GLIBTOP_FSUSAGE_WRITE); + for (;;) { + ds = geom_stats_snapshot_next (sc); + if (ds == NULL) { + break; + } + if (ds->id == NULL) { + continue; + } + + gid = geom_lookupid (&gmp, ds->id); + if (gid == NULL) { + geom_deletetree (&gmp); + result = geom_gettree (&gmp); + gid = geom_lookupid (&gmp, ds->id); + } + + if (gid == NULL) { + continue; + } + if (gid->lg_what == ISCONSUMER) { + continue; + } + + gp = gid->lg_ptr; + + if (!g_str_has_suffix (sfs.f_mntfromname, gp->lg_name)) { + continue; + } else { + result = devstat_compute_statistics (ds, NULL, etime, + DSM_TOTAL_TRANSFERS_READ, + &ld[0], + DSM_TOTAL_TRANSFERS_WRITE, + &ld[1], DSM_NONE); + if (result != 0) { + glibtop_warn_io_r (server, + "devstat_compute_statistics()"); + geom_stats_snapshot_free (sc); + geom_stats_close (); + geom_deletetree (&gmp); + return; + } + break; + } + } + + geom_stats_snapshot_free (sc); + geom_stats_close (); + geom_deletetree (&gmp); + + buf->read = ld[0]; + buf->write = ld[1]; +#else + buf->read = sfs.f_syncreads + sfs.f_asyncreads; + buf->write = sfs.f_syncwrites + sfs.f_asyncwrites; +#endif + buf->flags |= (1 << GLIBTOP_FSUSAGE_READ) | (1 << GLIBTOP_FSUSAGE_WRITE); } diff --git a/sysdeps/freebsd/glibtop_machine.h b/sysdeps/freebsd/glibtop_machine.h index 7c1cb920..a1ca2e82 100644 --- a/sysdeps/freebsd/glibtop_machine.h +++ b/sysdeps/freebsd/glibtop_machine.h @@ -35,17 +35,7 @@ #include <fcntl.h> -#ifdef __FreeBSD__ #include <osreldate.h> -#endif - -#ifdef __NetBSD__ -#include <sys/proc.h> - -#ifndef SRUN -#define SRUN SACTIVE -#endif -#endif G_BEGIN_DECLS diff --git a/sysdeps/freebsd/glibtop_server.h b/sysdeps/freebsd/glibtop_server.h index 087e2a35..c82fbd4e 100644 --- a/sysdeps/freebsd/glibtop_server.h +++ b/sysdeps/freebsd/glibtop_server.h @@ -21,19 +21,12 @@ Boston, MA 02111-1307, USA. */ -#ifndef __GLIBTOP_SERVER_H__ -#define __GLIBTOP_SERVER_H__ +#ifndef __FREEBSD__GLIBTOP_SERVER_H__ +#define __FREEBSD__GLIBTOP_SERVER_H__ G_BEGIN_DECLS -#define GLIBTOP_SUID_CPU (1 << GLIBTOP_SYSDEPS_CPU) -#define GLIBTOP_SUID_MEM (1 << GLIBTOP_SYSDEPS_MEM) #define GLIBTOP_SUID_SWAP (1 << GLIBTOP_SYSDEPS_SWAP) -#define GLIBTOP_SUID_UPTIME (1 << GLIBTOP_SYSDEPS_UPTIME) -#define GLIBTOP_SUID_LOADAVG (1 << GLIBTOP_SYSDEPS_LOADAVG) -#define GLIBTOP_SUID_SHM_LIMITS (1 << GLIBTOP_SYSDEPS_SHM_LIMITS) -#define GLIBTOP_SUID_MSG_LIMITS (1 << GLIBTOP_SYSDEPS_MSG_LIMITS) -#define GLIBTOP_SUID_SEM_LIMITS (1 << GLIBTOP_SYSDEPS_SEM_LIMITS) #define GLIBTOP_SUID_PROCLIST (1 << GLIBTOP_SYSDEPS_PROCLIST) #define GLIBTOP_SUID_PROC_STATE (1 << GLIBTOP_SYSDEPS_PROC_STATE) #define GLIBTOP_SUID_PROC_UID (1 << GLIBTOP_SYSDEPS_PROC_UID) @@ -45,8 +38,15 @@ G_BEGIN_DECLS #define GLIBTOP_SUID_PROC_ARGS (1 << GLIBTOP_SYSDEPS_PROC_ARGS) #define GLIBTOP_SUID_PROC_MAP (1 << GLIBTOP_SYSDEPS_PROC_MAP) #define GLIBTOP_SUID_NETLOAD (1 << GLIBTOP_SYSDEPS_NETLOAD) -#define GLIBTOP_SUID_NETLIST 0 #define GLIBTOP_SUID_PPP (1 << GLIBTOP_SYSDEPS_PPP) +#define GLIBTOP_SUID_CPU 0 +#define GLIBTOP_SUID_MEM 0 +#define GLIBTOP_SUID_UPTIME 0 +#define GLIBTOP_SUID_LOADAVG 0 +#define GLIBTOP_SUID_SHM_LIMITS 0 +#define GLIBTOP_SUID_MSG_LIMITS 0 +#define GLIBTOP_SUID_SEM_LIMITS 0 +#define GLIBTOP_SUID_NETLIST 0 G_END_DECLS diff --git a/sysdeps/freebsd/init.c b/sysdeps/freebsd/init.c deleted file mode 100644 index d43b71f8..00000000 --- a/sysdeps/freebsd/init.c +++ /dev/null @@ -1,46 +0,0 @@ -/* $Id$ */ - -/* Copyright (C) 1998 Joshua Sled - This file is part of LibGTop 1.0. - - Contributed by Joshua Sled <jsled@xcf.berkeley.edu>, July 1998. - - LibGTop is free software; you can redistribute it and/or modify it - under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, - or (at your option) any later version. - - LibGTop is distributed in the hope that it will be useful, but WITHOUT - ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - for more details. - - You should have received a copy of the GNU General Public License - along with LibGTop; see the file COPYING. If not, write to the - Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. -*/ - -#include <config.h> -#include <glibtop.h> -#include <glibtop/open.h> - -static glibtop _glibtop_global_server; -glibtop *glibtop_global_server = NULL; - -glibtop * -glibtop_init_r (glibtop **server, - const unsigned long features, - const unsigned flags) -{ - if (*server != NULL) - return *server; - - if (glibtop_global_server == NULL) { - glibtop_global_server = &_glibtop_global_server; - glibtop_open (glibtop_global_server, "glibtop", - features, flags); - } - - return *server = glibtop_global_server; -} diff --git a/sysdeps/freebsd/loadavg.c b/sysdeps/freebsd/loadavg.c index 5764e475..5c7ee050 100644 --- a/sysdeps/freebsd/loadavg.c +++ b/sysdeps/freebsd/loadavg.c @@ -22,32 +22,40 @@ */ #include <config.h> +#include <stdlib.h> #include <glibtop.h> #include <glibtop/error.h> #include <glibtop/loadavg.h> -#include <glibtop_suid.h> +#include <sys/types.h> +#include <sys/sysctl.h> static const unsigned long _glibtop_sysdeps_loadavg = (1L << GLIBTOP_LOADAVG_LOADAVG); +static const unsigned long _glibtop_sysdeps_last_pid = +(1L << GLIBTOP_LOADAVG_LAST_PID); + /* Init function. */ void -glibtop_init_loadavg_p (glibtop *server) +glibtop_init_loadavg_s (glibtop *server) { - server->sysdeps.loadavg = _glibtop_sysdeps_loadavg; + server->sysdeps.loadavg = _glibtop_sysdeps_loadavg | + _glibtop_sysdeps_last_pid; } /* Provides load averange. */ void -glibtop_get_loadavg_p (glibtop *server, glibtop_loadavg *buf) +glibtop_get_loadavg_s (glibtop *server, glibtop_loadavg *buf) { double ldavg[3]; + pid_t last_pid; + size_t len; int i; - glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_LOADAVG), 0); + glibtop_init_s (&server, GLIBTOP_SYSDEPS_LOADAVG, 0); memset (buf, 0, sizeof (glibtop_loadavg)); @@ -58,4 +66,14 @@ glibtop_get_loadavg_p (glibtop *server, glibtop_loadavg *buf) for (i = 0; i < 3; i++) { buf->loadavg [i] = ldavg [i]; } /* end for */ + + len = sizeof (last_pid); + if (sysctlbyname ("kern.lastpid", &last_pid, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.lastpid)"); + return; + } + + buf->last_pid = last_pid; + + buf->flags |= _glibtop_sysdeps_last_pid; } diff --git a/sysdeps/freebsd/mem.c b/sysdeps/freebsd/mem.c index 95266163..1b7bf3d7 100644 --- a/sysdeps/freebsd/mem.c +++ b/sysdeps/freebsd/mem.c @@ -26,199 +26,67 @@ #include <glibtop/error.h> #include <glibtop/mem.h> -#include <glibtop_suid.h> - +#include <sys/types.h> #include <sys/sysctl.h> -#include <sys/vmmeter.h> -#if defined(__NetBSD__) && (__NetBSD_Version__ < 105020000) -#include <vm/vm_param.h> -#endif - -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) || defined(__OpenBSD__) -#include <uvm/uvm_extern.h> -#endif static const unsigned long _glibtop_sysdeps_mem = (1L << GLIBTOP_MEM_TOTAL) + (1L << GLIBTOP_MEM_USED) + -(1L << GLIBTOP_MEM_FREE) + -(1L << GLIBTOP_MEM_SHARED) + -(1L << GLIBTOP_MEM_BUFFER) + -#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) -(1L << GLIBTOP_MEM_CACHED) + -#endif -(1L << GLIBTOP_MEM_USER) + (1L << GLIBTOP_MEM_LOCKED); - -#ifndef LOG1024 -#define LOG1024 10 -#endif +(1L << GLIBTOP_MEM_FREE) + (1L << GLIBTOP_MEM_SHARED) + +(1L << GLIBTOP_MEM_BUFFER) + (1L << GLIBTOP_MEM_CACHED) + +(1L << GLIBTOP_MEM_USER); /* 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) - -/* nlist structure for kernel access */ -static struct nlist nlst [] = { -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) || defined(__OpenBSD__) - { "_bufpages" }, - { 0 } -#else -#if defined(__bsdi__) - { "_bufcachemem" }, -#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) - { "_bufspace" }, -#else - { "_bufpages" }, -#endif - { "_cnt" }, - { 0 } -#endif -}; - -/* MIB array for sysctl */ -#ifdef __bsdi__ -static int mib [] = { CTL_VM, VM_TOTAL }; -#else -static int mib [] = { CTL_VM, VM_METER }; -#endif - -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) || defined(__OpenBSD__) -static int mib_uvmexp [] = { CTL_VM, VM_UVMEXP }; -#endif +static int pagesize; /* Init function. */ - void -glibtop_init_mem_p (glibtop *server) +glibtop_init_mem_s (glibtop *server) { - register int pagesize; - - if (kvm_nlist (server->machine.kd, nlst) < 0) { - glibtop_warn_io_r (server, "kvm_nlist (mem)"); - return; - } - - /* get the page size with "getpagesize" and calculate pageshift - * from it */ pagesize = getpagesize (); - pageshift = 0; - while (pagesize > 1) { - pageshift++; - pagesize >>= 1; - } - - /* we only need the amount of log(2)1024 for our conversion */ - pageshift -= LOG1024; server->sysdeps.mem = _glibtop_sysdeps_mem; } void -glibtop_get_mem_p (glibtop *server, glibtop_mem *buf) +glibtop_get_mem_s (glibtop *server, glibtop_mem *buf) { - struct vmtotal vmt; - size_t length_vmt; -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) || defined(__OpenBSD__) - struct uvmexp uvmexp; - size_t length_uvmexp; -#else - struct vmmeter vmm; -#endif - u_int v_used_count; - u_int v_total_count; - u_int v_free_count; - int bufspace; - - glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_MEM), 0); - - memset (buf, 0, sizeof (glibtop_mem)); - - if (server->sysdeps.mem == 0) - return; + gulong memtotal; + guint memused; + gulong buffers; + guint cached; + size_t len; - /* [FIXME: On FreeBSD 2.2.6, sysctl () returns an incorrect - * value for `vmt.vm'. We use some code from Unix top - * here.] */ + glibtop_init_s (&server, GLIBTOP_SYSDEPS_MEM, 0); - /* Get the data from sysctl */ - length_vmt = sizeof (vmt); - if (sysctl (mib, 2, &vmt, &length_vmt, NULL, 0)) { - glibtop_warn_io_r (server, "sysctl (vmt)"); - return; - } + memset (buf, 0, sizeof *buf); -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) || defined(__OpenBSD__) - length_uvmexp = sizeof (uvmexp); - if (sysctl (mib_uvmexp, 2, &uvmexp, &length_uvmexp, NULL, 0)) { - glibtop_warn_io_r (server, "sysctl (uvmexp)"); + len = sizeof (memtotal); + if (sysctlbyname ("hw.physmem", &memtotal, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (hw.physmem)"); return; } -#else - /* Get the data from kvm_* */ - if (kvm_read (server->machine.kd, nlst[1].n_value, - &vmm, sizeof (vmm)) != sizeof (vmm)) { - glibtop_warn_io_r (server, "kvm_read (cnt)"); + + len = sizeof (memused); + if (sysctlbyname ("vm.stats.vm.v_wire_count", &memused, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (vm.stats.vm.v_wire_count)"); return; } -#endif - if (kvm_read (server->machine.kd, nlst[0].n_value, - &bufspace, sizeof (bufspace)) != sizeof (bufspace)) { - glibtop_warn_io_r (server, "kvm_read (bufspace)"); + len = sizeof (cached); + if (sysctlbyname ("vm.stats.vm.v_cache_count", &cached, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (vm.stats.vm.v_cache_count)"); return; } - /* convert memory stats to Kbytes */ - -#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) - v_total_count = vmm.v_page_count; -#else -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) || defined(__OpenBSD__) - v_total_count = uvmexp.reserve_kernel + - uvmexp.reserve_pagedaemon + - uvmexp.free + uvmexp.wired + uvmexp.active + - uvmexp.inactive; -#else - v_total_count = vmm.v_kernel_pages + - vmm.v_free_count + vmm.v_wire_count + - vmm.v_active_count + vmm.v_inactive_count; -#endif -#endif - -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) || defined(__OpenBSD__) - v_used_count = uvmexp.active + uvmexp.inactive; - v_free_count = uvmexp.free; -#else - v_used_count = vmm.v_active_count + vmm.v_inactive_count; - v_free_count = vmm.v_free_count; -#endif - - buf->total = (guint64) pagetok (v_total_count) << LOG1024; - buf->used = (guint64) pagetok (v_used_count) << LOG1024; - buf->free = (guint64) pagetok (v_free_count) << LOG1024; - -#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) - buf->cached = (guint64) pagetok (vmm.v_cache_count) << LOG1024; -#endif - -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) || defined(__OpenBSD__) - buf->locked = (guint64) pagetok (uvmexp.wired) << LOG1024; -#else - buf->locked = (guint64) pagetok (vmm.v_wire_count) << LOG1024; -#endif - - buf->shared = (guint64) pagetok (vmt.t_rmshr) << LOG1024; - -#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) - buf->buffer = (guint64) bufspace; -#else - buf->buffer = (guint64) pagetok (bufspace) << LOG1024; -#endif - - /* user */ - buf->user = buf->total - buf->free - buf->shared - buf->buffer; - - /* Set the values to return */ + buffers = 0; + + buf->total = memtotal; + buf->used = (memused * pagesize); + buf->free = (buf->total - buf->used); + buf->shared = 0; + buf->cached = (cached * pagesize); + buf->buffer = buffers; + + buf->user = buf->total - buf->free - buf->cached - buf->buffer; buf->flags = _glibtop_sysdeps_mem; } diff --git a/sysdeps/freebsd/msg_limits.c b/sysdeps/freebsd/msg_limits.c index 4d40dc69..a718db64 100644 --- a/sysdeps/freebsd/msg_limits.c +++ b/sysdeps/freebsd/msg_limits.c @@ -26,91 +26,79 @@ #include <glibtop/error.h> #include <glibtop/msg_limits.h> -#include <glibtop_suid.h> +#include <sys/types.h> +#include <sys/sysctl.h> -#if (defined __bsdi__) && (_BSDI_VERSION < 199700) -/* Older versions of BSDI don't seem to have this. */ +static const unsigned long _glibtop_sysdeps_msg_limits = +(1L << GLIBTOP_IPC_MSGMAX) + (1L << GLIBTOP_IPC_MSGMNI) + +(1L << GLIBTOP_IPC_MSGMNB) + (1L << GLIBTOP_IPC_MSGTQL) + +(1L << GLIBTOP_IPC_MSGSSZ) + (1L << GLIBTOP_IPC_MSGPOOL); -void -glibtop_init_msg_limits_p (glibtop *server) -{ } +/* Init function. */ void -glibtop_get_msg_limits_p (glibtop *server, glibtop_msg_limits *buf) +glibtop_init_msg_limits_s (glibtop *server) { - glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_MSG_LIMITS), 0); - - memset (buf, 0, sizeof (glibtop_msg_limits)); + server->sysdeps.msg_limits = _glibtop_sysdeps_msg_limits; } -#else - -/* Define the appropriate macro (if any) to get declaration of `struct - * msginfo'. Needed on, at least, FreeBSD. */ -#if defined (STRUCT_MSGINFO_NEEDS_KERNEL) -#define KERNEL 1 -#elif defined (STRUCT_MSGINFO_NEEDS__KERNEL) -#define _KERNEL 1 -#endif - -#include <sys/ipc.h> -#include <sys/msg.h> +/* Provides information about sysv ipc limits. */ -static const unsigned long _glibtop_sysdeps_msg_limits = -(1L << GLIBTOP_IPC_MSGMAX) + (1L << GLIBTOP_IPC_MSGMNI) + -(1L << GLIBTOP_IPC_MSGMNB) + (1L << GLIBTOP_IPC_MSGTQL) + -(1L << GLIBTOP_IPC_MSGSSZ); +void +glibtop_get_msg_limits_s (glibtop *server, glibtop_msg_limits *buf) +{ + size_t len; + int msgmax, msgmni, msgmnb, msgtql, msgssz, msgseg; -/* The values in this structure never change at runtime, so we only - * read it once during initialization. We have to use the name `_msginfo' - * since `msginfo' is already declared external in <sys/msg.h>. */ -static struct msginfo _msginfo; + glibtop_init_s (&server, GLIBTOP_SYSDEPS_MSG_LIMITS, 0); -/* nlist structure for kernel access */ -static struct nlist nlst [] = { - { "_msginfo" }, - { 0 } -}; + memset (buf, 0, sizeof (glibtop_msg_limits)); -/* Init function. */ + if (server->sysdeps.msg_limits == 0) + return; -void -glibtop_init_msg_limits_p (glibtop *server) -{ - if (kvm_nlist (server->machine.kd, nlst) < 0) { - glibtop_warn_io_r (server, "kvm_nlist (msg_limits)"); + len = sizeof (msgseg); + if (sysctlbyname ("kern.ipc.msgseg", &msgseg, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.msgseg)"); return; } - if (kvm_read (server->machine.kd, nlst [0].n_value, - &_msginfo, sizeof (_msginfo)) != sizeof (_msginfo)) { - glibtop_warn_io_r (server, "kvm_read (msginfo)"); + len = sizeof (msgssz); + if (sysctlbyname ("kern.ipc.msgssz", &msgssz, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.msgssz)"); return; } - server->sysdeps.msg_limits = _glibtop_sysdeps_msg_limits; -} - -/* Provides information about sysv ipc limits. */ + len = sizeof (msgtql); + if (sysctlbyname ("kern.ipc.msgtql", &msgtql, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.msgtql)"); + return; + } -void -glibtop_get_msg_limits_p (glibtop *server, glibtop_msg_limits *buf) -{ - glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_MSG_LIMITS), 0); + len = sizeof (msgmnb); + if (sysctlbyname ("kern.ipc.msgmnb", &msgmnb, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.msgmnb)"); + return; + } - memset (buf, 0, sizeof (glibtop_msg_limits)); + len = sizeof (msgmni); + if (sysctlbyname ("kern.ipc.msgmni", &msgmni, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.msgmni)"); + return; + } - if (server->sysdeps.msg_limits == 0) + len = sizeof (msgmax); + if (sysctlbyname ("kern.ipc.msgmax", &msgmax, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.msgmax)"); return; + } - buf->msgmax = _msginfo.msgmax; - buf->msgmni = _msginfo.msgmni; - buf->msgmnb = _msginfo.msgmnb; - buf->msgtql = _msginfo.msgtql; - buf->msgssz = _msginfo.msgtql; + buf->msgmax = msgmax; + buf->msgmni = msgmni; + buf->msgmnb = msgmnb; + buf->msgtql = msgtql; + buf->msgssz = msgssz; + buf->msgpool = msgseg; buf->flags = _glibtop_sysdeps_msg_limits; } - -#endif /* either a newer BSDI or no BSDI at all. */ - diff --git a/sysdeps/freebsd/netload.c b/sysdeps/freebsd/netload.c index 4451dd9c..596230c6 100644 --- a/sysdeps/freebsd/netload.c +++ b/sysdeps/freebsd/netload.c @@ -30,6 +30,10 @@ #include <string.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/ioctl.h> + #include <net/if.h> #include <net/if_dl.h> #include <net/if_types.h> @@ -54,189 +58,199 @@ static const unsigned long _glibtop_sysdeps_netload = (1L << GLIBTOP_NETLOAD_ERRORS_TOTAL) + (1L << GLIBTOP_NETLOAD_COLLISIONS); -static const unsigned _glibtop_sysdeps_netload_data = +static const unsigned long _glibtop_sysdeps_netload_data = (1L << GLIBTOP_NETLOAD_ADDRESS) + -#if !defined(__bsdi__) -(1L << GLIBTOP_NETLOAD_SUBNET) + -#endif (1L << GLIBTOP_NETLOAD_MTU); +static const unsigned long _glibtop_sysdeps_netload6 = +(1L << GLIBTOP_NETLOAD_ADDRESS6) + +(1L << GLIBTOP_NETLOAD_SCOPE6); + /* nlist structure for kernel access */ -static struct nlist nlst [] = { - { "_ifnet" }, - { 0 } -}; +static struct nlist nlst [] = + { + { "_ifnet" + }, + { 0 } + }; /* Init function. */ void glibtop_init_netload_p (glibtop *server) { - server->sysdeps.netload = _glibtop_sysdeps_netload; + if (kvm_nlist (server->machine.kd, nlst) < 0) { + glibtop_warn_io_r (server, "kvm_nlist"); + return; + } - if (kvm_nlist (server->machine.kd, nlst) < 0) - glibtop_error_io_r (server, "kvm_nlist"); + server->sysdeps.netload = _glibtop_sysdeps_netload; } /* Provides Network statistics. */ void glibtop_get_netload_p (glibtop *server, glibtop_netload *buf, - const char *interface) + const char *interface) { - struct ifnet ifnet; - u_long ifnetaddr, ifnetfound; - struct sockaddr *sa = NULL; -#if (defined(__FreeBSD__) && (__FreeBSD_version < 501113)) || defined(__bsdi__) - char tname [16]; -#endif - char name [32]; - - union { - struct ifaddr ifa; - struct in_ifaddr in; - } ifaddr; - - glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_NETLOAD), 0); + struct ifnet ifnet; + u_long ifnetaddr, ifnetfound; + struct sockaddr *sa = NULL; + char name [32]; - memset (buf, 0, sizeof (glibtop_netload)); + union { + struct ifaddr ifa; + struct in_ifaddr in; + } ifaddr; - if (kvm_read (server->machine.kd, nlst [0].n_value, - &ifnetaddr, sizeof (ifnetaddr)) != sizeof (ifnetaddr)) - glibtop_error_io_r (server, "kvm_read (ifnet)"); + glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_NETLOAD), 0); - while (ifnetaddr) { - struct sockaddr_in *sin; - register char *cp; - u_long ifaddraddr; + memset (buf, 0, sizeof (glibtop_netload)); - { - ifnetfound = ifnetaddr; - - if (kvm_read (server->machine.kd, ifnetaddr, &ifnet, - sizeof (ifnet)) != sizeof (ifnet)) - glibtop_error_io_r (server, "kvm_read (ifnetaddr)"); - -#if (defined(__FreeBSD__) && (__FreeBSD_version < 501113)) || defined(__bsdi__) - if (kvm_read (server->machine.kd, (u_long) ifnet.if_name, - tname, 16) != 16) - glibtop_error_io_r (server, "kvm_read (if_name)"); - tname[15] = '\0'; - snprintf (name, 32, "%s%d", tname, ifnet.if_unit); -#else - g_strlcpy (name, ifnet.if_xname, sizeof(name)); -#endif -#if defined(__FreeBSD__) && (__FreeBSD_version >= 300000) - ifnetaddr = (u_long) ifnet.if_link.tqe_next; -#elif defined(__FreeBSD__) || defined(__bsdi__) - ifnetaddr = (u_long) ifnet.if_next; -#else - ifnetaddr = (u_long) ifnet.if_list.tqe_next; -#endif + if (server->sysdeps.netload == 0) return; - if (strcmp (name, interface) != 0) - continue; - -#if defined(__FreeBSD__) && (__FreeBSD_version >= 300000) - ifaddraddr = (u_long) ifnet.if_addrhead.tqh_first; -#elif defined(__FreeBSD__) || defined(__bsdi__) - ifaddraddr = (u_long) ifnet.if_addrlist; -#else - ifaddraddr = (u_long) ifnet.if_addrlist.tqh_first; -#endif + if (kvm_read (server->machine.kd, nlst [0].n_value, + &ifnetaddr, sizeof (ifnetaddr)) != sizeof (ifnetaddr)) { + glibtop_warn_io_r (server, "kvm_read (ifnet)"); + return; } - if (ifnet.if_flags & IFF_UP) - buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_UP); - if (ifnet.if_flags & IFF_BROADCAST) - buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_BROADCAST); - if (ifnet.if_flags & IFF_DEBUG) - buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_DEBUG); - if (ifnet.if_flags & IFF_LOOPBACK) - buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_LOOPBACK); - if (ifnet.if_flags & IFF_POINTOPOINT) - buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_POINTOPOINT); + + while (ifnetaddr) + { + struct sockaddr_in *sin; + register char *cp; + u_long ifaddraddr; + + { + ifnetfound = ifnetaddr; + + if (kvm_read (server->machine.kd, ifnetaddr, &ifnet, + sizeof (ifnet)) != sizeof (ifnet)) { + glibtop_warn_io_r (server, + "kvm_read (ifnetaddr)"); + continue; + } + + g_strlcpy (name, ifnet.if_xname, sizeof(name)); + ifnetaddr = (u_long) ifnet.if_link.tqe_next; + + if (strcmp (name, interface) != 0) + continue; + + ifaddraddr = (u_long) ifnet.if_addrhead.tqh_first; + } + if (ifnet.if_flags & IFF_UP) + buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_UP); + if (ifnet.if_flags & IFF_BROADCAST) + buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_BROADCAST); + if (ifnet.if_flags & IFF_DEBUG) + buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_DEBUG); + if (ifnet.if_flags & IFF_LOOPBACK) + buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_LOOPBACK); + if (ifnet.if_flags & IFF_POINTOPOINT) + buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_POINTOPOINT); #ifdef IFF_DRV_RUNNING - if (ifnet.if_drv_flags & IFF_DRV_RUNNING) + if (ifnet.if_drv_flags & IFF_DRV_RUNNING) #else - if (ifnet.if_flags & IFF_RUNNING) + if (ifnet.if_flags & IFF_RUNNING) #endif - buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_RUNNING); - if (ifnet.if_flags & IFF_NOARP) - buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_NOARP); - if (ifnet.if_flags & IFF_PROMISC) - buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_PROMISC); - if (ifnet.if_flags & IFF_ALLMULTI) - buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_ALLMULTI); + buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_RUNNING); + if (ifnet.if_flags & IFF_NOARP) + buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_NOARP); + if (ifnet.if_flags & IFF_PROMISC) + buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_PROMISC); + if (ifnet.if_flags & IFF_ALLMULTI) + buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_ALLMULTI); #ifdef IFF_DRV_OACTIVE - if (ifnet.if_drv_flags & IFF_DRV_OACTIVE) + if (ifnet.if_drv_flags & IFF_DRV_OACTIVE) #else - if (ifnet.if_flags & IFF_OACTIVE) -#endif - buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_OACTIVE); - if (ifnet.if_flags & IFF_SIMPLEX) - buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_SIMPLEX); - if (ifnet.if_flags & IFF_LINK0) - buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_LINK0); - if (ifnet.if_flags & IFF_LINK1) - buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_LINK1); - if (ifnet.if_flags & IFF_LINK2) - buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_LINK2); -#ifdef __FreeBSD__ - if (ifnet.if_flags & IFF_ALTPHYS) - buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_ALTPHYS); + if (ifnet.if_flags & IFF_OACTIVE) #endif - if (ifnet.if_flags & IFF_MULTICAST) - buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_MULTICAST); - - buf->packets_in = ifnet.if_ipackets; - buf->packets_out = ifnet.if_opackets; - buf->packets_total = buf->packets_in + buf->packets_out; - - buf->bytes_in = ifnet.if_ibytes; - buf->bytes_out = ifnet.if_obytes; - buf->bytes_total = buf->bytes_in + buf->bytes_out; - - buf->errors_in = ifnet.if_ierrors; - buf->errors_out = ifnet.if_oerrors; - buf->errors_total = buf->errors_in + buf->errors_out; - - buf->collisions = ifnet.if_collisions; - buf->flags = _glibtop_sysdeps_netload; - - while (ifaddraddr) { - if ((kvm_read (server->machine.kd, ifaddraddr, &ifaddr, - sizeof (ifaddr)) != sizeof (ifaddr))) - glibtop_error_io_r (server, "kvm_read (ifaddraddr)"); + buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_OACTIVE); + if (ifnet.if_flags & IFF_SIMPLEX) + buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_SIMPLEX); + if (ifnet.if_flags & IFF_LINK0) + buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_LINK0); + if (ifnet.if_flags & IFF_LINK1) + buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_LINK1); + if (ifnet.if_flags & IFF_LINK2) + buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_LINK2); + if (ifnet.if_flags & IFF_ALTPHYS) + buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_ALTPHYS); + if (ifnet.if_flags & IFF_MULTICAST) + buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_MULTICAST); + + buf->packets_in = ifnet.if_ipackets; + buf->packets_out = ifnet.if_opackets; + buf->packets_total = buf->packets_in + buf->packets_out; + + buf->bytes_in = ifnet.if_ibytes; + buf->bytes_out = ifnet.if_obytes; + buf->bytes_total = buf->bytes_in + buf->bytes_out; + + buf->errors_in = ifnet.if_ierrors; + buf->errors_out = ifnet.if_oerrors; + buf->errors_total = buf->errors_in + buf->errors_out; + + buf->collisions = ifnet.if_collisions; + buf->flags = _glibtop_sysdeps_netload; + + while (ifaddraddr) { + if ((kvm_read (server->machine.kd, ifaddraddr, &ifaddr, + sizeof (ifaddr)) != sizeof (ifaddr))) { + glibtop_warn_io_r (server, + "kvm_read (ifaddraddr)"); + continue; + } #define CP(x) ((char *)(x)) - cp = (CP(ifaddr.ifa.ifa_addr) - CP(ifaddraddr)) + - CP(&ifaddr); - sa = (struct sockaddr *)cp; - - if (sa->sa_family == AF_LINK) { - struct sockaddr_dl *dl = (struct sockaddr_dl *) sa; - - memcpy (buf->hwaddress, LLADDR (dl), sizeof (buf->hwaddress)); - buf->flags |= GLIBTOP_NETLOAD_HWADDRESS; - } else if (sa->sa_family == AF_INET) { - sin = (struct sockaddr_in *)sa; -#if !defined(__bsdi__) - /* Commenting out to "fix" #13345. */ - buf->subnet = htonl (ifaddr.in.ia_subnet); -#endif - buf->address = sin->sin_addr.s_addr; - buf->mtu = ifnet.if_mtu; - - buf->flags |= _glibtop_sysdeps_netload_data; - } else if (sa->sa_family == AF_INET6) { - struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) sa; - - memcpy (buf->address6, &sin6->sin6_addr, sizeof (buf->address6)); - buf->flags |= GLIBTOP_NETLOAD_ADDRESS6; - } - /* FIXME prefix6, scope6 */ - ifaddraddr = (u_long) ifaddr.ifa.ifa_link.tqe_next; - } - return; - } + cp = (CP(ifaddr.ifa.ifa_addr) - CP(ifaddraddr)) + + CP(&ifaddr); + sa = (struct sockaddr *)cp; + + if (sa->sa_family == AF_LINK) { + struct sockaddr_dl *dl = (struct sockaddr_dl *) sa; + + memcpy (buf->hwaddress, LLADDR (dl), + sizeof (buf->hwaddress)); + buf->flags |= GLIBTOP_NETLOAD_HWADDRESS; + } else if (sa->sa_family == AF_INET) { + sin = (struct sockaddr_in *)sa; + /* Commenting out to "fix" #13345. */ + buf->subnet = htonl (ifaddr.in.ia_subnet); + buf->address = sin->sin_addr.s_addr; + buf->mtu = ifnet.if_mtu; + + buf->flags |= _glibtop_sysdeps_netload_data; + } else if (sa->sa_family == AF_INET6) { + struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) sa; + int in6fd; + + memcpy (buf->address6, &sin6->sin6_addr, + sizeof (buf->address6)); + buf->scope6 = (guint8) sin6->sin6_scope_id; + buf->flags |= _glibtop_sysdeps_netload6; + + in6fd = socket (AF_INET6, SOCK_DGRAM, 0); + if (in6fd >= 0) { + struct in6_ifreq ifr; + + memset (&ifr, 0, sizeof (ifr)); + ifr.ifr_addr = *sin6; + g_strlcpy (ifr.ifr_name, interface, + sizeof (ifr.ifr_name)); + if (ioctl (in6fd, SIOCGIFNETMASK_IN6, + (char *) &ifr) >= 0) { + memcpy (buf->prefix6, + &ifr.ifr_addr.sin6_addr, + sizeof (buf->prefix6)); + buf->flags |= GLIBTOP_NETLOAD_PREFIX6; + } + close (in6fd); + } + } + ifaddraddr = (u_long) ifaddr.ifa.ifa_link.tqe_next; + } + return; + } } diff --git a/sysdeps/freebsd/open.c b/sysdeps/freebsd/open.c index 4703eb70..fdf4bc85 100644 --- a/sysdeps/freebsd/open.c +++ b/sysdeps/freebsd/open.c @@ -23,6 +23,7 @@ #include <config.h> #include <glibtop.h> +#include <glibtop/error.h> #include <glibtop/open.h> #include <glibtop/init_hooks.h> @@ -65,9 +66,7 @@ glibtop_open_p (glibtop *server, const char *program_name, server->machine.gid = getgid (); server->machine.egid = getegid (); -#ifdef __FreeBSD__ server->os_version_code = __FreeBSD_version; -#endif /* Setup machine-specific data */ server->machine.kd = kvm_open (NULL, NULL, NULL, O_RDONLY, "kvm_open"); diff --git a/sysdeps/freebsd/ppp.c b/sysdeps/freebsd/ppp.c index 1c97bdca..9ad4afa1 100644 --- a/sysdeps/freebsd/ppp.c +++ b/sysdeps/freebsd/ppp.c @@ -40,11 +40,7 @@ #include <net/netisr.h> #include <net/route.h> -#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) #include <net/if_sppp.h> -#else -#include <i4b/sppp/if_sppp.h> -#endif /* Read `misc/i4b_acct.txt' for details ... */ #ifdef HAVE_I4B_ACCT @@ -83,8 +79,10 @@ glibtop_init_ppp_p (glibtop *server) #endif #endif /* HAVE_I4B */ - if (kvm_nlist (server->machine.kd, nlst) < 0) - glibtop_error_io_r (server, "kvm_nlist"); + if (kvm_nlist (server->machine.kd, nlst) < 0) { + glibtop_warn_io_r (server, "kvm_nlist"); + server->sysdeps.ppp = 0; + } } /* Provides information about ppp usage. */ @@ -104,9 +102,13 @@ glibtop_get_ppp_p (glibtop *server, glibtop_ppp *buf, unsigned short device) memset (buf, 0, sizeof (glibtop_ppp)); + if (server->sysdeps.ppp == 0) return; + if (kvm_read (server->machine.kd, nlst [0].n_value, - &data, sizeof (data)) != sizeof (data)) - glibtop_error_io_r (server, "kvm_read (i4bisppp_softc)"); + &data, sizeof (data)) != sizeof (data)) { + glibtop_warn_io_r (server, "kvm_read (i4bisppp_softc)"); + return; + } #ifdef HAVE_I4B_ACCT phase = data.sc_if_un.scu_sp.pp_phase; diff --git a/sysdeps/freebsd/procargs.c b/sysdeps/freebsd/procargs.c index 9b7357ee..ec4671bf 100644 --- a/sysdeps/freebsd/procargs.c +++ b/sysdeps/freebsd/procargs.c @@ -54,11 +54,6 @@ glibtop_get_proc_args_p (glibtop *server, glibtop_proc_args *buf, size_t size = 0, pos = 0; int count; -#ifndef __bsdi__ - char filename [BUFSIZ]; - struct stat statb; -#endif - glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_PROC_ARGS), 0); memset (buf, 0, sizeof (glibtop_proc_args)); @@ -66,25 +61,20 @@ glibtop_get_proc_args_p (glibtop *server, glibtop_proc_args *buf, /* swapper, init, pagedaemon, vmdaemon, update - this doen't work. */ if (pid < 5) return NULL; -#ifndef __bsdi__ - sprintf (filename, "/proc/%d/mem", pid); - if (stat (filename, &statb)) return NULL; -#endif - glibtop_suid_enter (server); /* Get the process data */ pinfo = kvm_getprocs (server->machine.kd, KERN_PROC_PID, pid, &count); if ((pinfo == NULL) || (count < 1)) { - glibtop_suid_leave (server); glibtop_warn_io_r (server, "kvm_getprocs (%d)", pid); + glibtop_suid_leave (server); return NULL; } args = kvm_getargv (server->machine.kd, pinfo, max_len); if (args == NULL) { - glibtop_suid_leave (server); glibtop_warn_io_r (server, "kvm_getargv (%d)", pid); + glibtop_suid_leave (server); return NULL; } diff --git a/sysdeps/freebsd/procdata.c b/sysdeps/freebsd/procdata.c deleted file mode 100644 index e8503cbf..00000000 --- a/sysdeps/freebsd/procdata.c +++ /dev/null @@ -1,170 +0,0 @@ -/* $Id$ */ - -/* Copyright (C) 1998 Joshua Sled - This file is part of LibGTop 1.0. - - Contributed by Joshua Sled <jsled@xcf.berkeley.edu>, July 1998. - - LibGTop is free software; you can redistribute it and/or modify it - under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, - or (at your option) any later version. - - LibGTop is distributed in the hope that it will be useful, but WITHOUT - ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - for more details. - - You should have received a copy of the GNU General Public License - along with LibGTop; see the file COPYING. If not, write to the - Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. -*/ - -#include <config.h> -#include <glibtop/procdata.h> - -#include <sys/stat.h> - - -#define BIT_SHIFT(x) (1L << (x % 64)) - -static const unsigned long _glibtop_sysdeps_procdata_0 = -BIT_SHIFT(GLIBTOP_PROCDATA_CMD) + -BIT_SHIFT(GLIBTOP_PROCDATA_STATE) + -BIT_SHIFT(GLIBTOP_PROCDATA_UID) + -BIT_SHIFT(GLIBTOP_PROCDATA_PID) + -BIT_SHIFT(GLIBTOP_PROCDATA_PPID) + -BIT_SHIFT(GLIBTOP_PROCDATA_PGRP) + -BIT_SHIFT(GLIBTOP_PROCDATA_SESSION) + -BIT_SHIFT(GLIBTOP_PROCDATA_TTY) + -BIT_SHIFT(GLIBTOP_PROCDATA_TPGID) + -BIT_SHIFT(GLIBTOP_PROCDATA_PRIORITY) + -BIT_SHIFT(GLIBTOP_PROCDATA_NICE) + -BIT_SHIFT(GLIBTOP_PROCDATA_SIGNAL) + -BIT_SHIFT(GLIBTOP_PROCDATA_BLOCKED) + -BIT_SHIFT(GLIBTOP_PROCDATA_SIGIGNORE) + -BIT_SHIFT(GLIBTOP_PROCDATA_SIGCATCH) + -BIT_SHIFT(GLIBTOP_PROCDATA_START_TIME) + -BIT_SHIFT(GLIBTOP_PROCDATA_UTIME) + -BIT_SHIFT(GLIBTOP_PROCDATA_STIME) + -BIT_SHIFT(GLIBTOP_PROCDATA_CUTIME) + -BIT_SHIFT(GLIBTOP_PROCDATA_CSTIME) + -BIT_SHIFT(GLIBTOP_PROCDATA_SIZE) + -BIT_SHIFT(GLIBTOP_PROCDATA_RESIDENT) + -BIT_SHIFT(GLIBTOP_PROCDATA_SHARE) + -BIT_SHIFT(GLIBTOP_PROCDATA_TRS) + -BIT_SHIFT(GLIBTOP_PROCDATA_LRS) + -BIT_SHIFT(GLIBTOP_PROCDATA_DRS) + -BIT_SHIFT(GLIBTOP_PROCDATA_DT) + -BIT_SHIFT(GLIBTOP_PROCDATA_VSIZE) + -BIT_SHIFT(GLIBTOP_PROCDATA_RSS) + -BIT_SHIFT(GLIBTOP_PROCDATA_RSS_RLIM) + -BIT_SHIFT(GLIBTOP_PROCDATA_TIMEOUT) + -BIT_SHIFT(GLIBTOP_PROCDATA_IT_REAL_VALUE); - -static const unsigned long _glibtop_sysdeps_procdata_1 = -BIT_SHIFT(GLIBTOP_PROCDATA_K_FLAGS) + -BIT_SHIFT(GLIBTOP_PROCDATA_MIN_FLT) + -BIT_SHIFT(GLIBTOP_PROCDATA_MAJ_FLT) + -BIT_SHIFT(GLIBTOP_PROCDATA_CMIN_FLT) + -BIT_SHIFT(GLIBTOP_PROCDATA_CMAJ_FLT) + -BIT_SHIFT(GLIBTOP_PROCDATA_START_CODE) + -BIT_SHIFT(GLIBTOP_PROCDATA_END_CODE) + -BIT_SHIFT(GLIBTOP_PROCDATA_START_STACK) + -BIT_SHIFT(GLIBTOP_PROCDATA_KSTK_ESP) + -BIT_SHIFT(GLIBTOP_PROCDATA_KSTK_EIP) + -BIT_SHIFT(GLIBTOP_PROCDATA_WCHAN); - -/* Provides detailed information about a process. */ - -void -glibtop_get_procdata_s (glibtop *server, glibtop_procdata *buf, pid_t pid) -{ - char input [BUFSIZ], *tmp; - struct stat statb; - int nread; - FILE *f; - - glibtop_init_r (&server, 0, 0); - - memset (buf, 0, sizeof (glibtop_procdata)); - - if (pid == 0) { - /* Client is only interested in the flags. */ - buf->flags [0] = _glibtop_sysdeps_procdata_0; - buf->flags [1] = _glibtop_sysdeps_procdata_1; - return; - } - - - sprintf (input, "/proc/%d/stat", pid); - - if (stat (input, &statb)) return; - - buf->uid = statb.st_uid; - - f = fopen (input, "r"); - if (!f) return; - - nread = fread (input, 1, BUFSIZ, f); - - if (nread < 0) { - fclose (f); - return; - } - - input [nread] = 0; - - /* This is from guile-utils/gtop/proc/readproc.c */ - - /* split into "PID (cmd" and "<rest>" */ - tmp = strrchr (input, ')'); - *tmp = '\0'; /* replace trailing ')' with NUL */ - /* parse these two strings separately, skipping the leading "(". */ - memset (buf->cmd, 0, sizeof (buf->cmd)); - sscanf (input, "%d (%39c", &buf->pid, buf->cmd); - sscanf(tmp + 2, /* skip space after ')' too */ - "%c %d %d %d %d %d %lu %lu %lu %lu %lu " - "%ld %ld %ld %ld %d %d %lu %lu %ld %lu " - "%lu %lu %lu %lu %lu %lu %lu %d %d %d %d %lu", - &buf->state, &buf->ppid, &buf->pgrp, &buf->session, - &buf->tty, &buf->tpgid, &buf->k_flags, &buf->min_flt, - &buf->cmin_flt, &buf->maj_flt, &buf->cmaj_flt, - &buf->utime, &buf->stime, &buf->cutime, &buf->cstime, - &buf->priority, &buf->nice, &buf->timeout, - &buf->it_real_value, &buf->start_time, &buf->vsize, - &buf->rss, &buf->rss_rlim, &buf->start_code, - &buf->end_code, &buf->start_stack, &buf->kstk_esp, - &buf->kstk_eip, &buf->signal, &buf->blocked, - &buf->sigignore, &buf->sigcatch, &buf->wchan); - - if (buf->tty == 0) - /* the old notty val, update elsewhere bef. moving to 0 */ - buf->tty = -1; - - fclose (f); - - sprintf (input, "/proc/%d/statm", pid); - - f = fopen (input, "r"); - if (!f) return; - - nread = fread (input, 1, BUFSIZ, f); - - if (nread < 0) { - fclose (f); - return; - } - - input [nread] = 0; - - sscanf (input, "%ld %ld %ld %ld %ld %ld %ld", - &buf->size, &buf->resident, &buf->share, - &buf->trs, &buf->lrs, &buf->drs, &buf->dt); - - fclose (f); - - buf->flags [0] = _glibtop_sysdeps_procdata_0; - buf->flags [1] = _glibtop_sysdeps_procdata_1; -} diff --git a/sysdeps/freebsd/prockernel.c b/sysdeps/freebsd/prockernel.c index 08a8511b..759ab5d5 100644 --- a/sysdeps/freebsd/prockernel.c +++ b/sysdeps/freebsd/prockernel.c @@ -32,51 +32,27 @@ #include <sys/param.h> #include <sys/sysctl.h> #include <sys/proc.h> -#if (!defined __OpenBSD__) && (!defined __bsdi__) #include <sys/user.h> -#endif -#if !defined(__bsdi__) && !(defined(__FreeBSD__) && defined(__alpha__)) && \ - !defined(__NetBSD__) -#include <machine/pcb.h> -#endif #include <unistd.h> #include <fcntl.h> -#ifdef __FreeBSD__ #include <osreldate.h> -#endif - -#ifdef __NetBSD__ -#include <machine/vmparam.h> -#include <machine/pmap.h> -#ifdef __arm32__ -#define KERNBASE KERNEL_BASE -#endif -#endif - -#ifdef __NetBSD__ -#include <machine/vmparam.h> -#include <machine/pmap.h> -#ifdef __arm32__ -#define KERNBASE KERNEL_BASE -#endif -#endif - static const unsigned long _glibtop_sysdeps_proc_kernel_pstats = +(1L << GLIBTOP_PROC_KERNEL_K_FLAGS) + (1L << GLIBTOP_PROC_KERNEL_MIN_FLT) + (1L << GLIBTOP_PROC_KERNEL_MAJ_FLT) + +#if (__FreeBSD_version >= 600006) || defined(__FreeBSD_kernel__) (1L << GLIBTOP_PROC_KERNEL_CMIN_FLT) + (1L << GLIBTOP_PROC_KERNEL_CMAJ_FLT); - -static const unsigned long _glibtop_sysdeps_proc_kernel_pcb = -(1L << GLIBTOP_PROC_KERNEL_KSTK_EIP) + -(1L << GLIBTOP_PROC_KERNEL_KSTK_ESP); +#else +0; +#endif static const unsigned long _glibtop_sysdeps_proc_kernel_wchan = -(1L << GLIBTOP_PROC_KERNEL_NWCHAN) + -(1L << GLIBTOP_PROC_KERNEL_WCHAN); +(1L << GLIBTOP_PROC_KERNEL_WCHAN) + +(1L << GLIBTOP_PROC_KERNEL_NWCHAN); /* Init function. */ @@ -84,7 +60,6 @@ void glibtop_init_proc_kernel_p (glibtop *server) { server->sysdeps.proc_kernel = _glibtop_sysdeps_proc_kernel_pstats | - _glibtop_sysdeps_proc_kernel_pcb | _glibtop_sysdeps_proc_kernel_wchan; } @@ -94,16 +69,8 @@ glibtop_get_proc_kernel_p (glibtop *server, pid_t pid) { struct kinfo_proc *pinfo; -#if !(defined(__FreeBSD__) || defined(__FreeBSD_kernel__)) - struct user *u_addr = (struct user *)USRSTACK; - struct pstats pstats; - struct pcb pcb; -#endif int count; - char filename [BUFSIZ]; - struct stat statb; - glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_PROC_KERNEL), 0); memset (buf, 0, sizeof (glibtop_proc_kernel)); @@ -114,159 +81,43 @@ glibtop_get_proc_kernel_p (glibtop *server, /* It does not work for the swapper task. */ if (pid == 0) return; + glibtop_suid_enter (server); + /* Get the process information */ pinfo = kvm_getprocs (server->machine.kd, KERN_PROC_PID, pid, &count); if ((pinfo == NULL) || (count != 1)) { glibtop_warn_io_r (server, "kvm_getprocs (%d)", pid); + glibtop_suid_leave (server); return; } -#if (defined(__FreeBSD__) && (__FreeBSD_version >= 500013)) || defined(__FreeBSD_kernel__) + glibtop_suid_leave (server); #define PROC_WCHAN ki_wchan #define PROC_WMESG ki_wmesg #define PROC_WMESG ki_wmesg -#else - -#define PROC_WCHAN kp_proc.p_wchan -#define PROC_WMESG kp_proc.p_wmesg -#define PROC_WMESG kp_eproc.e_wmesg - -#endif - -#if !defined(__NetBSD__) || !defined(SACTIVE) - buf->nwchan = (unsigned long) pinfo [0].PROC_WCHAN &~ KERNBASE; + buf->nwchan = (unsigned long) pinfo [0].PROC_WCHAN; buf->flags |= (1L << GLIBTOP_PROC_KERNEL_NWCHAN); - if (pinfo [0].PROC_WCHAN && pinfo [0].PROC_WMESG) { + if (pinfo [0].PROC_WCHAN && pinfo [0].PROC_WMESG[0] != 0) { g_strlcpy (buf->wchan, pinfo [0].PROC_WMESG, sizeof buf->wchan); buf->flags |= (1L << GLIBTOP_PROC_KERNEL_WCHAN); } else { buf->wchan [0] = 0; } -#endif - -#if !(defined(__FreeBSD__) || defined(__FreeBSD_kernel__)) - - /* Taken from `saveuser ()' in `/usr/src/bin/ps/ps.c'. */ - - /* [FIXME]: /usr/include/sys/user.h tells me that the user area - * may or may not be at the same kernel address in all - * processes, but I don't see any way to get that address. - * Since `ps' simply uses its own address, I think it's - * safe to do this here, too. */ - /* NOTE: You need to mount the /proc filesystem to make - * `kvm_uread' work. */ - - sprintf (filename, "/proc/%d/mem", (int) pid); - if (stat (filename, &statb)) return; - - glibtop_suid_enter (server); - -#if !defined(__NetBSD__) || !defined(SACTIVE) -#ifdef __NetBSD__ - /* On NetBSD, there is no kvm_uread(), and kvm_read() always reads - * from kernel memory. */ - - if (kvm_read (server->machine.kd, -#else - - if ((pinfo [0].kp_proc.p_flag & P_INMEM) && - kvm_uread (server->machine.kd, &(pinfo [0]).kp_proc, + buf->k_flags = (unsigned long) pinfo [0].ki_flag; + buf->min_flt = (unsigned long) pinfo [0].ki_rusage.ru_minflt; + buf->maj_flt = (unsigned long) pinfo [0].ki_rusage.ru_majflt; +#if (__FreeBSD_version >= 600006) || defined(__FreeBSD_kernel__) + buf->cmin_flt = (unsigned long) buf->min_flt + pinfo [0].ki_rusage_ch.ru_minflt; + buf->cmaj_flt = (unsigned long) buf->maj_flt + pinfo [0].ki_rusage_ch.ru_majflt; #endif - (unsigned long) &u_addr->u_stats, - (char *) &pstats, sizeof (pstats)) == sizeof (pstats)) - { - /* - * The u-area might be swapped out, and we can't get - * at it because we have a crashdump and no swap. - * If it's here fill in these fields, otherwise, just - * leave them 0. - */ - buf->min_flt = (guint64) pstats.p_ru.ru_minflt; - buf->maj_flt = (guint64) pstats.p_ru.ru_majflt; - buf->cmin_flt = (guint64) pstats.p_cru.ru_minflt; - buf->cmaj_flt = (guint64) pstats.p_cru.ru_majflt; + buf->flags |= _glibtop_sysdeps_proc_kernel_pstats; - buf->flags |= _glibtop_sysdeps_proc_kernel_pstats; - } - -#ifdef __NetBSD__ - if (kvm_read (server->machine.kd, -#else - if ((pinfo [0].kp_proc.p_flag & P_INMEM) && - kvm_uread (server->machine.kd, &(pinfo [0]).kp_proc, -#endif - (unsigned long) &u_addr->u_pcb, - (char *) &pcb, sizeof (pcb)) == sizeof (pcb)) - { -#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) -#ifndef __alpha__ -#if (__FreeBSD_version >= 300003) || defined(__FreeBSD_kernel__) - buf->kstk_esp = (guint64) pcb.pcb_esp; - buf->kstk_eip = (guint64) pcb.pcb_eip; -#else - buf->kstk_esp = (guint64) pcb.pcb_ksp; - buf->kstk_eip = (guint64) pcb.pcb_pc; -#endif -#else - /*xxx FreeBSD/Alpha? */ -#endif -#else -#ifdef __i386__ - buf->kstk_esp = (guint64) pcb.pcb_tss.tss_esp0; -#ifdef __bsdi__ - buf->kstk_eip = (guint64) pcb.pcb_tss.tss_eip; -#else - buf->kstk_eip = (guint64) pcb.pcb_tss.__tss_eip; -#endif -#else -#if defined(__NetBSD__) -#if defined(__m68k__) - buf->kstk_esp = (guint64) pcb.pcb_usp; - buf->kstk_eip = (guint64) 0; -#elif defined(__x86_64__) - buf->kstk_esp = (guint64) pcb.pcb_usersp; - buf->kstk_eip = (guint64) 0; -#elif (defined(__arm32__) || defined(__powerpc__)) - buf->kstk_esp = (guint64) pcb.pcb_sp; - buf->kstk_eip = (guint64) 0; -#elif defined(__mipsel__) - buf->kstk_esp = (guint64) pcb.pcb_context[8]; - buf->kstk_eip = (guint64) 0; -#elif defined(__sparc__) - buf->kstk_esp = (guint64) pcb.pcb_sp; - buf->kstk_eip = (guint64) pcb.pcb_pc; -#elif defined(__alpha__) - buf->kstk_esp = (guint64) pcb.pcb_context[9]; - buf->kstk_eip = (guint64) pcb.pcb_context[8]; -#else - /* provide some defaults for other platforms */ - buf->kstk_esp = (guint64) 0; - buf->kstk_eip = (guint64) 0; -#endif /* ${MACHINE_ARCH} */ -#endif /* __NetBSD__ */ - buf->flags |= _glibtop_sysdeps_proc_kernel_pcb; -#endif -#endif - } -#endif - - /* Taken from `wchan ()' in `/usr/src/bin/ps/print.c'. */ - - glibtop_suid_leave (server); - -#else - /* XXX: the code here was, quite frankly, junk, and almost - * certainly wrong - remove it all, leave these fields - * unpopulated, and give up until such time as the right - * code is produced for both FreeBSD 4.x and 5.x - */ return; -#endif /* __FreeBSD__ */ } diff --git a/sysdeps/freebsd/proclist.c b/sysdeps/freebsd/proclist.c index 9a866550..665ac4c1 100644 --- a/sysdeps/freebsd/proclist.c +++ b/sysdeps/freebsd/proclist.c @@ -25,9 +25,14 @@ #include <glibtop.h> #include <glibtop/error.h> #include <glibtop/proclist.h> +#include <glibtop/procstate.h> #include <glibtop_suid.h> +#include <sys/types.h> +#include <sys/sysctl.h> +#include <sys/user.h> + static const unsigned long _glibtop_sysdeps_proclist = (1L << GLIBTOP_PROCLIST_TOTAL) + (1L << GLIBTOP_PROCLIST_NUMBER) + (1L << GLIBTOP_PROCLIST_SIZE); @@ -60,56 +65,90 @@ glibtop_init_proclist_p (glibtop *server) unsigned * glibtop_get_proclist_p (glibtop *server, glibtop_proclist *buf, - gint64 real_which, gint64 arg) + gint64 which, gint64 arg) { struct kinfo_proc *pinfo; - unsigned *pids = NULL; - int which, count; - int i,j; + GArray *pids; + glibtop_proc_state procstate; + size_t len; + unsigned int i; glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_PROCLIST), 0); memset (buf, 0, sizeof (glibtop_proclist)); - which = (int)(real_which & GLIBTOP_KERN_PROC_MASK); + if (sysctlbyname ("kern.proc.all", NULL, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.proc.all)"); + return NULL; + } + + pinfo = (struct kinfo_proc *) g_malloc0 (len); - /* Get the process data */ - pinfo = kvm_getprocs (server->machine.kd, which, arg, &count); - if ((pinfo == NULL) || (count < 1)) { - glibtop_warn_io_r (server, "kvm_getprocs (proclist)"); + if (sysctlbyname ("kern.proc.all", pinfo, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.proc.all)"); + g_free (pinfo); return NULL; } - count--; - - /* Allocate count objects in the pids_chain array - * Same as malloc is pids is NULL, which it is. */ - pids = g_realloc (pids, count * sizeof (unsigned)); - /* Copy the pids over to this chain */ - for (i=j=0; i < count; i++) { -#if (defined(__FreeBSD__) && (__FreeBSD_version >= 500013)) || defined(__FreeBSD_kernel__) -#define PROC_STAT ki_stat -#define PROC_RUID ki_ruid -#define PROC_PID ki_pid - -#else -#define PROC_STAT kp_proc.p_stat -#define PROC_RUID kp_eproc.e_pcred.p_ruid -#define PROC_PID kp_proc.p_pid - -#endif - - if ((real_which & GLIBTOP_EXCLUDE_IDLE) && - (pinfo[i].PROC_STAT != SRUN)) - continue; - else if ((real_which & GLIBTOP_EXCLUDE_SYSTEM) && - (pinfo[i].PROC_RUID == 0)) - continue; - pids [j++] = (unsigned) pinfo[i].PROC_PID; - } /* end for */ - /* Set the fields in buf */ - buf->number = j; - buf->size = sizeof (unsigned); - buf->total = j * sizeof (unsigned); + + len /= sizeof (struct kinfo_proc); + + pids = g_array_sized_new (FALSE, FALSE, sizeof (unsigned), len); + + for (i = 0; i < len; i++) { + unsigned pid; + + pid = (unsigned) pinfo[i].ki_pid; + + switch (which & GLIBTOP_KERN_PROC_MASK) { + case GLIBTOP_KERN_PROC_ALL: + break; + case GLIBTOP_KERN_PROC_PID: + if ((unsigned) arg != pid) + continue; + break; + case GLIBTOP_KERN_PROC_UID: + if ((uid_t) arg != pinfo[i].ki_ruid) + continue; + break; + case GLIBTOP_KERN_PROC_PGRP: + if ((pid_t) arg != pinfo[i].ki_pgid) + continue; + break; + case GLIBTOP_KERN_PROC_SESSION: + if ((pid_t) arg != pinfo[i].ki_sid) + continue; + break; + case GLIBTOP_KERN_PROC_TTY: + if ((dev_t) arg != pinfo[i].ki_tdev) + continue; + break; + case GLIBTOP_KERN_PROC_RUID: + if ((uid_t) arg != pinfo[i].ki_ruid) + continue; + break; + } + + if (which & GLIBTOP_EXCLUDE_NOTTY) + if (pinfo[i].ki_tdev == (dev_t) -1) continue; + + if (which & GLIBTOP_EXCLUDE_IDLE) { + glibtop_get_proc_state_p (server, &procstate, pid); + if (procstate.flags & (1L << GLIBTOP_PROC_STATE_STATE)) + if (procstate.state != GLIBTOP_PROCESS_RUNNING) continue; + } + + if (which & GLIBTOP_EXCLUDE_SYSTEM) + if (pinfo[i].ki_ruid == (uid_t) 0) continue; + + g_array_append_val (pids, pid); + } + + g_free (pinfo); + buf->flags = _glibtop_sysdeps_proclist; - return pids; + buf->size = sizeof (unsigned); + buf->number = pids->len; + buf->total = buf->number * buf->size; + + return (unsigned *) g_array_free (pids, FALSE); } diff --git a/sysdeps/freebsd/procmap.c b/sysdeps/freebsd/procmap.c index 8c2c0f89..0b60d096 100644 --- a/sysdeps/freebsd/procmap.c +++ b/sysdeps/freebsd/procmap.c @@ -32,282 +32,256 @@ #include <sys/param.h> #include <sys/proc.h> #include <sys/resource.h> -#if defined(__NetBSD__) && (__NetBSD_Version__ < 105020000) #include <vm/vm_object.h> -#include <vm/vm_prot.h> #include <vm/vm_map.h> -#elif defined(__NetBSD__) && (__NetBSD_Version__ >= 105020000) -#include <uvm/uvm_extern.h> -#else -#include <vm/vm_object.h> -#include <vm/vm_map.h> -#if (__FreeBSD_version >= 400011) || defined(__FreeBSD_kernel__) #include <vm/vm.h> -#else -#include <vm/vm_prot.h> -#endif -#endif -#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) #define _KVM_VNODE -#endif #include <sys/vnode.h> -#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) #undef _KVM_VNODE -#endif + +#define _KERNEL +#include <sys/pipe.h> +#include <sys/conf.h> +#include <sys/file.h> #include <sys/mount.h> #include <ufs/ufs/quota.h> #include <ufs/ufs/inode.h> +#include <fs/devfs/devfs.h> +#if (__FreeBSD_version >= 600006) || defined(__FreeBSD_kernel__) +#include <fs/devfs/devfs_int.h> +#endif +#undef _KERNEL #include <sys/ucred.h> -#if (!defined __OpenBSD__) && (!defined __bsdi__) -#include <sys/user.h> -#endif #include <sys/sysctl.h> -#if !defined(__NetBSD__) || (__NetBSD_Version__ < 105020000) -#include <vm/vm.h> -#endif - -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) -/* Fixme ... */ -#undef _KERNEL -#define _UVM_UVM_AMAP_I_H_ 1 -#define _UVM_UVM_MAP_I_H_ 1 -#include <uvm/uvm.h> -#endif static const unsigned long _glibtop_sysdeps_proc_map = -(1L << GLIBTOP_PROC_MAP_TOTAL) + (1L << GLIBTOP_PROC_MAP_NUMBER) + -(1L << GLIBTOP_PROC_MAP_SIZE); + (1L << GLIBTOP_PROC_MAP_TOTAL) + (1L << GLIBTOP_PROC_MAP_NUMBER) + + (1L << GLIBTOP_PROC_MAP_SIZE); static const unsigned long _glibtop_sysdeps_map_entry = -(1L << GLIBTOP_MAP_ENTRY_START) + (1L << GLIBTOP_MAP_ENTRY_END) + -(1L << GLIBTOP_MAP_ENTRY_OFFSET) + (1L << GLIBTOP_MAP_ENTRY_PERM) + -(1L << GLIBTOP_MAP_ENTRY_INODE) + (1L << GLIBTOP_MAP_ENTRY_DEVICE); + (1L << GLIBTOP_MAP_ENTRY_START) + (1L << GLIBTOP_MAP_ENTRY_END) + + (1L << GLIBTOP_MAP_ENTRY_OFFSET) + (1L << GLIBTOP_MAP_ENTRY_PERM) + + (1L << GLIBTOP_MAP_ENTRY_INODE) + (1L << GLIBTOP_MAP_ENTRY_DEVICE); + +#if (__FreeBSD_version >= 600006) || defined(__FreeBSD_kernel__) +void _glibtop_sysdeps_freebsd_dev_inode (glibtop *server, struct vnode *vnode, struct vnode *vn, guint64 *inum, guint64 *dev); + +void +_glibtop_sysdeps_freebsd_dev_inode (glibtop *server, struct vnode *vnode, + struct vnode *vn, guint64 *inum, + guint64 *dev) +{ + char *tagptr; + char tagstr[12]; + struct inode inode; + struct cdev_priv priv; + struct cdev si; + + *inum = 0; + *dev = 0; + + if (kvm_read (server->machine.kd, (gulong) &vnode->v_tag, + (char *) &tagptr, sizeof (tagptr)) != sizeof (tagptr) || + kvm_read (server->machine.kd, (gulong) tagptr, + (char *) tagstr, sizeof (tagstr)) != sizeof (tagstr)) + { + glibtop_warn_io_r (server, "kvm_read (tagptr)"); + return; + } + + tagstr[sizeof(tagstr) - 1] = '\0'; + + if (strcmp (tagstr, "ufs")) + return; + + if (kvm_read (server->machine.kd, (gulong) VTOI(vn), (char *) &inode, + sizeof (inode)) != sizeof (inode)) + { + glibtop_warn_io_r (server, "kvm_read (inode)"); + return; + } + + if (kvm_read (server->machine.kd, (gulong) inode.i_dev, (char *) &si, + sizeof (si)) != sizeof (si) || + kvm_read (server->machine.kd, (gulong) si.si_priv, (char *) &priv, + sizeof (priv)) != sizeof (priv)) + { + glibtop_warn_io_r (server, "kvm_read (si)"); + return; + } + + *inum = (guint64) inode.i_number; + *dev = (guint64) priv.cdp_inode; +} +#endif /* Init function. */ void glibtop_init_proc_map_p (glibtop *server) { - server->sysdeps.proc_map = _glibtop_sysdeps_proc_map; + server->sysdeps.proc_map = _glibtop_sysdeps_proc_map; } /* Provides detailed information about a process. */ glibtop_map_entry * glibtop_get_proc_map_p (glibtop *server, glibtop_proc_map *buf, - pid_t pid) + pid_t pid) { - struct kinfo_proc *pinfo; - struct vm_map_entry entry, *first; - struct vmspace vmspace; -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) - struct vnode vnode; - struct inode inode; -#else - struct vm_object object; -#endif - GArray *maps = g_array_sized_new(FALSE, FALSE, - sizeof(glibtop_map_entry), - 100); -#if (defined __FreeBSD__) || defined(__FreeBSD_kernel__) - struct vnode vnode; -#if (__FreeBSD_version < 500039) && !defined(__FreeBSD_kernel__) - struct inode inode; -#endif -#endif - int count, i = 0; - int update = 0; - - glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_PROC_MAP), 0); - - memset (buf, 0, sizeof (glibtop_proc_map)); - - /* It does not work for the swapper task. */ - if (pid == 0) return (glibtop_map_entry*) g_array_free(maps, TRUE); - - glibtop_suid_enter (server); - - /* Get the process data */ - pinfo = kvm_getprocs (server->machine.kd, KERN_PROC_PID, pid, &count); - if ((pinfo == NULL) || (count < 1)) { - glibtop_warn_io_r (server, "kvm_getprocs (%d)", pid); - return (glibtop_map_entry*) g_array_free(maps, TRUE); - } - - /* Now we get the memory maps. */ - - if (kvm_read (server->machine.kd, -#if (defined(__FreeBSD__) && (__FreeBSD_version >= 500013)) || defined(__FreeBSD_kernel__) - (unsigned long) pinfo [0].ki_vmspace, -#else - (unsigned long) pinfo [0].kp_proc.p_vmspace, -#endif - (char *) &vmspace, sizeof (vmspace)) != sizeof (vmspace)) - glibtop_error_io_r (server, "kvm_read (vmspace)"); - - first = vmspace.vm_map.header.next; - - if (kvm_read (server->machine.kd, - (unsigned long) vmspace.vm_map.header.next, - (char *) &entry, sizeof (entry)) != sizeof (entry)) - glibtop_error_io_r (server, "kvm_read (entry)"); - - /* Allocate space. */ - - buf->number = vmspace.vm_map.nentries; - buf->size = sizeof (glibtop_map_entry); - - buf->total = buf->number * buf->size; - - buf->flags = _glibtop_sysdeps_proc_map; - - /* Walk through the `vm_map_entry' list ... */ - - /* I tested this a few times with `mmap'; as soon as you write - * to the mmap'ed area, the object type changes from OBJT_VNODE - * to OBJT_DEFAULT so if seems this really works. */ - - do { - glibtop_map_entry *mentry; - unsigned long inum, dev; - guint len; - - if (update) { - if (kvm_read (server->machine.kd, - (unsigned long) entry.next, - &entry, sizeof (entry)) != sizeof (entry)) - glibtop_error_io_r (server, "kvm_read (entry)"); - } else { - update = 1; - } - -#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) -#if (__FreeBSD__ >= 4) || defined(__FreeBSD_kernel__) - if (entry.eflags & (MAP_ENTRY_IS_SUB_MAP)) - continue; -#else - if (entry.eflags & (MAP_ENTRY_IS_A_MAP|MAP_ENTRY_IS_SUB_MAP)) - continue; -#endif -#else -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) - if (UVM_ET_ISSUBMAP (&entry)) - continue; -#else - if (entry.is_a_map || entry.is_sub_map) - continue; -#endif -#endif - - -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) - if (!entry.object.uvm_obj) - continue; - - /* We're only interested in vnodes */ + struct kinfo_proc *pinfo; + struct vm_map_entry entry, *first; + struct vmspace vmspace; + struct vm_object object; + GArray *maps; + struct vnode vnode; + int count; + int update = 0; + + glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_PROC_MAP), 0); + + memset (buf, 0, sizeof (glibtop_proc_map)); + + /* It does not work for the swapper task. */ + if (pid == 0) return NULL; + + /*return (glibtop_map_entry*) g_array_free(maps, TRUE);*/ + + glibtop_suid_enter (server); + + /* Get the process data */ + pinfo = kvm_getprocs (server->machine.kd, KERN_PROC_PID, pid, &count); + if ((pinfo == NULL) || (count < 1)) { + glibtop_warn_io_r (server, "kvm_getprocs (%d)", pid); + glibtop_suid_leave (server); + return NULL; + } + + /* Now we get the memory maps. */ + + if (kvm_read (server->machine.kd, + (gulong) pinfo [0].ki_vmspace, + (char *) &vmspace, sizeof (vmspace)) != sizeof (vmspace)) { + glibtop_warn_io_r (server, "kvm_read (vmspace)"); + glibtop_suid_leave (server); + return NULL; + } + + first = vmspace.vm_map.header.next; + + if (kvm_read (server->machine.kd, + (gulong) vmspace.vm_map.header.next, + (char *) &entry, sizeof (entry)) != sizeof (entry)) { + glibtop_warn_io_r (server, "kvm_read (entry)"); + glibtop_suid_leave (server); + return NULL; + } + + /* Walk through the `vm_map_entry' list ... */ + + /* I tested this a few times with `mmap'; as soon as you write + * to the mmap'ed area, the object type changes from OBJT_VNODE + * to OBJT_DEFAULT so if seems this really works. */ + + maps = g_array_sized_new(FALSE, FALSE, sizeof(glibtop_map_entry), + vmspace.vm_map.nentries); + + do { + glibtop_map_entry *mentry; + guint64 inum, dev; + guint len; + + if (update) { + if (kvm_read (server->machine.kd, + (gulong) entry.next, + (char *) &entry, sizeof (entry)) != sizeof (entry)) { + glibtop_warn_io_r (server, "kvm_read (entry)"); + continue; + } + } else { + update = 1; + } + + if (entry.eflags & (MAP_ENTRY_IS_SUB_MAP)) + continue; + + if (!entry.object.vm_object) + continue; + + /* We're only interested in `vm_object's */ + + if (kvm_read (server->machine.kd, + (gulong) entry.object.vm_object, + (char *) &object, sizeof (object)) != sizeof (object)) { + glibtop_warn_io_r (server, "kvm_read (object)"); + continue; + } + + /* If the object is of type vnode, add its size */ + + if (object.type != OBJT_VNODE) + continue; + + if (!object.handle) + continue; + + if (kvm_read (server->machine.kd, + (gulong) object.handle, + (char *) &vnode, sizeof (vnode)) != sizeof (vnode)) { + glibtop_warn_io_r (server, "kvm_read (vnode)"); + continue; + } + + switch (vnode.v_type) { + case VNON: + case VBAD: + continue; + default: +#if (__FreeBSD_version < 600006) && !defined(__FreeBSD_kernel__) + inum = vnode.v_cachedid; + dev = vnode.v_cachedfs; - if (kvm_read (server->machine.kd, - (unsigned long) entry.object.uvm_obj, - &vnode, sizeof (vnode)) != sizeof (vnode)) { - glibtop_warn_io_r (server, "kvm_read (vnode)"); - return (glibtop_map_entry*) g_array_free(maps, TRUE); - } #else - if (!entry.object.vm_object) - continue; - - /* We're only interested in `vm_object's */ - - if (kvm_read (server->machine.kd, - (unsigned long) entry.object.vm_object, - &object, sizeof (object)) != sizeof (object)) - glibtop_error_io_r (server, "kvm_read (object)"); -#endif - -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) -#if defined(UVM_VNODE_VALID) - if (!vnode.v_uvm.u_flags & UVM_VNODE_VALID) - continue; + _glibtop_sysdeps_freebsd_dev_inode (server, + (struct vnode *) object.handle, + &vnode, &inum, &dev); #endif - if ((vnode.v_type != VREG) || (vnode.v_tag != VT_UFS) || - !vnode.v_data) continue; - - if (kvm_read (server->machine.kd, - (unsigned long) vnode.v_data, - &inode, sizeof (inode)) != sizeof (inode)) - glibtop_error_io_r (server, "kvm_read (inode)"); - - inum = inode.i_number; - dev = inode.i_dev; -#endif - + break; + } -#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) - /* If the object is of type vnode, add its size */ + len = maps->len; + g_array_set_size(maps, len + 1); + mentry = &g_array_index(maps, glibtop_map_entry, len); - if (object.type != OBJT_VNODE) - continue; + memset (mentry, 0, sizeof (glibtop_map_entry)); - if (!object.handle) - continue; - - if (kvm_read (server->machine.kd, - (unsigned long) object.handle, - &vnode, sizeof (vnode)) != sizeof (vnode)) - glibtop_error_io_r (server, "kvm_read (vnode)"); - -#if (defined(__FreeBSD__) && (__FreeBSD_version >= 500039)) || defined(__FreeBSD_kernel__) - switch (vnode.v_type) { - case VREG: -#if (__FreeBSD_version < 600006) && !defined(__FreeBSD_kernel__) - inum = vnode.v_cachedid; - dev = vnode.v_cachedfs; -#endif - default: - continue; - } -#else - if ((vnode.v_type != VREG) || (vnode.v_tag != VT_UFS) || - !vnode.v_data) continue; - - if (kvm_read (server->machine.kd, - (unsigned long) vnode.v_data, - &inode, sizeof (inode)) != sizeof (inode)) - glibtop_error_io_r (server, "kvm_read (inode)"); - - inum = inode.i_number; - dev = inode.i_dev; -#endif -#endif - len = maps->len; - g_array_set_size(maps, len + 1); - mentry = &g_array_index(maps, glibtop_map_entry, len); + mentry->flags = _glibtop_sysdeps_map_entry; + mentry->start = (guint64) entry.start; + mentry->end = (guint64) entry.end; + mentry->offset = (guint64) entry.offset; + mentry->device = (guint64) dev; + mentry->inode = (guint64) inum; - mentry->flags = _glibtop_sysdeps_map_entry; + mentry->perm = (guint64) 0; - mentry->start = (guint64) entry.start; - mentry->end = (guint64) entry.end; - mentry->offset = (guint64) entry.offset; - mentry->device = (guint64) dev; - mentry->inode = (guint64) inum; + if (entry.protection & VM_PROT_READ) + mentry->perm |= GLIBTOP_MAP_PERM_READ; + if (entry.protection & VM_PROT_WRITE) + mentry->perm |= GLIBTOP_MAP_PERM_WRITE; + if (entry.protection & VM_PROT_EXECUTE) + mentry->perm |= GLIBTOP_MAP_PERM_EXECUTE; - mentry->perm = (guint64) 0; + } while (entry.next != first); - if (entry.protection & VM_PROT_READ) - mentry->perm |= GLIBTOP_MAP_PERM_READ; - if (entry.protection & VM_PROT_WRITE) - mentry->perm |= GLIBTOP_MAP_PERM_WRITE; - if (entry.protection & VM_PROT_EXECUTE) - mentry->perm |= GLIBTOP_MAP_PERM_EXECUTE; - } while (entry.next != first); + glibtop_suid_leave (server); - buf->flags = _glibtop_sysdeps_proc_map; + buf->flags = _glibtop_sysdeps_proc_map; - buf->number = maps->len; - buf->size = sizeof (glibtop_map_entry); - buf->total = buf->number * buf->size; + buf->number = (guint64) maps->len; + buf->size = (guint64) sizeof (glibtop_map_entry); + buf->total = (guint64) (buf->number * buf->size); - return (glibtop_map_entry*) g_array_free(maps, FALSE); + return (glibtop_map_entry*) g_array_free(maps, FALSE); } diff --git a/sysdeps/freebsd/procmem.c b/sysdeps/freebsd/procmem.c index 864ff344..d18df8a4 100644 --- a/sysdeps/freebsd/procmem.c +++ b/sysdeps/freebsd/procmem.c @@ -32,36 +32,17 @@ #include <sys/param.h> #include <sys/proc.h> #include <sys/resource.h> -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 105020000) -#include <uvm/uvm_extern.h> -#else #include <vm/vm_object.h> #include <vm/vm_map.h> -#endif #include <sys/vnode.h> #include <ufs/ufs/quota.h> #include <ufs/ufs/inode.h> #include <sys/ucred.h> -#if (!defined __OpenBSD__) && (!defined __bsdi__) #include <sys/user.h> -#endif #include <sys/sysctl.h> -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 105020000) -#include <uvm/uvm.h> -#else #include <vm/vm.h> -#endif - -#if defined(__NetBSD__) && \ - (__NetBSD_Version__ >= 104000000) && (__NetBSD_Version__ < 105020000) -/* Fixme ... */ -#undef _KERNEL -#define _UVM_UVM_AMAP_I_H_ 1 -#define _UVM_UVM_MAP_I_H_ 1 -#include <uvm/uvm.h> -#endif static const unsigned long _glibtop_sysdeps_proc_mem = (1L << GLIBTOP_PROC_MEM_SIZE) + @@ -71,43 +52,16 @@ static const unsigned long _glibtop_sysdeps_proc_mem = (1L << GLIBTOP_PROC_MEM_RSS_RLIM); static const unsigned long _glibtop_sysdeps_proc_mem_share = -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) -(1L << GLIBTOP_PROC_MEM_SHARE); -#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) (1L << GLIBTOP_PROC_MEM_SHARE); -#else -0; -#endif - -#ifndef LOG1024 -#define LOG1024 10 -#endif - -/* 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) +#define ps_pgtok(a) (((a) * getpagesize()) / 1024) /* Init function. */ void glibtop_init_proc_mem_p (glibtop *server) { - register int pagesize; - - /* get the page size with "getpagesize" and calculate pageshift - * from it */ - pagesize = getpagesize (); - pageshift = 0; - while (pagesize > 1) { - pageshift++; - pagesize >>= 1; - } - - /* we only need the amount of log(2)1024 for our conversion */ - pageshift -= LOG1024; - server->sysdeps.proc_mem = _glibtop_sysdeps_proc_mem | _glibtop_sysdeps_proc_mem_share; } @@ -120,15 +74,8 @@ glibtop_get_proc_mem_p (glibtop *server, glibtop_proc_mem *buf, { struct kinfo_proc *pinfo; struct vm_map_entry entry, *first; - struct vmspace *vms, vmspace; -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) - struct vnode vnode; -#else + struct vmspace vmspace; struct vm_object object; -#endif -#if (!defined(__FreeBSD__) || (__FreeBSD_version < 500013)) && !defined(__FreeBSD_kernel__) - struct plimit plimit; -#endif int count; glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_PROC_MEM), 0); @@ -147,40 +94,15 @@ glibtop_get_proc_mem_p (glibtop *server, glibtop_proc_mem *buf, glibtop_warn_io_r (server, "kvm_getprocs (%d)", pid); return; } -#if (defined(__FreeBSD__) && (__FreeBSD_version >= 500013)) || defined(__FreeBSD_kernel__) #define PROC_VMSPACE ki_vmspace buf->rss_rlim = pinfo [0].ki_rssize; - buf->vsize = buf->size = (guint64) pagetok - (pinfo [0].ki_tsize + pinfo [0].ki_dsize + pinfo[0].ki_ssize) - << LOG1024; - buf->resident = buf->rss = (guint64) pagetok - (pinfo [0].ki_rssize) << LOG1024; - -#else - -#define PROC_VMSPACE kp_proc.p_vmspace - - if (kvm_read (server->machine.kd, - (unsigned long) pinfo [0].PROC_VMSPACE, - (char *) &plimit, sizeof (plimit)) != sizeof (plimit)) { - glibtop_warn_io_r (server, "kvm_read (plimit)"); - return; - } - - buf->rss_rlim = (guint64) - (plimit.pl_rlimit [RLIMIT_RSS].rlim_cur); - - vms = &pinfo [0].kp_eproc.e_vm; - - buf->vsize = buf->size = (guint64) pagetok - (vms->vm_tsize + vms->vm_dsize + vms->vm_ssize) << LOG1024; - - buf->resident = buf->rss = (guint64) pagetok - (vms->vm_rssize) << LOG1024; -#endif + buf->vsize = buf->size = (guint64) + (pinfo [0].ki_size / 1024); + buf->resident = buf->rss = (guint64) + ps_pgtok (pinfo [0].ki_rssize); /* Now we get the shared memory. */ @@ -209,42 +131,14 @@ glibtop_get_proc_mem_p (glibtop *server, glibtop_proc_mem *buf, while (entry.next != first) { if (kvm_read (server->machine.kd, (unsigned long) entry.next, - &entry, sizeof (entry)) != sizeof (entry)) { + (char *) &entry, sizeof (entry)) != sizeof (entry)) { glibtop_warn_io_r (server, "kvm_read (entry)"); return; } -#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) -#if (__FreeBSD__ >= 4) || defined(__FreeBSD_kernel__) if (entry.eflags & (MAP_ENTRY_IS_SUB_MAP)) continue; -#else - if (entry.eflags & (MAP_ENTRY_IS_A_MAP|MAP_ENTRY_IS_SUB_MAP)) - continue; -#endif -#else -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) - if (UVM_ET_ISSUBMAP (&entry)) - continue; -#else - if (entry.is_a_map || entry.is_sub_map) - continue; -#endif -#endif - -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) - if (!entry.object.uvm_obj) - continue; - - /* We're only interested in vnodes */ - if (kvm_read (server->machine.kd, - (unsigned long) entry.object.uvm_obj, - &vnode, sizeof (vnode)) != sizeof (vnode)) { - glibtop_warn_io_r (server, "kvm_read (vnode)"); - return; - } -#else if (!entry.object.vm_object) continue; @@ -252,42 +146,15 @@ glibtop_get_proc_mem_p (glibtop *server, glibtop_proc_mem *buf, if (kvm_read (server->machine.kd, (unsigned long) entry.object.vm_object, - &object, sizeof (object)) != sizeof (object)) { + (char *) &object, sizeof (object)) != sizeof (object)) { glibtop_warn_io_r (server, "kvm_read (object)"); return; } -#endif - /* If the object is of type vnode, add its size */ - -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) -#if defined(UVM_VNODE_VALID) - if (!vnode.v_uvm.u_flags & UVM_VNODE_VALID) - continue; -#endif - if ((vnode.v_type != VREG) || (vnode.v_tag != VT_UFS) || - !vnode.v_data) continue; -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 105250000) - /* Reference count must be at least two. */ - if (vnode.v_usecount <= 1) - continue; - - buf->share += pagetok (vnode.v_uobj.uo_npages) << LOG1024; -#else - - /* Reference count must be at least two. */ - if (vnode.v_uvm.u_obj.uo_refs <= 1) - continue; - - buf->share += pagetok (vnode.v_uvm.u_obj.uo_npages) << LOG1024; -#endif /* __NetBSD_Version__ >= 105250000 */ -#endif -#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) if (object.type != OBJT_VNODE) continue; buf->share += object.un_pager.vnp.vnp_size; -#endif } buf->flags = _glibtop_sysdeps_proc_mem | diff --git a/sysdeps/freebsd/procsegment.c b/sysdeps/freebsd/procsegment.c index 460f96ad..5790062f 100644 --- a/sysdeps/freebsd/procsegment.c +++ b/sysdeps/freebsd/procsegment.c @@ -32,13 +32,18 @@ #include <sys/param.h> #include <sys/sysctl.h> -static const unsigned long _glibtop_sysdeps_proc_segment = 0; +static const unsigned long _glibtop_sysdeps_proc_segment = +(1L << GLIBTOP_PROC_SEGMENT_TEXT_RSS) + +(1L << GLIBTOP_PROC_SEGMENT_DATA_RSS); + +static int pagesize; /* Init function. */ void glibtop_init_proc_segment_p (glibtop *server) { + pagesize = getpagesize (); server->sysdeps.proc_segment = _glibtop_sysdeps_proc_segment; } @@ -49,35 +54,25 @@ glibtop_get_proc_segment_p (glibtop *server, glibtop_proc_segment *buf, pid_t pid) { + struct kinfo_proc *pinfo; + int count = 0; + glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_PROC_SEGMENT), 0); memset (buf, 0, sizeof (glibtop_proc_segment)); -#if 0 + /* It does not work for the swapper task. */ + if (pid == 0) return; + /* Get the process info from the kernel */ - kvm_getprocs (server->machine.kd, KERN_PROC_PID, pid, count); - if (*count != 1) { - return; /* the zeroed-out buffer indicating no data */ + pinfo = kvm_getprocs (server->machine.kd, KERN_PROC_PID, pid, &count); + if ((pinfo == NULL) || (count != 1)) { + glibtop_warn_io_r (server, "kvm_getprocs (%d)", pid); + return; } - /* trs: text resident set size - pinfo[0]->kp_eproc.e_xrssize; - */ - /* buf->trs = pinfo[0]->kp_eproc.e_xrssize; */ - /* lrs: shared-lib resident set size - ? */ - /* drs: data resident set size - pinfo[0]->kp_eproc.e_vm.vm_map.vm_dsize; - */ - /* dt: dirty pages - */ - /* start_code: address of beginning of code segment - - */ - /* end_code: address of end of code segment - */ - /* start_stack: address of the bottom of stack segment - */ -#endif -} + buf->text_rss = pinfo[0].ki_tsize * pagesize; + buf->data_rss = pinfo[0].ki_dsize * pagesize; + buf->flags = _glibtop_sysdeps_proc_segment; +} diff --git a/sysdeps/freebsd/procsignal.c b/sysdeps/freebsd/procsignal.c index 41d9b00a..9ae966b7 100644 --- a/sysdeps/freebsd/procsignal.c +++ b/sysdeps/freebsd/procsignal.c @@ -30,9 +30,7 @@ #include <sys/param.h> -#ifdef __FreeBSD__ #include <osreldate.h> -#endif static const unsigned long _glibtop_sysdeps_proc_signal = (1L << GLIBTOP_PROC_SIGNAL_SIGNAL) + @@ -70,69 +68,30 @@ glibtop_get_proc_signal_p (glibtop *server, return; } -#if (defined(__FreeBSD__) && (__FreeBSD_version >= 500013)) || defined(__FreeBSD_kernel__) - #define PROC_SIGLIST ki_siglist #define PROC_SIGMASK ki_sigmask #define PROC_SIGIGNORE ki_sigignore #define PROC_SIGCATCH ki_sigcatch -#else - -#define PROC_SIGLIST kp_proc.p_siglist -#define PROC_SIGMASK kp_proc.p_sigmask -#define PROC_SIGIGNORE kp_proc.p_sigignore -#define PROC_SIGCATCH kp_proc.p_sigcatch - -#endif - /* signal: mask of pending signals. * pinfo [0].kp_proc.p_siglist */ -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 105150000) - buf->signal [0] = pinfo [0].kp_proc.p_sigctx.ps_siglist.__bits[0]; -#elif (defined(__NetBSD__) && (NSIG > 32)) || \ - (defined(__FreeBSD__) && (__FreeBSD_version >= 400011) || defined(__FreeBSD_kernel__)) buf->signal [0] = pinfo [0].PROC_SIGLIST.__bits[0]; -#else - buf->signal [0] = pinfo [0].kp_proc.p_siglist; -#endif /* blocked: mask of blocked signals. * pinfo [0].kp_proc.p_sigmask */ -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 105150000) - buf->blocked [0] = pinfo [0].kp_proc.p_sigctx.ps_sigmask.__bits[0]; -#elif (defined(__NetBSD__) && (NSIG > 32)) || \ - (defined(__FreeBSD__) && (__FreeBSD_version >= 400011) || defined(__FreeBSD_kernel__)) buf->blocked [0] = pinfo [0].PROC_SIGMASK.__bits[0]; -#else - buf->blocked [0] = pinfo [0].kp_proc.p_sigmask; -#endif /* sigignore: mask of ignored signals. * pinfo [0].kp_proc.p_sigignore */ -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 105150000) - buf->sigignore [0] = pinfo [0].kp_proc.p_sigctx.ps_sigignore.__bits[0]; -#elif (defined(__NetBSD__) && (NSIG > 32)) || \ - (defined(__FreeBSD__) && (__FreeBSD_version >= 400011) || defined(__FreeBSD_kernel__)) buf->sigignore [0] = pinfo [0].PROC_SIGIGNORE.__bits[0]; -#else - buf->sigignore [0] = pinfo [0].kp_proc.p_sigignore; -#endif /* sigcatch: mask of caught signals. * pinfo [0].kp_proc.p_sigcatch */ -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 105150000) - buf->sigcatch [0] = pinfo [0].kp_proc.p_sigctx.ps_sigcatch.__bits[0]; -#elif (defined(__NetBSD__) && (NSIG > 32)) || \ - (defined(__FreeBSD__) && (__FreeBSD_version >= 400011) || defined(__FreeBSD_kernel__)) buf->sigcatch [0] = pinfo [0].PROC_SIGCATCH.__bits[0]; -#else - buf->sigcatch [0] = pinfo [0].kp_proc.p_sigcatch; -#endif buf->flags = _glibtop_sysdeps_proc_signal; } diff --git a/sysdeps/freebsd/procstate.c b/sysdeps/freebsd/procstate.c index 723a0c10..e5eee22b 100644 --- a/sysdeps/freebsd/procstate.c +++ b/sysdeps/freebsd/procstate.c @@ -28,25 +28,18 @@ #include <glibtop_suid.h> -#if !defined(__OpenBSD__) -/* && (!defined __bsdi__) */ #include <sys/user.h> -#endif static const unsigned long _glibtop_sysdeps_proc_state = -(1L << GLIBTOP_PROC_STATE_CMD) + (1L << GLIBTOP_PROC_STATE_UID) + -(1L << GLIBTOP_PROC_STATE_GID); - -static const unsigned long _glibtop_sysdeps_proc_state_new = -0; +(1L << GLIBTOP_PROC_STATE_CMD) + (1L << GLIBTOP_PROC_STATE_STATE) + +(1L << GLIBTOP_PROC_STATE_UID) + (1L << GLIBTOP_PROC_STATE_GID); /* Init function. */ void glibtop_init_proc_state_p (glibtop *server) { - server->sysdeps.proc_state = _glibtop_sysdeps_proc_state | - _glibtop_sysdeps_proc_state_new; + server->sysdeps.proc_state = _glibtop_sysdeps_proc_state; } /* Provides detailed information about a process. */ @@ -73,78 +66,33 @@ glibtop_get_proc_state_p (glibtop *server, return; } -#if (defined(__FreeBSD__) && (__FreeBSD_version >= 500013)) || defined(__FreeBSD_kernel__) -#define PROC_COMM ki_comm -#define PROC_SVUID ki_svuid -#define PROC_SVGID ki_svgid -#define PROC_RUID ki_ruid -#define PROC_RGID ki_rgid -#define PROC_STAT ki_stat - -#else -#define PROC_COMM kp_proc.p_comm -#define PROC_SVUID kp_eproc.e_pcred.p_svuid -#define PROC_SVGID kp_eproc.e_pcred.p_svgid -#define PROC_RUID kp_eproc.e_pcred.p_ruid -#define PROC_RGID kp_eproc.e_pcred.p_rgid -#define PROC_STAT kp_proc.p_stat - -#endif - - g_strlcpy (buf->cmd, pinfo [0].PROC_COMM, sizeof buf->cmd); - - buf->uid = pinfo [0].PROC_SVUID; - buf->gid = pinfo [0].PROC_SVGID; - - /* Set the flags for the data we're about to return*/ - buf->flags = _glibtop_sysdeps_proc_state | - _glibtop_sysdeps_proc_state_new; - -#if LIBGTOP_VERSION_CODE >= 1001000 - switch (pinfo [0].PROC_STAT) { - case SIDL: - buf->state = 0; - break; - case SRUN: - buf->state = GLIBTOP_PROCESS_RUNNING; - break; -#ifdef SSLEEP - case SSLEEP: - buf->state = GLIBTOP_PROCESS_INTERRUPTIBLE; - break; -#endif - case SSTOP: - buf->state = GLIBTOP_PROCESS_STOPPED; - break; - case SZOMB: - buf->state = GLIBTOP_PROCESS_ZOMBIE; - break; - default: - return; - } -#else - switch (pinfo [0].PROC_STAT) { - case SIDL: - buf->state = 'D'; - break; - case SRUN: - buf->state = 'R'; - break; -#ifdef SSLEEP - case SSLEEP: - buf->state = 'S'; - break; -#endif - case SSTOP: - buf->state = 'T'; - break; - case SZOMB: - buf->state = 'Z'; - break; - default: - return; + buf->uid = pinfo[0].ki_ruid; + buf->gid = pinfo[0].ki_rgid; + + g_strlcpy (buf->cmd, pinfo[0].ki_comm, sizeof (buf->cmd)); + + switch (pinfo[0].ki_stat) { + case SRUN: + buf->state = GLIBTOP_PROCESS_RUNNING; + break; + case SSLEEP: + buf->state = GLIBTOP_PROCESS_INTERRUPTIBLE; + break; + case SSTOP: + buf->state = GLIBTOP_PROCESS_STOPPED; + break; + case SZOMB: + buf->state = GLIBTOP_PROCESS_ZOMBIE; + break; + case SWAIT: + case SLOCK: + buf->state = GLIBTOP_PROCESS_UNINTERRUPTIBLE; + break; + case SIDL: + default: + buf->state = 0; + break; } -#endif - buf->flags |= (1L << GLIBTOP_PROC_STATE_STATE); + buf->flags = _glibtop_sysdeps_proc_state; } diff --git a/sysdeps/freebsd/proctime.c b/sysdeps/freebsd/proctime.c index b7bd595c..25239910 100644 --- a/sysdeps/freebsd/proctime.c +++ b/sysdeps/freebsd/proctime.c @@ -28,9 +28,8 @@ #include <glibtop_suid.h> -#ifdef __FreeBSD__ +#include <sys/time.h> #include <osreldate.h> -#endif static const unsigned long _glibtop_sysdeps_proc_time = (1L << GLIBTOP_PROC_TIME_RTIME) + (1L << GLIBTOP_PROC_TIME_FREQUENCY); @@ -53,63 +52,6 @@ glibtop_init_proc_time_p (glibtop *server) /* Taken from /usr/src/sys/kern/kern_resource.c */ -/* - * Transform the running time and tick information in proc p into user, - * system, and interrupt time usage. - */ - -#if !(defined(__FreeBSD__) || defined(__FreeBSD_kernel__)) - -static void -calcru(p, up, sp, ip) - struct proc *p; - struct timeval *up; - struct timeval *sp; - struct timeval *ip; -{ - quad_t totusec; - u_quad_t u, st, ut, it, tot; - long sec, usec; - struct timeval tv; - - st = p->p_sticks; - ut = p->p_uticks; - it = p->p_iticks; - - tot = st + ut + it; - if (tot == 0) { - st = 1; - tot = 1; - } - - sec = p->p_rtime.tv_sec; - usec = p->p_rtime.tv_usec; - - totusec = (quad_t)sec * 1000000 + usec; - - if (totusec < 0) { - /* XXX no %qd in kernel. Truncate. */ - fprintf (stderr, "calcru: negative time: %ld usec\n", - (long)totusec); - totusec = 0; - } - - - u = totusec; - st = (u * st) / tot; - sp->tv_sec = st / 1000000; - sp->tv_usec = st % 1000000; - ut = (u * ut) / tot; - up->tv_sec = ut / 1000000; - up->tv_usec = ut % 1000000; - if (ip != NULL) { - it = (u * it) / tot; - ip->tv_sec = it / 1000000; - ip->tv_usec = it % 1000000; - } -} -#endif /* !__FreeBSD__ */ - /* Provides detailed information about a process. */ void @@ -117,13 +59,9 @@ glibtop_get_proc_time_p (glibtop *server, glibtop_proc_time *buf, pid_t pid) { struct kinfo_proc *pinfo; -#if (defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000)) || (defined(OpenBSD) && (OpenBSD >= 199912)) - register struct rusage *rup; -#else - struct user *u_addr = (struct user *)USRSTACK; -#endif - struct pstats pstats; + struct clockinfo ci; int count; + size_t len; glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_PROC_TIME), 0); @@ -132,123 +70,42 @@ glibtop_get_proc_time_p (glibtop *server, glibtop_proc_time *buf, /* It does not work for the swapper task. */ if (pid == 0) return; -#if (defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000)) - if (server->sysdeps.proc_time == 0) - return; -#endif + glibtop_suid_enter (server); /* Get the process information */ pinfo = kvm_getprocs (server->machine.kd, KERN_PROC_PID, pid, &count); if ((pinfo == NULL) || (count != 1)) { glibtop_warn_io_r (server, "kvm_getprocs (%d)", pid); + glibtop_suid_leave (server); return; } -#if (defined(__FreeBSD__) && (__FreeBSD_version >= 500013)) || defined(__FreeBSD_kernel__) - buf->rtime = pinfo [0].ki_runtime; -#elif (defined __FreeBSD__) && (__FreeBSD_version <= 500013) - buf->rtime = pinfo [0].kp_proc.p_runtime; -#else - buf->rtime = tv2sec (pinfo [0].kp_proc.p_rtime); -#endif - - buf->frequency = 1000000; - buf->flags = _glibtop_sysdeps_proc_time; + glibtop_suid_leave (server); -#if (defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000)) || (defined(OpenBSD) && (OpenBSD >= 199912)) - glibtop_suid_enter (server); + buf->rtime = pinfo [0].ki_runtime * 1e-6; - if (kvm_read (server->machine.kd, - (unsigned long) pinfo [0].kp_proc.p_stats, - &pstats, sizeof (pstats)) != sizeof (pstats)) { - glibtop_warn_io_r (server, "kvm_read (pstats)"); + len = sizeof (ci); + if (sysctlbyname ("kern.clockrate", &ci, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.clockrate) (%d)", pid); + glibtop_suid_leave (server); return; } - glibtop_suid_leave (server); - - rup = &pstats.p_ru; - calcru(&(pinfo [0]).kp_proc, - &rup->ru_utime, &rup->ru_stime, NULL); - - buf->utime = tv2sec (pstats.p_ru.ru_utime); - buf->stime = tv2sec (pstats.p_ru.ru_stime); - - buf->cutime = tv2sec (pstats.p_cru.ru_utime); - buf->cstime = tv2sec (pstats.p_cru.ru_stime); + buf->frequency = (ci.stathz ? ci.stathz : ci.hz); + buf->flags = _glibtop_sysdeps_proc_time; - buf->start_time = (guint64) pstats.p_start.tv_sec; + buf->rtime *= buf->frequency; - buf->flags |= _glibtop_sysdeps_proc_time_user; -#else -#if (defined(__FreeBSD__) && (__FreeBSD_version >= 500013)) || defined(__FreeBSD_kernel__) -#if (__FreeBSD_version >= 500016) || defined(__FreeBSD_kernel__) if ((pinfo [0].ki_flag & PS_INMEM)) { + buf->utime = (pinfo [0].ki_runtime * 1e-6) * buf->frequency; + buf->stime = tv2sec (pinfo [0].ki_rusage.ru_stime) * buf->frequency; + buf->cutime = tv2sec (pinfo [0].ki_childtime) * buf->frequency; +#if (__FreeBSD_version >= 600006) || defined(__FreeBSD_kernel__) + buf->cstime = tv2sec (pinfo [0].ki_rusage_ch.ru_stime) * buf->frequency; #else - if ((pinfo [0].ki_flag & P_INMEM)) { -#endif - buf->utime = pinfo [0].ki_runtime; - buf->stime = tv2sec (pinfo [0].ki_rusage.ru_stime); - buf->cutime = tv2sec (pinfo [0].ki_childtime); -#if (__FreeBSD_version >= 600000) || (__FreeBSD_kernel_version >= 600000) - buf->cstime = tv2sec (pinfo [0].ki_rusage_ch.ru_stime); -#else - buf->cstime = 0; + buf->cstime = 0; #endif buf->start_time = tv2sec (pinfo [0].ki_start); - buf->flags = _glibtop_sysdeps_proc_time_user; + buf->flags |= _glibtop_sysdeps_proc_time_user; } - - glibtop_suid_enter (server); - -#elif (__FreeBSD_version <= 500013) - - if ((pinfo [0].kp_proc.p_flag & P_INMEM) && - kvm_uread (server->machine.kd, &(pinfo [0]).kp_proc, - (unsigned long) &u_addr->u_stats, - (char *) &pstats, sizeof (pstats)) == sizeof (pstats)) - { - - buf->utime = tv2sec (pinfo[0].kp_eproc.e_stats.p_ru.ru_utime); - buf->stime = tv2sec (pinfo[0].kp_eproc.e_stats.p_ru.ru_stime); - buf->cutime = tv2sec (pinfo[0].kp_eproc.e_stats.p_cru.ru_utime); - buf->cstime = tv2sec (pinfo[0].kp_eproc.e_stats.p_cru.ru_stime); - buf->start_time = tv2sec (pinfo[0].kp_eproc.e_stats.p_start); - buf->flags = _glibtop_sysdeps_proc_time_user; - glibtop_suid_leave (server); - } -#else - - if ((pinfo [0].kp_proc.p_flag & P_INMEM) && - kvm_uread (server->machine.kd, &(pinfo [0]).kp_proc, - (unsigned long) &u_addr->u_stats, - (char *) &pstats, sizeof (pstats)) == sizeof (pstats)) - { - /* This is taken form the kernel source code of - * FreeBSD 2.2.6. */ - - /* Well, we just do the same getrusage () does ... */ - - register struct rusage *rup; - - glibtop_suid_leave (server); - - rup = &pstats.p_ru; - calcru(&(pinfo [0]).kp_proc, - &rup->ru_utime, &rup->ru_stime, NULL); - - buf->utime = tv2sec (pstats.p_ru.ru_utime); - buf->stime = tv2sec (pstats.p_ru.ru_stime); - - buf->cutime = tv2sec (pstats.p_cru.ru_utime); - buf->cstime = tv2sec (pstats.p_cru.ru_stime); - - buf->start_time = tv2sec (pstats.p_start); - - buf->flags = _glibtop_sysdeps_proc_time_user; - } -#endif - glibtop_suid_leave (server); -#endif } - diff --git a/sysdeps/freebsd/procuid.c b/sysdeps/freebsd/procuid.c index 133c6b97..c7f130c2 100644 --- a/sysdeps/freebsd/procuid.c +++ b/sysdeps/freebsd/procuid.c @@ -33,18 +33,14 @@ static const unsigned long _glibtop_sysdeps_proc_uid = (1L << GLIBTOP_PROC_UID_EGID) + (1L << GLIBTOP_PROC_UID_PID) + (1L << GLIBTOP_PROC_UID_PPID) + (1L << GLIBTOP_PROC_UID_PGRP) + (1L << GLIBTOP_PROC_UID_TPGID) + (1L << GLIBTOP_PROC_UID_PRIORITY) + -(1L << GLIBTOP_PROC_UID_NICE); - -static const unsigned long _glibtop_sysdeps_proc_uid_groups = -0L; +(1L << GLIBTOP_PROC_UID_NICE) + (1L << GLIBTOP_PROC_UID_GID); /* Init function. */ void glibtop_init_proc_uid_p (glibtop *server) { - server->sysdeps.proc_uid = _glibtop_sysdeps_proc_uid | - _glibtop_sysdeps_proc_uid_groups; + server->sysdeps.proc_uid = _glibtop_sysdeps_proc_uid; } /* Provides detailed information about a process. */ @@ -56,13 +52,6 @@ glibtop_get_proc_uid_p (glibtop *server, glibtop_proc_uid *buf, struct kinfo_proc *pinfo; int count = 0; -#if LIBGTOP_VERSION_CODE >= 1001000 -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) - struct ucred ucred; - void *ucred_ptr; -#endif -#endif - glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_PROC_UID), 0); memset (buf, 0, sizeof (glibtop_proc_uid)); @@ -77,10 +66,8 @@ glibtop_get_proc_uid_p (glibtop *server, glibtop_proc_uid *buf, return; } -#if (defined(__FreeBSD__) && (__FreeBSD_version >= 500013)) || defined(__FreeBSD_kernel__) - #define PROC_RUID ki_ruid -#define PROC_SVUID ki_svuid +#define PROC_EUID ki_uid #define PROC_RGID ki_rgid #define PROC_SVGID ki_svgid #define PROC_PPID ki_ppid @@ -88,22 +75,9 @@ glibtop_get_proc_uid_p (glibtop *server, glibtop_proc_uid *buf, #define PROC_TPGID ki_tpgid #define PROC_NICE ki_nice #define PROC_PRIORITY ki_pri.pri_user -#else - -#define PROC_RUID kp_eproc.e_pcred.p_ruid -#define PROC_SVUID kp_eproc.e_pcred.p_svuid -#define PROC_RGID kp_eproc.e_pcred.p_rgid -#define PROC_SVGID kp_eproc.e_pcred.p_svgid -#define PROC_PPID kp_eproc.e_ppid -#define PROC_PGID kp_eproc.e_pgid -#define PROC_TPGID kp_eproc.e_tpgid -#define PROC_NICE kp_proc.p_nice -#define PROC_PRIORITY kp_proc.p_priority - -#endif buf->uid = pinfo [0].PROC_RUID; - buf->euid = pinfo [0].PROC_SVUID; + buf->euid = pinfo [0].PROC_EUID; buf->gid = pinfo [0].PROC_RGID; buf->egid = pinfo [0].PROC_SVGID; @@ -112,39 +86,7 @@ glibtop_get_proc_uid_p (glibtop *server, glibtop_proc_uid *buf, buf->tpgid = pinfo [0].PROC_TPGID; buf->nice = pinfo [0].PROC_NICE; -#if defined(__NetBSD__) && defined(SACTIVE) - buf->priority = 0; -#else buf->priority = pinfo [0].PROC_PRIORITY; -#endif - /* Set the flags for the data we're about to return*/ buf->flags = _glibtop_sysdeps_proc_uid; - - /* Use LibGTop conditionals here so we can more easily merge this - * code into the LIBGTOP_STABLE_1_0 branch. */ -#if 0 - /* This probably also works with other versions, but not yet - * tested. Please remove the conditional if this is true. */ -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) - ucred_ptr = (void *) pinfo [0].kp_eproc.e_pcred.pc_ucred; - - if (ucred_ptr) { - if (kvm_read (server->machine.kd, (unsigned long) ucred_ptr, - &ucred, sizeof (ucred)) != sizeof (ucred)) { - glibtop_warn_io_r (server, "kvm_read (ucred)"); - } else { - int count = (ucred.cr_ngroups < GLIBTOP_MAX_GROUPS) ? - ucred.cr_ngroups : GLIBTOP_MAX_GROUPS; - int i; - - for (i = 0; i < count; i++) - buf->groups [i] = ucred.cr_groups [i]; - buf->ngroups = count; - - buf->flags |= _glibtop_sysdeps_proc_uid_groups; - } - } -#endif -#endif } diff --git a/sysdeps/freebsd/sem_limits.c b/sysdeps/freebsd/sem_limits.c index 191c25c0..a7c82a2a 100644 --- a/sysdeps/freebsd/sem_limits.c +++ b/sysdeps/freebsd/sem_limits.c @@ -26,96 +26,111 @@ #include <glibtop/error.h> #include <glibtop/sem_limits.h> -#include <glibtop_suid.h> +#include <sys/types.h> +#include <sys/sysctl.h> -#if defined(__bsdi__) && (_BSDI_VERSION < 199700) -/* Older versions of BSDI don't seem to have this. */ +static unsigned long _glibtop_sysdeps_sem_limits = +(1L << GLIBTOP_IPC_SEMMAP) + (1L << GLIBTOP_IPC_SEMMNI) + +(1L << GLIBTOP_IPC_SEMMNS) + (1L << GLIBTOP_IPC_SEMMNU) + +(1L << GLIBTOP_IPC_SEMMSL) + (1L << GLIBTOP_IPC_SEMOPM) + +(1L << GLIBTOP_IPC_SEMUME) + (1L << GLIBTOP_IPC_SEMUSZ) + +(1L << GLIBTOP_IPC_SEMVMX) + (1L << GLIBTOP_IPC_SEMAEM); -void -glibtop_init_sem_limits_p (glibtop *server) -{ } +/* Init function. */ void -glibtop_get_sem_limits_p (glibtop *server, glibtop_sem_limits *buf) +glibtop_init_sem_limits_s (glibtop *server) { - glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_SEM_LIMITS), 0); - - memset (buf, 0, sizeof (glibtop_sem_limits)); + server->sysdeps.sem_limits = _glibtop_sysdeps_sem_limits; } -#else +/* Provides information about sysv sem limits. */ -/* #define KERNEL to get declaration of `struct seminfo'. */ +void +glibtop_get_sem_limits_s (glibtop *server, glibtop_sem_limits *buf) +{ + size_t len; + int semmap, semmni, semmns, semmnu, semmsl, semopm, semume, semusz; + int semvmx, semaem; -#if (defined(__FreeBSD__) && (__FreeBSD_version < 410000)) || defined(__bsdi__) -#define KERNEL 1 -#else -#define _KERNEL 1 -#endif + glibtop_init_s (&server, GLIBTOP_SYSDEPS_SEM_LIMITS, 0); -#include <sys/ipc.h> -#include <sys/sem.h> + memset (buf, 0, sizeof (glibtop_sem_limits)); -static unsigned long _glibtop_sysdeps_sem_limits = -(1L << GLIBTOP_IPC_SEMMAP) + (1L << GLIBTOP_IPC_SEMMNI) + -(1L << GLIBTOP_IPC_SEMMNS) + (1L << GLIBTOP_IPC_SEMMNU) + -(1L << GLIBTOP_IPC_SEMMSL) + (1L << GLIBTOP_IPC_SEMOPM) + -(1L << GLIBTOP_IPC_SEMUME) + (1L << GLIBTOP_IPC_SEMUSZ) + -(1L << GLIBTOP_IPC_SEMVMX) + (1L << GLIBTOP_IPC_SEMAEM); + if (server->sysdeps.sem_limits == 0) + return; -/* The values in this structure never change at runtime, so we only - * read it once during initialization. We have to use the name `_seminfo' - * since `seminfo' is already declared external in <sys/sem.h>. */ -static struct seminfo _seminfo; + len = sizeof (semmap); + if (sysctlbyname ("kern.ipc.semmap", &semmap, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.semmap)"); + return; + } -/* nlist structure for kernel access */ -static struct nlist nlst [] = { - { "_seminfo" }, - { 0 } -}; + len = sizeof (semmni); + if (sysctlbyname ("kern.ipc.semmni", &semmni, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.semmni)"); + return; + } -/* Init function. */ + len = sizeof (semmns); + if (sysctlbyname ("kern.ipc.semmns", &semmns, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.semmns)"); + return; + } -void -glibtop_init_sem_limits_p (glibtop *server) -{ - if (kvm_nlist (server->machine.kd, nlst) < 0) { - glibtop_warn_io_r (server, "kvm_nlist (sem_limits)"); + len = sizeof (semmnu); + if (sysctlbyname ("kern.ipc.semmnu", &semmnu, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.semmnu)"); return; } - if (kvm_read (server->machine.kd, nlst [0].n_value, - &_seminfo, sizeof (_seminfo)) != sizeof (_seminfo)) { - glibtop_warn_io_r (server, "kvm_read (seminfo)"); + len = sizeof (semmsl); + if (sysctlbyname ("kern.ipc.semmsl", &semmsl, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.semmsl)"); return; } - server->sysdeps.sem_limits = _glibtop_sysdeps_sem_limits; -} + len = sizeof (semopm); + if (sysctlbyname ("kern.ipc.semopm", &semopm, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.semopm)"); + return; + } -/* Provides information about sysv sem limits. */ + len = sizeof (semume); + if (sysctlbyname ("kern.ipc.semume", &semume, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.semume)"); + return; + } -void -glibtop_get_sem_limits_p (glibtop *server, glibtop_sem_limits *buf) -{ - glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_SEM_LIMITS), 0); + len = sizeof (semusz); + if (sysctlbyname ("kern.ipc.semusz", &semusz, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.semusz)"); + return; + } - memset (buf, 0, sizeof (glibtop_sem_limits)); + len = sizeof (semvmx); + if (sysctlbyname ("kern.ipc.semvmx", &semvmx, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.semvmx)"); + return; + } - if (server->sysdeps.sem_limits == 0) + len = sizeof (semaem); + if (sysctlbyname ("kern.ipc.semaem", &semaem, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.semaem)"); return; + } - buf->semmap = _seminfo.semmap; - buf->semmni = _seminfo.semmni; - buf->semmns = _seminfo.semmns; - buf->semmnu = _seminfo.semmnu; - buf->semmsl = _seminfo.semmsl; - buf->semopm = _seminfo.semopm; - buf->semvmx = _seminfo.semvmx; - buf->semaem = _seminfo.semaem; + buf->semmap = semmap; + buf->semmni = semmni; + buf->semmns = semmns; + buf->semmnu = semmnu; + buf->semmsl = semmsl; + buf->semopm = semopm; + buf->semume = semume; + buf->semusz = semusz; + buf->semvmx = semvmx; + buf->semaem = semaem; buf->flags = _glibtop_sysdeps_sem_limits; } -#endif /* either a newer BSDI or no BSDI at all. */ - diff --git a/sysdeps/freebsd/shm_limits.c b/sysdeps/freebsd/shm_limits.c index c7b2584b..4251e9b6 100644 --- a/sysdeps/freebsd/shm_limits.c +++ b/sysdeps/freebsd/shm_limits.c @@ -26,91 +26,72 @@ #include <glibtop/error.h> #include <glibtop/shm_limits.h> -#include <glibtop_suid.h> - -#if defined(__bsdi__) && (_BSDI_VERSION < 199700) -/* Older versions of BSDI don't seem to have this. */ - -void -glibtop_init_shm_limits_p (glibtop *server) -{ } - -void -glibtop_get_shm_limits_p (glibtop *server, glibtop_shm_limits *buf) -{ - glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_SHM_LIMITS), 0); - - memset (buf, 0, sizeof (glibtop_shm_limits)); -} - -#else - -/* #define KERNEL to get declaration of `struct shminfo'. */ - -#if (defined(__FreeBSD__) && (__FreeBSD_version < 410000)) || defined(__bsdi__) -#define KERNEL 1 -#else -#define _KERNEL 1 -#endif - -#include <sys/ipc.h> -#include <sys/shm.h> +#include <sys/types.h> +#include <sys/sysctl.h> static unsigned long _glibtop_sysdeps_shm_limits = (1L << GLIBTOP_IPC_SHMMAX) + (1L << GLIBTOP_IPC_SHMMIN) + (1L << GLIBTOP_IPC_SHMMNI) + (1L << GLIBTOP_IPC_SHMSEG) + (1L << GLIBTOP_IPC_SHMALL); -/* The values in this structure never change at runtime, so we only - * read it once during initialization. We have to use the name `_shminfo' - * since `shminfo' is already declared external in <sys/shm.h>. */ -static struct shminfo _shminfo; - -/* nlist structure for kernel access */ -static struct nlist nlst [] = { - { "_shminfo" }, - { 0 } -}; - /* Init function. */ void -glibtop_init_shm_limits_p (glibtop *server) +glibtop_init_shm_limits_s (glibtop *server) { - if (kvm_nlist (server->machine.kd, nlst) < 0) { - glibtop_warn_io_r (server, "kvm_nlist (shm_limits)"); - return; - } - - if (kvm_read (server->machine.kd, nlst [0].n_value, - &_shminfo, sizeof (_shminfo)) != sizeof (_shminfo)) { - glibtop_warn_io_r (server, "kvm_read (shminfo)"); - return; - } - server->sysdeps.shm_limits = _glibtop_sysdeps_shm_limits; } /* Provides information about sysv ipc limits. */ void -glibtop_get_shm_limits_p (glibtop *server, glibtop_shm_limits *buf) +glibtop_get_shm_limits_s (glibtop *server, glibtop_shm_limits *buf) { - glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_SHM_LIMITS), 0); + size_t len; + int shmmax, shmmin, shmmni, shmseg, shmall; + + glibtop_init_s (&server, GLIBTOP_SYSDEPS_SHM_LIMITS, 0); memset (buf, 0, sizeof (glibtop_shm_limits)); if (server->sysdeps.shm_limits == 0) return; - buf->shmmax = _shminfo.shmmax; - buf->shmmin = _shminfo.shmmin; - buf->shmmni = _shminfo.shmmni; - buf->shmseg = _shminfo.shmseg; - buf->shmall = _shminfo.shmall; + len = sizeof (shmmax); + if (sysctlbyname ("kern.ipc.shmmax", &shmmax, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.shmmax)"); + return; + } - buf->flags = _glibtop_sysdeps_shm_limits; -} + len = sizeof (shmmin); + if (sysctlbyname ("kern.ipc.shmmin", &shmmin, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.shmmin)"); + return; + } -#endif /* either a newer BSDI or no BSDI at all. */ + len = sizeof (shmmni); + if (sysctlbyname ("kern.ipc.shmmni", &shmmni, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.shmmni)"); + return; + } + len = sizeof (shmseg); + if (sysctlbyname ("kern.ipc.shmseg", &shmseg, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.shmseg)"); + return; + } + + len = sizeof (shmall); + if (sysctlbyname ("kern.ipc.shmall", &shmall, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (kern.ipc.shmall)"); + return; + } + + buf->shmmax = shmmax; + buf->shmmin = shmmin; + buf->shmmni = shmmni; + buf->shmseg = shmseg; + buf->shmall = shmall; + + buf->flags = _glibtop_sysdeps_shm_limits; +} diff --git a/sysdeps/freebsd/swap.c b/sysdeps/freebsd/swap.c index 438b36ae..c9934481 100644 --- a/sysdeps/freebsd/swap.c +++ b/sysdeps/freebsd/swap.c @@ -30,396 +30,67 @@ static const unsigned long _glibtop_sysdeps_swap = (1L << GLIBTOP_SWAP_TOTAL) + (1L << GLIBTOP_SWAP_USED) + -(1L << GLIBTOP_SWAP_FREE) + (1L << GLIBTOP_SWAP_PAGEIN) + -(1L << GLIBTOP_SWAP_PAGEOUT); +(1L << GLIBTOP_SWAP_FREE); -#if defined(__FreeBSD__) || defined(__bsdi__) || defined(__FreeBSD_kernel__) +static const unsigned long _glibtop_sysdeps_swap_paging = +(1L << GLIBTOP_SWAP_PAGEIN) + (1L << GLIBTOP_SWAP_PAGEOUT); -#include <sys/conf.h> -#ifdef __bsdi__ -#include <vm/swap_pager.h> -#else -#if (__FreeBSD_version < 400005) && !defined(__FreeBSD_kernel__) -#include <sys/rlist.h> -#endif -#endif -#include <sys/vmmeter.h> - -/* nlist structure for kernel access */ - -#if defined(__bsdi__) -static struct nlist nlst [] = { - { "_swapstats" }, /* general swap info */ - { 0 } -}; -#elif __FreeBSD__ < 4 -static struct nlist nlst [] = { -#define VM_SWAPLIST 0 - { "_swaplist" },/* list of free swap areas */ -#define VM_SWDEVT 1 - { "_swdevt" }, /* list of swap devices and sizes */ -#define VM_NSWAP 2 - { "_nswap" }, /* size of largest swap device */ -#define VM_NSWDEV 3 - { "_nswdev" }, /* number of swap devices */ -#define VM_DMMAX 4 - { "_dmmax" }, /* maximum size of a swap block */ - { 0 } -}; -#endif - -#elif defined(__NetBSD__) || defined(__OpenBSD__) - -#if (__NetBSD_Version__ >= 104000000) || defined(__OpenBSD__) -#include <uvm/uvm_extern.h> -#include <sys/swap.h> -#else -#include <vm/vm_swap.h> -#endif - -#endif - -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) || defined(__OpenBSD__) -static int mib_uvmexp [] = { CTL_VM, VM_UVMEXP }; -#else -/* nlist structure for kernel access */ -static struct nlist nlst2 [] = { - { "_cnt" }, - { 0 } -}; -#endif +static int pagesize; /* Init function. */ void glibtop_init_swap_p (glibtop *server) { -#if defined(__FreeBSD__) || defined(__bsdi__) || defined(__FreeBSD_kernel__) -#if __FreeBSD__ < 4 || defined(__bsdi__) - if (kvm_nlist (server->machine.kd, nlst) < 0) { - glibtop_warn_io_r (server, "kvm_nlist (swap)"); - return; - } -#else - struct kvm_swap dummy; - - if (kvm_getswapinfo (server->machine.kd, &dummy, 1, 0) != 0) { - glibtop_warn_io_r (server, "kvm_swap (swap)"); - return; - } -#endif -#endif - -#if !(defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000)) && !defined(__OpenBSD__) - if (kvm_nlist (server->machine.kd, nlst2) < 0) { - glibtop_warn_io_r (server, "kvm_nlist (cnt)"); - return; - } -#endif + pagesize = getpagesize (); - server->sysdeps.swap = _glibtop_sysdeps_swap; + server->sysdeps.swap = _glibtop_sysdeps_swap | + _glibtop_sysdeps_swap_paging; } /* Provides information about swap usage. */ -/* - * This function is based on a program called swapinfo written - * by Kevin Lahey <kml@rokkaku.atl.ga.us>. - */ - void glibtop_get_swap_p (glibtop *server, glibtop_swap *buf) { -#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) - -# if (__FreeBSD__ < 4) && !defined(__FreeBSD_kernel__) - char *header; - int hlen, nswdev, dmmax; - int div, nfree, npfree; - struct swdevt *sw; - long blocksize, *perdev; - struct rlist head; - struct rlisthdr swaplist; - struct rlist *swapptr; - size_t sw_size; - u_long ptr; -# else + size_t len; + unsigned int swappgsout, swappgsin; int nswdev; struct kvm_swap kvmsw[16]; -# endif - -#elif defined(__bsdi__) - struct swapstats swap; -#elif defined(__NetBSD__) || defined(__OpenBSD__) - struct swapent *swaplist; -#endif - - int nswap, i; - int avail = 0, inuse = 0; - -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) || defined(__OpenBSD__) - struct uvmexp uvmexp; - size_t length_uvmexp; -#else - /* To get `pagein' and `pageout'. */ - struct vmmeter vmm; -#endif - static int swappgsin = -1; - static int swappgsout = -1; glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_SWAP), 0); memset (buf, 0, sizeof (glibtop_swap)); + memset (kvmsw, 0, sizeof (kvmsw)); - if (server->sysdeps.swap == 0) - return; - -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) || defined(__OpenBSD__) - length_uvmexp = sizeof (uvmexp); - if (sysctl (mib_uvmexp, 2, &uvmexp, &length_uvmexp, NULL, 0)) { - glibtop_warn_io_r (server, "sysctl (uvmexp)"); - return; - } -#else - /* This is used to get the `pagein' and `pageout' members. */ - - if (kvm_read (server->machine.kd, nlst2[0].n_value, - &vmm, sizeof (vmm)) != sizeof (vmm)) { - glibtop_warn_io_r (server, "kvm_read (cnt)"); - return; - } -#endif - - if (swappgsin < 0) { - buf->pagein = 0; - buf->pageout = 0; - } else { -#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) - buf->pagein = vmm.v_swappgsin - swappgsin; - buf->pageout = vmm.v_swappgsout - swappgsout; -#else -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) || defined(__OpenBSD__) - buf->pagein = uvmexp.swapins - swappgsin; - buf->pageout = uvmexp.swapouts - swappgsout; -#else - buf->pagein = vmm.v_swpin - swappgsin; - buf->pageout = vmm.v_swpout - swappgsout; -#endif -#endif - } - -#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) - swappgsin = vmm.v_swappgsin; - swappgsout = vmm.v_swappgsout; -#else -#if defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000) || defined(__OpenBSD__) - swappgsin = uvmexp.swapins; - swappgsout = uvmexp.swapouts; -#else - swappgsin = vmm.v_swpin; - swappgsout = vmm.v_swpout; -#endif -#endif - -#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) - -#if (__FreeBSD__ < 4) && !defined(__FreeBSD_kernel__) - - /* Size of largest swap device. */ - - if (kvm_read (server->machine.kd, nlst[VM_NSWAP].n_value, - &nswap, sizeof (nswap)) != sizeof (nswap)) { - glibtop_warn_io_r (server, "kvm_read (nswap)"); - return; - } - - /* Number of swap devices. */ - - if (kvm_read (server->machine.kd, nlst[VM_NSWDEV].n_value, - &nswdev, sizeof (nswdev)) != sizeof (nswdev)) { - glibtop_warn_io_r (server, "kvm_read (nswdev)"); - return; - } - - /* Maximum size of a swap block. */ - - if (kvm_read (server->machine.kd, nlst[VM_DMMAX].n_value, - &dmmax, sizeof (dmmax)) != sizeof (dmmax)) { - glibtop_warn_io_r (server, "kvm_read (dmmax)"); - return; - } - - /* List of free swap areas. */ - - if (kvm_read (server->machine.kd, nlst[VM_SWAPLIST].n_value, - &swaplist, sizeof (swaplist)) != sizeof (swaplist)) { - glibtop_warn_io_r (server, "kvm_read (swaplist)"); - return; - } - - /* Kernel offset of list of swap devices and sizes. */ - - if (kvm_read (server->machine.kd, nlst[VM_SWDEVT].n_value, - &ptr, sizeof (ptr)) != sizeof (ptr)) { - glibtop_warn_io_r (server, "kvm_read (swdevt)"); - return; - } - - /* List of swap devices and sizes. */ - - sw_size = nswdev * sizeof (*sw); - sw = g_malloc (sw_size); - - if (kvm_read (server->machine.kd, ptr, sw, sw_size) != (ssize_t)sw_size) { - glibtop_warn_io_r (server, "kvm_read (*swdevt)"); - return; - } - - perdev = g_malloc (nswdev * sizeof (*perdev)); - - /* Count up swap space. */ - - nfree = 0; - memset (perdev, 0, nswdev * sizeof(*perdev)); - - swapptr = swaplist.rlh_list; - - while (swapptr) { - int top, bottom, next_block; - - if (kvm_read (server->machine.kd, (int) swapptr, &head, - sizeof (struct rlist)) != sizeof (struct rlist)) { - glibtop_warn_io_r (server, "kvm_read (swapptr)"); - return; - } - - top = head.rl_end; - bottom = head.rl_start; - - nfree += top - bottom + 1; - - /* - * Swap space is split up among the configured disks. - * - * For interleaved swap devices, the first dmmax blocks - * of swap space some from the first disk, the next dmmax - * blocks from the next, and so on up to nswap blocks. - * - * The list of free space joins adjacent free blocks, - * ignoring device boundries. If we want to keep track - * of this information per device, we'll just have to - * extract it ourselves. - */ - while (top / dmmax != bottom / dmmax) { - next_block = ((bottom + dmmax) / dmmax); - perdev[(bottom / dmmax) % nswdev] += - next_block * dmmax - bottom; - bottom = next_block * dmmax; - } - perdev[(bottom / dmmax) % nswdev] += - top - bottom + 1; - - swapptr = head.rl_next; - } - - header = getbsize (&hlen, &blocksize); - - div = blocksize / 512; - avail = npfree = 0; - for (i = 0; i < nswdev; i++) { - int xsize, xfree; - - /* - * Don't report statistics for partitions which have not - * yet been activated via swapon(8). - */ - if (!(sw[i].sw_flags & SW_FREED)) - continue; - - /* The first dmmax is never allocated to avoid trashing of - * disklabels - */ - xsize = sw[i].sw_nblks - dmmax; - xfree = perdev[i]; - inuse = xsize - xfree; - npfree++; - avail += xsize; - } - - /* - * If only one partition has been set up via swapon(8), we don't - * need to bother with totals. - */ - inuse = avail - nfree; - - g_free (sw); - g_free (perdev); + nswdev = kvm_getswapinfo (server->machine.kd, kvmsw, 16, 0); + if (nswdev < 1) return; buf->flags = _glibtop_sysdeps_swap; - buf->used = inuse; - buf->free = avail; - - buf->total = inuse + avail; - -#else - - nswdev = kvm_getswapinfo(server->machine.kd, kvmsw, 16, 0); - - buf->flags = _glibtop_sysdeps_swap; + /* See the man page for kvm_getswapinfo(3) to see why we can do this. */ + buf->used = kvmsw[nswdev].ksw_used; + buf->total = kvmsw[nswdev].ksw_total; - buf->used = kvmsw[nswdev].ksw_used * getpagesize(); - buf->total = kvmsw[nswdev].ksw_total * getpagesize(); + buf->total *= pagesize; + buf->used *= pagesize; buf->free = buf->total - buf->used; -#endif - -#elif defined(__bsdi__) - - /* General info about swap devices. */ - - if (kvm_read (server->machine.kd, nlst[0].n_value, - &swap, sizeof (swap)) != sizeof (swap)) { - glibtop_warn_io_r (server, "kvm_read (swap)"); - return; - } - - buf->flags = _glibtop_sysdeps_swap; - - buf->used = swap.swap_total - swap.swap_free; - buf->free = swap.swap_free; - - buf->total = swap.swap_total; - -#elif defined(__NetBSD__) || defined(__OpenBSD__) - - nswap = swapctl (SWAP_NSWAP, NULL, 0); - if (nswap < 0) { - glibtop_warn_io_r (server, "swapctl (SWAP_NSWAP)"); + len = sizeof (swappgsout); + if (sysctlbyname ("vm.stats.vm.v_swappgsout", &swappgsout, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (vm.stats.vm.v_swappgsout)"); return; } - swaplist = g_malloc (nswap * sizeof (struct swapent)); - - if (swapctl (SWAP_STATS, swaplist, nswap) != nswap) { - glibtop_warn_io_r (server, "swapctl (SWAP_STATS)"); - g_free (swaplist); + len = sizeof (swappgsin); + if (sysctlbyname ("vm.stats.vm.v_swappgsin", &swappgsin, &len, NULL, 0)) { + glibtop_warn_io_r (server, "sysctl (vm.stats.vm.v_swappgsin)"); return; } - for (i = 0; i < nswap; i++) { - avail += swaplist[i].se_nblks; - inuse += swaplist[i].se_inuse; - } - - g_free (swaplist); - - buf->flags = _glibtop_sysdeps_swap; - - buf->used = inuse; - buf->free = avail; + buf->pagein = (guint64) swappgsin; + buf->pageout = (guint64) swappgsout; - buf->total = inuse + avail; -#endif + buf->flags |= _glibtop_sysdeps_swap_paging; } diff --git a/sysdeps/freebsd/sysinfo.c b/sysdeps/freebsd/sysinfo.c index 10cbd6f3..9e281ca0 100644 --- a/sysdeps/freebsd/sysinfo.c +++ b/sysdeps/freebsd/sysinfo.c @@ -73,6 +73,10 @@ init_sysinfo (glibtop *server) g_hash_table_insert (cpuinfo->values, "vendor_id", g_strdup(model)); + g_ptr_array_add (cpuinfo->labels, "model name"); + g_hash_table_insert (cpuinfo->values, "model name", + g_strdup(model)); + g_ptr_array_add (cpuinfo->labels, "cpu MHz"); g_hash_table_insert (cpuinfo->values, "cpu MHz", g_strdup_printf("%d", mhz)); diff --git a/sysdeps/freebsd/uptime.c b/sysdeps/freebsd/uptime.c index a7d8e40e..8a371f18 100644 --- a/sysdeps/freebsd/uptime.c +++ b/sysdeps/freebsd/uptime.c @@ -28,19 +28,23 @@ #include <glibtop/cpu.h> -#include <glibtop_suid.h> +#include <sys/types.h> +#include <sys/sysctl.h> static const unsigned long _glibtop_sysdeps_uptime = -(1L << GLIBTOP_UPTIME_UPTIME) + (1L << GLIBTOP_UPTIME_IDLETIME); +(1L << GLIBTOP_UPTIME_UPTIME); + +static const unsigned long _glibtop_sysdeps_idletime = +(1L << GLIBTOP_UPTIME_IDLETIME); static const unsigned long _required_cpu_flags = -(1L << GLIBTOP_CPU_TOTAL) + (1L << GLIBTOP_CPU_IDLE) + +(1L << GLIBTOP_CPU_IDLE) + (1L << GLIBTOP_CPU_FREQUENCY); /* Init function. */ void -glibtop_init_uptime_p (glibtop *server) +glibtop_init_uptime_s (glibtop *server) { server->sysdeps.uptime = _glibtop_sysdeps_uptime; } @@ -48,14 +52,17 @@ glibtop_init_uptime_p (glibtop *server) /* Provides uptime and idle time. */ void -glibtop_get_uptime_p (glibtop *server, glibtop_uptime *buf) +glibtop_get_uptime_s (glibtop *server, glibtop_uptime *buf) { -#if defined(__NetBSD__) || defined(__OpenBSD__) time_t now; - time_t uptime; int mib[2]; struct timeval boottime; size_t size; + glibtop_cpu cpu; + + glibtop_init_s (&server, GLIBTOP_SYSDEPS_UPTIME, 0); + + memset (buf, 0, sizeof (glibtop_uptime)); mib[0] = CTL_KERN; mib[1] = KERN_BOOTTIME; @@ -64,20 +71,10 @@ glibtop_get_uptime_p (glibtop *server, glibtop_uptime *buf) boottime.tv_sec != 0) { time(&now); buf->uptime = now - boottime.tv_sec; - /* XXX: don't know a useful value to put here. */ - buf->idletime = 0; buf->flags = _glibtop_sysdeps_uptime; } -#else - glibtop_cpu cpu; - - glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_UPTIME), 0); - - memset (buf, 0, sizeof (glibtop_uptime)); - - /* We simply calculate it from the CPU usage. */ - glibtop_get_cpu_p (server, &cpu); + glibtop_get_cpu_s (server, &cpu); /* Make sure all required fields are present. */ @@ -86,9 +83,8 @@ glibtop_get_uptime_p (glibtop *server, glibtop_uptime *buf) /* Calculate values. */ - buf->uptime = (double) cpu.total / (double) cpu.frequency; buf->idletime = (double) cpu.idle / (double) cpu.frequency; + buf->idletime /= (double) (server->ncpu + 1); - buf->flags = _glibtop_sysdeps_uptime; -#endif + buf->flags |= _glibtop_sysdeps_idletime; } |