1// SPDX-License-Identifier: GPL-2.0-or-later 2/* Signal support for 32-bit kernel builds 3 * 4 * Copyright (C) 2001 Matthew Wilcox <willy at parisc-linux.org> 5 * Copyright (C) 2006 Kyle McMartin <kyle at parisc-linux.org> 6 * 7 * Code was mostly borrowed from kernel/signal.c. 8 * See kernel/signal.c for additional Copyrights. 9 */ 10 11#include <linux/compat.h> 12#include <linux/module.h> 13#include <linux/unistd.h> 14#include <linux/init.h> 15#include <linux/sched.h> 16#include <linux/syscalls.h> 17#include <linux/types.h> 18#include <linux/errno.h> 19 20#include <linux/uaccess.h> 21 22#include "signal32.h" 23 24#define DEBUG_COMPAT_SIG 0 25#define DEBUG_COMPAT_SIG_LEVEL 2 26 27#if DEBUG_COMPAT_SIG 28#define DBG(LEVEL, ...) \ 29 ((DEBUG_COMPAT_SIG_LEVEL >= LEVEL) \ 30 ? printk(__VA_ARGS__) : (void) 0) 31#else 32#define DBG(LEVEL, ...) 33#endif 34 35long 36restore_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf, 37 struct pt_regs *regs) 38{ 39 long err = 0; 40 compat_uint_t compat_reg; 41 compat_uint_t compat_regt; 42 int regn; 43 44 /* When loading 32-bit values into 64-bit registers make 45 sure to clear the upper 32-bits */ 46 DBG(2,"restore_sigcontext32: PER_LINUX32 process\n"); 47 DBG(2,"restore_sigcontext32: sc = 0x%p, rf = 0x%p, regs = 0x%p\n", sc, rf, regs); 48 DBG(2,"restore_sigcontext32: compat_sigcontext is %#lx bytes\n", sizeof(*sc)); 49 for(regn=0; regn < 32; regn++){ 50 err |= __get_user(compat_reg,&sc->sc_gr[regn]); 51 regs->gr[regn] = compat_reg; 52 /* Load upper half */ 53 err |= __get_user(compat_regt,&rf->rf_gr[regn]); 54 regs->gr[regn] = ((u64)compat_regt << 32) | (u64)compat_reg; 55 DBG(3,"restore_sigcontext32: gr%02d = %#lx (%#x / %#x)\n", 56 regn, regs->gr[regn], compat_regt, compat_reg); 57 } 58 DBG(2,"restore_sigcontext32: sc->sc_fr = 0x%p (%#lx)\n",sc->sc_fr, sizeof(sc->sc_fr)); 59 /* XXX: BE WARNED FR's are 64-BIT! */ 60 err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr)); 61 62 /* Better safe than sorry, pass __get_user two things of 63 the same size and let gcc do the upward conversion to 64 64-bits */ 65 err |= __get_user(compat_reg, &sc->sc_iaoq[0]); 66 /* Load upper half */ 67 err |= __get_user(compat_regt, &rf->rf_iaoq[0]); 68 regs->iaoq[0] = ((u64)compat_regt << 32) | (u64)compat_reg; 69 DBG(2,"restore_sigcontext32: upper half of iaoq[0] = %#lx\n", compat_regt); 70 DBG(2,"restore_sigcontext32: sc->sc_iaoq[0] = %p => %#x\n", 71 &sc->sc_iaoq[0], compat_reg); 72 73 err |= __get_user(compat_reg, &sc->sc_iaoq[1]); 74 /* Load upper half */ 75 err |= __get_user(compat_regt, &rf->rf_iaoq[1]); 76 regs->iaoq[1] = ((u64)compat_regt << 32) | (u64)compat_reg; 77 DBG(2,"restore_sigcontext32: upper half of iaoq[1] = %#lx\n", compat_regt); 78 DBG(2,"restore_sigcontext32: sc->sc_iaoq[1] = %p => %#x\n", 79 &sc->sc_iaoq[1],compat_reg); 80 DBG(2,"restore_sigcontext32: iaoq is %#lx / %#lx\n", 81 regs->iaoq[0],regs->iaoq[1]); 82 83 err |= __get_user(compat_reg, &sc->sc_iasq[0]); 84 /* Load the upper half for iasq */ 85 err |= __get_user(compat_regt, &rf->rf_iasq[0]); 86 regs->iasq[0] = ((u64)compat_regt << 32) | (u64)compat_reg; 87 DBG(2,"restore_sigcontext32: upper half of iasq[0] = %#lx\n", compat_regt); 88 89 err |= __get_user(compat_reg, &sc->sc_iasq[1]); 90 /* Load the upper half for iasq */ 91 err |= __get_user(compat_regt, &rf->rf_iasq[1]); 92 regs->iasq[1] = ((u64)compat_regt << 32) | (u64)compat_reg; 93 DBG(2,"restore_sigcontext32: upper half of iasq[1] = %#lx\n", compat_regt); 94 DBG(2,"restore_sigcontext32: iasq is %#lx / %#lx\n", 95 regs->iasq[0],regs->iasq[1]); 96 97 err |= __get_user(compat_reg, &sc->sc_sar); 98 /* Load the upper half for sar */ 99 err |= __get_user(compat_regt, &rf->rf_sar); 100 regs->sar = ((u64)compat_regt << 32) | (u64)compat_reg; 101 DBG(2,"restore_sigcontext32: upper_half & sar = %#lx\n", compat_regt); 102 DBG(2,"restore_sigcontext32: sar is %#lx\n", regs->sar); 103 DBG(2,"restore_sigcontext32: r28 is %ld\n", regs->gr[28]); 104 105 return err; 106} 107 108/* 109 * Set up the sigcontext structure for this process. 110 * This is not an easy task if the kernel is 64-bit, it will require 111 * that we examine the process personality to determine if we need to 112 * truncate for a 32-bit userspace. 113 */ 114long 115setup_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf, 116 struct pt_regs *regs, int in_syscall) 117{ 118 compat_int_t flags = 0; 119 long err = 0; 120 compat_uint_t compat_reg; 121 compat_uint_t compat_regb; 122 int regn; 123 124 if (on_sig_stack((unsigned long) sc)) 125 flags |= PARISC_SC_FLAG_ONSTACK; 126 127 if (in_syscall) { 128 129 DBG(1,"setup_sigcontext32: in_syscall\n"); 130 131 flags |= PARISC_SC_FLAG_IN_SYSCALL; 132 /* Truncate gr31 */ 133 compat_reg = (compat_uint_t)(regs->gr[31]); 134 /* regs->iaoq is undefined in the syscall return path */ 135 err |= __put_user(compat_reg, &sc->sc_iaoq[0]); 136 DBG(2,"setup_sigcontext32: sc->sc_iaoq[0] = %p <= %#x\n", 137 &sc->sc_iaoq[0], compat_reg); 138 139 /* Store upper half */ 140 compat_reg = (compat_uint_t)(regs->gr[31] >> 32); 141 err |= __put_user(compat_reg, &rf->rf_iaoq[0]); 142 DBG(2,"setup_sigcontext32: upper half iaoq[0] = %#x\n", compat_reg); 143 144 145 compat_reg = (compat_uint_t)(regs->gr[31]+4); 146 err |= __put_user(compat_reg, &sc->sc_iaoq[1]); 147 DBG(2,"setup_sigcontext32: sc->sc_iaoq[1] = %p <= %#x\n", 148 &sc->sc_iaoq[1], compat_reg); 149 /* Store upper half */ 150 compat_reg = (compat_uint_t)((regs->gr[31]+4) >> 32); 151 err |= __put_user(compat_reg, &rf->rf_iaoq[1]); 152 DBG(2,"setup_sigcontext32: upper half iaoq[1] = %#x\n", compat_reg); 153 154 /* Truncate sr3 */ 155 compat_reg = (compat_uint_t)(regs->sr[3]); 156 err |= __put_user(compat_reg, &sc->sc_iasq[0]); 157 err |= __put_user(compat_reg, &sc->sc_iasq[1]); 158 159 /* Store upper half */ 160 compat_reg = (compat_uint_t)(regs->sr[3] >> 32); 161 err |= __put_user(compat_reg, &rf->rf_iasq[0]); 162 err |= __put_user(compat_reg, &rf->rf_iasq[1]); 163 164 DBG(2,"setup_sigcontext32: upper half iasq[0] = %#x\n", compat_reg); 165 DBG(2,"setup_sigcontext32: upper half iasq[1] = %#x\n", compat_reg); 166 DBG(1,"setup_sigcontext32: iaoq %#lx / %#lx\n", 167 regs->gr[31], regs->gr[31]+4); 168 169 } else { 170 171 compat_reg = (compat_uint_t)(regs->iaoq[0]); 172 err |= __put_user(compat_reg, &sc->sc_iaoq[0]); 173 DBG(2,"setup_sigcontext32: sc->sc_iaoq[0] = %p <= %#x\n", 174 &sc->sc_iaoq[0], compat_reg); 175 /* Store upper half */ 176 compat_reg = (compat_uint_t)(regs->iaoq[0] >> 32); 177 err |= __put_user(compat_reg, &rf->rf_iaoq[0]); 178 DBG(2,"setup_sigcontext32: upper half iaoq[0] = %#x\n", compat_reg); 179 180 compat_reg = (compat_uint_t)(regs->iaoq[1]); 181 err |= __put_user(compat_reg, &sc->sc_iaoq[1]); 182 DBG(2,"setup_sigcontext32: sc->sc_iaoq[1] = %p <= %#x\n", 183 &sc->sc_iaoq[1], compat_reg); 184 /* Store upper half */ 185 compat_reg = (compat_uint_t)(regs->iaoq[1] >> 32); 186 err |= __put_user(compat_reg, &rf->rf_iaoq[1]); 187 DBG(2,"setup_sigcontext32: upper half iaoq[1] = %#x\n", compat_reg); 188 189 190 compat_reg = (compat_uint_t)(regs->iasq[0]); 191 err |= __put_user(compat_reg, &sc->sc_iasq[0]); 192 DBG(2,"setup_sigcontext32: sc->sc_iasq[0] = %p <= %#x\n", 193 &sc->sc_iasq[0], compat_reg); 194 /* Store upper half */ 195 compat_reg = (compat_uint_t)(regs->iasq[0] >> 32); 196 err |= __put_user(compat_reg, &rf->rf_iasq[0]); 197 DBG(2,"setup_sigcontext32: upper half iasq[0] = %#x\n", compat_reg); 198 199 200 compat_reg = (compat_uint_t)(regs->iasq[1]); 201 err |= __put_user(compat_reg, &sc->sc_iasq[1]); 202 DBG(2,"setup_sigcontext32: sc->sc_iasq[1] = %p <= %#x\n", 203 &sc->sc_iasq[1], compat_reg); 204 /* Store upper half */ 205 compat_reg = (compat_uint_t)(regs->iasq[1] >> 32); 206 err |= __put_user(compat_reg, &rf->rf_iasq[1]); 207 DBG(2,"setup_sigcontext32: upper half iasq[1] = %#x\n", compat_reg); 208 209 /* Print out the IAOQ for debugging */ 210 DBG(1,"setup_sigcontext32: ia0q %#lx / %#lx\n", 211 regs->iaoq[0], regs->iaoq[1]); 212 } 213 214 err |= __put_user(flags, &sc->sc_flags); 215 216 DBG(1,"setup_sigcontext32: Truncating general registers.\n"); 217 218 for(regn=0; regn < 32; regn++){ 219 /* Truncate a general register */ 220 compat_reg = (compat_uint_t)(regs->gr[regn]); 221 err |= __put_user(compat_reg, &sc->sc_gr[regn]); 222 /* Store upper half */ 223 compat_regb = (compat_uint_t)(regs->gr[regn] >> 32); 224 err |= __put_user(compat_regb, &rf->rf_gr[regn]); 225 226 /* DEBUG: Write out the "upper / lower" register data */ 227 DBG(2,"setup_sigcontext32: gr%02d = %#x / %#x\n", regn, 228 compat_regb, compat_reg); 229 } 230 231 /* Copy the floating point registers (same size) 232 XXX: BE WARNED FR's are 64-BIT! */ 233 DBG(1,"setup_sigcontext32: Copying from regs to sc, " 234 "sc->sc_fr size = %#lx, regs->fr size = %#lx\n", 235 sizeof(regs->fr), sizeof(sc->sc_fr)); 236 err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr)); 237 238 compat_reg = (compat_uint_t)(regs->sar); 239 err |= __put_user(compat_reg, &sc->sc_sar); 240 DBG(2,"setup_sigcontext32: sar is %#x\n", compat_reg); 241 /* Store upper half */ 242 compat_reg = (compat_uint_t)(regs->sar >> 32); 243 err |= __put_user(compat_reg, &rf->rf_sar); 244 DBG(2,"setup_sigcontext32: upper half sar = %#x\n", compat_reg); 245 DBG(1,"setup_sigcontext32: r28 is %ld\n", regs->gr[28]); 246 247 return err; 248} 249