Contents of /tags/mkinitrd-6_1_12/busybox/libbb/procps.c
Parent Directory | Revision Log
Revision 939 -
(show annotations)
(download)
Tue Nov 17 21:24:51 2009 UTC (14 years, 10 months ago) by niro
File MIME type: text/plain
File size: 12069 byte(s)
Tue Nov 17 21:24:51 2009 UTC (14 years, 10 months ago) by niro
File MIME type: text/plain
File size: 12069 byte(s)
tagged 'mkinitrd-6_1_12'
1 | /* 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 | * SELinux support: (c) 2007 by Yuichi Nakamura <ynakam@hitachisoft.jp> |
8 | * |
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 | void FAST_FUNC clear_username_cache(void) |
34 | { |
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 | cp->cache = xrealloc_vector(cp->cache, 2, i); |
50 | cp->cache[i++].id = id; |
51 | return -i; |
52 | } |
53 | #endif |
54 | |
55 | typedef char* FAST_FUNC ug_func(char *name, int bufsize, long uid); |
56 | 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 | cp->cache = xrealloc_vector(cp->cache, 2, i); |
64 | cp->cache[i].id = id; |
65 | /* Never fails. Generates numeric string if name isn't found */ |
66 | fp(cp->cache[i].name, sizeof(cp->cache[i].name), id); |
67 | return cp->cache[i].name; |
68 | } |
69 | const char* FAST_FUNC get_cached_username(uid_t uid) |
70 | { |
71 | return get_cached(&username, uid, bb_getpwuid); |
72 | } |
73 | const char* FAST_FUNC get_cached_groupname(gid_t gid) |
74 | { |
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 | 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 | ((char *)buf)[ret > 0 ? ret : 0] = '\0'; |
93 | return ret; |
94 | } |
95 | |
96 | static procps_status_t* FAST_FUNC alloc_procps_scan(void) |
97 | { |
98 | unsigned n = getpagesize(); |
99 | procps_status_t* sp = xzalloc(sizeof(procps_status_t)); |
100 | sp->dir = xopendir("/proc"); |
101 | 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 | return sp; |
108 | } |
109 | |
110 | void FAST_FUNC free_procps_scan(procps_status_t* sp) |
111 | { |
112 | closedir(sp->dir); |
113 | free(sp->argv0); |
114 | USE_SELINUX(free(sp->context);) |
115 | free(sp); |
116 | } |
117 | |
118 | #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 | void BUG_comm_size(void); |
166 | procps_status_t* FAST_FUNC procps_scan(procps_status_t* sp, int flags) |
167 | { |
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 | sp = alloc_procps_scan(); |
179 | |
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 | memset(&sp->vsz, 0, sizeof(*sp) - offsetof(procps_status_t, vsz)); |
195 | |
196 | sp->pid = pid; |
197 | if (!(flags & ~PSSCAN_PID)) break; |
198 | |
199 | #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 | 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 | char *cp, *comm1; |
218 | int tty; |
219 | #if !ENABLE_FEATURE_FAST_TOP |
220 | unsigned long vsz, rss; |
221 | #endif |
222 | /* 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 | /*if (!cp || cp[1] != ' ') |
229 | break;*/ |
230 | cp[0] = '\0'; |
231 | if (sizeof(sp->comm) < 16) |
232 | BUG_comm_size(); |
233 | comm1 = strchr(buf, '('); |
234 | /*if (comm1)*/ |
235 | safe_strncpy(sp->comm, comm1 + 1, sizeof(sp->comm)); |
236 | |
237 | #if !ENABLE_FEATURE_FAST_TOP |
238 | n = sscanf(cp+2, |
239 | "%c %u " /* state, ppid */ |
240 | "%u %u %d %*s " /* pgid, sid, tty, tpgid */ |
241 | "%*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 | "%*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 | sp->state, &sp->ppid, |
257 | &sp->pgid, &sp->sid, &tty, |
258 | &sp->utime, &sp->stime, |
259 | &tasknice, |
260 | &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 | break; |
270 | #if ENABLE_FEATURE_TOP_SMP_PROCESS |
271 | if (n < 11+15) |
272 | sp->last_seen_on_cpu = 0; |
273 | #endif |
274 | |
275 | /* 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 | sp->state[1] = 'W'; |
315 | else |
316 | sp->state[1] = ' '; |
317 | if (tasknice < 0) |
318 | sp->state[2] = '<'; |
319 | else if (tasknice) /* > 0 */ |
320 | sp->state[2] = 'N'; |
321 | else |
322 | sp->state[2] = ' '; |
323 | } |
324 | |
325 | #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 | } |
374 | #endif /* TOPMEM */ |
375 | |
376 | #if 0 /* PSSCAN_CMD is not used */ |
377 | if (flags & (PSSCAN_CMD|PSSCAN_ARGV0)) { |
378 | free(sp->argv0); |
379 | sp->argv0 = NULL; |
380 | free(sp->cmd); |
381 | sp->cmd = NULL; |
382 | strcpy(filename_tail, "/cmdline"); |
383 | /* TODO: to get rid of size limits, read into malloc buf, |
384 | * then realloc it down to real size. */ |
385 | n = read_to_buf(filename, buf); |
386 | if (n <= 0) |
387 | break; |
388 | 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 | } |
398 | } |
399 | #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 | break; |
419 | } |
420 | return sp; |
421 | } |
422 | |
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 | /* 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 | */ |