oxmc/libgtop
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Huge (k)FreeBSD update. (k)FreeBSD support is freebsd/ Other BSD are in

Browse Source 
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
This commit is contained in:
Benoît Dejean
2007-02-18 01:10:53 +00:00
committed by Benoît Dejean
parent 747438e334
commit 5a15e409cf
69 changed files with 5820 additions and 1967 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
sysdeps/freebsd/AUTHORS
View File

@@ -1,2 +1,3 @@
Martin Baulig (martin@home-of-linux.org)
Josh Sled (jsled@scam.XCF.Berkeley.EDU)
Joe Marcus Clarke (marcus@FreeBSD.org)

49
sysdeps/freebsd/ChangeLog
View File

@@ -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):

17
sysdeps/freebsd/Makefile.am
View File

@@ -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)

10
sysdeps/freebsd/NOTES
View File

@@ -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(...)

104
sysdeps/freebsd/cpu.c
View File

@@ -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);
(1L << GLIBTOP_CPU_IRQ);
#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
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");
if (sysctlbyname ("kern.cp_time", cpts, &length, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (kern.cp_time)");
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)");
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;
}
}

138
sysdeps/freebsd/fsusage.c
View File

@@ -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);
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;
}
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);
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
result = statfs (path, &sfs);
buf->read = sfs.f_syncreads + sfs.f_asyncreads;
buf->write = sfs.f_syncwrites + sfs.f_asyncwrites;
#endif
if (result == -1) {
return;
}
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);
buf->flags |= (1 << GLIBTOP_FSUSAGE_READ) | (1 << GLIBTOP_FSUSAGE_WRITE);
}

10
sysdeps/freebsd/glibtop_machine.h
View File

@@ -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

20
sysdeps/freebsd/glibtop_server.h
View File

@@ -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

46
sysdeps/freebsd/init.c
View File

@@ -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;
}

28
sysdeps/freebsd/loadavg.c
View File

@@ -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;
}

198
sysdeps/freebsd/mem.c
View File

@@ -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;
gulong memtotal;
guint memused;
gulong buffers;
guint cached;
size_t len;
glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_MEM), 0);
glibtop_init_s (&server, GLIBTOP_SYSDEPS_MEM, 0);
memset (buf, 0, sizeof (glibtop_mem));
memset (buf, 0, sizeof *buf);
if (server->sysdeps.mem == 0)
return;
/* [FIXME: On FreeBSD 2.2.6, sysctl () returns an incorrect
* value for `vmt.vm'. We use some code from Unix top
* here.] */
/* 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)");
len = sizeof (memtotal);
if (sysctlbyname ("hw.physmem", &memtotal, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (hw.physmem)");
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
/* 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)");
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 (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;
}
/* convert memory stats to Kbytes */
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;
}
#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
buffers = 0;
#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 = memtotal;
buf->used = (memused * pagesize);
buf->free = (buf->total - buf->used);
buf->shared = 0;
buf->cached = (cached * pagesize);
buf->buffer = buffers;
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 */
buf->user = buf->total - buf->free - buf->cached - buf->buffer;
buf->flags = _glibtop_sysdeps_mem;
}

114
sysdeps/freebsd/msg_limits.c
View File

