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