arch/um/os-Linux/skas/process.c

   1 /*
   2  * Copyright (C) 2002- 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
   3  * Licensed under the GPL
   4  */
   5
   6 #include <stdlib.h>
   7 #include <unistd.h>
   8 #include <sched.h>
   9 #include <errno.h>
  10 #include <string.h>
  11 #include <sys/mman.h>
  12 #include <sys/wait.h>
  13 #include <asm/unistd.h>
  14 #include <as-layout.h>
  15 #include <init.h>
  16 #include <kern_util.h>
  17 #include <mem.h>
  18 #include <os.h>
  19 #include <proc_mm.h>
  20 #include <ptrace_user.h>
  21 #include <registers.h>
  22 #include <skas.h>
  23 #include <skas_ptrace.h>
  24 #include <sysdep/stub.h>
  25
  26 int is_skas_winch(int pid, int fd, void *data)
  27 {
  28         return pid == getpgrp();
  29 }
  30
  31 static int ptrace_dump_regs(int pid)
  32 {
  33         unsigned long regs[MAX_REG_NR];
  34         int i;
  35
  36         if (ptrace(PTRACE_GETREGS, pid, 0, regs) < 0)
  37                 return -errno;
  38
  39         printk(UM_KERN_ERR "Stub registers -\n");
  40         for (i = 0; i < ARRAY_SIZE(regs); i++)
  41                 printk(UM_KERN_ERR "\t%d - %lx\n", i, regs[i]);
  42
  43         return 0;
  44 }
  45
  46 /*
  47  * Signals that are OK to receive in the stub - we'll just continue it.
  48  * SIGWINCH will happen when UML is inside a detached screen.
  49  */
  50 #define STUB_SIG_MASK ((1 << SIGVTALRM) | (1 << SIGWINCH))
  51
  52 /* Signals that the stub will finish with - anything else is an error */
  53 #define STUB_DONE_MASK (1 << SIGTRAP)
  54
  55 void wait_stub_done(int pid)
  56 {
  57         int n, status, err, bad_stop = 0;
  58
  59         while (1) {
  60                 CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED | __WALL));
  61                 if ((n < 0) || !WIFSTOPPED(status))
  62                         goto bad_wait;
  63
  64                 if (((1 << WSTOPSIG(status)) & STUB_SIG_MASK) == 0)
  65                         break;
  66
  67                 err = ptrace(PTRACE_CONT, pid, 0, 0);
  68                 if (err) {
  69                         printk(UM_KERN_ERR "wait_stub_done : continue failed, "
  70                                "errno = %d\n", errno);
  71                         fatal_sigsegv();
  72                 }
  73         }
  74
  75         if (((1 << WSTOPSIG(status)) & STUB_DONE_MASK) != 0)
  76                 return;
  77         else
  78                 bad_stop = 1;
  79
  80 bad_wait:
  81         err = ptrace_dump_regs(pid);
  82         if (err)
  83                 printk(UM_KERN_ERR "Failed to get registers from stub, "
  84                        "errno = %d\n", -err);
  85         printk(UM_KERN_ERR "wait_stub_done : failed to wait for SIGTRAP, "
  86                "pid = %d, n = %d, errno = %d, status = 0x%x\n", pid, n, errno,
  87                status);
  88         if (bad_stop)
  89                 kill(pid, SIGKILL);
  90         else
  91                 fatal_sigsegv();
  92 }
  93
  94 extern unsigned long current_stub_stack(void);
  95
  96 static void get_skas_faultinfo(int pid, struct faultinfo *fi)
  97 {
  98         int err;
  99
 100         if (ptrace_faultinfo) {
 101                 err = ptrace(PTRACE_FAULTINFO, pid, 0, fi);
 102                 if (err) {
 103                         printk(UM_KERN_ERR "get_skas_faultinfo - "
 104                                "PTRACE_FAULTINFO failed, errno = %d\n", errno);
 105                         fatal_sigsegv();
 106                 }
 107
 108                 /* Special handling for i386, which has different structs */
 109                 if (sizeof(struct ptrace_faultinfo) < sizeof(struct faultinfo))
 110                         memset((char *)fi + sizeof(struct ptrace_faultinfo), 0,
 111                                sizeof(struct faultinfo) -
 112                                sizeof(struct ptrace_faultinfo));
 113         }
 114         else {
 115                 unsigned long fpregs[FP_SIZE];
 116
 117                 err = get_fp_registers(pid, fpregs);
 118                 if (err < 0) {
 119                         printk(UM_KERN_ERR "save_fp_registers returned %d\n",
 120                                err);
 121                         fatal_sigsegv();
 122                 }
 123                 err = ptrace(PTRACE_CONT, pid, 0, SIGSEGV);
 124                 if (err) {
 125                         printk(UM_KERN_ERR "Failed to continue stub, pid = %d, "
 126                                "errno = %d\n", pid, errno);
 127                         fatal_sigsegv();
 128                 }
 129                 wait_stub_done(pid);
 130
 131                 /*
 132                  * faultinfo is prepared by the stub-segv-handler at start of
 133                  * the stub stack page. We just have to copy it.
 134                  */
 135                 memcpy(fi, (void *)current_stub_stack(), sizeof(*fi));
 136
 137                 err = put_fp_registers(pid, fpregs);
 138                 if (err < 0) {
 139                         printk(UM_KERN_ERR "put_fp_registers returned %d\n",
 140                                err);
 141                         fatal_sigsegv();
 142                 }
 143         }
 144 }
 145
 146 static void handle_segv(int pid, struct uml_pt_regs * regs)
 147 {
 148         get_skas_faultinfo(pid, &regs->faultinfo);
 149         segv(regs->faultinfo, 0, 1, NULL);
 150 }
 151
 152 /*
 153  * To use the same value of using_sysemu as the caller, ask it that value
 154  * (in local_using_sysemu
 155  */
 156 static void handle_trap(int pid, struct uml_pt_regs *regs,
 157                         int local_using_sysemu)
 158 {
 159         int err, status;
 160
 161         if ((UPT_IP(regs) >= STUB_START) && (UPT_IP(regs) < STUB_END))
 162                 fatal_sigsegv();
 163
 164         /* Mark this as a syscall */
 165         UPT_SYSCALL_NR(regs) = PT_SYSCALL_NR(regs->gp);
 166
 167         if (!local_using_sysemu)
 168         {
 169                 err = ptrace(PTRACE_POKEUSER, pid, PT_SYSCALL_NR_OFFSET,
 170                              __NR_getpid);
 171                 if (err < 0) {
 172                         printk(UM_KERN_ERR "handle_trap - nullifying syscall "
 173                                "failed, errno = %d\n", errno);
 174                         fatal_sigsegv();
 175                 }
 176
 177                 err = ptrace(PTRACE_SYSCALL, pid, 0, 0);
 178                 if (err < 0) {
 179                         printk(UM_KERN_ERR "handle_trap - continuing to end of "
 180                                "syscall failed, errno = %d\n", errno);
 181                         fatal_sigsegv();
 182                 }
 183
 184                 CATCH_EINTR(err = waitpid(pid, &status, WUNTRACED | __WALL));
 185                 if ((err < 0) || !WIFSTOPPED(status) ||
 186                     (WSTOPSIG(status) != SIGTRAP + 0x80)) {
 187                         err = ptrace_dump_regs(pid);
 188                         if (err)
 189                                 printk(UM_KERN_ERR "Failed to get registers "
 190                                        "from process, errno = %d\n", -err);
 191                         printk(UM_KERN_ERR "handle_trap - failed to wait at "
 192                                "end of syscall, errno = %d, status = %d\n",
 193                                errno, status);
 194                         fatal_sigsegv();
 195                 }
 196         }
 197
 198         handle_syscall(regs);
 199 }
 200
 201 extern int __syscall_stub_start;
 202
 203 static int userspace_tramp(void *stack)
 204 {
 205         void *addr;
 206         int err;
 207
 208         ptrace(PTRACE_TRACEME, 0, 0, 0);
 209
 210         signal(SIGTERM, SIG_DFL);
 211         signal(SIGWINCH, SIG_IGN);
 212         err = set_interval();
 213         if (err) {
 214                 printk(UM_KERN_ERR "userspace_tramp - setting timer failed, "
 215                        "errno = %d\n", err);
 216                 exit(1);
 217         }
 218
 219         if (!proc_mm) {
 220                 /*
 221                  * This has a pte, but it can't be mapped in with the usual
 222                  * tlb_flush mechanism because this is part of that mechanism
 223                  */
 224                 int fd;
 225                 unsigned long long offset;
 226                 fd = phys_mapping(to_phys(&__syscall_stub_start), &offset);
 227                 addr = mmap64((void *) STUB_CODE, UM_KERN_PAGE_SIZE,
 228                               PROT_EXEC, MAP_FIXED | MAP_PRIVATE, fd, offset);
 229                 if (addr == MAP_FAILED) {
 230                         printk(UM_KERN_ERR "mapping mmap stub at 0x%lx failed, "
 231                                "errno = %d\n", STUB_CODE, errno);
 232                         exit(1);
 233                 }
 234
 235                 if (stack != NULL) {
 236                         fd = phys_mapping(to_phys(stack), &offset);
 237                         addr = mmap((void *) STUB_DATA,
 238                                     UM_KERN_PAGE_SIZE, PROT_READ | PROT_WRITE,
 239                                     MAP_FIXED | MAP_SHARED, fd, offset);
 240                         if (addr == MAP_FAILED) {
 241                                 printk(UM_KERN_ERR "mapping segfault stack "
 242                                        "at 0x%lx failed, errno = %d\n",
 243                                        STUB_DATA, errno);
 244                                 exit(1);
 245                         }
 246                 }
 247         }
 248         if (!ptrace_faultinfo && (stack != NULL)) {
 249                 struct sigaction sa;
 250
 251                 unsigned long v = STUB_CODE +
 252                                   (unsigned long) stub_segv_handler -
 253                                   (unsigned long) &__syscall_stub_start;
 254
 255                 set_sigstack((void *) STUB_DATA, UM_KERN_PAGE_SIZE);
 256                 sigemptyset(&sa.sa_mask);
 257                 sa.sa_flags = SA_ONSTACK | SA_NODEFER | SA_SIGINFO;
 258                 sa.sa_sigaction = (void *) v;
 259                 sa.sa_restorer = NULL;
 260                 if (sigaction(SIGSEGV, &sa, NULL) < 0) {
 261                         printk(UM_KERN_ERR "userspace_tramp - setting SIGSEGV "
 262                                "handler failed - errno = %d\n", errno);
 263                         exit(1);
 264                 }
 265         }
 266
 267         kill(os_getpid(), SIGSTOP);
 268         return 0;
 269 }
 270
 271 /* Each element set once, and only accessed by a single processor anyway */
 272 #undef NR_CPUS
 273 #define NR_CPUS 1
 274 int userspace_pid[NR_CPUS];
 275
 276 int start_userspace(unsigned long stub_stack)
 277 {
 278         void *stack;
 279         unsigned long sp;
 280         int pid, status, n, flags, err;
 281
 282         stack = mmap(NULL, UM_KERN_PAGE_SIZE,
 283                      PROT_READ | PROT_WRITE | PROT_EXEC,
 284                      MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 285         if (stack == MAP_FAILED) {
 286                 err = -errno;
 287                 printk(UM_KERN_ERR "start_userspace : mmap failed, "
 288                        "errno = %d\n", errno);
 289                 return err;
 290         }
 291
 292         sp = (unsigned long) stack + UM_KERN_PAGE_SIZE - sizeof(void *);
 293
 294         flags = CLONE_FILES;
 295         if (proc_mm)
 296                 flags |= CLONE_VM;
 297         else
 298                 flags |= SIGCHLD;
 299
 300         pid = clone(userspace_tramp, (void *) sp, flags, (void *) stub_stack);
 301         if (pid < 0) {
 302                 err = -errno;
 303                 printk(UM_KERN_ERR "start_userspace : clone failed, "
 304                        "errno = %d\n", errno);
 305                 return err;
 306         }
 307
 308         do {
 309                 CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED | __WALL));
 310                 if (n < 0) {
 311                         err = -errno;
 312                         printk(UM_KERN_ERR "start_userspace : wait failed, "
 313                                "errno = %d\n", errno);
 314                         goto out_kill;
 315                 }
 316         } while (WIFSTOPPED(status) && (WSTOPSIG(status) == SIGVTALRM));
 317
 318         if (!WIFSTOPPED(status) || (WSTOPSIG(status) != SIGSTOP)) {
 319                 err = -EINVAL;
 320                 printk(UM_KERN_ERR "start_userspace : expected SIGSTOP, got "
 321                        "status = %d\n", status);
 322                 goto out_kill;
 323         }
 324
 325         if (ptrace(PTRACE_OLDSETOPTIONS, pid, NULL,
 326                    (void *) PTRACE_O_TRACESYSGOOD) < 0) {
 327                 err = -errno;
 328                 printk(UM_KERN_ERR "start_userspace : PTRACE_OLDSETOPTIONS "
 329                        "failed, errno = %d\n", errno);
 330                 goto out_kill;
 331         }
 332
 333         if (munmap(stack, UM_KERN_PAGE_SIZE) < 0) {
 334                 err = -errno;
 335                 printk(UM_KERN_ERR "start_userspace : munmap failed, "
 336                        "errno = %d\n", errno);
 337                 goto out_kill;
 338         }
 339
 340         return pid;
 341
 342  out_kill:
 343         os_kill_ptraced_process(pid, 1);
 344         return err;
 345 }
 346
 347 void userspace(struct uml_pt_regs *regs)
 348 {
 349         struct itimerval timer;
 350         unsigned long long nsecs, now;
 351         int err, status, op, pid = userspace_pid[0];
 352         /* To prevent races if using_sysemu changes under us.*/
 353         int local_using_sysemu;
 354         siginfo_t si;
 355
 356         /* Handle any immediate reschedules or signals */
 357         interrupt_end();
 358
 359         if (getitimer(ITIMER_VIRTUAL, &timer))
 360                 printk(UM_KERN_ERR "Failed to get itimer, errno = %d\n", errno);
 361         nsecs = timer.it_value.tv_sec * UM_NSEC_PER_SEC +
 362                 timer.it_value.tv_usec * UM_NSEC_PER_USEC;
 363         nsecs += os_nsecs();
 364
 365         while (1) {
 366                 /*
 367                  * This can legitimately fail if the process loads a
 368                  * bogus value into a segment register.  It will
 369                  * segfault and PTRACE_GETREGS will read that value
 370                  * out of the process.  However, PTRACE_SETREGS will
 371                  * fail.  In this case, there is nothing to do but
 372                  * just kill the process.
 373                  */
 374                 if (ptrace(PTRACE_SETREGS, pid, 0, regs->gp))
 375                         fatal_sigsegv();
 376
 377                 if (put_fp_registers(pid, regs->fp))
 378                         fatal_sigsegv();
 379
 380                 /* Now we set local_using_sysemu to be used for one loop */
 381                 local_using_sysemu = get_using_sysemu();
 382
 383                 op = SELECT_PTRACE_OPERATION(local_using_sysemu,
 384                                              singlestepping(NULL));
 385
 386                 if (ptrace(op, pid, 0, 0)) {
 387                         printk(UM_KERN_ERR "userspace - ptrace continue "
 388                                "failed, op = %d, errno = %d\n", op, errno);
 389                         fatal_sigsegv();
 390                 }
 391
 392                 CATCH_EINTR(err = waitpid(pid, &status, WUNTRACED | __WALL));
 393                 if (err < 0) {
 394                         printk(UM_KERN_ERR "userspace - wait failed, "
 395                                "errno = %d\n", errno);
 396                         fatal_sigsegv();
 397                 }
 398
 399                 regs->is_user = 1;
 400                 if (ptrace(PTRACE_GETREGS, pid, 0, regs->gp)) {
 401                         printk(UM_KERN_ERR "userspace - PTRACE_GETREGS failed, "
 402                                "errno = %d\n", errno);
 403                         fatal_sigsegv();
 404                 }
 405
 406                 if (get_fp_registers(pid, regs->fp)) {
 407                         printk(UM_KERN_ERR "userspace -  get_fp_registers failed, "
 408                                "errno = %d\n", errno);
 409                         fatal_sigsegv();
 410                 }
 411
 412                 UPT_SYSCALL_NR(regs) = -1; /* Assume: It's not a syscall */
 413
 414                 if (WIFSTOPPED(status)) {
 415                         int sig = WSTOPSIG(status);
 416
 417                         ptrace(PTRACE_GETSIGINFO, pid, 0, (struct siginfo *)&si);
 418
 419                         switch (sig) {
 420                         case SIGSEGV:
 421                                 if (PTRACE_FULL_FAULTINFO ||
 422                                     !ptrace_faultinfo) {
 423                                         get_skas_faultinfo(pid,
 424                                                            &regs->faultinfo);
 425                                         (*sig_info[SIGSEGV])(SIGSEGV, (struct siginfo *)&si,
 426                                                              regs);
 427                                 }
 428                                 else handle_segv(pid, regs);
 429                                 break;
 430                         case SIGTRAP + 0x80:
 431                                 handle_trap(pid, regs, local_using_sysemu);
 432                                 break;
 433                         case SIGTRAP:
 434                                 relay_signal(SIGTRAP, (struct siginfo *)&si, regs);
 435                                 break;
 436                         case SIGVTALRM:
 437                                 now = os_nsecs();
 438                                 if (now < nsecs)
 439                                         break;
 440                                 block_signals();
 441                                 (*sig_info[sig])(sig, (struct siginfo *)&si, regs);
 442                                 unblock_signals();
 443                                 nsecs = timer.it_value.tv_sec *
 444                                         UM_NSEC_PER_SEC +
 445                                         timer.it_value.tv_usec *
 446                                         UM_NSEC_PER_USEC;
 447                                 nsecs += os_nsecs();
 448                                 break;
 449                         case SIGIO:
 450                         case SIGILL:
 451                         case SIGBUS:
 452                         case SIGFPE:
 453                         case SIGWINCH:
 454                                 block_signals();
 455                                 (*sig_info[sig])(sig, (struct siginfo *)&si, regs);
 456                                 unblock_signals();
 457                                 break;
 458                         default:
 459                                 printk(UM_KERN_ERR "userspace - child stopped "
 460                                        "with signal %d\n", sig);
 461                                 fatal_sigsegv();
 462                         }
 463                         pid = userspace_pid[0];
 464                         interrupt_end();
 465
 466                         /* Avoid -ERESTARTSYS handling in host */
 467                         if (PT_SYSCALL_NR_OFFSET != PT_SYSCALL_RET_OFFSET)
 468                                 PT_SYSCALL_NR(regs->gp) = -1;
 469                 }
 470         }
 471 }
 472
 473 static unsigned long thread_regs[MAX_REG_NR];
 474 static unsigned long thread_fp_regs[FP_SIZE];
 475
 476 static int __init init_thread_regs(void)
 477 {
 478         get_safe_registers(thread_regs, thread_fp_regs);
 479         /* Set parent's instruction pointer to start of clone-stub */
 480         thread_regs[REGS_IP_INDEX] = STUB_CODE +
 481                                 (unsigned long) stub_clone_handler -
 482                                 (unsigned long) &__syscall_stub_start;
 483         thread_regs[REGS_SP_INDEX] = STUB_DATA + UM_KERN_PAGE_SIZE -
 484                 sizeof(void *);
 485 #ifdef __SIGNAL_FRAMESIZE
 486         thread_regs[REGS_SP_INDEX] -= __SIGNAL_FRAMESIZE;
 487 #endif
 488         return 0;
 489 }
 490
 491 __initcall(init_thread_regs);
 492
 493 int copy_context_skas0(unsigned long new_stack, int pid)
 494 {
 495         struct timeval tv = { .tv_sec = 0, .tv_usec = UM_USEC_PER_SEC / UM_HZ };
 496         int err;
 497         unsigned long current_stack = current_stub_stack();
 498         struct stub_data *data = (struct stub_data *) current_stack;
 499         struct stub_data *child_data = (struct stub_data *) new_stack;
 500         unsigned long long new_offset;
 501         int new_fd = phys_mapping(to_phys((void *)new_stack), &new_offset);
 502
 503         /*
 504          * prepare offset and fd of child's stack as argument for parent's
 505          * and child's mmap2 calls
 506          */
 507         *data = ((struct stub_data) { .offset   = MMAP_OFFSET(new_offset),
 508                                       .fd       = new_fd,
 509                                       .timer    = ((struct itimerval)
 510                                                    { .it_value = tv,
 511                                                      .it_interval = tv }) });
 512
 513         err = ptrace_setregs(pid, thread_regs);
 514         if (err < 0) {
 515                 err = -errno;
 516                 printk(UM_KERN_ERR "copy_context_skas0 : PTRACE_SETREGS "
 517                        "failed, pid = %d, errno = %d\n", pid, -err);
 518                 return err;
 519         }
 520
 521         err = put_fp_registers(pid, thread_fp_regs);
 522         if (err < 0) {
 523                 printk(UM_KERN_ERR "copy_context_skas0 : put_fp_registers "
 524                        "failed, pid = %d, err = %d\n", pid, err);
 525                 return err;
 526         }
 527
 528         /* set a well known return code for detection of child write failure */
 529         child_data->err = 12345678;
 530
 531         /*
 532          * Wait, until parent has finished its work: read child's pid from
 533          * parent's stack, and check, if bad result.
 534          */
 535         err = ptrace(PTRACE_CONT, pid, 0, 0);
 536         if (err) {
 537                 err = -errno;
 538                 printk(UM_KERN_ERR "Failed to continue new process, pid = %d, "
 539                        "errno = %d\n", pid, errno);
 540                 return err;
 541         }
 542
 543         wait_stub_done(pid);
 544
 545         pid = data->err;
 546         if (pid < 0) {
 547                 printk(UM_KERN_ERR "copy_context_skas0 - stub-parent reports "
 548                        "error %d\n", -pid);
 549                 return pid;
 550         }
 551
 552         /*
 553          * Wait, until child has finished too: read child's result from
 554          * child's stack and check it.
 555          */
 556         wait_stub_done(pid);
 557         if (child_data->err != STUB_DATA) {
 558                 printk(UM_KERN_ERR "copy_context_skas0 - stub-child reports "
 559                        "error %ld\n", child_data->err);
 560                 err = child_data->err;
 561                 goto out_kill;
 562         }
 563
 564         if (ptrace(PTRACE_OLDSETOPTIONS, pid, NULL,
 565                    (void *)PTRACE_O_TRACESYSGOOD) < 0) {
 566                 err = -errno;
 567                 printk(UM_KERN_ERR "copy_context_skas0 : PTRACE_OLDSETOPTIONS "
 568                        "failed, errno = %d\n", errno);
 569                 goto out_kill;
 570         }
 571
 572         return pid;
 573
 574  out_kill:
 575         os_kill_ptraced_process(pid, 1);
 576         return err;
 577 }
 578
 579 /*
 580  * This is used only, if stub pages are needed, while proc_mm is
 581  * available. Opening /proc/mm creates a new mm_context, which lacks
 582  * the stub-pages. Thus, we map them using /proc/mm-fd
 583  */
 584 int map_stub_pages(int fd, unsigned long code, unsigned long data,
 585                    unsigned long stack)
 586 {
 587         struct proc_mm_op mmop;
 588         int n;
 589         unsigned long long code_offset;
 590         int code_fd = phys_mapping(to_phys((void *) &__syscall_stub_start),
 591                                    &code_offset);
 592
 593         mmop = ((struct proc_mm_op) { .op        = MM_MMAP,
 594                                       .u         =
 595                                       { .mmap    =
 596                                         { .addr    = code,
 597                                           .len     = UM_KERN_PAGE_SIZE,
 598                                           .prot    = PROT_EXEC,
 599                                           .flags   = MAP_FIXED | MAP_PRIVATE,
 600                                           .fd      = code_fd,
 601                                           .offset  = code_offset
 602         } } });
 603         CATCH_EINTR(n = write(fd, &mmop, sizeof(mmop)));
 604         if (n != sizeof(mmop)) {
 605                 n = errno;
 606                 printk(UM_KERN_ERR "mmap args - addr = 0x%lx, fd = %d, "
 607                        "offset = %llx\n", code, code_fd,
 608                        (unsigned long long) code_offset);
 609                 printk(UM_KERN_ERR "map_stub_pages : /proc/mm map for code "
 610                        "failed, err = %d\n", n);
 611                 return -n;
 612         }
 613
 614         if (stack) {
 615                 unsigned long long map_offset;
 616                 int map_fd = phys_mapping(to_phys((void *)stack), &map_offset);
 617                 mmop = ((struct proc_mm_op)
 618                                 { .op        = MM_MMAP,
 619                                   .u         =
 620                                   { .mmap    =
 621                                     { .addr    = data,
 622                                       .len     = UM_KERN_PAGE_SIZE,
 623                                       .prot    = PROT_READ | PROT_WRITE,
 624                                       .flags   = MAP_FIXED | MAP_SHARED,
 625                                       .fd      = map_fd,
 626                                       .offset  = map_offset
 627                 } } });
 628                 CATCH_EINTR(n = write(fd, &mmop, sizeof(mmop)));
 629                 if (n != sizeof(mmop)) {
 630                         n = errno;
 631                         printk(UM_KERN_ERR "map_stub_pages : /proc/mm map for "
 632                                "data failed, err = %d\n", n);
 633                         return -n;
 634                 }
 635         }
 636
 637         return 0;
 638 }
 639
 640 void new_thread(void *stack, jmp_buf *buf, void (*handler)(void))
 641 {
 642         (*buf)[0].JB_IP = (unsigned long) handler;
 643         (*buf)[0].JB_SP = (unsigned long) stack + UM_THREAD_SIZE -
 644                 sizeof(void *);
 645 }
 646
 647 #define INIT_JMP_NEW_THREAD 0
 648 #define INIT_JMP_CALLBACK 1
 649 #define INIT_JMP_HALT 2
 650 #define INIT_JMP_REBOOT 3
 651
 652 void switch_threads(jmp_buf *me, jmp_buf *you)
 653 {
 654         if (UML_SETJMP(me) == 0)
 655                 UML_LONGJMP(you, 1);
 656 }
 657
 658 static jmp_buf initial_jmpbuf;
 659
 660 /* XXX Make these percpu */
 661 static void (*cb_proc)(void *arg);
 662 static void *cb_arg;
 663 static jmp_buf *cb_back;
 664
 665 int start_idle_thread(void *stack, jmp_buf *switch_buf)
 666 {
 667         int n;
 668
 669         set_handler(SIGWINCH);
 670
 671         /*
 672          * Can't use UML_SETJMP or UML_LONGJMP here because they save
 673          * and restore signals, with the possible side-effect of
 674          * trying to handle any signals which came when they were
 675          * blocked, which can't be done on this stack.
 676          * Signals must be blocked when jumping back here and restored
 677          * after returning to the jumper.
 678          */
 679         n = setjmp(initial_jmpbuf);
 680         switch (n) {
 681         case INIT_JMP_NEW_THREAD:
 682                 (*switch_buf)[0].JB_IP = (unsigned long) new_thread_handler;
 683                 (*switch_buf)[0].JB_SP = (unsigned long) stack +
 684                         UM_THREAD_SIZE - sizeof(void *);
 685                 break;
 686         case INIT_JMP_CALLBACK:
 687                 (*cb_proc)(cb_arg);
 688                 longjmp(*cb_back, 1);
 689                 break;
 690         case INIT_JMP_HALT:
 691                 kmalloc_ok = 0;
 692                 return 0;
 693         case INIT_JMP_REBOOT:
 694                 kmalloc_ok = 0;
 695                 return 1;
 696         default:
 697                 printk(UM_KERN_ERR "Bad sigsetjmp return in "
 698                        "start_idle_thread - %d\n", n);
 699                 fatal_sigsegv();
 700         }
 701         longjmp(*switch_buf, 1);
 702 }
 703
 704 void initial_thread_cb_skas(void (*proc)(void *), void *arg)
 705 {
 706         jmp_buf here;
 707
 708         cb_proc = proc;
 709         cb_arg = arg;
 710         cb_back = &here;
 711
 712         block_signals();
 713         if (UML_SETJMP(&here) == 0)
 714                 UML_LONGJMP(&initial_jmpbuf, INIT_JMP_CALLBACK);
 715         unblock_signals();
 716
 717         cb_proc = NULL;
 718         cb_arg = NULL;
 719         cb_back = NULL;
 720 }
 721
 722 void halt_skas(void)
 723 {
 724         block_signals();
 725         UML_LONGJMP(&initial_jmpbuf, INIT_JMP_HALT);
 726 }
 727
 728 void reboot_skas(void)
 729 {
 730         block_signals();
 731         UML_LONGJMP(&initial_jmpbuf, INIT_JMP_REBOOT);
 732 }
 733
 734 void __switch_mm(struct mm_id *mm_idp)
 735 {
 736         int err;
 737
 738         /* FIXME: need cpu pid in __switch_mm */
 739         if (proc_mm) {
 740                 err = ptrace(PTRACE_SWITCH_MM, userspace_pid[0], 0,
 741                              mm_idp->u.mm_fd);
 742                 if (err) {
 743                         printk(UM_KERN_ERR "__switch_mm - PTRACE_SWITCH_MM "
 744                                "failed, errno = %d\n", errno);
 745                         fatal_sigsegv();
 746                 }
 747         }
 748         else userspace_pid[0] = mm_idp->u.pid;
 749 }