SPDP dtime(void) { SPDP q; int secs, msecs; u32_t system_hz; times(&tms); getsysinfo_up(PM_PROC_NR, SIU_SYSTEMHZ, sizeof(system_hz), &system_hz); secs = tms.tms_utime / system_hz; q = secs; tms.tms_utime -= secs * system_hz; msecs = tms.tms_utime * 100 / system_hz; q += (float) msecs * 0.01; return q; }
int main(int argc, char *argv[]) { int r, c, s = 0, orig; getsysinfo_up(PM_PROC_NR, SIU_SYSTEMHZ, sizeof(system_hz), &system_hz); init(&r); while((c=getopt(argc, argv, "s:B")) != EOF) { switch(c) { case 's': s = atoi(optarg); break; case 'B': blockedverbose = 1; break; default: fprintf(stderr, "Usage: %s [-s<secdelay>] [-B]\n", argv[0]); return 1; } } if(s < 1) s = 2; /* Catch window size changes so display is updated properly * right away. */ signal(SIGWINCH, sigwinch); while(1) { fd_set fds; int ns; struct timeval tv; showtop(r); tv.tv_sec = s; tv.tv_usec = 0; FD_ZERO(&fds); FD_SET(STDIN_FILENO, &fds); if((ns=select(STDIN_FILENO+1, &fds, NULL, NULL, &tv)) < 0 && errno != EINTR) { perror("select"); sleep(1); } if(ns > 0 && FD_ISSET(STDIN_FILENO, &fds)) { char c; if(read(STDIN_FILENO, &c, 1) == 1) { switch(c) { case 'q': return 0; break; } } } } return 0; }
/* Retrieve system load average information. */ int getloadavg(double *loadavg, int nelem) { struct loadinfo loadinfo; static u32_t system_hz = 0; int h, p, unfilled_ticks; #define PERIODS 3 int minutes[3] = { 1, 5, 15 }; size_t loadsize; ssize_t l; if(nelem < 1) { errno = ENOSPC; return -1; } if(system_hz == 0) { if((getsysinfo_up(PM_PROC_NR, SIU_SYSTEMHZ, sizeof(system_hz), &system_hz)) < 0) { system_hz = DEFAULT_HZ; } } loadsize = sizeof(loadinfo); if((l=getsysinfo_up(PM_PROC_NR, SIU_LOADINFO, loadsize, &loadinfo)) < 0) return -1; if(l != sizeof(loadinfo)) return -1; if(nelem > PERIODS) nelem = PERIODS; /* How many ticks are missing from the newest-filled slot? */ #define TICKSPERSLOT (_LOAD_UNIT_SECS * system_hz) unfilled_ticks = TICKSPERSLOT - (loadinfo.last_clock % TICKSPERSLOT); for(p = 0; p < nelem; p++) { int h, offset, slots; double l = 0.0; int latest = loadinfo.proc_last_slot; slots = minutes[p] * 60 / _LOAD_UNIT_SECS; /* Add up the total number of process ticks for this number * of minutes (minutes[p]). Start with the newest slot, which * is latest, and count back for the number of slots that * correspond to the right number of minutes. Take wraparound * into account by calculating the index modulo _LOAD_HISTORY, * which is the number of slots of history kept. */ for(h = 0; h < slots; h++) { int slot; slot = (latest - h + _LOAD_HISTORY) % _LOAD_HISTORY; l += (double) loadinfo.proc_load_history[slot]; } /* The load average over this number of minutes is the number of * process-ticks divided by the number of ticks, not counting the * number of ticks the last slot hasn't been around yet. */ loadavg[p] = l / (slots * TICKSPERSLOT - unfilled_ticks); } return nelem; }
int main(int argc, char*argv[]) { char *ipstat_device; int fd, i, r; char *query, *pval; size_t len; struct timeval uptime; clock_t now; int fl; int a_flag, n_flag, v_flag; struct tms tmsbuf; getsysinfo_up(PM_PROC_NR, SIU_SYSTEMHZ, sizeof(system_hz), &system_hz); (prog_name=strrchr(argv[0], '/')) ? prog_name++ : (prog_name=argv[0]); a_flag= 0; n_flag= 0; v_flag= 0; while ((fl= getopt(argc, argv, "?anv")) != -1) { switch(fl) { case '?': usage(); case 'a': a_flag= 1; break; case 'n': n_flag= 1; break; case 'v': v_flag= 1; break; default: fprintf(stderr, "%s: getopt failed: '%c'\n", prog_name, fl); exit(1); } } inclListen= !!a_flag; numerical= !!n_flag; verbose= !!v_flag; ipstat_device= IPSTAT_DEVICE; if ((fd= open(ipstat_device, O_RDWR)) == -1) { fprintf(stderr, "%s: unable to open '%s': %s\n", prog_name, ipstat_device, strerror(errno)); exit(1); } query= "tcp_conn_table"; len= strlen(query); r= write(fd, query, len); if (r != len) { fprintf(stderr, "%s: write to %s failed: %s\n", prog_name, ipstat_device, r < 0 ? strerror(errno) : "short write"); exit(1); } r= read(fd, values, sizeof(values)); if (r == -1) { fprintf(stderr, "%s: read from %s failed: %s\n", prog_name, ipstat_device, strerror(errno)); exit(1); } pval= values; if (paramvalue(&pval, tcp_conn_table, sizeof(tcp_conn_table)) != sizeof(tcp_conn_table)) { fprintf(stderr, "%s: unable to decode the results from queryparam\n", prog_name); exit(1); } #ifdef __minix_vmd /* Get the uptime in clock ticks. */ if (sysutime(UTIME_UPTIME, &uptime) == -1) { fprintf(stderr, "%s: sysutime failed: %s\n", prog_name, strerror(errno)); exit(1); } now= uptime.tv_sec * HZ + (uptime.tv_usec*HZ/1000000); #else /* Minix 3 */ now= times(&tmsbuf); #endif for (i= 0; i<TCP_CONN_NR; i++) print_conn(i, now); exit(0); }