4cf5a04ec2139bab7a694cfff43eac2c411ed940
[dragonfly.git] / sys / emulation / linux / i386 / linux_sysvec.c
1 /*-
2  * Copyright (c) 1994-1996 Søren Schmidt
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer 
10  *    in this position and unchanged.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  * 3. The name of the author may not be used to endorse or promote products
15  *    derived from this software withough specific prior written permission
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  *
28  * $FreeBSD: src/sys/i386/linux/linux_sysvec.c,v 1.55.2.9 2002/01/12 11:03:30 bde Exp $
29  * $DragonFly: src/sys/emulation/linux/i386/linux_sysvec.c,v 1.31 2008/04/21 15:47:53 dillon Exp $
30  */
31
32 /* XXX we use functions that might not exist. */
33 #include "opt_compat.h"
34
35 #ifndef COMPAT_43
36 #error "Unable to compile Linux-emulator due to missing COMPAT_43 option!"
37 #endif
38
39 #include <sys/param.h>
40 #include <sys/systm.h>
41 #include <sys/imgact.h>
42 #include <sys/imgact_aout.h>
43 #include <sys/imgact_elf.h>
44 #include <sys/kern_syscall.h>
45 #include <sys/lock.h>
46 #include <sys/malloc.h>
47 #include <sys/proc.h>
48 #include <sys/signalvar.h>
49 #include <sys/sysent.h>
50 #include <sys/sysproto.h>
51
52 #include <vm/vm.h>
53 #include <vm/vm_param.h>
54 #include <vm/vm_page.h>
55 #include <vm/vm_extern.h>
56 #include <sys/exec.h>
57 #include <sys/kernel.h>
58 #include <sys/module.h>
59 #include <machine/cpu.h>
60
61 #include "linux.h"
62 #include "linux_proto.h"
63 #include "../linux_signal.h"
64 #include "../linux_util.h"
65
66 MALLOC_DEFINE(M_LINUX, "linux", "Linux mode structures");
67
68 #if BYTE_ORDER == LITTLE_ENDIAN
69 #define SHELLMAGIC      0x2123 /* #! */
70 #else
71 #define SHELLMAGIC      0x2321
72 #endif
73
74 /*
75  * Allow the sendsig functions to use the ldebug() facility
76  * even though they are not syscalls themselves. Map them
77  * to syscall 0. This is slightly less bogus than using
78  * ldebug(sigreturn).
79  */
80 #define LINUX_SYS_linux_rt_sendsig      0
81 #define LINUX_SYS_linux_sendsig         0
82
83 extern char linux_sigcode[];
84 extern int linux_szsigcode;
85
86 extern struct sysent linux_sysent[LINUX_SYS_MAXSYSCALL];
87
88 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,
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->args->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->args->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->args->argc + imgp->args->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_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);
235         
236         kfree(imgp->auxargs, M_TEMP);      
237         imgp->auxargs = NULL;
238
239         (*stack_base)--;
240         **stack_base = (long)imgp->args->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         struct proc *p = curproc;
251         struct lwp *lp = curthread->td_lwp;
252         struct trapframe *regs;
253         struct l_rt_sigframe *fp, frame;
254         int oonstack;
255
256         regs = lp->lwp_md.md_regs;
257         oonstack = lp->lwp_sigstk.ss_flags & SS_ONSTACK;
258
259 #ifdef DEBUG
260         if (ldebug(rt_sendsig))
261                 kprintf(ARGS(rt_sendsig, "%p, %d, %p, %lu"),
262                     catcher, sig, (void*)mask, code);
263 #endif
264         /*
265          * Allocate space for the signal handler context.
266          */
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;
272         } else
273                 fp = (struct l_rt_sigframe *)regs->tf_esp - 1;
274
275         /*
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.
279          */
280         if ((grow_stack (p, (int)fp) == FALSE) ||
281             !useracc((caddr_t)fp, sizeof (struct l_rt_sigframe), 
282             VM_PROT_WRITE)) {
283                 /*
284                  * Process has trashed its stack; give it an illegal
285                  * instruction to halt it in its tracks.
286                  */
287                 SIGACTION(p, SIGILL) = SIG_DFL;
288                 SIGDELSET(p->p_sigignore, SIGILL);
289                 SIGDELSET(p->p_sigcatch, SIGILL);
290                 SIGDELSET(lp->lwp_sigmask, SIGILL);
291 #ifdef DEBUG
292                 if (ldebug(rt_sendsig))
293                         kprintf(LMSG("rt_sendsig: bad stack %p, oonstack=%x"),
294                             fp, oonstack);
295 #endif
296                 lwpsignal(p, lp, SIGILL);
297                 return;
298         }
299
300         /*
301          * Build the argument list for the signal handler.
302          */
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)];
306
307         frame.sf_handler = catcher;
308         frame.sf_sig = sig;
309         frame.sf_siginfo = &fp->sf_si;
310         frame.sf_ucontext = &fp->sf_sc;
311
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;
316
317         /*
318          * Build the signal context to be used by sigreturn.
319          */
320         frame.sf_sc.uc_flags = 0;               /* XXX ??? */
321         frame.sf_sc.uc_link = NULL;             /* XXX ??? */
322
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;
327
328         bsd_to_linux_sigset(mask, &frame.sf_sc.uc_sigmask);
329
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);
349
350 #ifdef DEBUG
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);
355 #endif
356
357         if (copyout(&frame, fp, sizeof(frame)) != 0) {
358                 /*
359                  * Process has trashed its stack; give it an illegal
360                  * instruction to halt it in its tracks.
361                  */
362                 sigexit(lp, SIGILL);
363                 /* NOTREACHED */
364         }
365
366         /*
367          * Build context to run handler in.
368          */
369         regs->tf_esp = (int)fp;
370         regs->tf_eip = PS_STRINGS - *(p->p_sysent->sv_szsigcode) + 
371             linux_sznonrtsigcode;
372
373         /*
374          * i386 abi specifies that the direction flag must be cleared
375          * on function entry
376          */
377         regs->tf_eflags &= ~(PSL_T | PSL_VM | PSL_D);
378
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 */
383         /*
384         regs->tf_fs = _udatasel;
385         regs->tf_gs = _udatasel;
386         */
387         regs->tf_ss = _udatasel;
388 }
389
390
391 /*
392  * Send an interrupt to process.
393  *
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
399  * specified pc, psl.
400  */
401
402 static void
403 linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code)
404 {
405         struct proc *p = curproc;
406         struct lwp *lp = curthread->td_lwp;
407         struct trapframe *regs;
408         struct l_sigframe *fp, frame;
409         l_sigset_t lmask;
410         int oonstack, i;
411
412         if (SIGISMEMBER(p->p_sigacts->ps_siginfo, sig)) {
413                 /* Signal handler installed with SA_SIGINFO. */
414                 linux_rt_sendsig(catcher, sig, mask, code);
415                 return;
416         }
417
418         regs = lp->lwp_md.md_regs;
419         oonstack = lp->lwp_sigstk.ss_flags & SS_ONSTACK;
420
421 #ifdef DEBUG
422         if (ldebug(sendsig))
423                 kprintf(ARGS(sendsig, "%p, %d, %p, %lu"),
424                     catcher, sig, (void*)mask, code);
425 #endif
426
427         /*
428          * Allocate space for the signal handler context.
429          */
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;
435         } else
436                 fp = (struct l_sigframe *)regs->tf_esp - 1;
437
438         /*
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.
442          */
443         if ((grow_stack (p, (int)fp) == FALSE) ||
444             !useracc((caddr_t)fp, sizeof (struct l_sigframe), 
445             VM_PROT_WRITE)) {
446                 /*
447                  * Process has trashed its stack; give it an illegal
448                  * instruction to halt it in its tracks.
449                  */
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);
455                 return;
456         }
457
458         /*
459          * Build the argument list for the signal handler.
460          */
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)];
464
465         frame.sf_handler = catcher;
466         frame.sf_sig = sig;
467
468         bsd_to_linux_sigset(mask, &lmask);
469
470         /*
471          * Build the signal context to be used by sigreturn.
472          */
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);
492
493         bzero(&frame.sf_fpstate, sizeof(struct l_fpstate));
494
495         for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
496                 frame.sf_extramask[i] = lmask.__bits[i+1];
497
498         if (copyout(&frame, fp, sizeof(frame)) != 0) {
499                 /*
500                  * Process has trashed its stack; give it an illegal
501                  * instruction to halt it in its tracks.
502                  */
503                 sigexit(lp, SIGILL);
504                 /* NOTREACHED */
505         }
506
507         /*
508          * Build context to run handler in.
509          */
510         regs->tf_esp = (int)fp;
511         regs->tf_eip = PS_STRINGS - *(p->p_sysent->sv_szsigcode);
512
513         /*
514          * i386 abi specifies that the direction flag must be cleared
515          * on function entry
516          */
517         regs->tf_eflags &= ~(PSL_T | PSL_VM | PSL_D);
518
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 */
523         /*
524         regs->tf_fs = _udatasel;
525         regs->tf_gs = _udatasel;
526         */
527         regs->tf_ss = _udatasel;
528 }
529
530 /*
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
538  * a machine fault.
539  */
540 int
541 sys_linux_sigreturn(struct linux_sigreturn_args *args)
542 {
543         struct lwp *lp = curthread->td_lwp;
544         struct l_sigframe frame;
545         struct trapframe *regs;
546         l_sigset_t lmask;
547         int eflags, i;
548
549         regs = lp->lwp_md.md_regs;
550
551 #ifdef DEBUG
552         if (ldebug(sigreturn))
553                 kprintf(ARGS(sigreturn, "%p"), (void *)args->sfp);
554 #endif
555         /*
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.
559          */
560         if (copyin((caddr_t)args->sfp, &frame, sizeof(frame)) != 0)
561                 return (EFAULT);
562
563         /*
564          * Check for security violations.
565          */
566 #define EFLAGS_SECURE(ef, oef)  ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
567         eflags = frame.sf_sc.sc_eflags;
568         /*
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.
577          */
578         if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF)) {
579                 return(EINVAL);
580         }
581
582         /*
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.
586          */
587 #define CS_SECURE(cs)   (ISPL(cs) == SEL_UPL)
588         if (!CS_SECURE(frame.sf_sc.sc_cs)) {
589                 trapsignal(lp, SIGBUS, T_PROTFLT);
590                 return(EINVAL);
591         }
592
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);
599
600         /*
601          * Restore signal context.
602          */
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;
619
620         return (EJUSTRETURN);
621 }
622
623 /*
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
631  * a machine fault.
632  */
633 int
634 sys_linux_rt_sigreturn(struct linux_rt_sigreturn_args *args)
635 {
636         struct lwp *lp = curthread->td_lwp;
637         struct l_ucontext uc;
638         struct l_sigcontext *context;
639         l_stack_t *lss;
640         stack_t ss;
641         struct trapframe *regs;
642         int eflags;
643
644         regs = lp->lwp_md.md_regs;
645
646 #ifdef DEBUG
647         if (ldebug(rt_sigreturn))
648                 kprintf(ARGS(rt_sigreturn, "%p"), (void *)args->ucp);
649 #endif
650         /*
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.
654          */
655         if (copyin((caddr_t)args->ucp, &uc, sizeof(uc)) != 0)
656                 return (EFAULT);
657
658         context = &uc.uc_mcontext;
659
660         /*
661          * Check for security violations.
662          */
663 #define EFLAGS_SECURE(ef, oef)  ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
664         eflags = context->sc_eflags;
665         /*
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.
674          */
675         if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF)) {
676                 return(EINVAL);
677         }
678
679         /*
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.
683          */
684 #define CS_SECURE(cs)   (ISPL(cs) == SEL_UPL)
685         if (!CS_SECURE(context->sc_cs)) {
686                 trapsignal(lp, SIGBUS, T_PROTFLT);
687                 return(EINVAL);
688         }
689
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);
693
694         /*
695          * Restore signal context
696          */
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;
713
714         /*
715          * call sigaltstack & ignore results..
716          */
717         lss = &uc.uc_stack;
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);
721
722 #ifdef DEBUG
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);
726 #endif
727         kern_sigaltstack(&ss, NULL);
728
729         return (EJUSTRETURN);
730 }
731
732 /*
733  * Prep arguments.
734  *
735  * MUST BE MPSAFE
736  */
737 static void
738 linux_prepsyscall(struct trapframe *tf, int *args, u_int *code, caddr_t *params)
739 {
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 */
747 }
748
749 /*
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.
754  */
755 static int      exec_linux_imgact_try (struct image_params *iparams);
756
757 static int
758 exec_linux_imgact_try(struct image_params *imgp)
759 {
760     const char *head = (const char *)imgp->image_header;
761     int error = -1;
762
763     /*
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.
767      */
768     if (((const short *)head)[0] == SHELLMAGIC) {
769             /*
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.
773              */
774             if ((error = exec_shell_imgact(imgp)) == 0) {
775                     linux_translate_path(imgp->interpreter_name,
776                         MAXSHELLCMDLEN);
777             }
778     }
779     return(error);
780 }
781
782 struct sysentvec linux_sysvec = {
783         LINUX_SYS_MAXSYSCALL,
784         linux_sysent,
785         0xff,
786         LINUX_SIGTBLSZ,
787         bsd_to_linux_signal,
788         ELAST + 1, 
789         bsd_to_linux_errno,
790         translate_traps,
791         linux_fixup,
792         linux_sendsig,
793         linux_sigcode,  
794         &linux_szsigcode,
795         linux_prepsyscall,
796         "Linux a.out",
797         NULL,
798         exec_linux_imgact_try,
799         LINUX_MINSIGSTKSZ
800 };
801
802 struct sysentvec elf_linux_sysvec = {
803         LINUX_SYS_MAXSYSCALL,
804         linux_sysent,
805         0xff,
806         LINUX_SIGTBLSZ,
807         bsd_to_linux_signal,
808         ELAST + 1,
809         bsd_to_linux_errno,
810         translate_traps,
811         elf_linux_fixup,
812         linux_sendsig,
813         linux_sigcode,
814         &linux_szsigcode,
815         linux_prepsyscall,
816         "Linux ELF",
817         elf_coredump,
818         exec_linux_imgact_try,
819         LINUX_MINSIGSTKSZ
820 };
821
822 static int      linux_match_abi_note(const Elf_Note *abi_note);
823 static int      linux_match_suse_note(const Elf_Note *abi_note);
824
825 static Elf32_Brandinfo linux_brand = {
826                                         ELFOSABI_LINUX,
827                                         "Linux",
828                                         linux_match_abi_note,
829                                         "/compat/linux",
830                                         "/lib/ld-linux.so.1",
831                                         &elf_linux_sysvec
832                                  };
833
834 static Elf32_Brandinfo linux_glibc2brand = {
835                                         ELFOSABI_LINUX,
836                                         "Linux",
837                                         linux_match_abi_note,
838                                         "/compat/linux",
839                                         "/lib/ld-linux.so.2",
840                                         &elf_linux_sysvec
841                                  };
842
843 static Elf32_Brandinfo linux_suse_brand = {
844                                         ELFOSABI_LINUX,
845                                         "Linux",
846                                         linux_match_suse_note,
847                                         "/compat/linux",
848                                         "/lib/ld-linux.so.2",
849                                         &elf_linux_sysvec
850                                  };
851
852 Elf32_Brandinfo *linux_brandlist[] = {
853                                         &linux_brand,
854                                         &linux_glibc2brand,
855                                         &linux_suse_brand,
856                                         NULL
857                                 };
858
859 static int
860 linux_match_abi_note(const Elf_Note *abi_note)
861 {
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);
866
867         if (abi_note->n_namesz != sizeof("GNU"))
868                 return(FALSE);
869         if (memcmp(abi_name, "GNU", sizeof("GNU")))
870                 return(FALSE);
871         if (abi_note->n_descsz < sizeof(uint32_t))
872                 return(FALSE);
873
874         if (*descr != 0)
875                 return(FALSE);
876         return(TRUE);
877 }
878
879 static int
880 linux_match_suse_note(const Elf_Note *abi_note)
881 {
882         const char *abi_name = (const char *)
883             ((const uint8_t *)abi_note + sizeof(*abi_note));
884
885         if (abi_note->n_namesz != sizeof("SuSE"))
886                 return(FALSE);
887         if (memcmp(abi_name, "SuSE", sizeof("SuSE")))
888                 return(FALSE);
889
890         return(TRUE);
891 }
892
893 static int
894 linux_elf_modevent(module_t mod, int type, void *data)
895 {
896         Elf32_Brandinfo **brandinfo;
897         int error;
898
899         error = 0;
900
901         switch(type) {
902         case MOD_LOAD:
903                 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
904                      ++brandinfo)
905                         if (elf_insert_brand_entry(*brandinfo) < 0)
906                                 error = EINVAL;
907                 if (error == 0) {
908                         if (bootverbose)
909                                 kprintf("Linux ELF exec handler installed\n");
910                 } else
911                         kprintf("cannot insert Linux ELF brand handler\n");
912                 break;
913         case MOD_UNLOAD:
914                 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
915                      ++brandinfo)
916                         if (elf_brand_inuse(*brandinfo))
917                                 error = EBUSY;
918                 if (error == 0) {
919                         for (brandinfo = &linux_brandlist[0];
920                              *brandinfo != NULL; ++brandinfo)
921                                 if (elf_remove_brand_entry(*brandinfo) < 0)
922                                         error = EINVAL;
923                 }
924                 if (error == 0) {
925                         if (bootverbose)
926                                 kprintf("Linux ELF exec handler removed\n");
927                 } else
928                         kprintf("Could not deinstall ELF interpreter entry\n");
929                 break;
930         default:
931                 break;
932         }
933         return error;
934 }
935
936 static moduledata_t linux_elf_mod = {
937         "linuxelf",
938         linux_elf_modevent,
939         0
940 };
941
942 DECLARE_MODULE(linuxelf, linux_elf_mod, SI_SUB_EXEC, SI_ORDER_ANY);