@@ -26,91 +26,79 @@
#include <glibtop/error.h>
#include <glibtop/msg_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_msg_limits_p (glibtop *server)
{ }
void
glibtop_get_msg_limits_p (glibtop *server, glibtop_msg_limits *buf)
{
glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_MSG_LIMITS), 0);
memset (buf, 0, sizeof (glibtop_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>
#include <sys/types.h>
#include <sys/sysctl.h>
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);
/* 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;
/* nlist structure for kernel access */
static struct nlist nlst [] = {
{ "_msginfo" },
{ 0 }
};
(1L << GLIBTOP_IPC_MSGSSZ) + (1L << GLIBTOP_IPC_MSGPOOL);
/* Init function. */
void
glibtop_init_msg_limits_p (glibtop *server)
glibtop_init_msg_limits_s (glibtop *server)
{
if (kvm_nlist (server->machine.kd, nlst) < 0) {
glibtop_warn_io_r (server, "kvm_nlist (msg_limits)");
return;
}
if (kvm_read (server->machine.kd, nlst [0].n_value,
&_msginfo, sizeof (_msginfo)) != sizeof (_msginfo)) {
glibtop_warn_io_r (server, "kvm_read (msginfo)");
return;
}
server->sysdeps.msg_limits = _glibtop_sysdeps_msg_limits;
}
/* Provides information about sysv ipc limits. */
void
glibtop_get_msg_limits_p (glibtop *server, glibtop_msg_limits *buf)
glibtop_get_msg_limits_s (glibtop *server, glibtop_msg_limits *buf)
{
glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_MSG_LIMITS), 0);
size_t len;
int msgmax, msgmni, msgmnb, msgtql, msgssz, msgseg;
glibtop_init_s (&server, GLIBTOP_SYSDEPS_MSG_LIMITS, 0);
memset (buf, 0, sizeof (glibtop_msg_limits));
if (server->sysdeps.msg_limits == 0)
return;
buf->msgmax = _msginfo.msgmax;
buf->msgmni = _msginfo.msgmni;
buf->msgmnb = _msginfo.msgmnb;
buf->msgtql = _msginfo.msgtql;
buf->msgssz = _msginfo.msgtql;
len = sizeof (msgseg);
if (sysctlbyname ("kern.ipc.msgseg", &msgseg, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (kern.ipc.msgseg)");
return;
}
len = sizeof (msgssz);
if (sysctlbyname ("kern.ipc.msgssz", &msgssz, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (kern.ipc.msgssz)");
return;
}
len = sizeof (msgtql);
if (sysctlbyname ("kern.ipc.msgtql", &msgtql, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (kern.ipc.msgtql)");
return;
}
len = sizeof (msgmnb);
if (sysctlbyname ("kern.ipc.msgmnb", &msgmnb, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (kern.ipc.msgmnb)");
return;
}
len = sizeof (msgmni);
if (sysctlbyname ("kern.ipc.msgmni", &msgmni, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (kern.ipc.msgmni)");
return;
}
len = sizeof (msgmax);
if (sysctlbyname ("kern.ipc.msgmax", &msgmax, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (kern.ipc.msgmax)");
return;
}
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. */

302
sysdeps/freebsd/netload.c
View File

@@ -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];
struct ifnet ifnet;
u_long ifnetaddr, ifnetfound;
struct sockaddr *sa = NULL;
char name [32];
union {
struct ifaddr ifa;
struct in_ifaddr in;
} ifaddr;
union {
struct ifaddr ifa;
struct in_ifaddr in;
} ifaddr;
glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_NETLOAD), 0);
glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_NETLOAD), 0);
memset (buf, 0, sizeof (glibtop_netload));
memset (buf, 0, sizeof (glibtop_netload));
if (kvm_read (server->machine.kd, nlst [0].n_value,
&ifnetaddr, sizeof (ifnetaddr)) != sizeof (ifnetaddr))
glibtop_error_io_r (server, "kvm_read (ifnet)");
if (server->sysdeps.netload == 0) return;
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_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 (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)
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);
#endif
if (ifnet.if_flags & IFF_MULTICAST)
buf->if_flags |= (1L << GLIBTOP_IF_FLAGS_MULTICAST);
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->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->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->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;
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)");
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;
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;
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;
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;
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->flags |= GLIBTOP_NETLOAD_ADDRESS6;
}
/* FIXME prefix6, scope6 */
ifaddraddr = (u_long) ifaddr.ifa.ifa_link.tqe_next;
}
return;
}
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;
}
}

3
sysdeps/freebsd/open.c
View File

@@ -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");

18
sysdeps/freebsd/ppp.c
View File

@@ -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;

14
sysdeps/freebsd/procargs.c
View File

@@ -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;
}

