~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/proc/array.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.10 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.83 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.153 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.200 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.200 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.76 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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/smp.h>
 72 #include <linux/signal.h>
 73 #include <linux/highmem.h>
 74 #include <linux/file.h>
 75 #include <linux/fdtable.h>
 76 #include <linux/times.h>
 77 #include <linux/cpuset.h>
 78 #include <linux/rcupdate.h>
 79 #include <linux/delayacct.h>
 80 #include <linux/seq_file.h>
 81 #include <linux/pid_namespace.h>
 82 #include <linux/ptrace.h>
 83 #include <linux/tracehook.h>
 84 #include <linux/string_helpers.h>
 85 #include <linux/user_namespace.h>
 86 
 87 #include <asm/pgtable.h>
 88 #include <asm/processor.h>
 89 #include "internal.h"
 90 
 91 static inline void task_name(struct seq_file *m, struct task_struct *p)
 92 {
 93         char *buf;
 94         size_t size;
 95         char tcomm[sizeof(p->comm)];
 96         int ret;
 97 
 98         get_task_comm(tcomm, p);
 99 
100         seq_puts(m, "Name:\t");
101 
102         size = seq_get_buf(m, &buf);
103         ret = string_escape_str(tcomm, buf, size, ESCAPE_SPACE | ESCAPE_SPECIAL, "\n\\");
104         seq_commit(m, ret < size ? ret : -1);
105 
106         seq_putc(m, '\n');
107 }
108 
109 /*
110  * The task state array is a strange "bitmap" of
111  * reasons to sleep. Thus "running" is zero, and
112  * you can test for combinations of others with
113  * simple bit tests.
114  */
115 static const char * const task_state_array[] = {
116         "R (running)",          /*   0 */
117         "S (sleeping)",         /*   1 */
118         "D (disk sleep)",       /*   2 */
119         "T (stopped)",          /*   4 */
120         "t (tracing stop)",     /*   8 */
121         "X (dead)",             /*  16 */
122         "Z (zombie)",           /*  32 */
123 };
124 
125 static inline const char *get_task_state(struct task_struct *tsk)
126 {
127         unsigned int state = (tsk->state | tsk->exit_state) & TASK_REPORT;
128 
129         /*
130          * Parked tasks do not run; they sit in __kthread_parkme().
131          * Without this check, we would report them as running, which is
132          * clearly wrong, so we report them as sleeping instead.
133          */
134         if (tsk->state == TASK_PARKED)
135                 state = TASK_INTERRUPTIBLE;
136 
137         BUILD_BUG_ON(1 + ilog2(TASK_REPORT) != ARRAY_SIZE(task_state_array)-1);
138 
139         return task_state_array[fls(state)];
140 }
141 
142 static inline void task_state(struct seq_file *m, struct pid_namespace *ns,
143                                 struct pid *pid, struct task_struct *p)
144 {
145         struct user_namespace *user_ns = seq_user_ns(m);
146         struct group_info *group_info;
147         int g;
148         struct task_struct *tracer;
149         const struct cred *cred;
150         pid_t ppid, tpid = 0, tgid, ngid;
151         unsigned int max_fds = 0;
152 
153         rcu_read_lock();
154         ppid = pid_alive(p) ?
155                 task_tgid_nr_ns(rcu_dereference(p->real_parent), ns) : 0;
156 
157         tracer = ptrace_parent(p);
158         if (tracer)
159                 tpid = task_pid_nr_ns(tracer, ns);
160 
161         tgid = task_tgid_nr_ns(p, ns);
162         ngid = task_numa_group_id(p);
163         cred = get_task_cred(p);
164 
165         task_lock(p);
166         if (p->files)
167                 max_fds = files_fdtable(p->files)->max_fds;
168         task_unlock(p);
169         rcu_read_unlock();
170 
171         seq_printf(m,
172                 "State:\t%s\n"
173                 "Tgid:\t%d\n"
174                 "Ngid:\t%d\n"
175                 "Pid:\t%d\n"
176                 "PPid:\t%d\n"
177                 "TracerPid:\t%d\n"
178                 "Uid:\t%d\t%d\t%d\t%d\n"
179                 "Gid:\t%d\t%d\t%d\t%d\n"
180                 "FDSize:\t%d\nGroups:\t",
181                 get_task_state(p),
182                 tgid, ngid, pid_nr_ns(pid, ns), ppid, tpid,
183                 from_kuid_munged(user_ns, cred->uid),
184                 from_kuid_munged(user_ns, cred->euid),
185                 from_kuid_munged(user_ns, cred->suid),
186                 from_kuid_munged(user_ns, cred->fsuid),
187                 from_kgid_munged(user_ns, cred->gid),
188                 from_kgid_munged(user_ns, cred->egid),
189                 from_kgid_munged(user_ns, cred->sgid),
190                 from_kgid_munged(user_ns, cred->fsgid),
191                 max_fds);
192 
193         group_info = cred->group_info;
194         for (g = 0; g < group_info->ngroups; g++)
195                 seq_printf(m, "%d ",
196                            from_kgid_munged(user_ns, GROUP_AT(group_info, g)));
197         put_cred(cred);
198 
199 #ifdef CONFIG_PID_NS
200         seq_puts(m, "\nNStgid:");
201         for (g = ns->level; g <= pid->level; g++)
202                 seq_printf(m, "\t%d",
203                         task_tgid_nr_ns(p, pid->numbers[g].ns));
204         seq_puts(m, "\nNSpid:");
205         for (g = ns->level; g <= pid->level; g++)
206                 seq_printf(m, "\t%d",
207                         task_pid_nr_ns(p, pid->numbers[g].ns));
208         seq_puts(m, "\nNSpgid:");
209         for (g = ns->level; g <= pid->level; g++)
210                 seq_printf(m, "\t%d",
211                         task_pgrp_nr_ns(p, pid->numbers[g].ns));
212         seq_puts(m, "\nNSsid:");
213         for (g = ns->level; g <= pid->level; g++)
214                 seq_printf(m, "\t%d",
215                         task_session_nr_ns(p, pid->numbers[g].ns));
216 #endif
217         seq_putc(m, '\n');
218 }
219 
220 void render_sigset_t(struct seq_file *m, const char *header,
221                                 sigset_t *set)
222 {
223         int i;
224 
225         seq_puts(m, header);
226 
227         i = _NSIG;
228         do {
229                 int x = 0;
230 
231                 i -= 4;
232                 if (sigismember(set, i+1)) x |= 1;
233                 if (sigismember(set, i+2)) x |= 2;
234                 if (sigismember(set, i+3)) x |= 4;
235                 if (sigismember(set, i+4)) x |= 8;
236                 seq_printf(m, "%x", x);
237         } while (i >= 4);
238 
239         seq_putc(m, '\n');
240 }
241 
242 static void collect_sigign_sigcatch(struct task_struct *p, sigset_t *ign,
243                                     sigset_t *catch)
244 {
245         struct k_sigaction *k;
246         int i;
247 
248         k = p->sighand->action;
249         for (i = 1; i <= _NSIG; ++i, ++k) {
250                 if (k->sa.sa_handler == SIG_IGN)
251                         sigaddset(ign, i);
252                 else if (k->sa.sa_handler != SIG_DFL)
253                         sigaddset(catch, i);
254         }
255 }
256 
257 static inline void task_sig(struct seq_file *m, struct task_struct *p)
258 {
259         unsigned long flags;
260         sigset_t pending, shpending, blocked, ignored, caught;
261         int num_threads = 0;
262         unsigned long qsize = 0;
263         unsigned long qlim = 0;
264 
265         sigemptyset(&pending);
266         sigemptyset(&shpending);
267         sigemptyset(&blocked);
268         sigemptyset(&ignored);
269         sigemptyset(&caught);
270 
271         if (lock_task_sighand(p, &flags)) {
272                 pending = p->pending.signal;
273                 shpending = p->signal->shared_pending.signal;
274                 blocked = p->blocked;
275                 collect_sigign_sigcatch(p, &ignored, &caught);
276                 num_threads = get_nr_threads(p);
277                 rcu_read_lock();  /* FIXME: is this correct? */
278                 qsize = atomic_read(&__task_cred(p)->user->sigpending);
279                 rcu_read_unlock();
280                 qlim = task_rlimit(p, RLIMIT_SIGPENDING);
281                 unlock_task_sighand(p, &flags);
282         }
283 
284         seq_printf(m, "Threads:\t%d\n", num_threads);
285         seq_printf(m, "SigQ:\t%lu/%lu\n", qsize, qlim);
286 
287         /* render them all */
288         render_sigset_t(m, "SigPnd:\t", &pending);
289         render_sigset_t(m, "ShdPnd:\t", &shpending);
290         render_sigset_t(m, "SigBlk:\t", &blocked);
291         render_sigset_t(m, "SigIgn:\t", &ignored);
292         render_sigset_t(m, "SigCgt:\t", &caught);
293 }
294 
295 static void render_cap_t(struct seq_file *m, const char *header,
296                         kernel_cap_t *a)
297 {
298         unsigned __capi;
299 
300         seq_puts(m, header);
301         CAP_FOR_EACH_U32(__capi) {
302                 seq_printf(m, "%08x",
303                            a->cap[CAP_LAST_U32 - __capi]);
304         }
305         seq_putc(m, '\n');
306 }
307 
308 static inline void task_cap(struct seq_file *m, struct task_struct *p)
309 {
310         const struct cred *cred;
311         kernel_cap_t cap_inheritable, cap_permitted, cap_effective,
312                         cap_bset, cap_ambient;
313 
314         rcu_read_lock();
315         cred = __task_cred(p);
316         cap_inheritable = cred->cap_inheritable;
317         cap_permitted   = cred->cap_permitted;
318         cap_effective   = cred->cap_effective;
319         cap_bset        = cred->cap_bset;
320         cap_ambient     = cred->cap_ambient;
321         rcu_read_unlock();
322 
323         render_cap_t(m, "CapInh:\t", &cap_inheritable);
324         render_cap_t(m, "CapPrm:\t", &cap_permitted);
325         render_cap_t(m, "CapEff:\t", &cap_effective);
326         render_cap_t(m, "CapBnd:\t", &cap_bset);
327         render_cap_t(m, "CapAmb:\t", &cap_ambient);
328 }
329 
330 static inline void task_seccomp(struct seq_file *m, struct task_struct *p)
331 {
332 #ifdef CONFIG_SECCOMP
333         seq_printf(m, "Seccomp:\t%d\n", p->seccomp.mode);
334 #endif
335 }
336 
337 static inline void task_context_switch_counts(struct seq_file *m,
338                                                 struct task_struct *p)
339 {
340         seq_printf(m,   "voluntary_ctxt_switches:\t%lu\n"
341                         "nonvoluntary_ctxt_switches:\t%lu\n",
342                         p->nvcsw,
343                         p->nivcsw);
344 }
345 
346 static void task_cpus_allowed(struct seq_file *m, struct task_struct *task)
347 {
348         seq_printf(m, "Cpus_allowed:\t%*pb\n",
349                    cpumask_pr_args(&task->cpus_allowed));
350         seq_printf(m, "Cpus_allowed_list:\t%*pbl\n",
351                    cpumask_pr_args(&task->cpus_allowed));
352 }
353 
354 int proc_pid_status(struct seq_file *m, struct pid_namespace *ns,
355                         struct pid *pid, struct task_struct *task)
356 {
357         struct mm_struct *mm = get_task_mm(task);
358 
359         task_name(m, task);
360         task_state(m, ns, pid, task);
361 
362         if (mm) {
363                 task_mem(m, mm);
364                 mmput(mm);
365         }
366         task_sig(m, task);
367         task_cap(m, task);
368         task_seccomp(m, task);
369         task_cpus_allowed(m, task);
370         cpuset_task_status_allowed(m, task);
371         task_context_switch_counts(m, task);
372         return 0;
373 }
374 
375 static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
376                         struct pid *pid, struct task_struct *task, int whole)
377 {
378         unsigned long vsize, eip, esp, wchan = 0;
379         int priority, nice;
380         int tty_pgrp = -1, tty_nr = 0;
381         sigset_t sigign, sigcatch;
382         char state;
383         pid_t ppid = 0, pgid = -1, sid = -1;
384         int num_threads = 0;
385         int permitted;
386         struct mm_struct *mm;
387         unsigned long long start_time;
388         unsigned long cmin_flt = 0, cmaj_flt = 0;
389         unsigned long  min_flt = 0,  maj_flt = 0;
390         cputime_t cutime, cstime, utime, stime;
391         cputime_t cgtime, gtime;
392         unsigned long rsslim = 0;
393         char tcomm[sizeof(task->comm)];
394         unsigned long flags;
395 
396         state = *get_task_state(task);
397         vsize = eip = esp = 0;
398         permitted = ptrace_may_access(task, PTRACE_MODE_READ_FSCREDS | PTRACE_MODE_NOAUDIT);
399         mm = get_task_mm(task);
400         if (mm) {
401                 vsize = task_vsize(mm);
402                 if (permitted) {
403                         eip = KSTK_EIP(task);
404                         esp = KSTK_ESP(task);
405                 }
406         }
407 
408         get_task_comm(tcomm, task);
409 
410         sigemptyset(&sigign);
411         sigemptyset(&sigcatch);
412         cutime = cstime = utime = stime = 0;
413         cgtime = gtime = 0;
414 
415         if (lock_task_sighand(task, &flags)) {
416                 struct signal_struct *sig = task->signal;
417 
418                 if (sig->tty) {
419                         struct pid *pgrp = tty_get_pgrp(sig->tty);
420                         tty_pgrp = pid_nr_ns(pgrp, ns);
421                         put_pid(pgrp);
422                         tty_nr = new_encode_dev(tty_devnum(sig->tty));
423                 }
424 
425                 num_threads = get_nr_threads(task);
426                 collect_sigign_sigcatch(task, &sigign, &sigcatch);
427 
428                 cmin_flt = sig->cmin_flt;
429                 cmaj_flt = sig->cmaj_flt;
430                 cutime = sig->cutime;
431                 cstime = sig->cstime;
432                 cgtime = sig->cgtime;
433                 rsslim = ACCESS_ONCE(sig->rlim[RLIMIT_RSS].rlim_cur);
434 
435                 /* add up live thread stats at the group level */
436                 if (whole) {
437                         struct task_struct *t = task;
438                         do {
439                                 min_flt += t->min_flt;
440                                 maj_flt += t->maj_flt;
441                                 gtime += task_gtime(t);
442                         } while_each_thread(task, t);
443 
444                         min_flt += sig->min_flt;
445                         maj_flt += sig->maj_flt;
446                         thread_group_cputime_adjusted(task, &utime, &stime);
447                         gtime += sig->gtime;
448                 }
449 
450                 sid = task_session_nr_ns(task, ns);
451                 ppid = task_tgid_nr_ns(task->real_parent, ns);
452                 pgid = task_pgrp_nr_ns(task, ns);
453 
454                 unlock_task_sighand(task, &flags);
455         }
456 
457         if (permitted && (!whole || num_threads < 2))
458                 wchan = get_wchan(task);
459         if (!whole) {
460                 min_flt = task->min_flt;
461                 maj_flt = task->maj_flt;
462                 task_cputime_adjusted(task, &utime, &stime);
463                 gtime = task_gtime(task);
464         }
465 
466         /* scale priority and nice values from timeslices to -20..20 */
467         /* to make it look like a "normal" Unix priority/nice value  */
468         priority = task_prio(task);
469         nice = task_nice(task);
470 
471         /* convert nsec -> ticks */
472         start_time = nsec_to_clock_t(task->real_start_time);
473 
474         seq_printf(m, "%d (%s) %c", pid_nr_ns(pid, ns), tcomm, state);
475         seq_put_decimal_ll(m, ' ', ppid);
476         seq_put_decimal_ll(m, ' ', pgid);
477         seq_put_decimal_ll(m, ' ', sid);
478         seq_put_decimal_ll(m, ' ', tty_nr);
479         seq_put_decimal_ll(m, ' ', tty_pgrp);
480         seq_put_decimal_ull(m, ' ', task->flags);
481         seq_put_decimal_ull(m, ' ', min_flt);
482         seq_put_decimal_ull(m, ' ', cmin_flt);
483         seq_put_decimal_ull(m, ' ', maj_flt);
484         seq_put_decimal_ull(m, ' ', cmaj_flt);
485         seq_put_decimal_ull(m, ' ', cputime_to_clock_t(utime));
486         seq_put_decimal_ull(m, ' ', cputime_to_clock_t(stime));
487         seq_put_decimal_ll(m, ' ', cputime_to_clock_t(cutime));
488         seq_put_decimal_ll(m, ' ', cputime_to_clock_t(cstime));
489         seq_put_decimal_ll(m, ' ', priority);
490         seq_put_decimal_ll(m, ' ', nice);
491         seq_put_decimal_ll(m, ' ', num_threads);
492         seq_put_decimal_ull(m, ' ', 0);
493         seq_put_decimal_ull(m, ' ', start_time);
494         seq_put_decimal_ull(m, ' ', vsize);
495         seq_put_decimal_ull(m, ' ', mm ? get_mm_rss(mm) : 0);
496         seq_put_decimal_ull(m, ' ', rsslim);
497         seq_put_decimal_ull(m, ' ', mm ? (permitted ? mm->start_code : 1) : 0);
498         seq_put_decimal_ull(m, ' ', mm ? (permitted ? mm->end_code : 1) : 0);
499         seq_put_decimal_ull(m, ' ', (permitted && mm) ? mm->start_stack : 0);
500         seq_put_decimal_ull(m, ' ', esp);
501         seq_put_decimal_ull(m, ' ', eip);
502         /* The signal information here is obsolete.
503          * It must be decimal for Linux 2.0 compatibility.
504          * Use /proc/#/status for real-time signals.
505          */
506         seq_put_decimal_ull(m, ' ', task->pending.signal.sig[0] & 0x7fffffffUL);
507         seq_put_decimal_ull(m, ' ', task->blocked.sig[0] & 0x7fffffffUL);
508         seq_put_decimal_ull(m, ' ', sigign.sig[0] & 0x7fffffffUL);
509         seq_put_decimal_ull(m, ' ', sigcatch.sig[0] & 0x7fffffffUL);
510 
511         /*
512          * We used to output the absolute kernel address, but that's an
513          * information leak - so instead we show a 0/1 flag here, to signal
514          * to user-space whether there's a wchan field in /proc/PID/wchan.
515          *
516          * This works with older implementations of procps as well.
517          */
518         if (wchan)
519                 seq_puts(m, " 1");
520         else
521                 seq_puts(m, " 0");
522 
523         seq_put_decimal_ull(m, ' ', 0);
524         seq_put_decimal_ull(m, ' ', 0);
525         seq_put_decimal_ll(m, ' ', task->exit_signal);
526         seq_put_decimal_ll(m, ' ', task_cpu(task));
527         seq_put_decimal_ull(m, ' ', task->rt_priority);
528         seq_put_decimal_ull(m, ' ', task->policy);
529         seq_put_decimal_ull(m, ' ', delayacct_blkio_ticks(task));
530         seq_put_decimal_ull(m, ' ', cputime_to_clock_t(gtime));
531         seq_put_decimal_ll(m, ' ', cputime_to_clock_t(cgtime));
532 
533         if (mm && permitted) {
534                 seq_put_decimal_ull(m, ' ', mm->start_data);
535                 seq_put_decimal_ull(m, ' ', mm->end_data);
536                 seq_put_decimal_ull(m, ' ', mm->start_brk);
537                 seq_put_decimal_ull(m, ' ', mm->arg_start);
538                 seq_put_decimal_ull(m, ' ', mm->arg_end);
539                 seq_put_decimal_ull(m, ' ', mm->env_start);
540                 seq_put_decimal_ull(m, ' ', mm->env_end);
541         } else
542                 seq_printf(m, " 0 0 0 0 0 0 0");
543 
544         if (permitted)
545                 seq_put_decimal_ll(m, ' ', task->exit_code);
546         else
547                 seq_put_decimal_ll(m, ' ', 0);
548 
549         seq_putc(m, '\n');
550         if (mm)
551                 mmput(mm);
552         return 0;
553 }
554 
555 int proc_tid_stat(struct seq_file *m, struct pid_namespace *ns,
556                         struct pid *pid, struct task_struct *task)
557 {
558         return do_task_stat(m, ns, pid, task, 0);
559 }
560 
561 int proc_tgid_stat(struct seq_file *m, struct pid_namespace *ns,
562                         struct pid *pid, struct task_struct *task)
563 {
564         return do_task_stat(m, ns, pid, task, 1);
565 }
566 
567 int proc_pid_statm(struct seq_file *m, struct pid_namespace *ns,
568                         struct pid *pid, struct task_struct *task)
569 {
570         unsigned long size = 0, resident = 0, shared = 0, text = 0, data = 0;
571         struct mm_struct *mm = get_task_mm(task);
572 
573         if (mm) {
574                 size = task_statm(mm, &shared, &text, &data, &resident);
575                 mmput(mm);
576         }
577         /*
578          * For quick read, open code by putting numbers directly
579          * expected format is
580          * seq_printf(m, "%lu %lu %lu %lu 0 %lu 0\n",
581          *               size, resident, shared, text, data);
582          */
583         seq_put_decimal_ull(m, 0, size);
584         seq_put_decimal_ull(m, ' ', resident);
585         seq_put_decimal_ull(m, ' ', shared);
586         seq_put_decimal_ull(m, ' ', text);
587         seq_put_decimal_ull(m, ' ', 0);
588         seq_put_decimal_ull(m, ' ', data);
589         seq_put_decimal_ull(m, ' ', 0);
590         seq_putc(m, '\n');
591 
592         return 0;
593 }
594 
595 #ifdef CONFIG_PROC_CHILDREN
596 static struct pid *
597 get_children_pid(struct inode *inode, struct pid *pid_prev, loff_t pos)
598 {
599         struct task_struct *start, *task;
600         struct pid *pid = NULL;
601 
602         read_lock(&tasklist_lock);
603 
604         start = pid_task(proc_pid(inode), PIDTYPE_PID);
605         if (!start)
606                 goto out;
607 
608         /*
609          * Lets try to continue searching first, this gives
610          * us significant speedup on children-rich processes.
611          */
612         if (pid_prev) {
613                 task = pid_task(pid_prev, PIDTYPE_PID);
614                 if (task && task->real_parent == start &&
615                     !(list_empty(&task->sibling))) {
616                         if (list_is_last(&task->sibling, &start->children))
617                                 goto out;
618                         task = list_first_entry(&task->sibling,
619                                                 struct task_struct, sibling);
620                         pid = get_pid(task_pid(task));
621                         goto out;
622                 }
623         }
624 
625         /*
626          * Slow search case.
627          *
628          * We might miss some children here if children
629          * are exited while we were not holding the lock,
630          * but it was never promised to be accurate that
631          * much.
632          *
633          * "Just suppose that the parent sleeps, but N children
634          *  exit after we printed their tids. Now the slow paths
635          *  skips N extra children, we miss N tasks." (c)
636          *
637          * So one need to stop or freeze the leader and all
638          * its children to get a precise result.
639          */
640         list_for_each_entry(task, &start->children, sibling) {
641                 if (pos-- == 0) {
642                         pid = get_pid(task_pid(task));
643                         break;
644                 }
645         }
646 
647 out:
648         read_unlock(&tasklist_lock);
649         return pid;
650 }
651 
652 static int children_seq_show(struct seq_file *seq, void *v)
653 {
654         struct inode *inode = seq->private;
655         pid_t pid;
656 
657         pid = pid_nr_ns(v, inode->i_sb->s_fs_info);
658         seq_printf(seq, "%d ", pid);
659 
660         return 0;
661 }
662 
663 static void *children_seq_start(struct seq_file *seq, loff_t *pos)
664 {
665         return get_children_pid(seq->private, NULL, *pos);
666 }
667 
668 static void *children_seq_next(struct seq_file *seq, void *v, loff_t *pos)
669 {
670         struct pid *pid;
671 
672         pid = get_children_pid(seq->private, v, *pos + 1);
673         put_pid(v);
674 
675         ++*pos;
676         return pid;
677 }
678 
679 static void children_seq_stop(struct seq_file *seq, void *v)
680 {
681         put_pid(v);
682 }
683 
684 static const struct seq_operations children_seq_ops = {
685         .start  = children_seq_start,
686         .next   = children_seq_next,
687         .stop   = children_seq_stop,
688         .show   = children_seq_show,
689 };
690 
691 static int children_seq_open(struct inode *inode, struct file *file)
692 {
693         struct seq_file *m;
694         int ret;
695 
696         ret = seq_open(file, &children_seq_ops);
697         if (ret)
698                 return ret;
699 
700         m = file->private_data;
701         m->private = inode;
702 
703         return ret;
704 }
705 
706 int children_seq_release(struct inode *inode, struct file *file)
707 {
708         seq_release(inode, file);
709         return 0;
710 }
711 
712 const struct file_operations proc_tid_children_operations = {
713         .open    = children_seq_open,
714         .read    = seq_read,
715         .llseek  = seq_lseek,
716         .release = children_seq_release,
717 };
718 #endif /* CONFIG_PROC_CHILDREN */
719 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp