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

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

Version: ~ [ linux-5.14-rc3 ] ~ [ linux-5.13.5 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.53 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.135 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.198 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.240 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.276 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.276 ] ~ [ 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  * Based on arch/arm/kernel/signal.c
  3  *
  4  * Copyright (C) 1995-2009 Russell King
  5  * Copyright (C) 2012 ARM Ltd.
  6  *
  7  * This program is free software; you can redistribute it and/or modify
  8  * it under the terms of the GNU General Public License version 2 as
  9  * published by the Free Software Foundation.
 10  *
 11  * This program is distributed in the hope that it will be useful,
 12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 14  * GNU General Public License for more details.
 15  *
 16  * You should have received a copy of the GNU General Public License
 17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 18  */
 19 
 20 #include <linux/compat.h>
 21 #include <linux/errno.h>
 22 #include <linux/signal.h>
 23 #include <linux/personality.h>
 24 #include <linux/freezer.h>
 25 #include <linux/uaccess.h>
 26 #include <linux/tracehook.h>
 27 #include <linux/ratelimit.h>
 28 
 29 #include <asm/debug-monitors.h>
 30 #include <asm/elf.h>
 31 #include <asm/cacheflush.h>
 32 #include <asm/ucontext.h>
 33 #include <asm/unistd.h>
 34 #include <asm/fpsimd.h>
 35 #include <asm/signal32.h>
 36 #include <asm/vdso.h>
 37 
 38 /*
 39  * Do a signal return; undo the signal stack. These are aligned to 128-bit.
 40  */
 41 struct rt_sigframe {
 42         struct siginfo info;
 43         struct ucontext uc;
 44         u64 fp;
 45         u64 lr;
 46 };
 47 
 48 static int preserve_fpsimd_context(struct fpsimd_context __user *ctx)
 49 {
 50         struct fpsimd_state *fpsimd = &current->thread.fpsimd_state;
 51         int err;
 52 
 53         /* dump the hardware registers to the fpsimd_state structure */
 54         fpsimd_preserve_current_state();
 55 
 56         /* copy the FP and status/control registers */
 57         err = __copy_to_user(ctx->vregs, fpsimd->vregs, sizeof(fpsimd->vregs));
 58         __put_user_error(fpsimd->fpsr, &ctx->fpsr, err);
 59         __put_user_error(fpsimd->fpcr, &ctx->fpcr, err);
 60 
 61         /* copy the magic/size information */
 62         __put_user_error(FPSIMD_MAGIC, &ctx->head.magic, err);
 63         __put_user_error(sizeof(struct fpsimd_context), &ctx->head.size, err);
 64 
 65         return err ? -EFAULT : 0;
 66 }
 67 
 68 static int restore_fpsimd_context(struct fpsimd_context __user *ctx)
 69 {
 70         struct fpsimd_state fpsimd;
 71         __u32 magic, size;
 72         int err = 0;
 73 
 74         /* check the magic/size information */
 75         __get_user_error(magic, &ctx->head.magic, err);
 76         __get_user_error(size, &ctx->head.size, err);
 77         if (err)
 78                 return -EFAULT;
 79         if (magic != FPSIMD_MAGIC || size != sizeof(struct fpsimd_context))
 80                 return -EINVAL;
 81 
 82         /* copy the FP and status/control registers */
 83         err = __copy_from_user(fpsimd.vregs, ctx->vregs,
 84                                sizeof(fpsimd.vregs));
 85         __get_user_error(fpsimd.fpsr, &ctx->fpsr, err);
 86         __get_user_error(fpsimd.fpcr, &ctx->fpcr, err);
 87 
 88         /* load the hardware registers from the fpsimd_state structure */
 89         if (!err)
 90                 fpsimd_update_current_state(&fpsimd);
 91 
 92         return err ? -EFAULT : 0;
 93 }
 94 
 95 static int restore_sigframe(struct pt_regs *regs,
 96                             struct rt_sigframe __user *sf)
 97 {
 98         sigset_t set;
 99         int i, err;
100         void *aux = sf->uc.uc_mcontext.__reserved;
101 
102         err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
103         if (err == 0)
104                 set_current_blocked(&set);
105 
106         for (i = 0; i < 31; i++)
107                 __get_user_error(regs->regs[i], &sf->uc.uc_mcontext.regs[i],
108                                  err);
109         __get_user_error(regs->sp, &sf->uc.uc_mcontext.sp, err);
110         __get_user_error(regs->pc, &sf->uc.uc_mcontext.pc, err);
111         __get_user_error(regs->pstate, &sf->uc.uc_mcontext.pstate, err);
112 
113         /*
114          * Avoid sys_rt_sigreturn() restarting.
115          */
116         regs->syscallno = ~0UL;
117 
118         err |= !valid_user_regs(&regs->user_regs, current);
119 
120         if (err == 0) {
121                 struct fpsimd_context *fpsimd_ctx =
122                         container_of(aux, struct fpsimd_context, head);
123                 err |= restore_fpsimd_context(fpsimd_ctx);
124         }
125 
126         return err;
127 }
128 
129 asmlinkage long sys_rt_sigreturn(struct pt_regs *regs)
130 {
131         struct rt_sigframe __user *frame;
132 
133         /* Always make any pending restarted system calls return -EINTR */
134         current->restart_block.fn = do_no_restart_syscall;
135 
136         /*
137          * Since we stacked the signal on a 128-bit boundary, then 'sp' should
138          * be word aligned here.
139          */
140         if (regs->sp & 15)
141                 goto badframe;
142 
143         frame = (struct rt_sigframe __user *)regs->sp;
144 
145         if (!access_ok(VERIFY_READ, frame, sizeof (*frame)))
146                 goto badframe;
147 
148         if (restore_sigframe(regs, frame))
149                 goto badframe;
150 
151         if (restore_altstack(&frame->uc.uc_stack))
152                 goto badframe;
153 
154         return regs->regs[0];
155 
156 badframe:
157         if (show_unhandled_signals)
158                 pr_info_ratelimited("%s[%d]: bad frame in %s: pc=%08llx sp=%08llx\n",
159                                     current->comm, task_pid_nr(current), __func__,
160                                     regs->pc, regs->sp);
161         force_sig(SIGSEGV, current);
162         return 0;
163 }
164 
165 static int setup_sigframe(struct rt_sigframe __user *sf,
166                           struct pt_regs *regs, sigset_t *set)
167 {
168         int i, err = 0;
169         void *aux = sf->uc.uc_mcontext.__reserved;
170         struct _aarch64_ctx *end;
171 
172         /* set up the stack frame for unwinding */
173         __put_user_error(regs->regs[29], &sf->fp, err);
174         __put_user_error(regs->regs[30], &sf->lr, err);
175 
176         for (i = 0; i < 31; i++)
177                 __put_user_error(regs->regs[i], &sf->uc.uc_mcontext.regs[i],
178                                  err);
179         __put_user_error(regs->sp, &sf->uc.uc_mcontext.sp, err);
180         __put_user_error(regs->pc, &sf->uc.uc_mcontext.pc, err);
181         __put_user_error(regs->pstate, &sf->uc.uc_mcontext.pstate, err);
182 
183         __put_user_error(current->thread.fault_address, &sf->uc.uc_mcontext.fault_address, err);
184 
185         err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set));
186 
187         if (err == 0) {
188                 struct fpsimd_context *fpsimd_ctx =
189                         container_of(aux, struct fpsimd_context, head);
190                 err |= preserve_fpsimd_context(fpsimd_ctx);
191                 aux += sizeof(*fpsimd_ctx);
192         }
193 
194         /* fault information, if valid */
195         if (current->thread.fault_code) {
196                 struct esr_context *esr_ctx =
197                         container_of(aux, struct esr_context, head);
198                 __put_user_error(ESR_MAGIC, &esr_ctx->head.magic, err);
199                 __put_user_error(sizeof(*esr_ctx), &esr_ctx->head.size, err);
200                 __put_user_error(current->thread.fault_code, &esr_ctx->esr, err);
201                 aux += sizeof(*esr_ctx);
202         }
203 
204         /* set the "end" magic */
205         end = aux;
206         __put_user_error(0, &end->magic, err);
207         __put_user_error(0, &end->size, err);
208 
209         return err;
210 }
211 
212 static struct rt_sigframe __user *get_sigframe(struct ksignal *ksig,
213                                                struct pt_regs *regs)
214 {
215         unsigned long sp, sp_top;
216         struct rt_sigframe __user *frame;
217 
218         sp = sp_top = sigsp(regs->sp, ksig);
219 
220         sp = (sp - sizeof(struct rt_sigframe)) & ~15;
221         frame = (struct rt_sigframe __user *)sp;
222 
223         /*
224          * Check that we can actually write to the signal frame.
225          */
226         if (!access_ok(VERIFY_WRITE, frame, sp_top - sp))
227                 frame = NULL;
228 
229         return frame;
230 }
231 
232 static void setup_return(struct pt_regs *regs, struct k_sigaction *ka,
233                          void __user *frame, int usig)
234 {
235         __sigrestore_t sigtramp;
236 
237         regs->regs[0] = usig;
238         regs->sp = (unsigned long)frame;
239         regs->regs[29] = regs->sp + offsetof(struct rt_sigframe, fp);
240         regs->pc = (unsigned long)ka->sa.sa_handler;
241 
242         if (ka->sa.sa_flags & SA_RESTORER)
243                 sigtramp = ka->sa.sa_restorer;
244         else
245                 sigtramp = VDSO_SYMBOL(current->mm->context.vdso, sigtramp);
246 
247         regs->regs[30] = (unsigned long)sigtramp;
248 }
249 
250 static int setup_rt_frame(int usig, struct ksignal *ksig, sigset_t *set,
251                           struct pt_regs *regs)
252 {
253         struct rt_sigframe __user *frame;
254         int err = 0;
255 
256         frame = get_sigframe(ksig, regs);
257         if (!frame)
258                 return 1;
259 
260         __put_user_error(0, &frame->uc.uc_flags, err);
261         __put_user_error(NULL, &frame->uc.uc_link, err);
262 
263         err |= __save_altstack(&frame->uc.uc_stack, regs->sp);
264         err |= setup_sigframe(frame, regs, set);
265         if (err == 0) {
266                 setup_return(regs, &ksig->ka, frame, usig);
267                 if (ksig->ka.sa.sa_flags & SA_SIGINFO) {
268                         err |= copy_siginfo_to_user(&frame->info, &ksig->info);
269                         regs->regs[1] = (unsigned long)&frame->info;
270                         regs->regs[2] = (unsigned long)&frame->uc;
271                 }
272         }
273 
274         return err;
275 }
276 
277 static void setup_restart_syscall(struct pt_regs *regs)
278 {
279         if (is_compat_task())
280                 compat_setup_restart_syscall(regs);
281         else
282                 regs->regs[8] = __NR_restart_syscall;
283 }
284 
285 /*
286  * OK, we're invoking a handler
287  */
288 static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
289 {
290         struct task_struct *tsk = current;
291         sigset_t *oldset = sigmask_to_save();
292         int usig = ksig->sig;
293         int ret;
294 
295         /*
296          * Set up the stack frame
297          */
298         if (is_compat_task()) {
299                 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
300                         ret = compat_setup_rt_frame(usig, ksig, oldset, regs);
301                 else
302                         ret = compat_setup_frame(usig, ksig, oldset, regs);
303         } else {
304                 ret = setup_rt_frame(usig, ksig, oldset, regs);
305         }
306 
307         /*
308          * Check that the resulting registers are actually sane.
309          */
310         ret |= !valid_user_regs(&regs->user_regs, current);
311 
312         /*
313          * Fast forward the stepping logic so we step into the signal
314          * handler.
315          */
316         if (!ret)
317                 user_fastforward_single_step(tsk);
318 
319         signal_setup_done(ret, ksig, 0);
320 }
321 
322 /*
323  * Note that 'init' is a special process: it doesn't get signals it doesn't
324  * want to handle. Thus you cannot kill init even with a SIGKILL even by
325  * mistake.
326  *
327  * Note that we go through the signals twice: once to check the signals that
328  * the kernel can handle, and then we build all the user-level signal handling
329  * stack-frames in one go after that.
330  */
331 static void do_signal(struct pt_regs *regs)
332 {
333         unsigned long continue_addr = 0, restart_addr = 0;
334         int retval = 0;
335         int syscall = (int)regs->syscallno;
336         struct ksignal ksig;
337 
338         /*
339          * If we were from a system call, check for system call restarting...
340          */
341         if (syscall >= 0) {
342                 continue_addr = regs->pc;
343                 restart_addr = continue_addr - (compat_thumb_mode(regs) ? 2 : 4);
344                 retval = regs->regs[0];
345 
346                 /*
347                  * Avoid additional syscall restarting via ret_to_user.
348                  */
349                 regs->syscallno = ~0UL;
350 
351                 /*
352                  * Prepare for system call restart. We do this here so that a
353                  * debugger will see the already changed PC.
354                  */
355                 switch (retval) {
356                 case -ERESTARTNOHAND:
357                 case -ERESTARTSYS:
358                 case -ERESTARTNOINTR:
359                 case -ERESTART_RESTARTBLOCK:
360                         regs->regs[0] = regs->orig_x0;
361                         regs->pc = restart_addr;
362                         break;
363                 }
364         }
365 
366         /*
367          * Get the signal to deliver. When running under ptrace, at this point
368          * the debugger may change all of our registers.
369          */
370         if (get_signal(&ksig)) {
371                 /*
372                  * Depending on the signal settings, we may need to revert the
373                  * decision to restart the system call, but skip this if a
374                  * debugger has chosen to restart at a different PC.
375                  */
376                 if (regs->pc == restart_addr &&
377                     (retval == -ERESTARTNOHAND ||
378                      retval == -ERESTART_RESTARTBLOCK ||
379                      (retval == -ERESTARTSYS &&
380                       !(ksig.ka.sa.sa_flags & SA_RESTART)))) {
381                         regs->regs[0] = -EINTR;
382                         regs->pc = continue_addr;
383                 }
384 
385                 handle_signal(&ksig, regs);
386                 return;
387         }
388 
389         /*
390          * Handle restarting a different system call. As above, if a debugger
391          * has chosen to restart at a different PC, ignore the restart.
392          */
393         if (syscall >= 0 && regs->pc == restart_addr) {
394                 if (retval == -ERESTART_RESTARTBLOCK)
395                         setup_restart_syscall(regs);
396                 user_rewind_single_step(current);
397         }
398 
399         restore_saved_sigmask();
400 }
401 
402 asmlinkage void do_notify_resume(struct pt_regs *regs,
403                                  unsigned int thread_flags)
404 {
405         if (thread_flags & _TIF_SIGPENDING)
406                 do_signal(regs);
407 
408         if (thread_flags & _TIF_NOTIFY_RESUME) {
409                 clear_thread_flag(TIF_NOTIFY_RESUME);
410                 tracehook_notify_resume(regs);
411         }
412 
413         if (thread_flags & _TIF_FOREIGN_FPSTATE)
414                 fpsimd_restore_current_state();
415 
416 }
417 

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