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 without 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>
51 #include <sys/eventhandler.h>
54 #include <vm/vm_param.h>
55 #include <vm/vm_page.h>
56 #include <vm/vm_extern.h>
58 #include <sys/kernel.h>
59 #include <sys/module.h>
60 #include <machine/cpu.h>
63 #include "linux_proto.h"
64 #include "../linux_signal.h"
65 #include "../linux_util.h"
66 #include "../linux_futex.h"
67 #include "../linux_emuldata.h"
69 MODULE_VERSION(linux, 1);
71 MALLOC_DEFINE(M_LINUX, "linux", "Linux mode structures");
73 #if BYTE_ORDER == LITTLE_ENDIAN
74 #define SHELLMAGIC 0x2123 /* #! */
76 #define SHELLMAGIC 0x2321
80 * Allow the sendsig functions to use the ldebug() facility
81 * even though they are not syscalls themselves. Map them
82 * to syscall 0. This is slightly less bogus than using
85 #define LINUX_SYS_linux_rt_sendsig 0
86 #define LINUX_SYS_linux_sendsig 0
88 extern char linux_sigcode[];
89 extern int linux_szsigcode;
91 extern struct sysent linux_sysent[LINUX_SYS_MAXSYSCALL];
93 static int linux_fixup (register_t **stack_base,
94 struct image_params *iparams);
95 static int elf_linux_fixup (register_t **stack_base,
96 struct image_params *iparams);
97 static void linux_prepsyscall (struct trapframe *tf, int *args,
98 u_int *code, caddr_t *params);
99 static void linux_sendsig (sig_t catcher, int sig, sigset_t *mask,
102 static eventhandler_tag linux_exec_tag;
103 static eventhandler_tag linux_exit_tag;
106 * Linux syscalls return negative errno's, we do positive and map them
108 static int bsd_to_linux_errno[ELAST + 1] = {
109 -0, -1, -2, -3, -4, -5, -6, -7, -8, -9,
110 -10, -35, -12, -13, -14, -15, -16, -17, -18, -19,
111 -20, -21, -22, -23, -24, -25, -26, -27, -28, -29,
112 -30, -31, -32, -33, -34, -11,-115,-114, -88, -89,
113 -90, -91, -92, -93, -94, -95, -96, -97, -98, -99,
114 -100,-101,-102,-103,-104,-105,-106,-107,-108,-109,
115 -110,-111, -40, -36,-112,-113, -39, -11, -87,-122,
116 -116, -66, -6, -6, -6, -6, -6, -37, -38, -9,
117 -6, -6, -43, -42, -75, -6, -84
120 int bsd_to_linux_signal[LINUX_SIGTBLSZ] = {
121 LINUX_SIGHUP, LINUX_SIGINT, LINUX_SIGQUIT, LINUX_SIGILL,
122 LINUX_SIGTRAP, LINUX_SIGABRT, 0, LINUX_SIGFPE,
123 LINUX_SIGKILL, LINUX_SIGBUS, LINUX_SIGSEGV, LINUX_SIGSYS,
124 LINUX_SIGPIPE, LINUX_SIGALRM, LINUX_SIGTERM, LINUX_SIGURG,
125 LINUX_SIGSTOP, LINUX_SIGTSTP, LINUX_SIGCONT, LINUX_SIGCHLD,
126 LINUX_SIGTTIN, LINUX_SIGTTOU, LINUX_SIGIO, LINUX_SIGXCPU,
127 LINUX_SIGXFSZ, LINUX_SIGVTALRM, LINUX_SIGPROF, LINUX_SIGWINCH,
128 0, LINUX_SIGUSR1, LINUX_SIGUSR2
131 int linux_to_bsd_signal[LINUX_SIGTBLSZ] = {
132 SIGHUP, SIGINT, SIGQUIT, SIGILL,
133 SIGTRAP, SIGABRT, SIGBUS, SIGFPE,
134 SIGKILL, SIGUSR1, SIGSEGV, SIGUSR2,
135 SIGPIPE, SIGALRM, SIGTERM, SIGBUS,
136 SIGCHLD, SIGCONT, SIGSTOP, SIGTSTP,
137 SIGTTIN, SIGTTOU, SIGURG, SIGXCPU,
138 SIGXFSZ, SIGVTALRM, SIGPROF, SIGWINCH,
139 SIGIO, SIGURG, SIGSYS
142 #define LINUX_T_UNKNOWN 255
143 static int _bsd_to_linux_trapcode[] = {
144 LINUX_T_UNKNOWN, /* 0 */
145 6, /* 1 T_PRIVINFLT */
146 LINUX_T_UNKNOWN, /* 2 */
148 LINUX_T_UNKNOWN, /* 4 */
149 LINUX_T_UNKNOWN, /* 5 */
150 16, /* 6 T_ARITHTRAP */
151 254, /* 7 T_ASTFLT */
152 LINUX_T_UNKNOWN, /* 8 */
153 13, /* 9 T_PROTFLT */
154 1, /* 10 T_TRCTRAP */
155 LINUX_T_UNKNOWN, /* 11 */
156 14, /* 12 T_PAGEFLT */
157 LINUX_T_UNKNOWN, /* 13 */
158 17, /* 14 T_ALIGNFLT */
159 LINUX_T_UNKNOWN, /* 15 */
160 LINUX_T_UNKNOWN, /* 16 */
161 LINUX_T_UNKNOWN, /* 17 */
167 8, /* 23 T_DOUBLEFLT */
168 9, /* 24 T_FPOPFLT */
169 10, /* 25 T_TSSFLT */
170 11, /* 26 T_SEGNPFLT */
171 12, /* 27 T_STKFLT */
173 19, /* 29 T_XMMFLT */
174 15 /* 30 T_RESERVED */
176 #define bsd_to_linux_trapcode(code) \
177 ((code)<sizeof(_bsd_to_linux_trapcode)/sizeof(*_bsd_to_linux_trapcode)? \
178 _bsd_to_linux_trapcode[(code)]: \
182 * If FreeBSD & Linux have a difference of opinion about what a trap
183 * means, deal with it here.
186 translate_traps(int signal, int trap_code)
188 if (signal != SIGBUS)
202 linux_fixup(register_t **stack_base, struct image_params *imgp)
204 register_t *argv, *envp;
207 envp = *stack_base + (imgp->args->argc + 1);
209 **stack_base = (intptr_t)(void *)envp;
211 **stack_base = (intptr_t)(void *)argv;
213 **stack_base = imgp->args->argc;
218 elf_linux_fixup(register_t **stack_base, struct image_params *imgp)
220 Elf32_Auxargs *args = (Elf32_Auxargs *)imgp->auxargs;
223 pos = *stack_base + (imgp->args->argc + imgp->args->envc + 2);
226 AUXARGS_ENTRY(pos, AT_DEBUG, 1);
228 if (args->execfd != -1) {
229 AUXARGS_ENTRY(pos, AT_EXECFD, args->execfd);
231 AUXARGS_ENTRY(pos, AT_PHDR, args->phdr);
232 AUXARGS_ENTRY(pos, AT_PHENT, args->phent);
233 AUXARGS_ENTRY(pos, AT_PHNUM, args->phnum);
234 AUXARGS_ENTRY(pos, AT_PAGESZ, args->pagesz);
235 AUXARGS_ENTRY(pos, AT_FLAGS, args->flags);
236 AUXARGS_ENTRY(pos, AT_ENTRY, args->entry);
237 AUXARGS_ENTRY(pos, AT_BASE, args->base);
238 AUXARGS_ENTRY(pos, AT_UID, imgp->proc->p_ucred->cr_ruid);
239 AUXARGS_ENTRY(pos, AT_EUID, imgp->proc->p_ucred->cr_svuid);
240 AUXARGS_ENTRY(pos, AT_GID, imgp->proc->p_ucred->cr_rgid);
241 AUXARGS_ENTRY(pos, AT_EGID, imgp->proc->p_ucred->cr_svgid);
242 AUXARGS_ENTRY(pos, AT_NULL, 0);
244 kfree(imgp->auxargs, M_TEMP);
245 imgp->auxargs = NULL;
248 **stack_base = (long)imgp->args->argc;
252 extern int _ucodesel, _udatasel;
253 extern unsigned long linux_sznonrtsigcode;
256 linux_rt_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code)
258 struct proc *p = curproc;
259 struct lwp *lp = curthread->td_lwp;
260 struct trapframe *regs;
261 struct l_rt_sigframe *fp, frame;
264 regs = lp->lwp_md.md_regs;
265 oonstack = lp->lwp_sigstk.ss_flags & SS_ONSTACK;
268 if (ldebug(rt_sendsig))
269 kprintf(ARGS(rt_sendsig, "%p, %d, %p, %lu"),
270 catcher, sig, (void*)mask, code);
273 * Allocate space for the signal handler context.
275 if ((lp->lwp_flag & LWP_ALTSTACK) && !oonstack &&
276 SIGISMEMBER(p->p_sigacts->ps_sigonstack, sig)) {
277 fp = (struct l_rt_sigframe *)(lp->lwp_sigstk.ss_sp +
278 lp->lwp_sigstk.ss_size - sizeof(struct l_rt_sigframe));
279 lp->lwp_sigstk.ss_flags |= SS_ONSTACK;
281 fp = (struct l_rt_sigframe *)regs->tf_esp - 1;
284 * grow() will return FALSE if the fp will not fit inside the stack
285 * and the stack can not be grown. useracc will return FALSE
286 * if access is denied.
288 if ((vm_map_growstack(p, (vm_offset_t)fp) != KERN_SUCCESS) ||
289 !useracc((caddr_t)fp, sizeof (struct l_rt_sigframe),
292 * Process has trashed its stack; give it an illegal
293 * instruction to halt it in its tracks.
295 SIGACTION(p, SIGILL) = SIG_DFL;
296 SIGDELSET(p->p_sigignore, SIGILL);
297 SIGDELSET(p->p_sigcatch, SIGILL);
298 SIGDELSET(lp->lwp_sigmask, SIGILL);
300 if (ldebug(rt_sendsig))
301 kprintf(LMSG("rt_sendsig: bad stack %p, oonstack=%x"),
304 lwpsignal(p, lp, SIGILL);
309 * Build the argument list for the signal handler.
311 if (p->p_sysent->sv_sigtbl)
312 if (sig <= p->p_sysent->sv_sigsize)
313 sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
315 frame.sf_handler = catcher;
317 frame.sf_siginfo = &fp->sf_si;
318 frame.sf_ucontext = &fp->sf_sc;
320 /* Fill siginfo structure. */
321 frame.sf_si.lsi_signo = sig;
322 frame.sf_si.lsi_code = code;
323 frame.sf_si.lsi_addr = (void *)regs->tf_err;
326 * Build the signal context to be used by sigreturn.
328 frame.sf_sc.uc_flags = 0; /* XXX ??? */
329 frame.sf_sc.uc_link = NULL; /* XXX ??? */
331 frame.sf_sc.uc_stack.ss_sp = lp->lwp_sigstk.ss_sp;
332 frame.sf_sc.uc_stack.ss_size = lp->lwp_sigstk.ss_size;
333 frame.sf_sc.uc_stack.ss_flags = (lp->lwp_flag & LWP_ALTSTACK)
334 ? ((oonstack) ? LINUX_SS_ONSTACK : 0) : LINUX_SS_DISABLE;
336 bsd_to_linux_sigset(mask, &frame.sf_sc.uc_sigmask);
338 frame.sf_sc.uc_mcontext.sc_mask = frame.sf_sc.uc_sigmask.__bits[0];
339 frame.sf_sc.uc_mcontext.sc_gs = regs->tf_gs;
340 frame.sf_sc.uc_mcontext.sc_fs = regs->tf_fs;
341 frame.sf_sc.uc_mcontext.sc_es = regs->tf_es;
342 frame.sf_sc.uc_mcontext.sc_ds = regs->tf_ds;
343 frame.sf_sc.uc_mcontext.sc_edi = regs->tf_edi;
344 frame.sf_sc.uc_mcontext.sc_esi = regs->tf_esi;
345 frame.sf_sc.uc_mcontext.sc_ebp = regs->tf_ebp;
346 frame.sf_sc.uc_mcontext.sc_ebx = regs->tf_ebx;
347 frame.sf_sc.uc_mcontext.sc_edx = regs->tf_edx;
348 frame.sf_sc.uc_mcontext.sc_ecx = regs->tf_ecx;
349 frame.sf_sc.uc_mcontext.sc_eax = regs->tf_eax;
350 frame.sf_sc.uc_mcontext.sc_eip = regs->tf_eip;
351 frame.sf_sc.uc_mcontext.sc_cs = regs->tf_cs;
352 frame.sf_sc.uc_mcontext.sc_eflags = regs->tf_eflags;
353 frame.sf_sc.uc_mcontext.sc_esp_at_signal = regs->tf_esp;
354 frame.sf_sc.uc_mcontext.sc_ss = regs->tf_ss;
355 frame.sf_sc.uc_mcontext.sc_err = regs->tf_err;
356 frame.sf_sc.uc_mcontext.sc_trapno = bsd_to_linux_trapcode(code);
359 if (ldebug(rt_sendsig))
360 kprintf(LMSG("rt_sendsig flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
361 frame.sf_sc.uc_stack.ss_flags, lp->lwp_sigstk.ss_sp,
362 lp->lwp_sigstk.ss_size, frame.sf_sc.uc_mcontext.sc_mask);
365 if (copyout(&frame, fp, sizeof(frame)) != 0) {
367 * Process has trashed its stack; give it an illegal
368 * instruction to halt it in its tracks.
375 * Build context to run handler in.
377 regs->tf_esp = (int)fp;
378 regs->tf_eip = PS_STRINGS - *(p->p_sysent->sv_szsigcode) +
379 linux_sznonrtsigcode;
382 * i386 abi specifies that the direction flag must be cleared
385 regs->tf_eflags &= ~(PSL_T | PSL_VM | PSL_D);
387 regs->tf_cs = _ucodesel;
388 regs->tf_ds = _udatasel;
389 regs->tf_es = _udatasel;
390 /* allow %fs and %gs to be inherited by the signal handler */
392 regs->tf_fs = _udatasel;
393 regs->tf_gs = _udatasel;
395 regs->tf_ss = _udatasel;
400 * Send an interrupt to process.
402 * Stack is set up to allow sigcode stored
403 * in u. to call routine, followed by kcall
404 * to sigreturn routine below. After sigreturn
405 * resets the signal mask, the stack, and the
406 * frame pointer, it returns to the user
411 linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code)
413 struct proc *p = curproc;
414 struct lwp *lp = curthread->td_lwp;
415 struct trapframe *regs;
416 struct l_sigframe *fp, frame;
420 if (SIGISMEMBER(p->p_sigacts->ps_siginfo, sig)) {
421 /* Signal handler installed with SA_SIGINFO. */
422 linux_rt_sendsig(catcher, sig, mask, code);
426 regs = lp->lwp_md.md_regs;
427 oonstack = lp->lwp_sigstk.ss_flags & SS_ONSTACK;
431 kprintf(ARGS(sendsig, "%p, %d, %p, %lu"),
432 catcher, sig, (void*)mask, code);
436 * Allocate space for the signal handler context.
438 if ((lp->lwp_flag & LWP_ALTSTACK) && !oonstack &&
439 SIGISMEMBER(p->p_sigacts->ps_sigonstack, sig)) {
440 fp = (struct l_sigframe *)(lp->lwp_sigstk.ss_sp +
441 lp->lwp_sigstk.ss_size - sizeof(struct l_sigframe));
442 lp->lwp_sigstk.ss_flags |= SS_ONSTACK;
444 fp = (struct l_sigframe *)regs->tf_esp - 1;
447 * grow() will return FALSE if the fp will not fit inside the stack
448 * and the stack can not be grown. useracc will return FALSE
449 * if access is denied.
451 if ((vm_map_growstack(p, (vm_offset_t)fp) != KERN_SUCCESS) ||
452 !useracc((caddr_t)fp, sizeof (struct l_sigframe),
455 * Process has trashed its stack; give it an illegal
456 * instruction to halt it in its tracks.
458 SIGACTION(p, SIGILL) = SIG_DFL;
459 SIGDELSET(p->p_sigignore, SIGILL);
460 SIGDELSET(p->p_sigcatch, SIGILL);
461 SIGDELSET(lp->lwp_sigmask, SIGILL);
462 lwpsignal(p, lp, SIGILL);
467 * Build the argument list for the signal handler.
469 if (p->p_sysent->sv_sigtbl)
470 if (sig <= p->p_sysent->sv_sigsize)
471 sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
473 frame.sf_handler = catcher;
476 bsd_to_linux_sigset(mask, &lmask);
479 * Build the signal context to be used by sigreturn.
481 frame.sf_sc.sc_mask = lmask.__bits[0];
482 frame.sf_sc.sc_gs = regs->tf_gs;
483 frame.sf_sc.sc_fs = regs->tf_fs;
484 frame.sf_sc.sc_es = regs->tf_es;
485 frame.sf_sc.sc_ds = regs->tf_ds;
486 frame.sf_sc.sc_edi = regs->tf_edi;
487 frame.sf_sc.sc_esi = regs->tf_esi;
488 frame.sf_sc.sc_ebp = regs->tf_ebp;
489 frame.sf_sc.sc_ebx = regs->tf_ebx;
490 frame.sf_sc.sc_edx = regs->tf_edx;
491 frame.sf_sc.sc_ecx = regs->tf_ecx;
492 frame.sf_sc.sc_eax = regs->tf_eax;
493 frame.sf_sc.sc_eip = regs->tf_eip;
494 frame.sf_sc.sc_cs = regs->tf_cs;
495 frame.sf_sc.sc_eflags = regs->tf_eflags;
496 frame.sf_sc.sc_esp_at_signal = regs->tf_esp;
497 frame.sf_sc.sc_ss = regs->tf_ss;
498 frame.sf_sc.sc_err = regs->tf_err;
499 frame.sf_sc.sc_trapno = bsd_to_linux_trapcode(code);
501 bzero(&frame.sf_fpstate, sizeof(struct l_fpstate));
503 for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
504 frame.sf_extramask[i] = lmask.__bits[i+1];
506 if (copyout(&frame, fp, sizeof(frame)) != 0) {
508 * Process has trashed its stack; give it an illegal
509 * instruction to halt it in its tracks.
516 * Build context to run handler in.
518 regs->tf_esp = (int)fp;
519 regs->tf_eip = PS_STRINGS - *(p->p_sysent->sv_szsigcode);
522 * i386 abi specifies that the direction flag must be cleared
525 regs->tf_eflags &= ~(PSL_T | PSL_VM | PSL_D);
527 regs->tf_cs = _ucodesel;
528 regs->tf_ds = _udatasel;
529 regs->tf_es = _udatasel;
530 /* Allow %fs and %gs to be inherited by the signal handler */
532 regs->tf_fs = _udatasel;
533 regs->tf_gs = _udatasel;
535 regs->tf_ss = _udatasel;
539 * System call to cleanup state after a signal
540 * has been taken. Reset signal mask and
541 * stack state from context left by sendsig (above).
542 * Return to previous pc and psl as specified by
543 * context left by sendsig. Check carefully to
544 * make sure that the user has not modified the
545 * psl to gain improper privileges or to cause
551 sys_linux_sigreturn(struct linux_sigreturn_args *args)
553 struct lwp *lp = curthread->td_lwp;
554 struct l_sigframe frame;
555 struct trapframe *regs;
559 regs = lp->lwp_md.md_regs;
562 if (ldebug(sigreturn))
563 kprintf(ARGS(sigreturn, "%p"), (void *)args->sfp);
566 * The trampoline code hands us the sigframe.
567 * It is unsafe to keep track of it ourselves, in the event that a
568 * program jumps out of a signal handler.
570 if (copyin((caddr_t)args->sfp, &frame, sizeof(frame)) != 0)
574 * Check for security violations.
576 #define EFLAGS_SECURE(ef, oef) ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
577 eflags = frame.sf_sc.sc_eflags;
579 * XXX do allow users to change the privileged flag PSL_RF. The
580 * cpu sets PSL_RF in tf_eflags for faults. Debuggers should
581 * sometimes set it there too. tf_eflags is kept in the signal
582 * context during signal handling and there is no other place
583 * to remember it, so the PSL_RF bit may be corrupted by the
584 * signal handler without us knowing. Corruption of the PSL_RF
585 * bit at worst causes one more or one less debugger trap, so
586 * allowing it is fairly harmless.
588 if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF)) {
593 * Don't allow users to load a valid privileged %cs. Let the
594 * hardware check for invalid selectors, excess privilege in
595 * other selectors, invalid %eip's and invalid %esp's.
597 #define CS_SECURE(cs) (ISPL(cs) == SEL_UPL)
598 if (!CS_SECURE(frame.sf_sc.sc_cs)) {
599 trapsignal(lp, SIGBUS, T_PROTFLT);
603 lp->lwp_sigstk.ss_flags &= ~SS_ONSTACK;
604 lmask.__bits[0] = frame.sf_sc.sc_mask;
605 for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
606 lmask.__bits[i+1] = frame.sf_extramask[i];
607 linux_to_bsd_sigset(&lmask, &lp->lwp_sigmask);
608 SIG_CANTMASK(lp->lwp_sigmask);
611 * Restore signal context.
613 /* %gs was restored by the trampoline. */
614 regs->tf_fs = frame.sf_sc.sc_fs;
615 regs->tf_es = frame.sf_sc.sc_es;
616 regs->tf_ds = frame.sf_sc.sc_ds;
617 regs->tf_edi = frame.sf_sc.sc_edi;
618 regs->tf_esi = frame.sf_sc.sc_esi;
619 regs->tf_ebp = frame.sf_sc.sc_ebp;
620 regs->tf_ebx = frame.sf_sc.sc_ebx;
621 regs->tf_edx = frame.sf_sc.sc_edx;
622 regs->tf_ecx = frame.sf_sc.sc_ecx;
623 regs->tf_eax = frame.sf_sc.sc_eax;
624 regs->tf_eip = frame.sf_sc.sc_eip;
625 regs->tf_cs = frame.sf_sc.sc_cs;
626 regs->tf_eflags = eflags;
627 regs->tf_esp = frame.sf_sc.sc_esp_at_signal;
628 regs->tf_ss = frame.sf_sc.sc_ss;
630 return (EJUSTRETURN);
634 * System call to cleanup state after a signal
635 * has been taken. Reset signal mask and
636 * stack state from context left by rt_sendsig (above).
637 * Return to previous pc and psl as specified by
638 * context left by sendsig. Check carefully to
639 * make sure that the user has not modified the
640 * psl to gain improper privileges or to cause
646 sys_linux_rt_sigreturn(struct linux_rt_sigreturn_args *args)
648 struct lwp *lp = curthread->td_lwp;
649 struct l_ucontext uc;
650 struct l_sigcontext *context;
653 struct trapframe *regs;
656 regs = lp->lwp_md.md_regs;
659 if (ldebug(rt_sigreturn))
660 kprintf(ARGS(rt_sigreturn, "%p"), (void *)args->ucp);
663 * The trampoline code hands us the ucontext.
664 * It is unsafe to keep track of it ourselves, in the event that a
665 * program jumps out of a signal handler.
667 if (copyin((caddr_t)args->ucp, &uc, sizeof(uc)) != 0)
670 context = &uc.uc_mcontext;
673 * Check for security violations.
675 #define EFLAGS_SECURE(ef, oef) ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
676 eflags = context->sc_eflags;
678 * XXX do allow users to change the privileged flag PSL_RF. The
679 * cpu sets PSL_RF in tf_eflags for faults. Debuggers should
680 * sometimes set it there too. tf_eflags is kept in the signal
681 * context during signal handling and there is no other place
682 * to remember it, so the PSL_RF bit may be corrupted by the
683 * signal handler without us knowing. Corruption of the PSL_RF
684 * bit at worst causes one more or one less debugger trap, so
685 * allowing it is fairly harmless.
687 if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF)) {
692 * Don't allow users to load a valid privileged %cs. Let the
693 * hardware check for invalid selectors, excess privilege in
694 * other selectors, invalid %eip's and invalid %esp's.
696 #define CS_SECURE(cs) (ISPL(cs) == SEL_UPL)
697 if (!CS_SECURE(context->sc_cs)) {
698 trapsignal(lp, SIGBUS, T_PROTFLT);
702 lp->lwp_sigstk.ss_flags &= ~SS_ONSTACK;
703 linux_to_bsd_sigset(&uc.uc_sigmask, &lp->lwp_sigmask);
704 SIG_CANTMASK(lp->lwp_sigmask);
707 * Restore signal context
709 /* %gs was restored by the trampoline. */
710 regs->tf_fs = context->sc_fs;
711 regs->tf_es = context->sc_es;
712 regs->tf_ds = context->sc_ds;
713 regs->tf_edi = context->sc_edi;
714 regs->tf_esi = context->sc_esi;
715 regs->tf_ebp = context->sc_ebp;
716 regs->tf_ebx = context->sc_ebx;
717 regs->tf_edx = context->sc_edx;
718 regs->tf_ecx = context->sc_ecx;
719 regs->tf_eax = context->sc_eax;
720 regs->tf_eip = context->sc_eip;
721 regs->tf_cs = context->sc_cs;
722 regs->tf_eflags = eflags;
723 regs->tf_esp = context->sc_esp_at_signal;
724 regs->tf_ss = context->sc_ss;
727 * call sigaltstack & ignore results..
730 ss.ss_sp = lss->ss_sp;
731 ss.ss_size = lss->ss_size;
732 ss.ss_flags = linux_to_bsd_sigaltstack(lss->ss_flags);
735 if (ldebug(rt_sigreturn))
736 kprintf(LMSG("rt_sigret flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
737 ss.ss_flags, ss.ss_sp, ss.ss_size, context->sc_mask);
739 kern_sigaltstack(&ss, NULL);
741 return (EJUSTRETURN);
750 linux_prepsyscall(struct trapframe *tf, int *args, u_int *code, caddr_t *params)
752 args[0] = tf->tf_ebx;
753 args[1] = tf->tf_ecx;
754 args[2] = tf->tf_edx;
755 args[3] = tf->tf_esi;
756 args[4] = tf->tf_edi;
757 args[5] = tf->tf_ebp;
758 *params = NULL; /* no copyin */
762 * If a linux binary is exec'ing something, try this image activator
763 * first. We override standard shell script execution in order to
764 * be able to modify the interpreter path. We only do this if a linux
765 * binary is doing the exec, so we do not create an EXEC module for it.
767 static int exec_linux_imgact_try (struct image_params *iparams);
770 exec_linux_imgact_try(struct image_params *imgp)
772 const char *head = (const char *)imgp->image_header;
776 * The interpreter for shell scripts run from a linux binary needs
777 * to be located in /compat/linux if possible in order to recursively
778 * maintain linux path emulation.
780 if (((const short *)head)[0] == SHELLMAGIC) {
782 * Run our normal shell image activator. If it succeeds attempt
783 * to use the alternate path for the interpreter. If an alternate
784 * path is found, use our stringspace to store it.
786 if ((error = exec_shell_imgact(imgp)) == 0) {
787 linux_translate_path(imgp->interpreter_name,
794 struct sysentvec linux_sysvec = {
795 LINUX_SYS_MAXSYSCALL,
810 exec_linux_imgact_try,
814 struct sysentvec elf_linux_sysvec = {
815 LINUX_SYS_MAXSYSCALL,
828 #if defined(__x86_64__)
834 exec_linux_imgact_try,
838 static int linux_match_abi_note(const Elf_Note *abi_note);
839 static int linux_match_suse_note(const Elf_Note *abi_note);
841 static Elf32_Brandinfo linux_brand = {
844 linux_match_abi_note,
846 "/lib/ld-linux.so.1",
850 static Elf32_Brandinfo linux_glibc2brand = {
853 linux_match_abi_note,
855 "/lib/ld-linux.so.2",
859 static Elf32_Brandinfo linux_suse_brand = {
862 linux_match_suse_note,
864 "/lib/ld-linux.so.2",
868 Elf32_Brandinfo *linux_brandlist[] = {
876 linux_match_abi_note(const Elf_Note *abi_note)
878 const char *abi_name = (const char *)
879 ((const uint8_t *)abi_note + sizeof(*abi_note));
880 const uint32_t *descr = (const uint32_t *)
881 ((const uint8_t *)abi_name + abi_note->n_namesz);
883 if (abi_note->n_namesz != sizeof("GNU"))
885 if (memcmp(abi_name, "GNU", sizeof("GNU")))
887 if (abi_note->n_descsz < sizeof(uint32_t))
896 linux_match_suse_note(const Elf_Note *abi_note)
898 const char *abi_name = (const char *)
899 ((const uint8_t *)abi_note + sizeof(*abi_note));
901 if (abi_note->n_namesz != sizeof("SuSE"))
903 if (memcmp(abi_name, "SuSE", sizeof("SuSE")))
910 linux_elf_modevent(module_t mod, int type, void *data)
912 Elf32_Brandinfo **brandinfo;
919 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
921 if (elf_insert_brand_entry(*brandinfo) < 0)
925 kprintf("Linux ELF exec handler installed\n");
927 kprintf("cannot insert Linux ELF brand handler\n");
930 lockinit(&futex_mtx, "linftxs", 0, LK_CANRECURSE);
931 linux_exec_tag = EVENTHANDLER_REGISTER(process_exec, linux_proc_transition,
933 linux_exit_tag = EVENTHANDLER_REGISTER(process_exit, emuldata_exit,
937 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
939 if (elf_brand_inuse(*brandinfo))
942 for (brandinfo = &linux_brandlist[0];
943 *brandinfo != NULL; ++brandinfo)
944 if (elf_remove_brand_entry(*brandinfo) < 0)
949 kprintf("Linux ELF exec handler removed\n");
951 kprintf("Could not deinstall ELF interpreter entry\n");
953 EVENTHANDLER_DEREGISTER(process_exec, linux_exec_tag);
954 EVENTHANDLER_DEREGISTER(process_exit, linux_exit_tag);
955 lockuninit(&futex_mtx);
964 static moduledata_t linux_elf_mod = {
970 DECLARE_MODULE(linuxelf, linux_elf_mod, SI_SUB_EXEC, SI_ORDER_ANY);