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