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