root/arch/i386/i386/svr4_machdep.c

DEFINITIONS

1. svr4_getcontext
2. svr4_setcontext
3. svr4_getsiginfo
4. svr4_sendsig
5. svr4_sys_sysarch

    1 /*      $OpenBSD: svr4_machdep.c,v 1.25 2006/12/29 13:04:37 pedro Exp $ */
    2 /*      $NetBSD: svr4_machdep.c,v 1.24 1996/05/03 19:42:26 christos Exp $        */
    4 /*
    5  * Copyright (c) 1994 Christos Zoulas
    6  * All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 3. The name of the author may not be used to endorse or promote products
   17  *    derived from this software without specific prior written permission
   18  *
   19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   29  */
   31 #include <sys/param.h>
   32 #include <sys/systm.h>
   33 #include <sys/namei.h>
   34 #include <sys/proc.h>
   35 #include <sys/user.h>
   36 #include <sys/filedesc.h>
   37 #include <sys/ioctl.h>
   38 #include <sys/mount.h>
   39 #include <sys/kernel.h>
   40 #include <sys/signal.h>
   41 #include <sys/signalvar.h>
   42 #include <sys/malloc.h>
   44 #include <sys/syscallargs.h>
   45 #include <compat/svr4/svr4_types.h>
   46 #include <compat/svr4/svr4_ucontext.h>
   47 #include <compat/svr4/svr4_syscallargs.h>
   48 #include <compat/svr4/svr4_util.h>
   50 #include <machine/cpu.h>
   51 #include <machine/cpufunc.h>
   52 #include <machine/psl.h>
   53 #include <machine/reg.h>
   54 #include <machine/specialreg.h>
   55 #include <machine/sysarch.h>
   56 #include <machine/vm86.h>
   57 #include <machine/svr4_machdep.h>
   59 static void svr4_getsiginfo(union svr4_siginfo *, int, u_long, int, caddr_t);
   61 void
svr4_getcontext(struct proc *p, struct svr4_ucontext *uc, int mask,
   63     int oonstack)
   64 {
   65         struct trapframe *tf = p->p_md.md_regs;
   66         struct sigacts *psp = p->p_sigacts;
svr4_greg_t *r = uc->uc_mcontext.greg;
   68         struct svr4_sigaltstack *s = &uc->uc_stack;
   69         struct sigaltstack *sf = &psp->ps_sigstk;
bzero(uc, sizeof(struct svr4_ucontext));
   73         /*
   74          * Set the general purpose registers
   75          */
   76 #ifdef VM86
   77         if (tf->tf_eflags & PSL_VM) {
r[SVR4_X86_GS] = tf->tf_vm86_gs;
r[SVR4_X86_FS] = tf->tf_vm86_fs;
r[SVR4_X86_ES] = tf->tf_vm86_es;
r[SVR4_X86_DS] = tf->tf_vm86_ds;
r[SVR4_X86_EFL] = get_vflags(p);
   83         } else
   84 #endif
   85         {
r[SVR4_X86_FS] = tf->tf_fs;
r[SVR4_X86_GS] = tf->tf_gs;
r[SVR4_X86_ES] = tf->tf_es;
r[SVR4_X86_DS] = tf->tf_ds;
r[SVR4_X86_EFL] = tf->tf_eflags;
   91         }
r[SVR4_X86_EDI] = tf->tf_edi;
r[SVR4_X86_ESI] = tf->tf_esi;
r[SVR4_X86_EBP] = tf->tf_ebp;
r[SVR4_X86_ESP] = tf->tf_esp;
r[SVR4_X86_EBX] = tf->tf_ebx;
r[SVR4_X86_EDX] = tf->tf_edx;
r[SVR4_X86_ECX] = tf->tf_ecx;
r[SVR4_X86_EAX] = tf->tf_eax;
r[SVR4_X86_TRAPNO] = 0;
r[SVR4_X86_ERR] = 0;
r[SVR4_X86_EIP] = tf->tf_eip;
r[SVR4_X86_CS] = tf->tf_cs;
r[SVR4_X86_UESP] = 0;
r[SVR4_X86_SS] = tf->tf_ss;
  107         /*
  108          * Set the signal stack
  109          */
bsd_to_svr4_sigaltstack(sf, s);
  112         /*
  113          * Set the signal mask
  114          */
bsd_to_svr4_sigset(&mask, &uc->uc_sigmask);
  117         /*
  118          * Set the flags
  119          */
uc->uc_flags = SVR4_UC_ALL;
  121 }
  124 /*
  125  * Set to ucontext specified.
  126  * has been taken.  Reset signal mask and
  127  * stack state from context.
  128  * Return to previous pc and psl as specified by
  129  * context left by sendsig. Check carefully to
  130  * make sure that the user has not modified the
  131  * psl to gain improper privileges or to cause
  132  * a machine fault.
  133  */
  134 int
