1 /*
2 * Emulation of Linux signals
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
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
25 /* A Sparc register window */
26 struct target_reg_window {
27 abi_ulong locals[8];
28 abi_ulong ins[8];
29 };
30
31 /* A Sparc stack frame. */
32 struct target_stackf {
33 /*
34 * Since qemu does not reference fp or callers_pc directly,
35 * it's simpler to treat fp and callers_pc as elements of ins[],
36 * and then bundle locals[] and ins[] into reg_window.
37 */
38 struct target_reg_window win;
39 /*
40 * Similarly, bundle structptr and xxargs into xargs[].
41 * This portion of the struct is part of the function call abi,
42 * and belongs to the callee for spilling argument registers.
43 */
44 abi_ulong xargs[8];
45 };
46
47 struct target_siginfo_fpu {
48 #ifdef TARGET_SPARC64
49 uint64_t si_double_regs[32];
50 uint64_t si_fsr;
51 uint64_t si_gsr;
52 uint64_t si_fprs;
53 #else
54 /* It is more convenient for qemu to move doubles, not singles. */
55 uint64_t si_double_regs[16];
56 uint32_t si_fsr;
57 uint32_t si_fpqdepth;
58 struct {
59 uint32_t insn_addr;
60 uint32_t insn;
61 } si_fpqueue [16];
62 #endif
63 };
64
65 #ifdef TARGET_ARCH_HAS_SETUP_FRAME
66 struct target_signal_frame {
67 struct target_stackf ss;
68 struct target_pt_regs regs;
69 uint32_t si_mask;
70 abi_ulong fpu_save;
71 uint32_t insns[2] QEMU_ALIGNED(8);
72 abi_ulong extramask[TARGET_NSIG_WORDS - 1];
73 abi_ulong extra_size; /* Should be 0 */
74 abi_ulong rwin_save;
75 };
76 #endif
77
78 struct target_rt_signal_frame {
79 struct target_stackf ss;
80 target_siginfo_t info;
81 struct target_pt_regs regs;
82 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
83 abi_ulong fpu_save;
84 target_stack_t stack;
85 target_sigset_t mask;
86 #else
87 target_sigset_t mask;
88 abi_ulong fpu_save;
89 uint32_t insns[2];
90 target_stack_t stack;
91 abi_ulong extra_size; /* Should be 0 */
92 #endif
93 abi_ulong rwin_save;
94 };
95
get_sigframe(struct target_sigaction * sa,CPUSPARCState * env,size_t framesize)96 static abi_ulong get_sigframe(struct target_sigaction *sa,
97 CPUSPARCState *env,
98 size_t framesize)
99 {
100 abi_ulong sp = get_sp_from_cpustate(env);
101
102 /*
103 * If we are on the alternate signal stack and would overflow it, don't.
104 * Return an always-bogus address instead so we will die with SIGSEGV.
105 */
106 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - framesize))) {
107 return -1;
108 }
109
110 /* This is the X/Open sanctioned signal stack switching. */
111 sp = target_sigsp(sp, sa) - framesize;
112
113 /*
114 * Always align the stack frame. This handles two cases. First,
115 * sigaltstack need not be mindful of platform specific stack
116 * alignment. Second, if we took this signal because the stack
117 * is not aligned properly, we'd like to take the signal cleanly
118 * and report that.
119 */
120 sp &= ~15UL;
121
122 return sp;
123 }
124
save_pt_regs(struct target_pt_regs * regs,CPUSPARCState * env)125 static void save_pt_regs(struct target_pt_regs *regs, CPUSPARCState *env)
126 {
127 int i;
128
129 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
130 __put_user(sparc64_tstate(env), ®s->tstate);
131 /* TODO: magic should contain PT_REG_MAGIC + %tt. */
132 __put_user(0, ®s->magic);
133 #else
134 __put_user(cpu_get_psr(env), ®s->psr);
135 #endif
136
137 __put_user(env->pc, ®s->pc);
138 __put_user(env->npc, ®s->npc);
139 __put_user(env->y, ®s->y);
140
141 for (i = 0; i < 8; i++) {
142 __put_user(env->gregs[i], ®s->u_regs[i]);
143 }
144 for (i = 0; i < 8; i++) {
145 __put_user(env->regwptr[WREG_O0 + i], ®s->u_regs[i + 8]);
146 }
147 }
148
restore_pt_regs(struct target_pt_regs * regs,CPUSPARCState * env)149 static void restore_pt_regs(struct target_pt_regs *regs, CPUSPARCState *env)
150 {
151 int i;
152
153 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
154 /* User can only change condition codes and %asi in %tstate. */
155 uint64_t tstate;
156 __get_user(tstate, ®s->tstate);
157 cpu_put_ccr(env, tstate >> 32);
158 env->asi = extract64(tstate, 24, 8);
159 #else
160 /*
161 * User can only change condition codes and FPU enabling in %psr.
162 * But don't bother with FPU enabling, since a real kernel would
163 * just re-enable the FPU upon the next fpu trap.
164 */
165 uint32_t psr;
166 __get_user(psr, ®s->psr);
167 cpu_put_psr_icc(env, psr);
168 #endif
169
170 /* Note that pc and npc are handled in the caller. */
171
172 __get_user(env->y, ®s->y);
173
174 for (i = 0; i < 8; i++) {
175 __get_user(env->gregs[i], ®s->u_regs[i]);
176 }
177 for (i = 0; i < 8; i++) {
178 __get_user(env->regwptr[WREG_O0 + i], ®s->u_regs[i + 8]);
179 }
180 }
181
save_reg_win(struct target_reg_window * win,CPUSPARCState * env)182 static void save_reg_win(struct target_reg_window *win, CPUSPARCState *env)
183 {
184 int i;
185
186 for (i = 0; i < 8; i++) {
187 __put_user(env->regwptr[i + WREG_L0], &win->locals[i]);
188 }
189 for (i = 0; i < 8; i++) {
190 __put_user(env->regwptr[i + WREG_I0], &win->ins[i]);
191 }
192 }
193
save_fpu(struct target_siginfo_fpu * fpu,CPUSPARCState * env)194 static void save_fpu(struct target_siginfo_fpu *fpu, CPUSPARCState *env)
195 {
196 int i;
197
198 #ifdef TARGET_SPARC64
199 for (i = 0; i < 32; ++i) {
200 __put_user(env->fpr[i].ll, &fpu->si_double_regs[i]);
201 }
202 __put_user(cpu_get_fsr(env), &fpu->si_fsr);
203 __put_user(env->gsr, &fpu->si_gsr);
204 __put_user(env->fprs, &fpu->si_fprs);
205 #else
206 for (i = 0; i < 16; ++i) {
207 __put_user(env->fpr[i].ll, &fpu->si_double_regs[i]);
208 }
209 __put_user(cpu_get_fsr(env), &fpu->si_fsr);
210 __put_user(0, &fpu->si_fpqdepth);
211 #endif
212 }
213
restore_fpu(struct target_siginfo_fpu * fpu,CPUSPARCState * env)214 static void restore_fpu(struct target_siginfo_fpu *fpu, CPUSPARCState *env)
215 {
216 target_ulong fsr;
217 int i;
218
219 #ifdef TARGET_SPARC64
220 uint64_t fprs;
221 __get_user(fprs, &fpu->si_fprs);
222
223 /* In case the user mucks about with FPRS, restore as directed. */
224 if (fprs & FPRS_DL) {
225 for (i = 0; i < 16; ++i) {
226 __get_user(env->fpr[i].ll, &fpu->si_double_regs[i]);
227 }
228 }
229 if (fprs & FPRS_DU) {
230 for (i = 16; i < 32; ++i) {
231 __get_user(env->fpr[i].ll, &fpu->si_double_regs[i]);
232 }
233 }
234 __get_user(env->gsr, &fpu->si_gsr);
235 env->fprs |= fprs;
236 #else
237 for (i = 0; i < 16; ++i) {
238 __get_user(env->fpr[i].ll, &fpu->si_double_regs[i]);
239 }
240 #endif
241
242 __get_user(fsr, &fpu->si_fsr);
243 cpu_put_fsr(env, fsr);
244 }
245
246 #ifdef TARGET_ARCH_HAS_SETUP_FRAME
install_sigtramp(uint32_t * tramp,int syscall)247 static void install_sigtramp(uint32_t *tramp, int syscall)
248 {
249 __put_user(0x82102000u + syscall, &tramp[0]); /* mov syscall, %g1 */
250 __put_user(0x91d02010u, &tramp[1]); /* t 0x10 */
251 }
252
setup_frame(int sig,struct target_sigaction * ka,target_sigset_t * set,CPUSPARCState * env)253 void setup_frame(int sig, struct target_sigaction *ka,
254 target_sigset_t *set, CPUSPARCState *env)
255 {
256 abi_ulong sf_addr;
257 struct target_signal_frame *sf;
258 size_t sf_size = sizeof(*sf) + sizeof(struct target_siginfo_fpu);
259 int i;
260
261 sf_addr = get_sigframe(ka, env, sf_size);
262 trace_user_setup_frame(env, sf_addr);
263
264 sf = lock_user(VERIFY_WRITE, sf_addr, sf_size, 0);
265 if (!sf) {
266 force_sigsegv(sig);
267 return;
268 }
269
270 /* 2. Save the current process state */
271 save_pt_regs(&sf->regs, env);
272 __put_user(0, &sf->extra_size);
273
274 save_fpu((struct target_siginfo_fpu *)(sf + 1), env);
275 __put_user(sf_addr + sizeof(*sf), &sf->fpu_save);
276
277 __put_user(0, &sf->rwin_save); /* TODO: save_rwin_state */
278
279 __put_user(set->sig[0], &sf->si_mask);
280 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
281 __put_user(set->sig[i + 1], &sf->extramask[i]);
282 }
283
284 save_reg_win(&sf->ss.win, env);
285
286 /* 3. signal handler back-trampoline and parameters */
287 env->regwptr[WREG_SP] = sf_addr;
288 env->regwptr[WREG_O0] = sig;
289 env->regwptr[WREG_O1] = sf_addr +
290 offsetof(struct target_signal_frame, regs);
291 env->regwptr[WREG_O2] = sf_addr +
292 offsetof(struct target_signal_frame, regs);
293
294 /* 4. signal handler */
295 env->pc = ka->_sa_handler;
296 env->npc = env->pc + 4;
297
298 /* 5. return to kernel instructions */
299 if (ka->ka_restorer) {
300 env->regwptr[WREG_O7] = ka->ka_restorer;
301 } else {
302 /* Not used, but retain for ABI compatibility. */
303 install_sigtramp(sf->insns, TARGET_NR_sigreturn);
304 env->regwptr[WREG_O7] = default_sigreturn;
305 }
306 unlock_user(sf, sf_addr, sf_size);
307 }
308 #endif /* TARGET_ARCH_HAS_SETUP_FRAME */
309
setup_rt_frame(int sig,struct target_sigaction * ka,target_siginfo_t * info,target_sigset_t * set,CPUSPARCState * env)310 void setup_rt_frame(int sig, struct target_sigaction *ka,
311 target_siginfo_t *info,
312 target_sigset_t *set, CPUSPARCState *env)
313 {
314 abi_ulong sf_addr;
315 struct target_rt_signal_frame *sf;
316 size_t sf_size = sizeof(*sf) + sizeof(struct target_siginfo_fpu);
317
318 sf_addr = get_sigframe(ka, env, sf_size);
319 trace_user_setup_rt_frame(env, sf_addr);
320
321 sf = lock_user(VERIFY_WRITE, sf_addr, sf_size, 0);
322 if (!sf) {
323 force_sigsegv(sig);
324 return;
325 }
326
327 /* 2. Save the current process state */
328 save_reg_win(&sf->ss.win, env);
329 save_pt_regs(&sf->regs, env);
330
331 save_fpu((struct target_siginfo_fpu *)(sf + 1), env);
332 __put_user(sf_addr + sizeof(*sf), &sf->fpu_save);
333
334 __put_user(0, &sf->rwin_save); /* TODO: save_rwin_state */
335
336 sf->info = *info;
337 tswap_sigset(&sf->mask, set);
338 target_save_altstack(&sf->stack, env);
339
340 #ifdef TARGET_ABI32
341 __put_user(0, &sf->extra_size);
342 #endif
343
344 /* 3. signal handler back-trampoline and parameters */
345 env->regwptr[WREG_SP] = sf_addr - TARGET_STACK_BIAS;
346 env->regwptr[WREG_O0] = sig;
347 env->regwptr[WREG_O1] =
348 sf_addr + offsetof(struct target_rt_signal_frame, info);
349 #ifdef TARGET_ABI32
350 env->regwptr[WREG_O2] =
351 sf_addr + offsetof(struct target_rt_signal_frame, regs);
352 #else
353 env->regwptr[WREG_O2] = env->regwptr[WREG_O1];
354 #endif
355
356 /* 4. signal handler */
357 env->pc = ka->_sa_handler;
358 env->npc = env->pc + 4;
359
360 /* 5. return to kernel instructions */
361 #ifdef TARGET_ABI32
362 if (ka->ka_restorer) {
363 env->regwptr[WREG_O7] = ka->ka_restorer;
364 } else {
365 /* Not used, but retain for ABI compatibility. */
366 install_sigtramp(sf->insns, TARGET_NR_rt_sigreturn);
367 env->regwptr[WREG_O7] = default_rt_sigreturn;
368 }
369 #else
370 env->regwptr[WREG_O7] = ka->ka_restorer;
371 #endif
372
373 unlock_user(sf, sf_addr, sf_size);
374 }
375
do_sigreturn(CPUSPARCState * env)376 long do_sigreturn(CPUSPARCState *env)
377 {
378 #ifdef TARGET_ARCH_HAS_SETUP_FRAME
379 abi_ulong sf_addr;
380 struct target_signal_frame *sf = NULL;
381 abi_ulong pc, npc, ptr;
382 target_sigset_t set;
383 sigset_t host_set;
384 int i;
385
386 sf_addr = env->regwptr[WREG_SP];
387 trace_user_do_sigreturn(env, sf_addr);
388
389 /* 1. Make sure we are not getting garbage from the user */
390 if ((sf_addr & 15) || !lock_user_struct(VERIFY_READ, sf, sf_addr, 1)) {
391 goto segv_and_exit;
392 }
393
394 /* Make sure stack pointer is aligned. */
395 __get_user(ptr, &sf->regs.u_regs[14]);
396 if (ptr & 7) {
397 goto segv_and_exit;
398 }
399
400 /* Make sure instruction pointers are aligned. */
401 __get_user(pc, &sf->regs.pc);
402 __get_user(npc, &sf->regs.npc);
403 if ((pc | npc) & 3) {
404 goto segv_and_exit;
405 }
406
407 /* 2. Restore the state */
408 restore_pt_regs(&sf->regs, env);
409 env->pc = pc;
410 env->npc = npc;
411
412 __get_user(ptr, &sf->fpu_save);
413 if (ptr) {
414 struct target_siginfo_fpu *fpu;
415 if ((ptr & 3) || !lock_user_struct(VERIFY_READ, fpu, ptr, 1)) {
416 goto segv_and_exit;
417 }
418 restore_fpu(fpu, env);
419 unlock_user_struct(fpu, ptr, 0);
420 }
421
422 __get_user(ptr, &sf->rwin_save);
423 if (ptr) {
424 goto segv_and_exit; /* TODO: restore_rwin */
425 }
426
427 __get_user(set.sig[0], &sf->si_mask);
428 for (i = 1; i < TARGET_NSIG_WORDS; i++) {
429 __get_user(set.sig[i], &sf->extramask[i - 1]);
430 }
431
432 target_to_host_sigset_internal(&host_set, &set);
433 set_sigmask(&host_set);
434
435 unlock_user_struct(sf, sf_addr, 0);
436 return -QEMU_ESIGRETURN;
437
438 segv_and_exit:
439 unlock_user_struct(sf, sf_addr, 0);
440 force_sig(TARGET_SIGSEGV);
441 return -QEMU_ESIGRETURN;
442 #else
443 return -TARGET_ENOSYS;
444 #endif
445 }
446
do_rt_sigreturn(CPUSPARCState * env)447 long do_rt_sigreturn(CPUSPARCState *env)
448 {
449 abi_ulong sf_addr, tpc, tnpc, ptr;
450 struct target_rt_signal_frame *sf = NULL;
451 sigset_t set;
452
453 sf_addr = get_sp_from_cpustate(env);
454 trace_user_do_rt_sigreturn(env, sf_addr);
455
456 /* 1. Make sure we are not getting garbage from the user */
457 if ((sf_addr & 15) || !lock_user_struct(VERIFY_READ, sf, sf_addr, 1)) {
458 goto segv_and_exit;
459 }
460
461 /* Validate SP alignment. */
462 __get_user(ptr, &sf->regs.u_regs[8 + WREG_SP]);
463 if ((ptr + TARGET_STACK_BIAS) & 7) {
464 goto segv_and_exit;
465 }
466
467 /* Validate PC and NPC alignment. */
468 __get_user(tpc, &sf->regs.pc);
469 __get_user(tnpc, &sf->regs.npc);
470 if ((tpc | tnpc) & 3) {
471 goto segv_and_exit;
472 }
473
474 /* 2. Restore the state */
475 restore_pt_regs(&sf->regs, env);
476
477 __get_user(ptr, &sf->fpu_save);
478 if (ptr) {
479 struct target_siginfo_fpu *fpu;
480 if ((ptr & 7) || !lock_user_struct(VERIFY_READ, fpu, ptr, 1)) {
481 goto segv_and_exit;
482 }
483 restore_fpu(fpu, env);
484 unlock_user_struct(fpu, ptr, 0);
485 }
486
487 __get_user(ptr, &sf->rwin_save);
488 if (ptr) {
489 goto segv_and_exit; /* TODO: restore_rwin_state */
490 }
491
492 target_restore_altstack(&sf->stack, env);
493 target_to_host_sigset(&set, &sf->mask);
494 set_sigmask(&set);
495
496 env->pc = tpc;
497 env->npc = tnpc;
498
499 unlock_user_struct(sf, sf_addr, 0);
500 return -QEMU_ESIGRETURN;
501
502 segv_and_exit:
503 unlock_user_struct(sf, sf_addr, 0);
504 force_sig(TARGET_SIGSEGV);
505 return -QEMU_ESIGRETURN;
506 }
507
508 #ifdef TARGET_ABI32
setup_sigtramp(abi_ulong sigtramp_page)509 void setup_sigtramp(abi_ulong sigtramp_page)
510 {
511 uint32_t *tramp = lock_user(VERIFY_WRITE, sigtramp_page, 2 * 8, 0);
512 assert(tramp != NULL);
513
514 default_sigreturn = sigtramp_page;
515 install_sigtramp(tramp, TARGET_NR_sigreturn);
516
517 default_rt_sigreturn = sigtramp_page + 8;
518 install_sigtramp(tramp + 2, TARGET_NR_rt_sigreturn);
519
520 unlock_user(tramp, sigtramp_page, 2 * 8);
521 }
522 #endif
523
524 #ifdef TARGET_SPARC64
525 #define SPARC_MC_TSTATE 0
526 #define SPARC_MC_PC 1
527 #define SPARC_MC_NPC 2
528 #define SPARC_MC_Y 3
529 #define SPARC_MC_G1 4
530 #define SPARC_MC_G2 5
531 #define SPARC_MC_G3 6
532 #define SPARC_MC_G4 7
533 #define SPARC_MC_G5 8
534 #define SPARC_MC_G6 9
535 #define SPARC_MC_G7 10
536 #define SPARC_MC_O0 11
537 #define SPARC_MC_O1 12
538 #define SPARC_MC_O2 13
539 #define SPARC_MC_O3 14
540 #define SPARC_MC_O4 15
541 #define SPARC_MC_O5 16
542 #define SPARC_MC_O6 17
543 #define SPARC_MC_O7 18
544 #define SPARC_MC_NGREG 19
545
546 typedef abi_ulong target_mc_greg_t;
547 typedef target_mc_greg_t target_mc_gregset_t[SPARC_MC_NGREG];
548
549 /*
550 * Note the manual 16-alignment; the kernel gets this because it
551 * includes a "long double qregs[16]" in the mcpu_fregs union,
552 * which we can't do.
553 */
554 struct target_mc_fpu {
555 union {
556 uint32_t sregs[32];
557 uint64_t dregs[32];
558 //uint128_t qregs[16];
559 } mcfpu_fregs;
560 abi_ulong mcfpu_fsr;
561 abi_ulong mcfpu_fprs;
562 abi_ulong mcfpu_gsr;
563 abi_ulong mcfpu_fq;
564 unsigned char mcfpu_qcnt;
565 unsigned char mcfpu_qentsz;
566 unsigned char mcfpu_enab;
567 } __attribute__((aligned(16)));
568 typedef struct target_mc_fpu target_mc_fpu_t;
569
570 typedef struct {
571 target_mc_gregset_t mc_gregs;
572 target_mc_greg_t mc_fp;
573 target_mc_greg_t mc_i7;
574 target_mc_fpu_t mc_fpregs;
575 } target_mcontext_t;
576
577 struct target_ucontext {
578 abi_ulong tuc_link;
579 abi_ulong tuc_flags;
580 target_sigset_t tuc_sigmask;
581 target_mcontext_t tuc_mcontext;
582 };
583
584 /* {set, get}context() needed for 64-bit SparcLinux userland. */
sparc64_set_context(CPUSPARCState * env)585 void sparc64_set_context(CPUSPARCState *env)
586 {
587 abi_ulong ucp_addr;
588 struct target_ucontext *ucp;
589 target_mc_gregset_t *grp;
590 target_mc_fpu_t *fpup;
591 target_ulong pc, npc, tstate;
592 unsigned int i;
593 unsigned char fenab;
594
595 ucp_addr = env->regwptr[WREG_O0];
596 if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1)) {
597 goto do_sigsegv;
598 }
599 grp = &ucp->tuc_mcontext.mc_gregs;
600 __get_user(pc, &((*grp)[SPARC_MC_PC]));
601 __get_user(npc, &((*grp)[SPARC_MC_NPC]));
602 if ((pc | npc) & 3) {
603 goto do_sigsegv;
604 }
605 if (env->regwptr[WREG_O1]) {
606 target_sigset_t target_set;
607 sigset_t set;
608
609 if (TARGET_NSIG_WORDS == 1) {
610 __get_user(target_set.sig[0], &ucp->tuc_sigmask.sig[0]);
611 } else {
612 abi_ulong *src, *dst;
613 src = ucp->tuc_sigmask.sig;
614 dst = target_set.sig;
615 for (i = 0; i < TARGET_NSIG_WORDS; i++, dst++, src++) {
616 __get_user(*dst, src);
617 }
618 }
619 target_to_host_sigset_internal(&set, &target_set);
620 set_sigmask(&set);
621 }
622 env->pc = pc;
623 env->npc = npc;
624 __get_user(env->y, &((*grp)[SPARC_MC_Y]));
625 __get_user(tstate, &((*grp)[SPARC_MC_TSTATE]));
626 /* Honour TSTATE_ASI, TSTATE_ICC and TSTATE_XCC only */
627 env->asi = (tstate >> 24) & 0xff;
628 cpu_put_ccr(env, (tstate >> 32) & 0xff);
629 __get_user(env->gregs[1], (&(*grp)[SPARC_MC_G1]));
630 __get_user(env->gregs[2], (&(*grp)[SPARC_MC_G2]));
631 __get_user(env->gregs[3], (&(*grp)[SPARC_MC_G3]));
632 __get_user(env->gregs[4], (&(*grp)[SPARC_MC_G4]));
633 __get_user(env->gregs[5], (&(*grp)[SPARC_MC_G5]));
634 __get_user(env->gregs[6], (&(*grp)[SPARC_MC_G6]));
635 /* Skip g7 as that's the thread register in userspace */
636
637 /*
638 * Note that unlike the kernel, we didn't need to mess with the
639 * guest register window state to save it into a pt_regs to run
640 * the kernel. So for us the guest's O regs are still in WREG_O*
641 * (unlike the kernel which has put them in UREG_I* in a pt_regs)
642 * and the fp and i7 are still in WREG_I6 and WREG_I7 and don't
643 * need to be written back to userspace memory.
644 */
645 __get_user(env->regwptr[WREG_O0], (&(*grp)[SPARC_MC_O0]));
646 __get_user(env->regwptr[WREG_O1], (&(*grp)[SPARC_MC_O1]));
647 __get_user(env->regwptr[WREG_O2], (&(*grp)[SPARC_MC_O2]));
648 __get_user(env->regwptr[WREG_O3], (&(*grp)[SPARC_MC_O3]));
649 __get_user(env->regwptr[WREG_O4], (&(*grp)[SPARC_MC_O4]));
650 __get_user(env->regwptr[WREG_O5], (&(*grp)[SPARC_MC_O5]));
651 __get_user(env->regwptr[WREG_O6], (&(*grp)[SPARC_MC_O6]));
652 __get_user(env->regwptr[WREG_O7], (&(*grp)[SPARC_MC_O7]));
653
654 __get_user(env->regwptr[WREG_FP], &(ucp->tuc_mcontext.mc_fp));
655 __get_user(env->regwptr[WREG_I7], &(ucp->tuc_mcontext.mc_i7));
656
657 fpup = &ucp->tuc_mcontext.mc_fpregs;
658
659 __get_user(fenab, &(fpup->mcfpu_enab));
660 if (fenab) {
661 abi_ulong fprs;
662 abi_ulong fsr;
663
664 /*
665 * We use the FPRS from the guest only in deciding whether
666 * to restore the upper, lower, or both banks of the FPU regs.
667 * The kernel here writes the FPU register data into the
668 * process's current_thread_info state and unconditionally
669 * clears FPRS and TSTATE_PEF: this disables the FPU so that the
670 * next FPU-disabled trap will copy the data out of
671 * current_thread_info and into the real FPU registers.
672 * QEMU doesn't need to handle lazy-FPU-state-restoring like that,
673 * so we always load the data directly into the FPU registers
674 * and leave FPRS and TSTATE_PEF alone (so the FPU stays enabled).
675 * Note that because we (and the kernel) always write zeroes for
676 * the fenab and fprs in sparc64_get_context() none of this code
677 * will execute unless the guest manually constructed or changed
678 * the context structure.
679 */
680 __get_user(fprs, &(fpup->mcfpu_fprs));
681 if (fprs & FPRS_DL) {
682 for (i = 0; i < 16; i++) {
683 __get_user(env->fpr[i].ll, &(fpup->mcfpu_fregs.dregs[i]));
684 }
685 }
686 if (fprs & FPRS_DU) {
687 for (i = 16; i < 32; i++) {
688 __get_user(env->fpr[i].ll, &(fpup->mcfpu_fregs.dregs[i]));
689 }
690 }
691 __get_user(fsr, &(fpup->mcfpu_fsr));
692 cpu_put_fsr(env, fsr);
693 __get_user(env->gsr, &(fpup->mcfpu_gsr));
694 }
695 unlock_user_struct(ucp, ucp_addr, 0);
696 return;
697 do_sigsegv:
698 unlock_user_struct(ucp, ucp_addr, 0);
699 force_sig(TARGET_SIGSEGV);
700 }
701
sparc64_get_context(CPUSPARCState * env)702 void sparc64_get_context(CPUSPARCState *env)
703 {
704 abi_ulong ucp_addr;
705 struct target_ucontext *ucp;
706 target_mc_gregset_t *grp;
707 target_mcontext_t *mcp;
708 int err;
709 unsigned int i;
710 target_sigset_t target_set;
711 sigset_t set;
712
713 ucp_addr = env->regwptr[WREG_O0];
714 if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0)) {
715 goto do_sigsegv;
716 }
717
718 memset(ucp, 0, sizeof(*ucp));
719
720 mcp = &ucp->tuc_mcontext;
721 grp = &mcp->mc_gregs;
722
723 /* Skip over the trap instruction, first. */
724 env->pc = env->npc;
725 env->npc += 4;
726
727 /* If we're only reading the signal mask then do_sigprocmask()
728 * is guaranteed not to fail, which is important because we don't
729 * have any way to signal a failure or restart this operation since
730 * this is not a normal syscall.
731 */
732 err = do_sigprocmask(0, NULL, &set);
733 assert(err == 0);
734 host_to_target_sigset_internal(&target_set, &set);
735 if (TARGET_NSIG_WORDS == 1) {
736 __put_user(target_set.sig[0],
737 (abi_ulong *)&ucp->tuc_sigmask);
738 } else {
739 abi_ulong *src, *dst;
740 src = target_set.sig;
741 dst = ucp->tuc_sigmask.sig;
742 for (i = 0; i < TARGET_NSIG_WORDS; i++, dst++, src++) {
743 __put_user(*src, dst);
744 }
745 }
746
747 __put_user(sparc64_tstate(env), &((*grp)[SPARC_MC_TSTATE]));
748 __put_user(env->pc, &((*grp)[SPARC_MC_PC]));
749 __put_user(env->npc, &((*grp)[SPARC_MC_NPC]));
750 __put_user(env->y, &((*grp)[SPARC_MC_Y]));
751 __put_user(env->gregs[1], &((*grp)[SPARC_MC_G1]));
752 __put_user(env->gregs[2], &((*grp)[SPARC_MC_G2]));
753 __put_user(env->gregs[3], &((*grp)[SPARC_MC_G3]));
754 __put_user(env->gregs[4], &((*grp)[SPARC_MC_G4]));
755 __put_user(env->gregs[5], &((*grp)[SPARC_MC_G5]));
756 __put_user(env->gregs[6], &((*grp)[SPARC_MC_G6]));
757 __put_user(env->gregs[7], &((*grp)[SPARC_MC_G7]));
758
759 /*
760 * Note that unlike the kernel, we didn't need to mess with the
761 * guest register window state to save it into a pt_regs to run
762 * the kernel. So for us the guest's O regs are still in WREG_O*
763 * (unlike the kernel which has put them in UREG_I* in a pt_regs)
764 * and the fp and i7 are still in WREG_I6 and WREG_I7 and don't
765 * need to be fished out of userspace memory.
766 */
767 __put_user(env->regwptr[WREG_O0], &((*grp)[SPARC_MC_O0]));
768 __put_user(env->regwptr[WREG_O1], &((*grp)[SPARC_MC_O1]));
769 __put_user(env->regwptr[WREG_O2], &((*grp)[SPARC_MC_O2]));
770 __put_user(env->regwptr[WREG_O3], &((*grp)[SPARC_MC_O3]));
771 __put_user(env->regwptr[WREG_O4], &((*grp)[SPARC_MC_O4]));
772 __put_user(env->regwptr[WREG_O5], &((*grp)[SPARC_MC_O5]));
773 __put_user(env->regwptr[WREG_O6], &((*grp)[SPARC_MC_O6]));
774 __put_user(env->regwptr[WREG_O7], &((*grp)[SPARC_MC_O7]));
775
776 __put_user(env->regwptr[WREG_FP], &(mcp->mc_fp));
777 __put_user(env->regwptr[WREG_I7], &(mcp->mc_i7));
778
779 /*
780 * We don't write out the FPU state. This matches the kernel's
781 * implementation (which has the code for doing this but
782 * hidden behind an "if (fenab)" where fenab is always 0).
783 */
784
785 unlock_user_struct(ucp, ucp_addr, 1);
786 return;
787 do_sigsegv:
788 unlock_user_struct(ucp, ucp_addr, 1);
789 force_sig(TARGET_SIGSEGV);
790 }
791 #endif /* TARGET_SPARC64 */
792