busybox/libbb/procps.c

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


typedef struct unsigned_to_name_map_t {
	unsigned id;
	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

typedef char* FAST_FUNC ug_func(char *name, int bufsize, long uid);
static char* get_cached(cache_t *cp, unsigned id, ug_func* fp)
{
	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 */
	fp(cp->cache[i].name, sizeof(cp->cache[i].name), id);
	return cp->cache[i].name;
}
const char* FAST_FUNC get_cached_username(uid_t uid)
{
	return get_cached(&username, uid, bb_getpwuid);
}
const char* FAST_FUNC get_cached_groupname(gid_t gid)
{
	return get_cached(&groupname, gid, bb_getgrgid);
}


#define PROCPS_BUFSIZE 1024

static int read_to_buf(const char *filename, void *buf)
{
	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;
}

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;
}

void FAST_FUNC free_procps_scan(procps_status_t* sp)
{
	closedir(sp->dir);
	free(sp->argv0);
	USE_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 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();

	for (;;) {
		entry = readdir(sp->dir);
		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;
		}
#endif

		filename_tail = filename + sprintf(filename, "/proc/%d", pid);

		if (flags & PSSCAN_UIDGID) {
			if (stat(filename, &sb))
				break;
			/* Need comment - is this effective or real UID/GID? */
			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;
			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_strtoul_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 (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 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
		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
	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",
		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
*/
1	niro	532	/* vi: set sw=4 ts=4: */
2			/*
3			* Utility routines.
4			*
5			* Copyright 1998 by Albert Cahalan; all rights reserved.
6			* Copyright (C) 2002 by Vladimir Oleynik <dzo@simtreas.ru>
7	niro	816	* SELinux support: (c) 2007 by Yuichi Nakamura <ynakam@hitachisoft.jp>
8	niro	532	*
9			* Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
10			*/
11
12			#include "libbb.h"
13
14
15			typedef struct unsigned_to_name_map_t {
16			unsigned id;
17			char name[USERNAME_MAX_SIZE];
18			} unsigned_to_name_map_t;
19
20			typedef struct cache_t {
21			unsigned_to_name_map_t *cache;
22			int size;
23			} cache_t;
24
25			static cache_t username, groupname;
26
27			static void clear_cache(cache_t *cp)
28			{
29			free(cp->cache);
30			cp->cache = NULL;
31			cp->size = 0;
32			}
33	niro	816	void FAST_FUNC clear_username_cache(void)
34	niro	532	{
35			clear_cache(&username);
36			clear_cache(&groupname);
37			}
38
39			#if 0 /* more generic, but we don't need that yet */
40			/* Returns -N-1 if not found. */
41			/* cp->cache[N] is allocated and must be filled in this case */
42			static int get_cached(cache_t *cp, unsigned id)
43			{
44			int i;
45			for (i = 0; i < cp->size; i++)
46			if (cp->cache[i].id == id)
47			return i;
48			i = cp->size++;
49	niro	816	cp->cache = xrealloc_vector(cp->cache, 2, i);
50	niro	532	cp->cache[i++].id = id;
51			return -i;
52			}
53			#endif
54
55	niro	816	typedef char* FAST_FUNC ug_func(char *name, int bufsize, long uid);
56	niro	532	static char* get_cached(cache_t cp, unsigned id, ug_func fp)
57			{
58			int i;
59			for (i = 0; i < cp->size; i++)
60			if (cp->cache[i].id == id)
61			return cp->cache[i].name;
62			i = cp->size++;
63	niro	816	cp->cache = xrealloc_vector(cp->cache, 2, i);
64	niro	532	cp->cache[i].id = id;
65	niro	816	/* Never fails. Generates numeric string if name isn't found */
66			fp(cp->cache[i].name, sizeof(cp->cache[i].name), id);
67	niro	532	return cp->cache[i].name;
68			}
69	niro	816	const char* FAST_FUNC get_cached_username(uid_t uid)
70	niro	532	{
71			return get_cached(&username, uid, bb_getpwuid);
72			}
73	niro	816	const char* FAST_FUNC get_cached_groupname(gid_t gid)
74	niro	532	{
75			return get_cached(&groupname, gid, bb_getgrgid);
76			}
77
78
79			#define PROCPS_BUFSIZE 1024
80
81			static int read_to_buf(const char filename, void buf)
82			{
83	niro	816	int fd;
84			/* open_read_close() would do two reads, checking for EOF.
85			* When you have 10000 /proc/$NUM/stat to read, it isn't desirable */
86			ssize_t ret = -1;
87			fd = open(filename, O_RDONLY);
88			if (fd >= 0) {
89			ret = read(fd, buf, PROCPS_BUFSIZE-1);
90			close(fd);
91			}
92	niro	532	((char *)buf)[ret > 0 ? ret : 0] = '\0';
93			return ret;
94			}
95
96	niro	816	static procps_status_t* FAST_FUNC alloc_procps_scan(void)
97	niro	532	{
98	niro	816	unsigned n = getpagesize();
99	niro	532	procps_status_t* sp = xzalloc(sizeof(procps_status_t));
100			sp->dir = xopendir("/proc");
101	niro	816	while (1) {
102			n >>= 1;
103			if (!n) break;
104			sp->shift_pages_to_bytes++;
105			}
106			sp->shift_pages_to_kb = sp->shift_pages_to_bytes - 10;
107	niro	532	return sp;
108			}
109
110	niro	816	void FAST_FUNC free_procps_scan(procps_status_t* sp)
111	niro	532	{
112			closedir(sp->dir);
113	niro	816	free(sp->argv0);
114			USE_SELINUX(free(sp->context);)
115	niro	532	free(sp);
116			}
117
118	niro	816	#if ENABLE_FEATURE_TOPMEM
119			static unsigned long fast_strtoul_16(char **endptr)
120			{
121			unsigned char c;
122			char str = endptr;
123			unsigned long n = 0;
124
125			while ((c = *str++) != ' ') {
126			c = ((c\|0x20) - '0');
127			if (c > 9)
128			// c = c + '0' - 'a' + 10:
129			c = c - ('a' - '0' - 10);
130			n = n*16 + c;
131			}
132			endptr = str; / We skip trailing space! */
133			return n;
134			}
135			/* TOPMEM uses fast_strtoul_10, so... */
136			#undef ENABLE_FEATURE_FAST_TOP
137			#define ENABLE_FEATURE_FAST_TOP 1
138			#endif
139
140			#if ENABLE_FEATURE_FAST_TOP
141			/* We cut a lot of corners here for speed */
142			static unsigned long fast_strtoul_10(char **endptr)
143			{
144			char c;
145			char str = endptr;
146			unsigned long n = *str - '0';
147
148			while ((c = *++str) != ' ')
149			n = n*10 + (c - '0');
150
151			endptr = str + 1; / We skip trailing space! */
152			return n;
153			}
154			static char skip_fields(char str, int count)
155			{
156			do {
157			while (*str++ != ' ')
158			continue;
159			/* we found a space char, str points after it */
160			} while (--count);
161			return str;
162			}
163			#endif
164
165	niro	532	void BUG_comm_size(void);
166	niro	816	procps_status_t* FAST_FUNC procps_scan(procps_status_t* sp, int flags)
167	niro	532	{
168			struct dirent *entry;
169			char buf[PROCPS_BUFSIZE];
170			char filename[sizeof("/proc//cmdline") + sizeof(int)*3];
171			char *filename_tail;
172			long tasknice;
173			unsigned pid;
174			int n;
175			struct stat sb;
176
177			if (!sp)
178	niro	816	sp = alloc_procps_scan();
179	niro	532
180			for (;;) {
181			entry = readdir(sp->dir);
182			if (entry == NULL) {
183			free_procps_scan(sp);
184			return NULL;
185			}
186			pid = bb_strtou(entry->d_name, NULL, 10);
187			if (errno)
188			continue;
189
190			/* After this point we have to break, not continue
191			* ("continue" would mean that current /proc/NNN
192			* is not a valid process info) */
193
194	niro	816	memset(&sp->vsz, 0, sizeof(*sp) - offsetof(procps_status_t, vsz));
195	niro	532
196			sp->pid = pid;
197			if (!(flags & ~PSSCAN_PID)) break;
198
199	niro	816	#if ENABLE_SELINUX
200			if (flags & PSSCAN_CONTEXT) {
201			if (getpidcon(sp->pid, &sp->context) < 0)
202			sp->context = NULL;
203			}
204			#endif
205
206	niro	532	filename_tail = filename + sprintf(filename, "/proc/%d", pid);
207
208			if (flags & PSSCAN_UIDGID) {
209			if (stat(filename, &sb))
210			break;
211			/* Need comment - is this effective or real UID/GID? */
212			sp->uid = sb.st_uid;
213			sp->gid = sb.st_gid;
214			}
215
216			if (flags & PSSCAN_STAT) {
217	niro	816	char cp, comm1;
218			int tty;
219			#if !ENABLE_FEATURE_FAST_TOP
220			unsigned long vsz, rss;
221			#endif
222	niro	532	/* see proc(5) for some details on this */
223			strcpy(filename_tail, "/stat");
224			n = read_to_buf(filename, buf);
225			if (n < 0)
226			break;
227			cp = strrchr(buf, ')'); /* split into "PID (cmd" and "<rest>" */
228	niro	816	/*if (!cp \|\| cp[1] != ' ')
229			break;*/
230	niro	532	cp[0] = '\0';
231			if (sizeof(sp->comm) < 16)
232			BUG_comm_size();
233	niro	816	comm1 = strchr(buf, '(');
234			/if (comm1)/
235			safe_strncpy(sp->comm, comm1 + 1, sizeof(sp->comm));
236
237			#if !ENABLE_FEATURE_FAST_TOP
238	niro	532	n = sscanf(cp+2,
239			"%c %u " /* state, ppid */
240	niro	816	"%u %u %d %s " / pgid, sid, tty, tpgid */
241	niro	532	"%s %s %s %s %s " / flags, min_flt, cmin_flt, maj_flt, cmaj_flt */
242			"%lu %lu " /* utime, stime */
243			"%s %s %s " / cutime, cstime, priority */
244			"%ld " /* nice */
245	niro	816	"%s %s " /* timeout, it_real_value */
246			"%lu " /* start_time */
247			"%lu " /* vsize */
248			"%lu " /* rss */
249			#if ENABLE_FEATURE_TOP_SMP_PROCESS
250			"%s %s %s %s %s %s " /rss_rlim, start_code, end_code, start_stack, kstk_esp, kstk_eip /
251			"%s %s %s %s " /signal, blocked, sigignore, sigcatch /
252			"%s %s %s %s " /wchan, nswap, cnswap, exit_signal /
253			"%d" /cpu last seen on/
254			#endif
255			,
256	niro	532	sp->state, &sp->ppid,
257	niro	816	&sp->pgid, &sp->sid, &tty,
258	niro	532	&sp->utime, &sp->stime,
259			&tasknice,
260	niro	816	&sp->start_time,
261			&vsz,
262			&rss
263			#if ENABLE_FEATURE_TOP_SMP_PROCESS
264			, &sp->last_seen_on_cpu
265			#endif
266			);
267
268			if (n < 11)
269	niro	532	break;
270	niro	816	#if ENABLE_FEATURE_TOP_SMP_PROCESS
271			if (n < 11+15)
272			sp->last_seen_on_cpu = 0;
273			#endif
274	niro	532
275	niro	816	/* vsz is in bytes and we want kb */
276			sp->vsz = vsz >> 10;
277			/* vsz is in bytes but rss is in PAGES! Can you believe that? */
278			sp->rss = rss << sp->shift_pages_to_kb;
279			sp->tty_major = (tty >> 8) & 0xfff;
280			sp->tty_minor = (tty & 0xff) \| ((tty >> 12) & 0xfff00);
281			#else
282			/* This costs ~100 bytes more but makes top faster by 20%
283			* If you run 10000 processes, this may be important for you */
284			sp->state[0] = cp[2];
285			cp += 4;
286			sp->ppid = fast_strtoul_10(&cp);
287			sp->pgid = fast_strtoul_10(&cp);
288			sp->sid = fast_strtoul_10(&cp);
289			tty = fast_strtoul_10(&cp);
290			sp->tty_major = (tty >> 8) & 0xfff;
291			sp->tty_minor = (tty & 0xff) \| ((tty >> 12) & 0xfff00);
292			cp = skip_fields(cp, 6); /* tpgid, flags, min_flt, cmin_flt, maj_flt, cmaj_flt */
293			sp->utime = fast_strtoul_10(&cp);
294			sp->stime = fast_strtoul_10(&cp);
295			cp = skip_fields(cp, 3); /* cutime, cstime, priority */
296			tasknice = fast_strtoul_10(&cp);
297			cp = skip_fields(cp, 2); /* timeout, it_real_value */
298			sp->start_time = fast_strtoul_10(&cp);
299			/* vsz is in bytes and we want kb */
300			sp->vsz = fast_strtoul_10(&cp) >> 10;
301			/* vsz is in bytes but rss is in PAGES! Can you believe that? */
302			sp->rss = fast_strtoul_10(&cp) << sp->shift_pages_to_kb;
303			#if ENABLE_FEATURE_TOP_SMP_PROCESS
304			/* (6): rss_rlim, start_code, end_code, start_stack, kstk_esp, kstk_eip */
305			/* (4): signal, blocked, sigignore, sigcatch */
306			/* (4): wchan, nswap, cnswap, exit_signal */
307			cp = skip_fields(cp, 14);
308			//FIXME: is it safe to assume this field exists?
309			sp->last_seen_on_cpu = fast_strtoul_10(&cp);
310			#endif
311			#endif /* end of !ENABLE_FEATURE_TOP_SMP_PROCESS */
312
313			if (sp->vsz == 0 && sp->state[0] != 'Z')
314	niro	532	sp->state[1] = 'W';
315			else
316			sp->state[1] = ' ';
317			if (tasknice < 0)
318			sp->state[2] = '<';
319	niro	816	else if (tasknice) /* > 0 */
320	niro	532	sp->state[2] = 'N';
321			else
322			sp->state[2] = ' ';
323	niro	816	}
324	niro	532
325	niro	816	#if ENABLE_FEATURE_TOPMEM
326			if (flags & (PSSCAN_SMAPS)) {
327			FILE *file;
328
329			strcpy(filename_tail, "/smaps");
330			file = fopen_for_read(filename);
331			if (!file)
332			break;
333			while (fgets(buf, sizeof(buf), file)) {
334			unsigned long sz;
335			char *tp;
336			char w;
337			#define SCAN(str, name) \
338			if (strncmp(buf, str, sizeof(str)-1) == 0) { \
339			tp = skip_whitespace(buf + sizeof(str)-1); \
340			sp->name += fast_strtoul_10(&tp); \
341			continue; \
342			}
343			SCAN("Shared_Clean:" , shared_clean );
344			SCAN("Shared_Dirty:" , shared_dirty );
345			SCAN("Private_Clean:", private_clean);
346			SCAN("Private_Dirty:", private_dirty);
347			#undef SCAN
348			// f7d29000-f7d39000 rw-s ADR M:m OFS FILE
349			tp = strchr(buf, '-');
350			if (tp) {
351			*tp = ' ';
352			tp = buf;
353			sz = fast_strtoul_16(&tp); /* start */
354			sz = (fast_strtoul_16(&tp) - sz) >> 10; /* end - start */
355			// tp -> "rw-s" string
356			w = tp[1];
357			// skipping "rw-s ADR M:m OFS "
358			tp = skip_whitespace(skip_fields(tp, 4));
359			// filter out /dev/something (something != zero)
360			if (strncmp(tp, "/dev/", 5) != 0 \|\| strcmp(tp, "/dev/zero\n") == 0) {
361			if (w == 'w') {
362			sp->mapped_rw += sz;
363			} else if (w == '-') {
364			sp->mapped_ro += sz;
365			}
366			}
367			//else printf("DROPPING %s (%s)\n", buf, tp);
368			if (strcmp(tp, "[stack]\n") == 0)
369			sp->stack += sz;
370			}
371			}
372			fclose(file);
373	niro	532	}
374	niro	816	#endif /* TOPMEM */
375	niro	532
376	niro	816	#if 0 /* PSSCAN_CMD is not used */
377			if (flags & (PSSCAN_CMD\|PSSCAN_ARGV0)) {
378			free(sp->argv0);
379			sp->argv0 = NULL;
380	niro	532	free(sp->cmd);
381			sp->cmd = NULL;
382			strcpy(filename_tail, "/cmdline");
383	niro	816	/* TODO: to get rid of size limits, read into malloc buf,
384			* then realloc it down to real size. */
385	niro	532	n = read_to_buf(filename, buf);
386			if (n <= 0)
387			break;
388	niro	816	if (flags & PSSCAN_ARGV0)
389			sp->argv0 = xstrdup(buf);
390			if (flags & PSSCAN_CMD) {
391			do {
392			n--;
393			if ((unsigned char)(buf[n]) < ' ')
394			buf[n] = ' ';
395			} while (n);
396			sp->cmd = xstrdup(buf);
397	niro	532	}
398			}
399	niro	816	#else
400			if (flags & (PSSCAN_ARGV0\|PSSCAN_ARGVN)) {
401			free(sp->argv0);
402			sp->argv0 = NULL;
403			strcpy(filename_tail, "/cmdline");
404			n = read_to_buf(filename, buf);
405			if (n <= 0)
406			break;
407			if (flags & PSSCAN_ARGVN) {
408			sp->argv_len = n;
409			sp->argv0 = xmalloc(n + 1);
410			memcpy(sp->argv0, buf, n + 1);
411			/* sp->argv0[n] = '\0'; - buf has it */
412			} else {
413			sp->argv_len = 0;
414			sp->argv0 = xstrdup(buf);
415			}
416			}
417			#endif
418	niro	532	break;
419			}
420			return sp;
421			}
422	niro	816
423			void FAST_FUNC read_cmdline(char buf, int col, unsigned pid, const char comm)
424			{
425			ssize_t sz;
426			char filename[sizeof("/proc//cmdline") + sizeof(int)*3];
427
428			sprintf(filename, "/proc/%u/cmdline", pid);
429			sz = open_read_close(filename, buf, col);
430			if (sz > 0) {
431			buf[sz] = '\0';
432			while (--sz >= 0)
433			if ((unsigned char)(buf[sz]) < ' ')
434			buf[sz] = ' ';
435			} else {
436			snprintf(buf, col, "[%s]", comm);
437			}
438			}
439
440	niro	532	/* from kernel:
441			// pid comm S ppid pgid sid tty_nr tty_pgrp flg
442			sprintf(buffer,"%d (%s) %c %d %d %d %d %d %lu %lu \
443			%lu %lu %lu %lu %lu %ld %ld %ld %ld %d 0 %llu %lu %ld %lu %lu %lu %lu %lu \
444			%lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %lu %llu\n",
445			task->pid,
446			tcomm,
447			state,
448			ppid,
449			pgid,
450			sid,
451			tty_nr,
452			tty_pgrp,
453			task->flags,
454			min_flt,
455			cmin_flt,
456			maj_flt,
457			cmaj_flt,
458			cputime_to_clock_t(utime),
459			cputime_to_clock_t(stime),
460			cputime_to_clock_t(cutime),
461			cputime_to_clock_t(cstime),
462			priority,
463			nice,
464			num_threads,
465			// 0,
466			start_time,
467			vsize,
468			mm ? get_mm_rss(mm) : 0,
469			rsslim,
470			mm ? mm->start_code : 0,
471			mm ? mm->end_code : 0,
472			mm ? mm->start_stack : 0,
473			esp,
474			eip,
475			the rest is some obsolete cruft
476			*/