svr4_setcontext(struct proc *p, struct svr4_ucontext *uc)
  136 {
  137         struct sigacts *psp = p->p_sigacts;
  138         struct trapframe *tf;
svr4_greg_t *r = uc->uc_mcontext.greg;
  140         struct svr4_sigaltstack *s = &uc->uc_stack;
  141         struct sigaltstack *sf = &psp->ps_sigstk;
  142         int mask;
  144         /*
  145          * XXX:
  146          * Should we check the value of flags to determine what to restore?
  147          * What to do with uc_link?
  148          * What to do with floating point stuff?
  149          * Should we bother with the rest of the registers that we
  150          * set to 0 right now?
  151          */
tf = p->p_md.md_regs;
  155         /*
  156          * Restore register context.
  157          */
  158 #ifdef VM86
  159         if (r[SVR4_X86_EFL] & PSL_VM) {
tf->tf_vm86_gs = r[SVR4_X86_GS];
tf->tf_vm86_fs = r[SVR4_X86_FS];
tf->tf_vm86_es = r[SVR4_X86_ES];
tf->tf_vm86_ds = r[SVR4_X86_DS];
set_vflags(p, r[SVR4_X86_EFL]);
  165         } else
  166 #endif
  167         {
  168                 /*
  169                  * Check for security violations.  If we're returning to
  170                  * protected mode, the CPU will validate the segment registers
  171                  * automatically and generate a trap on violations.  We handle
  172                  * the trap, rather than doing all of the checking here.
  173                  */
  174                 if (((r[SVR4_X86_EFL] ^ tf->tf_eflags) & PSL_USERSTATIC) != 0 ||
  175                     !USERMODE(r[SVR4_X86_CS], r[SVR4_X86_EFL]))
  176                         return (EINVAL);
tf->tf_fs = r[SVR4_X86_FS];
tf->tf_gs = r[SVR4_X86_GS];
tf->tf_es = r[SVR4_X86_ES];
tf->tf_ds = r[SVR4_X86_DS];
tf->tf_eflags = r[SVR4_X86_EFL];
  183         }
tf->tf_edi = r[SVR4_X86_EDI];
tf->tf_esi = r[SVR4_X86_ESI];
tf->tf_ebp = r[SVR4_X86_EBP];
tf->tf_ebx = r[SVR4_X86_EBX];
tf->tf_edx = r[SVR4_X86_EDX];
tf->tf_ecx = r[SVR4_X86_ECX];
tf->tf_eax = r[SVR4_X86_EAX];
tf->tf_eip = r[SVR4_X86_EIP];
tf->tf_cs = r[SVR4_X86_CS];
tf->tf_ss = r[SVR4_X86_SS];
tf->tf_esp = r[SVR4_X86_ESP];
  196         /*
  197          * restore signal stack
  198          */
svr4_to_bsd_sigaltstack(s, sf);
  201         /*
  202          * restore signal mask
  203          */
svr4_to_bsd_sigset(&uc->uc_sigmask, &mask);
p->p_sigmask = mask & ~sigcantmask;
  207         return EJUSTRETURN;
  208 }
  211 static void
