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.31 2008/04/21 15:47:53 dillon 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 kfree(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 lwp *lp = curthread->td_lwp;
252 struct trapframe *regs;
253 struct l_rt_sigframe *fp, frame;
256 regs = lp->lwp_md.md_regs;
257 oonstack = lp->lwp_sigstk.ss_flags & SS_ONSTACK;
260 if (ldebug(rt_sendsig))
261 kprintf(ARGS(rt_sendsig, "%p, %d, %p, %lu"),
262 catcher, sig, (void*)mask, code);
265 * Allocate space for the signal handler context.
267 if ((lp->lwp_flag & LWP_ALTSTACK) && !oonstack &&
268 SIGISMEMBER(p->p_sigacts->ps_sigonstack, sig)) {
269 fp = (struct l_rt_sigframe *)(lp->lwp_sigstk.ss_sp +
270 lp->lwp_sigstk.ss_size - sizeof(struct l_rt_sigframe));
271 lp->lwp_sigstk.ss_flags |= SS_ONSTACK;
273 fp = (struct l_rt_sigframe *)regs->tf_esp - 1;
276 * grow() will return FALSE if the fp will not fit inside the stack
277 * and the stack can not be grown. useracc will return FALSE
278 * if access is denied.
280 if ((grow_stack (p, (int)fp) == FALSE) ||
281 !useracc((caddr_t)fp, sizeof (struct l_rt_sigframe),
284 * Process has trashed its stack; give it an illegal
285 * instruction to halt it in its tracks.
287 SIGACTION(p, SIGILL) = SIG_DFL;
288 SIGDELSET(p->p_sigignore, SIGILL);
289 SIGDELSET(p->p_sigcatch, SIGILL);
290 SIGDELSET(lp->lwp_sigmask, SIGILL);
292 if (ldebug(rt_sendsig))
293 kprintf(LMSG("rt_sendsig: bad stack %p, oonstack=%x"),
296 lwpsignal(p, lp, SIGILL);
301 * Build the argument list for the signal handler.
303 if (p->p_sysent->sv_sigtbl)
304 if (sig <= p->p_sysent->sv_sigsize)
305 sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
307 frame.sf_handler = catcher;
309 frame.sf_siginfo = &fp->sf_si;
310 frame.sf_ucontext = &fp->sf_sc;
312 /* Fill siginfo structure. */
313 frame.sf_si.lsi_signo = sig;
314 frame.sf_si.lsi_code = code;
315 frame.sf_si.lsi_addr = (void *)regs->tf_err;
318 * Build the signal context to be used by sigreturn.
320 frame.sf_sc.uc_flags = 0; /* XXX ??? */
321 frame.sf_sc.uc_link = NULL; /* XXX ??? */
323 frame.sf_sc.uc_stack.ss_sp = lp->lwp_sigstk.ss_sp;
324 frame.sf_sc.uc_stack.ss_size = lp->lwp_sigstk.ss_size;
325 frame.sf_sc.uc_stack.ss_flags = (lp->lwp_flag & LWP_ALTSTACK)
326 ? ((oonstack) ? LINUX_SS_ONSTACK : 0) : LINUX_SS_DISABLE;
328 bsd_to_linux_sigset(mask, &frame.sf_sc.uc_sigmask);
330 frame.sf_sc.uc_mcontext.sc_mask = frame.sf_sc.uc_sigmask.__bits[0];
331 frame.sf_sc.uc_mcontext.sc_gs = regs->tf_gs;
332 frame.sf_sc.uc_mcontext.sc_fs = regs->tf_fs;
333 frame.sf_sc.uc_mcontext.sc_es = regs->tf_es;
334 frame.sf_sc.uc_mcontext.sc_ds = regs->tf_ds;
335 frame.sf_sc.uc_mcontext.sc_edi = regs->tf_edi;
336 frame.sf_sc.uc_mcontext.sc_esi = regs->tf_esi;
337 frame.sf_sc.uc_mcontext.sc_ebp = regs->tf_ebp;
338 frame.sf_sc.uc_mcontext.sc_ebx = regs->tf_ebx;
339 frame.sf_sc.uc_mcontext.sc_edx = regs->tf_edx;
340 frame.sf_sc.uc_mcontext.sc_ecx = regs->tf_ecx;
341 frame.sf_sc.uc_mcontext.sc_eax = regs->tf_eax;
342 frame.sf_sc.uc_mcontext.sc_eip = regs->tf_eip;
343 frame.sf_sc.uc_mcontext.sc_cs = regs->tf_cs;
344 frame.sf_sc.uc_mcontext.sc_eflags = regs->tf_eflags;
345 frame.sf_sc.uc_mcontext.sc_esp_at_signal = regs->tf_esp;
346 frame.sf_sc.uc_mcontext.sc_ss = regs->tf_ss;
347 frame.sf_sc.uc_mcontext.sc_err = regs->tf_err;
348 frame.sf_sc.uc_mcontext.sc_trapno = bsd_to_linux_trapcode(code);
351 if (ldebug(rt_sendsig))
352 kprintf(LMSG("rt_sendsig flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
353 frame.sf_sc.uc_stack.ss_flags, lp->lwp_sigstk.ss_sp,
354 lp->lwp_sigstk.ss_size, frame.sf_sc.uc_mcontext.sc_mask);
357 if (copyout(&frame, fp, sizeof(frame)) != 0) {
359 * Process has trashed its stack; give it an illegal
360 * instruction to halt it in its tracks.
367 * Build context to run handler in.
369 regs->tf_esp = (int)fp;
370 regs->tf_eip = PS_STRINGS - *(p->p_sysent->sv_szsigcode) +
371 linux_sznonrtsigcode;
374 * i386 abi specifies that the direction flag must be cleared
377 regs->tf_eflags &= ~(PSL_T | PSL_VM | PSL_D);
379 regs->tf_cs = _ucodesel;
380 regs->tf_ds = _udatasel;
381 regs->tf_es = _udatasel;
382 /* allow %fs and %gs to be inherited by the signal handler */
384 regs->tf_fs = _udatasel;
385 regs->tf_gs = _udatasel;
387 regs->tf_ss = _udatasel;
392 * Send an interrupt to process.
394 * Stack is set up to allow sigcode stored
395 * in u. to call routine, followed by kcall
396 * to sigreturn routine below. After sigreturn
397 * resets the signal mask, the stack, and the
398 * frame pointer, it returns to the user
403 linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code)
405 struct proc *p = curproc;
406 struct lwp *lp = curthread->td_lwp;
407 struct trapframe *regs;
408 struct l_sigframe *fp, frame;
412 if (SIGISMEMBER(p->p_sigacts->ps_siginfo, sig)) {
413 /* Signal handler installed with SA_SIGINFO. */
414 linux_rt_sendsig(catcher, sig, mask, code);
418 regs = lp->lwp_md.md_regs;
419 oonstack = lp->lwp_sigstk.ss_flags & SS_ONSTACK;
423 kprintf(ARGS(sendsig, "%p, %d, %p, %lu"),
424 catcher, sig, (void*)mask, code);
428 * Allocate space for the signal handler context.
430 if ((lp->lwp_flag & LWP_ALTSTACK) && !oonstack &&
431 SIGISMEMBER(p->p_sigacts->ps_sigonstack, sig)) {
432 fp = (struct l_sigframe *)(lp->lwp_sigstk.ss_sp +
433 lp->lwp_sigstk.ss_size - sizeof(struct l_sigframe));
434 lp->lwp_sigstk.ss_flags |= SS_ONSTACK;
436 fp = (struct l_sigframe *)regs->tf_esp - 1;
439 * grow() will return FALSE if the fp will not fit inside the stack
440 * and the stack can not be grown. useracc will return FALSE
441 * if access is denied.
443 if ((grow_stack (p, (int)fp) == FALSE) ||
444 !useracc((caddr_t)fp, sizeof (struct l_sigframe),
447 * Process has trashed its stack; give it an illegal
448 * instruction to halt it in its tracks.
450 SIGACTION(p, SIGILL) = SIG_DFL;
451 SIGDELSET(p->p_sigignore, SIGILL);
452 SIGDELSET(p->p_sigcatch, SIGILL);
453 SIGDELSET(lp->lwp_sigmask, SIGILL);
454 lwpsignal(p, lp, SIGILL);
459 * Build the argument list for the signal handler.
461 if (p->p_sysent->sv_sigtbl)
462 if (sig <= p->p_sysent->sv_sigsize)
463 sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
465 frame.sf_handler = catcher;
468 bsd_to_linux_sigset(mask, &lmask);
471 * Build the signal context to be used by sigreturn.
473 frame.sf_sc.sc_mask = lmask.__bits[0];
474 frame.sf_sc.sc_gs = regs->tf_gs;
475 frame.sf_sc.sc_fs = regs->tf_fs;
476 frame.sf_sc.sc_es = regs->tf_es;
477 frame.sf_sc.sc_ds = regs->tf_ds;
478 frame.sf_sc.sc_edi = regs->tf_edi;
479 frame.sf_sc.sc_esi = regs->tf_esi;
480 frame.sf_sc.sc_ebp = regs->tf_ebp;
481 frame.sf_sc.sc_ebx = regs->tf_ebx;
482 frame.sf_sc.sc_edx = regs->tf_edx;
483 frame.sf_sc.sc_ecx = regs->tf_ecx;
484 frame.sf_sc.sc_eax = regs->tf_eax;
485 frame.sf_sc.sc_eip = regs->tf_eip;
486 frame.sf_sc.sc_cs = regs->tf_cs;
487 frame.sf_sc.sc_eflags = regs->tf_eflags;
488 frame.sf_sc.sc_esp_at_signal = regs->tf_esp;
489 frame.sf_sc.sc_ss = regs->tf_ss;
490 frame.sf_sc.sc_err = regs->tf_err;
491 frame.sf_sc.sc_trapno = bsd_to_linux_trapcode(code);
493 bzero(&frame.sf_fpstate, sizeof(struct l_fpstate));
495 for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
496 frame.sf_extramask[i] = lmask.__bits[i+1];
498 if (copyout(&frame, fp, sizeof(frame)) != 0) {
500 * Process has trashed its stack; give it an illegal
501 * instruction to halt it in its tracks.
508 * Build context to run handler in.
510 regs->tf_esp = (int)fp;
511 regs->tf_eip = PS_STRINGS - *(p->p_sysent->sv_szsigcode);
514 * i386 abi specifies that the direction flag must be cleared
517 regs->tf_eflags &= ~(PSL_T | PSL_VM | PSL_D);
519 regs->tf_cs = _ucodesel;
520 regs->tf_ds = _udatasel;
521 regs->tf_es = _udatasel;
522 /* Allow %fs and %gs to be inherited by the signal handler */
524 regs->tf_fs = _udatasel;
525 regs->tf_gs = _udatasel;
527 regs->tf_ss = _udatasel;
531 * System call to cleanup state after a signal
532 * has been taken. Reset signal mask and
533 * stack state from context left by sendsig (above).
534 * Return to previous pc and psl as specified by
535 * context left by sendsig. Check carefully to
536 * make sure that the user has not modified the
537 * psl to gain improper privileges or to cause
541 sys_linux_sigreturn(struct linux_sigreturn_args *args)
543 struct lwp *lp = curthread->td_lwp;
544 struct l_sigframe frame;
545 struct trapframe *regs;
549 regs = lp->lwp_md.md_regs;
552 if (ldebug(sigreturn))
553 kprintf(ARGS(sigreturn, "%p"), (void *)args->sfp);
556 * The trampoline code hands us the sigframe.
557 * It is unsafe to keep track of it ourselves, in the event that a
558 * program jumps out of a signal handler.
560 if (copyin((caddr_t)args->sfp, &frame, sizeof(frame)) != 0)
564 * Check for security violations.
566 #define EFLAGS_SECURE(ef, oef) ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
567 eflags = frame.sf_sc.sc_eflags;
569 * XXX do allow users to change the privileged flag PSL_RF. The
570 * cpu sets PSL_RF in tf_eflags for faults. Debuggers should
571 * sometimes set it there too. tf_eflags is kept in the signal
572 * context during signal handling and there is no other place
573 * to remember it, so the PSL_RF bit may be corrupted by the
574 * signal handler without us knowing. Corruption of the PSL_RF
575 * bit at worst causes one more or one less debugger trap, so
576 * allowing it is fairly harmless.
578 if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF)) {
583 * Don't allow users to load a valid privileged %cs. Let the
584 * hardware check for invalid selectors, excess privilege in
585 * other selectors, invalid %eip's and invalid %esp's.
587 #define CS_SECURE(cs) (ISPL(cs) == SEL_UPL)
588 if (!CS_SECURE(frame.sf_sc.sc_cs)) {
589 trapsignal(lp, SIGBUS, T_PROTFLT);
593 lp->lwp_sigstk.ss_flags &= ~SS_ONSTACK;
594 lmask.__bits[0] = frame.sf_sc.sc_mask;
595 for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
596 lmask.__bits[i+1] = frame.sf_extramask[i];
597 linux_to_bsd_sigset(&lmask, &lp->lwp_sigmask);
598 SIG_CANTMASK(lp->lwp_sigmask);
601 * Restore signal context.
603 /* %gs was restored by the trampoline. */
604 regs->tf_fs = frame.sf_sc.sc_fs;
605 regs->tf_es = frame.sf_sc.sc_es;
606 regs->tf_ds = frame.sf_sc.sc_ds;
607 regs->tf_edi = frame.sf_sc.sc_edi;
608 regs->tf_esi = frame.sf_sc.sc_esi;
609 regs->tf_ebp = frame.sf_sc.sc_ebp;
610 regs->tf_ebx = frame.sf_sc.sc_ebx;
611 regs->tf_edx = frame.sf_sc.sc_edx;
612 regs->tf_ecx = frame.sf_sc.sc_ecx;
613 regs->tf_eax = frame.sf_sc.sc_eax;
614 regs->tf_eip = frame.sf_sc.sc_eip;
615 regs->tf_cs = frame.sf_sc.sc_cs;
616 regs->tf_eflags = eflags;
617 regs->tf_esp = frame.sf_sc.sc_esp_at_signal;
618 regs->tf_ss = frame.sf_sc.sc_ss;
620 return (EJUSTRETURN);
624 * System call to cleanup state after a signal
625 * has been taken. Reset signal mask and
626 * stack state from context left by rt_sendsig (above).
627 * Return to previous pc and psl as specified by
628 * context left by sendsig. Check carefully to
629 * make sure that the user has not modified the
630 * psl to gain improper privileges or to cause
634 sys_linux_rt_sigreturn(struct linux_rt_sigreturn_args *args)
636 struct lwp *lp = curthread->td_lwp;
637 struct l_ucontext uc;
638 struct l_sigcontext *context;
641 struct trapframe *regs;
644 regs = lp->lwp_md.md_regs;
647 if (ldebug(rt_sigreturn))
648 kprintf(ARGS(rt_sigreturn, "%p"), (void *)args->ucp);
651 * The trampoline code hands us the ucontext.
652 * It is unsafe to keep track of it ourselves, in the event that a
653 * program jumps out of a signal handler.
655 if (copyin((caddr_t)args->ucp, &uc, sizeof(uc)) != 0)
658 context = &uc.uc_mcontext;
661 * Check for security violations.
663 #define EFLAGS_SECURE(ef, oef) ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
664 eflags = context->sc_eflags;
666 * XXX do allow users to change the privileged flag PSL_RF. The
667 * cpu sets PSL_RF in tf_eflags for faults. Debuggers should
668 * sometimes set it there too. tf_eflags is kept in the signal
669 * context during signal handling and there is no other place
670 * to remember it, so the PSL_RF bit may be corrupted by the
671 * signal handler without us knowing. Corruption of the PSL_RF
672 * bit at worst causes one more or one less debugger trap, so
673 * allowing it is fairly harmless.
675 if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF)) {
680 * Don't allow users to load a valid privileged %cs. Let the
681 * hardware check for invalid selectors, excess privilege in
682 * other selectors, invalid %eip's and invalid %esp's.
684 #define CS_SECURE(cs) (ISPL(cs) == SEL_UPL)
685 if (!CS_SECURE(context->sc_cs)) {
686 trapsignal(lp, SIGBUS, T_PROTFLT);
690 lp->lwp_sigstk.ss_flags &= ~SS_ONSTACK;
691 linux_to_bsd_sigset(&uc.uc_sigmask, &lp->lwp_sigmask);
692 SIG_CANTMASK(lp->lwp_sigmask);
695 * Restore signal context
697 /* %gs was restored by the trampoline. */
698 regs->tf_fs = context->sc_fs;
699 regs->tf_es = context->sc_es;
700 regs->tf_ds = context->sc_ds;
701 regs->tf_edi = context->sc_edi;
702 regs->tf_esi = context->sc_esi;
703 regs->tf_ebp = context->sc_ebp;
704 regs->tf_ebx = context->sc_ebx;
705 regs->tf_edx = context->sc_edx;
706 regs->tf_ecx = context->sc_ecx;
707 regs->tf_eax = context->sc_eax;
708 regs->tf_eip = context->sc_eip;
709 regs->tf_cs = context->sc_cs;
710 regs->tf_eflags = eflags;
711 regs->tf_esp = context->sc_esp_at_signal;
712 regs->tf_ss = context->sc_ss;
715 * call sigaltstack & ignore results..
718 ss.ss_sp = lss->ss_sp;
719 ss.ss_size = lss->ss_size;
720 ss.ss_flags = linux_to_bsd_sigaltstack(lss->ss_flags);
723 if (ldebug(rt_sigreturn))
724 kprintf(LMSG("rt_sigret flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
725 ss.ss_flags, ss.ss_sp, ss.ss_size, context->sc_mask);
727 kern_sigaltstack(&ss, NULL);
729 return (EJUSTRETURN);
738 linux_prepsyscall(struct trapframe *tf, int *args, u_int *code, caddr_t *params)
740 args[0] = tf->tf_ebx;
741 args[1] = tf->tf_ecx;
742 args[2] = tf->tf_edx;
743 args[3] = tf->tf_esi;
744 args[4] = tf->tf_edi;
745 args[5] = tf->tf_ebp;
746 *params = NULL; /* no copyin */
750 * If a linux binary is exec'ing something, try this image activator
751 * first. We override standard shell script execution in order to
752 * be able to modify the interpreter path. We only do this if a linux
753 * binary is doing the exec, so we do not create an EXEC module for it.
755 static int exec_linux_imgact_try (struct image_params *iparams);
758 exec_linux_imgact_try(struct image_params *imgp)
760 const char *head = (const char *)imgp->image_header;
764 * The interpreter for shell scripts run from a linux binary needs
765 * to be located in /compat/linux if possible in order to recursively
766 * maintain linux path emulation.
768 if (((const short *)head)[0] == SHELLMAGIC) {
770 * Run our normal shell image activator. If it succeeds attempt
771 * to use the alternate path for the interpreter. If an alternate
772 * path is found, use our stringspace to store it.
774 if ((error = exec_shell_imgact(imgp)) == 0) {
775 linux_translate_path(imgp->interpreter_name,
782 struct sysentvec linux_sysvec = {
783 LINUX_SYS_MAXSYSCALL,
798 exec_linux_imgact_try,
802 struct sysentvec elf_linux_sysvec = {
803 LINUX_SYS_MAXSYSCALL,
818 exec_linux_imgact_try,
822 static int linux_match_abi_note(const Elf_Note *abi_note);
823 static int linux_match_suse_note(const Elf_Note *abi_note);
825 static Elf32_Brandinfo linux_brand = {
828 linux_match_abi_note,
830 "/lib/ld-linux.so.1",
834 static Elf32_Brandinfo linux_glibc2brand = {
837 linux_match_abi_note,
839 "/lib/ld-linux.so.2",
843 static Elf32_Brandinfo linux_suse_brand = {
846 linux_match_suse_note,
848 "/lib/ld-linux.so.2",
852 Elf32_Brandinfo *linux_brandlist[] = {
860 linux_match_abi_note(const Elf_Note *abi_note)
862 const char *abi_name = (const char *)
863 ((const uint8_t *)abi_note + sizeof(*abi_note));
864 const uint32_t *descr = (const uint32_t *)
865 ((const uint8_t *)abi_name + abi_note->n_namesz);
867 if (abi_note->n_namesz != sizeof("GNU"))
869 if (memcmp(abi_name, "GNU", sizeof("GNU")))
871 if (abi_note->n_descsz < sizeof(uint32_t))
880 linux_match_suse_note(const Elf_Note *abi_note)
882 const char *abi_name = (const char *)
883 ((const uint8_t *)abi_note + sizeof(*abi_note));
885 if (abi_note->n_namesz != sizeof("SuSE"))
887 if (memcmp(abi_name, "SuSE", sizeof("SuSE")))
894 linux_elf_modevent(module_t mod, int type, void *data)
896 Elf32_Brandinfo **brandinfo;
903 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
905 if (elf_insert_brand_entry(*brandinfo) < 0)
909 kprintf("Linux ELF exec handler installed\n");
911 kprintf("cannot insert Linux ELF brand handler\n");
914 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
916 if (elf_brand_inuse(*brandinfo))
919 for (brandinfo = &linux_brandlist[0];
920 *brandinfo != NULL; ++brandinfo)
921 if (elf_remove_brand_entry(*brandinfo) < 0)
926 kprintf("Linux ELF exec handler removed\n");
928 kprintf("Could not deinstall ELF interpreter entry\n");
936 static moduledata_t linux_elf_mod = {
942 DECLARE_MODULE(linuxelf, linux_elf_mod, SI_SUB_EXEC, SI_ORDER_ANY);