1 /* Signal support for 32-bit kernel builds
3 * Copyright (C) 2001 Matthew Wilcox <willy at parisc-linux.org>
4 * Copyright (C) 2006 Kyle McMartin <kyle at parisc-linux.org>
6 * Code was mostly borrowed from kernel/signal.c.
7 * See kernel/signal.c for additional Copyrights.
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #include <linux/compat.h>
26 #include <linux/module.h>
27 #include <linux/unistd.h>
28 #include <linux/init.h>
29 #include <linux/sched.h>
30 #include <linux/syscalls.h>
31 #include <linux/types.h>
32 #include <linux/errno.h>
34 #include <asm/uaccess.h>
39 #define DEBUG_COMPAT_SIG 0
40 #define DEBUG_COMPAT_SIG_LEVEL 2
43 #define DBG(LEVEL, ...) \
44 ((DEBUG_COMPAT_SIG_LEVEL >= LEVEL) \
45 ? printk(__VA_ARGS__) : (void) 0)
47 #define DBG(LEVEL, ...)
51 sigset_32to64(sigset_t
*s64
, compat_sigset_t
*s32
)
53 s64
->sig
[0] = s32
->sig
[0] | ((unsigned long)s32
->sig
[1] << 32);
57 sigset_64to32(compat_sigset_t
*s32
, sigset_t
*s64
)
59 s32
->sig
[0] = s64
->sig
[0] & 0xffffffffUL
;
60 s32
->sig
[1] = (s64
->sig
[0] >> 32) & 0xffffffffUL
;
64 put_sigset32(compat_sigset_t __user
*up
, sigset_t
*set
, size_t sz
)
68 if (sz
!= sizeof *set
)
70 sigset_64to32(&s
, set
);
72 return copy_to_user(up
, &s
, sizeof s
);
76 get_sigset32(compat_sigset_t __user
*up
, sigset_t
*set
, size_t sz
)
81 if (sz
!= sizeof *set
)
84 if ((r
= copy_from_user(&s
, up
, sz
)) == 0) {
85 sigset_32to64(set
, &s
);
91 int sys32_rt_sigprocmask(int how
, compat_sigset_t __user
*set
, compat_sigset_t __user
*oset
,
92 unsigned int sigsetsize
)
94 sigset_t old_set
, new_set
;
97 if (set
&& get_sigset32(set
, &new_set
, sigsetsize
))
100 KERNEL_SYSCALL(ret
, sys_rt_sigprocmask
, how
, set
? (sigset_t __user
*)&new_set
: NULL
,
101 oset
? (sigset_t __user
*)&old_set
: NULL
, sigsetsize
);
103 if (!ret
&& oset
&& put_sigset32(oset
, &old_set
, sigsetsize
))
110 int sys32_rt_sigpending(compat_sigset_t __user
*uset
, unsigned int sigsetsize
)
115 KERNEL_SYSCALL(ret
, sys_rt_sigpending
, (sigset_t __user
*)&set
, sigsetsize
);
117 if (!ret
&& put_sigset32(uset
, &set
, sigsetsize
))
124 sys32_rt_sigaction(int sig
, const struct sigaction32 __user
*act
, struct sigaction32 __user
*oact
,
127 struct k_sigaction32 new_sa32
, old_sa32
;
128 struct k_sigaction new_sa
, old_sa
;
132 if (copy_from_user(&new_sa32
.sa
, act
, sizeof new_sa32
.sa
))
134 new_sa
.sa
.sa_handler
= (__sighandler_t
)(unsigned long)new_sa32
.sa
.sa_handler
;
135 new_sa
.sa
.sa_flags
= new_sa32
.sa
.sa_flags
;
136 sigset_32to64(&new_sa
.sa
.sa_mask
, &new_sa32
.sa
.sa_mask
);
139 ret
= do_sigaction(sig
, act
? &new_sa
: NULL
, oact
? &old_sa
: NULL
);
142 sigset_64to32(&old_sa32
.sa
.sa_mask
, &old_sa
.sa
.sa_mask
);
143 old_sa32
.sa
.sa_flags
= old_sa
.sa
.sa_flags
;
144 old_sa32
.sa
.sa_handler
= (__sighandler_t32
)(unsigned long)old_sa
.sa
.sa_handler
;
145 if (copy_to_user(oact
, &old_sa32
.sa
, sizeof old_sa32
.sa
))
152 do_sigaltstack32 (const compat_stack_t __user
*uss32
, compat_stack_t __user
*uoss32
, unsigned long sp
)
154 compat_stack_t ss32
, oss32
;
156 stack_t
*ssp
= NULL
, *ossp
= NULL
;
160 if (copy_from_user(&ss32
, uss32
, sizeof ss32
))
163 ss
.ss_sp
= (void __user
*)(unsigned long)ss32
.ss_sp
;
164 ss
.ss_flags
= ss32
.ss_flags
;
165 ss
.ss_size
= ss32
.ss_size
;
173 KERNEL_SYSCALL(ret
, do_sigaltstack
, (const stack_t __user
*)ssp
, (stack_t __user
*)ossp
, sp
);
175 if (!ret
&& uoss32
) {
176 oss32
.ss_sp
= (unsigned int)(unsigned long)oss
.ss_sp
;
177 oss32
.ss_flags
= oss
.ss_flags
;
178 oss32
.ss_size
= oss
.ss_size
;
179 if (copy_to_user(uoss32
, &oss32
, sizeof *uoss32
))
187 restore_sigcontext32(struct compat_sigcontext __user
*sc
, struct compat_regfile __user
* rf
,
188 struct pt_regs
*regs
)
191 compat_uint_t compat_reg
;
192 compat_uint_t compat_regt
;
195 /* When loading 32-bit values into 64-bit registers make
196 sure to clear the upper 32-bits */
197 DBG(2,"restore_sigcontext32: PER_LINUX32 process\n");
198 DBG(2,"restore_sigcontext32: sc = 0x%p, rf = 0x%p, regs = 0x%p\n", sc
, rf
, regs
);
199 DBG(2,"restore_sigcontext32: compat_sigcontext is %#lx bytes\n", sizeof(*sc
));
200 for(regn
=0; regn
< 32; regn
++){
201 err
|= __get_user(compat_reg
,&sc
->sc_gr
[regn
]);
202 regs
->gr
[regn
] = compat_reg
;
203 /* Load upper half */
204 err
|= __get_user(compat_regt
,&rf
->rf_gr
[regn
]);
205 regs
->gr
[regn
] = ((u64
)compat_regt
<< 32) | (u64
)compat_reg
;
206 DBG(3,"restore_sigcontext32: gr%02d = %#lx (%#x / %#x)\n",
207 regn
, regs
->gr
[regn
], compat_regt
, compat_reg
);
209 DBG(2,"restore_sigcontext32: sc->sc_fr = 0x%p (%#lx)\n",sc
->sc_fr
, sizeof(sc
->sc_fr
));
210 /* XXX: BE WARNED FR's are 64-BIT! */
211 err
|= __copy_from_user(regs
->fr
, sc
->sc_fr
, sizeof(regs
->fr
));
213 /* Better safe than sorry, pass __get_user two things of
214 the same size and let gcc do the upward conversion to
216 err
|= __get_user(compat_reg
, &sc
->sc_iaoq
[0]);
217 /* Load upper half */
218 err
|= __get_user(compat_regt
, &rf
->rf_iaoq
[0]);
219 regs
->iaoq
[0] = ((u64
)compat_regt
<< 32) | (u64
)compat_reg
;
220 DBG(2,"restore_sigcontext32: upper half of iaoq[0] = %#lx\n", compat_regt
);
221 DBG(2,"restore_sigcontext32: sc->sc_iaoq[0] = %p => %#x\n",
222 &sc
->sc_iaoq
[0], compat_reg
);
224 err
|= __get_user(compat_reg
, &sc
->sc_iaoq
[1]);
225 /* Load upper half */
226 err
|= __get_user(compat_regt
, &rf
->rf_iaoq
[1]);
227 regs
->iaoq
[1] = ((u64
)compat_regt
<< 32) | (u64
)compat_reg
;
228 DBG(2,"restore_sigcontext32: upper half of iaoq[1] = %#lx\n", compat_regt
);
229 DBG(2,"restore_sigcontext32: sc->sc_iaoq[1] = %p => %#x\n",
230 &sc
->sc_iaoq
[1],compat_reg
);
231 DBG(2,"restore_sigcontext32: iaoq is %#lx / %#lx\n",
232 regs
->iaoq
[0],regs
->iaoq
[1]);
234 err
|= __get_user(compat_reg
, &sc
->sc_iasq
[0]);
235 /* Load the upper half for iasq */
236 err
|= __get_user(compat_regt
, &rf
->rf_iasq
[0]);
237 regs
->iasq
[0] = ((u64
)compat_regt
<< 32) | (u64
)compat_reg
;
238 DBG(2,"restore_sigcontext32: upper half of iasq[0] = %#lx\n", compat_regt
);
240 err
|= __get_user(compat_reg
, &sc
->sc_iasq
[1]);
241 /* Load the upper half for iasq */
242 err
|= __get_user(compat_regt
, &rf
->rf_iasq
[1]);
243 regs
->iasq
[1] = ((u64
)compat_regt
<< 32) | (u64
)compat_reg
;
244 DBG(2,"restore_sigcontext32: upper half of iasq[1] = %#lx\n", compat_regt
);
245 DBG(2,"restore_sigcontext32: iasq is %#lx / %#lx\n",
246 regs
->iasq
[0],regs
->iasq
[1]);
248 err
|= __get_user(compat_reg
, &sc
->sc_sar
);
249 /* Load the upper half for sar */
250 err
|= __get_user(compat_regt
, &rf
->rf_sar
);
251 regs
->sar
= ((u64
)compat_regt
<< 32) | (u64
)compat_reg
;
252 DBG(2,"restore_sigcontext32: upper_half & sar = %#lx\n", compat_regt
);
253 DBG(2,"restore_sigcontext32: sar is %#lx\n", regs
->sar
);
254 DBG(2,"restore_sigcontext32: r28 is %ld\n", regs
->gr
[28]);
260 * Set up the sigcontext structure for this process.
261 * This is not an easy task if the kernel is 64-bit, it will require
262 * that we examine the process personality to determine if we need to
263 * truncate for a 32-bit userspace.
266 setup_sigcontext32(struct compat_sigcontext __user
*sc
, struct compat_regfile __user
* rf
,
267 struct pt_regs
*regs
, int in_syscall
)
269 compat_int_t flags
= 0;
271 compat_uint_t compat_reg
;
272 compat_uint_t compat_regb
;
275 if (on_sig_stack((unsigned long) sc
))
276 flags
|= PARISC_SC_FLAG_ONSTACK
;
280 DBG(1,"setup_sigcontext32: in_syscall\n");
282 flags
|= PARISC_SC_FLAG_IN_SYSCALL
;
284 compat_reg
= (compat_uint_t
)(regs
->gr
[31]);
285 /* regs->iaoq is undefined in the syscall return path */
286 err
|= __put_user(compat_reg
, &sc
->sc_iaoq
[0]);
287 DBG(2,"setup_sigcontext32: sc->sc_iaoq[0] = %p <= %#x\n",
288 &sc
->sc_iaoq
[0], compat_reg
);
290 /* Store upper half */
291 compat_reg
= (compat_uint_t
)(regs
->gr
[31] >> 32);
292 err
|= __put_user(compat_reg
, &rf
->rf_iaoq
[0]);
293 DBG(2,"setup_sigcontext32: upper half iaoq[0] = %#x\n", compat_reg
);
296 compat_reg
= (compat_uint_t
)(regs
->gr
[31]+4);
297 err
|= __put_user(compat_reg
, &sc
->sc_iaoq
[1]);
298 DBG(2,"setup_sigcontext32: sc->sc_iaoq[1] = %p <= %#x\n",
299 &sc
->sc_iaoq
[1], compat_reg
);
300 /* Store upper half */
301 compat_reg
= (compat_uint_t
)((regs
->gr
[31]+4) >> 32);
302 err
|= __put_user(compat_reg
, &rf
->rf_iaoq
[1]);
303 DBG(2,"setup_sigcontext32: upper half iaoq[1] = %#x\n", compat_reg
);
306 compat_reg
= (compat_uint_t
)(regs
->sr
[3]);
307 err
|= __put_user(compat_reg
, &sc
->sc_iasq
[0]);
308 err
|= __put_user(compat_reg
, &sc
->sc_iasq
[1]);
310 /* Store upper half */
311 compat_reg
= (compat_uint_t
)(regs
->sr
[3] >> 32);
312 err
|= __put_user(compat_reg
, &rf
->rf_iasq
[0]);
313 err
|= __put_user(compat_reg
, &rf
->rf_iasq
[1]);
315 DBG(2,"setup_sigcontext32: upper half iasq[0] = %#x\n", compat_reg
);
316 DBG(2,"setup_sigcontext32: upper half iasq[1] = %#x\n", compat_reg
);
317 DBG(1,"setup_sigcontext32: iaoq %#lx / %#lx\n",
318 regs
->gr
[31], regs
->gr
[31]+4);
322 compat_reg
= (compat_uint_t
)(regs
->iaoq
[0]);
323 err
|= __put_user(compat_reg
, &sc
->sc_iaoq
[0]);
324 DBG(2,"setup_sigcontext32: sc->sc_iaoq[0] = %p <= %#x\n",
325 &sc
->sc_iaoq
[0], compat_reg
);
326 /* Store upper half */
327 compat_reg
= (compat_uint_t
)(regs
->iaoq
[0] >> 32);
328 err
|= __put_user(compat_reg
, &rf
->rf_iaoq
[0]);
329 DBG(2,"setup_sigcontext32: upper half iaoq[0] = %#x\n", compat_reg
);
331 compat_reg
= (compat_uint_t
)(regs
->iaoq
[1]);
332 err
|= __put_user(compat_reg
, &sc
->sc_iaoq
[1]);
333 DBG(2,"setup_sigcontext32: sc->sc_iaoq[1] = %p <= %#x\n",
334 &sc
->sc_iaoq
[1], compat_reg
);
335 /* Store upper half */
336 compat_reg
= (compat_uint_t
)(regs
->iaoq
[1] >> 32);
337 err
|= __put_user(compat_reg
, &rf
->rf_iaoq
[1]);
338 DBG(2,"setup_sigcontext32: upper half iaoq[1] = %#x\n", compat_reg
);
341 compat_reg
= (compat_uint_t
)(regs
->iasq
[0]);
342 err
|= __put_user(compat_reg
, &sc
->sc_iasq
[0]);
343 DBG(2,"setup_sigcontext32: sc->sc_iasq[0] = %p <= %#x\n",
344 &sc
->sc_iasq
[0], compat_reg
);
345 /* Store upper half */
346 compat_reg
= (compat_uint_t
)(regs
->iasq
[0] >> 32);
347 err
|= __put_user(compat_reg
, &rf
->rf_iasq
[0]);
348 DBG(2,"setup_sigcontext32: upper half iasq[0] = %#x\n", compat_reg
);
351 compat_reg
= (compat_uint_t
)(regs
->iasq
[1]);
352 err
|= __put_user(compat_reg
, &sc
->sc_iasq
[1]);
353 DBG(2,"setup_sigcontext32: sc->sc_iasq[1] = %p <= %#x\n",
354 &sc
->sc_iasq
[1], compat_reg
);
355 /* Store upper half */
356 compat_reg
= (compat_uint_t
)(regs
->iasq
[1] >> 32);
357 err
|= __put_user(compat_reg
, &rf
->rf_iasq
[1]);
358 DBG(2,"setup_sigcontext32: upper half iasq[1] = %#x\n", compat_reg
);
360 /* Print out the IAOQ for debugging */
361 DBG(1,"setup_sigcontext32: ia0q %#lx / %#lx\n",
362 regs
->iaoq
[0], regs
->iaoq
[1]);
365 err
|= __put_user(flags
, &sc
->sc_flags
);
367 DBG(1,"setup_sigcontext32: Truncating general registers.\n");
369 for(regn
=0; regn
< 32; regn
++){
370 /* Truncate a general register */
371 compat_reg
= (compat_uint_t
)(regs
->gr
[regn
]);
372 err
|= __put_user(compat_reg
, &sc
->sc_gr
[regn
]);
373 /* Store upper half */
374 compat_regb
= (compat_uint_t
)(regs
->gr
[regn
] >> 32);
375 err
|= __put_user(compat_regb
, &rf
->rf_gr
[regn
]);
377 /* DEBUG: Write out the "upper / lower" register data */
378 DBG(2,"setup_sigcontext32: gr%02d = %#x / %#x\n", regn
,
379 compat_regb
, compat_reg
);
382 /* Copy the floating point registers (same size)
383 XXX: BE WARNED FR's are 64-BIT! */
384 DBG(1,"setup_sigcontext32: Copying from regs to sc, "
385 "sc->sc_fr size = %#lx, regs->fr size = %#lx\n",
386 sizeof(regs
->fr
), sizeof(sc
->sc_fr
));
387 err
|= __copy_to_user(sc
->sc_fr
, regs
->fr
, sizeof(regs
->fr
));
389 compat_reg
= (compat_uint_t
)(regs
->sar
);
390 err
|= __put_user(compat_reg
, &sc
->sc_sar
);
391 DBG(2,"setup_sigcontext32: sar is %#x\n", compat_reg
);
392 /* Store upper half */
393 compat_reg
= (compat_uint_t
)(regs
->sar
>> 32);
394 err
|= __put_user(compat_reg
, &rf
->rf_sar
);
395 DBG(2,"setup_sigcontext32: upper half sar = %#x\n", compat_reg
);
396 DBG(1,"setup_sigcontext32: r28 is %ld\n", regs
->gr
[28]);
402 copy_siginfo_from_user32 (siginfo_t
*to
, compat_siginfo_t __user
*from
)
407 if (!access_ok(VERIFY_READ
, from
, sizeof(compat_siginfo_t
)))
410 err
= __get_user(to
->si_signo
, &from
->si_signo
);
411 err
|= __get_user(to
->si_errno
, &from
->si_errno
);
412 err
|= __get_user(to
->si_code
, &from
->si_code
);
415 err
|= __copy_from_user(&to
->_sifields
._pad
, &from
->_sifields
._pad
, SI_PAD_SIZE
);
417 switch (to
->si_code
>> 16) {
418 case __SI_CHLD
>> 16:
419 err
|= __get_user(to
->si_utime
, &from
->si_utime
);
420 err
|= __get_user(to
->si_stime
, &from
->si_stime
);
421 err
|= __get_user(to
->si_status
, &from
->si_status
);
423 err
|= __get_user(to
->si_pid
, &from
->si_pid
);
424 err
|= __get_user(to
->si_uid
, &from
->si_uid
);
426 case __SI_FAULT
>> 16:
427 err
|= __get_user(addr
, &from
->si_addr
);
428 to
->si_addr
= compat_ptr(addr
);
430 case __SI_POLL
>> 16:
431 err
|= __get_user(to
->si_band
, &from
->si_band
);
432 err
|= __get_user(to
->si_fd
, &from
->si_fd
);
434 case __SI_RT
>> 16: /* This is not generated by the kernel as of now. */
435 case __SI_MESGQ
>> 16:
436 err
|= __get_user(to
->si_pid
, &from
->si_pid
);
437 err
|= __get_user(to
->si_uid
, &from
->si_uid
);
438 err
|= __get_user(to
->si_int
, &from
->si_int
);
446 copy_siginfo_to_user32 (compat_siginfo_t __user
*to
, siginfo_t
*from
)
452 if (!access_ok(VERIFY_WRITE
, to
, sizeof(compat_siginfo_t
)))
455 /* If you change siginfo_t structure, please be sure
456 this code is fixed accordingly.
457 It should never copy any pad contained in the structure
458 to avoid security leaks, but must copy the generic
459 3 ints plus the relevant union member.
460 This routine must convert siginfo from 64bit to 32bit as well
462 err
= __put_user(from
->si_signo
, &to
->si_signo
);
463 err
|= __put_user(from
->si_errno
, &to
->si_errno
);
464 err
|= __put_user((short)from
->si_code
, &to
->si_code
);
465 if (from
->si_code
< 0)
466 err
|= __copy_to_user(&to
->_sifields
._pad
, &from
->_sifields
._pad
, SI_PAD_SIZE
);
468 switch (from
->si_code
>> 16) {
469 case __SI_CHLD
>> 16:
470 err
|= __put_user(from
->si_utime
, &to
->si_utime
);
471 err
|= __put_user(from
->si_stime
, &to
->si_stime
);
472 err
|= __put_user(from
->si_status
, &to
->si_status
);
474 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
475 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
477 case __SI_FAULT
>> 16:
478 addr
= ptr_to_compat(from
->si_addr
);
479 err
|= __put_user(addr
, &to
->si_addr
);
481 case __SI_POLL
>> 16:
482 err
|= __put_user(from
->si_band
, &to
->si_band
);
483 err
|= __put_user(from
->si_fd
, &to
->si_fd
);
485 case __SI_TIMER
>> 16:
486 err
|= __put_user(from
->si_tid
, &to
->si_tid
);
487 err
|= __put_user(from
->si_overrun
, &to
->si_overrun
);
488 val
= (compat_int_t
)from
->si_int
;
489 err
|= __put_user(val
, &to
->si_int
);
491 case __SI_RT
>> 16: /* Not generated by the kernel as of now. */
492 case __SI_MESGQ
>> 16:
493 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
494 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
495 val
= (compat_int_t
)from
->si_int
;
496 err
|= __put_user(val
, &to
->si_int
);
503 asmlinkage
long compat_sys_rt_sigqueueinfo(int pid
, int sig
,
504 struct compat_siginfo __user
*uinfo
)
508 if (copy_siginfo_from_user32(&info
, uinfo
))
511 /* Not even root can pretend to send signals from the kernel.
512 Nor can they impersonate a kill(), which adds source info. */
513 if (info
.si_code
>= 0)
517 /* POSIX.1b doesn't mention process groups. */
518 return kill_proc_info(sig
, &info
, pid
);