1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include "qemu/osdep.h"
20#include "qemu.h"
21#include "user-internals.h"
22#include "signal-common.h"
23#include "linux-user/trace.h"
24
25struct target_sigcontext {
26 abi_ulong sc_pc;
27 abi_ulong sc_ps;
28 abi_ulong sc_lbeg;
29 abi_ulong sc_lend;
30 abi_ulong sc_lcount;
31 abi_ulong sc_sar;
32 abi_ulong sc_acclo;
33 abi_ulong sc_acchi;
34 abi_ulong sc_a[16];
35 abi_ulong sc_xtregs;
36};
37
38struct target_ucontext {
39 abi_ulong tuc_flags;
40 abi_ulong tuc_link;
41 target_stack_t tuc_stack;
42 struct target_sigcontext tuc_mcontext;
43 target_sigset_t tuc_sigmask;
44};
45
46struct target_rt_sigframe {
47 target_siginfo_t info;
48 struct target_ucontext uc;
49
50 uint8_t retcode[6];
51 abi_ulong window[4];
52};
53
54static abi_ulong get_sigframe(struct target_sigaction *sa,
55 CPUXtensaState *env,
56 unsigned long framesize)
57{
58 abi_ulong sp;
59
60 sp = target_sigsp(get_sp_from_cpustate(env), sa);
61
62 return (sp - framesize) & -16;
63}
64
65static int flush_window_regs(CPUXtensaState *env)
66{
67 uint32_t wb = env->sregs[WINDOW_BASE];
68 uint32_t ws = xtensa_replicate_windowstart(env) >> (wb + 1);
69 unsigned d = ctz32(ws) + 1;
70 unsigned i;
71 int ret = 0;
72
73 for (i = d; i < env->config->nareg / 4; i += d) {
74 uint32_t ssp, osp;
75 unsigned j;
76
77 ws >>= d;
78 xtensa_rotate_window(env, d);
79
80 if (ws & 0x1) {
81 ssp = env->regs[5];
82 d = 1;
83 } else if (ws & 0x2) {
84 ssp = env->regs[9];
85 ret |= get_user_ual(osp, env->regs[1] - 12);
86 osp -= 32;
87 d = 2;
88 } else if (ws & 0x4) {
89 ssp = env->regs[13];
90 ret |= get_user_ual(osp, env->regs[1] - 12);
91 osp -= 48;
92 d = 3;
93 } else {
94 g_assert_not_reached();
95 }
96
97 for (j = 0; j < 4; ++j) {
98 ret |= put_user_ual(env->regs[j], ssp - 16 + j * 4);
99 }
100 for (j = 4; j < d * 4; ++j) {
101 ret |= put_user_ual(env->regs[j], osp - 16 + j * 4);
102 }
103 }
104 xtensa_rotate_window(env, d);
105 g_assert(env->sregs[WINDOW_BASE] == wb);
106 return ret == 0;
107}
108
109static int setup_sigcontext(struct target_rt_sigframe *frame,
110 CPUXtensaState *env)
111{
112 struct target_sigcontext *sc = &frame->uc.tuc_mcontext;
113 int i;
114
115 __put_user(env->pc, &sc->sc_pc);
116 __put_user(env->sregs[PS], &sc->sc_ps);
117 __put_user(env->sregs[LBEG], &sc->sc_lbeg);
118 __put_user(env->sregs[LEND], &sc->sc_lend);
119 __put_user(env->sregs[LCOUNT], &sc->sc_lcount);
120 if (!flush_window_regs(env)) {
121 return 0;
122 }
123 for (i = 0; i < 16; ++i) {
124 __put_user(env->regs[i], sc->sc_a + i);
125 }
126 __put_user(0, &sc->sc_xtregs);
127
128 return 1;
129}
130
131static void install_sigtramp(uint8_t *tramp)
132{
133#ifdef TARGET_WORDS_BIGENDIAN
134
135 __put_user(0x22, &tramp[0]);
136 __put_user(0x0a, &tramp[1]);
137 __put_user(TARGET_NR_rt_sigreturn, &tramp[2]);
138
139 __put_user(0x00, &tramp[3]);
140 __put_user(0x05, &tramp[4]);
141 __put_user(0x00, &tramp[5]);
142#else
143
144 __put_user(0x22, &tramp[0]);
145 __put_user(0xa0, &tramp[1]);
146 __put_user(TARGET_NR_rt_sigreturn, &tramp[2]);
147
148 __put_user(0x00, &tramp[3]);
149 __put_user(0x50, &tramp[4]);
150 __put_user(0x00, &tramp[5]);
151#endif
152}
153
154void setup_rt_frame(int sig, struct target_sigaction *ka,
155 target_siginfo_t *info,
156 target_sigset_t *set, CPUXtensaState *env)
157{
158 abi_ulong frame_addr;
159 struct target_rt_sigframe *frame;
160 uint32_t ra;
161 bool abi_call0;
162 unsigned base;
163 int i;
164
165 frame_addr = get_sigframe(ka, env, sizeof(*frame));
166 trace_user_setup_rt_frame(env, frame_addr);
167
168 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
169 goto give_sigsegv;
170 }
171
172 if (ka->sa_flags & SA_SIGINFO) {
173 tswap_siginfo(&frame->info, info);
174 }
175
176 __put_user(0, &frame->uc.tuc_flags);
177 __put_user(0, &frame->uc.tuc_link);
178 target_save_altstack(&frame->uc.tuc_stack, env);
179 if (!setup_sigcontext(frame, env)) {
180 unlock_user_struct(frame, frame_addr, 0);
181 goto give_sigsegv;
182 }
183 for (i = 0; i < TARGET_NSIG_WORDS; ++i) {
184 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
185 }
186
187 if (ka->sa_flags & TARGET_SA_RESTORER) {
188 ra = ka->sa_restorer;
189 } else {
190
191 install_sigtramp(frame->retcode);
192 ra = default_rt_sigreturn;
193 }
194 memset(env->regs, 0, sizeof(env->regs));
195 env->pc = ka->_sa_handler;
196 env->regs[1] = frame_addr;
197 env->sregs[WINDOW_BASE] = 0;
198 env->sregs[WINDOW_START] = 1;
199
200 abi_call0 = (env->sregs[PS] & PS_WOE) == 0;
201 env->sregs[PS] = PS_UM | (3 << PS_RING_SHIFT);
202
203 if (abi_call0) {
204 base = 0;
205 env->regs[base] = ra;
206 } else {
207 env->sregs[PS] |= PS_WOE | (1 << PS_CALLINC_SHIFT);
208 base = 4;
209 env->regs[base] = (ra & 0x3fffffff) | 0x40000000;
210 }
211 env->regs[base + 2] = sig;
212 env->regs[base + 3] = frame_addr + offsetof(struct target_rt_sigframe,
213 info);
214 env->regs[base + 4] = frame_addr + offsetof(struct target_rt_sigframe, uc);
215 unlock_user_struct(frame, frame_addr, 1);
216 return;
217
218give_sigsegv:
219 force_sigsegv(sig);
220 return;
221}
222
223static void restore_sigcontext(CPUXtensaState *env,
224 struct target_rt_sigframe *frame)
225{
226 struct target_sigcontext *sc = &frame->uc.tuc_mcontext;
227 uint32_t ps;
228 int i;
229
230 __get_user(env->pc, &sc->sc_pc);
231 __get_user(ps, &sc->sc_ps);
232 __get_user(env->sregs[LBEG], &sc->sc_lbeg);
233 __get_user(env->sregs[LEND], &sc->sc_lend);
234 __get_user(env->sregs[LCOUNT], &sc->sc_lcount);
235
236 env->sregs[WINDOW_BASE] = 0;
237 env->sregs[WINDOW_START] = 1;
238 env->sregs[PS] = deposit32(env->sregs[PS],
239 PS_CALLINC_SHIFT,
240 PS_CALLINC_LEN,
241 extract32(ps, PS_CALLINC_SHIFT,
242 PS_CALLINC_LEN));
243 for (i = 0; i < 16; ++i) {
244 __get_user(env->regs[i], sc->sc_a + i);
245 }
246
247}
248
249long do_rt_sigreturn(CPUXtensaState *env)
250{
251 abi_ulong frame_addr = env->regs[1];
252 struct target_rt_sigframe *frame;
253 sigset_t set;
254
255 trace_user_do_rt_sigreturn(env, frame_addr);
256 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
257 goto badframe;
258 }
259 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
260 set_sigmask(&set);
261
262 restore_sigcontext(env, frame);
263 target_restore_altstack(&frame->uc.tuc_stack, env);
264
265 unlock_user_struct(frame, frame_addr, 0);
266 return -TARGET_QEMU_ESIGRETURN;
267
268badframe:
269 unlock_user_struct(frame, frame_addr, 0);
270 force_sig(TARGET_SIGSEGV);
271 return -TARGET_QEMU_ESIGRETURN;
272}
273
274void setup_sigtramp(abi_ulong sigtramp_page)
275{
276 uint8_t *tramp = lock_user(VERIFY_WRITE, sigtramp_page, 6, 0);
277 assert(tramp != NULL);
278
279 default_rt_sigreturn = sigtramp_page;
280 install_sigtramp(tramp);
281 unlock_user(tramp, sigtramp_page, 6);
282}
283
