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

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

Version: ~ [ linux-6.0-rc1 ] ~ [ linux-5.19.1 ] ~ [ linux-5.18.17 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.60 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.136 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.210 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.255 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.290 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.325 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ 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.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Signal handling
  3  *
  4  * Copyright (C) 2008-2009 Michal Simek <monstr@monstr.eu>
  5  * Copyright (C) 2008-2009 PetaLogix
  6  * Copyright (C) 2003,2004 John Williams <jwilliams@itee.uq.edu.au>
  7  * Copyright (C) 2001 NEC Corporation
  8  * Copyright (C) 2001 Miles Bader <miles@gnu.org>
  9  * Copyright (C) 1999,2000 Niibe Yutaka & Kaz Kojima
 10  * Copyright (C) 1991,1992 Linus Torvalds
 11  *
 12  * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
 13  *
 14  * This file was was derived from the sh version, arch/sh/kernel/signal.c
 15  *
 16  * This file is subject to the terms and conditions of the GNU General
 17  * Public License. See the file COPYING in the main directory of this
 18  * archive for more details.
 19  */
 20 
 21 #include <linux/sched.h>
 22 #include <linux/mm.h>
 23 #include <linux/smp.h>
 24 #include <linux/kernel.h>
 25 #include <linux/signal.h>
 26 #include <linux/errno.h>
 27 #include <linux/wait.h>
 28 #include <linux/ptrace.h>
 29 #include <linux/unistd.h>
 30 #include <linux/stddef.h>
 31 #include <linux/personality.h>
 32 #include <linux/percpu.h>
 33 #include <linux/linkage.h>
 34 #include <linux/tracehook.h>
 35 #include <asm/entry.h>
 36 #include <asm/ucontext.h>
 37 #include <linux/uaccess.h>
 38 #include <asm/pgtable.h>
 39 #include <asm/pgalloc.h>
 40 #include <linux/syscalls.h>
 41 #include <asm/cacheflush.h>
 42 #include <asm/syscalls.h>
 43 
 44 /*
 45  * Do a signal return; undo the signal stack.
 46  */
 47 struct sigframe {
 48         struct sigcontext sc;
 49         unsigned long extramask[_NSIG_WORDS-1];
 50         unsigned long tramp[2]; /* signal trampoline */
 51 };
 52 
 53 struct rt_sigframe {
 54         struct siginfo info;
 55         struct ucontext uc;
 56         unsigned long tramp[2]; /* signal trampoline */
 57 };
 58 
 59 static int restore_sigcontext(struct pt_regs *regs,
 60                                 struct sigcontext __user *sc, int *rval_p)
 61 {
 62         unsigned int err = 0;
 63 
 64 #define COPY(x)         {err |= __get_user(regs->x, &sc->regs.x); }
 65         COPY(r0);
 66         COPY(r1);
 67         COPY(r2);       COPY(r3);       COPY(r4);       COPY(r5);
 68         COPY(r6);       COPY(r7);       COPY(r8);       COPY(r9);
 69         COPY(r10);      COPY(r11);      COPY(r12);      COPY(r13);
 70         COPY(r14);      COPY(r15);      COPY(r16);      COPY(r17);
 71         COPY(r18);      COPY(r19);      COPY(r20);      COPY(r21);
 72         COPY(r22);      COPY(r23);      COPY(r24);      COPY(r25);
 73         COPY(r26);      COPY(r27);      COPY(r28);      COPY(r29);
 74         COPY(r30);      COPY(r31);
 75         COPY(pc);       COPY(ear);      COPY(esr);      COPY(fsr);
 76 #undef COPY
 77 
 78         *rval_p = regs->r3;
 79 
 80         return err;
 81 }
 82 
 83 asmlinkage long sys_rt_sigreturn(struct pt_regs *regs)
 84 {
 85         struct rt_sigframe __user *frame =
 86                 (struct rt_sigframe __user *)(regs->r1);
 87 
 88         sigset_t set;
 89         int rval;
 90 
 91         /* Always make any pending restarted system calls return -EINTR */
 92         current->restart_block.fn = do_no_restart_syscall;
 93 
 94         if (!access_ok(frame, sizeof(*frame)))
 95                 goto badframe;
 96 
 97         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 98                 goto badframe;
 99 
100         set_current_blocked(&set);
101 
102         if (restore_sigcontext(regs, &frame->uc.uc_mcontext, &rval))
103                 goto badframe;
104 
105         if (restore_altstack(&frame->uc.uc_stack))
106                 goto badframe;
107 
108         return rval;
109 
110 badframe:
111         force_sig(SIGSEGV, current);
112         return 0;
113 }
114 
115 /*
116  * Set up a signal frame.
117  */
118 
119 static int
120 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
121                 unsigned long mask)
122 {
123         int err = 0;
124 
125 #define COPY(x)         {err |= __put_user(regs->x, &sc->regs.x); }
126         COPY(r0);
127         COPY(r1);
128         COPY(r2);       COPY(r3);       COPY(r4);       COPY(r5);
129         COPY(r6);       COPY(r7);       COPY(r8);       COPY(r9);
130         COPY(r10);      COPY(r11);      COPY(r12);      COPY(r13);
131         COPY(r14);      COPY(r15);      COPY(r16);      COPY(r17);
132         COPY(r18);      COPY(r19);      COPY(r20);      COPY(r21);
133         COPY(r22);      COPY(r23);      COPY(r24);      COPY(r25);
134         COPY(r26);      COPY(r27);      COPY(r28);      COPY(r29);
135         COPY(r30);      COPY(r31);
136         COPY(pc);       COPY(ear);      COPY(esr);      COPY(fsr);
137 #undef COPY
138 
139         err |= __put_user(mask, &sc->oldmask);
140 
141         return err;
142 }
143 
144 /*
145  * Determine which stack to use..
146  */
147 static inline void __user *
148 get_sigframe(struct ksignal *ksig, struct pt_regs *regs, size_t frame_size)
149 {
150         /* Default to using normal stack */
151         unsigned long sp = sigsp(regs->r1, ksig);
152 
153         return (void __user *)((sp - frame_size) & -8UL);
154 }
155 
156 static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
157                           struct pt_regs *regs)
158 {
159         struct rt_sigframe __user *frame;
160         int err = 0, sig = ksig->sig;
161         unsigned long address = 0;
162 #ifdef CONFIG_MMU
163         pmd_t *pmdp;
164         pte_t *ptep;
165 #endif
166 
167         frame = get_sigframe(ksig, regs, sizeof(*frame));
168 
169         if (!access_ok(frame, sizeof(*frame)))
170                 return -EFAULT;
171 
172         if (ksig->ka.sa.sa_flags & SA_SIGINFO)
173                 err |= copy_siginfo_to_user(&frame->info, &ksig->info);
174 
175         /* Create the ucontext. */
176         err |= __put_user(0, &frame->uc.uc_flags);
177         err |= __put_user(NULL, &frame->uc.uc_link);
178         err |= __save_altstack(&frame->uc.uc_stack, regs->r1);
179         err |= setup_sigcontext(&frame->uc.uc_mcontext,
180                         regs, set->sig[0]);
181         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
182 
183         /* Set up to return from userspace. If provided, use a stub
184          already in userspace. */
185         /* minus 8 is offset to cater for "rtsd r15,8" */
186         /* addi r12, r0, __NR_sigreturn */
187         err |= __put_user(0x31800000 | __NR_rt_sigreturn ,
188                         frame->tramp + 0);
189         /* brki r14, 0x8 */
190         err |= __put_user(0xb9cc0008, frame->tramp + 1);
191 
192         /* Return from sighandler will jump to the tramp.
193          Negative 8 offset because return is rtsd r15, 8 */
194         regs->r15 = ((unsigned long)frame->tramp)-8;
195 
196         address = ((unsigned long)frame->tramp);
197 #ifdef CONFIG_MMU
198         pmdp = pmd_offset(pud_offset(
199                         pgd_offset(current->mm, address),
200                                         address), address);
201 
202         preempt_disable();
203         ptep = pte_offset_map(pmdp, address);
204         if (pte_present(*ptep)) {
205                 address = (unsigned long) page_address(pte_page(*ptep));
206                 /* MS: I need add offset in page */
207                 address += ((unsigned long)frame->tramp) & ~PAGE_MASK;
208                 /* MS address is virtual */
209                 address = __virt_to_phys(address);
210                 invalidate_icache_range(address, address + 8);
211                 flush_dcache_range(address, address + 8);
212         }
213         pte_unmap(ptep);
214         preempt_enable();
215 #else
216         flush_icache_range(address, address + 8);
217         flush_dcache_range(address, address + 8);
218 #endif
219         if (err)
220                 return -EFAULT;
221 
222         /* Set up registers for signal handler */
223         regs->r1 = (unsigned long) frame;
224 
225         /* Signal handler args: */
226         regs->r5 = sig; /* arg 0: signum */
227         regs->r6 = (unsigned long) &frame->info; /* arg 1: siginfo */
228         regs->r7 = (unsigned long) &frame->uc; /* arg2: ucontext */
229         /* Offset to handle microblaze rtid r14, 0 */
230         regs->pc = (unsigned long)ksig->ka.sa.sa_handler;
231 
232 #ifdef DEBUG_SIG
233         pr_info("SIG deliver (%s:%d): sp=%p pc=%08lx\n",
234                 current->comm, current->pid, frame, regs->pc);
235 #endif
236 
237         return 0;
238 }
239 
240 /* Handle restarting system calls */
241 static inline void
242 handle_restart(struct pt_regs *regs, struct k_sigaction *ka, int has_handler)
243 {
244         switch (regs->r3) {
245         case -ERESTART_RESTARTBLOCK:
246         case -ERESTARTNOHAND:
247                 if (!has_handler)
248                         goto do_restart;
249                 regs->r3 = -EINTR;
250                 break;
251         case -ERESTARTSYS:
252                 if (has_handler && !(ka->sa.sa_flags & SA_RESTART)) {
253                         regs->r3 = -EINTR;
254                         break;
255         }
256         /* fallthrough */
257         case -ERESTARTNOINTR:
258 do_restart:
259                 /* offset of 4 bytes to re-execute trap (brki) instruction */
260                 regs->pc -= 4;
261                 break;
262         }
263 }
264 
265 /*
266  * OK, we're invoking a handler
267  */
268 
269 static void
270 handle_signal(struct ksignal *ksig, struct pt_regs *regs)
271 {
272         sigset_t *oldset = sigmask_to_save();
273         int ret;
274 
275         /* Set up the stack frame */
276         ret = setup_rt_frame(ksig, oldset, regs);
277 
278         signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
279 }
280 
281 /*
282  * Note that 'init' is a special process: it doesn't get signals it doesn't
283  * want to handle. Thus you cannot kill init even with a SIGKILL even by
284  * mistake.
285  *
286  * Note that we go through the signals twice: once to check the signals that
287  * the kernel can handle, and then we build all the user-level signal handling
288  * stack-frames in one go after that.
289  */
290 static void do_signal(struct pt_regs *regs, int in_syscall)
291 {
292         struct ksignal ksig;
293 
294 #ifdef DEBUG_SIG
295         pr_info("do signal: %p %d\n", regs, in_syscall);
296         pr_info("do signal2: %lx %lx %ld [%lx]\n", regs->pc, regs->r1,
297                         regs->r12, current_thread_info()->flags);
298 #endif
299 
300         if (get_signal(&ksig)) {
301                 /* Whee! Actually deliver the signal. */
302                 if (in_syscall)
303                         handle_restart(regs, &ksig.ka, 1);
304                 handle_signal(&ksig, regs);
305                 return;
306         }
307 
308         if (in_syscall)
309                 handle_restart(regs, NULL, 0);
310 
311         /*
312          * If there's no signal to deliver, we just put the saved sigmask
313          * back.
314          */
315         restore_saved_sigmask();
316 }
317 
318 asmlinkage void do_notify_resume(struct pt_regs *regs, int in_syscall)
319 {
320         if (test_thread_flag(TIF_SIGPENDING))
321                 do_signal(regs, in_syscall);
322 
323         if (test_and_clear_thread_flag(TIF_NOTIFY_RESUME))
324                 tracehook_notify_resume(regs);
325 }
326 

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