signal.c

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * OpenRISC signal.c
  4 *
  5 * Linux architectural port borrowing liberally from similar works of
  6 * others.  All original copyrights apply as per the original source
  7 * declaration.
  8 *
  9 * Modifications for the OpenRISC architecture:
 10 * Copyright (C) 2003 Matjaz Breskvar <phoenix@bsemi.com>
 11 * Copyright (C) 2010-2011 Jonas Bonn <jonas@southpole.se>
 12 */
 13
 14#include <linux/sched.h>
 15#include <linux/mm.h>
 16#include <linux/smp.h>
 17#include <linux/kernel.h>
 18#include <linux/signal.h>
 19#include <linux/errno.h>
 20#include <linux/wait.h>
 21#include <linux/ptrace.h>
 22#include <linux/unistd.h>
 23#include <linux/stddef.h>
 24#include <linux/resume_user_mode.h>
 25
 26#include <asm/fpu.h>
 27#include <asm/processor.h>
 28#include <asm/syscall.h>
 29#include <asm/ucontext.h>
 30#include <linux/uaccess.h>
 31
 32struct rt_sigframe {
 33	struct siginfo info;
 34	struct ucontext uc;
 35	unsigned char retcode[16];	/* trampoline code */
 36};
 37
 38asmlinkage long _sys_rt_sigreturn(struct pt_regs *regs);
 39
 40asmlinkage int do_work_pending(struct pt_regs *regs, unsigned int thread_flags,
 41			       int syscall);
 42
 43#ifdef CONFIG_FPU
 44static long restore_fp_state(struct sigcontext __user *sc)
 45{
 46	long err;
 47
 48	err = __copy_from_user(&current->thread.fpcsr, &sc->fpcsr, sizeof(unsigned long));
 49	if (unlikely(err))
 50		return err;
 51
 52	/* Restore the FPU state */
 53	restore_fpu(current);
 54
 55	return 0;
 56}
 57
 58static long save_fp_state(struct sigcontext __user *sc)
 59{
 60	long err;
 61
 62	/* Sync the user FPU state so we can copy to sigcontext */
 63	save_fpu(current);
 64
 65	err = __copy_to_user(&sc->fpcsr, &current->thread.fpcsr, sizeof(unsigned long));
 66
 67	return err;
 68}
 69#else
 70#define save_fp_state(sc) (0)
 71#define restore_fp_state(sc) (0)
 72#endif
 73
 74static int restore_sigcontext(struct pt_regs *regs,
 75			      struct sigcontext __user *sc)
 76{
 77	int err = 0;
 78
 79	/* Always make any pending restarted system calls return -EINTR */
 80	current->restart_block.fn = do_no_restart_syscall;
 81
 82	/*
 83	 * Restore the regs from &sc->regs.
 84	 * (sc is already checked since the sigframe was
 85	 *  checked in sys_sigreturn previously)
 86	 */
 87	err |= __copy_from_user(regs, sc->regs.gpr, 32 * sizeof(unsigned long));
 88	err |= __copy_from_user(&regs->pc, &sc->regs.pc, sizeof(unsigned long));
 89	err |= __copy_from_user(&regs->sr, &sc->regs.sr, sizeof(unsigned long));
 90	err |= restore_fp_state(sc);
 91
 92	/* make sure the SM-bit is cleared so user-mode cannot fool us */
 93	regs->sr &= ~SPR_SR_SM;
 94
 95	regs->orig_gpr11 = -1;	/* Avoid syscall restart checks */
 96
 97	/* TODO: the other ports use regs->orig_XX to disable syscall checks
 98	 * after this completes, but we don't use that mechanism. maybe we can
 99	 * use it now ?
100	 */
101
102	return err;
103}
104
105asmlinkage long _sys_rt_sigreturn(struct pt_regs *regs)
106{
107	struct rt_sigframe __user *frame = (struct rt_sigframe __user *)regs->sp;
108	sigset_t set;
109
110	/*
111	 * Since we stacked the signal on a dword boundary,
112	 * then frame should be dword aligned here.  If it's
113	 * not, then the user is trying to mess with us.
114	 */
115	if (((unsigned long)frame) & 3)
116		goto badframe;
117
118	if (!access_ok(frame, sizeof(*frame)))
119		goto badframe;
120	if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
121		goto badframe;
122
123	set_current_blocked(&set);
124
125	if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
126		goto badframe;
127
128	if (restore_altstack(&frame->uc.uc_stack))
129		goto badframe;
130
131	return regs->gpr[11];
132
133badframe:
134	force_sig(SIGSEGV);
135	return 0;
136}
137
138/*
139 * Set up a signal frame.
140 */
141
142static int setup_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
143{
144	int err = 0;
145
146	/* copy the regs */
147	/* There should be no need to save callee-saved registers here...
148	 * ...but we save them anyway.  Revisit this
149	 */
150	err |= __copy_to_user(sc->regs.gpr, regs, 32 * sizeof(unsigned long));
151	err |= __copy_to_user(&sc->regs.pc, &regs->pc, sizeof(unsigned long));
152	err |= __copy_to_user(&sc->regs.sr, &regs->sr, sizeof(unsigned long));
153	err |= save_fp_state(sc);
154
155	return err;
156}
157
158static inline unsigned long align_sigframe(unsigned long sp)
159{
160	return sp & ~3UL;
161}
162
163/*
164 * Work out where the signal frame should go.  It's either on the user stack
165 * or the alternate stack.
166 */
167
168static inline void __user *get_sigframe(struct ksignal *ksig,
169					struct pt_regs *regs, size_t frame_size)
170{
171	unsigned long sp = regs->sp;
172
173	/* redzone */
174	sp -= STACK_FRAME_OVERHEAD;
175	sp = sigsp(sp, ksig);
176	sp = align_sigframe(sp - frame_size);
177
178	return (void __user *)sp;
179}
180
181/* grab and setup a signal frame.
182 *
183 * basically we stack a lot of state info, and arrange for the
184 * user-mode program to return to the kernel using either a
185 * trampoline which performs the syscall sigreturn, or a provided
186 * user-mode trampoline.
187 */
188static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
189			  struct pt_regs *regs)
190{
191	struct rt_sigframe __user *frame;
192	unsigned long return_ip;
193	int err = 0;
194
195	frame = get_sigframe(ksig, regs, sizeof(*frame));
196
197	if (!access_ok(frame, sizeof(*frame)))
198		return -EFAULT;
199
200	/* Create siginfo.  */
201	if (ksig->ka.sa.sa_flags & SA_SIGINFO)
202		err |= copy_siginfo_to_user(&frame->info, &ksig->info);
203
204	/* Create the ucontext.  */
205	err |= __put_user(0, &frame->uc.uc_flags);
206	err |= __put_user(NULL, &frame->uc.uc_link);
207	err |= __save_altstack(&frame->uc.uc_stack, regs->sp);
208	err |= setup_sigcontext(regs, &frame->uc.uc_mcontext);
209
210	err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
211
212	if (err)
213		return -EFAULT;
214
215	/* trampoline - the desired return ip is the retcode itself */
216	return_ip = (unsigned long)&frame->retcode;
217	/* This is:
218		l.ori r11,r0,__NR_sigreturn
219		l.sys 1
220	 */
221	err |= __put_user(0xa960,             (short __user *)(frame->retcode + 0));
222	err |= __put_user(__NR_rt_sigreturn,  (short __user *)(frame->retcode + 2));
223	err |= __put_user(0x20000001, (unsigned long __user *)(frame->retcode + 4));
224	err |= __put_user(0x15000000, (unsigned long __user *)(frame->retcode + 8));
225
226	if (err)
227		return -EFAULT;
228
229	/* Set up registers for signal handler */
230	regs->pc = (unsigned long)ksig->ka.sa.sa_handler; /* what we enter NOW */
231	regs->gpr[9] = (unsigned long)return_ip;     /* what we enter LATER */
232	regs->gpr[3] = (unsigned long)ksig->sig;           /* arg 1: signo */
233	regs->gpr[4] = (unsigned long)&frame->info;  /* arg 2: (siginfo_t*) */
234	regs->gpr[5] = (unsigned long)&frame->uc;    /* arg 3: ucontext */
235
236	/* actually move the usp to reflect the stacked frame */
237	regs->sp = (unsigned long)frame;
238
239	return 0;
240}
241
242static inline void
243handle_signal(struct ksignal *ksig, struct pt_regs *regs)
244{
245	int ret;
246
247	rseq_signal_deliver(ksig, regs);
248
249	ret = setup_rt_frame(ksig, sigmask_to_save(), regs);
250
251	signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
252}
253
254/*
255 * Note that 'init' is a special process: it doesn't get signals it doesn't
256 * want to handle. Thus you cannot kill init even with a SIGKILL even by
257 * mistake.
258 *
259 * Also note that the regs structure given here as an argument, is the latest
260 * pushed pt_regs. It may or may not be the same as the first pushed registers
261 * when the initial usermode->kernelmode transition took place. Therefore
262 * we can use user_mode(regs) to see if we came directly from kernel or user
263 * mode below.
264 */
265
266static int do_signal(struct pt_regs *regs, int syscall)
267{
268	struct ksignal ksig;
269	unsigned long continue_addr = 0;
270	unsigned long restart_addr = 0;
271	unsigned long retval = 0;
272	int restart = 0;
273
274	if (syscall) {
275		continue_addr = regs->pc;
276		restart_addr = continue_addr - 4;
277		retval = regs->gpr[11];
278
279		/*
280		 * Setup syscall restart here so that a debugger will
281		 * see the already changed PC.
282		 */
283		switch (retval) {
284		case -ERESTART_RESTARTBLOCK:
285			restart = -2;
286			fallthrough;
287		case -ERESTARTNOHAND:
288		case -ERESTARTSYS:
289		case -ERESTARTNOINTR:
290			restart++;
291			regs->gpr[11] = regs->orig_gpr11;
292			regs->pc = restart_addr;
293			break;
294		}
295	}
296
297	/*
298	 * Get the signal to deliver.  During the call to get_signal the
299	 * debugger may change all our registers so we may need to revert
300	 * the decision to restart the syscall; specifically, if the PC is
301	 * changed, don't restart the syscall.
302	 */
303	if (get_signal(&ksig)) {
304		if (unlikely(restart) && regs->pc == restart_addr) {
305			if (retval == -ERESTARTNOHAND ||
306			    retval == -ERESTART_RESTARTBLOCK
307			    || (retval == -ERESTARTSYS
308			        && !(ksig.ka.sa.sa_flags & SA_RESTART))) {
309				/* No automatic restart */
310				regs->gpr[11] = -EINTR;
311				regs->pc = continue_addr;
312			}
313		}
314		handle_signal(&ksig, regs);
315	} else {
316		/* no handler */
317		restore_saved_sigmask();
318		/*
319		 * Restore pt_regs PC as syscall restart will be handled by
320		 * kernel without return to userspace
321		 */
322		if (unlikely(restart) && regs->pc == restart_addr) {
323			regs->pc = continue_addr;
324			return restart;
325		}
326	}
327
328	return 0;
329}
330
331asmlinkage int
332do_work_pending(struct pt_regs *regs, unsigned int thread_flags, int syscall)
333{
334	do {
335		if (likely(thread_flags & _TIF_NEED_RESCHED)) {
336			schedule();
337		} else {
338			if (unlikely(!user_mode(regs)))
339				return 0;
340			local_irq_enable();
341			if (thread_flags & (_TIF_SIGPENDING|_TIF_NOTIFY_SIGNAL)) {
342				int restart = do_signal(regs, syscall);
343				if (unlikely(restart)) {
344					/*
345					 * Restart without handlers.
346					 * Deal with it without leaving
347					 * the kernel space.
348					 */
349					return restart;
350				}
351				syscall = 0;
352			} else {
353				resume_user_mode_work(regs);
354			}
355		}
356		local_irq_disable();
357		thread_flags = read_thread_flags();
358	} while (thread_flags & _TIF_WORK_MASK);
359	return 0;
360}