]>
Commit | Line | Data |
---|---|---|
1a59d1b8 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
1da177e4 LT |
2 | /* Signal support for 32-bit kernel builds |
3 | * | |
4 | * Copyright (C) 2001 Matthew Wilcox <willy at parisc-linux.org> | |
d104f11c KM |
5 | * Copyright (C) 2006 Kyle McMartin <kyle at parisc-linux.org> |
6 | * | |
1da177e4 LT |
7 | * Code was mostly borrowed from kernel/signal.c. |
8 | * See kernel/signal.c for additional Copyrights. | |
1da177e4 LT |
9 | */ |
10 | ||
11 | #include <linux/compat.h> | |
1da177e4 LT |
12 | #include <linux/module.h> |
13 | #include <linux/unistd.h> | |
1da177e4 LT |
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 | ||
7c0f6ba6 | 20 | #include <linux/uaccess.h> |
1da177e4 LT |
21 | |
22 | #include "signal32.h" | |
1da177e4 LT |
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 | ||
1da177e4 LT |
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 */ | |
f4441b62 | 140 | compat_reg = (compat_uint_t)(regs->gr[31] >> 32); |
1da177e4 LT |
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 */ | |
f4441b62 | 150 | compat_reg = (compat_uint_t)((regs->gr[31]+4) >> 32); |
1da177e4 LT |
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 | } |