107
108static int linux_fixup(register_t **stack_base,
109 struct image_params *iparams);
110static int elf_linux_fixup(register_t **stack_base,
111 struct image_params *iparams);
112static void linux_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask);
113static void exec_linux_setregs(struct thread *td,
114 struct image_params *imgp, u_long stack);
115static register_t *linux_copyout_strings(struct image_params *imgp);
116static boolean_t linux_trans_osrel(const Elf_Note *note, int32_t *osrel);
117static void linux_vdso_install(void *param);
118static void linux_vdso_deinstall(void *param);
119
120static int linux_szplatform;
121const char *linux_kplatform;
122
123static eventhandler_tag linux_exit_tag;
124static eventhandler_tag linux_exec_tag;
125static eventhandler_tag linux_thread_dtor_tag;
126
127/*
128 * Linux syscalls return negative errno's, we do positive and map them
129 * Reference:
130 * FreeBSD: src/sys/sys/errno.h
131 * Linux: linux-2.6.17.8/include/asm-generic/errno-base.h
132 * linux-2.6.17.8/include/asm-generic/errno.h
133 */
134static int bsd_to_linux_errno[ELAST + 1] = {
135 -0, -1, -2, -3, -4, -5, -6, -7, -8, -9,
136 -10, -35, -12, -13, -14, -15, -16, -17, -18, -19,
137 -20, -21, -22, -23, -24, -25, -26, -27, -28, -29,
138 -30, -31, -32, -33, -34, -11,-115,-114, -88, -89,
139 -90, -91, -92, -93, -94, -95, -96, -97, -98, -99,
140 -100,-101,-102,-103,-104,-105,-106,-107,-108,-109,
141 -110,-111, -40, -36,-112,-113, -39, -11, -87,-122,
142 -116, -66, -6, -6, -6, -6, -6, -37, -38, -9,
143 -6, -6, -43, -42, -75,-125, -84, -95, -16, -74,
144 -72, -67, -71
145};
146
147int bsd_to_linux_signal[LINUX_SIGTBLSZ] = {
148 LINUX_SIGHUP, LINUX_SIGINT, LINUX_SIGQUIT, LINUX_SIGILL,
149 LINUX_SIGTRAP, LINUX_SIGABRT, 0, LINUX_SIGFPE,
150 LINUX_SIGKILL, LINUX_SIGBUS, LINUX_SIGSEGV, LINUX_SIGSYS,
151 LINUX_SIGPIPE, LINUX_SIGALRM, LINUX_SIGTERM, LINUX_SIGURG,
152 LINUX_SIGSTOP, LINUX_SIGTSTP, LINUX_SIGCONT, LINUX_SIGCHLD,
153 LINUX_SIGTTIN, LINUX_SIGTTOU, LINUX_SIGIO, LINUX_SIGXCPU,
154 LINUX_SIGXFSZ, LINUX_SIGVTALRM, LINUX_SIGPROF, LINUX_SIGWINCH,
155 0, LINUX_SIGUSR1, LINUX_SIGUSR2
156};
157
158int linux_to_bsd_signal[LINUX_SIGTBLSZ] = {
159 SIGHUP, SIGINT, SIGQUIT, SIGILL,
160 SIGTRAP, SIGABRT, SIGBUS, SIGFPE,
161 SIGKILL, SIGUSR1, SIGSEGV, SIGUSR2,
162 SIGPIPE, SIGALRM, SIGTERM, SIGBUS,
163 SIGCHLD, SIGCONT, SIGSTOP, SIGTSTP,
164 SIGTTIN, SIGTTOU, SIGURG, SIGXCPU,
165 SIGXFSZ, SIGVTALRM, SIGPROF, SIGWINCH,
166 SIGIO, SIGURG, SIGSYS
167};
168
169#define LINUX_T_UNKNOWN 255
170static int _bsd_to_linux_trapcode[] = {
171 LINUX_T_UNKNOWN, /* 0 */
172 6, /* 1 T_PRIVINFLT */
173 LINUX_T_UNKNOWN, /* 2 */
174 3, /* 3 T_BPTFLT */
175 LINUX_T_UNKNOWN, /* 4 */
176 LINUX_T_UNKNOWN, /* 5 */
177 16, /* 6 T_ARITHTRAP */
178 254, /* 7 T_ASTFLT */
179 LINUX_T_UNKNOWN, /* 8 */
180 13, /* 9 T_PROTFLT */
181 1, /* 10 T_TRCTRAP */
182 LINUX_T_UNKNOWN, /* 11 */
183 14, /* 12 T_PAGEFLT */
184 LINUX_T_UNKNOWN, /* 13 */
185 17, /* 14 T_ALIGNFLT */
186 LINUX_T_UNKNOWN, /* 15 */
187 LINUX_T_UNKNOWN, /* 16 */
188 LINUX_T_UNKNOWN, /* 17 */
189 0, /* 18 T_DIVIDE */
190 2, /* 19 T_NMI */
191 4, /* 20 T_OFLOW */
192 5, /* 21 T_BOUND */
193 7, /* 22 T_DNA */
194 8, /* 23 T_DOUBLEFLT */
195 9, /* 24 T_FPOPFLT */
196 10, /* 25 T_TSSFLT */
197 11, /* 26 T_SEGNPFLT */
198 12, /* 27 T_STKFLT */
199 18, /* 28 T_MCHK */
200 19, /* 29 T_XMMFLT */
201 15 /* 30 T_RESERVED */
202};
203#define bsd_to_linux_trapcode(code) \
204 ((code)<sizeof(_bsd_to_linux_trapcode)/sizeof(*_bsd_to_linux_trapcode)? \
205 _bsd_to_linux_trapcode[(code)]: \
206 LINUX_T_UNKNOWN)
207
208LINUX_VDSO_SYM_INTPTR(linux_sigcode);
209LINUX_VDSO_SYM_INTPTR(linux_rt_sigcode);
210LINUX_VDSO_SYM_INTPTR(linux_vsyscall);
211
212/*
213 * If FreeBSD & Linux have a difference of opinion about what a trap
214 * means, deal with it here.
215 *
216 * MPSAFE
217 */
218static int
219translate_traps(int signal, int trap_code)
220{
221 if (signal != SIGBUS)
222 return (signal);
223 switch (trap_code) {
224 case T_PROTFLT:
225 case T_TSSFLT:
226 case T_DOUBLEFLT:
227 case T_PAGEFLT:
228 return (SIGSEGV);
229 default:
230 return (signal);
231 }
232}
233
234static int
235linux_fixup(register_t **stack_base, struct image_params *imgp)
236{
237 register_t *argv, *envp;
238
239 argv = *stack_base;
240 envp = *stack_base + (imgp->args->argc + 1);
241 (*stack_base)--;
242 suword(*stack_base, (intptr_t)(void *)envp);
243 (*stack_base)--;
244 suword(*stack_base, (intptr_t)(void *)argv);
245 (*stack_base)--;
246 suword(*stack_base, imgp->args->argc);
247 return (0);
248}
249
250static int
251elf_linux_fixup(register_t **stack_base, struct image_params *imgp)
252{
253 struct proc *p;
254 Elf32_Auxargs *args;
255 Elf32_Addr *uplatform;
256 struct ps_strings *arginfo;
257 register_t *pos;
258
259 KASSERT(curthread->td_proc == imgp->proc,
260 ("unsafe elf_linux_fixup(), should be curproc"));
261
262 p = imgp->proc;
263 arginfo = (struct ps_strings *)p->p_sysent->sv_psstrings;
264 uplatform = (Elf32_Addr *)((caddr_t)arginfo - linux_szplatform);
265 args = (Elf32_Auxargs *)imgp->auxargs;
266 pos = *stack_base + (imgp->args->argc + imgp->args->envc + 2);
267
268 AUXARGS_ENTRY(pos, LINUX_AT_SYSINFO_EHDR,
269 imgp->proc->p_sysent->sv_shared_page_base);
270 AUXARGS_ENTRY(pos, LINUX_AT_SYSINFO, linux_vsyscall);
271 AUXARGS_ENTRY(pos, LINUX_AT_HWCAP, cpu_feature);
272
273 /*
274 * Do not export AT_CLKTCK when emulating Linux kernel prior to 2.4.0,
275 * as it has appeared in the 2.4.0-rc7 first time.
276 * Being exported, AT_CLKTCK is returned by sysconf(_SC_CLK_TCK),
277 * glibc falls back to the hard-coded CLK_TCK value when aux entry
278 * is not present.
279 * Also see linux_times() implementation.
280 */
281 if (linux_kernver(curthread) >= LINUX_KERNVER_2004000)
282 AUXARGS_ENTRY(pos, LINUX_AT_CLKTCK, stclohz);
283 AUXARGS_ENTRY(pos, AT_PHDR, args->phdr);
284 AUXARGS_ENTRY(pos, AT_PHENT, args->phent);
285 AUXARGS_ENTRY(pos, AT_PHNUM, args->phnum);
286 AUXARGS_ENTRY(pos, AT_PAGESZ, args->pagesz);
287 AUXARGS_ENTRY(pos, AT_FLAGS, args->flags);
288 AUXARGS_ENTRY(pos, AT_ENTRY, args->entry);
289 AUXARGS_ENTRY(pos, AT_BASE, args->base);
290 AUXARGS_ENTRY(pos, LINUX_AT_SECURE, 0);
291 AUXARGS_ENTRY(pos, AT_UID, imgp->proc->p_ucred->cr_ruid);
292 AUXARGS_ENTRY(pos, AT_EUID, imgp->proc->p_ucred->cr_svuid);
293 AUXARGS_ENTRY(pos, AT_GID, imgp->proc->p_ucred->cr_rgid);
294 AUXARGS_ENTRY(pos, AT_EGID, imgp->proc->p_ucred->cr_svgid);
295 AUXARGS_ENTRY(pos, LINUX_AT_PLATFORM, PTROUT(uplatform));
296 if (args->execfd != -1)
297 AUXARGS_ENTRY(pos, AT_EXECFD, args->execfd);
298 AUXARGS_ENTRY(pos, AT_NULL, 0);
299
300 free(imgp->auxargs, M_TEMP);
301 imgp->auxargs = NULL;
302
303 (*stack_base)--;
304 suword(*stack_base, (register_t)imgp->args->argc);
305 return (0);
306}
307
308/*
309 * Copied from kern/kern_exec.c
310 */
311static register_t *
312linux_copyout_strings(struct image_params *imgp)
313{
314 int argc, envc;
315 char **vectp;
316 char *stringp, *destp;
317 register_t *stack_base;
318 struct ps_strings *arginfo;
319 struct proc *p;
320
321 /*
322 * Calculate string base and vector table pointers.
323 */
324 p = imgp->proc;
325 arginfo = (struct ps_strings *)p->p_sysent->sv_psstrings;
326 destp = (caddr_t)arginfo - SPARE_USRSPACE - linux_szplatform -
327 roundup((ARG_MAX - imgp->args->stringspace), sizeof(char *));
328
329 /*
330 * install LINUX_PLATFORM
331 */
332 copyout(linux_kplatform, ((caddr_t)arginfo - linux_szplatform),
333 linux_szplatform);
334
335 /*
336 * If we have a valid auxargs ptr, prepare some room
337 * on the stack.
338 */
339 if (imgp->auxargs) {
340 /*
341 * 'AT_COUNT*2' is size for the ELF Auxargs data. This is for
342 * lower compatibility.
343 */
344 imgp->auxarg_size = (imgp->auxarg_size) ? imgp->auxarg_size :
345 (LINUX_AT_COUNT * 2);
346 /*
347 * The '+ 2' is for the null pointers at the end of each of
348 * the arg and env vector sets,and imgp->auxarg_size is room
349 * for argument of Runtime loader.
350 */
351 vectp = (char **)(destp - (imgp->args->argc +
352 imgp->args->envc + 2 + imgp->auxarg_size) * sizeof(char *));
353 } else {
354 /*
355 * The '+ 2' is for the null pointers at the end of each of
356 * the arg and env vector sets
357 */
358 vectp = (char **)(destp - (imgp->args->argc + imgp->args->envc + 2) *
359 sizeof(char *));
360 }
361
362 /*
363 * vectp also becomes our initial stack base
364 */
365 stack_base = (register_t *)vectp;
366
367 stringp = imgp->args->begin_argv;
368 argc = imgp->args->argc;
369 envc = imgp->args->envc;
370
371 /*
372 * Copy out strings - arguments and environment.
373 */
374 copyout(stringp, destp, ARG_MAX - imgp->args->stringspace);
375
376 /*
377 * Fill in "ps_strings" struct for ps, w, etc.
378 */
379 suword(&arginfo->ps_argvstr, (long)(intptr_t)vectp);
380 suword(&arginfo->ps_nargvstr, argc);
381
382 /*
383 * Fill in argument portion of vector table.
384 */
385 for (; argc > 0; --argc) {
386 suword(vectp++, (long)(intptr_t)destp);
387 while (*stringp++ != 0)
388 destp++;
389 destp++;
390 }
391
392 /* a null vector table pointer separates the argp's from the envp's */
393 suword(vectp++, 0);
394
395 suword(&arginfo->ps_envstr, (long)(intptr_t)vectp);
396 suword(&arginfo->ps_nenvstr, envc);
397
398 /*
399 * Fill in environment portion of vector table.
400 */
401 for (; envc > 0; --envc) {
402 suword(vectp++, (long)(intptr_t)destp);
403 while (*stringp++ != 0)
404 destp++;
405 destp++;
406 }
407
408 /* end of vector table is a null pointer */
409 suword(vectp, 0);
410
411 return (stack_base);
412}
413
414static void
415linux_rt_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
416{
417 struct thread *td = curthread;
418 struct proc *p = td->td_proc;
419 struct sigacts *psp;
420 struct trapframe *regs;
421 struct l_rt_sigframe *fp, frame;
422 int sig, code;
423 int oonstack;
424
425 sig = ksi->ksi_signo;
426 code = ksi->ksi_code;
427 PROC_LOCK_ASSERT(p, MA_OWNED);
428 psp = p->p_sigacts;
429 mtx_assert(&psp->ps_mtx, MA_OWNED);
430 regs = td->td_frame;
431 oonstack = sigonstack(regs->tf_esp);
432
433#ifdef DEBUG
434 if (ldebug(rt_sendsig))
435 printf(ARGS(rt_sendsig, "%p, %d, %p, %u"),
436 catcher, sig, (void*)mask, code);
437#endif
438 /*
439 * Allocate space for the signal handler context.
440 */
441 if ((td->td_pflags & TDP_ALTSTACK) && !oonstack &&
442 SIGISMEMBER(psp->ps_sigonstack, sig)) {
443 fp = (struct l_rt_sigframe *)(td->td_sigstk.ss_sp +
444 td->td_sigstk.ss_size - sizeof(struct l_rt_sigframe));
445 } else
446 fp = (struct l_rt_sigframe *)regs->tf_esp - 1;
447 mtx_unlock(&psp->ps_mtx);
448
449 /*
450 * Build the argument list for the signal handler.
451 */
452 if (p->p_sysent->sv_sigtbl)
453 if (sig <= p->p_sysent->sv_sigsize)
454 sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
455
456 bzero(&frame, sizeof(frame));
457
458 frame.sf_handler = catcher;
459 frame.sf_sig = sig;
460 frame.sf_siginfo = &fp->sf_si;
461 frame.sf_ucontext = &fp->sf_sc;
462
463 /* Fill in POSIX parts */
464 ksiginfo_to_lsiginfo(ksi, &frame.sf_si, sig);
465
466 /*
467 * Build the signal context to be used by sigreturn.
468 */
469 frame.sf_sc.uc_flags = 0; /* XXX ??? */
470 frame.sf_sc.uc_link = NULL; /* XXX ??? */
471
472 frame.sf_sc.uc_stack.ss_sp = td->td_sigstk.ss_sp;
473 frame.sf_sc.uc_stack.ss_size = td->td_sigstk.ss_size;
474 frame.sf_sc.uc_stack.ss_flags = (td->td_pflags & TDP_ALTSTACK)
475 ? ((oonstack) ? LINUX_SS_ONSTACK : 0) : LINUX_SS_DISABLE;
476 PROC_UNLOCK(p);
477
478 bsd_to_linux_sigset(mask, &frame.sf_sc.uc_sigmask);
479
480 frame.sf_sc.uc_mcontext.sc_mask = frame.sf_sc.uc_sigmask.__bits[0];
481 frame.sf_sc.uc_mcontext.sc_gs = rgs();
482 frame.sf_sc.uc_mcontext.sc_fs = regs->tf_fs;
483 frame.sf_sc.uc_mcontext.sc_es = regs->tf_es;
484 frame.sf_sc.uc_mcontext.sc_ds = regs->tf_ds;
485 frame.sf_sc.uc_mcontext.sc_edi = regs->tf_edi;
486 frame.sf_sc.uc_mcontext.sc_esi = regs->tf_esi;
487 frame.sf_sc.uc_mcontext.sc_ebp = regs->tf_ebp;
488 frame.sf_sc.uc_mcontext.sc_ebx = regs->tf_ebx;
489 frame.sf_sc.uc_mcontext.sc_esp = regs->tf_esp;
490 frame.sf_sc.uc_mcontext.sc_edx = regs->tf_edx;
491 frame.sf_sc.uc_mcontext.sc_ecx = regs->tf_ecx;
492 frame.sf_sc.uc_mcontext.sc_eax = regs->tf_eax;
493 frame.sf_sc.uc_mcontext.sc_eip = regs->tf_eip;
494 frame.sf_sc.uc_mcontext.sc_cs = regs->tf_cs;
495 frame.sf_sc.uc_mcontext.sc_eflags = regs->tf_eflags;
496 frame.sf_sc.uc_mcontext.sc_esp_at_signal = regs->tf_esp;
497 frame.sf_sc.uc_mcontext.sc_ss = regs->tf_ss;
498 frame.sf_sc.uc_mcontext.sc_err = regs->tf_err;
499 frame.sf_sc.uc_mcontext.sc_cr2 = (register_t)ksi->ksi_addr;
500 frame.sf_sc.uc_mcontext.sc_trapno = bsd_to_linux_trapcode(code);
501
502#ifdef DEBUG
503 if (ldebug(rt_sendsig))
504 printf(LMSG("rt_sendsig flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
505 frame.sf_sc.uc_stack.ss_flags, td->td_sigstk.ss_sp,
506 td->td_sigstk.ss_size, frame.sf_sc.uc_mcontext.sc_mask);
507#endif
508
509 if (copyout(&frame, fp, sizeof(frame)) != 0) {
510 /*
511 * Process has trashed its stack; give it an illegal
512 * instruction to halt it in its tracks.
513 */
514#ifdef DEBUG
515 if (ldebug(rt_sendsig))
516 printf(LMSG("rt_sendsig: bad stack %p, oonstack=%x"),
517 fp, oonstack);
518#endif
519 PROC_LOCK(p);
520 sigexit(td, SIGILL);
521 }
522
523 /*
524 * Build context to run handler in.
525 */
526 regs->tf_esp = (int)fp;
527 regs->tf_eip = linux_rt_sigcode;
528 regs->tf_eflags &= ~(PSL_T | PSL_VM | PSL_D);
529 regs->tf_cs = _ucodesel;
530 regs->tf_ds = _udatasel;
531 regs->tf_es = _udatasel;
532 regs->tf_fs = _udatasel;
533 regs->tf_ss = _udatasel;
534 PROC_LOCK(p);
535 mtx_lock(&psp->ps_mtx);
536}
537
538
539/*
540 * Send an interrupt to process.
541 *
542 * Stack is set up to allow sigcode stored
543 * in u. to call routine, followed by kcall
544 * to sigreturn routine below. After sigreturn
545 * resets the signal mask, the stack, and the
546 * frame pointer, it returns to the user
547 * specified pc, psl.
548 */
549static void
550linux_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
551{
552 struct thread *td = curthread;
553 struct proc *p = td->td_proc;
554 struct sigacts *psp;
555 struct trapframe *regs;
556 struct l_sigframe *fp, frame;
557 l_sigset_t lmask;
558 int sig, code;
559 int oonstack, i;
560
561 PROC_LOCK_ASSERT(p, MA_OWNED);
562 psp = p->p_sigacts;
563 sig = ksi->ksi_signo;
564 code = ksi->ksi_code;
565 mtx_assert(&psp->ps_mtx, MA_OWNED);
566 if (SIGISMEMBER(psp->ps_siginfo, sig)) {
567 /* Signal handler installed with SA_SIGINFO. */
568 linux_rt_sendsig(catcher, ksi, mask);
569 return;
570 }
571 regs = td->td_frame;
572 oonstack = sigonstack(regs->tf_esp);
573
574#ifdef DEBUG
575 if (ldebug(sendsig))
576 printf(ARGS(sendsig, "%p, %d, %p, %u"),
577 catcher, sig, (void*)mask, code);
578#endif
579
580 /*
581 * Allocate space for the signal handler context.
582 */
583 if ((td->td_pflags & TDP_ALTSTACK) && !oonstack &&
584 SIGISMEMBER(psp->ps_sigonstack, sig)) {
585 fp = (struct l_sigframe *)(td->td_sigstk.ss_sp +
586 td->td_sigstk.ss_size - sizeof(struct l_sigframe));
587 } else
588 fp = (struct l_sigframe *)regs->tf_esp - 1;
589 mtx_unlock(&psp->ps_mtx);
590 PROC_UNLOCK(p);
591
592 /*
593 * Build the argument list for the signal handler.
594 */
595 if (p->p_sysent->sv_sigtbl)
596 if (sig <= p->p_sysent->sv_sigsize)
597 sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
598
599 bzero(&frame, sizeof(frame));
600
601 frame.sf_handler = catcher;
602 frame.sf_sig = sig;
603
604 bsd_to_linux_sigset(mask, &lmask);
605
606 /*
607 * Build the signal context to be used by sigreturn.
608 */
609 frame.sf_sc.sc_mask = lmask.__bits[0];
610 frame.sf_sc.sc_gs = rgs();
611 frame.sf_sc.sc_fs = regs->tf_fs;
612 frame.sf_sc.sc_es = regs->tf_es;
613 frame.sf_sc.sc_ds = regs->tf_ds;
614 frame.sf_sc.sc_edi = regs->tf_edi;
615 frame.sf_sc.sc_esi = regs->tf_esi;
616 frame.sf_sc.sc_ebp = regs->tf_ebp;
617 frame.sf_sc.sc_ebx = regs->tf_ebx;
618 frame.sf_sc.sc_esp = regs->tf_esp;
619 frame.sf_sc.sc_edx = regs->tf_edx;
620 frame.sf_sc.sc_ecx = regs->tf_ecx;
621 frame.sf_sc.sc_eax = regs->tf_eax;
622 frame.sf_sc.sc_eip = regs->tf_eip;
623 frame.sf_sc.sc_cs = regs->tf_cs;
624 frame.sf_sc.sc_eflags = regs->tf_eflags;
625 frame.sf_sc.sc_esp_at_signal = regs->tf_esp;
626 frame.sf_sc.sc_ss = regs->tf_ss;
627 frame.sf_sc.sc_err = regs->tf_err;
628 frame.sf_sc.sc_cr2 = (register_t)ksi->ksi_addr;
629 frame.sf_sc.sc_trapno = bsd_to_linux_trapcode(ksi->ksi_trapno);
630
631 for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
632 frame.sf_extramask[i] = lmask.__bits[i+1];
633
634 if (copyout(&frame, fp, sizeof(frame)) != 0) {
635 /*
636 * Process has trashed its stack; give it an illegal
637 * instruction to halt it in its tracks.
638 */
639 PROC_LOCK(p);
640 sigexit(td, SIGILL);
641 }
642
643 /*
644 * Build context to run handler in.
645 */
646 regs->tf_esp = (int)fp;
647 regs->tf_eip = linux_sigcode;
648 regs->tf_eflags &= ~(PSL_T | PSL_VM | PSL_D);
649 regs->tf_cs = _ucodesel;
650 regs->tf_ds = _udatasel;
651 regs->tf_es = _udatasel;
652 regs->tf_fs = _udatasel;
653 regs->tf_ss = _udatasel;
654 PROC_LOCK(p);
655 mtx_lock(&psp->ps_mtx);
656}
657
658/*
659 * System call to cleanup state after a signal
660 * has been taken. Reset signal mask and
661 * stack state from context left by sendsig (above).
662 * Return to previous pc and psl as specified by
663 * context left by sendsig. Check carefully to
664 * make sure that the user has not modified the
665 * psl to gain improper privileges or to cause
666 * a machine fault.
667 */
668int
669linux_sigreturn(struct thread *td, struct linux_sigreturn_args *args)
670{
671 struct l_sigframe frame;
672 struct trapframe *regs;
673 l_sigset_t lmask;
674 sigset_t bmask;
675 int eflags, i;
676 ksiginfo_t ksi;
677
678 regs = td->td_frame;
679
680#ifdef DEBUG
681 if (ldebug(sigreturn))
682 printf(ARGS(sigreturn, "%p"), (void *)args->sfp);
683#endif
684 /*
685 * The trampoline code hands us the sigframe.
686 * It is unsafe to keep track of it ourselves, in the event that a
687 * program jumps out of a signal handler.
688 */
689 if (copyin(args->sfp, &frame, sizeof(frame)) != 0)
690 return (EFAULT);
691
692 /*
693 * Check for security violations.
694 */
695#define EFLAGS_SECURE(ef, oef) ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
696 eflags = frame.sf_sc.sc_eflags;
697 if (!EFLAGS_SECURE(eflags, regs->tf_eflags))
698 return (EINVAL);
699
700 /*
701 * Don't allow users to load a valid privileged %cs. Let the
702 * hardware check for invalid selectors, excess privilege in
703 * other selectors, invalid %eip's and invalid %esp's.
704 */
705#define CS_SECURE(cs) (ISPL(cs) == SEL_UPL)
706 if (!CS_SECURE(frame.sf_sc.sc_cs)) {
707 ksiginfo_init_trap(&ksi);
708 ksi.ksi_signo = SIGBUS;
709 ksi.ksi_code = BUS_OBJERR;
710 ksi.ksi_trapno = T_PROTFLT;
711 ksi.ksi_addr = (void *)regs->tf_eip;
712 trapsignal(td, &ksi);
713 return (EINVAL);
714 }
715
716 lmask.__bits[0] = frame.sf_sc.sc_mask;
717 for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
718 lmask.__bits[i+1] = frame.sf_extramask[i];
719 linux_to_bsd_sigset(&lmask, &bmask);
720 kern_sigprocmask(td, SIG_SETMASK, &bmask, NULL, 0);
721
722 /*
723 * Restore signal context.
724 */
725 /* %gs was restored by the trampoline. */
726 regs->tf_fs = frame.sf_sc.sc_fs;
727 regs->tf_es = frame.sf_sc.sc_es;
728 regs->tf_ds = frame.sf_sc.sc_ds;
729 regs->tf_edi = frame.sf_sc.sc_edi;
730 regs->tf_esi = frame.sf_sc.sc_esi;
731 regs->tf_ebp = frame.sf_sc.sc_ebp;
732 regs->tf_ebx = frame.sf_sc.sc_ebx;
733 regs->tf_edx = frame.sf_sc.sc_edx;
734 regs->tf_ecx = frame.sf_sc.sc_ecx;
735 regs->tf_eax = frame.sf_sc.sc_eax;
736 regs->tf_eip = frame.sf_sc.sc_eip;
737 regs->tf_cs = frame.sf_sc.sc_cs;
738 regs->tf_eflags = eflags;
739 regs->tf_esp = frame.sf_sc.sc_esp_at_signal;
740 regs->tf_ss = frame.sf_sc.sc_ss;
741
742 return (EJUSTRETURN);
743}
744
745/*
746 * System call to cleanup state after a signal
747 * has been taken. Reset signal mask and
748 * stack state from context left by rt_sendsig (above).
749 * Return to previous pc and psl as specified by
750 * context left by sendsig. Check carefully to
751 * make sure that the user has not modified the
752 * psl to gain improper privileges or to cause
753 * a machine fault.
754 */
755int
756linux_rt_sigreturn(struct thread *td, struct linux_rt_sigreturn_args *args)
757{
758 struct l_ucontext uc;
759 struct l_sigcontext *context;
760 sigset_t bmask;
761 l_stack_t *lss;
762 stack_t ss;
763 struct trapframe *regs;
764 int eflags;
765 ksiginfo_t ksi;
766
767 regs = td->td_frame;
768
769#ifdef DEBUG
770 if (ldebug(rt_sigreturn))
771 printf(ARGS(rt_sigreturn, "%p"), (void *)args->ucp);
772#endif
773 /*
774 * The trampoline code hands us the ucontext.
775 * It is unsafe to keep track of it ourselves, in the event that a
776 * program jumps out of a signal handler.
777 */
778 if (copyin(args->ucp, &uc, sizeof(uc)) != 0)
779 return (EFAULT);
780
781 context = &uc.uc_mcontext;
782
783 /*
784 * Check for security violations.
785 */
786#define EFLAGS_SECURE(ef, oef) ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
787 eflags = context->sc_eflags;
788 if (!EFLAGS_SECURE(eflags, regs->tf_eflags))
789 return (EINVAL);
790
791 /*
792 * Don't allow users to load a valid privileged %cs. Let the
793 * hardware check for invalid selectors, excess privilege in
794 * other selectors, invalid %eip's and invalid %esp's.
795 */
796#define CS_SECURE(cs) (ISPL(cs) == SEL_UPL)
797 if (!CS_SECURE(context->sc_cs)) {
798 ksiginfo_init_trap(&ksi);
799 ksi.ksi_signo = SIGBUS;
800 ksi.ksi_code = BUS_OBJERR;
801 ksi.ksi_trapno = T_PROTFLT;
802 ksi.ksi_addr = (void *)regs->tf_eip;
803 trapsignal(td, &ksi);
804 return (EINVAL);
805 }
806
807 linux_to_bsd_sigset(&uc.uc_sigmask, &bmask);
808 kern_sigprocmask(td, SIG_SETMASK, &bmask, NULL, 0);
809
810 /*
811 * Restore signal context
812 */
813 /* %gs was restored by the trampoline. */
814 regs->tf_fs = context->sc_fs;
815 regs->tf_es = context->sc_es;
816 regs->tf_ds = context->sc_ds;
817 regs->tf_edi = context->sc_edi;
818 regs->tf_esi = context->sc_esi;
819 regs->tf_ebp = context->sc_ebp;
820 regs->tf_ebx = context->sc_ebx;
821 regs->tf_edx = context->sc_edx;
822 regs->tf_ecx = context->sc_ecx;
823 regs->tf_eax = context->sc_eax;
824 regs->tf_eip = context->sc_eip;
825 regs->tf_cs = context->sc_cs;
826 regs->tf_eflags = eflags;
827 regs->tf_esp = context->sc_esp_at_signal;
828 regs->tf_ss = context->sc_ss;
829
830 /*
831 * call sigaltstack & ignore results..
832 */
833 lss = &uc.uc_stack;
834 ss.ss_sp = lss->ss_sp;
835 ss.ss_size = lss->ss_size;
836 ss.ss_flags = linux_to_bsd_sigaltstack(lss->ss_flags);
837
838#ifdef DEBUG
839 if (ldebug(rt_sigreturn))
840 printf(LMSG("rt_sigret flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
841 ss.ss_flags, ss.ss_sp, ss.ss_size, context->sc_mask);
842#endif
843 (void)kern_sigaltstack(td, &ss, NULL);
844
845 return (EJUSTRETURN);
846}
847
848static int
849linux_fetch_syscall_args(struct thread *td, struct syscall_args *sa)
850{
851 struct proc *p;
852 struct trapframe *frame;
853
854 p = td->td_proc;
855 frame = td->td_frame;
856
857 sa->code = frame->tf_eax;
858 sa->args[0] = frame->tf_ebx;
859 sa->args[1] = frame->tf_ecx;
860 sa->args[2] = frame->tf_edx;
861 sa->args[3] = frame->tf_esi;
862 sa->args[4] = frame->tf_edi;
863 sa->args[5] = frame->tf_ebp; /* Unconfirmed */
864
865 if (sa->code >= p->p_sysent->sv_size)
866 sa->callp = &p->p_sysent->sv_table[0];
867 else
868 sa->callp = &p->p_sysent->sv_table[sa->code];
869 sa->narg = sa->callp->sy_narg;
870
871 td->td_retval[0] = 0;
872 td->td_retval[1] = frame->tf_edx;
873
874 return (0);
875}
876
877/*
878 * If a linux binary is exec'ing something, try this image activator
879 * first. We override standard shell script execution in order to
880 * be able to modify the interpreter path. We only do this if a linux
881 * binary is doing the exec, so we do not create an EXEC module for it.
882 */
883static int exec_linux_imgact_try(struct image_params *iparams);
884
885static int
886exec_linux_imgact_try(struct image_params *imgp)
887{
888 const char *head = (const char *)imgp->image_header;
889 char *rpath;
890 int error = -1;
891
892 /*
893 * The interpreter for shell scripts run from a linux binary needs
894 * to be located in /compat/linux if possible in order to recursively
895 * maintain linux path emulation.
896 */
897 if (((const short *)head)[0] == SHELLMAGIC) {
898 /*
899 * Run our normal shell image activator. If it succeeds attempt
900 * to use the alternate path for the interpreter. If an alternate
901 * path is found, use our stringspace to store it.
902 */
903 if ((error = exec_shell_imgact(imgp)) == 0) {
904 linux_emul_convpath(FIRST_THREAD_IN_PROC(imgp->proc),
905 imgp->interpreter_name, UIO_SYSSPACE, &rpath, 0, AT_FDCWD);
906 if (rpath != NULL)
907 imgp->args->fname_buf =
908 imgp->interpreter_name = rpath;
909 }
910 }
911 return (error);
912}
913
914/*
915 * exec_setregs may initialize some registers differently than Linux
916 * does, thus potentially confusing Linux binaries. If necessary, we
917 * override the exec_setregs default(s) here.
918 */
919static void
920exec_linux_setregs(struct thread *td, struct image_params *imgp, u_long stack)
921{
922 struct pcb *pcb = td->td_pcb;
923
924 exec_setregs(td, imgp, stack);
925
926 /* Linux sets %gs to 0, we default to _udatasel */
927 pcb->pcb_gs = 0;
928 load_gs(0);
929
930 pcb->pcb_initial_npxcw = __LINUX_NPXCW__;
931}
932
933static void
934linux_get_machine(const char **dst)
935{
936
937 switch (cpu_class) {
938 case CPUCLASS_686:
939 *dst = "i686";
940 break;
941 case CPUCLASS_586:
942 *dst = "i586";
943 break;
944 case CPUCLASS_486:
945 *dst = "i486";
946 break;
947 default:
948 *dst = "i386";
949 }
950}
951
952struct sysentvec linux_sysvec = {
953 .sv_size = LINUX_SYS_MAXSYSCALL,
954 .sv_table = linux_sysent,
955 .sv_mask = 0,
956 .sv_sigsize = LINUX_SIGTBLSZ,
957 .sv_sigtbl = bsd_to_linux_signal,
958 .sv_errsize = ELAST + 1,
959 .sv_errtbl = bsd_to_linux_errno,
960 .sv_transtrap = translate_traps,
961 .sv_fixup = linux_fixup,
962 .sv_sendsig = linux_sendsig,
963 .sv_sigcode = &_binary_linux_locore_o_start,
964 .sv_szsigcode = &linux_szsigcode,
965 .sv_prepsyscall = NULL,
966 .sv_name = "Linux a.out",
967 .sv_coredump = NULL,
968 .sv_imgact_try = exec_linux_imgact_try,
969 .sv_minsigstksz = LINUX_MINSIGSTKSZ,
970 .sv_pagesize = PAGE_SIZE,
971 .sv_minuser = VM_MIN_ADDRESS,
972 .sv_maxuser = VM_MAXUSER_ADDRESS,
973 .sv_usrstack = LINUX_USRSTACK,
974 .sv_psstrings = PS_STRINGS,
975 .sv_stackprot = VM_PROT_ALL,
976 .sv_copyout_strings = exec_copyout_strings,
977 .sv_setregs = exec_linux_setregs,
978 .sv_fixlimit = NULL,
979 .sv_maxssiz = NULL,
980 .sv_flags = SV_ABI_LINUX | SV_AOUT | SV_IA32 | SV_ILP32,
981 .sv_set_syscall_retval = cpu_set_syscall_retval,
982 .sv_fetch_syscall_args = linux_fetch_syscall_args,
983 .sv_syscallnames = NULL,
984 .sv_shared_page_base = LINUX_SHAREDPAGE,
985 .sv_shared_page_len = PAGE_SIZE,
986 .sv_schedtail = linux_schedtail,
987 .sv_thread_detach = linux_thread_detach,
988};
989INIT_SYSENTVEC(aout_sysvec, &linux_sysvec);
990
991struct sysentvec elf_linux_sysvec = {
992 .sv_size = LINUX_SYS_MAXSYSCALL,
993 .sv_table = linux_sysent,
994 .sv_mask = 0,
995 .sv_sigsize = LINUX_SIGTBLSZ,
996 .sv_sigtbl = bsd_to_linux_signal,
997 .sv_errsize = ELAST + 1,
998 .sv_errtbl = bsd_to_linux_errno,
999 .sv_transtrap = translate_traps,
1000 .sv_fixup = elf_linux_fixup,
1001 .sv_sendsig = linux_sendsig,
1002 .sv_sigcode = &_binary_linux_locore_o_start,
1003 .sv_szsigcode = &linux_szsigcode,
1004 .sv_prepsyscall = NULL,
1005 .sv_name = "Linux ELF",
1006 .sv_coredump = elf32_coredump,
1007 .sv_imgact_try = exec_linux_imgact_try,
1008 .sv_minsigstksz = LINUX_MINSIGSTKSZ,
1009 .sv_pagesize = PAGE_SIZE,
1010 .sv_minuser = VM_MIN_ADDRESS,
1011 .sv_maxuser = VM_MAXUSER_ADDRESS,
1012 .sv_usrstack = LINUX_USRSTACK,
1013 .sv_psstrings = LINUX_PS_STRINGS,
1014 .sv_stackprot = VM_PROT_ALL,
1015 .sv_copyout_strings = linux_copyout_strings,
1016 .sv_setregs = exec_linux_setregs,
1017 .sv_fixlimit = NULL,
1018 .sv_maxssiz = NULL,
1019 .sv_flags = SV_ABI_LINUX | SV_IA32 | SV_ILP32 | SV_SHP,
1020 .sv_set_syscall_retval = cpu_set_syscall_retval,
1021 .sv_fetch_syscall_args = linux_fetch_syscall_args,
1022 .sv_syscallnames = NULL,
1023 .sv_shared_page_base = LINUX_SHAREDPAGE,
1024 .sv_shared_page_len = PAGE_SIZE,
1025 .sv_schedtail = linux_schedtail,
1026 .sv_thread_detach = linux_thread_detach,
1027};
1028
1029static void
1030linux_vdso_install(void *param)
1031{
1032
1033 linux_szsigcode = (&_binary_linux_locore_o_end -
1034 &_binary_linux_locore_o_start);
1035
1036 if (linux_szsigcode > elf_linux_sysvec.sv_shared_page_len)
1037 panic("Linux invalid vdso size\n");
1038
1039 __elfN(linux_vdso_fixup)(&elf_linux_sysvec);
1040
1041 linux_shared_page_obj = __elfN(linux_shared_page_init)
1042 (&linux_shared_page_mapping);
1043
1044 __elfN(linux_vdso_reloc)(&elf_linux_sysvec, LINUX_SHAREDPAGE);
1045
1046 bcopy(elf_linux_sysvec.sv_sigcode, linux_shared_page_mapping,
1047 linux_szsigcode);
1048 elf_linux_sysvec.sv_shared_page_obj = linux_shared_page_obj;
1049}
1050SYSINIT(elf_linux_vdso_init, SI_SUB_EXEC, SI_ORDER_ANY,
1051 (sysinit_cfunc_t)linux_vdso_install, NULL);
1052
1053static void
1054linux_vdso_deinstall(void *param)
1055{
1056
1057 __elfN(linux_shared_page_fini)(linux_shared_page_obj);
1058};
1059SYSUNINIT(elf_linux_vdso_uninit, SI_SUB_EXEC, SI_ORDER_FIRST,
1060 (sysinit_cfunc_t)linux_vdso_deinstall, NULL);
1061
1062static char GNU_ABI_VENDOR[] = "GNU";
1063static int GNULINUX_ABI_DESC = 0;
1064
1065static boolean_t
1066linux_trans_osrel(const Elf_Note *note, int32_t *osrel)
1067{
1068 const Elf32_Word *desc;
1069 uintptr_t p;
1070
1071 p = (uintptr_t)(note + 1);
1072 p += roundup2(note->n_namesz, sizeof(Elf32_Addr));
1073
1074 desc = (const Elf32_Word *)p;
1075 if (desc[0] != GNULINUX_ABI_DESC)
1076 return (FALSE);
1077
1078 /*
1079 * For linux we encode osrel as follows (see linux_mib.c):
1080 * VVVMMMIII (version, major, minor), see linux_mib.c.
1081 */
1082 *osrel = desc[1] * 1000000 + desc[2] * 1000 + desc[3];
1083
1084 return (TRUE);
1085}
1086
1087static Elf_Brandnote linux_brandnote = {
1088 .hdr.n_namesz = sizeof(GNU_ABI_VENDOR),
1089 .hdr.n_descsz = 16, /* XXX at least 16 */
1090 .hdr.n_type = 1,
1091 .vendor = GNU_ABI_VENDOR,
1092 .flags = BN_TRANSLATE_OSREL,
1093 .trans_osrel = linux_trans_osrel
1094};
1095
1096static Elf32_Brandinfo linux_brand = {
1097 .brand = ELFOSABI_LINUX,
1098 .machine = EM_386,
1099 .compat_3_brand = "Linux",
1100 .emul_path = "/compat/linux",
1101 .interp_path = "/lib/ld-linux.so.1",
1102 .sysvec = &elf_linux_sysvec,
1103 .interp_newpath = NULL,
1104 .brand_note = &linux_brandnote,
1105 .flags = BI_CAN_EXEC_DYN | BI_BRAND_NOTE
1106};
1107
1108static Elf32_Brandinfo linux_glibc2brand = {
1109 .brand = ELFOSABI_LINUX,
1110 .machine = EM_386,
1111 .compat_3_brand = "Linux",
1112 .emul_path = "/compat/linux",
1113 .interp_path = "/lib/ld-linux.so.2",
1114 .sysvec = &elf_linux_sysvec,
1115 .interp_newpath = NULL,
1116 .brand_note = &linux_brandnote,
1117 .flags = BI_CAN_EXEC_DYN | BI_BRAND_NOTE
1118};
1119
1120Elf32_Brandinfo *linux_brandlist[] = {
1121 &linux_brand,
1122 &linux_glibc2brand,
1123 NULL
1124};
1125
1126static int
1127linux_elf_modevent(module_t mod, int type, void *data)
1128{
1129 Elf32_Brandinfo **brandinfo;
1130 int error;
1131 struct linux_ioctl_handler **lihp;
| 112
113static int linux_fixup(register_t **stack_base,
114 struct image_params *iparams);
115static int elf_linux_fixup(register_t **stack_base,
116 struct image_params *iparams);
117static void linux_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask);
118static void exec_linux_setregs(struct thread *td,
119 struct image_params *imgp, u_long stack);
120static register_t *linux_copyout_strings(struct image_params *imgp);
121static boolean_t linux_trans_osrel(const Elf_Note *note, int32_t *osrel);
122static void linux_vdso_install(void *param);
123static void linux_vdso_deinstall(void *param);
124
125static int linux_szplatform;
126const char *linux_kplatform;
127
128static eventhandler_tag linux_exit_tag;
129static eventhandler_tag linux_exec_tag;
130static eventhandler_tag linux_thread_dtor_tag;
131
132/*
133 * Linux syscalls return negative errno's, we do positive and map them
134 * Reference:
135 * FreeBSD: src/sys/sys/errno.h
136 * Linux: linux-2.6.17.8/include/asm-generic/errno-base.h
137 * linux-2.6.17.8/include/asm-generic/errno.h
138 */
139static int bsd_to_linux_errno[ELAST + 1] = {
140 -0, -1, -2, -3, -4, -5, -6, -7, -8, -9,
141 -10, -35, -12, -13, -14, -15, -16, -17, -18, -19,
142 -20, -21, -22, -23, -24, -25, -26, -27, -28, -29,
143 -30, -31, -32, -33, -34, -11,-115,-114, -88, -89,
144 -90, -91, -92, -93, -94, -95, -96, -97, -98, -99,
145 -100,-101,-102,-103,-104,-105,-106,-107,-108,-109,
146 -110,-111, -40, -36,-112,-113, -39, -11, -87,-122,
147 -116, -66, -6, -6, -6, -6, -6, -37, -38, -9,
148 -6, -6, -43, -42, -75,-125, -84, -95, -16, -74,
149 -72, -67, -71
150};
151
152int bsd_to_linux_signal[LINUX_SIGTBLSZ] = {
153 LINUX_SIGHUP, LINUX_SIGINT, LINUX_SIGQUIT, LINUX_SIGILL,
154 LINUX_SIGTRAP, LINUX_SIGABRT, 0, LINUX_SIGFPE,
155 LINUX_SIGKILL, LINUX_SIGBUS, LINUX_SIGSEGV, LINUX_SIGSYS,
156 LINUX_SIGPIPE, LINUX_SIGALRM, LINUX_SIGTERM, LINUX_SIGURG,
157 LINUX_SIGSTOP, LINUX_SIGTSTP, LINUX_SIGCONT, LINUX_SIGCHLD,
158 LINUX_SIGTTIN, LINUX_SIGTTOU, LINUX_SIGIO, LINUX_SIGXCPU,
159 LINUX_SIGXFSZ, LINUX_SIGVTALRM, LINUX_SIGPROF, LINUX_SIGWINCH,
160 0, LINUX_SIGUSR1, LINUX_SIGUSR2
161};
162
163int linux_to_bsd_signal[LINUX_SIGTBLSZ] = {
164 SIGHUP, SIGINT, SIGQUIT, SIGILL,
165 SIGTRAP, SIGABRT, SIGBUS, SIGFPE,
166 SIGKILL, SIGUSR1, SIGSEGV, SIGUSR2,
167 SIGPIPE, SIGALRM, SIGTERM, SIGBUS,
168 SIGCHLD, SIGCONT, SIGSTOP, SIGTSTP,
169 SIGTTIN, SIGTTOU, SIGURG, SIGXCPU,
170 SIGXFSZ, SIGVTALRM, SIGPROF, SIGWINCH,
171 SIGIO, SIGURG, SIGSYS
172};
173
174#define LINUX_T_UNKNOWN 255
175static int _bsd_to_linux_trapcode[] = {
176 LINUX_T_UNKNOWN, /* 0 */
177 6, /* 1 T_PRIVINFLT */
178 LINUX_T_UNKNOWN, /* 2 */
179 3, /* 3 T_BPTFLT */
180 LINUX_T_UNKNOWN, /* 4 */
181 LINUX_T_UNKNOWN, /* 5 */
182 16, /* 6 T_ARITHTRAP */
183 254, /* 7 T_ASTFLT */
184 LINUX_T_UNKNOWN, /* 8 */
185 13, /* 9 T_PROTFLT */
186 1, /* 10 T_TRCTRAP */
187 LINUX_T_UNKNOWN, /* 11 */
188 14, /* 12 T_PAGEFLT */
189 LINUX_T_UNKNOWN, /* 13 */
190 17, /* 14 T_ALIGNFLT */
191 LINUX_T_UNKNOWN, /* 15 */
192 LINUX_T_UNKNOWN, /* 16 */
193 LINUX_T_UNKNOWN, /* 17 */
194 0, /* 18 T_DIVIDE */
195 2, /* 19 T_NMI */
196 4, /* 20 T_OFLOW */
197 5, /* 21 T_BOUND */
198 7, /* 22 T_DNA */
199 8, /* 23 T_DOUBLEFLT */
200 9, /* 24 T_FPOPFLT */
201 10, /* 25 T_TSSFLT */
202 11, /* 26 T_SEGNPFLT */
203 12, /* 27 T_STKFLT */
204 18, /* 28 T_MCHK */
205 19, /* 29 T_XMMFLT */
206 15 /* 30 T_RESERVED */
207};
208#define bsd_to_linux_trapcode(code) \
209 ((code)<sizeof(_bsd_to_linux_trapcode)/sizeof(*_bsd_to_linux_trapcode)? \
210 _bsd_to_linux_trapcode[(code)]: \
211 LINUX_T_UNKNOWN)
212
213LINUX_VDSO_SYM_INTPTR(linux_sigcode);
214LINUX_VDSO_SYM_INTPTR(linux_rt_sigcode);
215LINUX_VDSO_SYM_INTPTR(linux_vsyscall);
216
217/*
218 * If FreeBSD & Linux have a difference of opinion about what a trap
219 * means, deal with it here.
220 *
221 * MPSAFE
222 */
223static int
224translate_traps(int signal, int trap_code)
225{
226 if (signal != SIGBUS)
227 return (signal);
228 switch (trap_code) {
229 case T_PROTFLT:
230 case T_TSSFLT:
231 case T_DOUBLEFLT:
232 case T_PAGEFLT:
233 return (SIGSEGV);
234 default:
235 return (signal);
236 }
237}
238
239static int
240linux_fixup(register_t **stack_base, struct image_params *imgp)
241{
242 register_t *argv, *envp;
243
244 argv = *stack_base;
245 envp = *stack_base + (imgp->args->argc + 1);
246 (*stack_base)--;
247 suword(*stack_base, (intptr_t)(void *)envp);
248 (*stack_base)--;
249 suword(*stack_base, (intptr_t)(void *)argv);
250 (*stack_base)--;
251 suword(*stack_base, imgp->args->argc);
252 return (0);
253}
254
255static int
256elf_linux_fixup(register_t **stack_base, struct image_params *imgp)
257{
258 struct proc *p;
259 Elf32_Auxargs *args;
260 Elf32_Addr *uplatform;
261 struct ps_strings *arginfo;
262 register_t *pos;
263
264 KASSERT(curthread->td_proc == imgp->proc,
265 ("unsafe elf_linux_fixup(), should be curproc"));
266
267 p = imgp->proc;
268 arginfo = (struct ps_strings *)p->p_sysent->sv_psstrings;
269 uplatform = (Elf32_Addr *)((caddr_t)arginfo - linux_szplatform);
270 args = (Elf32_Auxargs *)imgp->auxargs;
271 pos = *stack_base + (imgp->args->argc + imgp->args->envc + 2);
272
273 AUXARGS_ENTRY(pos, LINUX_AT_SYSINFO_EHDR,
274 imgp->proc->p_sysent->sv_shared_page_base);
275 AUXARGS_ENTRY(pos, LINUX_AT_SYSINFO, linux_vsyscall);
276 AUXARGS_ENTRY(pos, LINUX_AT_HWCAP, cpu_feature);
277
278 /*
279 * Do not export AT_CLKTCK when emulating Linux kernel prior to 2.4.0,
280 * as it has appeared in the 2.4.0-rc7 first time.
281 * Being exported, AT_CLKTCK is returned by sysconf(_SC_CLK_TCK),
282 * glibc falls back to the hard-coded CLK_TCK value when aux entry
283 * is not present.
284 * Also see linux_times() implementation.
285 */
286 if (linux_kernver(curthread) >= LINUX_KERNVER_2004000)
287 AUXARGS_ENTRY(pos, LINUX_AT_CLKTCK, stclohz);
288 AUXARGS_ENTRY(pos, AT_PHDR, args->phdr);
289 AUXARGS_ENTRY(pos, AT_PHENT, args->phent);
290 AUXARGS_ENTRY(pos, AT_PHNUM, args->phnum);
291 AUXARGS_ENTRY(pos, AT_PAGESZ, args->pagesz);
292 AUXARGS_ENTRY(pos, AT_FLAGS, args->flags);
293 AUXARGS_ENTRY(pos, AT_ENTRY, args->entry);
294 AUXARGS_ENTRY(pos, AT_BASE, args->base);
295 AUXARGS_ENTRY(pos, LINUX_AT_SECURE, 0);
296 AUXARGS_ENTRY(pos, AT_UID, imgp->proc->p_ucred->cr_ruid);
297 AUXARGS_ENTRY(pos, AT_EUID, imgp->proc->p_ucred->cr_svuid);
298 AUXARGS_ENTRY(pos, AT_GID, imgp->proc->p_ucred->cr_rgid);
299 AUXARGS_ENTRY(pos, AT_EGID, imgp->proc->p_ucred->cr_svgid);
300 AUXARGS_ENTRY(pos, LINUX_AT_PLATFORM, PTROUT(uplatform));
301 if (args->execfd != -1)
302 AUXARGS_ENTRY(pos, AT_EXECFD, args->execfd);
303 AUXARGS_ENTRY(pos, AT_NULL, 0);
304
305 free(imgp->auxargs, M_TEMP);
306 imgp->auxargs = NULL;
307
308 (*stack_base)--;
309 suword(*stack_base, (register_t)imgp->args->argc);
310 return (0);
311}
312
313/*
314 * Copied from kern/kern_exec.c
315 */
316static register_t *
317linux_copyout_strings(struct image_params *imgp)
318{
319 int argc, envc;
320 char **vectp;
321 char *stringp, *destp;
322 register_t *stack_base;
323 struct ps_strings *arginfo;
324 struct proc *p;
325
326 /*
327 * Calculate string base and vector table pointers.
328 */
329 p = imgp->proc;
330 arginfo = (struct ps_strings *)p->p_sysent->sv_psstrings;
331 destp = (caddr_t)arginfo - SPARE_USRSPACE - linux_szplatform -
332 roundup((ARG_MAX - imgp->args->stringspace), sizeof(char *));
333
334 /*
335 * install LINUX_PLATFORM
336 */
337 copyout(linux_kplatform, ((caddr_t)arginfo - linux_szplatform),
338 linux_szplatform);
339
340 /*
341 * If we have a valid auxargs ptr, prepare some room
342 * on the stack.
343 */
344 if (imgp->auxargs) {
345 /*
346 * 'AT_COUNT*2' is size for the ELF Auxargs data. This is for
347 * lower compatibility.
348 */
349 imgp->auxarg_size = (imgp->auxarg_size) ? imgp->auxarg_size :
350 (LINUX_AT_COUNT * 2);
351 /*
352 * The '+ 2' is for the null pointers at the end of each of
353 * the arg and env vector sets,and imgp->auxarg_size is room
354 * for argument of Runtime loader.
355 */
356 vectp = (char **)(destp - (imgp->args->argc +
357 imgp->args->envc + 2 + imgp->auxarg_size) * sizeof(char *));
358 } else {
359 /*
360 * The '+ 2' is for the null pointers at the end of each of
361 * the arg and env vector sets
362 */
363 vectp = (char **)(destp - (imgp->args->argc + imgp->args->envc + 2) *
364 sizeof(char *));
365 }
366
367 /*
368 * vectp also becomes our initial stack base
369 */
370 stack_base = (register_t *)vectp;
371
372 stringp = imgp->args->begin_argv;
373 argc = imgp->args->argc;
374 envc = imgp->args->envc;
375
376 /*
377 * Copy out strings - arguments and environment.
378 */
379 copyout(stringp, destp, ARG_MAX - imgp->args->stringspace);
380
381 /*
382 * Fill in "ps_strings" struct for ps, w, etc.
383 */
384 suword(&arginfo->ps_argvstr, (long)(intptr_t)vectp);
385 suword(&arginfo->ps_nargvstr, argc);
386
387 /*
388 * Fill in argument portion of vector table.
389 */
390 for (; argc > 0; --argc) {
391 suword(vectp++, (long)(intptr_t)destp);
392 while (*stringp++ != 0)
393 destp++;
394 destp++;
395 }
396
397 /* a null vector table pointer separates the argp's from the envp's */
398 suword(vectp++, 0);
399
400 suword(&arginfo->ps_envstr, (long)(intptr_t)vectp);
401 suword(&arginfo->ps_nenvstr, envc);
402
403 /*
404 * Fill in environment portion of vector table.
405 */
406 for (; envc > 0; --envc) {
407 suword(vectp++, (long)(intptr_t)destp);
408 while (*stringp++ != 0)
409 destp++;
410 destp++;
411 }
412
413 /* end of vector table is a null pointer */
414 suword(vectp, 0);
415
416 return (stack_base);
417}
418
419static void
420linux_rt_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
421{
422 struct thread *td = curthread;
423 struct proc *p = td->td_proc;
424 struct sigacts *psp;
425 struct trapframe *regs;
426 struct l_rt_sigframe *fp, frame;
427 int sig, code;
428 int oonstack;
429
430 sig = ksi->ksi_signo;
431 code = ksi->ksi_code;
432 PROC_LOCK_ASSERT(p, MA_OWNED);
433 psp = p->p_sigacts;
434 mtx_assert(&psp->ps_mtx, MA_OWNED);
435 regs = td->td_frame;
436 oonstack = sigonstack(regs->tf_esp);
437
438#ifdef DEBUG
439 if (ldebug(rt_sendsig))
440 printf(ARGS(rt_sendsig, "%p, %d, %p, %u"),
441 catcher, sig, (void*)mask, code);
442#endif
443 /*
444 * Allocate space for the signal handler context.
445 */
446 if ((td->td_pflags & TDP_ALTSTACK) && !oonstack &&
447 SIGISMEMBER(psp->ps_sigonstack, sig)) {
448 fp = (struct l_rt_sigframe *)(td->td_sigstk.ss_sp +
449 td->td_sigstk.ss_size - sizeof(struct l_rt_sigframe));
450 } else
451 fp = (struct l_rt_sigframe *)regs->tf_esp - 1;
452 mtx_unlock(&psp->ps_mtx);
453
454 /*
455 * Build the argument list for the signal handler.
456 */
457 if (p->p_sysent->sv_sigtbl)
458 if (sig <= p->p_sysent->sv_sigsize)
459 sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
460
461 bzero(&frame, sizeof(frame));
462
463 frame.sf_handler = catcher;
464 frame.sf_sig = sig;
465 frame.sf_siginfo = &fp->sf_si;
466 frame.sf_ucontext = &fp->sf_sc;
467
468 /* Fill in POSIX parts */
469 ksiginfo_to_lsiginfo(ksi, &frame.sf_si, sig);
470
471 /*
472 * Build the signal context to be used by sigreturn.
473 */
474 frame.sf_sc.uc_flags = 0; /* XXX ??? */
475 frame.sf_sc.uc_link = NULL; /* XXX ??? */
476
477 frame.sf_sc.uc_stack.ss_sp = td->td_sigstk.ss_sp;
478 frame.sf_sc.uc_stack.ss_size = td->td_sigstk.ss_size;
479 frame.sf_sc.uc_stack.ss_flags = (td->td_pflags & TDP_ALTSTACK)
480 ? ((oonstack) ? LINUX_SS_ONSTACK : 0) : LINUX_SS_DISABLE;
481 PROC_UNLOCK(p);
482
483 bsd_to_linux_sigset(mask, &frame.sf_sc.uc_sigmask);
484
485 frame.sf_sc.uc_mcontext.sc_mask = frame.sf_sc.uc_sigmask.__bits[0];
486 frame.sf_sc.uc_mcontext.sc_gs = rgs();
487 frame.sf_sc.uc_mcontext.sc_fs = regs->tf_fs;
488 frame.sf_sc.uc_mcontext.sc_es = regs->tf_es;
489 frame.sf_sc.uc_mcontext.sc_ds = regs->tf_ds;
490 frame.sf_sc.uc_mcontext.sc_edi = regs->tf_edi;
491 frame.sf_sc.uc_mcontext.sc_esi = regs->tf_esi;
492 frame.sf_sc.uc_mcontext.sc_ebp = regs->tf_ebp;
493 frame.sf_sc.uc_mcontext.sc_ebx = regs->tf_ebx;
494 frame.sf_sc.uc_mcontext.sc_esp = regs->tf_esp;
495 frame.sf_sc.uc_mcontext.sc_edx = regs->tf_edx;
496 frame.sf_sc.uc_mcontext.sc_ecx = regs->tf_ecx;
497 frame.sf_sc.uc_mcontext.sc_eax = regs->tf_eax;
498 frame.sf_sc.uc_mcontext.sc_eip = regs->tf_eip;
499 frame.sf_sc.uc_mcontext.sc_cs = regs->tf_cs;
500 frame.sf_sc.uc_mcontext.sc_eflags = regs->tf_eflags;
501 frame.sf_sc.uc_mcontext.sc_esp_at_signal = regs->tf_esp;
502 frame.sf_sc.uc_mcontext.sc_ss = regs->tf_ss;
503 frame.sf_sc.uc_mcontext.sc_err = regs->tf_err;
504 frame.sf_sc.uc_mcontext.sc_cr2 = (register_t)ksi->ksi_addr;
505 frame.sf_sc.uc_mcontext.sc_trapno = bsd_to_linux_trapcode(code);
506
507#ifdef DEBUG
508 if (ldebug(rt_sendsig))
509 printf(LMSG("rt_sendsig flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
510 frame.sf_sc.uc_stack.ss_flags, td->td_sigstk.ss_sp,
511 td->td_sigstk.ss_size, frame.sf_sc.uc_mcontext.sc_mask);
512#endif
513
514 if (copyout(&frame, fp, sizeof(frame)) != 0) {
515 /*
516 * Process has trashed its stack; give it an illegal
517 * instruction to halt it in its tracks.
518 */
519#ifdef DEBUG
520 if (ldebug(rt_sendsig))
521 printf(LMSG("rt_sendsig: bad stack %p, oonstack=%x"),
522 fp, oonstack);
523#endif
524 PROC_LOCK(p);
525 sigexit(td, SIGILL);
526 }
527
528 /*
529 * Build context to run handler in.
530 */
531 regs->tf_esp = (int)fp;
532 regs->tf_eip = linux_rt_sigcode;
533 regs->tf_eflags &= ~(PSL_T | PSL_VM | PSL_D);
534 regs->tf_cs = _ucodesel;
535 regs->tf_ds = _udatasel;
536 regs->tf_es = _udatasel;
537 regs->tf_fs = _udatasel;
538 regs->tf_ss = _udatasel;
539 PROC_LOCK(p);
540 mtx_lock(&psp->ps_mtx);
541}
542
543
544/*
545 * Send an interrupt to process.
546 *
547 * Stack is set up to allow sigcode stored
548 * in u. to call routine, followed by kcall
549 * to sigreturn routine below. After sigreturn
550 * resets the signal mask, the stack, and the
551 * frame pointer, it returns to the user
552 * specified pc, psl.
553 */
554static void
555linux_sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
556{
557 struct thread *td = curthread;
558 struct proc *p = td->td_proc;
559 struct sigacts *psp;
560 struct trapframe *regs;
561 struct l_sigframe *fp, frame;
562 l_sigset_t lmask;
563 int sig, code;
564 int oonstack, i;
565
566 PROC_LOCK_ASSERT(p, MA_OWNED);
567 psp = p->p_sigacts;
568 sig = ksi->ksi_signo;
569 code = ksi->ksi_code;
570 mtx_assert(&psp->ps_mtx, MA_OWNED);
571 if (SIGISMEMBER(psp->ps_siginfo, sig)) {
572 /* Signal handler installed with SA_SIGINFO. */
573 linux_rt_sendsig(catcher, ksi, mask);
574 return;
575 }
576 regs = td->td_frame;
577 oonstack = sigonstack(regs->tf_esp);
578
579#ifdef DEBUG
580 if (ldebug(sendsig))
581 printf(ARGS(sendsig, "%p, %d, %p, %u"),
582 catcher, sig, (void*)mask, code);
583#endif
584
585 /*
586 * Allocate space for the signal handler context.
587 */
588 if ((td->td_pflags & TDP_ALTSTACK) && !oonstack &&
589 SIGISMEMBER(psp->ps_sigonstack, sig)) {
590 fp = (struct l_sigframe *)(td->td_sigstk.ss_sp +
591 td->td_sigstk.ss_size - sizeof(struct l_sigframe));
592 } else
593 fp = (struct l_sigframe *)regs->tf_esp - 1;
594 mtx_unlock(&psp->ps_mtx);
595 PROC_UNLOCK(p);
596
597 /*
598 * Build the argument list for the signal handler.
599 */
600 if (p->p_sysent->sv_sigtbl)
601 if (sig <= p->p_sysent->sv_sigsize)
602 sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
603
604 bzero(&frame, sizeof(frame));
605
606 frame.sf_handler = catcher;
607 frame.sf_sig = sig;
608
609 bsd_to_linux_sigset(mask, &lmask);
610
611 /*
612 * Build the signal context to be used by sigreturn.
613 */
614 frame.sf_sc.sc_mask = lmask.__bits[0];
615 frame.sf_sc.sc_gs = rgs();
616 frame.sf_sc.sc_fs = regs->tf_fs;
617 frame.sf_sc.sc_es = regs->tf_es;
618 frame.sf_sc.sc_ds = regs->tf_ds;
619 frame.sf_sc.sc_edi = regs->tf_edi;
620 frame.sf_sc.sc_esi = regs->tf_esi;
621 frame.sf_sc.sc_ebp = regs->tf_ebp;
622 frame.sf_sc.sc_ebx = regs->tf_ebx;
623 frame.sf_sc.sc_esp = regs->tf_esp;
624 frame.sf_sc.sc_edx = regs->tf_edx;
625 frame.sf_sc.sc_ecx = regs->tf_ecx;
626 frame.sf_sc.sc_eax = regs->tf_eax;
627 frame.sf_sc.sc_eip = regs->tf_eip;
628 frame.sf_sc.sc_cs = regs->tf_cs;
629 frame.sf_sc.sc_eflags = regs->tf_eflags;
630 frame.sf_sc.sc_esp_at_signal = regs->tf_esp;
631 frame.sf_sc.sc_ss = regs->tf_ss;
632 frame.sf_sc.sc_err = regs->tf_err;
633 frame.sf_sc.sc_cr2 = (register_t)ksi->ksi_addr;
634 frame.sf_sc.sc_trapno = bsd_to_linux_trapcode(ksi->ksi_trapno);
635
636 for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
637 frame.sf_extramask[i] = lmask.__bits[i+1];
638
639 if (copyout(&frame, fp, sizeof(frame)) != 0) {
640 /*
641 * Process has trashed its stack; give it an illegal
642 * instruction to halt it in its tracks.
643 */
644 PROC_LOCK(p);
645 sigexit(td, SIGILL);
646 }
647
648 /*
649 * Build context to run handler in.
650 */
651 regs->tf_esp = (int)fp;
652 regs->tf_eip = linux_sigcode;
653 regs->tf_eflags &= ~(PSL_T | PSL_VM | PSL_D);
654 regs->tf_cs = _ucodesel;
655 regs->tf_ds = _udatasel;
656 regs->tf_es = _udatasel;
657 regs->tf_fs = _udatasel;
658 regs->tf_ss = _udatasel;
659 PROC_LOCK(p);
660 mtx_lock(&psp->ps_mtx);
661}
662
663/*
664 * System call to cleanup state after a signal
665 * has been taken. Reset signal mask and
666 * stack state from context left by sendsig (above).
667 * Return to previous pc and psl as specified by
668 * context left by sendsig. Check carefully to
669 * make sure that the user has not modified the
670 * psl to gain improper privileges or to cause
671 * a machine fault.
672 */
673int
674linux_sigreturn(struct thread *td, struct linux_sigreturn_args *args)
675{
676 struct l_sigframe frame;
677 struct trapframe *regs;
678 l_sigset_t lmask;
679 sigset_t bmask;
680 int eflags, i;
681 ksiginfo_t ksi;
682
683 regs = td->td_frame;
684
685#ifdef DEBUG
686 if (ldebug(sigreturn))
687 printf(ARGS(sigreturn, "%p"), (void *)args->sfp);
688#endif
689 /*
690 * The trampoline code hands us the sigframe.
691 * It is unsafe to keep track of it ourselves, in the event that a
692 * program jumps out of a signal handler.
693 */
694 if (copyin(args->sfp, &frame, sizeof(frame)) != 0)
695 return (EFAULT);
696
697 /*
698 * Check for security violations.
699 */
700#define EFLAGS_SECURE(ef, oef) ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
701 eflags = frame.sf_sc.sc_eflags;
702 if (!EFLAGS_SECURE(eflags, regs->tf_eflags))
703 return (EINVAL);
704
705 /*
706 * Don't allow users to load a valid privileged %cs. Let the
707 * hardware check for invalid selectors, excess privilege in
708 * other selectors, invalid %eip's and invalid %esp's.
709 */
710#define CS_SECURE(cs) (ISPL(cs) == SEL_UPL)
711 if (!CS_SECURE(frame.sf_sc.sc_cs)) {
712 ksiginfo_init_trap(&ksi);
713 ksi.ksi_signo = SIGBUS;
714 ksi.ksi_code = BUS_OBJERR;
715 ksi.ksi_trapno = T_PROTFLT;
716 ksi.ksi_addr = (void *)regs->tf_eip;
717 trapsignal(td, &ksi);
718 return (EINVAL);
719 }
720
721 lmask.__bits[0] = frame.sf_sc.sc_mask;
722 for (i = 0; i < (LINUX_NSIG_WORDS-1); i++)
723 lmask.__bits[i+1] = frame.sf_extramask[i];
724 linux_to_bsd_sigset(&lmask, &bmask);
725 kern_sigprocmask(td, SIG_SETMASK, &bmask, NULL, 0);
726
727 /*
728 * Restore signal context.
729 */
730 /* %gs was restored by the trampoline. */
731 regs->tf_fs = frame.sf_sc.sc_fs;
732 regs->tf_es = frame.sf_sc.sc_es;
733 regs->tf_ds = frame.sf_sc.sc_ds;
734 regs->tf_edi = frame.sf_sc.sc_edi;
735 regs->tf_esi = frame.sf_sc.sc_esi;
736 regs->tf_ebp = frame.sf_sc.sc_ebp;
737 regs->tf_ebx = frame.sf_sc.sc_ebx;
738 regs->tf_edx = frame.sf_sc.sc_edx;
739 regs->tf_ecx = frame.sf_sc.sc_ecx;
740 regs->tf_eax = frame.sf_sc.sc_eax;
741 regs->tf_eip = frame.sf_sc.sc_eip;
742 regs->tf_cs = frame.sf_sc.sc_cs;
743 regs->tf_eflags = eflags;
744 regs->tf_esp = frame.sf_sc.sc_esp_at_signal;
745 regs->tf_ss = frame.sf_sc.sc_ss;
746
747 return (EJUSTRETURN);
748}
749
750/*
751 * System call to cleanup state after a signal
752 * has been taken. Reset signal mask and
753 * stack state from context left by rt_sendsig (above).
754 * Return to previous pc and psl as specified by
755 * context left by sendsig. Check carefully to
756 * make sure that the user has not modified the
757 * psl to gain improper privileges or to cause
758 * a machine fault.
759 */
760int
761linux_rt_sigreturn(struct thread *td, struct linux_rt_sigreturn_args *args)
762{
763 struct l_ucontext uc;
764 struct l_sigcontext *context;
765 sigset_t bmask;
766 l_stack_t *lss;
767 stack_t ss;
768 struct trapframe *regs;
769 int eflags;
770 ksiginfo_t ksi;
771
772 regs = td->td_frame;
773
774#ifdef DEBUG
775 if (ldebug(rt_sigreturn))
776 printf(ARGS(rt_sigreturn, "%p"), (void *)args->ucp);
777#endif
778 /*
779 * The trampoline code hands us the ucontext.
780 * It is unsafe to keep track of it ourselves, in the event that a
781 * program jumps out of a signal handler.
782 */
783 if (copyin(args->ucp, &uc, sizeof(uc)) != 0)
784 return (EFAULT);
785
786 context = &uc.uc_mcontext;
787
788 /*
789 * Check for security violations.
790 */
791#define EFLAGS_SECURE(ef, oef) ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0)
792 eflags = context->sc_eflags;
793 if (!EFLAGS_SECURE(eflags, regs->tf_eflags))
794 return (EINVAL);
795
796 /*
797 * Don't allow users to load a valid privileged %cs. Let the
798 * hardware check for invalid selectors, excess privilege in
799 * other selectors, invalid %eip's and invalid %esp's.
800 */
801#define CS_SECURE(cs) (ISPL(cs) == SEL_UPL)
802 if (!CS_SECURE(context->sc_cs)) {
803 ksiginfo_init_trap(&ksi);
804 ksi.ksi_signo = SIGBUS;
805 ksi.ksi_code = BUS_OBJERR;
806 ksi.ksi_trapno = T_PROTFLT;
807 ksi.ksi_addr = (void *)regs->tf_eip;
808 trapsignal(td, &ksi);
809 return (EINVAL);
810 }
811
812 linux_to_bsd_sigset(&uc.uc_sigmask, &bmask);
813 kern_sigprocmask(td, SIG_SETMASK, &bmask, NULL, 0);
814
815 /*
816 * Restore signal context
817 */
818 /* %gs was restored by the trampoline. */
819 regs->tf_fs = context->sc_fs;
820 regs->tf_es = context->sc_es;
821 regs->tf_ds = context->sc_ds;
822 regs->tf_edi = context->sc_edi;
823 regs->tf_esi = context->sc_esi;
824 regs->tf_ebp = context->sc_ebp;
825 regs->tf_ebx = context->sc_ebx;
826 regs->tf_edx = context->sc_edx;
827 regs->tf_ecx = context->sc_ecx;
828 regs->tf_eax = context->sc_eax;
829 regs->tf_eip = context->sc_eip;
830 regs->tf_cs = context->sc_cs;
831 regs->tf_eflags = eflags;
832 regs->tf_esp = context->sc_esp_at_signal;
833 regs->tf_ss = context->sc_ss;
834
835 /*
836 * call sigaltstack & ignore results..
837 */
838 lss = &uc.uc_stack;
839 ss.ss_sp = lss->ss_sp;
840 ss.ss_size = lss->ss_size;
841 ss.ss_flags = linux_to_bsd_sigaltstack(lss->ss_flags);
842
843#ifdef DEBUG
844 if (ldebug(rt_sigreturn))
845 printf(LMSG("rt_sigret flags: 0x%x, sp: %p, ss: 0x%x, mask: 0x%x"),
846 ss.ss_flags, ss.ss_sp, ss.ss_size, context->sc_mask);
847#endif
848 (void)kern_sigaltstack(td, &ss, NULL);
849
850 return (EJUSTRETURN);
851}
852
853static int
854linux_fetch_syscall_args(struct thread *td, struct syscall_args *sa)
855{
856 struct proc *p;
857 struct trapframe *frame;
858
859 p = td->td_proc;
860 frame = td->td_frame;
861
862 sa->code = frame->tf_eax;
863 sa->args[0] = frame->tf_ebx;
864 sa->args[1] = frame->tf_ecx;
865 sa->args[2] = frame->tf_edx;
866 sa->args[3] = frame->tf_esi;
867 sa->args[4] = frame->tf_edi;
868 sa->args[5] = frame->tf_ebp; /* Unconfirmed */
869
870 if (sa->code >= p->p_sysent->sv_size)
871 sa->callp = &p->p_sysent->sv_table[0];
872 else
873 sa->callp = &p->p_sysent->sv_table[sa->code];
874 sa->narg = sa->callp->sy_narg;
875
876 td->td_retval[0] = 0;
877 td->td_retval[1] = frame->tf_edx;
878
879 return (0);
880}
881
882/*
883 * If a linux binary is exec'ing something, try this image activator
884 * first. We override standard shell script execution in order to
885 * be able to modify the interpreter path. We only do this if a linux
886 * binary is doing the exec, so we do not create an EXEC module for it.
887 */
888static int exec_linux_imgact_try(struct image_params *iparams);
889
890static int
891exec_linux_imgact_try(struct image_params *imgp)
892{
893 const char *head = (const char *)imgp->image_header;
894 char *rpath;
895 int error = -1;
896
897 /*
898 * The interpreter for shell scripts run from a linux binary needs
899 * to be located in /compat/linux if possible in order to recursively
900 * maintain linux path emulation.
901 */
902 if (((const short *)head)[0] == SHELLMAGIC) {
903 /*
904 * Run our normal shell image activator. If it succeeds attempt
905 * to use the alternate path for the interpreter. If an alternate
906 * path is found, use our stringspace to store it.
907 */
908 if ((error = exec_shell_imgact(imgp)) == 0) {
909 linux_emul_convpath(FIRST_THREAD_IN_PROC(imgp->proc),
910 imgp->interpreter_name, UIO_SYSSPACE, &rpath, 0, AT_FDCWD);
911 if (rpath != NULL)
912 imgp->args->fname_buf =
913 imgp->interpreter_name = rpath;
914 }
915 }
916 return (error);
917}
918
919/*
920 * exec_setregs may initialize some registers differently than Linux
921 * does, thus potentially confusing Linux binaries. If necessary, we
922 * override the exec_setregs default(s) here.
923 */
924static void
925exec_linux_setregs(struct thread *td, struct image_params *imgp, u_long stack)
926{
927 struct pcb *pcb = td->td_pcb;
928
929 exec_setregs(td, imgp, stack);
930
931 /* Linux sets %gs to 0, we default to _udatasel */
932 pcb->pcb_gs = 0;
933 load_gs(0);
934
935 pcb->pcb_initial_npxcw = __LINUX_NPXCW__;
936}
937
938static void
939linux_get_machine(const char **dst)
940{
941
942 switch (cpu_class) {
943 case CPUCLASS_686:
944 *dst = "i686";
945 break;
946 case CPUCLASS_586:
947 *dst = "i586";
948 break;
949 case CPUCLASS_486:
950 *dst = "i486";
951 break;
952 default:
953 *dst = "i386";
954 }
955}
956
957struct sysentvec linux_sysvec = {
958 .sv_size = LINUX_SYS_MAXSYSCALL,
959 .sv_table = linux_sysent,
960 .sv_mask = 0,
961 .sv_sigsize = LINUX_SIGTBLSZ,
962 .sv_sigtbl = bsd_to_linux_signal,
963 .sv_errsize = ELAST + 1,
964 .sv_errtbl = bsd_to_linux_errno,
965 .sv_transtrap = translate_traps,
966 .sv_fixup = linux_fixup,
967 .sv_sendsig = linux_sendsig,
968 .sv_sigcode = &_binary_linux_locore_o_start,
969 .sv_szsigcode = &linux_szsigcode,
970 .sv_prepsyscall = NULL,
971 .sv_name = "Linux a.out",
972 .sv_coredump = NULL,
973 .sv_imgact_try = exec_linux_imgact_try,
974 .sv_minsigstksz = LINUX_MINSIGSTKSZ,
975 .sv_pagesize = PAGE_SIZE,
976 .sv_minuser = VM_MIN_ADDRESS,
977 .sv_maxuser = VM_MAXUSER_ADDRESS,
978 .sv_usrstack = LINUX_USRSTACK,
979 .sv_psstrings = PS_STRINGS,
980 .sv_stackprot = VM_PROT_ALL,
981 .sv_copyout_strings = exec_copyout_strings,
982 .sv_setregs = exec_linux_setregs,
983 .sv_fixlimit = NULL,
984 .sv_maxssiz = NULL,
985 .sv_flags = SV_ABI_LINUX | SV_AOUT | SV_IA32 | SV_ILP32,
986 .sv_set_syscall_retval = cpu_set_syscall_retval,
987 .sv_fetch_syscall_args = linux_fetch_syscall_args,
988 .sv_syscallnames = NULL,
989 .sv_shared_page_base = LINUX_SHAREDPAGE,
990 .sv_shared_page_len = PAGE_SIZE,
991 .sv_schedtail = linux_schedtail,
992 .sv_thread_detach = linux_thread_detach,
993};
994INIT_SYSENTVEC(aout_sysvec, &linux_sysvec);
995
996struct sysentvec elf_linux_sysvec = {
997 .sv_size = LINUX_SYS_MAXSYSCALL,
998 .sv_table = linux_sysent,
999 .sv_mask = 0,
1000 .sv_sigsize = LINUX_SIGTBLSZ,
1001 .sv_sigtbl = bsd_to_linux_signal,
1002 .sv_errsize = ELAST + 1,
1003 .sv_errtbl = bsd_to_linux_errno,
1004 .sv_transtrap = translate_traps,
1005 .sv_fixup = elf_linux_fixup,
1006 .sv_sendsig = linux_sendsig,
1007 .sv_sigcode = &_binary_linux_locore_o_start,
1008 .sv_szsigcode = &linux_szsigcode,
1009 .sv_prepsyscall = NULL,
1010 .sv_name = "Linux ELF",
1011 .sv_coredump = elf32_coredump,
1012 .sv_imgact_try = exec_linux_imgact_try,
1013 .sv_minsigstksz = LINUX_MINSIGSTKSZ,
1014 .sv_pagesize = PAGE_SIZE,
1015 .sv_minuser = VM_MIN_ADDRESS,
1016 .sv_maxuser = VM_MAXUSER_ADDRESS,
1017 .sv_usrstack = LINUX_USRSTACK,
1018 .sv_psstrings = LINUX_PS_STRINGS,
1019 .sv_stackprot = VM_PROT_ALL,
1020 .sv_copyout_strings = linux_copyout_strings,
1021 .sv_setregs = exec_linux_setregs,
1022 .sv_fixlimit = NULL,
1023 .sv_maxssiz = NULL,
1024 .sv_flags = SV_ABI_LINUX | SV_IA32 | SV_ILP32 | SV_SHP,
1025 .sv_set_syscall_retval = cpu_set_syscall_retval,
1026 .sv_fetch_syscall_args = linux_fetch_syscall_args,
1027 .sv_syscallnames = NULL,
1028 .sv_shared_page_base = LINUX_SHAREDPAGE,
1029 .sv_shared_page_len = PAGE_SIZE,
1030 .sv_schedtail = linux_schedtail,
1031 .sv_thread_detach = linux_thread_detach,
1032};
1033
1034static void
1035linux_vdso_install(void *param)
1036{
1037
1038 linux_szsigcode = (&_binary_linux_locore_o_end -
1039 &_binary_linux_locore_o_start);
1040
1041 if (linux_szsigcode > elf_linux_sysvec.sv_shared_page_len)
1042 panic("Linux invalid vdso size\n");
1043
1044 __elfN(linux_vdso_fixup)(&elf_linux_sysvec);
1045
1046 linux_shared_page_obj = __elfN(linux_shared_page_init)
1047 (&linux_shared_page_mapping);
1048
1049 __elfN(linux_vdso_reloc)(&elf_linux_sysvec, LINUX_SHAREDPAGE);
1050
1051 bcopy(elf_linux_sysvec.sv_sigcode, linux_shared_page_mapping,
1052 linux_szsigcode);
1053 elf_linux_sysvec.sv_shared_page_obj = linux_shared_page_obj;
1054}
1055SYSINIT(elf_linux_vdso_init, SI_SUB_EXEC, SI_ORDER_ANY,
1056 (sysinit_cfunc_t)linux_vdso_install, NULL);
1057
1058static void
1059linux_vdso_deinstall(void *param)
1060{
1061
1062 __elfN(linux_shared_page_fini)(linux_shared_page_obj);
1063};
1064SYSUNINIT(elf_linux_vdso_uninit, SI_SUB_EXEC, SI_ORDER_FIRST,
1065 (sysinit_cfunc_t)linux_vdso_deinstall, NULL);
1066
1067static char GNU_ABI_VENDOR[] = "GNU";
1068static int GNULINUX_ABI_DESC = 0;
1069
1070static boolean_t
1071linux_trans_osrel(const Elf_Note *note, int32_t *osrel)
1072{
1073 const Elf32_Word *desc;
1074 uintptr_t p;
1075
1076 p = (uintptr_t)(note + 1);
1077 p += roundup2(note->n_namesz, sizeof(Elf32_Addr));
1078
1079 desc = (const Elf32_Word *)p;
1080 if (desc[0] != GNULINUX_ABI_DESC)
1081 return (FALSE);
1082
1083 /*
1084 * For linux we encode osrel as follows (see linux_mib.c):
1085 * VVVMMMIII (version, major, minor), see linux_mib.c.
1086 */
1087 *osrel = desc[1] * 1000000 + desc[2] * 1000 + desc[3];
1088
1089 return (TRUE);
1090}
1091
1092static Elf_Brandnote linux_brandnote = {
1093 .hdr.n_namesz = sizeof(GNU_ABI_VENDOR),
1094 .hdr.n_descsz = 16, /* XXX at least 16 */
1095 .hdr.n_type = 1,
1096 .vendor = GNU_ABI_VENDOR,
1097 .flags = BN_TRANSLATE_OSREL,
1098 .trans_osrel = linux_trans_osrel
1099};
1100
1101static Elf32_Brandinfo linux_brand = {
1102 .brand = ELFOSABI_LINUX,
1103 .machine = EM_386,
1104 .compat_3_brand = "Linux",
1105 .emul_path = "/compat/linux",
1106 .interp_path = "/lib/ld-linux.so.1",
1107 .sysvec = &elf_linux_sysvec,
1108 .interp_newpath = NULL,
1109 .brand_note = &linux_brandnote,
1110 .flags = BI_CAN_EXEC_DYN | BI_BRAND_NOTE
1111};
1112
1113static Elf32_Brandinfo linux_glibc2brand = {
1114 .brand = ELFOSABI_LINUX,
1115 .machine = EM_386,
1116 .compat_3_brand = "Linux",
1117 .emul_path = "/compat/linux",
1118 .interp_path = "/lib/ld-linux.so.2",
1119 .sysvec = &elf_linux_sysvec,
1120 .interp_newpath = NULL,
1121 .brand_note = &linux_brandnote,
1122 .flags = BI_CAN_EXEC_DYN | BI_BRAND_NOTE
1123};
1124
1125Elf32_Brandinfo *linux_brandlist[] = {
1126 &linux_brand,
1127 &linux_glibc2brand,
1128 NULL
1129};
1130
1131static int
1132linux_elf_modevent(module_t mod, int type, void *data)
1133{
1134 Elf32_Brandinfo **brandinfo;
1135 int error;
1136 struct linux_ioctl_handler **lihp;
|