sys/compat/linux/arch/arm/linux_machdep.c

   1 /*      $NetBSD: linux_machdep.c,v 1.27 2008/04/28 20:23:42 martin Exp $        */
   2
   3 /*-
   4  * Copyright (c) 1995, 2000 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Frank van der Linden.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  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  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33
  34 __KERNEL_RCSID(0, "$NetBSD: linux_machdep.c,v 1.27 2008/04/28 20:23:42 martin Exp $");
  35
  36 #include <sys/param.h>
  37 #include <sys/systm.h>
  38 #include <sys/signalvar.h>
  39 #include <sys/kernel.h>
  40 #include <sys/proc.h>
  41 #include <sys/buf.h>
  42 #include <sys/reboot.h>
  43 #include <sys/conf.h>
  44 #include <sys/exec.h>
  45 #include <sys/file.h>
  46 #include <sys/callout.h>
  47 #include <sys/malloc.h>
  48 #include <sys/mbuf.h>
  49 #include <sys/msgbuf.h>
  50 #include <sys/mount.h>
  51 #include <sys/vnode.h>
  52 #include <sys/device.h>
  53 #include <sys/syscallargs.h>
  54 #include <sys/filedesc.h>
  55 #include <sys/exec_elf.h>
  56 #include <sys/disklabel.h>
  57 #include <sys/ioctl.h>
  58 #include <miscfs/specfs/specdev.h>
  59
  60 #include <compat/linux/common/linux_types.h>
  61 #include <compat/linux/common/linux_signal.h>
  62 #include <compat/linux/common/linux_util.h>
  63 #include <compat/linux/common/linux_ioctl.h>
  64 #include <compat/linux/common/linux_hdio.h>
  65 #include <compat/linux/common/linux_exec.h>
  66 #include <compat/linux/common/linux_machdep.h>
  67 #include <compat/linux/linux_syscallargs.h>
  68
  69 void
  70 linux_setregs(struct lwp *l, struct exec_package *epp, u_long stack)
  71 {
  72
  73         setregs(l, epp, stack);
  74 }
  75
  76 void
  77 linux_sendsig(const ksiginfo_t *ksi, const sigset_t *mask)
  78 {
  79         struct lwp *l = curlwp;
  80         struct proc *p = l->l_proc;
  81         struct trapframe *tf;
  82         struct linux_sigframe *fp, frame;
  83         int onstack, error;
  84         const int sig = ksi->ksi_signo;
  85         sig_t catcher = SIGACTION(p, sig).sa_handler;
  86
  87         tf = process_frame(l);
  88
  89         /*
  90          * The Linux version of this code is in
  91          * linux/arch/arm/kernel/signal.c.
  92          */
  93
  94         /* Do we need to jump onto the signal stack? */
  95         onstack =
  96             (l->l_sigstk.ss_flags & (SS_DISABLE | SS_ONSTACK)) == 0 &&
  97             (SIGACTION(p, sig).sa_flags & SA_ONSTACK) != 0;
  98
  99         /* Allocate space for the signal handler context. */
 100         if (onstack)
 101                 fp = (struct linux_sigframe *)((char *)l->l_sigstk.ss_sp +
 102                                           l->l_sigstk.ss_size);
 103         else
 104                 fp = (struct linux_sigframe *)tf->tf_usr_sp;
 105         fp--;
 106
 107         /* Build stack frame for signal trampoline. */
 108
 109         /* Save register context. */
 110         frame.sf_sc.sc_r0     = tf->tf_r0;
 111         frame.sf_sc.sc_r1     = tf->tf_r1;
 112         frame.sf_sc.sc_r2     = tf->tf_r2;
 113         frame.sf_sc.sc_r3     = tf->tf_r3;
 114         frame.sf_sc.sc_r4     = tf->tf_r4;
 115         frame.sf_sc.sc_r5     = tf->tf_r5;
 116         frame.sf_sc.sc_r6     = tf->tf_r6;
 117         frame.sf_sc.sc_r7     = tf->tf_r7;
 118         frame.sf_sc.sc_r8     = tf->tf_r8;
 119         frame.sf_sc.sc_r9     = tf->tf_r9;
 120         frame.sf_sc.sc_r10    = tf->tf_r10;
 121         frame.sf_sc.sc_r11    = tf->tf_r11;
 122         frame.sf_sc.sc_r12    = tf->tf_r12;
 123         frame.sf_sc.sc_sp     = tf->tf_usr_sp;
 124         frame.sf_sc.sc_lr     = tf->tf_usr_lr;
 125         frame.sf_sc.sc_pc     = tf->tf_pc;
 126         frame.sf_sc.sc_cpsr   = tf->tf_spsr;
 127
 128         /* Save signal stack. */
 129         /* Linux doesn't save the onstack flag in sigframe */
 130
 131         /* Save signal mask. */
 132         native_to_linux_old_extra_sigset(&frame.sf_sc.sc_mask,
 133             frame.sf_extramask, mask);
 134
 135         /* Other state (mostly faked) */
 136         /*
 137          * trapno should indicate the trap that caused the signal:
 138          * 6  -> undefined instruction
 139          * 11 -> address exception
 140          * 14 -> data/prefetch abort
 141          */
 142         frame.sf_sc.sc_trapno = 0;
 143         frame.sf_sc.sc_error_code = 0;
 144         frame.sf_sc.sc_fault_address = (u_int32_t) ksi->ksi_addr;
 145         sendsig_reset(l, sig);
 146
 147         mutex_exit(p->p_lock);
 148         error = copyout(&frame, fp, sizeof(frame));
 149         mutex_enter(p->p_lock);
 150
 151         if (error != 0) {
 152                 /*
 153                  * Process has trashed its stack; give it an illegal
 154                  * instruction to halt it in its tracks.
 155                  */
 156                 sigexit(l, SIGILL);
 157                 /* NOTREACHED */
 158         }
 159         /*
 160          * Build context to run handler in.
 161          */
 162         tf->tf_r0 = native_to_linux_signo[sig];
 163         tf->tf_r1 = 0; /* XXX Should be a siginfo_t */
 164         tf->tf_r2 = 0;
 165         tf->tf_r3 = (register_t)catcher;
 166         tf->tf_usr_sp = (register_t)fp;
 167         tf->tf_pc = (register_t)p->p_sigctx.ps_sigcode;
 168
 169         /* Remember that we're now on the signal stack. */
 170         if (onstack)
 171                 l->l_sigstk.ss_flags |= SS_ONSTACK;
 172
 173 }
 174
 175 #if 0
 176 /*
 177  * System call to cleanup state after a signal
 178  * has been taken.  Reset signal mask and
 179  * stack state from context left by sendsig (above).
 180  * Return to previous pc and psl as specified by
 181  * context left by sendsig. Check carefully to
 182  * make sure that the user has not modified the
 183  * psl to gain improper privileges or to cause
 184  * a machine fault.
 185  */
 186 int
 187 linux_sys_rt_sigreturn(struct proc *p, void *v, register_t *retval)
 188 {
 189         /* XXX XAX write me */
 190         return(ENOSYS);
 191 }
 192 #endif
 193
 194 int
 195 linux_sys_sigreturn(struct lwp *l, const struct linux_sys_sigreturn_args *v,
 196         register_t *retval)
 197 {
 198         struct linux_sigframe *sfp, frame;
 199         struct proc *p = l->l_proc;
 200         struct trapframe *tf;
 201         sigset_t mask;
 202
 203         tf = process_frame(l);
 204
 205         /*
 206          * The trampoline code hands us the context.
 207          * It is unsafe to keep track of it ourselves, in the event that a
 208          * program jumps out of a signal handler.
 209          */
 210         sfp = (struct linux_sigframe *)tf->tf_usr_sp;
 211         if (copyin((void *)sfp, &frame, sizeof(*sfp)) != 0)
 212                 return (EFAULT);
 213
 214         /*
 215          * Make sure the processor mode has not been tampered with and
 216          * interrupts have not been disabled.
 217          */
 218         if (!VALID_R15_PSR(frame.sf_sc.sc_pc, frame.sf_sc.sc_cpsr))
 219                 return EINVAL;
 220
 221         /* Restore register context. */
 222         tf = process_frame(l);
 223         tf->tf_r0    = frame.sf_sc.sc_r0;
 224         tf->tf_r1    = frame.sf_sc.sc_r1;
 225         tf->tf_r2    = frame.sf_sc.sc_r2;
 226         tf->tf_r3    = frame.sf_sc.sc_r3;
 227         tf->tf_r4    = frame.sf_sc.sc_r4;
 228         tf->tf_r5    = frame.sf_sc.sc_r5;
 229         tf->tf_r6    = frame.sf_sc.sc_r6;
 230         tf->tf_r7    = frame.sf_sc.sc_r7;
 231         tf->tf_r8    = frame.sf_sc.sc_r8;
 232         tf->tf_r9    = frame.sf_sc.sc_r9;
 233         tf->tf_r10   = frame.sf_sc.sc_r10;
 234         tf->tf_r11   = frame.sf_sc.sc_r11;
 235         tf->tf_r12   = frame.sf_sc.sc_r12;
 236         tf->tf_usr_sp = frame.sf_sc.sc_sp;
 237         tf->tf_usr_lr = frame.sf_sc.sc_lr;
 238         tf->tf_pc    = frame.sf_sc.sc_pc;
 239         tf->tf_spsr  = frame.sf_sc.sc_cpsr;
 240
 241         mutex_enter(p->p_lock);
 242
 243         /* Restore signal stack. */
 244         l->l_sigstk.ss_flags &= ~SS_ONSTACK;
 245
 246         /* Restore signal mask. */
 247         linux_old_extra_to_native_sigset(&mask, &frame.sf_sc.sc_mask,
 248             frame.sf_extramask);
 249         (void) sigprocmask1(l, SIG_SETMASK, &mask, 0);
 250
 251         mutex_exit(p->p_lock);
 252
 253         return (EJUSTRETURN);
 254 }
 255
 256 /*
 257  * major device numbers remapping
 258  */
 259 dev_t
 260 linux_fakedev(dev_t dev, int raw)
 261 {
 262         /* XXX write me */
 263         return dev;
 264 }
 265
 266 /*
 267  * We come here in a last attempt to satisfy a Linux ioctl() call
 268  */
 269 int
 270 linux_machdepioctl(struct lwp *l, const struct linux_sys_ioctl_args *uap, register_t *retval)
 271 {
 272         /* {
 273                 syscallarg(int) fd;
 274                 syscallarg(u_long) com;
 275                 syscallarg(void *) data;
 276         } */
 277         struct sys_ioctl_args bia;
 278         u_long com;
 279
 280         SCARG(&bia, fd) = SCARG(uap, fd);
 281         SCARG(&bia, data) = SCARG(uap, data);
 282         com = SCARG(uap, com);
 283
 284         switch (com) {
 285         default:
 286                 printf("linux_machdepioctl: invalid ioctl %08lx\n", com);
 287                 return EINVAL;
 288         }
 289         SCARG(&bia, com) = com;
 290
 291         return sys_ioctl(l, &bia, retval);
 292 }
 293
 294 int
 295 linux_usertrap(struct lwp *l, vaddr_t trapaddr, void *arg)
 296 {
 297         return 0;
 298 }