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