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 inline void 51 sigset_32to64(sigset_t *s64, compat_sigset_t *s32) 52 { 53 s64->sig[0] = s32->sig[0] | ((unsigned long)s32->sig[1] << 32); 54 } 55 56 inline void 57 sigset_64to32(compat_sigset_t *s32, sigset_t *s64) 58 { 59 s32->sig[0] = s64->sig[0] & 0xffffffffUL; 60 s32->sig[1] = (s64->sig[0] >> 32) & 0xffffffffUL; 61 } 62 63 static int 64 put_sigset32(compat_sigset_t __user *up, sigset_t *set, size_t sz) 65 { 66 compat_sigset_t s; 67 68 if (sz != sizeof *set) panic("put_sigset32()"); 69 sigset_64to32(&s, set); 70 71 return copy_to_user(up, &s, sizeof s); 72 } 73 74 static int 75 get_sigset32(compat_sigset_t __user *up, sigset_t *set, size_t sz) 76 { 77 compat_sigset_t s; 78 int r; 79 80 if (sz != sizeof *set) panic("put_sigset32()"); 81 82 if ((r = copy_from_user(&s, up, sz)) == 0) { 83 sigset_32to64(set, &s); 84 } 85 86 return r; 87 } 88 89 int sys32_rt_sigprocmask(int how, compat_sigset_t __user *set, compat_sigset_t __user *oset, 90 unsigned int sigsetsize) 91 { 92 sigset_t old_set, new_set; 93 int ret; 94 95 if (set && get_sigset32(set, &new_set, sigsetsize)) 96 return -EFAULT; 97 98 KERNEL_SYSCALL(ret, sys_rt_sigprocmask, how, set ? (sigset_t __user *)&new_set : NULL, 99 oset ? (sigset_t __user *)&old_set : NULL, sigsetsize); 100 101 if (!ret && oset && put_sigset32(oset, &old_set, sigsetsize)) 102 return -EFAULT; 103 104 return ret; 105 } 106 107 108 int sys32_rt_sigpending(compat_sigset_t __user *uset, unsigned int sigsetsize) 109 { 110 int ret; 111 sigset_t set; 112 113 KERNEL_SYSCALL(ret, sys_rt_sigpending, (sigset_t __user *)&set, sigsetsize); 114 115 if (!ret && put_sigset32(uset, &set, sigsetsize)) 116 return -EFAULT; 117 118 return ret; 119 } 120 121 long 122 sys32_rt_sigaction(int sig, const struct sigaction32 __user *act, struct sigaction32 __user *oact, 123 size_t sigsetsize) 124 { 125 struct k_sigaction32 new_sa32, old_sa32; 126 struct k_sigaction new_sa, old_sa; 127 int ret = -EINVAL; 128 129 if (act) { 130 if (copy_from_user(&new_sa32.sa, act, sizeof new_sa32.sa)) 131 return -EFAULT; 132 new_sa.sa.sa_handler = (__sighandler_t)(unsigned long)new_sa32.sa.sa_handler; 133 new_sa.sa.sa_flags = new_sa32.sa.sa_flags; 134 sigset_32to64(&new_sa.sa.sa_mask, &new_sa32.sa.sa_mask); 135 } 136 137 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL); 138 139 if (!ret && oact) { 140 sigset_64to32(&old_sa32.sa.sa_mask, &old_sa.sa.sa_mask); 141 old_sa32.sa.sa_flags = old_sa.sa.sa_flags; 142 old_sa32.sa.sa_handler = (__sighandler_t32)(unsigned long)old_sa.sa.sa_handler; 143 if (copy_to_user(oact, &old_sa32.sa, sizeof old_sa32.sa)) 144 return -EFAULT; 145 } 146 return ret; 147 } 148 149 int 150 do_sigaltstack32 (const compat_stack_t __user *uss32, compat_stack_t __user *uoss32, unsigned long sp) 151 { 152 compat_stack_t ss32, oss32; 153 stack_t ss, oss; 154 stack_t *ssp = NULL, *ossp = NULL; 155 int ret; 156 157 if (uss32) { 158 if (copy_from_user(&ss32, uss32, sizeof ss32)) 159 return -EFAULT; 160 161 ss.ss_sp = (void __user *)(unsigned long)ss32.ss_sp; 162 ss.ss_flags = ss32.ss_flags; 163 ss.ss_size = ss32.ss_size; 164 165 ssp = &ss; 166 } 167 168 if (uoss32) 169 ossp = &oss; 170 171 KERNEL_SYSCALL(ret, do_sigaltstack, (const stack_t __user *)ssp, (stack_t __user *)ossp, sp); 172 173 if (!ret && uoss32) { 174 oss32.ss_sp = (unsigned int)(unsigned long)oss.ss_sp; 175 oss32.ss_flags = oss.ss_flags; 176 oss32.ss_size = oss.ss_size; 177 if (copy_to_user(uoss32, &oss32, sizeof *uoss32)) 178 return -EFAULT; 179 } 180 181 return ret; 182 } 183 184 long 185 restore_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf, 186 struct pt_regs *regs) 187 { 188 long err = 0; 189 compat_uint_t compat_reg; 190 compat_uint_t compat_regt; 191 int regn; 192 193 /* When loading 32-bit values into 64-bit registers make 194 sure to clear the upper 32-bits */ 195 DBG(2,"restore_sigcontext32: PER_LINUX32 process\n"); 196 DBG(2,"restore_sigcontext32: sc = 0x%p, rf = 0x%p, regs = 0x%p\n", sc, rf, regs); 197 DBG(2,"restore_sigcontext32: compat_sigcontext is %#lx bytes\n", sizeof(*sc)); 198 for(regn=0; regn < 32; regn++){ 199 err |= __get_user(compat_reg,&sc->sc_gr[regn]); 200 regs->gr[regn] = compat_reg; 201 /* Load upper half */ 202 err |= __get_user(compat_regt,&rf->rf_gr[regn]); 203 regs->gr[regn] = ((u64)compat_regt << 32) | (u64)compat_reg; 204 DBG(3,"restore_sigcontext32: gr%02d = %#lx (%#x / %#x)\n", 205 regn, regs->gr[regn], compat_regt, compat_reg); 206 } 207 DBG(2,"restore_sigcontext32: sc->sc_fr = 0x%p (%#lx)\n",sc->sc_fr, sizeof(sc->sc_fr)); 208 /* XXX: BE WARNED FR's are 64-BIT! */ 209 err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr)); 210 211 /* Better safe than sorry, pass __get_user two things of 212 the same size and let gcc do the upward conversion to 213 64-bits */ 214 err |= __get_user(compat_reg, &sc->sc_iaoq[0]); 215 /* Load upper half */ 216 err |= __get_user(compat_regt, &rf->rf_iaoq[0]); 217 regs->iaoq[0] = ((u64)compat_regt << 32) | (u64)compat_reg; 218 DBG(2,"restore_sigcontext32: upper half of iaoq[0] = %#lx\n", compat_regt); 219 DBG(2,"restore_sigcontext32: sc->sc_iaoq[0] = %p => %#x\n", 220 &sc->sc_iaoq[0], compat_reg); 221 222 err |= __get_user(compat_reg, &sc->sc_iaoq[1]); 223 /* Load upper half */ 224 err |= __get_user(compat_regt, &rf->rf_iaoq[1]); 225 regs->iaoq[1] = ((u64)compat_regt << 32) | (u64)compat_reg; 226 DBG(2,"restore_sigcontext32: upper half of iaoq[1] = %#lx\n", compat_regt); 227 DBG(2,"restore_sigcontext32: sc->sc_iaoq[1] = %p => %#x\n", 228 &sc->sc_iaoq[1],compat_reg); 229 DBG(2,"restore_sigcontext32: iaoq is %#lx / %#lx\n", 230 regs->iaoq[0],regs->iaoq[1]); 231 232 err |= __get_user(compat_reg, &sc->sc_iasq[0]); 233 /* Load the upper half for iasq */ 234 err |= __get_user(compat_regt, &rf->rf_iasq[0]); 235 regs->iasq[0] = ((u64)compat_regt << 32) | (u64)compat_reg; 236 DBG(2,"restore_sigcontext32: upper half of iasq[0] = %#lx\n", compat_regt); 237 238 err |= __get_user(compat_reg, &sc->sc_iasq[1]); 239 /* Load the upper half for iasq */ 240 err |= __get_user(compat_regt, &rf->rf_iasq[1]); 241 regs->iasq[1] = ((u64)compat_regt << 32) | (u64)compat_reg; 242 DBG(2,"restore_sigcontext32: upper half of iasq[1] = %#lx\n", compat_regt); 243 DBG(2,"restore_sigcontext32: iasq is %#lx / %#lx\n", 244 regs->iasq[0],regs->iasq[1]); 245 246 err |= __get_user(compat_reg, &sc->sc_sar); 247 /* Load the upper half for sar */ 248 err |= __get_user(compat_regt, &rf->rf_sar); 249 regs->sar = ((u64)compat_regt << 32) | (u64)compat_reg; 250 DBG(2,"restore_sigcontext32: upper_half & sar = %#lx\n", compat_regt); 251 DBG(2,"restore_sigcontext32: sar is %#lx\n", regs->sar); 252 DBG(2,"restore_sigcontext32: r28 is %ld\n", regs->gr[28]); 253 254 return err; 255 } 256 257 /* 258 * Set up the sigcontext structure for this process. 259 * This is not an easy task if the kernel is 64-bit, it will require 260 * that we examine the process personality to determine if we need to 261 * truncate for a 32-bit userspace. 262 */ 263 long 264 setup_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf, 265 struct pt_regs *regs, int in_syscall) 266 { 267 compat_int_t flags = 0; 268 long err = 0; 269 compat_uint_t compat_reg; 270 compat_uint_t compat_regb; 271 int regn; 272 273 if (on_sig_stack((unsigned long) sc)) 274 flags |= PARISC_SC_FLAG_ONSTACK; 275 276 if (in_syscall) { 277 278 DBG(1,"setup_sigcontext32: in_syscall\n"); 279 280 flags |= PARISC_SC_FLAG_IN_SYSCALL; 281 /* Truncate gr31 */ 282 compat_reg = (compat_uint_t)(regs->gr[31]); 283 /* regs->iaoq is undefined in the syscall return path */ 284 err |= __put_user(compat_reg, &sc->sc_iaoq[0]); 285 DBG(2,"setup_sigcontext32: sc->sc_iaoq[0] = %p <= %#x\n", 286 &sc->sc_iaoq[0], compat_reg); 287 288 /* Store upper half */ 289 compat_reg = (compat_uint_t)(regs->gr[31] >> 32); 290 err |= __put_user(compat_reg, &rf->rf_iaoq[0]); 291 DBG(2,"setup_sigcontext32: upper half iaoq[0] = %#x\n", compat_reg); 292 293 294 compat_reg = (compat_uint_t)(regs->gr[31]+4); 295 err |= __put_user(compat_reg, &sc->sc_iaoq[1]); 296 DBG(2,"setup_sigcontext32: sc->sc_iaoq[1] = %p <= %#x\n", 297 &sc->sc_iaoq[1], compat_reg); 298 /* Store upper half */ 299 compat_reg = (compat_uint_t)((regs->gr[31]+4) >> 32); 300 err |= __put_user(compat_reg, &rf->rf_iaoq[1]); 301 DBG(2,"setup_sigcontext32: upper half iaoq[1] = %#x\n", compat_reg); 302 303 /* Truncate sr3 */ 304 compat_reg = (compat_uint_t)(regs->sr[3]); 305 err |= __put_user(compat_reg, &sc->sc_iasq[0]); 306 err |= __put_user(compat_reg, &sc->sc_iasq[1]); 307 308 /* Store upper half */ 309 compat_reg = (compat_uint_t)(regs->sr[3] >> 32); 310 err |= __put_user(compat_reg, &rf->rf_iasq[0]); 311 err |= __put_user(compat_reg, &rf->rf_iasq[1]); 312 313 DBG(2,"setup_sigcontext32: upper half iasq[0] = %#x\n", compat_reg); 314 DBG(2,"setup_sigcontext32: upper half iasq[1] = %#x\n", compat_reg); 315 DBG(1,"setup_sigcontext32: iaoq %#lx / %#lx\n", 316 regs->gr[31], regs->gr[31]+4); 317 318 } else { 319 320 compat_reg = (compat_uint_t)(regs->iaoq[0]); 321 err |= __put_user(compat_reg, &sc->sc_iaoq[0]); 322 DBG(2,"setup_sigcontext32: sc->sc_iaoq[0] = %p <= %#x\n", 323 &sc->sc_iaoq[0], compat_reg); 324 /* Store upper half */ 325 compat_reg = (compat_uint_t)(regs->iaoq[0] >> 32); 326 err |= __put_user(compat_reg, &rf->rf_iaoq[0]); 327 DBG(2,"setup_sigcontext32: upper half iaoq[0] = %#x\n", compat_reg); 328 329 compat_reg = (compat_uint_t)(regs->iaoq[1]); 330 err |= __put_user(compat_reg, &sc->sc_iaoq[1]); 331 DBG(2,"setup_sigcontext32: sc->sc_iaoq[1] = %p <= %#x\n", 332 &sc->sc_iaoq[1], compat_reg); 333 /* Store upper half */ 334 compat_reg = (compat_uint_t)(regs->iaoq[1] >> 32); 335 err |= __put_user(compat_reg, &rf->rf_iaoq[1]); 336 DBG(2,"setup_sigcontext32: upper half iaoq[1] = %#x\n", compat_reg); 337 338 339 compat_reg = (compat_uint_t)(regs->iasq[0]); 340 err |= __put_user(compat_reg, &sc->sc_iasq[0]); 341 DBG(2,"setup_sigcontext32: sc->sc_iasq[0] = %p <= %#x\n", 342 &sc->sc_iasq[0], compat_reg); 343 /* Store upper half */ 344 compat_reg = (compat_uint_t)(regs->iasq[0] >> 32); 345 err |= __put_user(compat_reg, &rf->rf_iasq[0]); 346 DBG(2,"setup_sigcontext32: upper half iasq[0] = %#x\n", compat_reg); 347 348 349 compat_reg = (compat_uint_t)(regs->iasq[1]); 350 err |= __put_user(compat_reg, &sc->sc_iasq[1]); 351 DBG(2,"setup_sigcontext32: sc->sc_iasq[1] = %p <= %#x\n", 352 &sc->sc_iasq[1], compat_reg); 353 /* Store upper half */ 354 compat_reg = (compat_uint_t)(regs->iasq[1] >> 32); 355 err |= __put_user(compat_reg, &rf->rf_iasq[1]); 356 DBG(2,"setup_sigcontext32: upper half iasq[1] = %#x\n", compat_reg); 357 358 /* Print out the IAOQ for debugging */ 359 DBG(1,"setup_sigcontext32: ia0q %#lx / %#lx\n", 360 regs->iaoq[0], regs->iaoq[1]); 361 } 362 363 err |= __put_user(flags, &sc->sc_flags); 364 365 DBG(1,"setup_sigcontext32: Truncating general registers.\n"); 366 367 for(regn=0; regn < 32; regn++){ 368 /* Truncate a general register */ 369 compat_reg = (compat_uint_t)(regs->gr[regn]); 370 err |= __put_user(compat_reg, &sc->sc_gr[regn]); 371 /* Store upper half */ 372 compat_regb = (compat_uint_t)(regs->gr[regn] >> 32); 373 err |= __put_user(compat_regb, &rf->rf_gr[regn]); 374 375 /* DEBUG: Write out the "upper / lower" register data */ 376 DBG(2,"setup_sigcontext32: gr%02d = %#x / %#x\n", regn, 377 compat_regb, compat_reg); 378 } 379 380 /* Copy the floating point registers (same size) 381 XXX: BE WARNED FR's are 64-BIT! */ 382 DBG(1,"setup_sigcontext32: Copying from regs to sc, " 383 "sc->sc_fr size = %#lx, regs->fr size = %#lx\n", 384 sizeof(regs->fr), sizeof(sc->sc_fr)); 385 err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr)); 386 387 compat_reg = (compat_uint_t)(regs->sar); 388 err |= __put_user(compat_reg, &sc->sc_sar); 389 DBG(2,"setup_sigcontext32: sar is %#x\n", compat_reg); 390 /* Store upper half */ 391 compat_reg = (compat_uint_t)(regs->sar >> 32); 392 err |= __put_user(compat_reg, &rf->rf_sar); 393 DBG(2,"setup_sigcontext32: upper half sar = %#x\n", compat_reg); 394 DBG(1,"setup_sigcontext32: r28 is %ld\n", regs->gr[28]); 395 396 return err; 397 } 398 399 int 400 copy_siginfo_from_user32 (siginfo_t *to, compat_siginfo_t __user *from) 401 { 402 compat_uptr_t addr; 403 int err; 404 405 if (!access_ok(VERIFY_READ, from, sizeof(compat_siginfo_t))) 406 return -EFAULT; 407 408 err = __get_user(to->si_signo, &from->si_signo); 409 err |= __get_user(to->si_errno, &from->si_errno); 410 err |= __get_user(to->si_code, &from->si_code); 411 412 if (to->si_code < 0) 413 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE); 414 else { 415 switch (to->si_code >> 16) { 416 case __SI_CHLD >> 16: 417 err |= __get_user(to->si_utime, &from->si_utime); 418 err |= __get_user(to->si_stime, &from->si_stime); 419 err |= __get_user(to->si_status, &from->si_status); 420 default: 421 err |= __get_user(to->si_pid, &from->si_pid); 422 err |= __get_user(to->si_uid, &from->si_uid); 423 break; 424 case __SI_FAULT >> 16: 425 err |= __get_user(addr, &from->si_addr); 426 to->si_addr = compat_ptr(addr); 427 break; 428 case __SI_POLL >> 16: 429 err |= __get_user(to->si_band, &from->si_band); 430 err |= __get_user(to->si_fd, &from->si_fd); 431 break; 432 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */ 433 case __SI_MESGQ >> 16: 434 err |= __get_user(to->si_pid, &from->si_pid); 435 err |= __get_user(to->si_uid, &from->si_uid); 436 err |= __get_user(to->si_int, &from->si_int); 437 break; 438 } 439 } 440 return err; 441 } 442 443 int 444 copy_siginfo_to_user32 (compat_siginfo_t __user *to, siginfo_t *from) 445 { 446 compat_uptr_t addr; 447 compat_int_t val; 448 int err; 449 450 if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t))) 451 return -EFAULT; 452 453 /* If you change siginfo_t structure, please be sure 454 this code is fixed accordingly. 455 It should never copy any pad contained in the structure 456 to avoid security leaks, but must copy the generic 457 3 ints plus the relevant union member. 458 This routine must convert siginfo from 64bit to 32bit as well 459 at the same time. */ 460 err = __put_user(from->si_signo, &to->si_signo); 461 err |= __put_user(from->si_errno, &to->si_errno); 462 err |= __put_user((short)from->si_code, &to->si_code); 463 if (from->si_code < 0) 464 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE); 465 else { 466 switch (from->si_code >> 16) { 467 case __SI_CHLD >> 16: 468 err |= __put_user(from->si_utime, &to->si_utime); 469 err |= __put_user(from->si_stime, &to->si_stime); 470 err |= __put_user(from->si_status, &to->si_status); 471 default: 472 err |= __put_user(from->si_pid, &to->si_pid); 473 err |= __put_user(from->si_uid, &to->si_uid); 474 break; 475 case __SI_FAULT >> 16: 476 addr = ptr_to_compat(from->si_addr); 477 err |= __put_user(addr, &to->si_addr); 478 break; 479 case __SI_POLL >> 16: 480 err |= __put_user(from->si_band, &to->si_band); 481 err |= __put_user(from->si_fd, &to->si_fd); 482 break; 483 case __SI_TIMER >> 16: 484 err |= __put_user(from->si_tid, &to->si_tid); 485 err |= __put_user(from->si_overrun, &to->si_overrun); 486 val = (compat_int_t)from->si_int; 487 err |= __put_user(val, &to->si_int); 488 break; 489 case __SI_RT >> 16: /* Not generated by the kernel as of now. */ 490 case __SI_MESGQ >> 16: 491 err |= __put_user(from->si_uid, &to->si_uid); 492 err |= __put_user(from->si_pid, &to->si_pid); 493 val = (compat_int_t)from->si_int; 494 err |= __put_user(val, &to->si_int); 495 break; 496 } 497 } 498 return err; 499 } 500 501 asmlinkage long compat_sys_rt_sigqueueinfo(int pid, int sig, 502 struct compat_siginfo __user *uinfo) 503 { 504 siginfo_t info; 505 506 if (copy_siginfo_from_user32(&info, uinfo)) 507 return -EFAULT; 508 509 /* Not even root can pretend to send signals from the kernel. 510 Nor can they impersonate a kill(), which adds source info. */ 511 if (info.si_code >= 0) 512 return -EPERM; 513 info.si_signo = sig; 514 515 /* POSIX.1b doesn't mention process groups. */ 516 return kill_proc_info(sig, &info, pid); 517 } 518 519