/*
* Load the latest CPU usage statistics
*/
int netsnmp_cpu_arch_load( netsnmp_cache *cache, void *magic ) {
struct vmmeter vmm;
size_t len;
struct kinfo_cputime cp_time;
netsnmp_cpu_info *cpu = netsnmp_cpu_get_byIdx( -1, 0 );
kinfo_get_sched_cputime(&cp_time);
len = sizeof(vmm);
sysctlbyname("vm.vmmeter", &vmm, &len, NULL, 0);
cpu->user_ticks = cp_time.cp_user;
cpu->nice_ticks = cp_time.cp_nice;
cpu->sys2_ticks = cp_time.cp_sys + cp_time.cp_intr;
cpu->idle_ticks = cp_time.cp_idle;
cpu->kern_ticks = cp_time.cp_sys;
cpu->intrpt_ticks = cp_time.cp_intr;
cpu->swapIn = vmm.v_swappgsin + vmm.v_vnodepgsin;
cpu->swapOut = vmm.v_swappgsout + vmm.v_vnodepgsout;
cpu->nInterrupts = vmm.v_intr;
cpu->nCtxSwitches = vmm.v_swtch;
/* Copy "overall" figures to cpu0 entry */
_cpu_copy_stats( cpu );
return 0;
}
void
fetchiostat(void)
{
struct devinfo *tmp_dinfo;
if (kinfo_get_sched_cputime(&cp_time))
err(1, "kinfo_get_sched_cputime");
tmp_dinfo = last.dinfo;
last.dinfo = cur.dinfo;
cur.dinfo = tmp_dinfo;
last.busy_time = cur.busy_time;
/*
* Here what we want to do is refresh our device stats.
* getdevs() returns 1 when the device list has changed.
* If the device list has changed, we want to go through
* the selection process again, in case a device that we
* were previously displaying has gone away.
*/
switch (getdevs(&cur)) {
case -1:
errx(1, "%s", devstat_errbuf);
break;
case 1:
cmdiostat("refresh", NULL);
break;
default:
break;
}
num_devices = cur.dinfo->numdevs;
generation = cur.dinfo->generation;
}
int cpu_state(int which) {
static struct kinfo_cputime cp_old, cp_diff;
static uint64_t total_change, half_change;
static struct timeval this_time, last_time;
struct kinfo_cputime cp_time;
struct timeval time_diff;
if (which == -1) {
bzero(&cp_old, sizeof(cp_old));
bzero(&cp_diff, sizeof(cp_diff));
total_change = 1;
half_change = 0;
bzero(&last_time, sizeof(last_time));
return 0.0;
}
gettimeofday(&this_time, NULL);
timersub(&this_time, &last_time, &time_diff);
if (timertod(&time_diff) < MIN_CPU_POLL_INTERVAL) {
goto output;
}
last_time = this_time;
if (kinfo_get_sched_cputime(&cp_time)) {
warn("kinfo_get_sched_cputime");
return 0.0;
}
cp_diff.cp_user = cp_time.cp_user - cp_old.cp_user;
cp_diff.cp_nice = cp_time.cp_nice - cp_old.cp_nice;
cp_diff.cp_sys = cp_time.cp_sys - cp_old.cp_sys;
cp_diff.cp_intr = cp_time.cp_intr - cp_old.cp_intr;
cp_diff.cp_idle = cp_time.cp_idle - cp_old.cp_idle;
total_change = cp_diff.cp_user + cp_diff.cp_nice + cp_diff.cp_sys
+ cp_diff.cp_sys + cp_diff.cp_intr + cp_diff.cp_idle;
if (total_change == 0)
total_change = 1;
half_change = total_change >> 1;
output:
switch (which) {
case 0:
return (cp_diff.cp_user * 100 + half_change) / total_change;
case 1:
return (cp_diff.cp_nice * 100 + half_change) / total_change;
case 2:
return (cp_diff.cp_sys * 100 + half_change) / total_change;
case 3:
return (cp_diff.cp_intr * 100 + half_change) / total_change;
case 4:
return (cp_diff.cp_idle * 100 + half_change) / total_change;
default:
return 0;
}
}
void
gkrellm_sys_cpu_read_data(void)
{
struct kinfo_cputime cp_time;
if (kinfo_get_sched_cputime(&cp_time))
return;
gkrellm_cpu_assign_data(0, cp_time.cp_user, cp_time.cp_nice,
cp_time.cp_sys, cp_time.cp_idle);
}
/* returns current CPU usage in percent */
int
cpu_get_usage(cpu_options *opts)
{
static uint64_t old_used, old_total;
uint64_t used, total;
struct kinfo_cputime cp_time;
int usage;
if (kinfo_get_sched_cputime(&cp_time) < 0)
return 0;
used = cp_time.cp_user + cp_time.cp_sys;
if (!opts->ignore_nice)
used += cp_time.cp_nice;
total = used + cp_time.cp_idle;
if (old_total == 0 || total == old_total)
usage = 0;
else
usage = 100 * (used - old_used + used / 2 - old_used / 2) / (total - old_total);
old_used = used;
old_total = total;
return usage;
}
void
updatestat(void)
{
int i, hz;
struct clockinfo clockrate;
struct vmmeter vmm;
size_t vmm_size = sizeof(vmm);
struct ifmibdata ifmd;
double avrun[3];
struct timeval tm, btm;
struct kinfo_cputime cp_time;
int mib[6];
size_t len;
int ifcount;
#ifdef DEBUG
fprintf(stderr, "entering updatestat\n");
#endif
if (sincelastreq >= closedown) {
#ifdef DEBUG
fprintf(stderr, "about to closedown\n");
#endif
if (from_inetd)
exit(0);
else {
stat_is_init = 0;
return;
}
}
sincelastreq++;
mib[0] = CTL_KERN;
mib[1] = KERN_CLOCKRATE;
len = sizeof clockrate;
if (sysctl(mib, 2, &clockrate, &len, 0, 0) < 0) {
syslog(LOG_ERR, "sysctl(kern.clockrate): %m");
exit(1);
}
hz = clockrate.hz;
if (kinfo_get_sched_cputime(&cp_time)) {
syslog(LOG_ERR, "rstat: can't read cp_time from kmem");
exit(1);
}
stats_all.s1.cp_time[0] = cp_time.cp_user;
stats_all.s1.cp_time[1] = cp_time.cp_nice;
stats_all.s1.cp_time[2] = cp_time.cp_sys;
stats_all.s1.cp_time[3] = cp_time.cp_idle;
(void)getloadavg(avrun, sizeof(avrun) / sizeof(avrun[0]));
stats_all.s2.avenrun[0] = avrun[0] * FSCALE;
stats_all.s2.avenrun[1] = avrun[1] * FSCALE;
stats_all.s2.avenrun[2] = avrun[2] * FSCALE;
mib[0] = CTL_KERN;
mib[1] = KERN_BOOTTIME;
len = sizeof btm;
if (sysctl(mib, 2, &btm, &len, 0, 0) < 0) {
syslog(LOG_ERR, "sysctl(kern.boottime): %m");
exit(1);
}
stats_all.s2.boottime.tv_sec = btm.tv_sec;
stats_all.s2.boottime.tv_usec = btm.tv_usec;
#ifdef DEBUG
fprintf(stderr, "%d %d %d %d\n", stats_all.s1.cp_time[0],
stats_all.s1.cp_time[1], stats_all.s1.cp_time[2], stats_all.s1.cp_time[3]);
#endif
if (sysctlbyname("vm.vmmeter", &vmm, &vmm_size, NULL, 0)) {
syslog(LOG_ERR, "sysctlbyname: vm.vmmeter");
exit(1);
}
stats_all.s1.v_pgpgin = vmm.v_vnodepgsin;
stats_all.s1.v_pgpgout = vmm.v_vnodepgsout;
stats_all.s1.v_pswpin = vmm.v_swappgsin;
stats_all.s1.v_pswpout = vmm.v_swappgsout;
stats_all.s1.v_intr = vmm.v_intr;
gettimeofday(&tm, NULL);
stats_all.s1.v_intr -= hz*(tm.tv_sec - btm.tv_sec) +
hz*(tm.tv_usec - btm.tv_usec)/1000000;
stats_all.s2.v_swtch = vmm.v_swtch;
/* update disk transfers */
updatexfers(RSTAT_DK_NDRIVE, stats_all.s1.dk_xfer);
mib[0] = CTL_NET;
mib[1] = PF_LINK;
mib[2] = NETLINK_GENERIC;
mib[3] = IFMIB_SYSTEM;
mib[4] = IFMIB_IFCOUNT;
len = sizeof ifcount;
if (sysctl(mib, 5, &ifcount, &len, 0, 0) < 0) {
syslog(LOG_ERR, "sysctl(net.link.generic.system.ifcount): %m");
exit(1);
}
stats_all.s1.if_ipackets = 0;
stats_all.s1.if_opackets = 0;
stats_all.s1.if_ierrors = 0;
stats_all.s1.if_oerrors = 0;
stats_all.s1.if_collisions = 0;
for (i = 1; i <= ifcount; i++) {
len = sizeof ifmd;
mib[3] = IFMIB_IFDATA;
mib[4] = i;
mib[5] = IFDATA_GENERAL;
if (sysctl(mib, 6, &ifmd, &len, 0, 0) < 0) {
syslog(LOG_ERR, "sysctl(net.link.ifdata.%d.general)"
": %m", i);
exit(1);
}
stats_all.s1.if_ipackets += ifmd.ifmd_data.ifi_ipackets;
stats_all.s1.if_opackets += ifmd.ifmd_data.ifi_opackets;
stats_all.s1.if_ierrors += ifmd.ifmd_data.ifi_ierrors;
stats_all.s1.if_oerrors += ifmd.ifmd_data.ifi_oerrors;
stats_all.s1.if_collisions += ifmd.ifmd_data.ifi_collisions;
}
gettimeofday((struct timeval *)&stats_all.s3.curtime, NULL);
alarm(1);
}
static void
getinfo(struct Info *ls)
{
struct devinfo *tmp_dinfo;
struct nchstats *nch_tmp;
size_t size;
size_t vms_size = sizeof(ls->Vms);
size_t vmm_size = sizeof(ls->Vmm);
size_t nch_size = sizeof(ls->nchstats) * SMP_MAXCPU;
if (sysctlbyname("vm.vmstats", &ls->Vms, &vms_size, NULL, 0)) {
perror("sysctlbyname: vm.vmstats");
exit(1);
}
if (sysctlbyname("vm.vmmeter", &ls->Vmm, &vmm_size, NULL, 0)) {
perror("sysctlbyname: vm.vmstats");
exit(1);
}
if (kinfo_get_sched_cputime(&ls->cp_time))
err(1, "kinfo_get_sched_cputime");
if (kinfo_get_sched_cputime(&cp_time))
err(1, "kinfo_get_sched_cputime");
NREAD(X_BUFFERSPACE, &ls->bufspace, sizeof(ls->bufspace));
NREAD(X_DESIREDVNODES, &ls->desiredvnodes, sizeof(ls->desiredvnodes));
NREAD(X_NUMVNODES, &ls->numvnodes, sizeof(ls->numvnodes));
NREAD(X_FREEVNODES, &ls->freevnodes, sizeof(ls->freevnodes));
NREAD(X_NUMDIRTYBUFFERS, &ls->dirtybufspace, sizeof(ls->dirtybufspace));
if (nintr) {
size = nintr * sizeof(ls->intrcnt[0]);
sysctlbyname("hw.intrcnt_all", ls->intrcnt, &size, NULL, 0);
}
size = sizeof(ls->Total);
if (sysctlbyname("vm.vmtotal", &ls->Total, &size, NULL, 0) < 0) {
error("Can't get kernel info: %s\n", strerror(errno));
bzero(&ls->Total, sizeof(ls->Total));
}
if ((nch_tmp = malloc(nch_size)) == NULL) {
perror("malloc");
exit(1);
} else {
if (sysctlbyname("vfs.cache.nchstats", nch_tmp, &nch_size, NULL, 0)) {
perror("sysctlbyname vfs.cache.nchstats");
free(nch_tmp);
exit(1);
} else {
if ((nch_tmp = realloc(nch_tmp, nch_size)) == NULL) {
perror("realloc");
exit(1);
}
}
}
if (kinfo_get_cpus(&ncpu))
err(1, "kinfo_get_cpus");
kvm_nch_cpuagg(nch_tmp, &ls->nchstats, ncpu);
free(nch_tmp);
tmp_dinfo = last.dinfo;
last.dinfo = cur.dinfo;
cur.dinfo = tmp_dinfo;
last.busy_time = cur.busy_time;
switch (getdevs(&cur)) {
case -1:
errx(1, "%s", devstat_errbuf);
break;
case 1:
num_devices = cur.dinfo->numdevs;
generation = cur.dinfo->generation;
cmdkre("refresh", NULL);
break;
default:
break;
}
}
static void
dovmstat(u_int interval, int reps)
{
struct vmtotal total;
struct devinfo *tmp_dinfo;
size_t vmm_size = sizeof(vmm);
size_t vms_size = sizeof(vms);
size_t vmt_size = sizeof(total);
int initial = 1;
signal(SIGCONT, needhdr);
for (hdrcnt = 1;;) {
if (!--hdrcnt)
printhdr();
if (kinfo_get_sched_cputime(&cp_time))
err(1, "kinfo_get_sched_cputime");
tmp_dinfo = last.dinfo;
last.dinfo = cur.dinfo;
cur.dinfo = tmp_dinfo;
last.busy_time = cur.busy_time;
/*
* Here what we want to do is refresh our device stats.
* getdevs() returns 1 when the device list has changed.
* If the device list has changed, we want to go through
* the selection process again, in case a device that we
* were previously displaying has gone away.
*/
switch (getdevs(&cur)) {
case -1:
errx(1, "%s", devstat_errbuf);
break;
case 1: {
int retval;
num_devices = cur.dinfo->numdevs;
generation = cur.dinfo->generation;
retval = selectdevs(&dev_select, &num_selected,
&num_selections, &select_generation,
generation, cur.dinfo->devices,
num_devices, matches, num_matches,
specified_devices,
num_devices_specified, select_mode,
maxshowdevs, 0);
switch (retval) {
case -1:
errx(1, "%s", devstat_errbuf);
break;
case 1:
printhdr();
break;
default:
break;
}
}
default:
break;
}
if (sysctlbyname("vm.vmstats", &vms, &vms_size, NULL, 0)) {
perror("sysctlbyname: vm.vmstats");
exit(1);
}
if (sysctlbyname("vm.vmmeter", &vmm, &vmm_size, NULL, 0)) {
perror("sysctlbyname: vm.vmmeter");
exit(1);
}
if (sysctlbyname("vm.vmtotal", &total, &vmt_size, NULL, 0)) {
perror("sysctlbyname: vm.vmtotal");
exit(1);
}
printf("%2ld %1ld %1ld",
total.t_rq - 1, total.t_dw + total.t_pw, total.t_sw);
#define vmstat_pgtok(a) \
(intmax_t)(((intmax_t)(a) * vms.v_page_size) >> 10)
#define rate(x) \
(intmax_t)(initial ? (x) : ((intmax_t)(x) * 1000 + interval / 2) \
/ interval)
printf(" %7jd %6jd ",
vmstat_pgtok(total.t_avm),
vmstat_pgtok(total.t_free));
printf("%4ju ",
rate(vmm.v_vm_faults - ovmm.v_vm_faults));
printf("%3ju ",
rate(vmm.v_reactivated - ovmm.v_reactivated));
printf("%3ju ",
rate(vmm.v_swapin + vmm.v_vnodein -
(ovmm.v_swapin + ovmm.v_vnodein)));
printf("%3ju ",
rate(vmm.v_swapout + vmm.v_vnodeout -
(ovmm.v_swapout + ovmm.v_vnodeout)));
printf("%3ju ",
rate(vmm.v_tfree - ovmm.v_tfree));
printf("%3ju ",
rate(vmm.v_pdpages - ovmm.v_pdpages));
devstats();
printf("%4ju %4ju %3ju ",
rate(vmm.v_intr - ovmm.v_intr),
rate(vmm.v_syscall - ovmm.v_syscall),
rate(vmm.v_swtch - ovmm.v_swtch));
cpustats();
printf("\n");
fflush(stdout);
if (reps >= 0 && --reps <= 0)
break;
ovmm = vmm;
usleep(interval * 1000);
initial = 0;
}
}
void CpuView::updateCpu(CpuData &cpu, int cpuNumber)
{
#ifdef Q_OS_LINUX
if (!m_procStream)
return;
bool cpuFound = false;
TQString output;
TQString parser;
TQString cpuString;
cpuString.setNum(cpuNumber).prepend("cpu");
// Parse the proc file
while (!m_procStream->atEnd()) {
parser = m_procStream->readLine();
// remove all the entries apart from the line containing 'cpuString'
if (!cpuFound && parser.find(TQRegExp(cpuString)) != -1) {
output = parser;
cpuFound = true;
}
}
TQStringList cpuList = TQStringList::split(' ', output);
if (!cpuList.isEmpty()) {
cpu.name = cpuList[0].stripWhiteSpace();
cpu.user = cpuList[1].toULong();
cpu.nice = cpuList[2].toULong();
cpu.sys = cpuList[3].toULong();
cpu.idle = cpuList[4].toULong();
}
fseek(m_procFile, 0L, SEEK_SET);
#endif
#ifdef __DragonFly__
struct kinfo_cputime cp_time;
if (kinfo_get_sched_cputime(&cp_time))
err(1, "kinfo_get_sched_cputime");
cpu.user = cp_time.cp_user;
cpu.nice = cp_time.cp_nice;
cpu.sys = cp_time.cp_sys;
cpu.idle = cp_time.cp_idle;
#elif defined(Q_OS_FREEBSD)
#warning "add support for SMP on FreeBSD"
Q_UNUSED(cpuNumber);
static int name2oid[2] = { 0, 3 };
static int oidCpuTime[CTL_MAXNAME + 2];
static size_t oidCpuTimeLen = sizeof(oidCpuTime);
long cpuTime[CPUSTATES];
size_t cpuTimeLen = sizeof(cpuTime);
static char name[] = "kern.cp_time";
static int initialized = 0;
if (!initialized) {
if (sysctl(name2oid, 2, oidCpuTime, &oidCpuTimeLen,
name, strlen(name)) < 0)
return;
oidCpuTimeLen /= sizeof(int);
initialized = 1;
}
if (sysctl(oidCpuTime, oidCpuTimeLen,
cpuTime, &cpuTimeLen, 0, 0) < 0)
return;
cpu.user = cpuTime[CP_USER];
cpu.nice = cpuTime[CP_NICE];
cpu.sys = cpuTime[CP_SYS];
cpu.idle = cpuTime[CP_IDLE];
#endif
#if defined(Q_OS_NETBSD)
#define KERN_CPTIME KERN_CP_TIME
#endif
#if defined(Q_OS_OPENBSD) || defined(Q_OS_NETBSD)
//#warning "add support for SMP on OpenBSD and NetBSD"
int name2oid[2] = { CTL_KERN, KERN_CPTIME };
long cpuTime[CPUSTATES];
size_t cpuTimeLen = sizeof(cpuTime);
if (sysctl(name2oid, 2, &cpuTime, &cpuTimeLen,
0, 0) < 0)
return;
cpu.user = cpuTime[CP_USER];
cpu.nice = cpuTime[CP_NICE];
cpu.sys = cpuTime[CP_SYS];
cpu.idle = cpuTime[CP_IDLE];
#endif
}
