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