Merge with /usr/src/ntfs-2.6.git
[linux-2.6] / arch / um / kernel / tt / process_kern.c
1 /* 
2  * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
3  * Licensed under the GPL
4  */
5
6 #include "linux/sched.h"
7 #include "linux/signal.h"
8 #include "linux/kernel.h"
9 #include "linux/interrupt.h"
10 #include "linux/ptrace.h"
11 #include "asm/system.h"
12 #include "asm/pgalloc.h"
13 #include "asm/ptrace.h"
14 #include "asm/tlbflush.h"
15 #include "irq_user.h"
16 #include "signal_user.h"
17 #include "kern_util.h"
18 #include "user_util.h"
19 #include "os.h"
20 #include "kern.h"
21 #include "sigcontext.h"
22 #include "time_user.h"
23 #include "mem_user.h"
24 #include "tlb.h"
25 #include "mode.h"
26 #include "init.h"
27 #include "tt.h"
28
29 void *switch_to_tt(void *prev, void *next, void *last)
30 {
31         struct task_struct *from, *to, *prev_sched;
32         unsigned long flags;
33         int err, vtalrm, alrm, prof, cpu;
34         char c;
35         /* jailing and SMP are incompatible, so this doesn't need to be 
36          * made per-cpu 
37          */
38         static int reading;
39
40         from = prev;
41         to = next;
42
43         to->thread.prev_sched = from;
44
45         cpu = from->thread_info->cpu;
46         if(cpu == 0)
47                 forward_interrupts(to->thread.mode.tt.extern_pid);
48 #ifdef CONFIG_SMP
49         forward_ipi(cpu_data[cpu].ipi_pipe[0], to->thread.mode.tt.extern_pid);
50 #endif
51         local_irq_save(flags);
52
53         vtalrm = change_sig(SIGVTALRM, 0);
54         alrm = change_sig(SIGALRM, 0);
55         prof = change_sig(SIGPROF, 0);
56
57         forward_pending_sigio(to->thread.mode.tt.extern_pid);
58
59         c = 0;
60         set_current(to);
61
62         reading = 0;
63         err = os_write_file(to->thread.mode.tt.switch_pipe[1], &c, sizeof(c));
64         if(err != sizeof(c))
65                 panic("write of switch_pipe failed, err = %d", -err);
66
67         reading = 1;
68         if(from->thread.mode.tt.switch_pipe[0] == -1)
69                 os_kill_process(os_getpid(), 0);
70
71         err = os_read_file(from->thread.mode.tt.switch_pipe[0], &c, sizeof(c));
72         if(err != sizeof(c))
73                 panic("read of switch_pipe failed, errno = %d", -err);
74
75         /* If the process that we have just scheduled away from has exited,
76          * then it needs to be killed here.  The reason is that, even though
77          * it will kill itself when it next runs, that may be too late.  Its
78          * stack will be freed, possibly before then, and if that happens,
79          * we have a use-after-free situation.  So, it gets killed here
80          * in case it has not already killed itself.
81          */
82         prev_sched = current->thread.prev_sched;
83         if(prev_sched->thread.mode.tt.switch_pipe[0] == -1)
84                 os_kill_process(prev_sched->thread.mode.tt.extern_pid, 1);
85
86         change_sig(SIGVTALRM, vtalrm);
87         change_sig(SIGALRM, alrm);
88         change_sig(SIGPROF, prof);
89
90         arch_switch();
91
92         flush_tlb_all();
93         local_irq_restore(flags);
94
95         return(current->thread.prev_sched);
96 }
97
98 void release_thread_tt(struct task_struct *task)
99 {
100         int pid = task->thread.mode.tt.extern_pid;
101
102         /*
103          * We first have to kill the other process, before
104          * closing its switch_pipe. Else it might wake up
105          * and receive "EOF" before we could kill it.
106          */
107         if(os_getpid() != pid)
108                 os_kill_process(pid, 0);
109
110         os_close_file(task->thread.mode.tt.switch_pipe[0]);
111         os_close_file(task->thread.mode.tt.switch_pipe[1]);
112         /* use switch_pipe as flag: thread is released */
113         task->thread.mode.tt.switch_pipe[0] = -1;
114 }
115
116 void suspend_new_thread(int fd)
117 {
118         int err;
119         char c;
120
121         os_stop_process(os_getpid());
122         err = os_read_file(fd, &c, sizeof(c));
123         if(err != sizeof(c))
124                 panic("read failed in suspend_new_thread, err = %d", -err);
125 }
126
127 void schedule_tail(task_t *prev);
128
129 static void new_thread_handler(int sig)
130 {
131         unsigned long disable;
132         int (*fn)(void *);
133         void *arg;
134
135         fn = current->thread.request.u.thread.proc;
136         arg = current->thread.request.u.thread.arg;
137
138         UPT_SC(&current->thread.regs.regs) = (void *) (&sig + 1);
139         disable = (1 << (SIGVTALRM - 1)) | (1 << (SIGALRM - 1)) |
140                 (1 << (SIGIO - 1)) | (1 << (SIGPROF - 1));
141         SC_SIGMASK(UPT_SC(&current->thread.regs.regs)) &= ~disable;
142
143         suspend_new_thread(current->thread.mode.tt.switch_pipe[0]);
144
145         force_flush_all();
146         if(current->thread.prev_sched != NULL)
147                 schedule_tail(current->thread.prev_sched);
148         current->thread.prev_sched = NULL;
149
150         init_new_thread_signals(1);
151         enable_timer();
152         free_page(current->thread.temp_stack);
153         set_cmdline("(kernel thread)");
154
155         change_sig(SIGUSR1, 1);
156         change_sig(SIGVTALRM, 1);
157         change_sig(SIGPROF, 1);
158         local_irq_enable();
159         if(!run_kernel_thread(fn, arg, &current->thread.exec_buf))
160                 do_exit(0);
161
162         /* XXX No set_user_mode here because a newly execed process will
163          * immediately segfault on its non-existent IP, coming straight back
164          * to the signal handler, which will call set_user_mode on its way
165          * out.  This should probably change since it's confusing.
166          */
167 }
168
169 static int new_thread_proc(void *stack)
170 {
171         /* local_irq_disable is needed to block out signals until this thread is
172          * properly scheduled.  Otherwise, the tracing thread will get mighty
173          * upset about any signals that arrive before that.
174          * This has the complication that it sets the saved signal mask in
175          * the sigcontext to block signals.  This gets restored when this
176          * thread (or a descendant, since they get a copy of this sigcontext)
177          * returns to userspace.
178          * So, this is compensated for elsewhere.
179          * XXX There is still a small window until local_irq_disable() actually
180          * finishes where signals are possible - shouldn't be a problem in
181          * practice since SIGIO hasn't been forwarded here yet, and the
182          * local_irq_disable should finish before a SIGVTALRM has time to be
183          * delivered.
184          */
185
186         local_irq_disable();
187         init_new_thread_stack(stack, new_thread_handler);
188         os_usr1_process(os_getpid());
189         change_sig(SIGUSR1, 1);
190         return(0);
191 }
192
193 /* Signal masking - signals are blocked at the start of fork_tramp.  They
194  * are re-enabled when finish_fork_handler is entered by fork_tramp hitting
195  * itself with a SIGUSR1.  set_user_mode has to be run with SIGUSR1 off,
196  * so it is blocked before it's called.  They are re-enabled on sigreturn
197  * despite the fact that they were blocked when the SIGUSR1 was issued because
198  * copy_thread copies the parent's sigcontext, including the signal mask
199  * onto the signal frame.
200  */
201
202 void finish_fork_handler(int sig)
203 {
204         UPT_SC(&current->thread.regs.regs) = (void *) (&sig + 1);
205         suspend_new_thread(current->thread.mode.tt.switch_pipe[0]);
206
207         force_flush_all();
208         if(current->thread.prev_sched != NULL)
209                 schedule_tail(current->thread.prev_sched);
210         current->thread.prev_sched = NULL;
211
212         enable_timer();
213         change_sig(SIGVTALRM, 1);
214         local_irq_enable();
215         if(current->mm != current->parent->mm)
216                 protect_memory(uml_reserved, high_physmem - uml_reserved, 1, 
217                                1, 0, 1);
218         task_protections((unsigned long) current_thread);
219
220         free_page(current->thread.temp_stack);
221         local_irq_disable();
222         change_sig(SIGUSR1, 0);
223         set_user_mode(current);
224 }
225
226 int fork_tramp(void *stack)
227 {
228         local_irq_disable();
229         arch_init_thread();
230         init_new_thread_stack(stack, finish_fork_handler);
231
232         os_usr1_process(os_getpid());
233         change_sig(SIGUSR1, 1);
234         return(0);
235 }
236
237 int copy_thread_tt(int nr, unsigned long clone_flags, unsigned long sp,
238                    unsigned long stack_top, struct task_struct * p, 
239                    struct pt_regs *regs)
240 {
241         int (*tramp)(void *);
242         int new_pid, err;
243         unsigned long stack;
244         
245         if(current->thread.forking)
246                 tramp = fork_tramp;
247         else {
248                 tramp = new_thread_proc;
249                 p->thread.request.u.thread = current->thread.request.u.thread;
250         }
251
252         err = os_pipe(p->thread.mode.tt.switch_pipe, 1, 1);
253         if(err < 0){
254                 printk("copy_thread : pipe failed, err = %d\n", -err);
255                 return(err);
256         }
257
258         stack = alloc_stack(0, 0);
259         if(stack == 0){
260                 printk(KERN_ERR "copy_thread : failed to allocate "
261                        "temporary stack\n");
262                 return(-ENOMEM);
263         }
264
265         clone_flags &= CLONE_VM;
266         p->thread.temp_stack = stack;
267         new_pid = start_fork_tramp(p->thread_info, stack, clone_flags, tramp);
268         if(new_pid < 0){
269                 printk(KERN_ERR "copy_thread : clone failed - errno = %d\n", 
270                        -new_pid);
271                 return(new_pid);
272         }
273
274         if(current->thread.forking){
275                 sc_to_sc(UPT_SC(&p->thread.regs.regs), 
276                          UPT_SC(&current->thread.regs.regs));
277                 SC_SET_SYSCALL_RETURN(UPT_SC(&p->thread.regs.regs), 0);
278                 if(sp != 0) SC_SP(UPT_SC(&p->thread.regs.regs)) = sp;
279         }
280         p->thread.mode.tt.extern_pid = new_pid;
281
282         current->thread.request.op = OP_FORK;
283         current->thread.request.u.fork.pid = new_pid;
284         os_usr1_process(os_getpid());
285
286         /* Enable the signal and then disable it to ensure that it is handled
287          * here, and nowhere else.
288          */
289         change_sig(SIGUSR1, 1);
290
291         change_sig(SIGUSR1, 0);
292         err = 0;
293         return(err);
294 }
295
296 void reboot_tt(void)
297 {
298         current->thread.request.op = OP_REBOOT;
299         os_usr1_process(os_getpid());
300         change_sig(SIGUSR1, 1);
301 }
302
303 void halt_tt(void)
304 {
305         current->thread.request.op = OP_HALT;
306         os_usr1_process(os_getpid());
307         change_sig(SIGUSR1, 1);
308 }
309
310 void kill_off_processes_tt(void)
311 {
312         struct task_struct *p;
313         int me;
314
315         me = os_getpid();
316         for_each_process(p){
317                 if(p->thread.mode.tt.extern_pid != me) 
318                         os_kill_process(p->thread.mode.tt.extern_pid, 0);
319         }
320         if(init_task.thread.mode.tt.extern_pid != me) 
321                 os_kill_process(init_task.thread.mode.tt.extern_pid, 0);
322 }
323
324 void initial_thread_cb_tt(void (*proc)(void *), void *arg)
325 {
326         if(os_getpid() == tracing_pid){
327                 (*proc)(arg);
328         }
329         else {
330                 current->thread.request.op = OP_CB;
331                 current->thread.request.u.cb.proc = proc;
332                 current->thread.request.u.cb.arg = arg;
333                 os_usr1_process(os_getpid());
334                 change_sig(SIGUSR1, 1);
335
336                 change_sig(SIGUSR1, 0);
337         }
338 }
339
340 int do_proc_op(void *t, int proc_id)
341 {
342         struct task_struct *task;
343         struct thread_struct *thread;
344         int op, pid;
345
346         task = t;
347         thread = &task->thread;
348         op = thread->request.op;
349         switch(op){
350         case OP_NONE:
351         case OP_TRACE_ON:
352                 break;
353         case OP_EXEC:
354                 pid = thread->request.u.exec.pid;
355                 do_exec(thread->mode.tt.extern_pid, pid);
356                 thread->mode.tt.extern_pid = pid;
357                 cpu_tasks[task->thread_info->cpu].pid = pid;
358                 break;
359         case OP_FORK:
360                 attach_process(thread->request.u.fork.pid);
361                 break;
362         case OP_CB:
363                 (*thread->request.u.cb.proc)(thread->request.u.cb.arg);
364                 break;
365         case OP_REBOOT:
366         case OP_HALT:
367                 break;
368         default:
369                 tracer_panic("Bad op in do_proc_op");
370                 break;
371         }
372         thread->request.op = OP_NONE;
373         return(op);
374 }
375
376 void init_idle_tt(void)
377 {
378         default_idle();
379 }
380
381 extern void start_kernel(void);
382
383 static int start_kernel_proc(void *unused)
384 {
385         int pid;
386
387         block_signals();
388         pid = os_getpid();
389
390         cpu_tasks[0].pid = pid;
391         cpu_tasks[0].task = current;
392 #ifdef CONFIG_SMP
393         cpu_online_map = cpumask_of_cpu(0);
394 #endif
395         if(debug) os_stop_process(pid);
396         start_kernel();
397         return(0);
398 }
399
400 void set_tracing(void *task, int tracing)
401 {
402         ((struct task_struct *) task)->thread.mode.tt.tracing = tracing;
403 }
404
405 int is_tracing(void *t)
406 {
407         return (((struct task_struct *) t)->thread.mode.tt.tracing);
408 }
409
410 int set_user_mode(void *t)
411 {
412         struct task_struct *task;
413
414         task = t ? t : current;
415         if(task->thread.mode.tt.tracing) 
416                 return(1);
417         task->thread.request.op = OP_TRACE_ON;
418         os_usr1_process(os_getpid());
419         return(0);
420 }
421
422 void set_init_pid(int pid)
423 {
424         int err;
425
426         init_task.thread.mode.tt.extern_pid = pid;
427         err = os_pipe(init_task.thread.mode.tt.switch_pipe, 1, 1);
428         if(err)
429                 panic("Can't create switch pipe for init_task, errno = %d",
430                       -err);
431 }
432
433 int start_uml_tt(void)
434 {
435         void *sp;
436         int pages;
437
438         pages = (1 << CONFIG_KERNEL_STACK_ORDER);
439         sp = (void *) ((unsigned long) init_task.thread_info) +
440                 pages * PAGE_SIZE - sizeof(unsigned long);
441         return(tracer(start_kernel_proc, sp));
442 }
443
444 int external_pid_tt(struct task_struct *task)
445 {
446         return(task->thread.mode.tt.extern_pid);
447 }
448
449 int thread_pid_tt(struct task_struct *task)
450 {
451         return(task->thread.mode.tt.extern_pid);
452 }
453
454 int is_valid_pid(int pid)
455 {
456         struct task_struct *task;
457
458         read_lock(&tasklist_lock);
459         for_each_process(task){
460                 if(task->thread.mode.tt.extern_pid == pid){
461                         read_unlock(&tasklist_lock);
462                         return(1);
463                 }
464         }
465         read_unlock(&tasklist_lock);
466         return(0);
467 }
468
469 /*
470  * Overrides for Emacs so that we follow Linus's tabbing style.
471  * Emacs will notice this stuff at the end of the file and automatically
472  * adjust the settings for this buffer only.  This must remain at the end
473  * of the file.
474  * ---------------------------------------------------------------------------
475  * Local variables:
476  * c-file-style: "linux"
477  * End:
478  */