← Back to branch summary

~ubuntu-branches/ubuntu/saucy/linux-ti-omap4/saucy-proposed

« back to all changes in this revision

Viewing changes to arch/mips/kernel/signal.c

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati, Stefan Bader, Upstream Kernel Changes
  • Date: 2012-08-15 17:17:43 UTC
  • Revision ID: package-import@ubuntu.com-20120815171743-h5wnuf51xe7pvdid
Tags: 3.5.0-207.13
[ Paolo Pisati ]

* Start new release

[ Stefan Bader ]

* (config) Enable getabis to use local package copies

[ Upstream Kernel Changes ]

* fixup: gargabe collect iva_seq[0|1] init
* [Config] enable all SND_OMAP_SOC_*s
* fixup: cm2xxx_3xxx.o is needed for omap2_cm_read|write_reg
* fixup: add some snd_soc_dai* helper functions
* fixup: s/snd_soc_dpcm_params/snd_soc_dpcm/g
* fixup: typo, no_host_mode and useless SDP4430 init
* fixup: enable again aess hwmod

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/mips/kernel/signal.c
255
255
        uset = (sigset_t __user *) regs.regs[4];
256
256
        if (copy_from_user(&newset, uset, sizeof(sigset_t)))
257
257
                return -EFAULT;
258
 
        sigdelsetmask(&newset, ~_BLOCKABLE);
259
 
 
260
 
        current->saved_sigmask = current->blocked;
261
 
        set_current_blocked(&newset);
262
 
 
263
 
        current->state = TASK_INTERRUPTIBLE;
264
 
        schedule();
265
 
        set_thread_flag(TIF_RESTORE_SIGMASK);
266
 
        return -ERESTARTNOHAND;
 
258
        return sigsuspend(&newset);
267
259
}
268
260
#endif
269
261
 
281
273
        unewset = (sigset_t __user *) regs.regs[4];
282
274
        if (copy_from_user(&newset, unewset, sizeof(newset)))
283
275
                return -EFAULT;
284
 
        sigdelsetmask(&newset, ~_BLOCKABLE);
285
 
 
286
 
        current->saved_sigmask = current->blocked;
287
 
        set_current_blocked(&newset);
288
 
 
289
 
        current->state = TASK_INTERRUPTIBLE;
290
 
        schedule();
291
 
        set_thread_flag(TIF_RESTORE_SIGMASK);
292
 
        return -ERESTARTNOHAND;
 
276
        return sigsuspend(&newset);
293
277
}
294
278
 
295
279
#ifdef CONFIG_TRAD_SIGNALS
355
339
        if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
356
340
                goto badframe;
357
341
 
358
 
        sigdelsetmask(&blocked, ~_BLOCKABLE);
359
342
        set_current_blocked(&blocked);
360
343
 
361
344
        sig = restore_sigcontext(&regs, &frame->sf_sc);
391
374
        if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
392
375
                goto badframe;
393
376
 
394
 
        sigdelsetmask(&set, ~_BLOCKABLE);
395
377
        set_current_blocked(&set);
396
378
 
397
379
        sig = restore_sigcontext(&regs, &frame->rs_uc.uc_mcontext);
530
512
        .restart        = __NR_restart_syscall
531
513
};
532
514
 
533
 
static int handle_signal(unsigned long sig, siginfo_t *info,
534
 
        struct k_sigaction *ka, sigset_t *oldset, struct pt_regs *regs)
 
515
static void handle_signal(unsigned long sig, siginfo_t *info,
 
516
        struct k_sigaction *ka, struct pt_regs *regs)
535
517
{
 
518
        sigset_t *oldset = sigmask_to_save();
536
519
        int ret;
537
520
        struct mips_abi *abi = current->thread.abi;
538
521
        void *vdso = current->mm->context.vdso;
566
549
                                       ka, regs, sig, oldset);
567
550
 
568
551
        if (ret)
569
 
                return ret;
570
 
 
571
 
        block_sigmask(ka, sig);
572
 
 
573
 
        return ret;
 
552
                return;
 
553
 
 
554
        signal_delivered(sig, info, ka, regs, 0);
574
555
}
575
556
 
576
557
static void do_signal(struct pt_regs *regs)
577
558
{
578
559
        struct k_sigaction ka;
579
 
        sigset_t *oldset;
580
560
        siginfo_t info;
581
561
        int signr;
582
562
 
588
568
        if (!user_mode(regs))
589
569
                return;
590
570
 
591
 
        if (test_thread_flag(TIF_RESTORE_SIGMASK))
592
 
                oldset = &current->saved_sigmask;
593
 
        else
594
 
                oldset = &current->blocked;
595
 
 
596
571
        signr = get_signal_to_deliver(&info, &ka, regs, NULL);
597
572
        if (signr > 0) {
598
573
                /* Whee!  Actually deliver the signal.  */
599
 
                if (handle_signal(signr, &info, &ka, oldset, regs) == 0) {
600
 
                        /*
601
 
                         * A signal was successfully delivered; the saved
602
 
                         * sigmask will have been stored in the signal frame,
603
 
                         * and will be restored by sigreturn, so we can simply
604
 
                         * clear the TIF_RESTORE_SIGMASK flag.
605
 
                         */
606
 
                        if (test_thread_flag(TIF_RESTORE_SIGMASK))
607
 
                                clear_thread_flag(TIF_RESTORE_SIGMASK);
608
 
                }
609
 
 
 
574
                handle_signal(signr, &info, &ka, regs);
610
575
                return;
611
576
        }
612
577
 
630
595
         * If there's no signal to deliver, we just put the saved sigmask
631
596
         * back
632
597
         */
633
 
        if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
634
 
                clear_thread_flag(TIF_RESTORE_SIGMASK);
635
 
                sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
636
 
        }
 
598
        restore_saved_sigmask();
637
599
}
638
600
 
639
601
/*
646
608
        local_irq_enable();
647
609
 
648
610
        /* deal with pending signal delivery */
649
 
        if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
 
611
        if (thread_info_flags & _TIF_SIGPENDING)
650
612
                do_signal(regs);
651
613
 
652
614
        if (thread_info_flags & _TIF_NOTIFY_RESUME) {
653
615
                clear_thread_flag(TIF_NOTIFY_RESUME);
654
616
                tracehook_notify_resume(regs);
655
 
                if (current->replacement_session_keyring)
656
 
                        key_replace_session_keyring();
657
617
        }
658
618
}
659
619