xref: /freebsd/sys/amd64/linux32/linux32_sysvec.c (revision bb15ca603fa442c72dde3f3cb8b46db6970e3950)
1 /*-
2  * Copyright (c) 2004 Tim J. Robbins
3  * Copyright (c) 2003 Peter Wemm
4  * Copyright (c) 2002 Doug Rabson
5  * Copyright (c) 1998-1999 Andrew Gallatin
6  * Copyright (c) 1994-1996 S�ren Schmidt
7  * All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer
14  *    in this position and unchanged.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. The name of the author may not be used to endorse or promote products
19  *    derived from this software without specific prior written permission
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32 
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD$");
35 #include "opt_compat.h"
36 
37 #ifndef COMPAT_FREEBSD32
38 #error "Unable to compile Linux-emulator due to missing COMPAT_FREEBSD32 option!"
39 #endif
40 
41 #define	__ELF_WORD_SIZE	32
42 
43 #include <sys/param.h>
44 #include <sys/systm.h>
45 #include <sys/exec.h>
46 #include <sys/fcntl.h>
47 #include <sys/imgact.h>
48 #include <sys/imgact_elf.h>
49 #include <sys/kernel.h>
50 #include <sys/lock.h>
51 #include <sys/malloc.h>
52 #include <sys/module.h>
53 #include <sys/mutex.h>
54 #include <sys/proc.h>
55 #include <sys/resourcevar.h>
56 #include <sys/signalvar.h>
57 #include <sys/sysctl.h>
58 #include <sys/syscallsubr.h>
59 #include <sys/sysent.h>
60 #include <sys/sysproto.h>
61 #include <sys/vnode.h>
62 #include <sys/eventhandler.h>
63 
64 #include <vm/vm.h>
65 #include <vm/pmap.h>
66 #include <vm/vm_extern.h>
67 #include <vm/vm_map.h>
68 #include <vm/vm_object.h>
69 #include <vm/vm_page.h>
70 #include <vm/vm_param.h>
71 
72 #include <machine/cpu.h>
73 #include <machine/md_var.h>
74 #include <machine/pcb.h>
75 #include <machine/specialreg.h>
76 
77 #include <amd64/linux32/linux.h>
78 #include <amd64/linux32/linux32_proto.h>
79 #include <compat/linux/linux_emul.h>
80 #include <compat/linux/linux_futex.h>
81 #include <compat/linux/linux_mib.h>
82 #include <compat/linux/linux_misc.h>
83 #include <compat/linux/linux_signal.h>
84 #include <compat/linux/linux_util.h>
85 
86 MODULE_VERSION(linux, 1);
87 
88 MALLOC_DEFINE(M_LINUX, "linux", "Linux mode structures");
89 
90 #define	AUXARGS_ENTRY_32(pos, id, val)	\
91 	do {				\
92 		suword32(pos++, id);	\
93 		suword32(pos++, val);	\
94 	} while (0)
95 
96 #if BYTE_ORDER == LITTLE_ENDIAN
97 #define SHELLMAGIC      0x2123 /* #! */
98 #else
99 #define SHELLMAGIC      0x2321
100 #endif
101 
102 /*
103  * Allow the sendsig functions to use the ldebug() facility
104  * even though they are not syscalls themselves. Map them
105  * to syscall 0. This is slightly less bogus than using
106  * ldebug(sigreturn).
107  */
108 #define	LINUX_SYS_linux_rt_sendsig	0
109 #define	LINUX_SYS_linux_sendsig		0
110 
111 const char *linux_platform = "i686";
112 static int linux_szplatform;
113 extern char linux_sigcode[];
114 extern int linux_szsigcode;
115 
116 extern struct sysent linux_sysent[LINUX_SYS_MAXSYSCALL];
117 
118 SET_DECLARE(linux_ioctl_handler_set, struct linux_ioctl_handler);
119 SET_DECLARE(linux_device_handler_set, struct linux_device_handler);
120 
121 static int	elf_linux_fixup(register_t **stack_base,
122 		    struct image_params *iparams);
123 static register_t *linux_copyout_strings(struct image_params *imgp);
124 static void     linux_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask);
125 static void	exec_linux_setregs(struct thread *td,
126 				   struct image_params *imgp, u_long stack);
127 static void	linux32_fixlimit(struct rlimit *rl, int which);
128 static boolean_t linux32_trans_osrel(const Elf_Note *note, int32_t *osrel);
129 
130 static eventhandler_tag linux_exit_tag;
131 static eventhandler_tag linux_exec_tag;
132 
133 /*
134  * Linux syscalls return negative errno's, we do positive and map them
135  * Reference:
136  *   FreeBSD: src/sys/sys/errno.h
137  *   Linux:   linux-2.6.17.8/include/asm-generic/errno-base.h
138  *            linux-2.6.17.8/include/asm-generic/errno.h
139  */
140 static int bsd_to_linux_errno[ELAST + 1] = {
141 	-0,  -1,  -2,  -3,  -4,  -5,  -6,  -7,  -8,  -9,
142 	-10, -35, -12, -13, -14, -15, -16, -17, -18, -19,
143 	-20, -21, -22, -23, -24, -25, -26, -27, -28, -29,
144 	-30, -31, -32, -33, -34, -11,-115,-114, -88, -89,
145 	-90, -91, -92, -93, -94, -95, -96, -97, -98, -99,
146 	-100,-101,-102,-103,-104,-105,-106,-107,-108,-109,
147 	-110,-111, -40, -36,-112,-113, -39, -11, -87,-122,
148 	-116, -66,  -6,  -6,  -6,  -6,  -6, -37, -38,  -9,
149 	  -6,  -6, -43, -42, -75,-125, -84, -95, -16, -74,
150 	 -72, -67, -71
151 };
152 
153 int bsd_to_linux_signal[LINUX_SIGTBLSZ] = {
154 	LINUX_SIGHUP, LINUX_SIGINT, LINUX_SIGQUIT, LINUX_SIGILL,
155 	LINUX_SIGTRAP, LINUX_SIGABRT, 0, LINUX_SIGFPE,
156 	LINUX_SIGKILL, LINUX_SIGBUS, LINUX_SIGSEGV, LINUX_SIGSYS,
157 	LINUX_SIGPIPE, LINUX_SIGALRM, LINUX_SIGTERM, LINUX_SIGURG,
158 	LINUX_SIGSTOP, LINUX_SIGTSTP, LINUX_SIGCONT, LINUX_SIGCHLD,
159 	LINUX_SIGTTIN, LINUX_SIGTTOU, LINUX_SIGIO, LINUX_SIGXCPU,
160 	LINUX_SIGXFSZ, LINUX_SIGVTALRM, LINUX_SIGPROF, LINUX_SIGWINCH,
161 	0, LINUX_SIGUSR1, LINUX_SIGUSR2
162 };
163 
164 int linux_to_bsd_signal[LINUX_SIGTBLSZ] = {
165 	SIGHUP, SIGINT, SIGQUIT, SIGILL,
166 	SIGTRAP, SIGABRT, SIGBUS, SIGFPE,
167 	SIGKILL, SIGUSR1, SIGSEGV, SIGUSR2,
168 	SIGPIPE, SIGALRM, SIGTERM, SIGBUS,
169 	SIGCHLD, SIGCONT, SIGSTOP, SIGTSTP,
170 	SIGTTIN, SIGTTOU, SIGURG, SIGXCPU,
171 	SIGXFSZ, SIGVTALRM, SIGPROF, SIGWINCH,
172 	SIGIO, SIGURG, SIGSYS
173 };
174 
175 #define LINUX_T_UNKNOWN  255
176 static int _bsd_to_linux_trapcode[] = {
177 	LINUX_T_UNKNOWN,	/* 0 */
178 	6,			/* 1  T_PRIVINFLT */
179 	LINUX_T_UNKNOWN,	/* 2 */
180 	3,			/* 3  T_BPTFLT */
181 	LINUX_T_UNKNOWN,	/* 4 */
182 	LINUX_T_UNKNOWN,	/* 5 */
183 	16,			/* 6  T_ARITHTRAP */
184 	254,			/* 7  T_ASTFLT */
185 	LINUX_T_UNKNOWN,	/* 8 */
186 	13,			/* 9  T_PROTFLT */
187 	1,			/* 10 T_TRCTRAP */
188 	LINUX_T_UNKNOWN,	/* 11 */
189 	14,			/* 12 T_PAGEFLT */
190 	LINUX_T_UNKNOWN,	/* 13 */
191 	17,			/* 14 T_ALIGNFLT */
192 	LINUX_T_UNKNOWN,	/* 15 */
193 	LINUX_T_UNKNOWN,	/* 16 */
194 	LINUX_T_UNKNOWN,	/* 17 */
195 	0,			/* 18 T_DIVIDE */
196 	2,			/* 19 T_NMI */
197 	4,			/* 20 T_OFLOW */
198 	5,			/* 21 T_BOUND */
199 	7,			/* 22 T_DNA */
200 	8,			/* 23 T_DOUBLEFLT */
201 	9,			/* 24 T_FPOPFLT */
202 	10,			/* 25 T_TSSFLT */
203 	11,			/* 26 T_SEGNPFLT */
204 	12,			/* 27 T_STKFLT */
205 	18,			/* 28 T_MCHK */
206 	19,			/* 29 T_XMMFLT */
207 	15			/* 30 T_RESERVED */
208 };
209 #define bsd_to_linux_trapcode(code) \
210     ((code)<sizeof(_bsd_to_linux_trapcode)/sizeof(*_bsd_to_linux_trapcode)? \
211      _bsd_to_linux_trapcode[(code)]: \
212      LINUX_T_UNKNOWN)
213 
214 struct linux32_ps_strings {
215 	u_int32_t ps_argvstr;	/* first of 0 or more argument strings */
216 	u_int ps_nargvstr;	/* the number of argument strings */
217 	u_int32_t ps_envstr;	/* first of 0 or more environment strings */
218 	u_int ps_nenvstr;	/* the number of environment strings */
219 };
220 
221 /*
222  * If FreeBSD & Linux have a difference of opinion about what a trap
223  * means, deal with it here.
224  *
225  * MPSAFE
226  */
227 static int
228 translate_traps(int signal, int trap_code)
229 {
230 	if (signal != SIGBUS)
231 		return signal;
232 	switch (trap_code) {
233 	case T_PROTFLT:
234 	case T_TSSFLT:
235 	case T_DOUBLEFLT:
236 	case T_PAGEFLT:
237 		return SIGSEGV;
238 	default:
239 		return signal;
240 	}
241 }
242 
243 static int
244 elf_linux_fixup(register_t **stack_base, struct image_params *imgp)
245 {
246 	Elf32_Auxargs *args;
247 	Elf32_Addr *base;
248 	Elf32_Addr *pos, *uplatform;
249 	struct linux32_ps_strings *arginfo;
250 
251 	arginfo = (struct linux32_ps_strings *)LINUX32_PS_STRINGS;
252 	uplatform = (Elf32_Addr *)((caddr_t)arginfo - linux_szplatform);
253 
254 	KASSERT(curthread->td_proc == imgp->proc,
255 	    ("unsafe elf_linux_fixup(), should be curproc"));
256 	base = (Elf32_Addr *)*stack_base;
257 	args = (Elf32_Auxargs *)imgp->auxargs;
258 	pos = base + (imgp->args->argc + imgp->args->envc + 2);
259 
260 	AUXARGS_ENTRY_32(pos, LINUX_AT_HWCAP, cpu_feature);
261 
262 	/*
263 	 * Do not export AT_CLKTCK when emulating Linux kernel prior to 2.4.0,
264 	 * as it has appeared in the 2.4.0-rc7 first time.
265 	 * Being exported, AT_CLKTCK is returned by sysconf(_SC_CLK_TCK),
266 	 * glibc falls back to the hard-coded CLK_TCK value when aux entry
267 	 * is not present.
268 	 * Also see linux_times() implementation.
269 	 */
270 	if (linux_kernver(curthread) >= LINUX_KERNVER_2004000)
271 		AUXARGS_ENTRY_32(pos, LINUX_AT_CLKTCK, stclohz);
272 	AUXARGS_ENTRY_32(pos, AT_PHDR, args->phdr);
273 	AUXARGS_ENTRY_32(pos, AT_PHENT, args->phent);
274 	AUXARGS_ENTRY_32(pos, AT_PHNUM, args->phnum);
275 	AUXARGS_ENTRY_32(pos, AT_PAGESZ, args->pagesz);
276 	AUXARGS_ENTRY_32(pos, AT_FLAGS, args->flags);
277 	AUXARGS_ENTRY_32(pos, AT_ENTRY, args->entry);
278 	AUXARGS_ENTRY_32(pos, AT_BASE, args->base);
279 	AUXARGS_ENTRY_32(pos, LINUX_AT_SECURE, 0);
280 	AUXARGS_ENTRY_32(pos, AT_UID, imgp->proc->p_ucred->cr_ruid);
281 	AUXARGS_ENTRY_32(pos, AT_EUID, imgp->proc->p_ucred->cr_svuid);
282 	AUXARGS_ENTRY_32(pos, AT_GID, imgp->proc->p_ucred->cr_rgid);
283 	AUXARGS_ENTRY_32(pos, AT_EGID, imgp->proc->p_ucred->cr_svgid);
284 	AUXARGS_ENTRY_32(pos, LINUX_AT_PLATFORM, PTROUT(uplatform));
285 	if (args->execfd != -1)
286 		AUXARGS_ENTRY_32(pos, AT_EXECFD, args->execfd);
287 	AUXARGS_ENTRY_32(pos, AT_NULL, 0);
288 
289 	free(imgp->auxargs, M_TEMP);
290 	imgp->auxargs = NULL;
291 
292 	base--;
293 	suword32(base, (uint32_t)imgp->args->argc);
294 	*stack_base = (register_t *)base;
295 	return 0;
296 }
297 
298 extern unsigned long linux_sznonrtsigcode;
299 
300 static void
301 linux_rt_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
302 {
303 	struct thread *td = curthread;
304 	struct proc *p = td->td_proc;
305 	struct sigacts *psp;
306 	struct trapframe *regs;
307 	struct l_rt_sigframe *fp, frame;
308 	int oonstack;
309 	int sig;
310 	int code;
311 
312 	sig = ksi->ksi_signo;
313 	code = ksi->ksi_code;
314 	PROC_LOCK_ASSERT(p, MA_OWNED);
315 	psp = p->p_sigacts;
316 	mtx_assert(&psp->ps_mtx, MA_OWNED);
317 	regs = td->td_frame;
318 	oonstack = sigonstack(regs->tf_rsp);
319 
320 #ifdef DEBUG
321 	if (ldebug(rt_sendsig))
322 		printf(ARGS(rt_sendsig, "%p, %d, %p, %u"),
323 		    catcher, sig, (void*)mask, code);
324 #endif
325 	/*
326 	 * Allocate space for the signal handler context.
327 	 */
328 	if ((td->td_pflags & TDP_ALTSTACK) && !oonstack &&
329 	    SIGISMEMBER(psp->ps_sigonstack, sig)) {
330 		fp = (struct l_rt_sigframe *)(td->td_sigstk.ss_sp +
331 		    td->td_sigstk.ss_size - sizeof(struct l_rt_sigframe));
332 	} else
333 		fp = (struct l_rt_sigframe *)regs->tf_rsp - 1;
334 	mtx_unlock(&psp->ps_mtx);
335 
336 	/*
337 	 * Build the argument list for the signal handler.
338 	 */
339 	if (p->p_sysent->sv_sigtbl)
340 		if (sig <= p->p_sysent->sv_sigsize)
341 			sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
342 
343 	bzero(&frame, sizeof(frame));
344 
345 	frame.sf_handler = PTROUT(catcher);
346 	frame.sf_sig = sig;
347 	frame.sf_siginfo = PTROUT(&fp->sf_si);
348 	frame.sf_ucontext = PTROUT(&fp->sf_sc);
349 
350 	/* Fill in POSIX parts */
351 	ksiginfo_to_lsiginfo(ksi, &frame.sf_si, sig);
352 
353 	/*
354 	 * Build the signal context to be used by sigreturn.
355 	 */
356 	frame.sf_sc.uc_flags = 0;		/* XXX ??? */
357 	frame.sf_sc.uc_link = 0;		/* XXX ??? */
358 
359 	frame.sf_sc.uc_stack.ss_sp = PTROUT(td->td_sigstk.ss_sp);
360 	frame.sf_sc.uc_stack.ss_size = td->td_sigstk.ss_size;
361 	frame.sf_sc.uc_stack.ss_flags = (td->td_pflags & TDP_ALTSTACK)
362 	    ? ((oonstack) ? LINUX_SS_ONSTACK : 0) : LINUX_SS_DISABLE;
363 	PROC_UNLOCK(p);
364 
365 	bsd_to_linux_sigset(mask, &frame.sf_sc.uc_sigmask);
366 
367 	frame.sf_sc.uc_mcontext.sc_mask   = frame.sf_sc.uc_sigmask.__bits[0];
368 	frame.sf_sc.uc_mcontext.sc_edi    = regs->tf_rdi;
369 	frame.sf_sc.uc_mcontext.sc_esi    = regs->tf_rsi;
370 	frame.sf_sc.uc_mcontext.sc_ebp    = regs->tf_rbp;
371 	frame.sf_sc.uc_mcontext.sc_ebx    = regs->tf_rbx;
372 	frame.sf_sc.uc_mcontext.sc_edx    = regs->tf_rdx;
373 	frame.sf_sc.uc_mcontext.sc_ecx    = regs->tf_rcx;
374 	frame.sf_sc.uc_mcontext.sc_eax    = regs->tf_rax;
375 	frame.sf_sc.uc_mcontext.sc_eip    = regs->tf_rip;
376 	frame.sf_sc.uc_mcontext.sc_cs     = regs->tf_cs;
377 	frame.sf_sc.uc_mcontext.sc_gs     = regs->tf_gs;
378 	frame.sf_sc.uc_mcontext.sc_fs     = regs->tf_fs;
379 	frame.sf_sc.uc_mcontext.sc_es     = regs->tf_es;
380 	frame.sf_sc.uc_mcontext.sc_ds     = regs->tf_ds;
381 	frame.sf_sc.uc_mcontext.sc_eflags = regs->tf_rflags;
382 	frame.sf_sc.uc_mcontext.sc_esp_at_signal = regs->tf_rsp;
383 	frame.sf_sc.uc_mcontext.sc_ss     = regs->tf_ss;
384 	frame.sf_sc.uc_mcontext.sc_err    = regs->tf_err;
385 	frame.sf_sc.uc_mcontext.sc_cr2    = (u_int32_t)(uintptr_t)ksi->ksi_addr;
386 	frame.sf_sc.uc_mcontext.sc_trapno = bsd_to_linux_trapcode(code);
387 
388 #ifdef DEBUG
389 	if (ldebug(rt_sendsig))
390 		printf(LMSG("rt_sendsig flags: 0x%x, sp: %p, ss: 0x%lx, mask: 0x%x"),
391 		    frame.sf_sc.uc_stack.ss_flags, td->td_sigstk.ss_sp,
392 		    td->td_sigstk.ss_size, frame.sf_sc.uc_mcontext.sc_mask);
393 #endif
394 
395 	if (copyout(&frame, fp, sizeof(frame)) != 0) {
396 		/*
397 		 * Process has trashed its stack; give it an illegal
398 		 * instruction to halt it in its tracks.
399 		 */
400 #ifdef DEBUG
401 		if (ldebug(rt_sendsig))
402 			printf(LMSG("rt_sendsig: bad stack %p, oonstack=%x"),
403 			    fp, oonstack);
404 #endif
405 		PROC_LOCK(p);
406 		sigexit(td, SIGILL);
407 	}
408 
409 	/*
410 	 * Build context to run handler in.
411 	 */
412 	regs->tf_rsp = PTROUT(fp);
413 	regs->tf_rip = p->p_sysent->sv_sigcode_base + linux_sznonrtsigcode;
414 	regs->tf_rflags &= ~(PSL_T | PSL_D);
415 	regs->tf_cs = _ucode32sel;
416 	regs->tf_ss = _udatasel;
417 	regs->tf_ds = _udatasel;
418 	regs->tf_es = _udatasel;
419 	regs->tf_fs = _ufssel;
420 	regs->tf_gs = _ugssel;
421 	regs->tf_flags = TF_HASSEGS;
422 	set_pcb_flags(td->td_pcb, PCB_FULL_IRET);
423 	PROC_LOCK(p);
424 	mtx_lock(&psp->ps_mtx);
425 }
426 
427 
428 /*
429  * Send an interrupt to process.
430  *
431  * Stack is set up to allow sigcode stored
432  * in u. to call routine, followed by kcall
433  * to sigreturn routine below.  After sigreturn
434  * resets the signal mask, the stack, and the
435  * frame pointer, it returns to the user
436  * specified pc, psl.
437  */
438 static void
439 linux_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
440 {
441 	struct thread *td = curthread;
442 	struct proc *p = td->td_proc;
443 	struct sigacts *psp;
444 	struct trapframe *regs;
445 	struct l_sigframe *fp, frame;
446 	l_sigset_t lmask;
447 	int oonstack, i;
448 	int sig, code;
449 
450 	sig = ksi->ksi_signo;
451 	code = ksi->ksi_code;
452 	PROC_LOCK_ASSERT(p, MA_OWNED);
453 	psp = p->p_sigacts;
454 	mtx_assert(&psp->ps_mtx, MA_OWNED);
455 	if (SIGISMEMBER(psp->ps_siginfo, sig)) {
456 		/* Signal handler installed with SA_SIGINFO. */
457 		linux_rt_sendsig(catcher, ksi, mask);
458 		return;
459 	}
460 
461 	regs = td->td_frame;
462 	oonstack = sigonstack(regs->tf_rsp);
463 
464 #ifdef DEBUG
465 	if (ldebug(sendsig))
466 		printf(ARGS(sendsig, "%p, %d, %p, %u"),
467 		    catcher, sig, (void*)mask, code);
468 #endif
469 
470 	/*
471 	 * Allocate space for the signal handler context.
472 	 */
473 	if ((td->td_pflags & TDP_ALTSTACK) && !oonstack &&
474 	    SIGISMEMBER(psp->ps_sigonstack, sig)) {
475 		fp = (struct l_sigframe *)(td->td_sigstk.ss_sp +
476 		    td->td_sigstk.ss_size - sizeof(struct l_sigframe));
477 	} else
478 		fp = (struct l_sigframe *)regs->tf_rsp - 1;
479 	mtx_unlock(&psp->ps_mtx);
480 	PROC_UNLOCK(p);
481 
482 	/*
483 	 * Build the argument list for the signal handler.
484 	 */
485 	if (p->p_sysent->sv_sigtbl)
486 		if (sig <= p->p_sysent->sv_sigsize)
487 			sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
488 
489 	bzero(&frame, sizeof(frame));
490 
491 	frame.sf_handler = PTROUT(catcher);
492 	frame.sf_sig = sig;
493 
494 	bsd_to_linux_sigset(mask, &lmask);
495 
496 	/*
497 	 * Build the signal context to be used by sigreturn.
498 	 */
499 	frame.sf_sc.sc_mask   = lmask.__bits[0];
500 	frame.sf_sc.sc_gs     = regs->tf_gs;
501 	frame.sf_sc.sc_fs     = regs->tf_fs;
502 	frame.sf_sc.sc_es     = regs->tf_es;
503 	frame.sf_sc.sc_ds     = regs->tf_ds;
504 	frame.sf_sc.sc_edi    = regs->tf_rdi;
505 	frame.sf_sc.sc_esi    = regs->tf_rsi;
506 	frame.sf_sc.sc_ebp    = regs->tf_rbp;
507 	frame.sf_sc.sc_ebx    = regs->tf_rbx;
508 	frame.sf_sc.sc_edx    = regs->tf_rdx;
509 	frame.sf_sc.sc_ecx    = regs->tf_rcx;
510 	frame.sf_sc.sc_eax    = regs->tf_rax;
511 	frame.sf_sc.sc_eip    = regs->tf_rip;
512 	frame.sf_sc.sc_cs     = regs->tf_cs;
513 	frame.sf_sc.sc_eflags = regs->tf_rflags;
514 	frame.sf_sc.sc_esp_at_signal = regs->tf_rsp;
515 	frame.sf_sc.sc_ss     = regs->tf_ss;
516 	frame.sf_sc.sc_err    = regs->tf_err;
517 	frame.sf_sc.sc_cr2    = (u_int32_t)(uintptr_t)ksi->ksi_addr;
518 	frame.sf_sc.sc_trapno = bsd_to_linux_trapcode(code);
519 
520 	for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
521 		frame.sf_extramask[i] = lmask.__bits[i+1];
522 
523 	if (copyout(&frame, fp, sizeof(frame)) != 0) {
524 		/*
525 		 * Process has trashed its stack; give it an illegal
526 		 * instruction to halt it in its tracks.
527 		 */
528 		PROC_LOCK(p);
529 		sigexit(td, SIGILL);
530 	}
531 
532 	/*
533 	 * Build context to run handler in.
534 	 */
535 	regs->tf_rsp = PTROUT(fp);
536 	regs->tf_rip = p->p_sysent->sv_sigcode_base;
537 	regs->tf_rflags &= ~(PSL_T | PSL_D);
538 	regs->tf_cs = _ucode32sel;
539 	regs->tf_ss = _udatasel;
540 	regs->tf_ds = _udatasel;
541 	regs->tf_es = _udatasel;
542 	regs->tf_fs = _ufssel;
543 	regs->tf_gs = _ugssel;
544 	regs->tf_flags = TF_HASSEGS;
545 	set_pcb_flags(td->td_pcb, PCB_FULL_IRET);
546 	PROC_LOCK(p);
547 	mtx_lock(&psp->ps_mtx);
548 }
549 
550 /*
551  * System call to cleanup state after a signal
552  * has been taken.  Reset signal mask and
553  * stack state from context left by sendsig (above).
554  * Return to previous pc and psl as specified by
555  * context left by sendsig. Check carefully to
556  * make sure that the user has not modified the
557  * psl to gain improper privileges or to cause
558  * a machine fault.
559  */
560 int
561 linux_sigreturn(struct thread *td, struct linux_sigreturn_args *args)
562 {
563 	struct l_sigframe frame;
564 	struct trapframe *regs;
565 	sigset_t bmask;
566 	l_sigset_t lmask;
567 	int eflags, i;
568 	ksiginfo_t ksi;
569 
570 	regs = td->td_frame;
571 
572 #ifdef DEBUG
573 	if (ldebug(sigreturn))
574 		printf(ARGS(sigreturn, "%p"), (void *)args->sfp);
575 #endif
576 	/*
577 	 * The trampoline code hands us the sigframe.
578 	 * It is unsafe to keep track of it ourselves, in the event that a
579 	 * program jumps out of a signal handler.
580 	 */
581 	if (copyin(args->sfp, &frame, sizeof(frame)) != 0)
582 		return (EFAULT);
583 
584 	/*
585 	 * Check for security violations.
586 	 */
587 #define	EFLAGS_SECURE(ef, oef)	((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
588 	eflags = frame.sf_sc.sc_eflags;
589 	/*
590 	 * XXX do allow users to change the privileged flag PSL_RF.  The
591 	 * cpu sets PSL_RF in tf_eflags for faults.  Debuggers should
592 	 * sometimes set it there too.  tf_eflags is kept in the signal
593 	 * context during signal handling and there is no other place
594 	 * to remember it, so the PSL_RF bit may be corrupted by the
595 	 * signal handler without us knowing.  Corruption of the PSL_RF
596 	 * bit at worst causes one more or one less debugger trap, so
597 	 * allowing it is fairly harmless.
598 	 */
599 	if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_rflags & ~PSL_RF))
600 		return(EINVAL);
601 
602 	/*
603 	 * Don't allow users to load a valid privileged %cs.  Let the
604 	 * hardware check for invalid selectors, excess privilege in
605 	 * other selectors, invalid %eip's and invalid %esp's.
606 	 */
607 #define	CS_SECURE(cs)	(ISPL(cs) == SEL_UPL)
608 	if (!CS_SECURE(frame.sf_sc.sc_cs)) {
609 		ksiginfo_init_trap(&ksi);
610 		ksi.ksi_signo = SIGBUS;
611 		ksi.ksi_code = BUS_OBJERR;
612 		ksi.ksi_trapno = T_PROTFLT;
613 		ksi.ksi_addr = (void *)regs->tf_rip;
614 		trapsignal(td, &ksi);
615 		return(EINVAL);
616 	}
617 
618 	lmask.__bits[0] = frame.sf_sc.sc_mask;
619 	for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
620 		lmask.__bits[i+1] = frame.sf_extramask[i];
621 	linux_to_bsd_sigset(&lmask, &bmask);
622 	kern_sigprocmask(td, SIG_SETMASK, &bmask, NULL, 0);
623 
624 	/*
625 	 * Restore signal context.
626 	 */
627 	regs->tf_rdi    = frame.sf_sc.sc_edi;
628 	regs->tf_rsi    = frame.sf_sc.sc_esi;
629 	regs->tf_rbp    = frame.sf_sc.sc_ebp;
630 	regs->tf_rbx    = frame.sf_sc.sc_ebx;
631 	regs->tf_rdx    = frame.sf_sc.sc_edx;
632 	regs->tf_rcx    = frame.sf_sc.sc_ecx;
633 	regs->tf_rax    = frame.sf_sc.sc_eax;
634 	regs->tf_rip    = frame.sf_sc.sc_eip;
635 	regs->tf_cs     = frame.sf_sc.sc_cs;
636 	regs->tf_ds     = frame.sf_sc.sc_ds;
637 	regs->tf_es     = frame.sf_sc.sc_es;
638 	regs->tf_fs     = frame.sf_sc.sc_fs;
639 	regs->tf_gs     = frame.sf_sc.sc_gs;
640 	regs->tf_rflags = eflags;
641 	regs->tf_rsp    = frame.sf_sc.sc_esp_at_signal;
642 	regs->tf_ss     = frame.sf_sc.sc_ss;
643 	set_pcb_flags(td->td_pcb, PCB_FULL_IRET);
644 
645 	return (EJUSTRETURN);
646 }
647 
648 /*
649  * System call to cleanup state after a signal
650  * has been taken.  Reset signal mask and
651  * stack state from context left by rt_sendsig (above).
652  * Return to previous pc and psl as specified by
653  * context left by sendsig. Check carefully to
654  * make sure that the user has not modified the
655  * psl to gain improper privileges or to cause
656  * a machine fault.
657  */
658 int
659 linux_rt_sigreturn(struct thread *td, struct linux_rt_sigreturn_args *args)
660 {
661 	struct l_ucontext uc;
662 	struct l_sigcontext *context;
663 	sigset_t bmask;
664 	l_stack_t *lss;
665 	stack_t ss;
666 	struct trapframe *regs;
667 	int eflags;
668 	ksiginfo_t ksi;
669 
670 	regs = td->td_frame;
671 
672 #ifdef DEBUG
673 	if (ldebug(rt_sigreturn))
674 		printf(ARGS(rt_sigreturn, "%p"), (void *)args->ucp);
675 #endif
676 	/*
677 	 * The trampoline code hands us the ucontext.
678 	 * It is unsafe to keep track of it ourselves, in the event that a
679 	 * program jumps out of a signal handler.
680 	 */
681 	if (copyin(args->ucp, &uc, sizeof(uc)) != 0)
682 		return (EFAULT);
683 
684 	context = &uc.uc_mcontext;
685 
686 	/*
687 	 * Check for security violations.
688 	 */
689 #define	EFLAGS_SECURE(ef, oef)	((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
690 	eflags = context->sc_eflags;
691 	/*
692 	 * XXX do allow users to change the privileged flag PSL_RF.  The
693 	 * cpu sets PSL_RF in tf_eflags for faults.  Debuggers should
694 	 * sometimes set it there too.  tf_eflags is kept in the signal
695 	 * context during signal handling and there is no other place
696 	 * to remember it, so the PSL_RF bit may be corrupted by the
697 	 * signal handler without us knowing.  Corruption of the PSL_RF
698 	 * bit at worst causes one more or one less debugger trap, so
699 	 * allowing it is fairly harmless.
700 	 */
701 	if (!EFLAGS_SECURE(eflags & ~PSL_RF, regs->tf_rflags & ~PSL_RF))
702 		return(EINVAL);
703 
704 	/*
705 	 * Don't allow users to load a valid privileged %cs.  Let the
706 	 * hardware check for invalid selectors, excess privilege in
707 	 * other selectors, invalid %eip's and invalid %esp's.
708 	 */
709 #define	CS_SECURE(cs)	(ISPL(cs) == SEL_UPL)
710 	if (!CS_SECURE(context->sc_cs)) {
711 		ksiginfo_init_trap(&ksi);
712 		ksi.ksi_signo = SIGBUS;
713 		ksi.ksi_code = BUS_OBJERR;
714 		ksi.ksi_trapno = T_PROTFLT;
715 		ksi.ksi_addr = (void *)regs->tf_rip;
716 		trapsignal(td, &ksi);
717 		return(EINVAL);
718 	}
719 
720 	linux_to_bsd_sigset(&uc.uc_sigmask, &bmask);
721 	kern_sigprocmask(td, SIG_SETMASK, &bmask, NULL, 0);
722 
723 	/*
724 	 * Restore signal context
725 	 */
726 	regs->tf_gs	= context->sc_gs;
727 	regs->tf_fs	= context->sc_fs;
728 	regs->tf_es	= context->sc_es;
729 	regs->tf_ds	= context->sc_ds;
730 	regs->tf_rdi    = context->sc_edi;
731 	regs->tf_rsi    = context->sc_esi;
732 	regs->tf_rbp    = context->sc_ebp;
733 	regs->tf_rbx    = context->sc_ebx;
734 	regs->tf_rdx    = context->sc_edx;
735 	regs->tf_rcx    = context->sc_ecx;
736 	regs->tf_rax    = context->sc_eax;
737 	regs->tf_rip    = context->sc_eip;
738 	regs->tf_cs     = context->sc_cs;
739 	regs->tf_rflags = eflags;
740 	regs->tf_rsp    = context->sc_esp_at_signal;
741 	regs->tf_ss     = context->sc_ss;
742 	set_pcb_flags(td->td_pcb, PCB_FULL_IRET);
743 
744 	/*
745 	 * call sigaltstack & ignore results..
746 	 */
747 	lss = &uc.uc_stack;
748 	ss.ss_sp = PTRIN(lss->ss_sp);
749 	ss.ss_size = lss->ss_size;
750 	ss.ss_flags = linux_to_bsd_sigaltstack(lss->ss_flags);
751 
752 #ifdef DEBUG
753 	if (ldebug(rt_sigreturn))
754 		printf(LMSG("rt_sigret flags: 0x%x, sp: %p, ss: 0x%lx, mask: 0x%x"),
755 		    ss.ss_flags, ss.ss_sp, ss.ss_size, context->sc_mask);
756 #endif
757 	(void)kern_sigaltstack(td, &ss, NULL);
758 
759 	return (EJUSTRETURN);
760 }
761 
762 static int
763 linux32_fetch_syscall_args(struct thread *td, struct syscall_args *sa)
764 {
765 	struct proc *p;
766 	struct trapframe *frame;
767 
768 	p = td->td_proc;
769 	frame = td->td_frame;
770 
771 	sa->args[0] = frame->tf_rbx;
772 	sa->args[1] = frame->tf_rcx;
773 	sa->args[2] = frame->tf_rdx;
774 	sa->args[3] = frame->tf_rsi;
775 	sa->args[4] = frame->tf_rdi;
776 	sa->args[5] = frame->tf_rbp;	/* Unconfirmed */
777 	sa->code = frame->tf_rax;
778 
779 	if (sa->code >= p->p_sysent->sv_size)
780 		sa->callp = &p->p_sysent->sv_table[0];
781 	else
782 		sa->callp = &p->p_sysent->sv_table[sa->code];
783 	sa->narg = sa->callp->sy_narg;
784 
785 	td->td_retval[0] = 0;
786 	td->td_retval[1] = frame->tf_rdx;
787 
788 	return (0);
789 }
790 
791 /*
792  * If a linux binary is exec'ing something, try this image activator
793  * first.  We override standard shell script execution in order to
794  * be able to modify the interpreter path.  We only do this if a linux
795  * binary is doing the exec, so we do not create an EXEC module for it.
796  */
797 static int	exec_linux_imgact_try(struct image_params *iparams);
798 
799 static int
800 exec_linux_imgact_try(struct image_params *imgp)
801 {
802 	const char *head = (const char *)imgp->image_header;
803 	char *rpath;
804 	int error = -1;
805 
806 	/*
807 	* The interpreter for shell scripts run from a linux binary needs
808 	* to be located in /compat/linux if possible in order to recursively
809 	* maintain linux path emulation.
810 	*/
811 	if (((const short *)head)[0] == SHELLMAGIC) {
812 		/*
813 		* Run our normal shell image activator.  If it succeeds attempt
814 		* to use the alternate path for the interpreter.  If an
815 		* alternate * path is found, use our stringspace to store it.
816 		*/
817 		if ((error = exec_shell_imgact(imgp)) == 0) {
818 			linux_emul_convpath(FIRST_THREAD_IN_PROC(imgp->proc),
819 			    imgp->interpreter_name, UIO_SYSSPACE, &rpath, 0,
820 			    AT_FDCWD);
821 			if (rpath != NULL)
822 				imgp->args->fname_buf =
823 				    imgp->interpreter_name = rpath;
824 		}
825 	}
826 	return (error);
827 }
828 
829 /*
830  * Clear registers on exec
831  * XXX copied from ia32_signal.c.
832  */
833 static void
834 exec_linux_setregs(struct thread *td, struct image_params *imgp, u_long stack)
835 {
836 	struct trapframe *regs = td->td_frame;
837 	struct pcb *pcb = td->td_pcb;
838 
839 	mtx_lock(&dt_lock);
840 	if (td->td_proc->p_md.md_ldt != NULL)
841 		user_ldt_free(td);
842 	else
843 		mtx_unlock(&dt_lock);
844 
845 	critical_enter();
846 	wrmsr(MSR_FSBASE, 0);
847 	wrmsr(MSR_KGSBASE, 0);	/* User value while we're in the kernel */
848 	pcb->pcb_fsbase = 0;
849 	pcb->pcb_gsbase = 0;
850 	critical_exit();
851 	pcb->pcb_initial_fpucw = __LINUX_NPXCW__;
852 
853 	bzero((char *)regs, sizeof(struct trapframe));
854 	regs->tf_rip = imgp->entry_addr;
855 	regs->tf_rsp = stack;
856 	regs->tf_rflags = PSL_USER | (regs->tf_rflags & PSL_T);
857 	regs->tf_gs = _ugssel;
858 	regs->tf_fs = _ufssel;
859 	regs->tf_es = _udatasel;
860 	regs->tf_ds = _udatasel;
861 	regs->tf_ss = _udatasel;
862 	regs->tf_flags = TF_HASSEGS;
863 	regs->tf_cs = _ucode32sel;
864 	regs->tf_rbx = imgp->ps_strings;
865 
866 	fpstate_drop(td);
867 
868 	/* Do full restore on return so that we can change to a different %cs */
869 	set_pcb_flags(pcb, PCB_32BIT | PCB_FULL_IRET);
870 	clear_pcb_flags(pcb, PCB_GS32BIT);
871 	td->td_retval[1] = 0;
872 }
873 
874 /*
875  * XXX copied from ia32_sysvec.c.
876  */
877 static register_t *
878 linux_copyout_strings(struct image_params *imgp)
879 {
880 	int argc, envc;
881 	u_int32_t *vectp;
882 	char *stringp, *destp;
883 	u_int32_t *stack_base;
884 	struct linux32_ps_strings *arginfo;
885 
886 	/*
887 	 * Calculate string base and vector table pointers.
888 	 * Also deal with signal trampoline code for this exec type.
889 	 */
890 	arginfo = (struct linux32_ps_strings *)LINUX32_PS_STRINGS;
891 	destp =	(caddr_t)arginfo - SPARE_USRSPACE - linux_szplatform -
892 	    roundup((ARG_MAX - imgp->args->stringspace),
893 	    sizeof(char *));
894 
895 	/*
896 	 * Install LINUX_PLATFORM
897 	 */
898 	copyout(linux_platform, ((caddr_t)arginfo - linux_szplatform),
899 	    linux_szplatform);
900 
901 	/*
902 	 * If we have a valid auxargs ptr, prepare some room
903 	 * on the stack.
904 	 */
905 	if (imgp->auxargs) {
906 		/*
907 		 * 'AT_COUNT*2' is size for the ELF Auxargs data. This is for
908 		 * lower compatibility.
909 		 */
910 		imgp->auxarg_size = (imgp->auxarg_size) ? imgp->auxarg_size :
911 		    (LINUX_AT_COUNT * 2);
912 		/*
913 		 * The '+ 2' is for the null pointers at the end of each of
914 		 * the arg and env vector sets,and imgp->auxarg_size is room
915 		 * for argument of Runtime loader.
916 		 */
917 		vectp = (u_int32_t *) (destp - (imgp->args->argc +
918 		    imgp->args->envc + 2 + imgp->auxarg_size) *
919 		    sizeof(u_int32_t));
920 
921 	} else
922 		/*
923 		 * The '+ 2' is for the null pointers at the end of each of
924 		 * the arg and env vector sets
925 		 */
926 		vectp = (u_int32_t *)(destp - (imgp->args->argc +
927 		    imgp->args->envc + 2) * sizeof(u_int32_t));
928 
929 	/*
930 	 * vectp also becomes our initial stack base
931 	 */
932 	stack_base = vectp;
933 
934 	stringp = imgp->args->begin_argv;
935 	argc = imgp->args->argc;
936 	envc = imgp->args->envc;
937 	/*
938 	 * Copy out strings - arguments and environment.
939 	 */
940 	copyout(stringp, destp, ARG_MAX - imgp->args->stringspace);
941 
942 	/*
943 	 * Fill in "ps_strings" struct for ps, w, etc.
944 	 */
945 	suword32(&arginfo->ps_argvstr, (uint32_t)(intptr_t)vectp);
946 	suword32(&arginfo->ps_nargvstr, argc);
947 
948 	/*
949 	 * Fill in argument portion of vector table.
950 	 */
951 	for (; argc > 0; --argc) {
952 		suword32(vectp++, (uint32_t)(intptr_t)destp);
953 		while (*stringp++ != 0)
954 			destp++;
955 		destp++;
956 	}
957 
958 	/* a null vector table pointer separates the argp's from the envp's */
959 	suword32(vectp++, 0);
960 
961 	suword32(&arginfo->ps_envstr, (uint32_t)(intptr_t)vectp);
962 	suword32(&arginfo->ps_nenvstr, envc);
963 
964 	/*
965 	 * Fill in environment portion of vector table.
966 	 */
967 	for (; envc > 0; --envc) {
968 		suword32(vectp++, (uint32_t)(intptr_t)destp);
969 		while (*stringp++ != 0)
970 			destp++;
971 		destp++;
972 	}
973 
974 	/* end of vector table is a null pointer */
975 	suword32(vectp, 0);
976 
977 	return ((register_t *)stack_base);
978 }
979 
980 static SYSCTL_NODE(_compat, OID_AUTO, linux32, CTLFLAG_RW, 0,
981     "32-bit Linux emulation");
982 
983 static u_long	linux32_maxdsiz = LINUX32_MAXDSIZ;
984 SYSCTL_ULONG(_compat_linux32, OID_AUTO, maxdsiz, CTLFLAG_RW,
985     &linux32_maxdsiz, 0, "");
986 static u_long	linux32_maxssiz = LINUX32_MAXSSIZ;
987 SYSCTL_ULONG(_compat_linux32, OID_AUTO, maxssiz, CTLFLAG_RW,
988     &linux32_maxssiz, 0, "");
989 static u_long	linux32_maxvmem = LINUX32_MAXVMEM;
990 SYSCTL_ULONG(_compat_linux32, OID_AUTO, maxvmem, CTLFLAG_RW,
991     &linux32_maxvmem, 0, "");
992 
993 static void
994 linux32_fixlimit(struct rlimit *rl, int which)
995 {
996 
997 	switch (which) {
998 	case RLIMIT_DATA:
999 		if (linux32_maxdsiz != 0) {
1000 			if (rl->rlim_cur > linux32_maxdsiz)
1001 				rl->rlim_cur = linux32_maxdsiz;
1002 			if (rl->rlim_max > linux32_maxdsiz)
1003 				rl->rlim_max = linux32_maxdsiz;
1004 		}
1005 		break;
1006 	case RLIMIT_STACK:
1007 		if (linux32_maxssiz != 0) {
1008 			if (rl->rlim_cur > linux32_maxssiz)
1009 				rl->rlim_cur = linux32_maxssiz;
1010 			if (rl->rlim_max > linux32_maxssiz)
1011 				rl->rlim_max = linux32_maxssiz;
1012 		}
1013 		break;
1014 	case RLIMIT_VMEM:
1015 		if (linux32_maxvmem != 0) {
1016 			if (rl->rlim_cur > linux32_maxvmem)
1017 				rl->rlim_cur = linux32_maxvmem;
1018 			if (rl->rlim_max > linux32_maxvmem)
1019 				rl->rlim_max = linux32_maxvmem;
1020 		}
1021 		break;
1022 	}
1023 }
1024 
1025 struct sysentvec elf_linux_sysvec = {
1026 	.sv_size	= LINUX_SYS_MAXSYSCALL,
1027 	.sv_table	= linux_sysent,
1028 	.sv_mask	= 0,
1029 	.sv_sigsize	= LINUX_SIGTBLSZ,
1030 	.sv_sigtbl	= bsd_to_linux_signal,
1031 	.sv_errsize	= ELAST + 1,
1032 	.sv_errtbl	= bsd_to_linux_errno,
1033 	.sv_transtrap	= translate_traps,
1034 	.sv_fixup	= elf_linux_fixup,
1035 	.sv_sendsig	= linux_sendsig,
1036 	.sv_sigcode	= linux_sigcode,
1037 	.sv_szsigcode	= &linux_szsigcode,
1038 	.sv_prepsyscall	= NULL,
1039 	.sv_name	= "Linux ELF32",
1040 	.sv_coredump	= elf32_coredump,
1041 	.sv_imgact_try	= exec_linux_imgact_try,
1042 	.sv_minsigstksz	= LINUX_MINSIGSTKSZ,
1043 	.sv_pagesize	= PAGE_SIZE,
1044 	.sv_minuser	= VM_MIN_ADDRESS,
1045 	.sv_maxuser	= LINUX32_MAXUSER,
1046 	.sv_usrstack	= LINUX32_USRSTACK,
1047 	.sv_psstrings	= LINUX32_PS_STRINGS,
1048 	.sv_stackprot	= VM_PROT_ALL,
1049 	.sv_copyout_strings = linux_copyout_strings,
1050 	.sv_setregs	= exec_linux_setregs,
1051 	.sv_fixlimit	= linux32_fixlimit,
1052 	.sv_maxssiz	= &linux32_maxssiz,
1053 	.sv_flags	= SV_ABI_LINUX | SV_ILP32 | SV_IA32 | SV_SHP,
1054 	.sv_set_syscall_retval = cpu_set_syscall_retval,
1055 	.sv_fetch_syscall_args = linux32_fetch_syscall_args,
1056 	.sv_syscallnames = NULL,
1057 	.sv_shared_page_base = LINUX32_SHAREDPAGE,
1058 	.sv_shared_page_len = PAGE_SIZE,
1059 	.sv_schedtail	= linux_schedtail,
1060 };
1061 INIT_SYSENTVEC(elf_sysvec, &elf_linux_sysvec);
1062 
1063 static char GNU_ABI_VENDOR[] = "GNU";
1064 static int GNULINUX_ABI_DESC = 0;
1065 
1066 static boolean_t
1067 linux32_trans_osrel(const Elf_Note *note, int32_t *osrel)
1068 {
1069 	const Elf32_Word *desc;
1070 	uintptr_t p;
1071 
1072 	p = (uintptr_t)(note + 1);
1073 	p += roundup2(note->n_namesz, sizeof(Elf32_Addr));
1074 
1075 	desc = (const Elf32_Word *)p;
1076 	if (desc[0] != GNULINUX_ABI_DESC)
1077 		return (FALSE);
1078 
1079 	/*
1080 	 * For linux we encode osrel as follows (see linux_mib.c):
1081 	 * VVVMMMIII (version, major, minor), see linux_mib.c.
1082 	 */
1083 	*osrel = desc[1] * 1000000 + desc[2] * 1000 + desc[3];
1084 
1085 	return (TRUE);
1086 }
1087 
1088 static Elf_Brandnote linux32_brandnote = {
1089 	.hdr.n_namesz	= sizeof(GNU_ABI_VENDOR),
1090 	.hdr.n_descsz	= 16,	/* XXX at least 16 */
1091 	.hdr.n_type	= 1,
1092 	.vendor		= GNU_ABI_VENDOR,
1093 	.flags		= BN_TRANSLATE_OSREL,
1094 	.trans_osrel	= linux32_trans_osrel
1095 };
1096 
1097 static Elf32_Brandinfo linux_brand = {
1098 	.brand		= ELFOSABI_LINUX,
1099 	.machine	= EM_386,
1100 	.compat_3_brand	= "Linux",
1101 	.emul_path	= "/compat/linux",
1102 	.interp_path	= "/lib/ld-linux.so.1",
1103 	.sysvec		= &elf_linux_sysvec,
1104 	.interp_newpath	= NULL,
1105 	.brand_note	= &linux32_brandnote,
1106 	.flags		= BI_CAN_EXEC_DYN | BI_BRAND_NOTE
1107 };
1108 
1109 static Elf32_Brandinfo linux_glibc2brand = {
1110 	.brand		= ELFOSABI_LINUX,
1111 	.machine	= EM_386,
1112 	.compat_3_brand	= "Linux",
1113 	.emul_path	= "/compat/linux",
1114 	.interp_path	= "/lib/ld-linux.so.2",
1115 	.sysvec		= &elf_linux_sysvec,
1116 	.interp_newpath	= NULL,
1117 	.brand_note	= &linux32_brandnote,
1118 	.flags		= BI_CAN_EXEC_DYN | BI_BRAND_NOTE
1119 };
1120 
1121 Elf32_Brandinfo *linux_brandlist[] = {
1122 	&linux_brand,
1123 	&linux_glibc2brand,
1124 	NULL
1125 };
1126 
1127 static int
1128 linux_elf_modevent(module_t mod, int type, void *data)
1129 {
1130 	Elf32_Brandinfo **brandinfo;
1131 	int error;
1132 	struct linux_ioctl_handler **lihp;
1133 	struct linux_device_handler **ldhp;
1134 
1135 	error = 0;
1136 
1137 	switch(type) {
1138 	case MOD_LOAD:
1139 		for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
1140 		     ++brandinfo)
1141 			if (elf32_insert_brand_entry(*brandinfo) < 0)
1142 				error = EINVAL;
1143 		if (error == 0) {
1144 			SET_FOREACH(lihp, linux_ioctl_handler_set)
1145 				linux_ioctl_register_handler(*lihp);
1146 			SET_FOREACH(ldhp, linux_device_handler_set)
1147 				linux_device_register_handler(*ldhp);
1148 			mtx_init(&emul_lock, "emuldata lock", NULL, MTX_DEF);
1149 			sx_init(&emul_shared_lock, "emuldata->shared lock");
1150 			LIST_INIT(&futex_list);
1151 			mtx_init(&futex_mtx, "ftllk", NULL, MTX_DEF);
1152 			linux_exit_tag = EVENTHANDLER_REGISTER(process_exit,
1153 			    linux_proc_exit, NULL, 1000);
1154 			linux_exec_tag = EVENTHANDLER_REGISTER(process_exec,
1155 			    linux_proc_exec, NULL, 1000);
1156 			linux_szplatform = roundup(strlen(linux_platform) + 1,
1157 			    sizeof(char *));
1158 			linux_osd_jail_register();
1159 			stclohz = (stathz ? stathz : hz);
1160 			if (bootverbose)
1161 				printf("Linux ELF exec handler installed\n");
1162 		} else
1163 			printf("cannot insert Linux ELF brand handler\n");
1164 		break;
1165 	case MOD_UNLOAD:
1166 		for (brandinfo = &linux_brandlist[0]; *brandinfo != NULL;
1167 		     ++brandinfo)
1168 			if (elf32_brand_inuse(*brandinfo))
1169 				error = EBUSY;
1170 		if (error == 0) {
1171 			for (brandinfo = &linux_brandlist[0];
1172 			     *brandinfo != NULL; ++brandinfo)
1173 				if (elf32_remove_brand_entry(*brandinfo) < 0)
1174 					error = EINVAL;
1175 		}
1176 		if (error == 0) {
1177 			SET_FOREACH(lihp, linux_ioctl_handler_set)
1178 				linux_ioctl_unregister_handler(*lihp);
1179 			SET_FOREACH(ldhp, linux_device_handler_set)
1180 				linux_device_unregister_handler(*ldhp);
1181 			mtx_destroy(&emul_lock);
1182 			sx_destroy(&emul_shared_lock);
1183 			mtx_destroy(&futex_mtx);
1184 			EVENTHANDLER_DEREGISTER(process_exit, linux_exit_tag);
1185 			EVENTHANDLER_DEREGISTER(process_exec, linux_exec_tag);
1186 			linux_osd_jail_deregister();
1187 			if (bootverbose)
1188 				printf("Linux ELF exec handler removed\n");
1189 		} else
1190 			printf("Could not deinstall ELF interpreter entry\n");
1191 		break;
1192 	default:
1193 		return EOPNOTSUPP;
1194 	}
1195 	return error;
1196 }
1197 
1198 static moduledata_t linux_elf_mod = {
1199 	"linuxelf",
1200 	linux_elf_modevent,
1201 	0
1202 };
1203 
1204 DECLARE_MODULE_TIED(linuxelf, linux_elf_mod, SI_SUB_EXEC, SI_ORDER_ANY);
1205