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  */
  30
  31 /* XXX we use functions that might not exist. */
  32 #include "opt_compat.h"
  33
  34 #ifndef COMPAT_43
  35 #error "Unable to compile Linux-emulator due to missing COMPAT_43 option!"
  36 #endif
  37
  38 #include <sys/param.h>
  39 #include <sys/systm.h>
  40 #include <sys/imgact.h>
  41 #include <sys/imgact_aout.h>
  42 #include <sys/imgact_elf.h>
  43 #include <sys/lock.h>
  44 #include <sys/malloc.h>
  45 #include <sys/proc.h>
  46 #include <sys/signalvar.h>
  47 #include <sys/sysent.h>
  48 #include <sys/sysproto.h>
  49
  50 #include <vm/vm.h>
  51 #include <vm/vm_param.h>
  52 #include <vm/vm_page.h>
  53 #include <vm/vm_extern.h>
  54 #include <sys/exec.h>
  55 #include <sys/kernel.h>
  56 #include <sys/module.h>
  57 #include <machine/cpu.h>
  58
  59 #include <i386/linux/linux.h>
  60 #include <i386/linux/linux_proto.h>
  61 #include <compat/linux/linux_signal.h>
  62 #include <compat/linux/linux_util.h>
  63
  64 MALLOC_DEFINE(M_LINUX, "linux", "Linux mode structures");
  65
  66 #if BYTE_ORDER == LITTLE_ENDIAN
  67 #define SHELLMAGIC      0x2123 /* #! */
  68 #else
  69 #define SHELLMAGIC      0x2321
  70 #endif
  71
  72 /*
  73  * Allow the sendsig functions to use the ldebug() facility
  74  * even though they are not syscalls themselves. Map them
  75  * to syscall 0. This is slightly less bogus than using
  76  * ldebug(sigreturn).
  77  */
  78 #define LINUX_SYS_linux_rt_sendsig      0
  79 #define LINUX_SYS_linux_sendsig         0
  80
  81 extern char linux_sigcode[];
  82 extern int linux_szsigcode;
  83
  84 extern struct sysent linux_sysent[LINUX_SYS_MAXSYSCALL];
  85
  86 extern struct linker_set linux_ioctl_handler_set;
  87
  88 static int      linux_fixup __P((register_t **stack_base,
  89                                  struct image_params *iparams));
  90 static int      elf_linux_fixup __P((register_t **stack_base,
  91                                      struct image_params *iparams));
  92 static void     linux_prepsyscall __P((struct trapframe *tf, int *args,
  93                                        u_int *code, caddr_t *params));
  94 static void     linux_sendsig __P((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->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->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->argc + imgp->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_cred->p_ruid);
 231         AUXARGS_ENTRY(pos, AT_EUID, imgp->proc->p_cred->p_svuid);
 232         AUXARGS_ENTRY(pos, AT_GID, imgp->proc->p_cred->p_rgid);
 233         AUXARGS_ENTRY(pos, AT_EGID, imgp->proc->p_cred->p_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->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         register struct proc *p = curproc;
 251         register 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         register struct proc *p = curproc;
 395         register 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(p, args)
 520         struct proc *p;
 521         struct linux_sigreturn_args *args;
 522 {
 523         struct l_sigframe frame;
 524         register struct trapframe *regs;
 525         l_sigset_t lmask;
 526         int eflags, i;
 527
 528         regs = p->p_md.md_regs;
 529
 530 #ifdef DEBUG
 531         if (ldebug(sigreturn))
 532                 printf(ARGS(sigreturn, "%p"), (void *)args->sfp);
 533 #endif
 534         /*
 535          * The trampoline code hands us the sigframe.
 536          * It is unsafe to keep track of it ourselves, in the event that a
 537          * program jumps out of a signal handler.
 538          */
 539         if (copyin((caddr_t)args->sfp, &frame, sizeof(frame)) != 0)
 540                 return (EFAULT);
 541
 542         /*
 543          * Check for security violations.
 544          */
 545 #define EFLAGS_SECURE(ef, oef)  ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
 546         eflags = frame.sf_sc.sc_eflags;
 547         /*
 548          * XXX do allow users to change the privileged flag PSL_RF.  The
 549          * cpu sets PSL_RF in tf_eflags for faults.  Debuggers should
 550          * sometimes set it there too.  tf_eflags is kept in the signal
 551          * context during signal handling and there is no other place
 552          * to remember it, so the PSL_RF bit may be corrupted by the
 553          * signal handler without us knowing.  Corruption of the PSL_RF
 554          * bit at worst causes one more or one less debugger trap, so
 555          * allowing it is fairly harmless.
 556          */
 557         if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF)) {
 558                 return(EINVAL);
 559         }
 560
 561         /*
 562          * Don't allow users to load a valid privileged %cs.  Let the
 563          * hardware check for invalid selectors, excess privilege in
 564          * other selectors, invalid %eip's and invalid %esp's.
 565          */
 566 #define CS_SECURE(cs)   (ISPL(cs) == SEL_UPL)
 567         if (!CS_SECURE(frame.sf_sc.sc_cs)) {
 568                 trapsignal(p, SIGBUS, T_PROTFLT);
 569                 return(EINVAL);
 570         }
 571
 572         p->p_sigstk.ss_flags &= ~SS_ONSTACK;
 573         lmask.__bits[0] = frame.sf_sc.sc_mask;
 574         for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
 575                 lmask.__bits[i+1] = frame.sf_extramask[i];
 576         linux_to_bsd_sigset(&lmask, &p->p_sigmask);
 577         SIG_CANTMASK(p->p_sigmask);
 578
 579         /*
 580          * Restore signal context.
 581          */
 582         /* %gs was restored by the trampoline. */
 583         regs->tf_fs     = frame.sf_sc.sc_fs;
 584         regs->tf_es     = frame.sf_sc.sc_es;
 585         regs->tf_ds     = frame.sf_sc.sc_ds;
 586         regs->tf_edi    = frame.sf_sc.sc_edi;
 587         regs->tf_esi    = frame.sf_sc.sc_esi;
 588         regs->tf_ebp    = frame.sf_sc.sc_ebp;
 589         regs->tf_ebx    = frame.sf_sc.sc_ebx;
 590         regs->tf_edx    = frame.sf_sc.sc_edx;
 591         regs->tf_ecx    = frame.sf_sc.sc_ecx;
 592         regs->tf_eax    = frame.sf_sc.sc_eax;
 593         regs->tf_eip    = frame.sf_sc.sc_eip;
 594         regs->tf_cs     = frame.sf_sc.sc_cs;
 595         regs->tf_eflags = eflags;
 596         regs->tf_esp    = frame.sf_sc.sc_esp_at_signal;
 597         regs->tf_ss     = frame.sf_sc.sc_ss;
 598
 599         return (EJUSTRETURN);
 600 }
 601
 602 /*
 603  * System call to cleanup state after a signal
 604  * has been taken.  Reset signal mask and
 605  * stack state from context left by rt_sendsig (above).
 606  * Return to previous pc and psl as specified by
 607  * context left by sendsig. Check carefully to
 608  * make sure that the user has not modified the
 609  * psl to gain improper privileges or to cause
 610  * a machine fault.
 611  */
 612 int
 613 linux_rt_sigreturn(p, args)
 614         struct proc *p;
 615         struct linux_rt_sigreturn_args *args;
 616 {
 617         struct sigaltstack_args sasargs;
 618         struct l_ucontext uc;
 619         struct l_sigcontext *context;
 620         l_stack_t *lss;
 621         stack_t *ss;
 622         register struct trapframe *regs;
 623         int eflags;
 624         caddr_t sg = stackgap_init();
 625
 626         regs = p->p_md.md_regs;
 627
 628 #ifdef DEBUG
 629         if (ldebug(rt_sigreturn))
 630                 printf(ARGS(rt_sigreturn, "%p"), (void *)args->ucp);
 631 #endif
 632         /*
 633          * The trampoline code hands us the ucontext.
 634          * It is unsafe to keep track of it ourselves, in the event that a
 635          * program jumps out of a signal handler.
 636          */
 637         if (copyin((caddr_t)args->ucp, &uc, sizeof(uc)) != 0)
 638                 return (EFAULT);
 639
 640         context = &uc.uc_mcontext;
 641
 642         /*
 643          * Check for security violations.
 644          */
 645 #define EFLAGS_SECURE(ef, oef)  ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
 646         eflags = context->sc_eflags;
 647         /*
 648          * XXX do allow users to change the privileged flag PSL_RF.  The
 649          * cpu sets PSL_RF in tf_eflags for faults.  Debuggers should
 650          * sometimes set it there too.  tf_eflags is kept in the signal
 651          * context during signal handling and there is no other place
 652          * to remember it, so the PSL_RF bit may be corrupted by the
 653          * signal handler without us knowing.  Corruption of the PSL_RF
 654          * bit at worst causes one more or one less debugger trap, so
 655          * allowing it is fairly harmless.
 656          */
 657         if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF)) {
 658                 return(EINVAL);
 659         }
 660
 661         /*
 662          * Don't allow users to load a valid privileged %cs.  Let the
 663          * hardware check for invalid selectors, excess privilege in
 664          * other selectors, invalid %eip's and invalid %esp's.
 665          */
 666 #define CS_SECURE(cs)   (ISPL(cs) == SEL_UPL)
 667         if (!CS_SECURE(context->sc_cs)) {
 668                 trapsignal(p, SIGBUS, T_PROTFLT);
 669                 return(EINVAL);
 670         }
 671
 672         p->p_sigstk.ss_flags &= ~SS_ONSTACK;
 673         linux_to_bsd_sigset(&uc.uc_sigmask, &p->p_sigmask);
 674         SIG_CANTMASK(p->p_sigmask);
 675
 676         /*
 677          * Restore signal context
 678          */
 679         /* %gs was restored by the trampoline. */
 680         regs->tf_fs     = context->sc_fs;
 681         regs->tf_es     = context->sc_es;
 682         regs->tf_ds     = context->sc_ds;
 683         regs->tf_edi    = context->sc_edi;
 684         regs->tf_esi    = context->sc_esi;
 685         regs->tf_ebp    = context->sc_ebp;
 686         regs->tf_ebx    = context->sc_ebx;
 687         regs->tf_edx    = context->sc_edx;
 688         regs->tf_ecx    = context->sc_ecx;
 689         regs->tf_eax    = context->sc_eax;
 690         regs->tf_eip    = context->sc_eip;
 691         regs->tf_cs     = context->sc_cs;
 692         regs->tf_eflags = eflags;
 693         regs->tf_esp    = context->sc_esp_at_signal;
 694         regs->tf_ss     = context->sc_ss;
 695
 696         /*
 697          * call sigaltstack & ignore results..
 698          */
 699         ss = stackgap_alloc(&sg, sizeof(stack_t));
 700         lss = &uc.uc_stack;
 701         ss->ss_sp = lss->ss_sp;
 702         ss->ss_size = lss->ss_size;
 703         ss->ss_flags = linux_to_bsd_sigaltstack(lss->ss_flags);
 704
 705 #ifdef DEBUG
 706         if (ldebug(rt_sigreturn))
 707                 printf(LMSG("rt_sigret flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
 708                     ss->ss_flags, ss->ss_sp, ss->ss_size, context->sc_mask);
 709 #endif
 710         sasargs.ss = ss;
 711         sasargs.oss = NULL;
 712         (void) sigaltstack(p, &sasargs);
 713
 714         return (EJUSTRETURN);
 715 }
 716
 717 static void
 718 linux_prepsyscall(struct trapframe *tf, int *args, u_int *code, caddr_t *params)
 719 {
 720         args[0] = tf->tf_ebx;
 721         args[1] = tf->tf_ecx;
 722         args[2] = tf->tf_edx;
 723         args[3] = tf->tf_esi;
 724         args[4] = tf->tf_edi;
 725         *params = NULL;         /* no copyin */
 726 }
 727
 728 /*
 729  * If a linux binary is exec'ing something, try this image activator
 730  * first.  We override standard shell script execution in order to
 731  * be able to modify the interpreter path.  We only do this if a linux
 732  * binary is doing the exec, so we do not create an EXEC module for it.
 733  */
 734 static int      exec_linux_imgact_try __P((struct image_params *iparams));
 735
 736 static int
 737 exec_linux_imgact_try(imgp)
 738     struct image_params *imgp;
 739 {
 740     const char *head = (const char *)imgp->image_header;
 741     int error = -1;
 742
 743     /*
 744      * The interpreter for shell scripts run from a linux binary needs
 745      * to be located in /compat/linux if possible in order to recursively
 746      * maintain linux path emulation.
 747      */
 748     if (((const short *)head)[0] == SHELLMAGIC) {
 749             /*
 750              * Run our normal shell image activator.  If it succeeds attempt
 751              * to use the alternate path for the interpreter.  If an alternate
 752              * path is found, use our stringspace to store it.
 753              */
 754             if ((error = exec_shell_imgact(imgp)) == 0) {
 755                     char *rpath = NULL;
 756
 757                     linux_emul_find(imgp->proc, NULL, linux_emul_path,
 758                         imgp->interpreter_name, &rpath, 0);
 759                     if (rpath != imgp->interpreter_name) {
 760                             int len = strlen(rpath) + 1;
 761
 762                             if (len <= MAXSHELLCMDLEN) {
 763                                 memcpy(imgp->interpreter_name, rpath, len);
 764                             }
 765                             free(rpath, M_TEMP);
 766                     }
 767             }
 768     }
 769     return(error);
 770 }
 771
 772 struct sysentvec linux_sysvec = {
 773         LINUX_SYS_MAXSYSCALL,
 774         linux_sysent,
 775         0xff,
 776         LINUX_SIGTBLSZ,
 777         bsd_to_linux_signal,
 778         ELAST + 1,
 779         bsd_to_linux_errno,
 780         translate_traps,
 781         linux_fixup,
 782         linux_sendsig,
 783         linux_sigcode,
 784         &linux_szsigcode,
 785         linux_prepsyscall,
 786         "Linux a.out",
 787         aout_coredump,
 788         exec_linux_imgact_try,
 789         LINUX_MINSIGSTKSZ
 790 };
 791
 792 struct sysentvec elf_linux_sysvec = {
 793         LINUX_SYS_MAXSYSCALL,
 794         linux_sysent,
 795         0xff,
 796         LINUX_SIGTBLSZ,
 797         bsd_to_linux_signal,
 798         ELAST + 1,
 799         bsd_to_linux_errno,
 800         translate_traps,
 801         elf_linux_fixup,
 802         linux_sendsig,
 803         linux_sigcode,
 804         &linux_szsigcode,
 805         linux_prepsyscall,
 806         "Linux ELF",
 807         elf_coredump,
 808         exec_linux_imgact_try,
 809         LINUX_MINSIGSTKSZ
 810 };
 811
 812 static Elf32_Brandinfo linux_brand = {
 813                                         ELFOSABI_LINUX,
 814                                         "Linux",
 815                                         "/compat/linux",
 816                                         "/lib/ld-linux.so.1",
 817                                         &elf_linux_sysvec
 818                                  };
 819
 820 static Elf32_Brandinfo linux_glibc2brand = {
 821                                         ELFOSABI_LINUX,
 822                                         "Linux",
 823                                         "/compat/linux",
 824                                         "/lib/ld-linux.so.2",
 825                                         &elf_linux_sysvec
 826                                  };
 827
 828 Elf32_Brandinfo *linux_brandlist[] = {
 829                                         &linux_brand,
 830                                         &linux_glibc2brand,
 831                                         NULL
 832                                 };
 833
 834 static int
 835 linux_elf_modevent(module_t mod, int type, void *data)
 836 {
 837         Elf32_Brandinfo **brandinfo;
 838         int error;
 839
 840         error = 0;
 841
 842         switch(type) {
 843         case MOD_LOAD:
 844                 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
 845                      ++brandinfo)
 846                         if (elf_insert_brand_entry(*brandinfo) < 0)
 847                                 error = EINVAL;
 848                 if (error == 0) {
 849                         linux_ioctl_register_handlers(
 850                                 &linux_ioctl_handler_set);
 851                         if (bootverbose)
 852                                 printf("Linux ELF exec handler installed\n");
 853                 } else
 854                         printf("cannot insert Linux ELF brand handler\n");
 855                 break;
 856         case MOD_UNLOAD:
 857                 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
 858                      ++brandinfo)
 859                         if (elf_brand_inuse(*brandinfo))
 860                                 error = EBUSY;
 861                 if (error == 0) {
 862                         for (brandinfo = &linux_brandlist[0];
 863                              *brandinfo != NULL; ++brandinfo)
 864                                 if (elf_remove_brand_entry(*brandinfo) < 0)
 865                                         error = EINVAL;
 866                 }
 867                 if (error == 0) {
 868                         linux_ioctl_unregister_handlers(
 869                                 &linux_ioctl_handler_set);
 870                         if (bootverbose)
 871                                 printf("Linux ELF exec handler removed\n");
 872                 } else
 873                         printf("Could not deinstall ELF interpreter entry\n");
 874                 break;
 875         default:
 876                 break;
 877         }
 878         return error;
 879 }
 880
 881 static moduledata_t linux_elf_mod = {
 882         "linuxelf",
 883         linux_elf_modevent,
 884         0
 885 };
 886
 887 DECLARE_MODULE(linuxelf, linux_elf_mod, SI_SUB_EXEC, SI_ORDER_ANY);