blob: 90b09ca35c849b2a6421dd2dc717d7f58dc3a71b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/kernel/exit.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
Linus Torvalds1da177e2005-04-16 15:20:36 -07007#include <linux/mm.h>
8#include <linux/slab.h>
9#include <linux/interrupt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include <linux/module.h>
Randy.Dunlapc59ede72006-01-11 12:17:46 -080011#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/completion.h>
13#include <linux/personality.h>
14#include <linux/tty.h>
Jens Axboeda9cbc82008-06-30 20:42:08 +020015#include <linux/iocontext.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/key.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/cpu.h>
18#include <linux/acct.h>
Jay Lan8f0ab512006-09-30 23:28:59 -070019#include <linux/tsacct_kern.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/file.h>
Al Viro9f3acc32008-04-24 07:44:08 -040021#include <linux/fdtable.h>
Mandeep Singh Baines80d26af2013-02-27 17:03:20 -080022#include <linux/freezer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/binfmts.h>
Serge E. Hallynab516012006-10-02 02:18:06 -070024#include <linux/nsproxy.h>
Sukadev Bhattiprolu84d73782006-12-08 02:38:01 -080025#include <linux/pid_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/ptrace.h>
27#include <linux/profile.h>
28#include <linux/mount.h>
29#include <linux/proc_fs.h>
Eric W. Biederman49d769d2007-05-09 02:34:33 -070030#include <linux/kthread.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <linux/mempolicy.h>
Shailabh Nagarc7572492006-07-14 00:24:40 -070032#include <linux/taskstats_kern.h>
Shailabh Nagarca74e922006-07-14 00:24:36 -070033#include <linux/delayacct.h>
Paul Menageb4f48b62007-10-18 23:39:33 -070034#include <linux/cgroup.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/syscalls.h>
Jesper Juhl7ed20e12005-05-01 08:59:14 -070036#include <linux/signal.h>
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -080037#include <linux/posix-timers.h>
Matt Helsley9f460802005-11-07 00:59:16 -080038#include <linux/cn_proc.h>
Ingo Molnarde5097c2006-01-09 15:59:21 -080039#include <linux/mutex.h>
Ingo Molnar0771dfe2006-03-27 01:16:22 -080040#include <linux/futex.h>
Jens Axboeb92ce552006-04-11 13:52:07 +020041#include <linux/pipe_fs_i.h>
Al Virofa84cb92006-03-29 20:30:19 -050042#include <linux/audit.h> /* for audit_free() */
Adrian Bunk83cc5ed2006-06-25 05:47:41 -070043#include <linux/resource.h>
David Howells0d67a462006-08-29 19:05:56 +010044#include <linux/blkdev.h>
Eric Dumazet6eaeeab2007-05-10 22:22:37 -070045#include <linux/task_io_accounting_ops.h>
Roland McGrath30199f52008-07-25 19:45:46 -070046#include <linux/tracehook.h>
Al Viro5ad4e532009-03-29 19:50:06 -040047#include <linux/fs_struct.h>
Mike Rapoportca49ca72017-02-24 14:58:25 -080048#include <linux/userfaultfd_k.h>
David Howellsd84f4f92008-11-14 10:39:23 +110049#include <linux/init_task.h>
Ingo Molnarcdd6c482009-09-21 12:02:48 +020050#include <linux/perf_event.h>
Steven Rostedtad8d75f2009-04-14 19:39:12 -040051#include <trace/events/sched.h>
Frederic Weisbecker24f1e32c2009-09-09 19:22:48 +020052#include <linux/hw_breakpoint.h>
Ying Han3d5992d2010-10-26 14:21:23 -070053#include <linux/oom.h>
Wu Fengguang54848d72011-04-05 13:21:19 -060054#include <linux/writeback.h>
Al Viro40401532012-02-13 03:58:52 +000055#include <linux/shm.h>
Dmitry Vyukov5c9a8752016-03-22 14:27:30 -070056#include <linux/kcov.h>
Nicolas Pitre53d3eaa2016-11-11 00:10:09 -050057#include <linux/random.h>
Davidlohr Bueso8f95c902017-01-11 07:22:25 -080058#include <linux/rcuwait.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
Linus Torvalds7c0f6ba2016-12-24 11:46:01 -080060#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070061#include <asm/unistd.h>
62#include <asm/pgtable.h>
63#include <asm/mmu_context.h>
64
Oleg Nesterovd40e48e2010-05-26 14:43:19 -070065static void __unhash_process(struct task_struct *p, bool group_dead)
Linus Torvalds1da177e2005-04-16 15:20:36 -070066{
67 nr_threads--;
Oleg Nesterov50d75f82012-06-20 12:53:04 -070068 detach_pid(p, PIDTYPE_PID);
Oleg Nesterovd40e48e2010-05-26 14:43:19 -070069 if (group_dead) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 detach_pid(p, PIDTYPE_PGID);
71 detach_pid(p, PIDTYPE_SID);
Oleg Nesterovc97d9892006-03-28 16:11:06 -080072
Eric W. Biederman5e85d4a2006-04-18 22:20:16 -070073 list_del_rcu(&p->tasks);
Oleg Nesterov9cd80bb2009-12-17 15:27:15 -080074 list_del_init(&p->sibling);
Christoph Lameter909ea962010-12-08 16:22:55 +010075 __this_cpu_dec(process_counts);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 }
Oleg Nesterov47e65322006-03-28 16:11:25 -080077 list_del_rcu(&p->thread_group);
Oleg Nesterov0c740d02014-01-21 15:49:56 -080078 list_del_rcu(&p->thread_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079}
80
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -080081/*
82 * This function expects the tasklist_lock write-locked.
83 */
84static void __exit_signal(struct task_struct *tsk)
85{
86 struct signal_struct *sig = tsk->signal;
Oleg Nesterovd40e48e2010-05-26 14:43:19 -070087 bool group_dead = thread_group_leader(tsk);
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -080088 struct sighand_struct *sighand;
Oleg Nesterov4ada8562010-05-26 14:43:17 -070089 struct tty_struct *uninitialized_var(tty);
Frederic Weisbecker5613fda2017-01-31 04:09:23 +010090 u64 utime, stime;
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -080091
Paul E. McKenneyd11c5632010-02-22 17:04:50 -080092 sighand = rcu_dereference_check(tsk->sighand,
Paul E. McKenneydb1466b2010-03-03 07:46:56 -080093 lockdep_tasklist_lock_is_held());
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -080094 spin_lock(&sighand->siglock);
95
Nicolas Pitrebaa73d92016-11-11 00:10:10 -050096#ifdef CONFIG_POSIX_TIMERS
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -080097 posix_cpu_timers_exit(tsk);
Oleg Nesterovd40e48e2010-05-26 14:43:19 -070098 if (group_dead) {
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -080099 posix_cpu_timers_exit_group(tsk);
Oleg Nesterov4a599942010-05-26 14:43:12 -0700100 } else {
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -0800101 /*
Oleg Nesterove0a70212010-11-05 16:53:42 +0100102 * This can only happen if the caller is de_thread().
103 * FIXME: this is the temporary hack, we should teach
104 * posix-cpu-timers to handle this case correctly.
105 */
106 if (unlikely(has_group_leader_pid(tsk)))
107 posix_cpu_timers_exit_group(tsk);
Nicolas Pitrebaa73d92016-11-11 00:10:10 -0500108 }
109#endif
Oleg Nesterove0a70212010-11-05 16:53:42 +0100110
Nicolas Pitrebaa73d92016-11-11 00:10:10 -0500111 if (group_dead) {
112 tty = sig->tty;
113 sig->tty = NULL;
114 } else {
Oleg Nesterove0a70212010-11-05 16:53:42 +0100115 /*
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -0800116 * If there is any task waiting for the group exit
117 * then notify it:
118 */
Oleg Nesterovd3441932010-05-26 14:43:11 -0700119 if (sig->notify_count > 0 && !--sig->notify_count)
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -0800120 wake_up_process(sig->group_exit_task);
Oleg Nesterov6db840f2007-10-16 23:27:23 -0700121
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -0800122 if (tsk == sig->curr_target)
123 sig->curr_target = next_thread(tsk);
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -0800124 }
125
Nicolas Pitre53d3eaa2016-11-11 00:10:09 -0500126 add_device_randomness((const void*) &tsk->se.sum_exec_runtime,
127 sizeof(unsigned long long));
128
Rik van Riel90ed9cb2014-08-15 16:05:36 -0400129 /*
Oleg Nesterov26e75b52014-12-10 15:54:54 -0800130 * Accumulate here the counters for all threads as they die. We could
131 * skip the group leader because it is the last user of signal_struct,
132 * but we want to avoid the race with thread_group_cputime() which can
133 * see the empty ->thread_head list.
Rik van Riel90ed9cb2014-08-15 16:05:36 -0400134 */
135 task_cputime(tsk, &utime, &stime);
Rik van Riele78c3492014-08-16 13:40:10 -0400136 write_seqlock(&sig->stats_lock);
Rik van Riel90ed9cb2014-08-15 16:05:36 -0400137 sig->utime += utime;
138 sig->stime += stime;
139 sig->gtime += task_gtime(tsk);
140 sig->min_flt += tsk->min_flt;
141 sig->maj_flt += tsk->maj_flt;
142 sig->nvcsw += tsk->nvcsw;
143 sig->nivcsw += tsk->nivcsw;
144 sig->inblock += task_io_get_inblock(tsk);
145 sig->oublock += task_io_get_oublock(tsk);
146 task_io_accounting_add(&sig->ioac, &tsk->ioac);
147 sig->sum_sched_runtime += tsk->se.sum_exec_runtime;
Oleg Nesterovb3ac0222010-05-26 14:43:24 -0700148 sig->nr_threads--;
Oleg Nesterovd40e48e2010-05-26 14:43:19 -0700149 __unhash_process(tsk, group_dead);
Rik van Riele78c3492014-08-16 13:40:10 -0400150 write_sequnlock(&sig->stats_lock);
Oleg Nesterov58767002006-03-28 16:11:20 -0800151
Oleg Nesterovda7978b2008-05-23 13:04:41 -0700152 /*
153 * Do this under ->siglock, we can race with another thread
154 * doing sigqueue_free() if we have SIGQUEUE_PREALLOC signals.
155 */
156 flush_sigqueue(&tsk->pending);
Oleg Nesterova7e53282006-03-28 16:11:27 -0800157 tsk->sighand = NULL;
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -0800158 spin_unlock(&sighand->siglock);
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -0800159
Oleg Nesterova7e53282006-03-28 16:11:27 -0800160 __cleanup_sighand(sighand);
Ionut Alexaa0be55d2014-08-08 14:21:18 -0700161 clear_tsk_thread_flag(tsk, TIF_SIGPENDING);
Oleg Nesterovd40e48e2010-05-26 14:43:19 -0700162 if (group_dead) {
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -0800163 flush_sigqueue(&sig->shared_pending);
Oleg Nesterov4ada8562010-05-26 14:43:17 -0700164 tty_kref_put(tty);
Oleg Nesterov6a14c5c2006-03-28 16:11:18 -0800165 }
166}
167
Eric W. Biederman8c7904a2006-03-31 02:31:37 -0800168static void delayed_put_task_struct(struct rcu_head *rhp)
169{
Mathieu Desnoyers0a16b602008-07-18 12:16:17 -0400170 struct task_struct *tsk = container_of(rhp, struct task_struct, rcu);
171
Peter Zijlstra4e231c72010-09-09 21:01:59 +0200172 perf_event_delayed_put(tsk);
Mathieu Desnoyers0a16b602008-07-18 12:16:17 -0400173 trace_sched_process_free(tsk);
174 put_task_struct(tsk);
Eric W. Biederman8c7904a2006-03-31 02:31:37 -0800175}
176
Roland McGrathf4700212008-03-24 18:36:23 -0700177
Ionut Alexaa0be55d2014-08-08 14:21:18 -0700178void release_task(struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179{
Ingo Molnar36c8b582006-07-03 00:25:41 -0700180 struct task_struct *leader;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 int zap_leader;
Oleg Nesterov1f09f972006-03-28 16:11:11 -0800182repeat:
David Howellsc69e8d92008-11-14 10:39:19 +1100183 /* don't need to get the RCU readlock here - the process is dead and
Paul E. McKenneyd11c5632010-02-22 17:04:50 -0800184 * can't be modifying its own credentials. But shut RCU-lockdep up */
185 rcu_read_lock();
David Howellsc69e8d92008-11-14 10:39:19 +1100186 atomic_dec(&__task_cred(p)->user->processes);
Paul E. McKenneyd11c5632010-02-22 17:04:50 -0800187 rcu_read_unlock();
David Howellsc69e8d92008-11-14 10:39:19 +1100188
Pavel Emelyanov60347f62007-10-18 23:40:03 -0700189 proc_flush_task(p);
Ingo Molnar02030262009-05-17 11:24:08 +0200190
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 write_lock_irq(&tasklist_lock);
Tejun Heoa288eec2011-06-17 16:50:37 +0200192 ptrace_release_task(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 __exit_signal(p);
Oleg Nesterov35f5cad2006-03-28 16:11:19 -0800194
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 /*
196 * If we are the last non-leader member of the thread
197 * group, and the leader is zombie, then notify the
198 * group leader's parent process. (if it wants notification.)
199 */
200 zap_leader = 0;
201 leader = p->group_leader;
Ionut Alexaa0be55d2014-08-08 14:21:18 -0700202 if (leader != p && thread_group_empty(leader)
203 && leader->exit_state == EXIT_ZOMBIE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 /*
205 * If we were the last child thread and the leader has
206 * exited already, and the leader's parent ignores SIGCHLD,
207 * then we are the one who should release the leader.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 */
Oleg Nesterov86773472011-06-22 23:09:09 +0200209 zap_leader = do_notify_parent(leader, leader->exit_signal);
Roland McGrathdae33572008-07-25 19:45:48 -0700210 if (zap_leader)
211 leader->exit_state = EXIT_DEAD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 }
213
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 write_unlock_irq(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 release_thread(p);
Eric W. Biederman8c7904a2006-03-31 02:31:37 -0800216 call_rcu(&p->rcu, delayed_put_task_struct);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217
218 p = leader;
219 if (unlikely(zap_leader))
220 goto repeat;
221}
222
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223/*
Oleg Nesterov150593b2016-05-18 19:02:18 +0200224 * Note that if this function returns a valid task_struct pointer (!NULL)
225 * task->usage must remain >0 for the duration of the RCU critical section.
226 */
227struct task_struct *task_rcu_dereference(struct task_struct **ptask)
228{
229 struct sighand_struct *sighand;
230 struct task_struct *task;
231
232 /*
233 * We need to verify that release_task() was not called and thus
234 * delayed_put_task_struct() can't run and drop the last reference
235 * before rcu_read_unlock(). We check task->sighand != NULL,
236 * but we can read the already freed and reused memory.
237 */
238retry:
239 task = rcu_dereference(*ptask);
240 if (!task)
241 return NULL;
242
243 probe_kernel_address(&task->sighand, sighand);
244
245 /*
246 * Pairs with atomic_dec_and_test() in put_task_struct(). If this task
247 * was already freed we can not miss the preceding update of this
248 * pointer.
249 */
250 smp_rmb();
251 if (unlikely(task != READ_ONCE(*ptask)))
252 goto retry;
253
254 /*
255 * We've re-checked that "task == *ptask", now we have two different
256 * cases:
257 *
258 * 1. This is actually the same task/task_struct. In this case
259 * sighand != NULL tells us it is still alive.
260 *
261 * 2. This is another task which got the same memory for task_struct.
262 * We can't know this of course, and we can not trust
263 * sighand != NULL.
264 *
265 * In this case we actually return a random value, but this is
266 * correct.
267 *
268 * If we return NULL - we can pretend that we actually noticed that
269 * *ptask was updated when the previous task has exited. Or pretend
270 * that probe_slab_address(&sighand) reads NULL.
271 *
272 * If we return the new task (because sighand is not NULL for any
273 * reason) - this is fine too. This (new) task can't go away before
274 * another gp pass.
275 *
276 * And note: We could even eliminate the false positive if re-read
277 * task->sighand once again to avoid the falsely NULL. But this case
278 * is very unlikely so we don't care.
279 */
280 if (!sighand)
281 return NULL;
282
283 return task;
284}
285
Davidlohr Bueso8f95c902017-01-11 07:22:25 -0800286void rcuwait_wake_up(struct rcuwait *w)
287{
288 struct task_struct *task;
289
290 rcu_read_lock();
291
292 /*
293 * Order condition vs @task, such that everything prior to the load
294 * of @task is visible. This is the condition as to why the user called
295 * rcuwait_trywake() in the first place. Pairs with set_current_state()
296 * barrier (A) in rcuwait_wait_event().
297 *
298 * WAIT WAKE
299 * [S] tsk = current [S] cond = true
300 * MB (A) MB (B)
301 * [L] cond [L] tsk
302 */
303 smp_rmb(); /* (B) */
304
305 /*
306 * Avoid using task_rcu_dereference() magic as long as we are careful,
307 * see comment in rcuwait_wait_event() regarding ->exit_state.
308 */
309 task = rcu_dereference(w->task);
310 if (task)
311 wake_up_process(task);
312 rcu_read_unlock();
313}
314
Oleg Nesterov150593b2016-05-18 19:02:18 +0200315struct task_struct *try_get_task_struct(struct task_struct **ptask)
316{
317 struct task_struct *task;
318
319 rcu_read_lock();
320 task = task_rcu_dereference(ptask);
321 if (task)
322 get_task_struct(task);
323 rcu_read_unlock();
324
325 return task;
326}
327
328/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 * Determine if a process group is "orphaned", according to the POSIX
330 * definition in 2.2.2.52. Orphaned process groups are not to be affected
331 * by terminal-generated stop signals. Newly orphaned process groups are
332 * to receive a SIGHUP and a SIGCONT.
333 *
334 * "I ask you, have you ever known what it is to be an orphan?"
335 */
Ionut Alexaa0be55d2014-08-08 14:21:18 -0700336static int will_become_orphaned_pgrp(struct pid *pgrp,
337 struct task_struct *ignored_task)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338{
339 struct task_struct *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340
Eric W. Biederman0475ac082007-02-12 00:52:57 -0800341 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
Oleg Nesterov05e83df2008-03-02 21:44:42 +0300342 if ((p == ignored_task) ||
343 (p->exit_state && thread_group_empty(p)) ||
344 is_global_init(p->real_parent))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 continue;
Oleg Nesterov05e83df2008-03-02 21:44:42 +0300346
Eric W. Biederman0475ac082007-02-12 00:52:57 -0800347 if (task_pgrp(p->real_parent) != pgrp &&
Oleg Nesterov05e83df2008-03-02 21:44:42 +0300348 task_session(p->real_parent) == task_session(p))
349 return 0;
Eric W. Biederman0475ac082007-02-12 00:52:57 -0800350 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
Oleg Nesterov05e83df2008-03-02 21:44:42 +0300351
352 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353}
354
Eric W. Biederman3e7cd6c2007-02-12 00:52:58 -0800355int is_current_pgrp_orphaned(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356{
357 int retval;
358
359 read_lock(&tasklist_lock);
Eric W. Biederman3e7cd6c2007-02-12 00:52:58 -0800360 retval = will_become_orphaned_pgrp(task_pgrp(current), NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 read_unlock(&tasklist_lock);
362
363 return retval;
364}
365
Oleg Nesterov961c4672011-07-07 21:33:54 +0200366static bool has_stopped_jobs(struct pid *pgrp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 struct task_struct *p;
369
Eric W. Biederman0475ac082007-02-12 00:52:57 -0800370 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
Oleg Nesterov961c4672011-07-07 21:33:54 +0200371 if (p->signal->flags & SIGNAL_STOP_STOPPED)
372 return true;
Eric W. Biederman0475ac082007-02-12 00:52:57 -0800373 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
Oleg Nesterov961c4672011-07-07 21:33:54 +0200374
375 return false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376}
377
Oleg Nesterovf49ee502008-03-02 21:44:40 +0300378/*
379 * Check to see if any process groups have become orphaned as
380 * a result of our exiting, and if they have any stopped jobs,
381 * send them a SIGHUP and then a SIGCONT. (POSIX 3.2.2.2)
382 */
383static void
384kill_orphaned_pgrp(struct task_struct *tsk, struct task_struct *parent)
385{
386 struct pid *pgrp = task_pgrp(tsk);
387 struct task_struct *ignored_task = tsk;
388
389 if (!parent)
Ionut Alexaa0be55d2014-08-08 14:21:18 -0700390 /* exit: our father is in a different pgrp than
391 * we are and we were the only connection outside.
392 */
Oleg Nesterovf49ee502008-03-02 21:44:40 +0300393 parent = tsk->real_parent;
394 else
395 /* reparent: our child is in a different pgrp than
396 * we are, and it was the only connection outside.
397 */
398 ignored_task = NULL;
399
400 if (task_pgrp(parent) != pgrp &&
401 task_session(parent) == task_session(tsk) &&
402 will_become_orphaned_pgrp(pgrp, ignored_task) &&
403 has_stopped_jobs(pgrp)) {
404 __kill_pgrp_info(SIGHUP, SEND_SIG_PRIV, pgrp);
405 __kill_pgrp_info(SIGCONT, SEND_SIG_PRIV, pgrp);
406 }
407}
408
Oleg Nesterovf98bafa2014-06-04 16:07:34 -0700409#ifdef CONFIG_MEMCG
Balbir Singhcf475ad22008-04-29 01:00:16 -0700410/*
KAMEZAWA Hiroyuki733eda72011-06-15 15:08:43 -0700411 * A task is exiting. If it owned this mm, find a new owner for the mm.
Balbir Singhcf475ad22008-04-29 01:00:16 -0700412 */
Balbir Singhcf475ad22008-04-29 01:00:16 -0700413void mm_update_next_owner(struct mm_struct *mm)
414{
415 struct task_struct *c, *g, *p = current;
416
417retry:
KAMEZAWA Hiroyuki733eda72011-06-15 15:08:43 -0700418 /*
419 * If the exiting or execing task is not the owner, it's
420 * someone else's problem.
421 */
422 if (mm->owner != p)
Balbir Singhcf475ad22008-04-29 01:00:16 -0700423 return;
KAMEZAWA Hiroyuki733eda72011-06-15 15:08:43 -0700424 /*
425 * The current owner is exiting/execing and there are no other
426 * candidates. Do not leave the mm pointing to a possibly
427 * freed task structure.
428 */
429 if (atomic_read(&mm->mm_users) <= 1) {
430 mm->owner = NULL;
431 return;
432 }
Balbir Singhcf475ad22008-04-29 01:00:16 -0700433
434 read_lock(&tasklist_lock);
435 /*
436 * Search in the children
437 */
438 list_for_each_entry(c, &p->children, sibling) {
439 if (c->mm == mm)
440 goto assign_new_owner;
441 }
442
443 /*
444 * Search in the siblings
445 */
Oleg Nesterovdea33cf2009-06-17 16:27:29 -0700446 list_for_each_entry(c, &p->real_parent->children, sibling) {
Balbir Singhcf475ad22008-04-29 01:00:16 -0700447 if (c->mm == mm)
448 goto assign_new_owner;
449 }
450
451 /*
Oleg Nesterovf87fb592014-06-04 16:07:52 -0700452 * Search through everything else, we should not get here often.
Balbir Singhcf475ad22008-04-29 01:00:16 -0700453 */
Oleg Nesterov39af1762014-06-04 16:07:54 -0700454 for_each_process(g) {
455 if (g->flags & PF_KTHREAD)
456 continue;
457 for_each_thread(g, c) {
458 if (c->mm == mm)
459 goto assign_new_owner;
460 if (c->mm)
461 break;
462 }
Oleg Nesterovf87fb592014-06-04 16:07:52 -0700463 }
Balbir Singhcf475ad22008-04-29 01:00:16 -0700464 read_unlock(&tasklist_lock);
Balbir Singh31a78f22008-09-28 23:09:31 +0100465 /*
466 * We found no owner yet mm_users > 1: this implies that we are
467 * most likely racing with swapoff (try_to_unuse()) or /proc or
Hugh Dickinse5991372009-01-06 14:39:22 -0800468 * ptrace or page migration (get_task_mm()). Mark owner as NULL.
Balbir Singh31a78f22008-09-28 23:09:31 +0100469 */
Balbir Singh31a78f22008-09-28 23:09:31 +0100470 mm->owner = NULL;
Balbir Singhcf475ad22008-04-29 01:00:16 -0700471 return;
472
473assign_new_owner:
474 BUG_ON(c == p);
475 get_task_struct(c);
476 /*
477 * The task_lock protects c->mm from changing.
478 * We always want mm->owner->mm == mm
479 */
480 task_lock(c);
Hugh Dickinse5991372009-01-06 14:39:22 -0800481 /*
482 * Delay read_unlock() till we have the task_lock()
483 * to ensure that c does not slip away underneath us
484 */
485 read_unlock(&tasklist_lock);
Balbir Singhcf475ad22008-04-29 01:00:16 -0700486 if (c->mm != mm) {
487 task_unlock(c);
488 put_task_struct(c);
489 goto retry;
490 }
Balbir Singhcf475ad22008-04-29 01:00:16 -0700491 mm->owner = c;
492 task_unlock(c);
493 put_task_struct(c);
494}
Oleg Nesterovf98bafa2014-06-04 16:07:34 -0700495#endif /* CONFIG_MEMCG */
Balbir Singhcf475ad22008-04-29 01:00:16 -0700496
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497/*
498 * Turn us into a lazy TLB process if we
499 * aren't already..
500 */
Davidlohr Bueso00399622017-01-03 13:43:11 -0800501static void exit_mm(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502{
Davidlohr Bueso00399622017-01-03 13:43:11 -0800503 struct mm_struct *mm = current->mm;
Oleg Nesterovb564daf2008-07-25 01:47:44 -0700504 struct core_state *core_state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
Davidlohr Bueso00399622017-01-03 13:43:11 -0800506 mm_release(current, mm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 if (!mm)
508 return;
Konstantin Khlebnikov4fe7efd2012-06-20 12:53:01 -0700509 sync_mm_rss(mm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 /*
511 * Serialize with any possible pending coredump.
Oleg Nesterov999d9fc2008-07-25 01:47:41 -0700512 * We must hold mmap_sem around checking core_state
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 * and clearing tsk->mm. The core-inducing thread
Oleg Nesterov999d9fc2008-07-25 01:47:41 -0700514 * will increment ->nr_threads for each thread in the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 * group with ->mm != NULL.
516 */
517 down_read(&mm->mmap_sem);
Oleg Nesterovb564daf2008-07-25 01:47:44 -0700518 core_state = mm->core_state;
519 if (core_state) {
520 struct core_thread self;
Ionut Alexaa0be55d2014-08-08 14:21:18 -0700521
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 up_read(&mm->mmap_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523
Davidlohr Bueso00399622017-01-03 13:43:11 -0800524 self.task = current;
Oleg Nesterovb564daf2008-07-25 01:47:44 -0700525 self.next = xchg(&core_state->dumper.next, &self);
526 /*
527 * Implies mb(), the result of xchg() must be visible
528 * to core_state->dumper.
529 */
530 if (atomic_dec_and_test(&core_state->nr_threads))
531 complete(&core_state->startup);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532
Oleg Nesterova94e2d42008-07-25 01:47:46 -0700533 for (;;) {
Davidlohr Bueso642fa442017-01-03 13:43:14 -0800534 set_current_state(TASK_UNINTERRUPTIBLE);
Oleg Nesterova94e2d42008-07-25 01:47:46 -0700535 if (!self.task) /* see coredump_finish() */
536 break;
Mandeep Singh Baines80d26af2013-02-27 17:03:20 -0800537 freezable_schedule();
Oleg Nesterova94e2d42008-07-25 01:47:46 -0700538 }
Davidlohr Bueso642fa442017-01-03 13:43:14 -0800539 __set_current_state(TASK_RUNNING);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 down_read(&mm->mmap_sem);
541 }
542 atomic_inc(&mm->mm_count);
Davidlohr Bueso00399622017-01-03 13:43:11 -0800543 BUG_ON(mm != current->active_mm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 /* more a memory barrier than a real lock */
Davidlohr Bueso00399622017-01-03 13:43:11 -0800545 task_lock(current);
546 current->mm = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 up_read(&mm->mmap_sem);
548 enter_lazy_tlb(mm, current);
Davidlohr Bueso00399622017-01-03 13:43:11 -0800549 task_unlock(current);
Balbir Singhcf475ad22008-04-29 01:00:16 -0700550 mm_update_next_owner(mm);
Mike Rapoportca49ca72017-02-24 14:58:25 -0800551 userfaultfd_exit(mm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 mmput(mm);
Michal Hockoc32b3cb2015-02-11 15:26:24 -0800553 if (test_thread_flag(TIF_MEMDIE))
Tetsuo Handa38531202016-10-07 16:59:03 -0700554 exit_oom_victim();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555}
556
Oleg Nesterovc9dc05b2014-12-10 15:55:14 -0800557static struct task_struct *find_alive_thread(struct task_struct *p)
558{
559 struct task_struct *t;
560
561 for_each_thread(p, t) {
562 if (!(t->flags & PF_EXITING))
563 return t;
564 }
565 return NULL;
566}
567
Oleg Nesterov11099092014-12-10 15:55:11 -0800568static struct task_struct *find_child_reaper(struct task_struct *father)
569 __releases(&tasklist_lock)
570 __acquires(&tasklist_lock)
571{
572 struct pid_namespace *pid_ns = task_active_pid_ns(father);
573 struct task_struct *reaper = pid_ns->child_reaper;
574
575 if (likely(reaper != father))
576 return reaper;
577
Oleg Nesterovc9dc05b2014-12-10 15:55:14 -0800578 reaper = find_alive_thread(father);
579 if (reaper) {
Oleg Nesterov11099092014-12-10 15:55:11 -0800580 pid_ns->child_reaper = reaper;
581 return reaper;
582 }
583
584 write_unlock_irq(&tasklist_lock);
585 if (unlikely(pid_ns == &init_pid_ns)) {
586 panic("Attempted to kill init! exitcode=0x%08x\n",
587 father->signal->group_exit_code ?: father->exit_code);
588 }
589 zap_pid_ns_processes(pid_ns);
590 write_lock_irq(&tasklist_lock);
591
592 return father;
593}
594
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595/*
Lennart Poetteringebec18a2012-03-23 15:01:54 -0700596 * When we die, we re-parent all our children, and try to:
597 * 1. give them to another thread in our thread group, if such a member exists
598 * 2. give it to the first ancestor process which prctl'd itself as a
599 * child_subreaper for its children (like a service manager)
600 * 3. give it to the init process (PID 1) in our pid namespace
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 */
Oleg Nesterov11099092014-12-10 15:55:11 -0800602static struct task_struct *find_new_reaper(struct task_struct *father,
603 struct task_struct *child_reaper)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604{
Oleg Nesterovc9dc05b2014-12-10 15:55:14 -0800605 struct task_struct *thread, *reaper;
Oleg Nesterov762a24b2007-10-18 23:40:00 -0700606
Oleg Nesterovc9dc05b2014-12-10 15:55:14 -0800607 thread = find_alive_thread(father);
608 if (thread)
Oleg Nesterov950bbab2008-09-02 14:35:49 -0700609 return thread;
Oleg Nesterov762a24b2007-10-18 23:40:00 -0700610
Oleg Nesterov7d24e2d2014-12-10 15:55:02 -0800611 if (father->signal->has_child_subreaper) {
Oleg Nesterovc6c70f42017-01-30 19:17:35 +0100612 unsigned int ns_level = task_pid(father)->level;
Lennart Poetteringebec18a2012-03-23 15:01:54 -0700613 /*
Oleg Nesterov175aed32014-12-10 15:55:08 -0800614 * Find the first ->is_child_subreaper ancestor in our pid_ns.
Oleg Nesterovc6c70f42017-01-30 19:17:35 +0100615 * We can't check reaper != child_reaper to ensure we do not
616 * cross the namespaces, the exiting parent could be injected
617 * by setns() + fork().
618 * We check pid->level, this is slightly more efficient than
619 * task_active_pid_ns(reaper) != task_active_pid_ns(father).
Lennart Poetteringebec18a2012-03-23 15:01:54 -0700620 */
Oleg Nesterovc6c70f42017-01-30 19:17:35 +0100621 for (reaper = father->real_parent;
622 task_pid(reaper)->level == ns_level;
Lennart Poetteringebec18a2012-03-23 15:01:54 -0700623 reaper = reaper->real_parent) {
Oleg Nesterov175aed32014-12-10 15:55:08 -0800624 if (reaper == &init_task)
Lennart Poetteringebec18a2012-03-23 15:01:54 -0700625 break;
626 if (!reaper->signal->is_child_subreaper)
627 continue;
Oleg Nesterovc9dc05b2014-12-10 15:55:14 -0800628 thread = find_alive_thread(reaper);
629 if (thread)
630 return thread;
Lennart Poetteringebec18a2012-03-23 15:01:54 -0700631 }
Oleg Nesterov950bbab2008-09-02 14:35:49 -0700632 }
633
Oleg Nesterov11099092014-12-10 15:55:11 -0800634 return child_reaper;
Oleg Nesterov950bbab2008-09-02 14:35:49 -0700635}
636
Oleg Nesterov5dfc80b2009-04-02 16:58:19 -0700637/*
638* Any that need to be release_task'd are put on the @dead list.
639 */
Oleg Nesterov9cd80bb2009-12-17 15:27:15 -0800640static void reparent_leader(struct task_struct *father, struct task_struct *p,
Oleg Nesterov5dfc80b2009-04-02 16:58:19 -0700641 struct list_head *dead)
642{
Oleg Nesterov28310962014-12-10 15:45:30 -0800643 if (unlikely(p->exit_state == EXIT_DEAD))
Oleg Nesterov5dfc80b2009-04-02 16:58:19 -0700644 return;
645
Oleg Nesterovabd50b32014-04-07 15:38:42 -0700646 /* We don't want people slaying init. */
Oleg Nesterov5dfc80b2009-04-02 16:58:19 -0700647 p->exit_signal = SIGCHLD;
648
649 /* If it has exited notify the new parent about this child's death. */
Tejun Heod21142e2011-06-17 16:50:34 +0200650 if (!p->ptrace &&
Oleg Nesterov5dfc80b2009-04-02 16:58:19 -0700651 p->exit_state == EXIT_ZOMBIE && thread_group_empty(p)) {
Oleg Nesterov86773472011-06-22 23:09:09 +0200652 if (do_notify_parent(p, p->exit_signal)) {
Oleg Nesterov5dfc80b2009-04-02 16:58:19 -0700653 p->exit_state = EXIT_DEAD;
Oleg Nesterovdc2fd4b2014-12-10 15:45:24 -0800654 list_add(&p->ptrace_entry, dead);
Oleg Nesterov5dfc80b2009-04-02 16:58:19 -0700655 }
656 }
657
658 kill_orphaned_pgrp(p, father);
659}
660
Oleg Nesterov482a3762014-12-10 15:55:20 -0800661/*
662 * This does two things:
663 *
664 * A. Make init inherit all the child processes
665 * B. Check to see if any process groups have become orphaned
666 * as a result of our exiting, and if they have any stopped
667 * jobs, send them a SIGHUP and then a SIGCONT. (POSIX 3.2.2.2)
668 */
669static void forget_original_parent(struct task_struct *father,
670 struct list_head *dead)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671{
Oleg Nesterov482a3762014-12-10 15:55:20 -0800672 struct task_struct *p, *t, *reaper;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673
Oleg Nesterov7c8bd232014-12-10 15:45:33 -0800674 if (unlikely(!list_empty(&father->ptraced)))
Oleg Nesterov482a3762014-12-10 15:55:20 -0800675 exit_ptrace(father, dead);
Roland McGrathf4700212008-03-24 18:36:23 -0700676
Oleg Nesterov7c8bd232014-12-10 15:45:33 -0800677 /* Can drop and reacquire tasklist_lock */
Oleg Nesterov11099092014-12-10 15:55:11 -0800678 reaper = find_child_reaper(father);
Oleg Nesterovad9e2062014-12-10 15:55:17 -0800679 if (list_empty(&father->children))
Oleg Nesterov482a3762014-12-10 15:55:20 -0800680 return;
Oleg Nesterov11099092014-12-10 15:55:11 -0800681
682 reaper = find_new_reaper(father, reaper);
Oleg Nesterov28310962014-12-10 15:45:30 -0800683 list_for_each_entry(p, &father->children, sibling) {
Oleg Nesterov57a05912014-12-10 15:45:27 -0800684 for_each_thread(p, t) {
Oleg Nesterov9cd80bb2009-12-17 15:27:15 -0800685 t->real_parent = reaper;
Oleg Nesterov57a05912014-12-10 15:45:27 -0800686 BUG_ON((!t->ptrace) != (t->parent == father));
687 if (likely(!t->ptrace))
Oleg Nesterov9cd80bb2009-12-17 15:27:15 -0800688 t->parent = t->real_parent;
Oleg Nesterov9cd80bb2009-12-17 15:27:15 -0800689 if (t->pdeath_signal)
690 group_send_sig_info(t->pdeath_signal,
691 SEND_SIG_NOINFO, t);
Oleg Nesterov57a05912014-12-10 15:45:27 -0800692 }
Oleg Nesterov28310962014-12-10 15:45:30 -0800693 /*
694 * If this is a threaded reparent there is no need to
695 * notify anyone anything has happened.
696 */
697 if (!same_thread_group(reaper, father))
Oleg Nesterov482a3762014-12-10 15:55:20 -0800698 reparent_leader(father, p, dead);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 }
Oleg Nesterov28310962014-12-10 15:45:30 -0800700 list_splice_tail_init(&father->children, &reaper->children);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701}
702
703/*
704 * Send signals to all our closest relatives so that they know
705 * to properly mourn us..
706 */
Oleg Nesterov821c7de2008-03-02 21:44:44 +0300707static void exit_notify(struct task_struct *tsk, int group_dead)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708{
Oleg Nesterov53c8f9f2011-06-22 23:08:18 +0200709 bool autoreap;
Oleg Nesterov482a3762014-12-10 15:55:20 -0800710 struct task_struct *p, *n;
711 LIST_HEAD(dead);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712
Oleg Nesterov762a24b2007-10-18 23:40:00 -0700713 write_lock_irq(&tasklist_lock);
Oleg Nesterov482a3762014-12-10 15:55:20 -0800714 forget_original_parent(tsk, &dead);
715
Oleg Nesterov821c7de2008-03-02 21:44:44 +0300716 if (group_dead)
717 kill_orphaned_pgrp(tsk->group_leader, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718
Oleg Nesterov45cdf5c2011-06-23 19:06:50 +0200719 if (unlikely(tsk->ptrace)) {
720 int sig = thread_group_leader(tsk) &&
721 thread_group_empty(tsk) &&
722 !ptrace_reparented(tsk) ?
723 tsk->exit_signal : SIGCHLD;
724 autoreap = do_notify_parent(tsk, sig);
725 } else if (thread_group_leader(tsk)) {
726 autoreap = thread_group_empty(tsk) &&
727 do_notify_parent(tsk, tsk->exit_signal);
728 } else {
729 autoreap = true;
730 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731
Oleg Nesterov53c8f9f2011-06-22 23:08:18 +0200732 tsk->exit_state = autoreap ? EXIT_DEAD : EXIT_ZOMBIE;
Oleg Nesterov6c66e7d2014-12-10 15:55:23 -0800733 if (tsk->exit_state == EXIT_DEAD)
734 list_add(&tsk->ptrace_entry, &dead);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
Oleg Nesterov9c3391682010-05-26 14:43:10 -0700736 /* mt-exec, de_thread() is waiting for group leader */
737 if (unlikely(tsk->signal->notify_count < 0))
Oleg Nesterov6db840f2007-10-16 23:27:23 -0700738 wake_up_process(tsk->signal->group_exit_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 write_unlock_irq(&tasklist_lock);
740
Oleg Nesterov482a3762014-12-10 15:55:20 -0800741 list_for_each_entry_safe(p, n, &dead, ptrace_entry) {
742 list_del_init(&p->ptrace_entry);
743 release_task(p);
744 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745}
746
Jeff Dikee18eecb2007-07-15 23:38:48 -0700747#ifdef CONFIG_DEBUG_STACK_USAGE
748static void check_stack_usage(void)
749{
750 static DEFINE_SPINLOCK(low_water_lock);
751 static int lowest_to_date = THREAD_SIZE;
Jeff Dikee18eecb2007-07-15 23:38:48 -0700752 unsigned long free;
753
Eric Sandeen7c9f8862008-04-22 16:38:23 -0500754 free = stack_not_used(current);
Jeff Dikee18eecb2007-07-15 23:38:48 -0700755
756 if (free >= lowest_to_date)
757 return;
758
759 spin_lock(&low_water_lock);
760 if (free < lowest_to_date) {
Anton Blanchard627393d2016-08-02 14:05:40 -0700761 pr_info("%s (%d) used greatest stack depth: %lu bytes left\n",
Ionut Alexaa0be55d2014-08-08 14:21:18 -0700762 current->comm, task_pid_nr(current), free);
Jeff Dikee18eecb2007-07-15 23:38:48 -0700763 lowest_to_date = free;
764 }
765 spin_unlock(&low_water_lock);
766}
767#else
768static inline void check_stack_usage(void) {}
769#endif
770
Peter Zijlstra9af65282016-09-13 18:37:29 +0200771void __noreturn do_exit(long code)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772{
773 struct task_struct *tsk = current;
774 int group_dead;
Paul E. McKenney3f95aa82014-08-04 06:10:23 -0700775 TASKS_RCU(int tasks_rcu_i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
777 profile_task_exit(tsk);
Dmitry Vyukov5c9a8752016-03-22 14:27:30 -0700778 kcov_task_exit(tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779
Jens Axboe73c10102011-03-08 13:19:51 +0100780 WARN_ON(blk_needs_flush_plug(tsk));
Jens Axboe22e2c502005-06-27 10:55:12 +0200781
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 if (unlikely(in_interrupt()))
783 panic("Aiee, killing interrupt handler!");
784 if (unlikely(!tsk->pid))
785 panic("Attempted to kill the idle task!");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786
Nelson Elhage33dd94a2010-12-02 14:31:21 -0800787 /*
788 * If do_exit is called because this processes oopsed, it's possible
789 * that get_fs() was left as KERNEL_DS, so reset it to USER_DS before
790 * continuing. Amongst other possible reasons, this is to prevent
791 * mm_release()->clear_child_tid() from writing to a user-controlled
792 * kernel address.
793 */
794 set_fs(USER_DS);
795
Tejun Heoa288eec2011-06-17 16:50:37 +0200796 ptrace_event(PTRACE_EVENT_EXIT, code);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797
David Howellse0e81732009-09-02 09:13:40 +0100798 validate_creds_for_do_exit(tsk);
799
Alexander Nybergdf164db2005-06-23 00:09:13 -0700800 /*
801 * We're taking recursive faults here in do_exit. Safest is to just
802 * leave this task alone and wait for reboot.
803 */
804 if (unlikely(tsk->flags & PF_EXITING)) {
Ionut Alexaa0be55d2014-08-08 14:21:18 -0700805 pr_alert("Fixing recursive fault but reboot is needed!\n");
Alexey Kuznetsov778e9a92007-06-08 13:47:00 -0700806 /*
807 * We can do this unlocked here. The futex code uses
808 * this flag just to verify whether the pi state
809 * cleanup has been done or not. In the worst case it
810 * loops once more. We pretend that the cleanup was
811 * done as there is no way to return. Either the
812 * OWNER_DIED bit is set by now or we push the blocked
813 * task into the wait for ever nirwana as well.
814 */
815 tsk->flags |= PF_EXITPIDONE;
Alexander Nybergdf164db2005-06-23 00:09:13 -0700816 set_current_state(TASK_UNINTERRUPTIBLE);
817 schedule();
818 }
819
Oleg Nesterovd12619b2008-02-08 04:19:12 -0800820 exit_signals(tsk); /* sets PF_EXITING */
Alexey Kuznetsov778e9a92007-06-08 13:47:00 -0700821 /*
Peter Zijlstrabe3e7842016-05-24 14:45:21 +0200822 * Ensure that all new tsk->pi_lock acquisitions must observe
823 * PF_EXITING. Serializes against futex.c:attach_to_pi_owner().
Alexey Kuznetsov778e9a92007-06-08 13:47:00 -0700824 */
Oleg Nesterovd2ee7192007-10-16 23:26:47 -0700825 smp_mb();
Peter Zijlstrabe3e7842016-05-24 14:45:21 +0200826 /*
827 * Ensure that we must observe the pi_state in exit_mm() ->
828 * mm_release() -> exit_pi_state_list().
829 */
Thomas Gleixner1d615482009-11-17 14:54:03 +0100830 raw_spin_unlock_wait(&tsk->pi_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831
Peter Zijlstra1dc0fff2015-09-28 17:57:39 +0200832 if (unlikely(in_atomic())) {
Ionut Alexaa0be55d2014-08-08 14:21:18 -0700833 pr_info("note: %s[%d] exited with preempt_count %d\n",
834 current->comm, task_pid_nr(current),
835 preempt_count());
Peter Zijlstra1dc0fff2015-09-28 17:57:39 +0200836 preempt_count_set(PREEMPT_ENABLED);
837 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838
Linus Torvalds48d212a2012-06-07 17:54:07 -0700839 /* sync mm's RSS info before statistics gathering */
840 if (tsk->mm)
841 sync_mm_rss(tsk->mm);
Rik van Riel51229b42015-06-25 15:03:56 -0700842 acct_update_integrals(tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 group_dead = atomic_dec_and_test(&tsk->signal->live);
Andrew Mortonc3068952005-08-04 16:49:32 -0700844 if (group_dead) {
Nicolas Pitrebaa73d92016-11-11 00:10:10 -0500845#ifdef CONFIG_POSIX_TIMERS
Alexey Kuznetsov778e9a92007-06-08 13:47:00 -0700846 hrtimer_cancel(&tsk->signal->real_timer);
Roland McGrath25f407f2005-10-21 15:03:29 -0700847 exit_itimers(tsk->signal);
Nicolas Pitrebaa73d92016-11-11 00:10:10 -0500848#endif
Jiri Pirko1f102062009-09-22 16:44:10 -0700849 if (tsk->mm)
850 setmax_mm_hiwater_rss(&tsk->signal->maxrss, tsk->mm);
Andrew Mortonc3068952005-08-04 16:49:32 -0700851 }
KaiGai Koheif6ec29a2006-06-25 05:49:25 -0700852 acct_collect(code, group_dead);
Miloslav Trmac522ed772007-07-15 23:40:56 -0700853 if (group_dead)
854 tty_audit_exit();
Eric Parisa4ff8db2012-01-03 14:23:07 -0500855 audit_free(tsk);
Oleg Nesterov115085e2006-12-06 20:36:51 -0800856
Linus Torvalds48d212a2012-06-07 17:54:07 -0700857 tsk->exit_code = code;
Oleg Nesterov115085e2006-12-06 20:36:51 -0800858 taskstats_exit(tsk, group_dead);
Shailabh Nagarc7572492006-07-14 00:24:40 -0700859
Davidlohr Bueso00399622017-01-03 13:43:11 -0800860 exit_mm();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861
KaiGai Kohei0e464812006-06-25 05:49:24 -0700862 if (group_dead)
KaiGai Koheif6ec29a2006-06-25 05:49:25 -0700863 acct_process();
Mathieu Desnoyers0a16b602008-07-18 12:16:17 -0400864 trace_sched_process_exit(tsk);
865
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 exit_sem(tsk);
Vasiliy Kulikovb34a6b12011-07-26 16:08:48 -0700867 exit_shm(tsk);
Al Viro1ec7f1d2008-04-22 05:35:42 -0400868 exit_files(tsk);
869 exit_fs(tsk);
Oleg Nesterovc39df5f2014-04-07 15:38:29 -0700870 if (group_dead)
871 disassociate_ctty(1);
Oleg Nesterov8aac6272013-06-14 21:09:49 +0200872 exit_task_namespaces(tsk);
Al Viroed3e6942012-06-27 11:31:24 +0400873 exit_task_work(tsk);
Jiri Slabye6464692016-05-20 17:00:20 -0700874 exit_thread(tsk);
Stephane Eranian0b3fcf12011-01-03 18:20:01 +0200875
876 /*
877 * Flush inherited counters to the parent - before the parent
878 * gets woken up by child-exit notifications.
879 *
880 * because of cgroup mode, must be called before cgroup_exit()
881 */
882 perf_event_exit_task(tsk);
883
Oleg Nesterov8e5bfa82016-11-14 19:46:12 +0100884 sched_autogroup_exit_task(tsk);
Li Zefan1ec41832014-03-28 15:22:19 +0800885 cgroup_exit(tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886
Ingo Molnar33b2fb32009-05-17 11:08:41 +0200887 /*
Frederic Weisbecker24f1e32c2009-09-09 19:22:48 +0200888 * FIXME: do that only when needed, using sched_exit tracepoint
889 */
Oleg Nesterov7c8df282013-07-08 16:00:54 -0700890 flush_ptrace_hw_breakpoint(tsk);
Ingo Molnar33b2fb32009-05-17 11:08:41 +0200891
Paul E. McKenney49f59032015-09-01 00:42:57 -0700892 TASKS_RCU(preempt_disable());
Paul E. McKenney3f95aa82014-08-04 06:10:23 -0700893 TASKS_RCU(tasks_rcu_i = __srcu_read_lock(&tasks_rcu_exit_srcu));
Paul E. McKenney49f59032015-09-01 00:42:57 -0700894 TASKS_RCU(preempt_enable());
Oleg Nesterov821c7de2008-03-02 21:44:44 +0300895 exit_notify(tsk, group_dead);
Guillaume Morinef982392014-04-07 15:38:31 -0700896 proc_exit_connector(tsk);
David Rientjesc11600e2016-09-01 16:15:07 -0700897 mpol_put_task_policy(tsk);
Alexey Dobriyan42b2dd02007-10-16 23:27:30 -0700898#ifdef CONFIG_FUTEX
Ingo Molnarc87e2832006-06-27 02:54:58 -0700899 if (unlikely(current->pi_state_cache))
900 kfree(current->pi_state_cache);
Alexey Dobriyan42b2dd02007-10-16 23:27:30 -0700901#endif
Ingo Molnarc87e2832006-06-27 02:54:58 -0700902 /*
Ingo Molnar9a11b49a2006-07-03 00:24:33 -0700903 * Make sure we are holding no locks:
Ingo Molnarde5097c2006-01-09 15:59:21 -0800904 */
Colin Cross1b1d2fb2013-05-06 23:50:08 +0000905 debug_check_no_locks_held();
Alexey Kuznetsov778e9a92007-06-08 13:47:00 -0700906 /*
907 * We can do this unlocked here. The futex code uses this flag
908 * just to verify whether the pi state cleanup has been done
909 * or not. In the worst case it loops once more.
910 */
911 tsk->flags |= PF_EXITPIDONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912
Al Viroafc847b2006-02-28 12:51:55 -0500913 if (tsk->io_context)
Louis Rillingb69f2292009-12-04 14:52:42 +0100914 exit_io_context(tsk);
Al Viroafc847b2006-02-28 12:51:55 -0500915
Jens Axboeb92ce552006-04-11 13:52:07 +0200916 if (tsk->splice_pipe)
Al Viro4b8a8f12013-03-21 11:06:46 -0400917 free_pipe_info(tsk->splice_pipe);
Jens Axboeb92ce552006-04-11 13:52:07 +0200918
Eric Dumazet5640f762012-09-23 23:04:42 +0000919 if (tsk->task_frag.page)
920 put_page(tsk->task_frag.page);
921
David Howellse0e81732009-09-02 09:13:40 +0100922 validate_creds_for_do_exit(tsk);
923
Oleg Nesterov4bcb8232014-04-07 15:38:30 -0700924 check_stack_usage();
Coywolf Qi Hunt74072512005-10-30 15:02:47 -0800925 preempt_disable();
Wu Fengguang54848d72011-04-05 13:21:19 -0600926 if (tsk->nr_dirtied)
927 __this_cpu_add(dirty_throttle_leaks, tsk->nr_dirtied);
Paul E. McKenneyf41d9112009-08-22 13:56:52 -0700928 exit_rcu();
Paul E. McKenney3f95aa82014-08-04 06:10:23 -0700929 TASKS_RCU(__srcu_read_unlock(&tasks_rcu_exit_srcu, tasks_rcu_i));
Yasunori Gotob5740f42012-01-17 17:40:31 +0900930
Peter Zijlstra9af65282016-09-13 18:37:29 +0200931 do_task_dead();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932}
Russ Anderson012914d2005-04-23 00:08:00 -0700933EXPORT_SYMBOL_GPL(do_exit);
934
Joe Perches9402c952012-01-12 17:17:17 -0800935void complete_and_exit(struct completion *comp, long code)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936{
937 if (comp)
938 complete(comp);
Oleg Nesterov55a101f2006-09-29 02:01:10 -0700939
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 do_exit(code);
941}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942EXPORT_SYMBOL(complete_and_exit);
943
Heiko Carstens754fe8d2009-01-14 14:14:09 +0100944SYSCALL_DEFINE1(exit, int, error_code)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945{
946 do_exit((error_code&0xff)<<8);
947}
948
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949/*
950 * Take down every thread in the group. This is called by fatal signals
951 * as well as by sys_exit_group (below).
952 */
Joe Perches9402c952012-01-12 17:17:17 -0800953void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954do_group_exit(int exit_code)
955{
Oleg Nesterovbfc4b082008-04-30 00:52:36 -0700956 struct signal_struct *sig = current->signal;
957
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 BUG_ON(exit_code & 0x80); /* core dumps don't get here */
959
Oleg Nesterovbfc4b082008-04-30 00:52:36 -0700960 if (signal_group_exit(sig))
961 exit_code = sig->group_exit_code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 else if (!thread_group_empty(current)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 struct sighand_struct *const sighand = current->sighand;
Ionut Alexaa0be55d2014-08-08 14:21:18 -0700964
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 spin_lock_irq(&sighand->siglock);
Oleg Nesteroved5d2ca2008-02-04 22:27:24 -0800966 if (signal_group_exit(sig))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 /* Another thread got here before we took the lock. */
968 exit_code = sig->group_exit_code;
969 else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 sig->group_exit_code = exit_code;
Oleg Nesteroved5d2ca2008-02-04 22:27:24 -0800971 sig->flags = SIGNAL_GROUP_EXIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 zap_other_threads(current);
973 }
974 spin_unlock_irq(&sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 }
976
977 do_exit(exit_code);
978 /* NOTREACHED */
979}
980
981/*
982 * this kills every thread in the thread group. Note that any externally
983 * wait4()-ing process will get the correct exit code - even if this
984 * thread is not the thread group leader.
985 */
Heiko Carstens754fe8d2009-01-14 14:14:09 +0100986SYSCALL_DEFINE1(exit_group, int, error_code)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987{
988 do_group_exit((error_code & 0xff) << 8);
Heiko Carstens2ed7c032009-01-14 14:13:54 +0100989 /* NOTREACHED */
990 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991}
992
Oleg Nesterov9e8ae012009-06-17 16:27:39 -0700993struct wait_opts {
994 enum pid_type wo_type;
Oleg Nesterov9e8ae012009-06-17 16:27:39 -0700995 int wo_flags;
Richard Kennedye1eb1eb2009-06-17 16:27:42 -0700996 struct pid *wo_pid;
Oleg Nesterov9e8ae012009-06-17 16:27:39 -0700997
998 struct siginfo __user *wo_info;
999 int __user *wo_stat;
1000 struct rusage __user *wo_rusage;
1001
Oleg Nesterov0b7570e2009-09-23 15:56:46 -07001002 wait_queue_t child_wait;
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001003 int notask_error;
1004};
1005
Oleg Nesterov989264f2009-09-23 15:56:49 -07001006static inline
1007struct pid *task_pid_type(struct task_struct *task, enum pid_type type)
Eric W. Biederman161550d2008-02-08 04:19:14 -08001008{
Oleg Nesterov989264f2009-09-23 15:56:49 -07001009 if (type != PIDTYPE_PID)
1010 task = task->group_leader;
1011 return task->pids[type].pid;
Eric W. Biederman161550d2008-02-08 04:19:14 -08001012}
1013
Oleg Nesterov989264f2009-09-23 15:56:49 -07001014static int eligible_pid(struct wait_opts *wo, struct task_struct *p)
Oleg Nesterov5c01ba42009-09-23 15:56:48 -07001015{
1016 return wo->wo_type == PIDTYPE_MAX ||
1017 task_pid_type(p, wo->wo_type) == wo->wo_pid;
1018}
1019
Oleg Nesterovbf959932016-05-23 16:23:50 -07001020static int
1021eligible_child(struct wait_opts *wo, bool ptrace, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022{
Oleg Nesterov5c01ba42009-09-23 15:56:48 -07001023 if (!eligible_pid(wo, p))
1024 return 0;
Oleg Nesterovbf959932016-05-23 16:23:50 -07001025
1026 /*
1027 * Wait for all children (clone and not) if __WALL is set or
1028 * if it is traced by us.
1029 */
1030 if (ptrace || (wo->wo_flags & __WALL))
1031 return 1;
1032
1033 /*
1034 * Otherwise, wait for clone children *only* if __WCLONE is set;
1035 * otherwise, wait for non-clone children *only*.
1036 *
1037 * Note: a "clone" child here is one that reports to its parent
1038 * using a signal other than SIGCHLD, or a non-leader thread which
1039 * we can only see if it is traced by us.
1040 */
1041 if ((p->exit_signal != SIGCHLD) ^ !!(wo->wo_flags & __WCLONE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043
Roland McGrath14dd0b82008-03-30 18:41:25 -07001044 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045}
1046
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001047static int wait_noreap_copyout(struct wait_opts *wo, struct task_struct *p,
1048 pid_t pid, uid_t uid, int why, int status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049{
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001050 struct siginfo __user *infop;
1051 int retval = wo->wo_rusage
1052 ? getrusage(p, RUSAGE_BOTH, wo->wo_rusage) : 0;
Ingo Molnar36c8b582006-07-03 00:25:41 -07001053
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 put_task_struct(p);
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001055 infop = wo->wo_info;
Vitaly Mayatskikhb6fe2d12009-09-23 15:56:52 -07001056 if (infop) {
1057 if (!retval)
1058 retval = put_user(SIGCHLD, &infop->si_signo);
1059 if (!retval)
1060 retval = put_user(0, &infop->si_errno);
1061 if (!retval)
1062 retval = put_user((short)why, &infop->si_code);
1063 if (!retval)
1064 retval = put_user(pid, &infop->si_pid);
1065 if (!retval)
1066 retval = put_user(uid, &infop->si_uid);
1067 if (!retval)
1068 retval = put_user(status, &infop->si_status);
1069 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 if (!retval)
1071 retval = pid;
1072 return retval;
1073}
1074
1075/*
1076 * Handle sys_wait4 work for one task in state EXIT_ZOMBIE. We hold
1077 * read_lock(&tasklist_lock) on entry. If we return zero, we still hold
1078 * the lock and this task is uninteresting. If we return nonzero, we have
1079 * released the lock and the system call should return.
1080 */
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001081static int wait_task_zombie(struct wait_opts *wo, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082{
Oleg Nesterovf6507f82014-12-10 15:54:45 -08001083 int state, retval, status;
Pavel Emelyanov6c5f3e72008-02-08 04:19:20 -08001084 pid_t pid = task_pid_vnr(p);
Oleg Nesterov43e13cc2012-05-31 16:26:16 -07001085 uid_t uid = from_kuid_munged(current_user_ns(), task_uid(p));
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001086 struct siginfo __user *infop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001088 if (!likely(wo->wo_flags & WEXITED))
Roland McGrath98abed02008-03-19 19:24:59 -07001089 return 0;
1090
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001091 if (unlikely(wo->wo_flags & WNOWAIT)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 int exit_code = p->exit_code;
Thiago Farinaf3abd4f2010-03-05 13:42:52 -08001093 int why;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 get_task_struct(p);
1096 read_unlock(&tasklist_lock);
Peter Zijlstra1029a2b2014-09-24 10:18:49 +02001097 sched_annotate_sleep();
1098
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099 if ((exit_code & 0x7f) == 0) {
1100 why = CLD_EXITED;
1101 status = exit_code >> 8;
1102 } else {
1103 why = (exit_code & 0x80) ? CLD_DUMPED : CLD_KILLED;
1104 status = exit_code & 0x7f;
1105 }
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001106 return wait_noreap_copyout(wo, p, pid, uid, why, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 }
Oleg Nesterovbefca962009-06-18 16:49:11 -07001108 /*
Oleg Nesterovabd50b32014-04-07 15:38:42 -07001109 * Move the task's state to DEAD/TRACE, only one thread can do this.
1110 */
Oleg Nesterovf6507f82014-12-10 15:54:45 -08001111 state = (ptrace_reparented(p) && thread_group_leader(p)) ?
1112 EXIT_TRACE : EXIT_DEAD;
Oleg Nesterovabd50b32014-04-07 15:38:42 -07001113 if (cmpxchg(&p->exit_state, EXIT_ZOMBIE, state) != EXIT_ZOMBIE)
1114 return 0;
Oleg Nesterov986094d2014-12-10 15:54:51 -08001115 /*
1116 * We own this thread, nobody else can reap it.
1117 */
1118 read_unlock(&tasklist_lock);
1119 sched_annotate_sleep();
Oleg Nesterovf6507f82014-12-10 15:54:45 -08001120
Oleg Nesterovabd50b32014-04-07 15:38:42 -07001121 /*
Oleg Nesterovf6507f82014-12-10 15:54:45 -08001122 * Check thread_group_leader() to exclude the traced sub-threads.
Oleg Nesterovbefca962009-06-18 16:49:11 -07001123 */
Oleg Nesterovf6507f82014-12-10 15:54:45 -08001124 if (state == EXIT_DEAD && thread_group_leader(p)) {
Oleg Nesterovf953ccd2014-12-10 15:54:48 -08001125 struct signal_struct *sig = p->signal;
1126 struct signal_struct *psig = current->signal;
Jiri Pirko1f102062009-09-22 16:44:10 -07001127 unsigned long maxrss;
Frederic Weisbecker5613fda2017-01-31 04:09:23 +01001128 u64 tgutime, tgstime;
Jesper Juhl3795e162006-01-09 20:54:39 -08001129
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 /*
1131 * The resource counters for the group leader are in its
1132 * own task_struct. Those for dead threads in the group
1133 * are in its signal_struct, as are those for the child
1134 * processes it has previously reaped. All these
1135 * accumulate in the parent's signal_struct c* fields.
1136 *
1137 * We don't bother to take a lock here to protect these
Oleg Nesterovf953ccd2014-12-10 15:54:48 -08001138 * p->signal fields because the whole thread group is dead
1139 * and nobody can change them.
1140 *
1141 * psig->stats_lock also protects us from our sub-theads
1142 * which can reap other children at the same time. Until
1143 * we change k_getrusage()-like users to rely on this lock
1144 * we have to take ->siglock as well.
Hidetoshi Seto0cf55e12009-12-02 17:28:07 +09001145 *
Ionut Alexaa0be55d2014-08-08 14:21:18 -07001146 * We use thread_group_cputime_adjusted() to get times for
1147 * the thread group, which consolidates times for all threads
1148 * in the group including the group leader.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 */
Frederic Weisbeckere80d0a1a2012-11-21 16:26:44 +01001150 thread_group_cputime_adjusted(p, &tgutime, &tgstime);
Oleg Nesterovf953ccd2014-12-10 15:54:48 -08001151 spin_lock_irq(&current->sighand->siglock);
Rik van Riele78c3492014-08-16 13:40:10 -04001152 write_seqlock(&psig->stats_lock);
Martin Schwidefsky64861632011-12-15 14:56:09 +01001153 psig->cutime += tgutime + sig->cutime;
1154 psig->cstime += tgstime + sig->cstime;
Frederic Weisbecker6fac4822012-11-13 14:20:55 +01001155 psig->cgtime += task_gtime(p) + sig->gtime + sig->cgtime;
Jesper Juhl3795e162006-01-09 20:54:39 -08001156 psig->cmin_flt +=
1157 p->min_flt + sig->min_flt + sig->cmin_flt;
1158 psig->cmaj_flt +=
1159 p->maj_flt + sig->maj_flt + sig->cmaj_flt;
1160 psig->cnvcsw +=
1161 p->nvcsw + sig->nvcsw + sig->cnvcsw;
1162 psig->cnivcsw +=
1163 p->nivcsw + sig->nivcsw + sig->cnivcsw;
Eric Dumazet6eaeeab2007-05-10 22:22:37 -07001164 psig->cinblock +=
1165 task_io_get_inblock(p) +
1166 sig->inblock + sig->cinblock;
1167 psig->coublock +=
1168 task_io_get_oublock(p) +
1169 sig->oublock + sig->coublock;
Jiri Pirko1f102062009-09-22 16:44:10 -07001170 maxrss = max(sig->maxrss, sig->cmaxrss);
1171 if (psig->cmaxrss < maxrss)
1172 psig->cmaxrss = maxrss;
Andrea Righi59954772008-07-27 17:29:15 +02001173 task_io_accounting_add(&psig->ioac, &p->ioac);
1174 task_io_accounting_add(&psig->ioac, &sig->ioac);
Rik van Riele78c3492014-08-16 13:40:10 -04001175 write_sequnlock(&psig->stats_lock);
Oleg Nesterovf953ccd2014-12-10 15:54:48 -08001176 spin_unlock_irq(&current->sighand->siglock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 }
1178
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001179 retval = wo->wo_rusage
1180 ? getrusage(p, RUSAGE_BOTH, wo->wo_rusage) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 status = (p->signal->flags & SIGNAL_GROUP_EXIT)
1182 ? p->signal->group_exit_code : p->exit_code;
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001183 if (!retval && wo->wo_stat)
1184 retval = put_user(status, wo->wo_stat);
1185
1186 infop = wo->wo_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 if (!retval && infop)
1188 retval = put_user(SIGCHLD, &infop->si_signo);
1189 if (!retval && infop)
1190 retval = put_user(0, &infop->si_errno);
1191 if (!retval && infop) {
1192 int why;
1193
1194 if ((status & 0x7f) == 0) {
1195 why = CLD_EXITED;
1196 status >>= 8;
1197 } else {
1198 why = (status & 0x80) ? CLD_DUMPED : CLD_KILLED;
1199 status &= 0x7f;
1200 }
1201 retval = put_user((short)why, &infop->si_code);
1202 if (!retval)
1203 retval = put_user(status, &infop->si_status);
1204 }
1205 if (!retval && infop)
Oleg Nesterov3a515e42008-02-08 04:19:07 -08001206 retval = put_user(pid, &infop->si_pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 if (!retval && infop)
David Howellsc69e8d92008-11-14 10:39:19 +11001208 retval = put_user(uid, &infop->si_uid);
Oleg Nesterov2f4e6e22007-10-16 23:26:58 -07001209 if (!retval)
Oleg Nesterov3a515e42008-02-08 04:19:07 -08001210 retval = pid;
Oleg Nesterov2f4e6e22007-10-16 23:26:58 -07001211
Oleg Nesterovb4360692014-04-07 15:38:43 -07001212 if (state == EXIT_TRACE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 write_lock_irq(&tasklist_lock);
Oleg Nesterov2f4e6e22007-10-16 23:26:58 -07001214 /* We dropped tasklist, ptracer could die and untrace */
1215 ptrace_unlink(p);
Oleg Nesterovb4360692014-04-07 15:38:43 -07001216
1217 /* If parent wants a zombie, don't release it now */
1218 state = EXIT_ZOMBIE;
1219 if (do_notify_parent(p, p->exit_signal))
1220 state = EXIT_DEAD;
Oleg Nesterovabd50b32014-04-07 15:38:42 -07001221 p->exit_state = state;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 write_unlock_irq(&tasklist_lock);
1223 }
Oleg Nesterovabd50b32014-04-07 15:38:42 -07001224 if (state == EXIT_DEAD)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 release_task(p);
Oleg Nesterov2f4e6e22007-10-16 23:26:58 -07001226
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 return retval;
1228}
1229
Oleg Nesterov90bc8d82009-04-02 16:57:58 -07001230static int *task_stopped_code(struct task_struct *p, bool ptrace)
1231{
1232 if (ptrace) {
Oleg Nesterov570ac932016-01-20 14:59:58 -08001233 if (task_is_traced(p) && !(p->jobctl & JOBCTL_LISTENING))
Oleg Nesterov90bc8d82009-04-02 16:57:58 -07001234 return &p->exit_code;
1235 } else {
1236 if (p->signal->flags & SIGNAL_STOP_STOPPED)
1237 return &p->signal->group_exit_code;
1238 }
1239 return NULL;
1240}
1241
Tejun Heo19e27462011-05-12 10:47:23 +02001242/**
1243 * wait_task_stopped - Wait for %TASK_STOPPED or %TASK_TRACED
1244 * @wo: wait options
1245 * @ptrace: is the wait for ptrace
1246 * @p: task to wait for
1247 *
1248 * Handle sys_wait4() work for %p in state %TASK_STOPPED or %TASK_TRACED.
1249 *
1250 * CONTEXT:
1251 * read_lock(&tasklist_lock), which is released if return value is
1252 * non-zero. Also, grabs and releases @p->sighand->siglock.
1253 *
1254 * RETURNS:
1255 * 0 if wait condition didn't exist and search for other wait conditions
1256 * should continue. Non-zero return, -errno on failure and @p's pid on
1257 * success, implies that tasklist_lock is released and wait condition
1258 * search should terminate.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 */
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001260static int wait_task_stopped(struct wait_opts *wo,
1261 int ptrace, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262{
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001263 struct siginfo __user *infop;
Oleg Nesterov90bc8d82009-04-02 16:57:58 -07001264 int retval, exit_code, *p_code, why;
Oleg Nesterovee7c82d2008-02-08 04:19:01 -08001265 uid_t uid = 0; /* unneeded, required by compiler */
Oleg Nesterovc8950782007-11-28 16:21:24 -08001266 pid_t pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267
Oleg Nesterov47918022009-06-17 16:27:39 -07001268 /*
1269 * Traditionally we see ptrace'd stopped tasks regardless of options.
1270 */
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001271 if (!ptrace && !(wo->wo_flags & WUNTRACED))
Roland McGrath98abed02008-03-19 19:24:59 -07001272 return 0;
1273
Tejun Heo19e27462011-05-12 10:47:23 +02001274 if (!task_stopped_code(p, ptrace))
1275 return 0;
1276
Oleg Nesterovee7c82d2008-02-08 04:19:01 -08001277 exit_code = 0;
1278 spin_lock_irq(&p->sighand->siglock);
1279
Oleg Nesterov90bc8d82009-04-02 16:57:58 -07001280 p_code = task_stopped_code(p, ptrace);
1281 if (unlikely(!p_code))
Oleg Nesterovee7c82d2008-02-08 04:19:01 -08001282 goto unlock_sig;
1283
Oleg Nesterov90bc8d82009-04-02 16:57:58 -07001284 exit_code = *p_code;
Oleg Nesterovee7c82d2008-02-08 04:19:01 -08001285 if (!exit_code)
1286 goto unlock_sig;
1287
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001288 if (!unlikely(wo->wo_flags & WNOWAIT))
Oleg Nesterov90bc8d82009-04-02 16:57:58 -07001289 *p_code = 0;
Oleg Nesterovee7c82d2008-02-08 04:19:01 -08001290
Sasha Levin8ca937a2012-05-17 23:31:39 +02001291 uid = from_kuid_munged(current_user_ns(), task_uid(p));
Oleg Nesterovee7c82d2008-02-08 04:19:01 -08001292unlock_sig:
1293 spin_unlock_irq(&p->sighand->siglock);
1294 if (!exit_code)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 return 0;
1296
1297 /*
1298 * Now we are pretty sure this task is interesting.
1299 * Make sure it doesn't get reaped out from under us while we
1300 * give up the lock and then examine it below. We don't want to
1301 * keep holding onto the tasklist_lock while we call getrusage and
1302 * possibly take page faults for user memory.
1303 */
1304 get_task_struct(p);
Pavel Emelyanov6c5f3e72008-02-08 04:19:20 -08001305 pid = task_pid_vnr(p);
Roland McGrathf4700212008-03-24 18:36:23 -07001306 why = ptrace ? CLD_TRAPPED : CLD_STOPPED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 read_unlock(&tasklist_lock);
Peter Zijlstra1029a2b2014-09-24 10:18:49 +02001308 sched_annotate_sleep();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001310 if (unlikely(wo->wo_flags & WNOWAIT))
1311 return wait_noreap_copyout(wo, p, pid, uid, why, exit_code);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001313 retval = wo->wo_rusage
1314 ? getrusage(p, RUSAGE_BOTH, wo->wo_rusage) : 0;
1315 if (!retval && wo->wo_stat)
1316 retval = put_user((exit_code << 8) | 0x7f, wo->wo_stat);
1317
1318 infop = wo->wo_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 if (!retval && infop)
1320 retval = put_user(SIGCHLD, &infop->si_signo);
1321 if (!retval && infop)
1322 retval = put_user(0, &infop->si_errno);
1323 if (!retval && infop)
Roland McGrath6efcae462008-03-08 11:41:22 -08001324 retval = put_user((short)why, &infop->si_code);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 if (!retval && infop)
1326 retval = put_user(exit_code, &infop->si_status);
1327 if (!retval && infop)
Oleg Nesterovc8950782007-11-28 16:21:24 -08001328 retval = put_user(pid, &infop->si_pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 if (!retval && infop)
Oleg Nesterovee7c82d2008-02-08 04:19:01 -08001330 retval = put_user(uid, &infop->si_uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 if (!retval)
Oleg Nesterovc8950782007-11-28 16:21:24 -08001332 retval = pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 put_task_struct(p);
1334
1335 BUG_ON(!retval);
1336 return retval;
1337}
1338
1339/*
1340 * Handle do_wait work for one task in a live, non-stopped state.
1341 * read_lock(&tasklist_lock) on entry. If we return zero, we still hold
1342 * the lock and this task is uninteresting. If we return nonzero, we have
1343 * released the lock and the system call should return.
1344 */
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001345static int wait_task_continued(struct wait_opts *wo, struct task_struct *p)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346{
1347 int retval;
1348 pid_t pid;
1349 uid_t uid;
1350
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001351 if (!unlikely(wo->wo_flags & WCONTINUED))
Roland McGrath98abed02008-03-19 19:24:59 -07001352 return 0;
1353
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 if (!(p->signal->flags & SIGNAL_STOP_CONTINUED))
1355 return 0;
1356
1357 spin_lock_irq(&p->sighand->siglock);
1358 /* Re-check with the lock held. */
1359 if (!(p->signal->flags & SIGNAL_STOP_CONTINUED)) {
1360 spin_unlock_irq(&p->sighand->siglock);
1361 return 0;
1362 }
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001363 if (!unlikely(wo->wo_flags & WNOWAIT))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 p->signal->flags &= ~SIGNAL_STOP_CONTINUED;
Sasha Levin8ca937a2012-05-17 23:31:39 +02001365 uid = from_kuid_munged(current_user_ns(), task_uid(p));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366 spin_unlock_irq(&p->sighand->siglock);
1367
Pavel Emelyanov6c5f3e72008-02-08 04:19:20 -08001368 pid = task_pid_vnr(p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 get_task_struct(p);
1370 read_unlock(&tasklist_lock);
Peter Zijlstra1029a2b2014-09-24 10:18:49 +02001371 sched_annotate_sleep();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001373 if (!wo->wo_info) {
1374 retval = wo->wo_rusage
1375 ? getrusage(p, RUSAGE_BOTH, wo->wo_rusage) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 put_task_struct(p);
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001377 if (!retval && wo->wo_stat)
1378 retval = put_user(0xffff, wo->wo_stat);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 if (!retval)
Oleg Nesterov3a515e42008-02-08 04:19:07 -08001380 retval = pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 } else {
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001382 retval = wait_noreap_copyout(wo, p, pid, uid,
1383 CLD_CONTINUED, SIGCONT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 BUG_ON(retval == 0);
1385 }
1386
1387 return retval;
1388}
1389
Roland McGrath98abed02008-03-19 19:24:59 -07001390/*
1391 * Consider @p for a wait by @parent.
1392 *
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001393 * -ECHILD should be in ->notask_error before the first call.
Roland McGrath98abed02008-03-19 19:24:59 -07001394 * Returns nonzero for a final return, when we have unlocked tasklist_lock.
1395 * Returns zero if the search for a child should continue;
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001396 * then ->notask_error is 0 if @p is an eligible child,
Stephen Smalley3a2f5a52017-01-10 12:28:32 -05001397 * or still -ECHILD.
Roland McGrath98abed02008-03-19 19:24:59 -07001398 */
Oleg Nesterovb6e763f2009-09-23 15:56:50 -07001399static int wait_consider_task(struct wait_opts *wo, int ptrace,
1400 struct task_struct *p)
Roland McGrath98abed02008-03-19 19:24:59 -07001401{
Oleg Nesterov3245d6a2015-01-08 14:32:12 -08001402 /*
1403 * We can race with wait_task_zombie() from another thread.
1404 * Ensure that EXIT_ZOMBIE -> EXIT_DEAD/EXIT_TRACE transition
1405 * can't confuse the checks below.
1406 */
1407 int exit_state = ACCESS_ONCE(p->exit_state);
Oleg Nesterovb3ab0312014-04-07 15:38:45 -07001408 int ret;
1409
Oleg Nesterov3245d6a2015-01-08 14:32:12 -08001410 if (unlikely(exit_state == EXIT_DEAD))
Oleg Nesterovb3ab0312014-04-07 15:38:45 -07001411 return 0;
1412
Oleg Nesterovbf959932016-05-23 16:23:50 -07001413 ret = eligible_child(wo, ptrace, p);
Roland McGrath14dd0b82008-03-30 18:41:25 -07001414 if (!ret)
Roland McGrath98abed02008-03-19 19:24:59 -07001415 return ret;
1416
Oleg Nesterov3245d6a2015-01-08 14:32:12 -08001417 if (unlikely(exit_state == EXIT_TRACE)) {
Oleg Nesterov50b8d252012-01-04 17:29:02 +01001418 /*
Oleg Nesterovabd50b32014-04-07 15:38:42 -07001419 * ptrace == 0 means we are the natural parent. In this case
1420 * we should clear notask_error, debugger will notify us.
Oleg Nesterov50b8d252012-01-04 17:29:02 +01001421 */
Oleg Nesterovabd50b32014-04-07 15:38:42 -07001422 if (likely(!ptrace))
Oleg Nesterov50b8d252012-01-04 17:29:02 +01001423 wo->notask_error = 0;
Roland McGrath98abed02008-03-19 19:24:59 -07001424 return 0;
Oleg Nesterov50b8d252012-01-04 17:29:02 +01001425 }
Roland McGrath98abed02008-03-19 19:24:59 -07001426
Oleg Nesterov377d75d2014-04-07 15:38:47 -07001427 if (likely(!ptrace) && unlikely(p->ptrace)) {
1428 /*
1429 * If it is traced by its real parent's group, just pretend
1430 * the caller is ptrace_do_wait() and reap this child if it
1431 * is zombie.
1432 *
1433 * This also hides group stop state from real parent; otherwise
1434 * a single stop can be reported twice as group and ptrace stop.
1435 * If a ptracer wants to distinguish these two events for its
1436 * own children it should create a separate process which takes
1437 * the role of real parent.
1438 */
1439 if (!ptrace_reparented(p))
1440 ptrace = 1;
1441 }
1442
Tejun Heo9b84cca2011-03-23 10:37:01 +01001443 /* slay zombie? */
Oleg Nesterov3245d6a2015-01-08 14:32:12 -08001444 if (exit_state == EXIT_ZOMBIE) {
Tejun Heo9b84cca2011-03-23 10:37:01 +01001445 /* we don't reap group leaders with subthreads */
Oleg Nesterov7c733eb2014-04-07 15:38:49 -07001446 if (!delay_group_leader(p)) {
1447 /*
1448 * A zombie ptracee is only visible to its ptracer.
1449 * Notification and reaping will be cascaded to the
1450 * real parent when the ptracer detaches.
1451 */
1452 if (unlikely(ptrace) || likely(!p->ptrace))
1453 return wait_task_zombie(wo, p);
1454 }
Roland McGrath98abed02008-03-19 19:24:59 -07001455
Tejun Heo9b84cca2011-03-23 10:37:01 +01001456 /*
1457 * Allow access to stopped/continued state via zombie by
1458 * falling through. Clearing of notask_error is complex.
1459 *
1460 * When !@ptrace:
1461 *
1462 * If WEXITED is set, notask_error should naturally be
1463 * cleared. If not, subset of WSTOPPED|WCONTINUED is set,
1464 * so, if there are live subthreads, there are events to
1465 * wait for. If all subthreads are dead, it's still safe
1466 * to clear - this function will be called again in finite
1467 * amount time once all the subthreads are released and
1468 * will then return without clearing.
1469 *
1470 * When @ptrace:
1471 *
1472 * Stopped state is per-task and thus can't change once the
1473 * target task dies. Only continued and exited can happen.
1474 * Clear notask_error if WCONTINUED | WEXITED.
1475 */
1476 if (likely(!ptrace) || (wo->wo_flags & (WCONTINUED | WEXITED)))
1477 wo->notask_error = 0;
1478 } else {
1479 /*
1480 * @p is alive and it's gonna stop, continue or exit, so
1481 * there always is something to wait for.
1482 */
1483 wo->notask_error = 0;
1484 }
Roland McGrath98abed02008-03-19 19:24:59 -07001485
1486 /*
Tejun Heo45cb24a2011-03-23 10:37:01 +01001487 * Wait for stopped. Depending on @ptrace, different stopped state
1488 * is used and the two don't interact with each other.
Roland McGrath98abed02008-03-19 19:24:59 -07001489 */
Tejun Heo19e27462011-05-12 10:47:23 +02001490 ret = wait_task_stopped(wo, ptrace, p);
1491 if (ret)
1492 return ret;
Roland McGrath98abed02008-03-19 19:24:59 -07001493
Tejun Heo45cb24a2011-03-23 10:37:01 +01001494 /*
1495 * Wait for continued. There's only one continued state and the
1496 * ptracer can consume it which can confuse the real parent. Don't
1497 * use WCONTINUED from ptracer. You don't need or want it.
1498 */
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001499 return wait_task_continued(wo, p);
Roland McGrath98abed02008-03-19 19:24:59 -07001500}
1501
1502/*
1503 * Do the work of do_wait() for one thread in the group, @tsk.
1504 *
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001505 * -ECHILD should be in ->notask_error before the first call.
Roland McGrath98abed02008-03-19 19:24:59 -07001506 * Returns nonzero for a final return, when we have unlocked tasklist_lock.
1507 * Returns zero if the search for a child should continue; then
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001508 * ->notask_error is 0 if there were any eligible children,
Stephen Smalley3a2f5a52017-01-10 12:28:32 -05001509 * or still -ECHILD.
Roland McGrath98abed02008-03-19 19:24:59 -07001510 */
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001511static int do_wait_thread(struct wait_opts *wo, struct task_struct *tsk)
Roland McGrath98abed02008-03-19 19:24:59 -07001512{
1513 struct task_struct *p;
1514
1515 list_for_each_entry(p, &tsk->children, sibling) {
Oleg Nesterov9cd80bb2009-12-17 15:27:15 -08001516 int ret = wait_consider_task(wo, 0, p);
Ionut Alexaa0be55d2014-08-08 14:21:18 -07001517
Oleg Nesterov9cd80bb2009-12-17 15:27:15 -08001518 if (ret)
1519 return ret;
Roland McGrath98abed02008-03-19 19:24:59 -07001520 }
1521
1522 return 0;
1523}
1524
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001525static int ptrace_do_wait(struct wait_opts *wo, struct task_struct *tsk)
Roland McGrath98abed02008-03-19 19:24:59 -07001526{
1527 struct task_struct *p;
1528
Roland McGrathf4700212008-03-24 18:36:23 -07001529 list_for_each_entry(p, &tsk->ptraced, ptrace_entry) {
Oleg Nesterovb6e763f2009-09-23 15:56:50 -07001530 int ret = wait_consider_task(wo, 1, p);
Ionut Alexaa0be55d2014-08-08 14:21:18 -07001531
Roland McGrathf4700212008-03-24 18:36:23 -07001532 if (ret)
Roland McGrath98abed02008-03-19 19:24:59 -07001533 return ret;
Roland McGrath98abed02008-03-19 19:24:59 -07001534 }
1535
1536 return 0;
1537}
1538
Oleg Nesterov0b7570e2009-09-23 15:56:46 -07001539static int child_wait_callback(wait_queue_t *wait, unsigned mode,
1540 int sync, void *key)
1541{
1542 struct wait_opts *wo = container_of(wait, struct wait_opts,
1543 child_wait);
1544 struct task_struct *p = key;
1545
Oleg Nesterov5c01ba42009-09-23 15:56:48 -07001546 if (!eligible_pid(wo, p))
Oleg Nesterov0b7570e2009-09-23 15:56:46 -07001547 return 0;
1548
Oleg Nesterovb4fe51822009-09-23 15:56:47 -07001549 if ((wo->wo_flags & __WNOTHREAD) && wait->private != p->parent)
1550 return 0;
1551
Oleg Nesterov0b7570e2009-09-23 15:56:46 -07001552 return default_wake_function(wait, mode, sync, key);
1553}
1554
Oleg Nesterova7f07652009-09-23 15:56:44 -07001555void __wake_up_parent(struct task_struct *p, struct task_struct *parent)
1556{
Oleg Nesterov0b7570e2009-09-23 15:56:46 -07001557 __wake_up_sync_key(&parent->signal->wait_chldexit,
1558 TASK_INTERRUPTIBLE, 1, p);
Oleg Nesterova7f07652009-09-23 15:56:44 -07001559}
1560
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001561static long do_wait(struct wait_opts *wo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 struct task_struct *tsk;
Roland McGrath98abed02008-03-19 19:24:59 -07001564 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001566 trace_sched_process_wait(wo->wo_pid);
Mathieu Desnoyers0a16b602008-07-18 12:16:17 -04001567
Oleg Nesterov0b7570e2009-09-23 15:56:46 -07001568 init_waitqueue_func_entry(&wo->child_wait, child_wait_callback);
1569 wo->child_wait.private = current;
1570 add_wait_queue(&current->signal->wait_chldexit, &wo->child_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571repeat:
Roland McGrath98abed02008-03-19 19:24:59 -07001572 /*
Frans Klaver3da56d12015-05-21 22:35:57 +02001573 * If there is nothing that can match our criteria, just get out.
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001574 * We will clear ->notask_error to zero if we see any child that
1575 * might later match our criteria, even if we are not able to reap
1576 * it yet.
Roland McGrath98abed02008-03-19 19:24:59 -07001577 */
Oleg Nesterov64a16ca2009-06-17 16:27:40 -07001578 wo->notask_error = -ECHILD;
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001579 if ((wo->wo_type < PIDTYPE_MAX) &&
1580 (!wo->wo_pid || hlist_empty(&wo->wo_pid->tasks[wo->wo_type])))
Oleg Nesterov64a16ca2009-06-17 16:27:40 -07001581 goto notask;
Eric W. Biederman161550d2008-02-08 04:19:14 -08001582
Oleg Nesterovf95d39d2009-06-17 16:27:42 -07001583 set_current_state(TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 read_lock(&tasklist_lock);
1585 tsk = current;
1586 do {
Oleg Nesterov64a16ca2009-06-17 16:27:40 -07001587 retval = do_wait_thread(wo, tsk);
1588 if (retval)
Roland McGrath98abed02008-03-19 19:24:59 -07001589 goto end;
Oleg Nesterov64a16ca2009-06-17 16:27:40 -07001590
1591 retval = ptrace_do_wait(wo, tsk);
1592 if (retval)
1593 goto end;
Roland McGrath98abed02008-03-19 19:24:59 -07001594
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001595 if (wo->wo_flags & __WNOTHREAD)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 break;
Oleg Nesterova3f6dfb2009-06-17 16:27:41 -07001597 } while_each_thread(current, tsk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598 read_unlock(&tasklist_lock);
Oleg Nesterovf2cc3eb2008-02-08 04:19:06 -08001599
Oleg Nesterov64a16ca2009-06-17 16:27:40 -07001600notask:
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001601 retval = wo->notask_error;
1602 if (!retval && !(wo->wo_flags & WNOHANG)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 retval = -ERESTARTSYS;
Roland McGrath98abed02008-03-19 19:24:59 -07001604 if (!signal_pending(current)) {
1605 schedule();
1606 goto repeat;
1607 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609end:
Oleg Nesterovf95d39d2009-06-17 16:27:42 -07001610 __set_current_state(TASK_RUNNING);
Oleg Nesterov0b7570e2009-09-23 15:56:46 -07001611 remove_wait_queue(&current->signal->wait_chldexit, &wo->child_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 return retval;
1613}
1614
Heiko Carstens17da2bd2009-01-14 14:14:10 +01001615SYSCALL_DEFINE5(waitid, int, which, pid_t, upid, struct siginfo __user *,
1616 infop, int, options, struct rusage __user *, ru)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617{
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001618 struct wait_opts wo;
Eric W. Biederman161550d2008-02-08 04:19:14 -08001619 struct pid *pid = NULL;
1620 enum pid_type type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621 long ret;
1622
Oleg Nesterov91c4e8e2016-05-23 16:23:53 -07001623 if (options & ~(WNOHANG|WNOWAIT|WEXITED|WSTOPPED|WCONTINUED|
1624 __WNOTHREAD|__WCLONE|__WALL))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625 return -EINVAL;
1626 if (!(options & (WEXITED|WSTOPPED|WCONTINUED)))
1627 return -EINVAL;
1628
1629 switch (which) {
1630 case P_ALL:
Eric W. Biederman161550d2008-02-08 04:19:14 -08001631 type = PIDTYPE_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 break;
1633 case P_PID:
Eric W. Biederman161550d2008-02-08 04:19:14 -08001634 type = PIDTYPE_PID;
1635 if (upid <= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 return -EINVAL;
1637 break;
1638 case P_PGID:
Eric W. Biederman161550d2008-02-08 04:19:14 -08001639 type = PIDTYPE_PGID;
1640 if (upid <= 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 break;
1643 default:
1644 return -EINVAL;
1645 }
1646
Eric W. Biederman161550d2008-02-08 04:19:14 -08001647 if (type < PIDTYPE_MAX)
1648 pid = find_get_pid(upid);
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001649
1650 wo.wo_type = type;
1651 wo.wo_pid = pid;
1652 wo.wo_flags = options;
1653 wo.wo_info = infop;
1654 wo.wo_stat = NULL;
1655 wo.wo_rusage = ru;
1656 ret = do_wait(&wo);
Vitaly Mayatskikhdfe16df2009-09-23 15:56:51 -07001657
1658 if (ret > 0) {
1659 ret = 0;
1660 } else if (infop) {
1661 /*
1662 * For a WNOHANG return, clear out all the fields
1663 * we would set so the user can easily tell the
1664 * difference.
1665 */
1666 if (!ret)
1667 ret = put_user(0, &infop->si_signo);
1668 if (!ret)
1669 ret = put_user(0, &infop->si_errno);
1670 if (!ret)
1671 ret = put_user(0, &infop->si_code);
1672 if (!ret)
1673 ret = put_user(0, &infop->si_pid);
1674 if (!ret)
1675 ret = put_user(0, &infop->si_uid);
1676 if (!ret)
1677 ret = put_user(0, &infop->si_status);
1678 }
1679
Eric W. Biederman161550d2008-02-08 04:19:14 -08001680 put_pid(pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 return ret;
1682}
1683
Heiko Carstens754fe8d2009-01-14 14:14:09 +01001684SYSCALL_DEFINE4(wait4, pid_t, upid, int __user *, stat_addr,
1685 int, options, struct rusage __user *, ru)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686{
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001687 struct wait_opts wo;
Eric W. Biederman161550d2008-02-08 04:19:14 -08001688 struct pid *pid = NULL;
1689 enum pid_type type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 long ret;
1691
1692 if (options & ~(WNOHANG|WUNTRACED|WCONTINUED|
1693 __WNOTHREAD|__WCLONE|__WALL))
1694 return -EINVAL;
Eric W. Biederman161550d2008-02-08 04:19:14 -08001695
1696 if (upid == -1)
1697 type = PIDTYPE_MAX;
1698 else if (upid < 0) {
1699 type = PIDTYPE_PGID;
1700 pid = find_get_pid(-upid);
1701 } else if (upid == 0) {
1702 type = PIDTYPE_PGID;
Oleg Nesterov2ae448e2009-04-02 16:58:36 -07001703 pid = get_task_pid(current, PIDTYPE_PGID);
Eric W. Biederman161550d2008-02-08 04:19:14 -08001704 } else /* upid > 0 */ {
1705 type = PIDTYPE_PID;
1706 pid = find_get_pid(upid);
1707 }
1708
Oleg Nesterov9e8ae012009-06-17 16:27:39 -07001709 wo.wo_type = type;
1710 wo.wo_pid = pid;
1711 wo.wo_flags = options | WEXITED;
1712 wo.wo_info = NULL;
1713 wo.wo_stat = stat_addr;
1714 wo.wo_rusage = ru;
1715 ret = do_wait(&wo);
Eric W. Biederman161550d2008-02-08 04:19:14 -08001716 put_pid(pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 return ret;
1719}
1720
1721#ifdef __ARCH_WANT_SYS_WAITPID
1722
1723/*
1724 * sys_waitpid() remains for compatibility. waitpid() should be
1725 * implemented by calling sys_wait4() from libc.a.
1726 */
Heiko Carstens17da2bd2009-01-14 14:14:10 +01001727SYSCALL_DEFINE3(waitpid, pid_t, pid, int __user *, stat_addr, int, options)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728{
1729 return sys_wait4(pid, stat_addr, options, NULL);
1730}
1731
1732#endif