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