arch/x86/um/signal_64.c

   1 /*
   2  * Copyright (C) 2003 PathScale, Inc.
   3  * Copyright (C) 2003 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
   4  * Licensed under the GPL
   5  */
   6
   7 #include <linux/personality.h>
   8 #include <linux/ptrace.h>
   9 #include <linux/kernel.h>
  10 #include <asm/unistd.h>
  11 #include <asm/uaccess.h>
  12 #include <asm/ucontext.h>
  13 #include "frame_kern.h"
  14 #include "skas.h"
  15
  16 static int copy_sc_from_user(struct pt_regs *regs,
  17                              struct sigcontext __user *from)
  18 {
  19         struct sigcontext sc;
  20         struct user_i387_struct fp;
  21         void __user *buf;
  22         int err;
  23
  24         err = copy_from_user(&sc, from, sizeof(sc));
  25         if (err)
  26                 return err;
  27
  28 #define GETREG(regno, regname) regs->regs.gp[HOST_##regno] = sc.regname
  29
  30         GETREG(R8, r8);
  31         GETREG(R9, r9);
  32         GETREG(R10, r10);
  33         GETREG(R11, r11);
  34         GETREG(R12, r12);
  35         GETREG(R13, r13);
  36         GETREG(R14, r14);
  37         GETREG(R15, r15);
  38         GETREG(RDI, di);
  39         GETREG(RSI, si);
  40         GETREG(RBP, bp);
  41         GETREG(RBX, bx);
  42         GETREG(RDX, dx);
  43         GETREG(RAX, ax);
  44         GETREG(RCX, cx);
  45         GETREG(SP, sp);
  46         GETREG(IP, ip);
  47         GETREG(EFLAGS, flags);
  48         GETREG(CS, cs);
  49 #undef GETREG
  50
  51         buf = sc.fpstate;
  52
  53         err = copy_from_user(&fp, buf, sizeof(struct user_i387_struct));
  54         if (err)
  55                 return 1;
  56
  57         err = restore_fp_registers(userspace_pid[current_thread_info()->cpu],
  58                                    (unsigned long *) &fp);
  59         if (err < 0) {
  60                 printk(KERN_ERR "copy_sc_from_user - "
  61                        "restore_fp_registers failed, errno = %d\n",
  62                        -err);
  63                 return 1;
  64         }
  65
  66         return 0;
  67 }
  68
  69 static int copy_sc_to_user(struct sigcontext __user *to,
  70                            struct _fpstate __user *to_fp, struct pt_regs *regs,
  71                            unsigned long mask, unsigned long sp)
  72 {
  73         struct faultinfo * fi = &current->thread.arch.faultinfo;
  74         struct sigcontext sc;
  75         struct user_i387_struct fp;
  76         int err = 0;
  77         memset(&sc, 0, sizeof(struct sigcontext));
  78
  79 #define PUTREG(regno, regname) sc.regname = regs->regs.gp[HOST_##regno]
  80
  81         PUTREG(RDI, di);
  82         PUTREG(RSI, si);
  83         PUTREG(RBP, bp);
  84         /*
  85          * Must use original RSP, which is passed in, rather than what's in
  86          * signal frame.
  87          */
  88         sc.sp = sp;
  89         PUTREG(RBX, bx);
  90         PUTREG(RDX, dx);
  91         PUTREG(RCX, cx);
  92         PUTREG(RAX, ax);
  93         PUTREG(R8, r8);
  94         PUTREG(R9, r9);
  95         PUTREG(R10, r10);
  96         PUTREG(R11, r11);
  97         PUTREG(R12, r12);
  98         PUTREG(R13, r13);
  99         PUTREG(R14, r14);
 100         PUTREG(R15, r15);
 101         PUTREG(CS, cs); /* XXX x86_64 doesn't do this */
 102
 103         sc.cr2 = fi->cr2;
 104         sc.err = fi->error_code;
 105         sc.trapno = fi->trap_no;
 106
 107         PUTREG(IP, ip);
 108         PUTREG(EFLAGS, flags);
 109 #undef PUTREG
 110
 111         sc.oldmask = mask;
 112
 113         err = copy_to_user(to, &sc, sizeof(struct sigcontext));
 114         if (err)
 115                 return 1;
 116
 117         err = save_fp_registers(userspace_pid[current_thread_info()->cpu],
 118                                 (unsigned long *) &fp);
 119         if (err < 0) {
 120                 printk(KERN_ERR "copy_sc_from_user - restore_fp_registers "
 121                        "failed, errno = %d\n", -err);
 122                 return 1;
 123         }
 124
 125         if (copy_to_user(to_fp, &fp, sizeof(struct user_i387_struct)))
 126                 return 1;
 127
 128         return err;
 129 }
 130
 131 struct rt_sigframe
 132 {
 133         char __user *pretcode;
 134         struct ucontext uc;
 135         struct siginfo info;
 136         struct _fpstate fpstate;
 137 };
 138
 139 int setup_signal_stack_si(unsigned long stack_top, int sig,
 140                           struct k_sigaction *ka, struct pt_regs * regs,
 141                           siginfo_t *info, sigset_t *set)
 142 {
 143         struct rt_sigframe __user *frame;
 144         unsigned long save_sp = PT_REGS_RSP(regs);
 145         int err = 0;
 146         struct task_struct *me = current;
 147
 148         frame = (struct rt_sigframe __user *)
 149                 round_down(stack_top - sizeof(struct rt_sigframe), 16);
 150         /* Subtract 128 for a red zone and 8 for proper alignment */
 151         frame = (struct rt_sigframe __user *) ((unsigned long) frame - 128 - 8);
 152
 153         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 154                 goto out;
 155
 156         if (ka->sa.sa_flags & SA_SIGINFO) {
 157                 err |= copy_siginfo_to_user(&frame->info, info);
 158                 if (err)
 159                         goto out;
 160         }
 161
 162         /*
 163          * Update SP now because the page fault handler refuses to extend
 164          * the stack if the faulting address is too far below the current
 165          * SP, which frame now certainly is.  If there's an error, the original
 166          * value is restored on the way out.
 167          * When writing the sigcontext to the stack, we have to write the
 168          * original value, so that's passed to copy_sc_to_user, which does
 169          * the right thing with it.
 170          */
 171         PT_REGS_RSP(regs) = (unsigned long) frame;
 172
 173         /* Create the ucontext.  */
 174         err |= __put_user(0, &frame->uc.uc_flags);
 175         err |= __put_user(0, &frame->uc.uc_link);
 176         err |= __put_user(me->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 177         err |= __put_user(sas_ss_flags(save_sp),
 178                           &frame->uc.uc_stack.ss_flags);
 179         err |= __put_user(me->sas_ss_size, &frame->uc.uc_stack.ss_size);
 180         err |= copy_sc_to_user(&frame->uc.uc_mcontext, &frame->fpstate, regs,
 181                                set->sig[0], save_sp);
 182         err |= __put_user(&frame->fpstate, &frame->uc.uc_mcontext.fpstate);
 183         if (sizeof(*set) == 16) {
 184                 __put_user(set->sig[0], &frame->uc.uc_sigmask.sig[0]);
 185                 __put_user(set->sig[1], &frame->uc.uc_sigmask.sig[1]);
 186         }
 187         else
 188                 err |= __copy_to_user(&frame->uc.uc_sigmask, set,
 189                                       sizeof(*set));
 190
 191         /*
 192          * Set up to return from userspace.  If provided, use a stub
 193          * already in userspace.
 194          */
 195         /* x86-64 should always use SA_RESTORER. */
 196         if (ka->sa.sa_flags & SA_RESTORER)
 197                 err |= __put_user(ka->sa.sa_restorer, &frame->pretcode);
 198         else
 199                 /* could use a vstub here */
 200                 goto restore_sp;
 201
 202         if (err)
 203                 goto restore_sp;
 204
 205         /* Set up registers for signal handler */
 206         {
 207                 struct exec_domain *ed = current_thread_info()->exec_domain;
 208                 if (unlikely(ed && ed->signal_invmap && sig < 32))
 209                         sig = ed->signal_invmap[sig];
 210         }
 211
 212         PT_REGS_RDI(regs) = sig;
 213         /* In case the signal handler was declared without prototypes */
 214         PT_REGS_RAX(regs) = 0;
 215
 216         /*
 217          * This also works for non SA_SIGINFO handlers because they expect the
 218          * next argument after the signal number on the stack.
 219          */
 220         PT_REGS_RSI(regs) = (unsigned long) &frame->info;
 221         PT_REGS_RDX(regs) = (unsigned long) &frame->uc;
 222         PT_REGS_RIP(regs) = (unsigned long) ka->sa.sa_handler;
 223  out:
 224         return err;
 225
 226 restore_sp:
 227         PT_REGS_RSP(regs) = save_sp;
 228         return err;
 229 }
 230
 231 long sys_rt_sigreturn(struct pt_regs *regs)
 232 {
 233         unsigned long sp = PT_REGS_SP(&current->thread.regs);
 234         struct rt_sigframe __user *frame =
 235                 (struct rt_sigframe __user *)(sp - 8);
 236         struct ucontext __user *uc = &frame->uc;
 237         sigset_t set;
 238
 239         if (copy_from_user(&set, &uc->uc_sigmask, sizeof(set)))
 240                 goto segfault;
 241
 242         sigdelsetmask(&set, ~_BLOCKABLE);
 243         set_current_blocked(&set);
 244
 245         if (copy_sc_from_user(&current->thread.regs, &uc->uc_mcontext))
 246                 goto segfault;
 247
 248         /* Avoid ERESTART handling */
 249         PT_REGS_SYSCALL_NR(&current->thread.regs) = -1;
 250         return PT_REGS_SYSCALL_RET(&current->thread.regs);
 251
 252  segfault:
 253         force_sig(SIGSEGV, current);
 254         return 0;
 255 }