int netstat_init() { kstat_t *ksp; kc = kstat_open(); if (kstat_chain_update(kc)) (void) fprintf(stderr, "<<State Changed>>n"); for (ksp = kc->kc_chain; ksp != NULL; ksp = ksp->ks_next) { if (ksp->ks_type != KSTAT_TYPE_NAMED || strcmp(ksp->ks_class, "net") != 0 || kstat_read(kc, ksp, NULL) == -1 || kstat_data_lookup(ksp, "ipackets64") == NULL || kstat_data_lookup(ksp, "opackets64") == NULL) continue; strlcpy(nics[no_nics].interface, ksp->ks_name, INTERFACE_LEN); nics[no_nics++].ksp = ksp; if (no_nics >= MAX_NETS) { printf("Warning: Number of interfaces exceeded %d\n", MAX_NETS); return (-1); } } return (0); }
/* * Retrieve the vopstats. If kspp (pointer to kstat_t pointer) is non-NULL, * then pass it back to the caller. * * Returns 0 on success, non-zero on failure. */ int get_vopstats(kstat_ctl_t *kc, char *ksname, vopstats_t *vsp, kstat_t **kspp) { kstat_t *ksp; if (ksname == NULL || *ksname == 0) return (1); errno = 0; /* wait for a possibly up-to-date chain */ while (kstat_chain_update(kc) == -1) { if (errno == EAGAIN) { errno = 0; (void) poll(NULL, 0, RETRY_DELAY); continue; } perror("kstat_chain_update"); exit(1); } if ((ksp = kstat_lookup(kc, NULL, -1, ksname)) == NULL) { return (1); } if (kstat_read(kc, ksp, vsp) == -1) { return (1); } if (kspp) *kspp = ksp; return (0); }
/* * Determine the count of pages scanned by the global page scanner, obtained * from the cpu_stat:*::scan kstats. Return zero on success. */ static int get_globally_scanned_pages(uint64_t *scannedp) { kstat_t *ksp; uint64_t scanned = 0; if (kstat_chain_update(kctl) == -1) { warn(gettext("can't update kstat chain")); return (0); } for (ksp = kctl->kc_chain; ksp != NULL; ksp = ksp->ks_next) { if (strcmp(ksp->ks_module, "cpu_stat") == 0) { if (kstat_read(kctl, ksp, NULL) != -1) { scanned += ((cpu_stat_t *) ksp->ks_data)->cpu_vminfo.scan; } else { return (-1); } } } *scannedp = scanned; return (0); }
void netstat_snap(int snaptype) { int i, index; kstat_t *ksp; kid_t kstat_chain_id; if (kstat_chain_update(kc)) state_changed = 1; if (snaptype == SNAP_BEGIN) index = 0; else index = 1; for (i = 0; i < no_nics; i++) { ksp = nics[i].ksp; kstat_chain_id = kstat_read(kc, ksp, nets[0]); nics[i].s[index].tx_pkts = kstat_named_value(ksp, "opackets64"); nics[i].s[index].rx_pkts = kstat_named_value(ksp, "ipackets64"); nics[i].s[index].tx_bytes = kstat_named_value(ksp, "obytes64"); nics[i].s[index].rx_bytes = kstat_named_value(ksp, "rbytes64"); nics[i].s[index].stamp = gethrtime(); } }
void glibtop_get_cpu_s (glibtop *server, glibtop_cpu *buf) { kstat_ctl_t * const kc = server->machine->kc; cpu_stat_t cpu_stat; processorid_t cpu; int ncpu, found; memset (buf, 0, sizeof (glibtop_cpu)); buf->frequency = server->machine->ticks; buf->flags = _glibtop_sysdeps_cpu_freq; if(!kc) return; switch(kstat_chain_update(kc)) { case -1: assert(0); /* Debugging purposes, shouldn't happen */ case 0: break; default: glibtop_get_kstats(server); } ncpu = MIN(GLIBTOP_NCPU, server->ncpu); for (cpu = 0, found = 0; cpu < GLIBTOP_NCPU && found != ncpu; cpu++) { kstat_t * const ksp = server->machine->cpu_stat_kstat [cpu]; if (!ksp) continue;; ++found; if(p_online(cpu, P_STATUS) == P_ONLINE) buf->xcpu_flags |= (1L << cpu); else continue; if (kstat_read (kc, ksp, &cpu_stat) == -1) { glibtop_warn_io_r (server, "kstat_read (cpu_stat%d)", cpu); continue; } buf->xcpu_idle [cpu] = cpu_stat.cpu_sysinfo.cpu [CPU_IDLE]; buf->xcpu_user [cpu] = cpu_stat.cpu_sysinfo.cpu [CPU_USER]; buf->xcpu_sys [cpu] = cpu_stat.cpu_sysinfo.cpu [CPU_KERNEL]; buf->xcpu_total [cpu] = buf->xcpu_idle [cpu] + buf->xcpu_user [cpu] + buf->xcpu_sys [cpu]; buf->idle += cpu_stat.cpu_sysinfo.cpu [CPU_IDLE]; buf->user += cpu_stat.cpu_sysinfo.cpu [CPU_USER]; buf->sys += cpu_stat.cpu_sysinfo.cpu [CPU_KERNEL]; } if(!found) return; buf->total = buf->idle + buf->user + buf->sys; buf->flags = _glibtop_sysdeps_cpu_all; }
struct snapshot * acquire_snapshot(kstat_ctl_t *kc, int types, struct iodev_filter *iodev_filter) { struct snapshot *ss = NULL; int err; retry: err = 0; /* ensure any partial resources are freed on a retry */ free_snapshot(ss); ss = safe_alloc(sizeof (struct snapshot)); (void) memset(ss, 0, sizeof (struct snapshot)); ss->s_types = types; /* wait for a possibly up-to-date chain */ while (kstat_chain_update(kc) == -1) { if (errno == EAGAIN) (void) poll(NULL, 0, RETRY_DELAY); else fail(1, "kstat_chain_update failed"); } if (!err && (types & SNAP_INTERRUPTS)) err = acquire_intrs(ss, kc); if (!err && (types & (SNAP_CPUS | SNAP_SYSTEM | SNAP_PSETS))) err = acquire_cpus(ss, kc); if (!err && (types & SNAP_PSETS)) err = acquire_psets(ss); if (!err && (types & (SNAP_IODEVS | SNAP_CONTROLLERS | SNAP_IOPATHS_LI | SNAP_IOPATHS_LTI))) err = acquire_iodevs(ss, kc, iodev_filter); if (!err && (types & SNAP_SYSTEM)) err = acquire_sys(ss, kc); switch (err) { case 0: break; case EAGAIN: (void) poll(NULL, 0, RETRY_DELAY); /* a kstat disappeared from under us */ /*FALLTHRU*/ case ENXIO: case ENOENT: goto retry; default: fail(1, "acquiring snapshot failed"); } return (ss); }
void ks_chain_update(kstat_ctl_t * kc) { kid = kstat_chain_update(kc); if (kid < 0) { perror("kstat_chain_update"); return; } }
static void update_kstat() { if (kstat == NULL) { kstat = kstat_open(); if (kstat == NULL) { NORM_ERR("can't open kstat: %s", strerror(errno)); } } if (kstat_chain_update(kstat) == -1) { perror("kstat_chain_update"); return; } }
static void update_kstat(void) { if (kc == NULL) { if ((kc = kstat_open()) == NULL) ERROR("Unable to open kstat control structure"); } else { kid_t kid = kstat_chain_update(kc); if (kid > 0) { INFO("kstat chain has been updated"); plugin_init_all(); } else if (kid < 0) ERROR("kstat chain update failed"); /* else: everything works as expected */ } return; } /* static void update_kstat (void) */
/* * Initialise the list of CPUs on the system * (including descriptions) */ void init_cpu_kstat( void ) { int i = 0, n = 0, clock, state_begin; char ctype[15], ftype[15], state[10]; kstat_t *ksp; kstat_named_t *ks_data; netsnmp_cpu_info *cpu = netsnmp_cpu_get_byIdx( -1, 1 ); strcpy(cpu->name, "Overall CPU statistics"); if (kstat_fd == NULL) kstat_fd = kstat_open(); kstat_chain_update( kstat_fd ); DEBUGMSGTL(("cpu", "cpu_kstat init\n ")); for (ksp = kstat_fd->kc_chain; ksp != NULL; ksp = ksp->ks_next) { if (ksp->ks_flags & KSTAT_FLAG_INVALID) continue; if ((strcmp(ksp->ks_module, "cpu_info") == 0) && (strcmp(ksp->ks_class, "misc" ) == 0)) { kstat_read(kstat_fd, ksp, NULL ); n++; clock = 999999; memset(ctype, 0, sizeof(ctype)); memset(ftype, 0, sizeof(ftype)); memset(state, 0, sizeof(state)); for (i=0, ks_data = ksp->ks_data; i < ksp->ks_ndata; i++, ks_data++) { if ( strcmp( ks_data->name, "state" ) == 0 ) { strlcpy(state, ks_data->value.c, sizeof(state)); } else if ( strcmp( ks_data->name, "state_begin" ) == 0 ) { state_begin = ks_data->value.i32; } else if ( strcmp( ks_data->name, "cpu_type" ) == 0 ) { strlcpy(ctype, ks_data->value.c, sizeof(ctype)); } else if ( strcmp( ks_data->name, "fpu_type" ) == 0 ) { strlcpy(ftype, ks_data->value.c, sizeof(ftype)); } else if ( strcmp( ks_data->name, "clock_MHz" ) == 0 ) { clock = ks_data->value.i32; } } i = ksp->ks_instance; cpu = netsnmp_cpu_get_byIdx( i, 1 ); sprintf( cpu->name, "cpu%d", i ); sprintf( cpu->descr, "CPU %d Sun %d MHz %s with %s FPU %s", i, clock, ctype, ftype, state ); cpu->status = _cpu_status(state); /* XXX - or in 'n_c_a_load' ? */ } } cpu_num = i; }
void glibtop_get_loadavg_s (glibtop *server, glibtop_loadavg *buf) { #ifndef HAVE_GETLOADAVG kstat_ctl_t *kc; kstat_t *ksp; size_t i; static const char avestrings[][14] = { "avenrun_1min", "avenrun_5min", "avenrun_15min" }; #endif memset (buf, 0, sizeof (glibtop_loadavg)); #ifdef HAVE_GETLOADAVG if (getloadavg (buf->loadavg, 3) != 3) return; #else if(!(kc = server->machine->kc)) return; switch(kstat_chain_update(kc)) { case -1: assert(0); /* Debugging, shouldn't happen */ case 0: break; default: glibtop_get_kstats(server); } if(!(ksp = server->machine->system)) return; if(kstat_read(kc, ksp, NULL) < 0) return; for(i = 0; i < 3; ++i) /* Do we have a countof macro? */ { kstat_named_t *kn; kn = (kstat_named_t *)kstat_data_lookup(ksp, avestrings[i]); if(kn) buf->loadavg[i] = (double)kn->value.ul / FSCALE; } #endif /* HAVE_GETLOADAVG */ buf->flags = _glibtop_sysdeps_loadavg; }
/* * Check to see if any DR operations have occured, and deal with the * consequences. * * Use the Kstat chain ID to check for DR operations. If the ID has * changed then some kstats on system have been modified, we check * all the data structures to see are they still valid. If they are * not we remove them. */ void check_dr_ops() { dev_node_t *dev_node; kid_t new_id; kstat_t *ksp; int match = 0; if ((new_id = kstat_chain_update(kc)) < 0) { (void) fprintf(stderr, gettext("%s: could not get " "kstat chain id\n"), pgmname); exit(1); } if (new_id == 0) { /* Kstat chain has not changed. */ return; } /* * Scan the chain of device nodes, making sure that their associated * kstats are still present. If not we remove the appropiate node. */ dev_node = dev_list_head; while (dev_node != NULL) { for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) { if ((strcmp("bus", ksp->ks_class) == 0) && (strcmp("counters", ksp->ks_name) == 0) && (strcmp(dev_node->name, ksp->ks_module) == 0) && (ksp->ks_instance == dev_node->dev_inst)) { match = 1; break; } } if (match == 0) { (void) fprintf(stderr, gettext("%s: device %s%d" " (pic %d) no longer valid.\n"), pgmname, dev_node->name, dev_node->dev_inst, dev_node->pic_num); remove_dev_node(dev_node); } dev_node = dev_node->next; } }
gboolean get_cpu_usage (gushort *cpu_count, gfloat *cpu_user, gfloat *cpu_system) { kstat_t *ksp; kstat_named_t *knp; static gulong ticks_total = 0, ticks_total_old = 0; gulong ticks_user = 0, ticks_system = 0; if (!kc) init_stats (); _cpu_count = 0; kstat_chain_update (kc); ticks_total_old = ticks_total; ticks_total = 0; for (ksp = kc->kc_chain; ksp != NULL; ksp = ksp->ks_next) { if (!g_strcmp0 (ksp->ks_module, "cpu_info")) { _cpu_count += 1; } else if (!g_strcmp0 (ksp->ks_module, "cpu") && !g_strcmp0 (ksp->ks_name, "sys")) { kstat_read (kc, ksp, NULL); knp = kstat_data_lookup (ksp, "cpu_nsec_user"); ticks_user += knp->value.ul / 100000; knp = kstat_data_lookup (ksp, "cpu_nsec_kernel"); ticks_system += knp->value.ul / 100000; knp = kstat_data_lookup (ksp, "cpu_nsec_intr"); ticks_system += knp->value.ul / 100000; knp = kstat_data_lookup (ksp, "cpu_nsec_idle"); ticks_total += knp->value.ul / 100000; ticks_total += ticks_user + ticks_system; } } if (ticks_total > ticks_total_old) ticks_total_delta = ticks_total - ticks_total_old; get_cpu_percent (0, ticks_user, cpu_user, ticks_system, cpu_system); *cpu_count = _cpu_count; return TRUE; }
int updateLoadAvg(void) { #ifdef HAVE_KSTAT kstat_ctl_t *kctl; kstat_t *ksp; kstat_named_t *kdata; /* * get a kstat handle and update the user's kstat chain */ if((kctl = kstat_open()) == NULL) return (0); while(kstat_chain_update(kctl) != 0) ; /* * traverse the kstat chain to find the appropriate statistics */ if((ksp = kstat_lookup(kctl, "unix", 0, "system_misc")) == NULL) return (0); if(kstat_read(kctl, ksp, NULL) == -1) return (0); /* * lookup the data */ kdata = (kstat_named_t *)kstat_data_lookup(ksp, "avenrun_1min"); if(kdata != NULL) loadavg1 = LOAD(kdata->value.ui32); kdata = (kstat_named_t *)kstat_data_lookup(ksp, "avenrun_5min"); if(kdata != NULL) loadavg5 = LOAD(kdata->value.ui32); kdata = (kstat_named_t *)kstat_data_lookup(ksp, "avenrun_15min"); if(kdata != NULL) loadavg15 = LOAD(kdata->value.ui32); kstat_close(kctl); #endif /* ! HAVE_KSTAT */ return (0); }
int updateMemory( void ) { #ifdef HAVE_KSTAT kstat_ctl_t *kctl; kstat_t *ksp; kstat_named_t *kdata; /* * get a kstat handle and update the user's kstat chain */ if( (kctl = kstat_open()) == NULL ) return( 0 ); while( kstat_chain_update( kctl ) != 0 ) ; totalmem = pagetok( sysconf( _SC_PHYS_PAGES )); /* * traverse the kstat chain to find the appropriate statistics */ if( (ksp = kstat_lookup( kctl, "unix", 0, "system_pages" )) == NULL ) { goto done; } if( kstat_read( kctl, ksp, NULL ) == -1 ) { goto done; } /* * lookup the data */ kdata = (kstat_named_t *) kstat_data_lookup( ksp, "freemem" ); if( kdata != NULL ) freemem = pagetok( kdata->value.ui32 ); done: kstat_close( kctl ); #endif /* ! HAVE_KSTAT */ return( 0 ); }
kstat_ctl_t * kstat_open(void) { kstat_ctl_t *kc; int kd; kd = open("/dev/kstat", O_RDONLY); if (kd == -1) return (NULL); kstat_zalloc((void **)&kc, sizeof (kstat_ctl_t), 0); if (kc == NULL) return (NULL); kc->kc_kd = kd; kc->kc_chain = NULL; kc->kc_chain_id = 0; if (kstat_chain_update(kc) == -1) { int saved_err = errno; (void) kstat_close(kc); errno = saved_err; return (NULL); } return (kc); }
static int get_system_info (kstat_ctl_t *kc, sys_stat *sst) { kstat_t *ksp; kstat_named_t *kn; kid_t kcid, nkcid; int totalswap, freeswap; int i, j; cpu_stat_t cpu_stat[MAX_CPU]; static int pagesize = 0, maxmem = 0; static long cp_time[CPUSTATES]; static long cp_old[CPUSTATES]; static long cp_diff[CPUSTATES]; static kstat_t *cpu_ks[MAX_CPU]; static int ncpu = 0; static int freemem_check_time = 0; int changed = 0; kcid = kc->kc_chain_id; kcid_changed: nkcid = kstat_chain_update (kc); if (nkcid) { kcid = nkcid; changed = 1; } CHECK_KCID (nkcid, 0); ksp = kstat_lookup (kc, "unix", -1, "system_misc"); nkcid = kstat_read (kc, ksp, NULL); CHECK_KCID (nkcid, kcid); /* * collect load average information */ kn = kstat_data_lookup (ksp, "avenrun_1min"); sst->load_avg[0] = kn->value.ui32; kn = kstat_data_lookup (ksp, "avenrun_5min"); sst->load_avg[1] = kn->value.ui32; kn = kstat_data_lookup (ksp, "avenrun_15min"); sst->load_avg[2] = kn->value.ui32; /* * collect cpu information */ if (changed == 1 || ncpu == 0) { ncpu = 0; for (ksp = kc->kc_chain; ksp && ncpu < MAX_CPU; ksp = ksp->ks_next) { if (strncmp (ksp->ks_name, "cpu_stat", 8) == 0) { nkcid = kstat_read (kc, ksp, NULL); CHECK_KCID (nkcid, kcid); cpu_ks[ncpu] = ksp; ncpu++; } } } for (i = 0; i < ncpu; i++) { nkcid = kstat_read (kc, cpu_ks[i], & (cpu_stat[i])); CHECK_KCID (nkcid, kcid); } for (j = 0; j < CPUSTATES; j++) { cp_time[j] = 0L; } for (i = 0; i < ncpu; i++) { for (j = 0; j < CPU_WAIT; j++) { cp_time[j] += (long) cpu_stat[i].cpu_sysinfo.cpu[j]; } cp_time[CPUSTATE_IOWAIT] += (long) cpu_stat[i].cpu_sysinfo.wait[W_IO] + (long) cpu_stat[i].cpu_sysinfo.wait[W_PIO]; cp_time[CPUSTATE_SWAP] = (long) cpu_stat[i].cpu_sysinfo.wait[W_SWAP]; } percentages (CPUSTATES, sst->cpu_states, cp_time, cp_old, cp_diff); /* * collect memory information */ if (pagesize == 0) { pagesize = sysconf (_SC_PAGESIZE); } if (maxmem == 0) { maxmem = sysconf (_SC_PHYS_PAGES); sst->memory_stats[0] = PAGETOM (maxmem, pagesize); } if (time (NULL) - freemem_check_time > 30) { ksp = kstat_lookup (kc, "unix", 0, "system_pages"); nkcid = kstat_read (kc, ksp, NULL); CHECK_KCID (nkcid, kcid); kn = kstat_data_lookup (ksp, "freemem"); sst->memory_stats[2] = PAGETOM (kn->value.ui32, pagesize); if (sst->memory_stats[0] - sst->memory_stats[2] > 0) { sst->memory_stats[1] = sst->memory_stats[0] - sst->memory_stats[2]; } freemem_check_time = time (NULL); } #if 0 kn = kstat_data_lookup (ksp, "availrmem"); #endif get_swapinfo (&totalswap, &freeswap); sst->memory_stats[3] = PAGETOM ((totalswap - freeswap), pagesize); sst->memory_stats[4] = PAGETOM (freeswap, pagesize); return 1; }
void Solaris_Network_Interface_Monitor::access_kstats ( ACE_UINT64 &which_member) { this->kstats_ = kstat_open (); if (this->kstats_ == 0) { ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("opening kstats file failed\n"))); return; } this->kstat_id_ = this->kstats_->kc_chain_id; int status = 0; while (true) { /// We have to sum the network interfaces manually. for (this->kstat_ = this->kstats_->kc_chain; this->kstat_ != 0; this->kstat_ = this->kstat_->ks_next) { if (ACE_OS::strcmp (this->kstat_->ks_class, "net") != 0) { continue; } unsigned long ks_instance = this->kstat_->ks_instance; if (ACE_OS::strcmp (this->kstat_->ks_module, "lo") == 0) { /// Interfaces 'lo' have only packet counters. if (this->lookup_str_ == ACE_TEXT ("obytes") || this->lookup_str_ == ACE_TEXT ("rbytes")) { continue; } status = this->check_ks_module (ks_instance, MAX_LO_INTERFACES, "MAX_LO_INTERFACES", this->value_array_lo_, which_member); if (status == -1) { /// Unrecoverable error, diagnostic already output. (void) kstat_close (this->kstats_); return; } else if (status == 1) { /// The kstat_id changed underneath us, start over. break; } } else if (ACE_OS::strcmp (this->kstat_->ks_module, "hme") == 0 || ACE_OS::strcmp (this->kstat_->ks_module, "bge") == 0) { status = this->check_ks_module (ks_instance, MAX_HME_INTERFACES, "MAX_HME_INTERFACES", this->value_array_hme_, which_member); if (status == -1) { /// Unrecoverable error, diagnostic already output. (void) kstat_close (this->kstats_); return; } else if (status == 1) { /// The kstat_id changed underneath us, start over. break; } } } if (this->kstat_) { this->kstat_id_ = kstat_chain_update (this->kstats_); if (! this->kstat_id_ > 0) { ACELIB_ERROR ((LM_ERROR, "kstat is is not > 0.\n")); break; } } else { break; } } status = kstat_close (this->kstats_); if (status != 0) { ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("closing kstats file failed\n"))); } }
int updateNetDev( void ) { #ifdef HAVE_KSTAT kstat_ctl_t *kctl; kstat_t *ksp; kstat_named_t *kdata; int i; /* * get a kstat handle and update the user's kstat chain */ if( (kctl = kstat_open()) == NULL ) return( 0 ); while( kstat_chain_update( kctl ) != 0 ) ; for( i = 0; i < NetDevCount; i++ ) { char *name; char *ptr; /* * chop off the trailing interface no */ name = strdup( IfInfo[i].Name ); ptr = name + strlen( name ) - 1; while( (ptr > name) && isdigit( (int) *ptr ) ) { *ptr = '\0'; ptr--; } /* * traverse the kstat chain * to find the appropriate statistics */ if( (ksp = kstat_lookup( kctl, name, 0, IfInfo[i].Name )) == NULL ) { free( name ); return( 0 ); } if( kstat_read( kctl, ksp, NULL ) == -1 ) { free( name ); return( 0 ); } free( name ); /* * lookup & store the data */ kdata = (kstat_named_t *) kstat_data_lookup( ksp, "ipackets" ); if( kdata != NULL ) { IfInfo[i].OLDipackets = IfInfo[i].ipackets; IfInfo[i].ipackets = kdata->value.ul; } kdata = (kstat_named_t *) kstat_data_lookup( ksp, "opackets" ); if( kdata != NULL ) { IfInfo[i].OLDopackets = IfInfo[i].opackets; IfInfo[i].opackets = kdata->value.ul; } kdata = (kstat_named_t *) kstat_data_lookup( ksp, "ierrors" ); if( kdata != NULL ) { IfInfo[i].OLDierrors = IfInfo[i].ierrors; IfInfo[i].ierrors = kdata->value.ul; } kdata = (kstat_named_t *) kstat_data_lookup( ksp, "oerrors" ); if( kdata != NULL ) { IfInfo[i].OLDoerrors = IfInfo[i].oerrors; IfInfo[i].oerrors = kdata->value.ul; } kdata = (kstat_named_t *) kstat_data_lookup( ksp, "collisions" ); if( kdata != NULL ) { IfInfo[i].OLDcollisions = IfInfo[i].collisions; IfInfo[i].collisions = kdata->value.ul; } kdata = (kstat_named_t *) kstat_data_lookup( ksp, "multixmt" ); if( kdata != NULL ) { IfInfo[i].OLDmultixmt = IfInfo[i].multixmt; IfInfo[i].multixmt = kdata->value.ul; } kdata = (kstat_named_t *) kstat_data_lookup( ksp, "multircv" ); if( kdata != NULL ) { IfInfo[i].OLDmultircv = IfInfo[i].multircv; IfInfo[i].multircv = kdata->value.ul; } kdata = (kstat_named_t *) kstat_data_lookup( ksp, "brdcstxmt" ); if( kdata != NULL ) { IfInfo[i].OLDbrdcstxmt = IfInfo[i].brdcstxmt; IfInfo[i].brdcstxmt = kdata->value.ul; } kdata = (kstat_named_t *) kstat_data_lookup( ksp, "brdcstrcv" ); if( kdata != NULL ) { IfInfo[i].OLDbrdcstrcv = IfInfo[i].brdcstrcv; IfInfo[i].brdcstrcv = kdata->value.ul; } } kstat_close( kctl ); #endif /* ! HAVE_KSTAT */ return( 0 ); }
TCN_IMPLEMENT_CALL(jint, OS, info)(TCN_STDARGS, jlongArray inf) { jint rv; int i; jsize ilen = (*e)->GetArrayLength(e, inf); jlong *pvals = (*e)->GetLongArrayElements(e, inf, NULL); UNREFERENCED(o); if (ilen < 16) { return APR_EINVAL; } for (i = 0; i < 16; i++) pvals[i] = 0; #if defined(__linux__) { struct sysinfo info; if (sysinfo(&info)) rv = apr_get_os_error(); else { pvals[0] = (jlong)(info.totalram * info.mem_unit); pvals[1] = (jlong)(info.freeram * info.mem_unit); pvals[2] = (jlong)(info.totalswap * info.mem_unit); pvals[3] = (jlong)(info.freeswap * info.mem_unit); pvals[4] = (jlong)(info.sharedram * info.mem_unit); pvals[5] = (jlong)(info.bufferram * info.mem_unit); pvals[6] = (jlong)(100 - (info.freeram * 100 / info.totalram)); rv = APR_SUCCESS; } } #elif defined(sun) { /* static variables with basic procfs info */ static long creation = 0; /* unix timestamp of process creation */ static int psinf_fd = 0; /* file descriptor for the psinfo procfs file */ static int prusg_fd = 0; /* file descriptor for the usage procfs file */ static size_t rss = 0; /* maximum of resident set size from previous calls */ /* static variables with basic kstat info */ static kstat_ctl_t *kstat_ctl = NULL; /* kstat control object, only initialized once */ static kstat_t *kstat_cpu[MAX_CPUS]; /* array of kstat objects for per cpu statistics */ static int cpu_count = 0; /* number of cpu structures found in kstat */ static kid_t kid = 0; /* kstat ID, for which the kstat_ctl holds the correct chain */ /* non-static variables - general use */ int res = 0; /* general result state */ /* non-static variables - sysinfo/swapctl use */ long ret_sysconf; /* value returned from sysconf call */ long tck_dividend; /* factor used by transforming tick numbers to milliseconds */ long tck_divisor; /* divisor used by transforming tick numbers to milliseconds */ long sys_pagesize = sysconf(_SC_PAGESIZE); /* size of a system memory page in bytes */ long sys_clk_tck = sysconf(_SC_CLK_TCK); /* number of system ticks per second */ struct anoninfo info; /* structure for information about sizes in anonymous memory system */ /* non-static variables - procfs use */ psinfo_t psinf; /* psinfo structure from procfs */ prusage_t prusg; /* usage structure from procfs */ size_t new_rss = 0; /* resident set size read from procfs */ time_t now; /* time needed for calculating process creation time */ /* non-static variables - kstat use */ kstat_t *kstat = NULL; /* kstat working pointer */ cpu_sysinfo_t cpu; /* cpu sysinfo working pointer */ kid_t new_kid = 0; /* kstat ID returned from chain update */ int new_kstat = 0; /* flag indicating, if kstat structure has changed since last call */ rv = APR_SUCCESS; if (sys_pagesize <= 0) { rv = apr_get_os_error(); } else { ret_sysconf = sysconf(_SC_PHYS_PAGES); if (ret_sysconf >= 0) { pvals[0] = (jlong)((jlong)sys_pagesize * ret_sysconf); } else { rv = apr_get_os_error(); } ret_sysconf = sysconf(_SC_AVPHYS_PAGES); if (ret_sysconf >= 0) { pvals[1] = (jlong)((jlong)sys_pagesize * ret_sysconf); } else { rv = apr_get_os_error(); } res=swapctl(SC_AINFO, &info); if (res >= 0) { pvals[2] = (jlong)((jlong)sys_pagesize * info.ani_max); pvals[3] = (jlong)((jlong)sys_pagesize * info.ani_free); pvals[6] = (jlong)(100 - (jlong)info.ani_free * 100 / info.ani_max); } else { rv = apr_get_os_error(); } } if (psinf_fd == 0) { psinf_fd = proc_open("psinfo"); } res = proc_read(&psinf, PSINFO_T_SZ, psinf_fd); if (res >= 0) { new_rss = psinf.pr_rssize*1024; pvals[13] = (jlong)(new_rss); if (new_rss > rss) { rss = new_rss; } pvals[14] = (jlong)(rss); } else { psinf_fd = 0; rv = apr_get_os_error(); } if (prusg_fd == 0) { prusg_fd = proc_open("usage"); } res = proc_read(&prusg, PRUSAGE_T_SZ, prusg_fd); if (res >= 0) { if (creation <= 0) { time(&now); creation = (long)(now - (prusg.pr_tstamp.tv_sec - prusg.pr_create.tv_sec)); } pvals[10] = (jlong)(creation); pvals[11] = (jlong)((jlong)prusg.pr_stime.tv_sec * 1000 + (prusg.pr_stime.tv_nsec / 1000000)); pvals[12] = (jlong)((jlong)prusg.pr_utime.tv_sec * 1000 + (prusg.pr_utime.tv_nsec / 1000000)); pvals[15] = (jlong)(prusg.pr_majf); } else { prusg_fd = 0; rv = apr_get_os_error(); } if (sys_clk_tck <= 0) { rv = apr_get_os_error(); } else { tck_dividend = 1000; tck_divisor = sys_clk_tck; for (i = 0; i < 3; i++) { if (tck_divisor % 2 == 0) { tck_divisor = tck_divisor / 2; tck_dividend = tck_dividend / 2; } if (tck_divisor % 5 == 0) { tck_divisor = tck_divisor / 5; tck_dividend = tck_dividend / 5; } } if (kstat_ctl == NULL) { kstat_ctl = kstat_open(); kid = kstat_ctl->kc_chain_id; new_kstat = 1; } else { new_kid = kstat_chain_update(kstat_ctl); if (new_kid < 0) { res=kstat_close(kstat_ctl); kstat_ctl = kstat_open(); kid = kstat_ctl->kc_chain_id; new_kstat = 1; } else if (new_kid > 0 && kid != new_kid) { kid = new_kid; new_kstat = 1; } } if (new_kstat) { cpu_count = 0; for (kstat = kstat_ctl->kc_chain; kstat; kstat = kstat->ks_next) { if (strncmp(kstat->ks_name, "cpu_stat", 8) == 0) { kstat_cpu[cpu_count++]=kstat; } } } for (i = 0; i < cpu_count; i++) { new_kid = kstat_read(kstat_ctl, kstat_cpu[i], NULL); if (new_kid >= 0) { cpu = ((cpu_stat_t *)kstat_cpu[i]->ks_data)->cpu_sysinfo; if ( tck_divisor == 1 ) { pvals[7] += (jlong)(((jlong)cpu.cpu[CPU_IDLE]) * tck_dividend); pvals[7] += (jlong)(((jlong)cpu.cpu[CPU_WAIT]) * tck_dividend); pvals[8] += (jlong)(((jlong)cpu.cpu[CPU_KERNEL]) * tck_dividend); pvals[9] += (jlong)(((jlong)cpu.cpu[CPU_USER]) * tck_dividend); } else { pvals[7] += (jlong)(((jlong)cpu.cpu[CPU_IDLE]) * tck_dividend / tck_divisor); pvals[7] += (jlong)(((jlong)cpu.cpu[CPU_WAIT]) * tck_dividend / tck_divisor); pvals[8] += (jlong)(((jlong)cpu.cpu[CPU_KERNEL]) * tck_dividend / tck_divisor); pvals[9] += (jlong)(((jlong)cpu.cpu[CPU_USER]) * tck_dividend / tck_divisor); } } } } /* * The next two are not implemented yet for Solaris * inf[4] - Amount of shared memory * inf[5] - Memory used by buffers * */ } #elif defined(DARWIN) uint64_t mem_total; size_t len = sizeof(mem_total); vm_statistics_data_t vm_info; mach_msg_type_number_t info_count = HOST_VM_INFO_COUNT; sysctlbyname("hw.memsize", &mem_total, &len, NULL, 0); pvals[0] = (jlong)mem_total; host_statistics(mach_host_self (), HOST_VM_INFO, (host_info_t)&vm_info, &info_count); pvals[1] = (jlong)(((double)vm_info.free_count)*vm_page_size); pvals[6] = (jlong)(100 - (pvals[1] * 100 / mem_total)); rv = APR_SUCCESS; /* DARWIN */ #else rv = APR_ENOTIMPL; #endif (*e)->ReleaseLongArrayElements(e, inf, pvals, 0); return rv; }
void glibtop_get_mem_s (glibtop *server, glibtop_mem *buf) { kstat_ctl_t * const kc = server->machine->kc; kstat_t *ksp; kstat_named_t *kn; #undef PAGESIZE #define PAGESIZE (server->machine->pagesize) #define PAGESHIFT (PAGESIZE + 10) #ifdef _LP64 #define KN_VALUE kn->value.ui64 #elif !defined(KSTAT_DATA_UINT32) #define KN_VALUE kn->value.ul #else #define KN_VALUE kn->value.ui32 #endif memset (buf, 0, sizeof (glibtop_mem)); buf->total = (guint64) sysconf(_SC_PHYS_PAGES) << PAGESHIFT; buf->flags = (1 << GLIBTOP_MEM_TOTAL); if(!kc) return; switch(kstat_chain_update(kc)) { case -1: assert(0); /* Debugging purposes, shouldn't happen */ case 0: break; default: glibtop_get_kstats(server); } if((ksp = server->machine->syspages) && kstat_read(kc, ksp, NULL) >= 0) { kn = kstat_data_lookup(ksp, "pagesfree"); if(kn) { buf->free = (KN_VALUE << PAGESHIFT); buf->used = buf->total - buf->free; buf->flags |= (1 << GLIBTOP_MEM_FREE); buf->flags |= (1 << GLIBTOP_MEM_USED); } kn = kstat_data_lookup(ksp, "pageslocked"); if(kn) { buf->locked = (KN_VALUE << PAGESIZE); buf->flags |= (1 << GLIBTOP_MEM_LOCKED); } } /* Bunyip module provides data in multiples of system page size */ if((ksp = server->machine->bunyip) && kstat_read(kc, ksp, NULL) >= 0) { kn = kstat_data_lookup(ksp, "pages_exec"); if(kn) { buf->shared = (KN_VALUE << PAGESHIFT); buf->flags |= (1 << GLIBTOP_MEM_SHARED); } kn = kstat_data_lookup(ksp, "pages_vnode"); if(kn) { buf->buffer = (KN_VALUE << PAGESHIFT); buf->flags |= (1 << GLIBTOP_MEM_BUFFER); } kn = kstat_data_lookup(ksp, "pages_anon"); if(kn) { buf->user = (KN_VALUE << PAGESHIFT); buf->flags |= (1 << GLIBTOP_MEM_USER); } else goto user_old_way; } else /* Bunyip is not available, let's compute buf->user the old way */ { user_old_way: buf->user = buf->total - buf->free - buf->cached - buf->buffer; buf->flags |= (1 << GLIBTOP_MEM_USER); } }
int kupdate(int avenrun[3]) { kstat_t *ks; kid_t nkcid; int i; int changed = 0; static int ncpu = 0; static kid_t kcid = 0; kstat_named_t *kn; /* * 0. kstat_open */ if (!kc) { kc = kstat_open(); if (!kc) { perror("kstat_open "); return -1; } changed = 1; kcid = kc->kc_chain_id; } /* keep doing it until no more changes */ kcid_changed: /* * 1. kstat_chain_update */ nkcid = kstat_chain_update(kc); if (nkcid) { /* UPDKCID will abort if nkcid is -1, so no need to check */ changed = 1; kcid = nkcid; } UPDKCID(nkcid,0); ks = kstat_lookup(kc, "unix", 0, "system_misc"); if (kstat_read(kc, ks, 0) == -1) { perror("kstat_read"); return -1; } #if 0 /* load average */ kn = kstat_data_lookup(ks, "avenrun_1min"); if (kn) avenrun[0] = kn->value.ui32; kn = kstat_data_lookup(ks, "avenrun_5min"); if (kn) avenrun[1] = kn->value.ui32; kn = kstat_data_lookup(ks, "avenrun_15min"); if (kn) avenrun[2] = kn->value.ui32; /* nproc */ kn = kstat_data_lookup(ks, "nproc"); if (kn) { nproc = kn->value.ui32; #ifdef NO_NPROC if (nproc > maxprocs) reallocproc(2 * nproc); #endif } #endif if (changed) { int ncpus = 0; /* * 2. get data addresses */ ncpu = 0; kn = kstat_data_lookup(ks, "ncpus"); if (kn && kn->value.ui32 > ncpus) { ncpus = kn->value.ui32; cpu_ks = (kstat_t **)sge_realloc(cpu_ks, ncpus * sizeof(kstat_t *), 1); cpu_stat = (cpu_stat_t *)sge_realloc(cpu_stat, ncpus * sizeof(cpu_stat_t), 1); } for (ks = kc->kc_chain; ks; ks = ks->ks_next) { if (strncmp(ks->ks_name, "cpu_stat", 8) == 0) { nkcid = kstat_read(kc, ks, NULL); /* if kcid changed, pointer might be invalid */ UPDKCID(nkcid, kcid); cpu_ks[ncpu] = ks; ncpu++; if (ncpu >= ncpus) { break; } } } /* note that ncpu could be less than ncpus, but that's okay */ changed = 0; } /* * 3. get data */ for (i = 0; i < ncpu; i++) { nkcid = kstat_read(kc, cpu_ks[i], &cpu_stat[i]); /* if kcid changed, pointer might be invalid */ UPDKCID(nkcid, kcid); } /* return the number of cpus found */ return(ncpu); }
int updateMemory( void ) { long swaptotal; long swapfree; long swapused; #ifdef HAVE_KSTAT kstat_ctl_t *kctl; kstat_t *ksp; kstat_named_t *kdata; #endif /* HAVE_KSTAT */ swaptotal = swapused = swapfree = 0L; /* * Retrieve overall swap information from anonymous memory structure - * which is the same way "swap -s" retrieves it's statistics. * * swapctl(SC_LIST, void *arg) does not return what we are looking for. */ if (swapctl(SC_AINFO, &am_swap) == -1) return(0); swaptotal = am_swap.ani_max; swapused = am_swap.ani_resv; swapfree = swaptotal - swapused; totalswap = pagetok(swaptotal); freeswap = pagetok(swapfree); #ifdef HAVE_KSTAT /* * get a kstat handle and update the user's kstat chain */ if( (kctl = kstat_open()) == NULL ) return( 0 ); while( kstat_chain_update( kctl ) != 0 ) ; totalmem = pagetok( sysconf( _SC_PHYS_PAGES )); /* * traverse the kstat chain to find the appropriate statistics */ if( (ksp = kstat_lookup( kctl, "unix", 0, "system_pages" )) == NULL ) return( 0 ); if( kstat_read( kctl, ksp, NULL ) == -1 ) return( 0 ); /* * lookup the data */ kdata = (kstat_named_t *) kstat_data_lookup( ksp, "freemem" ); if( kdata != NULL ) freemem = pagetok( kdata->value.ui32 ); kstat_close( kctl ); #endif /* ! HAVE_KSTAT */ Dirty = 0; return( 0 ); }
static void update_cpu_kstat_counters() { if(kstat_chain_update(kstat_ctrl) != 0) { free(cpu_loads); map_cpu_kstat_counters(); } }
void CPU_Load_Monitor::access_kstats (unsigned long *which_idle) { this->kstats_ = kstat_open (); if (this->kstats_ == 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("opening kstats file failed\n"))); return; } this->kstat_id_ = this->kstats_->kc_chain_id; while (true) { this->kernel_ = 0UL; this->wait_ = 0UL; this->user_ = 0UL; (*which_idle) = 0UL; /// Unlike Linux's "/proc/stat", there is no entry for total CPU /// stats, so we have to sum them manually. for (this->kstat_ = this->kstats_->kc_chain; this->kstat_ != 0; this->kstat_ = this->kstat_->ks_next) { int result = ACE_OS::strncmp (this->kstat_->ks_name, "cpu_stat", ACE_OS::strlen ("cpu_stat")); if (result == 0) { /// Because the kstat chain can change dynamically, /// watch the chain ID and restart the walk if the ID /// differs from what we saw during the walk. The restart /// is done by breaking from the cycle with kstat_ not 0. kid_t kstat_id = kstat_read (this->kstats_, this->kstat_, 0); if (kstat_id != this->kstat_id_) { break; } cpu_stat_t &kstat_cpu = *((cpu_stat_t *) this->kstat_->ks_data); this->kernel_ += kstat_cpu.cpu_sysinfo.cpu[CPU_KERNEL]; this->wait_ += kstat_cpu.cpu_sysinfo.cpu[CPU_WAIT]; this->user_ += kstat_cpu.cpu_sysinfo.cpu[CPU_USER]; (*which_idle) += kstat_cpu.cpu_sysinfo.cpu[CPU_IDLE]; } } if (this->kstat_ != 0) { /// The ID changed underneath us, so get the new one and /// start again. this->kstat_id_ = kstat_chain_update (this->kstats_); if (! this->kstat_id_ > 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("kstat chain update ") ACE_TEXT ("returned null id\n"))); return; } } else { /// Clean run, exit the WHILE loop. break; } } int status = kstat_close (this->kstats_); if (status != 0) { ACE_ERROR ((LM_ERROR, ACE_TEXT ("closing kstats file failed\n"))); } }
static ERL_NIF_TERM update_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { ks_returner_t *ret; kstat_raw_reader_t save_raw = NULL; ks_handle_t *handle; kid_t id; ks_instance_t *ksi, *ktmp; ks_nvpair_t *nvpair, *ntmp; kstat_t *kp; int count = 0; ret = new_returner(env); if (argc < 1) { return EKSTAT_RETURN(enif_make_badarg(ret->env)); } if (!enif_get_resource(env, argv[0], kstat_handle, (void **)(&handle))) { return EKSTAT_RETURN(enif_make_badarg(ret->env)); } if ((id = kstat_chain_update(handle->ks_ctl)) == 0 && handle->ks_id != -1) { return EKSTAT_RETURN(EKSTAT_ERROR("kstat_chain_update stopped")); } if (id == -1) { return EKSTAT_RETURN(EKSTAT_ERROR("kid not valid")); } /* Free the instances list */ ksi = list_head(&handle->instances_list); while (ksi != NULL) { nvpair = list_head(&ksi->ks_nvlist); while (nvpair != NULL) { ntmp = nvpair; nvpair = list_next(&ksi->ks_nvlist, nvpair); list_remove(&ksi->ks_nvlist, ntmp); if (ntmp->data_type == KSTAT_DATA_STRING) free(ntmp->value.str.addr.ptr); free(ntmp); } ktmp = ksi; ksi = list_next(&handle->instances_list, ksi); list_remove(&handle->instances_list, ktmp); list_destroy(&ktmp->ks_nvlist); free(ktmp); } for (kp = handle->ks_ctl->kc_chain; kp != NULL; kp = kp->ks_next) { /* Don't bother storing the kstat headers */ if (strncmp(kp->ks_name, "kstat_", 6) == 0) { continue; } /* Don't bother storing raw stats we don't understand */ if (kp->ks_type == KSTAT_TYPE_RAW) { save_raw = lookup_raw_kstat_fn(kp->ks_module, kp->ks_name); if (save_raw == NULL) { continue; } } /* * Allocate a new instance and fill in the values * we know so far. */ ksi = (ks_instance_t *)(malloc(sizeof (ks_instance_t))); if (ksi == NULL) { return EKSTAT_RETURN(EKSTAT_ERROR("ks_instance_t malloc")); } list_link_init(&ksi->ks_next); (void) strlcpy(ksi->ks_module, kp->ks_module, KSTAT_STRLEN); (void) strlcpy(ksi->ks_name, kp->ks_name, KSTAT_STRLEN); (void) strlcpy(ksi->ks_class, kp->ks_class, KSTAT_STRLEN); ksi->ks_instance = kp->ks_instance; ksi->ks_snaptime = kp->ks_snaptime; ksi->ks_type = kp->ks_type; list_create(&ksi->ks_nvlist, sizeof (ks_nvpair_t), offsetof(ks_nvpair_t, nv_next)); SAVE_HRTIME_X(ret, ksi, "crtime", kp->ks_crtime); SAVE_HRTIME_X(ret, ksi, "snaptime", kp->ks_snaptime); /* Insert this instance into a sorted list */ ktmp = list_head(&handle->instances_list); while (ktmp != NULL && compare_instances(ksi, ktmp) < 0) { ktmp = list_next(&handle->instances_list, ktmp); } list_insert_before(&handle->instances_list, ktmp, ksi); /* Read the actual statistics */ id = kstat_read(handle->ks_ctl, kp, NULL); if (id == -1) { continue; } switch (kp->ks_type) { case KSTAT_TYPE_RAW: save_raw(ret, kp, ksi); break; case KSTAT_TYPE_NAMED: save_named(ret, kp, ksi); break; case KSTAT_TYPE_INTR: save_intr(ret, kp, ksi); break; case KSTAT_TYPE_IO: save_io(ret, kp, ksi); break; case KSTAT_TYPE_TIMER: save_timer(ret, kp, ksi); break; default: assert(B_FALSE); /* Invalid type */ break; } count++; } return EKSTAT_RETURN(EKSTAT_OK(EKSTAT_INT(count))); }
int updateSwap( int upd ) { long swaptotal; long swapfree; long swapused; #ifdef HAVE_KSTAT kstat_ctl_t *kctl; kstat_t *ksp; struct timeval sampling; vminfo_t vmi; uint64_t _swap_resv = 0; uint64_t _swap_free = 0; uint64_t _swap_avail = 0; uint64_t _swap_alloc = 0; #endif /* HAVE_KSTAT */ swaptotal = swapused = swapfree = 0L; #ifndef HAVE_KSTAT /* * Retrieve overall swap information from anonymous memory structure - * which is the same way "swap -s" retrieves it's statistics. * * swapctl(SC_LIST, void *arg) does not return what we are looking for. */ if (swapctl(SC_AINFO, &am_swap) == -1) return(0); swaptotal = am_swap.ani_max; swapused = am_swap.ani_resv; swapfree = swaptotal - swapused; usedswap = pagetok(swapused); freeswap = pagetok(swapfree); #else /* HAVE_KSTAT */ /* * get a kstat handle and update the user's kstat chain */ if( (kctl = kstat_open()) == NULL ) return( 0 ); while( kstat_chain_update( kctl ) != 0 ) ; totalmem = pagetok( sysconf( _SC_PHYS_PAGES )); if( (ksp = kstat_lookup( kctl, "unix", -1, "vminfo" )) == NULL ) { goto done; } if( kstat_read( kctl, ksp, &vmi ) == -1 ) { goto done; } _swap_resv = vmi.swap_resv - swap_resv; if (_swap_resv) swap_resv = vmi.swap_resv; _swap_free = vmi.swap_free - swap_free; if (_swap_free) swap_free = vmi.swap_free; _swap_avail = vmi.swap_avail - swap_avail; if (_swap_avail) swap_avail = vmi.swap_avail; _swap_alloc = vmi.swap_alloc - swap_alloc; if (_swap_alloc) swap_alloc = vmi.swap_alloc; if (upd) { long timeInterval; gettimeofday(&sampling, 0); timeInterval = sampling.tv_sec - lastSampling.tv_sec + ( sampling.tv_usec - lastSampling.tv_usec ) / 1000000.0; lastSampling = sampling; timeInterval = timeInterval > 0 ? timeInterval : 1; _swap_resv = _swap_resv / timeInterval; _swap_free = _swap_free / timeInterval; _swap_avail = _swap_avail / timeInterval; _swap_alloc = _swap_alloc / timeInterval; if (_swap_alloc) usedswap = pagetok((unsigned long)(_swap_alloc + _swap_free - _swap_avail)); /* * Assume minfree = totalmem / 8, i.e. it has not been tuned */ if (_swap_avail) freeswap = pagetok((unsigned long)(_swap_avail + totalmem / 8)); } done: kstat_close( kctl ); #endif /* ! HAVE_KSTAT */ return( 0 ); }
int main(int argc, char **argv) { ks_selector_t *nselector; ks_selector_t *uselector; kstat_ctl_t *kc; hrtime_t start_n; hrtime_t period_n; boolean_t errflg = B_FALSE; boolean_t nselflg = B_FALSE; boolean_t uselflg = B_FALSE; char *q; int count = 1; int infinite_cycles = 0; int interval = 0; int n = 0; int c, m, tmp; (void) setlocale(LC_ALL, ""); #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it wasn't */ #endif (void) textdomain(TEXT_DOMAIN); /* * Create the selector list and a dummy default selector to match * everything. While we process the cmdline options we will add * selectors to this list. */ list_create(&selector_list, sizeof (ks_selector_t), offsetof(ks_selector_t, ks_next)); nselector = new_selector(); /* * Parse named command line arguments. */ while ((c = getopt(argc, argv, "h?Cqjlpx:H:T:m:i:n:s:c:")) != EOF) switch (c) { case 'h': case '?': usage(); exit(0); break; case 'C': g_pflg = g_cflg = B_TRUE; break; case 'q': g_qflg = B_TRUE; break; case 'j': g_jflg = B_TRUE; break; case 'l': g_pflg = g_lflg = B_TRUE; break; case 'H': g_host = B_TRUE; tachyon_host = (char *)ks_safe_strdup(optarg); break; case 'x': g_url = g_pflg = g_nflg = B_TRUE; // If we use nsq we need to init curl globaly. tm_curl_global_init(); tachyon_url = (char *)ks_safe_strdup(optarg); break; case 'p': g_pflg = B_TRUE; break; case 'T': switch (*optarg) { case 'd': g_timestamp_fmt = DDATE; break; case 'u': g_timestamp_fmt = UDATE; break; default: errflg = B_TRUE; } break; case 'm': nselflg = B_TRUE; nselector->ks_module.pstr = (char *)ks_safe_strdup(optarg); break; case 'i': nselflg = B_TRUE; nselector->ks_instance.pstr = (char *)ks_safe_strdup(optarg); break; case 'n': nselflg = B_TRUE; nselector->ks_name.pstr = (char *)ks_safe_strdup(optarg); break; case 's': nselflg = B_TRUE; nselector->ks_statistic.pstr = (char *)ks_safe_strdup(optarg); break; case 'c': g_ks_class.pstr = (char *)ks_safe_strdup(optarg); break; default: errflg = B_TRUE; break; } if (g_qflg && (g_jflg || g_pflg || g_nflg)) { (void) fprintf(stderr, gettext( "-q and -lpjn are mutually exclusive\n")); errflg = B_TRUE; } if (g_url ^ g_host) { (void) fprintf(stderr, gettext( "-H and -x must both be set.\n")); errflg = B_TRUE; } if (errflg) { usage(); exit(2); } argc -= optind; argv += optind; /* * Consume the rest of the command line. Parsing the * unnamed command line arguments. */ while (argc--) { errno = 0; tmp = strtoul(*argv, &q, 10); if (tmp == ULONG_MAX && errno == ERANGE) { if (n == 0) { (void) fprintf(stderr, gettext( "Interval is too large\n")); } else if (n == 1) { (void) fprintf(stderr, gettext( "Count is too large\n")); } usage(); exit(2); } if (errno != 0 || *q != '\0') { m = 0; uselector = new_selector(); while ((q = (char *)strsep(argv, ":")) != NULL) { m++; if (m > 4) { free(uselector); usage(); exit(2); } if (*q != '\0') { switch (m) { case 1: uselector->ks_module.pstr = (char *)ks_safe_strdup(q); break; case 2: uselector->ks_instance.pstr = (char *)ks_safe_strdup(q); break; case 3: uselector->ks_name.pstr = (char *)ks_safe_strdup(q); break; case 4: uselector->ks_statistic.pstr = (char *)ks_safe_strdup(q); break; default: assert(B_FALSE); } } } uselflg = B_TRUE; list_insert_tail(&selector_list, uselector); } else { if (tmp < 1) { if (n == 0) { (void) fprintf(stderr, gettext( "Interval must be an " "integer >= 1")); } else if (n == 1) { (void) fprintf(stderr, gettext( "Count must be an integer >= 1")); } usage(); exit(2); } else { if (n == 0) { interval = tmp; count = -1; } else if (n == 1) { count = tmp; } else { usage(); exit(2); } } n++; } argv++; } /* * Check if we founded a named selector on the cmdline. */ if (uselflg) { if (nselflg) { (void) fprintf(stderr, gettext( "[module[:instance[:name[:statistic]]]] and " "-m -i -n -s are mutually exclusive")); usage(); exit(2); } else { free(nselector); } } else { list_insert_tail(&selector_list, nselector); } assert(!list_is_empty(&selector_list)); list_create(&instances_list, sizeof (ks_instance_t), offsetof(ks_instance_t, ks_next)); while ((kc = kstat_open()) == NULL) { if (errno == EAGAIN) { (void) poll(NULL, 0, 200); } else { perror("kstat_open"); exit(3); } } if (count > 1) { if (signal(SIGCONT, cont_handler) == SIG_ERR) { (void) fprintf(stderr, gettext( "signal failed")); exit(3); } } period_n = (hrtime_t)interval * NANOSEC; start_n = gethrtime(); while (count == -1 || count-- > 0) { ks_instances_read(kc); kstat_time = time(NULL); ks_instances_print(); if (interval && count) { ks_sleep_until(&start_n, period_n, infinite_cycles, &caught_cont); (void) kstat_chain_update(kc); if (! g_nflg) (void) putchar('\n'); } } (void) kstat_close(kc); return (g_matched); }
/* * Load the latest CPU usage statistics */ int netsnmp_cpu_arch_load( netsnmp_cache *cache, void *magic ) { int i=1; kstat_t *ksp; cpu_stat_t cs; netsnmp_cpu_info *cpu = netsnmp_cpu_get_byIdx( -1, 0 ); netsnmp_cpu_info *cpu2; /* Clear overall stats, ready for summing individual CPUs */ cpu->user_ticks = 0; cpu->idle_ticks = 0; cpu->kern_ticks = 0; cpu->wait_ticks = 0; cpu->sys2_ticks = 0; cpu->swapIn = 0; cpu->swapOut = 0; cpu->nInterrupts = 0; cpu->nCtxSwitches = 0; kstat_chain_update( kstat_fd ); DEBUGMSGTL(("cpu", "cpu_kstat load\n ")); for (ksp = kstat_fd->kc_chain; ksp != NULL; ksp = ksp->ks_next) { if (ksp->ks_flags & KSTAT_FLAG_INVALID) continue; if (strcmp(ksp->ks_module, "cpu_stat") == 0) { i = ksp->ks_instance; cpu2 = netsnmp_cpu_get_byIdx( i, 0 ); if ( !cpu2 ) break; /* or continue ? */ /* Skip new CPUs */ if ((ksp->ks_type != KSTAT_TYPE_RAW) || (ksp->ks_data_size != sizeof(cs))|| (kstat_read(kstat_fd, ksp, &cs) == -1)) { DEBUGMSGTL(("cpu", "cpu_kstat load failed (%d)\n ", i)); break; /* or continue ? */ } cpu2->user_ticks = (unsigned long long)cs.cpu_sysinfo.cpu[CPU_USER]; cpu2->idle_ticks = (unsigned long long)cs.cpu_sysinfo.cpu[CPU_IDLE]; cpu2->kern_ticks = (unsigned long long)cs.cpu_sysinfo.cpu[CPU_KERNEL]; cpu2->wait_ticks = (unsigned long long)cs.cpu_sysinfo.cpu[CPU_WAIT]; /* or cs.cpu_sysinfo.wait[W_IO]+cs.cpu_sysinfo.wait[W_PIO] */ cpu2->sys2_ticks = (unsigned long long)cpu2->kern_ticks+cpu2->wait_ticks; /* nice_ticks, intrpt_ticks, sirq_ticks unused */ /* sum these for the overall stats */ cpu->user_ticks += (unsigned long long)cs.cpu_sysinfo.cpu[CPU_USER]; cpu->idle_ticks += (unsigned long long)cs.cpu_sysinfo.cpu[CPU_IDLE]; cpu->kern_ticks += (unsigned long long)cs.cpu_sysinfo.cpu[CPU_KERNEL]; cpu->wait_ticks += (unsigned long long)cs.cpu_sysinfo.cpu[CPU_WAIT]; /* or cs.cpu_sysinfo.wait[W_IO]+cs.cpu_sysinfo.wait[W_PIO] */ cpu->sys2_ticks += (unsigned long long)cpu2->kern_ticks+cpu2->wait_ticks; /* * Interrupt/Context Switch statistics * XXX - Do these really belong here ? */ cpu->swapIn += (unsigned long long)cs.cpu_vminfo.swapin; cpu->swapOut += (unsigned long long)cs.cpu_vminfo.swapout; cpu->pageIn += (unsigned long long)cs.cpu_sysinfo.bread; cpu->pageOut += (unsigned long long)cs.cpu_sysinfo.bwrite; cpu->nInterrupts += (unsigned long long)cs.cpu_sysinfo.intr; cpu->nCtxSwitches += (unsigned long long)cs.cpu_sysinfo.pswitch; } } return 0; }
void KMemoryWidget::update() { kstat_ctl_t *kctl; kstat_t *ksp; kstat_named_t *kdata; /* * get a kstat handle first and update the user's kstat chain */ if( (kctl = kstat_open()) == NULL ) return; while( kstat_chain_update( kctl ) != 0 ) ; /* * traverse the kstat chain to find the appropriate kstat */ if( (ksp = kstat_lookup( kctl, "unix", 0, "system_pages" )) == NULL ) return; if( kstat_read( kctl, ksp, NULL ) == -1 ) return; /* * lookup the data */ #if 0 kdata = (kstat_named_t *) kstat_data_lookup( ksp, "physmem" ); if( kdata != NULL ) { Memory_Info[TOTAL_MEM] = PAGETOK(kdata->value.ui32); } #endif Memory_Info[TOTAL_MEM] = PAGETOK(sysconf(_SC_PHYS_PAGES)); kdata = (kstat_named_t *) kstat_data_lookup( ksp, "freemem" ); if( kdata != NULL ) Memory_Info[FREE_MEM] = PAGETOK(kdata->value.ui32); #ifdef __GNUC__ #warning "FIXME: Memory_Info[CACHED_MEM]" #endif Memory_Info[CACHED_MEM] = NO_MEMORY_INFO; // cached memory in ram kstat_close( kctl ); /* * Swap Info */ struct anoninfo am_swap; long swaptotal; long swapfree; long swapused; swaptotal = swapused = swapfree = 0L; /* * Retrieve overall swap information from anonymous memory structure - * which is the same way "swap -s" retrieves it's statistics. * * swapctl(SC_LIST, void *arg) does not return what we are looking for. */ if (swapctl(SC_AINFO, &am_swap) == -1) return; swaptotal = am_swap.ani_max; swapused = am_swap.ani_resv; swapfree = swaptotal - swapused; Memory_Info[SWAP_MEM] = PAGETOK(swaptotal); Memory_Info[FREESWAP_MEM] = PAGETOK(swapfree); }