1 /* 2 * linux/kernel/exit.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 */ 6 7 #include <linux/mm.h> 8 #include <linux/slab.h> 9 #include <linux/interrupt.h> 10 #include <linux/module.h> 11 #include <linux/capability.h> 12 #include <linux/completion.h> 13 #include <linux/personality.h> 14 #include <linux/tty.h> 15 #include <linux/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/signalfd.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/cpuset.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> /* for audit_free() */ 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 53 extern void sem_exit (void); 54 55 static void exit_mm(struct task_struct * tsk); 56 57 static 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 * This function expects the tasklist_lock write-locked. 74 */ 75 static 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 /* 88 * Notify that this sighand has been detached. This must 89 * be called with the tsk->sighand lock held. Also, this 90 * access tsk->sighand internally, so it must be called 91 * before tsk->sighand is reset. 92 */ 93 signalfd_detach_locked(tsk); 94 95 posix_cpu_timers_exit(tsk); 96 if (atomic_dec_and_test(&sig->count)) 97 posix_cpu_timers_exit_group(tsk); 98 else { 99 /* 100 * If there is any task waiting for the group exit 101 * then notify it: 102 */ 103 if (sig->group_exit_task && atomic_read(&sig->count) == sig->notify_count) { 104 wake_up_process(sig->group_exit_task); 105 sig->group_exit_task = NULL; 106 } 107 if (tsk == sig->curr_target) 108 sig->curr_target = next_thread(tsk); 109 /* 110 * Accumulate here the counters for all threads but the 111 * group leader as they die, so they can be added into 112 * the process-wide totals when those are taken. 113 * The group leader stays around as a zombie as long 114 * as there are other threads. When it gets reaped, 115 * the exit.c code will add its counts into these totals. 116 * We won't ever get here for the group leader, since it 117 * will have been the last reference on the signal_struct. 118 */ 119 sig->utime = cputime_add(sig->utime, tsk->utime); 120 sig->stime = cputime_add(sig->stime, tsk->stime); 121 sig->min_flt += tsk->min_flt; 122 sig->maj_flt += tsk->maj_flt; 123 sig->nvcsw += tsk->nvcsw; 124 sig->nivcsw += tsk->nivcsw; 125 sig->sched_time += tsk->sched_time; 126 sig->inblock += task_io_get_inblock(tsk); 127 sig->oublock += task_io_get_oublock(tsk); 128 sig = NULL; /* Marker for below. */ 129 } 130 131 __unhash_process(tsk); 132 133 tsk->signal = NULL; 134 tsk->sighand = NULL; 135 spin_unlock(&sighand->siglock); 136 rcu_read_unlock(); 137 138 __cleanup_sighand(sighand); 139 clear_tsk_thread_flag(tsk,TIF_SIGPENDING); 140 flush_sigqueue(&tsk->pending); 141 if (sig) { 142 flush_sigqueue(&sig->shared_pending); 143 taskstats_tgid_free(sig); 144 __cleanup_signal(sig); 145 } 146 } 147 148 static void delayed_put_task_struct(struct rcu_head *rhp) 149 { 150 put_task_struct(container_of(rhp, struct task_struct, rcu)); 151 } 152 153 void release_task(struct task_struct * p) 154 { 155 struct task_struct *leader; 156 int zap_leader; 157 repeat: 158 atomic_dec(&p->user->processes); 159 write_lock_irq(&tasklist_lock); 160 ptrace_unlink(p); 161 BUG_ON(!list_empty(&p->ptrace_list) || !list_empty(&p->ptrace_children)); 162 __exit_signal(p); 163 164 /* 165 * If we are the last non-leader member of the thread 166 * group, and the leader is zombie, then notify the 167 * group leader's parent process. (if it wants notification.) 168 */ 169 zap_leader = 0; 170 leader = p->group_leader; 171 if (leader != p && thread_group_empty(leader) && leader->exit_state == EXIT_ZOMBIE) { 172 BUG_ON(leader->exit_signal == -1); 173 do_notify_parent(leader, leader->exit_signal); 174 /* 175 * If we were the last child thread and the leader has 176 * exited already, and the leader's parent ignores SIGCHLD, 177 * then we are the one who should release the leader. 178 * 179 * do_notify_parent() will have marked it self-reaping in 180 * that case. 181 */ 182 zap_leader = (leader->exit_signal == -1); 183 } 184 185 sched_exit(p); 186 write_unlock_irq(&tasklist_lock); 187 proc_flush_task(p); 188 release_thread(p); 189 call_rcu(&p->rcu, delayed_put_task_struct); 190 191 p = leader; 192 if (unlikely(zap_leader)) 193 goto repeat; 194 } 195 196 /* 197 * This checks not only the pgrp, but falls back on the pid if no 198 * satisfactory pgrp is found. I dunno - gdb doesn't work correctly 199 * without this... 200 * 201 * The caller must hold rcu lock or the tasklist lock. 202 */ 203 struct pid *session_of_pgrp(struct pid *pgrp) 204 { 205 struct task_struct *p; 206 struct pid *sid = NULL; 207 208 p = pid_task(pgrp, PIDTYPE_PGID); 209 if (p == NULL) 210 p = pid_task(pgrp, PIDTYPE_PID); 211 if (p != NULL) 212 sid = task_session(p); 213 214 return sid; 215 } 216 217 /* 218 * Determine if a process group is "orphaned", according to the POSIX 219 * definition in 2.2.2.52. Orphaned process groups are not to be affected 220 * by terminal-generated stop signals. Newly orphaned process groups are 221 * to receive a SIGHUP and a SIGCONT. 222 * 223 * "I ask you, have you ever known what it is to be an orphan?" 224 */ 225 static int will_become_orphaned_pgrp(struct pid *pgrp, struct task_struct *ignored_task) 226 { 227 struct task_struct *p; 228 int ret = 1; 229 230 do_each_pid_task(pgrp, PIDTYPE_PGID, p) { 231 if (p == ignored_task 232 || p->exit_state 233 || is_init(p->real_parent)) 234 continue; 235 if (task_pgrp(p->real_parent) != pgrp && 236 task_session(p->real_parent) == task_session(p)) { 237 ret = 0; 238 break; 239 } 240 } while_each_pid_task(pgrp, PIDTYPE_PGID, p); 241 return ret; /* (sighing) "Often!" */ 242 } 243 244 int is_current_pgrp_orphaned(void) 245 { 246 int retval; 247 248 read_lock(&tasklist_lock); 249 retval = will_become_orphaned_pgrp(task_pgrp(current), NULL); 250 read_unlock(&tasklist_lock); 251 252 return retval; 253 } 254 255 static int has_stopped_jobs(struct pid *pgrp) 256 { 257 int retval = 0; 258 struct task_struct *p; 259 260 do_each_pid_task(pgrp, PIDTYPE_PGID, p) { 261 if (p->state != TASK_STOPPED) 262 continue; 263 retval = 1; 264 break; 265 } while_each_pid_task(pgrp, PIDTYPE_PGID, p); 266 return retval; 267 } 268 269 /** 270 * reparent_to_kthreadd - Reparent the calling kernel thread to kthreadd 271 * 272 * If a kernel thread is launched as a result of a system call, or if 273 * it ever exits, it should generally reparent itself to kthreadd so it 274 * isn't in the way of other processes and is correctly cleaned up on exit. 275 * 276 * The various task state such as scheduling policy and priority may have 277 * been inherited from a user process, so we reset them to sane values here. 278 * 279 * NOTE that reparent_to_kthreadd() gives the caller full capabilities. 280 */ 281 static void reparent_to_kthreadd(void) 282 { 283 write_lock_irq(&tasklist_lock); 284 285 ptrace_unlink(current); 286 /* Reparent to init */ 287 remove_parent(current); 288 current->real_parent = current->parent = kthreadd_task; 289 add_parent(current); 290 291 /* Set the exit signal to SIGCHLD so we signal init on exit */ 292 current->exit_signal = SIGCHLD; 293 294 if (!has_rt_policy(current) && (task_nice(current) < 0)) 295 set_user_nice(current, 0); 296 /* cpus_allowed? */ 297 /* rt_priority? */ 298 /* signals? */ 299 security_task_reparent_to_init(current); 300 memcpy(current->signal->rlim, init_task.signal->rlim, 301 sizeof(current->signal->rlim)); 302 atomic_inc(&(INIT_USER->__count)); 303 write_unlock_irq(&tasklist_lock); 304 switch_uid(INIT_USER); 305 } 306 307 void __set_special_pids(pid_t session, pid_t pgrp) 308 { 309 struct task_struct *curr = current->group_leader; 310 311 if (process_session(curr) != session) { 312 detach_pid(curr, PIDTYPE_SID); 313 set_signal_session(curr->signal, session); 314 attach_pid(curr, PIDTYPE_SID, find_pid(session)); 315 } 316 if (process_group(curr) != pgrp) { 317 detach_pid(curr, PIDTYPE_PGID); 318 curr->signal->pgrp = pgrp; 319 attach_pid(curr, PIDTYPE_PGID, find_pid(pgrp)); 320 } 321 } 322 323 static void set_special_pids(pid_t session, pid_t pgrp) 324 { 325 write_lock_irq(&tasklist_lock); 326 __set_special_pids(session, pgrp); 327 write_unlock_irq(&tasklist_lock); 328 } 329 330 /* 331 * Let kernel threads use this to say that they 332 * allow a certain signal (since daemonize() will 333 * have disabled all of them by default). 334 */ 335 int allow_signal(int sig) 336 { 337 if (!valid_signal(sig) || sig < 1) 338 return -EINVAL; 339 340 spin_lock_irq(¤t->sighand->siglock); 341 sigdelset(¤t->blocked, sig); 342 if (!current->mm) { 343 /* Kernel threads handle their own signals. 344 Let the signal code know it'll be handled, so 345 that they don't get converted to SIGKILL or 346 just silently dropped */ 347 current->sighand->action[(sig)-1].sa.sa_handler = (void __user *)2; 348 } 349 recalc_sigpending(); 350 spin_unlock_irq(¤t->sighand->siglock); 351 return 0; 352 } 353 354 EXPORT_SYMBOL(allow_signal); 355 356 int disallow_signal(int sig) 357 { 358 if (!valid_signal(sig) || sig < 1) 359 return -EINVAL; 360 361 spin_lock_irq(¤t->sighand->siglock); 362 current->sighand->action[(sig)-1].sa.sa_handler = SIG_IGN; 363 recalc_sigpending(); 364 spin_unlock_irq(¤t->sighand->siglock); 365 return 0; 366 } 367 368 EXPORT_SYMBOL(disallow_signal); 369 370 /* 371 * Put all the gunge required to become a kernel thread without 372 * attached user resources in one place where it belongs. 373 */ 374 375 void daemonize(const char *name, ...) 376 { 377 va_list args; 378 struct fs_struct *fs; 379 sigset_t blocked; 380 381 va_start(args, name); 382 vsnprintf(current->comm, sizeof(current->comm), name, args); 383 va_end(args); 384 385 /* 386 * If we were started as result of loading a module, close all of the 387 * user space pages. We don't need them, and if we didn't close them 388 * they would be locked into memory. 389 */ 390 exit_mm(current); 391 392 set_special_pids(1, 1); 393 proc_clear_tty(current); 394 395 /* Block and flush all signals */ 396 sigfillset(&blocked); 397 sigprocmask(SIG_BLOCK, &blocked, NULL); 398 flush_signals(current); 399 400 /* Become as one with the init task */ 401 402 exit_fs(current); /* current->fs->count--; */ 403 fs = init_task.fs; 404 current->fs = fs; 405 atomic_inc(&fs->count); 406 407 exit_task_namespaces(current); 408 current->nsproxy = init_task.nsproxy; 409 get_task_namespaces(current); 410 411 exit_files(current); 412 current->files = init_task.files; 413 atomic_inc(¤t->files->count); 414 415 reparent_to_kthreadd(); 416 } 417 418 EXPORT_SYMBOL(daemonize); 419 420 static void close_files(struct files_struct * files) 421 { 422 int i, j; 423 struct fdtable *fdt; 424 425 j = 0; 426 427 /* 428 * It is safe to dereference the fd table without RCU or 429 * ->file_lock because this is the last reference to the 430 * files structure. 431 */ 432 fdt = files_fdtable(files); 433 for (;;) { 434 unsigned long set; 435 i = j * __NFDBITS; 436 if (i >= fdt->max_fds) 437 break; 438 set = fdt->open_fds->fds_bits[j++]; 439 while (set) { 440 if (set & 1) { 441 struct file * file = xchg(&fdt->fd[i], NULL); 442 if (file) { 443 filp_close(file, files); 444 cond_resched(); 445 } 446 } 447 i++; 448 set >>= 1; 449 } 450 } 451 } 452 453 struct files_struct *get_files_struct(struct task_struct *task) 454 { 455 struct files_struct *files; 456 457 task_lock(task); 458 files = task->files; 459 if (files) 460 atomic_inc(&files->count); 461 task_unlock(task); 462 463 return files; 464 } 465 466 void fastcall put_files_struct(struct files_struct *files) 467 { 468 struct fdtable *fdt; 469 470 if (atomic_dec_and_test(&files->count)) { 471 close_files(files); 472 /* 473 * Free the fd and fdset arrays if we expanded them. 474 * If the fdtable was embedded, pass files for freeing 475 * at the end of the RCU grace period. Otherwise, 476 * you can free files immediately. 477 */ 478 fdt = files_fdtable(files); 479 if (fdt != &files->fdtab) 480 kmem_cache_free(files_cachep, files); 481 free_fdtable(fdt); 482 } 483 } 484 485 EXPORT_SYMBOL(put_files_struct); 486 487 void reset_files_struct(struct task_struct *tsk, struct files_struct *files) 488 { 489 struct files_struct *old; 490 491 old = tsk->files; 492 task_lock(tsk); 493 tsk->files = files; 494 task_unlock(tsk); 495 put_files_struct(old); 496 } 497 EXPORT_SYMBOL(reset_files_struct); 498 499 static inline void __exit_files(struct task_struct *tsk) 500 { 501 struct files_struct * files = tsk->files; 502 503 if (files) { 504 task_lock(tsk); 505 tsk->files = NULL; 506 task_unlock(tsk); 507 put_files_struct(files); 508 } 509 } 510 511 void exit_files(struct task_struct *tsk) 512 { 513 __exit_files(tsk); 514 } 515 516 static inline void __put_fs_struct(struct fs_struct *fs) 517 { 518 /* No need to hold fs->lock if we are killing it */ 519 if (atomic_dec_and_test(&fs->count)) { 520 dput(fs->root); 521 mntput(fs->rootmnt); 522 dput(fs->pwd); 523 mntput(fs->pwdmnt); 524 if (fs->altroot) { 525 dput(fs->altroot); 526 mntput(fs->altrootmnt); 527 } 528 kmem_cache_free(fs_cachep, fs); 529 } 530 } 531 532 void put_fs_struct(struct fs_struct *fs) 533 { 534 __put_fs_struct(fs); 535 } 536 537 static inline void __exit_fs(struct task_struct *tsk) 538 { 539 struct fs_struct * fs = tsk->fs; 540 541 if (fs) { 542 task_lock(tsk); 543 tsk->fs = NULL; 544 task_unlock(tsk); 545 __put_fs_struct(fs); 546 } 547 } 548 549 void exit_fs(struct task_struct *tsk) 550 { 551 __exit_fs(tsk); 552 } 553 554 EXPORT_SYMBOL_GPL(exit_fs); 555 556 /* 557 * Turn us into a lazy TLB process if we 558 * aren't already.. 559 */ 560 static void exit_mm(struct task_struct * tsk) 561 { 562 struct mm_struct *mm = tsk->mm; 563 564 mm_release(tsk, mm); 565 if (!mm) 566 return; 567 /* 568 * Serialize with any possible pending coredump. 569 * We must hold mmap_sem around checking core_waiters 570 * and clearing tsk->mm. The core-inducing thread 571 * will increment core_waiters for each thread in the 572 * group with ->mm != NULL. 573 */ 574 down_read(&mm->mmap_sem); 575 if (mm->core_waiters) { 576 up_read(&mm->mmap_sem); 577 down_write(&mm->mmap_sem); 578 if (!--mm->core_waiters) 579 complete(mm->core_startup_done); 580 up_write(&mm->mmap_sem); 581 582 wait_for_completion(&mm->core_done); 583 down_read(&mm->mmap_sem); 584 } 585 atomic_inc(&mm->mm_count); 586 BUG_ON(mm != tsk->active_mm); 587 /* more a memory barrier than a real lock */ 588 task_lock(tsk); 589 tsk->mm = NULL; 590 up_read(&mm->mmap_sem); 591 enter_lazy_tlb(mm, current); 592 task_unlock(tsk); 593 mmput(mm); 594 } 595 596 static inline void 597 choose_new_parent(struct task_struct *p, struct task_struct *reaper) 598 { 599 /* 600 * Make sure we're not reparenting to ourselves and that 601 * the parent is not a zombie. 602 */ 603 BUG_ON(p == reaper || reaper->exit_state); 604 p->real_parent = reaper; 605 } 606 607 static void 608 reparent_thread(struct task_struct *p, struct task_struct *father, int traced) 609 { 610 if (p->pdeath_signal) 611 /* We already hold the tasklist_lock here. */ 612 group_send_sig_info(p->pdeath_signal, SEND_SIG_NOINFO, p); 613 614 /* Move the child from its dying parent to the new one. */ 615 if (unlikely(traced)) { 616 /* Preserve ptrace links if someone else is tracing this child. */ 617 list_del_init(&p->ptrace_list); 618 if (p->parent != p->real_parent) 619 list_add(&p->ptrace_list, &p->real_parent->ptrace_children); 620 } else { 621 /* If this child is being traced, then we're the one tracing it 622 * anyway, so let go of it. 623 */ 624 p->ptrace = 0; 625 remove_parent(p); 626 p->parent = p->real_parent; 627 add_parent(p); 628 629 if (p->state == TASK_TRACED) { 630 /* 631 * If it was at a trace stop, turn it into 632 * a normal stop since it's no longer being 633 * traced. 634 */ 635 ptrace_untrace(p); 636 } 637 } 638 639 /* If this is a threaded reparent there is no need to 640 * notify anyone anything has happened. 641 */ 642 if (p->real_parent->group_leader == father->group_leader) 643 return; 644 645 /* We don't want people slaying init. */ 646 if (p->exit_signal != -1) 647 p->exit_signal = SIGCHLD; 648 649 /* If we'd notified the old parent about this child's death, 650 * also notify the new parent. 651 */ 652 if (!traced && p->exit_state == EXIT_ZOMBIE && 653 p->exit_signal != -1 && thread_group_empty(p)) 654 do_notify_parent(p, p->exit_signal); 655 656 /* 657 * process group orphan check 658 * Case ii: Our child is in a different pgrp 659 * than we are, and it was the only connection 660 * outside, so the child pgrp is now orphaned. 661 */ 662 if ((task_pgrp(p) != task_pgrp(father)) && 663 (task_session(p) == task_session(father))) { 664 struct pid *pgrp = task_pgrp(p); 665 666 if (will_become_orphaned_pgrp(pgrp, NULL) && 667 has_stopped_jobs(pgrp)) { 668 __kill_pgrp_info(SIGHUP, SEND_SIG_PRIV, pgrp); 669 __kill_pgrp_info(SIGCONT, SEND_SIG_PRIV, pgrp); 670 } 671 } 672 } 673 674 /* 675 * When we die, we re-parent all our children. 676 * Try to give them to another thread in our thread 677 * group, and if no such member exists, give it to 678 * the child reaper process (ie "init") in our pid 679 * space. 680 */ 681 static void 682 forget_original_parent(struct task_struct *father, struct list_head *to_release) 683 { 684 struct task_struct *p, *reaper = father; 685 struct list_head *_p, *_n; 686 687 do { 688 reaper = next_thread(reaper); 689 if (reaper == father) { 690 reaper = child_reaper(father); 691 break; 692 } 693 } while (reaper->exit_state); 694 695 /* 696 * There are only two places where our children can be: 697 * 698 * - in our child list 699 * - in our ptraced child list 700 * 701 * Search them and reparent children. 702 */ 703 list_for_each_safe(_p, _n, &father->children) { 704 int ptrace; 705 p = list_entry(_p, struct task_struct, sibling); 706 707 ptrace = p->ptrace; 708 709 /* if father isn't the real parent, then ptrace must be enabled */ 710 BUG_ON(father != p->real_parent && !ptrace); 711 712 if (father == p->real_parent) { 713 /* reparent with a reaper, real father it's us */ 714 choose_new_parent(p, reaper); 715 reparent_thread(p, father, 0); 716 } else { 717 /* reparent ptraced task to its real parent */ 718 __ptrace_unlink (p); 719 if (p->exit_state == EXIT_ZOMBIE && p->exit_signal != -1 && 720 thread_group_empty(p)) 721 do_notify_parent(p, p->exit_signal); 722 } 723 724 /* 725 * if the ptraced child is a zombie with exit_signal == -1 726 * we must collect it before we exit, or it will remain 727 * zombie forever since we prevented it from self-reap itself 728 * while it was being traced by us, to be able to see it in wait4. 729 */ 730 if (unlikely(ptrace && p->exit_state == EXIT_ZOMBIE && p->exit_signal == -1)) 731 list_add(&p->ptrace_list, to_release); 732 } 733 list_for_each_safe(_p, _n, &father->ptrace_children) { 734 p = list_entry(_p, struct task_struct, ptrace_list); 735 choose_new_parent(p, reaper); 736 reparent_thread(p, father, 1); 737 } 738 } 739 740 /* 741 * Send signals to all our closest relatives so that they know 742 * to properly mourn us.. 743 */ 744 static void exit_notify(struct task_struct *tsk) 745 { 746 int state; 747 struct task_struct *t; 748 struct list_head ptrace_dead, *_p, *_n; 749 struct pid *pgrp; 750 751 if (signal_pending(tsk) && !(tsk->signal->flags & SIGNAL_GROUP_EXIT) 752 && !thread_group_empty(tsk)) { 753 /* 754 * This occurs when there was a race between our exit 755 * syscall and a group signal choosing us as the one to 756 * wake up. It could be that we are the only thread 757 * alerted to check for pending signals, but another thread 758 * should be woken now to take the signal since we will not. 759 * Now we'll wake all the threads in the group just to make 760 * sure someone gets all the pending signals. 761 */ 762 read_lock(&tasklist_lock); 763 spin_lock_irq(&tsk->sighand->siglock); 764 for (t = next_thread(tsk); t != tsk; t = next_thread(t)) 765 if (!signal_pending(t) && !(t->flags & PF_EXITING)) { 766 recalc_sigpending_tsk(t); 767 if (signal_pending(t)) 768 signal_wake_up(t, 0); 769 } 770 spin_unlock_irq(&tsk->sighand->siglock); 771 read_unlock(&tasklist_lock); 772 } 773 774 write_lock_irq(&tasklist_lock); 775 776 /* 777 * This does two things: 778 * 779 * A. Make init inherit all the child processes 780 * B. Check to see if any process groups have become orphaned 781 * as a result of our exiting, and if they have any stopped 782 * jobs, send them a SIGHUP and then a SIGCONT. (POSIX 3.2.2.2) 783 */ 784 785 INIT_LIST_HEAD(&ptrace_dead); 786 forget_original_parent(tsk, &ptrace_dead); 787 BUG_ON(!list_empty(&tsk->children)); 788 BUG_ON(!list_empty(&tsk->ptrace_children)); 789 790 /* 791 * Check to see if any process groups have become orphaned 792 * as a result of our exiting, and if they have any stopped 793 * jobs, send them a SIGHUP and then a SIGCONT. (POSIX 3.2.2.2) 794 * 795 * Case i: Our father is in a different pgrp than we are 796 * and we were the only connection outside, so our pgrp 797 * is about to become orphaned. 798 */ 799 800 t = tsk->real_parent; 801 802 pgrp = task_pgrp(tsk); 803 if ((task_pgrp(t) != pgrp) && 804 (task_session(t) == task_session(tsk)) && 805 will_become_orphaned_pgrp(pgrp, tsk) && 806 has_stopped_jobs(pgrp)) { 807 __kill_pgrp_info(SIGHUP, SEND_SIG_PRIV, pgrp); 808 __kill_pgrp_info(SIGCONT, SEND_SIG_PRIV, pgrp); 809 } 810 811 /* Let father know we died 812 * 813 * Thread signals are configurable, but you aren't going to use 814 * that to send signals to arbitary processes. 815 * That stops right now. 816 * 817 * If the parent exec id doesn't match the exec id we saved 818 * when we started then we know the parent has changed security 819 * domain. 820 * 821 * If our self_exec id doesn't match our parent_exec_id then 822 * we have changed execution domain as these two values started 823 * the same after a fork. 824 * 825 */ 826 827 if (tsk->exit_signal != SIGCHLD && tsk->exit_signal != -1 && 828 ( tsk->parent_exec_id != t->self_exec_id || 829 tsk->self_exec_id != tsk->parent_exec_id) 830 && !capable(CAP_KILL)) 831 tsk->exit_signal = SIGCHLD; 832 833 834 /* If something other than our normal parent is ptracing us, then 835 * send it a SIGCHLD instead of honoring exit_signal. exit_signal 836 * only has special meaning to our real parent. 837 */ 838 if (tsk->exit_signal != -1 && thread_group_empty(tsk)) { 839 int signal = tsk->parent == tsk->real_parent ? tsk->exit_signal : SIGCHLD; 840 do_notify_parent(tsk, signal); 841 } else if (tsk->ptrace) { 842 do_notify_parent(tsk, SIGCHLD); 843 } 844 845 state = EXIT_ZOMBIE; 846 if (tsk->exit_signal == -1 && 847 (likely(tsk->ptrace == 0) || 848 unlikely(tsk->parent->signal->flags & SIGNAL_GROUP_EXIT))) 849 state = EXIT_DEAD; 850 tsk->exit_state = state; 851 852 write_unlock_irq(&tasklist_lock); 853 854 list_for_each_safe(_p, _n, &ptrace_dead) { 855 list_del_init(_p); 856 t = list_entry(_p, struct task_struct, ptrace_list); 857 release_task(t); 858 } 859 860 /* If the process is dead, release it - nobody will wait for it */ 861 if (state == EXIT_DEAD) 862 release_task(tsk); 863 } 864 865 fastcall NORET_TYPE void do_exit(long code) 866 { 867 struct task_struct *tsk = current; 868 int group_dead; 869 870 profile_task_exit(tsk); 871 872 WARN_ON(atomic_read(&tsk->fs_excl)); 873 874 if (unlikely(in_interrupt())) 875 panic("Aiee, killing interrupt handler!"); 876 if (unlikely(!tsk->pid)) 877 panic("Attempted to kill the idle task!"); 878 if (unlikely(tsk == child_reaper(tsk))) { 879 if (tsk->nsproxy->pid_ns != &init_pid_ns) 880 tsk->nsproxy->pid_ns->child_reaper = init_pid_ns.child_reaper; 881 else 882 panic("Attempted to kill init!"); 883 } 884 885 886 if (unlikely(current->ptrace & PT_TRACE_EXIT)) { 887 current->ptrace_message = code; 888 ptrace_notify((PTRACE_EVENT_EXIT << 8) | SIGTRAP); 889 } 890 891 /* 892 * We're taking recursive faults here in do_exit. Safest is to just 893 * leave this task alone and wait for reboot. 894 */ 895 if (unlikely(tsk->flags & PF_EXITING)) { 896 printk(KERN_ALERT 897 "Fixing recursive fault but reboot is needed!\n"); 898 if (tsk->io_context) 899 exit_io_context(); 900 set_current_state(TASK_UNINTERRUPTIBLE); 901 schedule(); 902 } 903 904 tsk->flags |= PF_EXITING; 905 906 if (unlikely(in_atomic())) 907 printk(KERN_INFO "note: %s[%d] exited with preempt_count %d\n", 908 current->comm, current->pid, 909 preempt_count()); 910 911 acct_update_integrals(tsk); 912 if (tsk->mm) { 913 update_hiwater_rss(tsk->mm); 914 update_hiwater_vm(tsk->mm); 915 } 916 group_dead = atomic_dec_and_test(&tsk->signal->live); 917 if (group_dead) { 918 hrtimer_cancel(&tsk->signal->real_timer); 919 exit_itimers(tsk->signal); 920 } 921 acct_collect(code, group_dead); 922 if (unlikely(tsk->robust_list)) 923 exit_robust_list(tsk); 924 #if defined(CONFIG_FUTEX) && defined(CONFIG_COMPAT) 925 if (unlikely(tsk->compat_robust_list)) 926 compat_exit_robust_list(tsk); 927 #endif 928 if (unlikely(tsk->audit_context)) 929 audit_free(tsk); 930 931 taskstats_exit(tsk, group_dead); 932 933 exit_mm(tsk); 934 935 if (group_dead) 936 acct_process(); 937 exit_sem(tsk); 938 __exit_files(tsk); 939 __exit_fs(tsk); 940 exit_thread(); 941 cpuset_exit(tsk); 942 exit_keys(tsk); 943 944 if (group_dead && tsk->signal->leader) 945 disassociate_ctty(1); 946 947 module_put(task_thread_info(tsk)->exec_domain->module); 948 if (tsk->binfmt) 949 module_put(tsk->binfmt->module); 950 951 tsk->exit_code = code; 952 proc_exit_connector(tsk); 953 exit_task_namespaces(tsk); 954 exit_notify(tsk); 955 #ifdef CONFIG_NUMA 956 mpol_free(tsk->mempolicy); 957 tsk->mempolicy = NULL; 958 #endif 959 /* 960 * This must happen late, after the PID is not 961 * hashed anymore: 962 */ 963 if (unlikely(!list_empty(&tsk->pi_state_list))) 964 exit_pi_state_list(tsk); 965 if (unlikely(current->pi_state_cache)) 966 kfree(current->pi_state_cache); 967 /* 968 * Make sure we are holding no locks: 969 */ 970 debug_check_no_locks_held(tsk); 971 972 if (tsk->io_context) 973 exit_io_context(); 974 975 if (tsk->splice_pipe) 976 __free_pipe_info(tsk->splice_pipe); 977 978 preempt_disable(); 979 /* causes final put_task_struct in finish_task_switch(). */ 980 tsk->state = TASK_DEAD; 981 982 schedule(); 983 BUG(); 984 /* Avoid "noreturn function does return". */ 985 for (;;) 986 cpu_relax(); /* For when BUG is null */ 987 } 988 989 EXPORT_SYMBOL_GPL(do_exit); 990 991 NORET_TYPE void complete_and_exit(struct completion *comp, long code) 992 { 993 if (comp) 994 complete(comp); 995 996 do_exit(code); 997 } 998 999 EXPORT_SYMBOL(complete_and_exit); 1000 1001 asmlinkage long sys_exit(int error_code) 1002 { 1003 do_exit((error_code&0xff)<<8); 1004 } 1005 1006 /* 1007 * Take down every thread in the group. This is called by fatal signals 1008 * as well as by sys_exit_group (below). 1009 */ 1010 NORET_TYPE void 1011 do_group_exit(int exit_code) 1012 { 1013 BUG_ON(exit_code & 0x80); /* core dumps don't get here */ 1014 1015 if (current->signal->flags & SIGNAL_GROUP_EXIT) 1016 exit_code = current->signal->group_exit_code; 1017 else if (!thread_group_empty(current)) { 1018 struct signal_struct *const sig = current->signal; 1019 struct sighand_struct *const sighand = current->sighand; 1020 spin_lock_irq(&sighand->siglock); 1021 if (sig->flags & SIGNAL_GROUP_EXIT) 1022 /* Another thread got here before we took the lock. */ 1023 exit_code = sig->group_exit_code; 1024 else { 1025 sig->group_exit_code = exit_code; 1026 zap_other_threads(current); 1027 } 1028 spin_unlock_irq(&sighand->siglock); 1029 } 1030 1031 do_exit(exit_code); 1032 /* NOTREACHED */ 1033 } 1034 1035 /* 1036 * this kills every thread in the thread group. Note that any externally 1037 * wait4()-ing process will get the correct exit code - even if this 1038 * thread is not the thread group leader. 1039 */ 1040 asmlinkage void sys_exit_group(int error_code) 1041 { 1042 do_group_exit((error_code & 0xff) << 8); 1043 } 1044 1045 static int eligible_child(pid_t pid, int options, struct task_struct *p) 1046 { 1047 int err; 1048 1049 if (pid > 0) { 1050 if (p->pid != pid) 1051 return 0; 1052 } else if (!pid) { 1053 if (process_group(p) != process_group(current)) 1054 return 0; 1055 } else if (pid != -1) { 1056 if (process_group(p) != -pid) 1057 return 0; 1058 } 1059 1060 /* 1061 * Do not consider detached threads that are 1062 * not ptraced: 1063 */ 1064 if (p->exit_signal == -1 && !p->ptrace) 1065 return 0; 1066 1067 /* Wait for all children (clone and not) if __WALL is set; 1068 * otherwise, wait for clone children *only* if __WCLONE is 1069 * set; otherwise, wait for non-clone children *only*. (Note: 1070 * A "clone" child here is one that reports to its parent 1071 * using a signal other than SIGCHLD.) */ 1072 if (((p->exit_signal != SIGCHLD) ^ ((options & __WCLONE) != 0)) 1073 && !(options & __WALL)) 1074 return 0; 1075 /* 1076 * Do not consider thread group leaders that are 1077 * in a non-empty thread group: 1078 */ 1079 if (delay_group_leader(p)) 1080 return 2; 1081 1082 err = security_task_wait(p); 1083 if (err) 1084 return err; 1085 1086 return 1; 1087 } 1088 1089 static int wait_noreap_copyout(struct task_struct *p, pid_t pid, uid_t uid, 1090 int why, int status, 1091 struct siginfo __user *infop, 1092 struct rusage __user *rusagep) 1093 { 1094 int retval = rusagep ? getrusage(p, RUSAGE_BOTH, rusagep) : 0; 1095 1096 put_task_struct(p); 1097 if (!retval) 1098 retval = put_user(SIGCHLD, &infop->si_signo); 1099 if (!retval) 1100 retval = put_user(0, &infop->si_errno); 1101 if (!retval) 1102 retval = put_user((short)why, &infop->si_code); 1103 if (!retval) 1104 retval = put_user(pid, &infop->si_pid); 1105 if (!retval) 1106 retval = put_user(uid, &infop->si_uid); 1107 if (!retval) 1108 retval = put_user(status, &infop->si_status); 1109 if (!retval) 1110 retval = pid; 1111 return retval; 1112 } 1113 1114 /* 1115 * Handle sys_wait4 work for one task in state EXIT_ZOMBIE. We hold 1116 * read_lock(&tasklist_lock) on entry. If we return zero, we still hold 1117 * the lock and this task is uninteresting. If we return nonzero, we have 1118 * released the lock and the system call should return. 1119 */ 1120 static int wait_task_zombie(struct task_struct *p, int noreap, 1121 struct siginfo __user *infop, 1122 int __user *stat_addr, struct rusage __user *ru) 1123 { 1124 unsigned long state; 1125 int retval; 1126 int status; 1127 1128 if (unlikely(noreap)) { 1129 pid_t pid = p->pid; 1130 uid_t uid = p->uid; 1131 int exit_code = p->exit_code; 1132 int why, status; 1133 1134 if (unlikely(p->exit_state != EXIT_ZOMBIE)) 1135 return 0; 1136 if (unlikely(p->exit_signal == -1 && p->ptrace == 0)) 1137 return 0; 1138 get_task_struct(p); 1139 read_unlock(&tasklist_lock); 1140 if ((exit_code & 0x7f) == 0) { 1141 why = CLD_EXITED; 1142 status = exit_code >> 8; 1143 } else { 1144 why = (exit_code & 0x80) ? CLD_DUMPED : CLD_KILLED; 1145 status = exit_code & 0x7f; 1146 } 1147 return wait_noreap_copyout(p, pid, uid, why, 1148 status, infop, ru); 1149 } 1150 1151 /* 1152 * Try to move the task's state to DEAD 1153 * only one thread is allowed to do this: 1154 */ 1155 state = xchg(&p->exit_state, EXIT_DEAD); 1156 if (state != EXIT_ZOMBIE) { 1157 BUG_ON(state != EXIT_DEAD); 1158 return 0; 1159 } 1160 if (unlikely(p->exit_signal == -1 && p->ptrace == 0)) { 1161 /* 1162 * This can only happen in a race with a ptraced thread 1163 * dying on another processor. 1164 */ 1165 return 0; 1166 } 1167 1168 if (likely(p->real_parent == p->parent) && likely(p->signal)) { 1169 struct signal_struct *psig; 1170 struct signal_struct *sig; 1171 1172 /* 1173 * The resource counters for the group leader are in its 1174 * own task_struct. Those for dead threads in the group 1175 * are in its signal_struct, as are those for the child 1176 * processes it has previously reaped. All these 1177 * accumulate in the parent's signal_struct c* fields. 1178 * 1179 * We don't bother to take a lock here to protect these 1180 * p->signal fields, because they are only touched by 1181 * __exit_signal, which runs with tasklist_lock 1182 * write-locked anyway, and so is excluded here. We do 1183 * need to protect the access to p->parent->signal fields, 1184 * as other threads in the parent group can be right 1185 * here reaping other children at the same time. 1186 */ 1187 spin_lock_irq(&p->parent->sighand->siglock); 1188 psig = p->parent->signal; 1189 sig = p->signal; 1190 psig->cutime = 1191 cputime_add(psig->cutime, 1192 cputime_add(p->utime, 1193 cputime_add(sig->utime, 1194 sig->cutime))); 1195 psig->cstime = 1196 cputime_add(psig->cstime, 1197 cputime_add(p->stime, 1198 cputime_add(sig->stime, 1199 sig->cstime))); 1200 psig->cmin_flt += 1201 p->min_flt + sig->min_flt + sig->cmin_flt; 1202 psig->cmaj_flt += 1203 p->maj_flt + sig->maj_flt + sig->cmaj_flt; 1204 psig->cnvcsw += 1205 p->nvcsw + sig->nvcsw + sig->cnvcsw; 1206 psig->cnivcsw += 1207 p->nivcsw + sig->nivcsw + sig->cnivcsw; 1208 psig->cinblock += 1209 task_io_get_inblock(p) + 1210 sig->inblock + sig->cinblock; 1211 psig->coublock += 1212 task_io_get_oublock(p) + 1213 sig->oublock + sig->coublock; 1214 spin_unlock_irq(&p->parent->sighand->siglock); 1215 } 1216 1217 /* 1218 * Now we are sure this task is interesting, and no other 1219 * thread can reap it because we set its state to EXIT_DEAD. 1220 */ 1221 read_unlock(&tasklist_lock); 1222 1223 retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0; 1224 status = (p->signal->flags & SIGNAL_GROUP_EXIT) 1225 ? p->signal->group_exit_code : p->exit_code; 1226 if (!retval && stat_addr) 1227 retval = put_user(status, stat_addr); 1228 if (!retval && infop) 1229 retval = put_user(SIGCHLD, &infop->si_signo); 1230 if (!retval && infop) 1231 retval = put_user(0, &infop->si_errno); 1232 if (!retval && infop) { 1233 int why; 1234 1235 if ((status & 0x7f) == 0) { 1236 why = CLD_EXITED; 1237 status >>= 8; 1238 } else { 1239 why = (status & 0x80) ? CLD_DUMPED : CLD_KILLED; 1240 status &= 0x7f; 1241 } 1242 retval = put_user((short)why, &infop->si_code); 1243 if (!retval) 1244 retval = put_user(status, &infop->si_status); 1245 } 1246 if (!retval && infop) 1247 retval = put_user(p->pid, &infop->si_pid); 1248 if (!retval && infop) 1249 retval = put_user(p->uid, &infop->si_uid); 1250 if (retval) { 1251 // TODO: is this safe? 1252 p->exit_state = EXIT_ZOMBIE; 1253 return retval; 1254 } 1255 retval = p->pid; 1256 if (p->real_parent != p->parent) { 1257 write_lock_irq(&tasklist_lock); 1258 /* Double-check with lock held. */ 1259 if (p->real_parent != p->parent) { 1260 __ptrace_unlink(p); 1261 // TODO: is this safe? 1262 p->exit_state = EXIT_ZOMBIE; 1263 /* 1264 * If this is not a detached task, notify the parent. 1265 * If it's still not detached after that, don't release 1266 * it now. 1267 */ 1268 if (p->exit_signal != -1) { 1269 do_notify_parent(p, p->exit_signal); 1270 if (p->exit_signal != -1) 1271 p = NULL; 1272 } 1273 } 1274 write_unlock_irq(&tasklist_lock); 1275 } 1276 if (p != NULL) 1277 release_task(p); 1278 BUG_ON(!retval); 1279 return retval; 1280 } 1281 1282 /* 1283 * Handle sys_wait4 work for one task in state TASK_STOPPED. We hold 1284 * read_lock(&tasklist_lock) on entry. If we return zero, we still hold 1285 * the lock and this task is uninteresting. If we return nonzero, we have 1286 * released the lock and the system call should return. 1287 */ 1288 static int wait_task_stopped(struct task_struct *p, int delayed_group_leader, 1289 int noreap, struct siginfo __user *infop, 1290 int __user *stat_addr, struct rusage __user *ru) 1291 { 1292 int retval, exit_code; 1293 1294 if (!p->exit_code) 1295 return 0; 1296 if (delayed_group_leader && !(p->ptrace & PT_PTRACED) && 1297 p->signal && p->signal->group_stop_count > 0) 1298 /* 1299 * A group stop is in progress and this is the group leader. 1300 * We won't report until all threads have stopped. 1301 */ 1302 return 0; 1303 1304 /* 1305 * Now we are pretty sure this task is interesting. 1306 * Make sure it doesn't get reaped out from under us while we 1307 * give up the lock and then examine it below. We don't want to 1308 * keep holding onto the tasklist_lock while we call getrusage and 1309 * possibly take page faults for user memory. 1310 */ 1311 get_task_struct(p); 1312 read_unlock(&tasklist_lock); 1313 1314 if (unlikely(noreap)) { 1315 pid_t pid = p->pid; 1316 uid_t uid = p->uid; 1317 int why = (p->ptrace & PT_PTRACED) ? CLD_TRAPPED : CLD_STOPPED; 1318 1319 exit_code = p->exit_code; 1320 if (unlikely(!exit_code) || 1321 unlikely(p->state & TASK_TRACED)) 1322 goto bail_ref; 1323 return wait_noreap_copyout(p, pid, uid, 1324 why, (exit_code << 8) | 0x7f, 1325 infop, ru); 1326 } 1327 1328 write_lock_irq(&tasklist_lock); 1329 1330 /* 1331 * This uses xchg to be atomic with the thread resuming and setting 1332 * it. It must also be done with the write lock held to prevent a 1333 * race with the EXIT_ZOMBIE case. 1334 */ 1335 exit_code = xchg(&p->exit_code, 0); 1336 if (unlikely(p->exit_state)) { 1337 /* 1338 * The task resumed and then died. Let the next iteration 1339 * catch it in EXIT_ZOMBIE. Note that exit_code might 1340 * already be zero here if it resumed and did _exit(0). 1341 * The task itself is dead and won't touch exit_code again; 1342 * other processors in this function are locked out. 1343 */ 1344 p->exit_code = exit_code; 1345 exit_code = 0; 1346 } 1347 if (unlikely(exit_code == 0)) { 1348 /* 1349 * Another thread in this function got to it first, or it 1350 * resumed, or it resumed and then died. 1351 */ 1352 write_unlock_irq(&tasklist_lock); 1353 bail_ref: 1354 put_task_struct(p); 1355 /* 1356 * We are returning to the wait loop without having successfully 1357 * removed the process and having released the lock. We cannot 1358 * continue, since the "p" task pointer is potentially stale. 1359 * 1360 * Return -EAGAIN, and do_wait() will restart the loop from the 1361 * beginning. Do _not_ re-acquire the lock. 1362 */ 1363 return -EAGAIN; 1364 } 1365 1366 /* move to end of parent's list to avoid starvation */ 1367 remove_parent(p); 1368 add_parent(p); 1369 1370 write_unlock_irq(&tasklist_lock); 1371 1372 retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0; 1373 if (!retval && stat_addr) 1374 retval = put_user((exit_code << 8) | 0x7f, stat_addr); 1375 if (!retval && infop) 1376 retval = put_user(SIGCHLD, &infop->si_signo); 1377 if (!retval && infop) 1378 retval = put_user(0, &infop->si_errno); 1379 if (!retval && infop) 1380 retval = put_user((short)((p->ptrace & PT_PTRACED) 1381 ? CLD_TRAPPED : CLD_STOPPED), 1382 &infop->si_code); 1383 if (!retval && infop) 1384 retval = put_user(exit_code, &infop->si_status); 1385 if (!retval && infop) 1386 retval = put_user(p->pid, &infop->si_pid); 1387 if (!retval && infop) 1388 retval = put_user(p->uid, &infop->si_uid); 1389 if (!retval) 1390 retval = p->pid; 1391 put_task_struct(p); 1392 1393 BUG_ON(!retval); 1394 return retval; 1395 } 1396 1397 /* 1398 * Handle do_wait work for one task in a live, non-stopped state. 1399 * read_lock(&tasklist_lock) on entry. If we return zero, we still hold 1400 * the lock and this task is uninteresting. If we return nonzero, we have 1401 * released the lock and the system call should return. 1402 */ 1403 static int wait_task_continued(struct task_struct *p, int noreap, 1404 struct siginfo __user *infop, 1405 int __user *stat_addr, struct rusage __user *ru) 1406 { 1407 int retval; 1408 pid_t pid; 1409 uid_t uid; 1410 1411 if (unlikely(!p->signal)) 1412 return 0; 1413 1414 if (!(p->signal->flags & SIGNAL_STOP_CONTINUED)) 1415 return 0; 1416 1417 spin_lock_irq(&p->sighand->siglock); 1418 /* Re-check with the lock held. */ 1419 if (!(p->signal->flags & SIGNAL_STOP_CONTINUED)) { 1420 spin_unlock_irq(&p->sighand->siglock); 1421 return 0; 1422 } 1423 if (!noreap) 1424 p->signal->flags &= ~SIGNAL_STOP_CONTINUED; 1425 spin_unlock_irq(&p->sighand->siglock); 1426 1427 pid = p->pid; 1428 uid = p->uid; 1429 get_task_struct(p); 1430 read_unlock(&tasklist_lock); 1431 1432 if (!infop) { 1433 retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0; 1434 put_task_struct(p); 1435 if (!retval && stat_addr) 1436 retval = put_user(0xffff, stat_addr); 1437 if (!retval) 1438 retval = p->pid; 1439 } else { 1440 retval = wait_noreap_copyout(p, pid, uid, 1441 CLD_CONTINUED, SIGCONT, 1442 infop, ru); 1443 BUG_ON(retval == 0); 1444 } 1445 1446 return retval; 1447 } 1448 1449 1450 static inline int my_ptrace_child(struct task_struct *p) 1451 { 1452 if (!(p->ptrace & PT_PTRACED)) 1453 return 0; 1454 if (!(p->ptrace & PT_ATTACHED)) 1455 return 1; 1456 /* 1457 * This child was PTRACE_ATTACH'd. We should be seeing it only if 1458 * we are the attacher. If we are the real parent, this is a race 1459 * inside ptrace_attach. It is waiting for the tasklist_lock, 1460 * which we have to switch the parent links, but has already set 1461 * the flags in p->ptrace. 1462 */ 1463 return (p->parent != p->real_parent); 1464 } 1465 1466 static long do_wait(pid_t pid, int options, struct siginfo __user *infop, 1467 int __user *stat_addr, struct rusage __user *ru) 1468 { 1469 DECLARE_WAITQUEUE(wait, current); 1470 struct task_struct *tsk; 1471 int flag, retval; 1472 int allowed, denied; 1473 1474 add_wait_queue(¤t->signal->wait_chldexit,&wait); 1475 repeat: 1476 /* 1477 * We will set this flag if we see any child that might later 1478 * match our criteria, even if we are not able to reap it yet. 1479 */ 1480 flag = 0; 1481 allowed = denied = 0; 1482 current->state = TASK_INTERRUPTIBLE; 1483 read_lock(&tasklist_lock); 1484 tsk = current; 1485 do { 1486 struct task_struct *p; 1487 struct list_head *_p; 1488 int ret; 1489 1490 list_for_each(_p,&tsk->children) { 1491 p = list_entry(_p, struct task_struct, sibling); 1492 1493 ret = eligible_child(pid, options, p); 1494 if (!ret) 1495 continue; 1496 1497 if (unlikely(ret < 0)) { 1498 denied = ret; 1499 continue; 1500 } 1501 allowed = 1; 1502 1503 switch (p->state) { 1504 case TASK_TRACED: 1505 /* 1506 * When we hit the race with PTRACE_ATTACH, 1507 * we will not report this child. But the 1508 * race means it has not yet been moved to 1509 * our ptrace_children list, so we need to 1510 * set the flag here to avoid a spurious ECHILD 1511 * when the race happens with the only child. 1512 */ 1513 flag = 1; 1514 if (!my_ptrace_child(p)) 1515 continue; 1516 /*FALLTHROUGH*/ 1517 case TASK_STOPPED: 1518 /* 1519 * It's stopped now, so it might later 1520 * continue, exit, or stop again. 1521 */ 1522 flag = 1; 1523 if (!(options & WUNTRACED) && 1524 !my_ptrace_child(p)) 1525 continue; 1526 retval = wait_task_stopped(p, ret == 2, 1527 (options & WNOWAIT), 1528 infop, 1529 stat_addr, ru); 1530 if (retval == -EAGAIN) 1531 goto repeat; 1532 if (retval != 0) /* He released the lock. */ 1533 goto end; 1534 break; 1535 default: 1536 // case EXIT_DEAD: 1537 if (p->exit_state == EXIT_DEAD) 1538 continue; 1539 // case EXIT_ZOMBIE: 1540 if (p->exit_state == EXIT_ZOMBIE) { 1541 /* 1542 * Eligible but we cannot release 1543 * it yet: 1544 */ 1545 if (ret == 2) 1546 goto check_continued; 1547 if (!likely(options & WEXITED)) 1548 continue; 1549 retval = wait_task_zombie( 1550 p, (options & WNOWAIT), 1551 infop, stat_addr, ru); 1552 /* He released the lock. */ 1553 if (retval != 0) 1554 goto end; 1555 break; 1556 } 1557 check_continued: 1558 /* 1559 * It's running now, so it might later 1560 * exit, stop, or stop and then continue. 1561 */ 1562 flag = 1; 1563 if (!unlikely(options & WCONTINUED)) 1564 continue; 1565 retval = wait_task_continued( 1566 p, (options & WNOWAIT), 1567 infop, stat_addr, ru); 1568 if (retval != 0) /* He released the lock. */ 1569 goto end; 1570 break; 1571 } 1572 } 1573 if (!flag) { 1574 list_for_each(_p, &tsk->ptrace_children) { 1575 p = list_entry(_p, struct task_struct, 1576 ptrace_list); 1577 if (!eligible_child(pid, options, p)) 1578 continue; 1579 flag = 1; 1580 break; 1581 } 1582 } 1583 if (options & __WNOTHREAD) 1584 break; 1585 tsk = next_thread(tsk); 1586 BUG_ON(tsk->signal != current->signal); 1587 } while (tsk != current); 1588 1589 read_unlock(&tasklist_lock); 1590 if (flag) { 1591 retval = 0; 1592 if (options & WNOHANG) 1593 goto end; 1594 retval = -ERESTARTSYS; 1595 if (signal_pending(current)) 1596 goto end; 1597 schedule(); 1598 goto repeat; 1599 } 1600 retval = -ECHILD; 1601 if (unlikely(denied) && !allowed) 1602 retval = denied; 1603 end: 1604 current->state = TASK_RUNNING; 1605 remove_wait_queue(¤t->signal->wait_chldexit,&wait); 1606 if (infop) { 1607 if (retval > 0) 1608 retval = 0; 1609 else { 1610 /* 1611 * For a WNOHANG return, clear out all the fields 1612 * we would set so the user can easily tell the 1613 * difference. 1614 */ 1615 if (!retval) 1616 retval = put_user(0, &infop->si_signo); 1617 if (!retval) 1618 retval = put_user(0, &infop->si_errno); 1619 if (!retval) 1620 retval = put_user(0, &infop->si_code); 1621 if (!retval) 1622 retval = put_user(0, &infop->si_pid); 1623 if (!retval) 1624 retval = put_user(0, &infop->si_uid); 1625 if (!retval) 1626 retval = put_user(0, &infop->si_status); 1627 } 1628 } 1629 return retval; 1630 } 1631 1632 asmlinkage long sys_waitid(int which, pid_t pid, 1633 struct siginfo __user *infop, int options, 1634 struct rusage __user *ru) 1635 { 1636 long ret; 1637 1638 if (options & ~(WNOHANG|WNOWAIT|WEXITED|WSTOPPED|WCONTINUED)) 1639 return -EINVAL; 1640 if (!(options & (WEXITED|WSTOPPED|WCONTINUED))) 1641 return -EINVAL; 1642 1643 switch (which) { 1644 case P_ALL: 1645 pid = -1; 1646 break; 1647 case P_PID: 1648 if (pid <= 0) 1649 return -EINVAL; 1650 break; 1651 case P_PGID: 1652 if (pid <= 0) 1653 return -EINVAL; 1654 pid = -pid; 1655 break; 1656 default: 1657 return -EINVAL; 1658 } 1659 1660 ret = do_wait(pid, options, infop, NULL, ru); 1661 1662 /* avoid REGPARM breakage on x86: */ 1663 prevent_tail_call(ret); 1664 return ret; 1665 } 1666 1667 asmlinkage long sys_wait4(pid_t pid, int __user *stat_addr, 1668 int options, struct rusage __user *ru) 1669 { 1670 long ret; 1671 1672 if (options & ~(WNOHANG|WUNTRACED|WCONTINUED| 1673 __WNOTHREAD|__WCLONE|__WALL)) 1674 return -EINVAL; 1675 ret = do_wait(pid, options | WEXITED, NULL, stat_addr, ru); 1676 1677 /* avoid REGPARM breakage on x86: */ 1678 prevent_tail_call(ret); 1679 return ret; 1680 } 1681 1682 #ifdef __ARCH_WANT_SYS_WAITPID 1683 1684 /* 1685 * sys_waitpid() remains for compatibility. waitpid() should be 1686 * implemented by calling sys_wait4() from libc.a. 1687 */ 1688 asmlinkage long sys_waitpid(pid_t pid, int __user *stat_addr, int options) 1689 { 1690 return sys_wait4(pid, stat_addr, options, NULL); 1691 } 1692 1693 #endif 1694