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