arch/tile/kernel/compat_signal.c

   1 /*
   2  * Copyright 2010 Tilera Corporation. All Rights Reserved.
   3  *
   4  *   This program is free software; you can redistribute it and/or
   5  *   modify it under the terms of the GNU General Public License
   6  *   as published by the Free Software Foundation, version 2.
   7  *
   8  *   This program is distributed in the hope that it will be useful, but
   9  *   WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  11  *   NON INFRINGEMENT.  See the GNU General Public License for
  12  *   more details.
  13  */
  14
  15 #include <linux/sched.h>
  16 #include <linux/sched/task_stack.h>
  17 #include <linux/mm.h>
  18 #include <linux/smp.h>
  19 #include <linux/kernel.h>
  20 #include <linux/signal.h>
  21 #include <linux/errno.h>
  22 #include <linux/wait.h>
  23 #include <linux/unistd.h>
  24 #include <linux/stddef.h>
  25 #include <linux/personality.h>
  26 #include <linux/suspend.h>
  27 #include <linux/ptrace.h>
  28 #include <linux/elf.h>
  29 #include <linux/compat.h>
  30 #include <linux/syscalls.h>
  31 #include <linux/uaccess.h>
  32 #include <asm/processor.h>
  33 #include <asm/ucontext.h>
  34 #include <asm/sigframe.h>
  35 #include <asm/syscalls.h>
  36 #include <asm/vdso.h>
  37 #include <arch/interrupts.h>
  38
  39 struct compat_ucontext {
  40         compat_ulong_t    uc_flags;
  41         compat_uptr_t     uc_link;
  42         struct compat_sigaltstack         uc_stack;
  43         struct sigcontext uc_mcontext;
  44         sigset_t          uc_sigmask;   /* mask last for extensibility */
  45 };
  46
  47 struct compat_rt_sigframe {
  48         unsigned char save_area[C_ABI_SAVE_AREA_SIZE]; /* caller save area */
  49         struct compat_siginfo info;
  50         struct compat_ucontext uc;
  51 };
  52
  53 int copy_siginfo_to_user32(struct compat_siginfo __user *to, const siginfo_t *from)
  54 {
  55         int err;
  56
  57         if (!access_ok(VERIFY_WRITE, to, sizeof(struct compat_siginfo)))
  58                 return -EFAULT;
  59
  60         /* If you change siginfo_t structure, please make sure that
  61            this code is fixed accordingly.
  62            It should never copy any pad contained in the structure
  63            to avoid security leaks, but must copy the generic
  64            3 ints plus the relevant union member.  */
  65         err = __put_user(from->si_signo, &to->si_signo);
  66         err |= __put_user(from->si_errno, &to->si_errno);
  67         err |= __put_user(from->si_code, &to->si_code);
  68
  69         if (from->si_code < 0) {
  70                 err |= __put_user(from->si_pid, &to->si_pid);
  71                 err |= __put_user(from->si_uid, &to->si_uid);
  72                 err |= __put_user(from->si_int, &to->si_int);
  73         } else {
  74                 /*
  75                  * First 32bits of unions are always present:
  76                  * si_pid === si_band === si_tid === si_addr(LS half)
  77                  */
  78                 err |= __put_user(from->_sifields._pad[0],
  79                                   &to->_sifields._pad[0]);
  80                 switch (siginfo_layout(from->si_signo, from->si_code)) {
  81                 case SIL_FAULT:
  82                         break;
  83                 case SIL_CHLD:
  84                         err |= __put_user(from->si_utime, &to->si_utime);
  85                         err |= __put_user(from->si_stime, &to->si_stime);
  86                         err |= __put_user(from->si_status, &to->si_status);
  87                         /* FALL THROUGH */
  88                 default:
  89                 case SIL_KILL:
  90                         err |= __put_user(from->si_uid, &to->si_uid);
  91                         break;
  92                 case SIL_POLL:
  93                         err |= __put_user(from->si_fd, &to->si_fd);
  94                         break;
  95                 case SIL_TIMER:
  96                         err |= __put_user(from->si_overrun, &to->si_overrun);
  97                         err |= __put_user(from->si_int, &to->si_int);
  98                         break;
  99                 case SIL_RT:
 100                         err |= __put_user(from->si_uid, &to->si_uid);
 101                         err |= __put_user(from->si_int, &to->si_int);
 102                         break;
 103                 }
 104         }
 105         return err;
 106 }
 107
 108 int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from)
 109 {
 110         int err;
 111
 112         if (!access_ok(VERIFY_READ, from, sizeof(struct compat_siginfo)))
 113                 return -EFAULT;
 114
 115         err = __get_user(to->si_signo, &from->si_signo);
 116         err |= __get_user(to->si_errno, &from->si_errno);
 117         err |= __get_user(to->si_code, &from->si_code);
 118
 119         err |= __get_user(to->si_pid, &from->si_pid);
 120         err |= __get_user(to->si_uid, &from->si_uid);
 121         err |= __get_user(to->si_int, &from->si_int);
 122
 123         return err;
 124 }
 125
 126 /* The assembly shim for this function arranges to ignore the return value. */
 127 long compat_sys_rt_sigreturn(void)
 128 {
 129         struct pt_regs *regs = current_pt_regs();
 130         struct compat_rt_sigframe __user *frame =
 131                 (struct compat_rt_sigframe __user *) compat_ptr(regs->sp);
 132         sigset_t set;
 133
 134         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 135                 goto badframe;
 136         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 137                 goto badframe;
 138
 139         set_current_blocked(&set);
 140
 141         if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
 142                 goto badframe;
 143
 144         if (compat_restore_altstack(&frame->uc.uc_stack))
 145                 goto badframe;
 146
 147         return 0;
 148
 149 badframe:
 150         signal_fault("bad sigreturn frame", regs, frame, 0);
 151         return 0;
 152 }
 153
 154 /*
 155  * Determine which stack to use..
 156  */
 157 static inline void __user *compat_get_sigframe(struct k_sigaction *ka,
 158                                                struct pt_regs *regs,
 159                                                size_t frame_size)
 160 {
 161         unsigned long sp;
 162
 163         /* Default to using normal stack */
 164         sp = (unsigned long)compat_ptr(regs->sp);
 165
 166         /*
 167          * If we are on the alternate signal stack and would overflow
 168          * it, don't.  Return an always-bogus address instead so we
 169          * will die with SIGSEGV.
 170          */
 171         if (on_sig_stack(sp) && !likely(on_sig_stack(sp - frame_size)))
 172                 return (void __user __force *)-1UL;
 173
 174         /* This is the X/Open sanctioned signal stack switching.  */
 175         if (ka->sa.sa_flags & SA_ONSTACK) {
 176                 if (sas_ss_flags(sp) == 0)
 177                         sp = current->sas_ss_sp + current->sas_ss_size;
 178         }
 179
 180         sp -= frame_size;
 181         /*
 182          * Align the stack pointer according to the TILE ABI,
 183          * i.e. so that on function entry (sp & 15) == 0.
 184          */
 185         sp &= -16UL;
 186         return (void __user *) sp;
 187 }
 188
 189 int compat_setup_rt_frame(struct ksignal *ksig, sigset_t *set,
 190                           struct pt_regs *regs)
 191 {
 192         unsigned long restorer;
 193         struct compat_rt_sigframe __user *frame;
 194         int err = 0, sig = ksig->sig;
 195
 196         frame = compat_get_sigframe(&ksig->ka, regs, sizeof(*frame));
 197
 198         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 199                 goto err;
 200
 201         /* Always write at least the signal number for the stack backtracer. */
 202         if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
 203                 /* At sigreturn time, restore the callee-save registers too. */
 204                 err |= copy_siginfo_to_user32(&frame->info, &ksig->info);
 205                 regs->flags |= PT_FLAGS_RESTORE_REGS;
 206         } else {
 207                 err |= __put_user(ksig->info.si_signo, &frame->info.si_signo);
 208         }
 209
 210         /* Create the ucontext.  */
 211         err |= __clear_user(&frame->save_area, sizeof(frame->save_area));
 212         err |= __put_user(0, &frame->uc.uc_flags);
 213         err |= __put_user(0, &frame->uc.uc_link);
 214         err |= __compat_save_altstack(&frame->uc.uc_stack, regs->sp);
 215         err |= setup_sigcontext(&frame->uc.uc_mcontext, regs);
 216         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 217         if (err)
 218                 goto err;
 219
 220         restorer = VDSO_SYM(&__vdso_rt_sigreturn);
 221         if (ksig->ka.sa.sa_flags & SA_RESTORER)
 222                 restorer = ptr_to_compat_reg(ksig->ka.sa.sa_restorer);
 223
 224         /*
 225          * Set up registers for signal handler.
 226          * Registers that we don't modify keep the value they had from
 227          * user-space at the time we took the signal.
 228          * We always pass siginfo and mcontext, regardless of SA_SIGINFO,
 229          * since some things rely on this (e.g. glibc's debug/segfault.c).
 230          */
 231         regs->pc = ptr_to_compat_reg(ksig->ka.sa.sa_handler);
 232         regs->ex1 = PL_ICS_EX1(USER_PL, 1); /* set crit sec in handler */
 233         regs->sp = ptr_to_compat_reg(frame);
 234         regs->lr = restorer;
 235         regs->regs[0] = (unsigned long) sig;
 236         regs->regs[1] = ptr_to_compat_reg(&frame->info);
 237         regs->regs[2] = ptr_to_compat_reg(&frame->uc);
 238         regs->flags |= PT_FLAGS_CALLER_SAVES;
 239         return 0;
 240
 241 err:
 242         trace_unhandled_signal("bad sigreturn frame", regs,
 243                               (unsigned long)frame, SIGSEGV);
 244         return -EFAULT;
 245 }