svr4_getsiginfo(union svr4_siginfo *si, int sig, u_long code, int type,
caddr_t addr)
  214 {
si->svr4_si_signo = bsd_to_svr4_sig[sig];
si->svr4_si_errno = 0;
si->svr4_si_addr  = addr;
si->svr4_si_code = 0;
si->svr4_si_trap = 0;
  222         switch (sig) {
  223         case SIGSEGV:
  224                 switch (type) {
  225                 case SEGV_ACCERR:
si->svr4_si_code = SVR4_SEGV_ACCERR;
si->svr4_si_trap = SVR4_T_PROTFLT;
  228                         break;
  229                 case SEGV_MAPERR:
si->svr4_si_code = SVR4_SEGV_MAPERR;
si->svr4_si_trap = SVR4_T_SEGNPFLT;
  232                         break;
  233                 }
  234                 break;
  235         case SIGBUS:
  236                 switch (type) {
  237                 case BUS_ADRALN:
si->svr4_si_code = SVR4_BUS_ADRALN;
si->svr4_si_trap = SVR4_T_ALIGNFLT;
  240                         break;
  241                 }
  242                 break;
  243         case SIGTRAP:
  244                 switch (type) {
  245                 case TRAP_BRKPT:
si->svr4_si_code = SVR4_TRAP_BRKPT;
si->svr4_si_trap = SVR4_T_BPTFLT;
  248                         break;
  249                 case TRAP_TRACE:
si->svr4_si_code = SVR4_TRAP_TRACE;
si->svr4_si_trap = SVR4_T_TRCTRAP;
  252                         break;
  253                 }
  254                 break;
  255         case SIGEMT:
  256                 switch (type) {
  257                 }
  258                 break;
  259         case SIGILL:
  260                 switch (type) {
  261                 case ILL_PRVOPC:
si->svr4_si_code = SVR4_ILL_PRVOPC;
si->svr4_si_trap = SVR4_T_PRIVINFLT;
  264                         break;
  265                 case ILL_BADSTK:
si->svr4_si_code = SVR4_ILL_BADSTK;
si->svr4_si_trap = SVR4_T_STKFLT;
  268                         break;
  269                 }
  270                 break;
  271         case SIGFPE:
  272                 switch (type) {
  273                 case FPE_INTOVF:
si->svr4_si_code = SVR4_FPE_INTOVF;
si->svr4_si_trap = SVR4_T_DIVIDE;
  276                         break;
  277                 case FPE_FLTDIV:
si->svr4_si_code = SVR4_FPE_FLTDIV;
si->svr4_si_trap = SVR4_T_DIVIDE;
  280                         break;
  281                 case FPE_FLTOVF:
si->svr4_si_code = SVR4_FPE_FLTOVF;
si->svr4_si_trap = SVR4_T_DIVIDE;
  284                         break;
  285                 case FPE_FLTSUB:
si->svr4_si_code = SVR4_FPE_FLTSUB;
si->svr4_si_trap = SVR4_T_BOUND;
  288                         break;
  289                 case FPE_FLTINV:
si->svr4_si_code = SVR4_FPE_FLTINV;
si->svr4_si_trap = SVR4_T_FPOPFLT;
  292                         break;
  293                 }
  294                 break;
  295         }
  296 }
  299 /*
  300  * Send an interrupt to process.
  301  *
  302  * Stack is set up to allow sigcode stored
  303  * in u. to call routine. After the handler is
  304  * done svr4 will call setcontext for us
  305  * with the user context we just set up, and we
  306  * will return to the user pc, psl.
  307  */
  308 void
svr4_sendsig(sig_t catcher, int sig, int mask, u_long code, int type,
  310     union sigval val)
  311 {
  312         struct proc *p = curproc;
  313         struct trapframe *tf;
  314         struct svr4_sigframe *fp, frame;
  315         struct sigacts *psp = p->p_sigacts;
  316         int oonstack;
tf = p->p_md.md_regs;
oonstack = psp->ps_sigstk.ss_flags & SS_ONSTACK;
  321         /*
  322          * Allocate space for the signal handler context.
  323          */
  324         if ((psp->ps_flags & SAS_ALTSTACK) && !oonstack &&
  325             (psp->ps_sigonstack & sigmask(sig))) {
fp = (struct svr4_sigframe *)((char *)psp->ps_sigstk.ss_sp +
psp->ps_sigstk.ss_size - sizeof(struct svr4_sigframe));
psp->ps_sigstk.ss_flags |= SS_ONSTACK;
  329         } else {
fp = (struct svr4_sigframe *)tf->tf_esp - 1;
  331         }
  333         /*
  334          * Build the argument list for the signal handler.
  335          * Notes:
  336          *      - we always build the whole argument list, even when we
  337          *        don't need to [when SA_SIGINFO is not set, we don't need
  338          *        to pass all sf_si and sf_uc]
  339          *      - we don't pass the correct signal address [we need to
  340          *        modify many kernel files to enable that]
  341          */
svr4_getcontext(p, &frame.sf_uc, mask, oonstack);
svr4_getsiginfo(&frame.sf_si, sig, code, type, val.sival_ptr);
frame.sf_signum = frame.sf_si.svr4_si_signo;
frame.sf_sip = &fp->sf_si;
frame.sf_ucp = &fp->sf_uc;
frame.sf_handler = catcher;
  350 #ifdef DEBUG_SVR4
printf("sig = %d, sip %p, ucp = %p, handler = %p\n",
frame.sf_signum, frame.sf_sip, frame.sf_ucp, frame.sf_handler);
  353 #endif
  355         if (copyout(&frame, fp, sizeof(frame)) != 0) {
  356                 /*
  357                  * Process has trashed its stack; give it an illegal
  358                  * instruction to halt it in its tracks.
  359                  */
sigexit(p, SIGILL);
  361                 /* NOTREACHED */
  362         }
  364         /*
  365          * Build context to run handler in.
  366          */
tf->tf_es = GSEL(GUDATA_SEL, SEL_UPL);
tf->tf_ds = GSEL(GUDATA_SEL, SEL_UPL);
tf->tf_eip = p->p_sigcode;
tf->tf_cs = GSEL(GUCODE_SEL, SEL_UPL);
tf->tf_eflags &= ~(PSL_T|PSL_VM|PSL_AC);
tf->tf_esp = (int)fp;
tf->tf_ss = GSEL(GUDATA_SEL, SEL_UPL);
  374 }
  377 /*
  378  * sysi86
  379  */
  380 int
