1 /* vi: set sw=4 ts=4: */
5 * Copyright 1998 by Albert Cahalan; all rights reserved.
6 * Copyright (C) 2002 by Vladimir Oleynik <dzo@simtreas.ru>
7 * SELinux support: (c) 2007 by Yuichi Nakamura <ynakam@hitachisoft.jp>
9 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
15 typedef struct id_to_name_map_t
{
17 char name
[USERNAME_MAX_SIZE
];
20 typedef struct cache_t
{
21 id_to_name_map_t
*cache
;
25 static cache_t username
, groupname
;
27 static void clear_cache(cache_t
*cp
)
33 void FAST_FUNC
clear_username_cache(void)
35 clear_cache(&username
);
36 clear_cache(&groupname
);
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
, uid_t id
)
45 for (i
= 0; i
< cp
->size
; i
++)
46 if (cp
->cache
[i
].id
== id
)
49 cp
->cache
= xrealloc_vector(cp
->cache
, 2, i
);
50 cp
->cache
[i
++].id
= id
;
55 static char* get_cached(cache_t
*cp
, uid_t id
,
56 char* FAST_FUNC
x2x_utoa(uid_t id
))
59 for (i
= 0; i
< cp
->size
; i
++)
60 if (cp
->cache
[i
].id
== id
)
61 return cp
->cache
[i
].name
;
63 cp
->cache
= xrealloc_vector(cp
->cache
, 2, i
);
65 /* Never fails. Generates numeric string if name isn't found */
66 safe_strncpy(cp
->cache
[i
].name
, x2x_utoa(id
), sizeof(cp
->cache
[i
].name
));
67 return cp
->cache
[i
].name
;
69 const char* FAST_FUNC
get_cached_username(uid_t uid
)
71 return get_cached(&username
, uid
, uid2uname_utoa
);
73 const char* FAST_FUNC
get_cached_groupname(gid_t gid
)
75 return get_cached(&groupname
, gid
, gid2group_utoa
);
79 #define PROCPS_BUFSIZE 1024
81 static int read_to_buf(const char *filename
, void *buf
)
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 */
87 fd
= open(filename
, O_RDONLY
);
89 ret
= read(fd
, buf
, PROCPS_BUFSIZE
-1);
92 ((char *)buf
)[ret
> 0 ? ret
: 0] = '\0';
96 static procps_status_t
* FAST_FUNC
alloc_procps_scan(void)
98 unsigned n
= getpagesize();
99 procps_status_t
* sp
= xzalloc(sizeof(procps_status_t
));
100 sp
->dir
= xopendir("/proc");
104 sp
->shift_pages_to_bytes
++;
106 sp
->shift_pages_to_kb
= sp
->shift_pages_to_bytes
- 10;
110 void FAST_FUNC
free_procps_scan(procps_status_t
* sp
)
113 #if ENABLE_FEATURE_SHOW_THREADS
115 closedir(sp
->task_dir
);
119 IF_SELINUX(free(sp
->context
);)
123 #if ENABLE_FEATURE_TOPMEM || ENABLE_PMAP
124 static unsigned long fast_strtoul_16(char **endptr
)
130 /* Need to stop on both ' ' and '\n' */
131 while ((c
= *str
++) > ' ') {
132 c
= ((c
|0x20) - '0');
134 /* c = c + '0' - 'a' + 10: */
135 c
= c
- ('a' - '0' - 10);
138 *endptr
= str
; /* We skip trailing space! */
143 #if ENABLE_FEATURE_FAST_TOP || ENABLE_FEATURE_TOPMEM || ENABLE_PMAP
144 /* We cut a lot of corners here for speed */
145 static unsigned long fast_strtoul_10(char **endptr
)
149 unsigned long n
= *str
- '0';
151 /* Need to stop on both ' ' and '\n' */
152 while ((c
= *++str
) > ' ')
153 n
= n
*10 + (c
- '0');
155 *endptr
= str
+ 1; /* We skip trailing space! */
159 # if ENABLE_FEATURE_FAST_TOP
160 static long fast_strtol_10(char **endptr
)
163 return fast_strtoul_10(endptr
);
166 return - (long)fast_strtoul_10(endptr
);
170 static char *skip_fields(char *str
, int count
)
173 while (*str
++ != ' ')
175 /* we found a space char, str points after it */
181 #if ENABLE_FEATURE_TOPMEM || ENABLE_PMAP
182 int FAST_FUNC
procps_read_smaps(pid_t pid
, struct smaprec
*total
,
183 void (*cb
)(struct smaprec
*, void *), void *data
)
186 struct smaprec currec
;
187 char filename
[sizeof("/proc/%u/smaps") + sizeof(int)*3];
188 char buf
[PROCPS_BUFSIZE
];
190 void (*cb
)(struct smaprec
*, void *) = NULL
;
194 sprintf(filename
, "/proc/%u/smaps", (int)pid
);
196 file
= fopen_for_read(filename
);
200 memset(&currec
, 0, sizeof(currec
));
201 while (fgets(buf
, PROCPS_BUFSIZE
, file
)) {
202 // Each mapping datum has this form:
203 // f7d29000-f7d39000 rw-s FILEOFS M:m INODE FILENAME
211 if (strncmp(tp, S, sizeof(S)-1) == 0) { \
212 tp = skip_whitespace(tp + sizeof(S)-1); \
213 total->X += currec.X = fast_strtoul_10(&tp); \
217 SCAN("Pss:" , smap_pss
);
218 SCAN("Swap:" , smap_swap
);
220 SCAN("Private_Dirty:", private_dirty
);
221 SCAN("Private_Clean:", private_clean
);
222 SCAN("Shared_Dirty:" , shared_dirty
);
223 SCAN("Shared_Clean:" , shared_clean
);
225 tp
= strchr(buf
, '-');
227 // We reached next mapping - the line of this form:
228 // f7d29000-f7d39000 rw-s FILEOFS M:m INODE FILENAME
231 /* If we have a previous record, there's nothing more
232 * for it, call the callback and clear currec
234 if (currec
.smap_size
)
236 free(currec
.smap_name
);
238 memset(&currec
, 0, sizeof(currec
));
242 currec
.smap_start
= fast_strtoul_16(&tp
);
243 currec
.smap_size
= (fast_strtoul_16(&tp
) - currec
.smap_start
) >> 10;
245 strncpy(currec
.smap_mode
, tp
, sizeof(currec
.smap_mode
)-1);
247 // skipping "rw-s FILEOFS M:m INODE "
248 tp
= skip_whitespace(skip_fields(tp
, 4));
249 // filter out /dev/something (something != zero)
250 if (strncmp(tp
, "/dev/", 5) != 0 || strcmp(tp
, "/dev/zero\n") == 0) {
251 if (currec
.smap_mode
[1] == 'w') {
252 currec
.mapped_rw
= currec
.smap_size
;
253 total
->mapped_rw
+= currec
.smap_size
;
254 } else if (currec
.smap_mode
[1] == '-') {
255 currec
.mapped_ro
= currec
.smap_size
;
256 total
->mapped_ro
+= currec
.smap_size
;
260 if (strcmp(tp
, "[stack]\n") == 0)
261 total
->stack
+= currec
.smap_size
;
263 p
= skip_non_whitespace(tp
);
265 currec
.smap_name
= xstrdup(" [ anon ]");
268 currec
.smap_name
= xstrdup(tp
);
271 total
->smap_size
+= currec
.smap_size
;
277 if (currec
.smap_size
)
279 free(currec
.smap_name
);
286 void BUG_comm_size(void);
287 procps_status_t
* FAST_FUNC
procps_scan(procps_status_t
* sp
, int flags
)
290 sp
= alloc_procps_scan();
293 struct dirent
*entry
;
294 char buf
[PROCPS_BUFSIZE
];
298 char filename
[sizeof("/proc/%u/task/%u/cmdline") + sizeof(int)*3 * 2];
301 #if ENABLE_FEATURE_SHOW_THREADS
303 entry
= readdir(sp
->task_dir
);
306 closedir(sp
->task_dir
);
310 entry
= readdir(sp
->dir
);
312 free_procps_scan(sp
);
315 IF_FEATURE_SHOW_THREADS(got_entry
:)
316 pid
= bb_strtou(entry
->d_name
, NULL
, 10);
319 #if ENABLE_FEATURE_SHOW_THREADS
320 if ((flags
& PSSCAN_TASKS
) && !sp
->task_dir
) {
321 /* We found another /proc/PID. Do not use it,
322 * there will be /proc/PID/task/PID (same PID!),
323 * so just go ahead and dive into /proc/PID/task. */
324 sprintf(filename
, "/proc/%u/task", pid
);
325 /* Note: if opendir fails, we just go to next /proc/XXX */
326 sp
->task_dir
= opendir(filename
);
327 sp
->main_thread_pid
= pid
;
332 /* After this point we can:
333 * "break": stop parsing, return the data
334 * "continue": try next /proc/XXX
337 memset(&sp
->vsz
, 0, sizeof(*sp
) - offsetof(procps_status_t
, vsz
));
340 if (!(flags
& ~PSSCAN_PID
))
341 break; /* we needed only pid, we got it */
344 if (flags
& PSSCAN_CONTEXT
) {
345 if (getpidcon(sp
->pid
, &sp
->context
) < 0)
350 #if ENABLE_FEATURE_SHOW_THREADS
352 filename_tail
= filename
+ sprintf(filename
, "/proc/%u/task/%u/", sp
->main_thread_pid
, pid
);
355 filename_tail
= filename
+ sprintf(filename
, "/proc/%u/", pid
);
357 if (flags
& PSSCAN_UIDGID
) {
359 if (stat(filename
, &sb
))
360 continue; /* process probably exited */
361 /* Effective UID/GID, not real */
366 /* These are all retrieved from proc/NN/stat in one go: */
367 if (flags
& (PSSCAN_PPID
| PSSCAN_PGID
| PSSCAN_SID
368 | PSSCAN_COMM
| PSSCAN_STATE
369 | PSSCAN_VSZ
| PSSCAN_RSS
370 | PSSCAN_STIME
| PSSCAN_UTIME
| PSSCAN_START_TIME
371 | PSSCAN_TTY
| PSSCAN_NICE
376 #if !ENABLE_FEATURE_FAST_TOP
377 unsigned long vsz
, rss
;
379 /* see proc(5) for some details on this */
380 strcpy(filename_tail
, "stat");
381 n
= read_to_buf(filename
, buf
);
383 continue; /* process probably exited */
384 cp
= strrchr(buf
, ')'); /* split into "PID (cmd" and "<rest>" */
385 /*if (!cp || cp[1] != ' ')
388 if (sizeof(sp
->comm
) < 16)
390 comm1
= strchr(buf
, '(');
392 safe_strncpy(sp
->comm
, comm1
+ 1, sizeof(sp
->comm
));
394 #if !ENABLE_FEATURE_FAST_TOP
396 "%c %u " /* state, ppid */
397 "%u %u %d %*s " /* pgid, sid, tty, tpgid */
398 "%*s %*s %*s %*s %*s " /* flags, min_flt, cmin_flt, maj_flt, cmaj_flt */
399 "%lu %lu " /* utime, stime */
400 "%*s %*s %*s " /* cutime, cstime, priority */
402 "%*s %*s " /* timeout, it_real_value */
403 "%lu " /* start_time */
406 # if ENABLE_FEATURE_TOP_SMP_PROCESS
407 "%*s %*s %*s %*s %*s %*s " /*rss_rlim, start_code, end_code, start_stack, kstk_esp, kstk_eip */
408 "%*s %*s %*s %*s " /*signal, blocked, sigignore, sigcatch */
409 "%*s %*s %*s %*s " /*wchan, nswap, cnswap, exit_signal */
410 "%d" /*cpu last seen on*/
413 sp
->state
, &sp
->ppid
,
414 &sp
->pgid
, &sp
->sid
, &tty
,
415 &sp
->utime
, &sp
->stime
,
420 # if ENABLE_FEATURE_TOP_SMP_PROCESS
421 , &sp
->last_seen_on_cpu
426 continue; /* bogus data, get next /proc/XXX */
427 # if ENABLE_FEATURE_TOP_SMP_PROCESS
429 sp
->last_seen_on_cpu
= 0;
432 /* vsz is in bytes and we want kb */
434 /* vsz is in bytes but rss is in *PAGES*! Can you believe that? */
435 sp
->rss
= rss
<< sp
->shift_pages_to_kb
;
436 sp
->tty_major
= (tty
>> 8) & 0xfff;
437 sp
->tty_minor
= (tty
& 0xff) | ((tty
>> 12) & 0xfff00);
439 /* This costs ~100 bytes more but makes top faster by 20%
440 * If you run 10000 processes, this may be important for you */
441 sp
->state
[0] = cp
[2];
443 sp
->ppid
= fast_strtoul_10(&cp
);
444 sp
->pgid
= fast_strtoul_10(&cp
);
445 sp
->sid
= fast_strtoul_10(&cp
);
446 tty
= fast_strtoul_10(&cp
);
447 sp
->tty_major
= (tty
>> 8) & 0xfff;
448 sp
->tty_minor
= (tty
& 0xff) | ((tty
>> 12) & 0xfff00);
449 cp
= skip_fields(cp
, 6); /* tpgid, flags, min_flt, cmin_flt, maj_flt, cmaj_flt */
450 sp
->utime
= fast_strtoul_10(&cp
);
451 sp
->stime
= fast_strtoul_10(&cp
);
452 cp
= skip_fields(cp
, 3); /* cutime, cstime, priority */
453 tasknice
= fast_strtol_10(&cp
);
454 cp
= skip_fields(cp
, 2); /* timeout, it_real_value */
455 sp
->start_time
= fast_strtoul_10(&cp
);
456 /* vsz is in bytes and we want kb */
457 sp
->vsz
= fast_strtoul_10(&cp
) >> 10;
458 /* vsz is in bytes but rss is in *PAGES*! Can you believe that? */
459 sp
->rss
= fast_strtoul_10(&cp
) << sp
->shift_pages_to_kb
;
460 # if ENABLE_FEATURE_TOP_SMP_PROCESS
461 /* (6): rss_rlim, start_code, end_code, start_stack, kstk_esp, kstk_eip */
462 /* (4): signal, blocked, sigignore, sigcatch */
463 /* (4): wchan, nswap, cnswap, exit_signal */
464 cp
= skip_fields(cp
, 14);
465 //FIXME: is it safe to assume this field exists?
466 sp
->last_seen_on_cpu
= fast_strtoul_10(&cp
);
468 #endif /* FEATURE_FAST_TOP */
470 #if ENABLE_FEATURE_PS_ADDITIONAL_COLUMNS
471 sp
->niceness
= tasknice
;
474 if (sp
->vsz
== 0 && sp
->state
[0] != 'Z')
480 else if (tasknice
) /* > 0 */
486 #if ENABLE_FEATURE_TOPMEM
487 if (flags
& PSSCAN_SMAPS
)
488 procps_read_smaps(pid
, &sp
->smaps
, NULL
, NULL
);
490 #if ENABLE_FEATURE_PS_ADDITIONAL_COLUMNS
491 if (flags
& PSSCAN_RUIDGID
) {
494 strcpy(filename_tail
, "status");
495 file
= fopen_for_read(filename
);
497 while (fgets(buf
, sizeof(buf
), file
)) {
499 #define SCAN_TWO(str, name, statement) \
500 if (strncmp(buf, str, sizeof(str)-1) == 0) { \
501 tp = skip_whitespace(buf + sizeof(str)-1); \
502 sscanf(tp, "%u", &sp->name); \
505 SCAN_TWO("Uid:", ruid
, continue);
506 SCAN_TWO("Gid:", rgid
, break);
512 #endif /* PS_ADDITIONAL_COLUMNS */
513 if (flags
& PSSCAN_EXE
) {
514 strcpy(filename_tail
, "exe");
516 sp
->exe
= xmalloc_readlink(filename
);
518 /* Note: if /proc/PID/cmdline is empty,
519 * code below "breaks". Therefore it must be
520 * the last code to parse /proc/PID/xxx data
521 * (we used to have /proc/PID/exe parsing after it
522 * and were getting stale sp->exe).
524 #if 0 /* PSSCAN_CMD is not used */
525 if (flags
& (PSSCAN_CMD
|PSSCAN_ARGV0
)) {
530 strcpy(filename_tail
, "cmdline");
531 /* TODO: to get rid of size limits, read into malloc buf,
532 * then realloc it down to real size. */
533 n
= read_to_buf(filename
, buf
);
536 if (flags
& PSSCAN_ARGV0
)
537 sp
->argv0
= xstrdup(buf
);
538 if (flags
& PSSCAN_CMD
) {
541 if ((unsigned char)(buf
[n
]) < ' ')
544 sp
->cmd
= xstrdup(buf
);
548 if (flags
& (PSSCAN_ARGV0
|PSSCAN_ARGVN
)) {
551 strcpy(filename_tail
, "cmdline");
552 n
= read_to_buf(filename
, buf
);
555 if (flags
& PSSCAN_ARGVN
) {
557 sp
->argv0
= xmalloc(n
+ 1);
558 memcpy(sp
->argv0
, buf
, n
+ 1);
559 /* sp->argv0[n] = '\0'; - buf has it */
562 sp
->argv0
= xstrdup(buf
);
572 void FAST_FUNC
read_cmdline(char *buf
, int col
, unsigned pid
, const char *comm
)
575 char filename
[sizeof("/proc/%u/cmdline") + sizeof(int)*3];
577 sprintf(filename
, "/proc/%u/cmdline", pid
);
578 sz
= open_read_close(filename
, buf
, col
- 1);
584 while (--sz
>= 0 && buf
[sz
] == '\0')
586 /* Prevent basename("process foo/bar") = "bar" */
587 strchrnul(buf
, ' ')[0] = '\0';
588 base
= bb_basename(buf
); /* before we replace argv0's NUL with space */
590 if ((unsigned char)(buf
[sz
]) < ' ')
595 /* If comm differs from argv0, prepend "{comm} ".
596 * It allows to see thread names set by prctl(PR_SET_NAME).
598 if (base
[0] == '-') /* "-sh" (login shell)? */
600 comm_len
= strlen(comm
);
601 /* Why compare up to comm_len, not COMM_LEN-1?
602 * Well, some processes rewrite argv, and use _spaces_ there
603 * while rewriting. (KDE is observed to do it).
604 * I prefer to still treat argv0 "process foo bar"
605 * as 'equal' to comm "process".
607 if (strncmp(base
, comm
, comm_len
) != 0) {
610 memmove(buf
+ comm_len
, buf
, col
- comm_len
);
611 snprintf(buf
, col
, "{%s}", comm
);
614 buf
[comm_len
- 1] = ' ';
619 snprintf(buf
, col
, "[%s]", comm
);
624 // pid comm S ppid pgid sid tty_nr tty_pgrp flg
625 sprintf(buffer,"%d (%s) %c %d %d %d %d %d %lu %lu \
626 %lu %lu %lu %lu %lu %ld %ld %ld %ld %d 0 %llu %lu %ld %lu %lu %lu %lu %lu \
627 %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %lu %llu\n",
641 cputime_to_clock_t(utime),
642 cputime_to_clock_t(stime),
643 cputime_to_clock_t(cutime),
644 cputime_to_clock_t(cstime),
651 mm ? get_mm_rss(mm) : 0,
653 mm ? mm->start_code : 0,
654 mm ? mm->end_code : 0,
655 mm ? mm->start_stack : 0,
658 the rest is some obsolete cruft