Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
exit.c
Go to the documentation of this file.
1 /*
2  * linux/kernel/exit.c
3  *
4  * Copyright (C) 1991, 1992 Linus Torvalds
5  */
6 
7 #include <linux/mm.h>
8 #include <linux/slab.h>
9 #include <linux/interrupt.h>
10 #include <linux/module.h>
11 #include <linux/capability.h>
12 #include <linux/completion.h>
13 #include <linux/personality.h>
14 #include <linux/tty.h>
15 #include <linux/iocontext.h>
16 #include <linux/key.h>
17 #include <linux/security.h>
18 #include <linux/cpu.h>
19 #include <linux/acct.h>
20 #include <linux/tsacct_kern.h>
21 #include <linux/file.h>
22 #include <linux/fdtable.h>
23 #include <linux/binfmts.h>
24 #include <linux/nsproxy.h>
25 #include <linux/pid_namespace.h>
26 #include <linux/ptrace.h>
27 #include <linux/profile.h>
28 #include <linux/mount.h>
29 #include <linux/proc_fs.h>
30 #include <linux/kthread.h>
31 #include <linux/mempolicy.h>
32 #include <linux/taskstats_kern.h>
33 #include <linux/delayacct.h>
34 #include <linux/freezer.h>
35 #include <linux/cgroup.h>
36 #include <linux/syscalls.h>
37 #include <linux/signal.h>
38 #include <linux/posix-timers.h>
39 #include <linux/cn_proc.h>
40 #include <linux/mutex.h>
41 #include <linux/futex.h>
42 #include <linux/pipe_fs_i.h>
43 #include <linux/audit.h> /* for audit_free() */
44 #include <linux/resource.h>
45 #include <linux/blkdev.h>
47 #include <linux/tracehook.h>
48 #include <linux/fs_struct.h>
49 #include <linux/init_task.h>
50 #include <linux/perf_event.h>
51 #include <trace/events/sched.h>
52 #include <linux/hw_breakpoint.h>
53 #include <linux/oom.h>
54 #include <linux/writeback.h>
55 #include <linux/shm.h>
56 
57 #include <asm/uaccess.h>
58 #include <asm/unistd.h>
59 #include <asm/pgtable.h>
60 #include <asm/mmu_context.h>
61 
62 static void exit_mm(struct task_struct * tsk);
63 
64 static void __unhash_process(struct task_struct *p, bool group_dead)
65 {
66  nr_threads--;
68  if (group_dead) {
71 
72  list_del_rcu(&p->tasks);
73  list_del_init(&p->sibling);
74  __this_cpu_dec(process_counts);
75  /*
76  * If we are the last child process in a pid namespace to be
77  * reaped, notify the reaper sleeping zap_pid_ns_processes().
78  */
79  if (IS_ENABLED(CONFIG_PID_NS)) {
80  struct task_struct *parent = p->real_parent;
81 
82  if ((task_active_pid_ns(parent)->child_reaper == parent) &&
83  list_empty(&parent->children) &&
84  (parent->flags & PF_EXITING))
85  wake_up_process(parent);
86  }
87  }
88  list_del_rcu(&p->thread_group);
89 }
90 
91 /*
92  * This function expects the tasklist_lock write-locked.
93  */
94 static void __exit_signal(struct task_struct *tsk)
95 {
96  struct signal_struct *sig = tsk->signal;
97  bool group_dead = thread_group_leader(tsk);
98  struct sighand_struct *sighand;
99  struct tty_struct *uninitialized_var(tty);
100 
101  sighand = rcu_dereference_check(tsk->sighand,
102  lockdep_tasklist_lock_is_held());
103  spin_lock(&sighand->siglock);
104 
106  if (group_dead) {
108  tty = sig->tty;
109  sig->tty = NULL;
110  } else {
111  /*
112  * This can only happen if the caller is de_thread().
113  * FIXME: this is the temporary hack, we should teach
114  * posix-cpu-timers to handle this case correctly.
115  */
116  if (unlikely(has_group_leader_pid(tsk)))
118 
119  /*
120  * If there is any task waiting for the group exit
121  * then notify it:
122  */
123  if (sig->notify_count > 0 && !--sig->notify_count)
125 
126  if (tsk == sig->curr_target)
127  sig->curr_target = next_thread(tsk);
128  /*
129  * Accumulate here the counters for all threads but the
130  * group leader as they die, so they can be added into
131  * the process-wide totals when those are taken.
132  * The group leader stays around as a zombie as long
133  * as there are other threads. When it gets reaped,
134  * the exit.c code will add its counts into these totals.
135  * We won't ever get here for the group leader, since it
136  * will have been the last reference on the signal_struct.
137  */
138  sig->utime += tsk->utime;
139  sig->stime += tsk->stime;
140  sig->gtime += tsk->gtime;
141  sig->min_flt += tsk->min_flt;
142  sig->maj_flt += tsk->maj_flt;
143  sig->nvcsw += tsk->nvcsw;
144  sig->nivcsw += tsk->nivcsw;
145  sig->inblock += task_io_get_inblock(tsk);
146  sig->oublock += task_io_get_oublock(tsk);
147  task_io_accounting_add(&sig->ioac, &tsk->ioac);
148  sig->sum_sched_runtime += tsk->se.sum_exec_runtime;
149  }
150 
151  sig->nr_threads--;
152  __unhash_process(tsk, group_dead);
153 
154  /*
155  * Do this under ->siglock, we can race with another thread
156  * doing sigqueue_free() if we have SIGQUEUE_PREALLOC signals.
157  */
158  flush_sigqueue(&tsk->pending);
159  tsk->sighand = NULL;
160  spin_unlock(&sighand->siglock);
161 
162  __cleanup_sighand(sighand);
163  clear_tsk_thread_flag(tsk,TIF_SIGPENDING);
164  if (group_dead) {
166  tty_kref_put(tty);
167  }
168 }
169 
170 static void delayed_put_task_struct(struct rcu_head *rhp)
171 {
172  struct task_struct *tsk = container_of(rhp, struct task_struct, rcu);
173 
175  trace_sched_process_free(tsk);
176  put_task_struct(tsk);
177 }
178 
179 
180 void release_task(struct task_struct * p)
181 {
182  struct task_struct *leader;
183  int zap_leader;
184 repeat:
185  /* don't need to get the RCU readlock here - the process is dead and
186  * can't be modifying its own credentials. But shut RCU-lockdep up */
187  rcu_read_lock();
188  atomic_dec(&__task_cred(p)->user->processes);
189  rcu_read_unlock();
190 
191  proc_flush_task(p);
192 
194  ptrace_release_task(p);
195  __exit_signal(p);
196 
197  /*
198  * If we are the last non-leader member of the thread
199  * group, and the leader is zombie, then notify the
200  * group leader's parent process. (if it wants notification.)
201  */
202  zap_leader = 0;
203  leader = p->group_leader;
204  if (leader != p && thread_group_empty(leader) && leader->exit_state == EXIT_ZOMBIE) {
205  /*
206  * If we were the last child thread and the leader has
207  * exited already, and the leader's parent ignores SIGCHLD,
208  * then we are the one who should release the leader.
209  */
210  zap_leader = do_notify_parent(leader, leader->exit_signal);
211  if (zap_leader)
212  leader->exit_state = EXIT_DEAD;
213  }
214 
216  release_thread(p);
217  call_rcu(&p->rcu, delayed_put_task_struct);
218 
219  p = leader;
220  if (unlikely(zap_leader))
221  goto repeat;
222 }
223 
224 /*
225  * This checks not only the pgrp, but falls back on the pid if no
226  * satisfactory pgrp is found. I dunno - gdb doesn't work correctly
227  * without this...
228  *
229  * The caller must hold rcu lock or the tasklist lock.
230  */
231 struct pid *session_of_pgrp(struct pid *pgrp)
232 {
233  struct task_struct *p;
234  struct pid *sid = NULL;
235 
236  p = pid_task(pgrp, PIDTYPE_PGID);
237  if (p == NULL)
238  p = pid_task(pgrp, PIDTYPE_PID);
239  if (p != NULL)
240  sid = task_session(p);
241 
242  return sid;
243 }
244 
245 /*
246  * Determine if a process group is "orphaned", according to the POSIX
247  * definition in 2.2.2.52. Orphaned process groups are not to be affected
248  * by terminal-generated stop signals. Newly orphaned process groups are
249  * to receive a SIGHUP and a SIGCONT.
250  *
251  * "I ask you, have you ever known what it is to be an orphan?"
252  */
253 static int will_become_orphaned_pgrp(struct pid *pgrp, struct task_struct *ignored_task)
254 {
255  struct task_struct *p;
256 
257  do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
258  if ((p == ignored_task) ||
259  (p->exit_state && thread_group_empty(p)) ||
260  is_global_init(p->real_parent))
261  continue;
262 
263  if (task_pgrp(p->real_parent) != pgrp &&
264  task_session(p->real_parent) == task_session(p))
265  return 0;
266  } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
267 
268  return 1;
269 }
270 
272 {
273  int retval;
274 
276  retval = will_become_orphaned_pgrp(task_pgrp(current), NULL);
278 
279  return retval;
280 }
281 
282 static bool has_stopped_jobs(struct pid *pgrp)
283 {
284  struct task_struct *p;
285 
286  do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
287  if (p->signal->flags & SIGNAL_STOP_STOPPED)
288  return true;
289  } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
290 
291  return false;
292 }
293 
294 /*
295  * Check to see if any process groups have become orphaned as
296  * a result of our exiting, and if they have any stopped jobs,
297  * send them a SIGHUP and then a SIGCONT. (POSIX 3.2.2.2)
298  */
299 static void
300 kill_orphaned_pgrp(struct task_struct *tsk, struct task_struct *parent)
301 {
302  struct pid *pgrp = task_pgrp(tsk);
303  struct task_struct *ignored_task = tsk;
304 
305  if (!parent)
306  /* exit: our father is in a different pgrp than
307  * we are and we were the only connection outside.
308  */
309  parent = tsk->real_parent;
310  else
311  /* reparent: our child is in a different pgrp than
312  * we are, and it was the only connection outside.
313  */
314  ignored_task = NULL;
315 
316  if (task_pgrp(parent) != pgrp &&
317  task_session(parent) == task_session(tsk) &&
318  will_become_orphaned_pgrp(pgrp, ignored_task) &&
319  has_stopped_jobs(pgrp)) {
322  }
323 }
324 
337 static void reparent_to_kthreadd(void)
338 {
339  write_lock_irq(&tasklist_lock);
340 
341  ptrace_unlink(current);
342  /* Reparent to init */
343  current->real_parent = current->parent = kthreadd_task;
344  list_move_tail(&current->sibling, &current->real_parent->children);
345 
346  /* Set the exit signal to SIGCHLD so we signal init on exit */
347  current->exit_signal = SIGCHLD;
348 
349  if (task_nice(current) < 0)
351  /* cpus_allowed? */
352  /* rt_priority? */
353  /* signals? */
354  memcpy(current->signal->rlim, init_task.signal->rlim,
355  sizeof(current->signal->rlim));
356 
357  atomic_inc(&init_cred.usage);
359  write_unlock_irq(&tasklist_lock);
360 }
361 
363 {
364  struct task_struct *curr = current->group_leader;
365 
366  if (task_session(curr) != pid)
367  change_pid(curr, PIDTYPE_SID, pid);
368 
369  if (task_pgrp(curr) != pid)
370  change_pid(curr, PIDTYPE_PGID, pid);
371 }
372 
373 static void set_special_pids(struct pid *pid)
374 {
375  write_lock_irq(&tasklist_lock);
376  __set_special_pids(pid);
377  write_unlock_irq(&tasklist_lock);
378 }
379 
380 /*
381  * Let kernel threads use this to say that they allow a certain signal.
382  * Must not be used if kthread was cloned with CLONE_SIGHAND.
383  */
384 int allow_signal(int sig)
385 {
386  if (!valid_signal(sig) || sig < 1)
387  return -EINVAL;
388 
389  spin_lock_irq(&current->sighand->siglock);
390  /* This is only needed for daemonize()'ed kthreads */
391  sigdelset(&current->blocked, sig);
392  /*
393  * Kernel threads handle their own signals. Let the signal code
394  * know it'll be handled, so that they don't get converted to
395  * SIGKILL or just silently dropped.
396  */
397  current->sighand->action[(sig)-1].sa.sa_handler = (void __user *)2;
399  spin_unlock_irq(&current->sighand->siglock);
400  return 0;
401 }
402 
404 
405 int disallow_signal(int sig)
406 {
407  if (!valid_signal(sig) || sig < 1)
408  return -EINVAL;
409 
410  spin_lock_irq(&current->sighand->siglock);
411  current->sighand->action[(sig)-1].sa.sa_handler = SIG_IGN;
413  spin_unlock_irq(&current->sighand->siglock);
414  return 0;
415 }
416 
418 
419 /*
420  * Put all the gunge required to become a kernel thread without
421  * attached user resources in one place where it belongs.
422  */
423 
424 void daemonize(const char *name, ...)
425 {
426  va_list args;
428 
429  va_start(args, name);
430  vsnprintf(current->comm, sizeof(current->comm), name, args);
431  va_end(args);
432 
433  /*
434  * If we were started as result of loading a module, close all of the
435  * user space pages. We don't need them, and if we didn't close them
436  * they would be locked into memory.
437  */
438  exit_mm(current);
439  /*
440  * We don't want to get frozen, in case system-wide hibernation
441  * or suspend transition begins right now.
442  */
443  current->flags |= (PF_NOFREEZE | PF_KTHREAD);
444 
445  if (current->nsproxy != &init_nsproxy) {
446  get_nsproxy(&init_nsproxy);
448  }
449  set_special_pids(&init_struct_pid);
451 
452  /* Block and flush all signals */
453  sigfillset(&blocked);
454  sigprocmask(SIG_BLOCK, &blocked, NULL);
456 
457  /* Become as one with the init task */
458 
461 
462  reparent_to_kthreadd();
463 }
464 
466 
467 #ifdef CONFIG_MM_OWNER
468 /*
469  * A task is exiting. If it owned this mm, find a new owner for the mm.
470  */
471 void mm_update_next_owner(struct mm_struct *mm)
472 {
473  struct task_struct *c, *g, *p = current;
474 
475 retry:
476  /*
477  * If the exiting or execing task is not the owner, it's
478  * someone else's problem.
479  */
480  if (mm->owner != p)
481  return;
482  /*
483  * The current owner is exiting/execing and there are no other
484  * candidates. Do not leave the mm pointing to a possibly
485  * freed task structure.
486  */
487  if (atomic_read(&mm->mm_users) <= 1) {
488  mm->owner = NULL;
489  return;
490  }
491 
492  read_lock(&tasklist_lock);
493  /*
494  * Search in the children
495  */
497  if (c->mm == mm)
498  goto assign_new_owner;
499  }
500 
501  /*
502  * Search in the siblings
503  */
504  list_for_each_entry(c, &p->real_parent->children, sibling) {
505  if (c->mm == mm)
506  goto assign_new_owner;
507  }
508 
509  /*
510  * Search through everything else. We should not get
511  * here often
512  */
513  do_each_thread(g, c) {
514  if (c->mm == mm)
515  goto assign_new_owner;
516  } while_each_thread(g, c);
517 
518  read_unlock(&tasklist_lock);
519  /*
520  * We found no owner yet mm_users > 1: this implies that we are
521  * most likely racing with swapoff (try_to_unuse()) or /proc or
522  * ptrace or page migration (get_task_mm()). Mark owner as NULL.
523  */
524  mm->owner = NULL;
525  return;
526 
527 assign_new_owner:
528  BUG_ON(c == p);
529  get_task_struct(c);
530  /*
531  * The task_lock protects c->mm from changing.
532  * We always want mm->owner->mm == mm
533  */
534  task_lock(c);
535  /*
536  * Delay read_unlock() till we have the task_lock()
537  * to ensure that c does not slip away underneath us
538  */
539  read_unlock(&tasklist_lock);
540  if (c->mm != mm) {
541  task_unlock(c);
542  put_task_struct(c);
543  goto retry;
544  }
545  mm->owner = c;
546  task_unlock(c);
547  put_task_struct(c);
548 }
549 #endif /* CONFIG_MM_OWNER */
550 
551 /*
552  * Turn us into a lazy TLB process if we
553  * aren't already..
554  */
555 static void exit_mm(struct task_struct * tsk)
556 {
557  struct mm_struct *mm = tsk->mm;
558  struct core_state *core_state;
559 
560  mm_release(tsk, mm);
561  if (!mm)
562  return;
563  sync_mm_rss(mm);
564  /*
565  * Serialize with any possible pending coredump.
566  * We must hold mmap_sem around checking core_state
567  * and clearing tsk->mm. The core-inducing thread
568  * will increment ->nr_threads for each thread in the
569  * group with ->mm != NULL.
570  */
571  down_read(&mm->mmap_sem);
572  core_state = mm->core_state;
573  if (core_state) {
574  struct core_thread self;
575  up_read(&mm->mmap_sem);
576 
577  self.task = tsk;
578  self.next = xchg(&core_state->dumper.next, &self);
579  /*
580  * Implies mb(), the result of xchg() must be visible
581  * to core_state->dumper.
582  */
583  if (atomic_dec_and_test(&core_state->nr_threads))
584  complete(&core_state->startup);
585 
586  for (;;) {
588  if (!self.task) /* see coredump_finish() */
589  break;
590  schedule();
591  }
593  down_read(&mm->mmap_sem);
594  }
595  atomic_inc(&mm->mm_count);
596  BUG_ON(mm != tsk->active_mm);
597  /* more a memory barrier than a real lock */
598  task_lock(tsk);
599  tsk->mm = NULL;
600  up_read(&mm->mmap_sem);
601  enter_lazy_tlb(mm, current);
602  task_unlock(tsk);
603  mm_update_next_owner(mm);
604  mmput(mm);
605 }
606 
607 /*
608  * When we die, we re-parent all our children, and try to:
609  * 1. give them to another thread in our thread group, if such a member exists
610  * 2. give it to the first ancestor process which prctl'd itself as a
611  * child_subreaper for its children (like a service manager)
612  * 3. give it to the init process (PID 1) in our pid namespace
613  */
614 static struct task_struct *find_new_reaper(struct task_struct *father)
615  __releases(&tasklist_lock)
616  __acquires(&tasklist_lock)
617 {
618  struct pid_namespace *pid_ns = task_active_pid_ns(father);
619  struct task_struct *thread;
620 
621  thread = father;
622  while_each_thread(father, thread) {
623  if (thread->flags & PF_EXITING)
624  continue;
625  if (unlikely(pid_ns->child_reaper == father))
626  pid_ns->child_reaper = thread;
627  return thread;
628  }
629 
630  if (unlikely(pid_ns->child_reaper == father)) {
631  write_unlock_irq(&tasklist_lock);
632  if (unlikely(pid_ns == &init_pid_ns)) {
633  panic("Attempted to kill init! exitcode=0x%08x\n",
634  father->signal->group_exit_code ?:
635  father->exit_code);
636  }
637 
638  zap_pid_ns_processes(pid_ns);
639  write_lock_irq(&tasklist_lock);
640  } else if (father->signal->has_child_subreaper) {
641  struct task_struct *reaper;
642 
643  /*
644  * Find the first ancestor marked as child_subreaper.
645  * Note that the code below checks same_thread_group(reaper,
646  * pid_ns->child_reaper). This is what we need to DTRT in a
647  * PID namespace. However we still need the check above, see
648  * http://marc.info/?l=linux-kernel&m=131385460420380
649  */
650  for (reaper = father->real_parent;
651  reaper != &init_task;
652  reaper = reaper->real_parent) {
653  if (same_thread_group(reaper, pid_ns->child_reaper))
654  break;
655  if (!reaper->signal->is_child_subreaper)
656  continue;
657  thread = reaper;
658  do {
659  if (!(thread->flags & PF_EXITING))
660  return reaper;
661  } while_each_thread(reaper, thread);
662  }
663  }
664 
665  return pid_ns->child_reaper;
666 }
667 
668 /*
669 * Any that need to be release_task'd are put on the @dead list.
670  */
671 static void reparent_leader(struct task_struct *father, struct task_struct *p,
672  struct list_head *dead)
673 {
674  list_move_tail(&p->sibling, &p->real_parent->children);
675 
676  if (p->exit_state == EXIT_DEAD)
677  return;
678  /*
679  * If this is a threaded reparent there is no need to
680  * notify anyone anything has happened.
681  */
682  if (same_thread_group(p->real_parent, father))
683  return;
684 
685  /* We don't want people slaying init. */
686  p->exit_signal = SIGCHLD;
687 
688  /* If it has exited notify the new parent about this child's death. */
689  if (!p->ptrace &&
690  p->exit_state == EXIT_ZOMBIE && thread_group_empty(p)) {
691  if (do_notify_parent(p, p->exit_signal)) {
692  p->exit_state = EXIT_DEAD;
693  list_move_tail(&p->sibling, dead);
694  }
695  }
696 
697  kill_orphaned_pgrp(p, father);
698 }
699 
700 static void forget_original_parent(struct task_struct *father)
701 {
702  struct task_struct *p, *n, *reaper;
703  LIST_HEAD(dead_children);
704 
705  write_lock_irq(&tasklist_lock);
706  /*
707  * Note that exit_ptrace() and find_new_reaper() might
708  * drop tasklist_lock and reacquire it.
709  */
710  exit_ptrace(father);
711  reaper = find_new_reaper(father);
712 
713  list_for_each_entry_safe(p, n, &father->children, sibling) {
714  struct task_struct *t = p;
715  do {
716  t->real_parent = reaper;
717  if (t->parent == father) {
718  BUG_ON(t->ptrace);
719  t->parent = t->real_parent;
720  }
721  if (t->pdeath_signal)
723  SEND_SIG_NOINFO, t);
724  } while_each_thread(p, t);
725  reparent_leader(father, p, &dead_children);
726  }
727  write_unlock_irq(&tasklist_lock);
728 
729  BUG_ON(!list_empty(&father->children));
730 
731  list_for_each_entry_safe(p, n, &dead_children, sibling) {
732  list_del_init(&p->sibling);
733  release_task(p);
734  }
735 }
736 
737 /*
738  * Send signals to all our closest relatives so that they know
739  * to properly mourn us..
740  */
741 static void exit_notify(struct task_struct *tsk, int group_dead)
742 {
743  bool autoreap;
744 
745  /*
746  * This does two things:
747  *
748  * A. Make init inherit all the child processes
749  * B. Check to see if any process groups have become orphaned
750  * as a result of our exiting, and if they have any stopped
751  * jobs, send them a SIGHUP and then a SIGCONT. (POSIX 3.2.2.2)
752  */
753  forget_original_parent(tsk);
755 
756  write_lock_irq(&tasklist_lock);
757  if (group_dead)
758  kill_orphaned_pgrp(tsk->group_leader, NULL);
759 
760  if (unlikely(tsk->ptrace)) {
761  int sig = thread_group_leader(tsk) &&
762  thread_group_empty(tsk) &&
763  !ptrace_reparented(tsk) ?
764  tsk->exit_signal : SIGCHLD;
765  autoreap = do_notify_parent(tsk, sig);
766  } else if (thread_group_leader(tsk)) {
767  autoreap = thread_group_empty(tsk) &&
768  do_notify_parent(tsk, tsk->exit_signal);
769  } else {
770  autoreap = true;
771  }
772 
773  tsk->exit_state = autoreap ? EXIT_DEAD : EXIT_ZOMBIE;
774 
775  /* mt-exec, de_thread() is waiting for group leader */
776  if (unlikely(tsk->signal->notify_count < 0))
777  wake_up_process(tsk->signal->group_exit_task);
778  write_unlock_irq(&tasklist_lock);
779 
780  /* If the process is dead, release it - nobody will wait for it */
781  if (autoreap)
782  release_task(tsk);
783 }
784 
785 #ifdef CONFIG_DEBUG_STACK_USAGE
786 static void check_stack_usage(void)
787 {
788  static DEFINE_SPINLOCK(low_water_lock);
789  static int lowest_to_date = THREAD_SIZE;
790  unsigned long free;
791 
792  free = stack_not_used(current);
793 
794  if (free >= lowest_to_date)
795  return;
796 
797  spin_lock(&low_water_lock);
798  if (free < lowest_to_date) {
799  printk(KERN_WARNING "%s (%d) used greatest stack depth: "
800  "%lu bytes left\n",
801  current->comm, task_pid_nr(current), free);
802  lowest_to_date = free;
803  }
804  spin_unlock(&low_water_lock);
805 }
806 #else
807 static inline void check_stack_usage(void) {}
808 #endif
809 
810 void do_exit(long code)
811 {
812  struct task_struct *tsk = current;
813  int group_dead;
814 
815  profile_task_exit(tsk);
816 
817  WARN_ON(blk_needs_flush_plug(tsk));
818 
819  if (unlikely(in_interrupt()))
820  panic("Aiee, killing interrupt handler!");
821  if (unlikely(!tsk->pid))
822  panic("Attempted to kill the idle task!");
823 
824  /*
825  * If do_exit is called because this processes oopsed, it's possible
826  * that get_fs() was left as KERNEL_DS, so reset it to USER_DS before
827  * continuing. Amongst other possible reasons, this is to prevent
828  * mm_release()->clear_child_tid() from writing to a user-controlled
829  * kernel address.
830  */
831  set_fs(USER_DS);
832 
833  ptrace_event(PTRACE_EVENT_EXIT, code);
834 
835  validate_creds_for_do_exit(tsk);
836 
837  /*
838  * We're taking recursive faults here in do_exit. Safest is to just
839  * leave this task alone and wait for reboot.
840  */
841  if (unlikely(tsk->flags & PF_EXITING)) {
843  "Fixing recursive fault but reboot is needed!\n");
844  /*
845  * We can do this unlocked here. The futex code uses
846  * this flag just to verify whether the pi state
847  * cleanup has been done or not. In the worst case it
848  * loops once more. We pretend that the cleanup was
849  * done as there is no way to return. Either the
850  * OWNER_DIED bit is set by now or we push the blocked
851  * task into the wait for ever nirwana as well.
852  */
853  tsk->flags |= PF_EXITPIDONE;
855  schedule();
856  }
857 
858  exit_signals(tsk); /* sets PF_EXITING */
859  /*
860  * tsk->flags are checked in the futex code to protect against
861  * an exiting task cleaning up the robust pi futexes.
862  */
863  smp_mb();
865 
866  if (unlikely(in_atomic()))
867  printk(KERN_INFO "note: %s[%d] exited with preempt_count %d\n",
868  current->comm, task_pid_nr(current),
869  preempt_count());
870 
871  acct_update_integrals(tsk);
872  /* sync mm's RSS info before statistics gathering */
873  if (tsk->mm)
874  sync_mm_rss(tsk->mm);
875  group_dead = atomic_dec_and_test(&tsk->signal->live);
876  if (group_dead) {
877  hrtimer_cancel(&tsk->signal->real_timer);
878  exit_itimers(tsk->signal);
879  if (tsk->mm)
880  setmax_mm_hiwater_rss(&tsk->signal->maxrss, tsk->mm);
881  }
882  acct_collect(code, group_dead);
883  if (group_dead)
884  tty_audit_exit();
885  audit_free(tsk);
886 
887  tsk->exit_code = code;
888  taskstats_exit(tsk, group_dead);
889 
890  exit_mm(tsk);
891 
892  if (group_dead)
893  acct_process();
894  trace_sched_process_exit(tsk);
895 
896  exit_sem(tsk);
897  exit_shm(tsk);
898  exit_files(tsk);
899  exit_fs(tsk);
900  exit_task_work(tsk);
901  check_stack_usage();
902  exit_thread();
903 
904  /*
905  * Flush inherited counters to the parent - before the parent
906  * gets woken up by child-exit notifications.
907  *
908  * because of cgroup mode, must be called before cgroup_exit()
909  */
911 
912  cgroup_exit(tsk, 1);
913 
914  if (group_dead)
916 
917  module_put(task_thread_info(tsk)->exec_domain->module);
918 
919  proc_exit_connector(tsk);
920 
921  /*
922  * FIXME: do that only when needed, using sched_exit tracepoint
923  */
924  ptrace_put_breakpoints(tsk);
925 
926  exit_notify(tsk, group_dead);
927 #ifdef CONFIG_NUMA
928  task_lock(tsk);
929  mpol_put(tsk->mempolicy);
930  tsk->mempolicy = NULL;
931  task_unlock(tsk);
932 #endif
933 #ifdef CONFIG_FUTEX
934  if (unlikely(current->pi_state_cache))
935  kfree(current->pi_state_cache);
936 #endif
937  /*
938  * Make sure we are holding no locks:
939  */
941  /*
942  * We can do this unlocked here. The futex code uses this flag
943  * just to verify whether the pi state cleanup has been done
944  * or not. In the worst case it loops once more.
945  */
946  tsk->flags |= PF_EXITPIDONE;
947 
948  if (tsk->io_context)
949  exit_io_context(tsk);
950 
951  if (tsk->splice_pipe)
953 
954  if (tsk->task_frag.page)
955  put_page(tsk->task_frag.page);
956 
957  validate_creds_for_do_exit(tsk);
958 
959  preempt_disable();
960  if (tsk->nr_dirtied)
961  __this_cpu_add(dirty_throttle_leaks, tsk->nr_dirtied);
962  exit_rcu();
963 
964  /*
965  * The setting of TASK_RUNNING by try_to_wake_up() may be delayed
966  * when the following two conditions become true.
967  * - There is race condition of mmap_sem (It is acquired by
968  * exit_mm()), and
969  * - SMI occurs before setting TASK_RUNINNG.
970  * (or hypervisor of virtual machine switches to other guest)
971  * As a result, we may become TASK_RUNNING after becoming TASK_DEAD
972  *
973  * To avoid it, we have to wait for releasing tsk->pi_lock which
974  * is held by try_to_wake_up()
975  */
976  smp_mb();
978 
979  /* causes final put_task_struct in finish_task_switch(). */
980  tsk->state = TASK_DEAD;
981  tsk->flags |= PF_NOFREEZE; /* tell freezer to ignore us */
982  schedule();
983  BUG();
984  /* Avoid "noreturn function does return". */
985  for (;;)
986  cpu_relax(); /* For when BUG is null */
987 }
988 
990 
991 void complete_and_exit(struct completion *comp, long code)
992 {
993  if (comp)
994  complete(comp);
995 
996  do_exit(code);
997 }
998 
1000 
1002 {
1003  do_exit((error_code&0xff)<<8);
1004 }
1005 
1006 /*
1007  * Take down every thread in the group. This is called by fatal signals
1008  * as well as by sys_exit_group (below).
1009  */
1010 void
1012 {
1013  struct signal_struct *sig = current->signal;
1014 
1015  BUG_ON(exit_code & 0x80); /* core dumps don't get here */
1016 
1017  if (signal_group_exit(sig))
1018  exit_code = sig->group_exit_code;
1019  else if (!thread_group_empty(current)) {
1020  struct sighand_struct *const sighand = current->sighand;
1021  spin_lock_irq(&sighand->siglock);
1022  if (signal_group_exit(sig))
1023  /* Another thread got here before we took the lock. */
1024  exit_code = sig->group_exit_code;
1025  else {
1026  sig->group_exit_code = exit_code;
1027  sig->flags = SIGNAL_GROUP_EXIT;
1029  }
1030  spin_unlock_irq(&sighand->siglock);
1031  }
1032 
1033  do_exit(exit_code);
1034  /* NOTREACHED */
1035 }
1036 
1037 /*
1038  * this kills every thread in the thread group. Note that any externally
1039  * wait4()-ing process will get the correct exit code - even if this
1040  * thread is not the thread group leader.
1041  */
1042 SYSCALL_DEFINE1(exit_group, int, error_code)
1043 {
1044  do_group_exit((error_code & 0xff) << 8);
1045  /* NOTREACHED */
1046  return 0;
1047 }
1048 
1049 struct wait_opts {
1052  struct pid *wo_pid;
1053 
1057 
1060 };
1061 
1062 static inline
1063 struct pid *task_pid_type(struct task_struct *task, enum pid_type type)
1064 {
1065  if (type != PIDTYPE_PID)
1066  task = task->group_leader;
1067  return task->pids[type].pid;
1068 }
1069 
1070 static int eligible_pid(struct wait_opts *wo, struct task_struct *p)
1071 {
1072  return wo->wo_type == PIDTYPE_MAX ||
1073  task_pid_type(p, wo->wo_type) == wo->wo_pid;
1074 }
1075 
1076 static int eligible_child(struct wait_opts *wo, struct task_struct *p)
1077 {
1078  if (!eligible_pid(wo, p))
1079  return 0;
1080  /* Wait for all children (clone and not) if __WALL is set;
1081  * otherwise, wait for clone children *only* if __WCLONE is
1082  * set; otherwise, wait for non-clone children *only*. (Note:
1083  * A "clone" child here is one that reports to its parent
1084  * using a signal other than SIGCHLD.) */
1085  if (((p->exit_signal != SIGCHLD) ^ !!(wo->wo_flags & __WCLONE))
1086  && !(wo->wo_flags & __WALL))
1087  return 0;
1088 
1089  return 1;
1090 }
1091 
1092 static int wait_noreap_copyout(struct wait_opts *wo, struct task_struct *p,
1093  pid_t pid, uid_t uid, int why, int status)
1094 {
1095  struct siginfo __user *infop;
1096  int retval = wo->wo_rusage
1097  ? getrusage(p, RUSAGE_BOTH, wo->wo_rusage) : 0;
1098 
1099  put_task_struct(p);
1100  infop = wo->wo_info;
1101  if (infop) {
1102  if (!retval)
1103  retval = put_user(SIGCHLD, &infop->si_signo);
1104  if (!retval)
1105  retval = put_user(0, &infop->si_errno);
1106  if (!retval)
1107  retval = put_user((short)why, &infop->si_code);
1108  if (!retval)
1109  retval = put_user(pid, &infop->si_pid);
1110  if (!retval)
1111  retval = put_user(uid, &infop->si_uid);
1112  if (!retval)
1113  retval = put_user(status, &infop->si_status);
1114  }
1115  if (!retval)
1116  retval = pid;
1117  return retval;
1118 }
1119 
1120 /*
1121  * Handle sys_wait4 work for one task in state EXIT_ZOMBIE. We hold
1122  * read_lock(&tasklist_lock) on entry. If we return zero, we still hold
1123  * the lock and this task is uninteresting. If we return nonzero, we have
1124  * released the lock and the system call should return.
1125  */
1126 static int wait_task_zombie(struct wait_opts *wo, struct task_struct *p)
1127 {
1128  unsigned long state;
1129  int retval, status, traced;
1130  pid_t pid = task_pid_vnr(p);
1132  struct siginfo __user *infop;
1133 
1134  if (!likely(wo->wo_flags & WEXITED))
1135  return 0;
1136 
1137  if (unlikely(wo->wo_flags & WNOWAIT)) {
1138  int exit_code = p->exit_code;
1139  int why;
1140 
1141  get_task_struct(p);
1142  read_unlock(&tasklist_lock);
1143  if ((exit_code & 0x7f) == 0) {
1144  why = CLD_EXITED;
1145  status = exit_code >> 8;
1146  } else {
1147  why = (exit_code & 0x80) ? CLD_DUMPED : CLD_KILLED;
1148  status = exit_code & 0x7f;
1149  }
1150  return wait_noreap_copyout(wo, p, pid, uid, why, status);
1151  }
1152 
1153  /*
1154  * Try to move the task's state to DEAD
1155  * only one thread is allowed to do this:
1156  */
1157  state = xchg(&p->exit_state, EXIT_DEAD);
1158  if (state != EXIT_ZOMBIE) {
1159  BUG_ON(state != EXIT_DEAD);
1160  return 0;
1161  }
1162 
1163  traced = ptrace_reparented(p);
1164  /*
1165  * It can be ptraced but not reparented, check
1166  * thread_group_leader() to filter out sub-threads.
1167  */
1168  if (likely(!traced) && thread_group_leader(p)) {
1169  struct signal_struct *psig;
1170  struct signal_struct *sig;
1171  unsigned long maxrss;
1172  cputime_t tgutime, tgstime;
1173 
1174  /*
1175  * The resource counters for the group leader are in its
1176  * own task_struct. Those for dead threads in the group
1177  * are in its signal_struct, as are those for the child
1178  * processes it has previously reaped. All these
1179  * accumulate in the parent's signal_struct c* fields.
1180  *
1181  * We don't bother to take a lock here to protect these
1182  * p->signal fields, because they are only touched by
1183  * __exit_signal, which runs with tasklist_lock
1184  * write-locked anyway, and so is excluded here. We do
1185  * need to protect the access to parent->signal fields,
1186  * as other threads in the parent group can be right
1187  * here reaping other children at the same time.
1188  *
1189  * We use thread_group_times() to get times for the thread
1190  * group, which consolidates times for all threads in the
1191  * group including the group leader.
1192  */
1193  thread_group_times(p, &tgutime, &tgstime);
1194  spin_lock_irq(&p->real_parent->sighand->siglock);
1195  psig = p->real_parent->signal;
1196  sig = p->signal;
1197  psig->cutime += tgutime + sig->cutime;
1198  psig->cstime += tgstime + sig->cstime;
1199  psig->cgtime += p->gtime + sig->gtime + sig->cgtime;
1200  psig->cmin_flt +=
1201  p->min_flt + sig->min_flt + sig->cmin_flt;
1202  psig->cmaj_flt +=
1203  p->maj_flt + sig->maj_flt + sig->cmaj_flt;
1204  psig->cnvcsw +=
1205  p->nvcsw + sig->nvcsw + sig->cnvcsw;
1206  psig->cnivcsw +=
1207  p->nivcsw + sig->nivcsw + sig->cnivcsw;
1208  psig->cinblock +=
1209  task_io_get_inblock(p) +
1210  sig->inblock + sig->cinblock;
1211  psig->coublock +=
1212  task_io_get_oublock(p) +
1213  sig->oublock + sig->coublock;
1214  maxrss = max(sig->maxrss, sig->cmaxrss);
1215  if (psig->cmaxrss < maxrss)
1216  psig->cmaxrss = maxrss;
1217  task_io_accounting_add(&psig->ioac, &p->ioac);
1218  task_io_accounting_add(&psig->ioac, &sig->ioac);
1219  spin_unlock_irq(&p->real_parent->sighand->siglock);
1220  }
1221 
1222  /*
1223  * Now we are sure this task is interesting, and no other
1224  * thread can reap it because we set its state to EXIT_DEAD.
1225  */
1226  read_unlock(&tasklist_lock);
1227 
1228  retval = wo->wo_rusage
1229  ? getrusage(p, RUSAGE_BOTH, wo->wo_rusage) : 0;
1230  status = (p->signal->flags & SIGNAL_GROUP_EXIT)
1231  ? p->signal->group_exit_code : p->exit_code;
1232  if (!retval && wo->wo_stat)
1233  retval = put_user(status, wo->wo_stat);
1234 
1235  infop = wo->wo_info;
1236  if (!retval && infop)
1237  retval = put_user(SIGCHLD, &infop->si_signo);
1238  if (!retval && infop)
1239  retval = put_user(0, &infop->si_errno);
1240  if (!retval && infop) {
1241  int why;
1242 
1243  if ((status & 0x7f) == 0) {
1244  why = CLD_EXITED;
1245  status >>= 8;
1246  } else {
1247  why = (status & 0x80) ? CLD_DUMPED : CLD_KILLED;
1248  status &= 0x7f;
1249  }
1250  retval = put_user((short)why, &infop->si_code);
1251  if (!retval)
1252  retval = put_user(status, &infop->si_status);
1253  }
1254  if (!retval && infop)
1255  retval = put_user(pid, &infop->si_pid);
1256  if (!retval && infop)
1257  retval = put_user(uid, &infop->si_uid);
1258  if (!retval)
1259  retval = pid;
1260 
1261  if (traced) {
1262  write_lock_irq(&tasklist_lock);
1263  /* We dropped tasklist, ptracer could die and untrace */
1264  ptrace_unlink(p);
1265  /*
1266  * If this is not a sub-thread, notify the parent.
1267  * If parent wants a zombie, don't release it now.
1268  */
1269  if (thread_group_leader(p) &&
1270  !do_notify_parent(p, p->exit_signal)) {
1271  p->exit_state = EXIT_ZOMBIE;
1272  p = NULL;
1273  }
1274  write_unlock_irq(&tasklist_lock);
1275  }
1276  if (p != NULL)
1277  release_task(p);
1278 
1279  return retval;
1280 }
1281 
1282 static int *task_stopped_code(struct task_struct *p, bool ptrace)
1283 {
1284  if (ptrace) {
1285  if (task_is_stopped_or_traced(p) &&
1286  !(p->jobctl & JOBCTL_LISTENING))
1287  return &p->exit_code;
1288  } else {
1289  if (p->signal->flags & SIGNAL_STOP_STOPPED)
1290  return &p->signal->group_exit_code;
1291  }
1292  return NULL;
1293 }
1294 
1313 static int wait_task_stopped(struct wait_opts *wo,
1314  int ptrace, struct task_struct *p)
1315 {
1316  struct siginfo __user *infop;
1317  int retval, exit_code, *p_code, why;
1318  uid_t uid = 0; /* unneeded, required by compiler */
1319  pid_t pid;
1320 
1321  /*
1322  * Traditionally we see ptrace'd stopped tasks regardless of options.
1323  */
1324  if (!ptrace && !(wo->wo_flags & WUNTRACED))
1325  return 0;
1326 
1327  if (!task_stopped_code(p, ptrace))
1328  return 0;
1329 
1330  exit_code = 0;
1331  spin_lock_irq(&p->sighand->siglock);
1332 
1333  p_code = task_stopped_code(p, ptrace);
1334  if (unlikely(!p_code))
1335  goto unlock_sig;
1336 
1337  exit_code = *p_code;
1338  if (!exit_code)
1339  goto unlock_sig;
1340 
1341  if (!unlikely(wo->wo_flags & WNOWAIT))
1342  *p_code = 0;
1343 
1345 unlock_sig:
1346  spin_unlock_irq(&p->sighand->siglock);
1347  if (!exit_code)
1348  return 0;
1349 
1350  /*
1351  * Now we are pretty sure this task is interesting.
1352  * Make sure it doesn't get reaped out from under us while we
1353  * give up the lock and then examine it below. We don't want to
1354  * keep holding onto the tasklist_lock while we call getrusage and
1355  * possibly take page faults for user memory.
1356  */
1357  get_task_struct(p);
1358  pid = task_pid_vnr(p);
1359  why = ptrace ? CLD_TRAPPED : CLD_STOPPED;
1360  read_unlock(&tasklist_lock);
1361 
1362  if (unlikely(wo->wo_flags & WNOWAIT))
1363  return wait_noreap_copyout(wo, p, pid, uid, why, exit_code);
1364 
1365  retval = wo->wo_rusage
1366  ? getrusage(p, RUSAGE_BOTH, wo->wo_rusage) : 0;
1367  if (!retval && wo->wo_stat)
1368  retval = put_user((exit_code << 8) | 0x7f, wo->wo_stat);
1369 
1370  infop = wo->wo_info;
1371  if (!retval && infop)
1372  retval = put_user(SIGCHLD, &infop->si_signo);
1373  if (!retval && infop)
1374  retval = put_user(0, &infop->si_errno);
1375  if (!retval && infop)
1376  retval = put_user((short)why, &infop->si_code);
1377  if (!retval && infop)
1378  retval = put_user(exit_code, &infop->si_status);
1379  if (!retval && infop)
1380  retval = put_user(pid, &infop->si_pid);
1381  if (!retval && infop)
1382  retval = put_user(uid, &infop->si_uid);
1383  if (!retval)
1384  retval = pid;
1385  put_task_struct(p);
1386 
1387  BUG_ON(!retval);
1388  return retval;
1389 }
1390 
1391 /*
1392  * Handle do_wait work for one task in a live, non-stopped state.
1393  * read_lock(&tasklist_lock) on entry. If we return zero, we still hold
1394  * the lock and this task is uninteresting. If we return nonzero, we have
1395  * released the lock and the system call should return.
1396  */
1397 static int wait_task_continued(struct wait_opts *wo, struct task_struct *p)
1398 {
1399  int retval;
1400  pid_t pid;
1401  uid_t uid;
1402 
1403  if (!unlikely(wo->wo_flags & WCONTINUED))
1404  return 0;
1405 
1406  if (!(p->signal->flags & SIGNAL_STOP_CONTINUED))
1407  return 0;
1408 
1409  spin_lock_irq(&p->sighand->siglock);
1410  /* Re-check with the lock held. */
1411  if (!(p->signal->flags & SIGNAL_STOP_CONTINUED)) {
1412  spin_unlock_irq(&p->sighand->siglock);
1413  return 0;
1414  }
1415  if (!unlikely(wo->wo_flags & WNOWAIT))
1416  p->signal->flags &= ~SIGNAL_STOP_CONTINUED;
1418  spin_unlock_irq(&p->sighand->siglock);
1419 
1420  pid = task_pid_vnr(p);
1421  get_task_struct(p);
1422  read_unlock(&tasklist_lock);
1423 
1424  if (!wo->wo_info) {
1425  retval = wo->wo_rusage
1426  ? getrusage(p, RUSAGE_BOTH, wo->wo_rusage) : 0;
1427  put_task_struct(p);
1428  if (!retval && wo->wo_stat)
1429  retval = put_user(0xffff, wo->wo_stat);
1430  if (!retval)
1431  retval = pid;
1432  } else {
1433  retval = wait_noreap_copyout(wo, p, pid, uid,
1435  BUG_ON(retval == 0);
1436  }
1437 
1438  return retval;
1439 }
1440 
1441 /*
1442  * Consider @p for a wait by @parent.
1443  *
1444  * -ECHILD should be in ->notask_error before the first call.
1445  * Returns nonzero for a final return, when we have unlocked tasklist_lock.
1446  * Returns zero if the search for a child should continue;
1447  * then ->notask_error is 0 if @p is an eligible child,
1448  * or another error from security_task_wait(), or still -ECHILD.
1449  */
1450 static int wait_consider_task(struct wait_opts *wo, int ptrace,
1451  struct task_struct *p)
1452 {
1453  int ret = eligible_child(wo, p);
1454  if (!ret)
1455  return ret;
1456 
1457  ret = security_task_wait(p);
1458  if (unlikely(ret < 0)) {
1459  /*
1460  * If we have not yet seen any eligible child,
1461  * then let this error code replace -ECHILD.
1462  * A permission error will give the user a clue
1463  * to look for security policy problems, rather
1464  * than for mysterious wait bugs.
1465  */
1466  if (wo->notask_error)
1467  wo->notask_error = ret;
1468  return 0;
1469  }
1470 
1471  /* dead body doesn't have much to contribute */
1472  if (unlikely(p->exit_state == EXIT_DEAD)) {
1473  /*
1474  * But do not ignore this task until the tracer does
1475  * wait_task_zombie()->do_notify_parent().
1476  */
1477  if (likely(!ptrace) && unlikely(ptrace_reparented(p)))
1478  wo->notask_error = 0;
1479  return 0;
1480  }
1481 
1482  /* slay zombie? */
1483  if (p->exit_state == EXIT_ZOMBIE) {
1484  /*
1485  * A zombie ptracee is only visible to its ptracer.
1486  * Notification and reaping will be cascaded to the real
1487  * parent when the ptracer detaches.
1488  */
1489  if (likely(!ptrace) && unlikely(p->ptrace)) {
1490  /* it will become visible, clear notask_error */
1491  wo->notask_error = 0;
1492  return 0;
1493  }
1494 
1495  /* we don't reap group leaders with subthreads */
1496  if (!delay_group_leader(p))
1497  return wait_task_zombie(wo, p);
1498 
1499  /*
1500  * Allow access to stopped/continued state via zombie by
1501  * falling through. Clearing of notask_error is complex.
1502  *
1503  * When !@ptrace:
1504  *
1505  * If WEXITED is set, notask_error should naturally be
1506  * cleared. If not, subset of WSTOPPED|WCONTINUED is set,
1507  * so, if there are live subthreads, there are events to
1508  * wait for. If all subthreads are dead, it's still safe
1509  * to clear - this function will be called again in finite
1510  * amount time once all the subthreads are released and
1511  * will then return without clearing.
1512  *
1513  * When @ptrace:
1514  *
1515  * Stopped state is per-task and thus can't change once the
1516  * target task dies. Only continued and exited can happen.
1517  * Clear notask_error if WCONTINUED | WEXITED.
1518  */
1519  if (likely(!ptrace) || (wo->wo_flags & (WCONTINUED | WEXITED)))
1520  wo->notask_error = 0;
1521  } else {
1522  /*
1523  * If @p is ptraced by a task in its real parent's group,
1524  * hide group stop/continued state when looking at @p as
1525  * the real parent; otherwise, a single stop can be
1526  * reported twice as group and ptrace stops.
1527  *
1528  * If a ptracer wants to distinguish the two events for its
1529  * own children, it should create a separate process which
1530  * takes the role of real parent.
1531  */
1532  if (likely(!ptrace) && p->ptrace && !ptrace_reparented(p))
1533  return 0;
1534 
1535  /*
1536  * @p is alive and it's gonna stop, continue or exit, so
1537  * there always is something to wait for.
1538  */
1539  wo->notask_error = 0;
1540  }
1541 
1542  /*
1543  * Wait for stopped. Depending on @ptrace, different stopped state
1544  * is used and the two don't interact with each other.
1545  */
1546  ret = wait_task_stopped(wo, ptrace, p);
1547  if (ret)
1548  return ret;
1549 
1550  /*
1551  * Wait for continued. There's only one continued state and the
1552  * ptracer can consume it which can confuse the real parent. Don't
1553  * use WCONTINUED from ptracer. You don't need or want it.
1554  */
1555  return wait_task_continued(wo, p);
1556 }
1557 
1558 /*
1559  * Do the work of do_wait() for one thread in the group, @tsk.
1560  *
1561  * -ECHILD should be in ->notask_error before the first call.
1562  * Returns nonzero for a final return, when we have unlocked tasklist_lock.
1563  * Returns zero if the search for a child should continue; then
1564  * ->notask_error is 0 if there were any eligible children,
1565  * or another error from security_task_wait(), or still -ECHILD.
1566  */
1567 static int do_wait_thread(struct wait_opts *wo, struct task_struct *tsk)
1568 {
1569  struct task_struct *p;
1570 
1571  list_for_each_entry(p, &tsk->children, sibling) {
1572  int ret = wait_consider_task(wo, 0, p);
1573  if (ret)
1574  return ret;
1575  }
1576 
1577  return 0;
1578 }
1579 
1580 static int ptrace_do_wait(struct wait_opts *wo, struct task_struct *tsk)
1581 {
1582  struct task_struct *p;
1583 
1585  int ret = wait_consider_task(wo, 1, p);
1586  if (ret)
1587  return ret;
1588  }
1589 
1590  return 0;
1591 }
1592 
1593 static int child_wait_callback(wait_queue_t *wait, unsigned mode,
1594  int sync, void *key)
1595 {
1596  struct wait_opts *wo = container_of(wait, struct wait_opts,
1597  child_wait);
1598  struct task_struct *p = key;
1599 
1600  if (!eligible_pid(wo, p))
1601  return 0;
1602 
1603  if ((wo->wo_flags & __WNOTHREAD) && wait->private != p->parent)
1604  return 0;
1605 
1606  return default_wake_function(wait, mode, sync, key);
1607 }
1608 
1609 void __wake_up_parent(struct task_struct *p, struct task_struct *parent)
1610 {
1611  __wake_up_sync_key(&parent->signal->wait_chldexit,
1612  TASK_INTERRUPTIBLE, 1, p);
1613 }
1614 
1615 static long do_wait(struct wait_opts *wo)
1616 {
1617  struct task_struct *tsk;
1618  int retval;
1619 
1620  trace_sched_process_wait(wo->wo_pid);
1621 
1622  init_waitqueue_func_entry(&wo->child_wait, child_wait_callback);
1623  wo->child_wait.private = current;
1624  add_wait_queue(&current->signal->wait_chldexit, &wo->child_wait);
1625 repeat:
1626  /*
1627  * If there is nothing that can match our critiera just get out.
1628  * We will clear ->notask_error to zero if we see any child that
1629  * might later match our criteria, even if we are not able to reap
1630  * it yet.
1631  */
1632  wo->notask_error = -ECHILD;
1633  if ((wo->wo_type < PIDTYPE_MAX) &&
1634  (!wo->wo_pid || hlist_empty(&wo->wo_pid->tasks[wo->wo_type])))
1635  goto notask;
1636 
1638  read_lock(&tasklist_lock);
1639  tsk = current;
1640  do {
1641  retval = do_wait_thread(wo, tsk);
1642  if (retval)
1643  goto end;
1644 
1645  retval = ptrace_do_wait(wo, tsk);
1646  if (retval)
1647  goto end;
1648 
1649  if (wo->wo_flags & __WNOTHREAD)
1650  break;
1651  } while_each_thread(current, tsk);
1652  read_unlock(&tasklist_lock);
1653 
1654 notask:
1655  retval = wo->notask_error;
1656  if (!retval && !(wo->wo_flags & WNOHANG)) {
1657  retval = -ERESTARTSYS;
1658  if (!signal_pending(current)) {
1659  schedule();
1660  goto repeat;
1661  }
1662  }
1663 end:
1665  remove_wait_queue(&current->signal->wait_chldexit, &wo->child_wait);
1666  return retval;
1667 }
1668 
1669 SYSCALL_DEFINE5(waitid, int, which, pid_t, upid, struct siginfo __user *,
1670  infop, int, options, struct rusage __user *, ru)
1671 {
1672  struct wait_opts wo;
1673  struct pid *pid = NULL;
1674  enum pid_type type;
1675  long ret;
1676 
1678  return -EINVAL;
1679  if (!(options & (WEXITED|WSTOPPED|WCONTINUED)))
1680  return -EINVAL;
1681 
1682  switch (which) {
1683  case P_ALL:
1684  type = PIDTYPE_MAX;
1685  break;
1686  case P_PID:
1687  type = PIDTYPE_PID;
1688  if (upid <= 0)
1689  return -EINVAL;
1690  break;
1691  case P_PGID:
1692  type = PIDTYPE_PGID;
1693  if (upid <= 0)
1694  return -EINVAL;
1695  break;
1696  default:
1697  return -EINVAL;
1698  }
1699 
1700  if (type < PIDTYPE_MAX)
1701  pid = find_get_pid(upid);
1702 
1703  wo.wo_type = type;
1704  wo.wo_pid = pid;
1705  wo.wo_flags = options;
1706  wo.wo_info = infop;
1707  wo.wo_stat = NULL;
1708  wo.wo_rusage = ru;
1709  ret = do_wait(&wo);
1710 
1711  if (ret > 0) {
1712  ret = 0;
1713  } else if (infop) {
1714  /*
1715  * For a WNOHANG return, clear out all the fields
1716  * we would set so the user can easily tell the
1717  * difference.
1718  */
1719  if (!ret)
1720  ret = put_user(0, &infop->si_signo);
1721  if (!ret)
1722  ret = put_user(0, &infop->si_errno);
1723  if (!ret)
1724  ret = put_user(0, &infop->si_code);
1725  if (!ret)
1726  ret = put_user(0, &infop->si_pid);
1727  if (!ret)
1728  ret = put_user(0, &infop->si_uid);
1729  if (!ret)
1730  ret = put_user(0, &infop->si_status);
1731  }
1732 
1733  put_pid(pid);
1734 
1735  /* avoid REGPARM breakage on x86: */
1736  asmlinkage_protect(5, ret, which, upid, infop, options, ru);
1737  return ret;
1738 }
1739 
1740 SYSCALL_DEFINE4(wait4, pid_t, upid, int __user *, stat_addr,
1741  int, options, struct rusage __user *, ru)
1742 {
1743  struct wait_opts wo;
1744  struct pid *pid = NULL;
1745  enum pid_type type;
1746  long ret;
1747 
1750  return -EINVAL;
1751 
1752  if (upid == -1)
1753  type = PIDTYPE_MAX;
1754  else if (upid < 0) {
1755  type = PIDTYPE_PGID;
1756  pid = find_get_pid(-upid);
1757  } else if (upid == 0) {
1758  type = PIDTYPE_PGID;
1760  } else /* upid > 0 */ {
1761  type = PIDTYPE_PID;
1762  pid = find_get_pid(upid);
1763  }
1764 
1765  wo.wo_type = type;
1766  wo.wo_pid = pid;
1767  wo.wo_flags = options | WEXITED;
1768  wo.wo_info = NULL;
1769  wo.wo_stat = stat_addr;
1770  wo.wo_rusage = ru;
1771  ret = do_wait(&wo);
1772  put_pid(pid);
1773 
1774  /* avoid REGPARM breakage on x86: */
1775  asmlinkage_protect(4, ret, upid, stat_addr, options, ru);
1776  return ret;
1777 }
1778 
1779 #ifdef __ARCH_WANT_SYS_WAITPID
1780 
1781 /*
1782  * sys_waitpid() remains for compatibility. waitpid() should be
1783  * implemented by calling sys_wait4() from libc.a.
1784  */
1785 SYSCALL_DEFINE3(waitpid, pid_t, pid, int __user *, stat_addr, int, options)
1786 {
1787  return sys_wait4(pid, stat_addr, options, NULL);
1788 }
1789 
1790 #endif