svr4_sys_sysarch(struct proc *p, void *v, register_t *retval)
  382 {
  383         struct svr4_sys_sysarch_args *uap = v;
  384         int error;
  385 #ifdef USER_LDT
caddr_t sg = stackgap_init(p->p_emul);
  387 #endif
  388         *retval = 0;    /* XXX: What to do */
  390         switch (SCARG(uap, op)) {
  391         case SVR4_SYSARCH_FPHW:
  392                 return 0;
  394         case SVR4_SYSARCH_DSCR:
  395 #ifdef USER_LDT
  396                 if (user_ldt_enable == 0)
  397                         return (ENOSYS);
  398                 else {
  399                         struct i386_set_ldt_args sa, *sap;
  400                         struct sys_sysarch_args ua;
  402                         struct svr4_ssd ssd;
  403                         union descriptor bsd;
  405                         if ((error = copyin(SCARG(uap, a1), &ssd,
  406                                             sizeof(ssd))) != 0) {
printf("Cannot copy arg1\n");
  408                                 return error;
  409                         }
printf("s=%x, b=%x, l=%x, a1=%x a2=%x\n",
ssd.selector, ssd.base, ssd.limit,
ssd.access1, ssd.access2);
  415                         /* We can only set ldt's for now. */
  416                         if (!ISLDT(ssd.selector)) {
printf("Not an ldt\n");
  418                                 return EPERM;
  419                         }
  421                         /* Oh, well we don't cleanup either */
  422                         if (ssd.access1 == 0)
  423                                 return 0;
bsd.sd.sd_lobase = ssd.base & 0xffffff;
bsd.sd.sd_hibase = (ssd.base >> 24) & 0xff;
bsd.sd.sd_lolimit = ssd.limit & 0xffff;
bsd.sd.sd_hilimit = (ssd.limit >> 16) & 0xf;
bsd.sd.sd_type = ssd.access1 & 0x1f;
bsd.sd.sd_dpl =  (ssd.access1 >> 5) & 0x3;
bsd.sd.sd_p = (ssd.access1 >> 7) & 0x1;
bsd.sd.sd_xx = ssd.access2 & 0x3;
bsd.sd.sd_def32 = (ssd.access2 >> 2) & 0x1;
bsd.sd.sd_gran = (ssd.access2 >> 3)& 0x1;
sa.start = IDXSEL(ssd.selector);
sa.desc = stackgap_alloc(&sg, sizeof(union descriptor));
sa.num = 1;
sap = stackgap_alloc(&sg,
  443                                              sizeof(struct i386_set_ldt_args));
  445                         if ((error = copyout(&sa, sap, sizeof(sa))) != 0) {
printf("Cannot copyout args\n");
  447                                 return error;
  448                         }
SCARG(&ua, op) = I386_SET_LDT;
SCARG(&ua, parms) = (char *) sap;
  453                         if ((error = copyout(&bsd, sa.desc, sizeof(bsd))) != 0) {
printf("Cannot copyout desc\n");
  455                                 return error;
  456                         }
  458                         return sys_sysarch(p, &ua, retval);
  459                 }
  460 #endif
  461         case SVR4_SYSARCH_GOSF:
  462                 {
  463                                 /* just as SCO Openserver 5.0 says */
  464                         char features[] = {1,1,1,1,1,1,1,1,2,1,1,1};
  466                         if ((error = copyout(features, SCARG(uap, a1),
  467                                              sizeof(features))) != 0) {
printf("Cannot copyout vector\n");
  469                                 return error;
  470                         }
  472                         return 0;
  473                 }
  475         default:
printf("svr4_sysarch(%d), a1 %p\n", SCARG(uap, op),
SCARG(uap, a1));
  478                 return 0;
  479         }
  480 }