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
35 long
36 restore_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 */
114 long
115 setup_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
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.