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