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  */