* Copyright (C) 1991, 1992 Linus Torvalds
*/
+#include <linux/config.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/mount.h>
#include <linux/proc_fs.h>
#include <linux/mempolicy.h>
-#include <linux/taskstats_kern.h>
-#include <linux/delayacct.h>
#include <linux/cpuset.h>
#include <linux/syscalls.h>
#include <linux/signal.h>
#include <linux/compat.h>
#include <linux/pipe_fs_i.h>
#include <linux/audit.h> /* for audit_free() */
-#include <linux/resource.h>
-#include <linux/vs_base.h>
+#include <linux/vs_limit.h>
#include <linux/vs_context.h>
#include <linux/vs_network.h>
-#include <linux/vs_limit.h>
+#include <linux/vs_cvirt.h>
#include <asm/uaccess.h>
#include <asm/unistd.h>
extern void sem_exit (void);
extern struct task_struct *child_reaper;
+int getrusage(struct task_struct *, int, struct rusage __user *);
+
static void exit_mm(struct task_struct * tsk);
static void __unhash_process(struct task_struct *p)
void release_task(struct task_struct * p)
{
- struct task_struct *leader;
int zap_leader;
+ task_t *leader;
+ struct dentry *proc_dentry;
+
repeat:
atomic_dec(&p->user->processes);
+ spin_lock(&p->proc_lock);
+ proc_dentry = proc_pid_unhash(p);
write_lock_irq(&tasklist_lock);
ptrace_unlink(p);
BUG_ON(!list_empty(&p->ptrace_list) || !list_empty(&p->ptrace_children));
sched_exit(p);
write_unlock_irq(&tasklist_lock);
- proc_flush_task(p);
+ spin_unlock(&p->proc_lock);
+ proc_pid_flush(proc_dentry);
release_thread(p);
call_rcu(&p->rcu, delayed_put_task_struct);
*
* "I ask you, have you ever known what it is to be an orphan?"
*/
-static int will_become_orphaned_pgrp(int pgrp, struct task_struct *ignored_task)
+static int will_become_orphaned_pgrp(int pgrp, task_t *ignored_task)
{
struct task_struct *p;
int ret = 1;
exit_mm(current);
set_special_pids(1, 1);
- proc_clear_tty(current);
+ mutex_lock(&tty_mutex);
+ current->signal->tty = NULL;
+ mutex_unlock(&tty_mutex);
/* Block and flush all signals */
sigfillset(&blocked);
down_read(&mm->mmap_sem);
}
atomic_inc(&mm->mm_count);
- BUG_ON(mm != tsk->active_mm);
+ if (mm != tsk->active_mm) BUG();
/* more a memory barrier than a real lock */
task_lock(tsk);
tsk->mm = NULL;
mmput(mm);
}
-static inline void
-choose_new_parent(struct task_struct *p, struct task_struct *reaper)
+static inline void choose_new_parent(task_t *p, task_t *reaper)
{
/* check for reaper context */
vxwprintk((p->xid != reaper->xid) && (reaper != child_reaper),
p->real_parent = reaper;
}
-static void
-reparent_thread(struct task_struct *p, struct task_struct *father, int traced)
+static void reparent_thread(task_t *p, task_t *father, int traced)
{
/* We don't want people slaying init. */
if (p->exit_signal != -1)
* group, and if no such member exists, give it to
* the global child reaper process (ie "init")
*/
-static void
-forget_original_parent(struct task_struct *father, struct list_head *to_release)
+static void forget_original_parent(struct task_struct * father,
+ struct list_head *to_release)
{
struct task_struct *p, *reaper = father;
struct list_head *_p, *_n;
*/
list_for_each_safe(_p, _n, &father->children) {
int ptrace;
- p = list_entry(_p, struct task_struct, sibling);
+ p = list_entry(_p,struct task_struct,sibling);
ptrace = p->ptrace;
list_add(&p->ptrace_list, to_release);
}
list_for_each_safe(_p, _n, &father->ptrace_children) {
- p = list_entry(_p, struct task_struct, ptrace_list);
+ p = list_entry(_p,struct task_struct,ptrace_list);
choose_new_parent(p, reaper);
reparent_thread(p, father, 1);
}
list_for_each_safe(_p, _n, &ptrace_dead) {
list_del_init(_p);
- t = list_entry(_p, struct task_struct, ptrace_list);
+ t = list_entry(_p,struct task_struct,ptrace_list);
release_task(t);
}
fastcall NORET_TYPE void do_exit(long code)
{
struct task_struct *tsk = current;
- struct taskstats *tidstats;
int group_dead;
- unsigned int mycpu;
profile_task_exit(tsk);
current->comm, current->pid,
preempt_count());
- taskstats_exit_alloc(&tidstats, &mycpu);
-
acct_update_integrals(tsk);
if (tsk->mm) {
update_hiwater_rss(tsk->mm);
if (group_dead) {
hrtimer_cancel(&tsk->signal->real_timer);
exit_itimers(tsk->signal);
- }
-
- if (current->tux_info) {
+ acct_process(code);
+ if (current->tux_info) {
#ifdef CONFIG_TUX_DEBUG
- printk("Possibly unexpected TUX-thread exit(%ld) at %p?\n",
- code, __builtin_return_address(0));
+ printk("Possibly unexpected TUX-thread exit(%ld) at %p?\n",
+ code, __builtin_return_address(0));
#endif
- current->tux_exit();
+ current->tux_exit();
+ }
}
-
- acct_collect(code, group_dead);
if (unlikely(tsk->robust_list))
exit_robust_list(tsk);
#if defined(CONFIG_FUTEX) && defined(CONFIG_COMPAT)
#endif
if (unlikely(tsk->audit_context))
audit_free(tsk);
- taskstats_exit_send(tsk, tidstats, group_dead, mycpu);
- taskstats_exit_free(tidstats);
-
exit_mm(tsk);
- if (group_dead)
- acct_process();
exit_sem(tsk);
__exit_files(tsk);
__exit_fs(tsk);
exit_namespace(tsk);
+ exit_vx_info(tsk, code);
+ exit_nx_info(tsk);
exit_thread();
cpuset_exit(tsk);
exit_keys(tsk);
tsk->exit_code = code;
proc_exit_connector(tsk);
- /* needs to stay before exit_notify() */
- exit_vx_info_early(tsk, code);
exit_notify(tsk);
#ifdef CONFIG_NUMA
mpol_free(tsk->mempolicy);
tsk->mempolicy = NULL;
#endif
/*
- * This must happen late, after the PID is not
- * hashed anymore:
- */
- if (unlikely(!list_empty(&tsk->pi_state_list)))
- exit_pi_state_list(tsk);
- if (unlikely(current->pi_state_cache))
- kfree(current->pi_state_cache);
- /*
- * Make sure we are holding no locks:
+ * If DEBUG_MUTEXES is on, make sure we are holding no locks:
*/
- debug_check_no_locks_held(tsk);
+ mutex_debug_check_no_locks_held(tsk);
if (tsk->io_context)
exit_io_context();
if (tsk->splice_pipe)
__free_pipe_info(tsk->splice_pipe);
- /* needs to stay after exit_notify() */
- exit_vx_info(tsk, code);
- exit_nx_info(tsk);
-
/* PF_DEAD causes final put_task_struct after we schedule. */
preempt_disable();
BUG_ON(tsk->flags & PF_DEAD);
do_group_exit((error_code & 0xff) << 8);
}
-static int eligible_child(pid_t pid, int options, struct task_struct *p)
+static int eligible_child(pid_t pid, int options, task_t *p)
{
if (pid > 0) {
if (p->pid != pid)
* Do not consider thread group leaders that are
* in a non-empty thread group:
*/
- if (delay_group_leader(p))
+ if (current->tgid != p->tgid && delay_group_leader(p))
return 2;
if (security_task_wait(p))
return 1;
}
-static int wait_noreap_copyout(struct task_struct *p, pid_t pid, uid_t uid,
+static int wait_noreap_copyout(task_t *p, pid_t pid, uid_t uid,
int why, int status,
struct siginfo __user *infop,
struct rusage __user *rusagep)
{
int retval = rusagep ? getrusage(p, RUSAGE_BOTH, rusagep) : 0;
-
put_task_struct(p);
if (!retval)
retval = put_user(SIGCHLD, &infop->si_signo);
* the lock and this task is uninteresting. If we return nonzero, we have
* released the lock and the system call should return.
*/
-static int wait_task_zombie(struct task_struct *p, int noreap,
+static int wait_task_zombie(task_t *p, int noreap,
struct siginfo __user *infop,
int __user *stat_addr, struct rusage __user *ru)
{
* the lock and this task is uninteresting. If we return nonzero, we have
* released the lock and the system call should return.
*/
-static int wait_task_stopped(struct task_struct *p, int delayed_group_leader,
- int noreap, struct siginfo __user *infop,
+static int wait_task_stopped(task_t *p, int delayed_group_leader, int noreap,
+ struct siginfo __user *infop,
int __user *stat_addr, struct rusage __user *ru)
{
int retval, exit_code;
* the lock and this task is uninteresting. If we return nonzero, we have
* released the lock and the system call should return.
*/
-static int wait_task_continued(struct task_struct *p, int noreap,
+static int wait_task_continued(task_t *p, int noreap,
struct siginfo __user *infop,
int __user *stat_addr, struct rusage __user *ru)
{
int ret;
list_for_each(_p,&tsk->children) {
- p = list_entry(_p, struct task_struct, sibling);
+ p = list_entry(_p,struct task_struct,sibling);
ret = eligible_child(pid, options, p);
if (!ret)
if (options & __WNOTHREAD)
break;
tsk = next_thread(tsk);
- BUG_ON(tsk->signal != current->signal);
+ if (tsk->signal != current->signal)
+ BUG();
} while (tsk != current);
read_unlock(&tasklist_lock);
git://git.onelab.eu / linux-2.6.git / blobdiff