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