[ 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  -  FREEBSD10  -  FREEBSD9  -  FREEBSD92  -  FREEBSD91  -  FREEBSD90  -  FREEBSD8  -  FREEBSD82  -  FREEBSD81  -  FREEBSD80  -  FREEBSD7  -  FREEBSD74  -  FREEBSD73  -  FREEBSD72  -  FREEBSD71  -  FREEBSD70  -  FREEBSD6  -  FREEBSD64  -  FREEBSD63  -  FREEBSD62  -  FREEBSD61  -  FREEBSD60  -  FREEBSD5  -  FREEBSD55  -  FREEBSD54  -  FREEBSD53  -  FREEBSD52  -  FREEBSD51  -  FREEBSD50  -  FREEBSD4  -  FREEBSD3  -  FREEBSD22  -  cheribsd  -  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  -  FREEBSD-LIBC  -  FREEBSD8-LIBC  -  FREEBSD7-LIBC  -  FREEBSD6-LIBC  -  GLIBC27 
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$");
   31 
   32 #include <sys/param.h>
   33 #include <sys/systm.h>
   34 #include <sys/exec.h>
   35 #include <sys/imgact.h>
   36 #include <sys/imgact_aout.h>
   37 #include <sys/imgact_elf.h>
   38 #include <sys/kernel.h>
   39 #include <sys/lock.h>
   40 #include <sys/malloc.h>
   41 #include <sys/module.h>
   42 #include <sys/mutex.h>
   43 #include <sys/proc.h>
   44 #include <sys/signalvar.h>
   45 #include <sys/syscallsubr.h>
   46 #include <sys/sysent.h>
   47 #include <sys/sysproto.h>
   48 #include <sys/vnode.h>
   49 #include <sys/eventhandler.h>
   50 
   51 #include <vm/vm.h>
   52 #include <vm/pmap.h>
   53 #include <vm/vm_extern.h>
   54 #include <vm/vm_map.h>
   55 #include <vm/vm_object.h>
   56 #include <vm/vm_page.h>
   57 #include <vm/vm_param.h>
   58 
   59 #include <machine/cpu.h>
   60 #include <machine/cputypes.h>
   61 #include <machine/md_var.h>
   62 #include <machine/pcb.h>
   63 
   64 #include <i386/linux/linux.h>
   65 #include <i386/linux/linux_proto.h>
   66 #include <compat/linux/linux_futex.h>
   67 #include <compat/linux/linux_emul.h>
   68 #include <compat/linux/linux_mib.h>
   69 #include <compat/linux/linux_misc.h>
   70 #include <compat/linux/linux_signal.h>
   71 #include <compat/linux/linux_util.h>
   72 
   73 MODULE_VERSION(linux, 1);
   74 
   75 MALLOC_DEFINE(M_LINUX, "linux", "Linux mode structures");
   76 
   77 #if BYTE_ORDER == LITTLE_ENDIAN
   78 #define SHELLMAGIC      0x2123 /* #! */
   79 #else
   80 #define SHELLMAGIC      0x2321
   81 #endif
   82 
   83 /*
   84  * Allow the sendsig functions to use the ldebug() facility
   85  * even though they are not syscalls themselves. Map them
   86  * to syscall 0. This is slightly less bogus than using
   87  * ldebug(sigreturn).
   88  */
   89 #define LINUX_SYS_linux_rt_sendsig      0
   90 #define LINUX_SYS_linux_sendsig         0
   91 
   92 extern char linux_sigcode[];
   93 extern int linux_szsigcode;
   94 
   95 extern struct sysent linux_sysent[LINUX_SYS_MAXSYSCALL];
   96 
   97 SET_DECLARE(linux_ioctl_handler_set, struct linux_ioctl_handler);
   98 SET_DECLARE(linux_device_handler_set, struct linux_device_handler);
   99 
  100 static int      linux_fixup(register_t **stack_base,
  101                     struct image_params *iparams);
  102 static int      elf_linux_fixup(register_t **stack_base,
  103                     struct image_params *iparams);
  104 static void     linux_prepsyscall(struct trapframe *tf, int *args, u_int *code,
  105                     caddr_t *params);
  106 static void     linux_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask);
  107 static void     exec_linux_setregs(struct thread *td, u_long entry,
  108                                    u_long stack, u_long ps_strings);
  109 static register_t *linux_copyout_strings(struct image_params *imgp);
  110 static boolean_t linux_trans_osrel(const Elf_Note *note, int32_t *osrel);
  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             (curthread->td_proc->p_flag & P_SA) == 0,
  249             ("unsafe elf_linux_fixup(), should be curproc"));
  250 
  251         p = imgp->proc;
  252         arginfo = (struct ps_strings *)p->p_sysent->sv_psstrings;
  253         uplatform = (Elf32_Addr *)((caddr_t)arginfo - linux_szsigcode -
  254             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, 0);
  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         **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 - linux_szsigcode - SPARE_USRSPACE -
  315             linux_szplatform - roundup((ARG_MAX - imgp->args->stringspace),
  316             sizeof(char *));
  317 
  318         /*
  319          * install sigcode
  320          */
  321         copyout(p->p_sysent->sv_sigcode, ((caddr_t)arginfo -
  322             linux_szsigcode), linux_szsigcode);
  323 
  324         /*
  325          * install LINUX_PLATFORM
  326          */
  327         copyout(linux_platform, ((caddr_t)arginfo - linux_szsigcode -
  328             linux_szplatform), linux_szplatform);
  329 
  330         /*
  331          * If we have a valid auxargs ptr, prepare some room
  332          * on the stack.
  333          */
  334         if (imgp->auxargs) {
  335                 /*
  336                  * 'AT_COUNT*2' is size for the ELF Auxargs data. This is for
  337                  * lower compatibility.
  338                  */
  339                 imgp->auxarg_size = (imgp->auxarg_size) ? imgp->auxarg_size :
  340                     (LINUX_AT_COUNT * 2);
  341                 /*
  342                  * The '+ 2' is for the null pointers at the end of each of
  343                  * the arg and env vector sets,and imgp->auxarg_size is room
  344                  * for argument of Runtime loader.
  345                  */
  346                 vectp = (char **)(destp - (imgp->args->argc +
  347                     imgp->args->envc + 2 + imgp->auxarg_size) * sizeof(char *));
  348         } else {
  349                 /*
  350                  * The '+ 2' is for the null pointers at the end of each of
  351                  * the arg and env vector sets
  352                  */
  353                 vectp = (char **)(destp - (imgp->args->argc + imgp->args->envc + 2) *
  354                     sizeof(char *));
  355         }
  356 
  357         /*
  358          * vectp also becomes our initial stack base
  359          */
  360         stack_base = (register_t *)vectp;
  361 
  362         stringp = imgp->args->begin_argv;
  363         argc = imgp->args->argc;
  364         envc = imgp->args->envc;
  365 
  366         /*
  367          * Copy out strings - arguments and environment.
  368          */
  369         copyout(stringp, destp, ARG_MAX - imgp->args->stringspace);
  370 
  371         /*
  372          * Fill in "ps_strings" struct for ps, w, etc.
  373          */
  374         suword(&arginfo->ps_argvstr, (long)(intptr_t)vectp);
  375         suword(&arginfo->ps_nargvstr, argc);
  376 
  377         /*
  378          * Fill in argument portion of vector table.
  379          */
  380         for (; argc > 0; --argc) {
  381                 suword(vectp++, (long)(intptr_t)destp);
  382                 while (*stringp++ != 0)
  383                         destp++;
  384                 destp++;
  385         }
  386 
  387         /* a null vector table pointer separates the argp's from the envp's */
  388         suword(vectp++, 0);
  389 
  390         suword(&arginfo->ps_envstr, (long)(intptr_t)vectp);
  391         suword(&arginfo->ps_nenvstr, envc);
  392 
  393         /*
  394          * Fill in environment portion of vector table.
  395          */
  396         for (; envc > 0; --envc) {
  397                 suword(vectp++, (long)(intptr_t)destp);
  398                 while (*stringp++ != 0)
  399                         destp++;
  400                 destp++;
  401         }
  402 
  403         /* end of vector table is a null pointer */
  404         suword(vectp, 0);
  405 
  406         return (stack_base);
  407 }
  408 
  409 extern int _ucodesel, _udatasel;
  410 extern unsigned long linux_sznonrtsigcode;
  411 
  412 static void
  413 linux_rt_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
  414 {
  415         struct thread *td = curthread;
  416         struct proc *p = td->td_proc;
  417         struct sigacts *psp;
  418         struct trapframe *regs;
  419         struct l_rt_sigframe *fp, frame;
  420         int sig, code;
  421         int oonstack;
  422 
  423         sig = ksi->ksi_signo;
  424         code = ksi->ksi_code;   
  425         PROC_LOCK_ASSERT(p, MA_OWNED);
  426         psp = p->p_sigacts;
  427         mtx_assert(&psp->ps_mtx, MA_OWNED);
  428         regs = td->td_frame;
  429         oonstack = sigonstack(regs->tf_esp);
  430 
  431 #ifdef DEBUG
  432         if (ldebug(rt_sendsig))
  433                 printf(ARGS(rt_sendsig, "%p, %d, %p, %u"),
  434                     catcher, sig, (void*)mask, code);
  435 #endif
  436         /*
  437          * Allocate space for the signal handler context.
  438          */
  439         if ((td->td_pflags & TDP_ALTSTACK) && !oonstack &&
  440             SIGISMEMBER(psp->ps_sigonstack, sig)) {
  441                 fp = (struct l_rt_sigframe *)(td->td_sigstk.ss_sp +
  442                     td->td_sigstk.ss_size - sizeof(struct l_rt_sigframe));
  443         } else
  444                 fp = (struct l_rt_sigframe *)regs->tf_esp - 1;
  445         mtx_unlock(&psp->ps_mtx);
  446 
  447         /*
  448          * Build the argument list for the signal handler.
  449          */
  450         if (p->p_sysent->sv_sigtbl)
  451                 if (sig <= p->p_sysent->sv_sigsize)
  452                         sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
  453 
  454         bzero(&frame, sizeof(frame));
  455 
  456         frame.sf_handler = catcher;
  457         frame.sf_sig = sig;
  458         frame.sf_siginfo = &fp->sf_si;
  459         frame.sf_ucontext = &fp->sf_sc;
  460 
  461         /* Fill in POSIX parts */
  462         frame.sf_si.lsi_signo = sig;
  463         frame.sf_si.lsi_code = code;
  464         frame.sf_si.lsi_addr = ksi->ksi_addr;
  465 
  466         /*
  467          * Build the signal context to be used by sigreturn.
  468          */
  469         frame.sf_sc.uc_flags = 0;               /* XXX ??? */
  470         frame.sf_sc.uc_link = NULL;             /* XXX ??? */
  471 
  472         frame.sf_sc.uc_stack.ss_sp = td->td_sigstk.ss_sp;
  473         frame.sf_sc.uc_stack.ss_size = td->td_sigstk.ss_size;
  474         frame.sf_sc.uc_stack.ss_flags = (td->td_pflags & TDP_ALTSTACK)
  475             ? ((oonstack) ? LINUX_SS_ONSTACK : 0) : LINUX_SS_DISABLE;
  476         PROC_UNLOCK(p);
  477 
  478         bsd_to_linux_sigset(mask, &frame.sf_sc.uc_sigmask);
  479 
  480         frame.sf_sc.uc_mcontext.sc_mask   = frame.sf_sc.uc_sigmask.__bits[0];
  481         frame.sf_sc.uc_mcontext.sc_gs     = rgs();
  482         frame.sf_sc.uc_mcontext.sc_fs     = regs->tf_fs;
  483         frame.sf_sc.uc_mcontext.sc_es     = regs->tf_es;
  484         frame.sf_sc.uc_mcontext.sc_ds     = regs->tf_ds;
  485         frame.sf_sc.uc_mcontext.sc_edi    = regs->tf_edi;
  486         frame.sf_sc.uc_mcontext.sc_esi    = regs->tf_esi;
  487         frame.sf_sc.uc_mcontext.sc_ebp    = regs->tf_ebp;
  488         frame.sf_sc.uc_mcontext.sc_ebx    = regs->tf_ebx;
  489         frame.sf_sc.uc_mcontext.sc_edx    = regs->tf_edx;
  490         frame.sf_sc.uc_mcontext.sc_ecx    = regs->tf_ecx;
  491         frame.sf_sc.uc_mcontext.sc_eax    = regs->tf_eax;
  492         frame.sf_sc.uc_mcontext.sc_eip    = regs->tf_eip;
  493         frame.sf_sc.uc_mcontext.sc_cs     = regs->tf_cs;
  494         frame.sf_sc.uc_mcontext.sc_eflags = regs->tf_eflags;
  495         frame.sf_sc.uc_mcontext.sc_esp_at_signal = regs->tf_esp;
  496         frame.sf_sc.uc_mcontext.sc_ss     = regs->tf_ss;
  497         frame.sf_sc.uc_mcontext.sc_err    = regs->tf_err;
  498         frame.sf_sc.uc_mcontext.sc_cr2    = (register_t)ksi->ksi_addr;
  499         frame.sf_sc.uc_mcontext.sc_trapno = bsd_to_linux_trapcode(code);
  500 
  501 #ifdef DEBUG
  502         if (ldebug(rt_sendsig))
  503                 printf(LMSG("rt_sendsig flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
  504                     frame.sf_sc.uc_stack.ss_flags, td->td_sigstk.ss_sp,
  505                     td->td_sigstk.ss_size, frame.sf_sc.uc_mcontext.sc_mask);
  506 #endif
  507 
  508         if (copyout(&frame, fp, sizeof(frame)) != 0) {
  509                 /*
  510                  * Process has trashed its stack; give it an illegal
  511                  * instruction to halt it in its tracks.
  512                  */
  513 #ifdef DEBUG
  514                 if (ldebug(rt_sendsig))
  515                         printf(LMSG("rt_sendsig: bad stack %p, oonstack=%x"),
  516                             fp, oonstack);
  517 #endif
  518                 PROC_LOCK(p);
  519                 sigexit(td, SIGILL);
  520         }
  521 
  522         /*
  523          * Build context to run handler in.
  524          */
  525         regs->tf_esp = (int)fp;
  526         regs->tf_eip = PS_STRINGS - *(p->p_sysent->sv_szsigcode) +
  527             linux_sznonrtsigcode;
  528         regs->tf_eflags &= ~(PSL_T | PSL_VM | PSL_D);
  529         regs->tf_cs = _ucodesel;
  530         regs->tf_ds = _udatasel;
  531         regs->tf_es = _udatasel;
  532         regs->tf_fs = _udatasel;
  533         regs->tf_ss = _udatasel;
  534         PROC_LOCK(p);
  535         mtx_lock(&psp->ps_mtx);
  536 }
  537 
  538 
  539 /*
  540  * Send an interrupt to process.
  541  *
  542  * Stack is set up to allow sigcode stored
  543  * in u. to call routine, followed by kcall
  544  * to sigreturn routine below.  After sigreturn
  545  * resets the signal mask, the stack, and the
  546  * frame pointer, it returns to the user
  547  * specified pc, psl.
  548  */
  549 static void
  550 linux_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
  551 {
  552         struct thread *td = curthread;
  553         struct proc *p = td->td_proc;
  554         struct sigacts *psp;
  555         struct trapframe *regs;
  556         struct l_sigframe *fp, frame;
  557         l_sigset_t lmask;
  558         int sig, code;
  559         int oonstack, i;
  560 
  561         PROC_LOCK_ASSERT(p, MA_OWNED);
  562         psp = p->p_sigacts;
  563         sig = ksi->ksi_signo;
  564         code = ksi->ksi_code;
  565         mtx_assert(&psp->ps_mtx, MA_OWNED);
  566         if (SIGISMEMBER(psp->ps_siginfo, sig)) {
  567                 /* Signal handler installed with SA_SIGINFO. */
  568                 linux_rt_sendsig(catcher, ksi, mask);
  569                 return;
  570         }
  571         regs = td->td_frame;
  572         oonstack = sigonstack(regs->tf_esp);
  573 
  574 #ifdef DEBUG
  575         if (ldebug(sendsig))
  576                 printf(ARGS(sendsig, "%p, %d, %p, %u"),
  577                     catcher, sig, (void*)mask, code);
  578 #endif
  579 
  580         /*
  581          * Allocate space for the signal handler context.
  582          */
  583         if ((td->td_pflags & TDP_ALTSTACK) && !oonstack &&
  584             SIGISMEMBER(psp->ps_sigonstack, sig)) {
  585                 fp = (struct l_sigframe *)(td->td_sigstk.ss_sp +
  586                     td->td_sigstk.ss_size - sizeof(struct l_sigframe));
  587         } else
  588                 fp = (struct l_sigframe *)regs->tf_esp - 1;
  589         mtx_unlock(&psp->ps_mtx);
  590         PROC_UNLOCK(p);
  591 
  592         /*
  593          * Build the argument list for the signal handler.
  594          */
  595         if (p->p_sysent->sv_sigtbl)
  596                 if (sig <= p->p_sysent->sv_sigsize)
  597                         sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
  598 
  599         bzero(&frame, sizeof(frame));
  600 
  601         frame.sf_handler = catcher;
  602         frame.sf_sig = sig;
  603 
  604         bsd_to_linux_sigset(mask, &lmask);
  605 
  606         /*
  607          * Build the signal context to be used by sigreturn.
  608          */
  609         frame.sf_sc.sc_mask   = lmask.__bits[0];
  610         frame.sf_sc.sc_gs     = rgs();
  611         frame.sf_sc.sc_fs     = regs->tf_fs;
  612         frame.sf_sc.sc_es     = regs->tf_es;
  613         frame.sf_sc.sc_ds     = regs->tf_ds;
  614         frame.sf_sc.sc_edi    = regs->tf_edi;
  615         frame.sf_sc.sc_esi    = regs->tf_esi;
  616         frame.sf_sc.sc_ebp    = regs->tf_ebp;
  617         frame.sf_sc.sc_ebx    = regs->tf_ebx;
  618         frame.sf_sc.sc_edx    = regs->tf_edx;
  619         frame.sf_sc.sc_ecx    = regs->tf_ecx;
  620         frame.sf_sc.sc_eax    = regs->tf_eax;
  621         frame.sf_sc.sc_eip    = regs->tf_eip;
  622         frame.sf_sc.sc_cs     = regs->tf_cs;
  623         frame.sf_sc.sc_eflags = regs->tf_eflags;
  624         frame.sf_sc.sc_esp_at_signal = regs->tf_esp;
  625         frame.sf_sc.sc_ss     = regs->tf_ss;
  626         frame.sf_sc.sc_err    = regs->tf_err;
  627         frame.sf_sc.sc_cr2    = (register_t)ksi->ksi_addr;
  628         frame.sf_sc.sc_trapno = bsd_to_linux_trapcode(ksi->ksi_trapno);
  629 
  630         for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
  631                 frame.sf_extramask[i] = lmask.__bits[i+1];
  632 
  633         if (copyout(&frame, fp, sizeof(frame)) != 0) {
  634                 /*
  635                  * Process has trashed its stack; give it an illegal
  636                  * instruction to halt it in its tracks.
  637                  */
  638                 PROC_LOCK(p);
  639                 sigexit(td, SIGILL);
  640         }
  641 
  642         /*
  643          * Build context to run handler in.
  644          */
  645         regs->tf_esp = (int)fp;
  646         regs->tf_eip = PS_STRINGS - *(p->p_sysent->sv_szsigcode);
  647         regs->tf_eflags &= ~(PSL_T | PSL_VM | PSL_D);
  648         regs->tf_cs = _ucodesel;
  649         regs->tf_ds = _udatasel;
  650         regs->tf_es = _udatasel;
  651         regs->tf_fs = _udatasel;
  652         regs->tf_ss = _udatasel;
  653         PROC_LOCK(p);
  654         mtx_lock(&psp->ps_mtx);
  655 }
  656 
  657 /*
  658  * System call to cleanup state after a signal
  659  * has been taken.  Reset signal mask and
  660  * stack state from context left by sendsig (above).
  661  * Return to previous pc and psl as specified by
  662  * context left by sendsig. Check carefully to
  663  * make sure that the user has not modified the
  664  * psl to gain improper privileges or to cause
  665  * a machine fault.
  666  */
  667 int
  668 linux_sigreturn(struct thread *td, struct linux_sigreturn_args *args)
  669 {
  670         struct proc *p = td->td_proc;
  671         struct l_sigframe frame;
  672         struct trapframe *regs;
  673         l_sigset_t lmask;
  674         int eflags, i;
  675         ksiginfo_t ksi;
  676 
  677         regs = td->td_frame;
  678 
  679 #ifdef DEBUG
  680         if (ldebug(sigreturn))
  681                 printf(ARGS(sigreturn, "%p"), (void *)args->sfp);
  682 #endif
  683         /*
  684          * The trampoline code hands us the sigframe.
  685          * It is unsafe to keep track of it ourselves, in the event that a
  686          * program jumps out of a signal handler.
  687          */
  688         if (copyin(args->sfp, &frame, sizeof(frame)) != 0)
  689                 return (EFAULT);
  690 
  691         /*
  692          * Check for security violations.
  693          */
  694 #define EFLAGS_SECURE(ef, oef)  ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
  695         eflags = frame.sf_sc.sc_eflags;
  696         /*
  697          * XXX do allow users to change the privileged flag PSL_RF.  The
  698          * cpu sets PSL_RF in tf_eflags for faults.  Debuggers should
  699          * sometimes set it there too.  tf_eflags is kept in the signal
  700          * context during signal handling and there is no other place
  701          * to remember it, so the PSL_RF bit may be corrupted by the
  702          * signal handler without us knowing.  Corruption of the PSL_RF
  703          * bit at worst causes one more or one less debugger trap, so
  704          * allowing it is fairly harmless.
  705          */
  706         if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF))
  707                 return(EINVAL);
  708 
  709         /*
  710          * Don't allow users to load a valid privileged %cs.  Let the
  711          * hardware check for invalid selectors, excess privilege in
  712          * other selectors, invalid %eip's and invalid %esp's.
  713          */
  714 #define CS_SECURE(cs)   (ISPL(cs) == SEL_UPL)
  715         if (!CS_SECURE(frame.sf_sc.sc_cs)) {
  716                 ksiginfo_init_trap(&ksi);
  717                 ksi.ksi_signo = SIGBUS;
  718                 ksi.ksi_code = BUS_OBJERR;
  719                 ksi.ksi_trapno = T_PROTFLT;
  720                 ksi.ksi_addr = (void *)regs->tf_eip;
  721                 trapsignal(td, &ksi);
  722                 return(EINVAL);
  723         }
  724 
  725         lmask.__bits[0] = frame.sf_sc.sc_mask;
  726         for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
  727                 lmask.__bits[i+1] = frame.sf_extramask[i];
  728         PROC_LOCK(p);
  729         linux_to_bsd_sigset(&lmask, &td->td_sigmask);
  730         SIG_CANTMASK(td->td_sigmask);
  731         signotify(td);
  732         PROC_UNLOCK(p);
  733 
  734         /*
  735          * Restore signal context.
  736          */
  737         /* %gs was restored by the trampoline. */
  738         regs->tf_fs     = frame.sf_sc.sc_fs;
  739         regs->tf_es     = frame.sf_sc.sc_es;
  740         regs->tf_ds     = frame.sf_sc.sc_ds;
  741         regs->tf_edi    = frame.sf_sc.sc_edi;
  742         regs->tf_esi    = frame.sf_sc.sc_esi;
  743         regs->tf_ebp    = frame.sf_sc.sc_ebp;
  744         regs->tf_ebx    = frame.sf_sc.sc_ebx;
  745         regs->tf_edx    = frame.sf_sc.sc_edx;
  746         regs->tf_ecx    = frame.sf_sc.sc_ecx;
  747         regs->tf_eax    = frame.sf_sc.sc_eax;
  748         regs->tf_eip    = frame.sf_sc.sc_eip;
  749         regs->tf_cs     = frame.sf_sc.sc_cs;
  750         regs->tf_eflags = eflags;
  751         regs->tf_esp    = frame.sf_sc.sc_esp_at_signal;
  752         regs->tf_ss     = frame.sf_sc.sc_ss;
  753 
  754         return (EJUSTRETURN);
  755 }
  756 
  757 /*
  758  * System call to cleanup state after a signal
  759  * has been taken.  Reset signal mask and
  760  * stack state from context left by rt_sendsig (above).
  761  * Return to previous pc and psl as specified by
  762  * context left by sendsig. Check carefully to
  763  * make sure that the user has not modified the
  764  * psl to gain improper privileges or to cause
  765  * a machine fault.
  766  */
  767 int
  768 linux_rt_sigreturn(struct thread *td, struct linux_rt_sigreturn_args *args)
  769 {
  770         struct proc *p = td->td_proc;
  771         struct l_ucontext uc;
  772         struct l_sigcontext *context;
  773         l_stack_t *lss;
  774         stack_t ss;
  775         struct trapframe *regs;
  776         int eflags;
  777         ksiginfo_t ksi;
  778 
  779         regs = td->td_frame;
  780 
  781 #ifdef DEBUG
  782         if (ldebug(rt_sigreturn))
  783                 printf(ARGS(rt_sigreturn, "%p"), (void *)args->ucp);
  784 #endif
  785         /*
  786          * The trampoline code hands us the ucontext.
  787          * It is unsafe to keep track of it ourselves, in the event that a
  788          * program jumps out of a signal handler.
  789          */
  790         if (copyin(args->ucp, &uc, sizeof(uc)) != 0)
  791                 return (EFAULT);
  792 
  793         context = &uc.uc_mcontext;
  794 
  795         /*
  796          * Check for security violations.
  797          */
  798 #define EFLAGS_SECURE(ef, oef)  ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
  799         eflags = context->sc_eflags;
  800         /*
  801          * XXX do allow users to change the privileged flag PSL_RF.  The
  802          * cpu sets PSL_RF in tf_eflags for faults.  Debuggers should
  803          * sometimes set it there too.  tf_eflags is kept in the signal
  804          * context during signal handling and there is no other place
  805          * to remember it, so the PSL_RF bit may be corrupted by the
  806          * signal handler without us knowing.  Corruption of the PSL_RF
  807          * bit at worst causes one more or one less debugger trap, so
  808          * allowing it is fairly harmless.
  809          */
  810         if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF))
  811                 return(EINVAL);
  812 
  813         /*
  814          * Don't allow users to load a valid privileged %cs.  Let the
  815          * hardware check for invalid selectors, excess privilege in
  816          * other selectors, invalid %eip's and invalid %esp's.
  817          */
  818 #define CS_SECURE(cs)   (ISPL(cs) == SEL_UPL)
  819         if (!CS_SECURE(context->sc_cs)) {
  820                 ksiginfo_init_trap(&ksi);
  821                 ksi.ksi_signo = SIGBUS;
  822                 ksi.ksi_code = BUS_OBJERR;
  823                 ksi.ksi_trapno = T_PROTFLT;
  824                 ksi.ksi_addr = (void *)regs->tf_eip;
  825                 trapsignal(td, &ksi);
  826                 return(EINVAL);
  827         }
  828 
  829         PROC_LOCK(p);
  830         linux_to_bsd_sigset(&uc.uc_sigmask, &td->td_sigmask);
  831         SIG_CANTMASK(td->td_sigmask);
  832         signotify(td);
  833         PROC_UNLOCK(p);
  834 
  835         /*
  836          * Restore signal context
  837          */
  838         /* %gs was restored by the trampoline. */
  839         regs->tf_fs     = context->sc_fs;
  840         regs->tf_es     = context->sc_es;
  841         regs->tf_ds     = context->sc_ds;
  842         regs->tf_edi    = context->sc_edi;
  843         regs->tf_esi    = context->sc_esi;
  844         regs->tf_ebp    = context->sc_ebp;
  845         regs->tf_ebx    = context->sc_ebx;
  846         regs->tf_edx    = context->sc_edx;
  847         regs->tf_ecx    = context->sc_ecx;
  848         regs->tf_eax    = context->sc_eax;
  849         regs->tf_eip    = context->sc_eip;
  850         regs->tf_cs     = context->sc_cs;
  851         regs->tf_eflags = eflags;
  852         regs->tf_esp    = context->sc_esp_at_signal;
  853         regs->tf_ss     = context->sc_ss;
  854 
  855         /*
  856          * call sigaltstack & ignore results..
  857          */
  858         lss = &uc.uc_stack;
  859         ss.ss_sp = lss->ss_sp;
  860         ss.ss_size = lss->ss_size;
  861         ss.ss_flags = linux_to_bsd_sigaltstack(lss->ss_flags);
  862 
  863 #ifdef DEBUG
  864         if (ldebug(rt_sigreturn))
  865                 printf(LMSG("rt_sigret flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
  866                     ss.ss_flags, ss.ss_sp, ss.ss_size, context->sc_mask);
  867 #endif
  868         (void)kern_sigaltstack(td, &ss, NULL);
  869 
  870         return (EJUSTRETURN);
  871 }
  872 
  873 /*
  874  * MPSAFE
  875  */
  876 static void
  877 linux_prepsyscall(struct trapframe *tf, int *args, u_int *code, caddr_t *params)
  878 {
  879         args[0] = tf->tf_ebx;
  880         args[1] = tf->tf_ecx;
  881         args[2] = tf->tf_edx;
  882         args[3] = tf->tf_esi;
  883         args[4] = tf->tf_edi;
  884         args[5] = tf->tf_ebp;   /* Unconfirmed */
  885         *params = NULL;         /* no copyin */
  886 }
  887 
  888 /*
  889  * If a linux binary is exec'ing something, try this image activator
  890  * first.  We override standard shell script execution in order to
  891  * be able to modify the interpreter path.  We only do this if a linux
  892  * binary is doing the exec, so we do not create an EXEC module for it.
  893  */
  894 static int      exec_linux_imgact_try(struct image_params *iparams);
  895 
  896 static int
  897 exec_linux_imgact_try(struct image_params *imgp)
  898 {
  899     const char *head = (const char *)imgp->image_header;
  900     char *rpath;
  901     int error = -1, len;
  902 
  903     /*
  904      * The interpreter for shell scripts run from a linux binary needs
  905      * to be located in /compat/linux if possible in order to recursively
  906      * maintain linux path emulation.
  907      */
  908     if (((const short *)head)[0] == SHELLMAGIC) {
  909             /*
  910              * Run our normal shell image activator.  If it succeeds attempt
  911              * to use the alternate path for the interpreter.  If an alternate
  912              * path is found, use our stringspace to store it.
  913              */
  914             if ((error = exec_shell_imgact(imgp)) == 0) {
  915                     linux_emul_convpath(FIRST_THREAD_IN_PROC(imgp->proc),
  916                         imgp->interpreter_name, UIO_SYSSPACE, &rpath, 0);
  917                     if (rpath != NULL) {
  918                             len = strlen(rpath) + 1;
  919 
  920                             if (len <= MAXSHELLCMDLEN) {
  921                                     memcpy(imgp->interpreter_name, rpath, len);
  922                             }
  923                             free(rpath, M_TEMP);
  924                     }
  925             }
  926     }
  927     return(error);
  928 }
  929 
  930 /*
  931  * exec_setregs may initialize some registers differently than Linux
  932  * does, thus potentially confusing Linux binaries. If necessary, we
  933  * override the exec_setregs default(s) here.
  934  */
  935 static void
  936 exec_linux_setregs(struct thread *td, u_long entry,
  937                    u_long stack, u_long ps_strings)
  938 {
  939         struct pcb *pcb = td->td_pcb;
  940 
  941         exec_setregs(td, entry, stack, ps_strings);
  942 
  943         /* Linux sets %gs to 0, we default to _udatasel */
  944         pcb->pcb_gs = 0;
  945         load_gs(0);
  946 
  947         pcb->pcb_initial_npxcw = __LINUX_NPXCW__;
  948 }
  949 
  950 static void
  951 linux_get_machine(const char **dst)
  952 {
  953 
  954         switch (cpu_class) {
  955         case CPUCLASS_686:
  956                 *dst = "i686";
  957                 break;
  958         case CPUCLASS_586:
  959                 *dst = "i586";
  960                 break;
  961         case CPUCLASS_486:
  962                 *dst = "i486";
  963                 break;
  964         default:
  965                 *dst = "i386";
  966         }
  967 }
  968 
  969 struct sysentvec linux_sysvec = {
  970         .sv_size        = LINUX_SYS_MAXSYSCALL,
  971         .sv_table       = linux_sysent,
  972         .sv_mask        = 0,
  973         .sv_sigsize     = LINUX_SIGTBLSZ,
  974         .sv_sigtbl      = bsd_to_linux_signal,
  975         .sv_errsize     = ELAST + 1,
  976         .sv_errtbl      = bsd_to_linux_errno,
  977         .sv_transtrap   = translate_traps,
  978         .sv_fixup       = linux_fixup,
  979         .sv_sendsig     = linux_sendsig,
  980         .sv_sigcode     = linux_sigcode,
  981         .sv_szsigcode   = &linux_szsigcode,
  982         .sv_prepsyscall = linux_prepsyscall,
  983         .sv_name        = "Linux a.out",
  984         .sv_coredump    = NULL,
  985         .sv_imgact_try  = exec_linux_imgact_try,
  986         .sv_minsigstksz = LINUX_MINSIGSTKSZ,
  987         .sv_pagesize    = PAGE_SIZE,
  988         .sv_minuser     = VM_MIN_ADDRESS,
  989         .sv_maxuser     = VM_MAXUSER_ADDRESS,
  990         .sv_usrstack    = USRSTACK,
  991         .sv_psstrings   = PS_STRINGS,
  992         .sv_stackprot   = VM_PROT_ALL,
  993         .sv_copyout_strings = exec_copyout_strings,
  994         .sv_setregs     = exec_linux_setregs,
  995         .sv_fixlimit    = NULL,
  996         .sv_maxssiz     = NULL
  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 };
 1028 
 1029 static char GNU_ABI_VENDOR[] = "GNU";
 1030 static int GNULINUX_ABI_DESC = 0;
 1031 
 1032 static boolean_t
 1033 linux_trans_osrel(const Elf_Note *note, int32_t *osrel)
 1034 {
 1035         const Elf32_Word *desc;
 1036         uintptr_t p;
 1037 
 1038         p = (uintptr_t)(note + 1);
 1039         p += roundup2(note->n_namesz, sizeof(Elf32_Addr));
 1040 
 1041         desc = (const Elf32_Word *)p;
 1042         if (desc[0] != GNULINUX_ABI_DESC)
 1043                 return (FALSE);
 1044 
 1045         /*
 1046          * For linux we encode osrel as follows (see linux_mib.c):
 1047          * VVVMMMIII (version, major, minor), see linux_mib.c.
 1048          */
 1049         *osrel = desc[1] * 1000000 + desc[2] * 1000 + desc[3];
 1050 
 1051         return (TRUE);
 1052 }
 1053 
 1054 static Elf_Brandnote linux_brandnote = {
 1055         .hdr.n_namesz   = sizeof(GNU_ABI_VENDOR),
 1056         .hdr.n_descsz   = 16,   /* XXX at least 16 */
 1057         .hdr.n_type     = 1,
 1058         .vendor         = GNU_ABI_VENDOR,
 1059         .flags          = BN_TRANSLATE_OSREL,
 1060         .trans_osrel    = linux_trans_osrel
 1061 };
 1062 
 1063 static Elf32_Brandinfo linux_brand = {
 1064         .brand          = ELFOSABI_LINUX,
 1065         .machine        = EM_386,
 1066         .compat_3_brand = "Linux",
 1067         .emul_path      = "/compat/linux",
 1068         .interp_path    = "/lib/ld-linux.so.1",
 1069         .sysvec         = &elf_linux_sysvec,
 1070         .interp_newpath = NULL,
 1071         .brand_note     = &linux_brandnote,
 1072         .flags          = BI_CAN_EXEC_DYN | BI_BRAND_NOTE
 1073 };
 1074 
 1075 static Elf32_Brandinfo linux_glibc2brand = {
 1076         .brand          = ELFOSABI_LINUX,
 1077         .machine        = EM_386,
 1078         .compat_3_brand = "Linux",
 1079         .emul_path      = "/compat/linux",
 1080         .interp_path    = "/lib/ld-linux.so.2",
 1081         .sysvec         = &elf_linux_sysvec,
 1082         .interp_newpath = NULL,
 1083         .brand_note     = &linux_brandnote,
 1084         .flags          = BI_CAN_EXEC_DYN | BI_BRAND_NOTE
 1085 };
 1086 
 1087 Elf32_Brandinfo *linux_brandlist[] = {
 1088         &linux_brand,
 1089         &linux_glibc2brand,
 1090         NULL
 1091 };
 1092 
 1093 static int
 1094 linux_elf_modevent(module_t mod, int type, void *data)
 1095 {
 1096         Elf32_Brandinfo **brandinfo;
 1097         int error;
 1098         struct linux_ioctl_handler **lihp;
 1099         struct linux_device_handler **ldhp;
 1100 
 1101         error = 0;
 1102 
 1103         switch(type) {
 1104         case MOD_LOAD:
 1105                 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
 1106                      ++brandinfo)
 1107                         if (elf32_insert_brand_entry(*brandinfo) < 0)
 1108                                 error = EINVAL;
 1109                 if (error == 0) {
 1110                         SET_FOREACH(lihp, linux_ioctl_handler_set)
 1111                                 linux_ioctl_register_handler(*lihp);
 1112                         SET_FOREACH(ldhp, linux_device_handler_set)
 1113                                 linux_device_register_handler(*ldhp);
 1114                         mtx_init(&emul_lock, "emuldata lock", NULL, MTX_DEF);
 1115                         sx_init(&emul_shared_lock, "emuldata->shared lock");
 1116                         LIST_INIT(&futex_list);
 1117                         mtx_init(&futex_mtx, "ftllk", NULL, MTX_DEF);
 1118                         linux_exit_tag = EVENTHANDLER_REGISTER(process_exit, linux_proc_exit,
 1119                               NULL, 1000);
 1120                         linux_schedtail_tag = EVENTHANDLER_REGISTER(schedtail, linux_schedtail,
 1121                               NULL, 1000);
 1122                         linux_exec_tag = EVENTHANDLER_REGISTER(process_exec, linux_proc_exec,
 1123                               NULL, 1000);
 1124                         linux_get_machine(&linux_platform);
 1125                         linux_szplatform = roundup(strlen(linux_platform) + 1,
 1126                             sizeof(char *));
 1127                         stclohz = (stathz ? stathz : hz);
 1128                         if (bootverbose)
 1129                                 printf("Linux ELF exec handler installed\n");
 1130                 } else
 1131                         printf("cannot insert Linux ELF brand handler\n");
 1132                 break;
 1133         case MOD_UNLOAD:
 1134                 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
 1135                      ++brandinfo)
 1136                         if (elf32_brand_inuse(*brandinfo))
 1137                                 error = EBUSY;
 1138                 if (error == 0) {
 1139                         for (brandinfo = &linux_brandlist[0];
 1140                              *brandinfo != NULL; ++brandinfo)
 1141                                 if (elf32_remove_brand_entry(*brandinfo) < 0)
 1142                                         error = EINVAL;
 1143                 }
 1144                 if (error == 0) {
 1145                         SET_FOREACH(lihp, linux_ioctl_handler_set)
 1146                                 linux_ioctl_unregister_handler(*lihp);
 1147                         SET_FOREACH(ldhp, linux_device_handler_set)
 1148                                 linux_device_unregister_handler(*ldhp);
 1149                         mtx_destroy(&emul_lock);
 1150                         sx_destroy(&emul_shared_lock);
 1151                         mtx_destroy(&futex_mtx);
 1152                         EVENTHANDLER_DEREGISTER(process_exit, linux_exit_tag);
 1153                         EVENTHANDLER_DEREGISTER(schedtail, linux_schedtail_tag);
 1154                         EVENTHANDLER_DEREGISTER(process_exec, linux_exec_tag);
 1155                         if (bootverbose)
 1156                                 printf("Linux ELF exec handler removed\n");
 1157                 } else
 1158                         printf("Could not deinstall ELF interpreter entry\n");
 1159                 break;
 1160         default:
 1161                 return EOPNOTSUPP;
 1162         }
 1163         return error;
 1164 }
 1165 
 1166 static moduledata_t linux_elf_mod = {
 1167         "linuxelf",
 1168         linux_elf_modevent,
 1169         0
 1170 };
 1171 
 1172 DECLARE_MODULE(linuxelf, linux_elf_mod, SI_SUB_EXEC, SI_ORDER_ANY);

Cache object: da294aafc35fa47d420bfacaa81d3f6f


[ 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.