uml: fix uml-hang-on-2.6.9-host.patch

@@ -54,7 +54,8 @@ struct thread_struct {
 		union {
 			struct {
 				int pid;
-			} fork, exec;
+				int mode;
+			} fork, exec, kill;
 			struct {
 				int (*proc)(void *);
 				void *arg;

@@ -8,7 +8,7 @@
 
 #include "sysdep/ptrace.h"
 
-enum { OP_NONE, OP_EXEC, OP_FORK, OP_TRACE_ON, OP_REBOOT, OP_HALT, OP_CB };
+enum { OP_NONE, OP_EXEC, OP_FORK, OP_KILL, OP_TRACE_ON, OP_REBOOT, OP_HALT, OP_CB };
 
 extern int tracing_pid;
 

@@ -16,6 +16,7 @@
 #include "kern_util.h"
 #include "user.h"
 #include "ptrace_user.h"
+#include "os.h"
 
 void do_exec(int old_pid, int new_pid)
 {

@@ -36,7 +37,7 @@ void do_exec(int old_pid, int new_pid)
 		tracer_panic("do_exec failed to get registers - errno = %d",
 			     errno);
 
-	kill(old_pid, SIGKILL);
+	os_kill_ptraced_process(old_pid, 0);
 
 	if (ptrace(PTRACE_SETOPTIONS, new_pid, 0, (void *)PTRACE_O_TRACESYSGOOD) < 0)
 		tracer_panic("do_exec: PTRACE_SETOPTIONS failed, errno = %d", errno);

@@ -82,7 +82,7 @@ void *switch_to_tt(void *prev, void *nex
 	prev_sched = current->thread.prev_sched;
 	if((prev_sched->state == TASK_ZOMBIE) ||
 	   (prev_sched->state == TASK_DEAD))
-		os_kill_ptraced_process(prev_sched->thread.mode.tt.extern_pid, 1);
+		request_kill_ptraced_process( prev_sched->thread.mode.tt.extern_pid, 1);
 
 	/* This works around a nasty race with 'jail'.  If we are switching
 	 * between two threads of a threaded app and the incoming process

@@ -119,7 +119,7 @@ void release_thread_tt(struct task_struc
 	int pid = task->thread.mode.tt.extern_pid;
 
 	if(os_getpid() != pid)
-		os_kill_process(pid, 0);
+		request_kill_ptraced_process(pid, 0);
 }
 
 void exit_thread_tt(void)

@@ -330,10 +330,10 @@ void kill_off_processes_tt(void)
 	me = os_getpid();
         for_each_process(p){
 		if(p->thread.mode.tt.extern_pid != me)
-			os_kill_process(p->thread.mode.tt.extern_pid, 0);
+			request_kill_ptraced_process(p->thread.mode.tt.extern_pid, 2);
 	}
 	if(init_task.thread.mode.tt.extern_pid != me)
-		os_kill_process(init_task.thread.mode.tt.extern_pid, 0);
+		request_kill_ptraced_process(init_task.thread.mode.tt.extern_pid, 2);
 }
 
 void initial_thread_cb_tt(void (*proc)(void *), void *arg)

@@ -352,6 +352,20 @@ void initial_thread_cb_tt(void (*proc)(v
 	}
 }
 
+void request_kill_ptraced_process(int pid, int mode)
+{
+	/* The tracer has to do the kill, since killing must be
+	 * done with ptrace(PTRACE_KILL, pid), which is possible
+	 * from the father only! */
+	current->thread.request.op = OP_KILL;
+	current->thread.request.u.exec.pid = pid;
+	current->thread.request.u.exec.mode = mode;
+	os_usr1_process(os_getpid());
+	change_sig(SIGUSR1, 1);
+
+	change_sig(SIGUSR1, 0);
+}
+
 int do_proc_op(void *t, int proc_id)
 {
 	struct task_struct *task;

@@ -374,6 +388,12 @@ int do_proc_op(void *t, int proc_id)
 	case OP_FORK:
 		attach_process(thread->request.u.fork.pid);
 		break;
+	case OP_KILL:
+		if ( thread->request.u.kill.mode > 1 )
+			os_kill_process(thread->request.u.kill.pid, 0);
+		os_kill_ptraced_process(thread->request.u.kill.pid,
+		                        thread->request.u.kill.mode);
+		break;
 	case OP_CB:
 		(*thread->request.u.cb.proc)(thread->request.u.cb.arg);
 		break;

@@ -20,6 +20,7 @@ extern void reboot_tt(void);
 extern void halt_tt(void);
 extern int is_tracer_winch(int pid, int fd, void *data);
 extern void kill_off_processes_tt(void);
+extern void request_kill_ptraced_process(int pid, int mode);
 
 #endif
 

@@ -22,7 +22,7 @@ static void kill_idlers(int me)
 	for(i = 0; i < sizeof(idle_threads)/sizeof(idle_threads[0]); i++){
 		p = idle_threads[i];
 		if((p != NULL) && (p->thread.mode.tt.extern_pid != me))
-			os_kill_process(p->thread.mode.tt.extern_pid, 0);
+			request_kill_ptraced_process(p->thread.mode.tt.extern_pid, 2);
 	}
 #endif
 }