/* * 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 }