sys/amd64/linux32/linux32_sysvec.c

   1 /*-
   2  * Copyright (c) 2004 Tim J. Robbins
   3  * Copyright (c) 2003 Peter Wemm
   4  * Copyright (c) 2002 Doug Rabson
   5  * Copyright (c) 1998-1999 Andrew Gallatin
   6  * Copyright (c) 1994-1996 Søren Schmidt
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer
  14  *    in this position and unchanged.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. The name of the author may not be used to endorse or promote products
  19  *    derived from this software without specific prior written permission
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32
  33 #include <sys/cdefs.h>
  34 __FBSDID("$FreeBSD$");
  35 #include "opt_compat.h"
  36
  37 #ifndef COMPAT_FREEBSD32
  38 #error "Unable to compile Linux-emulator due to missing COMPAT_FREEBSD32 option!"
  39 #endif
  40
  41 #define __ELF_WORD_SIZE 32
  42
  43 #include <sys/param.h>
  44 #include <sys/systm.h>
  45 #include <sys/exec.h>
  46 #include <sys/fcntl.h>
  47 #include <sys/imgact.h>
  48 #include <sys/imgact_elf.h>
  49 #include <sys/kernel.h>
  50 #include <sys/lock.h>
  51 #include <sys/malloc.h>
  52 #include <sys/module.h>
  53 #include <sys/mutex.h>
  54 #include <sys/proc.h>
  55 #include <sys/resourcevar.h>
  56 #include <sys/signalvar.h>
  57 #include <sys/sysctl.h>
  58 #include <sys/syscallsubr.h>
  59 #include <sys/sysent.h>
  60 #include <sys/sysproto.h>
  61 #include <sys/vnode.h>
  62 #include <sys/eventhandler.h>
  63
  64 #include <vm/vm.h>
  65 #include <vm/pmap.h>
  66 #include <vm/vm_extern.h>
  67 #include <vm/vm_map.h>
  68 #include <vm/vm_object.h>
  69 #include <vm/vm_page.h>
  70 #include <vm/vm_param.h>
  71
  72 #include <machine/cpu.h>
  73 #include <machine/md_var.h>
  74 #include <machine/pcb.h>
  75 #include <machine/specialreg.h>
  76
  77 #include <amd64/linux32/linux.h>
  78 #include <amd64/linux32/linux32_proto.h>
  79 #include <compat/linux/linux_emul.h>
  80 #include <compat/linux/linux_futex.h>
  81 #include <compat/linux/linux_ioctl.h>
  82 #include <compat/linux/linux_mib.h>
  83 #include <compat/linux/linux_misc.h>
  84 #include <compat/linux/linux_signal.h>
  85 #include <compat/linux/linux_util.h>
  86 #include <compat/linux/linux_vdso.h>
  87
  88 MODULE_VERSION(linux, 1);
  89
  90 MALLOC_DEFINE(M_LINUX, "linux", "Linux mode structures");
  91
  92 #define AUXARGS_ENTRY_32(pos, id, val)  \
  93         do {                            \
  94                 suword32(pos++, id);    \
  95                 suword32(pos++, val);   \
  96         } while (0)
  97
  98 #if BYTE_ORDER == LITTLE_ENDIAN
  99 #define SHELLMAGIC      0x2123 /* #! */
 100 #else
 101 #define SHELLMAGIC      0x2321
 102 #endif
 103
 104 /*
 105  * Allow the sendsig functions to use the ldebug() facility
 106  * even though they are not syscalls themselves. Map them
 107  * to syscall 0. This is slightly less bogus than using
 108  * ldebug(sigreturn).
 109  */
 110 #define LINUX_SYS_linux_rt_sendsig      0
 111 #define LINUX_SYS_linux_sendsig         0
 112
 113 const char *linux_platform = "i686";
 114 static int linux_szplatform;
 115 static int linux_szsigcode;
 116 static vm_object_t linux_shared_page_obj;
 117 static char *linux_shared_page_mapping;
 118 extern char _binary_linux32_locore_o_start;
 119 extern char _binary_linux32_locore_o_end;
 120
 121 extern struct sysent linux_sysent[LINUX_SYS_MAXSYSCALL];
 122
 123 SET_DECLARE(linux_ioctl_handler_set, struct linux_ioctl_handler);
 124 SET_DECLARE(linux_device_handler_set, struct linux_device_handler);
 125
 126 static int      elf_linux_fixup(register_t **stack_base,
 127                     struct image_params *iparams);
 128 static register_t *linux_copyout_strings(struct image_params *imgp);
 129 static void     linux_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask);
 130 static void     exec_linux_setregs(struct thread *td,
 131                                    struct image_params *imgp, u_long stack);
 132 static void     linux32_fixlimit(struct rlimit *rl, int which);
 133 static boolean_t linux32_trans_osrel(const Elf_Note *note, int32_t *osrel);
 134 static void     linux_vdso_install(void *param);
 135 static void     linux_vdso_deinstall(void *param);
 136
 137 static eventhandler_tag linux_exit_tag;
 138 static eventhandler_tag linux_exec_tag;
 139 static eventhandler_tag linux_thread_dtor_tag;
 140
 141 /*
 142  * Linux syscalls return negative errno's, we do positive and map them
 143  * Reference:
 144  *   FreeBSD: src/sys/sys/errno.h
 145  *   Linux:   linux-2.6.17.8/include/asm-generic/errno-base.h
 146  *            linux-2.6.17.8/include/asm-generic/errno.h
 147  */
 148 static int bsd_to_linux_errno[ELAST + 1] = {
 149         -0,  -1,  -2,  -3,  -4,  -5,  -6,  -7,  -8,  -9,
 150         -10, -35, -12, -13, -14, -15, -16, -17, -18, -19,
 151         -20, -21, -22, -23, -24, -25, -26, -27, -28, -29,
 152         -30, -31, -32, -33, -34, -11,-115,-114, -88, -89,
 153         -90, -91, -92, -93, -94, -95, -96, -97, -98, -99,
 154         -100,-101,-102,-103,-104,-105,-106,-107,-108,-109,
 155         -110,-111, -40, -36,-112,-113, -39, -11, -87,-122,
 156         -116, -66,  -6,  -6,  -6,  -6,  -6, -37, -38,  -9,
 157           -6,  -6, -43, -42, -75,-125, -84, -95, -16, -74,
 158          -72, -67, -71
 159 };
 160
 161 int bsd_to_linux_signal[LINUX_SIGTBLSZ] = {
 162         LINUX_SIGHUP, LINUX_SIGINT, LINUX_SIGQUIT, LINUX_SIGILL,
 163         LINUX_SIGTRAP, LINUX_SIGABRT, 0, LINUX_SIGFPE,
 164         LINUX_SIGKILL, LINUX_SIGBUS, LINUX_SIGSEGV, LINUX_SIGSYS,
 165         LINUX_SIGPIPE, LINUX_SIGALRM, LINUX_SIGTERM, LINUX_SIGURG,
 166         LINUX_SIGSTOP, LINUX_SIGTSTP, LINUX_SIGCONT, LINUX_SIGCHLD,
 167         LINUX_SIGTTIN, LINUX_SIGTTOU, LINUX_SIGIO, LINUX_SIGXCPU,
 168         LINUX_SIGXFSZ, LINUX_SIGVTALRM, LINUX_SIGPROF, LINUX_SIGWINCH,
 169         0, LINUX_SIGUSR1, LINUX_SIGUSR2
 170 };
 171
 172 int linux_to_bsd_signal[LINUX_SIGTBLSZ] = {
 173         SIGHUP, SIGINT, SIGQUIT, SIGILL,
 174         SIGTRAP, SIGABRT, SIGBUS, SIGFPE,
 175         SIGKILL, SIGUSR1, SIGSEGV, SIGUSR2,
 176         SIGPIPE, SIGALRM, SIGTERM, SIGBUS,
 177         SIGCHLD, SIGCONT, SIGSTOP, SIGTSTP,
 178         SIGTTIN, SIGTTOU, SIGURG, SIGXCPU,
 179         SIGXFSZ, SIGVTALRM, SIGPROF, SIGWINCH,
 180         SIGIO, SIGURG, SIGSYS
 181 };
 182
 183 #define LINUX_T_UNKNOWN  255
 184 static int _bsd_to_linux_trapcode[] = {
 185         LINUX_T_UNKNOWN,        /* 0 */
 186         6,                      /* 1  T_PRIVINFLT */
 187         LINUX_T_UNKNOWN,        /* 2 */
 188         3,                      /* 3  T_BPTFLT */
 189         LINUX_T_UNKNOWN,        /* 4 */
 190         LINUX_T_UNKNOWN,        /* 5 */
 191         16,                     /* 6  T_ARITHTRAP */
 192         254,                    /* 7  T_ASTFLT */
 193         LINUX_T_UNKNOWN,        /* 8 */
 194         13,                     /* 9  T_PROTFLT */
 195         1,                      /* 10 T_TRCTRAP */
 196         LINUX_T_UNKNOWN,        /* 11 */
 197         14,                     /* 12 T_PAGEFLT */
 198         LINUX_T_UNKNOWN,        /* 13 */
 199         17,                     /* 14 T_ALIGNFLT */
 200         LINUX_T_UNKNOWN,        /* 15 */
 201         LINUX_T_UNKNOWN,        /* 16 */
 202         LINUX_T_UNKNOWN,        /* 17 */
 203         0,                      /* 18 T_DIVIDE */
 204         2,                      /* 19 T_NMI */
 205         4,                      /* 20 T_OFLOW */
 206         5,                      /* 21 T_BOUND */
 207         7,                      /* 22 T_DNA */
 208         8,                      /* 23 T_DOUBLEFLT */
 209         9,                      /* 24 T_FPOPFLT */
 210         10,                     /* 25 T_TSSFLT */
 211         11,                     /* 26 T_SEGNPFLT */
 212         12,                     /* 27 T_STKFLT */
 213         18,                     /* 28 T_MCHK */
 214         19,                     /* 29 T_XMMFLT */
 215         15                      /* 30 T_RESERVED */
 216 };
 217 #define bsd_to_linux_trapcode(code) \
 218     ((code)<sizeof(_bsd_to_linux_trapcode)/sizeof(*_bsd_to_linux_trapcode)? \
 219      _bsd_to_linux_trapcode[(code)]: \
 220      LINUX_T_UNKNOWN)
 221
 222 struct linux32_ps_strings {
 223         u_int32_t ps_argvstr;   /* first of 0 or more argument strings */
 224         u_int ps_nargvstr;      /* the number of argument strings */
 225         u_int32_t ps_envstr;    /* first of 0 or more environment strings */
 226         u_int ps_nenvstr;       /* the number of environment strings */
 227 };
 228
 229 LINUX_VDSO_SYM_INTPTR(linux32_sigcode);
 230 LINUX_VDSO_SYM_INTPTR(linux32_rt_sigcode);
 231 LINUX_VDSO_SYM_INTPTR(linux32_vsyscall);
 232
 233 /*
 234  * If FreeBSD & Linux have a difference of opinion about what a trap
 235  * means, deal with it here.
 236  *
 237  * MPSAFE
 238  */
 239 static int
 240 translate_traps(int signal, int trap_code)
 241 {
 242         if (signal != SIGBUS)
 243                 return signal;
 244         switch (trap_code) {
 245         case T_PROTFLT:
 246         case T_TSSFLT:
 247         case T_DOUBLEFLT:
 248         case T_PAGEFLT:
 249                 return SIGSEGV;
 250         default:
 251                 return signal;
 252         }
 253 }
 254
 255 static int
 256 elf_linux_fixup(register_t **stack_base, struct image_params *imgp)
 257 {
 258         Elf32_Auxargs *args;
 259         Elf32_Addr *base;
 260         Elf32_Addr *pos, *uplatform;
 261         struct linux32_ps_strings *arginfo;
 262
 263         arginfo = (struct linux32_ps_strings *)LINUX32_PS_STRINGS;
 264         uplatform = (Elf32_Addr *)((caddr_t)arginfo - linux_szplatform);
 265
 266         KASSERT(curthread->td_proc == imgp->proc,
 267             ("unsafe elf_linux_fixup(), should be curproc"));
 268         base = (Elf32_Addr *)*stack_base;
 269         args = (Elf32_Auxargs *)imgp->auxargs;
 270         pos = base + (imgp->args->argc + imgp->args->envc + 2);
 271
 272         AUXARGS_ENTRY_32(pos, LINUX_AT_SYSINFO_EHDR,
 273             imgp->proc->p_sysent->sv_shared_page_base);
 274         AUXARGS_ENTRY_32(pos, LINUX_AT_SYSINFO, linux32_vsyscall);
 275         AUXARGS_ENTRY_32(pos, LINUX_AT_HWCAP, cpu_feature);
 276
 277         /*
 278          * Do not export AT_CLKTCK when emulating Linux kernel prior to 2.4.0,
 279          * as it has appeared in the 2.4.0-rc7 first time.
 280          * Being exported, AT_CLKTCK is returned by sysconf(_SC_CLK_TCK),
 281          * glibc falls back to the hard-coded CLK_TCK value when aux entry
 282          * is not present.
 283          * Also see linux_times() implementation.
 284          */
 285         if (linux_kernver(curthread) >= LINUX_KERNVER_2004000)
 286                 AUXARGS_ENTRY_32(pos, LINUX_AT_CLKTCK, stclohz);
 287         AUXARGS_ENTRY_32(pos, AT_PHDR, args->phdr);
 288         AUXARGS_ENTRY_32(pos, AT_PHENT, args->phent);
 289         AUXARGS_ENTRY_32(pos, AT_PHNUM, args->phnum);
 290         AUXARGS_ENTRY_32(pos, AT_PAGESZ, args->pagesz);
 291         AUXARGS_ENTRY_32(pos, AT_FLAGS, args->flags);
 292         AUXARGS_ENTRY_32(pos, AT_ENTRY, args->entry);
 293         AUXARGS_ENTRY_32(pos, AT_BASE, args->base);
 294         AUXARGS_ENTRY_32(pos, LINUX_AT_SECURE, 0);
 295         AUXARGS_ENTRY_32(pos, AT_UID, imgp->proc->p_ucred->cr_ruid);
 296         AUXARGS_ENTRY_32(pos, AT_EUID, imgp->proc->p_ucred->cr_svuid);
 297         AUXARGS_ENTRY_32(pos, AT_GID, imgp->proc->p_ucred->cr_rgid);
 298         AUXARGS_ENTRY_32(pos, AT_EGID, imgp->proc->p_ucred->cr_svgid);
 299         AUXARGS_ENTRY_32(pos, LINUX_AT_PLATFORM, PTROUT(uplatform));
 300         if (args->execfd != -1)
 301                 AUXARGS_ENTRY_32(pos, AT_EXECFD, args->execfd);
 302         AUXARGS_ENTRY_32(pos, AT_NULL, 0);
 303
 304         free(imgp->auxargs, M_TEMP);
 305         imgp->auxargs = NULL;
 306
 307         base--;
 308         suword32(base, (uint32_t)imgp->args->argc);
 309         *stack_base = (register_t *)base;
 310         return (0);
 311 }
 312
 313 static void
 314 linux_rt_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
 315 {
 316         struct thread *td = curthread;
 317         struct proc *p = td->td_proc;
 318         struct sigacts *psp;
 319         struct trapframe *regs;
 320         struct l_rt_sigframe *fp, frame;
 321         int oonstack;
 322         int sig;
 323         int code;
 324
 325         sig = ksi->ksi_signo;
 326         code = ksi->ksi_code;
 327         PROC_LOCK_ASSERT(p, MA_OWNED);
 328         psp = p->p_sigacts;
 329         mtx_assert(&psp->ps_mtx, MA_OWNED);
 330         regs = td->td_frame;
 331         oonstack = sigonstack(regs->tf_rsp);
 332
 333 #ifdef DEBUG
 334         if (ldebug(rt_sendsig))
 335                 printf(ARGS(rt_sendsig, "%p, %d, %p, %u"),
 336                     catcher, sig, (void*)mask, code);
 337 #endif
 338         /*
 339          * Allocate space for the signal handler context.
 340          */
 341         if ((td->td_pflags & TDP_ALTSTACK) && !oonstack &&
 342             SIGISMEMBER(psp->ps_sigonstack, sig)) {
 343                 fp = (struct l_rt_sigframe *)(td->td_sigstk.ss_sp +
 344                     td->td_sigstk.ss_size - sizeof(struct l_rt_sigframe));
 345         } else
 346                 fp = (struct l_rt_sigframe *)regs->tf_rsp - 1;
 347         mtx_unlock(&psp->ps_mtx);
 348
 349         /*
 350          * Build the argument list for the signal handler.
 351          */
 352         if (p->p_sysent->sv_sigtbl)
 353                 if (sig <= p->p_sysent->sv_sigsize)
 354                         sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
 355
 356         bzero(&frame, sizeof(frame));
 357
 358         frame.sf_handler = PTROUT(catcher);
 359         frame.sf_sig = sig;
 360         frame.sf_siginfo = PTROUT(&fp->sf_si);
 361         frame.sf_ucontext = PTROUT(&fp->sf_sc);
 362
 363         /* Fill in POSIX parts */
 364         ksiginfo_to_lsiginfo(ksi, &frame.sf_si, sig);
 365
 366         /*
 367          * Build the signal context to be used by sigreturn
 368          * and libgcc unwind.
 369          */
 370         frame.sf_sc.uc_flags = 0;               /* XXX ??? */
 371         frame.sf_sc.uc_link = 0;                /* XXX ??? */
 372
 373         frame.sf_sc.uc_stack.ss_sp = PTROUT(td->td_sigstk.ss_sp);
 374         frame.sf_sc.uc_stack.ss_size = td->td_sigstk.ss_size;
 375         frame.sf_sc.uc_stack.ss_flags = (td->td_pflags & TDP_ALTSTACK)
 376             ? ((oonstack) ? LINUX_SS_ONSTACK : 0) : LINUX_SS_DISABLE;
 377         PROC_UNLOCK(p);
 378
 379         bsd_to_linux_sigset(mask, &frame.sf_sc.uc_sigmask);
 380
 381         frame.sf_sc.uc_mcontext.sc_mask   = frame.sf_sc.uc_sigmask.__bits[0];
 382         frame.sf_sc.uc_mcontext.sc_edi    = regs->tf_rdi;
 383         frame.sf_sc.uc_mcontext.sc_esi    = regs->tf_rsi;
 384         frame.sf_sc.uc_mcontext.sc_ebp    = regs->tf_rbp;
 385         frame.sf_sc.uc_mcontext.sc_ebx    = regs->tf_rbx;
 386         frame.sf_sc.uc_mcontext.sc_esp    = regs->tf_rsp;
 387         frame.sf_sc.uc_mcontext.sc_edx    = regs->tf_rdx;
 388         frame.sf_sc.uc_mcontext.sc_ecx    = regs->tf_rcx;
 389         frame.sf_sc.uc_mcontext.sc_eax    = regs->tf_rax;
 390         frame.sf_sc.uc_mcontext.sc_eip    = regs->tf_rip;
 391         frame.sf_sc.uc_mcontext.sc_cs     = regs->tf_cs;
 392         frame.sf_sc.uc_mcontext.sc_gs     = regs->tf_gs;
 393         frame.sf_sc.uc_mcontext.sc_fs     = regs->tf_fs;
 394         frame.sf_sc.uc_mcontext.sc_es     = regs->tf_es;
 395         frame.sf_sc.uc_mcontext.sc_ds     = regs->tf_ds;
 396         frame.sf_sc.uc_mcontext.sc_eflags = regs->tf_rflags;
 397         frame.sf_sc.uc_mcontext.sc_esp_at_signal = regs->tf_rsp;
 398         frame.sf_sc.uc_mcontext.sc_ss     = regs->tf_ss;
 399         frame.sf_sc.uc_mcontext.sc_err    = regs->tf_err;
 400         frame.sf_sc.uc_mcontext.sc_cr2    = (u_int32_t)(uintptr_t)ksi->ksi_addr;
 401         frame.sf_sc.uc_mcontext.sc_trapno = bsd_to_linux_trapcode(code);
 402
 403 #ifdef DEBUG
 404         if (ldebug(rt_sendsig))
 405                 printf(LMSG("rt_sendsig flags: 0x%x, sp: %p, ss: 0x%lx, mask: 0x%x"),
 406                     frame.sf_sc.uc_stack.ss_flags, td->td_sigstk.ss_sp,
 407                     td->td_sigstk.ss_size, frame.sf_sc.uc_mcontext.sc_mask);
 408 #endif
 409
 410         if (copyout(&frame, fp, sizeof(frame)) != 0) {
 411                 /*
 412                  * Process has trashed its stack; give it an illegal
 413                  * instruction to halt it in its tracks.
 414                  */
 415 #ifdef DEBUG
 416                 if (ldebug(rt_sendsig))
 417                         printf(LMSG("rt_sendsig: bad stack %p, oonstack=%x"),
 418                             fp, oonstack);
 419 #endif
 420                 PROC_LOCK(p);
 421                 sigexit(td, SIGILL);
 422         }
 423
 424         /*
 425          * Build context to run handler in.
 426          */
 427         regs->tf_rsp = PTROUT(fp);
 428         regs->tf_rip = linux32_rt_sigcode;
 429         regs->tf_rflags &= ~(PSL_T | PSL_D);
 430         regs->tf_cs = _ucode32sel;
 431         regs->tf_ss = _udatasel;
 432         regs->tf_ds = _udatasel;
 433         regs->tf_es = _udatasel;
 434         regs->tf_fs = _ufssel;
 435         regs->tf_gs = _ugssel;
 436         regs->tf_flags = TF_HASSEGS;
 437         set_pcb_flags(td->td_pcb, PCB_FULL_IRET);
 438         PROC_LOCK(p);
 439         mtx_lock(&psp->ps_mtx);
 440 }
 441
 442
 443 /*
 444  * Send an interrupt to process.
 445  *
 446  * Stack is set up to allow sigcode stored
 447  * in u. to call routine, followed by kcall
 448  * to sigreturn routine below.  After sigreturn
 449  * resets the signal mask, the stack, and the
 450  * frame pointer, it returns to the user
 451  * specified pc, psl.
 452  */
 453 static void
 454 linux_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
 455 {
 456         struct thread *td = curthread;
 457         struct proc *p = td->td_proc;
 458         struct sigacts *psp;
 459         struct trapframe *regs;
 460         struct l_sigframe *fp, frame;
 461         l_sigset_t lmask;
 462         int oonstack, i;
 463         int sig, code;
 464
 465         sig = ksi->ksi_signo;
 466         code = ksi->ksi_code;
 467         PROC_LOCK_ASSERT(p, MA_OWNED);
 468         psp = p->p_sigacts;
 469         mtx_assert(&psp->ps_mtx, MA_OWNED);
 470         if (SIGISMEMBER(psp->ps_siginfo, sig)) {
 471                 /* Signal handler installed with SA_SIGINFO. */
 472                 linux_rt_sendsig(catcher, ksi, mask);
 473                 return;
 474         }
 475
 476         regs = td->td_frame;
 477         oonstack = sigonstack(regs->tf_rsp);
 478
 479 #ifdef DEBUG
 480         if (ldebug(sendsig))
 481                 printf(ARGS(sendsig, "%p, %d, %p, %u"),
 482                     catcher, sig, (void*)mask, code);
 483 #endif
 484
 485         /*
 486          * Allocate space for the signal handler context.
 487          */
 488         if ((td->td_pflags & TDP_ALTSTACK) && !oonstack &&
 489             SIGISMEMBER(psp->ps_sigonstack, sig)) {
 490                 fp = (struct l_sigframe *)(td->td_sigstk.ss_sp +
 491                     td->td_sigstk.ss_size - sizeof(struct l_sigframe));
 492         } else
 493                 fp = (struct l_sigframe *)regs->tf_rsp - 1;
 494         mtx_unlock(&psp->ps_mtx);
 495         PROC_UNLOCK(p);
 496
 497         /*
 498          * Build the argument list for the signal handler.
 499          */
 500         if (p->p_sysent->sv_sigtbl)
 501                 if (sig <= p->p_sysent->sv_sigsize)
 502                         sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
 503
 504         bzero(&frame, sizeof(frame));
 505
 506         frame.sf_handler = PTROUT(catcher);
 507         frame.sf_sig = sig;
 508
 509         bsd_to_linux_sigset(mask, &lmask);
 510
 511         /*
 512          * Build the signal context to be used by sigreturn.
 513          */
 514         frame.sf_sc.sc_mask   = lmask.__bits[0];
 515         frame.sf_sc.sc_gs     = regs->tf_gs;
 516         frame.sf_sc.sc_fs     = regs->tf_fs;
 517         frame.sf_sc.sc_es     = regs->tf_es;
 518         frame.sf_sc.sc_ds     = regs->tf_ds;
 519         frame.sf_sc.sc_edi    = regs->tf_rdi;
 520         frame.sf_sc.sc_esi    = regs->tf_rsi;
 521         frame.sf_sc.sc_ebp    = regs->tf_rbp;
 522         frame.sf_sc.sc_ebx    = regs->tf_rbx;
 523         frame.sf_sc.sc_esp    = regs->tf_rsp;
 524         frame.sf_sc.sc_edx    = regs->tf_rdx;
 525         frame.sf_sc.sc_ecx    = regs->tf_rcx;
 526         frame.sf_sc.sc_eax    = regs->tf_rax;
 527         frame.sf_sc.sc_eip    = regs->tf_rip;
 528         frame.sf_sc.sc_cs     = regs->tf_cs;
 529         frame.sf_sc.sc_eflags = regs->tf_rflags;
 530         frame.sf_sc.sc_esp_at_signal = regs->tf_rsp;
 531         frame.sf_sc.sc_ss     = regs->tf_ss;
 532         frame.sf_sc.sc_err    = regs->tf_err;
 533         frame.sf_sc.sc_cr2    = (u_int32_t)(uintptr_t)ksi->ksi_addr;
 534         frame.sf_sc.sc_trapno = bsd_to_linux_trapcode(code);
 535
 536         for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
 537                 frame.sf_extramask[i] = lmask.__bits[i+1];
 538
 539         if (copyout(&frame, fp, sizeof(frame)) != 0) {
 540                 /*
 541                  * Process has trashed its stack; give it an illegal
 542                  * instruction to halt it in its tracks.
 543                  */
 544                 PROC_LOCK(p);
 545                 sigexit(td, SIGILL);
 546         }
 547
 548         /*
 549          * Build context to run handler in.
 550          */
 551         regs->tf_rsp = PTROUT(fp);
 552         regs->tf_rip = linux32_sigcode;
 553         regs->tf_rflags &= ~(PSL_T | PSL_D);
 554         regs->tf_cs = _ucode32sel;
 555         regs->tf_ss = _udatasel;
 556         regs->tf_ds = _udatasel;
 557         regs->tf_es = _udatasel;
 558         regs->tf_fs = _ufssel;
 559         regs->tf_gs = _ugssel;
 560         regs->tf_flags = TF_HASSEGS;
 561         set_pcb_flags(td->td_pcb, PCB_FULL_IRET);
 562         PROC_LOCK(p);
 563         mtx_lock(&psp->ps_mtx);
 564 }
 565
 566 /*
 567  * System call to cleanup state after a signal
 568  * has been taken.  Reset signal mask and
 569  * stack state from context left by sendsig (above).
 570  * Return to previous pc and psl as specified by
 571  * context left by sendsig. Check carefully to
 572  * make sure that the user has not modified the
 573  * psl to gain improper privileges or to cause
 574  * a machine fault.
 575  */
 576 int
 577 linux_sigreturn(struct thread *td, struct linux_sigreturn_args *args)
 578 {
 579         struct l_sigframe frame;
 580         struct trapframe *regs;
 581         sigset_t bmask;
 582         l_sigset_t lmask;
 583         int eflags, i;
 584         ksiginfo_t ksi;
 585
 586         regs = td->td_frame;
 587
 588 #ifdef DEBUG
 589         if (ldebug(sigreturn))
 590                 printf(ARGS(sigreturn, "%p"), (void *)args->sfp);
 591 #endif
 592         /*
 593          * The trampoline code hands us the sigframe.
 594          * It is unsafe to keep track of it ourselves, in the event that a
 595          * program jumps out of a signal handler.
 596          */
 597         if (copyin(args->sfp, &frame, sizeof(frame)) != 0)
 598                 return (EFAULT);
 599
 600         /*
 601          * Check for security violations.
 602          */
 603 #define EFLAGS_SECURE(ef, oef)  ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
 604         eflags = frame.sf_sc.sc_eflags;
 605         if (!EFLAGS_SECURE(eflags, regs->tf_rflags))
 606                 return(EINVAL);
 607
 608         /*
 609          * Don't allow users to load a valid privileged %cs.  Let the
 610          * hardware check for invalid selectors, excess privilege in
 611          * other selectors, invalid %eip's and invalid %esp's.
 612          */
 613 #define CS_SECURE(cs)   (ISPL(cs) == SEL_UPL)
 614         if (!CS_SECURE(frame.sf_sc.sc_cs)) {
 615                 ksiginfo_init_trap(&ksi);
 616                 ksi.ksi_signo = SIGBUS;
 617                 ksi.ksi_code = BUS_OBJERR;
 618                 ksi.ksi_trapno = T_PROTFLT;
 619                 ksi.ksi_addr = (void *)regs->tf_rip;
 620                 trapsignal(td, &ksi);
 621                 return(EINVAL);
 622         }
 623
 624         lmask.__bits[0] = frame.sf_sc.sc_mask;
 625         for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
 626                 lmask.__bits[i+1] = frame.sf_extramask[i];
 627         linux_to_bsd_sigset(&lmask, &bmask);
 628         kern_sigprocmask(td, SIG_SETMASK, &bmask, NULL, 0);
 629
 630         /*
 631          * Restore signal context.
 632          */
 633         regs->tf_rdi    = frame.sf_sc.sc_edi;
 634         regs->tf_rsi    = frame.sf_sc.sc_esi;
 635         regs->tf_rbp    = frame.sf_sc.sc_ebp;
 636         regs->tf_rbx    = frame.sf_sc.sc_ebx;
 637         regs->tf_rdx    = frame.sf_sc.sc_edx;
 638         regs->tf_rcx    = frame.sf_sc.sc_ecx;
 639         regs->tf_rax    = frame.sf_sc.sc_eax;
 640         regs->tf_rip    = frame.sf_sc.sc_eip;
 641         regs->tf_cs     = frame.sf_sc.sc_cs;
 642         regs->tf_ds     = frame.sf_sc.sc_ds;
 643         regs->tf_es     = frame.sf_sc.sc_es;
 644         regs->tf_fs     = frame.sf_sc.sc_fs;
 645         regs->tf_gs     = frame.sf_sc.sc_gs;
 646         regs->tf_rflags = eflags;
 647         regs->tf_rsp    = frame.sf_sc.sc_esp_at_signal;
 648         regs->tf_ss     = frame.sf_sc.sc_ss;
 649         set_pcb_flags(td->td_pcb, PCB_FULL_IRET);
 650
 651         return (EJUSTRETURN);
 652 }
 653
 654 /*
 655  * System call to cleanup state after a signal
 656  * has been taken.  Reset signal mask and
 657  * stack state from context left by rt_sendsig (above).
 658  * Return to previous pc and psl as specified by
 659  * context left by sendsig. Check carefully to
 660  * make sure that the user has not modified the
 661  * psl to gain improper privileges or to cause
 662  * a machine fault.
 663  */
 664 int
 665 linux_rt_sigreturn(struct thread *td, struct linux_rt_sigreturn_args *args)
 666 {
 667         struct l_ucontext uc;
 668         struct l_sigcontext *context;
 669         sigset_t bmask;
 670         l_stack_t *lss;
 671         stack_t ss;
 672         struct trapframe *regs;
 673         int eflags;
 674         ksiginfo_t ksi;
 675
 676         regs = td->td_frame;
 677
 678 #ifdef DEBUG
 679         if (ldebug(rt_sigreturn))
 680                 printf(ARGS(rt_sigreturn, "%p"), (void *)args->ucp);
 681 #endif
 682         /*
 683          * The trampoline code hands us the ucontext.
 684          * It is unsafe to keep track of it ourselves, in the event that a
 685          * program jumps out of a signal handler.
 686          */
 687         if (copyin(args->ucp, &uc, sizeof(uc)) != 0)
 688                 return (EFAULT);
 689
 690         context = &uc.uc_mcontext;
 691
 692         /*
 693          * Check for security violations.
 694          */
 695 #define EFLAGS_SECURE(ef, oef)  ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
 696         eflags = context->sc_eflags;
 697         if (!EFLAGS_SECURE(eflags, regs->tf_rflags))
 698                 return(EINVAL);
 699
 700         /*
 701          * Don't allow users to load a valid privileged %cs.  Let the
 702          * hardware check for invalid selectors, excess privilege in
 703          * other selectors, invalid %eip's and invalid %esp's.
 704          */
 705 #define CS_SECURE(cs)   (ISPL(cs) == SEL_UPL)
 706         if (!CS_SECURE(context->sc_cs)) {
 707                 ksiginfo_init_trap(&ksi);
 708                 ksi.ksi_signo = SIGBUS;
 709                 ksi.ksi_code = BUS_OBJERR;
 710                 ksi.ksi_trapno = T_PROTFLT;
 711                 ksi.ksi_addr = (void *)regs->tf_rip;
 712                 trapsignal(td, &ksi);
 713                 return(EINVAL);
 714         }
 715
 716         linux_to_bsd_sigset(&uc.uc_sigmask, &bmask);
 717         kern_sigprocmask(td, SIG_SETMASK, &bmask, NULL, 0);
 718
 719         /*
 720          * Restore signal context
 721          */
 722         regs->tf_gs     = context->sc_gs;
 723         regs->tf_fs     = context->sc_fs;
 724         regs->tf_es     = context->sc_es;
 725         regs->tf_ds     = context->sc_ds;
 726         regs->tf_rdi    = context->sc_edi;
 727         regs->tf_rsi    = context->sc_esi;
 728         regs->tf_rbp    = context->sc_ebp;
 729         regs->tf_rbx    = context->sc_ebx;
 730         regs->tf_rdx    = context->sc_edx;
 731         regs->tf_rcx    = context->sc_ecx;
 732         regs->tf_rax    = context->sc_eax;
 733         regs->tf_rip    = context->sc_eip;
 734         regs->tf_cs     = context->sc_cs;
 735         regs->tf_rflags = eflags;
 736         regs->tf_rsp    = context->sc_esp_at_signal;
 737         regs->tf_ss     = context->sc_ss;
 738         set_pcb_flags(td->td_pcb, PCB_FULL_IRET);
 739
 740         /*
 741          * call sigaltstack & ignore results..
 742          */
 743         lss = &uc.uc_stack;
 744         ss.ss_sp = PTRIN(lss->ss_sp);
 745         ss.ss_size = lss->ss_size;
 746         ss.ss_flags = linux_to_bsd_sigaltstack(lss->ss_flags);
 747
 748 #ifdef DEBUG
 749         if (ldebug(rt_sigreturn))
 750                 printf(LMSG("rt_sigret flags: 0x%x, sp: %p, ss: 0x%lx, mask: 0x%x"),
 751                     ss.ss_flags, ss.ss_sp, ss.ss_size, context->sc_mask);
 752 #endif
 753         (void)kern_sigaltstack(td, &ss, NULL);
 754
 755         return (EJUSTRETURN);
 756 }
 757
 758 static int
 759 linux32_fetch_syscall_args(struct thread *td, struct syscall_args *sa)
 760 {
 761         struct proc *p;
 762         struct trapframe *frame;
 763
 764         p = td->td_proc;
 765         frame = td->td_frame;
 766
 767         sa->args[0] = frame->tf_rbx;
 768         sa->args[1] = frame->tf_rcx;
 769         sa->args[2] = frame->tf_rdx;
 770         sa->args[3] = frame->tf_rsi;
 771         sa->args[4] = frame->tf_rdi;
 772         sa->args[5] = frame->tf_rbp;    /* Unconfirmed */
 773         sa->code = frame->tf_rax;
 774
 775         if (sa->code >= p->p_sysent->sv_size)
 776                 sa->callp = &p->p_sysent->sv_table[0];
 777         else
 778                 sa->callp = &p->p_sysent->sv_table[sa->code];
 779         sa->narg = sa->callp->sy_narg;
 780
 781         td->td_retval[0] = 0;
 782         td->td_retval[1] = frame->tf_rdx;
 783
 784         return (0);
 785 }
 786
 787 /*
 788  * If a linux binary is exec'ing something, try this image activator
 789  * first.  We override standard shell script execution in order to
 790  * be able to modify the interpreter path.  We only do this if a linux
 791  * binary is doing the exec, so we do not create an EXEC module for it.
 792  */
 793 static int      exec_linux_imgact_try(struct image_params *iparams);
 794
 795 static int
 796 exec_linux_imgact_try(struct image_params *imgp)
 797 {
 798         const char *head = (const char *)imgp->image_header;
 799         char *rpath;
 800         int error = -1;
 801
 802         /*
 803         * The interpreter for shell scripts run from a linux binary needs
 804         * to be located in /compat/linux if possible in order to recursively
 805         * maintain linux path emulation.
 806         */
 807         if (((const short *)head)[0] == SHELLMAGIC) {
 808                 /*
 809                 * Run our normal shell image activator.  If it succeeds attempt
 810                 * to use the alternate path for the interpreter.  If an
 811                 * alternate * path is found, use our stringspace to store it.
 812                 */
 813                 if ((error = exec_shell_imgact(imgp)) == 0) {
 814                         linux_emul_convpath(FIRST_THREAD_IN_PROC(imgp->proc),
 815                             imgp->interpreter_name, UIO_SYSSPACE, &rpath, 0,
 816                             AT_FDCWD);
 817                         if (rpath != NULL)
 818                                 imgp->args->fname_buf =
 819                                     imgp->interpreter_name = rpath;
 820                 }
 821         }
 822         return (error);
 823 }
 824
 825 /*
 826  * Clear registers on exec
 827  * XXX copied from ia32_signal.c.
 828  */
 829 static void
 830 exec_linux_setregs(struct thread *td, struct image_params *imgp, u_long stack)
 831 {
 832         struct trapframe *regs = td->td_frame;
 833         struct pcb *pcb = td->td_pcb;
 834
 835         mtx_lock(&dt_lock);
 836         if (td->td_proc->p_md.md_ldt != NULL)
 837                 user_ldt_free(td);
 838         else
 839                 mtx_unlock(&dt_lock);
 840
 841         critical_enter();
 842         wrmsr(MSR_FSBASE, 0);
 843         wrmsr(MSR_KGSBASE, 0);  /* User value while we're in the kernel */
 844         pcb->pcb_fsbase = 0;
 845         pcb->pcb_gsbase = 0;
 846         critical_exit();
 847         pcb->pcb_initial_fpucw = __LINUX_NPXCW__;
 848
 849         bzero((char *)regs, sizeof(struct trapframe));
 850         regs->tf_rip = imgp->entry_addr;
 851         regs->tf_rsp = stack;
 852         regs->tf_rflags = PSL_USER | (regs->tf_rflags & PSL_T);
 853         regs->tf_gs = _ugssel;
 854         regs->tf_fs = _ufssel;
 855         regs->tf_es = _udatasel;
 856         regs->tf_ds = _udatasel;
 857         regs->tf_ss = _udatasel;
 858         regs->tf_flags = TF_HASSEGS;
 859         regs->tf_cs = _ucode32sel;
 860         regs->tf_rbx = imgp->ps_strings;
 861
 862         fpstate_drop(td);
 863
 864         /* Do full restore on return so that we can change to a different %cs */
 865         set_pcb_flags(pcb, PCB_32BIT | PCB_FULL_IRET);
 866         td->td_retval[1] = 0;
 867 }
 868
 869 /*
 870  * XXX copied from ia32_sysvec.c.
 871  */
 872 static register_t *
 873 linux_copyout_strings(struct image_params *imgp)
 874 {
 875         int argc, envc;
 876         u_int32_t *vectp;
 877         char *stringp, *destp;
 878         u_int32_t *stack_base;
 879         struct linux32_ps_strings *arginfo;
 880
 881         /*
 882          * Calculate string base and vector table pointers.
 883          * Also deal with signal trampoline code for this exec type.
 884          */
 885         arginfo = (struct linux32_ps_strings *)LINUX32_PS_STRINGS;
 886         destp = (caddr_t)arginfo - SPARE_USRSPACE - linux_szplatform -
 887             roundup((ARG_MAX - imgp->args->stringspace),
 888             sizeof(char *));
 889
 890         /*
 891          * Install LINUX_PLATFORM
 892          */
 893         copyout(linux_platform, ((caddr_t)arginfo - linux_szplatform),
 894             linux_szplatform);
 895
 896         /*
 897          * If we have a valid auxargs ptr, prepare some room
 898          * on the stack.
 899          */
 900         if (imgp->auxargs) {
 901                 /*
 902                  * 'AT_COUNT*2' is size for the ELF Auxargs data. This is for
 903                  * lower compatibility.
 904                  */
 905                 imgp->auxarg_size = (imgp->auxarg_size) ? imgp->auxarg_size :
 906                     (LINUX_AT_COUNT * 2);
 907                 /*
 908                  * The '+ 2' is for the null pointers at the end of each of
 909                  * the arg and env vector sets,and imgp->auxarg_size is room
 910                  * for argument of Runtime loader.
 911                  */
 912                 vectp = (u_int32_t *) (destp - (imgp->args->argc +
 913                     imgp->args->envc + 2 + imgp->auxarg_size) *
 914                     sizeof(u_int32_t));
 915
 916         } else
 917                 /*
 918                  * The '+ 2' is for the null pointers at the end of each of
 919                  * the arg and env vector sets
 920                  */
 921                 vectp = (u_int32_t *)(destp - (imgp->args->argc +
 922                     imgp->args->envc + 2) * sizeof(u_int32_t));
 923
 924         /*
 925          * vectp also becomes our initial stack base
 926          */
 927         stack_base = vectp;
 928
 929         stringp = imgp->args->begin_argv;
 930         argc = imgp->args->argc;
 931         envc = imgp->args->envc;
 932         /*
 933          * Copy out strings - arguments and environment.
 934          */
 935         copyout(stringp, destp, ARG_MAX - imgp->args->stringspace);
 936
 937         /*
 938          * Fill in "ps_strings" struct for ps, w, etc.
 939          */
 940         suword32(&arginfo->ps_argvstr, (uint32_t)(intptr_t)vectp);
 941         suword32(&arginfo->ps_nargvstr, argc);
 942
 943         /*
 944          * Fill in argument portion of vector table.
 945          */
 946         for (; argc > 0; --argc) {
 947                 suword32(vectp++, (uint32_t)(intptr_t)destp);
 948                 while (*stringp++ != 0)
 949                         destp++;
 950                 destp++;
 951         }
 952
 953         /* a null vector table pointer separates the argp's from the envp's */
 954         suword32(vectp++, 0);
 955
 956         suword32(&arginfo->ps_envstr, (uint32_t)(intptr_t)vectp);
 957         suword32(&arginfo->ps_nenvstr, envc);
 958
 959         /*
 960          * Fill in environment portion of vector table.
 961          */
 962         for (; envc > 0; --envc) {
 963                 suword32(vectp++, (uint32_t)(intptr_t)destp);
 964                 while (*stringp++ != 0)
 965                         destp++;
 966                 destp++;
 967         }
 968
 969         /* end of vector table is a null pointer */
 970         suword32(vectp, 0);
 971
 972         return ((register_t *)stack_base);
 973 }
 974
 975 static SYSCTL_NODE(_compat, OID_AUTO, linux32, CTLFLAG_RW, 0,
 976     "32-bit Linux emulation");
 977
 978 static u_long   linux32_maxdsiz = LINUX32_MAXDSIZ;
 979 SYSCTL_ULONG(_compat_linux32, OID_AUTO, maxdsiz, CTLFLAG_RW,
 980     &linux32_maxdsiz, 0, "");
 981 static u_long   linux32_maxssiz = LINUX32_MAXSSIZ;
 982 SYSCTL_ULONG(_compat_linux32, OID_AUTO, maxssiz, CTLFLAG_RW,
 983     &linux32_maxssiz, 0, "");
 984 static u_long   linux32_maxvmem = LINUX32_MAXVMEM;
 985 SYSCTL_ULONG(_compat_linux32, OID_AUTO, maxvmem, CTLFLAG_RW,
 986     &linux32_maxvmem, 0, "");
 987
 988 static void
 989 linux32_fixlimit(struct rlimit *rl, int which)
 990 {
 991
 992         switch (which) {
 993         case RLIMIT_DATA:
 994                 if (linux32_maxdsiz != 0) {
 995                         if (rl->rlim_cur > linux32_maxdsiz)
 996                                 rl->rlim_cur = linux32_maxdsiz;
 997                         if (rl->rlim_max > linux32_maxdsiz)
 998                                 rl->rlim_max = linux32_maxdsiz;
 999                 }
1000                 break;
1001         case RLIMIT_STACK:
1002                 if (linux32_maxssiz != 0) {
1003                         if (rl->rlim_cur > linux32_maxssiz)
1004                                 rl->rlim_cur = linux32_maxssiz;
1005                         if (rl->rlim_max > linux32_maxssiz)
1006                                 rl->rlim_max = linux32_maxssiz;
1007                 }
1008                 break;
1009         case RLIMIT_VMEM:
1010                 if (linux32_maxvmem != 0) {
1011                         if (rl->rlim_cur > linux32_maxvmem)
1012                                 rl->rlim_cur = linux32_maxvmem;
1013                         if (rl->rlim_max > linux32_maxvmem)
1014                                 rl->rlim_max = linux32_maxvmem;
1015                 }
1016                 break;
1017         }
1018 }
1019
1020 struct sysentvec elf_linux_sysvec = {
1021         .sv_size        = LINUX_SYS_MAXSYSCALL,
1022         .sv_table       = linux_sysent,
1023         .sv_mask        = 0,
1024         .sv_sigsize     = LINUX_SIGTBLSZ,
1025         .sv_sigtbl      = bsd_to_linux_signal,
1026         .sv_errsize     = ELAST + 1,
1027         .sv_errtbl      = bsd_to_linux_errno,
1028         .sv_transtrap   = translate_traps,
1029         .sv_fixup       = elf_linux_fixup,
1030         .sv_sendsig     = linux_sendsig,
1031         .sv_sigcode     = &_binary_linux32_locore_o_start,
1032         .sv_szsigcode   = &linux_szsigcode,
1033         .sv_prepsyscall = NULL,
1034         .sv_name        = "Linux ELF32",
1035         .sv_coredump    = elf32_coredump,
1036         .sv_imgact_try  = exec_linux_imgact_try,
1037         .sv_minsigstksz = LINUX_MINSIGSTKSZ,
1038         .sv_pagesize    = PAGE_SIZE,
1039         .sv_minuser     = VM_MIN_ADDRESS,
1040         .sv_maxuser     = LINUX32_MAXUSER,
1041         .sv_usrstack    = LINUX32_USRSTACK,
1042         .sv_psstrings   = LINUX32_PS_STRINGS,
1043         .sv_stackprot   = VM_PROT_ALL,
1044         .sv_copyout_strings = linux_copyout_strings,
1045         .sv_setregs     = exec_linux_setregs,
1046         .sv_fixlimit    = linux32_fixlimit,
1047         .sv_maxssiz     = &linux32_maxssiz,
1048         .sv_flags       = SV_ABI_LINUX | SV_ILP32 | SV_IA32 | SV_SHP,
1049         .sv_set_syscall_retval = cpu_set_syscall_retval,
1050         .sv_fetch_syscall_args = linux32_fetch_syscall_args,
1051         .sv_syscallnames = NULL,
1052         .sv_shared_page_base = LINUX32_SHAREDPAGE,
1053         .sv_shared_page_len = PAGE_SIZE,
1054         .sv_schedtail   = linux_schedtail,
1055         .sv_thread_detach = linux_thread_detach,
1056 };
1057
1058 static void
1059 linux_vdso_install(void *param)
1060 {
1061
1062         linux_szsigcode = (&_binary_linux32_locore_o_end -
1063             &_binary_linux32_locore_o_start);
1064
1065         if (linux_szsigcode > elf_linux_sysvec.sv_shared_page_len)
1066                 panic("Linux invalid vdso size\n");
1067
1068         __elfN(linux_vdso_fixup)(&elf_linux_sysvec);
1069
1070         linux_shared_page_obj = __elfN(linux_shared_page_init)
1071             (&linux_shared_page_mapping);
1072
1073         __elfN(linux_vdso_reloc)(&elf_linux_sysvec, LINUX32_SHAREDPAGE);
1074
1075         bcopy(elf_linux_sysvec.sv_sigcode, linux_shared_page_mapping,
1076             linux_szsigcode);
1077         elf_linux_sysvec.sv_shared_page_obj = linux_shared_page_obj;
1078 }
1079 SYSINIT(elf_linux_vdso_init, SI_SUB_EXEC, SI_ORDER_ANY,
1080     (sysinit_cfunc_t)linux_vdso_install, NULL);
1081
1082 static void
1083 linux_vdso_deinstall(void *param)
1084 {
1085
1086         __elfN(linux_shared_page_fini)(linux_shared_page_obj);
1087 };
1088 SYSUNINIT(elf_linux_vdso_uninit, SI_SUB_EXEC, SI_ORDER_FIRST,
1089     (sysinit_cfunc_t)linux_vdso_deinstall, NULL);
1090
1091 static char GNU_ABI_VENDOR[] = "GNU";
1092 static int GNULINUX_ABI_DESC = 0;
1093
1094 static boolean_t
1095 linux32_trans_osrel(const Elf_Note *note, int32_t *osrel)
1096 {
1097         const Elf32_Word *desc;
1098         uintptr_t p;
1099
1100         p = (uintptr_t)(note + 1);
1101         p += roundup2(note->n_namesz, sizeof(Elf32_Addr));
1102
1103         desc = (const Elf32_Word *)p;
1104         if (desc[0] != GNULINUX_ABI_DESC)
1105                 return (FALSE);
1106
1107         /*
1108          * For linux we encode osrel as follows (see linux_mib.c):
1109          * VVVMMMIII (version, major, minor), see linux_mib.c.
1110          */
1111         *osrel = desc[1] * 1000000 + desc[2] * 1000 + desc[3];
1112
1113         return (TRUE);
1114 }
1115
1116 static Elf_Brandnote linux32_brandnote = {
1117         .hdr.n_namesz   = sizeof(GNU_ABI_VENDOR),
1118         .hdr.n_descsz   = 16,   /* XXX at least 16 */
1119         .hdr.n_type     = 1,
1120         .vendor         = GNU_ABI_VENDOR,
1121         .flags          = BN_TRANSLATE_OSREL,
1122         .trans_osrel    = linux32_trans_osrel
1123 };
1124
1125 static Elf32_Brandinfo linux_brand = {
1126         .brand          = ELFOSABI_LINUX,
1127         .machine        = EM_386,
1128         .compat_3_brand = "Linux",
1129         .emul_path      = "/compat/linux",
1130         .interp_path    = "/lib/ld-linux.so.1",
1131         .sysvec         = &elf_linux_sysvec,
1132         .interp_newpath = NULL,
1133         .brand_note     = &linux32_brandnote,
1134         .flags          = BI_CAN_EXEC_DYN | BI_BRAND_NOTE
1135 };
1136
1137 static Elf32_Brandinfo linux_glibc2brand = {
1138         .brand          = ELFOSABI_LINUX,
1139         .machine        = EM_386,
1140         .compat_3_brand = "Linux",
1141         .emul_path      = "/compat/linux",
1142         .interp_path    = "/lib/ld-linux.so.2",
1143         .sysvec         = &elf_linux_sysvec,
1144         .interp_newpath = NULL,
1145         .brand_note     = &linux32_brandnote,
1146         .flags          = BI_CAN_EXEC_DYN | BI_BRAND_NOTE
1147 };
1148
1149 Elf32_Brandinfo *linux_brandlist[] = {
1150         &linux_brand,
1151         &linux_glibc2brand,
1152         NULL
1153 };
1154
1155 static int
1156 linux_elf_modevent(module_t mod, int type, void *data)
1157 {
1158         Elf32_Brandinfo **brandinfo;
1159         int error;
1160         struct linux_ioctl_handler **lihp;
1161         struct linux_device_handler **ldhp;
1162
1163         error = 0;
1164
1165         switch(type) {
1166         case MOD_LOAD:
1167                 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
1168                      ++brandinfo)
1169                         if (elf32_insert_brand_entry(*brandinfo) < 0)
1170                                 error = EINVAL;
1171                 if (error == 0) {
1172                         SET_FOREACH(lihp, linux_ioctl_handler_set)
1173                                 linux_ioctl_register_handler(*lihp);
1174                         SET_FOREACH(ldhp, linux_device_handler_set)
1175                                 linux_device_register_handler(*ldhp);
1176                         LIST_INIT(&futex_list);
1177                         mtx_init(&futex_mtx, "ftllk", NULL, MTX_DEF);
1178                         linux_exit_tag = EVENTHANDLER_REGISTER(process_exit,
1179                             linux_proc_exit, NULL, 1000);
1180                         linux_exec_tag = EVENTHANDLER_REGISTER(process_exec,
1181                             linux_proc_exec, NULL, 1000);
1182                         linux_thread_dtor_tag = EVENTHANDLER_REGISTER(thread_dtor,
1183                             linux_thread_dtor, NULL, EVENTHANDLER_PRI_ANY);
1184                         linux_szplatform = roundup(strlen(linux_platform) + 1,
1185                             sizeof(char *));
1186                         linux_osd_jail_register();
1187                         stclohz = (stathz ? stathz : hz);
1188                         if (bootverbose)
1189                                 printf("Linux ELF exec handler installed\n");
1190                 } else
1191                         printf("cannot insert Linux ELF brand handler\n");
1192                 break;
1193         case MOD_UNLOAD:
1194                 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
1195                      ++brandinfo)
1196                         if (elf32_brand_inuse(*brandinfo))
1197                                 error = EBUSY;
1198                 if (error == 0) {
1199                         for (brandinfo = &linux_brandlist[0];
1200                              *brandinfo != NULL; ++brandinfo)
1201                                 if (elf32_remove_brand_entry(*brandinfo) < 0)
1202                                         error = EINVAL;
1203                 }
1204                 if (error == 0) {
1205                         SET_FOREACH(lihp, linux_ioctl_handler_set)
1206                                 linux_ioctl_unregister_handler(*lihp);
1207                         SET_FOREACH(ldhp, linux_device_handler_set)
1208                                 linux_device_unregister_handler(*ldhp);
1209                         mtx_destroy(&futex_mtx);
1210                         EVENTHANDLER_DEREGISTER(process_exit, linux_exit_tag);
1211                         EVENTHANDLER_DEREGISTER(process_exec, linux_exec_tag);
1212                         EVENTHANDLER_DEREGISTER(thread_dtor, linux_thread_dtor_tag);
1213                         linux_osd_jail_deregister();
1214                         if (bootverbose)
1215                                 printf("Linux ELF exec handler removed\n");
1216                 } else
1217                         printf("Could not deinstall ELF interpreter entry\n");
1218                 break;
1219         default:
1220                 return (EOPNOTSUPP);
1221         }
1222         return (error);
1223 }
1224
1225 static moduledata_t linux_elf_mod = {
1226         "linuxelf",
1227         linux_elf_modevent,
1228         0
1229 };
1230
1231 DECLARE_MODULE_TIED(linuxelf, linux_elf_mod, SI_SUB_EXEC, SI_ORDER_ANY);