fc71ef295782296d10d118f3cc95b336e6b01fcb
[linux-2.6.git] / arch / um / kernel / skas / 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/slab.h"
8 #include "linux/ptrace.h"
9 #include "linux/proc_fs.h"
10 #include "linux/file.h"
11 #include "linux/errno.h"
12 #include "linux/init.h"
13 #include "asm/uaccess.h"
14 #include "asm/atomic.h"
15 #include "kern_util.h"
16 #include "time_user.h"
17 #include "signal_user.h"
18 #include "skas.h"
19 #include "os.h"
20 #include "user_util.h"
21 #include "tlb.h"
22 #include "kern.h"
23 #include "mode.h"
24 #include "proc_mm.h"
25 #include "registers.h"
26
27 void *switch_to_skas(void *prev, void *next)
28 {
29         struct task_struct *from, *to;
30
31         from = prev;
32         to = next;
33
34         /* XXX need to check runqueues[cpu].idle */
35         if(current->pid == 0)
36                 switch_timers(0);
37
38         to->thread.prev_sched = from;
39         set_current(to);
40
41         switch_threads(&from->thread.mode.skas.switch_buf, 
42                        to->thread.mode.skas.switch_buf);
43
44         if(current->pid == 0)
45                 switch_timers(1);
46
47         return(current->thread.prev_sched);
48 }
49
50 extern void schedule_tail(struct task_struct *prev);
51
52 void new_thread_handler(int sig)
53 {
54         int (*fn)(void *), n;
55         void *arg;
56
57         fn = current->thread.request.u.thread.proc;
58         arg = current->thread.request.u.thread.arg;
59         change_sig(SIGUSR1, 1);
60         thread_wait(&current->thread.mode.skas.switch_buf, 
61                     current->thread.mode.skas.fork_buf);
62
63         if(current->thread.prev_sched != NULL)
64                 schedule_tail(current->thread.prev_sched);
65         current->thread.prev_sched = NULL;
66
67         /* The return value is 1 if the kernel thread execs a process,
68          * 0 if it just exits
69          */
70         n = run_kernel_thread(fn, arg, &current->thread.exec_buf);
71         if(n == 1){
72                 /* Handle any immediate reschedules or signals */
73                 interrupt_end();
74                 userspace(&current->thread.regs.regs);
75         }
76         else do_exit(0);
77 }
78
79 void new_thread_proc(void *stack, void (*handler)(int sig))
80 {
81         init_new_thread_stack(stack, handler);
82         os_usr1_process(os_getpid());
83 }
84
85 void release_thread_skas(struct task_struct *task)
86 {
87 }
88
89 void fork_handler(int sig)
90 {
91         change_sig(SIGUSR1, 1);
92         thread_wait(&current->thread.mode.skas.switch_buf, 
93                     current->thread.mode.skas.fork_buf);
94         
95         force_flush_all();
96         if(current->thread.prev_sched == NULL)
97                 panic("blech");
98
99         schedule_tail(current->thread.prev_sched);
100         current->thread.prev_sched = NULL;
101
102         /* Handle any immediate reschedules or signals */
103         interrupt_end();
104         userspace(&current->thread.regs.regs);
105 }
106
107 int copy_thread_skas(int nr, unsigned long clone_flags, unsigned long sp,
108                      unsigned long stack_top, struct task_struct * p, 
109                      struct pt_regs *regs)
110 {
111         void (*handler)(int);
112
113         if(current->thread.forking){
114                 memcpy(&p->thread.regs.regs.skas, 
115                        &current->thread.regs.regs.skas, 
116                        sizeof(p->thread.regs.regs.skas));
117                 REGS_SET_SYSCALL_RETURN(p->thread.regs.regs.skas.regs, 0);
118                 if(sp != 0) REGS_SP(p->thread.regs.regs.skas.regs) = sp;
119
120                 handler = fork_handler;
121         }
122         else {
123                 init_thread_registers(&p->thread.regs.regs);
124                 p->thread.request.u.thread = current->thread.request.u.thread;
125                 handler = new_thread_handler;
126         }
127
128         new_thread(p->thread_info, &p->thread.mode.skas.switch_buf,
129                    &p->thread.mode.skas.fork_buf, handler);
130         return(0);
131 }
132
133 int new_mm(int from)
134 {
135         struct proc_mm_op copy;
136         int n, fd;
137
138         fd = os_open_file("/proc/mm", of_cloexec(of_write(OPENFLAGS())), 0);
139         if(fd < 0)
140                 return(fd);
141
142         if(from != -1){
143                 copy = ((struct proc_mm_op) { .op       = MM_COPY_SEGMENTS,
144                                               .u        =
145                                               { .copy_segments  = from } } );
146                 n = os_write_file(fd, &copy, sizeof(copy));
147                 if(n != sizeof(copy))
148                         printk("new_mm : /proc/mm copy_segments failed, "
149                                "err = %d\n", -n);
150         }
151
152         return(fd);
153 }
154
155 void init_idle_skas(void)
156 {
157         cpu_tasks[current_thread->cpu].pid = os_getpid();
158         default_idle();
159 }
160
161 extern void start_kernel(void);
162
163 static int start_kernel_proc(void *unused)
164 {
165         int pid;
166
167         block_signals();
168         pid = os_getpid();
169
170         cpu_tasks[0].pid = pid;
171         cpu_tasks[0].task = current;
172 #ifdef CONFIG_SMP
173         cpu_online_map = cpumask_of_cpu(0);
174 #endif
175         start_kernel();
176         return(0);
177 }
178
179 int start_uml_skas(void)
180 {
181         start_userspace(0);
182
183         init_new_thread_signals(1);
184         uml_idle_timer();
185
186         init_task.thread.request.u.thread.proc = start_kernel_proc;
187         init_task.thread.request.u.thread.arg = NULL;
188         return(start_idle_thread(init_task.thread_info,
189                                  &init_task.thread.mode.skas.switch_buf,
190                                  &init_task.thread.mode.skas.fork_buf));
191 }
192
193 int external_pid_skas(struct task_struct *task)
194 {
195 #warning Need to look up userspace_pid by cpu
196         return(userspace_pid[0]);
197 }
198
199 int thread_pid_skas(struct task_struct *task)
200 {
201 #warning Need to look up userspace_pid by cpu
202         return(userspace_pid[0]);
203 }
204
205 /*
206  * Overrides for Emacs so that we follow Linus's tabbing style.
207  * Emacs will notice this stuff at the end of the file and automatically
208  * adjust the settings for this buffer only.  This must remain at the end
209  * of the file.
210  * ---------------------------------------------------------------------------
211  * Local variables:
212  * c-file-style: "linux"
213  * End:
214  */