170
sysdeps/freebsd/procdata.c
View File

@@ -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;
}

191
sysdeps/freebsd/prockernel.c
View File

@@ -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;
}
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
#if !(defined(__FreeBSD__) || defined(__FreeBSD_kernel__))
buf->flags |= _glibtop_sysdeps_proc_kernel_pstats;
/* 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,
#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;
}
#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__ */
}

115
sysdeps/freebsd/proclist.c
View File

@@ -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);
/* 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", NULL, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (kern.proc.all)");
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
pinfo = (struct kinfo_proc *) g_malloc0 (len);
#else
#define PROC_STAT kp_proc.p_stat
#define PROC_RUID kp_eproc.e_pcred.p_ruid
#define PROC_PID kp_proc.p_pid
if (sysctlbyname ("kern.proc.all", pinfo, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (kern.proc.all)");
g_free (pinfo);
return NULL;
}
#endif
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);
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);
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);
}

402
sysdeps/freebsd/procmap.c
View File

@@ -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;
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);
glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_PROC_MAP), 0);
memset (buf, 0, sizeof (glibtop_proc_map));
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);
/* It does not work for the swapper task. */
if (pid == 0) return NULL;
glibtop_suid_enter (server);
/*return (glibtop_map_entry*) g_array_free(maps, TRUE);*/
/* 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);
}
glibtop_suid_enter (server);
/* Now we get the memory maps. */
/* 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;
}
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)");
/* Now we get the memory maps. */
first = vmspace.vm_map.header.next;
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;
}
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)");
first = vmspace.vm_map.header.next;
/* Allocate space. */
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;
}
buf->number = vmspace.vm_map.nentries;
buf->size = sizeof (glibtop_map_entry);
/* Walk through the `vm_map_entry' list ... */
buf->total = buf->number * buf->size;
/* 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. */
buf->flags = _glibtop_sysdeps_proc_map;
maps = g_array_sized_new(FALSE, FALSE, sizeof(glibtop_map_entry),
vmspace.vm_map.nentries);
/* Walk through the `vm_map_entry' list ... */
do {
glibtop_map_entry *mentry;
guint64 inum, dev;
guint len;
/* 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. */
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;
}
do {
glibtop_map_entry *mentry;
unsigned long inum, dev;
guint len;
if (entry.eflags & (MAP_ENTRY_IS_SUB_MAP))
continue;
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 (!entry.object.vm_object)
continue;
#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
/* 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 defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000)
if (!entry.object.uvm_obj)
continue;
/* If the object is of type vnode, add its size */
/* We're only interested in vnodes */
if (object.type != OBJT_VNODE)
continue;
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;
if (!object.handle)
continue;
/* We're only interested in `vm_object's */
if (kvm_read (server->machine.kd,
(gulong) object.handle,
(char *) &vnode, sizeof (vnode)) != sizeof (vnode)) {
glibtop_warn_io_r (server, "kvm_read (vnode)");
continue;
}
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;
#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
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
/* 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,
(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:
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;
#endif
default:
continue;
}
inum = vnode.v_cachedid;
dev = vnode.v_cachedfs;
#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;
_glibtop_sysdeps_freebsd_dev_inode (server,
(struct vnode *) object.handle,
&vnode, &inum, &dev);
#endif
#endif
len = maps->len;
g_array_set_size(maps, len + 1);
mentry = &g_array_index(maps, glibtop_map_entry, len);
break;
}
mentry->flags = _glibtop_sysdeps_map_entry;
len = maps->len;
g_array_set_size(maps, len + 1);
mentry = &g_array_index(maps, glibtop_map_entry, len);
mentry->start = (guint64) entry.start;
mentry->end = (guint64) entry.end;
mentry->offset = (guint64) entry.offset;
mentry->device = (guint64) dev;
mentry->inode = (guint64) inum;
memset (mentry, 0, sizeof (glibtop_map_entry));
mentry->perm = (guint64) 0;
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;
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);
mentry->perm = (guint64) 0;
buf->flags = _glibtop_sysdeps_proc_map;
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;
buf->number = maps->len;
buf->size = sizeof (glibtop_map_entry);
buf->total = buf->number * buf->size;
} while (entry.next != first);
return (glibtop_map_entry*) g_array_free(maps, FALSE);
glibtop_suid_leave (server);
buf->flags = _glibtop_sysdeps_proc_map;
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);
}

149
sysdeps/freebsd/procmem.c
View File

@@ -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 |

43
sysdeps/freebsd/procsegment.c
View File

@@ -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
buf->text_rss = pinfo[0].ki_tsize * pagesize;
buf->data_rss = pinfo[0].ki_dsize * pagesize;
*/
/* end_code: address of end of code segment
*/
/* start_stack: address of the bottom of stack segment
*/
#endif
buf->flags = _glibtop_sysdeps_proc_segment;
}

