1 /* Signal support for 32-bit kernel builds 2 * 3 * Copyright (C) 2001 Matthew Wilcox <willy at parisc-linux.org> 4 * Copyright (C) 2006 Kyle McMartin <kyle at parisc-linux.org> 5 * 6 * Code was mostly borrowed from kernel/signal.c. 7 * See kernel/signal.c for additional Copyrights. 8 * 9 * 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. 14 * 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. 19 * 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 23 */ 24 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> 33 34 #include <asm/uaccess.h> 35 36 #include "signal32.h" 37 #include "sys32.h" 38 39 #define DEBUG_COMPAT_SIG 0 40 #define DEBUG_COMPAT_SIG_LEVEL 2 41 42 #if DEBUG_COMPAT_SIG 43 #define DBG(LEVEL, ...) \ 44 ((DEBUG_COMPAT_SIG_LEVEL >= LEVEL) \ 45 ? printk(__VA_ARGS__) : (void) 0) 46 #else 47 #define DBG(LEVEL, ...) 48 #endif 49 50 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 51 52 inline void 53 sigset_32to64(sigset_t *s64, compat_sigset_t *s32) 54 { 55 s64->sig[0] = s32->sig[0] | ((unsigned long)s32->sig[1] << 32); 56 } 57 58 inline void 59 sigset_64to32(compat_sigset_t *s32, sigset_t *s64) 60 { 61 s32->sig[0] = s64->sig[0] & 0xffffffffUL; 62 s32->sig[1] = (s64->sig[0] >> 32) & 0xffffffffUL; 63 } 64 65 static int 66 put_sigset32(compat_sigset_t __user *up, sigset_t *set, size_t sz) 67 { 68 compat_sigset_t s; 69 70 if (sz != sizeof *set) panic("put_sigset32()"); 71 sigset_64to32(&s, set); 72 73 return copy_to_user(up, &s, sizeof s); 74 } 75 76 static int 77 get_sigset32(compat_sigset_t __user *up, sigset_t *set, size_t sz) 78 { 79 compat_sigset_t s; 80 int r; 81 82 if (sz != sizeof *set) panic("put_sigset32()"); 83 84 if ((r = copy_from_user(&s, up, sz)) == 0) { 85 sigset_32to64(set, &s); 86 } 87 88 return r; 89 } 90 91 int sys32_rt_sigprocmask(int how, compat_sigset_t __user *set, compat_sigset_t __user *oset, 92 unsigned int sigsetsize) 93 { 94 sigset_t old_set, new_set; 95 int ret; 96 97 if (set && get_sigset32(set, &new_set, sigsetsize)) 98 return -EFAULT; 99 100 KERNEL_SYSCALL(ret, sys_rt_sigprocmask, how, set ? (sigset_t __user *)&new_set : NULL, 101 oset ? (sigset_t __user *)&old_set : NULL, sigsetsize); 102 103 if (!ret && oset && put_sigset32(oset, &old_set, sigsetsize)) 104 return -EFAULT; 105 106 return ret; 107 } 108 109 110 int sys32_rt_sigpending(compat_sigset_t __user *uset, unsigned int sigsetsize) 111 { 112 int ret; 113 sigset_t set; 114 115 KERNEL_SYSCALL(ret, sys_rt_sigpending, (sigset_t __user *)&set, sigsetsize); 116 117 if (!ret && put_sigset32(uset, &set, sigsetsize)) 118 return -EFAULT; 119 120 return ret; 121 } 122 123 long 124 sys32_rt_sigaction(int sig, const struct sigaction32 __user *act, struct sigaction32 __user *oact, 125 size_t sigsetsize) 126 { 127 struct k_sigaction32 new_sa32, old_sa32; 128 struct k_sigaction new_sa, old_sa; 129 int ret = -EINVAL; 130 131 if (act) { 132 if (copy_from_user(&new_sa32.sa, act, sizeof new_sa32.sa)) 133 return -EFAULT; 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); 137 } 138 139 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL); 140 141 if (!ret && oact) { 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)) 146 return -EFAULT; 147 } 148 return ret; 149 } 150 151 int 152 do_sigaltstack32 (const compat_stack_t __user *uss32, compat_stack_t __user *uoss32, unsigned long sp) 153 { 154 compat_stack_t ss32, oss32; 155 stack_t ss, oss; 156 stack_t *ssp = NULL, *ossp = NULL; 157 int ret; 158 159 if (uss32) { 160 if (copy_from_user(&ss32, uss32, sizeof ss32)) 161 return -EFAULT; 162 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; 166 167 ssp = &ss; 168 } 169 170 if (uoss32) 171 ossp = &oss; 172 173 KERNEL_SYSCALL(ret, do_sigaltstack, (const stack_t __user *)ssp, (stack_t __user *)ossp, sp); 174 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)) 180 return -EFAULT; 181 } 182 183 return ret; 184 } 185 186 long 187 restore_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf, 188 struct pt_regs *regs) 189 { 190 long err = 0; 191 compat_uint_t compat_reg; 192 compat_uint_t compat_regt; 193 int regn; 194 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); 208 } 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)); 212 213 /* Better safe than sorry, pass __get_user two things of 214 the same size and let gcc do the upward conversion to 215 64-bits */ 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); 223 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]); 233 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); 239 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]); 247 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]); 255 256 return err; 257 } 258 259 /* 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. 264 */ 265 long 266 setup_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf, 267 struct pt_regs *regs, int in_syscall) 268 { 269 compat_int_t flags = 0; 270 long err = 0; 271 compat_uint_t compat_reg; 272 compat_uint_t compat_regb; 273 int regn; 274 275 if (on_sig_stack((unsigned long) sc)) 276 flags |= PARISC_SC_FLAG_ONSTACK; 277 278 if (in_syscall) { 279 280 DBG(1,"setup_sigcontext32: in_syscall\n"); 281 282 flags |= PARISC_SC_FLAG_IN_SYSCALL; 283 /* Truncate gr31 */ 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); 289 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); 294 295 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); 304 305 /* Truncate sr3 */ 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]); 309 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]); 314 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); 319 320 } else { 321 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); 330 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); 339 340 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); 349 350 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); 359 360 /* Print out the IAOQ for debugging */ 361 DBG(1,"setup_sigcontext32: ia0q %#lx / %#lx\n", 362 regs->iaoq[0], regs->iaoq[1]); 363 } 364 365 err |= __put_user(flags, &sc->sc_flags); 366 367 DBG(1,"setup_sigcontext32: Truncating general registers.\n"); 368 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]); 376 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); 380 } 381 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)); 388 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]); 397 398 return err; 399 } 400 401 int 402 copy_siginfo_from_user32 (siginfo_t *to, compat_siginfo_t __user *from) 403 { 404 compat_uptr_t addr; 405 int err; 406 407 if (!access_ok(VERIFY_READ, from, sizeof(compat_siginfo_t))) 408 return -EFAULT; 409 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); 413 414 if (to->si_code < 0) 415 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE); 416 else { 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); 422 default: 423 err |= __get_user(to->si_pid, &from->si_pid); 424 err |= __get_user(to->si_uid, &from->si_uid); 425 break; 426 case __SI_FAULT >> 16: 427 err |= __get_user(addr, &from->si_addr); 428 to->si_addr = compat_ptr(addr); 429 break; 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); 433 break; 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); 439 break; 440 } 441 } 442 return err; 443 } 444 445 int 446 copy_siginfo_to_user32 (compat_siginfo_t __user *to, siginfo_t *from) 447 { 448 compat_uptr_t addr; 449 compat_int_t val; 450 int err; 451 452 if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t))) 453 return -EFAULT; 454 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 461 at the same time. */ 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); 467 else { 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); 473 default: 474 err |= __put_user(from->si_pid, &to->si_pid); 475 err |= __put_user(from->si_uid, &to->si_uid); 476 break; 477 case __SI_FAULT >> 16: 478 addr = ptr_to_compat(from->si_addr); 479 err |= __put_user(addr, &to->si_addr); 480 break; 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); 484 break; 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); 490 break; 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); 497 break; 498 } 499 } 500 return err; 501 } 502 503 asmlinkage long compat_sys_rt_sigqueueinfo(int pid, int sig, 504 struct compat_siginfo __user *uinfo) 505 { 506 siginfo_t info; 507 508 if (copy_siginfo_from_user32(&info, uinfo)) 509 return -EFAULT; 510 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) 514 return -EPERM; 515 info.si_signo = sig; 516 517 /* POSIX.1b doesn't mention process groups. */ 518 return kill_proc_info(sig, &info, pid); 519 } 520 521