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