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, ®s->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 ®s->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 } 750