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

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