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

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

Version: ~ [ linux-5.10-rc1 ] ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ 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  * Signal Handling for ARC
  3  *
  4  * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
  5  *
  6  * This program is free software; you can redistribute it and/or modify
  7  * it under the terms of the GNU General Public License version 2 as
  8  * published by the Free Software Foundation.
  9  *
 10  * vineetg: Jan 2010 (Restarting of timer related syscalls)
 11  *
 12  * vineetg: Nov 2009 (Everything needed for TIF_RESTORE_SIGMASK)
 13  *  -do_signal() supports TIF_RESTORE_SIGMASK
 14  *  -do_signal() no loner needs oldset, required by OLD sys_sigsuspend
 15  *  -sys_rt_sigsuspend() now comes from generic code, so discard arch implemen
 16  *  -sys_sigsuspend() no longer needs to fudge ptregs, hence that arg removed
 17  *  -sys_sigsuspend() no longer loops for do_signal(), sets TIF_xxx and leaves
 18  *   the job to do_signal()
 19  *
 20  * vineetg: July 2009
 21  *  -Modified Code to support the uClibc provided userland sigreturn stub
 22  *   to avoid kernel synthesing it on user stack at runtime, costing TLB
 23  *   probes and Cache line flushes.
 24  *
 25  * vineetg: July 2009
 26  *  -In stash_usr_regs( ) and restore_usr_regs( ), save/restore of user regs
 27  *   in done in block copy rather than one word at a time.
 28  *   This saves around 2K of code and improves LMBench lat_sig <catch>
 29  *
 30  * rajeshwarr: Feb 2009
 31  *  - Support for Realtime Signals
 32  *
 33  * vineetg: Aug 11th 2008: Bug #94183
 34  *  -ViXS were still seeing crashes when using insmod to load drivers.
 35  *   It turned out that the code to change Execute permssions for TLB entries
 36  *   of user was not guarded for interrupts (mod_tlb_permission)
 37  *   This was cauing TLB entries to be overwritten on unrelated indexes
 38  *
 39  * Vineetg: July 15th 2008: Bug #94183
 40  *  -Exception happens in Delay slot of a JMP, and before user space resumes,
 41  *   Signal is delivered (Ctrl + C) = >SIGINT.
 42  *   setup_frame( ) sets up PC,SP,BLINK to enable user space signal handler
 43  *   to run, but doesn't clear the Delay slot bit from status32. As a result,
 44  *   on resuming user mode, signal handler branches off to BTA of orig JMP
 45  *  -FIX: clear the DE bit from status32 in setup_frame( )
 46  *
 47  * Rahul Trivedi, Kanika Nema: Codito Technologies 2004
 48  */
 49 
 50 #include <linux/signal.h>
 51 #include <linux/ptrace.h>
 52 #include <linux/personality.h>
 53 #include <linux/uaccess.h>
 54 #include <linux/syscalls.h>
 55 #include <linux/tracehook.h>
 56 #include <asm/ucontext.h>
 57 
 58 struct rt_sigframe {
 59         struct siginfo info;
 60         struct ucontext uc;
 61 #define MAGIC_SIGALTSTK         0x07302004
 62         unsigned int sigret_magic;
 63 };
 64 
 65 static int
 66 stash_usr_regs(struct rt_sigframe __user *sf, struct pt_regs *regs,
 67                sigset_t *set)
 68 {
 69         int err;
 70         err = __copy_to_user(&(sf->uc.uc_mcontext.regs), regs,
 71                              sizeof(sf->uc.uc_mcontext.regs.scratch));
 72         err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(sigset_t));
 73 
 74         return err;
 75 }
 76 
 77 static int restore_usr_regs(struct pt_regs *regs, struct rt_sigframe __user *sf)
 78 {
 79         sigset_t set;
 80         int err;
 81 
 82         err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
 83         if (!err)
 84                 set_current_blocked(&set);
 85 
 86         err |= __copy_from_user(regs, &(sf->uc.uc_mcontext.regs),
 87                                 sizeof(sf->uc.uc_mcontext.regs.scratch));
 88 
 89         return err;
 90 }
 91 
 92 static inline int is_do_ss_needed(unsigned int magic)
 93 {
 94         if (MAGIC_SIGALTSTK == magic)
 95                 return 1;
 96         else
 97                 return 0;
 98 }
 99 
