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.16 2004/08/15 14:15:00 joerg 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         free(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                 printf(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                         printf(LMSG("rt_sendsig: bad stack %p, oonstack=%x"),
 293                             fp, oonstack);
 294 #endif
 295                 psignal(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                 printf(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                 printf(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                 psignal(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 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                 printf(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 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                 printf(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                 printf(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 static void
 711 linux_prepsyscall(struct trapframe *tf, int *args, u_int *code, caddr_t *params)
 712 {
 713         args[0] = tf->tf_ebx;
 714         args[1] = tf->tf_ecx;
 715         args[2] = tf->tf_edx;
 716         args[3] = tf->tf_esi;
 717         args[4] = tf->tf_edi;
 718         args[5] = tf->tf_ebp;
 719         *params = NULL;         /* no copyin */
 720 }
 721
 722 /*
 723  * If a linux binary is exec'ing something, try this image activator
 724  * first.  We override standard shell script execution in order to
 725  * be able to modify the interpreter path.  We only do this if a linux
 726  * binary is doing the exec, so we do not create an EXEC module for it.
 727  */
 728 static int      exec_linux_imgact_try (struct image_params *iparams);
 729
 730 static int
 731 exec_linux_imgact_try(imgp)
 732     struct image_params *imgp;
 733 {
 734     const char *head = (const char *)imgp->image_header;
 735     int error = -1;
 736
 737     /*
 738      * The interpreter for shell scripts run from a linux binary needs
 739      * to be located in /compat/linux if possible in order to recursively
 740      * maintain linux path emulation.
 741      */
 742     if (((const short *)head)[0] == SHELLMAGIC) {
 743             /*
 744              * Run our normal shell image activator.  If it succeeds attempt
 745              * to use the alternate path for the interpreter.  If an alternate
 746              * path is found, use our stringspace to store it.
 747              */
 748             if ((error = exec_shell_imgact(imgp)) == 0) {
 749                     linux_translate_path(imgp->interpreter_name,
 750                         MAXSHELLCMDLEN);
 751             }
 752     }
 753     return(error);
 754 }
 755
 756 struct sysentvec linux_sysvec = {
 757         LINUX_SYS_MAXSYSCALL,
 758         linux_sysent,
 759         0xff,
 760         LINUX_SIGTBLSZ,
 761         bsd_to_linux_signal,
 762         ELAST + 1,
 763         bsd_to_linux_errno,
 764         translate_traps,
 765         linux_fixup,
 766         linux_sendsig,
 767         linux_sigcode,
 768         &linux_szsigcode,
 769         linux_prepsyscall,
 770         "Linux a.out",
 771         aout_coredump,
 772         exec_linux_imgact_try,
 773         LINUX_MINSIGSTKSZ
 774 };
 775
 776 struct sysentvec elf_linux_sysvec = {
 777         LINUX_SYS_MAXSYSCALL,
 778         linux_sysent,
 779         0xff,
 780         LINUX_SIGTBLSZ,
 781         bsd_to_linux_signal,
 782         ELAST + 1,
 783         bsd_to_linux_errno,
 784         translate_traps,
 785         elf_linux_fixup,
 786         linux_sendsig,
 787         linux_sigcode,
 788         &linux_szsigcode,
 789         linux_prepsyscall,
 790         "Linux ELF",
 791         elf_coredump,
 792         exec_linux_imgact_try,
 793         LINUX_MINSIGSTKSZ
 794 };
 795
 796 static Elf32_Brandinfo linux_brand = {
 797                                         ELFOSABI_LINUX,
 798                                         "Linux",
 799                                         "/compat/linux",
 800                                         "/lib/ld-linux.so.1",
 801                                         &elf_linux_sysvec
 802                                  };
 803
 804 static Elf32_Brandinfo linux_glibc2brand = {
 805                                         ELFOSABI_LINUX,
 806                                         "Linux",
 807                                         "/compat/linux",
 808                                         "/lib/ld-linux.so.2",
 809                                         &elf_linux_sysvec
 810                                  };
 811
 812 Elf32_Brandinfo *linux_brandlist[] = {
 813                                         &linux_brand,
 814                                         &linux_glibc2brand,
 815                                         NULL
 816                                 };
 817
 818 static int
 819 linux_elf_modevent(module_t mod, int type, void *data)
 820 {
 821         Elf32_Brandinfo **brandinfo;
 822         int error;
 823
 824         error = 0;
 825
 826         switch(type) {
 827         case MOD_LOAD:
 828                 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
 829                      ++brandinfo)
 830                         if (elf_insert_brand_entry(*brandinfo) < 0)
 831                                 error = EINVAL;
 832                 if (error == 0) {
 833                         if (bootverbose)
 834                                 printf("Linux ELF exec handler installed\n");
 835                 } else
 836                         printf("cannot insert Linux ELF brand handler\n");
 837                 break;
 838         case MOD_UNLOAD:
 839                 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
 840                      ++brandinfo)
 841                         if (elf_brand_inuse(*brandinfo))
 842                                 error = EBUSY;
 843                 if (error == 0) {
 844                         for (brandinfo = &linux_brandlist[0];
 845                              *brandinfo != NULL; ++brandinfo)
 846                                 if (elf_remove_brand_entry(*brandinfo) < 0)
 847                                         error = EINVAL;
 848                 }
 849                 if (error == 0) {
 850                         if (bootverbose)
 851                                 printf("Linux ELF exec handler removed\n");
 852                 } else
 853                         printf("Could not deinstall ELF interpreter entry\n");
 854                 break;
 855         default:
 856                 break;
 857         }
 858         return error;
 859 }
 860
 861 static moduledata_t linux_elf_mod = {
 862         "linuxelf",
 863         linux_elf_modevent,
 864         0
 865 };
 866
 867 DECLARE_MODULE(linuxelf, linux_elf_mod, SI_SUB_EXEC, SI_ORDER_ANY);