a4db3d22aac4802972fd4685e7c96e0c9d706b2c
[linux-3.10.git] / arch / arm64 / kernel / signal32.c
1 /*
2  * Based on arch/arm/kernel/signal.c
3  *
4  * Copyright (C) 1995-2009 Russell King
5  * Copyright (C) 2012 ARM Ltd.
6  * Modified by Will Deacon <will.deacon@arm.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <linux/compat.h>
22 #include <linux/signal.h>
23 #include <linux/syscalls.h>
24 #include <linux/ratelimit.h>
25
26 #include <asm/fpsimd.h>
27 #include <asm/signal32.h>
28 #include <asm/uaccess.h>
29 #include <asm/unistd32.h>
30
31 struct compat_sigaction {
32         compat_uptr_t                   sa_handler;
33         compat_ulong_t                  sa_flags;
34         compat_uptr_t                   sa_restorer;
35         compat_sigset_t                 sa_mask;
36 };
37
38 struct compat_old_sigaction {
39         compat_uptr_t                   sa_handler;
40         compat_old_sigset_t             sa_mask;
41         compat_ulong_t                  sa_flags;
42         compat_uptr_t                   sa_restorer;
43 };
44
45 typedef struct compat_sigaltstack {
46         compat_uptr_t                   ss_sp;
47         int                             ss_flags;
48         compat_size_t                   ss_size;
49 } compat_stack_t;
50
51 struct compat_sigcontext {
52         /* We always set these two fields to 0 */
53         compat_ulong_t                  trap_no;
54         compat_ulong_t                  error_code;
55
56         compat_ulong_t                  oldmask;
57         compat_ulong_t                  arm_r0;
58         compat_ulong_t                  arm_r1;
59         compat_ulong_t                  arm_r2;
60         compat_ulong_t                  arm_r3;
61         compat_ulong_t                  arm_r4;
62         compat_ulong_t                  arm_r5;
63         compat_ulong_t                  arm_r6;
64         compat_ulong_t                  arm_r7;
65         compat_ulong_t                  arm_r8;
66         compat_ulong_t                  arm_r9;
67         compat_ulong_t                  arm_r10;
68         compat_ulong_t                  arm_fp;
69         compat_ulong_t                  arm_ip;
70         compat_ulong_t                  arm_sp;
71         compat_ulong_t                  arm_lr;
72         compat_ulong_t                  arm_pc;
73         compat_ulong_t                  arm_cpsr;
74         compat_ulong_t                  fault_address;
75 };
76
77 struct compat_ucontext {
78         compat_ulong_t                  uc_flags;
79         struct compat_ucontext          *uc_link;
80         compat_stack_t                  uc_stack;
81         struct compat_sigcontext        uc_mcontext;
82         compat_sigset_t                 uc_sigmask;
83         int             __unused[32 - (sizeof (compat_sigset_t) / sizeof (int))];
84         compat_ulong_t  uc_regspace[128] __attribute__((__aligned__(8)));
85 };
86
87 struct compat_vfp_sigframe {
88         compat_ulong_t  magic;
89         compat_ulong_t  size;
90         struct compat_user_vfp {
91                 compat_u64      fpregs[32];
92                 compat_ulong_t  fpscr;
93         } ufp;
94         struct compat_user_vfp_exc {
95                 compat_ulong_t  fpexc;
96                 compat_ulong_t  fpinst;
97                 compat_ulong_t  fpinst2;
98         } ufp_exc;
99 } __attribute__((__aligned__(8)));
100
101 #define VFP_MAGIC               0x56465001
102 #define VFP_STORAGE_SIZE        sizeof(struct compat_vfp_sigframe)
103
104 struct compat_aux_sigframe {
105         struct compat_vfp_sigframe      vfp;
106
107         /* Something that isn't a valid magic number for any coprocessor.  */
108         unsigned long                   end_magic;
109 } __attribute__((__aligned__(8)));
110
111 struct compat_sigframe {
112         struct compat_ucontext  uc;
113         compat_ulong_t          retcode[2];
114 };
115
116 struct compat_rt_sigframe {
117         struct compat_siginfo info;
118         struct compat_sigframe sig;
119 };
120
121 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
122
123 /*
124  * For ARM syscalls, the syscall number has to be loaded into r7.
125  * We do not support an OABI userspace.
126  */
127 #define MOV_R7_NR_SIGRETURN     (0xe3a07000 | __NR_compat_sigreturn)
128 #define SVC_SYS_SIGRETURN       (0xef000000 | __NR_compat_sigreturn)
129 #define MOV_R7_NR_RT_SIGRETURN  (0xe3a07000 | __NR_compat_rt_sigreturn)
130 #define SVC_SYS_RT_SIGRETURN    (0xef000000 | __NR_compat_rt_sigreturn)
131
132 /*
133  * For Thumb syscalls, we also pass the syscall number via r7. We therefore
134  * need two 16-bit instructions.
135  */
136 #define SVC_THUMB_SIGRETURN     (((0xdf00 | __NR_compat_sigreturn) << 16) | \
137                                    0x2700 | __NR_compat_sigreturn)
138 #define SVC_THUMB_RT_SIGRETURN  (((0xdf00 | __NR_compat_rt_sigreturn) << 16) | \
139                                    0x2700 | __NR_compat_rt_sigreturn)
140
141 const compat_ulong_t aarch32_sigret_code[6] = {
142         /*
143          * AArch32 sigreturn code.
144          * We don't construct an OABI SWI - instead we just set the imm24 field
145          * to the EABI syscall number so that we create a sane disassembly.
146          */
147         MOV_R7_NR_SIGRETURN,    SVC_SYS_SIGRETURN,    SVC_THUMB_SIGRETURN,
148         MOV_R7_NR_RT_SIGRETURN, SVC_SYS_RT_SIGRETURN, SVC_THUMB_RT_SIGRETURN,
149 };
150
151 static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
152 {
153         compat_sigset_t cset;
154
155         cset.sig[0] = set->sig[0] & 0xffffffffull;
156         cset.sig[1] = set->sig[0] >> 32;
157
158         return copy_to_user(uset, &cset, sizeof(*uset));
159 }
160
161 static inline int get_sigset_t(sigset_t *set,
162                                const compat_sigset_t __user *uset)
163 {
164         compat_sigset_t s32;
165
166         if (copy_from_user(&s32, uset, sizeof(*uset)))
167                 return -EFAULT;
168
169         set->sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
170         return 0;
171 }
172
173 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
174 {
175         int err;
176
177         if (!access_ok(VERIFY_WRITE, to, sizeof(*to)))
178                 return -EFAULT;
179
180         /* If you change siginfo_t structure, please be sure
181          * this code is fixed accordingly.
182          * It should never copy any pad contained in the structure
183          * to avoid security leaks, but must copy the generic
184          * 3 ints plus the relevant union member.
185          * This routine must convert siginfo from 64bit to 32bit as well
186          * at the same time.
187          */
188         err = __put_user(from->si_signo, &to->si_signo);
189         err |= __put_user(from->si_errno, &to->si_errno);
190         err |= __put_user((short)from->si_code, &to->si_code);
191         if (from->si_code < 0)
192                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad,
193                                       SI_PAD_SIZE);
194         else switch (from->si_code & __SI_MASK) {
195         case __SI_KILL:
196                 err |= __put_user(from->si_pid, &to->si_pid);
197                 err |= __put_user(from->si_uid, &to->si_uid);
198                 break;
199         case __SI_TIMER:
200                  err |= __put_user(from->si_tid, &to->si_tid);
201                  err |= __put_user(from->si_overrun, &to->si_overrun);
202                  err |= __put_user((compat_uptr_t)(unsigned long)from->si_ptr,
203                                    &to->si_ptr);
204                 break;
205         case __SI_POLL:
206                 err |= __put_user(from->si_band, &to->si_band);
207                 err |= __put_user(from->si_fd, &to->si_fd);
208                 break;
209         case __SI_FAULT:
210                 err |= __put_user((compat_uptr_t)(unsigned long)from->si_addr,
211                                   &to->si_addr);
212 #ifdef BUS_MCEERR_AO
213                 /*
214                  * Other callers might not initialize the si_lsb field,
215                  * so check explicitely for the right codes here.
216                  */
217                 if (from->si_code == BUS_MCEERR_AR || from->si_code == BUS_MCEERR_AO)
218                         err |= __put_user(from->si_addr_lsb, &to->si_addr_lsb);
219 #endif
220                 break;
221         case __SI_CHLD:
222                 err |= __put_user(from->si_pid, &to->si_pid);
223                 err |= __put_user(from->si_uid, &to->si_uid);
224                 err |= __put_user(from->si_status, &to->si_status);
225                 err |= __put_user(from->si_utime, &to->si_utime);
226                 err |= __put_user(from->si_stime, &to->si_stime);
227                 break;
228         case __SI_RT: /* This is not generated by the kernel as of now. */
229         case __SI_MESGQ: /* But this is */
230                 err |= __put_user(from->si_pid, &to->si_pid);
231                 err |= __put_user(from->si_uid, &to->si_uid);
232                 err |= __put_user((compat_uptr_t)(unsigned long)from->si_ptr, &to->si_ptr);
233                 break;
234         default: /* this is just in case for now ... */
235                 err |= __put_user(from->si_pid, &to->si_pid);
236                 err |= __put_user(from->si_uid, &to->si_uid);
237                 break;
238         }
239         return err;
240 }
241
242 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
243 {
244         memset(to, 0, sizeof *to);
245
246         if (copy_from_user(to, from, __ARCH_SI_PREAMBLE_SIZE) ||
247             copy_from_user(to->_sifields._pad,
248                            from->_sifields._pad, SI_PAD_SIZE))
249                 return -EFAULT;
250
251         return 0;
252 }
253
254 /*
255  * VFP save/restore code.
256  */
257 static int compat_preserve_vfp_context(struct compat_vfp_sigframe __user *frame)
258 {
259         struct fpsimd_state *fpsimd = &current->thread.fpsimd_state;
260         compat_ulong_t magic = VFP_MAGIC;
261         compat_ulong_t size = VFP_STORAGE_SIZE;
262         compat_ulong_t fpscr, fpexc;
263         int err = 0;
264
265         /*
266          * Save the hardware registers to the fpsimd_state structure.
267          * Note that this also saves V16-31, which aren't visible
268          * in AArch32.
269          */
270         fpsimd_save_state(fpsimd);
271
272         /* Place structure header on the stack */
273         __put_user_error(magic, &frame->magic, err);
274         __put_user_error(size, &frame->size, err);
275
276         /*
277          * Now copy the FP registers. Since the registers are packed,
278          * we can copy the prefix we want (V0-V15) as it is.
279          * FIXME: Won't work if big endian.
280          */
281         err |= __copy_to_user(&frame->ufp.fpregs, fpsimd->vregs,
282                               sizeof(frame->ufp.fpregs));
283
284         /* Create an AArch32 fpscr from the fpsr and the fpcr. */
285         fpscr = (fpsimd->fpsr & VFP_FPSCR_STAT_MASK) |
286                 (fpsimd->fpcr & VFP_FPSCR_CTRL_MASK);
287         __put_user_error(fpscr, &frame->ufp.fpscr, err);
288
289         /*
290          * The exception register aren't available so we fake up a
291          * basic FPEXC and zero everything else.
292          */
293         fpexc = (1 << 30);
294         __put_user_error(fpexc, &frame->ufp_exc.fpexc, err);
295         __put_user_error(0, &frame->ufp_exc.fpinst, err);
296         __put_user_error(0, &frame->ufp_exc.fpinst2, err);
297
298         return err ? -EFAULT : 0;
299 }
300
301 static int compat_restore_vfp_context(struct compat_vfp_sigframe __user *frame)
302 {
303         struct fpsimd_state fpsimd;
304         compat_ulong_t magic = VFP_MAGIC;
305         compat_ulong_t size = VFP_STORAGE_SIZE;
306         compat_ulong_t fpscr;
307         int err = 0;
308
309         __get_user_error(magic, &frame->magic, err);
310         __get_user_error(size, &frame->size, err);
311
312         if (err)
313                 return -EFAULT;
314         if (magic != VFP_MAGIC || size != VFP_STORAGE_SIZE)
315                 return -EINVAL;
316
317         /*
318          * Copy the FP registers into the start of the fpsimd_state.
319          * FIXME: Won't work if big endian.
320          */
321         err |= __copy_from_user(fpsimd.vregs, frame->ufp.fpregs,
322                                 sizeof(frame->ufp.fpregs));
323
324         /* Extract the fpsr and the fpcr from the fpscr */
325         __get_user_error(fpscr, &frame->ufp.fpscr, err);
326         fpsimd.fpsr = fpscr & VFP_FPSCR_STAT_MASK;
327         fpsimd.fpcr = fpscr & VFP_FPSCR_CTRL_MASK;
328
329         /*
330          * We don't need to touch the exception register, so
331          * reload the hardware state.
332          */
333         if (!err) {
334                 preempt_disable();
335                 fpsimd_load_state(&fpsimd);
336                 preempt_enable();
337         }
338
339         return err ? -EFAULT : 0;
340 }
341
342 /*
343  * atomically swap in the new signal mask, and wait for a signal.
344  */
345 asmlinkage int compat_sys_sigsuspend(int restart, compat_ulong_t oldmask,
346                                      compat_old_sigset_t mask)
347 {
348         sigset_t blocked;
349
350         siginitset(&current->blocked, mask);
351         return sigsuspend(&blocked);
352 }
353
354 asmlinkage int compat_sys_sigaction(int sig,
355                                     const struct compat_old_sigaction __user *act,
356                                     struct compat_old_sigaction __user *oact)
357 {
358         struct k_sigaction new_ka, old_ka;
359         int ret;
360         compat_old_sigset_t mask;
361         compat_uptr_t handler, restorer;
362
363         if (act) {
364                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
365                     __get_user(handler, &act->sa_handler) ||
366                     __get_user(restorer, &act->sa_restorer) ||
367                     __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
368                     __get_user(mask, &act->sa_mask))
369                         return -EFAULT;
370
371                 new_ka.sa.sa_handler = compat_ptr(handler);
372                 new_ka.sa.sa_restorer = compat_ptr(restorer);
373                 siginitset(&new_ka.sa.sa_mask, mask);
374         }
375
376         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
377
378         if (!ret && oact) {
379                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
380                     __put_user(ptr_to_compat(old_ka.sa.sa_handler),
381                                &oact->sa_handler) ||
382                     __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
383                                &oact->sa_restorer) ||
384                     __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
385                     __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
386                         return -EFAULT;
387         }
388
389         return ret;
390 }
391
392 asmlinkage int compat_sys_rt_sigaction(int sig,
393                                        const struct compat_sigaction __user *act,
394                                        struct compat_sigaction __user *oact,
395                                        compat_size_t sigsetsize)
396 {
397         struct k_sigaction new_ka, old_ka;
398         int ret;
399
400         /* XXX: Don't preclude handling different sized sigset_t's.  */
401         if (sigsetsize != sizeof(compat_sigset_t))
402                 return -EINVAL;
403
404         if (act) {
405                 compat_uptr_t handler, restorer;
406
407                 ret = get_user(handler, &act->sa_handler);
408                 new_ka.sa.sa_handler = compat_ptr(handler);
409                 ret |= get_user(restorer, &act->sa_restorer);
410                 new_ka.sa.sa_restorer = compat_ptr(restorer);
411                 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask);
412                 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
413                 if (ret)
414                         return -EFAULT;
415         }
416
417         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
418         if (!ret && oact) {
419                 ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), &oact->sa_handler);
420                 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
421                 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
422         }
423         return ret;
424 }
425
426 int compat_do_sigaltstack(compat_uptr_t compat_uss, compat_uptr_t compat_uoss,
427                           compat_ulong_t sp)
428 {
429         compat_stack_t __user *newstack = compat_ptr(compat_uss);
430         compat_stack_t __user *oldstack = compat_ptr(compat_uoss);
431         compat_uptr_t ss_sp;
432         int ret;
433         mm_segment_t old_fs;
434         stack_t uss, uoss;
435
436         /* Marshall the compat new stack into a stack_t */
437         if (newstack) {
438                 if (get_user(ss_sp, &newstack->ss_sp) ||
439                     __get_user(uss.ss_flags, &newstack->ss_flags) ||
440                     __get_user(uss.ss_size, &newstack->ss_size))
441                         return -EFAULT;
442                 uss.ss_sp = compat_ptr(ss_sp);
443         }
444
445         old_fs = get_fs();
446         set_fs(KERNEL_DS);
447         /* The __user pointer casts are valid because of the set_fs() */
448         ret = do_sigaltstack(
449                 newstack ? (stack_t __user *) &uss : NULL,
450                 oldstack ? (stack_t __user *) &uoss : NULL,
451                 (unsigned long)sp);
452         set_fs(old_fs);
453
454         /* Convert the old stack_t into a compat stack. */
455         if (!ret && oldstack &&
456                 (put_user(ptr_to_compat(uoss.ss_sp), &oldstack->ss_sp) ||
457                  __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
458                  __put_user(uoss.ss_size, &oldstack->ss_size)))
459                 return -EFAULT;
460         return ret;
461 }
462
463 static int compat_restore_sigframe(struct pt_regs *regs,
464                                    struct compat_sigframe __user *sf)
465 {
466         int err;
467         sigset_t set;
468         struct compat_aux_sigframe __user *aux;
469
470         err = get_sigset_t(&set, &sf->uc.uc_sigmask);
471         if (err == 0) {
472                 sigdelsetmask(&set, ~_BLOCKABLE);
473                 set_current_blocked(&set);
474         }
475
476         __get_user_error(regs->regs[0], &sf->uc.uc_mcontext.arm_r0, err);
477         __get_user_error(regs->regs[1], &sf->uc.uc_mcontext.arm_r1, err);
478         __get_user_error(regs->regs[2], &sf->uc.uc_mcontext.arm_r2, err);
479         __get_user_error(regs->regs[3], &sf->uc.uc_mcontext.arm_r3, err);
480         __get_user_error(regs->regs[4], &sf->uc.uc_mcontext.arm_r4, err);
481         __get_user_error(regs->regs[5], &sf->uc.uc_mcontext.arm_r5, err);
482         __get_user_error(regs->regs[6], &sf->uc.uc_mcontext.arm_r6, err);
483         __get_user_error(regs->regs[7], &sf->uc.uc_mcontext.arm_r7, err);
484         __get_user_error(regs->regs[8], &sf->uc.uc_mcontext.arm_r8, err);
485         __get_user_error(regs->regs[9], &sf->uc.uc_mcontext.arm_r9, err);
486         __get_user_error(regs->regs[10], &sf->uc.uc_mcontext.arm_r10, err);
487         __get_user_error(regs->regs[11], &sf->uc.uc_mcontext.arm_fp, err);
488         __get_user_error(regs->regs[12], &sf->uc.uc_mcontext.arm_ip, err);
489         __get_user_error(regs->compat_sp, &sf->uc.uc_mcontext.arm_sp, err);
490         __get_user_error(regs->compat_lr, &sf->uc.uc_mcontext.arm_lr, err);
491         __get_user_error(regs->pc, &sf->uc.uc_mcontext.arm_pc, err);
492         __get_user_error(regs->pstate, &sf->uc.uc_mcontext.arm_cpsr, err);
493
494         /*
495          * Avoid compat_sys_sigreturn() restarting.
496          */
497         regs->syscallno = ~0UL;
498
499         err |= !valid_user_regs(&regs->user_regs);
500
501         aux = (struct compat_aux_sigframe __user *) sf->uc.uc_regspace;
502         if (err == 0)
503                 err |= compat_restore_vfp_context(&aux->vfp);
504
505         return err;
506 }
507
508 asmlinkage int compat_sys_sigreturn(struct pt_regs *regs)
509 {
510         struct compat_sigframe __user *frame;
511
512         /* Always make any pending restarted system calls return -EINTR */
513         current_thread_info()->restart_block.fn = do_no_restart_syscall;
514
515         /*
516          * Since we stacked the signal on a 64-bit boundary,
517          * then 'sp' should be word aligned here.  If it's
518          * not, then the user is trying to mess with us.
519          */
520         if (regs->compat_sp & 7)
521                 goto badframe;
522
523         frame = (struct compat_sigframe __user *)regs->compat_sp;
524
525         if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
526                 goto badframe;
527
528         if (compat_restore_sigframe(regs, frame))
529                 goto badframe;
530
531         return regs->regs[0];
532
533 badframe:
534         if (show_unhandled_signals)
535                 pr_info_ratelimited("%s[%d]: bad frame in %s: pc=%08llx sp=%08llx\n",
536                                     current->comm, task_pid_nr(current), __func__,
537                                     regs->pc, regs->sp);
538         force_sig(SIGSEGV, current);
539         return 0;
540 }
541
542 asmlinkage int compat_sys_rt_sigreturn(struct pt_regs *regs)
543 {
544         struct compat_rt_sigframe __user *frame;
545
546         /* Always make any pending restarted system calls return -EINTR */
547         current_thread_info()->restart_block.fn = do_no_restart_syscall;
548
549         /*
550          * Since we stacked the signal on a 64-bit boundary,
551          * then 'sp' should be word aligned here.  If it's
552          * not, then the user is trying to mess with us.
553          */
554         if (regs->compat_sp & 7)
555                 goto badframe;
556
557         frame = (struct compat_rt_sigframe __user *)regs->compat_sp;
558
559         if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
560                 goto badframe;
561
562         if (compat_restore_sigframe(regs, &frame->sig))
563                 goto badframe;
564
565         if (compat_do_sigaltstack(ptr_to_compat(&frame->sig.uc.uc_stack),
566                                  ptr_to_compat((void __user *)NULL),
567                                  regs->compat_sp) == -EFAULT)
568                 goto badframe;
569
570         return regs->regs[0];
571
572 badframe:
573         if (show_unhandled_signals)
574                 pr_info_ratelimited("%s[%d]: bad frame in %s: pc=%08llx sp=%08llx\n",
575                                     current->comm, task_pid_nr(current), __func__,
576                                     regs->pc, regs->sp);
577         force_sig(SIGSEGV, current);
578         return 0;
579 }
580
581 static void __user *compat_get_sigframe(struct k_sigaction *ka,
582                                         struct pt_regs *regs,
583                                         int framesize)
584 {
585         compat_ulong_t sp = regs->compat_sp;
586         void __user *frame;
587
588         /*
589          * This is the X/Open sanctioned signal stack switching.
590          */
591         if ((ka->sa.sa_flags & SA_ONSTACK) && !sas_ss_flags(sp))
592                 sp = current->sas_ss_sp + current->sas_ss_size;
593
594         /*
595          * ATPCS B01 mandates 8-byte alignment
596          */
597         frame = compat_ptr((compat_uptr_t)((sp - framesize) & ~7));
598
599         /*
600          * Check that we can actually write to the signal frame.
601          */
602         if (!access_ok(VERIFY_WRITE, frame, framesize))
603                 frame = NULL;
604
605         return frame;
606 }
607
608 static void compat_setup_return(struct pt_regs *regs, struct k_sigaction *ka,
609                                 compat_ulong_t __user *rc, void __user *frame,
610                                 int usig)
611 {
612         compat_ulong_t handler = ptr_to_compat(ka->sa.sa_handler);
613         compat_ulong_t retcode;
614         compat_ulong_t spsr = regs->pstate & ~PSR_f;
615         int thumb;
616
617         /* Check if the handler is written for ARM or Thumb */
618         thumb = handler & 1;
619
620         if (thumb) {
621                 spsr |= COMPAT_PSR_T_BIT;
622                 spsr &= ~COMPAT_PSR_IT_MASK;
623         } else {
624                 spsr &= ~COMPAT_PSR_T_BIT;
625         }
626
627         if (ka->sa.sa_flags & SA_RESTORER) {
628                 retcode = ptr_to_compat(ka->sa.sa_restorer);
629         } else {
630                 /* Set up sigreturn pointer */
631                 unsigned int idx = thumb << 1;
632
633                 if (ka->sa.sa_flags & SA_SIGINFO)
634                         idx += 3;
635
636                 retcode = AARCH32_VECTORS_BASE +
637                           AARCH32_KERN_SIGRET_CODE_OFFSET +
638                           (idx << 2) + thumb;
639         }
640
641         regs->regs[0]   = usig;
642         regs->compat_sp = ptr_to_compat(frame);
643         regs->compat_lr = retcode;
644         regs->pc        = handler;
645         regs->pstate    = spsr;
646 }
647
648 static int compat_setup_sigframe(struct compat_sigframe __user *sf,
649                                  struct pt_regs *regs, sigset_t *set)
650 {
651         struct compat_aux_sigframe __user *aux;
652         int err = 0;
653
654         __put_user_error(regs->regs[0], &sf->uc.uc_mcontext.arm_r0, err);
655         __put_user_error(regs->regs[1], &sf->uc.uc_mcontext.arm_r1, err);
656         __put_user_error(regs->regs[2], &sf->uc.uc_mcontext.arm_r2, err);
657         __put_user_error(regs->regs[3], &sf->uc.uc_mcontext.arm_r3, err);
658         __put_user_error(regs->regs[4], &sf->uc.uc_mcontext.arm_r4, err);
659         __put_user_error(regs->regs[5], &sf->uc.uc_mcontext.arm_r5, err);
660         __put_user_error(regs->regs[6], &sf->uc.uc_mcontext.arm_r6, err);
661         __put_user_error(regs->regs[7], &sf->uc.uc_mcontext.arm_r7, err);
662         __put_user_error(regs->regs[8], &sf->uc.uc_mcontext.arm_r8, err);
663         __put_user_error(regs->regs[9], &sf->uc.uc_mcontext.arm_r9, err);
664         __put_user_error(regs->regs[10], &sf->uc.uc_mcontext.arm_r10, err);
665         __put_user_error(regs->regs[11], &sf->uc.uc_mcontext.arm_fp, err);
666         __put_user_error(regs->regs[12], &sf->uc.uc_mcontext.arm_ip, err);
667         __put_user_error(regs->compat_sp, &sf->uc.uc_mcontext.arm_sp, err);
668         __put_user_error(regs->compat_lr, &sf->uc.uc_mcontext.arm_lr, err);
669         __put_user_error(regs->pc, &sf->uc.uc_mcontext.arm_pc, err);
670         __put_user_error(regs->pstate, &sf->uc.uc_mcontext.arm_cpsr, err);
671
672         __put_user_error((compat_ulong_t)0, &sf->uc.uc_mcontext.trap_no, err);
673         __put_user_error((compat_ulong_t)0, &sf->uc.uc_mcontext.error_code, err);
674         __put_user_error(current->thread.fault_address, &sf->uc.uc_mcontext.fault_address, err);
675         __put_user_error(set->sig[0], &sf->uc.uc_mcontext.oldmask, err);
676
677         err |= put_sigset_t(&sf->uc.uc_sigmask, set);
678
679         aux = (struct compat_aux_sigframe __user *) sf->uc.uc_regspace;
680
681         if (err == 0)
682                 err |= compat_preserve_vfp_context(&aux->vfp);
683         __put_user_error(0, &aux->end_magic, err);
684
685         return err;
686 }
687
688 /*
689  * 32-bit signal handling routines called from signal.c
690  */
691 int compat_setup_rt_frame(int usig, struct k_sigaction *ka, siginfo_t *info,
692                           sigset_t *set, struct pt_regs *regs)
693 {
694         struct compat_rt_sigframe __user *frame;
695         compat_stack_t stack;
696         int err = 0;
697
698         frame = compat_get_sigframe(ka, regs, sizeof(*frame));
699
700         if (!frame)
701                 return 1;
702
703         err |= copy_siginfo_to_user32(&frame->info, info);
704
705         __put_user_error(0, &frame->sig.uc.uc_flags, err);
706         __put_user_error(NULL, &frame->sig.uc.uc_link, err);
707
708         memset(&stack, 0, sizeof(stack));
709         stack.ss_sp = (compat_uptr_t)current->sas_ss_sp;
710         stack.ss_flags = sas_ss_flags(regs->compat_sp);
711         stack.ss_size = current->sas_ss_size;
712         err |= __copy_to_user(&frame->sig.uc.uc_stack, &stack, sizeof(stack));
713
714         err |= compat_setup_sigframe(&frame->sig, regs, set);
715
716         if (err == 0) {
717                 compat_setup_return(regs, ka, frame->sig.retcode, frame, usig);
718                 regs->regs[1] = (compat_ulong_t)(unsigned long)&frame->info;
719                 regs->regs[2] = (compat_ulong_t)(unsigned long)&frame->sig.uc;
720         }
721
722         return err;
723 }
724
725 int compat_setup_frame(int usig, struct k_sigaction *ka, sigset_t *set,
726                        struct pt_regs *regs)
727 {
728         struct compat_sigframe __user *frame;
729         int err = 0;
730
731         frame = compat_get_sigframe(ka, regs, sizeof(*frame));
732
733         if (!frame)
734                 return 1;
735
736         __put_user_error(0x5ac3c35a, &frame->uc.uc_flags, err);
737
738         err |= compat_setup_sigframe(frame, regs, set);
739         if (err == 0)
740                 compat_setup_return(regs, ka, frame->retcode, frame, usig);
741
742         return err;
743 }
744
745 /*
746  * RT signals don't have generic compat wrappers.
747  * See arch/powerpc/kernel/signal_32.c
748  */
749 asmlinkage int compat_sys_rt_sigprocmask(int how, compat_sigset_t __user *set,
750                                          compat_sigset_t __user *oset,
751                                          compat_size_t sigsetsize)
752 {
753         sigset_t s;
754         sigset_t __user *up;
755         int ret;
756         mm_segment_t old_fs = get_fs();
757
758         if (set) {
759                 if (get_sigset_t(&s, set))
760                         return -EFAULT;
761         }
762
763         set_fs(KERNEL_DS);
764         /* This is valid because of the set_fs() */
765         up = (sigset_t __user *) &s;
766         ret = sys_rt_sigprocmask(how, set ? up : NULL, oset ? up : NULL,
767                                  sigsetsize);
768         set_fs(old_fs);
769         if (ret)
770                 return ret;
771         if (oset) {
772                 if (put_sigset_t(oset, &s))
773                         return -EFAULT;
774         }
775         return 0;
776 }
777
778 asmlinkage int compat_sys_rt_sigpending(compat_sigset_t __user *set,
779                                         compat_size_t sigsetsize)
780 {
781         sigset_t s;
782         int ret;
783         mm_segment_t old_fs = get_fs();
784
785         set_fs(KERNEL_DS);
786         /* The __user pointer cast is valid because of the set_fs() */
787         ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
788         set_fs(old_fs);
789         if (!ret) {
790                 if (put_sigset_t(set, &s))
791                         return -EFAULT;
792         }
793         return ret;
794 }
795
796 asmlinkage int compat_sys_rt_sigqueueinfo(int pid, int sig,
797                                           compat_siginfo_t __user *uinfo)
798 {
799         siginfo_t info;
800         int ret;
801         mm_segment_t old_fs = get_fs();
802
803         ret = copy_siginfo_from_user32(&info, uinfo);
804         if (unlikely(ret))
805                 return ret;
806
807         set_fs (KERNEL_DS);
808         /* The __user pointer cast is valid because of the set_fs() */
809         ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *) &info);
810         set_fs (old_fs);
811         return ret;
812 }
813
814 void compat_setup_restart_syscall(struct pt_regs *regs)
815 {
816        regs->regs[7] = __NR_compat_restart_syscall;
817 }