sys/emulation/linux/i386/linux_sysvec.c

   1 /*-
   2  * Copyright (c) 1994-1996 Søren Schmidt
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer
  10  *    in this position and unchanged.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. The name of the author may not be used to endorse or promote products
  15  *    derived from this software without specific prior written permission
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * $FreeBSD: src/sys/i386/linux/linux_sysvec.c,v 1.55.2.9 2002/01/12 11:03:30 bde Exp $
  29  * $DragonFly: src/sys/emulation/linux/i386/linux_sysvec.c,v 1.31 2008/04/21 15:47:53 dillon Exp $
  30  */
  31
  32 /* XXX we use functions that might not exist. */
  33 #include "opt_compat.h"
  34
  35 #ifndef COMPAT_43
  36 #error "Unable to compile Linux-emulator due to missing COMPAT_43 option!"
  37 #endif
  38
  39 #include <sys/param.h>
  40 #include <sys/systm.h>
  41 #include <sys/imgact.h>
  42 #include <sys/imgact_aout.h>
  43 #include <sys/imgact_elf.h>
  44 #include <sys/kern_syscall.h>
  45 #include <sys/lock.h>
  46 #include <sys/malloc.h>
  47 #include <sys/proc.h>
  48 #include <sys/signalvar.h>
  49 #include <sys/sysent.h>
  50 #include <sys/sysproto.h>
  51 #include <sys/eventhandler.h>
  52
  53 #include <vm/vm.h>
  54 #include <vm/vm_param.h>
  55 #include <vm/vm_page.h>
  56 #include <vm/vm_extern.h>
  57 #include <sys/exec.h>
  58 #include <sys/kernel.h>
  59 #include <sys/module.h>
  60 #include <machine/cpu.h>
  61
  62 #include "linux.h"
  63 #include "linux_proto.h"
  64 #include "../linux_signal.h"
  65 #include "../linux_util.h"
  66 #include "../linux_futex.h"
  67 #include "../linux_emuldata.h"
  68
  69 MODULE_VERSION(linux, 1);
  70
  71 MALLOC_DEFINE(M_LINUX, "linux", "Linux mode structures");
  72
  73 #if BYTE_ORDER == LITTLE_ENDIAN
  74 #define SHELLMAGIC      0x2123 /* #! */
  75 #else
  76 #define SHELLMAGIC      0x2321
  77 #endif
  78
  79 /*
  80  * Allow the sendsig functions to use the ldebug() facility
  81  * even though they are not syscalls themselves. Map them
  82  * to syscall 0. This is slightly less bogus than using
  83  * ldebug(sigreturn).
  84  */
  85 #define LINUX_SYS_linux_rt_sendsig      0
  86 #define LINUX_SYS_linux_sendsig         0
  87
  88 extern char linux_sigcode[];
  89 extern int linux_szsigcode;
  90
  91 extern struct sysent linux_sysent[LINUX_SYS_MAXSYSCALL];
  92
  93 static int      linux_fixup (register_t **stack_base,
  94                                  struct image_params *iparams);
  95 static int      elf_linux_fixup (register_t **stack_base,
  96                                      struct image_params *iparams);
  97 static void     linux_prepsyscall (struct trapframe *tf, int *args,
  98                                        u_int *code, caddr_t *params);
  99 static void     linux_sendsig (sig_t catcher, int sig, sigset_t *mask,
 100                                    u_long code);
 101
 102 static eventhandler_tag linux_exec_tag;
 103 static eventhandler_tag linux_exit_tag;
 104
 105 /*
 106  * Linux syscalls return negative errno's, we do positive and map them
 107  */
 108 static int bsd_to_linux_errno[ELAST + 1] = {
 109         -0,  -1,  -2,  -3,  -4,  -5,  -6,  -7,  -8,  -9,
 110         -10, -35, -12, -13, -14, -15, -16, -17, -18, -19,
 111         -20, -21, -22, -23, -24, -25, -26, -27, -28, -29,
 112         -30, -31, -32, -33, -34, -11,-115,-114, -88, -89,
 113         -90, -91, -92, -93, -94, -95, -96, -97, -98, -99,
 114         -100,-101,-102,-103,-104,-105,-106,-107,-108,-109,
 115         -110,-111, -40, -36,-112,-113, -39, -11, -87,-122,
 116         -116, -66,  -6,  -6,  -6,  -6,  -6, -37, -38,  -9,
 117         -6, -6, -43, -42, -75, -6, -84
 118 };
 119
 120 int bsd_to_linux_signal[LINUX_SIGTBLSZ] = {
 121         LINUX_SIGHUP, LINUX_SIGINT, LINUX_SIGQUIT, LINUX_SIGILL,
 122         LINUX_SIGTRAP, LINUX_SIGABRT, 0, LINUX_SIGFPE,
 123         LINUX_SIGKILL, LINUX_SIGBUS, LINUX_SIGSEGV, LINUX_SIGSYS,
 124         LINUX_SIGPIPE, LINUX_SIGALRM, LINUX_SIGTERM, LINUX_SIGURG,
 125         LINUX_SIGSTOP, LINUX_SIGTSTP, LINUX_SIGCONT, LINUX_SIGCHLD,
 126         LINUX_SIGTTIN, LINUX_SIGTTOU, LINUX_SIGIO, LINUX_SIGXCPU,
 127         LINUX_SIGXFSZ, LINUX_SIGVTALRM, LINUX_SIGPROF, LINUX_SIGWINCH,
 128         0, LINUX_SIGUSR1, LINUX_SIGUSR2
 129 };
 130
 131 int linux_to_bsd_signal[LINUX_SIGTBLSZ] = {
 132         SIGHUP, SIGINT, SIGQUIT, SIGILL,
 133         SIGTRAP, SIGABRT, SIGBUS, SIGFPE,
 134         SIGKILL, SIGUSR1, SIGSEGV, SIGUSR2,
 135         SIGPIPE, SIGALRM, SIGTERM, SIGBUS,
 136         SIGCHLD, SIGCONT, SIGSTOP, SIGTSTP,
 137         SIGTTIN, SIGTTOU, SIGURG, SIGXCPU,
 138         SIGXFSZ, SIGVTALRM, SIGPROF, SIGWINCH,
 139         SIGIO, SIGURG, SIGSYS
 140 };
 141
 142 #define LINUX_T_UNKNOWN  255
 143 static int _bsd_to_linux_trapcode[] = {
 144         LINUX_T_UNKNOWN,        /* 0 */
 145         6,                      /* 1  T_PRIVINFLT */
 146         LINUX_T_UNKNOWN,        /* 2 */
 147         3,                      /* 3  T_BPTFLT */
 148         LINUX_T_UNKNOWN,        /* 4 */
 149         LINUX_T_UNKNOWN,        /* 5 */
 150         16,                     /* 6  T_ARITHTRAP */
 151         254,                    /* 7  T_ASTFLT */
 152         LINUX_T_UNKNOWN,        /* 8 */
 153         13,                     /* 9  T_PROTFLT */
 154         1,                      /* 10 T_TRCTRAP */
 155         LINUX_T_UNKNOWN,        /* 11 */
 156         14,                     /* 12 T_PAGEFLT */
 157         LINUX_T_UNKNOWN,        /* 13 */
 158         17,                     /* 14 T_ALIGNFLT */
 159         LINUX_T_UNKNOWN,        /* 15 */
 160         LINUX_T_UNKNOWN,        /* 16 */
 161         LINUX_T_UNKNOWN,        /* 17 */
 162         0,                      /* 18 T_DIVIDE */
 163         2,                      /* 19 T_NMI */
 164         4,                      /* 20 T_OFLOW */
 165         5,                      /* 21 T_BOUND */
 166         7,                      /* 22 T_DNA */
 167         8,                      /* 23 T_DOUBLEFLT */
 168         9,                      /* 24 T_FPOPFLT */
 169         10,                     /* 25 T_TSSFLT */
 170         11,                     /* 26 T_SEGNPFLT */
 171         12,                     /* 27 T_STKFLT */
 172         18,                     /* 28 T_MCHK */
 173         19,                     /* 29 T_XMMFLT */
 174         15                      /* 30 T_RESERVED */
 175 };
 176 #define bsd_to_linux_trapcode(code) \
 177     ((code)<sizeof(_bsd_to_linux_trapcode)/sizeof(*_bsd_to_linux_trapcode)? \
 178      _bsd_to_linux_trapcode[(code)]: \
 179      LINUX_T_UNKNOWN)
 180
 181 /*
 182  * If FreeBSD & Linux have a difference of opinion about what a trap
 183  * means, deal with it here.
 184  */
 185 static int
 186 translate_traps(int signal, int trap_code)
 187 {
 188         if (signal != SIGBUS)
 189                 return signal;
 190         switch (trap_code) {
 191         case T_PROTFLT:
 192         case T_TSSFLT:
 193         case T_DOUBLEFLT:
 194         case T_PAGEFLT:
 195                 return SIGSEGV;
 196         default:
 197                 return signal;
 198         }
 199 }
 200
 201 static int
 202 linux_fixup(register_t **stack_base, struct image_params *imgp)
 203 {
 204         register_t *argv, *envp;
 205
 206         argv = *stack_base;
 207         envp = *stack_base + (imgp->args->argc + 1);
 208         (*stack_base)--;
 209         **stack_base = (intptr_t)(void *)envp;
 210         (*stack_base)--;
 211         **stack_base = (intptr_t)(void *)argv;
 212         (*stack_base)--;
 213         **stack_base = imgp->args->argc;
 214         return 0;
 215 }
 216
 217 static int
 218 elf_linux_fixup(register_t **stack_base, struct image_params *imgp)
 219 {
 220         Elf32_Auxargs *args = (Elf32_Auxargs *)imgp->auxargs;
 221         register_t *pos;
 222
 223         pos = *stack_base + (imgp->args->argc + imgp->args->envc + 2);
 224
 225         if (args->trace) {
 226                 AUXARGS_ENTRY(pos, AT_DEBUG, 1);
 227         }
 228         if (args->execfd != -1) {
 229                 AUXARGS_ENTRY(pos, AT_EXECFD, args->execfd);
 230         }
 231         AUXARGS_ENTRY(pos, AT_PHDR, args->phdr);
 232         AUXARGS_ENTRY(pos, AT_PHENT, args->phent);
 233         AUXARGS_ENTRY(pos, AT_PHNUM, args->phnum);
 234         AUXARGS_ENTRY(pos, AT_PAGESZ, args->pagesz);
 235         AUXARGS_ENTRY(pos, AT_FLAGS, args->flags);
 236         AUXARGS_ENTRY(pos, AT_ENTRY, args->entry);
 237         AUXARGS_ENTRY(pos, AT_BASE, args->base);
 238         AUXARGS_ENTRY(pos, AT_UID, imgp->proc->p_ucred->cr_ruid);
 239         AUXARGS_ENTRY(pos, AT_EUID, imgp->proc->p_ucred->cr_svuid);
 240         AUXARGS_ENTRY(pos, AT_GID, imgp->proc->p_ucred->cr_rgid);
 241         AUXARGS_ENTRY(pos, AT_EGID, imgp->proc->p_ucred->cr_svgid);
 242         AUXARGS_ENTRY(pos, AT_NULL, 0);
 243
 244         kfree(imgp->auxargs, M_TEMP);
 245         imgp->auxargs = NULL;
 246
 247         (*stack_base)--;
 248         **stack_base = (long)imgp->args->argc;
 249         return 0;
 250 }
 251
 252 extern int _ucodesel, _udatasel;
 253 extern unsigned long linux_sznonrtsigcode;
 254
 255 static void
 256 linux_rt_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code)
 257 {
 258         struct proc *p = curproc;
 259         struct lwp *lp = curthread->td_lwp;
 260         struct trapframe *regs;
 261         struct l_rt_sigframe *fp, frame;
 262         int oonstack;
 263
 264         regs = lp->lwp_md.md_regs;
 265         oonstack = lp->lwp_sigstk.ss_flags & SS_ONSTACK;
 266
 267 #ifdef DEBUG
 268         if (ldebug(rt_sendsig))
 269                 kprintf(ARGS(rt_sendsig, "%p, %d, %p, %lu"),
 270                     catcher, sig, (void*)mask, code);
 271 #endif
 272         /*
 273          * Allocate space for the signal handler context.
 274          */
 275         if ((lp->lwp_flag & LWP_ALTSTACK) && !oonstack &&
 276             SIGISMEMBER(p->p_sigacts->ps_sigonstack, sig)) {
 277                 fp = (struct l_rt_sigframe *)(lp->lwp_sigstk.ss_sp +
 278                     lp->lwp_sigstk.ss_size - sizeof(struct l_rt_sigframe));
 279                 lp->lwp_sigstk.ss_flags |= SS_ONSTACK;
 280         } else
 281                 fp = (struct l_rt_sigframe *)regs->tf_esp - 1;
 282
 283         /*
 284          * grow() will return FALSE if the fp will not fit inside the stack
 285          *      and the stack can not be grown. useracc will return FALSE
 286          *      if access is denied.
 287          */
 288         if ((vm_map_growstack(p, (vm_offset_t)fp) != KERN_SUCCESS) ||
 289             !useracc((caddr_t)fp, sizeof (struct l_rt_sigframe),
 290             VM_PROT_WRITE)) {
 291                 /*
 292                  * Process has trashed its stack; give it an illegal
 293                  * instruction to halt it in its tracks.
 294                  */
 295                 SIGACTION(p, SIGILL) = SIG_DFL;
 296                 SIGDELSET(p->p_sigignore, SIGILL);
 297                 SIGDELSET(p->p_sigcatch, SIGILL);
 298                 SIGDELSET(lp->lwp_sigmask, SIGILL);
 299 #ifdef DEBUG
 300                 if (ldebug(rt_sendsig))
 301                         kprintf(LMSG("rt_sendsig: bad stack %p, oonstack=%x"),
 302                             fp, oonstack);
 303 #endif
 304                 lwpsignal(p, lp, SIGILL);
 305                 return;
 306         }
 307
 308         /*
 309          * Build the argument list for the signal handler.
 310          */
 311         if (p->p_sysent->sv_sigtbl)
 312                 if (sig <= p->p_sysent->sv_sigsize)
 313                         sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
 314
 315         frame.sf_handler = catcher;
 316         frame.sf_sig = sig;
 317         frame.sf_siginfo = &fp->sf_si;
 318         frame.sf_ucontext = &fp->sf_sc;
 319
 320         /* Fill siginfo structure. */
 321         frame.sf_si.lsi_signo = sig;
 322         frame.sf_si.lsi_code = code;
 323         frame.sf_si.lsi_addr = (void *)regs->tf_err;
 324
 325         /*
 326          * Build the signal context to be used by sigreturn.
 327          */
 328         frame.sf_sc.uc_flags = 0;               /* XXX ??? */
 329         frame.sf_sc.uc_link = NULL;             /* XXX ??? */
 330
 331         frame.sf_sc.uc_stack.ss_sp = lp->lwp_sigstk.ss_sp;
 332         frame.sf_sc.uc_stack.ss_size = lp->lwp_sigstk.ss_size;
 333         frame.sf_sc.uc_stack.ss_flags = (lp->lwp_flag & LWP_ALTSTACK)
 334             ? ((oonstack) ? LINUX_SS_ONSTACK : 0) : LINUX_SS_DISABLE;
 335
 336         bsd_to_linux_sigset(mask, &frame.sf_sc.uc_sigmask);
 337
 338         frame.sf_sc.uc_mcontext.sc_mask   = frame.sf_sc.uc_sigmask.__bits[0];
 339         frame.sf_sc.uc_mcontext.sc_gs     = regs->tf_gs;
 340         frame.sf_sc.uc_mcontext.sc_fs     = regs->tf_fs;
 341         frame.sf_sc.uc_mcontext.sc_es     = regs->tf_es;
 342         frame.sf_sc.uc_mcontext.sc_ds     = regs->tf_ds;
 343         frame.sf_sc.uc_mcontext.sc_edi    = regs->tf_edi;
 344         frame.sf_sc.uc_mcontext.sc_esi    = regs->tf_esi;
 345         frame.sf_sc.uc_mcontext.sc_ebp    = regs->tf_ebp;
 346         frame.sf_sc.uc_mcontext.sc_ebx    = regs->tf_ebx;
 347         frame.sf_sc.uc_mcontext.sc_edx    = regs->tf_edx;
 348         frame.sf_sc.uc_mcontext.sc_ecx    = regs->tf_ecx;
 349         frame.sf_sc.uc_mcontext.sc_eax    = regs->tf_eax;
 350         frame.sf_sc.uc_mcontext.sc_eip    = regs->tf_eip;
 351         frame.sf_sc.uc_mcontext.sc_cs     = regs->tf_cs;
 352         frame.sf_sc.uc_mcontext.sc_eflags = regs->tf_eflags;
 353         frame.sf_sc.uc_mcontext.sc_esp_at_signal = regs->tf_esp;
 354         frame.sf_sc.uc_mcontext.sc_ss     = regs->tf_ss;
 355         frame.sf_sc.uc_mcontext.sc_err    = regs->tf_err;
 356         frame.sf_sc.uc_mcontext.sc_trapno = bsd_to_linux_trapcode(code);
 357
 358 #ifdef DEBUG
 359         if (ldebug(rt_sendsig))
 360                 kprintf(LMSG("rt_sendsig flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
 361                     frame.sf_sc.uc_stack.ss_flags, lp->lwp_sigstk.ss_sp,
 362                     lp->lwp_sigstk.ss_size, frame.sf_sc.uc_mcontext.sc_mask);
 363 #endif
 364
 365         if (copyout(&frame, fp, sizeof(frame)) != 0) {
 366                 /*
 367                  * Process has trashed its stack; give it an illegal
 368                  * instruction to halt it in its tracks.
 369                  */
 370                 sigexit(lp, SIGILL);
 371                 /* NOTREACHED */
 372         }
 373
 374         /*
 375          * Build context to run handler in.
 376          */
 377         regs->tf_esp = (int)fp;
 378         regs->tf_eip = PS_STRINGS - *(p->p_sysent->sv_szsigcode) +
 379             linux_sznonrtsigcode;
 380
 381         /*
 382          * i386 abi specifies that the direction flag must be cleared
 383          * on function entry
 384          */
 385         regs->tf_eflags &= ~(PSL_T | PSL_VM | PSL_D);
 386
 387         regs->tf_cs = _ucodesel;
 388         regs->tf_ds = _udatasel;
 389         regs->tf_es = _udatasel;
 390         /* allow %fs and %gs to be inherited by the signal handler */
 391         /*
 392         regs->tf_fs = _udatasel;
 393         regs->tf_gs = _udatasel;
 394         */
 395         regs->tf_ss = _udatasel;
 396 }
 397
 398
 399 /*
 400  * Send an interrupt to process.
 401  *
 402  * Stack is set up to allow sigcode stored
 403  * in u. to call routine, followed by kcall
 404  * to sigreturn routine below.  After sigreturn
 405  * resets the signal mask, the stack, and the
 406  * frame pointer, it returns to the user
 407  * specified pc, psl.
 408  */
 409
 410 static void
 411 linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code)
 412 {
 413         struct proc *p = curproc;
 414         struct lwp *lp = curthread->td_lwp;
 415         struct trapframe *regs;
 416         struct l_sigframe *fp, frame;
 417         l_sigset_t lmask;
 418         int oonstack, i;
 419
 420         if (SIGISMEMBER(p->p_sigacts->ps_siginfo, sig)) {
 421                 /* Signal handler installed with SA_SIGINFO. */
 422                 linux_rt_sendsig(catcher, sig, mask, code);
 423                 return;
 424         }
 425
 426         regs = lp->lwp_md.md_regs;
 427         oonstack = lp->lwp_sigstk.ss_flags & SS_ONSTACK;
 428
 429 #ifdef DEBUG
 430         if (ldebug(sendsig))
 431                 kprintf(ARGS(sendsig, "%p, %d, %p, %lu"),
 432                     catcher, sig, (void*)mask, code);
 433 #endif
 434
 435         /*
 436          * Allocate space for the signal handler context.
 437          */
 438         if ((lp->lwp_flag & LWP_ALTSTACK) && !oonstack &&
 439             SIGISMEMBER(p->p_sigacts->ps_sigonstack, sig)) {
 440                 fp = (struct l_sigframe *)(lp->lwp_sigstk.ss_sp +
 441                     lp->lwp_sigstk.ss_size - sizeof(struct l_sigframe));
 442                 lp->lwp_sigstk.ss_flags |= SS_ONSTACK;
 443         } else
 444                 fp = (struct l_sigframe *)regs->tf_esp - 1;
 445
 446         /*
 447          * grow() will return FALSE if the fp will not fit inside the stack
 448          *      and the stack can not be grown. useracc will return FALSE
 449          *      if access is denied.
 450          */
 451         if ((vm_map_growstack(p, (vm_offset_t)fp) != KERN_SUCCESS) ||
 452             !useracc((caddr_t)fp, sizeof (struct l_sigframe),
 453             VM_PROT_WRITE)) {
 454                 /*
 455                  * Process has trashed its stack; give it an illegal
 456                  * instruction to halt it in its tracks.
 457                  */
 458                 SIGACTION(p, SIGILL) = SIG_DFL;
 459                 SIGDELSET(p->p_sigignore, SIGILL);
 460                 SIGDELSET(p->p_sigcatch, SIGILL);
 461                 SIGDELSET(lp->lwp_sigmask, SIGILL);
 462                 lwpsignal(p, lp, SIGILL);
 463                 return;
 464         }
 465
 466         /*
 467          * Build the argument list for the signal handler.
 468          */
 469         if (p->p_sysent->sv_sigtbl)
 470                 if (sig <= p->p_sysent->sv_sigsize)
 471                         sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
 472
 473         frame.sf_handler = catcher;
 474         frame.sf_sig = sig;
 475
 476         bsd_to_linux_sigset(mask, &lmask);
 477
 478         /*
 479          * Build the signal context to be used by sigreturn.
 480          */
 481         frame.sf_sc.sc_mask   = lmask.__bits[0];
 482         frame.sf_sc.sc_gs     = regs->tf_gs;
 483         frame.sf_sc.sc_fs     = regs->tf_fs;
 484         frame.sf_sc.sc_es     = regs->tf_es;
 485         frame.sf_sc.sc_ds     = regs->tf_ds;
 486         frame.sf_sc.sc_edi    = regs->tf_edi;
 487         frame.sf_sc.sc_esi    = regs->tf_esi;
 488         frame.sf_sc.sc_ebp    = regs->tf_ebp;
 489         frame.sf_sc.sc_ebx    = regs->tf_ebx;
 490         frame.sf_sc.sc_edx    = regs->tf_edx;
 491         frame.sf_sc.sc_ecx    = regs->tf_ecx;
 492         frame.sf_sc.sc_eax    = regs->tf_eax;
 493         frame.sf_sc.sc_eip    = regs->tf_eip;
 494         frame.sf_sc.sc_cs     = regs->tf_cs;
 495         frame.sf_sc.sc_eflags = regs->tf_eflags;
 496         frame.sf_sc.sc_esp_at_signal = regs->tf_esp;
 497         frame.sf_sc.sc_ss     = regs->tf_ss;
 498         frame.sf_sc.sc_err    = regs->tf_err;
 499         frame.sf_sc.sc_trapno = bsd_to_linux_trapcode(code);
 500
 501         bzero(&frame.sf_fpstate, sizeof(struct l_fpstate));
 502
 503         for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
 504                 frame.sf_extramask[i] = lmask.__bits[i+1];
 505
 506         if (copyout(&frame, fp, sizeof(frame)) != 0) {
 507                 /*
 508                  * Process has trashed its stack; give it an illegal
 509                  * instruction to halt it in its tracks.
 510                  */
 511                 sigexit(lp, SIGILL);
 512                 /* NOTREACHED */
 513         }
 514
 515         /*
 516          * Build context to run handler in.
 517          */
 518         regs->tf_esp = (int)fp;
 519         regs->tf_eip = PS_STRINGS - *(p->p_sysent->sv_szsigcode);
 520
 521         /*
 522          * i386 abi specifies that the direction flag must be cleared
 523          * on function entry
 524          */
 525         regs->tf_eflags &= ~(PSL_T | PSL_VM | PSL_D);
 526
 527         regs->tf_cs = _ucodesel;
 528         regs->tf_ds = _udatasel;
 529         regs->tf_es = _udatasel;
 530         /* Allow %fs and %gs to be inherited by the signal handler */
 531         /*
 532         regs->tf_fs = _udatasel;
 533         regs->tf_gs = _udatasel;
 534         */
 535         regs->tf_ss = _udatasel;
 536 }
 537
 538 /*
 539  * System call to cleanup state after a signal
 540  * has been taken.  Reset signal mask and
 541  * stack state from context left by sendsig (above).
 542  * Return to previous pc and psl as specified by
 543  * context left by sendsig. Check carefully to
 544  * make sure that the user has not modified the
 545  * psl to gain improper privileges or to cause
 546  * a machine fault.
 547  *
 548  * MPSAFE
 549  */
 550 int
 551 sys_linux_sigreturn(struct linux_sigreturn_args *args)
 552 {
 553         struct lwp *lp = curthread->td_lwp;
 554         struct l_sigframe frame;
 555         struct trapframe *regs;
 556         l_sigset_t lmask;
 557         int eflags, i;
 558
 559         regs = lp->lwp_md.md_regs;
 560
 561 #ifdef DEBUG
 562         if (ldebug(sigreturn))
 563                 kprintf(ARGS(sigreturn, "%p"), (void *)args->sfp);
 564 #endif
 565         /*
 566          * The trampoline code hands us the sigframe.
 567          * It is unsafe to keep track of it ourselves, in the event that a
 568          * program jumps out of a signal handler.
 569          */
 570         if (copyin((caddr_t)args->sfp, &frame, sizeof(frame)) != 0)
 571                 return (EFAULT);
 572
 573         /*
 574          * Check for security violations.
 575          */
 576 #define EFLAGS_SECURE(ef, oef)  ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
 577         eflags = frame.sf_sc.sc_eflags;
 578         /*
 579          * XXX do allow users to change the privileged flag PSL_RF.  The
 580          * cpu sets PSL_RF in tf_eflags for faults.  Debuggers should
 581          * sometimes set it there too.  tf_eflags is kept in the signal
 582          * context during signal handling and there is no other place
 583          * to remember it, so the PSL_RF bit may be corrupted by the
 584          * signal handler without us knowing.  Corruption of the PSL_RF
 585          * bit at worst causes one more or one less debugger trap, so
 586          * allowing it is fairly harmless.
 587          */
 588         if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF)) {
 589                 return(EINVAL);
 590         }
 591
 592         /*
 593          * Don't allow users to load a valid privileged %cs.  Let the
 594          * hardware check for invalid selectors, excess privilege in
 595          * other selectors, invalid %eip's and invalid %esp's.
 596          */
 597 #define CS_SECURE(cs)   (ISPL(cs) == SEL_UPL)
 598         if (!CS_SECURE(frame.sf_sc.sc_cs)) {
 599                 trapsignal(lp, SIGBUS, T_PROTFLT);
 600                 return(EINVAL);
 601         }
 602
 603         lp->lwp_sigstk.ss_flags &= ~SS_ONSTACK;
 604         lmask.__bits[0] = frame.sf_sc.sc_mask;
 605         for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
 606                 lmask.__bits[i+1] = frame.sf_extramask[i];
 607         linux_to_bsd_sigset(&lmask, &lp->lwp_sigmask);
 608         SIG_CANTMASK(lp->lwp_sigmask);
 609
 610         /*
 611          * Restore signal context.
 612          */
 613         /* %gs was restored by the trampoline. */
 614         regs->tf_fs     = frame.sf_sc.sc_fs;
 615         regs->tf_es     = frame.sf_sc.sc_es;
 616         regs->tf_ds     = frame.sf_sc.sc_ds;
 617         regs->tf_edi    = frame.sf_sc.sc_edi;
 618         regs->tf_esi    = frame.sf_sc.sc_esi;
 619         regs->tf_ebp    = frame.sf_sc.sc_ebp;
 620         regs->tf_ebx    = frame.sf_sc.sc_ebx;
 621         regs->tf_edx    = frame.sf_sc.sc_edx;
 622         regs->tf_ecx    = frame.sf_sc.sc_ecx;
 623         regs->tf_eax    = frame.sf_sc.sc_eax;
 624         regs->tf_eip    = frame.sf_sc.sc_eip;
 625         regs->tf_cs     = frame.sf_sc.sc_cs;
 626         regs->tf_eflags = eflags;
 627         regs->tf_esp    = frame.sf_sc.sc_esp_at_signal;
 628         regs->tf_ss     = frame.sf_sc.sc_ss;
 629
 630         return (EJUSTRETURN);
 631 }
 632
 633 /*
 634  * System call to cleanup state after a signal
 635  * has been taken.  Reset signal mask and
 636  * stack state from context left by rt_sendsig (above).
 637  * Return to previous pc and psl as specified by
 638  * context left by sendsig. Check carefully to
 639  * make sure that the user has not modified the
 640  * psl to gain improper privileges or to cause
 641  * a machine fault.
 642  *
 643  * MPSAFE
 644  */
 645 int
 646 sys_linux_rt_sigreturn(struct linux_rt_sigreturn_args *args)
 647 {
 648         struct lwp *lp = curthread->td_lwp;
 649         struct l_ucontext uc;
 650         struct l_sigcontext *context;
 651         l_stack_t *lss;
 652         stack_t ss;
 653         struct trapframe *regs;
 654         int eflags;
 655
 656         regs = lp->lwp_md.md_regs;
 657
 658 #ifdef DEBUG
 659         if (ldebug(rt_sigreturn))
 660                 kprintf(ARGS(rt_sigreturn, "%p"), (void *)args->ucp);
 661 #endif
 662         /*
 663          * The trampoline code hands us the ucontext.
 664          * It is unsafe to keep track of it ourselves, in the event that a
 665          * program jumps out of a signal handler.
 666          */
 667         if (copyin((caddr_t)args->ucp, &uc, sizeof(uc)) != 0)
 668                 return (EFAULT);
 669
 670         context = &uc.uc_mcontext;
 671
 672         /*
 673          * Check for security violations.
 674          */
 675 #define EFLAGS_SECURE(ef, oef)  ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
 676         eflags = context->sc_eflags;
 677         /*
 678          * XXX do allow users to change the privileged flag PSL_RF.  The
 679          * cpu sets PSL_RF in tf_eflags for faults.  Debuggers should
 680          * sometimes set it there too.  tf_eflags is kept in the signal
 681          * context during signal handling and there is no other place
 682          * to remember it, so the PSL_RF bit may be corrupted by the
 683          * signal handler without us knowing.  Corruption of the PSL_RF
 684          * bit at worst causes one more or one less debugger trap, so
 685          * allowing it is fairly harmless.
 686          */
 687         if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF)) {
 688                 return(EINVAL);
 689         }
 690
 691         /*
 692          * Don't allow users to load a valid privileged %cs.  Let the
 693          * hardware check for invalid selectors, excess privilege in
 694          * other selectors, invalid %eip's and invalid %esp's.
 695          */
 696 #define CS_SECURE(cs)   (ISPL(cs) == SEL_UPL)
 697         if (!CS_SECURE(context->sc_cs)) {
 698                 trapsignal(lp, SIGBUS, T_PROTFLT);
 699                 return(EINVAL);
 700         }
 701
 702         lp->lwp_sigstk.ss_flags &= ~SS_ONSTACK;
 703         linux_to_bsd_sigset(&uc.uc_sigmask, &lp->lwp_sigmask);
 704         SIG_CANTMASK(lp->lwp_sigmask);
 705
 706         /*
 707          * Restore signal context
 708          */
 709         /* %gs was restored by the trampoline. */
 710         regs->tf_fs     = context->sc_fs;
 711         regs->tf_es     = context->sc_es;
 712         regs->tf_ds     = context->sc_ds;
 713         regs->tf_edi    = context->sc_edi;
 714         regs->tf_esi    = context->sc_esi;
 715         regs->tf_ebp    = context->sc_ebp;
 716         regs->tf_ebx    = context->sc_ebx;
 717         regs->tf_edx    = context->sc_edx;
 718         regs->tf_ecx    = context->sc_ecx;
 719         regs->tf_eax    = context->sc_eax;
 720         regs->tf_eip    = context->sc_eip;
 721         regs->tf_cs     = context->sc_cs;
 722         regs->tf_eflags = eflags;
 723         regs->tf_esp    = context->sc_esp_at_signal;
 724         regs->tf_ss     = context->sc_ss;
 725
 726         /*
 727          * call sigaltstack & ignore results..
 728          */
 729         lss = &uc.uc_stack;
 730         ss.ss_sp = lss->ss_sp;
 731         ss.ss_size = lss->ss_size;
 732         ss.ss_flags = linux_to_bsd_sigaltstack(lss->ss_flags);
 733
 734 #ifdef DEBUG
 735         if (ldebug(rt_sigreturn))
 736                 kprintf(LMSG("rt_sigret flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
 737                     ss.ss_flags, ss.ss_sp, ss.ss_size, context->sc_mask);
 738 #endif
 739         kern_sigaltstack(&ss, NULL);
 740
 741         return (EJUSTRETURN);
 742 }
 743
 744 /*
 745  * Prep arguments.
 746  *
 747  * MUST BE MPSAFE
 748  */
 749 static void
 750 linux_prepsyscall(struct trapframe *tf, int *args, u_int *code, caddr_t *params)
 751 {
 752         args[0] = tf->tf_ebx;
 753         args[1] = tf->tf_ecx;
 754         args[2] = tf->tf_edx;
 755         args[3] = tf->tf_esi;
 756         args[4] = tf->tf_edi;
 757         args[5] = tf->tf_ebp;
 758         *params = NULL;         /* no copyin */
 759 }
 760
 761 /*
 762  * If a linux binary is exec'ing something, try this image activator
 763  * first.  We override standard shell script execution in order to
 764  * be able to modify the interpreter path.  We only do this if a linux
 765  * binary is doing the exec, so we do not create an EXEC module for it.
 766  */
 767 static int      exec_linux_imgact_try (struct image_params *iparams);
 768
 769 static int
 770 exec_linux_imgact_try(struct image_params *imgp)
 771 {
 772     const char *head = (const char *)imgp->image_header;
 773     int error = -1;
 774
 775     /*
 776      * The interpreter for shell scripts run from a linux binary needs
 777      * to be located in /compat/linux if possible in order to recursively
 778      * maintain linux path emulation.
 779      */
 780     if (((const short *)head)[0] == SHELLMAGIC) {
 781             /*
 782              * Run our normal shell image activator.  If it succeeds attempt
 783              * to use the alternate path for the interpreter.  If an alternate
 784              * path is found, use our stringspace to store it.
 785              */
 786             if ((error = exec_shell_imgact(imgp)) == 0) {
 787                     linux_translate_path(imgp->interpreter_name,
 788                         MAXSHELLCMDLEN);
 789             }
 790     }
 791     return(error);
 792 }
 793
 794 struct sysentvec linux_sysvec = {
 795         LINUX_SYS_MAXSYSCALL,
 796         linux_sysent,
 797         0xffffffff,
 798         LINUX_SIGTBLSZ,
 799         bsd_to_linux_signal,
 800         ELAST + 1,
 801         bsd_to_linux_errno,
 802         translate_traps,
 803         linux_fixup,
 804         linux_sendsig,
 805         linux_sigcode,
 806         &linux_szsigcode,
 807         linux_prepsyscall,
 808         "Linux a.out",
 809         NULL,
 810         exec_linux_imgact_try,
 811         LINUX_MINSIGSTKSZ
 812 };
 813
 814 struct sysentvec elf_linux_sysvec = {
 815         LINUX_SYS_MAXSYSCALL,
 816         linux_sysent,
 817         0xffffffff,
 818         LINUX_SIGTBLSZ,
 819         bsd_to_linux_signal,
 820         ELAST + 1,
 821         bsd_to_linux_errno,
 822         translate_traps,
 823         elf_linux_fixup,
 824         linux_sendsig,
 825         linux_sigcode,
 826         &linux_szsigcode,
 827         linux_prepsyscall,
 828 #if defined(__x86_64__)
 829         "Linux ELF64",
 830 #else
 831         "Linux ELF32",
 832 #endif
 833         elf_coredump,
 834         exec_linux_imgact_try,
 835         LINUX_MINSIGSTKSZ
 836 };
 837
 838 static int      linux_match_abi_note(const Elf_Note *abi_note);
 839 static int      linux_match_suse_note(const Elf_Note *abi_note);
 840
 841 static Elf32_Brandinfo linux_brand = {
 842                                         ELFOSABI_LINUX,
 843                                         "Linux",
 844                                         linux_match_abi_note,
 845                                         "/compat/linux",
 846                                         "/lib/ld-linux.so.1",
 847                                         &elf_linux_sysvec
 848                                  };
 849
 850 static Elf32_Brandinfo linux_glibc2brand = {
 851                                         ELFOSABI_LINUX,
 852                                         "Linux",
 853                                         linux_match_abi_note,
 854                                         "/compat/linux",
 855                                         "/lib/ld-linux.so.2",
 856                                         &elf_linux_sysvec
 857                                  };
 858
 859 static Elf32_Brandinfo linux_suse_brand = {
 860                                         ELFOSABI_LINUX,
 861                                         "Linux",
 862                                         linux_match_suse_note,
 863                                         "/compat/linux",
 864                                         "/lib/ld-linux.so.2",
 865                                         &elf_linux_sysvec
 866                                  };
 867
 868 Elf32_Brandinfo *linux_brandlist[] = {
 869                                         &linux_brand,
 870                                         &linux_glibc2brand,
 871                                         &linux_suse_brand,
 872                                         NULL
 873                                 };
 874
 875 static int
 876 linux_match_abi_note(const Elf_Note *abi_note)
 877 {
 878         const char *abi_name = (const char *)
 879             ((const uint8_t *)abi_note + sizeof(*abi_note));
 880         const uint32_t *descr = (const uint32_t *)
 881             ((const uint8_t *)abi_name + abi_note->n_namesz);
 882
 883         if (abi_note->n_namesz != sizeof("GNU"))
 884                 return(FALSE);
 885         if (memcmp(abi_name, "GNU", sizeof("GNU")))
 886                 return(FALSE);
 887         if (abi_note->n_descsz < sizeof(uint32_t))
 888                 return(FALSE);
 889
 890         if (*descr != 0)
 891                 return(FALSE);
 892         return(TRUE);
 893 }
 894
 895 static int
 896 linux_match_suse_note(const Elf_Note *abi_note)
 897 {
 898         const char *abi_name = (const char *)
 899             ((const uint8_t *)abi_note + sizeof(*abi_note));
 900
 901         if (abi_note->n_namesz != sizeof("SuSE"))
 902                 return(FALSE);
 903         if (memcmp(abi_name, "SuSE", sizeof("SuSE")))
 904                 return(FALSE);
 905
 906         return(TRUE);
 907 }
 908
 909 static int
 910 linux_elf_modevent(module_t mod, int type, void *data)
 911 {
 912         Elf32_Brandinfo **brandinfo;
 913         int error;
 914
 915         error = 0;
 916
 917         switch(type) {
 918         case MOD_LOAD:
 919                 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
 920                      ++brandinfo)
 921                         if (elf_insert_brand_entry(*brandinfo) < 0)
 922                                 error = EINVAL;
 923                 if (error == 0) {
 924                         if (bootverbose)
 925                                 kprintf("Linux ELF exec handler installed\n");
 926                 } else {
 927                         kprintf("cannot insert Linux ELF brand handler\n");
 928                 }
 929                 EMUL_LOCKINIT();
 930                 lockinit(&futex_mtx, "linftxs", 0, LK_CANRECURSE);
 931                 linux_exec_tag = EVENTHANDLER_REGISTER(process_exec, linux_proc_transition,
 932                     NULL, 1000);
 933                 linux_exit_tag = EVENTHANDLER_REGISTER(process_exit, emuldata_exit,
 934                     NULL, 1000);
 935                 break;
 936         case MOD_UNLOAD:
 937                 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
 938                      ++brandinfo)
 939                         if (elf_brand_inuse(*brandinfo))
 940                                 error = EBUSY;
 941                 if (error == 0) {
 942                         for (brandinfo = &linux_brandlist[0];
 943                              *brandinfo != NULL; ++brandinfo)
 944                                 if (elf_remove_brand_entry(*brandinfo) < 0)
 945                                         error = EINVAL;
 946                 }
 947                 if (error == 0) {
 948                         if (bootverbose)
 949                                 kprintf("Linux ELF exec handler removed\n");
 950                 } else {
 951                         kprintf("Could not deinstall ELF interpreter entry\n");
 952                 }
 953                 EVENTHANDLER_DEREGISTER(process_exec, linux_exec_tag);
 954                 EVENTHANDLER_DEREGISTER(process_exit, linux_exit_tag);
 955                 lockuninit(&futex_mtx);
 956                 EMUL_LOCKUNINIT();
 957                 break;
 958         default:
 959                 break;
 960         }
 961         return error;
 962 }
 963
 964 static moduledata_t linux_elf_mod = {
 965         "linuxelf",
 966         linux_elf_modevent,
 967         0
 968 };
 969
 970 DECLARE_MODULE(linuxelf, linux_elf_mod, SI_SUB_EXEC, SI_ORDER_ANY);