Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright IBM Corp. 2000, 2006
4 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
5 * Gerhard Tonn (ton@de.ibm.com)
6 *
7 * Copyright (C) 1991, 1992 Linus Torvalds
8 *
9 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
10 */
11
12#include <linux/compat.h>
13#include <linux/sched.h>
14#include <linux/sched/task_stack.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 <asm/ucontext.h>
28#include <linux/uaccess.h>
29#include <asm/lowcore.h>
30#include <asm/switch_to.h>
31#include "compat_linux.h"
32#include "compat_ptrace.h"
33#include "entry.h"
34
35typedef struct
36{
37 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
38 struct sigcontext32 sc;
39 _sigregs32 sregs;
40 int signo;
41 _sigregs_ext32 sregs_ext;
42 __u16 svc_insn; /* Offset of svc_insn is NOT fixed! */
43} sigframe32;
44
45typedef struct
46{
47 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
48 __u16 svc_insn;
49 compat_siginfo_t info;
50 struct ucontext32 uc;
51} rt_sigframe32;
52
53/* Store registers needed to create the signal frame */
54static void store_sigregs(void)
55{
56 save_access_regs(current->thread.acrs);
57 save_fpu_regs();
58}
59
60/* Load registers after signal return */
61static void load_sigregs(void)
62{
63 restore_access_regs(current->thread.acrs);
64}
65
66static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
67{
68 _sigregs32 user_sregs;
69 int i;
70
71 user_sregs.regs.psw.mask = (__u32)(regs->psw.mask >> 32);
72 user_sregs.regs.psw.mask &= PSW32_MASK_USER | PSW32_MASK_RI;
73 user_sregs.regs.psw.mask |= PSW32_USER_BITS;
74 user_sregs.regs.psw.addr = (__u32) regs->psw.addr |
75 (__u32)(regs->psw.mask & PSW_MASK_BA);
76 for (i = 0; i < NUM_GPRS; i++)
77 user_sregs.regs.gprs[i] = (__u32) regs->gprs[i];
78 memcpy(&user_sregs.regs.acrs, current->thread.acrs,
79 sizeof(user_sregs.regs.acrs));
80 fpregs_store((_s390_fp_regs *) &user_sregs.fpregs, ¤t->thread.fpu);
81 if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs32)))
82 return -EFAULT;
83 return 0;
84}
85
86static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
87{
88 _sigregs32 user_sregs;
89 int i;
90
91 /* Alwys make any pending restarted system call return -EINTR */
92 current->restart_block.fn = do_no_restart_syscall;
93
94 if (__copy_from_user(&user_sregs, &sregs->regs, sizeof(user_sregs)))
95 return -EFAULT;
96
97 if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW32_MASK_RI))
98 return -EINVAL;
99
100 /* Test the floating-point-control word. */
101 if (test_fp_ctl(user_sregs.fpregs.fpc))
102 return -EINVAL;
103
104 /* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */
105 regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | PSW_MASK_RI)) |
106 (__u64)(user_sregs.regs.psw.mask & PSW32_MASK_USER) << 32 |
107 (__u64)(user_sregs.regs.psw.mask & PSW32_MASK_RI) << 32 |
108 (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_AMODE);
109 /* Check for invalid user address space control. */
110 if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME)
111 regs->psw.mask = PSW_ASC_PRIMARY |
112 (regs->psw.mask & ~PSW_MASK_ASC);
113 regs->psw.addr = (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_INSN);
114 for (i = 0; i < NUM_GPRS; i++)
115 regs->gprs[i] = (__u64) user_sregs.regs.gprs[i];
116 memcpy(¤t->thread.acrs, &user_sregs.regs.acrs,
117 sizeof(current->thread.acrs));
118 fpregs_load((_s390_fp_regs *) &user_sregs.fpregs, ¤t->thread.fpu);
119
120 clear_pt_regs_flag(regs, PIF_SYSCALL); /* No longer in a system call */
121 return 0;
122}
123
124static int save_sigregs_ext32(struct pt_regs *regs,
125 _sigregs_ext32 __user *sregs_ext)
126{
127 __u32 gprs_high[NUM_GPRS];
128 __u64 vxrs[__NUM_VXRS_LOW];
129 int i;
130
131 /* Save high gprs to signal stack */
132 for (i = 0; i < NUM_GPRS; i++)
133 gprs_high[i] = regs->gprs[i] >> 32;
134 if (__copy_to_user(&sregs_ext->gprs_high, &gprs_high,
135 sizeof(sregs_ext->gprs_high)))
136 return -EFAULT;
137
138 /* Save vector registers to signal stack */
139 if (MACHINE_HAS_VX) {
140 for (i = 0; i < __NUM_VXRS_LOW; i++)
141 vxrs[i] = *((__u64 *)(current->thread.fpu.vxrs + i) + 1);
142 if (__copy_to_user(&sregs_ext->vxrs_low, vxrs,
143 sizeof(sregs_ext->vxrs_low)) ||
144 __copy_to_user(&sregs_ext->vxrs_high,
145 current->thread.fpu.vxrs + __NUM_VXRS_LOW,
146 sizeof(sregs_ext->vxrs_high)))
147 return -EFAULT;
148 }
149 return 0;
150}
151
152static int restore_sigregs_ext32(struct pt_regs *regs,
153 _sigregs_ext32 __user *sregs_ext)
154{
155 __u32 gprs_high[NUM_GPRS];
156 __u64 vxrs[__NUM_VXRS_LOW];
157 int i;
158
159 /* Restore high gprs from signal stack */
160 if (__copy_from_user(&gprs_high, &sregs_ext->gprs_high,
161 sizeof(sregs_ext->gprs_high)))
162 return -EFAULT;
163 for (i = 0; i < NUM_GPRS; i++)
164 *(__u32 *)®s->gprs[i] = gprs_high[i];
165
166 /* Restore vector registers from signal stack */
167 if (MACHINE_HAS_VX) {
168 if (__copy_from_user(vxrs, &sregs_ext->vxrs_low,
169 sizeof(sregs_ext->vxrs_low)) ||
170 __copy_from_user(current->thread.fpu.vxrs + __NUM_VXRS_LOW,
171 &sregs_ext->vxrs_high,
172 sizeof(sregs_ext->vxrs_high)))
173 return -EFAULT;
174 for (i = 0; i < __NUM_VXRS_LOW; i++)
175 *((__u64 *)(current->thread.fpu.vxrs + i) + 1) = vxrs[i];
176 }
177 return 0;
178}
179
180COMPAT_SYSCALL_DEFINE0(sigreturn)
181{
182 struct pt_regs *regs = task_pt_regs(current);
183 sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
184 sigset_t set;
185
186 if (get_compat_sigset(&set, (compat_sigset_t __user *)frame->sc.oldmask))
187 goto badframe;
188 set_current_blocked(&set);
189 save_fpu_regs();
190 if (restore_sigregs32(regs, &frame->sregs))
191 goto badframe;
192 if (restore_sigregs_ext32(regs, &frame->sregs_ext))
193 goto badframe;
194 load_sigregs();
195 return regs->gprs[2];
196badframe:
197 force_sig(SIGSEGV);
198 return 0;
199}
200
201COMPAT_SYSCALL_DEFINE0(rt_sigreturn)
202{
203 struct pt_regs *regs = task_pt_regs(current);
204 rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
205 sigset_t set;
206
207 if (get_compat_sigset(&set, &frame->uc.uc_sigmask))
208 goto badframe;
209 set_current_blocked(&set);
210 if (compat_restore_altstack(&frame->uc.uc_stack))
211 goto badframe;
212 save_fpu_regs();
213 if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
214 goto badframe;
215 if (restore_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext))
216 goto badframe;
217 load_sigregs();
218 return regs->gprs[2];
219badframe:
220 force_sig(SIGSEGV);
221 return 0;
222}
223
224/*
225 * Set up a signal frame.
226 */
227
228
229/*
230 * Determine which stack to use..
231 */
232static inline void __user *
233get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
234{
235 unsigned long sp;
236
237 /* Default to using normal stack */
238 sp = (unsigned long) A(regs->gprs[15]);
239
240 /* Overflow on alternate signal stack gives SIGSEGV. */
241 if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
242 return (void __user *) -1UL;
243
244 /* This is the X/Open sanctioned signal stack switching. */
245 if (ka->sa.sa_flags & SA_ONSTACK) {
246 if (! sas_ss_flags(sp))
247 sp = current->sas_ss_sp + current->sas_ss_size;
248 }
249
250 return (void __user *)((sp - frame_size) & -8ul);
251}
252
253static int setup_frame32(struct ksignal *ksig, sigset_t *set,
254 struct pt_regs *regs)
255{
256 int sig = ksig->sig;
257 sigframe32 __user *frame;
258 unsigned long restorer;
259 size_t frame_size;
260
261 /*
262 * gprs_high are always present for 31-bit compat tasks.
263 * The space for vector registers is only allocated if
264 * the machine supports it
265 */
266 frame_size = sizeof(*frame) - sizeof(frame->sregs_ext.__reserved);
267 if (!MACHINE_HAS_VX)
268 frame_size -= sizeof(frame->sregs_ext.vxrs_low) +
269 sizeof(frame->sregs_ext.vxrs_high);
270 frame = get_sigframe(&ksig->ka, regs, frame_size);
271 if (frame == (void __user *) -1UL)
272 return -EFAULT;
273
274 /* Set up backchain. */
275 if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
276 return -EFAULT;
277
278 /* Create struct sigcontext32 on the signal stack */
279 if (put_compat_sigset((compat_sigset_t __user *)frame->sc.oldmask,
280 set, sizeof(compat_sigset_t)))
281 return -EFAULT;
282 if (__put_user(ptr_to_compat(&frame->sregs), &frame->sc.sregs))
283 return -EFAULT;
284
285 /* Store registers needed to create the signal frame */
286 store_sigregs();
287
288 /* Create _sigregs32 on the signal stack */
289 if (save_sigregs32(regs, &frame->sregs))
290 return -EFAULT;
291
292 /* Place signal number on stack to allow backtrace from handler. */
293 if (__put_user(regs->gprs[2], (int __force __user *) &frame->signo))
294 return -EFAULT;
295
296 /* Create _sigregs_ext32 on the signal stack */
297 if (save_sigregs_ext32(regs, &frame->sregs_ext))
298 return -EFAULT;
299
300 /* Set up to return from userspace. If provided, use a stub
301 already in userspace. */
302 if (ksig->ka.sa.sa_flags & SA_RESTORER) {
303 restorer = (unsigned long __force)
304 ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE;
305 } else {
306 /* Signal frames without vectors registers are short ! */
307 __u16 __user *svc = (void __user *) frame + frame_size - 2;
308 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, svc))
309 return -EFAULT;
310 restorer = (unsigned long __force) svc | PSW32_ADDR_AMODE;
311 }
312
313 /* Set up registers for signal handler */
314 regs->gprs[14] = restorer;
315 regs->gprs[15] = (__force __u64) frame;
316 /* Force 31 bit amode and default user address space control. */
317 regs->psw.mask = PSW_MASK_BA |
318 (PSW_USER_BITS & PSW_MASK_ASC) |
319 (regs->psw.mask & ~PSW_MASK_ASC);
320 regs->psw.addr = (__force __u64) ksig->ka.sa.sa_handler;
321
322 regs->gprs[2] = sig;
323 regs->gprs[3] = (__force __u64) &frame->sc;
324
325 /* We forgot to include these in the sigcontext.
326 To avoid breaking binary compatibility, they are passed as args. */
327 if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
328 sig == SIGTRAP || sig == SIGFPE) {
329 /* set extra registers only for synchronous signals */
330 regs->gprs[4] = regs->int_code & 127;
331 regs->gprs[5] = regs->int_parm_long;
332 regs->gprs[6] = current->thread.last_break;
333 }
334
335 return 0;
336}
337
338static int setup_rt_frame32(struct ksignal *ksig, sigset_t *set,
339 struct pt_regs *regs)
340{
341 rt_sigframe32 __user *frame;
342 unsigned long restorer;
343 size_t frame_size;
344 u32 uc_flags;
345
346 frame_size = sizeof(*frame) -
347 sizeof(frame->uc.uc_mcontext_ext.__reserved);
348 /*
349 * gprs_high are always present for 31-bit compat tasks.
350 * The space for vector registers is only allocated if
351 * the machine supports it
352 */
353 uc_flags = UC_GPRS_HIGH;
354 if (MACHINE_HAS_VX) {
355 uc_flags |= UC_VXRS;
356 } else
357 frame_size -= sizeof(frame->uc.uc_mcontext_ext.vxrs_low) +
358 sizeof(frame->uc.uc_mcontext_ext.vxrs_high);
359 frame = get_sigframe(&ksig->ka, regs, frame_size);
360 if (frame == (void __user *) -1UL)
361 return -EFAULT;
362
363 /* Set up backchain. */
364 if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame))
365 return -EFAULT;
366
367 /* Set up to return from userspace. If provided, use a stub
368 already in userspace. */
369 if (ksig->ka.sa.sa_flags & SA_RESTORER) {
370 restorer = (unsigned long __force)
371 ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE;
372 } else {
373 __u16 __user *svc = &frame->svc_insn;
374 if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, svc))
375 return -EFAULT;
376 restorer = (unsigned long __force) svc | PSW32_ADDR_AMODE;
377 }
378
379 /* Create siginfo on the signal stack */
380 if (copy_siginfo_to_user32(&frame->info, &ksig->info))
381 return -EFAULT;
382
383 /* Store registers needed to create the signal frame */
384 store_sigregs();
385
386 /* Create ucontext on the signal stack. */
387 if (__put_user(uc_flags, &frame->uc.uc_flags) ||
388 __put_user(0, &frame->uc.uc_link) ||
389 __compat_save_altstack(&frame->uc.uc_stack, regs->gprs[15]) ||
390 save_sigregs32(regs, &frame->uc.uc_mcontext) ||
391 put_compat_sigset(&frame->uc.uc_sigmask, set, sizeof(compat_sigset_t)) ||
392 save_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext))
393 return -EFAULT;
394
395 /* Set up registers for signal handler */
396 regs->gprs[14] = restorer;
397 regs->gprs[15] = (__force __u64) frame;
398 /* Force 31 bit amode and default user address space control. */
399 regs->psw.mask = PSW_MASK_BA |
400 (PSW_USER_BITS & PSW_MASK_ASC) |
401 (regs->psw.mask & ~PSW_MASK_ASC);
402 regs->psw.addr = (__u64 __force) ksig->ka.sa.sa_handler;
403
404 regs->gprs[2] = ksig->sig;
405 regs->gprs[3] = (__force __u64) &frame->info;
406 regs->gprs[4] = (__force __u64) &frame->uc;
407 regs->gprs[5] = current->thread.last_break;
408 return 0;
409}
410
411/*
412 * OK, we're invoking a handler
413 */
414
415void handle_signal32(struct ksignal *ksig, sigset_t *oldset,
416 struct pt_regs *regs)
417{
418 int ret;
419
420 /* Set up the stack frame */
421 if (ksig->ka.sa.sa_flags & SA_SIGINFO)
422 ret = setup_rt_frame32(ksig, oldset, regs);
423 else
424 ret = setup_frame32(ksig, oldset, regs);
425
426 signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP));
427}
428
1/*
2 * arch/s390/kernel/compat_signal.c
3 *
4 * Copyright (C) IBM Corp. 2000,2006
5 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
6 * Gerhard Tonn (ton@de.ibm.com)
7 *
8 * Copyright (C) 1991, 1992 Linus Torvalds
9 *
10 * 1997-11-28 Modified for POSIX.1b signals by Richard Henderson
11 */
12
13#include <linux/compat.h>
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 <asm/ucontext.h>
28#include <asm/uaccess.h>
29#include <asm/lowcore.h>
30#include <asm/switch_to.h>
31#include "compat_linux.h"
32#include "compat_ptrace.h"
33#include "entry.h"
34
35typedef struct
36{
37 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
38 struct sigcontext32 sc;
39 _sigregs32 sregs;
40 int signo;
41 __u32 gprs_high[NUM_GPRS];
42 __u8 retcode[S390_SYSCALL_SIZE];
43} sigframe32;
44
45typedef struct
46{
47 __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
48 __u8 retcode[S390_SYSCALL_SIZE];
49 compat_siginfo_t info;
50 struct ucontext32 uc;
51 __u32 gprs_high[NUM_GPRS];
52} rt_sigframe32;
53
54int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
55{
56 int err;
57
58 if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
59 return -EFAULT;
60
61 /* If you change siginfo_t structure, please be sure
62 this code is fixed accordingly.
63 It should never copy any pad contained in the structure
64 to avoid security leaks, but must copy the generic
65 3 ints plus the relevant union member.
66 This routine must convert siginfo from 64bit to 32bit as well
67 at the same time. */
68 err = __put_user(from->si_signo, &to->si_signo);
69 err |= __put_user(from->si_errno, &to->si_errno);
70 err |= __put_user((short)from->si_code, &to->si_code);
71 if (from->si_code < 0)
72 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
73 else {
74 switch (from->si_code >> 16) {
75 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
76 case __SI_MESGQ >> 16:
77 err |= __put_user(from->si_int, &to->si_int);
78 /* fallthrough */
79 case __SI_KILL >> 16:
80 err |= __put_user(from->si_pid, &to->si_pid);
81 err |= __put_user(from->si_uid, &to->si_uid);
82 break;
83 case __SI_CHLD >> 16:
84 err |= __put_user(from->si_pid, &to->si_pid);
85 err |= __put_user(from->si_uid, &to->si_uid);
86 err |= __put_user(from->si_utime, &to->si_utime);
87 err |= __put_user(from->si_stime, &to->si_stime);
88 err |= __put_user(from->si_status, &to->si_status);
89 break;
90 case __SI_FAULT >> 16:
91 err |= __put_user((unsigned long) from->si_addr,
92 &to->si_addr);
93 break;
94 case __SI_POLL >> 16:
95 err |= __put_user(from->si_band, &to->si_band);
96 err |= __put_user(from->si_fd, &to->si_fd);
97 break;
98 case __SI_TIMER >> 16:
99 err |= __put_user(from->si_tid, &to->si_tid);
100 err |= __put_user(from->si_overrun, &to->si_overrun);
101 err |= __put_user(from->si_int, &to->si_int);
102 break;
103 default:
104 break;
105 }
106 }
107 return err;
108}
109
110int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
111{
112 int err;
113 u32 tmp;
114
115 if (!access_ok (VERIFY_READ, from, sizeof(compat_siginfo_t)))
116 return -EFAULT;
117
118 err = __get_user(to->si_signo, &from->si_signo);
119 err |= __get_user(to->si_errno, &from->si_errno);
120 err |= __get_user(to->si_code, &from->si_code);
121
122 if (to->si_code < 0)
123 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
124 else {
125 switch (to->si_code >> 16) {
126 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
127 case __SI_MESGQ >> 16:
128 err |= __get_user(to->si_int, &from->si_int);
129 /* fallthrough */
130 case __SI_KILL >> 16:
131 err |= __get_user(to->si_pid, &from->si_pid);
132 err |= __get_user(to->si_uid, &from->si_uid);
133 break;
134 case __SI_CHLD >> 16:
135 err |= __get_user(to->si_pid, &from->si_pid);
136 err |= __get_user(to->si_uid, &from->si_uid);
137 err |= __get_user(to->si_utime, &from->si_utime);
138 err |= __get_user(to->si_stime, &from->si_stime);
139 err |= __get_user(to->si_status, &from->si_status);
140 break;
141 case __SI_FAULT >> 16:
142 err |= __get_user(tmp, &from->si_addr);
143 to->si_addr = (void __force __user *)
144 (u64) (tmp & PSW32_ADDR_INSN);
145 break;
146 case __SI_POLL >> 16:
147 err |= __get_user(to->si_band, &from->si_band);
148 err |= __get_user(to->si_fd, &from->si_fd);
149 break;
150 case __SI_TIMER >> 16:
151 err |= __get_user(to->si_tid, &from->si_tid);
152 err |= __get_user(to->si_overrun, &from->si_overrun);
153 err |= __get_user(to->si_int, &from->si_int);
154 break;
155 default:
156 break;
157 }
158 }
159 return err;
160}
161
162asmlinkage long
163sys32_sigaction(int sig, const struct old_sigaction32 __user *act,
164 struct old_sigaction32 __user *oact)
165{
166 struct k_sigaction new_ka, old_ka;
167 unsigned long sa_handler, sa_restorer;
168 int ret;
169
170 if (act) {
171 compat_old_sigset_t mask;
172 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
173 __get_user(sa_handler, &act->sa_handler) ||
174 __get_user(sa_restorer, &act->sa_restorer) ||
175 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
176 __get_user(mask, &act->sa_mask))
177 return -EFAULT;
178 new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
179 new_ka.sa.sa_restorer = (void (*)(void)) sa_restorer;
180 siginitset(&new_ka.sa.sa_mask, mask);
181 }
182
183 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
184
185 if (!ret && oact) {
186 sa_handler = (unsigned long) old_ka.sa.sa_handler;
187 sa_restorer = (unsigned long) old_ka.sa.sa_restorer;
188 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
189 __put_user(sa_handler, &oact->sa_handler) ||
190 __put_user(sa_restorer, &oact->sa_restorer) ||
191 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
192 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
193 return -EFAULT;
194 }
195
196 return ret;
197}
198
199asmlinkage long
200sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
201 struct sigaction32 __user *oact, size_t sigsetsize)
202{
203 struct k_sigaction new_ka, old_ka;
204 unsigned long sa_handler;
205 int ret;
206 compat_sigset_t set32;
207
208 /* XXX: Don't preclude handling different sized sigset_t's. */
209 if (sigsetsize != sizeof(compat_sigset_t))
210 return -EINVAL;
211
212 if (act) {
213 ret = get_user(sa_handler, &act->sa_handler);
214 ret |= __copy_from_user(&set32, &act->sa_mask,
215 sizeof(compat_sigset_t));
216 new_ka.sa.sa_mask.sig[0] =
217 set32.sig[0] | (((long)set32.sig[1]) << 32);
218 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
219
220 if (ret)
221 return -EFAULT;
222 new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
223 }
224
225 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
226
227 if (!ret && oact) {
228 set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
229 set32.sig[0] = old_ka.sa.sa_mask.sig[0];
230 ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler);
231 ret |= __copy_to_user(&oact->sa_mask, &set32,
232 sizeof(compat_sigset_t));
233 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
234 }
235
236 return ret;
237}
238
239asmlinkage long
240sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss)
241{
242 struct pt_regs *regs = task_pt_regs(current);
243 stack_t kss, koss;
244 unsigned long ss_sp;
245 int ret, err = 0;
246 mm_segment_t old_fs = get_fs();
247
248 if (uss) {
249 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
250 return -EFAULT;
251 err |= __get_user(ss_sp, &uss->ss_sp);
252 err |= __get_user(kss.ss_size, &uss->ss_size);
253 err |= __get_user(kss.ss_flags, &uss->ss_flags);
254 if (err)
255 return -EFAULT;
256 kss.ss_sp = (void __user *) ss_sp;
257 }
258
259 set_fs (KERNEL_DS);
260 ret = do_sigaltstack((stack_t __force __user *) (uss ? &kss : NULL),
261 (stack_t __force __user *) (uoss ? &koss : NULL),
262 regs->gprs[15]);
263 set_fs (old_fs);
264
265 if (!ret && uoss) {
266 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
267 return -EFAULT;
268 ss_sp = (unsigned long) koss.ss_sp;
269 err |= __put_user(ss_sp, &uoss->ss_sp);
270 err |= __put_user(koss.ss_size, &uoss->ss_size);
271 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
272 if (err)
273 return -EFAULT;
274 }
275 return ret;
276}
277
278static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
279{
280 _s390_regs_common32 regs32;
281 int err, i;
282
283 regs32.psw.mask = psw32_user_bits |
284 ((__u32)(regs->psw.mask >> 32) & PSW32_MASK_USER);
285 regs32.psw.addr = (__u32) regs->psw.addr |
286 (__u32)(regs->psw.mask & PSW_MASK_BA);
287 for (i = 0; i < NUM_GPRS; i++)
288 regs32.gprs[i] = (__u32) regs->gprs[i];
289 save_access_regs(current->thread.acrs);
290 memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs));
291 err = __copy_to_user(&sregs->regs, ®s32, sizeof(regs32));
292 if (err)
293 return err;
294 save_fp_regs(¤t->thread.fp_regs);
295 /* s390_fp_regs and _s390_fp_regs32 are the same ! */
296 return __copy_to_user(&sregs->fpregs, ¤t->thread.fp_regs,
297 sizeof(_s390_fp_regs32));
298}
299
300static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
301{
302 _s390_regs_common32 regs32;
303 int err, i;
304
305 /* Alwys make any pending restarted system call return -EINTR */
306 current_thread_info()->restart_block.fn = do_no_restart_syscall;
307
308 err = __copy_from_user(®s32, &sregs->regs, sizeof(regs32));
309 if (err)
310 return err;
311 regs->psw.mask = (regs->psw.mask & ~PSW_MASK_USER) |
312 (__u64)(regs32.psw.mask & PSW32_MASK_USER) << 32 |
313 (__u64)(regs32.psw.addr & PSW32_ADDR_AMODE);
314 regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN);
315 for (i = 0; i < NUM_GPRS; i++)
316 regs->gprs[i] = (__u64) regs32.gprs[i];
317 memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs));
318 restore_access_regs(current->thread.acrs);
319
320 err = __copy_from_user(¤t->thread.fp_regs, &sregs->fpregs,
321 sizeof(_s390_fp_regs32));
322 current->thread.fp_regs.fpc &= FPC_VALID_MASK;
323 if (err)
324 return err;
325
326 restore_fp_regs(¤t->thread.fp_regs);
327 clear_thread_flag(TIF_SYSCALL); /* No longer in a system call */
328 return 0;
329}
330
331static int save_sigregs_gprs_high(struct pt_regs *regs, __u32 __user *uregs)
332{
333 __u32 gprs_high[NUM_GPRS];
334 int i;
335
336 for (i = 0; i < NUM_GPRS; i++)
337 gprs_high[i] = regs->gprs[i] >> 32;
338
339 return __copy_to_user(uregs, &gprs_high, sizeof(gprs_high));
340}
341
342static int restore_sigregs_gprs_high(struct pt_regs *regs, __u32 __user *uregs)
343{
344 __u32 gprs_high[NUM_GPRS];
345 int err, i;
346
347 err = __copy_from_user(&gprs_high, uregs, sizeof(gprs_high));
348 if (err)
349 return err;
350 for (i = 0; i < NUM_GPRS; i++)
351 *(__u32 *)®s->gprs[i] = gprs_high[i];
352 return 0;
353}
354
355asmlinkage long sys32_sigreturn(void)
356{
357 struct pt_regs *regs = task_pt_regs(current);
358 sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
359 sigset_t set;
360
361 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
362 goto badframe;
363 if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
364 goto badframe;
365 set_current_blocked(&set);
366 if (restore_sigregs32(regs, &frame->sregs))
367 goto badframe;
368 if (restore_sigregs_gprs_high(regs, frame->gprs_high))
369 goto badframe;
370 return regs->gprs[2];
371badframe:
372 force_sig(SIGSEGV, current);
373 return 0;
374}
375
376asmlinkage long sys32_rt_sigreturn(void)
377{
378 struct pt_regs *regs = task_pt_regs(current);
379 rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
380 sigset_t set;
381 stack_t st;
382 __u32 ss_sp;
383 int err;
384 mm_segment_t old_fs = get_fs();
385
386 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
387 goto badframe;
388 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
389 goto badframe;
390 set_current_blocked(&set);
391 if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
392 goto badframe;
393 if (restore_sigregs_gprs_high(regs, frame->gprs_high))
394 goto badframe;
395 err = __get_user(ss_sp, &frame->uc.uc_stack.ss_sp);
396 st.ss_sp = compat_ptr(ss_sp);
397 err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size);
398 err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags);
399 if (err)
400 goto badframe;
401 set_fs (KERNEL_DS);
402 do_sigaltstack((stack_t __force __user *)&st, NULL, regs->gprs[15]);
403 set_fs (old_fs);
404 return regs->gprs[2];
405badframe:
406 force_sig(SIGSEGV, current);
407 return 0;
408}
409
410/*
411 * Set up a signal frame.
412 */
413
414
415/*
416 * Determine which stack to use..
417 */
418static inline void __user *
419get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
420{
421 unsigned long sp;
422
423 /* Default to using normal stack */
424 sp = (unsigned long) A(regs->gprs[15]);
425
426 /* Overflow on alternate signal stack gives SIGSEGV. */
427 if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
428 return (void __user *) -1UL;
429
430 /* This is the X/Open sanctioned signal stack switching. */
431 if (ka->sa.sa_flags & SA_ONSTACK) {
432 if (! sas_ss_flags(sp))
433 sp = current->sas_ss_sp + current->sas_ss_size;
434 }
435
436 return (void __user *)((sp - frame_size) & -8ul);
437}
438
439static inline int map_signal(int sig)
440{
441 if (current_thread_info()->exec_domain
442 && current_thread_info()->exec_domain->signal_invmap
443 && sig < 32)
444 return current_thread_info()->exec_domain->signal_invmap[sig];
445 else
446 return sig;
447}
448
449static int setup_frame32(int sig, struct k_sigaction *ka,
450 sigset_t *set, struct pt_regs * regs)
451{
452 sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
453 if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32)))
454 goto give_sigsegv;
455
456 if (frame == (void __user *) -1UL)
457 goto give_sigsegv;
458
459 if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
460 goto give_sigsegv;
461
462 if (save_sigregs32(regs, &frame->sregs))
463 goto give_sigsegv;
464 if (save_sigregs_gprs_high(regs, frame->gprs_high))
465 goto give_sigsegv;
466 if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs))
467 goto give_sigsegv;
468
469 /* Set up to return from userspace. If provided, use a stub
470 already in userspace. */
471 if (ka->sa.sa_flags & SA_RESTORER) {
472 regs->gprs[14] = (__u64) ka->sa.sa_restorer | PSW32_ADDR_AMODE;
473 } else {
474 regs->gprs[14] = (__u64) frame->retcode | PSW32_ADDR_AMODE;
475 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
476 (u16 __force __user *)(frame->retcode)))
477 goto give_sigsegv;
478 }
479
480 /* Set up backchain. */
481 if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
482 goto give_sigsegv;
483
484 /* Set up registers for signal handler */
485 regs->gprs[15] = (__force __u64) frame;
486 regs->psw.mask |= PSW_MASK_BA; /* force amode 31 */
487 regs->psw.addr = (__force __u64) ka->sa.sa_handler;
488
489 regs->gprs[2] = map_signal(sig);
490 regs->gprs[3] = (__force __u64) &frame->sc;
491
492 /* We forgot to include these in the sigcontext.
493 To avoid breaking binary compatibility, they are passed as args. */
494 if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
495 sig == SIGTRAP || sig == SIGFPE) {
496 /* set extra registers only for synchronous signals */
497 regs->gprs[4] = regs->int_code & 127;
498 regs->gprs[5] = regs->int_parm_long;
499 }
500
501 /* Place signal number on stack to allow backtrace from handler. */
502 if (__put_user(regs->gprs[2], (int __force __user *) &frame->signo))
503 goto give_sigsegv;
504 return 0;
505
506give_sigsegv:
507 force_sigsegv(sig, current);
508 return -EFAULT;
509}
510
511static int setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
512 sigset_t *set, struct pt_regs * regs)
513{
514 int err = 0;
515 rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
516 if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32)))
517 goto give_sigsegv;
518
519 if (frame == (void __user *) -1UL)
520 goto give_sigsegv;
521
522 if (copy_siginfo_to_user32(&frame->info, info))
523 goto give_sigsegv;
524
525 /* Create the ucontext. */
526 err |= __put_user(UC_EXTENDED, &frame->uc.uc_flags);
527 err |= __put_user(0, &frame->uc.uc_link);
528 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
529 err |= __put_user(sas_ss_flags(regs->gprs[15]),
530 &frame->uc.uc_stack.ss_flags);
531 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
532 err |= save_sigregs32(regs, &frame->uc.uc_mcontext);
533 err |= save_sigregs_gprs_high(regs, frame->gprs_high);
534 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
535 if (err)
536 goto give_sigsegv;
537
538 /* Set up to return from userspace. If provided, use a stub
539 already in userspace. */
540 if (ka->sa.sa_flags & SA_RESTORER) {
541 regs->gprs[14] = (__u64) ka->sa.sa_restorer | PSW32_ADDR_AMODE;
542 } else {
543 regs->gprs[14] = (__u64) frame->retcode | PSW32_ADDR_AMODE;
544 err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
545 (u16 __force __user *)(frame->retcode));
546 }
547
548 /* Set up backchain. */
549 if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame))
550 goto give_sigsegv;
551
552 /* Set up registers for signal handler */
553 regs->gprs[15] = (__force __u64) frame;
554 regs->psw.mask |= PSW_MASK_BA; /* force amode 31 */
555 regs->psw.addr = (__u64) ka->sa.sa_handler;
556
557 regs->gprs[2] = map_signal(sig);
558 regs->gprs[3] = (__force __u64) &frame->info;
559 regs->gprs[4] = (__force __u64) &frame->uc;
560 return 0;
561
562give_sigsegv:
563 force_sigsegv(sig, current);
564 return -EFAULT;
565}
566
567/*
568 * OK, we're invoking a handler
569 */
570
571void handle_signal32(unsigned long sig, struct k_sigaction *ka,
572 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
573{
574 int ret;
575
576 /* Set up the stack frame */
577 if (ka->sa.sa_flags & SA_SIGINFO)
578 ret = setup_rt_frame32(sig, ka, info, oldset, regs);
579 else
580 ret = setup_frame32(sig, ka, oldset, regs);
581 if (ret)
582 return;
583 signal_delivered(sig, info, ka, regs,
584 test_thread_flag(TIF_SINGLE_STEP));
585}
586