~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/riscv/kernel/signal.c

Version: ~ [ linux-5.16 ] ~ [ linux-5.15.13 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.90 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.170 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.224 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.261 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.296 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.298 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0-or-later
  2 /*
  3  * Copyright (C) 2009 Sunplus Core Technology Co., Ltd.
  4  *  Chen Liqin <liqin.chen@sunplusct.com>
  5  *  Lennox Wu <lennox.wu@sunplusct.com>
  6  * Copyright (C) 2012 Regents of the University of California
  7  */
  8 
  9 #include <linux/signal.h>
 10 #include <linux/uaccess.h>
 11 #include <linux/syscalls.h>
 12 #include <linux/tracehook.h>
 13 #include <linux/linkage.h>
 14 
 15 #include <asm/ucontext.h>
 16 #include <asm/vdso.h>
 17 #include <asm/switch_to.h>
 18 #include <asm/csr.h>
 19 
 20 extern u32 __user_rt_sigreturn[2];
 21 
 22 #define DEBUG_SIG 0
 23 
 24 struct rt_sigframe {
 25         struct siginfo info;
 26         struct ucontext uc;
 27 #ifndef CONFIG_MMU
 28         u32 sigreturn_code[2];
 29 #endif
 30 };
 31 
 32 #ifdef CONFIG_FPU
 33 static long restore_fp_state(struct pt_regs *regs,
 34                              union __riscv_fp_state __user *sc_fpregs)
 35 {
 36         long err;
 37         struct __riscv_d_ext_state __user *state = &sc_fpregs->d;
 38         size_t i;
 39 
 40         err = __copy_from_user(&current->thread.fstate, state, sizeof(*state));
 41         if (unlikely(err))
 42                 return err;
 43 
 44         fstate_restore(current, regs);
 45 
 46         /* We support no other extension state at this time. */
 47         for (i = 0; i < ARRAY_SIZE(sc_fpregs->q.reserved); i++) {
 48                 u32 value;
 49 
 50                 err = __get_user(value, &sc_fpregs->q.reserved[i]);
 51                 if (unlikely(err))
 52                         break;
 53                 if (value != 0)
 54                         return -EINVAL;
 55         }
 56 
 57         return err;
 58 }
 59 
 60 static long save_fp_state(struct pt_regs *regs,
 61                           union __riscv_fp_state __user *sc_fpregs)
 62 {
 63         long err;
 64         struct __riscv_d_ext_state __user *state = &sc_fpregs->d;
 65         size_t i;
 66 
 67         fstate_save(current, regs);
 68         err = __copy_to_user(state, &current->thread.fstate, sizeof(*state));
 69         if (unlikely(err))
 70                 return err;
 71 
 72         /* We support no other extension state at this time. */
 73         for (i = 0; i < ARRAY_SIZE(sc_fpregs->q.reserved); i++) {
 74                 err = __put_user(0, &sc_fpregs->q.reserved[i]);
 75                 if (unlikely(err))
 76                         break;
 77         }
 78 
 79         return err;
 80 }
 81 #else
 82 #define save_fp_state(task, regs) (0)
 83 #define restore_fp_state(task, regs) (0)
 84 #endif
 85 
 86 static long restore_sigcontext(struct pt_regs *regs,
 87         struct sigcontext __user *sc)
 88 {
 89         long err;
 90         /* sc_regs is structured the same as the start of pt_regs */
 91         err = __copy_from_user(regs, &sc->sc_regs, sizeof(sc->sc_regs));
 92         /* Restore the floating-point state. */
 93         if (has_fpu)
 94                 err |= restore_fp_state(regs, &sc->sc_fpregs);
 95         return err;
 96 }
 97 
 98 SYSCALL_DEFINE0(rt_sigreturn)
 99 {
100         struct pt_regs *regs = current_pt_regs();
101         struct rt_sigframe __user *frame;
102         struct task_struct *task;
103         sigset_t set;
104 
105         /* Always make any pending restarted system calls return -EINTR */
106         current->restart_block.fn = do_no_restart_syscall;
107 
108         frame = (struct rt_sigframe __user *)regs->sp;
109 
110         if (!access_ok(frame, sizeof(*frame)))
111                 goto badframe;
112 
113         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
114                 goto badframe;
115 
116         set_current_blocked(&set);
117 
118         if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
119                 goto badframe;
120 
121         if (restore_altstack(&frame->uc.uc_stack))
122                 goto badframe;
123 
124         return regs->a0;
125 
126 badframe:
127         task = current;
128         if (show_unhandled_signals) {
129                 pr_info_ratelimited(
130                         "%s[%d]: bad frame in %s: frame=%p pc=%p sp=%p\n",
131                         task->comm, task_pid_nr(task), __func__,
132                         frame, (void *)regs->epc, (void *)regs->sp);
133         }
134         force_sig(SIGSEGV);
135         return 0;
136 }
137 
138 static long setup_sigcontext(struct rt_sigframe __user *frame,
139         struct pt_regs *regs)
140 {
141         struct sigcontext __user *sc = &frame->uc.uc_mcontext;
142         long err;
143         /* sc_regs is structured the same as the start of pt_regs */
144         err = __copy_to_user(&sc->sc_regs, regs, sizeof(sc->sc_regs));
145         /* Save the floating-point state. */
146         if (has_fpu)
147                 err |= save_fp_state(regs, &sc->sc_fpregs);
148         return err;
149 }
150 
151 static inline void __user *get_sigframe(struct ksignal *ksig,
152         struct pt_regs *regs, size_t framesize)
153 {
154         unsigned long sp;
155         /* Default to using normal stack */
156         sp = regs->sp;
157 
158         /*
159          * If we are on the alternate signal stack and would overflow it, don't.
160          * Return an always-bogus address instead so we will die with SIGSEGV.
161          */
162         if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize)))
163                 return (void __user __force *)(-1UL);
164 
165         /* This is the X/Open sanctioned signal stack switching. */
166         sp = sigsp(sp, ksig) - framesize;
167 
168         /* Align the stack frame. */
169         sp &= ~0xfUL;
170 
171         return (void __user *)sp;
172 }
173 
174 static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
175         struct pt_regs *regs)
176 {
177         struct rt_sigframe __user *frame;
178         long err = 0;
179 
180         frame = get_sigframe(ksig, regs, sizeof(*frame));
181         if (!access_ok(frame, sizeof(*frame)))
182                 return -EFAULT;
183 
184         err |= copy_siginfo_to_user(&frame->info, &ksig->info);
185 
186         /* Create the ucontext. */
187         err |= __put_user(0, &frame->uc.uc_flags);
188         err |= __put_user(NULL, &frame->uc.uc_link);
189         err |= __save_altstack(&frame->uc.uc_stack, regs->sp);
190         err |= setup_sigcontext(frame, regs);
191         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
192         if (err)
193                 return -EFAULT;
194 
195         /* Set up to return from userspace. */
196 #ifdef CONFIG_MMU
197         regs->ra = (unsigned long)VDSO_SYMBOL(
198                 current->mm->context.vdso, rt_sigreturn);
199 #else
200         /*
201          * For the nommu case we don't have a VDSO.  Instead we push two
202          * instructions to call the rt_sigreturn syscall onto the user stack.
203          */
204         if (copy_to_user(&frame->sigreturn_code, __user_rt_sigreturn,
205                          sizeof(frame->sigreturn_code)))
206                 return -EFAULT;
207         regs->ra = (unsigned long)&frame->sigreturn_code;
208 #endif /* CONFIG_MMU */
209 
210         /*
211          * Set up registers for signal handler.
212          * Registers that we don't modify keep the value they had from
213          * user-space at the time we took the signal.
214          * We always pass siginfo and mcontext, regardless of SA_SIGINFO,
215          * since some things rely on this (e.g. glibc's debug/segfault.c).
216          */
217         regs->epc = (unsigned long)ksig->ka.sa.sa_handler;
218         regs->sp = (unsigned long)frame;
219         regs->a0 = ksig->sig;                     /* a0: signal number */
220         regs->a1 = (unsigned long)(&frame->info); /* a1: siginfo pointer */
221         regs->a2 = (unsigned long)(&frame->uc);   /* a2: ucontext pointer */
222 
223 #if DEBUG_SIG
224         pr_info("SIG deliver (%s:%d): sig=%d pc=%p ra=%p sp=%p\n",
225                 current->comm, task_pid_nr(current), ksig->sig,
226                 (void *)regs->epc, (void *)regs->ra, frame);
227 #endif
228 
229         return 0;
230 }
231 
232 static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
233 {
234         sigset_t *oldset = sigmask_to_save();
235         int ret;
236 
237         /* Are we from a system call? */
238         if (regs->cause == EXC_SYSCALL) {
239                 /* Avoid additional syscall restarting via ret_from_exception */
240                 regs->cause = -1UL;
241                 /* If so, check system call restarting.. */
242                 switch (regs->a0) {
243                 case -ERESTART_RESTARTBLOCK:
244                 case -ERESTARTNOHAND:
245                         regs->a0 = -EINTR;
246                         break;
247 
248                 case -ERESTARTSYS:
249                         if (!(ksig->ka.sa.sa_flags & SA_RESTART)) {
250                                 regs->a0 = -EINTR;
251                                 break;
252                         }
253                         /* fallthrough */
254                 case -ERESTARTNOINTR:
255                         regs->a0 = regs->orig_a0;
256                         regs->epc -= 0x4;
257                         break;
258                 }
259         }
260 
261         /* Set up the stack frame */
262         ret = setup_rt_frame(ksig, oldset, regs);
263 
264         signal_setup_done(ret, ksig, 0);
265 }
266 
267 static void do_signal(struct pt_regs *regs)
268 {
269         struct ksignal ksig;
270 
271         if (get_signal(&ksig)) {
272                 /* Actually deliver the signal */
273                 handle_signal(&ksig, regs);
274                 return;
275         }
276 
277         /* Did we come from a system call? */
278         if (regs->cause == EXC_SYSCALL) {
279                 /* Avoid additional syscall restarting via ret_from_exception */
280                 regs->cause = -1UL;
281 
282                 /* Restart the system call - no handlers present */
283                 switch (regs->a0) {
284                 case -ERESTARTNOHAND:
285                 case -ERESTARTSYS:
286                 case -ERESTARTNOINTR:
287                         regs->a0 = regs->orig_a0;
288                         regs->epc -= 0x4;
289                         break;
290                 case -ERESTART_RESTARTBLOCK:
291                         regs->a0 = regs->orig_a0;
292                         regs->a7 = __NR_restart_syscall;
293                         regs->epc -= 0x4;
294                         break;
295                 }
296         }
297 
298         /*
299          * If there is no signal to deliver, we just put the saved
300          * sigmask back.
301          */
302         restore_saved_sigmask();
303 }
304 
305 /*
306  * notification of userspace execution resumption
307  * - triggered by the _TIF_WORK_MASK flags
308  */
309 asmlinkage __visible void do_notify_resume(struct pt_regs *regs,
310                                            unsigned long thread_info_flags)
311 {
312         /* Handle pending signal delivery */
313         if (thread_info_flags & _TIF_SIGPENDING)
314                 do_signal(regs);
315 
316         if (thread_info_flags & _TIF_NOTIFY_RESUME) {
317                 clear_thread_flag(TIF_NOTIFY_RESUME);
318                 tracehook_notify_resume(regs);
319         }
320 }
321 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp