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

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

Version: ~ [ linux-6.0 ] ~ [ linux-5.19.12 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.71 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.146 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.215 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.260 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.295 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.330 ] ~ [ 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  *  Copyright (C) 1991,1992  Linus Torvalds
  3  *  Copyright (C) 2005-2012  Imagination Technologies Ltd.
  4  *
  5  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
  6  *
  7  */
  8 
  9 #include <linux/sched.h>
 10 #include <linux/mm.h>
 11 #include <linux/smp.h>
 12 #include <linux/kernel.h>
 13 #include <linux/signal.h>
 14 #include <linux/errno.h>
 15 #include <linux/wait.h>
 16 #include <linux/ptrace.h>
 17 #include <linux/unistd.h>
 18 #include <linux/stddef.h>
 19 #include <linux/personality.h>
 20 #include <linux/uaccess.h>
 21 #include <linux/tracehook.h>
 22 
 23 #include <asm/ucontext.h>
 24 #include <asm/cacheflush.h>
 25 #include <asm/switch.h>
 26 #include <asm/syscall.h>
 27 #include <asm/syscalls.h>
 28 
 29 #define REG_FLAGS       ctx.SaveMask
 30 #define REG_RETVAL      ctx.DX[0].U0
 31 #define REG_SYSCALL     ctx.DX[0].U1
 32 #define REG_SP          ctx.AX[0].U0
 33 #define REG_ARG1        ctx.DX[3].U1
 34 #define REG_ARG2        ctx.DX[3].U0
 35 #define REG_ARG3        ctx.DX[2].U1
 36 #define REG_PC          ctx.CurrPC
 37 #define REG_RTP         ctx.DX[4].U1
 38 
 39 struct rt_sigframe {
 40         struct siginfo info;
 41         struct ucontext uc;
 42         unsigned long retcode[2];
 43 };
 44 
 45 static int restore_sigcontext(struct pt_regs *regs,
 46                               struct sigcontext __user *sc)
 47 {
 48         int err;
 49 
 50         /* Always make any pending restarted system calls return -EINTR */
 51         current->restart_block.fn = do_no_restart_syscall;
 52 
 53         err = metag_gp_regs_copyin(regs, 0, sizeof(struct user_gp_regs), NULL,
 54                                    &sc->regs);
 55         if (!err)
 56                 err = metag_cb_regs_copyin(regs, 0,
 57                                            sizeof(struct user_cb_regs), NULL,
 58                                            &sc->cb);
 59         if (!err)
 60                 err = metag_rp_state_copyin(regs, 0,
 61                                             sizeof(struct user_rp_state), NULL,
 62                                             &sc->rp);
 63 
 64         /* This is a user-mode context. */
 65         regs->REG_FLAGS |= TBICTX_PRIV_BIT;
 66 
 67         return err;
 68 }
 69 
 70 long sys_rt_sigreturn(void)
 71 {
 72         /* NOTE - Meta stack goes UPWARDS - so we wind the stack back */
 73         struct pt_regs *regs = current_pt_regs();
 74         struct rt_sigframe __user *frame;
 75         sigset_t set;
 76 
 77         frame = (__force struct rt_sigframe __user *)(regs->REG_SP -
 78                                                       sizeof(*frame));
 79 
 80         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 81                 goto badframe;
 82 
 83         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 84                 goto badframe;
 85 
 86         set_current_blocked(&set);
 87 
 88         if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
 89                 goto badframe;
 90 
 91         if (restore_altstack(&frame->uc.uc_stack))
 92                 goto badframe;
 93 
 94         return regs->REG_RETVAL;
 95 
 96 badframe:
 97         force_sig(SIGSEGV, current);
 98 
 99         return 0;
100 }
101 
102 static int setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
103                             unsigned long mask)
104 {
105         int err;
106 
107         err = metag_gp_regs_copyout(regs, 0, sizeof(struct user_gp_regs), NULL,
108                                     &sc->regs);
109 
110         if (!err)
111                 err = metag_cb_regs_copyout(regs, 0,
112                                             sizeof(struct user_cb_regs), NULL,
113                                             &sc->cb);
114         if (!err)
115                 err = metag_rp_state_copyout(regs, 0,
116                                              sizeof(struct user_rp_state), NULL,
117                                              &sc->rp);
118 
119         /* OK, clear that cbuf flag in the old context, or our stored
120          * catch buffer will be restored when we go to call the signal
121          * handler. Also clear out the CBRP RA/RD pipe bit incase
122          * that is pending as well!
123          * Note that as we have already stored this context, these
124          * flags will get restored on sigreturn to their original
125          * state.
126          */
127         regs->REG_FLAGS &= ~(TBICTX_XCBF_BIT | TBICTX_CBUF_BIT |
128                              TBICTX_CBRP_BIT);
129 
130         /* Clear out the LSM_STEP bits in case we are in the middle of
131          * and MSET/MGET.
132          */
133         regs->ctx.Flags &= ~TXSTATUS_LSM_STEP_BITS;
134 
135         err |= __put_user(mask, &sc->oldmask);
136 
137         return err;
138 }
139 
140 /*
141  * Determine which stack to use..
142  */
143 static void __user *get_sigframe(struct ksignal *ksig, unsigned long sp)
144 {
145         sp = sigsp(sp, ksig);
146         sp = (sp + 7) & ~7;                     /* 8byte align stack */
147 
148         return (void __user *)sp;
149 }
150 
151 static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
152                           struct pt_regs *regs)
153 {
154         struct rt_sigframe __user *frame;
155         int err;
156         unsigned long code;
157 
158         frame = get_sigframe(ksig, regs->REG_SP);
159         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
160                 return -EFAULT;
161 
162         err = copy_siginfo_to_user(&frame->info, &ksig->info);
163 
164         /* Create the ucontext.  */
165         err |= __put_user(0, &frame->uc.uc_flags);
166         err |= __put_user(0, (unsigned long __user *)&frame->uc.uc_link);
167         err |= __save_altstack(&frame->uc.uc_stack, regs->REG_SP);
168         err |= setup_sigcontext(&frame->uc.uc_mcontext,
169                                 regs, set->sig[0]);
170         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
171 
172         if (err)
173                 return -EFAULT;
174 
175         /* Set up to return from userspace.  */
176 
177         /* MOV D1Re0 (D1.0), #__NR_rt_sigreturn */
178         code = 0x03000004 | (__NR_rt_sigreturn << 3);
179         err |= __put_user(code, (unsigned long __user *)(&frame->retcode[0]));
180 
181         /* SWITCH #__METAG_SW_SYS */
182         code = __METAG_SW_ENCODING(SYS);
183         err |= __put_user(code, (unsigned long __user *)(&frame->retcode[1]));
184 
185         if (err)
186                 return -EFAULT;
187 
188         /* Set up registers for signal handler */
189         regs->REG_RTP = (unsigned long) frame->retcode;
190         regs->REG_SP = (unsigned long) frame + sizeof(*frame);
191         regs->REG_ARG1 = ksig->sig;
192         regs->REG_ARG2 = (unsigned long) &frame->info;
193         regs->REG_ARG3 = (unsigned long) &frame->uc;
194         regs->REG_PC = (unsigned long) ksig->ka.sa.sa_handler;
195 
196         pr_debug("SIG deliver (%s:%d): sp=%p pc=%08x pr=%08x\n",
197                  current->comm, current->pid, frame, regs->REG_PC,
198                  regs->REG_RTP);
199 
200         /* Now pass size of 'new code' into sigtramp so we can do a more
201          * effective cache flush - directed rather than 'full flush'.
202          */
203         flush_cache_sigtramp(regs->REG_RTP, sizeof(frame->retcode));
204 
205         return 0;
206 }
207 
208 static void handle_signal(struct ksignal *ksig, struct pt_regs *regs)
209 {
210         sigset_t *oldset = sigmask_to_save();
211         int ret;
212 
213         /* Set up the stack frame */
214         ret = setup_rt_frame(ksig, oldset, regs);
215 
216         signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP));
217 }
218 
219  /*
220   * Notes for Meta.
221   * We have moved from the old 2.4.9 SH way of using syscall_nr (in the stored
222   * context) to passing in the syscall flag on the stack.
223   * This is because having syscall_nr in our context does not fit with TBX, and
224   * corrupted the stack.
225   */
226 static int do_signal(struct pt_regs *regs, int syscall)
227 {
228         unsigned int retval = 0, continue_addr = 0, restart_addr = 0;
229         int restart = 0;
230         struct ksignal ksig;
231 
232         /*
233          * By the end of rt_sigreturn the context describes the point that the
234          * signal was taken (which may happen to be just before a syscall if
235          * it's already been restarted). This should *never* be mistaken for a
236          * system call in need of restarting.
237          */
238         if (syscall == __NR_rt_sigreturn)
239                 syscall = -1;
240 
241         /* Did we come from a system call? */
242         if (syscall >= 0) {
243                 continue_addr = regs->REG_PC;
244                 restart_addr = continue_addr - 4;
245                 retval = regs->REG_RETVAL;
246 
247                 /*
248                  * Prepare for system call restart. We do this here so that a
249                  * debugger will see the already changed PC.
250                  */
251                 switch (retval) {
252                 case -ERESTART_RESTARTBLOCK:
253                         restart = -2;
254                 case -ERESTARTNOHAND:
255                 case -ERESTARTSYS:
256                 case -ERESTARTNOINTR:
257                         ++restart;
258                         regs->REG_PC = restart_addr;
259                         break;
260                 }
261         }
262 
263         /*
264          * Get the signal to deliver. When running under ptrace, at this point
265          * the debugger may change all our registers ...
266          */
267         get_signal(&ksig);
268 
269         /*
270          * Depending on the signal settings we may need to revert the decision
271          * to restart the system call. But skip this if a debugger has chosen to
272          * restart at a different PC.
273          */
274         if (regs->REG_PC != restart_addr)
275                 restart = 0;
276         if (ksig.sig > 0) {
277                 if (unlikely(restart)) {
278                         if (retval == -ERESTARTNOHAND
279                             || retval == -ERESTART_RESTARTBLOCK
280                             || (retval == -ERESTARTSYS
281                                 && !(ksig.ka.sa.sa_flags & SA_RESTART))) {
282                                 regs->REG_RETVAL = -EINTR;
283                                 regs->REG_PC = continue_addr;
284                         }
285                 }
286 
287                 /* Whee! Actually deliver the signal.  */
288                 handle_signal(&ksig, regs);
289                 return 0;
290         }
291 
292         /* Handlerless -ERESTART_RESTARTBLOCK re-enters via restart_syscall */
293         if (unlikely(restart < 0))
294                 regs->REG_SYSCALL = __NR_restart_syscall;
295 
296         /*
297          * If there's no signal to deliver, we just put the saved sigmask back.
298          */
299         restore_saved_sigmask();
300 
301         return restart;
302 }
303 
304 int do_work_pending(struct pt_regs *regs, unsigned int thread_flags,
305                     int syscall)
306 {
307         do {
308                 if (likely(thread_flags & _TIF_NEED_RESCHED)) {
309                         schedule();
310                 } else {
311                         if (unlikely(!user_mode(regs)))
312                                 return 0;
313                         local_irq_enable();
314                         if (thread_flags & _TIF_SIGPENDING) {
315                                 int restart = do_signal(regs, syscall);
316                                 if (unlikely(restart)) {
317                                         /*
318                                          * Restart without handlers.
319                                          * Deal with it without leaving
320                                          * the kernel space.
321                                          */
322                                         return restart;
323                                 }
324                                 syscall = -1;
325                         } else {
326                                 clear_thread_flag(TIF_NOTIFY_RESUME);
327                                 tracehook_notify_resume(regs);
328                         }
329                 }
330                 local_irq_disable();
331                 thread_flags = current_thread_info()->flags;
332         } while (thread_flags & _TIF_WORK_MASK);
333         return 0;
334 }
335 

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