static void test_bytetok_5(void **state)
{
char *delims = " ,.;:-!";
unsigned char *pby = NULL;
int tok_len, delim_len, offset;
struct bytes *bytes = *state;
tok_len = delim_len = offset = 0;
pby = bytetok(bytes->data, bytes->len, delims,
offset, &tok_len, &delim_len);
assert_true(*pby == 'h');
assert_true(tok_len == 5);
offset = (tok_len + delim_len);
pby = bytetok(bytes->data, bytes->len, delims,
offset, &tok_len, &delim_len);
assert_true(pby == NULL);
}
void
get_system_info(struct system_info * si)
{
long total;
/* get process id of the last process */
(void) getkval(nlst[X_MPID].n_value, &(si->last_pid),
sizeof(si->last_pid),
nlst[X_MPID].n_name);
/* get the cp_time array */
(void) getkval(nlst[X_SYSINFO].n_value, (int *) cp_time, sizeof(cp_time),
nlst[X_SYSINFO].n_name);
/* convert cp_time counts to persentages */
total = percentages(CPUSTATES, cpu_states, cp_time, cp_old, cp_diff);
/* sum memory statistics */
(void) getkval(nlst[X_PHYSMEM].n_value, &memory_stats[0],
sizeof(memory_stats[0]), nlst[X_PHYSMEM].n_name);
(void) getkval(nlst[X_MAXMEM].n_value, &memory_stats[1],
sizeof(memory_stats[1]), nlst[X_MAXMEM].n_name);
(void) getkval(nlst[X_FREEMEM].n_value, &memory_stats[2],
sizeof(memory_stats[2]), nlst[X_FREEMEM].n_name);
(void) getkval(nlst[X_AVAILRMEM].n_value, &memory_stats[3],
sizeof(memory_stats[3]), nlst[X_AVAILRMEM].n_name);
(void) getkval(nlst[X_AVAILSMEM].n_value, &memory_stats[4],
sizeof(memory_stats[4]), nlst[X_AVAILSMEM].n_name);
(void) getkval(nlst[X_NSWAP].n_value, &memory_stats[5],
sizeof(memory_stats[5]), nlst[X_NSWAP].n_name);
memory_stats[0] = bytetok(ctob(memory_stats[0])); /* clicks -> bytes */
memory_stats[1] = bytetok(ctob(memory_stats[1])); /* clicks -> bytes */
memory_stats[2] = bytetok(ctob(memory_stats[2])); /* clicks -> bytes */
memory_stats[3] = bytetok(memory_stats[3] * NBPP); /* # bytes per page */
memory_stats[4] = bytetok(memory_stats[4] * NBPP); /* # bytes per page */
memory_stats[5] = bytetok(memory_stats[5] * NBPSCTR); /* # bytes per sector */
/* set arrays and strings */
/*
* Note: we keep memory_stats as an unsigned long to avoid sign extension
* problems when shifting in bytetok. But the module interface requires an
* array of signed longs. So we just cast the pointer here and hope for
* the best. --wnl
*/
si->cpustates = cpu_states;
si->memory = (long *) memory_stats;
tab_avenrun(si->load_avg); /* philiph */
}
static void
read_one_proc_stat(pid_t pid, struct top_proc * proc, struct process_select * sel)
{
char buffer[4096],
*p,
*q;
int fd,
len;
int fullcmd;
char value[BUFFERLEN + 1];
/* if anything goes wrong, we return with proc->state == 0 */
proc->state = 0;
/* full cmd handling */
fullcmd = sel->fullcmd;
if (fullcmd == 1)
{
sprintf(buffer, "%d/cmdline", pid);
if ((fd = open(buffer, O_RDONLY)) != -1)
{
/* read command line data */
/* (theres no sense in reading more than we can fit) */
if ((len = read(fd, buffer, MAX_COLS)) > 1)
{
buffer[len] = '\0';
xfrm_cmdline(buffer, len);
update_procname(proc, buffer);
}
else
{
fullcmd = 0;
}
close(fd);
}
else
{
fullcmd = 0;
}
}
/* grab the proc stat info in one go */
sprintf(buffer, "%d/stat", pid);
fd = open(buffer, O_RDONLY);
len = read(fd, buffer, sizeof(buffer) - 1);
close(fd);
buffer[len] = '\0';
proc->uid = (uid_t) proc_owner((int) pid);
/* parse out the status, described in 'man proc' */
/* skip pid and locate command, which is in parentheses */
if ((p = strchr(buffer, '(')) == NULL)
{
return;
}
if ((q = strrchr(++p, ')')) == NULL)
{
return;
}
/* set the procname */
*q = '\0';
if (!fullcmd)
{
update_procname(proc, p);
}
/* scan the rest of the line */
p = q + 1;
p = skip_ws(p);
switch (*p++) /* state */
{
case 'R':
proc->state = 1;
break;
case 'S':
proc->state = 2;
break;
case 'D':
proc->state = 3;
break;
case 'Z':
proc->state = 4;
break;
case 'T':
proc->state = 5;
break;
case 'W':
proc->state = 6;
break;
case '\0':
return;
}
p = skip_token(p); /* skip ppid */
p = skip_token(p); /* skip pgrp */
p = skip_token(p); /* skip session */
p = skip_token(p); /* skip tty nr */
p = skip_token(p); /* skip tty pgrp */
p = skip_token(p); /* skip flags */
p = skip_token(p); /* skip min flt */
p = skip_token(p); /* skip cmin flt */
p = skip_token(p); /* skip maj flt */
p = skip_token(p); /* skip cmaj flt */
proc->time = strtoul(p, &p, 10); /* utime */
proc->time += strtoul(p, &p, 10); /* stime */
p = skip_token(p); /* skip cutime */
p = skip_token(p); /* skip cstime */
proc->pri = strtol(p, &p, 10); /* priority */
proc->nice = strtol(p, &p, 10); /* nice */
p = skip_token(p); /* skip num_threads */
p = skip_token(p); /* skip itrealvalue, 0 */
proc->start_time = strtoul(p, &p, 10); /* start_time */
proc->size = bytetok(strtoul(p, &p, 10)); /* vsize */
proc->rss = pagetok(strtoul(p, &p, 10)); /* rss */
#if 0
/* for the record, here are the rest of the fields */
p = skip_token(p); /* skip rlim */
p = skip_token(p); /* skip start_code */
p = skip_token(p); /* skip end_code */
p = skip_token(p); /* skip start_stack */
p = skip_token(p); /* skip esp */
p = skip_token(p); /* skip eip */
p = skip_token(p); /* skip signal */
p = skip_token(p); /* skip sigblocked */
p = skip_token(p); /* skip sigignore */
p = skip_token(p); /* skip sigcatch */
p = skip_token(p); /* skip wchan */
p = skip_token(p); /* skip nswap, not maintained */
p = skip_token(p); /* exit signal */
p = skip_token(p); /* processor */
p = skip_token(p); /* rt_priority */
p = skip_token(p); /* policy */
p = skip_token(p); /* delayacct_blkio_ticks */
#endif
/* Get the io stats. */
sprintf(buffer, "%d/io", pid);
fd = open(buffer, O_RDONLY);
if (fd == -1)
{
/*
* CONFIG_TASK_IO_ACCOUNTING is not enabled in the Linux kernel or
* this version of Linux may not support collecting i/o statistics
* per pid. Report 0's.
*/
proc->rchar = 0;
proc->wchar = 0;
proc->syscr = 0;
proc->syscw = 0;
proc->read_bytes = 0;
proc->write_bytes = 0;
proc->cancelled_write_bytes = 0;
return;
}
len = read(fd, buffer, sizeof(buffer) - 1);
close(fd);
buffer[len] = '\0';
p = buffer;
GET_VALUE(proc->rchar);
GET_VALUE(proc->wchar);
GET_VALUE(proc->syscr);
GET_VALUE(proc->syscw);
GET_VALUE(proc->read_bytes);
GET_VALUE(proc->write_bytes);
GET_VALUE(proc->cancelled_write_bytes);
}
void
get_system_info(struct system_info * info)
{
char buffer[4096 + 1];
int fd,
len;
char *p;
/* get load averages */
if ((fd = open("loadavg", O_RDONLY)) != -1)
{
if ((len = read(fd, buffer, sizeof(buffer) - 1)) > 0)
{
buffer[len] = '\0';
info->load_avg[0] = strtod(buffer, &p);
info->load_avg[1] = strtod(p, &p);
info->load_avg[2] = strtod(p, &p);
p = skip_token(p); /* skip running/tasks */
p = skip_ws(p);
if (*p)
{
info->last_pid = atoi(p);
}
else
{
info->last_pid = -1;
}
}
close(fd);
}
/* get the cpu time info */
if ((fd = open("stat", O_RDONLY)) != -1)
{
if ((len = read(fd, buffer, sizeof(buffer) - 1)) > 0)
{
buffer[len] = '\0';
p = skip_token(buffer); /* "cpu" */
cp_time[0] = strtoul(p, &p, 0);
cp_time[1] = strtoul(p, &p, 0);
cp_time[2] = strtoul(p, &p, 0);
cp_time[3] = strtoul(p, &p, 0);
if (show_iowait)
{
cp_time[4] = strtoul(p, &p, 0);
}
/* convert cp_time counts to percentages */
percentages(NCPUSTATES, cpu_states, cp_time, cp_old, cp_diff);
}
close(fd);
}
/* get system wide memory usage */
if ((fd = open("meminfo", O_RDONLY)) != -1)
{
char *p;
int mem = 0;
int swap = 0;
unsigned long memtotal = 0;
unsigned long memfree = 0;
unsigned long swaptotal = 0;
if ((len = read(fd, buffer, sizeof(buffer) - 1)) > 0)
{
buffer[len] = '\0';
p = buffer - 1;
/* iterate thru the lines */
while (p != NULL)
{
p++;
if (p[0] == ' ' || p[0] == '\t')
{
/* skip */
}
else if (strncmp(p, "Mem:", 4) == 0)
{
p = skip_token(p); /* "Mem:" */
p = skip_token(p); /* total memory */
memory_stats[MEMUSED] = strtoul(p, &p, 10);
memory_stats[MEMFREE] = strtoul(p, &p, 10);
memory_stats[MEMSHARED] = strtoul(p, &p, 10);
memory_stats[MEMBUFFERS] = strtoul(p, &p, 10);
memory_stats[MEMCACHED] = strtoul(p, &p, 10);
memory_stats[MEMUSED] = bytetok(memory_stats[MEMUSED]);
memory_stats[MEMFREE] = bytetok(memory_stats[MEMFREE]);
memory_stats[MEMSHARED] = bytetok(memory_stats[MEMSHARED]);
memory_stats[MEMBUFFERS] =
bytetok(memory_stats[MEMBUFFERS]);
memory_stats[MEMCACHED] = bytetok(memory_stats[MEMCACHED]);
mem = 1;
}
else if (strncmp(p, "Swap:", 5) == 0)
{
p = skip_token(p); /* "Swap:" */
p = skip_token(p); /* total swap */
swap_stats[SWAPUSED] = strtoul(p, &p, 10);
swap_stats[SWAPFREE] = strtoul(p, &p, 10);
swap_stats[SWAPUSED] = bytetok(swap_stats[SWAPUSED]);
swap_stats[SWAPFREE] = bytetok(swap_stats[SWAPFREE]);
swap = 1;
}
else if (!mem && strncmp(p, "MemTotal:", 9) == 0)
{
p = skip_token(p);
memtotal = strtoul(p, &p, 10);
}
else if (!mem && memtotal > 0 && strncmp(p, "MemFree:", 8) == 0)
{
p = skip_token(p);
memfree = strtoul(p, &p, 10);
memory_stats[MEMUSED] = memtotal - memfree;
memory_stats[MEMFREE] = memfree;
}
else if (!mem && strncmp(p, "MemShared:", 10) == 0)
{
p = skip_token(p);
memory_stats[MEMSHARED] = strtoul(p, &p, 10);
}
else if (!mem && strncmp(p, "Buffers:", 8) == 0)
{
p = skip_token(p);
memory_stats[MEMBUFFERS] = strtoul(p, &p, 10);
}
else if (!mem && strncmp(p, "Cached:", 7) == 0)
{
p = skip_token(p);
memory_stats[MEMCACHED] = strtoul(p, &p, 10);
}
else if (!swap && strncmp(p, "SwapTotal:", 10) == 0)
{
p = skip_token(p);
swaptotal = strtoul(p, &p, 10);
}
else if (!swap && swaptotal > 0 && strncmp(p, "SwapFree:", 9) == 0)
{
p = skip_token(p);
memfree = strtoul(p, &p, 10);
swap_stats[SWAPUSED] = swaptotal - memfree;
swap_stats[SWAPFREE] = memfree;
}
else if (!mem && strncmp(p, "SwapCached:", 11) == 0)
{
p = skip_token(p);
swap_stats[SWAPCACHED] = strtoul(p, &p, 10);
}
/* move to the next line */
p = strchr(p, '\n');
}
}
close(fd);
}
/* set arrays and strings */
info->cpustates = cpu_states;
info->memory = memory_stats;
info->swap = swap_stats;
}
