projects / deliverable / linux.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Merge commit 'origin/master' into next
[deliverable/linux.git] / arch / mips / kernel / signal.c
... / ...
CommitLineData
1/*
2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
4 * for more details.
5 *
6 * Copyright (C) 1991, 1992 Linus Torvalds
7 * Copyright (C) 1994 - 2000 Ralf Baechle
8 * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
9 */
10#include <linux/cache.h>
11#include <linux/sched.h>
12#include <linux/mm.h>
13#include <linux/personality.h>
14#include <linux/smp.h>
15#include <linux/kernel.h>
16#include <linux/signal.h>
17#include <linux/errno.h>
18#include <linux/wait.h>
19#include <linux/ptrace.h>
20#include <linux/unistd.h>
21#include <linux/compiler.h>
22#include <linux/syscalls.h>
23#include <linux/uaccess.h>
24
25#include <asm/abi.h>
26#include <asm/asm.h>
27#include <linux/bitops.h>
28#include <asm/cacheflush.h>
29#include <asm/fpu.h>
30#include <asm/sim.h>
31#include <asm/ucontext.h>
32#include <asm/cpu-features.h>
33#include <asm/war.h>
34
35#include "signal-common.h"
36
37/*
38 * Horribly complicated - with the bloody RM9000 workarounds enabled
39 * the signal trampolines is moving to the end of the structure so we can
40 * increase the alignment without breaking software compatibility.
41 */
42#if ICACHE_REFILLS_WORKAROUND_WAR == 0
43
44struct sigframe {
45 u32 sf_ass[4]; /* argument save space for o32 */
46 u32 sf_code[2]; /* signal trampoline */
47 struct sigcontext sf_sc;
48 sigset_t sf_mask;
49};
50
51struct rt_sigframe {
52 u32 rs_ass[4]; /* argument save space for o32 */
53 u32 rs_code[2]; /* signal trampoline */
54 struct siginfo rs_info;
55 struct ucontext rs_uc;
56};
57
58#else
59
60struct sigframe {
61 u32 sf_ass[4]; /* argument save space for o32 */
62 u32 sf_pad[2];
63 struct sigcontext sf_sc; /* hw context */
64 sigset_t sf_mask;
65 u32 sf_code[8] ____cacheline_aligned; /* signal trampoline */
66};
67
68struct rt_sigframe {
69 u32 rs_ass[4]; /* argument save space for o32 */
70 u32 rs_pad[2];
71 struct siginfo rs_info;
72 struct ucontext rs_uc;
73 u32 rs_code[8] ____cacheline_aligned; /* signal trampoline */
74};
75
76#endif
77
78/*
79 * Helper routines
80 */
81static int protected_save_fp_context(struct sigcontext __user *sc)
82{
83 int err;
84 while (1) {
85 lock_fpu_owner();
86 own_fpu_inatomic(1);
87 err = save_fp_context(sc); /* this might fail */
88 unlock_fpu_owner();
89 if (likely(!err))
90 break;
91 /* touch the sigcontext and try again */
92 err = __put_user(0, &sc->sc_fpregs[0]) |
93 __put_user(0, &sc->sc_fpregs[31]) |
94 __put_user(0, &sc->sc_fpc_csr);
95 if (err)
96 break; /* really bad sigcontext */
97 }
98 return err;
99}
100
101static int protected_restore_fp_context(struct sigcontext __user *sc)
102{
103 int err, tmp;
104 while (1) {
105 lock_fpu_owner();
106 own_fpu_inatomic(0);
107 err = restore_fp_context(sc); /* this might fail */
108 unlock_fpu_owner();
109 if (likely(!err))
110 break;
111 /* touch the sigcontext and try again */
112 err = __get_user(tmp, &sc->sc_fpregs[0]) |
113 __get_user(tmp, &sc->sc_fpregs[31]) |
114 __get_user(tmp, &sc->sc_fpc_csr);
115 if (err)
116 break; /* really bad sigcontext */
117 }
118 return err;
119}
120
121int setup_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
122{
123 int err = 0;
124 int i;
125 unsigned int used_math;
126
127 err |= __put_user(regs->cp0_epc, &sc->sc_pc);
128
129 err |= __put_user(0, &sc->sc_regs[0]);
130 for (i = 1; i < 32; i++)
131 err |= __put_user(regs->regs[i], &sc->sc_regs[i]);
132
133#ifdef CONFIG_CPU_HAS_SMARTMIPS
134 err |= __put_user(regs->acx, &sc->sc_acx);
135#endif
136 err |= __put_user(regs->hi, &sc->sc_mdhi);
137 err |= __put_user(regs->lo, &sc->sc_mdlo);
138 if (cpu_has_dsp) {
139 err |= __put_user(mfhi1(), &sc->sc_hi1);
140 err |= __put_user(mflo1(), &sc->sc_lo1);
141 err |= __put_user(mfhi2(), &sc->sc_hi2);
142 err |= __put_user(mflo2(), &sc->sc_lo2);
143 err |= __put_user(mfhi3(), &sc->sc_hi3);
144 err |= __put_user(mflo3(), &sc->sc_lo3);
145 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
146 }
147
148 used_math = !!used_math();
149 err |= __put_user(used_math, &sc->sc_used_math);
150
151 if (used_math) {
152 /*
153 * Save FPU state to signal context. Signal handler
154 * will "inherit" current FPU state.
155 */
156 err |= protected_save_fp_context(sc);
157 }
158 return err;
159}
160
161int fpcsr_pending(unsigned int __user *fpcsr)
162{
163 int err, sig = 0;
164 unsigned int csr, enabled;
165
166 err = __get_user(csr, fpcsr);
167 enabled = FPU_CSR_UNI_X | ((csr & FPU_CSR_ALL_E) << 5);
168 /*
169 * If the signal handler set some FPU exceptions, clear it and
170 * send SIGFPE.
171 */
172 if (csr & enabled) {
173 csr &= ~enabled;
174 err |= __put_user(csr, fpcsr);
175 sig = SIGFPE;
176 }
177 return err ?: sig;
178}
179
180static int
181check_and_restore_fp_context(struct sigcontext __user *sc)
182{
183 int err, sig;
184
185 err = sig = fpcsr_pending(&sc->sc_fpc_csr);
186 if (err > 0)
187 err = 0;
188 err |= protected_restore_fp_context(sc);
189 return err ?: sig;
190}
191
192int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
193{
194 unsigned int used_math;
195 unsigned long treg;
196 int err = 0;
197 int i;
198
199 /* Always make any pending restarted system calls return -EINTR */
200 current_thread_info()->restart_block.fn = do_no_restart_syscall;
201
202 err |= __get_user(regs->cp0_epc, &sc->sc_pc);
203
204#ifdef CONFIG_CPU_HAS_SMARTMIPS
205 err |= __get_user(regs->acx, &sc->sc_acx);
206#endif
207 err |= __get_user(regs->hi, &sc->sc_mdhi);
208 err |= __get_user(regs->lo, &sc->sc_mdlo);
209 if (cpu_has_dsp) {
210 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
211 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
212 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
213 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
214 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
215 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
216 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
217 }
218
219 for (i = 1; i < 32; i++)
220 err |= __get_user(regs->regs[i], &sc->sc_regs[i]);
221
222 err |= __get_user(used_math, &sc->sc_used_math);
223 conditional_used_math(used_math);
224
225 if (used_math) {
226 /* restore fpu context if we have used it before */
227 if (!err)
228 err = check_and_restore_fp_context(sc);
229 } else {
230 /* signal handler may have used FPU. Give it up. */
231 lose_fpu(0);
232 }
233
234 return err;
235}
236
237void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
238 size_t frame_size)
239{
240 unsigned long sp;
241
242 /* Default to using normal stack */
243 sp = regs->regs[29];
244
245 /*
246 * FPU emulator may have it's own trampoline active just
247 * above the user stack, 16-bytes before the next lowest
248 * 16 byte boundary. Try to avoid trashing it.
249 */
250 sp -= 32;
251
252 /* This is the X/Open sanctioned signal stack switching. */
253 if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags (sp) == 0))
254 sp = current->sas_ss_sp + current->sas_ss_size;
255
256 return (void __user *)((sp - frame_size) & (ICACHE_REFILLS_WORKAROUND_WAR ? ~(cpu_icache_line_size()-1) : ALMASK));
257}
258
259int install_sigtramp(unsigned int __user *tramp, unsigned int syscall)
260{
261 int err;
262
263 /*
264 * Set up the return code ...
265 *
266 * li v0, __NR__foo_sigreturn
267 * syscall
268 */
269
270 err = __put_user(0x24020000 + syscall, tramp + 0);
271 err |= __put_user(0x0000000c , tramp + 1);
272 if (ICACHE_REFILLS_WORKAROUND_WAR) {
273 err |= __put_user(0, tramp + 2);
274 err |= __put_user(0, tramp + 3);
275 err |= __put_user(0, tramp + 4);
276 err |= __put_user(0, tramp + 5);
277 err |= __put_user(0, tramp + 6);
278 err |= __put_user(0, tramp + 7);
279 }
280 flush_cache_sigtramp((unsigned long) tramp);
281
282 return err;
283}
284
285/*
286 * Atomically swap in the new signal mask, and wait for a signal.
287 */
288
289#ifdef CONFIG_TRAD_SIGNALS
290asmlinkage int sys_sigsuspend(nabi_no_regargs struct pt_regs regs)
291{
292 sigset_t newset;
293 sigset_t __user *uset;
294
295 uset = (sigset_t __user *) regs.regs[4];
296 if (copy_from_user(&newset, uset, sizeof(sigset_t)))
297 return -EFAULT;
298 sigdelsetmask(&newset, ~_BLOCKABLE);
299
300 spin_lock_irq(&current->sighand->siglock);
301 current->saved_sigmask = current->blocked;
302 current->blocked = newset;
303 recalc_sigpending();
304 spin_unlock_irq(&current->sighand->siglock);
305
306 current->state = TASK_INTERRUPTIBLE;
307 schedule();
308 set_thread_flag(TIF_RESTORE_SIGMASK);
309 return -ERESTARTNOHAND;
310}
311#endif
312
313asmlinkage int sys_rt_sigsuspend(nabi_no_regargs struct pt_regs regs)
314{
315 sigset_t newset;
316 sigset_t __user *unewset;
317 size_t sigsetsize;
318
319 /* XXX Don't preclude handling different sized sigset_t's. */
320 sigsetsize = regs.regs[5];
321 if (sigsetsize != sizeof(sigset_t))
322 return -EINVAL;
323
324 unewset = (sigset_t __user *) regs.regs[4];
325 if (copy_from_user(&newset, unewset, sizeof(newset)))
326 return -EFAULT;
327 sigdelsetmask(&newset, ~_BLOCKABLE);
328
329 spin_lock_irq(&current->sighand->siglock);
330 current->saved_sigmask = current->blocked;
331 current->blocked = newset;
332 recalc_sigpending();
333 spin_unlock_irq(&current->sighand->siglock);
334
335 current->state = TASK_INTERRUPTIBLE;
336 schedule();
337 set_thread_flag(TIF_RESTORE_SIGMASK);
338 return -ERESTARTNOHAND;
339}
340
341#ifdef CONFIG_TRAD_SIGNALS
342SYSCALL_DEFINE3(sigaction, int, sig, const struct sigaction __user *, act,
343 struct sigaction __user *, oact)
344{
345 struct k_sigaction new_ka, old_ka;
346 int ret;
347 int err = 0;
348
349 if (act) {
350 old_sigset_t mask;
351
352 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
353 return -EFAULT;
354 err |= __get_user(new_ka.sa.sa_handler, &act->sa_handler);
355 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
356 err |= __get_user(mask, &act->sa_mask.sig[0]);
357 if (err)
358 return -EFAULT;
359
360 siginitset(&new_ka.sa.sa_mask, mask);
361 }
362
363 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
364
365 if (!ret && oact) {
366 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
367 return -EFAULT;
368 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
369 err |= __put_user(old_ka.sa.sa_handler, &oact->sa_handler);
370 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
371 err |= __put_user(0, &oact->sa_mask.sig[1]);
372 err |= __put_user(0, &oact->sa_mask.sig[2]);
373 err |= __put_user(0, &oact->sa_mask.sig[3]);
374 if (err)
375 return -EFAULT;
376 }
377
378 return ret;
379}
380#endif
381
382asmlinkage int sys_sigaltstack(nabi_no_regargs struct pt_regs regs)
383{
384 const stack_t __user *uss = (const stack_t __user *) regs.regs[4];
385 stack_t __user *uoss = (stack_t __user *) regs.regs[5];
386 unsigned long usp = regs.regs[29];
387
388 return do_sigaltstack(uss, uoss, usp);
389}
390
391#ifdef CONFIG_TRAD_SIGNALS
392asmlinkage void sys_sigreturn(nabi_no_regargs struct pt_regs regs)
393{
394 struct sigframe __user *frame;
395 sigset_t blocked;
396 int sig;
397
398 frame = (struct sigframe __user *) regs.regs[29];
399 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
400 goto badframe;
401 if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
402 goto badframe;
403
404 sigdelsetmask(&blocked, ~_BLOCKABLE);
405 spin_lock_irq(&current->sighand->siglock);
406 current->blocked = blocked;
407 recalc_sigpending();
408 spin_unlock_irq(&current->sighand->siglock);
409
410 sig = restore_sigcontext(&regs, &frame->sf_sc);
411 if (sig < 0)
412 goto badframe;
413 else if (sig)
414 force_sig(sig, current);
415
416 /*
417 * Don't let your children do this ...
418 */
419 __asm__ __volatile__(
420 "move\t$29, %0\n\t"
421 "j\tsyscall_exit"
422 :/* no outputs */
423 :"r" (&regs));
424 /* Unreached */
425
426badframe:
427 force_sig(SIGSEGV, current);
428}
429#endif /* CONFIG_TRAD_SIGNALS */
430
431asmlinkage void sys_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
432{
433 struct rt_sigframe __user *frame;
434 sigset_t set;
435 stack_t st;
436 int sig;
437
438 frame = (struct rt_sigframe __user *) regs.regs[29];
439 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
440 goto badframe;
441 if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
442 goto badframe;
443
444 sigdelsetmask(&set, ~_BLOCKABLE);
445 spin_lock_irq(&current->sighand->siglock);
446 current->blocked = set;
447 recalc_sigpending();
448 spin_unlock_irq(&current->sighand->siglock);
449
450 sig = restore_sigcontext(&regs, &frame->rs_uc.uc_mcontext);
451 if (sig < 0)
452 goto badframe;
453 else if (sig)
454 force_sig(sig, current);
455
456 if (__copy_from_user(&st, &frame->rs_uc.uc_stack, sizeof(st)))
457 goto badframe;
458 /* It is more difficult to avoid calling this function than to
459 call it and ignore errors. */
460 do_sigaltstack((stack_t __user *)&st, NULL, regs.regs[29]);
461
462 /*
463 * Don't let your children do this ...
464 */
465 __asm__ __volatile__(
466 "move\t$29, %0\n\t"
467 "j\tsyscall_exit"
468 :/* no outputs */
469 :"r" (&regs));
470 /* Unreached */
471
472badframe:
473 force_sig(SIGSEGV, current);
474}
475
476#ifdef CONFIG_TRAD_SIGNALS
477static int setup_frame(struct k_sigaction * ka, struct pt_regs *regs,
478 int signr, sigset_t *set)
479{
480 struct sigframe __user *frame;
481 int err = 0;
482
483 frame = get_sigframe(ka, regs, sizeof(*frame));
484 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
485 goto give_sigsegv;
486
487 err |= install_sigtramp(frame->sf_code, __NR_sigreturn);
488
489 err |= setup_sigcontext(regs, &frame->sf_sc);
490 err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
491 if (err)
492 goto give_sigsegv;
493
494 /*
495 * Arguments to signal handler:
496 *
497 * a0 = signal number
498 * a1 = 0 (should be cause)
499 * a2 = pointer to struct sigcontext
500 *
501 * $25 and c0_epc point to the signal handler, $29 points to the
502 * struct sigframe.
503 */
504 regs->regs[ 4] = signr;
505 regs->regs[ 5] = 0;
506 regs->regs[ 6] = (unsigned long) &frame->sf_sc;
507 regs->regs[29] = (unsigned long) frame;
508 regs->regs[31] = (unsigned long) frame->sf_code;
509 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
510
511 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
512 current->comm, current->pid,
513 frame, regs->cp0_epc, regs->regs[31]);
514 return 0;
515
516give_sigsegv:
517 force_sigsegv(signr, current);
518 return -EFAULT;
519}
520#endif
521
522static int setup_rt_frame(struct k_sigaction * ka, struct pt_regs *regs,
523 int signr, sigset_t *set, siginfo_t *info)
524{
525 struct rt_sigframe __user *frame;
526 int err = 0;
527
528 frame = get_sigframe(ka, regs, sizeof(*frame));
529 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
530 goto give_sigsegv;
531
532 err |= install_sigtramp(frame->rs_code, __NR_rt_sigreturn);
533
534 /* Create siginfo. */
535 err |= copy_siginfo_to_user(&frame->rs_info, info);
536
537 /* Create the ucontext. */
538 err |= __put_user(0, &frame->rs_uc.uc_flags);
539 err |= __put_user(NULL, &frame->rs_uc.uc_link);
540 err |= __put_user((void __user *)current->sas_ss_sp,
541 &frame->rs_uc.uc_stack.ss_sp);
542 err |= __put_user(sas_ss_flags(regs->regs[29]),
543 &frame->rs_uc.uc_stack.ss_flags);
544 err |= __put_user(current->sas_ss_size,
545 &frame->rs_uc.uc_stack.ss_size);
546 err |= setup_sigcontext(regs, &frame->rs_uc.uc_mcontext);
547 err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
548
549 if (err)
550 goto give_sigsegv;
551
552 /*
553 * Arguments to signal handler:
554 *
555 * a0 = signal number
556 * a1 = 0 (should be cause)
557 * a2 = pointer to ucontext
558 *
559 * $25 and c0_epc point to the signal handler, $29 points to
560 * the struct rt_sigframe.
561 */
562 regs->regs[ 4] = signr;
563 regs->regs[ 5] = (unsigned long) &frame->rs_info;
564 regs->regs[ 6] = (unsigned long) &frame->rs_uc;
565 regs->regs[29] = (unsigned long) frame;
566 regs->regs[31] = (unsigned long) frame->rs_code;
567 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
568
569 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
570 current->comm, current->pid,
571 frame, regs->cp0_epc, regs->regs[31]);
572
573 return 0;
574
575give_sigsegv:
576 force_sigsegv(signr, current);
577 return -EFAULT;
578}
579
580struct mips_abi mips_abi = {
581#ifdef CONFIG_TRAD_SIGNALS
582 .setup_frame = setup_frame,
583#endif
584 .setup_rt_frame = setup_rt_frame,
585 .restart = __NR_restart_syscall
586};
587
588static int handle_signal(unsigned long sig, siginfo_t *info,
589 struct k_sigaction *ka, sigset_t *oldset, struct pt_regs *regs)
590{
591 int ret;
592
593 switch(regs->regs[0]) {
594 case ERESTART_RESTARTBLOCK:
595 case ERESTARTNOHAND:
596 regs->regs[2] = EINTR;
597 break;
598 case ERESTARTSYS:
599 if (!(ka->sa.sa_flags & SA_RESTART)) {
600 regs->regs[2] = EINTR;
601 break;
602 }
603 /* fallthrough */
604 case ERESTARTNOINTR: /* Userland will reload $v0. */
605 regs->regs[7] = regs->regs[26];
606 regs->cp0_epc -= 8;
607 }
608
609 regs->regs[0] = 0; /* Don't deal with this again. */
610
611 if (sig_uses_siginfo(ka))
612 ret = current->thread.abi->setup_rt_frame(ka, regs, sig, oldset, info);
613 else
614 ret = current->thread.abi->setup_frame(ka, regs, sig, oldset);
615
616 spin_lock_irq(&current->sighand->siglock);
617 sigorsets(&current->blocked, &current->blocked, &ka->sa.sa_mask);
618 if (!(ka->sa.sa_flags & SA_NODEFER))
619 sigaddset(&current->blocked, sig);
620 recalc_sigpending();
621 spin_unlock_irq(&current->sighand->siglock);
622
623 return ret;
624}
625
626static void do_signal(struct pt_regs *regs)
627{
628 struct k_sigaction ka;
629 sigset_t *oldset;
630 siginfo_t info;
631 int signr;
632
633 /*
634 * We want the common case to go fast, which is why we may in certain
635 * cases get here from kernel mode. Just return without doing anything
636 * if so.
637 */
638 if (!user_mode(regs))
639 return;
640
641 if (test_thread_flag(TIF_RESTORE_SIGMASK))
642 oldset = &current->saved_sigmask;
643 else
644 oldset = &current->blocked;
645
646 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
647 if (signr > 0) {
648 /* Whee! Actually deliver the signal. */
649 if (handle_signal(signr, &info, &ka, oldset, regs) == 0) {
650 /*
651 * A signal was successfully delivered; the saved
652 * sigmask will have been stored in the signal frame,
653 * and will be restored by sigreturn, so we can simply
654 * clear the TIF_RESTORE_SIGMASK flag.
655 */
656 if (test_thread_flag(TIF_RESTORE_SIGMASK))
657 clear_thread_flag(TIF_RESTORE_SIGMASK);
658 }
659
660 return;
661 }
662
663 /*
664 * Who's code doesn't conform to the restartable syscall convention
665 * dies here!!! The li instruction, a single machine instruction,
666 * must directly be followed by the syscall instruction.
667 */
668 if (regs->regs[0]) {
669 if (regs->regs[2] == ERESTARTNOHAND ||
670 regs->regs[2] == ERESTARTSYS ||
671 regs->regs[2] == ERESTARTNOINTR) {
672 regs->regs[7] = regs->regs[26];
673 regs->cp0_epc -= 8;
674 }
675 if (regs->regs[2] == ERESTART_RESTARTBLOCK) {
676 regs->regs[2] = current->thread.abi->restart;
677 regs->regs[7] = regs->regs[26];
678 regs->cp0_epc -= 4;
679 }
680 regs->regs[0] = 0; /* Don't deal with this again. */
681 }
682
683 /*
684 * If there's no signal to deliver, we just put the saved sigmask
685 * back
686 */
687 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
688 clear_thread_flag(TIF_RESTORE_SIGMASK);
689 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
690 }
691}
692
693/*
694 * notification of userspace execution resumption
695 * - triggered by the TIF_WORK_MASK flags
696 */
697asmlinkage void do_notify_resume(struct pt_regs *regs, void *unused,
698 __u32 thread_info_flags)
699{
700 /* deal with pending signal delivery */
701 if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
702 do_signal(regs);
703}
Linux kernel - Deliverables
This page took 0.026047 seconds and 5 git commands to generate.