Root/arch/s390/kernel/signal.c

1/*
2 * arch/s390/kernel/signal.c
3 *
4 * Copyright (C) IBM Corp. 1999,2006
5 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
6 *
7 * Based on Intel version
8 *
9 * Copyright (C) 1991, 1992 Linus Torvalds
10 *
11 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
12 */
13
14#include <linux/sched.h>
15#include <linux/mm.h>
16#include <linux/smp.h>
17#include <linux/kernel.h>
18#include <linux/signal.h>
19#include <linux/errno.h>
20#include <linux/wait.h>
21#include <linux/ptrace.h>
22#include <linux/unistd.h>
23#include <linux/stddef.h>
24#include <linux/tty.h>
25#include <linux/personality.h>
26#include <linux/binfmts.h>
27#include <linux/tracehook.h>
28#include <linux/syscalls.h>
29#include <linux/compat.h>
30#include <asm/ucontext.h>
31#include <asm/uaccess.h>
32#include <asm/lowcore.h>
33#include "entry.h"
34
35#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
36
37
38typedef struct
39{
40    __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
41    struct sigcontext sc;
42    _sigregs sregs;
43    int signo;
44    __u8 retcode[S390_SYSCALL_SIZE];
45} sigframe;
46
47typedef struct
48{
49    __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
50    __u8 retcode[S390_SYSCALL_SIZE];
51    struct siginfo info;
52    struct ucontext uc;
53} rt_sigframe;
54
55/*
56 * Atomically swap in the new signal mask, and wait for a signal.
57 */
58SYSCALL_DEFINE3(sigsuspend, int, history0, int, history1, old_sigset_t, mask)
59{
60    mask &= _BLOCKABLE;
61    spin_lock_irq(&current->sighand->siglock);
62    current->saved_sigmask = current->blocked;
63    siginitset(&current->blocked, mask);
64    recalc_sigpending();
65    spin_unlock_irq(&current->sighand->siglock);
66
67    set_current_state(TASK_INTERRUPTIBLE);
68    schedule();
69    set_thread_flag(TIF_RESTORE_SIGMASK);
70
71    return -ERESTARTNOHAND;
72}
73
74SYSCALL_DEFINE3(sigaction, int, sig, const struct old_sigaction __user *, act,
75        struct old_sigaction __user *, oact)
76{
77    struct k_sigaction new_ka, old_ka;
78    int ret;
79
80    if (act) {
81        old_sigset_t mask;
82        if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
83            __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
84            __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
85            __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
86            __get_user(mask, &act->sa_mask))
87            return -EFAULT;
88        siginitset(&new_ka.sa.sa_mask, mask);
89    }
90
91    ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
92
93    if (!ret && oact) {
94        if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
95            __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
96            __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
97            __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
98            __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
99            return -EFAULT;
100    }
101
102    return ret;
103}
104
105SYSCALL_DEFINE2(sigaltstack, const stack_t __user *, uss,
106        stack_t __user *, uoss)
107{
108    struct pt_regs *regs = task_pt_regs(current);
109    return do_sigaltstack(uss, uoss, regs->gprs[15]);
110}
111
112/* Returns non-zero on fault. */
113static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
114{
115    _sigregs user_sregs;
116
117    save_access_regs(current->thread.acrs);
118
119    /* Copy a 'clean' PSW mask to the user to avoid leaking
120       information about whether PER is currently on. */
121    user_sregs.regs.psw.mask = PSW_MASK_MERGE(psw_user_bits, regs->psw.mask);
122    user_sregs.regs.psw.addr = regs->psw.addr;
123    memcpy(&user_sregs.regs.gprs, &regs->gprs, sizeof(sregs->regs.gprs));
124    memcpy(&user_sregs.regs.acrs, current->thread.acrs,
125           sizeof(sregs->regs.acrs));
126    /*
127     * We have to store the fp registers to current->thread.fp_regs
128     * to merge them with the emulated registers.
129     */
130    save_fp_regs(&current->thread.fp_regs);
131    memcpy(&user_sregs.fpregs, &current->thread.fp_regs,
132           sizeof(s390_fp_regs));
133    return __copy_to_user(sregs, &user_sregs, sizeof(_sigregs));
134}
135
136/* Returns positive number on error */
137static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
138{
139    int err;
140    _sigregs user_sregs;
141
142    /* Alwys make any pending restarted system call return -EINTR */
143    current_thread_info()->restart_block.fn = do_no_restart_syscall;
144
145    err = __copy_from_user(&user_sregs, sregs, sizeof(_sigregs));
146    if (err)
147        return err;
148    regs->psw.mask = PSW_MASK_MERGE(regs->psw.mask,
149                    user_sregs.regs.psw.mask);
150    regs->psw.addr = PSW_ADDR_AMODE | user_sregs.regs.psw.addr;
151    memcpy(&regs->gprs, &user_sregs.regs.gprs, sizeof(sregs->regs.gprs));
152    memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
153           sizeof(sregs->regs.acrs));
154    restore_access_regs(current->thread.acrs);
155
156    memcpy(&current->thread.fp_regs, &user_sregs.fpregs,
157           sizeof(s390_fp_regs));
158    current->thread.fp_regs.fpc &= FPC_VALID_MASK;
159
160    restore_fp_regs(&current->thread.fp_regs);
161    regs->svcnr = 0; /* disable syscall checks */
162    return 0;
163}
164
165SYSCALL_DEFINE0(sigreturn)
166{
167    struct pt_regs *regs = task_pt_regs(current);
168    sigframe __user *frame = (sigframe __user *)regs->gprs[15];
169    sigset_t set;
170
171    if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
172        goto badframe;
173    if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE))
174        goto badframe;
175
176    sigdelsetmask(&set, ~_BLOCKABLE);
177    spin_lock_irq(&current->sighand->siglock);
178    current->blocked = set;
179    recalc_sigpending();
180    spin_unlock_irq(&current->sighand->siglock);
181
182    if (restore_sigregs(regs, &frame->sregs))
183        goto badframe;
184
185    return regs->gprs[2];
186
187badframe:
188    force_sig(SIGSEGV, current);
189    return 0;
190}
191
192SYSCALL_DEFINE0(rt_sigreturn)
193{
194    struct pt_regs *regs = task_pt_regs(current);
195    rt_sigframe __user *frame = (rt_sigframe __user *)regs->gprs[15];
196    sigset_t set;
197
198    if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
199        goto badframe;
200    if (__copy_from_user(&set.sig, &frame->uc.uc_sigmask, sizeof(set)))
201        goto badframe;
202
203    sigdelsetmask(&set, ~_BLOCKABLE);
204    spin_lock_irq(&current->sighand->siglock);
205    current->blocked = set;
206    recalc_sigpending();
207    spin_unlock_irq(&current->sighand->siglock);
208
209    if (restore_sigregs(regs, &frame->uc.uc_mcontext))
210        goto badframe;
211
212    if (do_sigaltstack(&frame->uc.uc_stack, NULL,
213               regs->gprs[15]) == -EFAULT)
214        goto badframe;
215    return regs->gprs[2];
216
217badframe:
218    force_sig(SIGSEGV, current);
219    return 0;
220}
221
222/*
223 * Set up a signal frame.
224 */
225
226
227/*
228 * Determine which stack to use..
229 */
230static inline void __user *
231get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
232{
233    unsigned long sp;
234
235    /* Default to using normal stack */
236    sp = regs->gprs[15];
237
238    /* Overflow on alternate signal stack gives SIGSEGV. */
239    if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
240        return (void __user *) -1UL;
241
242    /* This is the X/Open sanctioned signal stack switching. */
243    if (ka->sa.sa_flags & SA_ONSTACK) {
244        if (! sas_ss_flags(sp))
245            sp = current->sas_ss_sp + current->sas_ss_size;
246    }
247
248    /* This is the legacy signal stack switching. */
249    else if (!user_mode(regs) &&
250         !(ka->sa.sa_flags & SA_RESTORER) &&
251         ka->sa.sa_restorer) {
252        sp = (unsigned long) ka->sa.sa_restorer;
253    }
254
255    return (void __user *)((sp - frame_size) & -8ul);
256}
257
258static inline int map_signal(int sig)
259{
260    if (current_thread_info()->exec_domain
261        && current_thread_info()->exec_domain->signal_invmap
262        && sig < 32)
263        return current_thread_info()->exec_domain->signal_invmap[sig];
264    else
265        return sig;
266}
267
268static int setup_frame(int sig, struct k_sigaction *ka,
269               sigset_t *set, struct pt_regs * regs)
270{
271    sigframe __user *frame;
272
273    frame = get_sigframe(ka, regs, sizeof(sigframe));
274    if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe)))
275        goto give_sigsegv;
276
277    if (frame == (void __user *) -1UL)
278        goto give_sigsegv;
279
280    if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE))
281        goto give_sigsegv;
282
283    if (save_sigregs(regs, &frame->sregs))
284        goto give_sigsegv;
285    if (__put_user(&frame->sregs, &frame->sc.sregs))
286        goto give_sigsegv;
287
288    /* Set up to return from userspace. If provided, use a stub
289       already in userspace. */
290    if (ka->sa.sa_flags & SA_RESTORER) {
291                regs->gprs[14] = (unsigned long)
292            ka->sa.sa_restorer | PSW_ADDR_AMODE;
293    } else {
294                regs->gprs[14] = (unsigned long)
295            frame->retcode | PSW_ADDR_AMODE;
296        if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
297                           (u16 __user *)(frame->retcode)))
298            goto give_sigsegv;
299    }
300
301    /* Set up backchain. */
302    if (__put_user(regs->gprs[15], (addr_t __user *) frame))
303        goto give_sigsegv;
304
305    /* Set up registers for signal handler */
306    regs->gprs[15] = (unsigned long) frame;
307    regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;
308
309    regs->gprs[2] = map_signal(sig);
310    regs->gprs[3] = (unsigned long) &frame->sc;
311
312    /* We forgot to include these in the sigcontext.
313       To avoid breaking binary compatibility, they are passed as args. */
314    regs->gprs[4] = current->thread.trap_no;
315    regs->gprs[5] = current->thread.prot_addr;
316    regs->gprs[6] = task_thread_info(current)->last_break;
317
318    /* Place signal number on stack to allow backtrace from handler. */
319    if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
320        goto give_sigsegv;
321    return 0;
322
323give_sigsegv:
324    force_sigsegv(sig, current);
325    return -EFAULT;
326}
327
328static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
329               sigset_t *set, struct pt_regs * regs)
330{
331    int err = 0;
332    rt_sigframe __user *frame;
333
334    frame = get_sigframe(ka, regs, sizeof(rt_sigframe));
335    if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe)))
336        goto give_sigsegv;
337
338    if (frame == (void __user *) -1UL)
339        goto give_sigsegv;
340
341    if (copy_siginfo_to_user(&frame->info, info))
342        goto give_sigsegv;
343
344    /* Create the ucontext. */
345    err |= __put_user(0, &frame->uc.uc_flags);
346    err |= __put_user(NULL, &frame->uc.uc_link);
347    err |= __put_user((void __user *)current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
348    err |= __put_user(sas_ss_flags(regs->gprs[15]),
349              &frame->uc.uc_stack.ss_flags);
350    err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
351    err |= save_sigregs(regs, &frame->uc.uc_mcontext);
352    err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
353    if (err)
354        goto give_sigsegv;
355
356    /* Set up to return from userspace. If provided, use a stub
357       already in userspace. */
358    if (ka->sa.sa_flags & SA_RESTORER) {
359                regs->gprs[14] = (unsigned long)
360            ka->sa.sa_restorer | PSW_ADDR_AMODE;
361    } else {
362                regs->gprs[14] = (unsigned long)
363            frame->retcode | PSW_ADDR_AMODE;
364        if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
365                   (u16 __user *)(frame->retcode)))
366            goto give_sigsegv;
367    }
368
369    /* Set up backchain. */
370    if (__put_user(regs->gprs[15], (addr_t __user *) frame))
371        goto give_sigsegv;
372
373    /* Set up registers for signal handler */
374    regs->gprs[15] = (unsigned long) frame;
375    regs->psw.addr = (unsigned long) ka->sa.sa_handler | PSW_ADDR_AMODE;
376
377    regs->gprs[2] = map_signal(sig);
378    regs->gprs[3] = (unsigned long) &frame->info;
379    regs->gprs[4] = (unsigned long) &frame->uc;
380    regs->gprs[5] = task_thread_info(current)->last_break;
381    return 0;
382
383give_sigsegv:
384    force_sigsegv(sig, current);
385    return -EFAULT;
386}
387
388/*
389 * OK, we're invoking a handler
390 */
391
392static int
393handle_signal(unsigned long sig, struct k_sigaction *ka,
394          siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
395{
396    int ret;
397
398    /* Set up the stack frame */
399    if (ka->sa.sa_flags & SA_SIGINFO)
400        ret = setup_rt_frame(sig, ka, info, oldset, regs);
401    else
402        ret = setup_frame(sig, ka, oldset, regs);
403
404    if (ret == 0) {
405        spin_lock_irq(&current->sighand->siglock);
406        sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
407        if (!(ka->sa.sa_flags & SA_NODEFER))
408            sigaddset(&current->blocked,sig);
409        recalc_sigpending();
410        spin_unlock_irq(&current->sighand->siglock);
411    }
412
413    return ret;
414}
415
416/*
417 * Note that 'init' is a special process: it doesn't get signals it doesn't
418 * want to handle. Thus you cannot kill init even with a SIGKILL even by
419 * mistake.
420 *
421 * Note that we go through the signals twice: once to check the signals that
422 * the kernel can handle, and then we build all the user-level signal handling
423 * stack-frames in one go after that.
424 */
425void do_signal(struct pt_regs *regs)
426{
427    unsigned long retval = 0, continue_addr = 0, restart_addr = 0;
428    siginfo_t info;
429    int signr;
430    struct k_sigaction ka;
431    sigset_t *oldset;
432
433    /*
434     * We want the common case to go fast, which
435     * is why we may in certain cases get here from
436     * kernel mode. Just return without doing anything
437     * if so.
438     */
439    if (!user_mode(regs))
440        return;
441
442    if (test_thread_flag(TIF_RESTORE_SIGMASK))
443        oldset = &current->saved_sigmask;
444    else
445        oldset = &current->blocked;
446
447    /* Are we from a system call? */
448    if (regs->svcnr) {
449        continue_addr = regs->psw.addr;
450        restart_addr = continue_addr - regs->ilc;
451        retval = regs->gprs[2];
452
453        /* Prepare for system call restart. We do this here so that a
454           debugger will see the already changed PSW. */
455        switch (retval) {
456        case -ERESTARTNOHAND:
457        case -ERESTARTSYS:
458        case -ERESTARTNOINTR:
459            regs->gprs[2] = regs->orig_gpr2;
460            regs->psw.addr = restart_addr;
461            break;
462        case -ERESTART_RESTARTBLOCK:
463            regs->gprs[2] = -EINTR;
464        }
465        regs->svcnr = 0; /* Don't deal with this again. */
466    }
467
468    /* Get signal to deliver. When running under ptrace, at this point
469       the debugger may change all our registers ... */
470    signr = get_signal_to_deliver(&info, &ka, regs, NULL);
471
472    /* Depending on the signal settings we may need to revert the
473       decision to restart the system call. */
474    if (signr > 0 && regs->psw.addr == restart_addr) {
475        if (retval == -ERESTARTNOHAND
476            || (retval == -ERESTARTSYS
477             && !(current->sighand->action[signr-1].sa.sa_flags
478                  & SA_RESTART))) {
479            regs->gprs[2] = -EINTR;
480            regs->psw.addr = continue_addr;
481        }
482    }
483
484    if (signr > 0) {
485        /* Whee! Actually deliver the signal. */
486        int ret;
487#ifdef CONFIG_COMPAT
488        if (is_compat_task()) {
489            ret = handle_signal32(signr, &ka, &info, oldset, regs);
490            }
491        else
492#endif
493            ret = handle_signal(signr, &ka, &info, oldset, regs);
494        if (!ret) {
495            /*
496             * A signal was successfully delivered; the saved
497             * sigmask will have been stored in the signal frame,
498             * and will be restored by sigreturn, so we can simply
499             * clear the TIF_RESTORE_SIGMASK flag.
500             */
501            if (test_thread_flag(TIF_RESTORE_SIGMASK))
502                clear_thread_flag(TIF_RESTORE_SIGMASK);
503
504            /*
505             * Let tracing know that we've done the handler setup.
506             */
507            tracehook_signal_handler(signr, &info, &ka, regs,
508                    current->thread.per_info.single_step);
509        }
510        return;
511    }
512
513    /*
514     * If there's no signal to deliver, we just put the saved sigmask back.
515     */
516    if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
517        clear_thread_flag(TIF_RESTORE_SIGMASK);
518        sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
519    }
520
521    /* Restart a different system call. */
522    if (retval == -ERESTART_RESTARTBLOCK
523        && regs->psw.addr == continue_addr) {
524        regs->gprs[2] = __NR_restart_syscall;
525        set_thread_flag(TIF_RESTART_SVC);
526    }
527}
528
529void do_notify_resume(struct pt_regs *regs)
530{
531    clear_thread_flag(TIF_NOTIFY_RESUME);
532    tracehook_notify_resume(regs);
533    if (current->replacement_session_keyring)
534        key_replace_session_keyring();
535}
536

Archive Download this file



interactive