41
sysdeps/freebsd/procsignal.c
View File

@@ -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;
}

108
sysdeps/freebsd/procstate.c
View File

@@ -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
buf->uid = pinfo[0].ki_ruid;
buf->gid = pinfo[0].ki_rgid;
#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
g_strlcpy (buf->cmd, pinfo[0].ki_comm, sizeof (buf->cmd));
#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;
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;
}
#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;
}
#endif
buf->flags |= (1L << GLIBTOP_PROC_STATE_STATE);
buf->flags = _glibtop_sysdeps_proc_state;
}

191
sysdeps/freebsd/proctime.c
View File

@@ -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
glibtop_suid_leave (server);
buf->frequency = 1000000;
buf->rtime = pinfo [0].ki_runtime * 1e-6;
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;
}
buf->frequency = (ci.stathz ? ci.stathz : ci.hz);
buf->flags = _glibtop_sysdeps_proc_time;
#if (defined(__NetBSD__) && (__NetBSD_Version__ >= 104000000)) || (defined(OpenBSD) && (OpenBSD >= 199912))
glibtop_suid_enter (server);
buf->rtime *= buf->frequency;
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)");
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->start_time = (guint64) pstats.p_start.tv_sec;
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
}

66
sysdeps/freebsd/procuid.c
View File

@@ -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
}

143
sysdeps/freebsd/sem_limits.c
View File

