sys/i386/linux/linux_sysvec.c

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