1 /* 2 * linux/kernel/exit.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 */ 6 7 #include <linux/config.h> 8 #include <linux/mm.h> 9 #include <linux/slab.h> 10 #include <linux/interrupt.h> 11 #include <linux/smp_lock.h> 12 #include <linux/module.h> 13 #include <linux/capability.h> 14 #include <linux/completion.h> 15 #include <linux/personality.h> 16 #include <linux/tty.h> 17 #include <linux/namespace.h> 18 #include <linux/key.h> 19 #include <linux/security.h> 20 #include <linux/cpu.h> 21 #include <linux/acct.h> 22 #include <linux/file.h> 23 #include <linux/binfmts.h> 24 #include <linux/ptrace.h> 25 #include <linux/profile.h> 26 #include <linux/mount.h> 27 #include <linux/proc_fs.h> 28 #include <linux/mempolicy.h> 29 #include <linux/cpuset.h> 30 #include <linux/syscalls.h> 31 #include <linux/signal.h> 32 #include <linux/posix-timers.h> 33 #include <linux/cn_proc.h> 34 #include <linux/mutex.h> 35 #include <linux/futex.h> 36 #include <linux/compat.h> 37 38 #include <asm/uaccess.h> 39 #include <asm/unistd.h> 40 #include <asm/pgtable.h> 41 #include <asm/mmu_context.h> 42 43 extern void sem_exit (void); 44 extern struct task_struct *child_reaper; 45 46 int getrusage(struct task_struct *, int, struct rusage __user *); 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_init(&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 void release_task(struct task_struct * p) 131 { 132 int zap_leader; 133 task_t *leader; 134 struct dentry *proc_dentry; 135 136 repeat: 137 atomic_dec(&p->user->processes); 138 spin_lock(&p->proc_lock); 139 proc_dentry = proc_pid_unhash(p); 140 write_lock_irq(&tasklist_lock); 141 ptrace_unlink(p); 142 BUG_ON(!list_empty(&p->ptrace_list) || !list_empty(&p->ptrace_children)); 143 __exit_signal(p); 144 145 /* 146 * If we are the last non-leader member of the thread 147 * group, and the leader is zombie, then notify the 148 * group leader's parent process. (if it wants notification.) 149 */ 150 zap_leader = 0; 151 leader = p->group_leader; 152 if (leader != p && thread_group_empty(leader) && leader->exit_state == EXIT_ZOMBIE) { 153 BUG_ON(leader->exit_signal == -1); 154 do_notify_parent(leader, leader->exit_signal); 155 /* 156 * If we were the last child thread and the leader has 157 * exited already, and the leader's parent ignores SIGCHLD, 158 * then we are the one who should release the leader. 159 * 160 * do_notify_parent() will have marked it self-reaping in 161 * that case. 162 */ 163 zap_leader = (leader->exit_signal == -1); 164 } 165 166 sched_exit(p); 167 write_unlock_irq(&tasklist_lock); 168 spin_unlock(&p->proc_lock); 169 proc_pid_flush(proc_dentry); 170 release_thread(p); 171 put_task_struct(p); 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, task_t *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 if (mm != tsk->active_mm) BUG(); 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 choose_new_parent(task_t *p, task_t *reaper) 586 { 587 /* 588 * Make sure we're not reparenting to ourselves and that 589 * the parent is not a zombie. 590 */ 591 BUG_ON(p == reaper || reaper->exit_state); 592 p->real_parent = reaper; 593 } 594 595 static void reparent_thread(task_t *p, task_t *father, int traced) 596 { 597 /* We don't want people slaying init. */ 598 if (p->exit_signal != -1) 599 p->exit_signal = SIGCHLD; 600 601 if (p->pdeath_signal) 602 /* We already hold the tasklist_lock here. */ 603 group_send_sig_info(p->pdeath_signal, SEND_SIG_NOINFO, p); 604 605 /* Move the child from its dying parent to the new one. */ 606 if (unlikely(traced)) { 607 /* Preserve ptrace links if someone else is tracing this child. */ 608 list_del_init(&p->ptrace_list); 609 if (p->parent != p->real_parent) 610 list_add(&p->ptrace_list, &p->real_parent->ptrace_children); 611 } else { 612 /* If this child is being traced, then we're the one tracing it 613 * anyway, so let go of it. 614 */ 615 p->ptrace = 0; 616 remove_parent(p); 617 p->parent = p->real_parent; 618 add_parent(p); 619 620 /* If we'd notified the old parent about this child's death, 621 * also notify the new parent. 622 */ 623 if (p->exit_state == EXIT_ZOMBIE && p->exit_signal != -1 && 624 thread_group_empty(p)) 625 do_notify_parent(p, p->exit_signal); 626 else if (p->state == TASK_TRACED) { 627 /* 628 * If it was at a trace stop, turn it into 629 * a normal stop since it's no longer being 630 * traced. 631 */ 632 ptrace_untrace(p); 633 } 634 } 635 636 /* 637 * process group orphan check 638 * Case ii: Our child is in a different pgrp 639 * than we are, and it was the only connection 640 * outside, so the child pgrp is now orphaned. 641 */ 642 if ((process_group(p) != process_group(father)) && 643 (p->signal->session == father->signal->session)) { 644 int pgrp = process_group(p); 645 646 if (will_become_orphaned_pgrp(pgrp, NULL) && has_stopped_jobs(pgrp)) { 647 __kill_pg_info(SIGHUP, SEND_SIG_PRIV, pgrp); 648 __kill_pg_info(SIGCONT, SEND_SIG_PRIV, pgrp); 649 } 650 } 651 } 652 653 /* 654 * When we die, we re-parent all our children. 655 * Try to give them to another thread in our thread 656 * group, and if no such member exists, give it to 657 * the global child reaper process (ie "init") 658 */ 659 static void forget_original_parent(struct task_struct * father, 660 struct list_head *to_release) 661 { 662 struct task_struct *p, *reaper = father; 663 struct list_head *_p, *_n; 664 665 do { 666 reaper = next_thread(reaper); 667 if (reaper == father) { 668 reaper = child_reaper; 669 break; 670 } 671 } while (reaper->exit_state); 672 673 /* 674 * There are only two places where our children can be: 675 * 676 * - in our child list 677 * - in our ptraced child list 678 * 679 * Search them and reparent children. 680 */ 681 list_for_each_safe(_p, _n, &father->children) { 682 int ptrace; 683 p = list_entry(_p,struct task_struct,sibling); 684 685 ptrace = p->ptrace; 686 687 /* if father isn't the real parent, then ptrace must be enabled */ 688 BUG_ON(father != p->real_parent && !ptrace); 689 690 if (father == p->real_parent) { 691 /* reparent with a reaper, real father it's us */ 692 choose_new_parent(p, reaper); 693 reparent_thread(p, father, 0); 694 } else { 695 /* reparent ptraced task to its real parent */ 696 __ptrace_unlink (p); 697 if (p->exit_state == EXIT_ZOMBIE && p->exit_signal != -1 && 698 thread_group_empty(p)) 699 do_notify_parent(p, p->exit_signal); 700 } 701 702 /* 703 * if the ptraced child is a zombie with exit_signal == -1 704 * we must collect it before we exit, or it will remain 705 * zombie forever since we prevented it from self-reap itself 706 * while it was being traced by us, to be able to see it in wait4. 707 */ 708 if (unlikely(ptrace && p->exit_state == EXIT_ZOMBIE && p->exit_signal == -1)) 709 list_add(&p->ptrace_list, to_release); 710 } 711 list_for_each_safe(_p, _n, &father->ptrace_children) { 712 p = list_entry(_p,struct task_struct,ptrace_list); 713 choose_new_parent(p, reaper); 714 reparent_thread(p, father, 1); 715 } 716 } 717 718 /* 719 * Send signals to all our closest relatives so that they know 720 * to properly mourn us.. 721 */ 722 static void exit_notify(struct task_struct *tsk) 723 { 724 int state; 725 struct task_struct *t; 726 struct list_head ptrace_dead, *_p, *_n; 727 728 if (signal_pending(tsk) && !(tsk->signal->flags & SIGNAL_GROUP_EXIT) 729 && !thread_group_empty(tsk)) { 730 /* 731 * This occurs when there was a race between our exit 732 * syscall and a group signal choosing us as the one to 733 * wake up. It could be that we are the only thread 734 * alerted to check for pending signals, but another thread 735 * should be woken now to take the signal since we will not. 736 * Now we'll wake all the threads in the group just to make 737 * sure someone gets all the pending signals. 738 */ 739 read_lock(&tasklist_lock); 740 spin_lock_irq(&tsk->sighand->siglock); 741 for (t = next_thread(tsk); t != tsk; t = next_thread(t)) 742 if (!signal_pending(t) && !(t->flags & PF_EXITING)) { 743 recalc_sigpending_tsk(t); 744 if (signal_pending(t)) 745 signal_wake_up(t, 0); 746 } 747 spin_unlock_irq(&tsk->sighand->siglock); 748 read_unlock(&tasklist_lock); 749 } 750 751 write_lock_irq(&tasklist_lock); 752 753 /* 754 * This does two things: 755 * 756 * A. Make init inherit all the child processes 757 * B. Check to see if any process groups have become orphaned 758 * as a result of our exiting, and if they have any stopped 759 * jobs, send them a SIGHUP and then a SIGCONT. (POSIX 3.2.2.2) 760 */ 761 762 INIT_LIST_HEAD(&ptrace_dead); 763 forget_original_parent(tsk, &ptrace_dead); 764 BUG_ON(!list_empty(&tsk->children)); 765 BUG_ON(!list_empty(&tsk->ptrace_children)); 766 767 /* 768 * Check to see if any process groups have become orphaned 769 * as a result of our exiting, and if they have any stopped 770 * jobs, send them a SIGHUP and then a SIGCONT. (POSIX 3.2.2.2) 771 * 772 * Case i: Our father is in a different pgrp than we are 773 * and we were the only connection outside, so our pgrp 774 * is about to become orphaned. 775 */ 776 777 t = tsk->real_parent; 778 779 if ((process_group(t) != process_group(tsk)) && 780 (t->signal->session == tsk->signal->session) && 781 will_become_orphaned_pgrp(process_group(tsk), tsk) && 782 has_stopped_jobs(process_group(tsk))) { 783 __kill_pg_info(SIGHUP, SEND_SIG_PRIV, process_group(tsk)); 784 __kill_pg_info(SIGCONT, SEND_SIG_PRIV, process_group(tsk)); 785 } 786 787 /* Let father know we died 788 * 789 * Thread signals are configurable, but you aren't going to use 790 * that to send signals to arbitary processes. 791 * That stops right now. 792 * 793 * If the parent exec id doesn't match the exec id we saved 794 * when we started then we know the parent has changed security 795 * domain. 796 * 797 * If our self_exec id doesn't match our parent_exec_id then 798 * we have changed execution domain as these two values started 799 * the same after a fork. 800 * 801 */ 802 803 if (tsk->exit_signal != SIGCHLD && tsk->exit_signal != -1 && 804 ( tsk->parent_exec_id != t->self_exec_id || 805 tsk->self_exec_id != tsk->parent_exec_id) 806 && !capable(CAP_KILL)) 807 tsk->exit_signal = SIGCHLD; 808 809 810 /* If something other than our normal parent is ptracing us, then 811 * send it a SIGCHLD instead of honoring exit_signal. exit_signal 812 * only has special meaning to our real parent. 813 */ 814 if (tsk->exit_signal != -1 && thread_group_empty(tsk)) { 815 int signal = tsk->parent == tsk->real_parent ? tsk->exit_signal : SIGCHLD; 816 do_notify_parent(tsk, signal); 817 } else if (tsk->ptrace) { 818 do_notify_parent(tsk, SIGCHLD); 819 } 820 821 state = EXIT_ZOMBIE; 822 if (tsk->exit_signal == -1 && 823 (likely(tsk->ptrace == 0) || 824 unlikely(tsk->parent->signal->flags & SIGNAL_GROUP_EXIT))) 825 state = EXIT_DEAD; 826 tsk->exit_state = state; 827 828 write_unlock_irq(&tasklist_lock); 829 830 list_for_each_safe(_p, _n, &ptrace_dead) { 831 list_del_init(_p); 832 t = list_entry(_p,struct task_struct,ptrace_list); 833 release_task(t); 834 } 835 836 /* If the process is dead, release it - nobody will wait for it */ 837 if (state == EXIT_DEAD) 838 release_task(tsk); 839 } 840 841 fastcall NORET_TYPE void do_exit(long code) 842 { 843 struct task_struct *tsk = current; 844 int group_dead; 845 846 profile_task_exit(tsk); 847 848 WARN_ON(atomic_read(&tsk->fs_excl)); 849 850 if (unlikely(in_interrupt())) 851 panic("Aiee, killing interrupt handler!"); 852 if (unlikely(!tsk->pid)) 853 panic("Attempted to kill the idle task!"); 854 if (unlikely(tsk == child_reaper)) 855 panic("Attempted to kill init!"); 856 857 if (unlikely(current->ptrace & PT_TRACE_EXIT)) { 858 current->ptrace_message = code; 859 ptrace_notify((PTRACE_EVENT_EXIT << 8) | SIGTRAP); 860 } 861 862 /* 863 * We're taking recursive faults here in do_exit. Safest is to just 864 * leave this task alone and wait for reboot. 865 */ 866 if (unlikely(tsk->flags & PF_EXITING)) { 867 printk(KERN_ALERT 868 "Fixing recursive fault but reboot is needed!\n"); 869 if (tsk->io_context) 870 exit_io_context(); 871 set_current_state(TASK_UNINTERRUPTIBLE); 872 schedule(); 873 } 874 875 tsk->flags |= PF_EXITING; 876 877 /* 878 * Make sure we don't try to process any timer firings 879 * while we are already exiting. 880 */ 881 tsk->it_virt_expires = cputime_zero; 882 tsk->it_prof_expires = cputime_zero; 883 tsk->it_sched_expires = 0; 884 885 if (unlikely(in_atomic())) 886 printk(KERN_INFO "note: %s[%d] exited with preempt_count %d\n", 887 current->comm, current->pid, 888 preempt_count()); 889 890 acct_update_integrals(tsk); 891 if (tsk->mm) { 892 update_hiwater_rss(tsk->mm); 893 update_hiwater_vm(tsk->mm); 894 } 895 group_dead = atomic_dec_and_test(&tsk->signal->live); 896 if (group_dead) { 897 hrtimer_cancel(&tsk->signal->real_timer); 898 exit_itimers(tsk->signal); 899 acct_process(code); 900 } 901 if (unlikely(tsk->robust_list)) 902 exit_robust_list(tsk); 903 #ifdef CONFIG_COMPAT 904 if (unlikely(tsk->compat_robust_list)) 905 compat_exit_robust_list(tsk); 906 #endif 907 exit_mm(tsk); 908 909 exit_sem(tsk); 910 __exit_files(tsk); 911 __exit_fs(tsk); 912 exit_namespace(tsk); 913 exit_thread(); 914 cpuset_exit(tsk); 915 exit_keys(tsk); 916 917 if (group_dead && tsk->signal->leader) 918 disassociate_ctty(1); 919 920 module_put(task_thread_info(tsk)->exec_domain->module); 921 if (tsk->binfmt) 922 module_put(tsk->binfmt->module); 923 924 tsk->exit_code = code; 925 proc_exit_connector(tsk); 926 exit_notify(tsk); 927 #ifdef CONFIG_NUMA 928 mpol_free(tsk->mempolicy); 929 tsk->mempolicy = NULL; 930 #endif 931 /* 932 * If DEBUG_MUTEXES is on, make sure we are holding no locks: 933 */ 934 mutex_debug_check_no_locks_held(tsk); 935 936 if (tsk->io_context) 937 exit_io_context(); 938 939 /* PF_DEAD causes final put_task_struct after we schedule. */ 940 preempt_disable(); 941 BUG_ON(tsk->flags & PF_DEAD); 942 tsk->flags |= PF_DEAD; 943 944 schedule(); 945 BUG(); 946 /* Avoid "noreturn function does return". */ 947 for (;;) ; 948 } 949 950 EXPORT_SYMBOL_GPL(do_exit); 951 952 NORET_TYPE void complete_and_exit(struct completion *comp, long code) 953 { 954 if (comp) 955 complete(comp); 956 957 do_exit(code); 958 } 959 960 EXPORT_SYMBOL(complete_and_exit); 961 962 asmlinkage long sys_exit(int error_code) 963 { 964 do_exit((error_code&0xff)<<8); 965 } 966 967 /* 968 * Take down every thread in the group. This is called by fatal signals 969 * as well as by sys_exit_group (below). 970 */ 971 NORET_TYPE void 972 do_group_exit(int exit_code) 973 { 974 BUG_ON(exit_code & 0x80); /* core dumps don't get here */ 975 976 if (current->signal->flags & SIGNAL_GROUP_EXIT) 977 exit_code = current->signal->group_exit_code; 978 else if (!thread_group_empty(current)) { 979 struct signal_struct *const sig = current->signal; 980 struct sighand_struct *const sighand = current->sighand; 981 spin_lock_irq(&sighand->siglock); 982 if (sig->flags & SIGNAL_GROUP_EXIT) 983 /* Another thread got here before we took the lock. */ 984 exit_code = sig->group_exit_code; 985 else { 986 sig->group_exit_code = exit_code; 987 zap_other_threads(current); 988 } 989 spin_unlock_irq(&sighand->siglock); 990 } 991 992 do_exit(exit_code); 993 /* NOTREACHED */ 994 } 995 996 /* 997 * this kills every thread in the thread group. Note that any externally 998 * wait4()-ing process will get the correct exit code - even if this 999 * thread is not the thread group leader. 1000 */ 1001 asmlinkage void sys_exit_group(int error_code) 1002 { 1003 do_group_exit((error_code & 0xff) << 8); 1004 } 1005 1006 static int eligible_child(pid_t pid, int options, task_t *p) 1007 { 1008 if (pid > 0) { 1009 if (p->pid != pid) 1010 return 0; 1011 } else if (!pid) { 1012 if (process_group(p) != process_group(current)) 1013 return 0; 1014 } else if (pid != -1) { 1015 if (process_group(p) != -pid) 1016 return 0; 1017 } 1018 1019 /* 1020 * Do not consider detached threads that are 1021 * not ptraced: 1022 */ 1023 if (p->exit_signal == -1 && !p->ptrace) 1024 return 0; 1025 1026 /* Wait for all children (clone and not) if __WALL is set; 1027 * otherwise, wait for clone children *only* if __WCLONE is 1028 * set; otherwise, wait for non-clone children *only*. (Note: 1029 * A "clone" child here is one that reports to its parent 1030 * using a signal other than SIGCHLD.) */ 1031 if (((p->exit_signal != SIGCHLD) ^ ((options & __WCLONE) != 0)) 1032 && !(options & __WALL)) 1033 return 0; 1034 /* 1035 * Do not consider thread group leaders that are 1036 * in a non-empty thread group: 1037 */ 1038 if (current->tgid != p->tgid && delay_group_leader(p)) 1039 return 2; 1040 1041 if (security_task_wait(p)) 1042 return 0; 1043 1044 return 1; 1045 } 1046 1047 static int wait_noreap_copyout(task_t *p, pid_t pid, uid_t uid, 1048 int why, int status, 1049 struct siginfo __user *infop, 1050 struct rusage __user *rusagep) 1051 { 1052 int retval = rusagep ? getrusage(p, RUSAGE_BOTH, rusagep) : 0; 1053 put_task_struct(p); 1054 if (!retval) 1055 retval = put_user(SIGCHLD, &infop->si_signo); 1056 if (!retval) 1057 retval = put_user(0, &infop->si_errno); 1058 if (!retval) 1059 retval = put_user((short)why, &infop->si_code); 1060 if (!retval) 1061 retval = put_user(pid, &infop->si_pid); 1062 if (!retval) 1063 retval = put_user(uid, &infop->si_uid); 1064 if (!retval) 1065 retval = put_user(status, &infop->si_status); 1066 if (!retval) 1067 retval = pid; 1068 return retval; 1069 } 1070 1071 /* 1072 * Handle sys_wait4 work for one task in state EXIT_ZOMBIE. We hold 1073 * read_lock(&tasklist_lock) on entry. If we return zero, we still hold 1074 * the lock and this task is uninteresting. If we return nonzero, we have 1075 * released the lock and the system call should return. 1076 */ 1077 static int wait_task_zombie(task_t *p, int noreap, 1078 struct siginfo __user *infop, 1079 int __user *stat_addr, struct rusage __user *ru) 1080 { 1081 unsigned long state; 1082 int retval; 1083 int status; 1084 1085 if (unlikely(noreap)) { 1086 pid_t pid = p->pid; 1087 uid_t uid = p->uid; 1088 int exit_code = p->exit_code; 1089 int why, status; 1090 1091 if (unlikely(p->exit_state != EXIT_ZOMBIE)) 1092 return 0; 1093 if (unlikely(p->exit_signal == -1 && p->ptrace == 0)) 1094 return 0; 1095 get_task_struct(p); 1096 read_unlock(&tasklist_lock); 1097 if ((exit_code & 0x7f) == 0) { 1098 why = CLD_EXITED; 1099 status = exit_code >> 8; 1100 } else { 1101 why = (exit_code & 0x80) ? CLD_DUMPED : CLD_KILLED; 1102 status = exit_code & 0x7f; 1103 } 1104 return wait_noreap_copyout(p, pid, uid, why, 1105 status, infop, ru); 1106 } 1107 1108 /* 1109 * Try to move the task's state to DEAD 1110 * only one thread is allowed to do this: 1111 */ 1112 state = xchg(&p->exit_state, EXIT_DEAD); 1113 if (state != EXIT_ZOMBIE) { 1114 BUG_ON(state != EXIT_DEAD); 1115 return 0; 1116 } 1117 if (unlikely(p->exit_signal == -1 && p->ptrace == 0)) { 1118 /* 1119 * This can only happen in a race with a ptraced thread 1120 * dying on another processor. 1121 */ 1122 return 0; 1123 } 1124 1125 if (likely(p->real_parent == p->parent) && likely(p->signal)) { 1126 struct signal_struct *psig; 1127 struct signal_struct *sig; 1128 1129 /* 1130 * The resource counters for the group leader are in its 1131 * own task_struct. Those for dead threads in the group 1132 * are in its signal_struct, as are those for the child 1133 * processes it has previously reaped. All these 1134 * accumulate in the parent's signal_struct c* fields. 1135 * 1136 * We don't bother to take a lock here to protect these 1137 * p->signal fields, because they are only touched by 1138 * __exit_signal, which runs with tasklist_lock 1139 * write-locked anyway, and so is excluded here. We do 1140 * need to protect the access to p->parent->signal fields, 1141 * as other threads in the parent group can be right 1142 * here reaping other children at the same time. 1143 */ 1144 spin_lock_irq(&p->parent->sighand->siglock); 1145 psig = p->parent->signal; 1146 sig = p->signal; 1147 psig->cutime = 1148 cputime_add(psig->cutime, 1149 cputime_add(p->utime, 1150 cputime_add(sig->utime, 1151 sig->cutime))); 1152 psig->cstime = 1153 cputime_add(psig->cstime, 1154 cputime_add(p->stime, 1155 cputime_add(sig->stime, 1156 sig->cstime))); 1157 psig->cmin_flt += 1158 p->min_flt + sig->min_flt + sig->cmin_flt; 1159 psig->cmaj_flt += 1160 p->maj_flt + sig->maj_flt + sig->cmaj_flt; 1161 psig->cnvcsw += 1162 p->nvcsw + sig->nvcsw + sig->cnvcsw; 1163 psig->cnivcsw += 1164 p->nivcsw + sig->nivcsw + sig->cnivcsw; 1165 spin_unlock_irq(&p->parent->sighand->siglock); 1166 } 1167 1168 /* 1169 * Now we are sure this task is interesting, and no other 1170 * thread can reap it because we set its state to EXIT_DEAD. 1171 */ 1172 read_unlock(&tasklist_lock); 1173 1174 retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0; 1175 status = (p->signal->flags & SIGNAL_GROUP_EXIT) 1176 ? p->signal->group_exit_code : p->exit_code; 1177 if (!retval && stat_addr) 1178 retval = put_user(status, stat_addr); 1179 if (!retval && infop) 1180 retval = put_user(SIGCHLD, &infop->si_signo); 1181 if (!retval && infop) 1182 retval = put_user(0, &infop->si_errno); 1183 if (!retval && infop) { 1184 int why; 1185 1186 if ((status & 0x7f) == 0) { 1187 why = CLD_EXITED; 1188 status >>= 8; 1189 } else { 1190 why = (status & 0x80) ? CLD_DUMPED : CLD_KILLED; 1191 status &= 0x7f; 1192 } 1193 retval = put_user((short)why, &infop->si_code); 1194 if (!retval) 1195 retval = put_user(status, &infop->si_status); 1196 } 1197 if (!retval && infop) 1198 retval = put_user(p->pid, &infop->si_pid); 1199 if (!retval && infop) 1200 retval = put_user(p->uid, &infop->si_uid); 1201 if (retval) { 1202 // TODO: is this safe? 1203 p->exit_state = EXIT_ZOMBIE; 1204 return retval; 1205 } 1206 retval = p->pid; 1207 if (p->real_parent != p->parent) { 1208 write_lock_irq(&tasklist_lock); 1209 /* Double-check with lock held. */ 1210 if (p->real_parent != p->parent) { 1211 __ptrace_unlink(p); 1212 // TODO: is this safe? 1213 p->exit_state = EXIT_ZOMBIE; 1214 /* 1215 * If this is not a detached task, notify the parent. 1216 * If it's still not detached after that, don't release 1217 * it now. 1218 */ 1219 if (p->exit_signal != -1) { 1220 do_notify_parent(p, p->exit_signal); 1221 if (p->exit_signal != -1) 1222 p = NULL; 1223 } 1224 } 1225 write_unlock_irq(&tasklist_lock); 1226 } 1227 if (p != NULL) 1228 release_task(p); 1229 BUG_ON(!retval); 1230 return retval; 1231 } 1232 1233 /* 1234 * Handle sys_wait4 work for one task in state TASK_STOPPED. We hold 1235 * read_lock(&tasklist_lock) on entry. If we return zero, we still hold 1236 * the lock and this task is uninteresting. If we return nonzero, we have 1237 * released the lock and the system call should return. 1238 */ 1239 static int wait_task_stopped(task_t *p, int delayed_group_leader, int noreap, 1240 struct siginfo __user *infop, 1241 int __user *stat_addr, struct rusage __user *ru) 1242 { 1243 int retval, exit_code; 1244 1245 if (!p->exit_code) 1246 return 0; 1247 if (delayed_group_leader && !(p->ptrace & PT_PTRACED) && 1248 p->signal && p->signal->group_stop_count > 0) 1249 /* 1250 * A group stop is in progress and this is the group leader. 1251 * We won't report until all threads have stopped. 1252 */ 1253 return 0; 1254 1255 /* 1256 * Now we are pretty sure this task is interesting. 1257 * Make sure it doesn't get reaped out from under us while we 1258 * give up the lock and then examine it below. We don't want to 1259 * keep holding onto the tasklist_lock while we call getrusage and 1260 * possibly take page faults for user memory. 1261 */ 1262 get_task_struct(p); 1263 read_unlock(&tasklist_lock); 1264 1265 if (unlikely(noreap)) { 1266 pid_t pid = p->pid; 1267 uid_t uid = p->uid; 1268 int why = (p->ptrace & PT_PTRACED) ? CLD_TRAPPED : CLD_STOPPED; 1269 1270 exit_code = p->exit_code; 1271 if (unlikely(!exit_code) || 1272 unlikely(p->state & TASK_TRACED)) 1273 goto bail_ref; 1274 return wait_noreap_copyout(p, pid, uid, 1275 why, (exit_code << 8) | 0x7f, 1276 infop, ru); 1277 } 1278 1279 write_lock_irq(&tasklist_lock); 1280 1281 /* 1282 * This uses xchg to be atomic with the thread resuming and setting 1283 * it. It must also be done with the write lock held to prevent a 1284 * race with the EXIT_ZOMBIE case. 1285 */ 1286 exit_code = xchg(&p->exit_code, 0); 1287 if (unlikely(p->exit_state)) { 1288 /* 1289 * The task resumed and then died. Let the next iteration 1290 * catch it in EXIT_ZOMBIE. Note that exit_code might 1291 * already be zero here if it resumed and did _exit(0). 1292 * The task itself is dead and won't touch exit_code again; 1293 * other processors in this function are locked out. 1294 */ 1295 p->exit_code = exit_code; 1296 exit_code = 0; 1297 } 1298 if (unlikely(exit_code == 0)) { 1299 /* 1300 * Another thread in this function got to it first, or it 1301 * resumed, or it resumed and then died. 1302 */ 1303 write_unlock_irq(&tasklist_lock); 1304 bail_ref: 1305 put_task_struct(p); 1306 /* 1307 * We are returning to the wait loop without having successfully 1308 * removed the process and having released the lock. We cannot 1309 * continue, since the "p" task pointer is potentially stale. 1310 * 1311 * Return -EAGAIN, and do_wait() will restart the loop from the 1312 * beginning. Do _not_ re-acquire the lock. 1313 */ 1314 return -EAGAIN; 1315 } 1316 1317 /* move to end of parent's list to avoid starvation */ 1318 remove_parent(p); 1319 add_parent(p); 1320 1321 write_unlock_irq(&tasklist_lock); 1322 1323 retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0; 1324 if (!retval && stat_addr) 1325 retval = put_user((exit_code << 8) | 0x7f, stat_addr); 1326 if (!retval && infop) 1327 retval = put_user(SIGCHLD, &infop->si_signo); 1328 if (!retval && infop) 1329 retval = put_user(0, &infop->si_errno); 1330 if (!retval && infop) 1331 retval = put_user((short)((p->ptrace & PT_PTRACED) 1332 ? CLD_TRAPPED : CLD_STOPPED), 1333 &infop->si_code); 1334 if (!retval && infop) 1335 retval = put_user(exit_code, &infop->si_status); 1336 if (!retval && infop) 1337 retval = put_user(p->pid, &infop->si_pid); 1338 if (!retval && infop) 1339 retval = put_user(p->uid, &infop->si_uid); 1340 if (!retval) 1341 retval = p->pid; 1342 put_task_struct(p); 1343 1344 BUG_ON(!retval); 1345 return retval; 1346 } 1347 1348 /* 1349 * Handle do_wait work for one task in a live, non-stopped state. 1350 * read_lock(&tasklist_lock) on entry. If we return zero, we still hold 1351 * the lock and this task is uninteresting. If we return nonzero, we have 1352 * released the lock and the system call should return. 1353 */ 1354 static int wait_task_continued(task_t *p, int noreap, 1355 struct siginfo __user *infop, 1356 int __user *stat_addr, struct rusage __user *ru) 1357 { 1358 int retval; 1359 pid_t pid; 1360 uid_t uid; 1361 1362 if (unlikely(!p->signal)) 1363 return 0; 1364 1365 if (!(p->signal->flags & SIGNAL_STOP_CONTINUED)) 1366 return 0; 1367 1368 spin_lock_irq(&p->sighand->siglock); 1369 /* Re-check with the lock held. */ 1370 if (!(p->signal->flags & SIGNAL_STOP_CONTINUED)) { 1371 spin_unlock_irq(&p->sighand->siglock); 1372 return 0; 1373 } 1374 if (!noreap) 1375 p->signal->flags &= ~SIGNAL_STOP_CONTINUED; 1376 spin_unlock_irq(&p->sighand->siglock); 1377 1378 pid = p->pid; 1379 uid = p->uid; 1380 get_task_struct(p); 1381 read_unlock(&tasklist_lock); 1382 1383 if (!infop) { 1384 retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0; 1385 put_task_struct(p); 1386 if (!retval && stat_addr) 1387 retval = put_user(0xffff, stat_addr); 1388 if (!retval) 1389 retval = p->pid; 1390 } else { 1391 retval = wait_noreap_copyout(p, pid, uid, 1392 CLD_CONTINUED, SIGCONT, 1393 infop, ru); 1394 BUG_ON(retval == 0); 1395 } 1396 1397 return retval; 1398 } 1399 1400 1401 static inline int my_ptrace_child(struct task_struct *p) 1402 { 1403 if (!(p->ptrace & PT_PTRACED)) 1404 return 0; 1405 if (!(p->ptrace & PT_ATTACHED)) 1406 return 1; 1407 /* 1408 * This child was PTRACE_ATTACH'd. We should be seeing it only if 1409 * we are the attacher. If we are the real parent, this is a race 1410 * inside ptrace_attach. It is waiting for the tasklist_lock, 1411 * which we have to switch the parent links, but has already set 1412 * the flags in p->ptrace. 1413 */ 1414 return (p->parent != p->real_parent); 1415 } 1416 1417 static long do_wait(pid_t pid, int options, struct siginfo __user *infop, 1418 int __user *stat_addr, struct rusage __user *ru) 1419 { 1420 DECLARE_WAITQUEUE(wait, current); 1421 struct task_struct *tsk; 1422 int flag, retval; 1423 1424 add_wait_queue(¤t->signal->wait_chldexit,&wait); 1425 repeat: 1426 /* 1427 * We will set this flag if we see any child that might later 1428 * match our criteria, even if we are not able to reap it yet. 1429 */ 1430 flag = 0; 1431 current->state = TASK_INTERRUPTIBLE; 1432 read_lock(&tasklist_lock); 1433 tsk = current; 1434 do { 1435 struct task_struct *p; 1436 struct list_head *_p; 1437 int ret; 1438 1439 list_for_each(_p,&tsk->children) { 1440 p = list_entry(_p,struct task_struct,sibling); 1441 1442 ret = eligible_child(pid, options, p); 1443 if (!ret) 1444 continue; 1445 1446 switch (p->state) { 1447 case TASK_TRACED: 1448 /* 1449 * When we hit the race with PTRACE_ATTACH, 1450 * we will not report this child. But the 1451 * race means it has not yet been moved to 1452 * our ptrace_children list, so we need to 1453 * set the flag here to avoid a spurious ECHILD 1454 * when the race happens with the only child. 1455 */ 1456 flag = 1; 1457 if (!my_ptrace_child(p)) 1458 continue; 1459 /*FALLTHROUGH*/ 1460 case TASK_STOPPED: 1461 /* 1462 * It's stopped now, so it might later 1463 * continue, exit, or stop again. 1464 */ 1465 flag = 1; 1466 if (!(options & WUNTRACED) && 1467 !my_ptrace_child(p)) 1468 continue; 1469 retval = wait_task_stopped(p, ret == 2, 1470 (options & WNOWAIT), 1471 infop, 1472 stat_addr, ru); 1473 if (retval == -EAGAIN) 1474 goto repeat; 1475 if (retval != 0) /* He released the lock. */ 1476 goto end; 1477 break; 1478 default: 1479 // case EXIT_DEAD: 1480 if (p->exit_state == EXIT_DEAD) 1481 continue; 1482 // case EXIT_ZOMBIE: 1483 if (p->exit_state == EXIT_ZOMBIE) { 1484 /* 1485 * Eligible but we cannot release 1486 * it yet: 1487 */ 1488 if (ret == 2) 1489 goto check_continued; 1490 if (!likely(options & WEXITED)) 1491 continue; 1492 retval = wait_task_zombie( 1493 p, (options & WNOWAIT), 1494 infop, stat_addr, ru); 1495 /* He released the lock. */ 1496 if (retval != 0) 1497 goto end; 1498 break; 1499 } 1500 check_continued: 1501 /* 1502 * It's running now, so it might later 1503 * exit, stop, or stop and then continue. 1504 */ 1505 flag = 1; 1506 if (!unlikely(options & WCONTINUED)) 1507 continue; 1508 retval = wait_task_continued( 1509 p, (options & WNOWAIT), 1510 infop, stat_addr, ru); 1511 if (retval != 0) /* He released the lock. */ 1512 goto end; 1513 break; 1514 } 1515 } 1516 if (!flag) { 1517 list_for_each(_p, &tsk->ptrace_children) { 1518 p = list_entry(_p, struct task_struct, 1519 ptrace_list); 1520 if (!eligible_child(pid, options, p)) 1521 continue; 1522 flag = 1; 1523 break; 1524 } 1525 } 1526 if (options & __WNOTHREAD) 1527 break; 1528 tsk = next_thread(tsk); 1529 if (tsk->signal != current->signal) 1530 BUG(); 1531 } while (tsk != current); 1532 1533 read_unlock(&tasklist_lock); 1534 if (flag) { 1535 retval = 0; 1536 if (options & WNOHANG) 1537 goto end; 1538 retval = -ERESTARTSYS; 1539 if (signal_pending(current)) 1540 goto end; 1541 schedule(); 1542 goto repeat; 1543 } 1544 retval = -ECHILD; 1545 end: 1546 current->state = TASK_RUNNING; 1547 remove_wait_queue(¤t->signal->wait_chldexit,&wait); 1548 if (infop) { 1549 if (retval > 0) 1550 retval = 0; 1551 else { 1552 /* 1553 * For a WNOHANG return, clear out all the fields 1554 * we would set so the user can easily tell the 1555 * difference. 1556 */ 1557 if (!retval) 1558 retval = put_user(0, &infop->si_signo); 1559 if (!retval) 1560 retval = put_user(0, &infop->si_errno); 1561 if (!retval) 1562 retval = put_user(0, &infop->si_code); 1563 if (!retval) 1564 retval = put_user(0, &infop->si_pid); 1565 if (!retval) 1566 retval = put_user(0, &infop->si_uid); 1567 if (!retval) 1568 retval = put_user(0, &infop->si_status); 1569 } 1570 } 1571 return retval; 1572 } 1573 1574 asmlinkage long sys_waitid(int which, pid_t pid, 1575 struct siginfo __user *infop, int options, 1576 struct rusage __user *ru) 1577 { 1578 long ret; 1579 1580 if (options & ~(WNOHANG|WNOWAIT|WEXITED|WSTOPPED|WCONTINUED)) 1581 return -EINVAL; 1582 if (!(options & (WEXITED|WSTOPPED|WCONTINUED))) 1583 return -EINVAL; 1584 1585 switch (which) { 1586 case P_ALL: 1587 pid = -1; 1588 break; 1589 case P_PID: 1590 if (pid <= 0) 1591 return -EINVAL; 1592 break; 1593 case P_PGID: 1594 if (pid <= 0) 1595 return -EINVAL; 1596 pid = -pid; 1597 break; 1598 default: 1599 return -EINVAL; 1600 } 1601 1602 ret = do_wait(pid, options, infop, NULL, ru); 1603 1604 /* avoid REGPARM breakage on x86: */ 1605 prevent_tail_call(ret); 1606 return ret; 1607 } 1608 1609 asmlinkage long sys_wait4(pid_t pid, int __user *stat_addr, 1610 int options, struct rusage __user *ru) 1611 { 1612 long ret; 1613 1614 if (options & ~(WNOHANG|WUNTRACED|WCONTINUED| 1615 __WNOTHREAD|__WCLONE|__WALL)) 1616 return -EINVAL; 1617 ret = do_wait(pid, options | WEXITED, NULL, stat_addr, ru); 1618 1619 /* avoid REGPARM breakage on x86: */ 1620 prevent_tail_call(ret); 1621 return ret; 1622 } 1623 1624 #ifdef __ARCH_WANT_SYS_WAITPID 1625 1626 /* 1627 * sys_waitpid() remains for compatibility. waitpid() should be 1628 * implemented by calling sys_wait4() from libc.a. 1629 */ 1630 asmlinkage long sys_waitpid(pid_t pid, int __user *stat_addr, int options) 1631 { 1632 return sys_wait4(pid, stat_addr, options, NULL); 1633 } 1634 1635 #endif 1636