100 SYSCALL_DEFINE0(rt_sigreturn)
101 {
102         struct rt_sigframe __user *sf;
103         unsigned int magic;
104         struct pt_regs *regs = current_pt_regs();
105 
106         /* Always make any pending restarted system calls return -EINTR */
107         current_thread_info()->restart_block.fn = do_no_restart_syscall;
108 
109         /* Since we stacked the signal on a word boundary,
110          * then 'sp' should be word aligned here.  If it's
111          * not, then the user is trying to mess with us.
112          */
113         if (regs->sp & 3)
114                 goto badframe;
115 
116         sf = (struct rt_sigframe __force __user *)(regs->sp);
117 
118         if (!access_ok(VERIFY_READ, sf, sizeof(*sf)))
119                 goto badframe;
120 
121         if (__get_user(magic, &sf->sigret_magic))
122                 goto badframe;
123 
124         if (unlikely(is_do_ss_needed(magic)))
125                 if (restore_altstack(&sf->uc.uc_stack))
126                         goto badframe;
127 
128         if (restore_usr_regs(regs, sf))
129                 goto badframe;
130 
131         /* Don't restart from sigreturn */
132         syscall_wont_restart(regs);
133 
134         return regs->r0;
135 
136 badframe:
137         force_sig(SIGSEGV, current);
138         return 0;
139 }
140 
141 /*
142  * Determine which stack to use..
143  */
144 static inline void __user *get_sigframe(struct k_sigaction *ka,
145                                         struct pt_regs *regs,
146                                         unsigned long framesize)
147 {
148         unsigned long sp = regs->sp;
149         void __user *frame;
150 
151         /* This is the X/Open sanctioned signal stack switching */
152         if ((ka->sa.sa_flags & SA_ONSTACK) && !sas_ss_flags(sp))
153                 sp = current->sas_ss_sp + current->sas_ss_size;
154 
155         /* No matter what happens, 'sp' must be word
156          * aligned otherwise nasty things could happen
157          */
158 
159         /* ATPCS B01 mandates 8-byte alignment */
160         frame = (void __user *)((sp - framesize) & ~7);
161 
162         /* Check that we can actually write to the signal frame */
163         if (!access_ok(VERIFY_WRITE, frame, framesize))
164                 frame = NULL;
165 
166         return frame;
167 }
168 
169 /*
170  * translate the signal
171  */
172 static inline int map_sig(int sig)
173 {
174         struct thread_info *thread = current_thread_info();
175         if (thread->exec_domain && thread->exec_domain->signal_invmap
176             && sig < 32)
177                 sig = thread->exec_domain->signal_invmap[sig];
178         return sig;
179 }
180 
181 static int
182 setup_rt_frame(int signo, struct k_sigaction *ka, siginfo_t *info,
183                sigset_t *set, struct pt_regs *regs)
184 {
185         struct rt_sigframe __user *sf;
186         unsigned int magic = 0;
187         int err = 0;
188 
189         sf = get_sigframe(ka, regs, sizeof(struct rt_sigframe));
190         if (!sf)
191                 return 1;
192 
193         /*
194          * w/o SA_SIGINFO, struct ucontext is partially populated (only
195          * uc_mcontext/uc_sigmask) for kernel's normal user state preservation
196          * during signal handler execution. This works for SA_SIGINFO as well
197          * although the semantics are now overloaded (the same reg state can be
198          * inspected by userland: but are they allowed to fiddle with it ?
199          */
200         err |= stash_usr_regs(sf, regs, set);
201 
202         /*
203          * SA_SIGINFO requires 3 args to signal handler:
204          *  #1: sig-no (common to any handler)
205          *  #2: struct siginfo
206          *  #3: struct ucontext (completely populated)
207          */
208         if (unlikely(ka->sa.sa_flags & SA_SIGINFO)) {
209                 err |= copy_siginfo_to_user(&sf->info, info);
210                 err |= __put_user(0, &sf->uc.uc_flags);
211                 err |= __put_user(NULL, &sf->uc.uc_link);
212                 err |= __save_altstack(&sf->uc.uc_stack, regs->sp);
213 
214                 /* setup args 2 and 3 for user mode handler */
215                 regs->r1 = (unsigned long)&sf->info;
216                 regs->r2 = (unsigned long)&sf->uc;
217 
218                 /*
219                  * small optim to avoid unconditonally calling do_sigaltstack
220                  * in sigreturn path, now that we only have rt_sigreturn
221                  */
222                 magic = MAGIC_SIGALTSTK;
223         }
224 
225         err |= __put_user(magic, &sf->sigret_magic);
226         if (err)
227                 return err;
228 
229         /* #1 arg to the user Signal handler */
230         regs->r0 = map_sig(signo);
231 
232         /* setup PC of user space signal handler */
233         regs->ret = (unsigned long)ka->sa.sa_handler;
234 
235         /*
236          * handler returns using sigreturn stub provided already by userpsace
237          */
238         BUG_ON(!(ka->sa.sa_flags & SA_RESTORER));
239         regs->blink = (unsigned long)ka->sa.sa_restorer;
240 
241         /* User Stack for signal handler will be above the frame just carved */
242         regs->sp = (unsigned long)sf;
243 
244         /*
245          * Bug 94183, Clear the DE bit, so that when signal handler
246          * starts to run, it doesn't use BTA
247          */
248         regs->status32 &= ~STATUS_DE_MASK;
249         regs->status32 |= STATUS_L_MASK;
250 
251         return err;
252 }
253 
254 static void arc_restart_syscall(struct k_sigaction *ka, struct pt_regs *regs)
255 {
256         switch (regs->r0) {
257         case -ERESTART_RESTARTBLOCK:
258         case -ERESTARTNOHAND:
259                 /*
260                  * ERESTARTNOHAND means that the syscall should
261                  * only be restarted if there was no handler for
262                  * the signal, and since we only get here if there
263                  * is a handler, we don't restart
264                  */
265                 regs->r0 = -EINTR;   /* ERESTART_xxx is internal */
266                 break;
267 
268         case -ERESTARTSYS:
269                 /*
270                  * ERESTARTSYS means to restart the syscall if
271                  * there is no handler or the handler was
272                  * registered with SA_RESTART
273                  */
274                 if (!(ka->sa.sa_flags & SA_RESTART)) {
275                         regs->r0 = -EINTR;
276                         break;
277                 }
278                 /* fallthrough */
279 
280         case -ERESTARTNOINTR:
281                 /*
282                  * ERESTARTNOINTR means that the syscall should
283                  * be called again after the signal handler returns.
284                  * Setup reg state just as it was before doing the trap
285                  * r0 has been clobbered with sys call ret code thus it
286                  * needs to be reloaded with orig first arg to syscall
287                  * in orig_r0. Rest of relevant reg-file:
288                  * r8 (syscall num) and (r1 - r7) will be reset to
289                  * their orig user space value when we ret from kernel
290                  */
291                 regs->r0 = regs->orig_r0;
292                 regs->ret -= 4;
293                 break;
294         }
295 }
296 
297 /*
298  * OK, we're invoking a handler
299  */
300 static void
301 handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
302               struct pt_regs *regs)
303 {
304         sigset_t *oldset = sigmask_to_save();
305         int ret;
306 
307         /* Set up the stack frame */
308         ret = setup_rt_frame(sig, ka, info, oldset, regs);
309 
310         if (ret)
311                 force_sigsegv(sig, current);
312         else
313                 signal_delivered(sig, info, ka, regs, 0);
314 }
315 
316 void do_signal(struct pt_regs *regs)
317 {
318         struct k_sigaction ka;
319         siginfo_t info;
320         int signr;
321         int restart_scall;
322 
323         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
324 
325         restart_scall = in_syscall(regs) && syscall_restartable(regs);
326 
327         if (signr > 0) {
328                 if (restart_scall) {
329                         arc_restart_syscall(&ka, regs);
330                         syscall_wont_restart(regs);     /* No more restarts */
331                 }
332                 handle_signal(signr, &ka, &info, regs);
333                 return;
334         }
335 
336         if (restart_scall) {
337                 /* No handler for syscall: restart it */
338                 if (regs->r0 == -ERESTARTNOHAND ||
339                     regs->r0 == -ERESTARTSYS || regs->r0 == -ERESTARTNOINTR) {
340                         regs->r0 = regs->orig_r0;
341                         regs->ret -= 4;
342                 } else if (regs->r0 == -ERESTART_RESTARTBLOCK) {
343                         regs->r8 = __NR_restart_syscall;
344                         regs->ret -= 4;
345                 }
346                 syscall_wont_restart(regs);     /* No more restarts */
347         }
348 
349         /* If there's no signal to deliver, restore the saved sigmask back */
350         restore_saved_sigmask();
351 }
352 
353 void do_notify_resume(struct pt_regs *regs)
354 {
355         /*
356          * ASM glue gaurantees that this is only called when returning to
357          * user mode
358          */
359         if (test_and_clear_thread_flag(TIF_NOTIFY_RESUME))
360                 tracehook_notify_resume(regs);
361 }
362 

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