The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/i386/linux/linux_sysvec.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    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: stable/9/sys/i386/linux/linux_sysvec.c 294903 2016-01-27 07:34:23Z delphij $");
   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_emul.h>
   68 #include <compat/linux/linux_futex.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 #define LINUX_PS_STRINGS        (LINUX_USRSTACK - sizeof(struct ps_strings))
   94 
   95 extern char linux_sigcode[];
   96 extern int linux_szsigcode;
   97 
   98 extern struct sysent linux_sysent[LINUX_SYS_MAXSYSCALL];
   99 
  100 SET_DECLARE(linux_ioctl_handler_set, struct linux_ioctl_handler);
  101 SET_DECLARE(linux_device_handler_set, struct linux_device_handler);
  102 
  103 static int      linux_fixup(register_t **stack_base,
  104                     struct image_params *iparams);
  105 static int      elf_linux_fixup(register_t **stack_base,
  106                     struct image_params *iparams);
  107 static void     linux_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask);
  108 static void     exec_linux_setregs(struct thread *td,
  109                     struct image_params *imgp, u_long stack);
  110 static register_t *linux_copyout_strings(struct image_params *imgp);
  111 static boolean_t linux_trans_osrel(const Elf_Note *note, int32_t *osrel);
  112 
  113 static int linux_szplatform;
  114 const char *linux_platform;
  115 
  116 static eventhandler_tag linux_exit_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         suword(*stack_base, (intptr_t)(void *)envp);
  231         (*stack_base)--;
  232         suword(*stack_base, (intptr_t)(void *)argv);
  233         (*stack_base)--;
  234         suword(*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         int issetugid;
  247 
  248         KASSERT(curthread->td_proc == imgp->proc,
  249             ("unsafe elf_linux_fixup(), should be curproc"));
  250 
  251         p = imgp->proc;
  252         issetugid = imgp->proc->p_flag & P_SUGID ? 1 : 0;
  253         arginfo = (struct ps_strings *)p->p_sysent->sv_psstrings;
  254         uplatform = (Elf32_Addr *)((caddr_t)arginfo - linux_szplatform);
  255         args = (Elf32_Auxargs *)imgp->auxargs;
  256         pos = *stack_base + (imgp->args->argc + imgp->args->envc + 2);
  257 
  258         AUXARGS_ENTRY(pos, LINUX_AT_HWCAP, cpu_feature);
  259 
  260         /*
  261          * Do not export AT_CLKTCK when emulating Linux kernel prior to 2.4.0,
  262          * as it has appeared in the 2.4.0-rc7 first time.
  263          * Being exported, AT_CLKTCK is returned by sysconf(_SC_CLK_TCK),
  264          * glibc falls back to the hard-coded CLK_TCK value when aux entry
  265          * is not present.
  266          * Also see linux_times() implementation.
  267          */
  268         if (linux_kernver(curthread) >= LINUX_KERNVER_2004000)
  269                 AUXARGS_ENTRY(pos, LINUX_AT_CLKTCK, stclohz);
  270         AUXARGS_ENTRY(pos, AT_PHDR, args->phdr);
  271         AUXARGS_ENTRY(pos, AT_PHENT, args->phent);
  272         AUXARGS_ENTRY(pos, AT_PHNUM, args->phnum);
  273         AUXARGS_ENTRY(pos, AT_PAGESZ, args->pagesz);
  274         AUXARGS_ENTRY(pos, AT_FLAGS, args->flags);
  275         AUXARGS_ENTRY(pos, AT_ENTRY, args->entry);
  276         AUXARGS_ENTRY(pos, AT_BASE, args->base);
  277         AUXARGS_ENTRY(pos, LINUX_AT_SECURE, issetugid);
  278         AUXARGS_ENTRY(pos, AT_UID, imgp->proc->p_ucred->cr_ruid);
  279         AUXARGS_ENTRY(pos, AT_EUID, imgp->proc->p_ucred->cr_svuid);
  280         AUXARGS_ENTRY(pos, AT_GID, imgp->proc->p_ucred->cr_rgid);
  281         AUXARGS_ENTRY(pos, AT_EGID, imgp->proc->p_ucred->cr_svgid);
  282         AUXARGS_ENTRY(pos, LINUX_AT_PLATFORM, PTROUT(uplatform));
  283         if (args->execfd != -1)
  284                 AUXARGS_ENTRY(pos, AT_EXECFD, args->execfd);
  285         AUXARGS_ENTRY(pos, AT_NULL, 0);
  286 
  287         free(imgp->auxargs, M_TEMP);
  288         imgp->auxargs = NULL;
  289 
  290         (*stack_base)--;
  291         suword(*stack_base, (register_t)imgp->args->argc);
  292         return (0);
  293 }
  294 
  295 /*
  296  * Copied from kern/kern_exec.c
  297  */
  298 static register_t *
  299 linux_copyout_strings(struct image_params *imgp)
  300 {
  301         int argc, envc;
  302         char **vectp;
  303         char *stringp, *destp;
  304         register_t *stack_base;
  305         struct ps_strings *arginfo;
  306         struct proc *p;
  307 
  308         /*
  309          * Calculate string base and vector table pointers.
  310          * Also deal with signal trampoline code for this exec type.
  311          */
  312         p = imgp->proc;
  313         arginfo = (struct ps_strings *)p->p_sysent->sv_psstrings;
  314         destp = (caddr_t)arginfo - SPARE_USRSPACE - linux_szplatform -
  315             roundup((ARG_MAX - imgp->args->stringspace), sizeof(char *));
  316 
  317         /*
  318          * install LINUX_PLATFORM
  319          */
  320         copyout(linux_platform, ((caddr_t)arginfo - linux_szplatform),
  321             linux_szplatform);
  322 
  323         /*
  324          * If we have a valid auxargs ptr, prepare some room
  325          * on the stack.
  326          */
  327         if (imgp->auxargs) {
  328                 /*
  329                  * 'AT_COUNT*2' is size for the ELF Auxargs data. This is for
  330                  * lower compatibility.
  331                  */
  332                 imgp->auxarg_size = (imgp->auxarg_size) ? imgp->auxarg_size :
  333                     (LINUX_AT_COUNT * 2);
  334                 /*
  335                  * The '+ 2' is for the null pointers at the end of each of
  336                  * the arg and env vector sets,and imgp->auxarg_size is room
  337                  * for argument of Runtime loader.
  338                  */
  339                 vectp = (char **)(destp - (imgp->args->argc +
  340                     imgp->args->envc + 2 + imgp->auxarg_size) * sizeof(char *));
  341         } else {
  342                 /*
  343                  * The '+ 2' is for the null pointers at the end of each of
  344                  * the arg and env vector sets
  345                  */
  346                 vectp = (char **)(destp - (imgp->args->argc + imgp->args->envc + 2) *
  347                     sizeof(char *));
  348         }
  349 
  350         /*
  351          * vectp also becomes our initial stack base
  352          */
  353         stack_base = (register_t *)vectp;
  354 
  355         stringp = imgp->args->begin_argv;
  356         argc = imgp->args->argc;
  357         envc = imgp->args->envc;
  358 
  359         /*
  360          * Copy out strings - arguments and environment.
  361          */
  362         copyout(stringp, destp, ARG_MAX - imgp->args->stringspace);
  363 
  364         /*
  365          * Fill in "ps_strings" struct for ps, w, etc.
  366          */
  367         suword(&arginfo->ps_argvstr, (long)(intptr_t)vectp);
  368         suword(&arginfo->ps_nargvstr, argc);
  369 
  370         /*
  371          * Fill in argument portion of vector table.
  372          */
  373         for (; argc > 0; --argc) {
  374                 suword(vectp++, (long)(intptr_t)destp);
  375                 while (*stringp++ != 0)
  376                         destp++;
  377                 destp++;
  378         }
  379 
  380         /* a null vector table pointer separates the argp's from the envp's */
  381         suword(vectp++, 0);
  382 
  383         suword(&arginfo->ps_envstr, (long)(intptr_t)vectp);
  384         suword(&arginfo->ps_nenvstr, envc);
  385 
  386         /*
  387          * Fill in environment portion of vector table.
  388          */
  389         for (; envc > 0; --envc) {
  390                 suword(vectp++, (long)(intptr_t)destp);
  391                 while (*stringp++ != 0)
  392                         destp++;
  393                 destp++;
  394         }
  395 
  396         /* end of vector table is a null pointer */
  397         suword(vectp, 0);
  398 
  399         return (stack_base);
  400 }
  401 
  402 
  403 
  404 extern int _ucodesel, _udatasel;
  405 extern unsigned long linux_sznonrtsigcode;
  406 
  407 static void
  408 linux_rt_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
  409 {
  410         struct thread *td = curthread;
  411         struct proc *p = td->td_proc;
  412         struct sigacts *psp;
  413         struct trapframe *regs;
  414         struct l_rt_sigframe *fp, frame;
  415         int sig, code;
  416         int oonstack;
  417 
  418         sig = ksi->ksi_signo;
  419         code = ksi->ksi_code;   
  420         PROC_LOCK_ASSERT(p, MA_OWNED);
  421         psp = p->p_sigacts;
  422         mtx_assert(&psp->ps_mtx, MA_OWNED);
  423         regs = td->td_frame;
  424         oonstack = sigonstack(regs->tf_esp);
  425 
  426 #ifdef DEBUG
  427         if (ldebug(rt_sendsig))
  428                 printf(ARGS(rt_sendsig, "%p, %d, %p, %u"),
  429                     catcher, sig, (void*)mask, code);
  430 #endif
  431         /*
  432          * Allocate space for the signal handler context.
  433          */
  434         if ((td->td_pflags & TDP_ALTSTACK) && !oonstack &&
  435             SIGISMEMBER(psp->ps_sigonstack, sig)) {
  436                 fp = (struct l_rt_sigframe *)(td->td_sigstk.ss_sp +
  437                     td->td_sigstk.ss_size - sizeof(struct l_rt_sigframe));
  438         } else
  439                 fp = (struct l_rt_sigframe *)regs->tf_esp - 1;
  440         mtx_unlock(&psp->ps_mtx);
  441 
  442         /*
  443          * Build the argument list for the signal handler.
  444          */
  445         if (p->p_sysent->sv_sigtbl)
  446                 if (sig <= p->p_sysent->sv_sigsize)
  447                         sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
  448 
  449         bzero(&frame, sizeof(frame));
  450 
  451         frame.sf_handler = catcher;
  452         frame.sf_sig = sig;
  453         frame.sf_siginfo = &fp->sf_si;
  454         frame.sf_ucontext = &fp->sf_sc;
  455 
  456         /* Fill in POSIX parts */
  457         ksiginfo_to_lsiginfo(ksi, &frame.sf_si, sig);
  458 
  459         /*
  460          * Build the signal context to be used by sigreturn.
  461          */
  462         frame.sf_sc.uc_flags = 0;               /* XXX ??? */
  463         frame.sf_sc.uc_link = NULL;             /* XXX ??? */
  464 
  465         frame.sf_sc.uc_stack.ss_sp = td->td_sigstk.ss_sp;
  466         frame.sf_sc.uc_stack.ss_size = td->td_sigstk.ss_size;
  467         frame.sf_sc.uc_stack.ss_flags = (td->td_pflags & TDP_ALTSTACK)
  468             ? ((oonstack) ? LINUX_SS_ONSTACK : 0) : LINUX_SS_DISABLE;
  469         PROC_UNLOCK(p);
  470 
  471         bsd_to_linux_sigset(mask, &frame.sf_sc.uc_sigmask);
  472 
  473         frame.sf_sc.uc_mcontext.sc_mask   = frame.sf_sc.uc_sigmask.__bits[0];
  474         frame.sf_sc.uc_mcontext.sc_gs     = rgs();
  475         frame.sf_sc.uc_mcontext.sc_fs     = regs->tf_fs;
  476         frame.sf_sc.uc_mcontext.sc_es     = regs->tf_es;
  477         frame.sf_sc.uc_mcontext.sc_ds     = regs->tf_ds;
  478         frame.sf_sc.uc_mcontext.sc_edi    = regs->tf_edi;
  479         frame.sf_sc.uc_mcontext.sc_esi    = regs->tf_esi;
  480         frame.sf_sc.uc_mcontext.sc_ebp    = regs->tf_ebp;
  481         frame.sf_sc.uc_mcontext.sc_ebx    = regs->tf_ebx;
  482         frame.sf_sc.uc_mcontext.sc_edx    = regs->tf_edx;
  483         frame.sf_sc.uc_mcontext.sc_ecx    = regs->tf_ecx;
  484         frame.sf_sc.uc_mcontext.sc_eax    = regs->tf_eax;
  485         frame.sf_sc.uc_mcontext.sc_eip    = regs->tf_eip;
  486         frame.sf_sc.uc_mcontext.sc_cs     = regs->tf_cs;
  487         frame.sf_sc.uc_mcontext.sc_eflags = regs->tf_eflags;
  488         frame.sf_sc.uc_mcontext.sc_esp_at_signal = regs->tf_esp;
  489         frame.sf_sc.uc_mcontext.sc_ss     = regs->tf_ss;
  490         frame.sf_sc.uc_mcontext.sc_err    = regs->tf_err;
  491         frame.sf_sc.uc_mcontext.sc_cr2    = (register_t)ksi->ksi_addr;
  492         frame.sf_sc.uc_mcontext.sc_trapno = bsd_to_linux_trapcode(code);
  493 
  494 #ifdef DEBUG
  495         if (ldebug(rt_sendsig))
  496                 printf(LMSG("rt_sendsig flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
  497                     frame.sf_sc.uc_stack.ss_flags, td->td_sigstk.ss_sp,
  498                     td->td_sigstk.ss_size, frame.sf_sc.uc_mcontext.sc_mask);
  499 #endif
  500 
  501         if (copyout(&frame, fp, sizeof(frame)) != 0) {
  502                 /*
  503                  * Process has trashed its stack; give it an illegal
  504                  * instruction to halt it in its tracks.
  505                  */
  506 #ifdef DEBUG
  507                 if (ldebug(rt_sendsig))
  508                         printf(LMSG("rt_sendsig: bad stack %p, oonstack=%x"),
  509                             fp, oonstack);
  510 #endif
  511                 PROC_LOCK(p);
  512                 sigexit(td, SIGILL);
  513         }
  514 
  515         /*
  516          * Build context to run handler in.
  517          */
  518         regs->tf_esp = (int)fp;
  519         regs->tf_eip = p->p_sysent->sv_sigcode_base + linux_sznonrtsigcode;
  520         regs->tf_eflags &= ~(PSL_T | PSL_VM | PSL_D);
  521         regs->tf_cs = _ucodesel;
  522         regs->tf_ds = _udatasel;
  523         regs->tf_es = _udatasel;
  524         regs->tf_fs = _udatasel;
  525         regs->tf_ss = _udatasel;
  526         PROC_LOCK(p);
  527         mtx_lock(&psp->ps_mtx);
  528 }
  529 
  530 
  531 /*
  532  * Send an interrupt to process.
  533  *
  534  * Stack is set up to allow sigcode stored
  535  * in u. to call routine, followed by kcall
  536  * to sigreturn routine below.  After sigreturn
  537  * resets the signal mask, the stack, and the
  538  * frame pointer, it returns to the user
  539  * specified pc, psl.
  540  */
  541 static void
  542 linux_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
  543 {
  544         struct thread *td = curthread;
  545         struct proc *p = td->td_proc;
  546         struct sigacts *psp;
  547         struct trapframe *regs;
  548         struct l_sigframe *fp, frame;
  549         l_sigset_t lmask;
  550         int sig, code;
  551         int oonstack, i;
  552 
  553         PROC_LOCK_ASSERT(p, MA_OWNED);
  554         psp = p->p_sigacts;
  555         sig = ksi->ksi_signo;
  556         code = ksi->ksi_code;
  557         mtx_assert(&psp->ps_mtx, MA_OWNED);
  558         if (SIGISMEMBER(psp->ps_siginfo, sig)) {
  559                 /* Signal handler installed with SA_SIGINFO. */
  560                 linux_rt_sendsig(catcher, ksi, mask);
  561                 return;
  562         }
  563         regs = td->td_frame;
  564         oonstack = sigonstack(regs->tf_esp);
  565 
  566 #ifdef DEBUG
  567         if (ldebug(sendsig))
  568                 printf(ARGS(sendsig, "%p, %d, %p, %u"),
  569                     catcher, sig, (void*)mask, code);
  570 #endif
  571 
  572         /*
  573          * Allocate space for the signal handler context.
  574          */
  575         if ((td->td_pflags & TDP_ALTSTACK) && !oonstack &&
  576             SIGISMEMBER(psp->ps_sigonstack, sig)) {
  577                 fp = (struct l_sigframe *)(td->td_sigstk.ss_sp +
  578                     td->td_sigstk.ss_size - sizeof(struct l_sigframe));
  579         } else
  580                 fp = (struct l_sigframe *)regs->tf_esp - 1;
  581         mtx_unlock(&psp->ps_mtx);
  582         PROC_UNLOCK(p);
  583 
  584         /*
  585          * Build the argument list for the signal handler.
  586          */
  587         if (p->p_sysent->sv_sigtbl)
  588                 if (sig <= p->p_sysent->sv_sigsize)
  589                         sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
  590 
  591         bzero(&frame, sizeof(frame));
  592 
  593         frame.sf_handler = catcher;
  594         frame.sf_sig = sig;
  595 
  596         bsd_to_linux_sigset(mask, &lmask);
  597 
  598         /*
  599          * Build the signal context to be used by sigreturn.
  600          */
  601         frame.sf_sc.sc_mask   = lmask.__bits[0];
  602         frame.sf_sc.sc_gs     = rgs();
  603         frame.sf_sc.sc_fs     = regs->tf_fs;
  604         frame.sf_sc.sc_es     = regs->tf_es;
  605         frame.sf_sc.sc_ds     = regs->tf_ds;
  606         frame.sf_sc.sc_edi    = regs->tf_edi;
  607         frame.sf_sc.sc_esi    = regs->tf_esi;
  608         frame.sf_sc.sc_ebp    = regs->tf_ebp;
  609         frame.sf_sc.sc_ebx    = regs->tf_ebx;
  610         frame.sf_sc.sc_edx    = regs->tf_edx;
  611         frame.sf_sc.sc_ecx    = regs->tf_ecx;
  612         frame.sf_sc.sc_eax    = regs->tf_eax;
  613         frame.sf_sc.sc_eip    = regs->tf_eip;
  614         frame.sf_sc.sc_cs     = regs->tf_cs;
  615         frame.sf_sc.sc_eflags = regs->tf_eflags;
  616         frame.sf_sc.sc_esp_at_signal = regs->tf_esp;
  617         frame.sf_sc.sc_ss     = regs->tf_ss;
  618         frame.sf_sc.sc_err    = regs->tf_err;
  619         frame.sf_sc.sc_cr2    = (register_t)ksi->ksi_addr;
  620         frame.sf_sc.sc_trapno = bsd_to_linux_trapcode(ksi->ksi_trapno);
  621 
  622         for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
  623                 frame.sf_extramask[i] = lmask.__bits[i+1];
  624 
  625         if (copyout(&frame, fp, sizeof(frame)) != 0) {
  626                 /*
  627                  * Process has trashed its stack; give it an illegal
  628                  * instruction to halt it in its tracks.
  629                  */
  630                 PROC_LOCK(p);
  631                 sigexit(td, SIGILL);
  632         }
  633 
  634         /*
  635          * Build context to run handler in.
  636          */
  637         regs->tf_esp = (int)fp;
  638         regs->tf_eip = p->p_sysent->sv_sigcode_base;
  639         regs->tf_eflags &= ~(PSL_T | PSL_VM | PSL_D);
  640         regs->tf_cs = _ucodesel;
  641         regs->tf_ds = _udatasel;
  642         regs->tf_es = _udatasel;
  643         regs->tf_fs = _udatasel;
  644         regs->tf_ss = _udatasel;
  645         PROC_LOCK(p);
  646         mtx_lock(&psp->ps_mtx);
  647 }
  648 
  649 /*
  650  * System call to cleanup state after a signal
  651  * has been taken.  Reset signal mask and
  652  * stack state from context left by sendsig (above).
  653  * Return to previous pc and psl as specified by
  654  * context left by sendsig. Check carefully to
  655  * make sure that the user has not modified the
  656  * psl to gain improper privileges or to cause
  657  * a machine fault.
  658  */
  659 int
  660 linux_sigreturn(struct thread *td, struct linux_sigreturn_args *args)
  661 {
  662         struct l_sigframe frame;
  663         struct trapframe *regs;
  664         l_sigset_t lmask;
  665         sigset_t bmask;
  666         int eflags, i;
  667         ksiginfo_t ksi;
  668 
  669         regs = td->td_frame;
  670 
  671 #ifdef DEBUG
  672         if (ldebug(sigreturn))
  673                 printf(ARGS(sigreturn, "%p"), (void *)args->sfp);
  674 #endif
  675         /*
  676          * The trampoline code hands us the sigframe.
  677          * It is unsafe to keep track of it ourselves, in the event that a
  678          * program jumps out of a signal handler.
  679          */
  680         if (copyin(args->sfp, &frame, sizeof(frame)) != 0)
  681                 return (EFAULT);
  682 
  683         /*
  684          * Check for security violations.
  685          */
  686 #define EFLAGS_SECURE(ef, oef)  ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
  687         eflags = frame.sf_sc.sc_eflags;
  688         if (!EFLAGS_SECURE(eflags, regs->tf_eflags))
  689                 return(EINVAL);
  690 
  691         /*
  692          * Don't allow users to load a valid privileged %cs.  Let the
  693          * hardware check for invalid selectors, excess privilege in
  694          * other selectors, invalid %eip's and invalid %esp's.
  695          */
  696 #define CS_SECURE(cs)   (ISPL(cs) == SEL_UPL)
  697         if (!CS_SECURE(frame.sf_sc.sc_cs)) {
  698                 ksiginfo_init_trap(&ksi);
  699                 ksi.ksi_signo = SIGBUS;
  700                 ksi.ksi_code = BUS_OBJERR;
  701                 ksi.ksi_trapno = T_PROTFLT;
  702                 ksi.ksi_addr = (void *)regs->tf_eip;
  703                 trapsignal(td, &ksi);
  704                 return(EINVAL);
  705         }
  706 
  707         lmask.__bits[0] = frame.sf_sc.sc_mask;
  708         for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
  709                 lmask.__bits[i+1] = frame.sf_extramask[i];
  710         linux_to_bsd_sigset(&lmask, &bmask);
  711         kern_sigprocmask(td, SIG_SETMASK, &bmask, NULL, 0);
  712 
  713         /*
  714          * Restore signal context.
  715          */
  716         /* %gs was restored by the trampoline. */
  717         regs->tf_fs     = frame.sf_sc.sc_fs;
  718         regs->tf_es     = frame.sf_sc.sc_es;
  719         regs->tf_ds     = frame.sf_sc.sc_ds;
  720         regs->tf_edi    = frame.sf_sc.sc_edi;
  721         regs->tf_esi    = frame.sf_sc.sc_esi;
  722         regs->tf_ebp    = frame.sf_sc.sc_ebp;
  723         regs->tf_ebx    = frame.sf_sc.sc_ebx;
  724         regs->tf_edx    = frame.sf_sc.sc_edx;
  725         regs->tf_ecx    = frame.sf_sc.sc_ecx;
  726         regs->tf_eax    = frame.sf_sc.sc_eax;
  727         regs->tf_eip    = frame.sf_sc.sc_eip;
  728         regs->tf_cs     = frame.sf_sc.sc_cs;
  729         regs->tf_eflags = eflags;
  730         regs->tf_esp    = frame.sf_sc.sc_esp_at_signal;
  731         regs->tf_ss     = frame.sf_sc.sc_ss;
  732 
  733         return (EJUSTRETURN);
  734 }
  735 
  736 /*
  737  * System call to cleanup state after a signal
  738  * has been taken.  Reset signal mask and
  739  * stack state from context left by rt_sendsig (above).
  740  * Return to previous pc and psl as specified by
  741  * context left by sendsig. Check carefully to
  742  * make sure that the user has not modified the
  743  * psl to gain improper privileges or to cause
  744  * a machine fault.
  745  */
  746 int
  747 linux_rt_sigreturn(struct thread *td, struct linux_rt_sigreturn_args *args)
  748 {
  749         struct l_ucontext uc;
  750         struct l_sigcontext *context;
  751         sigset_t bmask;
  752         l_stack_t *lss;
  753         stack_t ss;
  754         struct trapframe *regs;
  755         int eflags;
  756         ksiginfo_t ksi;
  757 
  758         regs = td->td_frame;
  759 
  760 #ifdef DEBUG
  761         if (ldebug(rt_sigreturn))
  762                 printf(ARGS(rt_sigreturn, "%p"), (void *)args->ucp);
  763 #endif
  764         /*
  765          * The trampoline code hands us the ucontext.
  766          * It is unsafe to keep track of it ourselves, in the event that a
  767          * program jumps out of a signal handler.
  768          */
  769         if (copyin(args->ucp, &uc, sizeof(uc)) != 0)
  770                 return (EFAULT);
  771 
  772         context = &uc.uc_mcontext;
  773 
  774         /*
  775          * Check for security violations.
  776          */
  777 #define EFLAGS_SECURE(ef, oef)  ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
  778         eflags = context->sc_eflags;
  779         if (!EFLAGS_SECURE(eflags, regs->tf_eflags))
  780                 return(EINVAL);
  781 
  782         /*
  783          * Don't allow users to load a valid privileged %cs.  Let the
  784          * hardware check for invalid selectors, excess privilege in
  785          * other selectors, invalid %eip's and invalid %esp's.
  786          */
  787 #define CS_SECURE(cs)   (ISPL(cs) == SEL_UPL)
  788         if (!CS_SECURE(context->sc_cs)) {
  789                 ksiginfo_init_trap(&ksi);
  790                 ksi.ksi_signo = SIGBUS;
  791                 ksi.ksi_code = BUS_OBJERR;
  792                 ksi.ksi_trapno = T_PROTFLT;
  793                 ksi.ksi_addr = (void *)regs->tf_eip;
  794                 trapsignal(td, &ksi);
  795                 return(EINVAL);
  796         }
  797 
  798         linux_to_bsd_sigset(&uc.uc_sigmask, &bmask);
  799         kern_sigprocmask(td, SIG_SETMASK, &bmask, NULL, 0);
  800 
  801         /*
  802          * Restore signal context
  803          */
  804         /* %gs was restored by the trampoline. */
  805         regs->tf_fs     = context->sc_fs;
  806         regs->tf_es     = context->sc_es;
  807         regs->tf_ds     = context->sc_ds;
  808         regs->tf_edi    = context->sc_edi;
  809         regs->tf_esi    = context->sc_esi;
  810         regs->tf_ebp    = context->sc_ebp;
  811         regs->tf_ebx    = context->sc_ebx;
  812         regs->tf_edx    = context->sc_edx;
  813         regs->tf_ecx    = context->sc_ecx;
  814         regs->tf_eax    = context->sc_eax;
  815         regs->tf_eip    = context->sc_eip;
  816         regs->tf_cs     = context->sc_cs;
  817         regs->tf_eflags = eflags;
  818         regs->tf_esp    = context->sc_esp_at_signal;
  819         regs->tf_ss     = context->sc_ss;
  820 
  821         /*
  822          * call sigaltstack & ignore results..
  823          */
  824         lss = &uc.uc_stack;
  825         ss.ss_sp = lss->ss_sp;
  826         ss.ss_size = lss->ss_size;
  827         ss.ss_flags = linux_to_bsd_sigaltstack(lss->ss_flags);
  828 
  829 #ifdef DEBUG
  830         if (ldebug(rt_sigreturn))
  831                 printf(LMSG("rt_sigret flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
  832                     ss.ss_flags, ss.ss_sp, ss.ss_size, context->sc_mask);
  833 #endif
  834         (void)kern_sigaltstack(td, &ss, NULL);
  835 
  836         return (EJUSTRETURN);
  837 }
  838 
  839 static int
  840 linux_fetch_syscall_args(struct thread *td, struct syscall_args *sa)
  841 {
  842         struct proc *p;
  843         struct trapframe *frame;
  844 
  845         p = td->td_proc;
  846         frame = td->td_frame;
  847 
  848         sa->code = frame->tf_eax;
  849         sa->args[0] = frame->tf_ebx;
  850         sa->args[1] = frame->tf_ecx;
  851         sa->args[2] = frame->tf_edx;
  852         sa->args[3] = frame->tf_esi;
  853         sa->args[4] = frame->tf_edi;
  854         sa->args[5] = frame->tf_ebp;    /* Unconfirmed */
  855 
  856         if (sa->code >= p->p_sysent->sv_size)
  857                 sa->callp = &p->p_sysent->sv_table[0];
  858         else
  859                 sa->callp = &p->p_sysent->sv_table[sa->code];
  860         sa->narg = sa->callp->sy_narg;
  861 
  862         td->td_retval[0] = 0;
  863         td->td_retval[1] = frame->tf_edx;
  864 
  865         return (0);
  866 }
  867 
  868 /*
  869  * If a linux binary is exec'ing something, try this image activator
  870  * first.  We override standard shell script execution in order to
  871  * be able to modify the interpreter path.  We only do this if a linux
  872  * binary is doing the exec, so we do not create an EXEC module for it.
  873  */
  874 static int      exec_linux_imgact_try(struct image_params *iparams);
  875 
  876 static int
  877 exec_linux_imgact_try(struct image_params *imgp)
  878 {
  879     const char *head = (const char *)imgp->image_header;
  880     char *rpath;
  881     int error = -1;
  882 
  883     /*
  884      * The interpreter for shell scripts run from a linux binary needs
  885      * to be located in /compat/linux if possible in order to recursively
  886      * maintain linux path emulation.
  887      */
  888     if (((const short *)head)[0] == SHELLMAGIC) {
  889             /*
  890              * Run our normal shell image activator.  If it succeeds attempt
  891              * to use the alternate path for the interpreter.  If an alternate
  892              * path is found, use our stringspace to store it.
  893              */
  894             if ((error = exec_shell_imgact(imgp)) == 0) {
  895                     linux_emul_convpath(FIRST_THREAD_IN_PROC(imgp->proc),
  896                         imgp->interpreter_name, UIO_SYSSPACE, &rpath, 0, AT_FDCWD);
  897                     if (rpath != NULL)
  898                             imgp->args->fname_buf =
  899                                 imgp->interpreter_name = rpath;
  900             }
  901     }
  902     return (error);
  903 }
  904 
  905 /*
  906  * exec_setregs may initialize some registers differently than Linux
  907  * does, thus potentially confusing Linux binaries. If necessary, we
  908  * override the exec_setregs default(s) here.
  909  */
  910 static void
  911 exec_linux_setregs(struct thread *td, struct image_params *imgp, u_long stack)
  912 {
  913         struct pcb *pcb = td->td_pcb;
  914 
  915         exec_setregs(td, imgp, stack);
  916 
  917         /* Linux sets %gs to 0, we default to _udatasel */
  918         pcb->pcb_gs = 0;
  919         load_gs(0);
  920 
  921         pcb->pcb_initial_npxcw = __LINUX_NPXCW__;
  922 }
  923 
  924 static void
  925 linux_get_machine(const char **dst)
  926 {
  927 
  928         switch (cpu_class) {
  929         case CPUCLASS_686:
  930                 *dst = "i686";
  931                 break;
  932         case CPUCLASS_586:
  933                 *dst = "i586";
  934                 break;
  935         case CPUCLASS_486:
  936                 *dst = "i486";
  937                 break;
  938         default:
  939                 *dst = "i386";
  940         }
  941 }
  942 
  943 struct sysentvec linux_sysvec = {
  944         .sv_size        = LINUX_SYS_MAXSYSCALL,
  945         .sv_table       = linux_sysent,
  946         .sv_mask        = 0,
  947         .sv_sigsize     = LINUX_SIGTBLSZ,
  948         .sv_sigtbl      = bsd_to_linux_signal,
  949         .sv_errsize     = ELAST + 1,
  950         .sv_errtbl      = bsd_to_linux_errno,
  951         .sv_transtrap   = translate_traps,
  952         .sv_fixup       = linux_fixup,
  953         .sv_sendsig     = linux_sendsig,
  954         .sv_sigcode     = linux_sigcode,
  955         .sv_szsigcode   = &linux_szsigcode,
  956         .sv_prepsyscall = NULL,
  957         .sv_name        = "Linux a.out",
  958         .sv_coredump    = NULL,
  959         .sv_imgact_try  = exec_linux_imgact_try,
  960         .sv_minsigstksz = LINUX_MINSIGSTKSZ,
  961         .sv_pagesize    = PAGE_SIZE,
  962         .sv_minuser     = VM_MIN_ADDRESS,
  963         .sv_maxuser     = VM_MAXUSER_ADDRESS,
  964         .sv_usrstack    = LINUX_USRSTACK,
  965         .sv_psstrings   = PS_STRINGS,
  966         .sv_stackprot   = VM_PROT_ALL,
  967         .sv_copyout_strings = exec_copyout_strings,
  968         .sv_setregs     = exec_linux_setregs,
  969         .sv_fixlimit    = NULL,
  970         .sv_maxssiz     = NULL,
  971         .sv_flags       = SV_ABI_LINUX | SV_AOUT | SV_IA32 | SV_ILP32,
  972         .sv_set_syscall_retval = cpu_set_syscall_retval,
  973         .sv_fetch_syscall_args = linux_fetch_syscall_args,
  974         .sv_syscallnames = NULL,
  975         .sv_shared_page_base = LINUX_SHAREDPAGE,
  976         .sv_shared_page_len = PAGE_SIZE,
  977         .sv_schedtail   = linux_schedtail,
  978 };
  979 INIT_SYSENTVEC(aout_sysvec, &linux_sysvec);
  980 
  981 struct sysentvec elf_linux_sysvec = {
  982         .sv_size        = LINUX_SYS_MAXSYSCALL,
  983         .sv_table       = linux_sysent,
  984         .sv_mask        = 0,
  985         .sv_sigsize     = LINUX_SIGTBLSZ,
  986         .sv_sigtbl      = bsd_to_linux_signal,
  987         .sv_errsize     = ELAST + 1,
  988         .sv_errtbl      = bsd_to_linux_errno,
  989         .sv_transtrap   = translate_traps,
  990         .sv_fixup       = elf_linux_fixup,
  991         .sv_sendsig     = linux_sendsig,
  992         .sv_sigcode     = linux_sigcode,
  993         .sv_szsigcode   = &linux_szsigcode,
  994         .sv_prepsyscall = NULL,
  995         .sv_name        = "Linux ELF",
  996         .sv_coredump    = elf32_coredump,
  997         .sv_imgact_try  = exec_linux_imgact_try,
  998         .sv_minsigstksz = LINUX_MINSIGSTKSZ,
  999         .sv_pagesize    = PAGE_SIZE,
 1000         .sv_minuser     = VM_MIN_ADDRESS,
 1001         .sv_maxuser     = VM_MAXUSER_ADDRESS,
 1002         .sv_usrstack    = LINUX_USRSTACK,
 1003         .sv_psstrings   = LINUX_PS_STRINGS,
 1004         .sv_stackprot   = VM_PROT_ALL,
 1005         .sv_copyout_strings = linux_copyout_strings,
 1006         .sv_setregs     = exec_linux_setregs,
 1007         .sv_fixlimit    = NULL,
 1008         .sv_maxssiz     = NULL,
 1009         .sv_flags       = SV_ABI_LINUX | SV_IA32 | SV_ILP32 | SV_SHP,
 1010         .sv_set_syscall_retval = cpu_set_syscall_retval,
 1011         .sv_fetch_syscall_args = linux_fetch_syscall_args,
 1012         .sv_syscallnames = NULL,
 1013         .sv_shared_page_base = LINUX_SHAREDPAGE,
 1014         .sv_shared_page_len = PAGE_SIZE,
 1015         .sv_schedtail   = linux_schedtail,
 1016 };
 1017 INIT_SYSENTVEC(elf_sysvec, &elf_linux_sysvec);
 1018 
 1019 static char GNU_ABI_VENDOR[] = "GNU";
 1020 static int GNULINUX_ABI_DESC = 0;
 1021 
 1022 static boolean_t
 1023 linux_trans_osrel(const Elf_Note *note, int32_t *osrel)
 1024 {
 1025         const Elf32_Word *desc;
 1026         uintptr_t p;
 1027 
 1028         p = (uintptr_t)(note + 1);
 1029         p += roundup2(note->n_namesz, sizeof(Elf32_Addr));
 1030 
 1031         desc = (const Elf32_Word *)p;
 1032         if (desc[0] != GNULINUX_ABI_DESC)
 1033                 return (FALSE);
 1034 
 1035         /*
 1036          * For linux we encode osrel as follows (see linux_mib.c):
 1037          * VVVMMMIII (version, major, minor), see linux_mib.c.
 1038          */
 1039         *osrel = desc[1] * 1000000 + desc[2] * 1000 + desc[3];
 1040 
 1041         return (TRUE);
 1042 }
 1043 
 1044 static Elf_Brandnote linux_brandnote = {
 1045         .hdr.n_namesz   = sizeof(GNU_ABI_VENDOR),
 1046         .hdr.n_descsz   = 16,   /* XXX at least 16 */
 1047         .hdr.n_type     = 1,
 1048         .vendor         = GNU_ABI_VENDOR,
 1049         .flags          = BN_TRANSLATE_OSREL,
 1050         .trans_osrel    = linux_trans_osrel
 1051 };
 1052 
 1053 static Elf32_Brandinfo linux_brand = {
 1054         .brand          = ELFOSABI_LINUX,
 1055         .machine        = EM_386,
 1056         .compat_3_brand = "Linux",
 1057         .emul_path      = "/compat/linux",
 1058         .interp_path    = "/lib/ld-linux.so.1",
 1059         .sysvec         = &elf_linux_sysvec,
 1060         .interp_newpath = NULL,
 1061         .brand_note     = &linux_brandnote,
 1062         .flags          = BI_CAN_EXEC_DYN | BI_BRAND_NOTE
 1063 };
 1064 
 1065 static Elf32_Brandinfo linux_glibc2brand = {
 1066         .brand          = ELFOSABI_LINUX,
 1067         .machine        = EM_386,
 1068         .compat_3_brand = "Linux",
 1069         .emul_path      = "/compat/linux",
 1070         .interp_path    = "/lib/ld-linux.so.2",
 1071         .sysvec         = &elf_linux_sysvec,
 1072         .interp_newpath = NULL,
 1073         .brand_note     = &linux_brandnote,
 1074         .flags          = BI_CAN_EXEC_DYN | BI_BRAND_NOTE
 1075 };
 1076 
 1077 Elf32_Brandinfo *linux_brandlist[] = {
 1078         &linux_brand,
 1079         &linux_glibc2brand,
 1080         NULL
 1081 };
 1082 
 1083 static int
 1084 linux_elf_modevent(module_t mod, int type, void *data)
 1085 {
 1086         Elf32_Brandinfo **brandinfo;
 1087         int error;
 1088         struct linux_ioctl_handler **lihp;
 1089         struct linux_device_handler **ldhp;
 1090 
 1091         error = 0;
 1092 
 1093         switch(type) {
 1094         case MOD_LOAD:
 1095                 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
 1096                      ++brandinfo)
 1097                         if (elf32_insert_brand_entry(*brandinfo) < 0)
 1098                                 error = EINVAL;
 1099                 if (error == 0) {
 1100                         SET_FOREACH(lihp, linux_ioctl_handler_set)
 1101                                 linux_ioctl_register_handler(*lihp);
 1102                         SET_FOREACH(ldhp, linux_device_handler_set)
 1103                                 linux_device_register_handler(*ldhp);
 1104                         mtx_init(&emul_lock, "emuldata lock", NULL, MTX_DEF);
 1105                         sx_init(&emul_shared_lock, "emuldata->shared lock");
 1106                         LIST_INIT(&futex_list);
 1107                         mtx_init(&futex_mtx, "ftllk", NULL, MTX_DEF);
 1108                         linux_exit_tag = EVENTHANDLER_REGISTER(process_exit, linux_proc_exit,
 1109                               NULL, 1000);
 1110                         linux_exec_tag = EVENTHANDLER_REGISTER(process_exec, linux_proc_exec,
 1111                               NULL, 1000);
 1112                         linux_get_machine(&linux_platform);
 1113                         linux_szplatform = roundup(strlen(linux_platform) + 1,
 1114                             sizeof(char *));
 1115                         linux_osd_jail_register();
 1116                         stclohz = (stathz ? stathz : hz);
 1117                         if (bootverbose)
 1118                                 printf("Linux ELF exec handler installed\n");
 1119                 } else
 1120                         printf("cannot insert Linux ELF brand handler\n");
 1121                 break;
 1122         case MOD_UNLOAD:
 1123                 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
 1124                      ++brandinfo)
 1125                         if (elf32_brand_inuse(*brandinfo))
 1126                                 error = EBUSY;
 1127                 if (error == 0) {
 1128                         for (brandinfo = &linux_brandlist[0];
 1129                              *brandinfo != NULL; ++brandinfo)
 1130                                 if (elf32_remove_brand_entry(*brandinfo) < 0)
 1131                                         error = EINVAL;
 1132                 }
 1133                 if (error == 0) {
 1134                         SET_FOREACH(lihp, linux_ioctl_handler_set)
 1135                                 linux_ioctl_unregister_handler(*lihp);
 1136                         SET_FOREACH(ldhp, linux_device_handler_set)
 1137                                 linux_device_unregister_handler(*ldhp);
 1138                         mtx_destroy(&emul_lock);
 1139                         sx_destroy(&emul_shared_lock);
 1140                         mtx_destroy(&futex_mtx);
 1141                         EVENTHANDLER_DEREGISTER(process_exit, linux_exit_tag);
 1142                         EVENTHANDLER_DEREGISTER(process_exec, linux_exec_tag);
 1143                         linux_osd_jail_deregister();
 1144                         if (bootverbose)
 1145                                 printf("Linux ELF exec handler removed\n");
 1146                 } else
 1147                         printf("Could not deinstall ELF interpreter entry\n");
 1148                 break;
 1149         default:
 1150                 return EOPNOTSUPP;
 1151         }
 1152         return error;
 1153 }
 1154 
 1155 static moduledata_t linux_elf_mod = {
 1156         "linuxelf",
 1157         linux_elf_modevent,
 1158         0
 1159 };
 1160 
 1161 DECLARE_MODULE_TIED(linuxelf, linux_elf_mod, SI_SUB_EXEC, SI_ORDER_ANY);

Cache object: bbc27fa43233d0d10f828e7cb1b2d720


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.