1
2
3
4
5
6
7#include <linux/mm.h>
8#include <linux/slab.h>
9#include <linux/interrupt.h>
10#include <linux/module.h>
11#include <linux/capability.h>
12#include <linux/completion.h>
13#include <linux/personality.h>
14#include <linux/tty.h>
15#include <linux/iocontext.h>
16#include <linux/key.h>
17#include <linux/security.h>
18#include <linux/cpu.h>
19#include <linux/acct.h>
20#include <linux/tsacct_kern.h>
21#include <linux/file.h>
22#include <linux/fdtable.h>
23#include <linux/binfmts.h>
24#include <linux/nsproxy.h>
25#include <linux/pid_namespace.h>
26#include <linux/ptrace.h>
27#include <linux/profile.h>
28#include <linux/mount.h>
29#include <linux/proc_fs.h>
30#include <linux/kthread.h>
31#include <linux/mempolicy.h>
32#include <linux/taskstats_kern.h>
33#include <linux/delayacct.h>
34#include <linux/freezer.h>
35#include <linux/cgroup.h>
36#include <linux/syscalls.h>
37#include <linux/signal.h>
38#include <linux/posix-timers.h>
39#include <linux/cn_proc.h>
40#include <linux/mutex.h>
41#include <linux/futex.h>
42#include <linux/pipe_fs_i.h>
43#include <linux/audit.h>
44#include <linux/resource.h>
45#include <linux/blkdev.h>
46#include <linux/task_io_accounting_ops.h>
47#include <linux/tracehook.h>
48#include <linux/fs_struct.h>
49#include <linux/init_task.h>
50#include <linux/perf_event.h>
51#include <trace/events/sched.h>
52
53#include <asm/uaccess.h>
54#include <asm/unistd.h>
55#include <asm/pgtable.h>
56#include <asm/mmu_context.h>
57#include "cred-internals.h"
58
59static void exit_mm(struct task_struct * tsk);
60
61static void __unhash_process(struct task_struct *p)
62{
63 nr_threads--;
64 detach_pid(p, PIDTYPE_PID);
65 if (thread_group_leader(p)) {
66 detach_pid(p, PIDTYPE_PGID);
67 detach_pid(p, PIDTYPE_SID);
68
69 list_del_rcu(&p->tasks);
70 __get_cpu_var(process_counts)--;
71 }
72 list_del_rcu(&p->thread_group);
73 list_del_init(&p->sibling);
74}
75
76
77
78
79static void __exit_signal(struct task_struct *tsk)
80{
81 struct signal_struct *sig = tsk->signal;
82 struct sighand_struct *sighand;
83
84 BUG_ON(!sig);
85 BUG_ON(!atomic_read(&sig->count));
86
87 sighand = rcu_dereference(tsk->sighand);
88 spin_lock(&sighand->siglock);
89
90 posix_cpu_timers_exit(tsk);
91 if (atomic_dec_and_test(&sig->count))
92 posix_cpu_timers_exit_group(tsk);
93 else {
94
95
96
97
98 if (sig->group_exit_task && atomic_read(&sig->count) == sig->notify_count)
99 wake_up_process(sig->group_exit_task);
100
101 if (tsk == sig->curr_target)
102 sig->curr_target = next_thread(tsk);
103
104
105
106
107
108
109
110
111
112
113 sig->utime = cputime_add(sig->utime, task_utime(tsk));
114 sig->stime = cputime_add(sig->stime, task_stime(tsk));
115 sig->gtime = cputime_add(sig->gtime, task_gtime(tsk));
116 sig->min_flt += tsk->min_flt;
117 sig->maj_flt += tsk->maj_flt;
118 sig->nvcsw += tsk->nvcsw;
119 sig->nivcsw += tsk->nivcsw;
120 sig->inblock += task_io_get_inblock(tsk);
121 sig->oublock += task_io_get_oublock(tsk);
122 task_io_accounting_add(&sig->ioac, &tsk->ioac);
123 sig->sum_sched_runtime += tsk->se.sum_exec_runtime;
124 sig = NULL;
125 }
126
127 __unhash_process(tsk);
128
129
130
131
132
133 flush_sigqueue(&tsk->pending);
134
135 tsk->signal = NULL;
136 tsk->sighand = NULL;
137 spin_unlock(&sighand->siglock);
138
139 __cleanup_sighand(sighand);
140 clear_tsk_thread_flag(tsk,TIF_SIGPENDING);
141 if (sig) {
142 flush_sigqueue(&sig->shared_pending);
143 taskstats_tgid_free(sig);
144
145
146
147
148 task_rq_unlock_wait(tsk);
149 __cleanup_signal(sig);
150 }
151}
152
153static void delayed_put_task_struct(struct rcu_head *rhp)
154{
155 struct task_struct *tsk = container_of(rhp, struct task_struct, rcu);
156
157#ifdef CONFIG_PERF_EVENTS
158 WARN_ON_ONCE(tsk->perf_event_ctxp);
159#endif
160 trace_sched_process_free(tsk);
161 put_task_struct(tsk);
162}
163
164
165void release_task(struct task_struct * p)
166{
167 struct task_struct *leader;
168 int zap_leader;
169repeat:
170 tracehook_prepare_release_task(p);
171
172
173 atomic_dec(&__task_cred(p)->user->processes);
174
175 proc_flush_task(p);
176
177 write_lock_irq(&tasklist_lock);
178 tracehook_finish_release_task(p);
179 __exit_signal(p);
180
181
182
183
184
185
186 zap_leader = 0;
187 leader = p->group_leader;
188 if (leader != p && thread_group_empty(leader) && leader->exit_state == EXIT_ZOMBIE) {
189 BUG_ON(task_detached(leader));
190 do_notify_parent(leader, leader->exit_signal);
191
192
193
194
195
196
197
198
199 zap_leader = task_detached(leader);
200
201
202
203
204
205 if (zap_leader)
206 leader->exit_state = EXIT_DEAD;
207 }
208
209 write_unlock_irq(&tasklist_lock);
210 release_thread(p);
211 call_rcu(&p->rcu, delayed_put_task_struct);
212
213 p = leader;
214 if (unlikely(zap_leader))
215 goto repeat;
216}
217
218
219
220
221
222
223
224
225struct pid *session_of_pgrp(struct pid *pgrp)
226{
227 struct task_struct *p;
228 struct pid *sid = NULL;
229
230 p = pid_task(pgrp, PIDTYPE_PGID);
231 if (p == NULL)
232 p = pid_task(pgrp, PIDTYPE_PID);
233 if (p != NULL)
234 sid = task_session(p);
235
236 return sid;
237}
238
239
240
241
242
243
244
245
246
247static int will_become_orphaned_pgrp(struct pid *pgrp, struct task_struct *ignored_task)
248{
249 struct task_struct *p;
250
251 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
252 if ((p == ignored_task) ||
253 (p->exit_state && thread_group_empty(p)) ||
254 is_global_init(p->real_parent))
255 continue;
256
257 if (task_pgrp(p->real_parent) != pgrp &&
258 task_session(p->real_parent) == task_session(p))
259 return 0;
260 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
261
262 return 1;
263}
264
265int is_current_pgrp_orphaned(void)
266{
267 int retval;
268
269 read_lock(&tasklist_lock);
270 retval = will_become_orphaned_pgrp(task_pgrp(current), NULL);
271 read_unlock(&tasklist_lock);
272
273 return retval;
274}
275
276static int has_stopped_jobs(struct pid *pgrp)
277{
278 int retval = 0;
279 struct task_struct *p;
280
281 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
282 if (!task_is_stopped(p))
283 continue;
284 retval = 1;
285 break;
286 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
287 return retval;
288}
289
290
291
292
293
294
295static void
296kill_orphaned_pgrp(struct task_struct *tsk, struct task_struct *parent)
297{
298 struct pid *pgrp = task_pgrp(tsk);
299 struct task_struct *ignored_task = tsk;
300
301 if (!parent)
302
303
304
305 parent = tsk->real_parent;
306 else
307
308
309
310 ignored_task = NULL;
311
312 if (task_pgrp(parent) != pgrp &&
313 task_session(parent) == task_session(tsk) &&
314 will_become_orphaned_pgrp(pgrp, ignored_task) &&
315 has_stopped_jobs(pgrp)) {
316 __kill_pgrp_info(SIGHUP, SEND_SIG_PRIV, pgrp);
317 __kill_pgrp_info(SIGCONT, SEND_SIG_PRIV, pgrp);
318 }
319}
320
321
322
323
324
325
326
327
328
329
330
331
332
333static void reparent_to_kthreadd(void)
334{
335 write_lock_irq(&tasklist_lock);
336
337 ptrace_unlink(current);
338
339 current->real_parent = current->parent = kthreadd_task;
340 list_move_tail(¤t->sibling, ¤t->real_parent->children);
341
342
343 current->exit_signal = SIGCHLD;
344
345 if (task_nice(current) < 0)
346 set_user_nice(current, 0);
347
348
349
350 memcpy(current->signal->rlim, init_task.signal->rlim,
351 sizeof(current->signal->rlim));
352
353 atomic_inc(&init_cred.usage);
354 commit_creds(&init_cred);
355 write_unlock_irq(&tasklist_lock);
356}
357
358void __set_special_pids(struct pid *pid)
359{
360 struct task_struct *curr = current->group_leader;
361
362 if (task_session(curr) != pid)
363 change_pid(curr, PIDTYPE_SID, pid);
364
365 if (task_pgrp(curr) != pid)
366 change_pid(curr, PIDTYPE_PGID, pid);
367}
368
369static void set_special_pids(struct pid *pid)
370{
371 write_lock_irq(&tasklist_lock);
372 __set_special_pids(pid);
373 write_unlock_irq(&tasklist_lock);
374}
375
376
377
378
379
380int allow_signal(int sig)
381{
382 if (!valid_signal(sig) || sig < 1)
383 return -EINVAL;
384
385 spin_lock_irq(¤t->sighand->siglock);
386
387 sigdelset(¤t->blocked, sig);
388
389
390
391
392
393 current->sighand->action[(sig)-1].sa.sa_handler = (void __user *)2;
394 recalc_sigpending();
395 spin_unlock_irq(¤t->sighand->siglock);
396 return 0;
397}
398
399EXPORT_SYMBOL(allow_signal);
400
401int disallow_signal(int sig)
402{
403 if (!valid_signal(sig) || sig < 1)
404 return -EINVAL;
405
406 spin_lock_irq(¤t->sighand->siglock);
407 current->sighand->action[(sig)-1].sa.sa_handler = SIG_IGN;
408 recalc_sigpending();
409 spin_unlock_irq(¤t->sighand->siglock);
410 return 0;
411}
412
413EXPORT_SYMBOL(disallow_signal);
414
415
416
417
418
419
420void daemonize(const char *name, ...)
421{
422 va_list args;
423 sigset_t blocked;
424
425 va_start(args, name);
426 vsnprintf(current->comm, sizeof(current->comm), name, args);
427 va_end(args);
428
429
430
431
432
433
434 exit_mm(current);
435
436
437
438
439 current->flags |= (PF_NOFREEZE | PF_KTHREAD);
440
441 if (current->nsproxy != &init_nsproxy) {
442 get_nsproxy(&init_nsproxy);
443 switch_task_namespaces(current, &init_nsproxy);
444 }
445 set_special_pids(&init_struct_pid);
446 proc_clear_tty(current);
447
448
449 sigfillset(&blocked);
450 sigprocmask(SIG_BLOCK, &blocked, NULL);
451 flush_signals(current);
452
453
454
455 daemonize_fs_struct();
456 exit_files(current);
457 current->files = init_task.files;
458 atomic_inc(¤t->files->count);
459
460 reparent_to_kthreadd();
461}
462
463EXPORT_SYMBOL(daemonize);
464
465static void close_files(struct files_struct * files)
466{
467 int i, j;
468 struct fdtable *fdt;
469
470 j = 0;
471
472
473
474
475
476
477 fdt = files_fdtable(files);
478 for (;;) {
479 unsigned long set;
480 i = j * __NFDBITS;
481 if (i >= fdt->max_fds)
482 break;
483 set = fdt->open_fds->fds_bits[j++];
484 while (set) {
485 if (set & 1) {
486 struct file * file = xchg(&fdt->fd[i], NULL);
487 if (file) {
488 filp_close(file, files);
489 cond_resched();
490 }
491 }
492 i++;
493 set >>= 1;
494 }
495 }
496}
497
498struct files_struct *get_files_struct(struct task_struct *task)
499{
500 struct files_struct *files;
501
502 task_lock(task);
503 files = task->files;
504 if (files)
505 atomic_inc(&files->count);
506 task_unlock(task);
507
508 return files;
509}
510
511void put_files_struct(struct files_struct *files)
512{
513 struct fdtable *fdt;
514
515 if (atomic_dec_and_test(&files->count)) {
516 close_files(files);
517
518
519
520
521
522
523 fdt = files_fdtable(files);
524 if (fdt != &files->fdtab)
525 kmem_cache_free(files_cachep, files);
526 free_fdtable(fdt);
527 }
528}
529
530void reset_files_struct(struct files_struct *files)
531{
532 struct task_struct *tsk = current;
533 struct files_struct *old;
534
535 old = tsk->files;
536 task_lock(tsk);
537 tsk->files = files;
538 task_unlock(tsk);
539 put_files_struct(old);
540}
541
542void exit_files(struct task_struct *tsk)
543{
544 struct files_struct * files = tsk->files;
545
546 if (files) {
547 task_lock(tsk);
548 tsk->files = NULL;
549 task_unlock(tsk);
550 put_files_struct(files);
551 }
552}
553
554#ifdef CONFIG_MM_OWNER
555
556
557
558static inline int
559mm_need_new_owner(struct mm_struct *mm, struct task_struct *p)
560{
561
562
563
564
565 if (atomic_read(&mm->mm_users) <= 1)
566 return 0;
567 if (mm->owner != p)
568 return 0;
569 return 1;
570}
571
572void mm_update_next_owner(struct mm_struct *mm)
573{
574 struct task_struct *c, *g, *p = current;
575
576retry:
577 if (!mm_need_new_owner(mm, p))
578 return;
579
580 read_lock(&tasklist_lock);
581
582
583
584 list_for_each_entry(c, &p->children, sibling) {
585 if (c->mm == mm)
586 goto assign_new_owner;
587 }
588
589
590
591
592 list_for_each_entry(c, &p->real_parent->children, sibling) {
593 if (c->mm == mm)
594 goto assign_new_owner;
595 }
596
597
598
599
600
601 do_each_thread(g, c) {
602 if (c->mm == mm)
603 goto assign_new_owner;
604 } while_each_thread(g, c);
605
606 read_unlock(&tasklist_lock);
607
608
609
610
611
612 mm->owner = NULL;
613 return;
614
615assign_new_owner:
616 BUG_ON(c == p);
617 get_task_struct(c);
618
619
620
621
622 task_lock(c);
623
624
625
626
627 read_unlock(&tasklist_lock);
628 if (c->mm != mm) {
629 task_unlock(c);
630 put_task_struct(c);
631 goto retry;
632 }
633 mm->owner = c;
634 task_unlock(c);
635 put_task_struct(c);
636}
637#endif
638
639
640
641
642
643static void exit_mm(struct task_struct * tsk)
644{
645 struct mm_struct *mm = tsk->mm;
646 struct core_state *core_state;
647
648 mm_release(tsk, mm);
649 if (!mm)
650 return;
651
652
653
654
655
656
657
658 down_read(&mm->mmap_sem);
659 core_state = mm->core_state;
660 if (core_state) {
661 struct core_thread self;
662 up_read(&mm->mmap_sem);
663
664 self.task = tsk;
665 self.next = xchg(&core_state->dumper.next, &self);
666
667
668
669
670 if (atomic_dec_and_test(&core_state->nr_threads))
671 complete(&core_state->startup);
672
673 for (;;) {
674 set_task_state(tsk, TASK_UNINTERRUPTIBLE);
675 if (!self.task)
676 break;
677 schedule();
678 }
679 __set_task_state(tsk, TASK_RUNNING);
680 down_read(&mm->mmap_sem);
681 }
682 atomic_inc(&mm->mm_count);
683 BUG_ON(mm != tsk->active_mm);
684
685 task_lock(tsk);
686 tsk->mm = NULL;
687 up_read(&mm->mmap_sem);
688 enter_lazy_tlb(mm, current);
689
690 clear_freeze_flag(tsk);
691 task_unlock(tsk);
692 mm_update_next_owner(mm);
693 mmput(mm);
694}
695
696
697
698
699
700
701
702
703static struct task_struct *find_new_reaper(struct task_struct *father)
704{
705 struct pid_namespace *pid_ns = task_active_pid_ns(father);
706 struct task_struct *thread;
707
708 thread = father;
709 while_each_thread(father, thread) {
710 if (thread->flags & PF_EXITING)
711 continue;
712 if (unlikely(pid_ns->child_reaper == father))
713 pid_ns->child_reaper = thread;
714 return thread;
715 }
716
717 if (unlikely(pid_ns->child_reaper == father)) {
718 write_unlock_irq(&tasklist_lock);
719 if (unlikely(pid_ns == &init_pid_ns))
720 panic("Attempted to kill init!");
721
722 zap_pid_ns_processes(pid_ns);
723 write_lock_irq(&tasklist_lock);
724
725
726
727
728
729 pid_ns->child_reaper = init_pid_ns.child_reaper;
730 }
731
732 return pid_ns->child_reaper;
733}
734
735
736
737
738static void reparent_thread(struct task_struct *father, struct task_struct *p,
739 struct list_head *dead)
740{
741 if (p->pdeath_signal)
742 group_send_sig_info(p->pdeath_signal, SEND_SIG_NOINFO, p);
743
744 list_move_tail(&p->sibling, &p->real_parent->children);
745
746 if (task_detached(p))
747 return;
748
749
750
751
752 if (same_thread_group(p->real_parent, father))
753 return;
754
755
756 p->exit_signal = SIGCHLD;
757
758
759 if (!task_ptrace(p) &&
760 p->exit_state == EXIT_ZOMBIE && thread_group_empty(p)) {
761 do_notify_parent(p, p->exit_signal);
762 if (task_detached(p)) {
763 p->exit_state = EXIT_DEAD;
764 list_move_tail(&p->sibling, dead);
765 }
766 }
767
768 kill_orphaned_pgrp(p, father);
769}
770
771static void forget_original_parent(struct task_struct *father)
772{
773 struct task_struct *p, *n, *reaper;
774 LIST_HEAD(dead_children);
775
776 exit_ptrace(father);
777
778 write_lock_irq(&tasklist_lock);
779 reaper = find_new_reaper(father);
780
781 list_for_each_entry_safe(p, n, &father->children, sibling) {
782 p->real_parent = reaper;
783 if (p->parent == father) {
784 BUG_ON(task_ptrace(p));
785 p->parent = p->real_parent;
786 }
787 reparent_thread(father, p, &dead_children);
788 }
789 write_unlock_irq(&tasklist_lock);
790
791 BUG_ON(!list_empty(&father->children));
792
793 list_for_each_entry_safe(p, n, &dead_children, sibling) {
794 list_del_init(&p->sibling);
795 release_task(p);
796 }
797}
798
799
800
801
802
803static void exit_notify(struct task_struct *tsk, int group_dead)
804{
805 int signal;
806 void *cookie;
807
808
809
810
811
812
813
814
815
816 forget_original_parent(tsk);
817 exit_task_namespaces(tsk);
818
819 write_lock_irq(&tasklist_lock);
820 if (group_dead)
821 kill_orphaned_pgrp(tsk->group_leader, NULL);
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837 if (tsk->exit_signal != SIGCHLD && !task_detached(tsk) &&
838 (tsk->parent_exec_id != tsk->real_parent->self_exec_id ||
839 tsk->self_exec_id != tsk->parent_exec_id))
840 tsk->exit_signal = SIGCHLD;
841
842 signal = tracehook_notify_death(tsk, &cookie, group_dead);
843 if (signal >= 0)
844 signal = do_notify_parent(tsk, signal);
845
846 tsk->exit_state = signal == DEATH_REAP ? EXIT_DEAD : EXIT_ZOMBIE;
847
848
849 if (thread_group_leader(tsk) &&
850 tsk->signal->group_exit_task &&
851 tsk->signal->notify_count < 0)
852 wake_up_process(tsk->signal->group_exit_task);
853
854 write_unlock_irq(&tasklist_lock);
855
856 tracehook_report_death(tsk, signal, cookie, group_dead);
857
858
859 if (signal == DEATH_REAP)
860 release_task(tsk);
861}
862
863#ifdef CONFIG_DEBUG_STACK_USAGE
864static void check_stack_usage(void)
865{
866 static DEFINE_SPINLOCK(low_water_lock);
867 static int lowest_to_date = THREAD_SIZE;
868 unsigned long free;
869
870 free = stack_not_used(current);
871
872 if (free >= lowest_to_date)
873 return;
874
875 spin_lock(&low_water_lock);
876 if (free < lowest_to_date) {
877 printk(KERN_WARNING "%s used greatest stack depth: %lu bytes "
878 "left\n",
879 current->comm, free);
880 lowest_to_date = free;
881 }
882 spin_unlock(&low_water_lock);
883}
884#else
885static inline void check_stack_usage(void) {}
886#endif
887
888NORET_TYPE void do_exit(long code)
889{
890 struct task_struct *tsk = current;
891 int group_dead;
892
893 profile_task_exit(tsk);
894
895 WARN_ON(atomic_read(&tsk->fs_excl));
896
897 if (unlikely(in_interrupt()))
898 panic("Aiee, killing interrupt handler!");
899 if (unlikely(!tsk->pid))
900 panic("Attempted to kill the idle task!");
901
902 tracehook_report_exit(&code);
903
904 validate_creds_for_do_exit(tsk);
905
906
907
908
909
910 if (unlikely(tsk->flags & PF_EXITING)) {
911 printk(KERN_ALERT
912 "Fixing recursive fault but reboot is needed!\n");
913
914
915
916
917
918
919
920
921
922 tsk->flags |= PF_EXITPIDONE;
923 set_current_state(TASK_UNINTERRUPTIBLE);
924 schedule();
925 }
926
927 exit_irq_thread();
928
929 exit_signals(tsk);
930
931
932
933
934 smp_mb();
935 spin_unlock_wait(&tsk->pi_lock);
936
937 if (unlikely(in_atomic()))
938 printk(KERN_INFO "note: %s[%d] exited with preempt_count %d\n",
939 current->comm, task_pid_nr(current),
940 preempt_count());
941
942 acct_update_integrals(tsk);
943
944 group_dead = atomic_dec_and_test(&tsk->signal->live);
945 if (group_dead) {
946 hrtimer_cancel(&tsk->signal->real_timer);
947 exit_itimers(tsk->signal);
948 if (tsk->mm)
949 setmax_mm_hiwater_rss(&tsk->signal->maxrss, tsk->mm);
950 }
951 acct_collect(code, group_dead);
952 if (group_dead)
953 tty_audit_exit();
954 if (unlikely(tsk->audit_context))
955 audit_free(tsk);
956
957 tsk->exit_code = code;
958 taskstats_exit(tsk, group_dead);
959
960 exit_mm(tsk);
961
962 if (group_dead)
963 acct_process();
964 trace_sched_process_exit(tsk);
965
966 exit_sem(tsk);
967 exit_files(tsk);
968 exit_fs(tsk);
969 check_stack_usage();
970 exit_thread();
971 cgroup_exit(tsk, 1);
972
973 if (group_dead && tsk->signal->leader)
974 disassociate_ctty(1);
975
976 module_put(task_thread_info(tsk)->exec_domain->module);
977
978 proc_exit_connector(tsk);
979
980
981
982
983
984 perf_event_exit_task(tsk);
985
986 exit_notify(tsk, group_dead);
987#ifdef CONFIG_NUMA
988 mpol_put(tsk->mempolicy);
989 tsk->mempolicy = NULL;
990#endif
991#ifdef CONFIG_FUTEX
992 if (unlikely(current->pi_state_cache))
993 kfree(current->pi_state_cache);
994#endif
995
996
997
998 debug_check_no_locks_held(tsk);
999
1000
1001
1002
1003
1004 tsk->flags |= PF_EXITPIDONE;
1005
1006 if (tsk->io_context)
1007 exit_io_context();
1008
1009 if (tsk->splice_pipe)
1010 __free_pipe_info(tsk->splice_pipe);
1011
1012 validate_creds_for_do_exit(tsk);
1013
1014 preempt_disable();
1015 exit_rcu();
1016
1017 tsk->state = TASK_DEAD;
1018 schedule();
1019 BUG();
1020
1021 for (;;)
1022 cpu_relax();
1023}
1024
1025EXPORT_SYMBOL_GPL(do_exit);
1026
1027NORET_TYPE void complete_and_exit(struct completion *comp, long code)
1028{
1029 if (comp)
1030 complete(comp);
1031
1032 do_exit(code);
1033}
1034
1035EXPORT_SYMBOL(complete_and_exit);
1036
1037SYSCALL_DEFINE1(exit, int, error_code)
1038{
1039 do_exit((error_code&0xff)<<8);
1040}
1041
1042
1043
1044
1045
1046NORET_TYPE void
1047do_group_exit(int exit_code)
1048{
1049 struct signal_struct *sig = current->signal;
1050
1051 BUG_ON(exit_code & 0x80);
1052
1053 if (signal_group_exit(sig))
1054 exit_code = sig->group_exit_code;
1055 else if (!thread_group_empty(current)) {
1056 struct sighand_struct *const sighand = current->sighand;
1057 spin_lock_irq(&sighand->siglock);
1058 if (signal_group_exit(sig))
1059
1060 exit_code = sig->group_exit_code;
1061 else {
1062 sig->group_exit_code = exit_code;
1063 sig->flags = SIGNAL_GROUP_EXIT;
1064 zap_other_threads(current);
1065 }
1066 spin_unlock_irq(&sighand->siglock);
1067 }
1068
1069 do_exit(exit_code);
1070
1071}
1072
1073
1074
1075
1076
1077
1078SYSCALL_DEFINE1(exit_group, int, error_code)
1079{
1080 do_group_exit((error_code & 0xff) << 8);
1081
1082 return 0;
1083}
1084
1085struct wait_opts {
1086 enum pid_type wo_type;
1087 int wo_flags;
1088 struct pid *wo_pid;
1089
1090 struct siginfo __user *wo_info;
1091 int __user *wo_stat;
1092 struct rusage __user *wo_rusage;
1093
1094 wait_queue_t child_wait;
1095 int notask_error;
1096};
1097
1098static inline
1099struct pid *task_pid_type(struct task_struct *task, enum pid_type type)
1100{
1101 if (type != PIDTYPE_PID)
1102 task = task->group_leader;
1103 return task->pids[type].pid;
1104}
1105
1106static int eligible_pid(struct wait_opts *wo, struct task_struct *p)
1107{
1108 return wo->wo_type == PIDTYPE_MAX ||
1109 task_pid_type(p, wo->wo_type) == wo->wo_pid;
1110}
1111
1112static int eligible_child(struct wait_opts *wo, struct task_struct *p)
1113{
1114 if (!eligible_pid(wo, p))
1115 return 0;
1116
1117
1118
1119
1120
1121 if (((p->exit_signal != SIGCHLD) ^ !!(wo->wo_flags & __WCLONE))
1122 && !(wo->wo_flags & __WALL))
1123 return 0;
1124
1125 return 1;
1126}
1127
1128static int wait_noreap_copyout(struct wait_opts *wo, struct task_struct *p,
1129 pid_t pid, uid_t uid, int why, int status)
1130{
1131 struct siginfo __user *infop;
1132 int retval = wo->wo_rusage
1133 ? getrusage(p, RUSAGE_BOTH, wo->wo_rusage) : 0;
1134
1135 put_task_struct(p);
1136 infop = wo->wo_info;
1137 if (infop) {
1138 if (!retval)
1139 retval = put_user(SIGCHLD, &infop->si_signo);
1140 if (!retval)
1141 retval = put_user(0, &infop->si_errno);
1142 if (!retval)
1143 retval = put_user((short)why, &infop->si_code);
1144 if (!retval)
1145 retval = put_user(pid, &infop->si_pid);
1146 if (!retval)
1147 retval = put_user(uid, &infop->si_uid);
1148 if (!retval)
1149 retval = put_user(status, &infop->si_status);
1150 }
1151 if (!retval)
1152 retval = pid;
1153 return retval;
1154}
1155
1156
1157
1158
1159
1160
1161
1162static int wait_task_zombie(struct wait_opts *wo, struct task_struct *p)
1163{
1164 unsigned long state;
1165 int retval, status, traced;
1166 pid_t pid = task_pid_vnr(p);
1167 uid_t uid = __task_cred(p)->uid;
1168 struct siginfo __user *infop;
1169
1170 if (!likely(wo->wo_flags & WEXITED))
1171 return 0;
1172
1173 if (unlikely(wo->wo_flags & WNOWAIT)) {
1174 int exit_code = p->exit_code;
1175 int why, status;
1176
1177 get_task_struct(p);
1178 read_unlock(&tasklist_lock);
1179 if ((exit_code & 0x7f) == 0) {
1180 why = CLD_EXITED;
1181 status = exit_code >> 8;
1182 } else {
1183 why = (exit_code & 0x80) ? CLD_DUMPED : CLD_KILLED;
1184 status = exit_code & 0x7f;
1185 }
1186 return wait_noreap_copyout(wo, p, pid, uid, why, status);
1187 }
1188
1189
1190
1191
1192
1193 state = xchg(&p->exit_state, EXIT_DEAD);
1194 if (state != EXIT_ZOMBIE) {
1195 BUG_ON(state != EXIT_DEAD);
1196 return 0;
1197 }
1198
1199 traced = ptrace_reparented(p);
1200
1201
1202
1203
1204 if (likely(!traced) && likely(!task_detached(p))) {
1205 struct signal_struct *psig;
1206 struct signal_struct *sig;
1207 unsigned long maxrss;
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224 spin_lock_irq(&p->real_parent->sighand->siglock);
1225 psig = p->real_parent->signal;
1226 sig = p->signal;
1227 psig->cutime =
1228 cputime_add(psig->cutime,
1229 cputime_add(p->utime,
1230 cputime_add(sig->utime,
1231 sig->cutime)));
1232 psig->cstime =
1233 cputime_add(psig->cstime,
1234 cputime_add(p->stime,
1235 cputime_add(sig->stime,
1236 sig->cstime)));
1237 psig->cgtime =
1238 cputime_add(psig->cgtime,
1239 cputime_add(p->gtime,
1240 cputime_add(sig->gtime,
1241 sig->cgtime)));
1242 psig->cmin_flt +=
1243 p->min_flt + sig->min_flt + sig->cmin_flt;
1244 psig->cmaj_flt +=
1245 p->maj_flt + sig->maj_flt + sig->cmaj_flt;
1246 psig->cnvcsw +=
1247 p->nvcsw + sig->nvcsw + sig->cnvcsw;
1248 psig->cnivcsw +=
1249 p->nivcsw + sig->nivcsw + sig->cnivcsw;
1250 psig->cinblock +=
1251 task_io_get_inblock(p) +
1252 sig->inblock + sig->cinblock;
1253 psig->coublock +=
1254 task_io_get_oublock(p) +
1255 sig->oublock + sig->coublock;
1256 maxrss = max(sig->maxrss, sig->cmaxrss);
1257 if (psig->cmaxrss < maxrss)
1258 psig->cmaxrss = maxrss;
1259 task_io_accounting_add(&psig->ioac, &p->ioac);
1260 task_io_accounting_add(&psig->ioac, &sig->ioac);
1261 spin_unlock_irq(&p->real_parent->sighand->siglock);
1262 }
1263
1264
1265
1266
1267
1268 read_unlock(&tasklist_lock);
1269
1270 retval = wo->wo_rusage
1271 ? getrusage(p, RUSAGE_BOTH, wo->wo_rusage) : 0;
1272 status = (p->signal->flags & SIGNAL_GROUP_EXIT)
1273 ? p->signal->group_exit_code : p->exit_code;
1274 if (!retval && wo->wo_stat)
1275 retval = put_user(status, wo->wo_stat);
1276
1277 infop = wo->wo_info;
1278 if (!retval && infop)
1279 retval = put_user(SIGCHLD, &infop->si_signo);
1280 if (!retval && infop)
1281 retval = put_user(0, &infop->si_errno);
1282 if (!retval && infop) {
1283 int why;
1284
1285 if ((status & 0x7f) == 0) {
1286 why = CLD_EXITED;
1287 status >>= 8;
1288 } else {
1289 why = (status & 0x80) ? CLD_DUMPED : CLD_KILLED;
1290 status &= 0x7f;
1291 }
1292 retval = put_user((short)why, &infop->si_code);
1293 if (!retval)
1294 retval = put_user(status, &infop->si_status);
1295 }
1296 if (!retval && infop)
1297 retval = put_user(pid, &infop->si_pid);
1298 if (!retval && infop)
1299 retval = put_user(uid, &infop->si_uid);
1300 if (!retval)
1301 retval = pid;
1302
1303 if (traced) {
1304 write_lock_irq(&tasklist_lock);
1305
1306 ptrace_unlink(p);
1307
1308
1309
1310
1311
1312 if (!task_detached(p)) {
1313 do_notify_parent(p, p->exit_signal);
1314 if (!task_detached(p)) {
1315 p->exit_state = EXIT_ZOMBIE;
1316 p = NULL;
1317 }
1318 }
1319 write_unlock_irq(&tasklist_lock);
1320 }
1321 if (p != NULL)
1322 release_task(p);
1323
1324 return retval;
1325}
1326
1327static int *task_stopped_code(struct task_struct *p, bool ptrace)
1328{
1329 if (ptrace) {
1330 if (task_is_stopped_or_traced(p))
1331 return &p->exit_code;
1332 } else {
1333 if (p->signal->flags & SIGNAL_STOP_STOPPED)
1334 return &p->signal->group_exit_code;
1335 }
1336 return NULL;
1337}
1338
1339
1340
1341
1342
1343
1344
1345static int wait_task_stopped(struct wait_opts *wo,
1346 int ptrace, struct task_struct *p)
1347{
1348 struct siginfo __user *infop;
1349 int retval, exit_code, *p_code, why;
1350 uid_t uid = 0;
1351 pid_t pid;
1352
1353
1354
1355
1356 if (!ptrace && !(wo->wo_flags & WUNTRACED))
1357 return 0;
1358
1359 exit_code = 0;
1360 spin_lock_irq(&p->sighand->siglock);
1361
1362 p_code = task_stopped_code(p, ptrace);
1363 if (unlikely(!p_code))
1364 goto unlock_sig;
1365
1366 exit_code = *p_code;
1367 if (!exit_code)
1368 goto unlock_sig;
1369
1370 if (!unlikely(wo->wo_flags & WNOWAIT))
1371 *p_code = 0;
1372
1373
1374 uid = __task_cred(p)->uid;
1375unlock_sig:
1376 spin_unlock_irq(&p->sighand->siglock);
1377 if (!exit_code)
1378 return 0;
1379
1380
1381
1382
1383
1384
1385
1386
1387 get_task_struct(p);
1388 pid = task_pid_vnr(p);
1389 why = ptrace ? CLD_TRAPPED : CLD_STOPPED;
1390 read_unlock(&tasklist_lock);
1391
1392 if (unlikely(wo->wo_flags & WNOWAIT))
1393 return wait_noreap_copyout(wo, p, pid, uid, why, exit_code);
1394
1395 retval = wo->wo_rusage
1396 ? getrusage(p, RUSAGE_BOTH, wo->wo_rusage) : 0;
1397 if (!retval && wo->wo_stat)
1398 retval = put_user((exit_code << 8) | 0x7f, wo->wo_stat);
1399
1400 infop = wo->wo_info;
1401 if (!retval && infop)
1402 retval = put_user(SIGCHLD, &infop->si_signo);
1403 if (!retval && infop)
1404 retval = put_user(0, &infop->si_errno);
1405 if (!retval && infop)
1406 retval = put_user((short)why, &infop->si_code);
1407 if (!retval && infop)
1408 retval = put_user(exit_code, &infop->si_status);
1409 if (!retval && infop)
1410 retval = put_user(pid, &infop->si_pid);
1411 if (!retval && infop)
1412 retval = put_user(uid, &infop->si_uid);
1413 if (!retval)
1414 retval = pid;
1415 put_task_struct(p);
1416
1417 BUG_ON(!retval);
1418 return retval;
1419}
1420
1421
1422
1423
1424
1425
1426
1427static int wait_task_continued(struct wait_opts *wo, struct task_struct *p)
1428{
1429 int retval;
1430 pid_t pid;
1431 uid_t uid;
1432
1433 if (!unlikely(wo->wo_flags & WCONTINUED))
1434 return 0;
1435
1436 if (!(p->signal->flags & SIGNAL_STOP_CONTINUED))
1437 return 0;
1438
1439 spin_lock_irq(&p->sighand->siglock);
1440
1441 if (!(p->signal->flags & SIGNAL_STOP_CONTINUED)) {
1442 spin_unlock_irq(&p->sighand->siglock);
1443 return 0;
1444 }
1445 if (!unlikely(wo->wo_flags & WNOWAIT))
1446 p->signal->flags &= ~SIGNAL_STOP_CONTINUED;
1447 uid = __task_cred(p)->uid;
1448 spin_unlock_irq(&p->sighand->siglock);
1449
1450 pid = task_pid_vnr(p);
1451 get_task_struct(p);
1452 read_unlock(&tasklist_lock);
1453
1454 if (!wo->wo_info) {
1455 retval = wo->wo_rusage
1456 ? getrusage(p, RUSAGE_BOTH, wo->wo_rusage) : 0;
1457 put_task_struct(p);
1458 if (!retval && wo->wo_stat)
1459 retval = put_user(0xffff, wo->wo_stat);
1460 if (!retval)
1461 retval = pid;
1462 } else {
1463 retval = wait_noreap_copyout(wo, p, pid, uid,
1464 CLD_CONTINUED, SIGCONT);
1465 BUG_ON(retval == 0);
1466 }
1467
1468 return retval;
1469}
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480static int wait_consider_task(struct wait_opts *wo, int ptrace,
1481 struct task_struct *p)
1482{
1483 int ret = eligible_child(wo, p);
1484 if (!ret)
1485 return ret;
1486
1487 ret = security_task_wait(p);
1488 if (unlikely(ret < 0)) {
1489
1490
1491
1492
1493
1494
1495
1496 if (wo->notask_error)
1497 wo->notask_error = ret;
1498 return 0;
1499 }
1500
1501 if (likely(!ptrace) && unlikely(task_ptrace(p))) {
1502
1503
1504
1505
1506 wo->notask_error = 0;
1507 return 0;
1508 }
1509
1510 if (p->exit_state == EXIT_DEAD)
1511 return 0;
1512
1513
1514
1515
1516 if (p->exit_state == EXIT_ZOMBIE && !delay_group_leader(p))
1517 return wait_task_zombie(wo, p);
1518
1519
1520
1521
1522
1523 wo->notask_error = 0;
1524
1525 if (task_stopped_code(p, ptrace))
1526 return wait_task_stopped(wo, ptrace, p);
1527
1528 return wait_task_continued(wo, p);
1529}
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540static int do_wait_thread(struct wait_opts *wo, struct task_struct *tsk)
1541{
1542 struct task_struct *p;
1543
1544 list_for_each_entry(p, &tsk->children, sibling) {
1545
1546
1547
1548 if (!task_detached(p)) {
1549 int ret = wait_consider_task(wo, 0, p);
1550 if (ret)
1551 return ret;
1552 }
1553 }
1554
1555 return 0;
1556}
1557
1558static int ptrace_do_wait(struct wait_opts *wo, struct task_struct *tsk)
1559{
1560 struct task_struct *p;
1561
1562 list_for_each_entry(p, &tsk->ptraced, ptrace_entry) {
1563 int ret = wait_consider_task(wo, 1, p);
1564 if (ret)
1565 return ret;
1566 }
1567
1568 return 0;
1569}
1570
1571static int child_wait_callback(wait_queue_t *wait, unsigned mode,
1572 int sync, void *key)
1573{
1574 struct wait_opts *wo = container_of(wait, struct wait_opts,
1575 child_wait);
1576 struct task_struct *p = key;
1577
1578 if (!eligible_pid(wo, p))
1579 return 0;
1580
1581 if ((wo->wo_flags & __WNOTHREAD) && wait->private != p->parent)
1582 return 0;
1583
1584 return default_wake_function(wait, mode, sync, key);
1585}
1586
1587void __wake_up_parent(struct task_struct *p, struct task_struct *parent)
1588{
1589 __wake_up_sync_key(&parent->signal->wait_chldexit,
1590 TASK_INTERRUPTIBLE, 1, p);
1591}
1592
1593static long do_wait(struct wait_opts *wo)
1594{
1595 struct task_struct *tsk;
1596 int retval;
1597
1598 trace_sched_process_wait(wo->wo_pid);
1599
1600 init_waitqueue_func_entry(&wo->child_wait, child_wait_callback);
1601 wo->child_wait.private = current;
1602 add_wait_queue(¤t->signal->wait_chldexit, &wo->child_wait);
1603repeat:
1604
1605
1606
1607
1608
1609
1610 wo->notask_error = -ECHILD;
1611 if ((wo->wo_type < PIDTYPE_MAX) &&
1612 (!wo->wo_pid || hlist_empty(&wo->wo_pid->tasks[wo->wo_type])))
1613 goto notask;
1614
1615 set_current_state(TASK_INTERRUPTIBLE);
1616 read_lock(&tasklist_lock);
1617 tsk = current;
1618 do {
1619 retval = do_wait_thread(wo, tsk);
1620 if (retval)
1621 goto end;
1622
1623 retval = ptrace_do_wait(wo, tsk);
1624 if (retval)
1625 goto end;
1626
1627 if (wo->wo_flags & __WNOTHREAD)
1628 break;
1629 } while_each_thread(current, tsk);
1630 read_unlock(&tasklist_lock);
1631
1632notask:
1633 retval = wo->notask_error;
1634 if (!retval && !(wo->wo_flags & WNOHANG)) {
1635 retval = -ERESTARTSYS;
1636 if (!signal_pending(current)) {
1637 schedule();
1638 goto repeat;
1639 }
1640 }
1641end:
1642 __set_current_state(TASK_RUNNING);
1643 remove_wait_queue(¤t->signal->wait_chldexit, &wo->child_wait);
1644 return retval;
1645}
1646
1647SYSCALL_DEFINE5(waitid, int, which, pid_t, upid, struct siginfo __user *,
1648 infop, int, options, struct rusage __user *, ru)
1649{
1650 struct wait_opts wo;
1651 struct pid *pid = NULL;
1652 enum pid_type type;
1653 long ret;
1654
1655 if (options & ~(WNOHANG|WNOWAIT|WEXITED|WSTOPPED|WCONTINUED))
1656 return -EINVAL;
1657 if (!(options & (WEXITED|WSTOPPED|WCONTINUED)))
1658 return -EINVAL;
1659
1660 switch (which) {
1661 case P_ALL:
1662 type = PIDTYPE_MAX;
1663 break;
1664 case P_PID:
1665 type = PIDTYPE_PID;
1666 if (upid <= 0)
1667 return -EINVAL;
1668 break;
1669 case P_PGID:
1670 type = PIDTYPE_PGID;
1671 if (upid <= 0)
1672 return -EINVAL;
1673 break;
1674 default:
1675 return -EINVAL;
1676 }
1677
1678 if (type < PIDTYPE_MAX)
1679 pid = find_get_pid(upid);
1680
1681 wo.wo_type = type;
1682 wo.wo_pid = pid;
1683 wo.wo_flags = options;
1684 wo.wo_info = infop;
1685 wo.wo_stat = NULL;
1686 wo.wo_rusage = ru;
1687 ret = do_wait(&wo);
1688
1689 if (ret > 0) {
1690 ret = 0;
1691 } else if (infop) {
1692
1693
1694
1695
1696
1697 if (!ret)
1698 ret = put_user(0, &infop->si_signo);
1699 if (!ret)
1700 ret = put_user(0, &infop->si_errno);
1701 if (!ret)
1702 ret = put_user(0, &infop->si_code);
1703 if (!ret)
1704 ret = put_user(0, &infop->si_pid);
1705 if (!ret)
1706 ret = put_user(0, &infop->si_uid);
1707 if (!ret)
1708 ret = put_user(0, &infop->si_status);
1709 }
1710
1711 put_pid(pid);
1712
1713
1714 asmlinkage_protect(5, ret, which, upid, infop, options, ru);
1715 return ret;
1716}
1717
1718SYSCALL_DEFINE4(wait4, pid_t, upid, int __user *, stat_addr,
1719 int, options, struct rusage __user *, ru)
1720{
1721 struct wait_opts wo;
1722 struct pid *pid = NULL;
1723 enum pid_type type;
1724 long ret;
1725
1726 if (options & ~(WNOHANG|WUNTRACED|WCONTINUED|
1727 __WNOTHREAD|__WCLONE|__WALL))
1728 return -EINVAL;
1729
1730 if (upid == -1)
1731 type = PIDTYPE_MAX;
1732 else if (upid < 0) {
1733 type = PIDTYPE_PGID;
1734 pid = find_get_pid(-upid);
1735 } else if (upid == 0) {
1736 type = PIDTYPE_PGID;
1737 pid = get_task_pid(current, PIDTYPE_PGID);
1738 } else {
1739 type = PIDTYPE_PID;
1740 pid = find_get_pid(upid);
1741 }
1742
1743 wo.wo_type = type;
1744 wo.wo_pid = pid;
1745 wo.wo_flags = options | WEXITED;
1746 wo.wo_info = NULL;
1747 wo.wo_stat = stat_addr;
1748 wo.wo_rusage = ru;
1749 ret = do_wait(&wo);
1750 put_pid(pid);
1751
1752
1753 asmlinkage_protect(4, ret, upid, stat_addr, options, ru);
1754 return ret;
1755}
1756
1757#ifdef __ARCH_WANT_SYS_WAITPID
1758
1759
1760
1761
1762
1763SYSCALL_DEFINE3(waitpid, pid_t, pid, int __user *, stat_addr, int, options)
1764{
1765 return sys_wait4(pid, stat_addr, options, NULL);
1766}
1767
1768#endif
1769