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  */
  30
  31 /* XXX we use functions that might not exist. */
  32 #include "opt_compat.h"
  33
  34 #ifndef COMPAT_43
  35 #error "Unable to compile Linux-emulator due to missing COMPAT_43 option!"
  36 #endif
  37
  38 #include <sys/param.h>
  39 #include <sys/systm.h>
  40 #include <sys/imgact.h>
  41 #include <sys/imgact_aout.h>
  42 #include <sys/imgact_elf.h>
  43 #include <sys/kern_syscall.h>
  44 #include <sys/lock.h>
  45 #include <sys/malloc.h>
  46 #include <sys/proc.h>
  47 #include <sys/signalvar.h>
  48 #include <sys/sysent.h>
  49 #include <sys/sysproto.h>
  50 #include <sys/eventhandler.h>
  51
  52 #include <vm/vm.h>
  53 #include <vm/vm_param.h>
  54 #include <vm/vm_page.h>
  55 #include <vm/vm_extern.h>
  56 #include <sys/exec.h>
  57 #include <sys/kernel.h>
  58 #include <sys/module.h>
  59 #include <machine/cpu.h>
  60
  61 #include "linux.h"
  62 #include "linux_proto.h"
  63 #include "../linux_signal.h"
  64 #include "../linux_util.h"
  65 #include "../linux_futex.h"
  66 #include "../linux_emuldata.h"
  67
  68 MODULE_VERSION(linux, 1);
  69
  70 MALLOC_DEFINE(M_LINUX, "linux", "Linux mode structures");
  71
  72 #if BYTE_ORDER == LITTLE_ENDIAN
  73 #define SHELLMAGIC      0x2123 /* #! */
  74 #else
  75 #define SHELLMAGIC      0x2321
  76 #endif
  77
  78 /*
  79  * Allow the sendsig functions to use the ldebug() facility
  80  * even though they are not syscalls themselves. Map them
  81  * to syscall 0. This is slightly less bogus than using
  82  * ldebug(sigreturn).
  83  */
  84 #define LINUX_SYS_linux_rt_sendsig      0
  85 #define LINUX_SYS_linux_sendsig         0
  86
  87 extern char linux_sigcode[];
  88 extern int linux_szsigcode;
  89
  90 extern struct sysent linux_sysent[LINUX_SYS_MAXSYSCALL];
  91
  92 static int      linux_fixup (register_t **stack_base,
  93                                  struct image_params *iparams);
  94 static int      elf_linux_fixup (register_t **stack_base,
  95                                      struct image_params *iparams);
  96 static void     linux_prepsyscall (struct trapframe *tf, int *args,
  97                                        u_int *code, caddr_t *params);
  98 static void     linux_sendsig (sig_t catcher, int sig, sigset_t *mask,
  99                                    u_long code);
 100 static boolean_t linux_trans_osrel(const Elf_Note *note, int32_t *osrel);
 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->execfd != -1) {
 226                 AUXARGS_ENTRY(pos, AT_EXECFD, args->execfd);
 227         }
 228         AUXARGS_ENTRY(pos, AT_PHDR, args->phdr);
 229         AUXARGS_ENTRY(pos, AT_PHENT, args->phent);
 230         AUXARGS_ENTRY(pos, AT_PHNUM, args->phnum);
 231         AUXARGS_ENTRY(pos, AT_PAGESZ, args->pagesz);
 232         AUXARGS_ENTRY(pos, AT_FLAGS, args->flags);
 233         AUXARGS_ENTRY(pos, AT_ENTRY, args->entry);
 234         AUXARGS_ENTRY(pos, AT_BASE, args->base);
 235         AUXARGS_ENTRY(pos, AT_UID, imgp->proc->p_ucred->cr_ruid);
 236         AUXARGS_ENTRY(pos, AT_EUID, imgp->proc->p_ucred->cr_svuid);
 237         AUXARGS_ENTRY(pos, AT_GID, imgp->proc->p_ucred->cr_rgid);
 238         AUXARGS_ENTRY(pos, AT_EGID, imgp->proc->p_ucred->cr_svgid);
 239         AUXARGS_ENTRY(pos, AT_NULL, 0);
 240
 241         kfree(imgp->auxargs, M_TEMP);
 242         imgp->auxargs = NULL;
 243
 244         (*stack_base)--;
 245         **stack_base = (long)imgp->args->argc;
 246         return 0;
 247 }
 248
 249 extern int _ucodesel, _udatasel;
 250 extern unsigned long linux_sznonrtsigcode;
 251
 252 static void
 253 linux_rt_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code)
 254 {
 255         struct proc *p = curproc;
 256         struct lwp *lp = curthread->td_lwp;
 257         struct trapframe *regs;
 258         struct l_rt_sigframe *fp, frame;
 259         int oonstack;
 260
 261         regs = lp->lwp_md.md_regs;
 262         oonstack = lp->lwp_sigstk.ss_flags & SS_ONSTACK;
 263
 264 #ifdef DEBUG
 265         if (ldebug(rt_sendsig))
 266                 kprintf(ARGS(rt_sendsig, "%p, %d, %p, %lu"),
 267                     catcher, sig, (void*)mask, code);
 268 #endif
 269         /*
 270          * Allocate space for the signal handler context.
 271          */
 272         if ((lp->lwp_flags & LWP_ALTSTACK) && !oonstack &&
 273             SIGISMEMBER(p->p_sigacts->ps_sigonstack, sig)) {
 274                 fp = (struct l_rt_sigframe *)(lp->lwp_sigstk.ss_sp +
 275                     lp->lwp_sigstk.ss_size - sizeof(struct l_rt_sigframe));
 276                 lp->lwp_sigstk.ss_flags |= SS_ONSTACK;
 277         } else
 278                 fp = (struct l_rt_sigframe *)regs->tf_esp - 1;
 279
 280         /*
 281          * grow() will return FALSE if the fp will not fit inside the stack
 282          *      and the stack can not be grown. useracc will return FALSE
 283          *      if access is denied.
 284          */
 285         if ((vm_map_growstack(p, (vm_offset_t)fp) != KERN_SUCCESS) ||
 286             !useracc((caddr_t)fp, sizeof (struct l_rt_sigframe),
 287             VM_PROT_WRITE)) {
 288                 /*
 289                  * Process has trashed its stack; give it an illegal
 290                  * instruction to halt it in its tracks.
 291                  */
 292                 SIGACTION(p, SIGILL) = SIG_DFL;
 293                 SIGDELSET(p->p_sigignore, SIGILL);
 294                 SIGDELSET(p->p_sigcatch, SIGILL);
 295                 SIGDELSET(lp->lwp_sigmask, SIGILL);
 296 #ifdef DEBUG
 297                 if (ldebug(rt_sendsig))
 298                         kprintf(LMSG("rt_sendsig: bad stack %p, oonstack=%x"),
 299                             fp, oonstack);
 300 #endif
 301                 lwpsignal(p, lp, SIGILL);
 302                 return;
 303         }
 304
 305         /*
 306          * Build the argument list for the signal handler.
 307          */
 308         if (p->p_sysent->sv_sigtbl)
 309                 if (sig <= p->p_sysent->sv_sigsize)
 310                         sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
 311
 312         frame.sf_handler = catcher;
 313         frame.sf_sig = sig;
 314         frame.sf_siginfo = &fp->sf_si;
 315         frame.sf_ucontext = &fp->sf_sc;
 316
 317         /* Fill siginfo structure. */
 318         frame.sf_si.lsi_signo = sig;
 319         frame.sf_si.lsi_code = code;
 320         frame.sf_si.lsi_addr = (void *)regs->tf_err;
 321
 322         /*
 323          * Build the signal context to be used by sigreturn.
 324          */
 325         frame.sf_sc.uc_flags = 0;               /* XXX ??? */
 326         frame.sf_sc.uc_link = NULL;             /* XXX ??? */
 327
 328         frame.sf_sc.uc_stack.ss_sp = lp->lwp_sigstk.ss_sp;
 329         frame.sf_sc.uc_stack.ss_size = lp->lwp_sigstk.ss_size;
 330         frame.sf_sc.uc_stack.ss_flags = (lp->lwp_flags & LWP_ALTSTACK)
 331             ? ((oonstack) ? LINUX_SS_ONSTACK : 0) : LINUX_SS_DISABLE;
 332
 333         bsd_to_linux_sigset(mask, &frame.sf_sc.uc_sigmask);
 334
 335         frame.sf_sc.uc_mcontext.sc_mask   = frame.sf_sc.uc_sigmask.__bits[0];
 336         frame.sf_sc.uc_mcontext.sc_gs     = regs->tf_gs;
 337         frame.sf_sc.uc_mcontext.sc_fs     = regs->tf_fs;
 338         frame.sf_sc.uc_mcontext.sc_es     = regs->tf_es;
 339         frame.sf_sc.uc_mcontext.sc_ds     = regs->tf_ds;
 340         frame.sf_sc.uc_mcontext.sc_edi    = regs->tf_edi;
 341         frame.sf_sc.uc_mcontext.sc_esi    = regs->tf_esi;
 342         frame.sf_sc.uc_mcontext.sc_ebp    = regs->tf_ebp;
 343         frame.sf_sc.uc_mcontext.sc_ebx    = regs->tf_ebx;
 344         frame.sf_sc.uc_mcontext.sc_edx    = regs->tf_edx;
 345         frame.sf_sc.uc_mcontext.sc_ecx    = regs->tf_ecx;
 346         frame.sf_sc.uc_mcontext.sc_eax    = regs->tf_eax;
 347         frame.sf_sc.uc_mcontext.sc_eip    = regs->tf_eip;
 348         frame.sf_sc.uc_mcontext.sc_cs     = regs->tf_cs;
 349         frame.sf_sc.uc_mcontext.sc_eflags = regs->tf_eflags;
 350         frame.sf_sc.uc_mcontext.sc_esp_at_signal = regs->tf_esp;
 351         frame.sf_sc.uc_mcontext.sc_ss     = regs->tf_ss;
 352         frame.sf_sc.uc_mcontext.sc_err    = regs->tf_err;
 353         frame.sf_sc.uc_mcontext.sc_trapno = bsd_to_linux_trapcode(code);
 354
 355 #ifdef DEBUG
 356         if (ldebug(rt_sendsig))
 357                 kprintf(LMSG("rt_sendsig flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
 358                     frame.sf_sc.uc_stack.ss_flags, lp->lwp_sigstk.ss_sp,
 359                     lp->lwp_sigstk.ss_size, frame.sf_sc.uc_mcontext.sc_mask);
 360 #endif
 361
 362         if (copyout(&frame, fp, sizeof(frame)) != 0) {
 363                 /*
 364                  * Process has trashed its stack; give it an illegal
 365                  * instruction to halt it in its tracks.
 366                  */
 367                 sigexit(lp, SIGILL);
 368                 /* NOTREACHED */
 369         }
 370
 371         /*
 372          * Build context to run handler in.
 373          */
 374         regs->tf_esp = (int)fp;
 375         regs->tf_eip = PS_STRINGS - *(p->p_sysent->sv_szsigcode) +
 376             linux_sznonrtsigcode;
 377
 378         /*
 379          * i386 abi specifies that the direction flag must be cleared
 380          * on function entry
 381          */
 382         regs->tf_eflags &= ~(PSL_T | PSL_VM | PSL_D);
 383
 384         regs->tf_cs = _ucodesel;
 385         regs->tf_ds = _udatasel;
 386         regs->tf_es = _udatasel;
 387         /* allow %fs and %gs to be inherited by the signal handler */
 388         /*
 389         regs->tf_fs = _udatasel;
 390         regs->tf_gs = _udatasel;
 391         */
 392         regs->tf_ss = _udatasel;
 393         clear_quickret();
 394 }
 395
 396
 397 /*
 398  * Send an interrupt to process.
 399  *
 400  * Stack is set up to allow sigcode stored
 401  * in u. to call routine, followed by kcall
 402  * to sigreturn routine below.  After sigreturn
 403  * resets the signal mask, the stack, and the
 404  * frame pointer, it returns to the user
 405  * specified pc, psl.
 406  */
 407
 408 static void
 409 linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code)
 410 {
 411         struct proc *p = curproc;
 412         struct lwp *lp = curthread->td_lwp;
 413         struct trapframe *regs;
 414         struct l_sigframe *fp, frame;
 415         l_sigset_t lmask;
 416         int oonstack, i;
 417
 418         if (SIGISMEMBER(p->p_sigacts->ps_siginfo, sig)) {
 419                 /* Signal handler installed with SA_SIGINFO. */
 420                 linux_rt_sendsig(catcher, sig, mask, code);
 421                 return;
 422         }
 423
 424         regs = lp->lwp_md.md_regs;
 425         oonstack = lp->lwp_sigstk.ss_flags & SS_ONSTACK;
 426
 427 #ifdef DEBUG
 428         if (ldebug(sendsig))
 429                 kprintf(ARGS(sendsig, "%p, %d, %p, %lu"),
 430                     catcher, sig, (void*)mask, code);
 431 #endif
 432
 433         /*
 434          * Allocate space for the signal handler context.
 435          */
 436         if ((lp->lwp_flags & LWP_ALTSTACK) && !oonstack &&
 437             SIGISMEMBER(p->p_sigacts->ps_sigonstack, sig)) {
 438                 fp = (struct l_sigframe *)(lp->lwp_sigstk.ss_sp +
 439                     lp->lwp_sigstk.ss_size - sizeof(struct l_sigframe));
 440                 lp->lwp_sigstk.ss_flags |= SS_ONSTACK;
 441         } else
 442                 fp = (struct l_sigframe *)regs->tf_esp - 1;
 443
 444         /*
 445          * grow() will return FALSE if the fp will not fit inside the stack
 446          *      and the stack can not be grown. useracc will return FALSE
 447          *      if access is denied.
 448          */
 449         if ((vm_map_growstack(p, (vm_offset_t)fp) != KERN_SUCCESS) ||
 450             !useracc((caddr_t)fp, sizeof (struct l_sigframe),
 451             VM_PROT_WRITE)) {
 452                 /*
 453                  * Process has trashed its stack; give it an illegal
 454                  * instruction to halt it in its tracks.
 455                  */
 456                 SIGACTION(p, SIGILL) = SIG_DFL;
 457                 SIGDELSET(p->p_sigignore, SIGILL);
 458                 SIGDELSET(p->p_sigcatch, SIGILL);
 459                 SIGDELSET(lp->lwp_sigmask, SIGILL);
 460                 lwpsignal(p, lp, SIGILL);
 461                 return;
 462         }
 463
 464         /*
 465          * Build the argument list for the signal handler.
 466          */
 467         if (p->p_sysent->sv_sigtbl)
 468                 if (sig <= p->p_sysent->sv_sigsize)
 469                         sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
 470
 471         frame.sf_handler = catcher;
 472         frame.sf_sig = sig;
 473
 474         bsd_to_linux_sigset(mask, &lmask);
 475
 476         /*
 477          * Build the signal context to be used by sigreturn.
 478          */
 479         frame.sf_sc.sc_mask   = lmask.__bits[0];
 480         frame.sf_sc.sc_gs     = regs->tf_gs;
 481         frame.sf_sc.sc_fs     = regs->tf_fs;
 482         frame.sf_sc.sc_es     = regs->tf_es;
 483         frame.sf_sc.sc_ds     = regs->tf_ds;
 484         frame.sf_sc.sc_edi    = regs->tf_edi;
 485         frame.sf_sc.sc_esi    = regs->tf_esi;
 486         frame.sf_sc.sc_ebp    = regs->tf_ebp;
 487         frame.sf_sc.sc_ebx    = regs->tf_ebx;
 488         frame.sf_sc.sc_edx    = regs->tf_edx;
 489         frame.sf_sc.sc_ecx    = regs->tf_ecx;
 490         frame.sf_sc.sc_eax    = regs->tf_eax;
 491         frame.sf_sc.sc_eip    = regs->tf_eip;
 492         frame.sf_sc.sc_cs     = regs->tf_cs;
 493         frame.sf_sc.sc_eflags = regs->tf_eflags;
 494         frame.sf_sc.sc_esp_at_signal = regs->tf_esp;
 495         frame.sf_sc.sc_ss     = regs->tf_ss;
 496         frame.sf_sc.sc_err    = regs->tf_err;
 497         frame.sf_sc.sc_trapno = bsd_to_linux_trapcode(code);
 498
 499         bzero(&frame.sf_fpstate, sizeof(struct l_fpstate));
 500
 501         for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
 502                 frame.sf_extramask[i] = lmask.__bits[i+1];
 503
 504         if (copyout(&frame, fp, sizeof(frame)) != 0) {
 505                 /*
 506                  * Process has trashed its stack; give it an illegal
 507                  * instruction to halt it in its tracks.
 508                  */
 509                 sigexit(lp, SIGILL);
 510                 /* NOTREACHED */
 511         }
 512
 513         /*
 514          * Build context to run handler in.
 515          */
 516         regs->tf_esp = (int)fp;
 517         regs->tf_eip = PS_STRINGS - *(p->p_sysent->sv_szsigcode);
 518
 519         /*
 520          * i386 abi specifies that the direction flag must be cleared
 521          * on function entry
 522          */
 523         regs->tf_eflags &= ~(PSL_T | PSL_VM | PSL_D);
 524
 525         regs->tf_cs = _ucodesel;
 526         regs->tf_ds = _udatasel;
 527         regs->tf_es = _udatasel;
 528         /* Allow %fs and %gs to be inherited by the signal handler */
 529         /*
 530         regs->tf_fs = _udatasel;
 531         regs->tf_gs = _udatasel;
 532         */
 533         regs->tf_ss = _udatasel;
 534         clear_quickret();
 535 }
 536
 537 /*
 538  * System call to cleanup state after a signal
 539  * has been taken.  Reset signal mask and
 540  * stack state from context left by sendsig (above).
 541  * Return to previous pc and psl as specified by
 542  * context left by sendsig. Check carefully to
 543  * make sure that the user has not modified the
 544  * psl to gain improper privileges or to cause
 545  * a machine fault.
 546  *
 547  * MPSAFE
 548  */
 549 int
 550 sys_linux_sigreturn(struct linux_sigreturn_args *args)
 551 {
 552         struct lwp *lp = curthread->td_lwp;
 553         struct l_sigframe frame;
 554         struct trapframe *regs;
 555         l_sigset_t lmask;
 556         int eflags, i;
 557
 558         regs = lp->lwp_md.md_regs;
 559
 560 #ifdef DEBUG
 561         if (ldebug(sigreturn))
 562                 kprintf(ARGS(sigreturn, "%p"), (void *)args->sfp);
 563 #endif
 564         /*
 565          * The trampoline code hands us the sigframe.
 566          * It is unsafe to keep track of it ourselves, in the event that a
 567          * program jumps out of a signal handler.
 568          */
 569         if (copyin((caddr_t)args->sfp, &frame, sizeof(frame)) != 0)
 570                 return (EFAULT);
 571
 572         /*
 573          * Check for security violations.
 574          */
 575 #define EFLAGS_SECURE(ef, oef)  ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
 576         eflags = frame.sf_sc.sc_eflags;
 577         /*
 578          * XXX do allow users to change the privileged flag PSL_RF.  The
 579          * cpu sets PSL_RF in tf_eflags for faults.  Debuggers should
 580          * sometimes set it there too.  tf_eflags is kept in the signal
 581          * context during signal handling and there is no other place
 582          * to remember it, so the PSL_RF bit may be corrupted by the
 583          * signal handler without us knowing.  Corruption of the PSL_RF
 584          * bit at worst causes one more or one less debugger trap, so
 585          * allowing it is fairly harmless.
 586          */
 587         if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF)) {
 588                 return(EINVAL);
 589         }
 590
 591         /*
 592          * Don't allow users to load a valid privileged %cs.  Let the
 593          * hardware check for invalid selectors, excess privilege in
 594          * other selectors, invalid %eip's and invalid %esp's.
 595          */
 596 #define CS_SECURE(cs)   (ISPL(cs) == SEL_UPL)
 597         if (!CS_SECURE(frame.sf_sc.sc_cs)) {
 598                 trapsignal(lp, SIGBUS, T_PROTFLT);
 599                 return(EINVAL);
 600         }
 601
 602         lp->lwp_sigstk.ss_flags &= ~SS_ONSTACK;
 603         lmask.__bits[0] = frame.sf_sc.sc_mask;
 604         for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
 605                 lmask.__bits[i+1] = frame.sf_extramask[i];
 606         linux_to_bsd_sigset(&lmask, &lp->lwp_sigmask);
 607         SIG_CANTMASK(lp->lwp_sigmask);
 608
 609         /*
 610          * Restore signal context.
 611          */
 612         /* %gs was restored by the trampoline. */
 613         regs->tf_fs     = frame.sf_sc.sc_fs;
 614         regs->tf_es     = frame.sf_sc.sc_es;
 615         regs->tf_ds     = frame.sf_sc.sc_ds;
 616         regs->tf_edi    = frame.sf_sc.sc_edi;
 617         regs->tf_esi    = frame.sf_sc.sc_esi;
 618         regs->tf_ebp    = frame.sf_sc.sc_ebp;
 619         regs->tf_ebx    = frame.sf_sc.sc_ebx;
 620         regs->tf_edx    = frame.sf_sc.sc_edx;
 621         regs->tf_ecx    = frame.sf_sc.sc_ecx;
 622         regs->tf_eax    = frame.sf_sc.sc_eax;
 623         regs->tf_eip    = frame.sf_sc.sc_eip;
 624         regs->tf_cs     = frame.sf_sc.sc_cs;
 625         regs->tf_eflags = eflags;
 626         regs->tf_esp    = frame.sf_sc.sc_esp_at_signal;
 627         regs->tf_ss     = frame.sf_sc.sc_ss;
 628         clear_quickret();
 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         clear_quickret();
 741
 742         return (EJUSTRETURN);
 743 }
 744
 745 /*
 746  * Prep arguments.
 747  *
 748  * MUST BE MPSAFE
 749  */
 750 static void
 751 linux_prepsyscall(struct trapframe *tf, int *args, u_int *code, caddr_t *params)
 752 {
 753         args[0] = tf->tf_ebx;
 754         args[1] = tf->tf_ecx;
 755         args[2] = tf->tf_edx;
 756         args[3] = tf->tf_esi;
 757         args[4] = tf->tf_edi;
 758         args[5] = tf->tf_ebp;
 759         *params = NULL;         /* no copyin */
 760 }
 761
 762 /*
 763  * If a linux binary is exec'ing something, try this image activator
 764  * first.  We override standard shell script execution in order to
 765  * be able to modify the interpreter path.  We only do this if a linux
 766  * binary is doing the exec, so we do not create an EXEC module for it.
 767  */
 768 static int      exec_linux_imgact_try (struct image_params *iparams);
 769
 770 static int
 771 exec_linux_imgact_try(struct image_params *imgp)
 772 {
 773     const char *head = (const char *)imgp->image_header;
 774     int error = -1;
 775
 776     /*
 777      * The interpreter for shell scripts run from a linux binary needs
 778      * to be located in /compat/linux if possible in order to recursively
 779      * maintain linux path emulation.
 780      */
 781     if (((const short *)head)[0] == SHELLMAGIC) {
 782             /*
 783              * Run our normal shell image activator.  If it succeeds attempt
 784              * to use the alternate path for the interpreter.  If an alternate
 785              * path is found, use our stringspace to store it.
 786              */
 787             if ((error = exec_shell_imgact(imgp)) == 0) {
 788                     linux_translate_path(imgp->interpreter_name,
 789                         MAXSHELLCMDLEN);
 790             }
 791     }
 792     return(error);
 793 }
 794
 795 struct sysentvec linux_sysvec = {
 796         .sv_size        = LINUX_SYS_MAXSYSCALL,
 797         .sv_table       = linux_sysent,
 798         .sv_mask        = 0xffffffff,
 799         .sv_sigsize     = LINUX_SIGTBLSZ,
 800         .sv_sigtbl      = bsd_to_linux_signal,
 801         .sv_errsize     = ELAST + 1,
 802         .sv_errtbl      = bsd_to_linux_errno,
 803         .sv_transtrap   = translate_traps,
 804         .sv_fixup       = linux_fixup,
 805         .sv_sendsig     = linux_sendsig,
 806         .sv_sigcode     = linux_sigcode,
 807         .sv_szsigcode   = &linux_szsigcode,
 808         .sv_prepsyscall = linux_prepsyscall,
 809         .sv_name        = "Linux a.out",
 810         .sv_coredump    = NULL,
 811         .sv_imgact_try  = exec_linux_imgact_try,
 812         .sv_minsigstksz = LINUX_MINSIGSTKSZ
 813 };
 814
 815 struct sysentvec elf_linux_sysvec = {
 816         .sv_size        = LINUX_SYS_MAXSYSCALL,
 817         .sv_table       = linux_sysent,
 818         .sv_mask        = 0xffffffff,
 819         .sv_sigsize     = LINUX_SIGTBLSZ,
 820         .sv_sigtbl      = bsd_to_linux_signal,
 821         .sv_errsize     = ELAST + 1,
 822         .sv_errtbl      = bsd_to_linux_errno,
 823         .sv_transtrap   = translate_traps,
 824         .sv_fixup       = elf_linux_fixup,
 825         .sv_sendsig     = linux_sendsig,
 826         .sv_sigcode     = linux_sigcode,
 827         .sv_szsigcode   = &linux_szsigcode,
 828         .sv_prepsyscall = linux_prepsyscall,
 829         .sv_name        = "Linux ELF32",
 830         .sv_coredump    = elf32_coredump,
 831         .sv_imgact_try  = exec_linux_imgact_try,
 832         .sv_minsigstksz = LINUX_MINSIGSTKSZ
 833 };
 834
 835 static const char GNU_ABI_VENDOR[] = "GNU";
 836 static const char SUSE_ABI_VENDOR[] = "SuSE";
 837 static int        GNULINUX_ABI_DESC = 0;
 838
 839 static boolean_t
 840 linux_trans_osrel(const Elf_Note *note, int32_t *osrel)
 841 {
 842         const Elf32_Word *desc;
 843         uintptr_t p;
 844
 845         p = (uintptr_t)(note + 1);
 846         p += roundup2(note->n_namesz, sizeof(Elf32_Addr));
 847
 848         desc = (const Elf32_Word *)p;
 849         if (desc[0] != GNULINUX_ABI_DESC)
 850                 return (FALSE);
 851         /*
 852          * For Linux we encode osrel as follows:
 853          * VVVMMMIII (version, major, minor)
 854          */
 855         *osrel = desc[1] * 1000000 +
 856                  desc[2] * 1000 +
 857                  desc[3];
 858
 859         return (TRUE);
 860 }
 861
 862 static Elf_Brandnote linux32_generic_brandnote = {
 863         .hdr.n_namesz   = sizeof(GNU_ABI_VENDOR),
 864         .hdr.n_descsz   = 16,
 865         .hdr.n_type     = 1,
 866         .vendor         = GNU_ABI_VENDOR,
 867         .flags          = BN_TRANSLATE_OSREL,
 868         .trans_osrel    = linux_trans_osrel,
 869 };
 870
 871 static Elf_Brandnote linux32_suse_brandnote = {
 872         .hdr.n_namesz   = sizeof(SUSE_ABI_VENDOR),
 873         .hdr.n_descsz   = 16,
 874         .hdr.n_type     = 1,
 875         .vendor         = SUSE_ABI_VENDOR,
 876         .flags          = BN_TRANSLATE_OSREL,
 877         .trans_osrel    = linux_trans_osrel,
 878 };
 879
 880 static Elf32_Brandinfo linux32_brand = {
 881         .brand          = ELFOSABI_LINUX,
 882         .machine        = EM_386,
 883         .compat_3_brand = "Linux",
 884         .emul_path      = "/compat/linux",
 885         .interp_path    = "/lib/ld-linux.so.1",
 886         .sysvec         = &elf_linux_sysvec,
 887         .interp_newpath = NULL,
 888         .flags          = BI_CAN_EXEC_DYN | BI_BRAND_NOTE,
 889         .brand_note     = &linux32_generic_brandnote,
 890 };
 891
 892 static Elf32_Brandinfo linux32_glibc2_brand = {
 893         .brand          = ELFOSABI_LINUX,
 894         .machine        = EM_386,
 895         .compat_3_brand = "Linux",
 896         .emul_path      = "/compat/linux",
 897         .interp_path    = "/lib/ld-linux.so.2",
 898         .sysvec         = &elf_linux_sysvec,
 899         .interp_newpath = NULL,
 900         .flags          = BI_CAN_EXEC_DYN | BI_BRAND_NOTE,
 901         .brand_note     = &linux32_generic_brandnote,
 902 };
 903
 904 static Elf32_Brandinfo linux32_suse_brand = {
 905         .brand          = ELFOSABI_LINUX,
 906         .machine        = EM_386,
 907         .compat_3_brand = "Linux",
 908         .emul_path      = "/compat/linux",
 909         .interp_path    = "/lib/ld-linux.so.2",
 910         .sysvec         = &elf_linux_sysvec,
 911         .interp_newpath = NULL,
 912         .flags          = BI_CAN_EXEC_DYN | BI_BRAND_NOTE,
 913         .brand_note     = &linux32_suse_brandnote,
 914 };
 915
 916 Elf32_Brandinfo *linux_brandlist[] = {
 917         &linux32_brand,
 918         &linux32_glibc2_brand,
 919         &linux32_suse_brand,
 920         NULL
 921 };
 922
 923 static int
 924 linux_elf_modevent(module_t mod, int type, void *data)
 925 {
 926         Elf32_Brandinfo **brandinfo;
 927         int error;
 928
 929         error = 0;
 930
 931         switch(type) {
 932         case MOD_LOAD:
 933                 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
 934                      ++brandinfo)
 935                         if (elf32_insert_brand_entry(*brandinfo) < 0)
 936                                 error = EINVAL;
 937                 if (error == 0) {
 938                         if (bootverbose)
 939                                 kprintf("Linux ELF exec handler installed\n");
 940                 } else {
 941                         kprintf("cannot insert Linux ELF brand handler\n");
 942                 }
 943                 EMUL_LOCKINIT();
 944                 lockinit(&futex_mtx, "linftxs", 0, LK_CANRECURSE);
 945                 linux_exec_tag = EVENTHANDLER_REGISTER(process_exec, linux_proc_transition,
 946                     NULL, 1000);
 947                 linux_exit_tag = EVENTHANDLER_REGISTER(process_exit, emuldata_exit,
 948                     NULL, 1000);
 949                 break;
 950         case MOD_UNLOAD:
 951                 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
 952                      ++brandinfo)
 953                         if (elf32_brand_inuse(*brandinfo))
 954                                 error = EBUSY;
 955                 if (error == 0) {
 956                         for (brandinfo = &linux_brandlist[0];
 957                              *brandinfo != NULL; ++brandinfo)
 958                                 if (elf32_remove_brand_entry(*brandinfo) < 0)
 959                                         error = EINVAL;
 960                 }
 961                 if (error == 0) {
 962                         if (bootverbose)
 963                                 kprintf("Linux ELF exec handler removed\n");
 964                 } else {
 965                         kprintf("Could not deinstall ELF interpreter entry\n");
 966                 }
 967                 EVENTHANDLER_DEREGISTER(process_exec, linux_exec_tag);
 968                 EVENTHANDLER_DEREGISTER(process_exit, linux_exit_tag);
 969                 lockuninit(&futex_mtx);
 970                 EMUL_LOCKUNINIT();
 971                 break;
 972         default:
 973                 break;
 974         }
 975         return error;
 976 }
 977
 978 static moduledata_t linux_elf_mod = {
 979         "linuxelf",
 980         linux_elf_modevent,
 981         0
 982 };
 983
 984 DECLARE_MODULE(linuxelf, linux_elf_mod, SI_SUB_EXEC, SI_ORDER_ANY);