1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* 28 * Copyright 2015 Joyent, Inc. All rights reserved. 29 */ 30 31 #include <sys/types.h> 32 #include <sys/syscall.h> 33 #include <sys/utsname.h> 34 #include <sys/inttypes.h> 35 #include <sys/stat.h> 36 #include <sys/mman.h> 37 #include <sys/fstyp.h> 38 #include <sys/fsid.h> 39 #include <sys/systm.h> 40 #include <sys/auxv.h> 41 #include <sys/frame.h> 42 #include <zone.h> 43 #include <sys/brand.h> 44 #include <sys/epoll.h> 45 #include <sys/stack.h> 46 47 #include <assert.h> 48 #include <stdio.h> 49 #include <stdarg.h> 50 #include <stdlib.h> 51 #include <strings.h> 52 #include <unistd.h> 53 #include <errno.h> 54 #include <syslog.h> 55 #include <signal.h> 56 #include <fcntl.h> 57 #include <synch.h> 58 #include <libelf.h> 59 #include <libgen.h> 60 #include <pthread.h> 61 #include <utime.h> 62 #include <dirent.h> 63 #include <ucontext.h> 64 #include <libintl.h> 65 #include <locale.h> 66 67 #include <sys/lx_misc.h> 68 #include <sys/lx_debug.h> 69 #include <sys/lx_brand.h> 70 #include <sys/lx_types.h> 71 #include <sys/lx_stat.h> 72 #include <sys/lx_statfs.h> 73 #include <sys/lx_signal.h> 74 #include <sys/lx_syscall.h> 75 #include <sys/lx_thread.h> 76 #include <sys/lx_aio.h> 77 78 /* 79 * There is a block comment in "uts/common/brand/lx/os/lx_brand.c" that 80 * describes the functioning of the LX brand in some detail. 81 * 82 * *** Setting errno 83 * 84 * This emulation library is loaded onto a seperate link map from the 85 * application whose address space we're running in. The Linux libc errno is 86 * independent of our native libc errno. To pass back an error the emulation 87 * function should return -errno back to the Linux caller. 88 */ 89 90 char lx_release[LX_VERS_MAX]; 91 char lx_cmd_name[MAXNAMLEN]; 92 93 /* 94 * Map a linux locale ending string to the solaris equivalent. 95 */ 96 struct lx_locale_ending { 97 const char *linux_end; /* linux ending string */ 98 const char *solaris_end; /* to transform with this string */ 99 int le_size; /* linux ending string length */ 100 int se_size; /* solaris ending string length */ 101 }; 102 103 #define l2s_locale(lname, sname) \ 104 {(lname), (sname), sizeof ((lname)) - 1, sizeof ((sname)) - 1} 105 106 #define MAXLOCALENAMELEN 30 107 #if !defined(TEXT_DOMAIN) /* should be defined by cc -D */ 108 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it wasn't */ 109 #endif 110 111 /* 112 * Most syscalls return an int but some return something else, typically a 113 * ssize_t. This can be either an int or a long, depending on if we're compiled 114 * for 32-bit or 64-bit. To correctly propagate the -errno return code in the 115 * 64-bit case, we declare all emulation wrappers will return a long. Thus, 116 * when we save the return value into the %eax or %rax register and return to 117 * Linux, we will have the right size value in both the 32 and 64 bit cases. 118 */ 119 120 typedef long (*lx_syscall_handler_t)(); 121 122 static lx_syscall_handler_t lx_handlers[LX_NSYSCALLS + 1]; 123 124 static uintptr_t stack_bottom; 125 126 #if defined(_LP64) 127 long lx_fsb; 128 long lx_fs; 129 #endif 130 int lx_install = 0; /* install mode enabled if non-zero */ 131 int lx_verbose = 0; /* verbose mode enabled if non-zero */ 132 int lx_debug_enabled = 0; /* debugging output enabled if non-zero */ 133 134 pid_t zoneinit_pid; /* zone init PID */ 135 136 thread_key_t lx_tsd_key; 137 138 int 139 uucopy_unsafe(const void *src, void *dst, size_t n) 140 { 141 bcopy(src, dst, n); 142 return (0); 143 } 144 145 int 146 uucopystr_unsafe(const void *src, void *dst, size_t n) 147 { 148 (void) strncpy((char *)src, dst, n); 149 return (0); 150 } 151 152 static void 153 i_lx_msg(int fd, char *msg, va_list ap) 154 { 155 int i; 156 char buf[LX_MSG_MAXLEN]; 157 158 /* LINTED [possible expansion issues] */ 159 i = vsnprintf(buf, sizeof (buf), msg, ap); 160 buf[LX_MSG_MAXLEN - 1] = '\0'; 161 if (i == -1) 162 return; 163 164 /* if debugging is enabled, send this message to debug output */ 165 if (LX_DEBUG_ISENABLED) 166 lx_debug(buf); 167 168 if (fd == 2) { 169 /* 170 * We let the user choose whether or not to see these 171 * messages on the console. 172 */ 173 if (lx_verbose == 0) 174 return; 175 } 176 177 /* we retry in case of EINTR */ 178 do { 179 i = write(fd, buf, strlen(buf)); 180 } while ((i == -1) && (errno == EINTR)); 181 } 182 183 /*PRINTFLIKE1*/ 184 void 185 lx_err(char *msg, ...) 186 { 187 va_list ap; 188 189 assert(msg != NULL); 190 191 va_start(ap, msg); 192 i_lx_msg(STDERR_FILENO, msg, ap); 193 va_end(ap); 194 } 195 196 /* 197 * This is just a non-zero exit value which also isn't one that would allow 198 * us to easily detect if a branded process exited because of a recursive 199 * fatal error. 200 */ 201 #define LX_ERR_FATAL 42 202 203 /* 204 * Our own custom version of abort(), this routine will be used in place 205 * of the one located in libc. The primary difference is that this version 206 * will first reset the signal handler for SIGABRT to SIG_DFL, ensuring the 207 * SIGABRT sent causes us to dump core and is not caught by a user program. 208 */ 209 void 210 abort(void) 211 { 212 static int aborting = 0; 213 214 struct sigaction sa; 215 sigset_t sigmask; 216 217 /* watch out for recursive calls to this function */ 218 if (aborting != 0) 219 exit(LX_ERR_FATAL); 220 221 aborting = 1; 222 223 /* 224 * Block all signals here to avoid taking any signals while exiting 225 * in an effort to avoid any strange user interaction with our death. 226 */ 227 (void) sigfillset(&sigmask); 228 (void) sigprocmask(SIG_BLOCK, &sigmask, NULL); 229 230 /* 231 * Our own version of abort(3C) that we know will never call 232 * a user-installed SIGABRT handler first. We WANT to die. 233 * 234 * Do this by resetting the handler to SIG_DFL, and releasing any 235 * held SIGABRTs. 236 * 237 * If no SIGABRTs are pending, send ourselves one. 238 * 239 * The while loop is a bit of overkill, but abort(3C) does it to 240 * assure it never returns so we will as well. 241 */ 242 (void) sigemptyset(&sa.sa_mask); 243 sa.sa_sigaction = SIG_DFL; 244 sa.sa_flags = 0; 245 246 for (;;) { 247 (void) sigaction(SIGABRT, &sa, NULL); 248 (void) sigrelse(SIGABRT); 249 (void) thr_kill(thr_self(), SIGABRT); 250 } 251 252 /*NOTREACHED*/ 253 } 254 255 /*PRINTFLIKE1*/ 256 void 257 lx_msg(char *msg, ...) 258 { 259 va_list ap; 260 261 assert(msg != NULL); 262 va_start(ap, msg); 263 i_lx_msg(STDOUT_FILENO, msg, ap); 264 va_end(ap); 265 } 266 267 /*PRINTFLIKE1*/ 268 void 269 lx_err_fatal(char *msg, ...) 270 { 271 va_list ap; 272 273 assert(msg != NULL); 274 275 va_start(ap, msg); 276 i_lx_msg(STDERR_FILENO, msg, ap); 277 va_end(ap); 278 abort(); 279 } 280 281 /* 282 * See if it is safe to alloca() sz bytes. Return 1 for yes, 0 for no. 283 */ 284 int 285 lx_check_alloca(size_t sz) 286 { 287 uintptr_t sp = (uintptr_t)&sz; 288 uintptr_t end = sp - sz; 289 290 return ((end < sp) && (end >= stack_bottom)); 291 } 292 293 /*PRINTFLIKE1*/ 294 void 295 lx_unsupported(char *msg, ...) 296 { 297 va_list ap; 298 char dmsg[256]; 299 int lastc; 300 301 assert(msg != NULL); 302 303 /* make a brand call so we can easily dtrace unsupported actions */ 304 va_start(ap, msg); 305 /* LINTED [possible expansion issues] */ 306 (void) vsnprintf(dmsg, sizeof (dmsg), msg, ap); 307 dmsg[255] = '\0'; 308 lastc = strlen(dmsg) - 1; 309 if (dmsg[lastc] == '\n') 310 dmsg[lastc] = '\0'; 311 (void) syscall(SYS_brand, B_UNSUPPORTED, dmsg); 312 va_end(ap); 313 314 /* send the msg to the error stream */ 315 va_start(ap, msg); 316 i_lx_msg(STDERR_FILENO, msg, ap); 317 va_end(ap); 318 } 319 320 int lx_init(int argc, char *argv[], char *envp[]); 321 322 lx_tsd_t * 323 lx_get_tsd(void) 324 { 325 int ret; 326 lx_tsd_t *lx_tsd; 327 328 if ((ret = thr_getspecific(lx_tsd_key, (void **)&lx_tsd)) != 0) { 329 lx_err_fatal("lx_get_tsd: unable to read " 330 "thread-specific data: %s", strerror(ret)); 331 } 332 333 assert(lx_tsd != 0); 334 335 return (lx_tsd); 336 } 337 338 /* 339 * This function is called from the kernel like a signal handler. Each 340 * function call is a request to provide emulation for a system call that, on 341 * illumos, is implemented in userland. The system call number selection and 342 * argument parsing have already been done by the kernel. 343 */ 344 void 345 lx_emulate(ucontext_t *ucp, int syscall_num, uintptr_t *args) 346 { 347 long emu_ret; 348 int emu_errno = 0; 349 350 LX_EMULATE_ENTER(ucp, syscall_num, args); 351 lx_debug("lx_emulate(%p, %d, [%p, %p, %p, %p, %p, %p])\n", 352 ucp, syscall_num, args[0], args[1], args[2], args[3], args[4], 353 args[5]); 354 355 /* 356 * The kernel should have saved us a context that will not restore the 357 * previous signal mask. Some emulated system calls alter the signal 358 * mask; restoring it after the emulation would cancel that out. 359 */ 360 assert(!(ucp->uc_flags & UC_SIGMASK)); 361 362 /* 363 * The kernel ensures that the syscall_num is sane; Use it as is. 364 */ 365 assert(syscall_num >= 0); 366 assert(syscall_num < (sizeof (lx_handlers) / sizeof (lx_handlers[0]))); 367 if (lx_handlers[syscall_num] == NULL) { 368 lx_err_fatal("lx_emulate: kernel sent us a call we cannot " 369 "emulate (%d)", syscall_num); 370 } 371 372 /* 373 * Call our handler function: 374 */ 375 emu_ret = lx_handlers[syscall_num](args[0], args[1], args[2], args[3], 376 args[4], args[5]); 377 378 /* 379 * If the return value is between -1 and -4095 then it's an errno. 380 * The kernel will translate it to the Linux equivalent for us. 381 */ 382 if (emu_ret < 0 && emu_ret > -4096) { 383 emu_errno = (int)-emu_ret; 384 } 385 386 /* 387 * Return to the context we were passed 388 */ 389 LX_EMULATE_RETURN(ucp, syscall_num, emu_ret, emu_errno); 390 lx_debug("\tlx_emulate(%d) done (ret %ld / 0x%p ; errno %d)", 391 syscall_num, emu_ret, emu_ret, emu_errno); 392 (void) syscall(SYS_brand, B_EMULATION_DONE, ucp, syscall_num, emu_ret, 393 emu_errno); 394 395 assert(!"cannot be returned here"); 396 } 397 398 static void 399 lx_close_fh(FILE *file) 400 { 401 int fd, fd_new; 402 403 if (file == NULL) 404 return; 405 406 if ((fd = fileno(file)) < 0) 407 return; 408 409 fd_new = dup(fd); 410 if (fd_new == -1) 411 return; 412 413 (void) fclose(file); 414 (void) dup2(fd_new, fd); 415 (void) close(fd_new); 416 } 417 418 419 extern int set_l10n_alternate_root(char *path); 420 421 #if defined(_LP64) 422 static void * 423 map_vdso() 424 { 425 int fd; 426 mmapobj_result_t mpp[10]; /* we know the size of our lib */ 427 mmapobj_result_t *smpp = mpp; 428 uint_t mapnum = 10; 429 430 if ((fd = open("/native/usr/lib/brand/lx/amd64/lx_vdso.so.1", 431 O_RDONLY)) == -1) 432 lx_err_fatal("couldn't open lx_vdso.so.1"); 433 434 if (mmapobj(fd, MMOBJ_INTERPRET, smpp, &mapnum, NULL) == -1) 435 lx_err_fatal("couldn't mmapobj lx_vdso.so.1"); 436 437 (void) close(fd); 438 439 /* assume first segment is the base of the mapping */ 440 return (smpp->mr_addr); 441 } 442 #endif 443 444 /* 445 * Initialize the thread specific data for this thread. 446 */ 447 void 448 lx_init_tsd(lx_tsd_t *lxtsd) 449 { 450 int err; 451 452 bzero(lxtsd, sizeof (*lxtsd)); 453 lxtsd->lxtsd_exit = LX_ET_NONE; 454 455 /* 456 * The Linux alternate signal stack is initially disabled: 457 */ 458 lxtsd->lxtsd_sigaltstack.ss_flags = LX_SS_DISABLE; 459 460 /* 461 * Create a per-thread exit context from the current register and 462 * native/brand stack state. Replace the saved program counter value 463 * with the address of lx_exit_common(); we wish to revector there when 464 * the thread or process is exiting. 465 */ 466 if (getcontext(&lxtsd->lxtsd_exit_context) != 0) { 467 lx_err_fatal("Unable to initialize thread-specific exit " 468 "context: %s", strerror(errno)); 469 } 470 LX_REG(&lxtsd->lxtsd_exit_context, REG_PC) = (uintptr_t)lx_exit_common; 471 472 /* 473 * Align the stack pointer and clear the frame pointer. 474 */ 475 LX_REG(&lxtsd->lxtsd_exit_context, REG_FP) = 0; 476 LX_REG(&lxtsd->lxtsd_exit_context, REG_SP) &= ~(STACK_ALIGN - 1UL); 477 #if defined(_LP64) 478 #if (STACK_ENTRY_ALIGN != 8) && (STACK_ALIGN != 16) 479 #error "lx_init_tsd: unexpected STACK_[ENTRY_]ALIGN values" 480 #endif 481 /* 482 * The AMD64 ABI requires that, on entry to a function, the stack 483 * pointer must be 8-byte aligned, but _not_ 16-byte aligned. When 484 * the frame pointer is pushed, the alignment will then be correct. 485 */ 486 LX_REG(&lxtsd->lxtsd_exit_context, REG_SP) -= STACK_ENTRY_ALIGN; 487 #endif 488 489 /* 490 * Block all signals in the exit context to avoid taking any signals 491 * (to the degree possible) while exiting. 492 */ 493 (void) sigfillset(&lxtsd->lxtsd_exit_context.uc_sigmask); 494 495 if ((err = thr_setspecific(lx_tsd_key, lxtsd)) != 0) { 496 lx_err_fatal("Unable to initialize thread-specific data: %s", 497 strerror(err)); 498 } 499 } 500 501 static void 502 lx_start(uintptr_t sp, uintptr_t entry) 503 { 504 ucontext_t jump_uc; 505 506 if (getcontext(&jump_uc) != 0) { 507 lx_err_fatal("Unable to getcontext for program start: %s", 508 strerror(errno)); 509 } 510 511 /* 512 * We want to load the general registers from this 513 * context, and switch to the BRAND stack. 514 */ 515 jump_uc.uc_flags = UC_CPU; 516 jump_uc.uc_brand_data[0] = (void *)LX_UC_STACK_BRAND; 517 518 LX_REG(&jump_uc, REG_FP) = NULL; 519 LX_REG(&jump_uc, REG_SP) = sp; 520 LX_REG(&jump_uc, REG_PC) = entry; 521 522 #if defined(_LP64) 523 /* 524 * The AMD64 ABI states that at process entry, %rdx contains "a 525 * function pointer that the application should register with 526 * atexit()". We make sure to pass NULL explicitly so that 527 * no function is registered. 528 */ 529 LX_REG(&jump_uc, REG_RDX) = NULL; 530 #endif 531 532 lx_debug("starting Linux program sp %p ldentry %p", sp, entry); 533 534 /* 535 * This system call should not return. 536 */ 537 if (syscall(SYS_brand, B_JUMP_TO_LINUX, &jump_uc) == -1) { 538 lx_err_fatal("B_JUMP_TO_LINUX failed: %s", 539 strerror(errno)); 540 } 541 abort(); 542 } 543 544 /*ARGSUSED*/ 545 int 546 lx_init(int argc, char *argv[], char *envp[]) 547 { 548 char *r; 549 auxv_t *ap; 550 long *p; 551 int err; 552 lx_elf_data_t edp; 553 lx_brand_registration_t reg; 554 lx_tsd_t *lxtsd; 555 #if defined(_LP64) 556 void *vdso_hdr; 557 #endif 558 559 bzero(®, sizeof (reg)); 560 561 stack_bottom = 2 * sysconf(_SC_PAGESIZE); 562 563 /* 564 * We need to shutdown all libc stdio. libc stdio normally goes to 565 * file descriptors, but since we're actually part of a linux 566 * process we don't own these file descriptors and we can't make 567 * any assumptions about their state. 568 */ 569 lx_close_fh(stdin); 570 lx_close_fh(stdout); 571 lx_close_fh(stderr); 572 573 lx_debug_init(); 574 575 r = getenv("LX_RELEASE"); 576 if (r == NULL) { 577 if (zone_getattr(getzoneid(), LX_KERN_VERSION_NUM, lx_release, 578 sizeof (lx_release)) != sizeof (lx_release)) 579 (void) strlcpy(lx_release, "2.4.21", LX_VERS_MAX); 580 } else { 581 (void) strlcpy(lx_release, r, 128); 582 } 583 584 lx_debug("lx_release: %s\n", lx_release); 585 586 /* 587 * Should we kill an application that attempts an unimplemented 588 * system call? 589 */ 590 if (getenv("LX_STRICT") != NULL) { 591 reg.lxbr_flags |= LX_PROC_STRICT_MODE; 592 lx_debug("STRICT mode enabled.\n"); 593 } 594 595 /* 596 * Are we in install mode? 597 */ 598 if (getenv("LX_INSTALL") != NULL) { 599 reg.lxbr_flags |= LX_PROC_INSTALL_MODE; 600 lx_install = 1; 601 lx_debug("INSTALL mode enabled.\n"); 602 } 603 604 /* 605 * Should we attempt to send messages to the screen? 606 */ 607 if (getenv("LX_VERBOSE") != NULL) { 608 lx_verbose = 1; 609 lx_debug("VERBOSE mode enabled.\n"); 610 } 611 612 (void) strlcpy(lx_cmd_name, basename(argv[0]), sizeof (lx_cmd_name)); 613 lx_debug("executing linux process: %s", argv[0]); 614 lx_debug("branding myself and setting handler to 0x%p", 615 (void *)lx_emulate); 616 617 reg.lxbr_version = LX_VERSION; 618 reg.lxbr_handler = (void *)&lx_emulate; 619 620 /* 621 * Register the address of the user-space handler with the lx brand 622 * module. As a side-effect this leaves the thread in native syscall 623 * mode so that it's ok to continue to make syscalls during setup. We 624 * need to switch to Linux mode at the end of initialization. 625 */ 626 if (syscall(SYS_brand, B_REGISTER, ®)) 627 lx_err_fatal("failed to brand the process"); 628 629 /* Look up the PID that serves as init for this zone */ 630 if ((err = lx_lpid_to_spid(1, &zoneinit_pid)) < 0) 631 lx_err_fatal("Unable to find PID for zone init process: %s", 632 strerror(err)); 633 634 /* 635 * Upload data about the lx executable from the kernel. 636 */ 637 if (syscall(SYS_brand, B_ELFDATA, (void *)&edp)) 638 lx_err_fatal("failed to get required ELF data from the kernel"); 639 640 if (lx_stat_init() != 0) 641 lx_err_fatal("failed to setup the stat translator"); 642 643 if (lx_statfs_init() != 0) 644 lx_err_fatal("failed to setup the statfs translator"); 645 646 lx_ptrace_init(); 647 648 #if defined(_LP64) 649 vdso_hdr = map_vdso(); 650 #endif 651 652 /* 653 * Find the aux vector on the stack. 654 */ 655 p = (long *)envp; 656 while (*p != NULL) 657 p++; 658 /* 659 * p is now pointing at the 0 word after the environ pointers. After 660 * that is the aux vectors. 661 */ 662 p++; 663 for (ap = (auxv_t *)p; ap->a_type != 0; ap++) { 664 switch (ap->a_type) { 665 case AT_BASE: 666 ap->a_un.a_val = edp.ed_base; 667 break; 668 case AT_ENTRY: 669 ap->a_un.a_val = edp.ed_entry; 670 break; 671 case AT_PHDR: 672 ap->a_un.a_val = edp.ed_phdr; 673 break; 674 case AT_PHENT: 675 ap->a_un.a_val = edp.ed_phent; 676 break; 677 case AT_PHNUM: 678 ap->a_un.a_val = edp.ed_phnum; 679 break; 680 #if defined(_LP64) 681 case AT_SUN_BRAND_LX_SYSINFO_EHDR: 682 ap->a_type = AT_SYSINFO_EHDR; 683 ap->a_un.a_val = (long)vdso_hdr; 684 break; 685 #endif 686 default: 687 break; 688 } 689 } 690 691 /* Setup signal handler information. */ 692 if (lx_siginit()) { 693 lx_err_fatal("failed to initialize lx signals for the " 694 "branded process"); 695 } 696 697 /* Setup thread-specific data area for managing linux threads. */ 698 if ((err = thr_keycreate(&lx_tsd_key, NULL)) != 0) { 699 lx_err_fatal("thr_keycreate(lx_tsd_key) failed: %s", 700 strerror(err)); 701 } 702 703 lx_debug("thr_keycreate created lx_tsd_key (%d)", lx_tsd_key); 704 705 /* 706 * Initialize the thread specific data for this thread. 707 */ 708 if ((lxtsd = malloc(sizeof (*lxtsd))) == NULL) { 709 lx_err_fatal("failed to allocate tsd for main thread: %s", 710 strerror(errno)); 711 } 712 lx_debug("lx tsd allocated @ %p", lxtsd); 713 lx_init_tsd(lxtsd); 714 715 /* 716 * Allocate the brand emulation stack for the main process thread. 717 * Register the thread-specific data structure with the stack list so 718 * that it may be freed at thread exit or fork(2). 719 */ 720 lx_install_stack(NULL, 0, lxtsd); 721 722 /* 723 * The brand linker expects the stack pointer to point to 724 * "argc", which is just before &argv[0]. 725 */ 726 lx_start((uintptr_t)argv - sizeof (void *), edp.ed_ldentry); 727 728 /*NOTREACHED*/ 729 abort(); 730 return (0); 731 } 732 733 /* 734 * We "return" to this function via a context hand-crafted by 735 * "lx_init_tsd()"; see that function for more detail. 736 * 737 * NOTE: Our call frame is on the main thread stack, not the alternate native 738 * stack -- it is safe to release the latter here. The frame does not have a 739 * valid return address, so this function MUST NOT return. 740 */ 741 void 742 lx_exit_common(void) 743 { 744 lx_tsd_t *lxtsd = lx_get_tsd(); 745 int ev = (0xff & lxtsd->lxtsd_exit_status); 746 747 switch (lxtsd->lxtsd_exit) { 748 case LX_ET_EXIT: 749 lx_debug("lx_exit_common(LX_ET_EXIT, %d)\n", ev); 750 751 /* 752 * If the thread is exiting, but not the entire process, we 753 * must free the stack we allocated for usermode emulation. 754 * This is safe to do here because the setcontext() put us 755 * back on the BRAND stack for this process. This function 756 * also frees the thread-specific data object for this thread. 757 */ 758 lx_free_stack(); 759 760 /* 761 * The native thread return value is never seen so we pass 762 * NULL. 763 */ 764 thr_exit(NULL); 765 break; 766 767 case LX_ET_EXIT_GROUP: 768 lx_debug("lx_exit_common(LX_ET_EXIT_GROUP, %d)\n", ev); 769 exit(ev); 770 break; 771 772 default: 773 abort(); 774 } 775 776 abort(); 777 } 778 779 const ucontext_t * 780 lx_find_brand_uc(void) 781 { 782 ucontext_t *ucp = NULL; 783 784 /* 785 * Ask for the current emulation (or signal handling) ucontext_t... 786 */ 787 assert(syscall(SYS_brand, B_GET_CURRENT_CONTEXT, &ucp) == 0); 788 789 for (;;) { 790 uintptr_t flags; 791 792 lx_debug("lx_find_brand_uc: inspect ucp %p...\n", ucp); 793 assert(ucp != NULL); 794 795 flags = (uintptr_t)ucp->uc_brand_data[0]; 796 797 if (flags & LX_UC_STACK_BRAND) { 798 lx_debug("lx_find_brand_uc: ucp %p\n", ucp); 799 800 return (ucp); 801 } 802 803 lx_debug("lx_find_brand_uc: skip non-BRAND ucp %p\n", ucp); 804 805 /* 806 * Walk up the context chain to find the most recently stored 807 * brand register state. 808 */ 809 ucp = ucp->uc_link; 810 } 811 } 812 813 uintptr_t 814 lx_find_brand_sp(void) 815 { 816 const ucontext_t *ucp = lx_find_brand_uc(); 817 uintptr_t sp = LX_REG(ucp, REG_SP); 818 819 lx_debug("lx_find_brand_sp: ucp %p sp %p\n", ucp, sp); 820 821 return (sp); 822 } 823 824 ucontext_t * 825 lx_syscall_regs(void) 826 { 827 ucontext_t *ucp = NULL; 828 uintptr_t flags; 829 830 /* 831 * Ask for the current emulation (or signal handling) ucontext_t... 832 */ 833 assert(syscall(SYS_brand, B_GET_CURRENT_CONTEXT, &ucp) == 0); 834 assert(ucp != NULL); 835 836 /* 837 * Use of the lx_syscall_regs() function implies that the topmost (i.e. 838 * current) context is for a system call emulation request from the 839 * kernel, rather than a signal handling frame. 840 */ 841 flags = (uintptr_t)ucp->uc_brand_data[0]; 842 assert(flags & LX_UC_FRAME_IS_SYSCALL); 843 844 lx_debug("lx_syscall_regs: ucp %p\n", ucp); 845 846 return (ucp); 847 } 848 849 int 850 lx_lpid_to_spair(pid_t lpid, pid_t *spid, lwpid_t *slwp) 851 { 852 pid_t pid; 853 lwpid_t tid; 854 855 if (lpid == 0) { 856 pid = getpid(); 857 tid = thr_self(); 858 } else { 859 if (syscall(SYS_brand, B_LPID_TO_SPAIR, lpid, &pid, &tid) < 0) 860 return (-errno); 861 862 /* 863 * If the returned pid is -1, that indicates we tried to 864 * look up the PID for init, but that process no longer 865 * exists. 866 */ 867 if (pid == -1) 868 return (-ESRCH); 869 } 870 871 if (uucopy(&pid, spid, sizeof (pid_t)) != 0) 872 return (-errno); 873 874 if (uucopy(&tid, slwp, sizeof (lwpid_t)) != 0) 875 return (-errno); 876 877 return (0); 878 } 879 880 int 881 lx_lpid_to_spid(pid_t lpid, pid_t *spid) 882 { 883 lwpid_t slwp; 884 885 return (lx_lpid_to_spair(lpid, spid, &slwp)); 886 } 887 888 char * 889 lx_fd_to_path(int fd, char *buf, int buf_size) 890 { 891 char path_proc[MAXPATHLEN]; 892 pid_t pid; 893 int n; 894 895 assert((buf != NULL) && (buf_size >= 0)); 896 897 if (fd < 0) 898 return (NULL); 899 900 if ((pid = getpid()) == -1) 901 return (NULL); 902 903 (void) snprintf(path_proc, MAXPATHLEN, 904 "/native/proc/%d/path/%d", pid, fd); 905 906 if ((n = readlink(path_proc, buf, buf_size - 1)) == -1) 907 return (NULL); 908 buf[n] = '\0'; 909 910 return (buf); 911 } 912 913 #if defined(_LP64) 914 /* The following is the 64-bit syscall table */ 915 916 static lx_syscall_handler_t lx_handlers[] = { 917 NULL, /* 0: read */ 918 NULL, /* 1: write */ 919 NULL, /* 2: open */ 920 lx_close, /* 3: close */ 921 lx_stat64, /* 4: stat */ 922 lx_fstat64, /* 5: fstat */ 923 lx_lstat64, /* 6: lstat */ 924 lx_poll, /* 7: poll */ 925 lx_lseek, /* 8: lseek */ 926 lx_mmap, /* 9: mmap */ 927 lx_mprotect, /* 10: mprotect */ 928 lx_munmap, /* 11: munmap */ 929 NULL, /* 12: brk */ 930 lx_rt_sigaction, /* 13: rt_sigaction */ 931 lx_rt_sigprocmask, /* 14: rt_sigprocmask */ 932 lx_rt_sigreturn, /* 15: rt_sigreturn */ 933 NULL, /* 16: ioctl */ 934 lx_pread, /* 17: pread64 */ 935 lx_pwrite, /* 18: pwrite64 */ 936 lx_readv, /* 19: readv */ 937 lx_writev, /* 20: writev */ 938 lx_access, /* 21: access */ 939 NULL, /* 22: pipe */ 940 lx_select, /* 23: select */ 941 NULL, /* 24: sched_yield */ 942 lx_remap, /* 25: mremap */ 943 lx_msync, /* 26: msync */ 944 lx_mincore, /* 27: mincore */ 945 lx_madvise, /* 28: madvise */ 946 lx_shmget, /* 29: shmget */ 947 lx_shmat, /* 30: shmat */ 948 lx_shmctl, /* 31: shmctl */ 949 lx_dup, /* 32: dup */ 950 lx_dup2, /* 33: dup2 */ 951 lx_pause, /* 34: pause */ 952 lx_nanosleep, /* 35: nanosleep */ 953 lx_getitimer, /* 36: getitimer */ 954 lx_alarm, /* 37: alarm */ 955 lx_setitimer, /* 38: setitimer */ 956 NULL, /* 39: getpid */ 957 lx_sendfile64, /* 40: sendfile */ 958 lx_socket, /* 41: socket */ 959 NULL, /* 42: connect */ 960 lx_accept, /* 43: accept */ 961 NULL, /* 44: sendto */ 962 NULL, /* 45: recvfrom */ 963 NULL, /* 46: sendmsg */ 964 NULL, /* 47: recvmsg */ 965 lx_shutdown, /* 48: shutdown */ 966 NULL, /* 49: bind */ 967 lx_listen, /* 50: listen */ 968 lx_getsockname, /* 51: getsockname */ 969 lx_getpeername, /* 52: getpeername */ 970 lx_socketpair, /* 53: socketpair */ 971 lx_setsockopt, /* 54: setsockopt */ 972 lx_getsockopt, /* 55: getsockopt */ 973 lx_clone, /* 56: clone */ 974 lx_fork, /* 57: fork */ 975 lx_vfork, /* 58: vfork */ 976 lx_execve, /* 59: execve */ 977 lx_exit, /* 60: exit */ 978 NULL, /* 61: wait4 */ 979 NULL, /* 62: kill */ 980 lx_uname, /* 63: uname */ 981 lx_semget, /* 64: semget */ 982 lx_semop, /* 65: semop */ 983 lx_semctl, /* 66: semctl */ 984 lx_shmdt, /* 67: shmdt */ 985 lx_msgget, /* 68: msgget */ 986 lx_msgsnd, /* 69: msgsnd */ 987 lx_msgrcv, /* 70: msgrcv */ 988 lx_msgctl, /* 71: msgctl */ 989 NULL, /* 72: fcntl */ 990 lx_flock, /* 73: flock */ 991 lx_fsync, /* 74: fsync */ 992 lx_fdatasync, /* 75: fdatasync */ 993 lx_truncate, /* 76: truncate */ 994 lx_ftruncate, /* 77: ftruncate */ 995 NULL, /* 78: getdents */ 996 lx_getcwd, /* 79: getcwd */ 997 lx_chdir, /* 80: chdir */ 998 lx_fchdir, /* 81: fchdir */ 999 lx_rename, /* 82: rename */ 1000 NULL, /* 83: mkdir */ 1001 lx_rmdir, /* 84: rmdir */ 1002 lx_creat, /* 85: creat */ 1003 lx_link, /* 86: link */ 1004 lx_unlink, /* 87: unlink */ 1005 lx_symlink, /* 88: symlink */ 1006 lx_readlink, /* 89: readlink */ 1007 NULL, /* 90: chmod */ 1008 NULL, /* 91: fchmod */ 1009 NULL, /* 92: chown */ 1010 NULL, /* 93: fchown */ 1011 NULL, /* 94: lchown */ 1012 lx_umask, /* 95: umask */ 1013 NULL, /* 96: gettimeofday */ 1014 NULL, /* 97: getrlimit */ 1015 lx_getrusage, /* 98: getrusage */ 1016 NULL, /* 99: sysinfo */ 1017 lx_times, /* 100: times */ 1018 lx_ptrace, /* 101: ptrace */ 1019 lx_getuid, /* 102: getuid */ 1020 lx_syslog, /* 103: syslog */ 1021 lx_getgid, /* 104: getgid */ 1022 lx_setuid, /* 105: setuid */ 1023 lx_setgid, /* 106: setgid */ 1024 lx_geteuid, /* 107: geteuid */ 1025 lx_getegid, /* 108: getegid */ 1026 lx_setpgid, /* 109: setpgid */ 1027 NULL, /* 110: getppid */ 1028 lx_getpgrp, /* 111: getpgrp */ 1029 lx_setsid, /* 112: setsid */ 1030 lx_setreuid, /* 113: setreuid */ 1031 lx_setregid, /* 114: setregid */ 1032 lx_getgroups, /* 115: getgroups */ 1033 lx_setgroups, /* 116: setgroups */ 1034 NULL, /* 117: setresuid */ 1035 lx_getresuid, /* 118: getresuid */ 1036 NULL, /* 119: setresgid */ 1037 lx_getresgid, /* 120: getresgid */ 1038 lx_getpgid, /* 121: getpgid */ 1039 lx_setfsuid, /* 122: setfsuid */ 1040 lx_setfsgid, /* 123: setfsgid */ 1041 lx_getsid, /* 124: getsid */ 1042 lx_capget, /* 125: capget */ 1043 lx_capset, /* 126: capset */ 1044 lx_rt_sigpending, /* 127: rt_sigpending */ 1045 lx_rt_sigtimedwait, /* 128: rt_sigtimedwait */ 1046 lx_rt_sigqueueinfo, /* 129: rt_sigqueueinfo */ 1047 lx_rt_sigsuspend, /* 130: rt_sigsuspend */ 1048 lx_sigaltstack, /* 131: sigaltstack */ 1049 lx_utime, /* 132: utime */ 1050 lx_mknod, /* 133: mknod */ 1051 NULL, /* 134: uselib */ 1052 lx_personality, /* 135: personality */ 1053 NULL, /* 136: ustat */ 1054 lx_statfs, /* 137: statfs */ 1055 lx_fstatfs, /* 138: fstatfs */ 1056 lx_sysfs, /* 139: sysfs */ 1057 lx_getpriority, /* 140: getpriority */ 1058 lx_setpriority, /* 141: setpriority */ 1059 lx_sched_setparam, /* 142: sched_setparam */ 1060 lx_sched_getparam, /* 143: sched_getparam */ 1061 lx_sched_setscheduler, /* 144: sched_setscheduler */ 1062 lx_sched_getscheduler, /* 145: sched_getscheduler */ 1063 lx_sched_get_priority_max, /* 146: sched_get_priority_max */ 1064 lx_sched_get_priority_min, /* 147: sched_get_priority_min */ 1065 lx_sched_rr_get_interval, /* 148: sched_rr_get_interval */ 1066 lx_mlock, /* 149: mlock */ 1067 lx_munlock, /* 150: munlock */ 1068 lx_mlockall, /* 151: mlockall */ 1069 lx_munlockall, /* 152: munlockall */ 1070 lx_vhangup, /* 153: vhangup */ 1071 NULL, /* 154: modify_ldt */ 1072 NULL, /* 155: pivot_root */ 1073 lx_sysctl, /* 156: sysctl */ 1074 NULL, /* 157: prctl */ 1075 NULL, /* 158: arch_prctl */ 1076 lx_adjtimex, /* 159: adjtimex */ 1077 NULL, /* 160: setrlimit */ 1078 lx_chroot, /* 161: chroot */ 1079 lx_sync, /* 162: sync */ 1080 NULL, /* 163: acct */ 1081 lx_settimeofday, /* 164: settimeofday */ 1082 lx_mount, /* 165: mount */ 1083 lx_umount2, /* 166: umount2 */ 1084 NULL, /* 167: swapon */ 1085 NULL, /* 168: swapoff */ 1086 lx_reboot, /* 169: reboot */ 1087 lx_sethostname, /* 170: sethostname */ 1088 lx_setdomainname, /* 171: setdomainname */ 1089 NULL, /* 172: iopl */ 1090 NULL, /* 173: ioperm */ 1091 NULL, /* 174: create_module */ 1092 NULL, /* 175: init_module */ 1093 NULL, /* 176: delete_module */ 1094 NULL, /* 177: get_kernel_syms */ 1095 lx_query_module, /* 178: query_module */ 1096 NULL, /* 179: quotactl */ 1097 NULL, /* 180: nfsservctl */ 1098 NULL, /* 181: getpmsg */ 1099 NULL, /* 182: putpmsg */ 1100 NULL, /* 183: afs_syscall */ 1101 NULL, /* 184: tux */ 1102 NULL, /* 185: security */ 1103 NULL, /* 186: gettid */ 1104 NULL, /* 187: readahead */ 1105 NULL, /* 188: setxattr */ 1106 NULL, /* 189: lsetxattr */ 1107 NULL, /* 190: fsetxattr */ 1108 NULL, /* 191: getxattr */ 1109 NULL, /* 192: lgetxattr */ 1110 NULL, /* 193: fgetxattr */ 1111 NULL, /* 194: listxattr */ 1112 NULL, /* 195: llistxattr */ 1113 NULL, /* 196: flistxattr */ 1114 NULL, /* 197: removexattr */ 1115 NULL, /* 198: lremovexattr */ 1116 NULL, /* 199: fremovexattr */ 1117 NULL, /* 200: tkill */ 1118 NULL, /* 201: time */ 1119 NULL, /* 202: futex */ 1120 lx_sched_setaffinity, /* 203: sched_setaffinity */ 1121 lx_sched_getaffinity, /* 204: sched_getaffinity */ 1122 NULL, /* 205: set_thread_area */ 1123 lx_io_setup, /* 206: io_setup */ 1124 lx_io_destroy, /* 207: io_destroy */ 1125 lx_io_getevents, /* 208: io_getevents */ 1126 lx_io_submit, /* 209: io_submit */ 1127 lx_io_cancel, /* 210: io_cancel */ 1128 NULL, /* 211: get_thread_area */ 1129 NULL, /* 212: lookup_dcookie */ 1130 lx_epoll_create, /* 213: epoll_create */ 1131 NULL, /* 214: epoll_ctl_old */ 1132 NULL, /* 215: epoll_wait_old */ 1133 NULL, /* 216: remap_file_pages */ 1134 NULL, /* 217: getdents64 */ 1135 NULL, /* 218: set_tid_address */ 1136 NULL, /* 219: restart_syscall */ 1137 lx_semtimedop, /* 220: semtimedop */ 1138 lx_fadvise64_64, /* 221: fadvise64 */ 1139 lx_timer_create, /* 222: timer_create */ 1140 lx_timer_settime, /* 223: timer_settime */ 1141 lx_timer_gettime, /* 224: timer_gettime */ 1142 lx_timer_getoverrun, /* 225: timer_getoverrun */ 1143 lx_timer_delete, /* 226: timer_delete */ 1144 NULL, /* 227: clock_settime */ 1145 NULL, /* 228: clock_gettime */ 1146 NULL, /* 229: clock_getres */ 1147 lx_clock_nanosleep, /* 230: clock_nanosleep */ 1148 lx_group_exit, /* 231: exit_group */ 1149 lx_epoll_wait, /* 232: epoll_wait */ 1150 lx_epoll_ctl, /* 233: epoll_ctl */ 1151 NULL, /* 234: tgkill */ 1152 lx_utimes, /* 235: utimes */ 1153 NULL, /* 236: vserver */ 1154 NULL, /* 237: mbind */ 1155 NULL, /* 238: set_mempolicy */ 1156 NULL, /* 239: get_mempolicy */ 1157 NULL, /* 240: mq_open */ 1158 NULL, /* 241: mq_unlink */ 1159 NULL, /* 242: mq_timedsend */ 1160 NULL, /* 243: mq_timedreceive */ 1161 NULL, /* 244: mq_notify */ 1162 NULL, /* 245: mq_getsetattr */ 1163 NULL, /* 246: kexec_load */ 1164 NULL, /* 247: waitid */ 1165 NULL, /* 248: add_key */ 1166 NULL, /* 249: request_key */ 1167 NULL, /* 250: keyctl */ 1168 NULL, /* 251: ioprio_set */ 1169 NULL, /* 252: ioprio_get */ 1170 lx_inotify_init, /* 253: inotify_init */ 1171 lx_inotify_add_watch, /* 254: inotify_add_watch */ 1172 lx_inotify_rm_watch, /* 255: inotify_rm_watch */ 1173 NULL, /* 256: migrate_pages */ 1174 NULL, /* 257: openat */ 1175 NULL, /* 258: mkdirat */ 1176 lx_mknodat, /* 259: mknodat */ 1177 NULL, /* 260: fchownat */ 1178 lx_futimesat, /* 261: futimesat */ 1179 lx_fstatat64, /* 262: fstatat64 */ 1180 lx_unlinkat, /* 263: unlinkat */ 1181 lx_renameat, /* 264: renameat */ 1182 lx_linkat, /* 265: linkat */ 1183 lx_symlinkat, /* 266: symlinkat */ 1184 lx_readlinkat, /* 267: readlinkat */ 1185 NULL, /* 268: fchmodat */ 1186 lx_faccessat, /* 269: faccessat */ 1187 lx_pselect6, /* 270: pselect6 */ 1188 lx_ppoll, /* 271: ppoll */ 1189 NULL, /* 272: unshare */ 1190 NULL, /* 273: set_robust_list */ 1191 NULL, /* 274: get_robust_list */ 1192 NULL, /* 275: splice */ 1193 NULL, /* 276: tee */ 1194 NULL, /* 277: sync_file_range */ 1195 NULL, /* 278: vmsplice */ 1196 NULL, /* 279: move_pages */ 1197 lx_utimensat, /* 280: utimensat */ 1198 lx_epoll_pwait, /* 281: epoll_pwait */ 1199 lx_signalfd, /* 282: signalfd */ 1200 lx_timerfd_create, /* 283: timerfd_create */ 1201 lx_eventfd, /* 284: eventfd */ 1202 NULL, /* 285: fallocate */ 1203 lx_timerfd_settime, /* 286: timerfd_settime */ 1204 lx_timerfd_gettime, /* 287: timerfd_gettime */ 1205 lx_accept4, /* 288: accept4 */ 1206 lx_signalfd4, /* 289: signalfd4 */ 1207 lx_eventfd2, /* 290: eventfd2 */ 1208 lx_epoll_create1, /* 291: epoll_create1 */ 1209 lx_dup3, /* 292: dup3 */ 1210 NULL, /* 293: pipe2 */ 1211 lx_inotify_init1, /* 294: inotify_init1 */ 1212 lx_preadv, /* 295: preadv */ 1213 lx_pwritev, /* 296: pwritev */ 1214 lx_rt_tgsigqueueinfo, /* 297: rt_tgsigqueueinfo */ 1215 NULL, /* 298: perf_event_open */ 1216 NULL, /* 299: recvmmsg */ 1217 NULL, /* 300: fanotify_init */ 1218 NULL, /* 301: fanotify_mark */ 1219 NULL, /* 302: prlimit64 */ 1220 NULL, /* 303: name_to_handle_at */ 1221 NULL, /* 304: open_by_handle_at */ 1222 NULL, /* 305: clock_adjtime */ 1223 NULL, /* 306: syncfs */ 1224 NULL, /* 307: sendmmsg */ 1225 NULL, /* 309: setns */ 1226 NULL, /* 309: getcpu */ 1227 NULL, /* 310: process_vm_readv */ 1228 NULL, /* 311: process_vm_writev */ 1229 NULL, /* 312: kcmp */ 1230 NULL, /* 313: finit_module */ 1231 NULL, /* 314: sched_setattr */ 1232 NULL, /* 315: sched_getattr */ 1233 NULL, /* 316: renameat2 */ 1234 NULL, /* 317: seccomp */ 1235 NULL, /* 318: getrandom */ 1236 NULL, /* 319: memfd_create */ 1237 NULL, /* 320: kexec_file_load */ 1238 NULL, /* 321: bpf */ 1239 NULL, /* 322: execveat */ 1240 1241 /* XXX TBD gap then x32 syscalls from 512 - 544 */ 1242 }; 1243 1244 #else 1245 /* The following is the 32-bit syscall table */ 1246 1247 static lx_syscall_handler_t lx_handlers[] = { 1248 NULL, /* 0: nosys */ 1249 lx_exit, /* 1: exit */ 1250 lx_fork, /* 2: fork */ 1251 NULL, /* 3: read */ 1252 NULL, /* 4: write */ 1253 NULL, /* 5: open */ 1254 lx_close, /* 6: close */ 1255 NULL, /* 7: waitpid */ 1256 lx_creat, /* 8: creat */ 1257 lx_link, /* 9: link */ 1258 lx_unlink, /* 10: unlink */ 1259 lx_execve, /* 11: execve */ 1260 lx_chdir, /* 12: chdir */ 1261 NULL, /* 13: time */ 1262 lx_mknod, /* 14: mknod */ 1263 NULL, /* 15: chmod */ 1264 NULL, /* 16: lchown16 */ 1265 NULL, /* 17: break */ 1266 NULL, /* 18: stat */ 1267 lx_lseek, /* 19: lseek */ 1268 NULL, /* 20: getpid */ 1269 lx_mount, /* 21: mount */ 1270 lx_umount, /* 22: umount */ 1271 lx_setuid16, /* 23: setuid16 */ 1272 lx_getuid16, /* 24: getuid16 */ 1273 lx_stime, /* 25: stime */ 1274 lx_ptrace, /* 26: ptrace */ 1275 lx_alarm, /* 27: alarm */ 1276 NULL, /* 28: fstat */ 1277 lx_pause, /* 29: pause */ 1278 lx_utime, /* 30: utime */ 1279 NULL, /* 31: stty */ 1280 NULL, /* 32: gtty */ 1281 lx_access, /* 33: access */ 1282 lx_nice, /* 34: nice */ 1283 NULL, /* 35: ftime */ 1284 lx_sync, /* 36: sync */ 1285 NULL, /* 37: kill */ 1286 lx_rename, /* 38: rename */ 1287 NULL, /* 39: mkdir */ 1288 lx_rmdir, /* 40: rmdir */ 1289 lx_dup, /* 41: dup */ 1290 NULL, /* 42: pipe */ 1291 lx_times, /* 43: times */ 1292 NULL, /* 44: prof */ 1293 NULL, /* 45: brk */ 1294 lx_setgid16, /* 46: setgid16 */ 1295 lx_getgid16, /* 47: getgid16 */ 1296 lx_signal, /* 48: signal */ 1297 lx_geteuid16, /* 49: geteuid16 */ 1298 lx_getegid16, /* 50: getegid16 */ 1299 NULL, /* 51: acct */ 1300 lx_umount2, /* 52: umount2 */ 1301 NULL, /* 53: lock */ 1302 NULL, /* 54: ioctl */ 1303 NULL, /* 55: fcntl */ 1304 NULL, /* 56: mpx */ 1305 lx_setpgid, /* 57: setpgid */ 1306 NULL, /* 58: ulimit */ 1307 NULL, /* 59: olduname */ 1308 lx_umask, /* 60: umask */ 1309 lx_chroot, /* 61: chroot */ 1310 NULL, /* 62: ustat */ 1311 lx_dup2, /* 63: dup2 */ 1312 NULL, /* 64: getppid */ 1313 lx_getpgrp, /* 65: getpgrp */ 1314 lx_setsid, /* 66: setsid */ 1315 lx_sigaction, /* 67: sigaction */ 1316 NULL, /* 68: sgetmask */ 1317 NULL, /* 69: ssetmask */ 1318 lx_setreuid16, /* 70: setreuid16 */ 1319 lx_setregid16, /* 71: setregid16 */ 1320 lx_sigsuspend, /* 72: sigsuspend */ 1321 lx_sigpending, /* 73: sigpending */ 1322 lx_sethostname, /* 74: sethostname */ 1323 NULL, /* 75: setrlimit */ 1324 NULL, /* 76: getrlimit */ 1325 lx_getrusage, /* 77: getrusage */ 1326 NULL, /* 78: gettimeofday */ 1327 lx_settimeofday, /* 79: settimeofday */ 1328 lx_getgroups16, /* 80: getgroups16 */ 1329 lx_setgroups16, /* 81: setgroups16 */ 1330 NULL, /* 82: select */ 1331 lx_symlink, /* 83: symlink */ 1332 NULL, /* 84: oldlstat */ 1333 lx_readlink, /* 85: readlink */ 1334 NULL, /* 86: uselib */ 1335 NULL, /* 87: swapon */ 1336 lx_reboot, /* 88: reboot */ 1337 lx_readdir, /* 89: readdir */ 1338 lx_mmap, /* 90: mmap */ 1339 lx_munmap, /* 91: munmap */ 1340 lx_truncate, /* 92: truncate */ 1341 lx_ftruncate, /* 93: ftruncate */ 1342 NULL, /* 94: fchmod */ 1343 NULL, /* 95: fchown16 */ 1344 lx_getpriority, /* 96: getpriority */ 1345 lx_setpriority, /* 97: setpriority */ 1346 NULL, /* 98: profil */ 1347 lx_statfs, /* 99: statfs */ 1348 lx_fstatfs, /* 100: fstatfs */ 1349 NULL, /* 101: ioperm */ 1350 lx_socketcall, /* 102: socketcall */ 1351 lx_syslog, /* 103: syslog */ 1352 lx_setitimer, /* 104: setitimer */ 1353 lx_getitimer, /* 105: getitimer */ 1354 lx_stat, /* 106: stat */ 1355 lx_lstat, /* 107: lstat */ 1356 lx_fstat, /* 108: fstat */ 1357 NULL, /* 109: uname */ 1358 NULL, /* 110: oldiopl */ 1359 lx_vhangup, /* 111: vhangup */ 1360 NULL, /* 112: idle */ 1361 NULL, /* 113: vm86old */ 1362 NULL, /* 114: wait4 */ 1363 NULL, /* 115: swapoff */ 1364 NULL, /* 116: sysinfo */ 1365 lx_ipc, /* 117: ipc */ 1366 lx_fsync, /* 118: fsync */ 1367 lx_sigreturn, /* 119: sigreturn */ 1368 lx_clone, /* 120: clone */ 1369 lx_setdomainname, /* 121: setdomainname */ 1370 lx_uname, /* 122: uname */ 1371 NULL, /* 123: modify_ldt */ 1372 lx_adjtimex, /* 124: adjtimex */ 1373 lx_mprotect, /* 125: mprotect */ 1374 lx_sigprocmask, /* 126: sigprocmask */ 1375 NULL, /* 127: create_module */ 1376 NULL, /* 128: init_module */ 1377 NULL, /* 129: delete_module */ 1378 NULL, /* 130: get_kernel_syms */ 1379 NULL, /* 131: quotactl */ 1380 lx_getpgid, /* 132: getpgid */ 1381 lx_fchdir, /* 133: fchdir */ 1382 NULL, /* 134: bdflush */ 1383 lx_sysfs, /* 135: sysfs */ 1384 lx_personality, /* 136: personality */ 1385 NULL, /* 137: afs_syscall */ 1386 lx_setfsuid16, /* 138: setfsuid16 */ 1387 lx_setfsgid16, /* 139: setfsgid16 */ 1388 lx_llseek, /* 140: llseek */ 1389 NULL, /* 141: getdents */ 1390 lx_select, /* 142: select */ 1391 lx_flock, /* 143: flock */ 1392 lx_msync, /* 144: msync */ 1393 lx_readv, /* 145: readv */ 1394 lx_writev, /* 146: writev */ 1395 lx_getsid, /* 147: getsid */ 1396 lx_fdatasync, /* 148: fdatasync */ 1397 lx_sysctl, /* 149: sysctl */ 1398 lx_mlock, /* 150: mlock */ 1399 lx_munlock, /* 151: munlock */ 1400 lx_mlockall, /* 152: mlockall */ 1401 lx_munlockall, /* 153: munlockall */ 1402 lx_sched_setparam, /* 154: sched_setparam */ 1403 lx_sched_getparam, /* 155: sched_getparam */ 1404 lx_sched_setscheduler, /* 156: sched_setscheduler */ 1405 lx_sched_getscheduler, /* 157: sched_getscheduler */ 1406 NULL, /* 158: sched_yield */ 1407 lx_sched_get_priority_max, /* 159: sched_get_priority_max */ 1408 lx_sched_get_priority_min, /* 160: sched_get_priority_min */ 1409 lx_sched_rr_get_interval, /* 161: sched_rr_get_interval */ 1410 lx_nanosleep, /* 162: nanosleep */ 1411 lx_remap, /* 163: mremap */ 1412 NULL, /* 164: setresuid16 */ 1413 lx_getresuid16, /* 165: getresuid16 */ 1414 NULL, /* 166: vm86 */ 1415 lx_query_module, /* 167: query_module */ 1416 lx_poll, /* 168: poll */ 1417 NULL, /* 169: nfsservctl */ 1418 NULL, /* 170: setresgid16 */ 1419 lx_getresgid16, /* 171: getresgid16 */ 1420 NULL, /* 172: prctl */ 1421 lx_rt_sigreturn, /* 173: rt_sigreturn */ 1422 lx_rt_sigaction, /* 174: rt_sigaction */ 1423 lx_rt_sigprocmask, /* 175: rt_sigprocmask */ 1424 lx_rt_sigpending, /* 176: rt_sigpending */ 1425 lx_rt_sigtimedwait, /* 177: rt_sigtimedwait */ 1426 lx_rt_sigqueueinfo, /* 178: rt_sigqueueinfo */ 1427 lx_rt_sigsuspend, /* 179: rt_sigsuspend */ 1428 lx_pread64, /* 180: pread64 */ 1429 lx_pwrite64, /* 181: pwrite64 */ 1430 NULL, /* 182: chown16 */ 1431 lx_getcwd, /* 183: getcwd */ 1432 lx_capget, /* 184: capget */ 1433 lx_capset, /* 185: capset */ 1434 lx_sigaltstack, /* 186: sigaltstack */ 1435 lx_sendfile, /* 187: sendfile */ 1436 NULL, /* 188: getpmsg */ 1437 NULL, /* 189: putpmsg */ 1438 lx_vfork, /* 190: vfork */ 1439 NULL, /* 191: getrlimit */ 1440 lx_mmap2, /* 192: mmap2 */ 1441 lx_truncate64, /* 193: truncate64 */ 1442 lx_ftruncate64, /* 194: ftruncate64 */ 1443 lx_stat64, /* 195: stat64 */ 1444 lx_lstat64, /* 196: lstat64 */ 1445 lx_fstat64, /* 197: fstat64 */ 1446 NULL, /* 198: lchown */ 1447 lx_getuid, /* 199: getuid */ 1448 lx_getgid, /* 200: getgid */ 1449 lx_geteuid, /* 201: geteuid */ 1450 lx_getegid, /* 202: getegid */ 1451 lx_setreuid, /* 203: setreuid */ 1452 lx_setregid, /* 204: setregid */ 1453 lx_getgroups, /* 205: getgroups */ 1454 lx_setgroups, /* 206: setgroups */ 1455 NULL, /* 207: fchown */ 1456 NULL, /* 208: setresuid */ 1457 lx_getresuid, /* 209: getresuid */ 1458 NULL, /* 210: setresgid */ 1459 lx_getresgid, /* 211: getresgid */ 1460 NULL, /* 212: chown */ 1461 lx_setuid, /* 213: setuid */ 1462 lx_setgid, /* 214: setgid */ 1463 lx_setfsuid, /* 215: setfsuid */ 1464 lx_setfsgid, /* 216: setfsgid */ 1465 NULL, /* 217: pivot_root */ 1466 lx_mincore, /* 218: mincore */ 1467 lx_madvise, /* 219: madvise */ 1468 NULL, /* 220: getdents64 */ 1469 NULL, /* 221: fcntl64 */ 1470 NULL, /* 222: tux */ 1471 NULL, /* 223: security */ 1472 NULL, /* 224: gettid */ 1473 NULL, /* 225: readahead */ 1474 NULL, /* 226: setxattr */ 1475 NULL, /* 227: lsetxattr */ 1476 NULL, /* 228: fsetxattr */ 1477 NULL, /* 229: getxattr */ 1478 NULL, /* 230: lgetxattr */ 1479 NULL, /* 231: fgetxattr */ 1480 NULL, /* 232: listxattr */ 1481 NULL, /* 233: llistxattr */ 1482 NULL, /* 234: flistxattr */ 1483 NULL, /* 235: removexattr */ 1484 NULL, /* 236: lremovexattr */ 1485 NULL, /* 237: fremovexattr */ 1486 NULL, /* 238: tkill */ 1487 lx_sendfile64, /* 239: sendfile64 */ 1488 NULL, /* 240: futex */ 1489 lx_sched_setaffinity, /* 241: sched_setaffinity */ 1490 lx_sched_getaffinity, /* 242: sched_getaffinity */ 1491 NULL, /* 243: set_thread_area */ 1492 NULL, /* 244: get_thread_area */ 1493 lx_io_setup, /* 245: io_setup */ 1494 lx_io_destroy, /* 246: io_destroy */ 1495 lx_io_getevents, /* 247: io_getevents */ 1496 lx_io_submit, /* 248: io_submit */ 1497 lx_io_cancel, /* 249: io_cancel */ 1498 lx_fadvise64, /* 250: fadvise64 */ 1499 NULL, /* 251: nosys */ 1500 lx_group_exit, /* 252: group_exit */ 1501 NULL, /* 253: lookup_dcookie */ 1502 lx_epoll_create, /* 254: epoll_create */ 1503 lx_epoll_ctl, /* 255: epoll_ctl */ 1504 lx_epoll_wait, /* 256: epoll_wait */ 1505 NULL, /* 257: remap_file_pages */ 1506 NULL, /* 258: set_tid_address */ 1507 lx_timer_create, /* 259: timer_create */ 1508 lx_timer_settime, /* 260: timer_settime */ 1509 lx_timer_gettime, /* 261: timer_gettime */ 1510 lx_timer_getoverrun, /* 262: timer_getoverrun */ 1511 lx_timer_delete, /* 263: timer_delete */ 1512 NULL, /* 264: clock_settime */ 1513 NULL, /* 265: clock_gettime */ 1514 NULL, /* 266: clock_getres */ 1515 lx_clock_nanosleep, /* 267: clock_nanosleep */ 1516 lx_statfs64, /* 268: statfs64 */ 1517 lx_fstatfs64, /* 269: fstatfs64 */ 1518 NULL, /* 270: tgkill */ 1519 lx_utimes, /* 271: utimes */ 1520 lx_fadvise64_64, /* 272: fadvise64_64 */ 1521 NULL, /* 273: vserver */ 1522 NULL, /* 274: mbind */ 1523 NULL, /* 275: get_mempolicy */ 1524 NULL, /* 276: set_mempolicy */ 1525 NULL, /* 277: mq_open */ 1526 NULL, /* 278: mq_unlink */ 1527 NULL, /* 279: mq_timedsend */ 1528 NULL, /* 280: mq_timedreceive */ 1529 NULL, /* 281: mq_notify */ 1530 NULL, /* 282: mq_getsetattr */ 1531 NULL, /* 283: kexec_load */ 1532 NULL, /* 284: waitid */ 1533 NULL, /* 285: sys_setaltroot */ 1534 NULL, /* 286: add_key */ 1535 NULL, /* 287: request_key */ 1536 NULL, /* 288: keyctl */ 1537 NULL, /* 289: ioprio_set */ 1538 NULL, /* 290: ioprio_get */ 1539 lx_inotify_init, /* 291: inotify_init */ 1540 lx_inotify_add_watch, /* 292: inotify_add_watch */ 1541 lx_inotify_rm_watch, /* 293: inotify_rm_watch */ 1542 NULL, /* 294: migrate_pages */ 1543 NULL, /* 295: openat */ 1544 NULL, /* 296: mkdirat */ 1545 lx_mknodat, /* 297: mknodat */ 1546 NULL, /* 298: fchownat */ 1547 lx_futimesat, /* 299: futimesat */ 1548 lx_fstatat64, /* 300: fstatat64 */ 1549 lx_unlinkat, /* 301: unlinkat */ 1550 lx_renameat, /* 302: renameat */ 1551 lx_linkat, /* 303: linkat */ 1552 lx_symlinkat, /* 304: symlinkat */ 1553 lx_readlinkat, /* 305: readlinkat */ 1554 NULL, /* 306: fchmodat */ 1555 lx_faccessat, /* 307: faccessat */ 1556 lx_pselect6, /* 308: pselect6 */ 1557 lx_ppoll, /* 309: ppoll */ 1558 NULL, /* 310: unshare */ 1559 NULL, /* 311: set_robust_list */ 1560 NULL, /* 312: get_robust_list */ 1561 NULL, /* 313: splice */ 1562 NULL, /* 314: sync_file_range */ 1563 NULL, /* 315: tee */ 1564 NULL, /* 316: vmsplice */ 1565 NULL, /* 317: move_pages */ 1566 NULL, /* 318: getcpu */ 1567 lx_epoll_pwait, /* 319: epoll_pwait */ 1568 lx_utimensat, /* 320: utimensat */ 1569 lx_signalfd, /* 321: signalfd */ 1570 lx_timerfd_create, /* 322: timerfd_create */ 1571 lx_eventfd, /* 323: eventfd */ 1572 NULL, /* 324: fallocate */ 1573 lx_timerfd_settime, /* 325: timerfd_settime */ 1574 lx_timerfd_gettime, /* 326: timerfd_gettime */ 1575 lx_signalfd4, /* 327: signalfd4 */ 1576 lx_eventfd2, /* 328: eventfd2 */ 1577 lx_epoll_create1, /* 329: epoll_create1 */ 1578 lx_dup3, /* 330: dup3 */ 1579 NULL, /* 331: pipe2 */ 1580 lx_inotify_init1, /* 332: inotify_init1 */ 1581 lx_preadv, /* 333: preadv */ 1582 lx_pwritev, /* 334: pwritev */ 1583 lx_rt_tgsigqueueinfo, /* 335: rt_tgsigqueueinfo */ 1584 NULL, /* 336: perf_event_open */ 1585 NULL, /* 337: recvmmsg */ 1586 NULL, /* 338: fanotify_init */ 1587 NULL, /* 339: fanotify_mark */ 1588 NULL, /* 340: prlimit64 */ 1589 NULL, /* 341: name_to_handle_at */ 1590 NULL, /* 342: open_by_handle_at */ 1591 NULL, /* 343: clock_adjtime */ 1592 NULL, /* 344: syncfs */ 1593 NULL, /* 345: sendmmsg */ 1594 NULL, /* 346: setns */ 1595 NULL, /* 347: process_vm_readv */ 1596 NULL, /* 348: process_vm_writev */ 1597 NULL, /* 349: kcmp */ 1598 NULL, /* 350: finit_module */ 1599 NULL, /* 351: sched_setattr */ 1600 NULL, /* 352: sched_getattr */ 1601 NULL, /* 353: renameat2 */ 1602 NULL, /* 354: seccomp */ 1603 NULL, /* 355: getrandom */ 1604 NULL, /* 356: memfd_create */ 1605 NULL, /* 357: bpf */ 1606 NULL, /* 358: execveat */ 1607 }; 1608 #endif