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 int get_syscall(struct uml_pt_regs *regs) 176 { 177 UPT_SYSCALL_NR(regs) = PT_SYSCALL_NR(regs->gp); 178 179 return UPT_SYSCALL_NR(regs); 180 } 181 182 extern char __syscall_stub_start[]; 183 184 static int userspace_tramp(void *stack) 185 { 186 void *addr; 187 int fd; 188 unsigned long long offset; 189 190 ptrace(PTRACE_TRACEME, 0, 0, 0); 191 192 signal(SIGTERM, SIG_DFL); 193 signal(SIGWINCH, SIG_IGN); 194 195 /* 196 * This has a pte, but it can't be mapped in with the usual 197 * tlb_flush mechanism because this is part of that mechanism 198 */ 199 fd = phys_mapping(to_phys(__syscall_stub_start), &offset); 200 addr = mmap64((void *) STUB_CODE, UM_KERN_PAGE_SIZE, 201 PROT_EXEC, MAP_FIXED | MAP_PRIVATE, fd, offset); 202 if (addr == MAP_FAILED) { 203 printk(UM_KERN_ERR "mapping mmap stub at 0x%lx failed, " 204 "errno = %d\n", STUB_CODE, errno); 205 exit(1); 206 } 207 208 if (stack != NULL) { 209 fd = phys_mapping(to_phys(stack), &offset); 210 addr = mmap((void *) STUB_DATA, 211 UM_KERN_PAGE_SIZE, PROT_READ | PROT_WRITE, 212 MAP_FIXED | MAP_SHARED, fd, offset); 213 if (addr == MAP_FAILED) { 214 printk(UM_KERN_ERR "mapping segfault stack " 215 "at 0x%lx failed, errno = %d\n", 216 STUB_DATA, errno); 217 exit(1); 218 } 219 } 220 if (stack != NULL) { 221 struct sigaction sa; 222 223 unsigned long v = STUB_CODE + 224 (unsigned long) stub_segv_handler - 225 (unsigned long) __syscall_stub_start; 226 227 set_sigstack((void *) STUB_DATA, UM_KERN_PAGE_SIZE); 228 sigemptyset(&sa.sa_mask); 229 sa.sa_flags = SA_ONSTACK | SA_NODEFER | SA_SIGINFO; 230 sa.sa_sigaction = (void *) v; 231 sa.sa_restorer = NULL; 232 if (sigaction(SIGSEGV, &sa, NULL) < 0) { 233 printk(UM_KERN_ERR "userspace_tramp - setting SIGSEGV " 234 "handler failed - errno = %d\n", errno); 235 exit(1); 236 } 237 } 238 239 kill(os_getpid(), SIGSTOP); 240 return 0; 241 } 242 243 /* Each element set once, and only accessed by a single processor anyway */ 244 #undef NR_CPUS 245 #define NR_CPUS 1 246 int userspace_pid[NR_CPUS]; 247 248 int start_userspace(unsigned long stub_stack) 249 { 250 void *stack; 251 unsigned long sp; 252 int pid, status, n, flags, err; 253 254 stack = mmap(NULL, UM_KERN_PAGE_SIZE, 255 PROT_READ | PROT_WRITE | PROT_EXEC, 256 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); 257 if (stack == MAP_FAILED) { 258 err = -errno; 259 printk(UM_KERN_ERR "start_userspace : mmap failed, " 260 "errno = %d\n", errno); 261 return err; 262 } 263 264 sp = (unsigned long) stack + UM_KERN_PAGE_SIZE - sizeof(void *); 265 266 flags = CLONE_FILES | SIGCHLD; 267 268 pid = clone(userspace_tramp, (void *) sp, flags, (void *) stub_stack); 269 if (pid < 0) { 270 err = -errno; 271 printk(UM_KERN_ERR "start_userspace : clone failed, " 272 "errno = %d\n", errno); 273 return err; 274 } 275 276 do { 277 CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED | __WALL)); 278 if (n < 0) { 279 err = -errno; 280 printk(UM_KERN_ERR "start_userspace : wait failed, " 281 "errno = %d\n", errno); 282 goto out_kill; 283 } 284 } while (WIFSTOPPED(status) && (WSTOPSIG(status) == SIGALRM)); 285 286 if (!WIFSTOPPED(status) || (WSTOPSIG(status) != SIGSTOP)) { 287 err = -EINVAL; 288 printk(UM_KERN_ERR "start_userspace : expected SIGSTOP, got " 289 "status = %d\n", status); 290 goto out_kill; 291 } 292 293 if (ptrace(PTRACE_OLDSETOPTIONS, pid, NULL, 294 (void *) PTRACE_O_TRACESYSGOOD) < 0) { 295 err = -errno; 296 printk(UM_KERN_ERR "start_userspace : PTRACE_OLDSETOPTIONS " 297 "failed, errno = %d\n", errno); 298 goto out_kill; 299 } 300 301 if (munmap(stack, UM_KERN_PAGE_SIZE) < 0) { 302 err = -errno; 303 printk(UM_KERN_ERR "start_userspace : munmap failed, " 304 "errno = %d\n", errno); 305 goto out_kill; 306 } 307 308 return pid; 309 310 out_kill: 311 os_kill_ptraced_process(pid, 1); 312 return err; 313 } 314 315 void userspace(struct uml_pt_regs *regs) 316 { 317 int err, status, op, pid = userspace_pid[0]; 318 /* To prevent races if using_sysemu changes under us.*/ 319 int local_using_sysemu; 320 siginfo_t si; 321 322 /* Handle any immediate reschedules or signals */ 323 interrupt_end(); 324 325 while (1) { 326 327 /* 328 * This can legitimately fail if the process loads a 329 * bogus value into a segment register. It will 330 * segfault and PTRACE_GETREGS will read that value 331 * out of the process. However, PTRACE_SETREGS will 332 * fail. In this case, there is nothing to do but 333 * just kill the process. 334 */ 335 if (ptrace(PTRACE_SETREGS, pid, 0, regs->gp)) 336 fatal_sigsegv(); 337 338 if (put_fp_registers(pid, regs->fp)) 339 fatal_sigsegv(); 340 341 /* Now we set local_using_sysemu to be used for one loop */ 342 local_using_sysemu = get_using_sysemu(); 343 344 op = SELECT_PTRACE_OPERATION(local_using_sysemu, 345 singlestepping(NULL)); 346 347 if (ptrace(op, pid, 0, 0)) { 348 printk(UM_KERN_ERR "userspace - ptrace continue " 349 "failed, op = %d, errno = %d\n", op, errno); 350 fatal_sigsegv(); 351 } 352 353 CATCH_EINTR(err = waitpid(pid, &status, WUNTRACED | __WALL)); 354 if (err < 0) { 355 printk(UM_KERN_ERR "userspace - wait failed, " 356 "errno = %d\n", errno); 357 fatal_sigsegv(); 358 } 359 360 regs->is_user = 1; 361 if (ptrace(PTRACE_GETREGS, pid, 0, regs->gp)) { 362 printk(UM_KERN_ERR "userspace - PTRACE_GETREGS failed, " 363 "errno = %d\n", errno); 364 fatal_sigsegv(); 365 } 366 367 if (get_fp_registers(pid, regs->fp)) { 368 printk(UM_KERN_ERR "userspace - get_fp_registers failed, " 369 "errno = %d\n", errno); 370 fatal_sigsegv(); 371 } 372 373 UPT_SYSCALL_NR(regs) = -1; /* Assume: It's not a syscall */ 374 375 if (WIFSTOPPED(status)) { 376 int sig = WSTOPSIG(status); 377 378 ptrace(PTRACE_GETSIGINFO, pid, 0, (struct siginfo *)&si); 379 380 switch (sig) { 381 case SIGSEGV: 382 if (PTRACE_FULL_FAULTINFO) { 383 get_skas_faultinfo(pid, 384 ®s->faultinfo); 385 (*sig_info[SIGSEGV])(SIGSEGV, (struct siginfo *)&si, 386 regs); 387 } 388 else handle_segv(pid, regs); 389 break; 390 case SIGTRAP + 0x80: 391 handle_trap(pid, regs, local_using_sysemu); 392 break; 393 case SIGTRAP: 394 relay_signal(SIGTRAP, (struct siginfo *)&si, regs); 395 break; 396 case SIGALRM: 397 break; 398 case SIGIO: 399 case SIGILL: 400 case SIGBUS: 401 case SIGFPE: 402 case SIGWINCH: 403 block_signals(); 404 (*sig_info[sig])(sig, (struct siginfo *)&si, regs); 405 unblock_signals(); 406 break; 407 default: 408 printk(UM_KERN_ERR "userspace - child stopped " 409 "with signal %d\n", sig); 410 fatal_sigsegv(); 411 } 412 pid = userspace_pid[0]; 413 interrupt_end(); 414 415 /* Avoid -ERESTARTSYS handling in host */ 416 if (PT_SYSCALL_NR_OFFSET != PT_SYSCALL_RET_OFFSET) 417 PT_SYSCALL_NR(regs->gp) = -1; 418 } 419 } 420 } 421 422 static unsigned long thread_regs[MAX_REG_NR]; 423 static unsigned long thread_fp_regs[FP_SIZE]; 424 425 static int __init init_thread_regs(void) 426 { 427 get_safe_registers(thread_regs, thread_fp_regs); 428 /* Set parent's instruction pointer to start of clone-stub */ 429 thread_regs[REGS_IP_INDEX] = STUB_CODE + 430 (unsigned long) stub_clone_handler - 431 (unsigned long) __syscall_stub_start; 432 thread_regs[REGS_SP_INDEX] = STUB_DATA + UM_KERN_PAGE_SIZE - 433 sizeof(void *); 434 #ifdef __SIGNAL_FRAMESIZE 435 thread_regs[REGS_SP_INDEX] -= __SIGNAL_FRAMESIZE; 436 #endif 437 return 0; 438 } 439 440 __initcall(init_thread_regs); 441 442 int copy_context_skas0(unsigned long new_stack, int pid) 443 { 444 int err; 445 unsigned long current_stack = current_stub_stack(); 446 struct stub_data *data = (struct stub_data *) current_stack; 447 struct stub_data *child_data = (struct stub_data *) new_stack; 448 unsigned long long new_offset; 449 int new_fd = phys_mapping(to_phys((void *)new_stack), &new_offset); 450 451 /* 452 * prepare offset and fd of child's stack as argument for parent's 453 * and child's mmap2 calls 454 */ 455 *data = ((struct stub_data) { 456 .offset = MMAP_OFFSET(new_offset), 457 .fd = new_fd 458 }); 459 460 err = ptrace_setregs(pid, thread_regs); 461 if (err < 0) { 462 err = -errno; 463 printk(UM_KERN_ERR "copy_context_skas0 : PTRACE_SETREGS " 464 "failed, pid = %d, errno = %d\n", pid, -err); 465 return err; 466 } 467 468 err = put_fp_registers(pid, thread_fp_regs); 469 if (err < 0) { 470 printk(UM_KERN_ERR "copy_context_skas0 : put_fp_registers " 471 "failed, pid = %d, err = %d\n", pid, err); 472 return err; 473 } 474 475 /* set a well known return code for detection of child write failure */ 476 child_data->err = 12345678; 477 478 /* 479 * Wait, until parent has finished its work: read child's pid from 480 * parent's stack, and check, if bad result. 481 */ 482 err = ptrace(PTRACE_CONT, pid, 0, 0); 483 if (err) { 484 err = -errno; 485 printk(UM_KERN_ERR "Failed to continue new process, pid = %d, " 486 "errno = %d\n", pid, errno); 487 return err; 488 } 489 490 wait_stub_done(pid); 491 492 pid = data->err; 493 if (pid < 0) { 494 printk(UM_KERN_ERR "copy_context_skas0 - stub-parent reports " 495 "error %d\n", -pid); 496 return pid; 497 } 498 499 /* 500 * Wait, until child has finished too: read child's result from 501 * child's stack and check it. 502 */ 503 wait_stub_done(pid); 504 if (child_data->err != STUB_DATA) { 505 printk(UM_KERN_ERR "copy_context_skas0 - stub-child reports " 506 "error %ld\n", child_data->err); 507 err = child_data->err; 508 goto out_kill; 509 } 510 511 if (ptrace(PTRACE_OLDSETOPTIONS, pid, NULL, 512 (void *)PTRACE_O_TRACESYSGOOD) < 0) { 513 err = -errno; 514 printk(UM_KERN_ERR "copy_context_skas0 : PTRACE_OLDSETOPTIONS " 515 "failed, errno = %d\n", errno); 516 goto out_kill; 517 } 518 519 return pid; 520 521 out_kill: 522 os_kill_ptraced_process(pid, 1); 523 return err; 524 } 525 526 void new_thread(void *stack, jmp_buf *buf, void (*handler)(void)) 527 { 528 (*buf)[0].JB_IP = (unsigned long) handler; 529 (*buf)[0].JB_SP = (unsigned long) stack + UM_THREAD_SIZE - 530 sizeof(void *); 531 } 532 533 #define INIT_JMP_NEW_THREAD 0 534 #define INIT_JMP_CALLBACK 1 535 #define INIT_JMP_HALT 2 536 #define INIT_JMP_REBOOT 3 537 538 void switch_threads(jmp_buf *me, jmp_buf *you) 539 { 540 if (UML_SETJMP(me) == 0) 541 UML_LONGJMP(you, 1); 542 } 543 544 static jmp_buf initial_jmpbuf; 545 546 /* XXX Make these percpu */ 547 static void (*cb_proc)(void *arg); 548 static void *cb_arg; 549 static jmp_buf *cb_back; 550 551 int start_idle_thread(void *stack, jmp_buf *switch_buf) 552 { 553 int n; 554 555 set_handler(SIGWINCH); 556 557 /* 558 * Can't use UML_SETJMP or UML_LONGJMP here because they save 559 * and restore signals, with the possible side-effect of 560 * trying to handle any signals which came when they were 561 * blocked, which can't be done on this stack. 562 * Signals must be blocked when jumping back here and restored 563 * after returning to the jumper. 564 */ 565 n = setjmp(initial_jmpbuf); 566 switch (n) { 567 case INIT_JMP_NEW_THREAD: 568 (*switch_buf)[0].JB_IP = (unsigned long) uml_finishsetup; 569 (*switch_buf)[0].JB_SP = (unsigned long) stack + 570 UM_THREAD_SIZE - sizeof(void *); 571 break; 572 case INIT_JMP_CALLBACK: 573 (*cb_proc)(cb_arg); 574 longjmp(*cb_back, 1); 575 break; 576 case INIT_JMP_HALT: 577 kmalloc_ok = 0; 578 return 0; 579 case INIT_JMP_REBOOT: 580 kmalloc_ok = 0; 581 return 1; 582 default: 583 printk(UM_KERN_ERR "Bad sigsetjmp return in " 584 "start_idle_thread - %d\n", n); 585 fatal_sigsegv(); 586 } 587 longjmp(*switch_buf, 1); 588 } 589 590 void initial_thread_cb_skas(void (*proc)(void *), void *arg) 591 { 592 jmp_buf here; 593 594 cb_proc = proc; 595 cb_arg = arg; 596 cb_back = &here; 597 598 block_signals(); 599 if (UML_SETJMP(&here) == 0) 600 UML_LONGJMP(&initial_jmpbuf, INIT_JMP_CALLBACK); 601 unblock_signals(); 602 603 cb_proc = NULL; 604 cb_arg = NULL; 605 cb_back = NULL; 606 } 607 608 void halt_skas(void) 609 { 610 block_signals(); 611 UML_LONGJMP(&initial_jmpbuf, INIT_JMP_HALT); 612 } 613 614 void reboot_skas(void) 615 { 616 block_signals(); 617 UML_LONGJMP(&initial_jmpbuf, INIT_JMP_REBOOT); 618 } 619 620 void __switch_mm(struct mm_id *mm_idp) 621 { 622 userspace_pid[0] = mm_idp->u.pid; 623 } 624