hush/libbb/procps.c

513 lines
12 KiB
C
Raw Normal View History

/* vi: set sw=4 ts=4: */
/*
* Utility routines.
*
* Copyright 1998 by Albert Cahalan; all rights reserved.
* Copyright (C) 2002 by Vladimir Oleynik <dzo@simtreas.ru>
* SELinux support: (c) 2007 by Yuichi Nakamura <ynakam@hitachisoft.jp>
*
* Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
*/
#include "libbb.h"
2006-02-13 22:04:27 +00:00
typedef struct unsigned_to_name_map_t {
long id;
2007-01-19 21:24:17 +00:00
char name[USERNAME_MAX_SIZE];
} unsigned_to_name_map_t;
typedef struct cache_t {
unsigned_to_name_map_t *cache;
int size;
} cache_t;
static cache_t username, groupname;
static void clear_cache(cache_t *cp)
{
free(cp->cache);
cp->cache = NULL;
cp->size = 0;
}
void FAST_FUNC clear_username_cache(void)
{
clear_cache(&username);
clear_cache(&groupname);
}
#if 0 /* more generic, but we don't need that yet */
/* Returns -N-1 if not found. */
/* cp->cache[N] is allocated and must be filled in this case */
static int get_cached(cache_t *cp, unsigned id)
{
int i;
for (i = 0; i < cp->size; i++)
if (cp->cache[i].id == id)
return i;
i = cp->size++;
cp->cache = xrealloc_vector(cp->cache, 2, i);
cp->cache[i++].id = id;
return -i;
}
#endif
static char* get_cached(cache_t *cp, long id,
char* FAST_FUNC x2x_utoa(long id))
{
int i;
for (i = 0; i < cp->size; i++)
if (cp->cache[i].id == id)
return cp->cache[i].name;
i = cp->size++;
cp->cache = xrealloc_vector(cp->cache, 2, i);
cp->cache[i].id = id;
/* Never fails. Generates numeric string if name isn't found */
safe_strncpy(cp->cache[i].name, x2x_utoa(id), sizeof(cp->cache[i].name));
return cp->cache[i].name;
}
const char* FAST_FUNC get_cached_username(uid_t uid)
{
return get_cached(&username, uid, uid2uname_utoa);
}
const char* FAST_FUNC get_cached_groupname(gid_t gid)
{
return get_cached(&groupname, gid, gid2group_utoa);
}
#define PROCPS_BUFSIZE 1024
static int read_to_buf(const char *filename, void *buf)
2006-02-13 22:04:27 +00:00
{
int fd;
/* open_read_close() would do two reads, checking for EOF.
* When you have 10000 /proc/$NUM/stat to read, it isn't desirable */
ssize_t ret = -1;
fd = open(filename, O_RDONLY);
if (fd >= 0) {
ret = read(fd, buf, PROCPS_BUFSIZE-1);
close(fd);
}
((char *)buf)[ret > 0 ? ret : 0] = '\0';
return ret;
2006-02-13 22:04:27 +00:00
}
static procps_status_t* FAST_FUNC alloc_procps_scan(void)
{
unsigned n = getpagesize();
procps_status_t* sp = xzalloc(sizeof(procps_status_t));
sp->dir = xopendir("/proc");
while (1) {
n >>= 1;
if (!n) break;
sp->shift_pages_to_bytes++;
}
sp->shift_pages_to_kb = sp->shift_pages_to_bytes - 10;
return sp;
}
2006-02-13 22:04:27 +00:00
void FAST_FUNC free_procps_scan(procps_status_t* sp)
{
closedir(sp->dir);
free(sp->argv0);
IF_SELINUX(free(sp->context);)
free(sp);
}
#if ENABLE_FEATURE_TOPMEM
static unsigned long fast_strtoul_16(char **endptr)
{
unsigned char c;
char *str = *endptr;
unsigned long n = 0;
while ((c = *str++) != ' ') {
c = ((c|0x20) - '0');
if (c > 9)
// c = c + '0' - 'a' + 10:
c = c - ('a' - '0' - 10);
n = n*16 + c;
}
*endptr = str; /* We skip trailing space! */
return n;
}
/* TOPMEM uses fast_strtoul_10, so... */
#undef ENABLE_FEATURE_FAST_TOP
#define ENABLE_FEATURE_FAST_TOP 1
#endif
#if ENABLE_FEATURE_FAST_TOP
/* We cut a lot of corners here for speed */
static unsigned long fast_strtoul_10(char **endptr)
{
char c;
char *str = *endptr;
unsigned long n = *str - '0';
while ((c = *++str) != ' ')
n = n*10 + (c - '0');
*endptr = str + 1; /* We skip trailing space! */
return n;
}
static long fast_strtol_10(char **endptr)
{
if (**endptr != '-')
return fast_strtoul_10(endptr);
(*endptr)++;
return - (long)fast_strtoul_10(endptr);
}
static char *skip_fields(char *str, int count)
{
do {
while (*str++ != ' ')
continue;
/* we found a space char, str points after it */
} while (--count);
return str;
}
#endif
void BUG_comm_size(void);
procps_status_t* FAST_FUNC procps_scan(procps_status_t* sp, int flags)
{
struct dirent *entry;
char buf[PROCPS_BUFSIZE];
char filename[sizeof("/proc//cmdline") + sizeof(int)*3];
char *filename_tail;
long tasknice;
unsigned pid;
int n;
struct stat sb;
if (!sp)
sp = alloc_procps_scan();
2006-07-12 20:04:00 +00:00
for (;;) {
entry = readdir(sp->dir);
2006-10-12 19:29:44 +00:00
if (entry == NULL) {
free_procps_scan(sp);
return NULL;
}
pid = bb_strtou(entry->d_name, NULL, 10);
if (errno)
continue;
/* After this point we have to break, not continue
* ("continue" would mean that current /proc/NNN
* is not a valid process info) */
memset(&sp->vsz, 0, sizeof(*sp) - offsetof(procps_status_t, vsz));
sp->pid = pid;
if (!(flags & ~PSSCAN_PID)) break;
#if ENABLE_SELINUX
if (flags & PSSCAN_CONTEXT) {
if (getpidcon(sp->pid, &sp->context) < 0)
sp->context = NULL;
2007-07-19 22:50:47 +00:00
}
#endif
filename_tail = filename + sprintf(filename, "/proc/%d", pid);
if (flags & PSSCAN_UIDGID) {
if (stat(filename, &sb))
break;
/* Effective UID/GID, not real */
sp->uid = sb.st_uid;
sp->gid = sb.st_gid;
}
if (flags & PSSCAN_STAT) {
char *cp, *comm1;
int tty;
#if !ENABLE_FEATURE_FAST_TOP
unsigned long vsz, rss;
#endif
/* see proc(5) for some details on this */
strcpy(filename_tail, "/stat");
n = read_to_buf(filename, buf);
if (n < 0)
break;
cp = strrchr(buf, ')'); /* split into "PID (cmd" and "<rest>" */
/*if (!cp || cp[1] != ' ')
break;*/
cp[0] = '\0';
if (sizeof(sp->comm) < 16)
BUG_comm_size();
comm1 = strchr(buf, '(');
/*if (comm1)*/
safe_strncpy(sp->comm, comm1 + 1, sizeof(sp->comm));
#if !ENABLE_FEATURE_FAST_TOP
n = sscanf(cp+2,
"%c %u " /* state, ppid */
"%u %u %d %*s " /* pgid, sid, tty, tpgid */
"%*s %*s %*s %*s %*s " /* flags, min_flt, cmin_flt, maj_flt, cmaj_flt */
"%lu %lu " /* utime, stime */
"%*s %*s %*s " /* cutime, cstime, priority */
"%ld " /* nice */
"%*s %*s " /* timeout, it_real_value */
"%lu " /* start_time */
"%lu " /* vsize */
"%lu " /* rss */
#if ENABLE_FEATURE_TOP_SMP_PROCESS
"%*s %*s %*s %*s %*s %*s " /*rss_rlim, start_code, end_code, start_stack, kstk_esp, kstk_eip */
"%*s %*s %*s %*s " /*signal, blocked, sigignore, sigcatch */
"%*s %*s %*s %*s " /*wchan, nswap, cnswap, exit_signal */
"%d" /*cpu last seen on*/
#endif
,
sp->state, &sp->ppid,
&sp->pgid, &sp->sid, &tty,
&sp->utime, &sp->stime,
&tasknice,
&sp->start_time,
&vsz,
&rss
#if ENABLE_FEATURE_TOP_SMP_PROCESS
, &sp->last_seen_on_cpu
#endif
);
if (n < 11)
break;
#if ENABLE_FEATURE_TOP_SMP_PROCESS
if (n < 11+15)
sp->last_seen_on_cpu = 0;
#endif
/* vsz is in bytes and we want kb */
sp->vsz = vsz >> 10;
/* vsz is in bytes but rss is in *PAGES*! Can you believe that? */
sp->rss = rss << sp->shift_pages_to_kb;
sp->tty_major = (tty >> 8) & 0xfff;
2007-06-21 07:09:18 +00:00
sp->tty_minor = (tty & 0xff) | ((tty >> 12) & 0xfff00);
#else
/* This costs ~100 bytes more but makes top faster by 20%
* If you run 10000 processes, this may be important for you */
sp->state[0] = cp[2];
cp += 4;
sp->ppid = fast_strtoul_10(&cp);
sp->pgid = fast_strtoul_10(&cp);
sp->sid = fast_strtoul_10(&cp);
tty = fast_strtoul_10(&cp);
sp->tty_major = (tty >> 8) & 0xfff;
sp->tty_minor = (tty & 0xff) | ((tty >> 12) & 0xfff00);
cp = skip_fields(cp, 6); /* tpgid, flags, min_flt, cmin_flt, maj_flt, cmaj_flt */
sp->utime = fast_strtoul_10(&cp);
sp->stime = fast_strtoul_10(&cp);
cp = skip_fields(cp, 3); /* cutime, cstime, priority */
tasknice = fast_strtol_10(&cp);
cp = skip_fields(cp, 2); /* timeout, it_real_value */
sp->start_time = fast_strtoul_10(&cp);
/* vsz is in bytes and we want kb */
sp->vsz = fast_strtoul_10(&cp) >> 10;
/* vsz is in bytes but rss is in *PAGES*! Can you believe that? */
sp->rss = fast_strtoul_10(&cp) << sp->shift_pages_to_kb;
#if ENABLE_FEATURE_TOP_SMP_PROCESS
/* (6): rss_rlim, start_code, end_code, start_stack, kstk_esp, kstk_eip */
/* (4): signal, blocked, sigignore, sigcatch */
/* (4): wchan, nswap, cnswap, exit_signal */
cp = skip_fields(cp, 14);
//FIXME: is it safe to assume this field exists?
sp->last_seen_on_cpu = fast_strtoul_10(&cp);
#endif
#endif /* end of !ENABLE_FEATURE_TOP_SMP_PROCESS */
#if ENABLE_FEATURE_PS_ADDITIONAL_COLUMNS
sp->niceness = tasknice;
#endif
if (sp->vsz == 0 && sp->state[0] != 'Z')
sp->state[1] = 'W';
else
sp->state[1] = ' ';
if (tasknice < 0)
sp->state[2] = '<';
else if (tasknice) /* > 0 */
sp->state[2] = 'N';
else
sp->state[2] = ' ';
}
#if ENABLE_FEATURE_TOPMEM
if (flags & (PSSCAN_SMAPS)) {
FILE *file;
strcpy(filename_tail, "/smaps");
file = fopen_for_read(filename);
if (!file)
break;
while (fgets(buf, sizeof(buf), file)) {
unsigned long sz;
char *tp;
char w;
#define SCAN(str, name) \
if (strncmp(buf, str, sizeof(str)-1) == 0) { \
tp = skip_whitespace(buf + sizeof(str)-1); \
sp->name += fast_strtoul_10(&tp); \
continue; \
}
SCAN("Shared_Clean:" , shared_clean );
SCAN("Shared_Dirty:" , shared_dirty );
SCAN("Private_Clean:", private_clean);
SCAN("Private_Dirty:", private_dirty);
#undef SCAN
// f7d29000-f7d39000 rw-s ADR M:m OFS FILE
tp = strchr(buf, '-');
if (tp) {
*tp = ' ';
tp = buf;
sz = fast_strtoul_16(&tp); /* start */
sz = (fast_strtoul_16(&tp) - sz) >> 10; /* end - start */
// tp -> "rw-s" string
w = tp[1];
// skipping "rw-s ADR M:m OFS "
tp = skip_whitespace(skip_fields(tp, 4));
// filter out /dev/something (something != zero)
if (strncmp(tp, "/dev/", 5) != 0 || strcmp(tp, "/dev/zero\n") == 0) {
if (w == 'w') {
sp->mapped_rw += sz;
} else if (w == '-') {
sp->mapped_ro += sz;
}
}
//else printf("DROPPING %s (%s)\n", buf, tp);
if (strcmp(tp, "[stack]\n") == 0)
sp->stack += sz;
}
}
fclose(file);
}
#endif /* TOPMEM */
#if ENABLE_FEATURE_PS_ADDITIONAL_COLUMNS
if (flags & PSSCAN_RUIDGID) {
FILE *file;
strcpy(filename_tail, "/status");
file = fopen_for_read(filename);
if (!file)
break;
while (fgets(buf, sizeof(buf), file)) {
char *tp;
#define SCAN_TWO(str, name, statement) \
if (strncmp(buf, str, sizeof(str)-1) == 0) { \
tp = skip_whitespace(buf + sizeof(str)-1); \
sscanf(tp, "%u", &sp->name); \
statement; \
}
SCAN_TWO("Uid:", ruid, continue);
SCAN_TWO("Gid:", rgid, break);
#undef SCAN_TWO
}
fclose(file);
}
#endif /* PS_ADDITIONAL_COLUMNS */
#if 0 /* PSSCAN_CMD is not used */
if (flags & (PSSCAN_CMD|PSSCAN_ARGV0)) {
free(sp->argv0);
sp->argv0 = NULL;
free(sp->cmd);
sp->cmd = NULL;
strcpy(filename_tail, "/cmdline");
/* TODO: to get rid of size limits, read into malloc buf,
* then realloc it down to real size. */
n = read_to_buf(filename, buf);
if (n <= 0)
break;
if (flags & PSSCAN_ARGV0)
sp->argv0 = xstrdup(buf);
if (flags & PSSCAN_CMD) {
do {
n--;
if ((unsigned char)(buf[n]) < ' ')
buf[n] = ' ';
} while (n);
sp->cmd = xstrdup(buf);
}
}
#else
2007-09-29 22:49:26 +00:00
if (flags & (PSSCAN_ARGV0|PSSCAN_ARGVN)) {
free(sp->argv0);
sp->argv0 = NULL;
strcpy(filename_tail, "/cmdline");
n = read_to_buf(filename, buf);
if (n <= 0)
break;
if (flags & PSSCAN_ARGVN) {
sp->argv_len = n;
sp->argv0 = xmalloc(n + 1);
memcpy(sp->argv0, buf, n + 1);
/* sp->argv0[n] = '\0'; - buf has it */
} else {
sp->argv_len = 0;
sp->argv0 = xstrdup(buf);
}
}
#endif
break;
}
return sp;
}
void FAST_FUNC read_cmdline(char *buf, int col, unsigned pid, const char *comm)
{
ssize_t sz;
char filename[sizeof("/proc//cmdline") + sizeof(int)*3];
sprintf(filename, "/proc/%u/cmdline", pid);
sz = open_read_close(filename, buf, col);
if (sz > 0) {
buf[sz] = '\0';
while (--sz >= 0)
if ((unsigned char)(buf[sz]) < ' ')
buf[sz] = ' ';
} else {
snprintf(buf, col, "[%s]", comm);
}
}
/* from kernel:
// pid comm S ppid pgid sid tty_nr tty_pgrp flg
2006-11-24 21:54:44 +00:00
sprintf(buffer,"%d (%s) %c %d %d %d %d %d %lu %lu \
%lu %lu %lu %lu %lu %ld %ld %ld %ld %d 0 %llu %lu %ld %lu %lu %lu %lu %lu \
%lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %lu %llu\n",
2006-11-24 21:54:44 +00:00
task->pid,
tcomm,
state,
ppid,
pgid,
sid,
tty_nr,
tty_pgrp,
task->flags,
min_flt,
cmin_flt,
maj_flt,
cmaj_flt,
cputime_to_clock_t(utime),
cputime_to_clock_t(stime),
cputime_to_clock_t(cutime),
cputime_to_clock_t(cstime),
priority,
nice,
num_threads,
// 0,
start_time,
vsize,
mm ? get_mm_rss(mm) : 0,
rsslim,
mm ? mm->start_code : 0,
mm ? mm->end_code : 0,
mm ? mm->start_stack : 0,
esp,
eip,
the rest is some obsolete cruft
*/