1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50#include <linux/signal.h>
51#include <linux/ptrace.h>
52#include <linux/personality.h>
53#include <linux/uaccess.h>
54#include <linux/syscalls.h>
55#include <linux/tracehook.h>
56#include <asm/ucontext.h>
57
58struct rt_sigframe {
59 struct siginfo info;
60 struct ucontext uc;
61#define MAGIC_SIGALTSTK 0x07302004
62 unsigned int sigret_magic;
63};
64
65static int
66stash_usr_regs(struct rt_sigframe __user *sf, struct pt_regs *regs,
67 sigset_t *set)
68{
69 int err;
70 err = __copy_to_user(&(sf->uc.uc_mcontext.regs), regs,
71 sizeof(sf->uc.uc_mcontext.regs.scratch));
72 err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(sigset_t));
73
74 return err;
75}
76
77static int restore_usr_regs(struct pt_regs *regs, struct rt_sigframe __user *sf)
78{
79 sigset_t set;
80 int err;
81
82 err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
83 if (!err)
84 set_current_blocked(&set);
85
86 err |= __copy_from_user(regs, &(sf->uc.uc_mcontext.regs),
87 sizeof(sf->uc.uc_mcontext.regs.scratch));
88
89 return err;
90}
91
92static inline int is_do_ss_needed(unsigned int magic)
93{
94 if (MAGIC_SIGALTSTK == magic)
95 return 1;
96 else
97 return 0;
98}
99
100SYSCALL_DEFINE0(rt_sigreturn)
101{
102 struct rt_sigframe __user *sf;
103 unsigned int magic;
104 int err;
105 struct pt_regs *regs = current_pt_regs();
106
107
108 current_thread_info()->restart_block.fn = do_no_restart_syscall;
109
110
111
112
113
114 if (regs->sp & 3)
115 goto badframe;
116
117 sf = (struct rt_sigframe __force __user *)(regs->sp);
118
119 if (!access_ok(VERIFY_READ, sf, sizeof(*sf)))
120 goto badframe;
121
122 err = restore_usr_regs(regs, sf);
123 err |= __get_user(magic, &sf->sigret_magic);
124 if (err)
125 goto badframe;
126
127 if (unlikely(is_do_ss_needed(magic)))
128 if (restore_altstack(&sf->uc.uc_stack))
129 goto badframe;
130
131
132 syscall_wont_restart(regs);
133
134 return regs->r0;
135
136badframe:
137 force_sig(SIGSEGV, current);
138 return 0;
139}
140
141
142
143
144static inline void __user *get_sigframe(struct k_sigaction *ka,
145 struct pt_regs *regs,
146 unsigned long framesize)
147{
148 unsigned long sp = regs->sp;
149 void __user *frame;
150
151
152 if ((ka->sa.sa_flags & SA_ONSTACK) && !sas_ss_flags(sp))
153 sp = current->sas_ss_sp + current->sas_ss_size;
154
155
156
157
158
159
160 frame = (void __user *)((sp - framesize) & ~7);
161
162
163 if (!access_ok(VERIFY_WRITE, frame, framesize))
164 frame = NULL;
165
166 return frame;
167}
168
169
170
171
172static inline int map_sig(int sig)
173{
174 struct thread_info *thread = current_thread_info();
175 if (thread->exec_domain && thread->exec_domain->signal_invmap
176 && sig < 32)
177 sig = thread->exec_domain->signal_invmap[sig];
178 return sig;
179}
180
181static int
182setup_rt_frame(int signo, struct k_sigaction *ka, siginfo_t *info,
183 sigset_t *set, struct pt_regs *regs)
184{
185 struct rt_sigframe __user *sf;
186 unsigned int magic = 0;
187 int err = 0;
188
189 sf = get_sigframe(ka, regs, sizeof(struct rt_sigframe));
190 if (!sf)
191 return 1;
192
193
194
195
196
197
198
199 if (unlikely(ka->sa.sa_flags & SA_SIGINFO)) {
200 err |= copy_siginfo_to_user(&sf->info, info);
201 err |= __put_user(0, &sf->uc.uc_flags);
202 err |= __put_user(NULL, &sf->uc.uc_link);
203 err |= __save_altstack(&sf->uc.uc_stack, regs->sp);
204
205
206 regs->r1 = (unsigned long)&sf->info;
207 regs->r2 = (unsigned long)&sf->uc;
208
209
210
211
212
213 magic = MAGIC_SIGALTSTK;
214 }
215
216
217
218
219
220
221
222
223 err |= stash_usr_regs(sf, regs, set);
224 err |= __put_user(magic, &sf->sigret_magic);
225 if (err)
226 return err;
227
228
229 regs->r0 = map_sig(signo);
230
231
232 regs->ret = (unsigned long)ka->sa.sa_handler;
233
234
235
236
237 BUG_ON(!(ka->sa.sa_flags & SA_RESTORER));
238 regs->blink = (unsigned long)ka->sa.sa_restorer;
239
240
241 regs->sp = (unsigned long)sf;
242
243
244
245
246
247 regs->status32 &= ~STATUS_DE_MASK;
248 regs->status32 |= STATUS_L_MASK;
249
250 return err;
251}
252
253static void arc_restart_syscall(struct k_sigaction *ka, struct pt_regs *regs)
254{
255 switch (regs->r0) {
256 case -ERESTART_RESTARTBLOCK:
257 case -ERESTARTNOHAND:
258
259
260
261
262
263
264 regs->r0 = -EINTR;
265 break;
266
267 case -ERESTARTSYS:
268
269
270
271
272
273 if (!(ka->sa.sa_flags & SA_RESTART)) {
274 regs->r0 = -EINTR;
275 break;
276 }
277
278
279 case -ERESTARTNOINTR:
280
281
282
283
284
285
286
287
288
289
290 regs->r0 = regs->orig_r0;
291 regs->ret -= 4;
292 break;
293 }
294}
295
296
297
298
299static void
300handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
301 struct pt_regs *regs)
302{
303 sigset_t *oldset = sigmask_to_save();
304 int ret;
305
306
307 ret = setup_rt_frame(sig, ka, info, oldset, regs);
308
309 if (ret)
310 force_sigsegv(sig, current);
311 else
312 signal_delivered(sig, info, ka, regs, 0);
313}
314
315void do_signal(struct pt_regs *regs)
316{
317 struct k_sigaction ka;
318 siginfo_t info;
319 int signr;
320 int restart_scall;
321
322 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
323
324 restart_scall = in_syscall(regs) && syscall_restartable(regs);
325
326 if (signr > 0) {
327 if (restart_scall) {
328 arc_restart_syscall(&ka, regs);
329 syscall_wont_restart(regs);
330 }
331 handle_signal(signr, &ka, &info, regs);
332 return;
333 }
334
335 if (restart_scall) {
336
337 if (regs->r0 == -ERESTARTNOHAND ||
338 regs->r0 == -ERESTARTSYS || regs->r0 == -ERESTARTNOINTR) {
339 regs->r0 = regs->orig_r0;
340 regs->ret -= 4;
341 } else if (regs->r0 == -ERESTART_RESTARTBLOCK) {
342 regs->r8 = __NR_restart_syscall;
343 regs->ret -= 4;
344 }
345 syscall_wont_restart(regs);
346 }
347
348
349 restore_saved_sigmask();
350}
351
352void do_notify_resume(struct pt_regs *regs)
353{
354
355
356
357
358 if (test_and_clear_thread_flag(TIF_NOTIFY_RESUME))
359 tracehook_notify_resume(regs);
360}
361