Root/
1 | /* |
2 | * linux/fs/proc/array.c |
3 | * |
4 | * Copyright (C) 1992 by Linus Torvalds |
5 | * based on ideas by Darren Senn |
6 | * |
7 | * Fixes: |
8 | * Michael. K. Johnson: stat,statm extensions. |
9 | * <johnsonm@stolaf.edu> |
10 | * |
11 | * Pauline Middelink : Made cmdline,envline only break at '\0's, to |
12 | * make sure SET_PROCTITLE works. Also removed |
13 | * bad '!' which forced address recalculation for |
14 | * EVERY character on the current page. |
15 | * <middelin@polyware.iaf.nl> |
16 | * |
17 | * Danny ter Haar : added cpuinfo |
18 | * <dth@cistron.nl> |
19 | * |
20 | * Alessandro Rubini : profile extension. |
21 | * <rubini@ipvvis.unipv.it> |
22 | * |
23 | * Jeff Tranter : added BogoMips field to cpuinfo |
24 | * <Jeff_Tranter@Mitel.COM> |
25 | * |
26 | * Bruno Haible : remove 4K limit for the maps file |
27 | * <haible@ma2s2.mathematik.uni-karlsruhe.de> |
28 | * |
29 | * Yves Arrouye : remove removal of trailing spaces in get_array. |
30 | * <Yves.Arrouye@marin.fdn.fr> |
31 | * |
32 | * Jerome Forissier : added per-CPU time information to /proc/stat |
33 | * and /proc/<pid>/cpu extension |
34 | * <forissier@isia.cma.fr> |
35 | * - Incorporation and non-SMP safe operation |
36 | * of forissier patch in 2.1.78 by |
37 | * Hans Marcus <crowbar@concepts.nl> |
38 | * |
39 | * aeb@cwi.nl : /proc/partitions |
40 | * |
41 | * |
42 | * Alan Cox : security fixes. |
43 | * <alan@lxorguk.ukuu.org.uk> |
44 | * |
45 | * Al Viro : safe handling of mm_struct |
46 | * |
47 | * Gerhard Wichert : added BIGMEM support |
48 | * Siemens AG <Gerhard.Wichert@pdb.siemens.de> |
49 | * |
50 | * Al Viro & Jeff Garzik : moved most of the thing into base.c and |
51 | * : proc_misc.c. The rest may eventually go into |
52 | * : base.c too. |
53 | */ |
54 | |
55 | #include <linux/types.h> |
56 | #include <linux/errno.h> |
57 | #include <linux/time.h> |
58 | #include <linux/kernel.h> |
59 | #include <linux/kernel_stat.h> |
60 | #include <linux/tty.h> |
61 | #include <linux/string.h> |
62 | #include <linux/mman.h> |
63 | #include <linux/proc_fs.h> |
64 | #include <linux/ioport.h> |
65 | #include <linux/uaccess.h> |
66 | #include <linux/io.h> |
67 | #include <linux/mm.h> |
68 | #include <linux/hugetlb.h> |
69 | #include <linux/pagemap.h> |
70 | #include <linux/swap.h> |
71 | #include <linux/slab.h> |
72 | #include <linux/smp.h> |
73 | #include <linux/signal.h> |
74 | #include <linux/highmem.h> |
75 | #include <linux/file.h> |
76 | #include <linux/fdtable.h> |
77 | #include <linux/times.h> |
78 | #include <linux/cpuset.h> |
79 | #include <linux/rcupdate.h> |
80 | #include <linux/delayacct.h> |
81 | #include <linux/seq_file.h> |
82 | #include <linux/pid_namespace.h> |
83 | #include <linux/ptrace.h> |
84 | #include <linux/tracehook.h> |
85 | |
86 | #include <asm/pgtable.h> |
87 | #include <asm/processor.h> |
88 | #include "internal.h" |
89 | |
90 | static inline void task_name(struct seq_file *m, struct task_struct *p) |
91 | { |
92 | int i; |
93 | char *buf, *end; |
94 | char *name; |
95 | char tcomm[sizeof(p->comm)]; |
96 | |
97 | get_task_comm(tcomm, p); |
98 | |
99 | seq_printf(m, "Name:\t"); |
100 | end = m->buf + m->size; |
101 | buf = m->buf + m->count; |
102 | name = tcomm; |
103 | i = sizeof(tcomm); |
104 | while (i && (buf < end)) { |
105 | unsigned char c = *name; |
106 | name++; |
107 | i--; |
108 | *buf = c; |
109 | if (!c) |
110 | break; |
111 | if (c == '\\') { |
112 | buf++; |
113 | if (buf < end) |
114 | *buf++ = c; |
115 | continue; |
116 | } |
117 | if (c == '\n') { |
118 | *buf++ = '\\'; |
119 | if (buf < end) |
120 | *buf++ = 'n'; |
121 | continue; |
122 | } |
123 | buf++; |
124 | } |
125 | m->count = buf - m->buf; |
126 | seq_printf(m, "\n"); |
127 | } |
128 | |
129 | /* |
130 | * The task state array is a strange "bitmap" of |
131 | * reasons to sleep. Thus "running" is zero, and |
132 | * you can test for combinations of others with |
133 | * simple bit tests. |
134 | */ |
135 | static const char *task_state_array[] = { |
136 | "R (running)", /* 0 */ |
137 | "S (sleeping)", /* 1 */ |
138 | "D (disk sleep)", /* 2 */ |
139 | "T (stopped)", /* 4 */ |
140 | "T (tracing stop)", /* 8 */ |
141 | "Z (zombie)", /* 16 */ |
142 | "X (dead)" /* 32 */ |
143 | }; |
144 | |
145 | static inline const char *get_task_state(struct task_struct *tsk) |
146 | { |
147 | unsigned int state = (tsk->state & TASK_REPORT) | tsk->exit_state; |
148 | const char **p = &task_state_array[0]; |
149 | |
150 | while (state) { |
151 | p++; |
152 | state >>= 1; |
153 | } |
154 | return *p; |
155 | } |
156 | |
157 | static inline void task_state(struct seq_file *m, struct pid_namespace *ns, |
158 | struct pid *pid, struct task_struct *p) |
159 | { |
160 | struct group_info *group_info; |
161 | int g; |
162 | struct fdtable *fdt = NULL; |
163 | const struct cred *cred; |
164 | pid_t ppid, tpid; |
165 | |
166 | rcu_read_lock(); |
167 | ppid = pid_alive(p) ? |
168 | task_tgid_nr_ns(rcu_dereference(p->real_parent), ns) : 0; |
169 | tpid = 0; |
170 | if (pid_alive(p)) { |
171 | struct task_struct *tracer = tracehook_tracer_task(p); |
172 | if (tracer) |
173 | tpid = task_pid_nr_ns(tracer, ns); |
174 | } |
175 | cred = get_cred((struct cred *) __task_cred(p)); |
176 | seq_printf(m, |
177 | "State:\t%s\n" |
178 | "Tgid:\t%d\n" |
179 | "Pid:\t%d\n" |
180 | "PPid:\t%d\n" |
181 | "TracerPid:\t%d\n" |
182 | "Uid:\t%d\t%d\t%d\t%d\n" |
183 | "Gid:\t%d\t%d\t%d\t%d\n", |
184 | get_task_state(p), |
185 | task_tgid_nr_ns(p, ns), |
186 | pid_nr_ns(pid, ns), |
187 | ppid, tpid, |
188 | cred->uid, cred->euid, cred->suid, cred->fsuid, |
189 | cred->gid, cred->egid, cred->sgid, cred->fsgid); |
190 | |
191 | task_lock(p); |
192 | if (p->files) |
193 | fdt = files_fdtable(p->files); |
194 | seq_printf(m, |
195 | "FDSize:\t%d\n" |
196 | "Groups:\t", |
197 | fdt ? fdt->max_fds : 0); |
198 | rcu_read_unlock(); |
199 | |
200 | group_info = cred->group_info; |
201 | task_unlock(p); |
202 | |
203 | for (g = 0; g < min(group_info->ngroups, NGROUPS_SMALL); g++) |
204 | seq_printf(m, "%d ", GROUP_AT(group_info, g)); |
205 | put_cred(cred); |
206 | |
207 | seq_printf(m, "\n"); |
208 | } |
209 | |
210 | static void render_sigset_t(struct seq_file *m, const char *header, |
211 | sigset_t *set) |
212 | { |
213 | int i; |
214 | |
215 | seq_printf(m, "%s", header); |
216 | |
217 | i = _NSIG; |
218 | do { |
219 | int x = 0; |
220 | |
221 | i -= 4; |
222 | if (sigismember(set, i+1)) x |= 1; |
223 | if (sigismember(set, i+2)) x |= 2; |
224 | if (sigismember(set, i+3)) x |= 4; |
225 | if (sigismember(set, i+4)) x |= 8; |
226 | seq_printf(m, "%x", x); |
227 | } while (i >= 4); |
228 | |
229 | seq_printf(m, "\n"); |
230 | } |
231 | |
232 | static void collect_sigign_sigcatch(struct task_struct *p, sigset_t *ign, |
233 | sigset_t *catch) |
234 | { |
235 | struct k_sigaction *k; |
236 | int i; |
237 | |
238 | k = p->sighand->action; |
239 | for (i = 1; i <= _NSIG; ++i, ++k) { |
240 | if (k->sa.sa_handler == SIG_IGN) |
241 | sigaddset(ign, i); |
242 | else if (k->sa.sa_handler != SIG_DFL) |
243 | sigaddset(catch, i); |
244 | } |
245 | } |
246 | |
247 | static inline void task_sig(struct seq_file *m, struct task_struct *p) |
248 | { |
249 | unsigned long flags; |
250 | sigset_t pending, shpending, blocked, ignored, caught; |
251 | int num_threads = 0; |
252 | unsigned long qsize = 0; |
253 | unsigned long qlim = 0; |
254 | |
255 | sigemptyset(&pending); |
256 | sigemptyset(&shpending); |
257 | sigemptyset(&blocked); |
258 | sigemptyset(&ignored); |
259 | sigemptyset(&caught); |
260 | |
261 | if (lock_task_sighand(p, &flags)) { |
262 | pending = p->pending.signal; |
263 | shpending = p->signal->shared_pending.signal; |
264 | blocked = p->blocked; |
265 | collect_sigign_sigcatch(p, &ignored, &caught); |
266 | num_threads = atomic_read(&p->signal->count); |
267 | qsize = atomic_read(&__task_cred(p)->user->sigpending); |
268 | qlim = p->signal->rlim[RLIMIT_SIGPENDING].rlim_cur; |
269 | unlock_task_sighand(p, &flags); |
270 | } |
271 | |
272 | seq_printf(m, "Threads:\t%d\n", num_threads); |
273 | seq_printf(m, "SigQ:\t%lu/%lu\n", qsize, qlim); |
274 | |
275 | /* render them all */ |
276 | render_sigset_t(m, "SigPnd:\t", &pending); |
277 | render_sigset_t(m, "ShdPnd:\t", &shpending); |
278 | render_sigset_t(m, "SigBlk:\t", &blocked); |
279 | render_sigset_t(m, "SigIgn:\t", &ignored); |
280 | render_sigset_t(m, "SigCgt:\t", &caught); |
281 | } |
282 | |
283 | static void render_cap_t(struct seq_file *m, const char *header, |
284 | kernel_cap_t *a) |
285 | { |
286 | unsigned __capi; |
287 | |
288 | seq_printf(m, "%s", header); |
289 | CAP_FOR_EACH_U32(__capi) { |
290 | seq_printf(m, "%08x", |
291 | a->cap[(_KERNEL_CAPABILITY_U32S-1) - __capi]); |
292 | } |
293 | seq_printf(m, "\n"); |
294 | } |
295 | |
296 | static inline void task_cap(struct seq_file *m, struct task_struct *p) |
297 | { |
298 | const struct cred *cred; |
299 | kernel_cap_t cap_inheritable, cap_permitted, cap_effective, cap_bset; |
300 | |
301 | rcu_read_lock(); |
302 | cred = __task_cred(p); |
303 | cap_inheritable = cred->cap_inheritable; |
304 | cap_permitted = cred->cap_permitted; |
305 | cap_effective = cred->cap_effective; |
306 | cap_bset = cred->cap_bset; |
307 | rcu_read_unlock(); |
308 | |
309 | render_cap_t(m, "CapInh:\t", &cap_inheritable); |
310 | render_cap_t(m, "CapPrm:\t", &cap_permitted); |
311 | render_cap_t(m, "CapEff:\t", &cap_effective); |
312 | render_cap_t(m, "CapBnd:\t", &cap_bset); |
313 | } |
314 | |
315 | static inline void task_context_switch_counts(struct seq_file *m, |
316 | struct task_struct *p) |
317 | { |
318 | seq_printf(m, "voluntary_ctxt_switches:\t%lu\n" |
319 | "nonvoluntary_ctxt_switches:\t%lu\n", |
320 | p->nvcsw, |
321 | p->nivcsw); |
322 | } |
323 | |
324 | int proc_pid_status(struct seq_file *m, struct pid_namespace *ns, |
325 | struct pid *pid, struct task_struct *task) |
326 | { |
327 | struct mm_struct *mm = get_task_mm(task); |
328 | |
329 | task_name(m, task); |
330 | task_state(m, ns, pid, task); |
331 | |
332 | if (mm) { |
333 | task_mem(m, mm); |
334 | mmput(mm); |
335 | } |
336 | task_sig(m, task); |
337 | task_cap(m, task); |
338 | cpuset_task_status_allowed(m, task); |
339 | #if defined(CONFIG_S390) |
340 | task_show_regs(m, task); |
341 | #endif |
342 | task_context_switch_counts(m, task); |
343 | return 0; |
344 | } |
345 | |
346 | static int do_task_stat(struct seq_file *m, struct pid_namespace *ns, |
347 | struct pid *pid, struct task_struct *task, int whole) |
348 | { |
349 | unsigned long vsize, eip, esp, wchan = ~0UL; |
350 | long priority, nice; |
351 | int tty_pgrp = -1, tty_nr = 0; |
352 | sigset_t sigign, sigcatch; |
353 | char state; |
354 | pid_t ppid = 0, pgid = -1, sid = -1; |
355 | int num_threads = 0; |
356 | int permitted; |
357 | struct mm_struct *mm; |
358 | unsigned long long start_time; |
359 | unsigned long cmin_flt = 0, cmaj_flt = 0; |
360 | unsigned long min_flt = 0, maj_flt = 0; |
361 | cputime_t cutime, cstime, utime, stime; |
362 | cputime_t cgtime, gtime; |
363 | unsigned long rsslim = 0; |
364 | char tcomm[sizeof(task->comm)]; |
365 | unsigned long flags; |
366 | |
367 | state = *get_task_state(task); |
368 | vsize = eip = esp = 0; |
369 | permitted = ptrace_may_access(task, PTRACE_MODE_READ); |
370 | mm = get_task_mm(task); |
371 | if (mm) { |
372 | vsize = task_vsize(mm); |
373 | if (permitted) { |
374 | eip = KSTK_EIP(task); |
375 | esp = KSTK_ESP(task); |
376 | } |
377 | } |
378 | |
379 | get_task_comm(tcomm, task); |
380 | |
381 | sigemptyset(&sigign); |
382 | sigemptyset(&sigcatch); |
383 | cutime = cstime = utime = stime = cputime_zero; |
384 | cgtime = gtime = cputime_zero; |
385 | |
386 | if (lock_task_sighand(task, &flags)) { |
387 | struct signal_struct *sig = task->signal; |
388 | |
389 | if (sig->tty) { |
390 | struct pid *pgrp = tty_get_pgrp(sig->tty); |
391 | tty_pgrp = pid_nr_ns(pgrp, ns); |
392 | put_pid(pgrp); |
393 | tty_nr = new_encode_dev(tty_devnum(sig->tty)); |
394 | } |
395 | |
396 | num_threads = atomic_read(&sig->count); |
397 | collect_sigign_sigcatch(task, &sigign, &sigcatch); |
398 | |
399 | cmin_flt = sig->cmin_flt; |
400 | cmaj_flt = sig->cmaj_flt; |
401 | cutime = sig->cutime; |
402 | cstime = sig->cstime; |
403 | cgtime = sig->cgtime; |
404 | rsslim = sig->rlim[RLIMIT_RSS].rlim_cur; |
405 | |
406 | /* add up live thread stats at the group level */ |
407 | if (whole) { |
408 | struct task_cputime cputime; |
409 | struct task_struct *t = task; |
410 | do { |
411 | min_flt += t->min_flt; |
412 | maj_flt += t->maj_flt; |
413 | gtime = cputime_add(gtime, task_gtime(t)); |
414 | t = next_thread(t); |
415 | } while (t != task); |
416 | |
417 | min_flt += sig->min_flt; |
418 | maj_flt += sig->maj_flt; |
419 | thread_group_cputime(task, &cputime); |
420 | utime = cputime.utime; |
421 | stime = cputime.stime; |
422 | gtime = cputime_add(gtime, sig->gtime); |
423 | } |
424 | |
425 | sid = task_session_nr_ns(task, ns); |
426 | ppid = task_tgid_nr_ns(task->real_parent, ns); |
427 | pgid = task_pgrp_nr_ns(task, ns); |
428 | |
429 | unlock_task_sighand(task, &flags); |
430 | } |
431 | |
432 | if (permitted && (!whole || num_threads < 2)) |
433 | wchan = get_wchan(task); |
434 | if (!whole) { |
435 | min_flt = task->min_flt; |
436 | maj_flt = task->maj_flt; |
437 | utime = task_utime(task); |
438 | stime = task_stime(task); |
439 | gtime = task_gtime(task); |
440 | } |
441 | |
442 | /* scale priority and nice values from timeslices to -20..20 */ |
443 | /* to make it look like a "normal" Unix priority/nice value */ |
444 | priority = task_prio(task); |
445 | nice = task_nice(task); |
446 | |
447 | /* Temporary variable needed for gcc-2.96 */ |
448 | /* convert timespec -> nsec*/ |
449 | start_time = |
450 | (unsigned long long)task->real_start_time.tv_sec * NSEC_PER_SEC |
451 | + task->real_start_time.tv_nsec; |
452 | /* convert nsec -> ticks */ |
453 | start_time = nsec_to_clock_t(start_time); |
454 | |
455 | seq_printf(m, "%d (%s) %c %d %d %d %d %d %u %lu \ |
456 | %lu %lu %lu %lu %lu %ld %ld %ld %ld %d 0 %llu %lu %ld %lu %lu %lu %lu %lu \ |
457 | %lu %lu %lu %lu %lu %lu %lu %lu %d %d %u %u %llu %lu %ld\n", |
458 | pid_nr_ns(pid, ns), |
459 | tcomm, |
460 | state, |
461 | ppid, |
462 | pgid, |
463 | sid, |
464 | tty_nr, |
465 | tty_pgrp, |
466 | task->flags, |
467 | min_flt, |
468 | cmin_flt, |
469 | maj_flt, |
470 | cmaj_flt, |
471 | cputime_to_clock_t(utime), |
472 | cputime_to_clock_t(stime), |
473 | cputime_to_clock_t(cutime), |
474 | cputime_to_clock_t(cstime), |
475 | priority, |
476 | nice, |
477 | num_threads, |
478 | start_time, |
479 | vsize, |
480 | mm ? get_mm_rss(mm) : 0, |
481 | rsslim, |
482 | mm ? mm->start_code : 0, |
483 | mm ? mm->end_code : 0, |
484 | (permitted && mm) ? mm->start_stack : 0, |
485 | esp, |
486 | eip, |
487 | /* The signal information here is obsolete. |
488 | * It must be decimal for Linux 2.0 compatibility. |
489 | * Use /proc/#/status for real-time signals. |
490 | */ |
491 | task->pending.signal.sig[0] & 0x7fffffffUL, |
492 | task->blocked.sig[0] & 0x7fffffffUL, |
493 | sigign .sig[0] & 0x7fffffffUL, |
494 | sigcatch .sig[0] & 0x7fffffffUL, |
495 | wchan, |
496 | 0UL, |
497 | 0UL, |
498 | task->exit_signal, |
499 | task_cpu(task), |
500 | task->rt_priority, |
501 | task->policy, |
502 | (unsigned long long)delayacct_blkio_ticks(task), |
503 | cputime_to_clock_t(gtime), |
504 | cputime_to_clock_t(cgtime)); |
505 | if (mm) |
506 | mmput(mm); |
507 | return 0; |
508 | } |
509 | |
510 | int proc_tid_stat(struct seq_file *m, struct pid_namespace *ns, |
511 | struct pid *pid, struct task_struct *task) |
512 | { |
513 | return do_task_stat(m, ns, pid, task, 0); |
514 | } |
515 | |
516 | int proc_tgid_stat(struct seq_file *m, struct pid_namespace *ns, |
517 | struct pid *pid, struct task_struct *task) |
518 | { |
519 | return do_task_stat(m, ns, pid, task, 1); |
520 | } |
521 | |
522 | int proc_pid_statm(struct seq_file *m, struct pid_namespace *ns, |
523 | struct pid *pid, struct task_struct *task) |
524 | { |
525 | int size = 0, resident = 0, shared = 0, text = 0, lib = 0, data = 0; |
526 | struct mm_struct *mm = get_task_mm(task); |
527 | |
528 | if (mm) { |
529 | size = task_statm(mm, &shared, &text, &data, &resident); |
530 | mmput(mm); |
531 | } |
532 | seq_printf(m, "%d %d %d %d %d %d %d\n", |
533 | size, resident, shared, text, lib, data, 0); |
534 | |
535 | return 0; |
536 | } |
537 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9