2 * Emulation of Linux signals
4 * Copyright (c) 2003 Fabrice Bellard
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.
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.
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/>.
19 #include "qemu/osdep.h"
21 #include "user-internals.h"
22 #include "signal-common.h"
23 #include "linux-user/trace.h"
25 /* A Sparc register window */
26 struct target_reg_window
{
31 /* A Sparc stack frame. */
32 struct target_stackf
{
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.
38 struct target_reg_window win
;
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.
47 struct target_siginfo_fpu
{
49 uint64_t si_double_regs
[32];
54 /* It is more convenient for qemu to move doubles, not singles. */
55 uint64_t si_double_regs
[16];
65 #ifdef TARGET_ARCH_HAS_SETUP_FRAME
66 struct target_signal_frame
{
67 struct target_stackf ss
;
68 struct target_pt_regs regs
;
71 uint32_t insns
[2] QEMU_ALIGNED(8);
72 abi_ulong extramask
[TARGET_NSIG_WORDS
- 1];
73 abi_ulong extra_size
; /* Should be 0 */
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)
91 abi_ulong extra_size
; /* Should be 0 */
96 static abi_ulong
get_sigframe(struct target_sigaction
*sa
,
100 abi_ulong sp
= get_sp_from_cpustate(env
);
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.
106 if (on_sig_stack(sp
) && !likely(on_sig_stack(sp
- framesize
))) {
110 /* This is the X/Open sanctioned signal stack switching. */
111 sp
= target_sigsp(sp
, sa
) - framesize
;
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
125 static void save_pt_regs(struct target_pt_regs
*regs
, CPUSPARCState
*env
)
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
);
134 __put_user(cpu_get_psr(env
), ®s
->psr
);
137 __put_user(env
->pc
, ®s
->pc
);
138 __put_user(env
->npc
, ®s
->npc
);
139 __put_user(env
->y
, ®s
->y
);
141 for (i
= 0; i
< 8; i
++) {
142 __put_user(env
->gregs
[i
], ®s
->u_regs
[i
]);
144 for (i
= 0; i
< 8; i
++) {
145 __put_user(env
->regwptr
[WREG_O0
+ i
], ®s
->u_regs
[i
+ 8]);
149 static void restore_pt_regs(struct target_pt_regs
*regs
, CPUSPARCState
*env
)
153 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
154 /* User can only change condition codes and %asi in %tstate. */
156 __get_user(tstate
, ®s
->tstate
);
157 cpu_put_ccr(env
, tstate
>> 32);
158 env
->asi
= extract64(tstate
, 24, 8);
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.
166 __get_user(psr
, ®s
->psr
);
167 cpu_put_psr_icc(env
, psr
);
170 /* Note that pc and npc are handled in the caller. */
172 __get_user(env
->y
, ®s
->y
);
174 for (i
= 0; i
< 8; i
++) {
175 __get_user(env
->gregs
[i
], ®s
->u_regs
[i
]);
177 for (i
= 0; i
< 8; i
++) {
178 __get_user(env
->regwptr
[WREG_O0
+ i
], ®s
->u_regs
[i
+ 8]);
182 static void save_reg_win(struct target_reg_window
*win
, CPUSPARCState
*env
)
186 for (i
= 0; i
< 8; i
++) {
187 __put_user(env
->regwptr
[i
+ WREG_L0
], &win
->locals
[i
]);
189 for (i
= 0; i
< 8; i
++) {
190 __put_user(env
->regwptr
[i
+ WREG_I0
], &win
->ins
[i
]);
194 static void save_fpu(struct target_siginfo_fpu
*fpu
, CPUSPARCState
*env
)
198 #ifdef TARGET_SPARC64
199 for (i
= 0; i
< 32; ++i
) {
200 __put_user(env
->fpr
[i
].ll
, &fpu
->si_double_regs
[i
]);
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
);
206 for (i
= 0; i
< 16; ++i
) {
207 __put_user(env
->fpr
[i
].ll
, &fpu
->si_double_regs
[i
]);
209 __put_user(cpu_get_fsr(env
), &fpu
->si_fsr
);
210 __put_user(0, &fpu
->si_fpqdepth
);
214 static void restore_fpu(struct target_siginfo_fpu
*fpu
, CPUSPARCState
*env
)
219 #ifdef TARGET_SPARC64
221 __get_user(fprs
, &fpu
->si_fprs
);
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
]);
229 if (fprs
& FPRS_DU
) {
230 for (i
= 16; i
< 32; ++i
) {
231 __get_user(env
->fpr
[i
].ll
, &fpu
->si_double_regs
[i
]);
234 __get_user(env
->gsr
, &fpu
->si_gsr
);
237 for (i
= 0; i
< 16; ++i
) {
238 __get_user(env
->fpr
[i
].ll
, &fpu
->si_double_regs
[i
]);
242 __get_user(fsr
, &fpu
->si_fsr
);
243 cpu_put_fsr(env
, fsr
);
246 #ifdef TARGET_ARCH_HAS_SETUP_FRAME
247 static void install_sigtramp(uint32_t *tramp
, int syscall
)
249 __put_user(0x82102000u
+ syscall
, &tramp
[0]); /* mov syscall, %g1 */
250 __put_user(0x91d02010u
, &tramp
[1]); /* t 0x10 */
253 void setup_frame(int sig
, struct target_sigaction
*ka
,
254 target_sigset_t
*set
, CPUSPARCState
*env
)
257 struct target_signal_frame
*sf
;
258 size_t sf_size
= sizeof(*sf
) + sizeof(struct target_siginfo_fpu
);
261 sf_addr
= get_sigframe(ka
, env
, sf_size
);
262 trace_user_setup_frame(env
, sf_addr
);
264 sf
= lock_user(VERIFY_WRITE
, sf_addr
, sf_size
, 0);
270 /* 2. Save the current process state */
271 save_pt_regs(&sf
->regs
, env
);
272 __put_user(0, &sf
->extra_size
);
274 save_fpu((struct target_siginfo_fpu
*)(sf
+ 1), env
);
275 __put_user(sf_addr
+ sizeof(*sf
), &sf
->fpu_save
);
277 __put_user(0, &sf
->rwin_save
); /* TODO: save_rwin_state */
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
]);
284 save_reg_win(&sf
->ss
.win
, env
);
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
);
294 /* 4. signal handler */
295 env
->pc
= ka
->_sa_handler
;
296 env
->npc
= env
->pc
+ 4;
298 /* 5. return to kernel instructions */
299 if (ka
->ka_restorer
) {
300 env
->regwptr
[WREG_O7
] = ka
->ka_restorer
;
302 /* Not used, but retain for ABI compatibility. */
303 install_sigtramp(sf
->insns
, TARGET_NR_sigreturn
);
304 env
->regwptr
[WREG_O7
] = default_sigreturn
;
306 unlock_user(sf
, sf_addr
, sf_size
);
308 #endif /* TARGET_ARCH_HAS_SETUP_FRAME */
310 void setup_rt_frame(int sig
, struct target_sigaction
*ka
,
311 target_siginfo_t
*info
,
312 target_sigset_t
*set
, CPUSPARCState
*env
)
315 struct target_rt_signal_frame
*sf
;
316 size_t sf_size
= sizeof(*sf
) + sizeof(struct target_siginfo_fpu
);
318 sf_addr
= get_sigframe(ka
, env
, sf_size
);
319 trace_user_setup_rt_frame(env
, sf_addr
);
321 sf
= lock_user(VERIFY_WRITE
, sf_addr
, sf_size
, 0);
327 /* 2. Save the current process state */
328 save_reg_win(&sf
->ss
.win
, env
);
329 save_pt_regs(&sf
->regs
, env
);
331 save_fpu((struct target_siginfo_fpu
*)(sf
+ 1), env
);
332 __put_user(sf_addr
+ sizeof(*sf
), &sf
->fpu_save
);
334 __put_user(0, &sf
->rwin_save
); /* TODO: save_rwin_state */
336 tswap_siginfo(&sf
->info
, info
);
337 tswap_sigset(&sf
->mask
, set
);
338 target_save_altstack(&sf
->stack
, env
);
341 __put_user(0, &sf
->extra_size
);
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
);
350 env
->regwptr
[WREG_O2
] =
351 sf_addr
+ offsetof(struct target_rt_signal_frame
, regs
);
353 env
->regwptr
[WREG_O2
] = env
->regwptr
[WREG_O1
];
356 /* 4. signal handler */
357 env
->pc
= ka
->_sa_handler
;
358 env
->npc
= env
->pc
+ 4;
360 /* 5. return to kernel instructions */
362 if (ka
->ka_restorer
) {
363 env
->regwptr
[WREG_O7
] = ka
->ka_restorer
;
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
;
370 env
->regwptr
[WREG_O7
] = ka
->ka_restorer
;
373 unlock_user(sf
, sf_addr
, sf_size
);
376 long do_sigreturn(CPUSPARCState
*env
)
378 #ifdef TARGET_ARCH_HAS_SETUP_FRAME
380 struct target_signal_frame
*sf
= NULL
;
381 abi_ulong pc
, npc
, ptr
;
386 sf_addr
= env
->regwptr
[WREG_SP
];
387 trace_user_do_sigreturn(env
, sf_addr
);
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)) {
394 /* Make sure stack pointer is aligned. */
395 __get_user(ptr
, &sf
->regs
.u_regs
[14]);
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) {
407 /* 2. Restore the state */
408 restore_pt_regs(&sf
->regs
, env
);
412 __get_user(ptr
, &sf
->fpu_save
);
414 struct target_siginfo_fpu
*fpu
;
415 if ((ptr
& 3) || !lock_user_struct(VERIFY_READ
, fpu
, ptr
, 1)) {
418 restore_fpu(fpu
, env
);
419 unlock_user_struct(fpu
, ptr
, 0);
422 __get_user(ptr
, &sf
->rwin_save
);
424 goto segv_and_exit
; /* TODO: restore_rwin */
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]);
432 target_to_host_sigset_internal(&host_set
, &set
);
433 set_sigmask(&host_set
);
435 unlock_user_struct(sf
, sf_addr
, 0);
436 return -QEMU_ESIGRETURN
;
439 unlock_user_struct(sf
, sf_addr
, 0);
440 force_sig(TARGET_SIGSEGV
);
441 return -QEMU_ESIGRETURN
;
443 return -TARGET_ENOSYS
;
447 long do_rt_sigreturn(CPUSPARCState
*env
)
449 abi_ulong sf_addr
, tpc
, tnpc
, ptr
;
450 struct target_rt_signal_frame
*sf
= NULL
;
453 sf_addr
= get_sp_from_cpustate(env
);
454 trace_user_do_rt_sigreturn(env
, sf_addr
);
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)) {
461 /* Validate SP alignment. */
462 __get_user(ptr
, &sf
->regs
.u_regs
[8 + WREG_SP
]);
463 if ((ptr
+ TARGET_STACK_BIAS
) & 7) {
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) {
474 /* 2. Restore the state */
475 restore_pt_regs(&sf
->regs
, env
);
477 __get_user(ptr
, &sf
->fpu_save
);
479 struct target_siginfo_fpu
*fpu
;
480 if ((ptr
& 7) || !lock_user_struct(VERIFY_READ
, fpu
, ptr
, 1)) {
483 restore_fpu(fpu
, env
);
484 unlock_user_struct(fpu
, ptr
, 0);
487 __get_user(ptr
, &sf
->rwin_save
);
489 goto segv_and_exit
; /* TODO: restore_rwin_state */
492 target_restore_altstack(&sf
->stack
, env
);
493 target_to_host_sigset(&set
, &sf
->mask
);
499 unlock_user_struct(sf
, sf_addr
, 0);
500 return -QEMU_ESIGRETURN
;
503 unlock_user_struct(sf
, sf_addr
, 0);
504 force_sig(TARGET_SIGSEGV
);
505 return -QEMU_ESIGRETURN
;
509 void setup_sigtramp(abi_ulong sigtramp_page
)
511 uint32_t *tramp
= lock_user(VERIFY_WRITE
, sigtramp_page
, 2 * 8, 0);
512 assert(tramp
!= NULL
);
514 default_sigreturn
= sigtramp_page
;
515 install_sigtramp(tramp
, TARGET_NR_sigreturn
);
517 default_rt_sigreturn
= sigtramp_page
+ 8;
518 install_sigtramp(tramp
+ 2, TARGET_NR_rt_sigreturn
);
520 unlock_user(tramp
, sigtramp_page
, 2 * 8);
524 #ifdef TARGET_SPARC64
525 #define SPARC_MC_TSTATE 0
526 #define SPARC_MC_PC 1
527 #define SPARC_MC_NPC 2
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
546 typedef abi_ulong target_mc_greg_t
;
547 typedef target_mc_greg_t target_mc_gregset_t
[SPARC_MC_NGREG
];
549 struct target_mc_fq
{
555 * Note the manual 16-alignment; the kernel gets this because it
556 * includes a "long double qregs[16]" in the mcpu_fregs union,
559 struct target_mc_fpu
{
563 //uint128_t qregs[16];
566 abi_ulong mcfpu_fprs
;
569 unsigned char mcfpu_qcnt
;
570 unsigned char mcfpu_qentsz
;
571 unsigned char mcfpu_enab
;
572 } __attribute__((aligned(16)));
573 typedef struct target_mc_fpu target_mc_fpu_t
;
576 target_mc_gregset_t mc_gregs
;
577 target_mc_greg_t mc_fp
;
578 target_mc_greg_t mc_i7
;
579 target_mc_fpu_t mc_fpregs
;
582 struct target_ucontext
{
585 target_sigset_t tuc_sigmask
;
586 target_mcontext_t tuc_mcontext
;
589 /* {set, get}context() needed for 64-bit SparcLinux userland. */
590 void sparc64_set_context(CPUSPARCState
*env
)
593 struct target_ucontext
*ucp
;
594 target_mc_gregset_t
*grp
;
595 target_mc_fpu_t
*fpup
;
596 target_ulong pc
, npc
, tstate
;
600 ucp_addr
= env
->regwptr
[WREG_O0
];
601 if (!lock_user_struct(VERIFY_READ
, ucp
, ucp_addr
, 1)) {
604 grp
= &ucp
->tuc_mcontext
.mc_gregs
;
605 __get_user(pc
, &((*grp
)[SPARC_MC_PC
]));
606 __get_user(npc
, &((*grp
)[SPARC_MC_NPC
]));
607 if ((pc
| npc
) & 3) {
610 if (env
->regwptr
[WREG_O1
]) {
611 target_sigset_t target_set
;
614 if (TARGET_NSIG_WORDS
== 1) {
615 __get_user(target_set
.sig
[0], &ucp
->tuc_sigmask
.sig
[0]);
617 abi_ulong
*src
, *dst
;
618 src
= ucp
->tuc_sigmask
.sig
;
619 dst
= target_set
.sig
;
620 for (i
= 0; i
< TARGET_NSIG_WORDS
; i
++, dst
++, src
++) {
621 __get_user(*dst
, src
);
624 target_to_host_sigset_internal(&set
, &target_set
);
629 __get_user(env
->y
, &((*grp
)[SPARC_MC_Y
]));
630 __get_user(tstate
, &((*grp
)[SPARC_MC_TSTATE
]));
631 /* Honour TSTATE_ASI, TSTATE_ICC and TSTATE_XCC only */
632 env
->asi
= (tstate
>> 24) & 0xff;
633 cpu_put_ccr(env
, (tstate
>> 32) & 0xff);
634 __get_user(env
->gregs
[1], (&(*grp
)[SPARC_MC_G1
]));
635 __get_user(env
->gregs
[2], (&(*grp
)[SPARC_MC_G2
]));
636 __get_user(env
->gregs
[3], (&(*grp
)[SPARC_MC_G3
]));
637 __get_user(env
->gregs
[4], (&(*grp
)[SPARC_MC_G4
]));
638 __get_user(env
->gregs
[5], (&(*grp
)[SPARC_MC_G5
]));
639 __get_user(env
->gregs
[6], (&(*grp
)[SPARC_MC_G6
]));
640 /* Skip g7 as that's the thread register in userspace */
643 * Note that unlike the kernel, we didn't need to mess with the
644 * guest register window state to save it into a pt_regs to run
645 * the kernel. So for us the guest's O regs are still in WREG_O*
646 * (unlike the kernel which has put them in UREG_I* in a pt_regs)
647 * and the fp and i7 are still in WREG_I6 and WREG_I7 and don't
648 * need to be written back to userspace memory.
650 __get_user(env
->regwptr
[WREG_O0
], (&(*grp
)[SPARC_MC_O0
]));
651 __get_user(env
->regwptr
[WREG_O1
], (&(*grp
)[SPARC_MC_O1
]));
652 __get_user(env
->regwptr
[WREG_O2
], (&(*grp
)[SPARC_MC_O2
]));
653 __get_user(env
->regwptr
[WREG_O3
], (&(*grp
)[SPARC_MC_O3
]));
654 __get_user(env
->regwptr
[WREG_O4
], (&(*grp
)[SPARC_MC_O4
]));
655 __get_user(env
->regwptr
[WREG_O5
], (&(*grp
)[SPARC_MC_O5
]));
656 __get_user(env
->regwptr
[WREG_O6
], (&(*grp
)[SPARC_MC_O6
]));
657 __get_user(env
->regwptr
[WREG_O7
], (&(*grp
)[SPARC_MC_O7
]));
659 __get_user(env
->regwptr
[WREG_FP
], &(ucp
->tuc_mcontext
.mc_fp
));
660 __get_user(env
->regwptr
[WREG_I7
], &(ucp
->tuc_mcontext
.mc_i7
));
662 fpup
= &ucp
->tuc_mcontext
.mc_fpregs
;
664 __get_user(fenab
, &(fpup
->mcfpu_enab
));
670 * We use the FPRS from the guest only in deciding whether
671 * to restore the upper, lower, or both banks of the FPU regs.
672 * The kernel here writes the FPU register data into the
673 * process's current_thread_info state and unconditionally
674 * clears FPRS and TSTATE_PEF: this disables the FPU so that the
675 * next FPU-disabled trap will copy the data out of
676 * current_thread_info and into the real FPU registers.
677 * QEMU doesn't need to handle lazy-FPU-state-restoring like that,
678 * so we always load the data directly into the FPU registers
679 * and leave FPRS and TSTATE_PEF alone (so the FPU stays enabled).
680 * Note that because we (and the kernel) always write zeroes for
681 * the fenab and fprs in sparc64_get_context() none of this code
682 * will execute unless the guest manually constructed or changed
683 * the context structure.
685 __get_user(fprs
, &(fpup
->mcfpu_fprs
));
686 if (fprs
& FPRS_DL
) {
687 for (i
= 0; i
< 16; i
++) {
688 __get_user(env
->fpr
[i
].ll
, &(fpup
->mcfpu_fregs
.dregs
[i
]));
691 if (fprs
& FPRS_DU
) {
692 for (i
= 16; i
< 32; i
++) {
693 __get_user(env
->fpr
[i
].ll
, &(fpup
->mcfpu_fregs
.dregs
[i
]));
696 __get_user(fsr
, &(fpup
->mcfpu_fsr
));
697 cpu_put_fsr(env
, fsr
);
698 __get_user(env
->gsr
, &(fpup
->mcfpu_gsr
));
700 unlock_user_struct(ucp
, ucp_addr
, 0);
703 unlock_user_struct(ucp
, ucp_addr
, 0);
704 force_sig(TARGET_SIGSEGV
);
707 void sparc64_get_context(CPUSPARCState
*env
)
710 struct target_ucontext
*ucp
;
711 target_mc_gregset_t
*grp
;
712 target_mcontext_t
*mcp
;
715 target_sigset_t target_set
;
718 ucp_addr
= env
->regwptr
[WREG_O0
];
719 if (!lock_user_struct(VERIFY_WRITE
, ucp
, ucp_addr
, 0)) {
723 memset(ucp
, 0, sizeof(*ucp
));
725 mcp
= &ucp
->tuc_mcontext
;
726 grp
= &mcp
->mc_gregs
;
728 /* Skip over the trap instruction, first. */
732 /* If we're only reading the signal mask then do_sigprocmask()
733 * is guaranteed not to fail, which is important because we don't
734 * have any way to signal a failure or restart this operation since
735 * this is not a normal syscall.
737 err
= do_sigprocmask(0, NULL
, &set
);
739 host_to_target_sigset_internal(&target_set
, &set
);
740 if (TARGET_NSIG_WORDS
== 1) {
741 __put_user(target_set
.sig
[0],
742 (abi_ulong
*)&ucp
->tuc_sigmask
);
744 abi_ulong
*src
, *dst
;
745 src
= target_set
.sig
;
746 dst
= ucp
->tuc_sigmask
.sig
;
747 for (i
= 0; i
< TARGET_NSIG_WORDS
; i
++, dst
++, src
++) {
748 __put_user(*src
, dst
);
752 __put_user(sparc64_tstate(env
), &((*grp
)[SPARC_MC_TSTATE
]));
753 __put_user(env
->pc
, &((*grp
)[SPARC_MC_PC
]));
754 __put_user(env
->npc
, &((*grp
)[SPARC_MC_NPC
]));
755 __put_user(env
->y
, &((*grp
)[SPARC_MC_Y
]));
756 __put_user(env
->gregs
[1], &((*grp
)[SPARC_MC_G1
]));
757 __put_user(env
->gregs
[2], &((*grp
)[SPARC_MC_G2
]));
758 __put_user(env
->gregs
[3], &((*grp
)[SPARC_MC_G3
]));
759 __put_user(env
->gregs
[4], &((*grp
)[SPARC_MC_G4
]));
760 __put_user(env
->gregs
[5], &((*grp
)[SPARC_MC_G5
]));
761 __put_user(env
->gregs
[6], &((*grp
)[SPARC_MC_G6
]));
762 __put_user(env
->gregs
[7], &((*grp
)[SPARC_MC_G7
]));
765 * Note that unlike the kernel, we didn't need to mess with the
766 * guest register window state to save it into a pt_regs to run
767 * the kernel. So for us the guest's O regs are still in WREG_O*
768 * (unlike the kernel which has put them in UREG_I* in a pt_regs)
769 * and the fp and i7 are still in WREG_I6 and WREG_I7 and don't
770 * need to be fished out of userspace memory.
772 __put_user(env
->regwptr
[WREG_O0
], &((*grp
)[SPARC_MC_O0
]));
773 __put_user(env
->regwptr
[WREG_O1
], &((*grp
)[SPARC_MC_O1
]));
774 __put_user(env
->regwptr
[WREG_O2
], &((*grp
)[SPARC_MC_O2
]));
775 __put_user(env
->regwptr
[WREG_O3
], &((*grp
)[SPARC_MC_O3
]));
776 __put_user(env
->regwptr
[WREG_O4
], &((*grp
)[SPARC_MC_O4
]));
777 __put_user(env
->regwptr
[WREG_O5
], &((*grp
)[SPARC_MC_O5
]));
778 __put_user(env
->regwptr
[WREG_O6
], &((*grp
)[SPARC_MC_O6
]));
779 __put_user(env
->regwptr
[WREG_O7
], &((*grp
)[SPARC_MC_O7
]));
781 __put_user(env
->regwptr
[WREG_FP
], &(mcp
->mc_fp
));
782 __put_user(env
->regwptr
[WREG_I7
], &(mcp
->mc_i7
));
785 * We don't write out the FPU state. This matches the kernel's
786 * implementation (which has the code for doing this but
787 * hidden behind an "if (fenab)" where fenab is always 0).
790 unlock_user_struct(ucp
, ucp_addr
, 1);
793 unlock_user_struct(ucp
, ucp_addr
, 1);
794 force_sig(TARGET_SIGSEGV
);
796 #endif /* TARGET_SPARC64 */