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 <unistd.h>
   8 #include <errno.h>
   9 #include <signal.h>
  10 #include <setjmp.h>
  11 #include <sched.h>
  12 #include <sys/wait.h>
  13 #include <sys/ptrace.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
  31 int is_skas_winch(int pid, int fd, void *data)
  32 {
  33         if(pid != getpid())
  34                 return(0);
  35
  36         register_winch_irq(-1, fd, -1, data);
  37         return(1);
  38 }
  39
  40 /* These are set once at boot time and not changed thereafter */
  41
  42 unsigned long exec_regs[FRAME_SIZE];
  43 unsigned long exec_fp_regs[HOST_FP_SIZE];
  44 unsigned long exec_fpx_regs[HOST_XFP_SIZE];
  45 int have_fpx_regs = 1;
  46
  47 static void handle_segv(int pid)
  48 {
  49         struct ptrace_faultinfo fault;
  50         int err;
  51
  52         err = ptrace(PTRACE_FAULTINFO, pid, 0, &fault);
  53         if(err)
  54                 panic("handle_segv - PTRACE_FAULTINFO failed, errno = %d\n",
  55                       errno);
  56
  57         segv(fault.addr, 0, FAULT_WRITE(fault.is_write), 1, NULL);
  58 }
  59
  60 static void handle_trap(int pid, union uml_pt_regs *regs)
  61 {
  62         int err, syscall_nr, status;
  63
  64         syscall_nr = PT_SYSCALL_NR(regs->skas.regs);
  65         UPT_SYSCALL_NR(regs) = syscall_nr;
  66         if(syscall_nr < 1){
  67                 relay_signal(SIGTRAP, regs);
  68                 return;
  69         }
  70
  71         err = ptrace(PTRACE_POKEUSER, pid, PT_SYSCALL_NR_OFFSET, __NR_getpid);
  72         if(err < 0)
  73                 panic("handle_trap - nullifying syscall failed errno = %d\n",
  74                       errno);
  75
  76         err = ptrace(PTRACE_SYSCALL, pid, 0, 0);
  77         if(err < 0)
  78                 panic("handle_trap - continuing to end of syscall failed, "
  79                       "errno = %d\n", errno);
  80
  81         err = waitpid(pid, &status, WUNTRACED);
  82         if((err < 0) || !WIFSTOPPED(status) || (WSTOPSIG(status) != SIGTRAP))
  83                 panic("handle_trap - failed to wait at end of syscall, "
  84                       "errno = %d, status = %d\n", errno, status);
  85
  86         handle_syscall(regs);
  87 }
  88
  89 static int userspace_tramp(void *arg)
  90 {
  91         init_new_thread_signals(0);
  92         enable_timer();
  93         ptrace(PTRACE_TRACEME, 0, 0, 0);
  94         os_stop_process(os_getpid());
  95         return(0);
  96 }
  97
  98 /* Each element set once, and only accessed by a single processor anyway */
  99 #define NR_CPUS 1
 100 int userspace_pid[NR_CPUS];
 101
 102 void start_userspace(int cpu)
 103 {
 104         void *stack;
 105         unsigned long sp;
 106         int pid, status, n;
 107
 108         stack = mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC,
 109                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 110         if(stack == MAP_FAILED)
 111                 panic("start_userspace : mmap failed, errno = %d", errno);
 112         sp = (unsigned long) stack + PAGE_SIZE - sizeof(void *);
 113
 114         pid = clone(userspace_tramp, (void *) sp,
 115                     CLONE_FILES | CLONE_VM | SIGCHLD, NULL);
 116         if(pid < 0)
 117                 panic("start_userspace : clone failed, errno = %d", errno);
 118
 119         do {
 120                 n = waitpid(pid, &status, WUNTRACED);
 121                 if(n < 0)
 122                         panic("start_userspace : wait failed, errno = %d",
 123                               errno);
 124         } while(WIFSTOPPED(status) && (WSTOPSIG(status) == SIGVTALRM));
 125
 126         if(!WIFSTOPPED(status) || (WSTOPSIG(status) != SIGSTOP))
 127                 panic("start_userspace : expected SIGSTOP, got status = %d",
 128                       status);
 129
 130         if(munmap(stack, PAGE_SIZE) < 0)
 131                 panic("start_userspace : munmap failed, errno = %d\n", errno);
 132
 133         userspace_pid[cpu] = pid;
 134 }
 135
 136 void userspace(union uml_pt_regs *regs)
 137 {
 138         int err, status, op, pid = userspace_pid[0];
 139
 140         restore_registers(regs);
 141
 142         err = ptrace(PTRACE_SYSCALL, pid, 0, 0);
 143         if(err)
 144                 panic("userspace - PTRACE_SYSCALL failed, errno = %d\n",
 145                        errno);
 146         while(1){
 147                 err = waitpid(pid, &status, WUNTRACED);
 148                 if(err < 0)
 149                         panic("userspace - waitpid failed, errno = %d\n",
 150                               errno);
 151
 152                 regs->skas.is_user = 1;
 153                 save_registers(regs);
 154
 155                 if(WIFSTOPPED(status)){
 156                         switch(WSTOPSIG(status)){
 157                         case SIGSEGV:
 158                                 handle_segv(pid);
 159                                 break;
 160                         case SIGTRAP:
 161                                 handle_trap(pid, regs);
 162                                 break;
 163                         case SIGIO:
 164                         case SIGVTALRM:
 165                         case SIGILL:
 166                         case SIGBUS:
 167                         case SIGFPE:
 168                         case SIGWINCH:
 169                                 user_signal(WSTOPSIG(status), regs);
 170                                 break;
 171                         default:
 172                                 printk("userspace - child stopped with signal "
 173                                        "%d\n", WSTOPSIG(status));
 174                         }
 175                         interrupt_end();
 176                 }
 177
 178                 restore_registers(regs);
 179
 180                 op = singlestepping_skas() ? PTRACE_SINGLESTEP :
 181                         PTRACE_SYSCALL;
 182                 err = ptrace(op, pid, 0, 0);
 183                 if(err)
 184                         panic("userspace - PTRACE_SYSCALL failed, "
 185                               "errno = %d\n", errno);
 186         }
 187 }
 188
 189 void new_thread(void *stack, void **switch_buf_ptr, void **fork_buf_ptr,
 190                 void (*handler)(int))
 191 {
 192         unsigned long flags;
 193         jmp_buf switch_buf, fork_buf;
 194
 195         *switch_buf_ptr = &switch_buf;
 196         *fork_buf_ptr = &fork_buf;
 197
 198         /* Somewhat subtle - siglongjmp restores the signal mask before doing
 199          * the longjmp.  This means that when jumping from one stack to another
 200          * when the target stack has interrupts enabled, an interrupt may occur
 201          * on the source stack.  This is bad when starting up a process because
 202          * it's not supposed to get timer ticks until it has been scheduled.
 203          * So, we disable interrupts around the sigsetjmp to ensure that
 204          * they can't happen until we get back here where they are safe.
 205          */
 206         flags = get_signals();
 207         block_signals();
 208         if(sigsetjmp(fork_buf, 1) == 0)
 209                 new_thread_proc(stack, handler);
 210         set_signals(flags);
 211
 212         remove_sigstack();
 213 }
 214
 215 void thread_wait(void *sw, void *fb)
 216 {
 217         jmp_buf buf, **switch_buf = sw, *fork_buf;
 218
 219         *switch_buf = &buf;
 220         fork_buf = fb;
 221         if(sigsetjmp(buf, 1) == 0)
 222                 siglongjmp(*fork_buf, 1);
 223 }
 224
 225 static int move_registers(int pid, int int_op, int fp_op,
 226                           union uml_pt_regs *regs, unsigned long *fp_regs)
 227 {
 228         if(ptrace(int_op, pid, 0, regs->skas.regs) < 0)
 229                 return(-errno);
 230         if(ptrace(fp_op, pid, 0, fp_regs) < 0)
 231                 return(-errno);
 232         return(0);
 233 }
 234
 235 void save_registers(union uml_pt_regs *regs)
 236 {
 237         unsigned long *fp_regs;
 238         int err, fp_op;
 239
 240         if(have_fpx_regs){
 241                 fp_op = PTRACE_GETFPXREGS;
 242                 fp_regs = regs->skas.xfp;
 243         }
 244         else {
 245                 fp_op = PTRACE_GETFPREGS;
 246                 fp_regs = regs->skas.fp;
 247         }
 248
 249         err = move_registers(userspace_pid[0], PTRACE_GETREGS, fp_op, regs,
 250                              fp_regs);
 251         if(err)
 252                 panic("save_registers - saving registers failed, errno = %d\n",
 253                       -err);
 254 }
 255
 256 void restore_registers(union uml_pt_regs *regs)
 257 {
 258         unsigned long *fp_regs;
 259         int err, fp_op;
 260
 261         if(have_fpx_regs){
 262                 fp_op = PTRACE_SETFPXREGS;
 263                 fp_regs = regs->skas.xfp;
 264         }
 265         else {
 266                 fp_op = PTRACE_SETFPREGS;
 267                 fp_regs = regs->skas.fp;
 268         }
 269
 270         err = move_registers(userspace_pid[0], PTRACE_SETREGS, fp_op, regs,
 271                              fp_regs);
 272         if(err)
 273                 panic("restore_registers - saving registers failed, "
 274                       "errno = %d\n", -err);
 275 }
 276
 277 void switch_threads(void *me, void *next)
 278 {
 279         jmp_buf my_buf, **me_ptr = me, *next_buf = next;
 280
 281         *me_ptr = &my_buf;
 282         if(sigsetjmp(my_buf, 1) == 0)
 283                 siglongjmp(*next_buf, 1);
 284 }
 285
 286 static jmp_buf initial_jmpbuf;
 287
 288 /* XXX Make these percpu */
 289 static void (*cb_proc)(void *arg);
 290 static void *cb_arg;
 291 static jmp_buf *cb_back;
 292
 293 int start_idle_thread(void *stack, void *switch_buf_ptr, void **fork_buf_ptr)
 294 {
 295         jmp_buf **switch_buf = switch_buf_ptr;
 296         int n;
 297
 298         *fork_buf_ptr = &initial_jmpbuf;
 299         n = sigsetjmp(initial_jmpbuf, 1);
 300         if(n == 0)
 301                 new_thread_proc((void *) stack, new_thread_handler);
 302         else if(n == 1)
 303                 remove_sigstack();
 304         else if(n == 2){
 305                 (*cb_proc)(cb_arg);
 306                 siglongjmp(*cb_back, 1);
 307         }
 308         else if(n == 3){
 309                 kmalloc_ok = 0;
 310                 return(0);
 311         }
 312         else if(n == 4){
 313                 kmalloc_ok = 0;
 314                 return(1);
 315         }
 316         siglongjmp(**switch_buf, 1);
 317 }
 318
 319 void remove_sigstack(void)
 320 {
 321         stack_t stack = ((stack_t) { .ss_flags  = SS_DISABLE,
 322                                      .ss_sp     = NULL,
 323                                      .ss_size   = 0 });
 324
 325         if(sigaltstack(&stack, NULL) != 0)
 326                 panic("disabling signal stack failed, errno = %d\n", errno);
 327 }
 328
 329 void initial_thread_cb_skas(void (*proc)(void *), void *arg)
 330 {
 331         jmp_buf here;
 332
 333         cb_proc = proc;
 334         cb_arg = arg;
 335         cb_back = &here;
 336
 337         block_signals();
 338         if(sigsetjmp(here, 1) == 0)
 339                 siglongjmp(initial_jmpbuf, 2);
 340         unblock_signals();
 341
 342         cb_proc = NULL;
 343         cb_arg = NULL;
 344         cb_back = NULL;
 345 }
 346
 347 void halt_skas(void)
 348 {
 349         block_signals();
 350         siglongjmp(initial_jmpbuf, 3);
 351 }
 352
 353 void reboot_skas(void)
 354 {
 355         block_signals();
 356         siglongjmp(initial_jmpbuf, 4);
 357 }
 358
 359 int new_mm(int from)
 360 {
 361         struct proc_mm_op copy;
 362         int n, fd = os_open_file("/proc/mm",
 363                                  of_cloexec(of_write(OPENFLAGS())), 0);
 364
 365         if(fd < 0)
 366                 return(fd);
 367
 368         if(from != -1){
 369                 copy = ((struct proc_mm_op) { .op       = MM_COPY_SEGMENTS,
 370                                               .u        =
 371                                               { .copy_segments  = from } } );
 372                 n = os_write_file(fd, &copy, sizeof(copy));
 373                 if(n != sizeof(copy))
 374                         printk("new_mm : /proc/mm copy_segments failed, "
 375                                "err = %d\n", -n);
 376         }
 377
 378         return(fd);
 379 }
 380
 381 void switch_mm_skas(int mm_fd)
 382 {
 383         int err;
 384
 385 #warning need cpu pid in switch_mm_skas
 386         err = ptrace(PTRACE_SWITCH_MM, userspace_pid[0], 0, mm_fd);
 387         if(err)
 388                 panic("switch_mm_skas - PTRACE_SWITCH_MM failed, errno = %d\n",
 389                       errno);
 390 }
 391
 392 void kill_off_processes_skas(void)
 393 {
 394 #warning need to loop over userspace_pids in kill_off_processes_skas
 395         os_kill_process(userspace_pid[0], 1);
 396 }
 397
 398 void init_registers(int pid)
 399 {
 400         int err;
 401
 402         if(ptrace(PTRACE_GETREGS, pid, 0, exec_regs) < 0)
 403                 panic("check_ptrace : PTRACE_GETREGS failed, errno = %d",
 404                       errno);
 405
 406         err = ptrace(PTRACE_GETFPXREGS, pid, 0, exec_fpx_regs);
 407         if(!err)
 408                 return;
 409
 410         have_fpx_regs = 0;
 411         if(errno != EIO)
 412                 panic("check_ptrace : PTRACE_GETFPXREGS failed, errno = %d",
 413                       errno);
 414
 415         err = ptrace(PTRACE_GETFPREGS, pid, 0, exec_fp_regs);
 416         if(err)
 417                 panic("check_ptrace : PTRACE_GETFPREGS failed, errno = %d",
 418                       errno);
 419 }
 420
 421 /*
 422  * Overrides for Emacs so that we follow Linus's tabbing style.
 423  * Emacs will notice this stuff at the end of the file and automatically
 424  * adjust the settings for this buffer only.  This must remain at the end
 425  * of the file.
 426  * ---------------------------------------------------------------------------
 427  * Local variables:
 428  * c-file-style: "linux"
 429  * End:
 430  */