Blame view
kernel/exit.c
42.1 KB
457c89965
|
1 |
// SPDX-License-Identifier: GPL-2.0-only |
1da177e4c
|
2 3 4 5 6 |
/* * linux/kernel/exit.c * * Copyright (C) 1991, 1992 Linus Torvalds */ |
1da177e4c
|
7 8 |
#include <linux/mm.h> #include <linux/slab.h> |
4eb5aaa3a
|
9 |
#include <linux/sched/autogroup.h> |
6e84f3152
|
10 |
#include <linux/sched/mm.h> |
03441a348
|
11 |
#include <linux/sched/stat.h> |
299300258
|
12 |
#include <linux/sched/task.h> |
68db0cf10
|
13 |
#include <linux/sched/task_stack.h> |
32ef5517c
|
14 |
#include <linux/sched/cputime.h> |
1da177e4c
|
15 |
#include <linux/interrupt.h> |
1da177e4c
|
16 |
#include <linux/module.h> |
c59ede7b7
|
17 |
#include <linux/capability.h> |
1da177e4c
|
18 19 20 |
#include <linux/completion.h> #include <linux/personality.h> #include <linux/tty.h> |
da9cbc873
|
21 |
#include <linux/iocontext.h> |
1da177e4c
|
22 |
#include <linux/key.h> |
1da177e4c
|
23 24 |
#include <linux/cpu.h> #include <linux/acct.h> |
8f0ab5147
|
25 |
#include <linux/tsacct_kern.h> |
1da177e4c
|
26 |
#include <linux/file.h> |
9f3acc314
|
27 |
#include <linux/fdtable.h> |
80d26af89
|
28 |
#include <linux/freezer.h> |
1da177e4c
|
29 |
#include <linux/binfmts.h> |
ab516013a
|
30 |
#include <linux/nsproxy.h> |
84d737866
|
31 |
#include <linux/pid_namespace.h> |
1da177e4c
|
32 33 34 35 |
#include <linux/ptrace.h> #include <linux/profile.h> #include <linux/mount.h> #include <linux/proc_fs.h> |
49d769d52
|
36 |
#include <linux/kthread.h> |
1da177e4c
|
37 |
#include <linux/mempolicy.h> |
c757249af
|
38 |
#include <linux/taskstats_kern.h> |
ca74e92b4
|
39 |
#include <linux/delayacct.h> |
b4f48b636
|
40 |
#include <linux/cgroup.h> |
1da177e4c
|
41 |
#include <linux/syscalls.h> |
7ed20e1ad
|
42 |
#include <linux/signal.h> |
6a14c5c9d
|
43 |
#include <linux/posix-timers.h> |
9f46080c4
|
44 |
#include <linux/cn_proc.h> |
de5097c2e
|
45 |
#include <linux/mutex.h> |
0771dfefc
|
46 |
#include <linux/futex.h> |
b92ce5589
|
47 |
#include <linux/pipe_fs_i.h> |
fa84cb935
|
48 |
#include <linux/audit.h> /* for audit_free() */ |
83cc5ed3c
|
49 |
#include <linux/resource.h> |
0d67a46df
|
50 |
#include <linux/blkdev.h> |
6eaeeaba3
|
51 |
#include <linux/task_io_accounting_ops.h> |
30199f5a4
|
52 |
#include <linux/tracehook.h> |
5ad4e53bd
|
53 |
#include <linux/fs_struct.h> |
d84f4f992
|
54 |
#include <linux/init_task.h> |
cdd6c482c
|
55 |
#include <linux/perf_event.h> |
ad8d75fff
|
56 |
#include <trace/events/sched.h> |
24f1e32c6
|
57 |
#include <linux/hw_breakpoint.h> |
3d5992d2a
|
58 |
#include <linux/oom.h> |
54848d73f
|
59 |
#include <linux/writeback.h> |
404015308
|
60 |
#include <linux/shm.h> |
5c9a8750a
|
61 |
#include <linux/kcov.h> |
53d3eaa31
|
62 |
#include <linux/random.h> |
8f95c90ce
|
63 |
#include <linux/rcuwait.h> |
7e95a2259
|
64 |
#include <linux/compat.h> |
1da177e4c
|
65 |
|
7c0f6ba68
|
66 |
#include <linux/uaccess.h> |
1da177e4c
|
67 68 69 |
#include <asm/unistd.h> #include <asm/pgtable.h> #include <asm/mmu_context.h> |
d40e48e02
|
70 |
static void __unhash_process(struct task_struct *p, bool group_dead) |
1da177e4c
|
71 72 |
{ nr_threads--; |
50d75f8da
|
73 |
detach_pid(p, PIDTYPE_PID); |
d40e48e02
|
74 |
if (group_dead) { |
6883f81aa
|
75 |
detach_pid(p, PIDTYPE_TGID); |
1da177e4c
|
76 77 |
detach_pid(p, PIDTYPE_PGID); detach_pid(p, PIDTYPE_SID); |
c97d98931
|
78 |
|
5e85d4abe
|
79 |
list_del_rcu(&p->tasks); |
9cd80bbb0
|
80 |
list_del_init(&p->sibling); |
909ea9646
|
81 |
__this_cpu_dec(process_counts); |
1da177e4c
|
82 |
} |
47e65328a
|
83 |
list_del_rcu(&p->thread_group); |
0c740d0af
|
84 |
list_del_rcu(&p->thread_node); |
1da177e4c
|
85 |
} |
6a14c5c9d
|
86 87 88 89 90 91 |
/* * This function expects the tasklist_lock write-locked. */ static void __exit_signal(struct task_struct *tsk) { struct signal_struct *sig = tsk->signal; |
d40e48e02
|
92 |
bool group_dead = thread_group_leader(tsk); |
6a14c5c9d
|
93 |
struct sighand_struct *sighand; |
4ada856fb
|
94 |
struct tty_struct *uninitialized_var(tty); |
5613fda9a
|
95 |
u64 utime, stime; |
6a14c5c9d
|
96 |
|
d11c563dd
|
97 |
sighand = rcu_dereference_check(tsk->sighand, |
db1466b3e
|
98 |
lockdep_tasklist_lock_is_held()); |
6a14c5c9d
|
99 |
spin_lock(&sighand->siglock); |
baa73d9e4
|
100 |
#ifdef CONFIG_POSIX_TIMERS |
6a14c5c9d
|
101 |
posix_cpu_timers_exit(tsk); |
d40e48e02
|
102 |
if (group_dead) { |
6a14c5c9d
|
103 |
posix_cpu_timers_exit_group(tsk); |
4a5999429
|
104 |
} else { |
6a14c5c9d
|
105 |
/* |
e0a702171
|
106 107 108 109 110 111 |
* This can only happen if the caller is de_thread(). * FIXME: this is the temporary hack, we should teach * posix-cpu-timers to handle this case correctly. */ if (unlikely(has_group_leader_pid(tsk))) posix_cpu_timers_exit_group(tsk); |
baa73d9e4
|
112 113 |
} #endif |
e0a702171
|
114 |
|
baa73d9e4
|
115 116 117 118 |
if (group_dead) { tty = sig->tty; sig->tty = NULL; } else { |
e0a702171
|
119 |
/* |
6a14c5c9d
|
120 121 122 |
* If there is any task waiting for the group exit * then notify it: */ |
d344193a0
|
123 |
if (sig->notify_count > 0 && !--sig->notify_count) |
6a14c5c9d
|
124 |
wake_up_process(sig->group_exit_task); |
6db840fa7
|
125 |
|
6a14c5c9d
|
126 127 |
if (tsk == sig->curr_target) sig->curr_target = next_thread(tsk); |
6a14c5c9d
|
128 |
} |
53d3eaa31
|
129 130 |
add_device_randomness((const void*) &tsk->se.sum_exec_runtime, sizeof(unsigned long long)); |
90ed9cbe7
|
131 |
/* |
26e75b5c3
|
132 133 134 135 |
* Accumulate here the counters for all threads as they die. We could * skip the group leader because it is the last user of signal_struct, * but we want to avoid the race with thread_group_cputime() which can * see the empty ->thread_head list. |
90ed9cbe7
|
136 137 |
*/ task_cputime(tsk, &utime, &stime); |
e78c34967
|
138 |
write_seqlock(&sig->stats_lock); |
90ed9cbe7
|
139 140 141 142 143 144 145 146 147 148 149 |
sig->utime += utime; sig->stime += stime; sig->gtime += task_gtime(tsk); sig->min_flt += tsk->min_flt; sig->maj_flt += tsk->maj_flt; sig->nvcsw += tsk->nvcsw; sig->nivcsw += tsk->nivcsw; sig->inblock += task_io_get_inblock(tsk); sig->oublock += task_io_get_oublock(tsk); task_io_accounting_add(&sig->ioac, &tsk->ioac); sig->sum_sched_runtime += tsk->se.sum_exec_runtime; |
b3ac022cb
|
150 |
sig->nr_threads--; |
d40e48e02
|
151 |
__unhash_process(tsk, group_dead); |
e78c34967
|
152 |
write_sequnlock(&sig->stats_lock); |
5876700cd
|
153 |
|
da7978b03
|
154 155 156 157 158 |
/* * Do this under ->siglock, we can race with another thread * doing sigqueue_free() if we have SIGQUEUE_PREALLOC signals. */ flush_sigqueue(&tsk->pending); |
a7e5328a0
|
159 |
tsk->sighand = NULL; |
6a14c5c9d
|
160 |
spin_unlock(&sighand->siglock); |
6a14c5c9d
|
161 |
|
a7e5328a0
|
162 |
__cleanup_sighand(sighand); |
a0be55dee
|
163 |
clear_tsk_thread_flag(tsk, TIF_SIGPENDING); |
d40e48e02
|
164 |
if (group_dead) { |
6a14c5c9d
|
165 |
flush_sigqueue(&sig->shared_pending); |
4ada856fb
|
166 |
tty_kref_put(tty); |
6a14c5c9d
|
167 168 |
} } |
8c7904a00
|
169 170 |
static void delayed_put_task_struct(struct rcu_head *rhp) { |
0a16b6075
|
171 |
struct task_struct *tsk = container_of(rhp, struct task_struct, rcu); |
4e231c796
|
172 |
perf_event_delayed_put(tsk); |
0a16b6075
|
173 174 |
trace_sched_process_free(tsk); put_task_struct(tsk); |
8c7904a00
|
175 |
} |
3fbd7ee28
|
176 177 178 179 180 |
void put_task_struct_rcu_user(struct task_struct *task) { if (refcount_dec_and_test(&task->rcu_users)) call_rcu(&task->rcu, delayed_put_task_struct); } |
f470021ad
|
181 |
|
a0be55dee
|
182 |
void release_task(struct task_struct *p) |
1da177e4c
|
183 |
{ |
36c8b5868
|
184 |
struct task_struct *leader; |
1da177e4c
|
185 |
int zap_leader; |
1f09f9749
|
186 |
repeat: |
c69e8d9c0
|
187 |
/* don't need to get the RCU readlock here - the process is dead and |
d11c563dd
|
188 189 |
* can't be modifying its own credentials. But shut RCU-lockdep up */ rcu_read_lock(); |
c69e8d9c0
|
190 |
atomic_dec(&__task_cred(p)->user->processes); |
d11c563dd
|
191 |
rcu_read_unlock(); |
c69e8d9c0
|
192 |
|
60347f671
|
193 |
proc_flush_task(p); |
6b115bf58
|
194 |
cgroup_release(p); |
0203026b5
|
195 |
|
1da177e4c
|
196 |
write_lock_irq(&tasklist_lock); |
a288eecce
|
197 |
ptrace_release_task(p); |
1da177e4c
|
198 |
__exit_signal(p); |
35f5cad8c
|
199 |
|
1da177e4c
|
200 201 202 203 204 205 206 |
/* * If we are the last non-leader member of the thread * group, and the leader is zombie, then notify the * group leader's parent process. (if it wants notification.) */ zap_leader = 0; leader = p->group_leader; |
a0be55dee
|
207 208 |
if (leader != p && thread_group_empty(leader) && leader->exit_state == EXIT_ZOMBIE) { |
1da177e4c
|
209 210 211 212 |
/* * If we were the last child thread and the leader has * exited already, and the leader's parent ignores SIGCHLD, * then we are the one who should release the leader. |
dae33574d
|
213 |
*/ |
867734737
|
214 |
zap_leader = do_notify_parent(leader, leader->exit_signal); |
dae33574d
|
215 216 |
if (zap_leader) leader->exit_state = EXIT_DEAD; |
1da177e4c
|
217 |
} |
1da177e4c
|
218 |
write_unlock_irq(&tasklist_lock); |
1da177e4c
|
219 |
release_thread(p); |
3fbd7ee28
|
220 |
put_task_struct_rcu_user(p); |
1da177e4c
|
221 222 223 224 225 |
p = leader; if (unlikely(zap_leader)) goto repeat; } |
8f95c90ce
|
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 |
void rcuwait_wake_up(struct rcuwait *w) { struct task_struct *task; rcu_read_lock(); /* * Order condition vs @task, such that everything prior to the load * of @task is visible. This is the condition as to why the user called * rcuwait_trywake() in the first place. Pairs with set_current_state() * barrier (A) in rcuwait_wait_event(). * * WAIT WAKE * [S] tsk = current [S] cond = true * MB (A) MB (B) * [L] cond [L] tsk */ |
6dc080eeb
|
243 |
smp_mb(); /* (B) */ |
8f95c90ce
|
244 |
|
8f95c90ce
|
245 246 247 248 249 |
task = rcu_dereference(w->task); if (task) wake_up_process(task); rcu_read_unlock(); } |
150593bf8
|
250 |
/* |
1da177e4c
|
251 252 253 254 255 256 257 |
* Determine if a process group is "orphaned", according to the POSIX * definition in 2.2.2.52. Orphaned process groups are not to be affected * by terminal-generated stop signals. Newly orphaned process groups are * to receive a SIGHUP and a SIGCONT. * * "I ask you, have you ever known what it is to be an orphan?" */ |
a0be55dee
|
258 259 |
static int will_become_orphaned_pgrp(struct pid *pgrp, struct task_struct *ignored_task) |
1da177e4c
|
260 261 |
{ struct task_struct *p; |
1da177e4c
|
262 |
|
0475ac084
|
263 |
do_each_pid_task(pgrp, PIDTYPE_PGID, p) { |
05e83df62
|
264 265 266 |
if ((p == ignored_task) || (p->exit_state && thread_group_empty(p)) || is_global_init(p->real_parent)) |
1da177e4c
|
267 |
continue; |
05e83df62
|
268 |
|
0475ac084
|
269 |
if (task_pgrp(p->real_parent) != pgrp && |
05e83df62
|
270 271 |
task_session(p->real_parent) == task_session(p)) return 0; |
0475ac084
|
272 |
} while_each_pid_task(pgrp, PIDTYPE_PGID, p); |
05e83df62
|
273 274 |
return 1; |
1da177e4c
|
275 |
} |
3e7cd6c41
|
276 |
int is_current_pgrp_orphaned(void) |
1da177e4c
|
277 278 279 280 |
{ int retval; read_lock(&tasklist_lock); |
3e7cd6c41
|
281 |
retval = will_become_orphaned_pgrp(task_pgrp(current), NULL); |
1da177e4c
|
282 283 284 285 |
read_unlock(&tasklist_lock); return retval; } |
961c4675c
|
286 |
static bool has_stopped_jobs(struct pid *pgrp) |
1da177e4c
|
287 |
{ |
1da177e4c
|
288 |
struct task_struct *p; |
0475ac084
|
289 |
do_each_pid_task(pgrp, PIDTYPE_PGID, p) { |
961c4675c
|
290 291 |
if (p->signal->flags & SIGNAL_STOP_STOPPED) return true; |
0475ac084
|
292 |
} while_each_pid_task(pgrp, PIDTYPE_PGID, p); |
961c4675c
|
293 294 |
return false; |
1da177e4c
|
295 |
} |
f49ee505b
|
296 297 298 299 300 301 302 303 304 305 306 307 |
/* * Check to see if any process groups have become orphaned as * a result of our exiting, and if they have any stopped jobs, * send them a SIGHUP and then a SIGCONT. (POSIX 3.2.2.2) */ static void kill_orphaned_pgrp(struct task_struct *tsk, struct task_struct *parent) { struct pid *pgrp = task_pgrp(tsk); struct task_struct *ignored_task = tsk; if (!parent) |
a0be55dee
|
308 309 310 |
/* exit: our father is in a different pgrp than * we are and we were the only connection outside. */ |
f49ee505b
|
311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 |
parent = tsk->real_parent; else /* reparent: our child is in a different pgrp than * we are, and it was the only connection outside. */ ignored_task = NULL; if (task_pgrp(parent) != pgrp && task_session(parent) == task_session(tsk) && will_become_orphaned_pgrp(pgrp, ignored_task) && has_stopped_jobs(pgrp)) { __kill_pgrp_info(SIGHUP, SEND_SIG_PRIV, pgrp); __kill_pgrp_info(SIGCONT, SEND_SIG_PRIV, pgrp); } } |
f98bafa06
|
326 |
#ifdef CONFIG_MEMCG |
cf475ad28
|
327 |
/* |
733eda7ac
|
328 |
* A task is exiting. If it owned this mm, find a new owner for the mm. |
cf475ad28
|
329 |
*/ |
cf475ad28
|
330 331 332 333 334 |
void mm_update_next_owner(struct mm_struct *mm) { struct task_struct *c, *g, *p = current; retry: |
733eda7ac
|
335 336 337 338 339 |
/* * If the exiting or execing task is not the owner, it's * someone else's problem. */ if (mm->owner != p) |
cf475ad28
|
340 |
return; |
733eda7ac
|
341 342 343 344 345 346 |
/* * The current owner is exiting/execing and there are no other * candidates. Do not leave the mm pointing to a possibly * freed task structure. */ if (atomic_read(&mm->mm_users) <= 1) { |
987717e5e
|
347 |
WRITE_ONCE(mm->owner, NULL); |
733eda7ac
|
348 349 |
return; } |
cf475ad28
|
350 351 352 353 354 355 356 357 358 359 360 361 362 |
read_lock(&tasklist_lock); /* * Search in the children */ list_for_each_entry(c, &p->children, sibling) { if (c->mm == mm) goto assign_new_owner; } /* * Search in the siblings */ |
dea33cfd9
|
363 |
list_for_each_entry(c, &p->real_parent->children, sibling) { |
cf475ad28
|
364 365 366 367 368 |
if (c->mm == mm) goto assign_new_owner; } /* |
f87fb599a
|
369 |
* Search through everything else, we should not get here often. |
cf475ad28
|
370 |
*/ |
39af1765f
|
371 372 373 374 375 376 377 378 379 |
for_each_process(g) { if (g->flags & PF_KTHREAD) continue; for_each_thread(g, c) { if (c->mm == mm) goto assign_new_owner; if (c->mm) break; } |
f87fb599a
|
380 |
} |
cf475ad28
|
381 |
read_unlock(&tasklist_lock); |
31a78f23b
|
382 383 384 |
/* * We found no owner yet mm_users > 1: this implies that we are * most likely racing with swapoff (try_to_unuse()) or /proc or |
e5991371e
|
385 |
* ptrace or page migration (get_task_mm()). Mark owner as NULL. |
31a78f23b
|
386 |
*/ |
987717e5e
|
387 |
WRITE_ONCE(mm->owner, NULL); |
cf475ad28
|
388 389 390 391 392 393 394 395 396 397 |
return; assign_new_owner: BUG_ON(c == p); get_task_struct(c); /* * The task_lock protects c->mm from changing. * We always want mm->owner->mm == mm */ task_lock(c); |
e5991371e
|
398 399 400 401 402 |
/* * Delay read_unlock() till we have the task_lock() * to ensure that c does not slip away underneath us */ read_unlock(&tasklist_lock); |
cf475ad28
|
403 404 405 406 407 |
if (c->mm != mm) { task_unlock(c); put_task_struct(c); goto retry; } |
987717e5e
|
408 |
WRITE_ONCE(mm->owner, c); |
cf475ad28
|
409 410 411 |
task_unlock(c); put_task_struct(c); } |
f98bafa06
|
412 |
#endif /* CONFIG_MEMCG */ |
cf475ad28
|
413 |
|
1da177e4c
|
414 415 416 417 |
/* * Turn us into a lazy TLB process if we * aren't already.. */ |
0039962a1
|
418 |
static void exit_mm(void) |
1da177e4c
|
419 |
{ |
0039962a1
|
420 |
struct mm_struct *mm = current->mm; |
b564daf80
|
421 |
struct core_state *core_state; |
1da177e4c
|
422 |
|
7d7e93588
|
423 |
exit_mm_release(current, mm); |
1da177e4c
|
424 425 |
if (!mm) return; |
4fe7efdbd
|
426 |
sync_mm_rss(mm); |
1da177e4c
|
427 428 |
/* * Serialize with any possible pending coredump. |
999d9fc16
|
429 |
* We must hold mmap_sem around checking core_state |
1da177e4c
|
430 |
* and clearing tsk->mm. The core-inducing thread |
999d9fc16
|
431 |
* will increment ->nr_threads for each thread in the |
1da177e4c
|
432 433 434 |
* group with ->mm != NULL. */ down_read(&mm->mmap_sem); |
b564daf80
|
435 436 437 |
core_state = mm->core_state; if (core_state) { struct core_thread self; |
a0be55dee
|
438 |
|
1da177e4c
|
439 |
up_read(&mm->mmap_sem); |
1da177e4c
|
440 |
|
0039962a1
|
441 |
self.task = current; |
b564daf80
|
442 443 444 445 446 447 448 |
self.next = xchg(&core_state->dumper.next, &self); /* * Implies mb(), the result of xchg() must be visible * to core_state->dumper. */ if (atomic_dec_and_test(&core_state->nr_threads)) complete(&core_state->startup); |
1da177e4c
|
449 |
|
a94e2d408
|
450 |
for (;;) { |
642fa448a
|
451 |
set_current_state(TASK_UNINTERRUPTIBLE); |
a94e2d408
|
452 453 |
if (!self.task) /* see coredump_finish() */ break; |
80d26af89
|
454 |
freezable_schedule(); |
a94e2d408
|
455 |
} |
642fa448a
|
456 |
__set_current_state(TASK_RUNNING); |
1da177e4c
|
457 458 |
down_read(&mm->mmap_sem); } |
f1f100764
|
459 |
mmgrab(mm); |
0039962a1
|
460 |
BUG_ON(mm != current->active_mm); |
1da177e4c
|
461 |
/* more a memory barrier than a real lock */ |
0039962a1
|
462 463 |
task_lock(current); current->mm = NULL; |
1da177e4c
|
464 465 |
up_read(&mm->mmap_sem); enter_lazy_tlb(mm, current); |
0039962a1
|
466 |
task_unlock(current); |
cf475ad28
|
467 |
mm_update_next_owner(mm); |
1da177e4c
|
468 |
mmput(mm); |
c32b3cbe0
|
469 |
if (test_thread_flag(TIF_MEMDIE)) |
38531201c
|
470 |
exit_oom_victim(); |
1da177e4c
|
471 |
} |
c9dc05bfd
|
472 473 474 475 476 477 478 479 480 481 |
static struct task_struct *find_alive_thread(struct task_struct *p) { struct task_struct *t; for_each_thread(p, t) { if (!(t->flags & PF_EXITING)) return t; } return NULL; } |
8fb335e07
|
482 483 |
static struct task_struct *find_child_reaper(struct task_struct *father, struct list_head *dead) |
1109909c7
|
484 485 486 487 488 |
__releases(&tasklist_lock) __acquires(&tasklist_lock) { struct pid_namespace *pid_ns = task_active_pid_ns(father); struct task_struct *reaper = pid_ns->child_reaper; |
8fb335e07
|
489 |
struct task_struct *p, *n; |
1109909c7
|
490 491 492 |
if (likely(reaper != father)) return reaper; |
c9dc05bfd
|
493 494 |
reaper = find_alive_thread(father); if (reaper) { |
1109909c7
|
495 496 497 498 499 |
pid_ns->child_reaper = reaper; return reaper; } write_unlock_irq(&tasklist_lock); |
8fb335e07
|
500 501 502 503 504 |
list_for_each_entry_safe(p, n, dead, ptrace_entry) { list_del_init(&p->ptrace_entry); release_task(p); } |
1109909c7
|
505 506 507 508 509 |
zap_pid_ns_processes(pid_ns); write_lock_irq(&tasklist_lock); return father; } |
1da177e4c
|
510 |
/* |
ebec18a6d
|
511 512 513 514 515 |
* When we die, we re-parent all our children, and try to: * 1. give them to another thread in our thread group, if such a member exists * 2. give it to the first ancestor process which prctl'd itself as a * child_subreaper for its children (like a service manager) * 3. give it to the init process (PID 1) in our pid namespace |
1da177e4c
|
516 |
*/ |
1109909c7
|
517 518 |
static struct task_struct *find_new_reaper(struct task_struct *father, struct task_struct *child_reaper) |
1da177e4c
|
519 |
{ |
c9dc05bfd
|
520 |
struct task_struct *thread, *reaper; |
1da177e4c
|
521 |
|
c9dc05bfd
|
522 523 |
thread = find_alive_thread(father); if (thread) |
950bbabb5
|
524 |
return thread; |
1da177e4c
|
525 |
|
7d24e2df5
|
526 |
if (father->signal->has_child_subreaper) { |
c6c70f445
|
527 |
unsigned int ns_level = task_pid(father)->level; |
ebec18a6d
|
528 |
/* |
175aed3f8
|
529 |
* Find the first ->is_child_subreaper ancestor in our pid_ns. |
c6c70f445
|
530 531 532 533 534 |
* We can't check reaper != child_reaper to ensure we do not * cross the namespaces, the exiting parent could be injected * by setns() + fork(). * We check pid->level, this is slightly more efficient than * task_active_pid_ns(reaper) != task_active_pid_ns(father). |
ebec18a6d
|
535 |
*/ |
c6c70f445
|
536 537 |
for (reaper = father->real_parent; task_pid(reaper)->level == ns_level; |
ebec18a6d
|
538 |
reaper = reaper->real_parent) { |
175aed3f8
|
539 |
if (reaper == &init_task) |
ebec18a6d
|
540 541 542 |
break; if (!reaper->signal->is_child_subreaper) continue; |
c9dc05bfd
|
543 544 545 |
thread = find_alive_thread(reaper); if (thread) return thread; |
ebec18a6d
|
546 |
} |
1da177e4c
|
547 |
} |
762a24bee
|
548 |
|
1109909c7
|
549 |
return child_reaper; |
950bbabb5
|
550 |
} |
5dfc80be7
|
551 552 553 |
/* * Any that need to be release_task'd are put on the @dead list. */ |
9cd80bbb0
|
554 |
static void reparent_leader(struct task_struct *father, struct task_struct *p, |
5dfc80be7
|
555 556 |
struct list_head *dead) { |
2831096e2
|
557 |
if (unlikely(p->exit_state == EXIT_DEAD)) |
5dfc80be7
|
558 |
return; |
abd50b39e
|
559 |
/* We don't want people slaying init. */ |
5dfc80be7
|
560 561 562 |
p->exit_signal = SIGCHLD; /* If it has exited notify the new parent about this child's death. */ |
d21142ece
|
563 |
if (!p->ptrace && |
5dfc80be7
|
564 |
p->exit_state == EXIT_ZOMBIE && thread_group_empty(p)) { |
867734737
|
565 |
if (do_notify_parent(p, p->exit_signal)) { |
5dfc80be7
|
566 |
p->exit_state = EXIT_DEAD; |
dc2fd4b00
|
567 |
list_add(&p->ptrace_entry, dead); |
5dfc80be7
|
568 569 570 571 572 |
} } kill_orphaned_pgrp(p, father); } |
482a3767e
|
573 574 575 576 577 578 579 580 581 582 |
/* * This does two things: * * A. Make init inherit all the child processes * B. Check to see if any process groups have become orphaned * as a result of our exiting, and if they have any stopped * jobs, send them a SIGHUP and then a SIGCONT. (POSIX 3.2.2.2) */ static void forget_original_parent(struct task_struct *father, struct list_head *dead) |
1da177e4c
|
583 |
{ |
482a3767e
|
584 |
struct task_struct *p, *t, *reaper; |
762a24bee
|
585 |
|
7c8bd2322
|
586 |
if (unlikely(!list_empty(&father->ptraced))) |
482a3767e
|
587 |
exit_ptrace(father, dead); |
f470021ad
|
588 |
|
7c8bd2322
|
589 |
/* Can drop and reacquire tasklist_lock */ |
8fb335e07
|
590 |
reaper = find_child_reaper(father, dead); |
ad9e206ae
|
591 |
if (list_empty(&father->children)) |
482a3767e
|
592 |
return; |
1109909c7
|
593 594 |
reaper = find_new_reaper(father, reaper); |
2831096e2
|
595 |
list_for_each_entry(p, &father->children, sibling) { |
57a059187
|
596 |
for_each_thread(p, t) { |
9cd80bbb0
|
597 |
t->real_parent = reaper; |
57a059187
|
598 599 |
BUG_ON((!t->ptrace) != (t->parent == father)); if (likely(!t->ptrace)) |
9cd80bbb0
|
600 |
t->parent = t->real_parent; |
9cd80bbb0
|
601 602 |
if (t->pdeath_signal) group_send_sig_info(t->pdeath_signal, |
010249808
|
603 604 |
SEND_SIG_NOINFO, t, PIDTYPE_TGID); |
57a059187
|
605 |
} |
2831096e2
|
606 607 608 609 610 |
/* * If this is a threaded reparent there is no need to * notify anyone anything has happened. */ if (!same_thread_group(reaper, father)) |
482a3767e
|
611 |
reparent_leader(father, p, dead); |
1da177e4c
|
612 |
} |
2831096e2
|
613 |
list_splice_tail_init(&father->children, &reaper->children); |
1da177e4c
|
614 615 616 617 618 619 |
} /* * Send signals to all our closest relatives so that they know * to properly mourn us.. */ |
821c7de71
|
620 |
static void exit_notify(struct task_struct *tsk, int group_dead) |
1da177e4c
|
621 |
{ |
53c8f9f19
|
622 |
bool autoreap; |
482a3767e
|
623 624 |
struct task_struct *p, *n; LIST_HEAD(dead); |
1da177e4c
|
625 |
|
762a24bee
|
626 |
write_lock_irq(&tasklist_lock); |
482a3767e
|
627 |
forget_original_parent(tsk, &dead); |
821c7de71
|
628 629 |
if (group_dead) kill_orphaned_pgrp(tsk->group_leader, NULL); |
1da177e4c
|
630 |
|
b191d6491
|
631 |
tsk->exit_state = EXIT_ZOMBIE; |
45cdf5cc0
|
632 633 634 635 636 637 638 639 640 641 642 643 |
if (unlikely(tsk->ptrace)) { int sig = thread_group_leader(tsk) && thread_group_empty(tsk) && !ptrace_reparented(tsk) ? tsk->exit_signal : SIGCHLD; autoreap = do_notify_parent(tsk, sig); } else if (thread_group_leader(tsk)) { autoreap = thread_group_empty(tsk) && do_notify_parent(tsk, tsk->exit_signal); } else { autoreap = true; } |
1da177e4c
|
644 |
|
30b692d3b
|
645 646 |
if (autoreap) { tsk->exit_state = EXIT_DEAD; |
6c66e7dba
|
647 |
list_add(&tsk->ptrace_entry, &dead); |
30b692d3b
|
648 |
} |
1da177e4c
|
649 |
|
9c3391684
|
650 651 |
/* mt-exec, de_thread() is waiting for group leader */ if (unlikely(tsk->signal->notify_count < 0)) |
6db840fa7
|
652 |
wake_up_process(tsk->signal->group_exit_task); |
1da177e4c
|
653 |
write_unlock_irq(&tasklist_lock); |
482a3767e
|
654 655 656 657 |
list_for_each_entry_safe(p, n, &dead, ptrace_entry) { list_del_init(&p->ptrace_entry); release_task(p); } |
1da177e4c
|
658 |
} |
e18eecb8b
|
659 660 661 662 663 |
#ifdef CONFIG_DEBUG_STACK_USAGE static void check_stack_usage(void) { static DEFINE_SPINLOCK(low_water_lock); static int lowest_to_date = THREAD_SIZE; |
e18eecb8b
|
664 |
unsigned long free; |
7c9f8861e
|
665 |
free = stack_not_used(current); |
e18eecb8b
|
666 667 668 669 670 671 |
if (free >= lowest_to_date) return; spin_lock(&low_water_lock); if (free < lowest_to_date) { |
627393d44
|
672 673 |
pr_info("%s (%d) used greatest stack depth: %lu bytes left ", |
a0be55dee
|
674 |
current->comm, task_pid_nr(current), free); |
e18eecb8b
|
675 676 677 678 679 680 681 |
lowest_to_date = free; } spin_unlock(&low_water_lock); } #else static inline void check_stack_usage(void) {} #endif |
9af6528ee
|
682 |
void __noreturn do_exit(long code) |
1da177e4c
|
683 684 685 686 687 |
{ struct task_struct *tsk = current; int group_dead; profile_task_exit(tsk); |
5c9a8750a
|
688 |
kcov_task_exit(tsk); |
1da177e4c
|
689 |
|
73c101011
|
690 |
WARN_ON(blk_needs_flush_plug(tsk)); |
22e2c507c
|
691 |
|
1da177e4c
|
692 693 694 695 |
if (unlikely(in_interrupt())) panic("Aiee, killing interrupt handler!"); if (unlikely(!tsk->pid)) panic("Attempted to kill the idle task!"); |
1da177e4c
|
696 |
|
33dd94ae1
|
697 698 699 700 701 702 703 704 |
/* * If do_exit is called because this processes oopsed, it's possible * that get_fs() was left as KERNEL_DS, so reset it to USER_DS before * continuing. Amongst other possible reasons, this is to prevent * mm_release()->clear_child_tid() from writing to a user-controlled * kernel address. */ set_fs(USER_DS); |
a288eecce
|
705 |
ptrace_event(PTRACE_EVENT_EXIT, code); |
1da177e4c
|
706 |
|
e0e817392
|
707 |
validate_creds_for_do_exit(tsk); |
df164db5f
|
708 709 710 711 712 |
/* * We're taking recursive faults here in do_exit. Safest is to just * leave this task alone and wait for reboot. */ if (unlikely(tsk->flags & PF_EXITING)) { |
a0be55dee
|
713 714 |
pr_alert("Fixing recursive fault but reboot is needed! "); |
b2f4e1067
|
715 |
futex_exit_recursive(tsk); |
df164db5f
|
716 717 718 |
set_current_state(TASK_UNINTERRUPTIBLE); schedule(); } |
d12619b5f
|
719 |
exit_signals(tsk); /* sets PF_EXITING */ |
1da177e4c
|
720 |
|
1dc0fffc4
|
721 |
if (unlikely(in_atomic())) { |
a0be55dee
|
722 723 724 725 |
pr_info("note: %s[%d] exited with preempt_count %d ", current->comm, task_pid_nr(current), preempt_count()); |
1dc0fffc4
|
726 727 |
preempt_count_set(PREEMPT_ENABLED); } |
1da177e4c
|
728 |
|
48d212a2e
|
729 730 731 |
/* sync mm's RSS info before statistics gathering */ if (tsk->mm) sync_mm_rss(tsk->mm); |
51229b495
|
732 |
acct_update_integrals(tsk); |
1da177e4c
|
733 |
group_dead = atomic_dec_and_test(&tsk->signal->live); |
c30689516
|
734 |
if (group_dead) { |
66d9052e6
|
735 736 737 738 739 740 741 742 |
/* * If the last thread of global init has exited, panic * immediately to get a useable coredump. */ if (unlikely(is_global_init(tsk))) panic("Attempted to kill init! exitcode=0x%08x ", tsk->signal->group_exit_code ?: (int)code); |
baa73d9e4
|
743 |
#ifdef CONFIG_POSIX_TIMERS |
778e9a9c3
|
744 |
hrtimer_cancel(&tsk->signal->real_timer); |
25f407f0b
|
745 |
exit_itimers(tsk->signal); |
baa73d9e4
|
746 |
#endif |
1f10206cf
|
747 748 |
if (tsk->mm) setmax_mm_hiwater_rss(&tsk->signal->maxrss, tsk->mm); |
c30689516
|
749 |
} |
f6ec29a42
|
750 |
acct_collect(code, group_dead); |
522ed7767
|
751 752 |
if (group_dead) tty_audit_exit(); |
a4ff8dba7
|
753 |
audit_free(tsk); |
115085ea0
|
754 |
|
48d212a2e
|
755 |
tsk->exit_code = code; |
115085ea0
|
756 |
taskstats_exit(tsk, group_dead); |
c757249af
|
757 |
|
0039962a1
|
758 |
exit_mm(); |
1da177e4c
|
759 |
|
0e4648141
|
760 |
if (group_dead) |
f6ec29a42
|
761 |
acct_process(); |
0a16b6075
|
762 |
trace_sched_process_exit(tsk); |
1da177e4c
|
763 |
exit_sem(tsk); |
b34a6b1da
|
764 |
exit_shm(tsk); |
1ec7f1ddb
|
765 766 |
exit_files(tsk); exit_fs(tsk); |
c39df5fa3
|
767 768 |
if (group_dead) disassociate_ctty(1); |
8aac62706
|
769 |
exit_task_namespaces(tsk); |
ed3e694d7
|
770 |
exit_task_work(tsk); |
e64646946
|
771 |
exit_thread(tsk); |
73ab1cb2d
|
772 |
exit_umh(tsk); |
0b3fcf178
|
773 774 775 776 777 778 779 780 |
/* * Flush inherited counters to the parent - before the parent * gets woken up by child-exit notifications. * * because of cgroup mode, must be called before cgroup_exit() */ perf_event_exit_task(tsk); |
8e5bfa8c1
|
781 |
sched_autogroup_exit_task(tsk); |
1ec41830e
|
782 |
cgroup_exit(tsk); |
1da177e4c
|
783 |
|
33b2fb303
|
784 |
/* |
24f1e32c6
|
785 786 |
* FIXME: do that only when needed, using sched_exit tracepoint */ |
7c8df2863
|
787 |
flush_ptrace_hw_breakpoint(tsk); |
33b2fb303
|
788 |
|
ccdd29fff
|
789 |
exit_tasks_rcu_start(); |
821c7de71
|
790 |
exit_notify(tsk, group_dead); |
ef9823939
|
791 |
proc_exit_connector(tsk); |
c11600e4f
|
792 |
mpol_put_task_policy(tsk); |
42b2dd0a0
|
793 |
#ifdef CONFIG_FUTEX |
c87e2837b
|
794 795 |
if (unlikely(current->pi_state_cache)) kfree(current->pi_state_cache); |
42b2dd0a0
|
796 |
#endif |
c87e2837b
|
797 |
/* |
9a11b49a8
|
798 |
* Make sure we are holding no locks: |
de5097c2e
|
799 |
*/ |
1b1d2fb44
|
800 |
debug_check_no_locks_held(); |
1da177e4c
|
801 |
|
afc847b7d
|
802 |
if (tsk->io_context) |
b69f22920
|
803 |
exit_io_context(tsk); |
afc847b7d
|
804 |
|
b92ce5589
|
805 |
if (tsk->splice_pipe) |
4b8a8f1e4
|
806 |
free_pipe_info(tsk->splice_pipe); |
b92ce5589
|
807 |
|
5640f7685
|
808 809 |
if (tsk->task_frag.page) put_page(tsk->task_frag.page); |
e0e817392
|
810 |
validate_creds_for_do_exit(tsk); |
4bcb8232c
|
811 |
check_stack_usage(); |
7407251a0
|
812 |
preempt_disable(); |
54848d73f
|
813 814 |
if (tsk->nr_dirtied) __this_cpu_add(dirty_throttle_leaks, tsk->nr_dirtied); |
f41d911f8
|
815 |
exit_rcu(); |
ccdd29fff
|
816 |
exit_tasks_rcu_finish(); |
b5740f4b2
|
817 |
|
b09be676e
|
818 |
lockdep_free_task(tsk); |
9af6528ee
|
819 |
do_task_dead(); |
1da177e4c
|
820 |
} |
012914dad
|
821 |
EXPORT_SYMBOL_GPL(do_exit); |
9402c95f3
|
822 |
void complete_and_exit(struct completion *comp, long code) |
1da177e4c
|
823 824 825 |
{ if (comp) complete(comp); |
55a101f8f
|
826 |
|
1da177e4c
|
827 828 |
do_exit(code); } |
1da177e4c
|
829 |
EXPORT_SYMBOL(complete_and_exit); |
754fe8d29
|
830 |
SYSCALL_DEFINE1(exit, int, error_code) |
1da177e4c
|
831 832 833 |
{ do_exit((error_code&0xff)<<8); } |
1da177e4c
|
834 835 836 837 |
/* * Take down every thread in the group. This is called by fatal signals * as well as by sys_exit_group (below). */ |
9402c95f3
|
838 |
void |
1da177e4c
|
839 840 |
do_group_exit(int exit_code) { |
bfc4b0890
|
841 |
struct signal_struct *sig = current->signal; |
1da177e4c
|
842 |
BUG_ON(exit_code & 0x80); /* core dumps don't get here */ |
bfc4b0890
|
843 844 |
if (signal_group_exit(sig)) exit_code = sig->group_exit_code; |
1da177e4c
|
845 |
else if (!thread_group_empty(current)) { |
1da177e4c
|
846 |
struct sighand_struct *const sighand = current->sighand; |
a0be55dee
|
847 |
|
1da177e4c
|
848 |
spin_lock_irq(&sighand->siglock); |
ed5d2cac1
|
849 |
if (signal_group_exit(sig)) |
1da177e4c
|
850 851 852 |
/* Another thread got here before we took the lock. */ exit_code = sig->group_exit_code; else { |
1da177e4c
|
853 |
sig->group_exit_code = exit_code; |
ed5d2cac1
|
854 |
sig->flags = SIGNAL_GROUP_EXIT; |
1da177e4c
|
855 856 857 |
zap_other_threads(current); } spin_unlock_irq(&sighand->siglock); |
1da177e4c
|
858 859 860 861 862 863 864 865 866 867 868 |
} do_exit(exit_code); /* NOTREACHED */ } /* * this kills every thread in the thread group. Note that any externally * wait4()-ing process will get the correct exit code - even if this * thread is not the thread group leader. */ |
754fe8d29
|
869 |
SYSCALL_DEFINE1(exit_group, int, error_code) |
1da177e4c
|
870 871 |
{ do_group_exit((error_code & 0xff) << 8); |
2ed7c03ec
|
872 873 |
/* NOTREACHED */ return 0; |
1da177e4c
|
874 |
} |
67d7ddded
|
875 876 877 878 879 880 |
struct waitid_info { pid_t pid; uid_t uid; int status; int cause; }; |
9e8ae01d1
|
881 882 |
struct wait_opts { enum pid_type wo_type; |
9e8ae01d1
|
883 |
int wo_flags; |
e1eb1ebcc
|
884 |
struct pid *wo_pid; |
9e8ae01d1
|
885 |
|
67d7ddded
|
886 |
struct waitid_info *wo_info; |
359566fae
|
887 |
int wo_stat; |
ce72a16fa
|
888 |
struct rusage *wo_rusage; |
9e8ae01d1
|
889 |
|
ac6424b98
|
890 |
wait_queue_entry_t child_wait; |
9e8ae01d1
|
891 892 |
int notask_error; }; |
989264f46
|
893 |
static int eligible_pid(struct wait_opts *wo, struct task_struct *p) |
1da177e4c
|
894 |
{ |
5c01ba49e
|
895 896 897 |
return wo->wo_type == PIDTYPE_MAX || task_pid_type(p, wo->wo_type) == wo->wo_pid; } |
1da177e4c
|
898 |
|
bf959931d
|
899 900 |
static int eligible_child(struct wait_opts *wo, bool ptrace, struct task_struct *p) |
5c01ba49e
|
901 902 903 |
{ if (!eligible_pid(wo, p)) return 0; |
bf959931d
|
904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 |
/* * Wait for all children (clone and not) if __WALL is set or * if it is traced by us. */ if (ptrace || (wo->wo_flags & __WALL)) return 1; /* * Otherwise, wait for clone children *only* if __WCLONE is set; * otherwise, wait for non-clone children *only*. * * Note: a "clone" child here is one that reports to its parent * using a signal other than SIGCHLD, or a non-leader thread which * we can only see if it is traced by us. */ if ((p->exit_signal != SIGCHLD) ^ !!(wo->wo_flags & __WCLONE)) |
1da177e4c
|
921 |
return 0; |
1da177e4c
|
922 |
|
14dd0b814
|
923 |
return 1; |
1da177e4c
|
924 |
} |
1da177e4c
|
925 926 927 928 929 930 |
/* * Handle sys_wait4 work for one task in state EXIT_ZOMBIE. We hold * read_lock(&tasklist_lock) on entry. If we return zero, we still hold * the lock and this task is uninteresting. If we return nonzero, we have * released the lock and the system call should return. */ |
9e8ae01d1
|
931 |
static int wait_task_zombie(struct wait_opts *wo, struct task_struct *p) |
1da177e4c
|
932 |
{ |
67d7ddded
|
933 |
int state, status; |
6c5f3e7b4
|
934 |
pid_t pid = task_pid_vnr(p); |
43e13cc10
|
935 |
uid_t uid = from_kuid_munged(current_user_ns(), task_uid(p)); |
67d7ddded
|
936 |
struct waitid_info *infop; |
1da177e4c
|
937 |
|
9e8ae01d1
|
938 |
if (!likely(wo->wo_flags & WEXITED)) |
98abed020
|
939 |
return 0; |
9e8ae01d1
|
940 |
if (unlikely(wo->wo_flags & WNOWAIT)) { |
76d9871e1
|
941 |
status = p->exit_code; |
1da177e4c
|
942 943 |
get_task_struct(p); read_unlock(&tasklist_lock); |
1029a2b52
|
944 |
sched_annotate_sleep(); |
e61a25022
|
945 946 |
if (wo->wo_rusage) getrusage(p, RUSAGE_BOTH, wo->wo_rusage); |
bb380ec33
|
947 |
put_task_struct(p); |
76d9871e1
|
948 |
goto out_info; |
1da177e4c
|
949 |
} |
1da177e4c
|
950 |
/* |
abd50b39e
|
951 |
* Move the task's state to DEAD/TRACE, only one thread can do this. |
1da177e4c
|
952 |
*/ |
f6507f83b
|
953 954 |
state = (ptrace_reparented(p) && thread_group_leader(p)) ? EXIT_TRACE : EXIT_DEAD; |
abd50b39e
|
955 |
if (cmpxchg(&p->exit_state, EXIT_ZOMBIE, state) != EXIT_ZOMBIE) |
1da177e4c
|
956 |
return 0; |
986094dfe
|
957 958 959 960 961 |
/* * We own this thread, nobody else can reap it. */ read_unlock(&tasklist_lock); sched_annotate_sleep(); |
f6507f83b
|
962 |
|
befca9677
|
963 |
/* |
f6507f83b
|
964 |
* Check thread_group_leader() to exclude the traced sub-threads. |
befca9677
|
965 |
*/ |
f6507f83b
|
966 |
if (state == EXIT_DEAD && thread_group_leader(p)) { |
f953ccd00
|
967 968 |
struct signal_struct *sig = p->signal; struct signal_struct *psig = current->signal; |
1f10206cf
|
969 |
unsigned long maxrss; |
5613fda9a
|
970 |
u64 tgutime, tgstime; |
3795e1616
|
971 |
|
1da177e4c
|
972 973 974 975 976 977 978 979 |
/* * The resource counters for the group leader are in its * own task_struct. Those for dead threads in the group * are in its signal_struct, as are those for the child * processes it has previously reaped. All these * accumulate in the parent's signal_struct c* fields. * * We don't bother to take a lock here to protect these |
f953ccd00
|
980 981 982 983 984 985 986 |
* p->signal fields because the whole thread group is dead * and nobody can change them. * * psig->stats_lock also protects us from our sub-theads * which can reap other children at the same time. Until * we change k_getrusage()-like users to rely on this lock * we have to take ->siglock as well. |
0cf55e1ec
|
987 |
* |
a0be55dee
|
988 989 990 |
* We use thread_group_cputime_adjusted() to get times for * the thread group, which consolidates times for all threads * in the group including the group leader. |
1da177e4c
|
991 |
*/ |
e80d0a1ae
|
992 |
thread_group_cputime_adjusted(p, &tgutime, &tgstime); |
f953ccd00
|
993 |
spin_lock_irq(¤t->sighand->siglock); |
e78c34967
|
994 |
write_seqlock(&psig->stats_lock); |
648616343
|
995 996 |
psig->cutime += tgutime + sig->cutime; psig->cstime += tgstime + sig->cstime; |
6fac4829c
|
997 |
psig->cgtime += task_gtime(p) + sig->gtime + sig->cgtime; |
3795e1616
|
998 999 1000 1001 1002 1003 1004 1005 |
psig->cmin_flt += p->min_flt + sig->min_flt + sig->cmin_flt; psig->cmaj_flt += p->maj_flt + sig->maj_flt + sig->cmaj_flt; psig->cnvcsw += p->nvcsw + sig->nvcsw + sig->cnvcsw; psig->cnivcsw += p->nivcsw + sig->nivcsw + sig->cnivcsw; |
6eaeeaba3
|
1006 1007 1008 1009 1010 1011 |
psig->cinblock += task_io_get_inblock(p) + sig->inblock + sig->cinblock; psig->coublock += task_io_get_oublock(p) + sig->oublock + sig->coublock; |
1f10206cf
|
1012 1013 1014 |
maxrss = max(sig->maxrss, sig->cmaxrss); if (psig->cmaxrss < maxrss) psig->cmaxrss = maxrss; |
5995477ab
|
1015 1016 |
task_io_accounting_add(&psig->ioac, &p->ioac); task_io_accounting_add(&psig->ioac, &sig->ioac); |
e78c34967
|
1017 |
write_sequnlock(&psig->stats_lock); |
f953ccd00
|
1018 |
spin_unlock_irq(¤t->sighand->siglock); |
1da177e4c
|
1019 |
} |
ce72a16fa
|
1020 1021 |
if (wo->wo_rusage) getrusage(p, RUSAGE_BOTH, wo->wo_rusage); |
1da177e4c
|
1022 1023 |
status = (p->signal->flags & SIGNAL_GROUP_EXIT) ? p->signal->group_exit_code : p->exit_code; |
359566fae
|
1024 |
wo->wo_stat = status; |
2f4e6e2a8
|
1025 |
|
b43606905
|
1026 |
if (state == EXIT_TRACE) { |
1da177e4c
|
1027 |
write_lock_irq(&tasklist_lock); |
2f4e6e2a8
|
1028 1029 |
/* We dropped tasklist, ptracer could die and untrace */ ptrace_unlink(p); |
b43606905
|
1030 1031 1032 1033 1034 |
/* If parent wants a zombie, don't release it now */ state = EXIT_ZOMBIE; if (do_notify_parent(p, p->exit_signal)) state = EXIT_DEAD; |
abd50b39e
|
1035 |
p->exit_state = state; |
1da177e4c
|
1036 1037 |
write_unlock_irq(&tasklist_lock); } |
abd50b39e
|
1038 |
if (state == EXIT_DEAD) |
1da177e4c
|
1039 |
release_task(p); |
2f4e6e2a8
|
1040 |
|
76d9871e1
|
1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 |
out_info: infop = wo->wo_info; if (infop) { if ((status & 0x7f) == 0) { infop->cause = CLD_EXITED; infop->status = status >> 8; } else { infop->cause = (status & 0x80) ? CLD_DUMPED : CLD_KILLED; infop->status = status & 0x7f; } infop->pid = pid; infop->uid = uid; } |
67d7ddded
|
1054 |
return pid; |
1da177e4c
|
1055 |
} |
90bc8d8b1
|
1056 1057 1058 |
static int *task_stopped_code(struct task_struct *p, bool ptrace) { if (ptrace) { |
570ac9337
|
1059 |
if (task_is_traced(p) && !(p->jobctl & JOBCTL_LISTENING)) |
90bc8d8b1
|
1060 1061 1062 1063 1064 1065 1066 |
return &p->exit_code; } else { if (p->signal->flags & SIGNAL_STOP_STOPPED) return &p->signal->group_exit_code; } return NULL; } |
19e274630
|
1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 |
/** * wait_task_stopped - Wait for %TASK_STOPPED or %TASK_TRACED * @wo: wait options * @ptrace: is the wait for ptrace * @p: task to wait for * * Handle sys_wait4() work for %p in state %TASK_STOPPED or %TASK_TRACED. * * CONTEXT: * read_lock(&tasklist_lock), which is released if return value is * non-zero. Also, grabs and releases @p->sighand->siglock. * * RETURNS: * 0 if wait condition didn't exist and search for other wait conditions * should continue. Non-zero return, -errno on failure and @p's pid on * success, implies that tasklist_lock is released and wait condition * search should terminate. |
1da177e4c
|
1084 |
*/ |
9e8ae01d1
|
1085 1086 |
static int wait_task_stopped(struct wait_opts *wo, int ptrace, struct task_struct *p) |
1da177e4c
|
1087 |
{ |
67d7ddded
|
1088 1089 |
struct waitid_info *infop; int exit_code, *p_code, why; |
ee7c82da8
|
1090 |
uid_t uid = 0; /* unneeded, required by compiler */ |
c89507835
|
1091 |
pid_t pid; |
1da177e4c
|
1092 |
|
47918025e
|
1093 1094 1095 |
/* * Traditionally we see ptrace'd stopped tasks regardless of options. */ |
9e8ae01d1
|
1096 |
if (!ptrace && !(wo->wo_flags & WUNTRACED)) |
98abed020
|
1097 |
return 0; |
19e274630
|
1098 1099 |
if (!task_stopped_code(p, ptrace)) return 0; |
ee7c82da8
|
1100 1101 |
exit_code = 0; spin_lock_irq(&p->sighand->siglock); |
90bc8d8b1
|
1102 1103 |
p_code = task_stopped_code(p, ptrace); if (unlikely(!p_code)) |
ee7c82da8
|
1104 |
goto unlock_sig; |
90bc8d8b1
|
1105 |
exit_code = *p_code; |
ee7c82da8
|
1106 1107 |
if (!exit_code) goto unlock_sig; |
9e8ae01d1
|
1108 |
if (!unlikely(wo->wo_flags & WNOWAIT)) |
90bc8d8b1
|
1109 |
*p_code = 0; |
ee7c82da8
|
1110 |
|
8ca937a66
|
1111 |
uid = from_kuid_munged(current_user_ns(), task_uid(p)); |
ee7c82da8
|
1112 1113 1114 |
unlock_sig: spin_unlock_irq(&p->sighand->siglock); if (!exit_code) |
1da177e4c
|
1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 |
return 0; /* * Now we are pretty sure this task is interesting. * Make sure it doesn't get reaped out from under us while we * give up the lock and then examine it below. We don't want to * keep holding onto the tasklist_lock while we call getrusage and * possibly take page faults for user memory. */ get_task_struct(p); |
6c5f3e7b4
|
1125 |
pid = task_pid_vnr(p); |
f470021ad
|
1126 |
why = ptrace ? CLD_TRAPPED : CLD_STOPPED; |
1da177e4c
|
1127 |
read_unlock(&tasklist_lock); |
1029a2b52
|
1128 |
sched_annotate_sleep(); |
e61a25022
|
1129 1130 |
if (wo->wo_rusage) getrusage(p, RUSAGE_BOTH, wo->wo_rusage); |
bb380ec33
|
1131 |
put_task_struct(p); |
1da177e4c
|
1132 |
|
bb380ec33
|
1133 1134 |
if (likely(!(wo->wo_flags & WNOWAIT))) wo->wo_stat = (exit_code << 8) | 0x7f; |
1da177e4c
|
1135 |
|
9e8ae01d1
|
1136 |
infop = wo->wo_info; |
67d7ddded
|
1137 1138 1139 1140 1141 1142 |
if (infop) { infop->cause = why; infop->status = exit_code; infop->pid = pid; infop->uid = uid; } |
67d7ddded
|
1143 |
return pid; |
1da177e4c
|
1144 1145 1146 1147 1148 1149 1150 1151 |
} /* * Handle do_wait work for one task in a live, non-stopped state. * read_lock(&tasklist_lock) on entry. If we return zero, we still hold * the lock and this task is uninteresting. If we return nonzero, we have * released the lock and the system call should return. */ |
9e8ae01d1
|
1152 |
static int wait_task_continued(struct wait_opts *wo, struct task_struct *p) |
1da177e4c
|
1153 |
{ |
bb380ec33
|
1154 |
struct waitid_info *infop; |
1da177e4c
|
1155 1156 |
pid_t pid; uid_t uid; |
9e8ae01d1
|
1157 |
if (!unlikely(wo->wo_flags & WCONTINUED)) |
98abed020
|
1158 |
return 0; |
1da177e4c
|
1159 1160 1161 1162 1163 1164 1165 1166 1167 |
if (!(p->signal->flags & SIGNAL_STOP_CONTINUED)) return 0; spin_lock_irq(&p->sighand->siglock); /* Re-check with the lock held. */ if (!(p->signal->flags & SIGNAL_STOP_CONTINUED)) { spin_unlock_irq(&p->sighand->siglock); return 0; } |
9e8ae01d1
|
1168 |
if (!unlikely(wo->wo_flags & WNOWAIT)) |
1da177e4c
|
1169 |
p->signal->flags &= ~SIGNAL_STOP_CONTINUED; |
8ca937a66
|
1170 |
uid = from_kuid_munged(current_user_ns(), task_uid(p)); |
1da177e4c
|
1171 |
spin_unlock_irq(&p->sighand->siglock); |
6c5f3e7b4
|
1172 |
pid = task_pid_vnr(p); |
1da177e4c
|
1173 1174 |
get_task_struct(p); read_unlock(&tasklist_lock); |
1029a2b52
|
1175 |
sched_annotate_sleep(); |
e61a25022
|
1176 1177 |
if (wo->wo_rusage) getrusage(p, RUSAGE_BOTH, wo->wo_rusage); |
bb380ec33
|
1178 |
put_task_struct(p); |
1da177e4c
|
1179 |
|
bb380ec33
|
1180 1181 |
infop = wo->wo_info; if (!infop) { |
359566fae
|
1182 |
wo->wo_stat = 0xffff; |
1da177e4c
|
1183 |
} else { |
bb380ec33
|
1184 1185 1186 1187 |
infop->cause = CLD_CONTINUED; infop->pid = pid; infop->uid = uid; infop->status = SIGCONT; |
1da177e4c
|
1188 |
} |
bb380ec33
|
1189 |
return pid; |
1da177e4c
|
1190 |
} |
98abed020
|
1191 1192 1193 |
/* * Consider @p for a wait by @parent. * |
9e8ae01d1
|
1194 |
* -ECHILD should be in ->notask_error before the first call. |
98abed020
|
1195 1196 |
* Returns nonzero for a final return, when we have unlocked tasklist_lock. * Returns zero if the search for a child should continue; |
9e8ae01d1
|
1197 |
* then ->notask_error is 0 if @p is an eligible child, |
3a2f5a59a
|
1198 |
* or still -ECHILD. |
98abed020
|
1199 |
*/ |
b6e763f07
|
1200 1201 |
static int wait_consider_task(struct wait_opts *wo, int ptrace, struct task_struct *p) |
98abed020
|
1202 |
{ |
3245d6aca
|
1203 1204 1205 1206 1207 |
/* * We can race with wait_task_zombie() from another thread. * Ensure that EXIT_ZOMBIE -> EXIT_DEAD/EXIT_TRACE transition * can't confuse the checks below. */ |
6aa7de059
|
1208 |
int exit_state = READ_ONCE(p->exit_state); |
b3ab03160
|
1209 |
int ret; |
3245d6aca
|
1210 |
if (unlikely(exit_state == EXIT_DEAD)) |
b3ab03160
|
1211 |
return 0; |
bf959931d
|
1212 |
ret = eligible_child(wo, ptrace, p); |
14dd0b814
|
1213 |
if (!ret) |
98abed020
|
1214 |
return ret; |
3245d6aca
|
1215 |
if (unlikely(exit_state == EXIT_TRACE)) { |
50b8d2574
|
1216 |
/* |
abd50b39e
|
1217 1218 |
* ptrace == 0 means we are the natural parent. In this case * we should clear notask_error, debugger will notify us. |
50b8d2574
|
1219 |
*/ |
abd50b39e
|
1220 |
if (likely(!ptrace)) |
50b8d2574
|
1221 |
wo->notask_error = 0; |
823b018e5
|
1222 |
return 0; |
50b8d2574
|
1223 |
} |
823b018e5
|
1224 |
|
377d75daf
|
1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 |
if (likely(!ptrace) && unlikely(p->ptrace)) { /* * If it is traced by its real parent's group, just pretend * the caller is ptrace_do_wait() and reap this child if it * is zombie. * * This also hides group stop state from real parent; otherwise * a single stop can be reported twice as group and ptrace stop. * If a ptracer wants to distinguish these two events for its * own children it should create a separate process which takes * the role of real parent. */ if (!ptrace_reparented(p)) ptrace = 1; } |
45cb24a1d
|
1240 |
/* slay zombie? */ |
3245d6aca
|
1241 |
if (exit_state == EXIT_ZOMBIE) { |
9b84cca25
|
1242 |
/* we don't reap group leaders with subthreads */ |
7c733eb3e
|
1243 1244 1245 1246 1247 1248 1249 1250 1251 |
if (!delay_group_leader(p)) { /* * A zombie ptracee is only visible to its ptracer. * Notification and reaping will be cascaded to the * real parent when the ptracer detaches. */ if (unlikely(ptrace) || likely(!p->ptrace)) return wait_task_zombie(wo, p); } |
98abed020
|
1252 |
|
f470021ad
|
1253 |
/* |
9b84cca25
|
1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 |
* Allow access to stopped/continued state via zombie by * falling through. Clearing of notask_error is complex. * * When !@ptrace: * * If WEXITED is set, notask_error should naturally be * cleared. If not, subset of WSTOPPED|WCONTINUED is set, * so, if there are live subthreads, there are events to * wait for. If all subthreads are dead, it's still safe * to clear - this function will be called again in finite * amount time once all the subthreads are released and * will then return without clearing. * * When @ptrace: * * Stopped state is per-task and thus can't change once the * target task dies. Only continued and exited can happen. * Clear notask_error if WCONTINUED | WEXITED. */ if (likely(!ptrace) || (wo->wo_flags & (WCONTINUED | WEXITED))) wo->notask_error = 0; } else { /* * @p is alive and it's gonna stop, continue or exit, so * there always is something to wait for. |
f470021ad
|
1279 |
*/ |
9e8ae01d1
|
1280 |
wo->notask_error = 0; |
f470021ad
|
1281 |
} |
98abed020
|
1282 |
/* |
45cb24a1d
|
1283 1284 |
* Wait for stopped. Depending on @ptrace, different stopped state * is used and the two don't interact with each other. |
98abed020
|
1285 |
*/ |
19e274630
|
1286 1287 1288 |
ret = wait_task_stopped(wo, ptrace, p); if (ret) return ret; |
98abed020
|
1289 1290 |
/* |
45cb24a1d
|
1291 1292 1293 |
* Wait for continued. There's only one continued state and the * ptracer can consume it which can confuse the real parent. Don't * use WCONTINUED from ptracer. You don't need or want it. |
98abed020
|
1294 |
*/ |
9e8ae01d1
|
1295 |
return wait_task_continued(wo, p); |
98abed020
|
1296 1297 1298 1299 1300 |
} /* * Do the work of do_wait() for one thread in the group, @tsk. * |
9e8ae01d1
|
1301 |
* -ECHILD should be in ->notask_error before the first call. |
98abed020
|
1302 1303 |
* Returns nonzero for a final return, when we have unlocked tasklist_lock. * Returns zero if the search for a child should continue; then |
9e8ae01d1
|
1304 |
* ->notask_error is 0 if there were any eligible children, |
3a2f5a59a
|
1305 |
* or still -ECHILD. |
98abed020
|
1306 |
*/ |
9e8ae01d1
|
1307 |
static int do_wait_thread(struct wait_opts *wo, struct task_struct *tsk) |
98abed020
|
1308 1309 1310 1311 |
{ struct task_struct *p; list_for_each_entry(p, &tsk->children, sibling) { |
9cd80bbb0
|
1312 |
int ret = wait_consider_task(wo, 0, p); |
a0be55dee
|
1313 |
|
9cd80bbb0
|
1314 1315 |
if (ret) return ret; |
98abed020
|
1316 1317 1318 1319 |
} return 0; } |
9e8ae01d1
|
1320 |
static int ptrace_do_wait(struct wait_opts *wo, struct task_struct *tsk) |
98abed020
|
1321 1322 |
{ struct task_struct *p; |
f470021ad
|
1323 |
list_for_each_entry(p, &tsk->ptraced, ptrace_entry) { |
b6e763f07
|
1324 |
int ret = wait_consider_task(wo, 1, p); |
a0be55dee
|
1325 |
|
f470021ad
|
1326 |
if (ret) |
98abed020
|
1327 |
return ret; |
98abed020
|
1328 1329 1330 1331 |
} return 0; } |
ac6424b98
|
1332 |
static int child_wait_callback(wait_queue_entry_t *wait, unsigned mode, |
0b7570e77
|
1333 1334 1335 1336 1337 |
int sync, void *key) { struct wait_opts *wo = container_of(wait, struct wait_opts, child_wait); struct task_struct *p = key; |
5c01ba49e
|
1338 |
if (!eligible_pid(wo, p)) |
0b7570e77
|
1339 |
return 0; |
b4fe51823
|
1340 1341 |
if ((wo->wo_flags & __WNOTHREAD) && wait->private != p->parent) return 0; |
0b7570e77
|
1342 1343 |
return default_wake_function(wait, mode, sync, key); } |
a7f0765ed
|
1344 1345 |
void __wake_up_parent(struct task_struct *p, struct task_struct *parent) { |
0b7570e77
|
1346 1347 |
__wake_up_sync_key(&parent->signal->wait_chldexit, TASK_INTERRUPTIBLE, 1, p); |
a7f0765ed
|
1348 |
} |
9e8ae01d1
|
1349 |
static long do_wait(struct wait_opts *wo) |
1da177e4c
|
1350 |
{ |
1da177e4c
|
1351 |
struct task_struct *tsk; |
98abed020
|
1352 |
int retval; |
1da177e4c
|
1353 |
|
9e8ae01d1
|
1354 |
trace_sched_process_wait(wo->wo_pid); |
0a16b6075
|
1355 |
|
0b7570e77
|
1356 1357 1358 |
init_waitqueue_func_entry(&wo->child_wait, child_wait_callback); wo->child_wait.private = current; add_wait_queue(¤t->signal->wait_chldexit, &wo->child_wait); |
1da177e4c
|
1359 |
repeat: |
98abed020
|
1360 |
/* |
3da56d166
|
1361 |
* If there is nothing that can match our criteria, just get out. |
9e8ae01d1
|
1362 1363 1364 |
* We will clear ->notask_error to zero if we see any child that * might later match our criteria, even if we are not able to reap * it yet. |
98abed020
|
1365 |
*/ |
64a16caf5
|
1366 |
wo->notask_error = -ECHILD; |
9e8ae01d1
|
1367 1368 |
if ((wo->wo_type < PIDTYPE_MAX) && (!wo->wo_pid || hlist_empty(&wo->wo_pid->tasks[wo->wo_type]))) |
64a16caf5
|
1369 |
goto notask; |
161550d74
|
1370 |
|
f95d39d10
|
1371 |
set_current_state(TASK_INTERRUPTIBLE); |
1da177e4c
|
1372 1373 1374 |
read_lock(&tasklist_lock); tsk = current; do { |
64a16caf5
|
1375 1376 1377 |
retval = do_wait_thread(wo, tsk); if (retval) goto end; |
9e8ae01d1
|
1378 |
|
64a16caf5
|
1379 1380 |
retval = ptrace_do_wait(wo, tsk); if (retval) |
98abed020
|
1381 |
goto end; |
98abed020
|
1382 |
|
9e8ae01d1
|
1383 |
if (wo->wo_flags & __WNOTHREAD) |
1da177e4c
|
1384 |
break; |
a3f6dfb72
|
1385 |
} while_each_thread(current, tsk); |
1da177e4c
|
1386 |
read_unlock(&tasklist_lock); |
f2cc3eb13
|
1387 |
|
64a16caf5
|
1388 |
notask: |
9e8ae01d1
|
1389 1390 |
retval = wo->notask_error; if (!retval && !(wo->wo_flags & WNOHANG)) { |
1da177e4c
|
1391 |
retval = -ERESTARTSYS; |
98abed020
|
1392 1393 1394 1395 |
if (!signal_pending(current)) { schedule(); goto repeat; } |
1da177e4c
|
1396 |
} |
1da177e4c
|
1397 |
end: |
f95d39d10
|
1398 |
__set_current_state(TASK_RUNNING); |
0b7570e77
|
1399 |
remove_wait_queue(¤t->signal->wait_chldexit, &wo->child_wait); |
1da177e4c
|
1400 1401 |
return retval; } |
3695eae5f
|
1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 |
static struct pid *pidfd_get_pid(unsigned int fd) { struct fd f; struct pid *pid; f = fdget(fd); if (!f.file) return ERR_PTR(-EBADF); pid = pidfd_pid(f.file); if (!IS_ERR(pid)) get_pid(pid); fdput(f); return pid; } |
67d7ddded
|
1418 |
static long kernel_waitid(int which, pid_t upid, struct waitid_info *infop, |
ce72a16fa
|
1419 |
int options, struct rusage *ru) |
1da177e4c
|
1420 |
{ |
9e8ae01d1
|
1421 |
struct wait_opts wo; |
161550d74
|
1422 1423 |
struct pid *pid = NULL; enum pid_type type; |
1da177e4c
|
1424 |
long ret; |
91c4e8ea8
|
1425 1426 |
if (options & ~(WNOHANG|WNOWAIT|WEXITED|WSTOPPED|WCONTINUED| __WNOTHREAD|__WCLONE|__WALL)) |
1da177e4c
|
1427 1428 1429 1430 1431 1432 |
return -EINVAL; if (!(options & (WEXITED|WSTOPPED|WCONTINUED))) return -EINVAL; switch (which) { case P_ALL: |
161550d74
|
1433 |
type = PIDTYPE_MAX; |
1da177e4c
|
1434 1435 |
break; case P_PID: |
161550d74
|
1436 1437 |
type = PIDTYPE_PID; if (upid <= 0) |
1da177e4c
|
1438 |
return -EINVAL; |
3695eae5f
|
1439 1440 |
pid = find_get_pid(upid); |
1da177e4c
|
1441 1442 |
break; case P_PGID: |
161550d74
|
1443 |
type = PIDTYPE_PGID; |
821cc7b0b
|
1444 |
if (upid < 0) |
1da177e4c
|
1445 |
return -EINVAL; |
3695eae5f
|
1446 |
|
821cc7b0b
|
1447 1448 1449 1450 |
if (upid) pid = find_get_pid(upid); else pid = get_task_pid(current, PIDTYPE_PGID); |
3695eae5f
|
1451 1452 1453 1454 |
break; case P_PIDFD: type = PIDTYPE_PID; if (upid < 0) |
1da177e4c
|
1455 |
return -EINVAL; |
3695eae5f
|
1456 1457 1458 1459 |
pid = pidfd_get_pid(upid); if (IS_ERR(pid)) return PTR_ERR(pid); |
1da177e4c
|
1460 1461 1462 1463 |
break; default: return -EINVAL; } |
9e8ae01d1
|
1464 1465 1466 1467 |
wo.wo_type = type; wo.wo_pid = pid; wo.wo_flags = options; wo.wo_info = infop; |
9e8ae01d1
|
1468 1469 |
wo.wo_rusage = ru; ret = do_wait(&wo); |
dfe16dfa4
|
1470 |
|
161550d74
|
1471 |
put_pid(pid); |
1da177e4c
|
1472 1473 |
return ret; } |
ce72a16fa
|
1474 1475 1476 1477 |
SYSCALL_DEFINE5(waitid, int, which, pid_t, upid, struct siginfo __user *, infop, int, options, struct rusage __user *, ru) { struct rusage r; |
67d7ddded
|
1478 1479 |
struct waitid_info info = {.status = 0}; long err = kernel_waitid(which, upid, &info, options, ru ? &r : NULL); |
634a81609
|
1480 |
int signo = 0; |
6c85501f2
|
1481 |
|
634a81609
|
1482 1483 1484 |
if (err > 0) { signo = SIGCHLD; err = 0; |
ce72a16fa
|
1485 1486 1487 |
if (ru && copy_to_user(ru, &r, sizeof(struct rusage))) return -EFAULT; } |
67d7ddded
|
1488 1489 |
if (!infop) return err; |
594cc251f
|
1490 |
if (!user_access_begin(infop, sizeof(*infop))) |
1c9fec470
|
1491 |
return -EFAULT; |
96ca579a1
|
1492 |
|
634a81609
|
1493 |
unsafe_put_user(signo, &infop->si_signo, Efault); |
4c48abe91
|
1494 |
unsafe_put_user(0, &infop->si_errno, Efault); |
cc731525f
|
1495 |
unsafe_put_user(info.cause, &infop->si_code, Efault); |
4c48abe91
|
1496 1497 1498 1499 |
unsafe_put_user(info.pid, &infop->si_pid, Efault); unsafe_put_user(info.uid, &infop->si_uid, Efault); unsafe_put_user(info.status, &infop->si_status, Efault); user_access_end(); |
ce72a16fa
|
1500 |
return err; |
4c48abe91
|
1501 1502 1503 |
Efault: user_access_end(); return -EFAULT; |
ce72a16fa
|
1504 |
} |
92ebce5ac
|
1505 1506 |
long kernel_wait4(pid_t upid, int __user *stat_addr, int options, struct rusage *ru) |
1da177e4c
|
1507 |
{ |
9e8ae01d1
|
1508 |
struct wait_opts wo; |
161550d74
|
1509 1510 |
struct pid *pid = NULL; enum pid_type type; |
1da177e4c
|
1511 1512 1513 1514 1515 |
long ret; if (options & ~(WNOHANG|WUNTRACED|WCONTINUED| __WNOTHREAD|__WCLONE|__WALL)) return -EINVAL; |
161550d74
|
1516 |
|
dd83c161f
|
1517 1518 1519 |
/* -INT_MIN is not defined */ if (upid == INT_MIN) return -ESRCH; |
161550d74
|
1520 1521 1522 1523 1524 1525 1526 |
if (upid == -1) type = PIDTYPE_MAX; else if (upid < 0) { type = PIDTYPE_PGID; pid = find_get_pid(-upid); } else if (upid == 0) { type = PIDTYPE_PGID; |
2ae448efc
|
1527 |
pid = get_task_pid(current, PIDTYPE_PGID); |
161550d74
|
1528 1529 1530 1531 |
} else /* upid > 0 */ { type = PIDTYPE_PID; pid = find_get_pid(upid); } |
9e8ae01d1
|
1532 1533 1534 1535 |
wo.wo_type = type; wo.wo_pid = pid; wo.wo_flags = options | WEXITED; wo.wo_info = NULL; |
359566fae
|
1536 |
wo.wo_stat = 0; |
9e8ae01d1
|
1537 1538 |
wo.wo_rusage = ru; ret = do_wait(&wo); |
161550d74
|
1539 |
put_pid(pid); |
359566fae
|
1540 1541 |
if (ret > 0 && stat_addr && put_user(wo.wo_stat, stat_addr)) ret = -EFAULT; |
1da177e4c
|
1542 |
|
1da177e4c
|
1543 1544 |
return ret; } |
ce72a16fa
|
1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 |
SYSCALL_DEFINE4(wait4, pid_t, upid, int __user *, stat_addr, int, options, struct rusage __user *, ru) { struct rusage r; long err = kernel_wait4(upid, stat_addr, options, ru ? &r : NULL); if (err > 0) { if (ru && copy_to_user(ru, &r, sizeof(struct rusage))) return -EFAULT; } return err; } |
1da177e4c
|
1557 1558 1559 1560 1561 1562 |
#ifdef __ARCH_WANT_SYS_WAITPID /* * sys_waitpid() remains for compatibility. waitpid() should be * implemented by calling sys_wait4() from libc.a. */ |
17da2bd90
|
1563 |
SYSCALL_DEFINE3(waitpid, pid_t, pid, int __user *, stat_addr, int, options) |
1da177e4c
|
1564 |
{ |
d300b6108
|
1565 |
return kernel_wait4(pid, stat_addr, options, NULL); |
1da177e4c
|
1566 1567 1568 |
} #endif |
7e95a2259
|
1569 1570 1571 1572 1573 1574 1575 1576 |
#ifdef CONFIG_COMPAT COMPAT_SYSCALL_DEFINE4(wait4, compat_pid_t, pid, compat_uint_t __user *, stat_addr, int, options, struct compat_rusage __user *, ru) { |
ce72a16fa
|
1577 1578 1579 1580 1581 |
struct rusage r; long err = kernel_wait4(pid, stat_addr, options, ru ? &r : NULL); if (err > 0) { if (ru && put_compat_rusage(&r, ru)) return -EFAULT; |
7e95a2259
|
1582 |
} |
ce72a16fa
|
1583 |
return err; |
7e95a2259
|
1584 1585 1586 1587 1588 1589 1590 |
} COMPAT_SYSCALL_DEFINE5(waitid, int, which, compat_pid_t, pid, struct compat_siginfo __user *, infop, int, options, struct compat_rusage __user *, uru) { |
7e95a2259
|
1591 |
struct rusage ru; |
67d7ddded
|
1592 1593 |
struct waitid_info info = {.status = 0}; long err = kernel_waitid(which, pid, &info, options, uru ? &ru : NULL); |
634a81609
|
1594 1595 1596 1597 |
int signo = 0; if (err > 0) { signo = SIGCHLD; err = 0; |
6c85501f2
|
1598 1599 1600 1601 1602 1603 1604 1605 1606 |
if (uru) { /* kernel_waitid() overwrites everything in ru */ if (COMPAT_USE_64BIT_TIME) err = copy_to_user(uru, &ru, sizeof(ru)); else err = put_compat_rusage(&ru, uru); if (err) return -EFAULT; } |
7e95a2259
|
1607 |
} |
4c48abe91
|
1608 1609 |
if (!infop) return err; |
594cc251f
|
1610 |
if (!user_access_begin(infop, sizeof(*infop))) |
1c9fec470
|
1611 |
return -EFAULT; |
96ca579a1
|
1612 |
|
634a81609
|
1613 |
unsafe_put_user(signo, &infop->si_signo, Efault); |
4c48abe91
|
1614 |
unsafe_put_user(0, &infop->si_errno, Efault); |
cc731525f
|
1615 |
unsafe_put_user(info.cause, &infop->si_code, Efault); |
4c48abe91
|
1616 1617 1618 1619 |
unsafe_put_user(info.pid, &infop->si_pid, Efault); unsafe_put_user(info.uid, &infop->si_uid, Efault); unsafe_put_user(info.status, &infop->si_status, Efault); user_access_end(); |
67d7ddded
|
1620 |
return err; |
4c48abe91
|
1621 1622 1623 |
Efault: user_access_end(); return -EFAULT; |
7e95a2259
|
1624 1625 |
} #endif |
7c2c11b20
|
1626 1627 1628 1629 1630 1631 1632 1633 |
__weak void abort(void) { BUG(); /* if that doesn't kill us, halt */ panic("Oops failed to kill thread"); } |
dc8635b78
|
1634 |
EXPORT_SYMBOL(abort); |