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

Cache object: eb32ec712ac362b080c3c055e162c150


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