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.14 2003/11/14 21:18:41 daver 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 SET_DECLARE(linux_ioctl_handler_set, struct linux_ioctl_handler);
  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         free(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 trapframe *regs;
 254         struct l_rt_sigframe *fp, frame;
 255         int oonstack;
 256
 257         regs = p->p_md.md_regs;
 258         oonstack = p->p_sigstk.ss_flags & SS_ONSTACK;
 259
 260 #ifdef DEBUG
 261         if (ldebug(rt_sendsig))
 262                 printf(ARGS(rt_sendsig, "%p, %d, %p, %lu"),
 263                     catcher, sig, (void*)mask, code);
 264 #endif
 265         /*
 266          * Allocate space for the signal handler context.
 267          */
 268         if ((p->p_flag & P_ALTSTACK) && !oonstack &&
 269             SIGISMEMBER(p->p_sigacts->ps_sigonstack, sig)) {
 270                 fp = (struct l_rt_sigframe *)(p->p_sigstk.ss_sp +
 271                     p->p_sigstk.ss_size - sizeof(struct l_rt_sigframe));
 272                 p->p_sigstk.ss_flags |= SS_ONSTACK;
 273         } else
 274                 fp = (struct l_rt_sigframe *)regs->tf_esp - 1;
 275
 276         /*
 277          * grow() will return FALSE if the fp will not fit inside the stack
 278          *      and the stack can not be grown. useracc will return FALSE
 279          *      if access is denied.
 280          */
 281         if ((grow_stack (p, (int)fp) == FALSE) ||
 282             !useracc((caddr_t)fp, sizeof (struct l_rt_sigframe),
 283             VM_PROT_WRITE)) {
 284                 /*
 285                  * Process has trashed its stack; give it an illegal
 286                  * instruction to halt it in its tracks.
 287                  */
 288                 SIGACTION(p, SIGILL) = SIG_DFL;
 289                 SIGDELSET(p->p_sigignore, SIGILL);
 290                 SIGDELSET(p->p_sigcatch, SIGILL);
 291                 SIGDELSET(p->p_sigmask, SIGILL);
 292 #ifdef DEBUG
 293                 if (ldebug(rt_sendsig))
 294                         printf(LMSG("rt_sendsig: bad stack %p, oonstack=%x"),
 295                             fp, oonstack);
 296 #endif
 297                 psignal(p, SIGILL);
 298                 return;
 299         }
 300
 301         /*
 302          * Build the argument list for the signal handler.
 303          */
 304         if (p->p_sysent->sv_sigtbl)
 305                 if (sig <= p->p_sysent->sv_sigsize)
 306                         sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
 307
 308         frame.sf_handler = catcher;
 309         frame.sf_sig = sig;
 310         frame.sf_siginfo = &fp->sf_si;
 311         frame.sf_ucontext = &fp->sf_sc;
 312
 313         /* Fill siginfo structure. */
 314         frame.sf_si.lsi_signo = sig;
 315         frame.sf_si.lsi_code = code;
 316         frame.sf_si.lsi_addr = (void *)regs->tf_err;
 317
 318         /*
 319          * Build the signal context to be used by sigreturn.
 320          */
 321         frame.sf_sc.uc_flags = 0;               /* XXX ??? */
 322         frame.sf_sc.uc_link = NULL;             /* XXX ??? */
 323
 324         frame.sf_sc.uc_stack.ss_sp = p->p_sigstk.ss_sp;
 325         frame.sf_sc.uc_stack.ss_size = p->p_sigstk.ss_size;
 326         frame.sf_sc.uc_stack.ss_flags = (p->p_flag & P_ALTSTACK)
 327             ? ((oonstack) ? LINUX_SS_ONSTACK : 0) : LINUX_SS_DISABLE;
 328
 329         bsd_to_linux_sigset(mask, &frame.sf_sc.uc_sigmask);
 330
 331         frame.sf_sc.uc_mcontext.sc_mask   = frame.sf_sc.uc_sigmask.__bits[0];
 332         frame.sf_sc.uc_mcontext.sc_gs     = rgs();
 333         frame.sf_sc.uc_mcontext.sc_fs     = regs->tf_fs;
 334         frame.sf_sc.uc_mcontext.sc_es     = regs->tf_es;
 335         frame.sf_sc.uc_mcontext.sc_ds     = regs->tf_ds;
 336         frame.sf_sc.uc_mcontext.sc_edi    = regs->tf_edi;
 337         frame.sf_sc.uc_mcontext.sc_esi    = regs->tf_esi;
 338         frame.sf_sc.uc_mcontext.sc_ebp    = regs->tf_ebp;
 339         frame.sf_sc.uc_mcontext.sc_ebx    = regs->tf_ebx;
 340         frame.sf_sc.uc_mcontext.sc_edx    = regs->tf_edx;
 341         frame.sf_sc.uc_mcontext.sc_ecx    = regs->tf_ecx;
 342         frame.sf_sc.uc_mcontext.sc_eax    = regs->tf_eax;
 343         frame.sf_sc.uc_mcontext.sc_eip    = regs->tf_eip;
 344         frame.sf_sc.uc_mcontext.sc_cs     = regs->tf_cs;
 345         frame.sf_sc.uc_mcontext.sc_eflags = regs->tf_eflags;
 346         frame.sf_sc.uc_mcontext.sc_esp_at_signal = regs->tf_esp;
 347         frame.sf_sc.uc_mcontext.sc_ss     = regs->tf_ss;
 348         frame.sf_sc.uc_mcontext.sc_err    = regs->tf_err;
 349         frame.sf_sc.uc_mcontext.sc_trapno = bsd_to_linux_trapcode(code);
 350
 351 #ifdef DEBUG
 352         if (ldebug(rt_sendsig))
 353                 printf(LMSG("rt_sendsig flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
 354                     frame.sf_sc.uc_stack.ss_flags, p->p_sigstk.ss_sp,
 355                     p->p_sigstk.ss_size, frame.sf_sc.uc_mcontext.sc_mask);
 356 #endif
 357
 358         if (copyout(&frame, fp, sizeof(frame)) != 0) {
 359                 /*
 360                  * Process has trashed its stack; give it an illegal
 361                  * instruction to halt it in its tracks.
 362                  */
 363                 sigexit(p, SIGILL);
 364                 /* NOTREACHED */
 365         }
 366
 367         /*
 368          * Build context to run handler in.
 369          */
 370         regs->tf_esp = (int)fp;
 371         regs->tf_eip = PS_STRINGS - *(p->p_sysent->sv_szsigcode) +
 372             linux_sznonrtsigcode;
 373         regs->tf_eflags &= ~(PSL_T | PSL_VM);
 374         regs->tf_cs = _ucodesel;
 375         regs->tf_ds = _udatasel;
 376         regs->tf_es = _udatasel;
 377         regs->tf_fs = _udatasel;
 378         regs->tf_ss = _udatasel;
 379 }
 380
 381
 382 /*
 383  * Send an interrupt to process.
 384  *
 385  * Stack is set up to allow sigcode stored
 386  * in u. to call routine, followed by kcall
 387  * to sigreturn routine below.  After sigreturn
 388  * resets the signal mask, the stack, and the
 389  * frame pointer, it returns to the user
 390  * specified pc, psl.
 391  */
 392
 393 static void
 394 linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code)
 395 {
 396         struct proc *p = curproc;
 397         struct trapframe *regs;
 398         struct l_sigframe *fp, frame;
 399         l_sigset_t lmask;
 400         int oonstack, i;
 401
 402         if (SIGISMEMBER(p->p_sigacts->ps_siginfo, sig)) {
 403                 /* Signal handler installed with SA_SIGINFO. */
 404                 linux_rt_sendsig(catcher, sig, mask, code);
 405                 return;
 406         }
 407
 408         regs = p->p_md.md_regs;
 409         oonstack = p->p_sigstk.ss_flags & SS_ONSTACK;
 410
 411 #ifdef DEBUG
 412         if (ldebug(sendsig))
 413                 printf(ARGS(sendsig, "%p, %d, %p, %lu"),
 414                     catcher, sig, (void*)mask, code);
 415 #endif
 416
 417         /*
 418          * Allocate space for the signal handler context.
 419          */
 420         if ((p->p_flag & P_ALTSTACK) && !oonstack &&
 421             SIGISMEMBER(p->p_sigacts->ps_sigonstack, sig)) {
 422                 fp = (struct l_sigframe *)(p->p_sigstk.ss_sp +
 423                     p->p_sigstk.ss_size - sizeof(struct l_sigframe));
 424                 p->p_sigstk.ss_flags |= SS_ONSTACK;
 425         } else
 426                 fp = (struct l_sigframe *)regs->tf_esp - 1;
 427
 428         /*
 429          * grow() will return FALSE if the fp will not fit inside the stack
 430          *      and the stack can not be grown. useracc will return FALSE
 431          *      if access is denied.
 432          */
 433         if ((grow_stack (p, (int)fp) == FALSE) ||
 434             !useracc((caddr_t)fp, sizeof (struct l_sigframe),
 435             VM_PROT_WRITE)) {
 436                 /*
 437                  * Process has trashed its stack; give it an illegal
 438                  * instruction to halt it in its tracks.
 439                  */
 440                 SIGACTION(p, SIGILL) = SIG_DFL;
 441                 SIGDELSET(p->p_sigignore, SIGILL);
 442                 SIGDELSET(p->p_sigcatch, SIGILL);
 443                 SIGDELSET(p->p_sigmask, SIGILL);
 444                 psignal(p, SIGILL);
 445                 return;
 446         }
 447
 448         /*
 449          * Build the argument list for the signal handler.
 450          */
 451         if (p->p_sysent->sv_sigtbl)
 452                 if (sig <= p->p_sysent->sv_sigsize)
 453                         sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
 454
 455         frame.sf_handler = catcher;
 456         frame.sf_sig = sig;
 457
 458         bsd_to_linux_sigset(mask, &lmask);
 459
 460         /*
 461          * Build the signal context to be used by sigreturn.
 462          */
 463         frame.sf_sc.sc_mask   = lmask.__bits[0];
 464         frame.sf_sc.sc_gs     = rgs();
 465         frame.sf_sc.sc_fs     = regs->tf_fs;
 466         frame.sf_sc.sc_es     = regs->tf_es;
 467         frame.sf_sc.sc_ds     = regs->tf_ds;
 468         frame.sf_sc.sc_edi    = regs->tf_edi;
 469         frame.sf_sc.sc_esi    = regs->tf_esi;
 470         frame.sf_sc.sc_ebp    = regs->tf_ebp;
 471         frame.sf_sc.sc_ebx    = regs->tf_ebx;
 472         frame.sf_sc.sc_edx    = regs->tf_edx;
 473         frame.sf_sc.sc_ecx    = regs->tf_ecx;
 474         frame.sf_sc.sc_eax    = regs->tf_eax;
 475         frame.sf_sc.sc_eip    = regs->tf_eip;
 476         frame.sf_sc.sc_cs     = regs->tf_cs;
 477         frame.sf_sc.sc_eflags = regs->tf_eflags;
 478         frame.sf_sc.sc_esp_at_signal = regs->tf_esp;
 479         frame.sf_sc.sc_ss     = regs->tf_ss;
 480         frame.sf_sc.sc_err    = regs->tf_err;
 481         frame.sf_sc.sc_trapno = bsd_to_linux_trapcode(code);
 482
 483         bzero(&frame.sf_fpstate, sizeof(struct l_fpstate));
 484
 485         for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
 486                 frame.sf_extramask[i] = lmask.__bits[i+1];
 487
 488         if (copyout(&frame, fp, sizeof(frame)) != 0) {
 489                 /*
 490                  * Process has trashed its stack; give it an illegal
 491                  * instruction to halt it in its tracks.
 492                  */
 493                 sigexit(p, SIGILL);
 494                 /* NOTREACHED */
 495         }
 496
 497         /*
 498          * Build context to run handler in.
 499          */
 500         regs->tf_esp = (int)fp;
 501         regs->tf_eip = PS_STRINGS - *(p->p_sysent->sv_szsigcode);
 502         regs->tf_eflags &= ~(PSL_T | PSL_VM);
 503         regs->tf_cs = _ucodesel;
 504         regs->tf_ds = _udatasel;
 505         regs->tf_es = _udatasel;
 506         regs->tf_fs = _udatasel;
 507         regs->tf_ss = _udatasel;
 508 }
 509
 510 /*
 511  * System call to cleanup state after a signal
 512  * has been taken.  Reset signal mask and
 513  * stack state from context left by sendsig (above).
 514  * Return to previous pc and psl as specified by
 515  * context left by sendsig. Check carefully to
 516  * make sure that the user has not modified the
 517  * psl to gain improper privileges or to cause
 518  * a machine fault.
 519  */
 520 int
 521 linux_sigreturn(struct linux_sigreturn_args *args)
 522 {
 523         struct proc *p = curproc;
 524         struct l_sigframe frame;
 525         struct trapframe *regs;
 526         l_sigset_t lmask;
 527         int eflags, i;
 528
 529         regs = p->p_md.md_regs;
 530
 531 #ifdef DEBUG
 532         if (ldebug(sigreturn))
 533                 printf(ARGS(sigreturn, "%p"), (void *)args->sfp);
 534 #endif
 535         /*
 536          * The trampoline code hands us the sigframe.
 537          * It is unsafe to keep track of it ourselves, in the event that a
 538          * program jumps out of a signal handler.
 539          */
 540         if (copyin((caddr_t)args->sfp, &frame, sizeof(frame)) != 0)
 541                 return (EFAULT);
 542
 543         /*
 544          * Check for security violations.
 545          */
 546 #define EFLAGS_SECURE(ef, oef)  ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
 547         eflags = frame.sf_sc.sc_eflags;
 548         /*
 549          * XXX do allow users to change the privileged flag PSL_RF.  The
 550          * cpu sets PSL_RF in tf_eflags for faults.  Debuggers should
 551          * sometimes set it there too.  tf_eflags is kept in the signal
 552          * context during signal handling and there is no other place
 553          * to remember it, so the PSL_RF bit may be corrupted by the
 554          * signal handler without us knowing.  Corruption of the PSL_RF
 555          * bit at worst causes one more or one less debugger trap, so
 556          * allowing it is fairly harmless.
 557          */
 558         if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF)) {
 559                 return(EINVAL);
 560         }
 561
 562         /*
 563          * Don't allow users to load a valid privileged %cs.  Let the
 564          * hardware check for invalid selectors, excess privilege in
 565          * other selectors, invalid %eip's and invalid %esp's.
 566          */
 567 #define CS_SECURE(cs)   (ISPL(cs) == SEL_UPL)
 568         if (!CS_SECURE(frame.sf_sc.sc_cs)) {
 569                 trapsignal(p, SIGBUS, T_PROTFLT);
 570                 return(EINVAL);
 571         }
 572
 573         p->p_sigstk.ss_flags &= ~SS_ONSTACK;
 574         lmask.__bits[0] = frame.sf_sc.sc_mask;
 575         for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
 576                 lmask.__bits[i+1] = frame.sf_extramask[i];
 577         linux_to_bsd_sigset(&lmask, &p->p_sigmask);
 578         SIG_CANTMASK(p->p_sigmask);
 579
 580         /*
 581          * Restore signal context.
 582          */
 583         /* %gs was restored by the trampoline. */
 584         regs->tf_fs     = frame.sf_sc.sc_fs;
 585         regs->tf_es     = frame.sf_sc.sc_es;
 586         regs->tf_ds     = frame.sf_sc.sc_ds;
 587         regs->tf_edi    = frame.sf_sc.sc_edi;
 588         regs->tf_esi    = frame.sf_sc.sc_esi;
 589         regs->tf_ebp    = frame.sf_sc.sc_ebp;
 590         regs->tf_ebx    = frame.sf_sc.sc_ebx;
 591         regs->tf_edx    = frame.sf_sc.sc_edx;
 592         regs->tf_ecx    = frame.sf_sc.sc_ecx;
 593         regs->tf_eax    = frame.sf_sc.sc_eax;
 594         regs->tf_eip    = frame.sf_sc.sc_eip;
 595         regs->tf_cs     = frame.sf_sc.sc_cs;
 596         regs->tf_eflags = eflags;
 597         regs->tf_esp    = frame.sf_sc.sc_esp_at_signal;
 598         regs->tf_ss     = frame.sf_sc.sc_ss;
 599
 600         return (EJUSTRETURN);
 601 }
 602
 603 /*
 604  * System call to cleanup state after a signal
 605  * has been taken.  Reset signal mask and
 606  * stack state from context left by rt_sendsig (above).
 607  * Return to previous pc and psl as specified by
 608  * context left by sendsig. Check carefully to
 609  * make sure that the user has not modified the
 610  * psl to gain improper privileges or to cause
 611  * a machine fault.
 612  */
 613 int
 614 linux_rt_sigreturn(struct linux_rt_sigreturn_args *args)
 615 {
 616         struct proc *p = curproc;
 617         struct l_ucontext uc;
 618         struct l_sigcontext *context;
 619         l_stack_t *lss;
 620         stack_t ss;
 621         struct trapframe *regs;
 622         int eflags;
 623
 624         regs = p->p_md.md_regs;
 625
 626 #ifdef DEBUG
 627         if (ldebug(rt_sigreturn))
 628                 printf(ARGS(rt_sigreturn, "%p"), (void *)args->ucp);
 629 #endif
 630         /*
 631          * The trampoline code hands us the ucontext.
 632          * It is unsafe to keep track of it ourselves, in the event that a
 633          * program jumps out of a signal handler.
 634          */
 635         if (copyin((caddr_t)args->ucp, &uc, sizeof(uc)) != 0)
 636                 return (EFAULT);
 637
 638         context = &uc.uc_mcontext;
 639
 640         /*
 641          * Check for security violations.
 642          */
 643 #define EFLAGS_SECURE(ef, oef)  ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
 644         eflags = context->sc_eflags;
 645         /*
 646          * XXX do allow users to change the privileged flag PSL_RF.  The
 647          * cpu sets PSL_RF in tf_eflags for faults.  Debuggers should
 648          * sometimes set it there too.  tf_eflags is kept in the signal
 649          * context during signal handling and there is no other place
 650          * to remember it, so the PSL_RF bit may be corrupted by the
 651          * signal handler without us knowing.  Corruption of the PSL_RF
 652          * bit at worst causes one more or one less debugger trap, so
 653          * allowing it is fairly harmless.
 654          */
 655         if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF)) {
 656                 return(EINVAL);
 657         }
 658
 659         /*
 660          * Don't allow users to load a valid privileged %cs.  Let the
 661          * hardware check for invalid selectors, excess privilege in
 662          * other selectors, invalid %eip's and invalid %esp's.
 663          */
 664 #define CS_SECURE(cs)   (ISPL(cs) == SEL_UPL)
 665         if (!CS_SECURE(context->sc_cs)) {
 666                 trapsignal(p, SIGBUS, T_PROTFLT);
 667                 return(EINVAL);
 668         }
 669
 670         p->p_sigstk.ss_flags &= ~SS_ONSTACK;
 671         linux_to_bsd_sigset(&uc.uc_sigmask, &p->p_sigmask);
 672         SIG_CANTMASK(p->p_sigmask);
 673
 674         /*
 675          * Restore signal context
 676          */
 677         /* %gs was restored by the trampoline. */
 678         regs->tf_fs     = context->sc_fs;
 679         regs->tf_es     = context->sc_es;
 680         regs->tf_ds     = context->sc_ds;
 681         regs->tf_edi    = context->sc_edi;
 682         regs->tf_esi    = context->sc_esi;
 683         regs->tf_ebp    = context->sc_ebp;
 684         regs->tf_ebx    = context->sc_ebx;
 685         regs->tf_edx    = context->sc_edx;
 686         regs->tf_ecx    = context->sc_ecx;
 687         regs->tf_eax    = context->sc_eax;
 688         regs->tf_eip    = context->sc_eip;
 689         regs->tf_cs     = context->sc_cs;
 690         regs->tf_eflags = eflags;
 691         regs->tf_esp    = context->sc_esp_at_signal;
 692         regs->tf_ss     = context->sc_ss;
 693
 694         /*
 695          * call sigaltstack & ignore results..
 696          */
 697         lss = &uc.uc_stack;
 698         ss.ss_sp = lss->ss_sp;
 699         ss.ss_size = lss->ss_size;
 700         ss.ss_flags = linux_to_bsd_sigaltstack(lss->ss_flags);
 701
 702 #ifdef DEBUG
 703         if (ldebug(rt_sigreturn))
 704                 printf(LMSG("rt_sigret flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
 705                     ss.ss_flags, ss.ss_sp, ss.ss_size, context->sc_mask);
 706 #endif
 707         kern_sigaltstack(&ss, NULL);
 708
 709         return (EJUSTRETURN);
 710 }
 711
 712 static void
 713 linux_prepsyscall(struct trapframe *tf, int *args, u_int *code, caddr_t *params)
 714 {
 715         args[0] = tf->tf_ebx;
 716         args[1] = tf->tf_ecx;
 717         args[2] = tf->tf_edx;
 718         args[3] = tf->tf_esi;
 719         args[4] = tf->tf_edi;
 720         *params = NULL;         /* no copyin */
 721 }
 722
 723 /*
 724  * If a linux binary is exec'ing something, try this image activator
 725  * first.  We override standard shell script execution in order to
 726  * be able to modify the interpreter path.  We only do this if a linux
 727  * binary is doing the exec, so we do not create an EXEC module for it.
 728  */
 729 static int      exec_linux_imgact_try (struct image_params *iparams);
 730
 731 static int
 732 exec_linux_imgact_try(imgp)
 733     struct image_params *imgp;
 734 {
 735     const char *head = (const char *)imgp->image_header;
 736     int error = -1;
 737
 738     /*
 739      * The interpreter for shell scripts run from a linux binary needs
 740      * to be located in /compat/linux if possible in order to recursively
 741      * maintain linux path emulation.
 742      */
 743     if (((const short *)head)[0] == SHELLMAGIC) {
 744             /*
 745              * Run our normal shell image activator.  If it succeeds attempt
 746              * to use the alternate path for the interpreter.  If an alternate
 747              * path is found, use our stringspace to store it.
 748              */
 749             if ((error = exec_shell_imgact(imgp)) == 0) {
 750                     linux_translate_path(imgp->interpreter_name,
 751                         MAXSHELLCMDLEN);
 752             }
 753     }
 754     return(error);
 755 }
 756
 757 struct sysentvec linux_sysvec = {
 758         LINUX_SYS_MAXSYSCALL,
 759         linux_sysent,
 760         0xff,
 761         LINUX_SIGTBLSZ,
 762         bsd_to_linux_signal,
 763         ELAST + 1,
 764         bsd_to_linux_errno,
 765         translate_traps,
 766         linux_fixup,
 767         linux_sendsig,
 768         linux_sigcode,
 769         &linux_szsigcode,
 770         linux_prepsyscall,
 771         "Linux a.out",
 772         aout_coredump,
 773         exec_linux_imgact_try,
 774         LINUX_MINSIGSTKSZ
 775 };
 776
 777 struct sysentvec elf_linux_sysvec = {
 778         LINUX_SYS_MAXSYSCALL,
 779         linux_sysent,
 780         0xff,
 781         LINUX_SIGTBLSZ,
 782         bsd_to_linux_signal,
 783         ELAST + 1,
 784         bsd_to_linux_errno,
 785         translate_traps,
 786         elf_linux_fixup,
 787         linux_sendsig,
 788         linux_sigcode,
 789         &linux_szsigcode,
 790         linux_prepsyscall,
 791         "Linux ELF",
 792         elf_coredump,
 793         exec_linux_imgact_try,
 794         LINUX_MINSIGSTKSZ
 795 };
 796
 797 static Elf32_Brandinfo linux_brand = {
 798                                         ELFOSABI_LINUX,
 799                                         "Linux",
 800                                         "/compat/linux",
 801                                         "/lib/ld-linux.so.1",
 802                                         &elf_linux_sysvec
 803                                  };
 804
 805 static Elf32_Brandinfo linux_glibc2brand = {
 806                                         ELFOSABI_LINUX,
 807                                         "Linux",
 808                                         "/compat/linux",
 809                                         "/lib/ld-linux.so.2",
 810                                         &elf_linux_sysvec
 811                                  };
 812
 813 Elf32_Brandinfo *linux_brandlist[] = {
 814                                         &linux_brand,
 815                                         &linux_glibc2brand,
 816                                         NULL
 817                                 };
 818
 819 static int
 820 linux_elf_modevent(module_t mod, int type, void *data)
 821 {
 822         Elf32_Brandinfo **brandinfo;
 823         int error;
 824         struct linux_ioctl_handler **lihp;
 825
 826         error = 0;
 827
 828         switch(type) {
 829         case MOD_LOAD:
 830                 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
 831                      ++brandinfo)
 832                         if (elf_insert_brand_entry(*brandinfo) < 0)
 833                                 error = EINVAL;
 834                 if (error == 0) {
 835                         SET_FOREACH(lihp, linux_ioctl_handler_set)
 836                                 linux_ioctl_register_handler(*lihp);
 837                         if (bootverbose)
 838                                 printf("Linux ELF exec handler installed\n");
 839                 } else
 840                         printf("cannot insert Linux ELF brand handler\n");
 841                 break;
 842         case MOD_UNLOAD:
 843                 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
 844                      ++brandinfo)
 845                         if (elf_brand_inuse(*brandinfo))
 846                                 error = EBUSY;
 847                 if (error == 0) {
 848                         for (brandinfo = &linux_brandlist[0];
 849                              *brandinfo != NULL; ++brandinfo)
 850                                 if (elf_remove_brand_entry(*brandinfo) < 0)
 851                                         error = EINVAL;
 852                 }
 853                 if (error == 0) {
 854                         SET_FOREACH(lihp, linux_ioctl_handler_set)
 855                                 linux_ioctl_unregister_handler(*lihp);
 856                         if (bootverbose)
 857                                 printf("Linux ELF exec handler removed\n");
 858                 } else
 859                         printf("Could not deinstall ELF interpreter entry\n");
 860                 break;
 861         default:
 862                 break;
 863         }
 864         return error;
 865 }
 866
 867 static moduledata_t linux_elf_mod = {
 868         "linuxelf",
 869         linux_elf_modevent,
 870         0
 871 };
 872
 873 DECLARE_MODULE(linuxelf, linux_elf_mod, SI_SUB_EXEC, SI_ORDER_ANY);