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
copy_siginfo_to_user32(struct compat_siginfo __user * to,const siginfo_t * from)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
copy_siginfo_from_user32(siginfo_t * to,struct compat_siginfo __user * from)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. */
compat_sys_rt_sigreturn(void)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 */
compat_get_sigframe(struct k_sigaction * ka,struct pt_regs * regs,size_t frame_size)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
compat_setup_rt_frame(struct ksignal * ksig,sigset_t * set,struct pt_regs * regs)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 }
246