@@ -26,35 +26,8 @@
#include <glibtop/error.h>
#include <glibtop/sem_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_sem_limits_p (glibtop *server)
{ }
void
glibtop_get_sem_limits_p (glibtop *server, glibtop_sem_limits *buf)
{
glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_SEM_LIMITS), 0);
memset (buf, 0, sizeof (glibtop_sem_limits));
}
#else
/* #define KERNEL to get declaration of `struct seminfo'. */
#if (defined(__FreeBSD__) && (__FreeBSD_version < 410000)) || defined(__bsdi__)
#define KERNEL 1
#else
#define _KERNEL 1
#endif
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/types.h>
#include <sys/sysctl.h>
static unsigned long _glibtop_sysdeps_sem_limits =
(1L << GLIBTOP_IPC_SEMMAP) + (1L << GLIBTOP_IPC_SEMMNI) +
@@ -63,59 +36,101 @@ static unsigned long _glibtop_sysdeps_sem_limits =
(1L << GLIBTOP_IPC_SEMUME) + (1L << GLIBTOP_IPC_SEMUSZ) +
(1L << GLIBTOP_IPC_SEMVMX) + (1L << GLIBTOP_IPC_SEMAEM);
/* 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;
/* nlist structure for kernel access */
static struct nlist nlst [] = {
{ "_seminfo" },
{ 0 }
};
/* Init function. */
void
glibtop_init_sem_limits_p (glibtop *server)
glibtop_init_sem_limits_s (glibtop *server)
{
if (kvm_nlist (server->machine.kd, nlst) < 0) {
glibtop_warn_io_r (server, "kvm_nlist (sem_limits)");
return;
}
if (kvm_read (server->machine.kd, nlst [0].n_value,
&_seminfo, sizeof (_seminfo)) != sizeof (_seminfo)) {
glibtop_warn_io_r (server, "kvm_read (seminfo)");
return;
}
server->sysdeps.sem_limits = _glibtop_sysdeps_sem_limits;
}
/* Provides information about sysv sem limits. */
void
glibtop_get_sem_limits_p (glibtop *server, glibtop_sem_limits *buf)
glibtop_get_sem_limits_s (glibtop *server, glibtop_sem_limits *buf)
{
glibtop_init_p (server, (1L << GLIBTOP_SYSDEPS_SEM_LIMITS), 0);
size_t len;
int semmap, semmni, semmns, semmnu, semmsl, semopm, semume, semusz;
int semvmx, semaem;
glibtop_init_s (&server, GLIBTOP_SYSDEPS_SEM_LIMITS, 0);
memset (buf, 0, sizeof (glibtop_sem_limits));
if (server->sysdeps.sem_limits == 0)
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;
len = sizeof (semmap);
if (sysctlbyname ("kern.ipc.semmap", &semmap, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (kern.ipc.semmap)");
return;
}
len = sizeof (semmni);
if (sysctlbyname ("kern.ipc.semmni", &semmni, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (kern.ipc.semmni)");
return;
}
len = sizeof (semmns);
if (sysctlbyname ("kern.ipc.semmns", &semmns, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (kern.ipc.semmns)");
return;
}
len = sizeof (semmnu);
if (sysctlbyname ("kern.ipc.semmnu", &semmnu, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (kern.ipc.semmnu)");
return;
}
len = sizeof (semmsl);
if (sysctlbyname ("kern.ipc.semmsl", &semmsl, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (kern.ipc.semmsl)");
return;
}
len = sizeof (semopm);
if (sysctlbyname ("kern.ipc.semopm", &semopm, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (kern.ipc.semopm)");
return;
}
len = sizeof (semume);
if (sysctlbyname ("kern.ipc.semume", &semume, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (kern.ipc.semume)");
return;
}
len = sizeof (semusz);
if (sysctlbyname ("kern.ipc.semusz", &semusz, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (kern.ipc.semusz)");
return;
}
len = sizeof (semvmx);
if (sysctlbyname ("kern.ipc.semvmx", &semvmx, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (kern.ipc.semvmx)");
return;
}
len = sizeof (semaem);
if (sysctlbyname ("kern.ipc.semaem", &semaem, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (kern.ipc.semaem)");
return;
}
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. */

105
sysdeps/freebsd/shm_limits.c
View File

@@ -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;
}
len = sizeof (shmmin);
if (sysctlbyname ("kern.ipc.shmmin", &shmmin, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (kern.ipc.shmmin)");
return;
}
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;
}
#endif /* either a newer BSDI or no BSDI at all. */

381
sysdeps/freebsd/swap.c
View File

@@ -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;
pagesize = getpagesize ();
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
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;
/* 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->total = inuse + avail;
#else
nswdev = kvm_getswapinfo(server->machine.kd, kvmsw, 16, 0);
buf->flags = _glibtop_sysdeps_swap;
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)");
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;
}
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 (swappgsin);
if (sysctlbyname ("vm.stats.vm.v_swappgsin", &swappgsin, &len, NULL, 0)) {
glibtop_warn_io_r (server, "sysctl (vm.stats.vm.v_swappgsin)");
return;
}
swaplist = g_malloc (nswap * sizeof (struct swapent));
buf->pagein = (guint64) swappgsin;
buf->pageout = (guint64) swappgsout;
if (swapctl (SWAP_STATS, swaplist, nswap) != nswap) {
glibtop_warn_io_r (server, "swapctl (SWAP_STATS)");
g_free (swaplist);
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->total = inuse + avail;
#endif
buf->flags |= _glibtop_sysdeps_swap_paging;
}

4
sysdeps/freebsd/sysinfo.c
View File

@@ -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));

38
sysdeps/freebsd/uptime.c
View File

@@ -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;
}