Kill two more stackgap allocations. One is in linux_sysctl(). The other
[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.13 2003/11/14 01:32:45 daver 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 SET_DECLARE(linux_ioctl_handler_set, struct linux_ioctl_handler);
89
90 static int      linux_fixup (register_t **stack_base,
91                                  struct image_params *iparams);
92 static int      elf_linux_fixup (register_t **stack_base,
93                                      struct image_params *iparams);
94 static void     linux_prepsyscall (struct trapframe *tf, int *args,
95                                        u_int *code, caddr_t *params);
96 static void     linux_sendsig (sig_t catcher, int sig, sigset_t *mask,
97                                    u_long code);
98
99 /*
100  * Linux syscalls return negative errno's, we do positive and map them
101  */
102 static int bsd_to_linux_errno[ELAST + 1] = {
103         -0,  -1,  -2,  -3,  -4,  -5,  -6,  -7,  -8,  -9,
104         -10, -35, -12, -13, -14, -15, -16, -17, -18, -19,
105         -20, -21, -22, -23, -24, -25, -26, -27, -28, -29,
106         -30, -31, -32, -33, -34, -11,-115,-114, -88, -89,
107         -90, -91, -92, -93, -94, -95, -96, -97, -98, -99,
108         -100,-101,-102,-103,-104,-105,-106,-107,-108,-109,
109         -110,-111, -40, -36,-112,-113, -39, -11, -87,-122,
110         -116, -66,  -6,  -6,  -6,  -6,  -6, -37, -38,  -9,
111         -6, -6, -43, -42, -75, -6, -84
112 };
113
114 int bsd_to_linux_signal[LINUX_SIGTBLSZ] = {
115         LINUX_SIGHUP, LINUX_SIGINT, LINUX_SIGQUIT, LINUX_SIGILL,
116         LINUX_SIGTRAP, LINUX_SIGABRT, 0, LINUX_SIGFPE,
117         LINUX_SIGKILL, LINUX_SIGBUS, LINUX_SIGSEGV, 0,
118         LINUX_SIGPIPE, LINUX_SIGALRM, LINUX_SIGTERM, LINUX_SIGURG,
119         LINUX_SIGSTOP, LINUX_SIGTSTP, LINUX_SIGCONT, LINUX_SIGCHLD,
120         LINUX_SIGTTIN, LINUX_SIGTTOU, LINUX_SIGIO, LINUX_SIGXCPU,
121         LINUX_SIGXFSZ, LINUX_SIGVTALRM, LINUX_SIGPROF, LINUX_SIGWINCH,
122         0, LINUX_SIGUSR1, LINUX_SIGUSR2
123 };
124
125 int linux_to_bsd_signal[LINUX_SIGTBLSZ] = {
126         SIGHUP, SIGINT, SIGQUIT, SIGILL,
127         SIGTRAP, SIGABRT, SIGBUS, SIGFPE,
128         SIGKILL, SIGUSR1, SIGSEGV, SIGUSR2,
129         SIGPIPE, SIGALRM, SIGTERM, SIGBUS,
130         SIGCHLD, SIGCONT, SIGSTOP, SIGTSTP,
131         SIGTTIN, SIGTTOU, SIGURG, SIGXCPU,
132         SIGXFSZ, SIGVTALRM, SIGPROF, SIGWINCH,
133         SIGIO, SIGURG, 0
134 };
135
136 #define LINUX_T_UNKNOWN  255
137 static int _bsd_to_linux_trapcode[] = {
138         LINUX_T_UNKNOWN,        /* 0 */
139         6,                      /* 1  T_PRIVINFLT */
140         LINUX_T_UNKNOWN,        /* 2 */
141         3,                      /* 3  T_BPTFLT */
142         LINUX_T_UNKNOWN,        /* 4 */
143         LINUX_T_UNKNOWN,        /* 5 */
144         16,                     /* 6  T_ARITHTRAP */
145         254,                    /* 7  T_ASTFLT */
146         LINUX_T_UNKNOWN,        /* 8 */
147         13,                     /* 9  T_PROTFLT */
148         1,                      /* 10 T_TRCTRAP */
149         LINUX_T_UNKNOWN,        /* 11 */
150         14,                     /* 12 T_PAGEFLT */
151         LINUX_T_UNKNOWN,        /* 13 */
152         17,                     /* 14 T_ALIGNFLT */
153         LINUX_T_UNKNOWN,        /* 15 */
154         LINUX_T_UNKNOWN,        /* 16 */
155         LINUX_T_UNKNOWN,        /* 17 */
156         0,                      /* 18 T_DIVIDE */
157         2,                      /* 19 T_NMI */
158         4,                      /* 20 T_OFLOW */
159         5,                      /* 21 T_BOUND */
160         7,                      /* 22 T_DNA */
161         8,                      /* 23 T_DOUBLEFLT */
162         9,                      /* 24 T_FPOPFLT */
163         10,                     /* 25 T_TSSFLT */
164         11,                     /* 26 T_SEGNPFLT */
165         12,                     /* 27 T_STKFLT */
166         18,                     /* 28 T_MCHK */
167         19,                     /* 29 T_XMMFLT */
168         15                      /* 30 T_RESERVED */
169 };
170 #define bsd_to_linux_trapcode(code) \
171     ((code)<sizeof(_bsd_to_linux_trapcode)/sizeof(*_bsd_to_linux_trapcode)? \
172      _bsd_to_linux_trapcode[(code)]: \
173      LINUX_T_UNKNOWN)
174
175 /*
176  * If FreeBSD & Linux have a difference of opinion about what a trap
177  * means, deal with it here.
178  */
179 static int
180 translate_traps(int signal, int trap_code)
181 {
182         if (signal != SIGBUS)
183                 return signal;
184         switch (trap_code) {
185         case T_PROTFLT:
186         case T_TSSFLT:
187         case T_DOUBLEFLT:
188         case T_PAGEFLT:
189                 return SIGSEGV;
190         default:
191                 return signal;
192         }
193 }
194
195 static int
196 linux_fixup(register_t **stack_base, struct image_params *imgp)
197 {
198         register_t *argv, *envp;
199
200         argv = *stack_base;
201         envp = *stack_base + (imgp->args->argc + 1);
202         (*stack_base)--;
203         **stack_base = (intptr_t)(void *)envp;
204         (*stack_base)--;
205         **stack_base = (intptr_t)(void *)argv;
206         (*stack_base)--;
207         **stack_base = imgp->args->argc;
208         return 0;
209 }
210
211 static int
212 elf_linux_fixup(register_t **stack_base, struct image_params *imgp)
213 {
214         Elf32_Auxargs *args = (Elf32_Auxargs *)imgp->auxargs;
215         register_t *pos;
216              
217         pos = *stack_base + (imgp->args->argc + imgp->args->envc + 2);  
218     
219         if (args->trace) {
220                 AUXARGS_ENTRY(pos, AT_DEBUG, 1);
221         }
222         if (args->execfd != -1) {
223                 AUXARGS_ENTRY(pos, AT_EXECFD, args->execfd);
224         }       
225         AUXARGS_ENTRY(pos, AT_PHDR, args->phdr);
226         AUXARGS_ENTRY(pos, AT_PHENT, args->phent);
227         AUXARGS_ENTRY(pos, AT_PHNUM, args->phnum);
228         AUXARGS_ENTRY(pos, AT_PAGESZ, args->pagesz);
229         AUXARGS_ENTRY(pos, AT_FLAGS, args->flags);
230         AUXARGS_ENTRY(pos, AT_ENTRY, args->entry);
231         AUXARGS_ENTRY(pos, AT_BASE, args->base);
232         AUXARGS_ENTRY(pos, AT_UID, imgp->proc->p_ucred->cr_ruid);
233         AUXARGS_ENTRY(pos, AT_EUID, imgp->proc->p_ucred->cr_svuid);
234         AUXARGS_ENTRY(pos, AT_GID, imgp->proc->p_ucred->cr_rgid);
235         AUXARGS_ENTRY(pos, AT_EGID, imgp->proc->p_ucred->cr_svgid);
236         AUXARGS_ENTRY(pos, AT_NULL, 0);
237         
238         free(imgp->auxargs, M_TEMP);      
239         imgp->auxargs = NULL;
240
241         (*stack_base)--;
242         **stack_base = (long)imgp->args->argc;
243         return 0;
244 }
245
246 extern int _ucodesel, _udatasel;
247 extern unsigned long linux_sznonrtsigcode;
248
249 static void
250 linux_rt_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code)
251 {
252         struct proc *p = curproc;
253         struct trapframe *regs;
254         struct l_rt_sigframe *fp, frame;
255         int oonstack;
256
257         regs = p->p_md.md_regs;
258         oonstack = p->p_sigstk.ss_flags & SS_ONSTACK;
259
260 #ifdef DEBUG
261         if (ldebug(rt_sendsig))
262                 printf(ARGS(rt_sendsig, "%p, %d, %p, %lu"),
263                     catcher, sig, (void*)mask, code);
264 #endif
265         /*
266          * Allocate space for the signal handler context.
267          */
268         if ((p->p_flag & P_ALTSTACK) && !oonstack &&
269             SIGISMEMBER(p->p_sigacts->ps_sigonstack, sig)) {
270                 fp = (struct l_rt_sigframe *)(p->p_sigstk.ss_sp +
271                     p->p_sigstk.ss_size - sizeof(struct l_rt_sigframe));
272                 p->p_sigstk.ss_flags |= SS_ONSTACK;
273         } else
274                 fp = (struct l_rt_sigframe *)regs->tf_esp - 1;
275
276         /*
277          * grow() will return FALSE if the fp will not fit inside the stack
278          *      and the stack can not be grown. useracc will return FALSE
279          *      if access is denied.
280          */
281         if ((grow_stack (p, (int)fp) == FALSE) ||
282             !useracc((caddr_t)fp, sizeof (struct l_rt_sigframe), 
283             VM_PROT_WRITE)) {
284                 /*
285                  * Process has trashed its stack; give it an illegal
286                  * instruction to halt it in its tracks.
287                  */
288                 SIGACTION(p, SIGILL) = SIG_DFL;
289                 SIGDELSET(p->p_sigignore, SIGILL);
290                 SIGDELSET(p->p_sigcatch, SIGILL);
291                 SIGDELSET(p->p_sigmask, SIGILL);
292 #ifdef DEBUG
293                 if (ldebug(rt_sendsig))
294                         printf(LMSG("rt_sendsig: bad stack %p, oonstack=%x"),
295                             fp, oonstack);
296 #endif
297                 psignal(p, SIGILL);
298                 return;
299         }
300
301         /*
302          * Build the argument list for the signal handler.
303          */
304         if (p->p_sysent->sv_sigtbl)
305                 if (sig <= p->p_sysent->sv_sigsize)
306                         sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
307
308         frame.sf_handler = catcher;
309         frame.sf_sig = sig;
310         frame.sf_siginfo = &fp->sf_si;
311         frame.sf_ucontext = &fp->sf_sc;
312
313         /* Fill siginfo structure. */
314         frame.sf_si.lsi_signo = sig;
315         frame.sf_si.lsi_code = code;
316         frame.sf_si.lsi_addr = (void *)regs->tf_err;
317
318         /*
319          * Build the signal context to be used by sigreturn.
320          */
321         frame.sf_sc.uc_flags = 0;               /* XXX ??? */
322         frame.sf_sc.uc_link = NULL;             /* XXX ??? */
323
324         frame.sf_sc.uc_stack.ss_sp = p->p_sigstk.ss_sp;
325         frame.sf_sc.uc_stack.ss_size = p->p_sigstk.ss_size;
326         frame.sf_sc.uc_stack.ss_flags = (p->p_flag & P_ALTSTACK)
327             ? ((oonstack) ? LINUX_SS_ONSTACK : 0) : LINUX_SS_DISABLE;
328
329         bsd_to_linux_sigset(mask, &frame.sf_sc.uc_sigmask);
330
331         frame.sf_sc.uc_mcontext.sc_mask   = frame.sf_sc.uc_sigmask.__bits[0];
332         frame.sf_sc.uc_mcontext.sc_gs     = rgs();
333         frame.sf_sc.uc_mcontext.sc_fs     = regs->tf_fs;
334         frame.sf_sc.uc_mcontext.sc_es     = regs->tf_es;
335         frame.sf_sc.uc_mcontext.sc_ds     = regs->tf_ds;
336         frame.sf_sc.uc_mcontext.sc_edi    = regs->tf_edi;
337         frame.sf_sc.uc_mcontext.sc_esi    = regs->tf_esi;
338         frame.sf_sc.uc_mcontext.sc_ebp    = regs->tf_ebp;
339         frame.sf_sc.uc_mcontext.sc_ebx    = regs->tf_ebx;
340         frame.sf_sc.uc_mcontext.sc_edx    = regs->tf_edx;
341         frame.sf_sc.uc_mcontext.sc_ecx    = regs->tf_ecx;
342         frame.sf_sc.uc_mcontext.sc_eax    = regs->tf_eax;
343         frame.sf_sc.uc_mcontext.sc_eip    = regs->tf_eip;
344         frame.sf_sc.uc_mcontext.sc_cs     = regs->tf_cs;
345         frame.sf_sc.uc_mcontext.sc_eflags = regs->tf_eflags;
346         frame.sf_sc.uc_mcontext.sc_esp_at_signal = regs->tf_esp;
347         frame.sf_sc.uc_mcontext.sc_ss     = regs->tf_ss;
348         frame.sf_sc.uc_mcontext.sc_err    = regs->tf_err;
349         frame.sf_sc.uc_mcontext.sc_trapno = bsd_to_linux_trapcode(code);
350
351 #ifdef DEBUG
352         if (ldebug(rt_sendsig))
353                 printf(LMSG("rt_sendsig flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
354                     frame.sf_sc.uc_stack.ss_flags, p->p_sigstk.ss_sp,
355                     p->p_sigstk.ss_size, frame.sf_sc.uc_mcontext.sc_mask);
356 #endif
357
358         if (copyout(&frame, fp, sizeof(frame)) != 0) {
359                 /*
360                  * Process has trashed its stack; give it an illegal
361                  * instruction to halt it in its tracks.
362                  */
363                 sigexit(p, SIGILL);
364                 /* NOTREACHED */
365         }
366
367         /*
368          * Build context to run handler in.
369          */
370         regs->tf_esp = (int)fp;
371         regs->tf_eip = PS_STRINGS - *(p->p_sysent->sv_szsigcode) + 
372             linux_sznonrtsigcode;
373         regs->tf_eflags &= ~(PSL_T | PSL_VM);
374         regs->tf_cs = _ucodesel;
375         regs->tf_ds = _udatasel;
376         regs->tf_es = _udatasel;
377         regs->tf_fs = _udatasel;
378         regs->tf_ss = _udatasel;
379 }
380
381
382 /*
383  * Send an interrupt to process.
384  *
385  * Stack is set up to allow sigcode stored
386  * in u. to call routine, followed by kcall
387  * to sigreturn routine below.  After sigreturn
388  * resets the signal mask, the stack, and the
389  * frame pointer, it returns to the user
390  * specified pc, psl.
391  */
392
393 static void
394 linux_sendsig(sig_t catcher, int sig, sigset_t *mask, u_long code)
395 {
396         struct proc *p = curproc;
397         struct trapframe *regs;
398         struct l_sigframe *fp, frame;
399         l_sigset_t lmask;
400         int oonstack, i;
401
402         if (SIGISMEMBER(p->p_sigacts->ps_siginfo, sig)) {
403                 /* Signal handler installed with SA_SIGINFO. */
404                 linux_rt_sendsig(catcher, sig, mask, code);
405                 return;
406         }
407
408         regs = p->p_md.md_regs;
409         oonstack = p->p_sigstk.ss_flags & SS_ONSTACK;
410
411 #ifdef DEBUG
412         if (ldebug(sendsig))
413                 printf(ARGS(sendsig, "%p, %d, %p, %lu"),
414                     catcher, sig, (void*)mask, code);
415 #endif
416
417         /*
418          * Allocate space for the signal handler context.
419          */
420         if ((p->p_flag & P_ALTSTACK) && !oonstack &&
421             SIGISMEMBER(p->p_sigacts->ps_sigonstack, sig)) {
422                 fp = (struct l_sigframe *)(p->p_sigstk.ss_sp +
423                     p->p_sigstk.ss_size - sizeof(struct l_sigframe));
424                 p->p_sigstk.ss_flags |= SS_ONSTACK;
425         } else
426                 fp = (struct l_sigframe *)regs->tf_esp - 1;
427
428         /*
429          * grow() will return FALSE if the fp will not fit inside the stack
430          *      and the stack can not be grown. useracc will return FALSE
431          *      if access is denied.
432          */
433         if ((grow_stack (p, (int)fp) == FALSE) ||
434             !useracc((caddr_t)fp, sizeof (struct l_sigframe), 
435             VM_PROT_WRITE)) {
436                 /*
437                  * Process has trashed its stack; give it an illegal
438                  * instruction to halt it in its tracks.
439                  */
440                 SIGACTION(p, SIGILL) = SIG_DFL;
441                 SIGDELSET(p->p_sigignore, SIGILL);
442                 SIGDELSET(p->p_sigcatch, SIGILL);
443                 SIGDELSET(p->p_sigmask, SIGILL);
444                 psignal(p, SIGILL);
445                 return;
446         }
447
448         /*
449          * Build the argument list for the signal handler.
450          */
451         if (p->p_sysent->sv_sigtbl)
452                 if (sig <= p->p_sysent->sv_sigsize)
453                         sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
454
455         frame.sf_handler = catcher;
456         frame.sf_sig = sig;
457
458         bsd_to_linux_sigset(mask, &lmask);
459
460         /*
461          * Build the signal context to be used by sigreturn.
462          */
463         frame.sf_sc.sc_mask   = lmask.__bits[0];
464         frame.sf_sc.sc_gs     = rgs();
465         frame.sf_sc.sc_fs     = regs->tf_fs;
466         frame.sf_sc.sc_es     = regs->tf_es;
467         frame.sf_sc.sc_ds     = regs->tf_ds;
468         frame.sf_sc.sc_edi    = regs->tf_edi;
469         frame.sf_sc.sc_esi    = regs->tf_esi;
470         frame.sf_sc.sc_ebp    = regs->tf_ebp;
471         frame.sf_sc.sc_ebx    = regs->tf_ebx;
472         frame.sf_sc.sc_edx    = regs->tf_edx;
473         frame.sf_sc.sc_ecx    = regs->tf_ecx;
474         frame.sf_sc.sc_eax    = regs->tf_eax;
475         frame.sf_sc.sc_eip    = regs->tf_eip;
476         frame.sf_sc.sc_cs     = regs->tf_cs;
477         frame.sf_sc.sc_eflags = regs->tf_eflags;
478         frame.sf_sc.sc_esp_at_signal = regs->tf_esp;
479         frame.sf_sc.sc_ss     = regs->tf_ss;
480         frame.sf_sc.sc_err    = regs->tf_err;
481         frame.sf_sc.sc_trapno = bsd_to_linux_trapcode(code);
482
483         bzero(&frame.sf_fpstate, sizeof(struct l_fpstate));
484
485         for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
486                 frame.sf_extramask[i] = lmask.__bits[i+1];
487
488         if (copyout(&frame, fp, sizeof(frame)) != 0) {
489                 /*
490                  * Process has trashed its stack; give it an illegal
491                  * instruction to halt it in its tracks.
492                  */
493                 sigexit(p, SIGILL);
494                 /* NOTREACHED */
495         }
496
497         /*
498          * Build context to run handler in.
499          */
500         regs->tf_esp = (int)fp;
501         regs->tf_eip = PS_STRINGS - *(p->p_sysent->sv_szsigcode);
502         regs->tf_eflags &= ~(PSL_T | PSL_VM);
503         regs->tf_cs = _ucodesel;
504         regs->tf_ds = _udatasel;
505         regs->tf_es = _udatasel;
506         regs->tf_fs = _udatasel;
507         regs->tf_ss = _udatasel;
508 }
509
510 /*
511  * System call to cleanup state after a signal
512  * has been taken.  Reset signal mask and
513  * stack state from context left by sendsig (above).
514  * Return to previous pc and psl as specified by
515  * context left by sendsig. Check carefully to
516  * make sure that the user has not modified the
517  * psl to gain improper privileges or to cause
518  * a machine fault.
519  */
520 int
521 linux_sigreturn(struct linux_sigreturn_args *args)
522 {
523         struct proc *p = curproc;
524         struct l_sigframe frame;
525         struct trapframe *regs;
526         l_sigset_t lmask;
527         int eflags, i;
528
529         regs = p->p_md.md_regs;
530
531 #ifdef DEBUG
532         if (ldebug(sigreturn))
533                 printf(ARGS(sigreturn, "%p"), (void *)args->sfp);
534 #endif
535         /*
536          * The trampoline code hands us the sigframe.
537          * It is unsafe to keep track of it ourselves, in the event that a
538          * program jumps out of a signal handler.
539          */
540         if (copyin((caddr_t)args->sfp, &frame, sizeof(frame)) != 0)
541                 return (EFAULT);
542
543         /*
544          * Check for security violations.
545          */
546 #define EFLAGS_SECURE(ef, oef)  ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
547         eflags = frame.sf_sc.sc_eflags;
548         /*
549          * XXX do allow users to change the privileged flag PSL_RF.  The
550          * cpu sets PSL_RF in tf_eflags for faults.  Debuggers should
551          * sometimes set it there too.  tf_eflags is kept in the signal
552          * context during signal handling and there is no other place
553          * to remember it, so the PSL_RF bit may be corrupted by the
554          * signal handler without us knowing.  Corruption of the PSL_RF
555          * bit at worst causes one more or one less debugger trap, so
556          * allowing it is fairly harmless.
557          */
558         if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF)) {
559                 return(EINVAL);
560         }
561
562         /*
563          * Don't allow users to load a valid privileged %cs.  Let the
564          * hardware check for invalid selectors, excess privilege in
565          * other selectors, invalid %eip's and invalid %esp's.
566          */
567 #define CS_SECURE(cs)   (ISPL(cs) == SEL_UPL)
568         if (!CS_SECURE(frame.sf_sc.sc_cs)) {
569                 trapsignal(p, SIGBUS, T_PROTFLT);
570                 return(EINVAL);
571         }
572
573         p->p_sigstk.ss_flags &= ~SS_ONSTACK;
574         lmask.__bits[0] = frame.sf_sc.sc_mask;
575         for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
576                 lmask.__bits[i+1] = frame.sf_extramask[i];
577         linux_to_bsd_sigset(&lmask, &p->p_sigmask);
578         SIG_CANTMASK(p->p_sigmask);
579
580         /*
581          * Restore signal context.
582          */
583         /* %gs was restored by the trampoline. */
584         regs->tf_fs     = frame.sf_sc.sc_fs;
585         regs->tf_es     = frame.sf_sc.sc_es;
586         regs->tf_ds     = frame.sf_sc.sc_ds;
587         regs->tf_edi    = frame.sf_sc.sc_edi;
588         regs->tf_esi    = frame.sf_sc.sc_esi;
589         regs->tf_ebp    = frame.sf_sc.sc_ebp;
590         regs->tf_ebx    = frame.sf_sc.sc_ebx;
591         regs->tf_edx    = frame.sf_sc.sc_edx;
592         regs->tf_ecx    = frame.sf_sc.sc_ecx;
593         regs->tf_eax    = frame.sf_sc.sc_eax;
594         regs->tf_eip    = frame.sf_sc.sc_eip;
595         regs->tf_cs     = frame.sf_sc.sc_cs;
596         regs->tf_eflags = eflags;
597         regs->tf_esp    = frame.sf_sc.sc_esp_at_signal;
598         regs->tf_ss     = frame.sf_sc.sc_ss;
599
600         return (EJUSTRETURN);
601 }
602
603 /*
604  * System call to cleanup state after a signal
605  * has been taken.  Reset signal mask and
606  * stack state from context left by rt_sendsig (above).
607  * Return to previous pc and psl as specified by
608  * context left by sendsig. Check carefully to
609  * make sure that the user has not modified the
610  * psl to gain improper privileges or to cause
611  * a machine fault.
612  */
613 int
614 linux_rt_sigreturn(struct linux_rt_sigreturn_args *args)
615 {
616         struct proc *p = curproc;
617         struct sigaltstack_args sasargs;
618         struct l_ucontext uc;
619         struct l_sigcontext *context;
620         l_stack_t *lss;
621         stack_t ss;
622         struct trapframe *regs;
623         int eflags;
624
625         regs = p->p_md.md_regs;
626
627 #ifdef DEBUG
628         if (ldebug(rt_sigreturn))
629                 printf(ARGS(rt_sigreturn, "%p"), (void *)args->ucp);
630 #endif
631         /*
632          * The trampoline code hands us the ucontext.
633          * It is unsafe to keep track of it ourselves, in the event that a
634          * program jumps out of a signal handler.
635          */
636         if (copyin((caddr_t)args->ucp, &uc, sizeof(uc)) != 0)
637                 return (EFAULT);
638
639         context = &uc.uc_mcontext;
640
641         /*
642          * Check for security violations.
643          */
644 #define EFLAGS_SECURE(ef, oef)  ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
645         eflags = context->sc_eflags;
646         /*
647          * XXX do allow users to change the privileged flag PSL_RF.  The
648          * cpu sets PSL_RF in tf_eflags for faults.  Debuggers should
649          * sometimes set it there too.  tf_eflags is kept in the signal
650          * context during signal handling and there is no other place
651          * to remember it, so the PSL_RF bit may be corrupted by the
652          * signal handler without us knowing.  Corruption of the PSL_RF
653          * bit at worst causes one more or one less debugger trap, so
654          * allowing it is fairly harmless.
655          */
656         if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_eflags & ~PSL_RF)) {
657                 return(EINVAL);
658         }
659
660         /*
661          * Don't allow users to load a valid privileged %cs.  Let the
662          * hardware check for invalid selectors, excess privilege in
663          * other selectors, invalid %eip's and invalid %esp's.
664          */
665 #define CS_SECURE(cs)   (ISPL(cs) == SEL_UPL)
666         if (!CS_SECURE(context->sc_cs)) {
667                 trapsignal(p, SIGBUS, T_PROTFLT);
668                 return(EINVAL);
669         }
670
671         p->p_sigstk.ss_flags &= ~SS_ONSTACK;
672         linux_to_bsd_sigset(&uc.uc_sigmask, &p->p_sigmask);
673         SIG_CANTMASK(p->p_sigmask);
674
675         /*
676          * Restore signal context
677          */
678         /* %gs was restored by the trampoline. */
679         regs->tf_fs     = context->sc_fs;
680         regs->tf_es     = context->sc_es;
681         regs->tf_ds     = context->sc_ds;
682         regs->tf_edi    = context->sc_edi;
683         regs->tf_esi    = context->sc_esi;
684         regs->tf_ebp    = context->sc_ebp;
685         regs->tf_ebx    = context->sc_ebx;
686         regs->tf_edx    = context->sc_edx;
687         regs->tf_ecx    = context->sc_ecx;
688         regs->tf_eax    = context->sc_eax;
689         regs->tf_eip    = context->sc_eip;
690         regs->tf_cs     = context->sc_cs;
691         regs->tf_eflags = eflags;
692         regs->tf_esp    = context->sc_esp_at_signal;
693         regs->tf_ss     = context->sc_ss;
694
695         /*
696          * call sigaltstack & ignore results..
697          */
698         lss = &uc.uc_stack;
699         ss.ss_sp = lss->ss_sp;
700         ss.ss_size = lss->ss_size;
701         ss.ss_flags = linux_to_bsd_sigaltstack(lss->ss_flags);
702
703 #ifdef DEBUG
704         if (ldebug(rt_sigreturn))
705                 printf(LMSG("rt_sigret flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
706                     ss.ss_flags, ss.ss_sp, ss.ss_size, context->sc_mask);
707 #endif
708         kern_sigaltstack(&ss, NULL);
709
710         return (EJUSTRETURN);
711 }
712
713 static void
714 linux_prepsyscall(struct trapframe *tf, int *args, u_int *code, caddr_t *params)
715 {
716         args[0] = tf->tf_ebx;
717         args[1] = tf->tf_ecx;
718         args[2] = tf->tf_edx;
719         args[3] = tf->tf_esi;
720         args[4] = tf->tf_edi;
721         *params = NULL;         /* no copyin */
722 }
723
724 /*
725  * If a linux binary is exec'ing something, try this image activator 
726  * first.  We override standard shell script execution in order to
727  * be able to modify the interpreter path.  We only do this if a linux
728  * binary is doing the exec, so we do not create an EXEC module for it.
729  */
730 static int      exec_linux_imgact_try (struct image_params *iparams);
731
732 static int
733 exec_linux_imgact_try(imgp)
734     struct image_params *imgp;
735 {
736     const char *head = (const char *)imgp->image_header;
737     int error = -1;
738
739     /*
740      * The interpreter for shell scripts run from a linux binary needs
741      * to be located in /compat/linux if possible in order to recursively
742      * maintain linux path emulation.
743      */
744     if (((const short *)head)[0] == SHELLMAGIC) {
745             /*
746              * Run our normal shell image activator.  If it succeeds attempt
747              * to use the alternate path for the interpreter.  If an alternate
748              * path is found, use our stringspace to store it.
749              */
750             if ((error = exec_shell_imgact(imgp)) == 0) {
751                     linux_translate_path(imgp->interpreter_name,
752                         MAXSHELLCMDLEN);
753             }
754     }
755     return(error);
756 }
757
758 struct sysentvec linux_sysvec = {
759         LINUX_SYS_MAXSYSCALL,
760         linux_sysent,
761         0xff,
762         LINUX_SIGTBLSZ,
763         bsd_to_linux_signal,
764         ELAST + 1, 
765         bsd_to_linux_errno,
766         translate_traps,
767         linux_fixup,
768         linux_sendsig,
769         linux_sigcode,  
770         &linux_szsigcode,
771         linux_prepsyscall,
772         "Linux a.out",
773         aout_coredump,
774         exec_linux_imgact_try,
775         LINUX_MINSIGSTKSZ
776 };
777
778 struct sysentvec elf_linux_sysvec = {
779         LINUX_SYS_MAXSYSCALL,
780         linux_sysent,
781         0xff,
782         LINUX_SIGTBLSZ,
783         bsd_to_linux_signal,
784         ELAST + 1,
785         bsd_to_linux_errno,
786         translate_traps,
787         elf_linux_fixup,
788         linux_sendsig,
789         linux_sigcode,
790         &linux_szsigcode,
791         linux_prepsyscall,
792         "Linux ELF",
793         elf_coredump,
794         exec_linux_imgact_try,
795         LINUX_MINSIGSTKSZ
796 };
797
798 static Elf32_Brandinfo linux_brand = {
799                                         ELFOSABI_LINUX,
800                                         "Linux",
801                                         "/compat/linux",
802                                         "/lib/ld-linux.so.1",
803                                         &elf_linux_sysvec
804                                  };
805
806 static Elf32_Brandinfo linux_glibc2brand = {
807                                         ELFOSABI_LINUX,
808                                         "Linux",
809                                         "/compat/linux",
810                                         "/lib/ld-linux.so.2",
811                                         &elf_linux_sysvec
812                                  };
813
814 Elf32_Brandinfo *linux_brandlist[] = {
815                                         &linux_brand,
816                                         &linux_glibc2brand,
817                                         NULL
818                                 };
819
820 static int
821 linux_elf_modevent(module_t mod, int type, void *data)
822 {
823         Elf32_Brandinfo **brandinfo;
824         int error;
825         struct linux_ioctl_handler **lihp;
826
827         error = 0;
828
829         switch(type) {
830         case MOD_LOAD:
831                 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
832                      ++brandinfo)
833                         if (elf_insert_brand_entry(*brandinfo) < 0)
834                                 error = EINVAL;
835                 if (error == 0) {
836                         SET_FOREACH(lihp, linux_ioctl_handler_set)
837                                 linux_ioctl_register_handler(*lihp);
838                         if (bootverbose)
839                                 printf("Linux ELF exec handler installed\n");
840                 } else
841                         printf("cannot insert Linux ELF brand handler\n");
842                 break;
843         case MOD_UNLOAD:
844                 for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
845                      ++brandinfo)
846                         if (elf_brand_inuse(*brandinfo))
847                                 error = EBUSY;
848                 if (error == 0) {
849                         for (brandinfo = &linux_brandlist[0];
850                              *brandinfo != NULL; ++brandinfo)
851                                 if (elf_remove_brand_entry(*brandinfo) < 0)
852                                         error = EINVAL;
853                 }
854                 if (error == 0) {
855                         SET_FOREACH(lihp, linux_ioctl_handler_set)
856                                 linux_ioctl_unregister_handler(*lihp);
857                         if (bootverbose)
858                                 printf("Linux ELF exec handler removed\n");
859                 } else
860                         printf("Could not deinstall ELF interpreter entry\n");
861                 break;
862         default:
863                 break;
864         }
865         return error;
866 }
867
868 static moduledata_t linux_elf_mod = {
869         "linuxelf",
870         linux_elf_modevent,
871         0
872 };
873
874 DECLARE_MODULE(linuxelf, linux_elf_mod, SI_SUB_EXEC, SI_ORDER_ANY);