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

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

Version: ~ [ linux-5.13-rc7 ] ~ [ linux-5.12.12 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.45 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.127 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.195 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.237 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.273 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.273 ] ~ [ 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 /*
  2  * Copyright (C) 2013-2014 Altera Corporation
  3  * Copyright (C) 2011-2012 Tobias Klauser <tklauser@distanz.ch>
  4  * Copyright (C) 2004 Microtronix Datacom Ltd
  5  * Copyright (C) 1991, 1992 Linus Torvalds
  6  *
  7  * This file is subject to the terms and conditions of the GNU General Public
  8  * License.  See the file COPYING in the main directory of this archive
  9  * for more details.
 10  */
 11 
 12 #include <linux/signal.h>
 13 #include <linux/errno.h>
 14 #include <linux/ptrace.h>
 15 #include <linux/uaccess.h>
 16 #include <linux/unistd.h>
 17 #include <linux/personality.h>
 18 #include <linux/tracehook.h>
 19 
 20 #include <asm/ucontext.h>
 21 #include <asm/cacheflush.h>
 22 
 23 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
 24 
 25 /*
 26  * Do a signal return; undo the signal stack.
 27  *
 28  * Keep the return code on the stack quadword aligned!
 29  * That makes the cache flush below easier.
 30  */
 31 
 32 struct rt_sigframe {
 33         struct siginfo info;
 34         struct ucontext uc;
 35 };
 36 
 37 static inline int rt_restore_ucontext(struct pt_regs *regs,
 38                                         struct switch_stack *sw,
 39                                         struct ucontext *uc, int *pr2)
 40 {
 41         int temp;
 42         unsigned long *gregs = uc->uc_mcontext.gregs;
 43         int err;
 44 
 45         /* Always make any pending restarted system calls return -EINTR */
 46         current->restart_block.fn = do_no_restart_syscall;
 47 
 48         err = __get_user(temp, &uc->uc_mcontext.version);
 49         if (temp != MCONTEXT_VERSION)
 50                 goto badframe;
 51         /* restore passed registers */
 52         err |= __get_user(regs->r1, &gregs[0]);
 53         err |= __get_user(regs->r2, &gregs[1]);
 54         err |= __get_user(regs->r3, &gregs[2]);
 55         err |= __get_user(regs->r4, &gregs[3]);
 56         err |= __get_user(regs->r5, &gregs[4]);
 57         err |= __get_user(regs->r6, &gregs[5]);
 58         err |= __get_user(regs->r7, &gregs[6]);
 59         err |= __get_user(regs->r8, &gregs[7]);
 60         err |= __get_user(regs->r9, &gregs[8]);
 61         err |= __get_user(regs->r10, &gregs[9]);
 62         err |= __get_user(regs->r11, &gregs[10]);
 63         err |= __get_user(regs->r12, &gregs[11]);
 64         err |= __get_user(regs->r13, &gregs[12]);
 65         err |= __get_user(regs->r14, &gregs[13]);
 66         err |= __get_user(regs->r15, &gregs[14]);
 67         err |= __get_user(sw->r16, &gregs[15]);
 68         err |= __get_user(sw->r17, &gregs[16]);
 69         err |= __get_user(sw->r18, &gregs[17]);
 70         err |= __get_user(sw->r19, &gregs[18]);
 71         err |= __get_user(sw->r20, &gregs[19]);
 72         err |= __get_user(sw->r21, &gregs[20]);
 73         err |= __get_user(sw->r22, &gregs[21]);
 74         err |= __get_user(sw->r23, &gregs[22]);
 75         /* gregs[23] is handled below */
 76         err |= __get_user(sw->fp, &gregs[24]);  /* Verify, should this be
 77                                                         settable */
 78         err |= __get_user(sw->gp, &gregs[25]);  /* Verify, should this be
 79                                                         settable */
 80 
 81         err |= __get_user(temp, &gregs[26]);  /* Not really necessary no user
 82                                                         settable bits */
 83         err |= __get_user(regs->ea, &gregs[27]);
 84 
 85         err |= __get_user(regs->ra, &gregs[23]);
 86         err |= __get_user(regs->sp, &gregs[28]);
 87 
 88         regs->orig_r2 = -1;             /* disable syscall checks */
 89 
 90         err |= restore_altstack(&uc->uc_stack);
 91         if (err)
 92                 goto badframe;
 93 
 94         *pr2 = regs->r2;
 95         return err;
 96 
 97 badframe:
 98         return 1;
 99 }
100 
101 asmlinkage int do_rt_sigreturn(struct switch_stack *sw)
102 {
103         struct pt_regs *regs = (struct pt_regs *)(sw + 1);
104         /* Verify, can we follow the stack back */
105         struct rt_sigframe *frame = (struct rt_sigframe *) regs->sp;
106         sigset_t set;
107         int rval;
108 
109         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
110                 goto badframe;
111 
112         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
113                 goto badframe;
114 
115         set_current_blocked(&set);
116 
117         if (rt_restore_ucontext(regs, sw, &frame->uc, &rval))
118                 goto badframe;
119 
120         return rval;
121 
122 badframe:
123         force_sig(SIGSEGV, current);
124         return 0;
125 }
126 
127 static inline int rt_setup_ucontext(struct ucontext *uc, struct pt_regs *regs)
128 {
129         struct switch_stack *sw = (struct switch_stack *)regs - 1;
130         unsigned long *gregs = uc->uc_mcontext.gregs;
131         int err = 0;
132 
133         err |= __put_user(MCONTEXT_VERSION, &uc->uc_mcontext.version);
134         err |= __put_user(regs->r1, &gregs[0]);
135         err |= __put_user(regs->r2, &gregs[1]);
136         err |= __put_user(regs->r3, &gregs[2]);
137         err |= __put_user(regs->r4, &gregs[3]);
138         err |= __put_user(regs->r5, &gregs[4]);
139         err |= __put_user(regs->r6, &gregs[5]);
140         err |= __put_user(regs->r7, &gregs[6]);
141         err |= __put_user(regs->r8, &gregs[7]);
142         err |= __put_user(regs->r9, &gregs[8]);
143         err |= __put_user(regs->r10, &gregs[9]);
144         err |= __put_user(regs->r11, &gregs[10]);
145         err |= __put_user(regs->r12, &gregs[11]);
146         err |= __put_user(regs->r13, &gregs[12]);
147         err |= __put_user(regs->r14, &gregs[13]);
148         err |= __put_user(regs->r15, &gregs[14]);
149         err |= __put_user(sw->r16, &gregs[15]);
150         err |= __put_user(sw->r17, &gregs[16]);
151         err |= __put_user(sw->r18, &gregs[17]);
152         err |= __put_user(sw->r19, &gregs[18]);
153         err |= __put_user(sw->r20, &gregs[19]);
154         err |= __put_user(sw->r21, &gregs[20]);
155         err |= __put_user(sw->r22, &gregs[21]);
156         err |= __put_user(sw->r23, &gregs[22]);
157         err |= __put_user(regs->ra, &gregs[23]);
158         err |= __put_user(sw->fp, &gregs[24]);
159         err |= __put_user(sw->gp, &gregs[25]);
160         err |= __put_user(regs->ea, &gregs[27]);
161         err |= __put_user(regs->sp, &gregs[28]);
162         return err;
163 }
164 
165 static inline void *get_sigframe(struct ksignal *ksig, struct pt_regs *regs,
166                                  size_t frame_size)
167 {
168         unsigned long usp;
169 
170         /* Default to using normal stack.  */
171         usp = regs->sp;
172 
173         /* This is the X/Open sanctioned signal stack switching.  */
174         usp = sigsp(usp, ksig);
175 
176         /* Verify, is it 32 or 64 bit aligned */
177         return (void *)((usp - frame_size) & -8UL);
178 }
179 
180 static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
181                           struct pt_regs *regs)
182 {
183         struct rt_sigframe *frame;
184         int err = 0;
185 
186         frame = get_sigframe(ksig, regs, sizeof(*frame));
187 
188         if (ksig->ka.sa.sa_flags & SA_SIGINFO)
189                 err |= copy_siginfo_to_user(&frame->info, &ksig->info);
190 
191         /* Create the ucontext.  */
192         err |= __put_user(0, &frame->uc.uc_flags);
193         err |= __put_user(0, &frame->uc.uc_link);
194         err |= __save_altstack(&frame->uc.uc_stack, regs->sp);
195         err |= rt_setup_ucontext(&frame->uc, regs);
196         err |= copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
197 
198         if (err)
199                 goto give_sigsegv;
200 
201         /* Set up to return from userspace; jump to fixed address sigreturn
202            trampoline on kuser page.  */
203         regs->ra = (unsigned long) (0x1044);
204 
205         /* Set up registers for signal handler */
206         regs->sp = (unsigned long) frame;
207         regs->r4 = (unsigned long) ksig->sig;
208         regs->r5 = (unsigned long) &frame->info;
209         regs->r6 = (unsigned long) &frame->uc;
210         regs->ea = (unsigned long) ksig->ka.sa.sa_handler;
211         return 0;
212 
213 give_sigsegv:
214         force_sigsegv(ksig->sig, current);
215         return -EFAULT;
216 }
217 
218 /*
219  * OK, we're invoking a handler
220  */
221 static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
222 {
223         int ret;
224         sigset_t *oldset = sigmask_to_save();
225 
226         /* set up the stack frame */
227         ret = setup_rt_frame(ksig, oldset, regs);
228 
229         signal_setup_done(ret, ksig, 0);
230 }
231 
232 static int do_signal(struct pt_regs *regs)
233 {
234         unsigned int retval = 0, continue_addr = 0, restart_addr = 0;
235         int restart = 0;
236         struct ksignal ksig;
237 
238         current->thread.kregs = regs;
239 
240         /*
241          * If we were from a system call, check for system call restarting...
242          */
243         if (regs->orig_r2 >= 0) {
244                 continue_addr = regs->ea;
245                 restart_addr = continue_addr - 4;
246                 retval = regs->r2;
247 
248                 /*
249                  * Prepare for system call restart. We do this here so that a
250                  * debugger will see the already changed PC.
251                  */
252                 switch (retval) {
253                 case ERESTART_RESTARTBLOCK:
254                         restart = -2;
255                 case ERESTARTNOHAND:
256                 case ERESTARTSYS:
257                 case ERESTARTNOINTR:
258                         restart++;
259                         regs->r2 = regs->orig_r2;
260                         regs->r7 = regs->orig_r7;
261                         regs->ea = restart_addr;
262                         break;
263                 }
264         }
265 
266         if (get_signal(&ksig)) {
267                 /* handler */
268                 if (unlikely(restart && regs->ea == restart_addr)) {
269                         if (retval == ERESTARTNOHAND ||
270                             retval == ERESTART_RESTARTBLOCK ||
271                              (retval == ERESTARTSYS
272                                 && !(ksig.ka.sa.sa_flags & SA_RESTART))) {
273                                 regs->r2 = EINTR;
274                                 regs->r7 = 1;
275                                 regs->ea = continue_addr;
276                         }
277                 }
278                 handle_signal(&ksig, regs);
279                 return 0;
280         }
281 
282         /*
283          * No handler present
284          */
285         if (unlikely(restart) && regs->ea == restart_addr) {
286                 regs->ea = continue_addr;
287                 regs->r2 = __NR_restart_syscall;
288         }
289 
290         /*
291         * If there's no signal to deliver, we just put the saved sigmask back.
292         */
293         restore_saved_sigmask();
294 
295         return restart;
296 }
297 
298 asmlinkage int do_notify_resume(struct pt_regs *regs)
299 {
300         /*
301          * We want the common case to go fast, which is why we may in certain
302          * cases get here from kernel mode. Just return without doing anything
303          * if so.
304          */
305         if (!user_mode(regs))
306                 return 0;
307 
308         if (test_thread_flag(TIF_SIGPENDING)) {
309                 int restart = do_signal(regs);
310 
311                 if (unlikely(restart)) {
312                         /*
313                          * Restart without handlers.
314                          * Deal with it without leaving
315                          * the kernel space.
316                          */
317                         return restart;
318                 }
319         } else if (test_and_clear_thread_flag(TIF_NOTIFY_RESUME))
320                 tracehook_notify_resume(regs);
321 
322         return 0;
323 }
324 

~ [ 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