Automatic merge of /spare/repo/netdev-2.6 branch ixgb
[linux-2.6] / arch / um / kernel / skas / process.c
1 /* 
2  * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
3  * Licensed under the GPL
4  */
5
6 #include <stdlib.h>
7 #include <string.h>
8 #include <unistd.h>
9 #include <errno.h>
10 #include <signal.h>
11 #include <setjmp.h>
12 #include <sched.h>
13 #include <sys/wait.h>
14 #include <sys/mman.h>
15 #include <sys/user.h>
16 #include <asm/unistd.h>
17 #include "user.h"
18 #include "ptrace_user.h"
19 #include "time_user.h"
20 #include "sysdep/ptrace.h"
21 #include "user_util.h"
22 #include "kern_util.h"
23 #include "skas.h"
24 #include "sysdep/sigcontext.h"
25 #include "os.h"
26 #include "proc_mm.h"
27 #include "skas_ptrace.h"
28 #include "chan_user.h"
29 #include "signal_user.h"
30 #include "registers.h"
31 #include "process.h"
32
33 int is_skas_winch(int pid, int fd, void *data)
34 {
35         if(pid != os_getpgrp())
36                 return(0);
37
38         register_winch_irq(-1, fd, -1, data);
39         return(1);
40 }
41
42 void get_skas_faultinfo(int pid, struct faultinfo * fi)
43 {
44         int err;
45
46         err = ptrace(PTRACE_FAULTINFO, pid, 0, fi);
47         if(err)
48                 panic("get_skas_faultinfo - PTRACE_FAULTINFO failed, "
49                       "errno = %d\n", errno);
50
51         /* Special handling for i386, which has different structs */
52         if (sizeof(struct ptrace_faultinfo) < sizeof(struct faultinfo))
53                 memset((char *)fi + sizeof(struct ptrace_faultinfo), 0,
54                        sizeof(struct faultinfo) -
55                        sizeof(struct ptrace_faultinfo));
56 }
57
58 static void handle_segv(int pid, union uml_pt_regs * regs)
59 {
60         get_skas_faultinfo(pid, &regs->skas.faultinfo);
61         segv(regs->skas.faultinfo, 0, 1, NULL);
62 }
63
64 /*To use the same value of using_sysemu as the caller, ask it that value (in local_using_sysemu)*/
65 static void handle_trap(int pid, union uml_pt_regs *regs, int local_using_sysemu)
66 {
67         int err, status;
68
69         /* Mark this as a syscall */
70         UPT_SYSCALL_NR(regs) = PT_SYSCALL_NR(regs->skas.regs);
71
72         if (!local_using_sysemu)
73         {
74                 err = ptrace(PTRACE_POKEUSR, pid, PT_SYSCALL_NR_OFFSET, __NR_getpid);
75                 if(err < 0)
76                         panic("handle_trap - nullifying syscall failed errno = %d\n",
77                               errno);
78
79                 err = ptrace(PTRACE_SYSCALL, pid, 0, 0);
80                 if(err < 0)
81                         panic("handle_trap - continuing to end of syscall failed, "
82                               "errno = %d\n", errno);
83
84                 CATCH_EINTR(err = waitpid(pid, &status, WUNTRACED));
85                 if((err < 0) || !WIFSTOPPED(status) ||
86                    (WSTOPSIG(status) != SIGTRAP + 0x80))
87                         panic("handle_trap - failed to wait at end of syscall, "
88                               "errno = %d, status = %d\n", errno, status);
89         }
90
91         handle_syscall(regs);
92 }
93
94 static int userspace_tramp(void *arg)
95 {
96         init_new_thread_signals(0);
97         enable_timer();
98         ptrace(PTRACE_TRACEME, 0, 0, 0);
99         os_stop_process(os_getpid());
100         return(0);
101 }
102
103 /* Each element set once, and only accessed by a single processor anyway */
104 #undef NR_CPUS
105 #define NR_CPUS 1
106 int userspace_pid[NR_CPUS];
107
108 void start_userspace(int cpu)
109 {
110         void *stack;
111         unsigned long sp;
112         int pid, status, n;
113
114         stack = mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC,
115                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
116         if(stack == MAP_FAILED)
117                 panic("start_userspace : mmap failed, errno = %d", errno);
118         sp = (unsigned long) stack + PAGE_SIZE - sizeof(void *);
119
120         pid = clone(userspace_tramp, (void *) sp, 
121                     CLONE_FILES | CLONE_VM | SIGCHLD, NULL);
122         if(pid < 0)
123                 panic("start_userspace : clone failed, errno = %d", errno);
124
125         do {
126                 CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED));
127                 if(n < 0)
128                         panic("start_userspace : wait failed, errno = %d", 
129                               errno);
130         } while(WIFSTOPPED(status) && (WSTOPSIG(status) == SIGVTALRM));
131
132         if(!WIFSTOPPED(status) || (WSTOPSIG(status) != SIGSTOP))
133                 panic("start_userspace : expected SIGSTOP, got status = %d",
134                       status);
135
136         if (ptrace(PTRACE_OLDSETOPTIONS, pid, NULL, (void *)PTRACE_O_TRACESYSGOOD) < 0)
137                 panic("start_userspace : PTRACE_SETOPTIONS failed, errno=%d\n",
138                       errno);
139
140         if(munmap(stack, PAGE_SIZE) < 0)
141                 panic("start_userspace : munmap failed, errno = %d\n", errno);
142
143         userspace_pid[cpu] = pid;
144 }
145
146 void userspace(union uml_pt_regs *regs)
147 {
148         int err, status, op, pid = userspace_pid[0];
149         int local_using_sysemu; /*To prevent races if using_sysemu changes under us.*/
150
151         while(1){
152                 restore_registers(pid, regs);
153
154                 /* Now we set local_using_sysemu to be used for one loop */
155                 local_using_sysemu = get_using_sysemu();
156
157                 op = SELECT_PTRACE_OPERATION(local_using_sysemu, singlestepping(NULL));
158
159                 err = ptrace(op, pid, 0, 0);
160                 if(err)
161                         panic("userspace - could not resume userspace process, "
162                               "pid=%d, ptrace operation = %d, errno = %d\n",
163                               op, errno);
164
165                 CATCH_EINTR(err = waitpid(pid, &status, WUNTRACED));
166                 if(err < 0)
167                         panic("userspace - waitpid failed, errno = %d\n", 
168                               errno);
169
170                 regs->skas.is_user = 1;
171                 save_registers(pid, regs);
172                 UPT_SYSCALL_NR(regs) = -1; /* Assume: It's not a syscall */
173
174                 if(WIFSTOPPED(status)){
175                         switch(WSTOPSIG(status)){
176                         case SIGSEGV:
177                                 handle_segv(pid, regs);
178                                 break;
179                         case SIGTRAP + 0x80:
180                                 handle_trap(pid, regs, local_using_sysemu);
181                                 break;
182                         case SIGTRAP:
183                                 relay_signal(SIGTRAP, regs);
184                                 break;
185                         case SIGIO:
186                         case SIGVTALRM:
187                         case SIGILL:
188                         case SIGBUS:
189                         case SIGFPE:
190                         case SIGWINCH:
191                                 user_signal(WSTOPSIG(status), regs, pid);
192                                 break;
193                         default:
194                                 printk("userspace - child stopped with signal "
195                                        "%d\n", WSTOPSIG(status));
196                         }
197                         interrupt_end();
198
199                         /* Avoid -ERESTARTSYS handling in host */
200                         PT_SYSCALL_NR(regs->skas.regs) = -1;
201                 }
202         }
203 }
204 #define INIT_JMP_NEW_THREAD 0
205 #define INIT_JMP_REMOVE_SIGSTACK 1
206 #define INIT_JMP_CALLBACK 2
207 #define INIT_JMP_HALT 3
208 #define INIT_JMP_REBOOT 4
209
210 void new_thread(void *stack, void **switch_buf_ptr, void **fork_buf_ptr,
211                 void (*handler)(int))
212 {
213         unsigned long flags;
214         sigjmp_buf switch_buf, fork_buf;
215
216         *switch_buf_ptr = &switch_buf;
217         *fork_buf_ptr = &fork_buf;
218
219         /* Somewhat subtle - siglongjmp restores the signal mask before doing
220          * the longjmp.  This means that when jumping from one stack to another
221          * when the target stack has interrupts enabled, an interrupt may occur
222          * on the source stack.  This is bad when starting up a process because
223          * it's not supposed to get timer ticks until it has been scheduled.
224          * So, we disable interrupts around the sigsetjmp to ensure that
225          * they can't happen until we get back here where they are safe.
226          */
227         flags = get_signals();
228         block_signals();
229         if(sigsetjmp(fork_buf, 1) == 0)
230                 new_thread_proc(stack, handler);
231
232         remove_sigstack();
233
234         set_signals(flags);
235 }
236
237 void thread_wait(void *sw, void *fb)
238 {
239         sigjmp_buf buf, **switch_buf = sw, *fork_buf;
240
241         *switch_buf = &buf;
242         fork_buf = fb;
243         if(sigsetjmp(buf, 1) == 0)
244                 siglongjmp(*fork_buf, INIT_JMP_REMOVE_SIGSTACK);
245 }
246
247 void switch_threads(void *me, void *next)
248 {
249         sigjmp_buf my_buf, **me_ptr = me, *next_buf = next;
250         
251         *me_ptr = &my_buf;
252         if(sigsetjmp(my_buf, 1) == 0)
253                 siglongjmp(*next_buf, 1);
254 }
255
256 static sigjmp_buf initial_jmpbuf;
257
258 /* XXX Make these percpu */
259 static void (*cb_proc)(void *arg);
260 static void *cb_arg;
261 static sigjmp_buf *cb_back;
262
263 int start_idle_thread(void *stack, void *switch_buf_ptr, void **fork_buf_ptr)
264 {
265         sigjmp_buf **switch_buf = switch_buf_ptr;
266         int n;
267
268         set_handler(SIGWINCH, (__sighandler_t) sig_handler,
269                     SA_ONSTACK | SA_RESTART, SIGUSR1, SIGIO, SIGALRM,
270                     SIGVTALRM, -1);
271
272         *fork_buf_ptr = &initial_jmpbuf;
273         n = sigsetjmp(initial_jmpbuf, 1);
274         switch(n){
275         case INIT_JMP_NEW_THREAD:
276                 new_thread_proc((void *) stack, new_thread_handler);
277                 break;
278         case INIT_JMP_REMOVE_SIGSTACK:
279                 remove_sigstack();
280                 break;
281         case INIT_JMP_CALLBACK:
282                 (*cb_proc)(cb_arg);
283                 siglongjmp(*cb_back, 1);
284                 break;
285         case INIT_JMP_HALT:
286                 kmalloc_ok = 0;
287                 return(0);
288         case INIT_JMP_REBOOT:
289                 kmalloc_ok = 0;
290                 return(1);
291         default:
292                 panic("Bad sigsetjmp return in start_idle_thread - %d\n", n);
293         }
294         siglongjmp(**switch_buf, 1);
295 }
296
297 void remove_sigstack(void)
298 {
299         stack_t stack = ((stack_t) { .ss_flags  = SS_DISABLE,
300                                      .ss_sp     = NULL,
301                                      .ss_size   = 0 });
302
303         if(sigaltstack(&stack, NULL) != 0)
304                 panic("disabling signal stack failed, errno = %d\n", errno);
305 }
306
307 void initial_thread_cb_skas(void (*proc)(void *), void *arg)
308 {
309         sigjmp_buf here;
310
311         cb_proc = proc;
312         cb_arg = arg;
313         cb_back = &here;
314
315         block_signals();
316         if(sigsetjmp(here, 1) == 0)
317                 siglongjmp(initial_jmpbuf, INIT_JMP_CALLBACK);
318         unblock_signals();
319
320         cb_proc = NULL;
321         cb_arg = NULL;
322         cb_back = NULL;
323 }
324
325 void halt_skas(void)
326 {
327         block_signals();
328         siglongjmp(initial_jmpbuf, INIT_JMP_HALT);
329 }
330
331 void reboot_skas(void)
332 {
333         block_signals();
334         siglongjmp(initial_jmpbuf, INIT_JMP_REBOOT);
335 }
336
337 void switch_mm_skas(int mm_fd)
338 {
339         int err;
340
341 #warning need cpu pid in switch_mm_skas
342         err = ptrace(PTRACE_SWITCH_MM, userspace_pid[0], 0, mm_fd);
343         if(err)
344                 panic("switch_mm_skas - PTRACE_SWITCH_MM failed, errno = %d\n",
345                       errno);
346 }
347
348 void kill_off_processes_skas(void)
349 {
350 #warning need to loop over userspace_pids in kill_off_processes_skas
351         os_kill_ptraced_process(userspace_pid[0], 1);
352 }
353
354 /*
355  * Overrides for Emacs so that we follow Linus's tabbing style.
356  * Emacs will notice this stuff at the end of the file and automatically
357  * adjust the settings for this buffer only.  This must remain at the end
358  * of the file.
359  * ---------------------------------------------------------------------------
360  * Local variables:
361  * c-file-style: "linux"
362  * End:
363  */