[PATCH] pidhash: kill switch_exec_pids

switch_exec_pids is only called from de_thread by way of exec, and it is
only called when we are exec'ing from a non thread group leader.

Currently switch_exec_pids gives the leader the pid of the thread and
unhashes and rehashes all of the process groups.  The leader is already in
the EXIT_DEAD state so no one cares about it's pids.  The only concern for
the leader is that __unhash_process called from release_task will function
correctly.  If we don't touch the leader at all we know that
__unhash_process will work fine so there is no need to touch the leader.

For the task becomming the thread group leader, we just need to give it the
pid of the old thread group leader, add it to the task list, and attach it
to the session and the process group of the thread group.

Currently de_thread is also adding the task to the task list which is just
silly.

Currently the only leader of __detach_pid besides detach_pid is
switch_exec_pids because of the ugly extra work that was being
performed.

So this patch removes switch_exec_pids because it is doing too much, it is
creating an unnecessary special case in pid.c, duing work duplicated in
de_thread, and generally obscuring what it is going on.

The necessary work is added to de_thread, and it seems to be a little
clearer there what is going on.

Signed-off-by: Eric W. Biederman <ebiederm@xmission.com>
Cc: Oleg Nesterov <oleg@tv-sign.ru>
Cc: Kirill Korotaev <dev@sw.ru>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/fs/exec.c b/fs/exec.c
index dd194923c52c77e482d0d4601c27916aee68139f..db0769447d33bf8743be643261d1ff8ab0fcbad0 100644 (file)
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -708,7 +708,17 @@ static int de_thread(struct task_struct *tsk)
                remove_parent(current);
                remove_parent(leader);
 
-               switch_exec_pids(leader, current);
+
+               /* Become a process group leader with the old leader's pid.
+                * Note: The old leader also uses thispid until release_task
+                *       is called.  Odd but simple and correct.
+                */
+               detach_pid(current, PIDTYPE_PID);
+               current->pid = leader->pid;
+               attach_pid(current, PIDTYPE_PID,  current->pid);
+               attach_pid(current, PIDTYPE_PGID, current->signal->pgrp);
+               attach_pid(current, PIDTYPE_SID,  current->signal->session);
+               list_add_tail(&current->tasks, &init_task.tasks);
 
                current->parent = current->real_parent = leader->real_parent;
                leader->parent = leader->real_parent = child_reaper;
@@ -722,8 +732,6 @@ static int de_thread(struct task_struct *tsk)
                        __ptrace_link(current, parent);
                }
 
-               list_del(&current->tasks);
-               list_add_tail(&current->tasks, &init_task.tasks);
                current->exit_signal = SIGCHLD;
 
                BUG_ON(leader->exit_state != EXIT_ZOMBIE);

diff --git a/include/linux/pid.h b/include/linux/pid.h
index 5b2fcb19d2dae977f86818caaae4f25d8204d2bd..099e70ecf7c73244add6fd9e9cd5d186553a1f68 100644 (file)
--- a/include/linux/pid.h
+++ b/include/linux/pid.h
@@ -38,7 +38,6 @@ extern struct pid *FASTCALL(find_pid(enum pid_type, int));
 
 extern int alloc_pidmap(void);
 extern void FASTCALL(free_pidmap(int));
-extern void switch_exec_pids(struct task_struct *leader, struct task_struct *thread);
 
 #define do_each_task_pid(who, type, task)                              \
        if ((task = find_task_by_pid_type(type, who))) {                \

diff --git a/kernel/pid.c b/kernel/pid.c
index 1acc07246991972a1eb012f5db0dadd4aeb1a188..7781d9999058337f12618910b81cea8c0ee1c0f0 100644 (file)
--- a/kernel/pid.c
+++ b/kernel/pid.c
@@ -217,36 +217,6 @@ task_t *find_task_by_pid_type(int type, int nr)
 
 EXPORT_SYMBOL(find_task_by_pid_type);
 
-/*
- * This function switches the PIDs if a non-leader thread calls
- * sys_execve() - this must be done without releasing the PID.
- * (which a detach_pid() would eventually do.)
- */
-void switch_exec_pids(task_t *leader, task_t *thread)
-{
-       __detach_pid(leader, PIDTYPE_PID);
-       __detach_pid(leader, PIDTYPE_TGID);
-       __detach_pid(leader, PIDTYPE_PGID);
-       __detach_pid(leader, PIDTYPE_SID);
-
-       __detach_pid(thread, PIDTYPE_PID);
-       __detach_pid(thread, PIDTYPE_TGID);
-
-       leader->pid = leader->tgid = thread->pid;
-       thread->pid = thread->tgid;
-
-       attach_pid(thread, PIDTYPE_PID, thread->pid);
-       attach_pid(thread, PIDTYPE_TGID, thread->tgid);
-       attach_pid(thread, PIDTYPE_PGID, thread->signal->pgrp);
-       attach_pid(thread, PIDTYPE_SID, thread->signal->session);
-       list_add_tail(&thread->tasks, &init_task.tasks);
-
-       attach_pid(leader, PIDTYPE_PID, leader->pid);
-       attach_pid(leader, PIDTYPE_TGID, leader->tgid);
-       attach_pid(leader, PIDTYPE_PGID, leader->signal->pgrp);
-       attach_pid(leader, PIDTYPE_SID, leader->signal->session);
-}
-
 /*
  * The pid hash table is scaled according to the amount of memory in the
  * machine.  From a minimum of 16 slots up to 4096 slots at one gigabyte or