Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * linux/arch/arm/kernel/signal.c
4 : : *
5 : : * Copyright (C) 1995-2009 Russell King
6 : : */
7 : : #include <linux/errno.h>
8 : : #include <linux/random.h>
9 : : #include <linux/signal.h>
10 : : #include <linux/personality.h>
11 : : #include <linux/uaccess.h>
12 : : #include <linux/tracehook.h>
13 : : #include <linux/uprobes.h>
14 : : #include <linux/syscalls.h>
15 : :
16 : : #include <asm/elf.h>
17 : : #include <asm/cacheflush.h>
18 : : #include <asm/traps.h>
19 : : #include <asm/unistd.h>
20 : : #include <asm/vfp.h>
21 : :
22 : : #include "signal.h"
23 : :
24 : : extern const unsigned long sigreturn_codes[17];
25 : :
26 : : static unsigned long signal_return_offset;
27 : :
28 : : #ifdef CONFIG_CRUNCH
29 : : static int preserve_crunch_context(struct crunch_sigframe __user *frame)
30 : : {
31 : : char kbuf[sizeof(*frame) + 8];
32 : : struct crunch_sigframe *kframe;
33 : :
34 : : /* the crunch context must be 64 bit aligned */
35 : : kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
36 : : kframe->magic = CRUNCH_MAGIC;
37 : : kframe->size = CRUNCH_STORAGE_SIZE;
38 : : crunch_task_copy(current_thread_info(), &kframe->storage);
39 : : return __copy_to_user(frame, kframe, sizeof(*frame));
40 : : }
41 : :
42 : : static int restore_crunch_context(char __user **auxp)
43 : : {
44 : : struct crunch_sigframe __user *frame =
45 : : (struct crunch_sigframe __user *)*auxp;
46 : : char kbuf[sizeof(*frame) + 8];
47 : : struct crunch_sigframe *kframe;
48 : :
49 : : /* the crunch context must be 64 bit aligned */
50 : : kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
51 : : if (__copy_from_user(kframe, frame, sizeof(*frame)))
52 : : return -1;
53 : : if (kframe->magic != CRUNCH_MAGIC ||
54 : : kframe->size != CRUNCH_STORAGE_SIZE)
55 : : return -1;
56 : : *auxp += CRUNCH_STORAGE_SIZE;
57 : : crunch_task_restore(current_thread_info(), &kframe->storage);
58 : : return 0;
59 : : }
60 : : #endif
61 : :
62 : : #ifdef CONFIG_IWMMXT
63 : :
64 : : static int preserve_iwmmxt_context(struct iwmmxt_sigframe __user *frame)
65 : : {
66 : : char kbuf[sizeof(*frame) + 8];
67 : : struct iwmmxt_sigframe *kframe;
68 : : int err = 0;
69 : :
70 : : /* the iWMMXt context must be 64 bit aligned */
71 : : kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
72 : :
73 : : if (test_thread_flag(TIF_USING_IWMMXT)) {
74 : : kframe->magic = IWMMXT_MAGIC;
75 : : kframe->size = IWMMXT_STORAGE_SIZE;
76 : : iwmmxt_task_copy(current_thread_info(), &kframe->storage);
77 : : } else {
78 : : /*
79 : : * For bug-compatibility with older kernels, some space
80 : : * has to be reserved for iWMMXt even if it's not used.
81 : : * Set the magic and size appropriately so that properly
82 : : * written userspace can skip it reliably:
83 : : */
84 : : *kframe = (struct iwmmxt_sigframe) {
85 : : .magic = DUMMY_MAGIC,
86 : : .size = IWMMXT_STORAGE_SIZE,
87 : : };
88 : : }
89 : :
90 : : err = __copy_to_user(frame, kframe, sizeof(*kframe));
91 : :
92 : : return err;
93 : : }
94 : :
95 : : static int restore_iwmmxt_context(char __user **auxp)
96 : : {
97 : : struct iwmmxt_sigframe __user *frame =
98 : : (struct iwmmxt_sigframe __user *)*auxp;
99 : : char kbuf[sizeof(*frame) + 8];
100 : : struct iwmmxt_sigframe *kframe;
101 : :
102 : : /* the iWMMXt context must be 64 bit aligned */
103 : : kframe = (struct iwmmxt_sigframe *)((unsigned long)(kbuf + 8) & ~7);
104 : : if (__copy_from_user(kframe, frame, sizeof(*frame)))
105 : : return -1;
106 : :
107 : : /*
108 : : * For non-iWMMXt threads: a single iwmmxt_sigframe-sized dummy
109 : : * block is discarded for compatibility with setup_sigframe() if
110 : : * present, but we don't mandate its presence. If some other
111 : : * magic is here, it's not for us:
112 : : */
113 : : if (!test_thread_flag(TIF_USING_IWMMXT) &&
114 : : kframe->magic != DUMMY_MAGIC)
115 : : return 0;
116 : :
117 : : if (kframe->size != IWMMXT_STORAGE_SIZE)
118 : : return -1;
119 : :
120 : : if (test_thread_flag(TIF_USING_IWMMXT)) {
121 : : if (kframe->magic != IWMMXT_MAGIC)
122 : : return -1;
123 : :
124 : : iwmmxt_task_restore(current_thread_info(), &kframe->storage);
125 : : }
126 : :
127 : : *auxp += IWMMXT_STORAGE_SIZE;
128 : : return 0;
129 : : }
130 : :
131 : : #endif
132 : :
133 : : #ifdef CONFIG_VFP
134 : :
135 : 3 : static int preserve_vfp_context(struct vfp_sigframe __user *frame)
136 : : {
137 : : struct vfp_sigframe kframe;
138 : : int err = 0;
139 : :
140 : 3 : memset(&kframe, 0, sizeof(kframe));
141 : 3 : kframe.magic = VFP_MAGIC;
142 : 3 : kframe.size = VFP_STORAGE_SIZE;
143 : :
144 : 3 : err = vfp_preserve_user_clear_hwstate(&kframe.ufp, &kframe.ufp_exc);
145 : 3 : if (err)
146 : : return err;
147 : :
148 : 3 : return __copy_to_user(frame, &kframe, sizeof(kframe));
149 : : }
150 : :
151 : 3 : static int restore_vfp_context(char __user **auxp)
152 : : {
153 : : struct vfp_sigframe frame;
154 : : int err;
155 : :
156 : 3 : err = __copy_from_user(&frame, *auxp, sizeof(frame));
157 : 3 : if (err)
158 : : return err;
159 : :
160 : 3 : if (frame.magic != VFP_MAGIC || frame.size != VFP_STORAGE_SIZE)
161 : : return -EINVAL;
162 : :
163 : 3 : *auxp += sizeof(frame);
164 : 3 : return vfp_restore_user_hwstate(&frame.ufp, &frame.ufp_exc);
165 : : }
166 : :
167 : : #endif
168 : :
169 : : /*
170 : : * Do a signal return; undo the signal stack. These are aligned to 64-bit.
171 : : */
172 : :
173 : 3 : static int restore_sigframe(struct pt_regs *regs, struct sigframe __user *sf)
174 : : {
175 : : struct sigcontext context;
176 : : char __user *aux;
177 : : sigset_t set;
178 : : int err;
179 : :
180 : 3 : err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
181 : 3 : if (err == 0)
182 : 3 : set_current_blocked(&set);
183 : :
184 : 3 : err |= __copy_from_user(&context, &sf->uc.uc_mcontext, sizeof(context));
185 : 3 : if (err == 0) {
186 : 3 : regs->ARM_r0 = context.arm_r0;
187 : 3 : regs->ARM_r1 = context.arm_r1;
188 : 3 : regs->ARM_r2 = context.arm_r2;
189 : 3 : regs->ARM_r3 = context.arm_r3;
190 : 3 : regs->ARM_r4 = context.arm_r4;
191 : 3 : regs->ARM_r5 = context.arm_r5;
192 : 3 : regs->ARM_r6 = context.arm_r6;
193 : 3 : regs->ARM_r7 = context.arm_r7;
194 : 3 : regs->ARM_r8 = context.arm_r8;
195 : 3 : regs->ARM_r9 = context.arm_r9;
196 : 3 : regs->ARM_r10 = context.arm_r10;
197 : 3 : regs->ARM_fp = context.arm_fp;
198 : 3 : regs->ARM_ip = context.arm_ip;
199 : 3 : regs->ARM_sp = context.arm_sp;
200 : 3 : regs->ARM_lr = context.arm_lr;
201 : 3 : regs->ARM_pc = context.arm_pc;
202 : 3 : regs->ARM_cpsr = context.arm_cpsr;
203 : : }
204 : :
205 : 3 : err |= !valid_user_regs(regs);
206 : :
207 : 3 : aux = (char __user *) sf->uc.uc_regspace;
208 : : #ifdef CONFIG_CRUNCH
209 : : if (err == 0)
210 : : err |= restore_crunch_context(&aux);
211 : : #endif
212 : : #ifdef CONFIG_IWMMXT
213 : : if (err == 0)
214 : : err |= restore_iwmmxt_context(&aux);
215 : : #endif
216 : : #ifdef CONFIG_VFP
217 : 3 : if (err == 0)
218 : 3 : err |= restore_vfp_context(&aux);
219 : : #endif
220 : :
221 : 3 : return err;
222 : : }
223 : :
224 : 3 : asmlinkage int sys_sigreturn(struct pt_regs *regs)
225 : : {
226 : : struct sigframe __user *frame;
227 : :
228 : : /* Always make any pending restarted system calls return -EINTR */
229 : 3 : current->restart_block.fn = do_no_restart_syscall;
230 : :
231 : : /*
232 : : * Since we stacked the signal on a 64-bit boundary,
233 : : * then 'sp' should be word aligned here. If it's
234 : : * not, then the user is trying to mess with us.
235 : : */
236 : 3 : if (regs->ARM_sp & 7)
237 : : goto badframe;
238 : :
239 : 3 : frame = (struct sigframe __user *)regs->ARM_sp;
240 : :
241 : 3 : if (!access_ok(frame, sizeof (*frame)))
242 : : goto badframe;
243 : :
244 : 3 : if (restore_sigframe(regs, frame))
245 : : goto badframe;
246 : :
247 : 3 : return regs->ARM_r0;
248 : :
249 : : badframe:
250 : 2 : force_sig(SIGSEGV);
251 : 0 : return 0;
252 : : }
253 : :
254 : 3 : asmlinkage int sys_rt_sigreturn(struct pt_regs *regs)
255 : : {
256 : : struct rt_sigframe __user *frame;
257 : :
258 : : /* Always make any pending restarted system calls return -EINTR */
259 : 3 : current->restart_block.fn = do_no_restart_syscall;
260 : :
261 : : /*
262 : : * Since we stacked the signal on a 64-bit boundary,
263 : : * then 'sp' should be word aligned here. If it's
264 : : * not, then the user is trying to mess with us.
265 : : */
266 : 3 : if (regs->ARM_sp & 7)
267 : : goto badframe;
268 : :
269 : 3 : frame = (struct rt_sigframe __user *)regs->ARM_sp;
270 : :
271 : 3 : if (!access_ok(frame, sizeof (*frame)))
272 : : goto badframe;
273 : :
274 : 3 : if (restore_sigframe(regs, &frame->sig))
275 : : goto badframe;
276 : :
277 : 3 : if (restore_altstack(&frame->sig.uc.uc_stack))
278 : : goto badframe;
279 : :
280 : 3 : return regs->ARM_r0;
281 : :
282 : : badframe:
283 : 3 : force_sig(SIGSEGV);
284 : 0 : return 0;
285 : : }
286 : :
287 : : static int
288 : 3 : setup_sigframe(struct sigframe __user *sf, struct pt_regs *regs, sigset_t *set)
289 : : {
290 : : struct aux_sigframe __user *aux;
291 : : struct sigcontext context;
292 : : int err = 0;
293 : :
294 : 3 : context = (struct sigcontext) {
295 : 3 : .arm_r0 = regs->ARM_r0,
296 : 3 : .arm_r1 = regs->ARM_r1,
297 : 3 : .arm_r2 = regs->ARM_r2,
298 : 3 : .arm_r3 = regs->ARM_r3,
299 : 3 : .arm_r4 = regs->ARM_r4,
300 : 3 : .arm_r5 = regs->ARM_r5,
301 : 3 : .arm_r6 = regs->ARM_r6,
302 : 3 : .arm_r7 = regs->ARM_r7,
303 : 3 : .arm_r8 = regs->ARM_r8,
304 : 3 : .arm_r9 = regs->ARM_r9,
305 : 3 : .arm_r10 = regs->ARM_r10,
306 : 3 : .arm_fp = regs->ARM_fp,
307 : 3 : .arm_ip = regs->ARM_ip,
308 : 3 : .arm_sp = regs->ARM_sp,
309 : 3 : .arm_lr = regs->ARM_lr,
310 : 3 : .arm_pc = regs->ARM_pc,
311 : 3 : .arm_cpsr = regs->ARM_cpsr,
312 : :
313 : 3 : .trap_no = current->thread.trap_no,
314 : 3 : .error_code = current->thread.error_code,
315 : 3 : .fault_address = current->thread.address,
316 : 3 : .oldmask = set->sig[0],
317 : : };
318 : :
319 : 3 : err |= __copy_to_user(&sf->uc.uc_mcontext, &context, sizeof(context));
320 : :
321 : 3 : err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set));
322 : :
323 : : aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
324 : : #ifdef CONFIG_CRUNCH
325 : : if (err == 0)
326 : : err |= preserve_crunch_context(&aux->crunch);
327 : : #endif
328 : : #ifdef CONFIG_IWMMXT
329 : : if (err == 0)
330 : : err |= preserve_iwmmxt_context(&aux->iwmmxt);
331 : : #endif
332 : : #ifdef CONFIG_VFP
333 : 3 : if (err == 0)
334 : 3 : err |= preserve_vfp_context(&aux->vfp);
335 : : #endif
336 : 3 : err |= __put_user(0, &aux->end_magic);
337 : :
338 : 3 : return err;
339 : : }
340 : :
341 : : static inline void __user *
342 : 3 : get_sigframe(struct ksignal *ksig, struct pt_regs *regs, int framesize)
343 : : {
344 : 3 : unsigned long sp = sigsp(regs->ARM_sp, ksig);
345 : : void __user *frame;
346 : :
347 : : /*
348 : : * ATPCS B01 mandates 8-byte alignment
349 : : */
350 : 3 : frame = (void __user *)((sp - framesize) & ~7);
351 : :
352 : : /*
353 : : * Check that we can actually write to the signal frame.
354 : : */
355 : 3 : if (!access_ok(frame, framesize))
356 : : frame = NULL;
357 : :
358 : 3 : return frame;
359 : : }
360 : :
361 : : static int
362 : 3 : setup_return(struct pt_regs *regs, struct ksignal *ksig,
363 : : unsigned long __user *rc, void __user *frame)
364 : : {
365 : 3 : unsigned long handler = (unsigned long)ksig->ka.sa.sa_handler;
366 : : unsigned long handler_fdpic_GOT = 0;
367 : : unsigned long retcode;
368 : : unsigned int idx, thumb = 0;
369 : 3 : unsigned long cpsr = regs->ARM_cpsr & ~(PSR_f | PSR_E_BIT);
370 : : bool fdpic = IS_ENABLED(CONFIG_BINFMT_ELF_FDPIC) &&
371 : : (current->personality & FDPIC_FUNCPTRS);
372 : :
373 : : if (fdpic) {
374 : : unsigned long __user *fdpic_func_desc =
375 : : (unsigned long __user *)handler;
376 : : if (__get_user(handler, &fdpic_func_desc[0]) ||
377 : : __get_user(handler_fdpic_GOT, &fdpic_func_desc[1]))
378 : : return 1;
379 : : }
380 : :
381 : : cpsr |= PSR_ENDSTATE;
382 : :
383 : : /*
384 : : * Maybe we need to deliver a 32-bit signal to a 26-bit task.
385 : : */
386 : 3 : if (ksig->ka.sa.sa_flags & SA_THIRTYTWO)
387 : 0 : cpsr = (cpsr & ~MODE_MASK) | USR_MODE;
388 : :
389 : : #ifdef CONFIG_ARM_THUMB
390 : 3 : if (elf_hwcap & HWCAP_THUMB) {
391 : : /*
392 : : * The LSB of the handler determines if we're going to
393 : : * be using THUMB or ARM mode for this signal handler.
394 : : */
395 : 3 : thumb = handler & 1;
396 : :
397 : : /*
398 : : * Clear the If-Then Thumb-2 execution state. ARM spec
399 : : * requires this to be all 000s in ARM mode. Snapdragon
400 : : * S4/Krait misbehaves on a Thumb=>ARM signal transition
401 : : * without this.
402 : : *
403 : : * We must do this whenever we are running on a Thumb-2
404 : : * capable CPU, which includes ARMv6T2. However, we elect
405 : : * to always do this to simplify the code; this field is
406 : : * marked UNK/SBZP for older architectures.
407 : : */
408 : 3 : cpsr &= ~PSR_IT_MASK;
409 : :
410 : 3 : if (thumb) {
411 : 1 : cpsr |= PSR_T_BIT;
412 : : } else
413 : 3 : cpsr &= ~PSR_T_BIT;
414 : : }
415 : : #endif
416 : :
417 : 3 : if (ksig->ka.sa.sa_flags & SA_RESTORER) {
418 : 3 : retcode = (unsigned long)ksig->ka.sa.sa_restorer;
419 : : if (fdpic) {
420 : : /*
421 : : * We need code to load the function descriptor.
422 : : * That code follows the standard sigreturn code
423 : : * (6 words), and is made of 3 + 2 words for each
424 : : * variant. The 4th copied word is the actual FD
425 : : * address that the assembly code expects.
426 : : */
427 : : idx = 6 + thumb * 3;
428 : : if (ksig->ka.sa.sa_flags & SA_SIGINFO)
429 : : idx += 5;
430 : : if (__put_user(sigreturn_codes[idx], rc ) ||
431 : : __put_user(sigreturn_codes[idx+1], rc+1) ||
432 : : __put_user(sigreturn_codes[idx+2], rc+2) ||
433 : : __put_user(retcode, rc+3))
434 : : return 1;
435 : : goto rc_finish;
436 : : }
437 : : } else {
438 : 0 : idx = thumb << 1;
439 : 0 : if (ksig->ka.sa.sa_flags & SA_SIGINFO)
440 : 0 : idx += 3;
441 : :
442 : : /*
443 : : * Put the sigreturn code on the stack no matter which return
444 : : * mechanism we use in order to remain ABI compliant
445 : : */
446 : 0 : if (__put_user(sigreturn_codes[idx], rc) ||
447 : 0 : __put_user(sigreturn_codes[idx+1], rc+1))
448 : : return 1;
449 : :
450 : : rc_finish:
451 : : #ifdef CONFIG_MMU
452 : 0 : if (cpsr & MODE32_BIT) {
453 : 0 : struct mm_struct *mm = current->mm;
454 : :
455 : : /*
456 : : * 32-bit code can use the signal return page
457 : : * except when the MPU has protected the vectors
458 : : * page from PL0
459 : : */
460 : 0 : retcode = mm->context.sigpage + signal_return_offset +
461 : 0 : (idx << 2) + thumb;
462 : : } else
463 : : #endif
464 : : {
465 : : /*
466 : : * Ensure that the instruction cache sees
467 : : * the return code written onto the stack.
468 : : */
469 : 0 : flush_icache_range((unsigned long)rc,
470 : : (unsigned long)(rc + 3));
471 : :
472 : 0 : retcode = ((unsigned long)rc) + thumb;
473 : : }
474 : : }
475 : :
476 : 3 : regs->ARM_r0 = ksig->sig;
477 : 3 : regs->ARM_sp = (unsigned long)frame;
478 : 3 : regs->ARM_lr = retcode;
479 : 3 : regs->ARM_pc = handler;
480 : : if (fdpic)
481 : : regs->ARM_r9 = handler_fdpic_GOT;
482 : 3 : regs->ARM_cpsr = cpsr;
483 : :
484 : 3 : return 0;
485 : : }
486 : :
487 : : static int
488 : 3 : setup_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
489 : : {
490 : 3 : struct sigframe __user *frame = get_sigframe(ksig, regs, sizeof(*frame));
491 : : int err = 0;
492 : :
493 : 3 : if (!frame)
494 : : return 1;
495 : :
496 : : /*
497 : : * Set uc.uc_flags to a value which sc.trap_no would never have.
498 : : */
499 : 3 : err = __put_user(0x5ac3c35a, &frame->uc.uc_flags);
500 : :
501 : 3 : err |= setup_sigframe(frame, regs, set);
502 : 3 : if (err == 0)
503 : 3 : err = setup_return(regs, ksig, frame->retcode, frame);
504 : :
505 : 3 : return err;
506 : : }
507 : :
508 : : static int
509 : 3 : setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs)
510 : : {
511 : 3 : struct rt_sigframe __user *frame = get_sigframe(ksig, regs, sizeof(*frame));
512 : : int err = 0;
513 : :
514 : 3 : if (!frame)
515 : : return 1;
516 : :
517 : 3 : err |= copy_siginfo_to_user(&frame->info, &ksig->info);
518 : :
519 : 3 : err |= __put_user(0, &frame->sig.uc.uc_flags);
520 : 3 : err |= __put_user(NULL, &frame->sig.uc.uc_link);
521 : :
522 : 3 : err |= __save_altstack(&frame->sig.uc.uc_stack, regs->ARM_sp);
523 : 3 : err |= setup_sigframe(&frame->sig, regs, set);
524 : 3 : if (err == 0)
525 : 3 : err = setup_return(regs, ksig, frame->sig.retcode, frame);
526 : :
527 : 3 : if (err == 0) {
528 : : /*
529 : : * For realtime signals we must also set the second and third
530 : : * arguments for the signal handler.
531 : : * -- Peter Maydell <pmaydell@chiark.greenend.org.uk> 2000-12-06
532 : : */
533 : 3 : regs->ARM_r1 = (unsigned long)&frame->info;
534 : 3 : regs->ARM_r2 = (unsigned long)&frame->sig.uc;
535 : : }
536 : :
537 : 3 : return err;
538 : : }
539 : :
540 : : /*
541 : : * OK, we're invoking a handler
542 : : */
543 : 3 : static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
544 : : {
545 : : sigset_t *oldset = sigmask_to_save();
546 : : int ret;
547 : :
548 : : /*
549 : : * Perform fixup for the pre-signal frame.
550 : : */
551 : 3 : rseq_signal_deliver(ksig, regs);
552 : :
553 : : /*
554 : : * Set up the stack frame
555 : : */
556 : 3 : if (ksig->ka.sa.sa_flags & SA_SIGINFO)
557 : 3 : ret = setup_rt_frame(ksig, oldset, regs);
558 : : else
559 : 3 : ret = setup_frame(ksig, oldset, regs);
560 : :
561 : : /*
562 : : * Check that the resulting registers are actually sane.
563 : : */
564 : 3 : ret |= !valid_user_regs(regs);
565 : :
566 : 3 : signal_setup_done(ret, ksig, 0);
567 : 3 : }
568 : :
569 : : /*
570 : : * Note that 'init' is a special process: it doesn't get signals it doesn't
571 : : * want to handle. Thus you cannot kill init even with a SIGKILL even by
572 : : * mistake.
573 : : *
574 : : * Note that we go through the signals twice: once to check the signals that
575 : : * the kernel can handle, and then we build all the user-level signal handling
576 : : * stack-frames in one go after that.
577 : : */
578 : 3 : static int do_signal(struct pt_regs *regs, int syscall)
579 : : {
580 : : unsigned int retval = 0, continue_addr = 0, restart_addr = 0;
581 : : struct ksignal ksig;
582 : : int restart = 0;
583 : :
584 : : /*
585 : : * If we were from a system call, check for system call restarting...
586 : : */
587 : 3 : if (syscall) {
588 : 3 : continue_addr = regs->ARM_pc;
589 : 3 : restart_addr = continue_addr - (thumb_mode(regs) ? 2 : 4);
590 : 3 : retval = regs->ARM_r0;
591 : :
592 : : /*
593 : : * Prepare for system call restart. We do this here so that a
594 : : * debugger will see the already changed PSW.
595 : : */
596 : 3 : switch (retval) {
597 : : case -ERESTART_RESTARTBLOCK:
598 : : restart -= 2;
599 : : /* Fall through */
600 : : case -ERESTARTNOHAND:
601 : : case -ERESTARTSYS:
602 : : case -ERESTARTNOINTR:
603 : 3 : restart++;
604 : 3 : regs->ARM_r0 = regs->ARM_ORIG_r0;
605 : 3 : regs->ARM_pc = restart_addr;
606 : 3 : break;
607 : : }
608 : : }
609 : :
610 : : /*
611 : : * Get the signal to deliver. When running under ptrace, at this
612 : : * point the debugger may change all our registers ...
613 : : */
614 : : /*
615 : : * Depending on the signal settings we may need to revert the
616 : : * decision to restart the system call. But skip this if a
617 : : * debugger has chosen to restart at a different PC.
618 : : */
619 : 3 : if (get_signal(&ksig)) {
620 : : /* handler */
621 : 3 : if (unlikely(restart) && regs->ARM_pc == restart_addr) {
622 : 3 : if (retval == -ERESTARTNOHAND ||
623 : 3 : retval == -ERESTART_RESTARTBLOCK
624 : 3 : || (retval == -ERESTARTSYS
625 : 3 : && !(ksig.ka.sa.sa_flags & SA_RESTART))) {
626 : 3 : regs->ARM_r0 = -EINTR;
627 : 3 : regs->ARM_pc = continue_addr;
628 : : }
629 : : }
630 : 3 : handle_signal(&ksig, regs);
631 : : } else {
632 : : /* no handler */
633 : 3 : restore_saved_sigmask();
634 : 3 : if (unlikely(restart) && regs->ARM_pc == restart_addr) {
635 : 3 : regs->ARM_pc = continue_addr;
636 : 3 : return restart;
637 : : }
638 : : }
639 : : return 0;
640 : : }
641 : :
642 : : asmlinkage int
643 : 3 : do_work_pending(struct pt_regs *regs, unsigned int thread_flags, int syscall)
644 : : {
645 : : /*
646 : : * The assembly code enters us with IRQs off, but it hasn't
647 : : * informed the tracing code of that for efficiency reasons.
648 : : * Update the trace code with the current status.
649 : : */
650 : 3 : trace_hardirqs_off();
651 : : do {
652 : 3 : if (likely(thread_flags & _TIF_NEED_RESCHED)) {
653 : 3 : schedule();
654 : : } else {
655 : 3 : if (unlikely(!user_mode(regs)))
656 : : return 0;
657 : 3 : local_irq_enable();
658 : 3 : if (thread_flags & _TIF_SIGPENDING) {
659 : 3 : int restart = do_signal(regs, syscall);
660 : 3 : if (unlikely(restart)) {
661 : : /*
662 : : * Restart without handlers.
663 : : * Deal with it without leaving
664 : : * the kernel space.
665 : : */
666 : 3 : return restart;
667 : : }
668 : : syscall = 0;
669 : 3 : } else if (thread_flags & _TIF_UPROBE) {
670 : : uprobe_notify_resume(regs);
671 : : } else {
672 : : clear_thread_flag(TIF_NOTIFY_RESUME);
673 : 3 : tracehook_notify_resume(regs);
674 : 3 : rseq_handle_notify_resume(NULL, regs);
675 : : }
676 : : }
677 : 3 : local_irq_disable();
678 : 3 : thread_flags = current_thread_info()->flags;
679 : 3 : } while (thread_flags & _TIF_WORK_MASK);
680 : : return 0;
681 : : }
682 : :
683 : 3 : struct page *get_signal_page(void)
684 : : {
685 : : unsigned long ptr;
686 : : unsigned offset;
687 : : struct page *page;
688 : : void *addr;
689 : :
690 : : page = alloc_pages(GFP_KERNEL, 0);
691 : :
692 : 3 : if (!page)
693 : : return NULL;
694 : :
695 : : addr = page_address(page);
696 : :
697 : : /* Give the signal return code some randomness */
698 : 3 : offset = 0x200 + (get_random_int() & 0x7fc);
699 : 3 : signal_return_offset = offset;
700 : :
701 : : /*
702 : : * Copy signal return handlers into the vector page, and
703 : : * set sigreturn to be a pointer to these.
704 : : */
705 : 3 : memcpy(addr + offset, sigreturn_codes, sizeof(sigreturn_codes));
706 : :
707 : 3 : ptr = (unsigned long)addr + offset;
708 : 3 : flush_icache_range(ptr, ptr + sizeof(sigreturn_codes));
709 : :
710 : 3 : return page;
711 : : }
712 : :
713 : : /* Defer to generic check */
714 : 0 : asmlinkage void addr_limit_check_failed(void)
715 : : {
716 : 0 : addr_limit_user_check();
717 : 0 : }
718 : :
719 : : #ifdef CONFIG_DEBUG_RSEQ
720 : : asmlinkage void do_rseq_syscall(struct pt_regs *regs)
721 : : {
722 : : rseq_syscall(regs);
723 : : }
724 : : #endif
|
