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