2 * Copyright (c) 1994-1996 Søren Schmidt
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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
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.
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 $
32 /* XXX we use functions that might not exist. */
33 #include "opt_compat.h"
36 #error "Unable to compile Linux-emulator due to missing COMPAT_43 option!"
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>
46 #include <sys/malloc.h>
48 #include <sys/signalvar.h>
49 #include <sys/sysent.h>
50 #include <sys/sysproto.h>
53 #include <vm/vm_param.h>
54 #include <vm/vm_page.h>
55 #include <vm/vm_extern.h>
57 #include <sys/kernel.h>
58 #include <sys/module.h>
59 #include <machine/cpu.h>
62 #include "linux_proto.h"
63 #include "../linux_signal.h"
64 #include "../linux_util.h"
66 MALLOC_DEFINE(M_LINUX, "linux", "Linux mode structures");
68 #if BYTE_ORDER == LITTLE_ENDIAN
69 #define SHELLMAGIC 0x2123 /* #! */
71 #define SHELLMAGIC 0x2321
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
80 #define LINUX_SYS_linux_rt_sendsig 0
81 #define LINUX_SYS_linux_sendsig 0
83 extern char linux_sigcode[];
84 extern int linux_szsigcode;
86 extern struct sysent linux_sysent[LINUX_SYS_MAXSYSCALL];
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,
98 * Linux syscalls return negative errno's, we do positive and map them
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
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
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,
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 */
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 */
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 */
165 19, /* 29 T_XMMFLT */
166 15 /* 30 T_RESERVED */
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)]: \
174 * If FreeBSD & Linux have a difference of opinion about what a trap
175 * means, deal with it here.
178 translate_traps(int signal, int trap_code)
180 if (signal != SIGBUS)
194 linux_fixup(register_t **stack_base, struct image_params *imgp)
196 register_t *argv, *envp;
199 envp = *stack_base + (imgp->args->argc + 1);
201 **stack_base = (intptr_t)(void *)envp;
203 **stack_base = (intptr_t)(void *)argv;
205 **stack_base = imgp->args->argc;
210 elf_linux_fixup(register_t **stack_base, struct image_params *imgp)
212 Elf32_Auxargs *args = (Elf32_Auxargs *)imgp->auxargs;
215 pos = *stack_base + (imgp->args->argc + imgp->args->envc + 2);
218 AUXARGS_ENTRY(pos, AT_DEBUG, 1);
220 if (args->execfd != -1) {
221 AUXARGS_ENTRY(pos, AT_EXECFD, args->execfd);
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);
236 free(imgp->auxargs, M_TEMP);
237 imgp->auxargs = NULL;
240 **stack_base = (long)imgp->args->argc;
244 extern int _ucodesel, _udatasel;
245 extern unsigned long linux_sznonrtsigcode;
248 linux_rt_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code)
250 struct proc *p = curproc;
251 struct trapframe *regs;
252 struct l_rt_sigframe *fp, frame;
255 regs = p->p_md.md_regs;
256 oonstack = p->p_sigstk.ss_flags & SS_ONSTACK;
259 if (ldebug(rt_sendsig))
260 printf(ARGS(rt_sendsig, "%p, %d, %p, %lu"),
261 catcher, sig, (void*)mask, code);
264 * Allocate space for the signal handler context.
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;
272 fp = (struct l_rt_sigframe *)regs->tf_esp - 1;
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.
279 if ((grow_stack (p, (int)fp) == FALSE) ||
280 !useracc((caddr_t)fp, sizeof (struct l_rt_sigframe),
283 * Process has trashed its stack; give it an illegal
284 * instruction to halt it in its tracks.
286 SIGACTION(p, SIGILL) = SIG_DFL;
287 SIGDELSET(p->p_sigignore, SIGILL);
288 SIGDELSET(p->p_sigcatch, SIGILL);
289 SIGDELSET(p->p_sigmask, SIGILL);
291 if (ldebug(rt_sendsig))
292 printf(LMSG("rt_sendsig: bad stack %p, oonstack=%x"),
300 * Build the argument list for the signal handler.
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)];
306 frame.sf_handler = catcher;
308 frame.sf_siginfo = &fp->sf_si;
309 frame.sf_ucontext = &fp->sf_sc;
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;
317 * Build the signal context to be used by sigreturn.
319 frame.sf_sc.uc_flags = 0; /* XXX ??? */
320 frame.sf_sc.uc_link = NULL; /* XXX ??? */
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;
327 bsd_to_linux_sigset(mask, &frame.sf_sc.uc_sigmask);
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);
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);
356 if (copyout(&frame, fp, sizeof(frame)) != 0) {
358 * Process has trashed its stack; give it an illegal
359 * instruction to halt it in its tracks.
366 * Build context to run handler in.
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;
381 * Send an interrupt to process.
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
392 linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code)
394 struct proc *p = curproc;
395 struct trapframe *regs;
396 struct l_sigframe *fp, frame;
400 if (SIGISMEMBER(p->p_sigacts->ps_siginfo, sig)) {
401 /* Signal handler installed with SA_SIGINFO. */
402 linux_rt_sendsig(catcher, sig, mask, code);
406 regs = p->p_md.md_regs;
407 oonstack = p->p_sigstk.ss_flags & SS_ONSTACK;
411 printf(ARGS(sendsig, "%p, %d, %p, %lu"),
412 catcher, sig, (void*)mask, code);
416 * Allocate space for the signal handler context.
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;
424 fp = (struct l_sigframe *)regs->tf_esp - 1;
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.
431 if ((grow_stack (p, (int)fp) == FALSE) ||
432 !useracc((caddr_t)fp, sizeof (struct l_sigframe),
435 * Process has trashed its stack; give it an illegal
436 * instruction to halt it in its tracks.
438 SIGACTION(p, SIGILL) = SIG_DFL;
439 SIGDELSET(p->p_sigignore, SIGILL);
440 SIGDELSET(p->p_sigcatch, SIGILL);
441 SIGDELSET(p->p_sigmask, SIGILL);
447 * Build the argument list for the signal handler.
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)];
453 frame.sf_handler = catcher;
456 bsd_to_linux_sigset(mask, &lmask);
459 * Build the signal context to be used by sigreturn.
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);
481 bzero(&frame.sf_fpstate, sizeof(struct l_fpstate));
483 for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
484 frame.sf_extramask[i] = lmask.__bits[i+1];
486 if (copyout(&frame, fp, sizeof(frame)) != 0) {
488 * Process has trashed its stack; give it an illegal
489 * instruction to halt it in its tracks.
496 * Build context to run handler in.
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;
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
519 linux_sigreturn(struct linux_sigreturn_args *args)
521 struct proc *p = curproc;
522 struct l_sigframe frame;
523 struct trapframe *regs;
527 regs = p->p_md.md_regs;
530 if (ldebug(sigreturn))
531 printf(ARGS(sigreturn, "%p"), (void *)args->sfp);
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.
538 if (copyin((caddr_t)args->sfp, &frame, sizeof(frame)) != 0)
542 * Check for security violations.
544 #define EFLAGS_SECURE(ef, oef) ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
545 eflags = frame.sf_sc.sc_eflags;
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.
556 if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF)) {
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.
565 #define CS_SECURE(cs) (ISPL(cs) == SEL_UPL)
566 if (!CS_SECURE(frame.sf_sc.sc_cs)) {
567 trapsignal(p, SIGBUS, T_PROTFLT);
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);
579 * Restore signal context.
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;
598 return (EJUSTRETURN);
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
612 linux_rt_sigreturn(struct linux_rt_sigreturn_args *args)
614 struct proc *p = curproc;
615 struct l_ucontext uc;
616 struct l_sigcontext *context;
619 struct trapframe *regs;
622 regs = p->p_md.md_regs;
625 if (ldebug(rt_sigreturn))
626 printf(ARGS(rt_sigreturn, "%p"), (void *)args->ucp);
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.
633 if (copyin((caddr_t)args->ucp, &uc, sizeof(uc)) != 0)
636 context = &uc.uc_mcontext;
639 * Check for security violations.
641 #define EFLAGS_SECURE(ef, oef) ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
642 eflags = context->sc_eflags;
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.
653 if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF)) {
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.
662 #define CS_SECURE(cs) (ISPL(cs) == SEL_UPL)
663 if (!CS_SECURE(context->sc_cs)) {
664 trapsignal(p, SIGBUS, T_PROTFLT);
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);
673 * Restore signal context
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;
693 * call sigaltstack & ignore results..
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);
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);
705 kern_sigaltstack(&ss, NULL);
707 return (EJUSTRETURN);
711 linux_prepsyscall(struct trapframe *tf, int *args, u_int *code, caddr_t *params)
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 */
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.
728 static int exec_linux_imgact_try (struct image_params *iparams);
731 exec_linux_imgact_try(imgp)
732 struct image_params *imgp;
734 const char *head = (const char *)imgp->image_header;
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.
742 if (((const short *)head)[0] == SHELLMAGIC) {
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.
748 if ((error = exec_shell_imgact(imgp)) == 0) {
749 linux_translate_path(imgp->interpreter_name,
756 struct sysentvec linux_sysvec = {
757 LINUX_SYS_MAXSYSCALL,
772 exec_linux_imgact_try,
776 struct sysentvec elf_linux_sysvec = {
777 LINUX_SYS_MAXSYSCALL,
792 exec_linux_imgact_try,
796 static Elf32_Brandinfo linux_brand = {
800 "/lib/ld-linux.so.1",
804 static Elf32_Brandinfo linux_glibc2brand = {
808 "/lib/ld-linux.so.2",
812 Elf32_Brandinfo *linux_brandlist[] = {
819 linux_elf_modevent(module_t mod, int type, void *data)
821 Elf32_Brandinfo **brandinfo;
828 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
830 if (elf_insert_brand_entry(*brandinfo) < 0)
834 printf("Linux ELF exec handler installed\n");
836 printf("cannot insert Linux ELF brand handler\n");
839 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
841 if (elf_brand_inuse(*brandinfo))
844 for (brandinfo = &linux_brandlist[0];
845 *brandinfo != NULL; ++brandinfo)
846 if (elf_remove_brand_entry(*brandinfo) < 0)
851 printf("Linux ELF exec handler removed\n");
853 printf("Could not deinstall ELF interpreter entry\n");
861 static moduledata_t linux_elf_mod = {
867 DECLARE_MODULE(linuxelf, linux_elf_mod, SI_SUB_EXEC, SI_ORDER_ANY);