#include <linux/mount.h>
#include <linux/proc_fs.h>
#include <linux/mempolicy.h>
+#include <linux/ckrm.h>
+#include <linux/ckrm_tsk.h>
+#include <linux/vs_limit.h>
+#include <linux/ckrm_mem.h>
#include <asm/uaccess.h>
#include <asm/unistd.h>
static void __unhash_process(struct task_struct *p)
{
nr_threads--;
+ /* tasklist_lock is held, is this sufficient? */
+ if (p->vx_info) {
+ atomic_dec(&p->vx_info->cvirt.nr_threads);
+ vx_nproc_dec(p);
+ }
detach_pid(p, PIDTYPE_PID);
detach_pid(p, PIDTYPE_TGID);
if (thread_group_leader(p)) {
*/
zap_leader = 0;
leader = p->group_leader;
- if (leader != p && thread_group_empty(leader) && leader->state == TASK_ZOMBIE) {
+ if (leader != p && thread_group_empty(leader) && leader->exit_state == EXIT_ZOMBIE) {
BUG_ON(leader->exit_signal == -1);
do_notify_parent(leader, leader->exit_signal);
/*
sched_exit(p);
write_unlock_irq(&tasklist_lock);
spin_unlock(&p->proc_lock);
- proc_pid_flush(proc_dentry);
+ dput(proc_dentry);
release_thread(p);
put_task_struct(p);
do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
if (p == ignored_task
- || p->state >= TASK_ZOMBIE
+ || p->exit_state >= EXIT_ZOMBIE
|| p->real_parent->pid == 1)
continue;
if (process_group(p->real_parent) != pgrp
ptrace_unlink(current);
/* Reparent to init */
REMOVE_LINKS(current);
+ /* FIXME handle vchild_reaper/initpid */
current->parent = child_reaper;
current->real_parent = child_reaper;
SET_LINKS(current);
while (set) {
if (set & 1) {
struct file * file = xchg(&files->fd[i], NULL);
- if (file)
+ if (file) {
filp_close(file, files);
+ cond_resched();
+ }
+ // vx_openfd_dec(fd);
}
i++;
set >>= 1;
task_lock(tsk);
tsk->mm = NULL;
up_read(&mm->mmap_sem);
+#ifdef CONFIG_CKRM_RES_MEM
+ spin_lock(&mm->peertask_lock);
+ list_del_init(&tsk->mm_peers);
+ ckrm_mem_evaluate_mm(mm);
+ spin_unlock(&mm->peertask_lock);
+#endif
enter_lazy_tlb(mm, current);
task_unlock(tsk);
mmput(mm);
__exit_mm(tsk);
}
-EXPORT_SYMBOL(exit_mm);
-
static inline void choose_new_parent(task_t *p, task_t *reaper, task_t *child_reaper)
{
/*
* Make sure we're not reparenting to ourselves and that
* the parent is not a zombie.
*/
- BUG_ON(p == reaper || reaper->state >= TASK_ZOMBIE);
+ BUG_ON(p == reaper || reaper->state >= EXIT_ZOMBIE || reaper->exit_state >= EXIT_ZOMBIE);
p->real_parent = reaper;
if (p->parent == p->real_parent)
BUG();
/* We don't want people slaying init. */
if (p->exit_signal != -1)
p->exit_signal = SIGCHLD;
- p->self_exec_id++;
if (p->pdeath_signal)
/* We already hold the tasklist_lock here. */
/* If we'd notified the old parent about this child's death,
* also notify the new parent.
*/
- if (p->state == TASK_ZOMBIE && p->exit_signal != -1 &&
+ if (p->exit_state == EXIT_ZOMBIE && p->exit_signal != -1 &&
thread_group_empty(p))
do_notify_parent(p, p->exit_signal);
else if (p->state == TASK_TRACED) {
reaper = child_reaper;
break;
}
- } while (reaper->state >= TASK_ZOMBIE);
+ } while (reaper->exit_state >= EXIT_ZOMBIE);
/*
* There are only two places where our children can be:
} else {
/* reparent ptraced task to its real parent */
__ptrace_unlink (p);
- if (p->state == TASK_ZOMBIE && p->exit_signal != -1 &&
+ if (p->exit_state == EXIT_ZOMBIE && p->exit_signal != -1 &&
thread_group_empty(p))
do_notify_parent(p, p->exit_signal);
}
* zombie forever since we prevented it from self-reap itself
* while it was being traced by us, to be able to see it in wait4.
*/
- if (unlikely(ptrace && p->state == TASK_ZOMBIE && p->exit_signal == -1))
+ if (unlikely(ptrace && p->exit_state == EXIT_ZOMBIE && p->exit_signal == -1))
list_add(&p->ptrace_list, to_release);
}
list_for_each_safe(_p, _n, &father->ptrace_children) {
struct task_struct *t;
struct list_head ptrace_dead, *_p, *_n;
+ ckrm_cb_exit(tsk);
+
if (signal_pending(tsk) && !tsk->signal->group_exit
&& !thread_group_empty(tsk)) {
/*
do_notify_parent(tsk, SIGCHLD);
}
- state = TASK_ZOMBIE;
+ state = EXIT_ZOMBIE;
if (tsk->exit_signal == -1 && tsk->ptrace == 0)
- state = TASK_DEAD;
- tsk->state = state;
+ state = EXIT_DEAD;
+ tsk->exit_state = state;
/*
* Clear these here so that update_process_times() won't try to deliver
}
/* If the process is dead, release it - nobody will wait for it */
- if (state == TASK_DEAD)
+ if (state == EXIT_DEAD)
release_task(tsk);
/* PF_DEAD causes final put_task_struct after we schedule. */
}
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));
+#endif
+ current->tux_exit();
+ }
__exit_mm(tsk);
exit_sem(tsk);
mpol_free(tsk->mempolicy);
tsk->mempolicy = NULL;
#endif
+
+ BUG_ON(!(current->flags & PF_DEAD));
schedule();
BUG();
/* Avoid "noreturn function does return". */
}
/*
- * Handle sys_wait4 work for one task in state TASK_ZOMBIE. We hold
+ * Handle sys_wait4 work for one task in state EXIT_ZOMBIE. We hold
* read_lock(&tasklist_lock) on entry. If we return zero, we still hold
* the lock and this task is uninteresting. If we return nonzero, we have
* released the lock and the system call should return.
int exit_code = p->exit_code;
int why, status;
- if (unlikely(p->state != TASK_ZOMBIE))
+ if (unlikely(p->exit_state != EXIT_ZOMBIE))
return 0;
if (unlikely(p->exit_signal == -1 && p->ptrace == 0))
return 0;
* Try to move the task's state to DEAD
* only one thread is allowed to do this:
*/
- state = xchg(&p->state, TASK_DEAD);
- if (state != TASK_ZOMBIE) {
- BUG_ON(state != TASK_DEAD);
+ state = xchg(&p->exit_state, EXIT_DEAD);
+ if (state != EXIT_ZOMBIE) {
+ BUG_ON(state != EXIT_DEAD);
return 0;
}
if (unlikely(p->exit_signal == -1 && p->ptrace == 0)) {
/*
* Now we are sure this task is interesting, and no other
- * thread can reap it because we set its state to TASK_DEAD.
+ * thread can reap it because we set its state to EXIT_DEAD.
*/
read_unlock(&tasklist_lock);
if (!retval && infop)
retval = put_user(p->uid, &infop->si_uid);
if (retval) {
- p->state = TASK_ZOMBIE;
+ // TODO: is this safe?
+ p->exit_state = EXIT_ZOMBIE;
return retval;
}
retval = p->pid;
/* Double-check with lock held. */
if (p->real_parent != p->parent) {
__ptrace_unlink(p);
- p->state = TASK_ZOMBIE;
+ // TODO: is this safe?
+ p->exit_state = EXIT_ZOMBIE;
/*
* If this is not a detached task, notify the parent.
* If it's still not detached after that, don't release
/*
* This uses xchg to be atomic with the thread resuming and setting
* it. It must also be done with the write lock held to prevent a
- * race with the TASK_ZOMBIE case.
+ * race with the EXIT_ZOMBIE case.
*/
exit_code = xchg(&p->exit_code, 0);
- if (unlikely(p->state >= TASK_ZOMBIE)) {
+ if (unlikely(p->exit_state >= EXIT_ZOMBIE)) {
/*
* The task resumed and then died. Let the next iteration
- * catch it in TASK_ZOMBIE. Note that exit_code might
+ * catch it in EXIT_ZOMBIE. Note that exit_code might
* already be zero here if it resumed and did _exit(0).
* The task itself is dead and won't touch exit_code again;
* other processors in this function are locked out.
write_unlock_irq(&tasklist_lock);
bail_ref:
put_task_struct(p);
- read_lock(&tasklist_lock);
- return 0;
+ /*
+ * We are returning to the wait loop without having successfully
+ * removed the process and having released the lock. We cannot
+ * continue, since the "p" task pointer is potentially stale.
+ *
+ * Return -EAGAIN, and do_wait() will restart the loop from the
+ * beginning. Do _not_ re-acquire the lock.
+ */
+ return -EAGAIN;
}
/* move to end of parent's list to avoid starvation */
return retval;
}
+/*
+ * Handle do_wait work for one task in a live, non-stopped state.
+ * read_lock(&tasklist_lock) on entry. If we return zero, we still hold
+ * 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(task_t *p, int noreap,
+ struct siginfo __user *infop,
+ int __user *stat_addr, struct rusage __user *ru)
+{
+ int retval;
+ pid_t pid;
+ uid_t uid;
+
+ if (unlikely(!p->signal))
+ return 0;
+
+ if (p->signal->stop_state >= 0)
+ return 0;
+
+ spin_lock_irq(&p->sighand->siglock);
+ if (p->signal->stop_state >= 0) { /* Re-check with the lock held. */
+ spin_unlock_irq(&p->sighand->siglock);
+ return 0;
+ }
+ if (!noreap)
+ p->signal->stop_state = 0;
+ spin_unlock_irq(&p->sighand->siglock);
+
+ pid = p->pid;
+ uid = p->uid;
+ get_task_struct(p);
+ read_unlock(&tasklist_lock);
+
+ if (!infop) {
+ retval = ru ? getrusage(p, RUSAGE_BOTH, ru) : 0;
+ put_task_struct(p);
+ if (!retval && stat_addr)
+ retval = put_user(0xffff, stat_addr);
+ if (!retval)
+ retval = p->pid;
+ } else {
+ retval = wait_noreap_copyout(p, pid, uid,
+ CLD_CONTINUED, SIGCONT,
+ infop, ru);
+ BUG_ON(retval == 0);
+ }
+
+ return retval;
+}
+
+
+static inline int my_ptrace_child(struct task_struct *p)
+{
+ if (!(p->ptrace & PT_PTRACED))
+ return 0;
+ /*
+ * This child was PTRACE_ATTACH'd. We should be seeing it only if
+ * we are the attacher. If we are the real parent, this is a race
+ * inside ptrace_attach. It is waiting for the tasklist_lock,
+ * which we have to switch the parent links, but has already set
+ * the flags in p->ptrace.
+ */
+ return (p->parent != p->real_parent);
+}
+
static long do_wait(pid_t pid, int options, struct siginfo __user *infop,
int __user *stat_addr, struct rusage __user *ru)
{
add_wait_queue(¤t->wait_chldexit,&wait);
repeat:
+ /*
+ * We will set this flag if we see any child that might later
+ * match our criteria, even if we are not able to reap it yet.
+ */
flag = 0;
current->state = TASK_INTERRUPTIBLE;
read_lock(&tasklist_lock);
ret = eligible_child(pid, options, p);
if (!ret)
continue;
- flag = 1;
switch (p->state) {
case TASK_TRACED:
- if (!(p->ptrace & PT_PTRACED))
+ if (!my_ptrace_child(p))
continue;
/*FALLTHROUGH*/
case TASK_STOPPED:
+ /*
+ * It's stopped now, so it might later
+ * continue, exit, or stop again.
+ */
+ flag = 1;
if (!(options & WUNTRACED) &&
- !(p->ptrace & PT_PTRACED))
+ !my_ptrace_child(p))
continue;
retval = wait_task_stopped(p, ret == 2,
(options & WNOWAIT),
infop,
stat_addr, ru);
+ if (retval == -EAGAIN)
+ goto repeat;
if (retval != 0) /* He released the lock. */
goto end;
break;
- case TASK_ZOMBIE:
+ default:
+ // case EXIT_DEAD:
+ if (p->exit_state == EXIT_DEAD)
+ continue;
+ // case EXIT_ZOMBIE:
+ if (p->exit_state == EXIT_ZOMBIE) {
+ /*
+ * Eligible but we cannot release
+ * it yet:
+ */
+ if (ret == 2)
+ goto check_continued;
+ if (!likely(options & WEXITED))
+ continue;
+ retval = wait_task_zombie(
+ p, (options & WNOWAIT),
+ infop, stat_addr, ru);
+ /* He released the lock. */
+ if (retval != 0)
+ goto end;
+ break;
+ }
+check_continued:
/*
- * Eligible but we cannot release it yet:
+ * It's running now, so it might later
+ * exit, stop, or stop and then continue.
*/
- if (ret == 2)
- goto check_continued;
- if (!likely(options & WEXITED))
+ flag = 1;
+ if (!unlikely(options & WCONTINUED))
continue;
- retval = wait_task_zombie(
+
+ retval = wait_task_continued(
p, (options & WNOWAIT),
infop, stat_addr, ru);
if (retval != 0) /* He released the lock. */
goto end;
break;
- case TASK_DEAD:
- continue;
- default:
-check_continued:
- if (!unlikely(options & WCONTINUED))
- continue;
- if (unlikely(!p->signal))
- continue;
- spin_lock_irq(&p->sighand->siglock);
- if (p->signal->stop_state < 0) {
- pid_t pid;
- uid_t uid;
-
- if (!(options & WNOWAIT))
- p->signal->stop_state = 0;
- spin_unlock_irq(&p->sighand->siglock);
- pid = p->pid;
- uid = p->uid;
- get_task_struct(p);
- read_unlock(&tasklist_lock);
- retval = wait_noreap_copyout(p, pid,
- uid, CLD_CONTINUED,
- SIGCONT, infop, ru);
- BUG_ON(retval == 0);
- goto end;
- }
- spin_unlock_irq(&p->sighand->siglock);
- break;
}
}
if (!flag) {
{
long ret;
- if (options & ~(WNOHANG|WUNTRACED|__WNOTHREAD|__WCLONE|__WALL))
+ if (options & ~(WNOHANG|WUNTRACED|WCONTINUED|
+ __WNOTHREAD|__WCLONE|__WALL))
return -EINVAL;
ret = do_wait(pid, options | WEXITED, NULL, stat_addr, ru);
git://git.onelab.eu / linux-2.6.git / blobdiff