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