?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
linux-user: Support for restarting system calls for ARM targets
[qemu.git] / linux-user / signal.c
blob14e58b05b28279263a04c277542471bdefad417d
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 <sys/ucontext.h>
21 #include <sys/resource.h>
22
23 #include "qemu.h"
24 #include "qemu-common.h"
25 #include "target_signal.h"
26 #include "trace.h"
27
28 static struct target_sigaltstack target_sigaltstack_used = {
29 .ss_sp = 0,
30 .ss_size = 0,
31 .ss_flags = TARGET_SS_DISABLE,
32 };
33
34 static struct target_sigaction sigact_table[TARGET_NSIG];
35
36 static void host_signal_handler(int host_signum, siginfo_t *info,
37 void *puc);
38
39 static uint8_t host_to_target_signal_table[_NSIG] = {
40 [SIGHUP] = TARGET_SIGHUP,
41 [SIGINT] = TARGET_SIGINT,
42 [SIGQUIT] = TARGET_SIGQUIT,
43 [SIGILL] = TARGET_SIGILL,
44 [SIGTRAP] = TARGET_SIGTRAP,
45 [SIGABRT] = TARGET_SIGABRT,
46 /* [SIGIOT] = TARGET_SIGIOT,*/
47 [SIGBUS] = TARGET_SIGBUS,
48 [SIGFPE] = TARGET_SIGFPE,
49 [SIGKILL] = TARGET_SIGKILL,
50 [SIGUSR1] = TARGET_SIGUSR1,
51 [SIGSEGV] = TARGET_SIGSEGV,
52 [SIGUSR2] = TARGET_SIGUSR2,
53 [SIGPIPE] = TARGET_SIGPIPE,
54 [SIGALRM] = TARGET_SIGALRM,
55 [SIGTERM] = TARGET_SIGTERM,
56 #ifdef SIGSTKFLT
57 [SIGSTKFLT] = TARGET_SIGSTKFLT,
58 #endif
59 [SIGCHLD] = TARGET_SIGCHLD,
60 [SIGCONT] = TARGET_SIGCONT,
61 [SIGSTOP] = TARGET_SIGSTOP,
62 [SIGTSTP] = TARGET_SIGTSTP,
63 [SIGTTIN] = TARGET_SIGTTIN,
64 [SIGTTOU] = TARGET_SIGTTOU,
65 [SIGURG] = TARGET_SIGURG,
66 [SIGXCPU] = TARGET_SIGXCPU,
67 [SIGXFSZ] = TARGET_SIGXFSZ,
68 [SIGVTALRM] = TARGET_SIGVTALRM,
69 [SIGPROF] = TARGET_SIGPROF,
70 [SIGWINCH] = TARGET_SIGWINCH,
71 [SIGIO] = TARGET_SIGIO,
72 [SIGPWR] = TARGET_SIGPWR,
73 [SIGSYS] = TARGET_SIGSYS,
74 /* next signals stay the same */
75 /* Nasty hack: Reverse SIGRTMIN and SIGRTMAX to avoid overlap with
76 host libpthread signals. This assumes no one actually uses SIGRTMAX :-/
77 To fix this properly we need to do manual signal delivery multiplexed
78 over a single host signal. */
79 [__SIGRTMIN] = __SIGRTMAX,
80 [__SIGRTMAX] = __SIGRTMIN,
81 };
82 static uint8_t target_to_host_signal_table[_NSIG];
83
84 static inline int on_sig_stack(unsigned long sp)
85 {
86 return (sp - target_sigaltstack_used.ss_sp
87 < target_sigaltstack_used.ss_size);
88 }
89
90 static inline int sas_ss_flags(unsigned long sp)
91 {
92 return (target_sigaltstack_used.ss_size == 0 ? SS_DISABLE
93 : on_sig_stack(sp) ? SS_ONSTACK : 0);
94 }
95
96 int host_to_target_signal(int sig)
97 {
98 if (sig < 0 || sig >= _NSIG)
99 return sig;
100 return host_to_target_signal_table[sig];
101 }
102
103 int target_to_host_signal(int sig)
104 {
105 if (sig < 0 || sig >= _NSIG)
106 return sig;
107 return target_to_host_signal_table[sig];
108 }
109
110 static inline void target_sigemptyset(target_sigset_t *set)
111 {
112 memset(set, 0, sizeof(*set));
113 }
114
115 static inline void target_sigaddset(target_sigset_t *set, int signum)
116 {
117 signum--;
118 abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
119 set->sig[signum / TARGET_NSIG_BPW] |= mask;
120 }
121
122 static inline int target_sigismember(const target_sigset_t *set, int signum)
123 {
124 signum--;
125 abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
126 return ((set->sig[signum / TARGET_NSIG_BPW] & mask) != 0);
127 }
128
129 static void host_to_target_sigset_internal(target_sigset_t *d,
130 const sigset_t *s)
131 {
132 int i;
133 target_sigemptyset(d);
134 for (i = 1; i <= TARGET_NSIG; i++) {
135 if (sigismember(s, i)) {
136 target_sigaddset(d, host_to_target_signal(i));
137 }
138 }
139 }
140
141 void host_to_target_sigset(target_sigset_t *d, const sigset_t *s)
142 {
143 target_sigset_t d1;
144 int i;
145
146 host_to_target_sigset_internal(&d1, s);
147 for(i = 0;i < TARGET_NSIG_WORDS; i++)
148 d->sig[i] = tswapal(d1.sig[i]);
149 }
150
151 static void target_to_host_sigset_internal(sigset_t *d,
152 const target_sigset_t *s)
153 {
154 int i;
155 sigemptyset(d);
156 for (i = 1; i <= TARGET_NSIG; i++) {
157 if (target_sigismember(s, i)) {
158 sigaddset(d, target_to_host_signal(i));
159 }
160 }
161 }
162
163 void target_to_host_sigset(sigset_t *d, const target_sigset_t *s)
164 {
165 target_sigset_t s1;
166 int i;
167
168 for(i = 0;i < TARGET_NSIG_WORDS; i++)
169 s1.sig[i] = tswapal(s->sig[i]);
170 target_to_host_sigset_internal(d, &s1);
171 }
172
173 void host_to_target_old_sigset(abi_ulong *old_sigset,
174 const sigset_t *sigset)
175 {
176 target_sigset_t d;
177 host_to_target_sigset(&d, sigset);
178 *old_sigset = d.sig[0];
179 }
180
181 void target_to_host_old_sigset(sigset_t *sigset,
182 const abi_ulong *old_sigset)
183 {
184 target_sigset_t d;
185 int i;
186
187 d.sig[0] = *old_sigset;
188 for(i = 1;i < TARGET_NSIG_WORDS; i++)
189 d.sig[i] = 0;
190 target_to_host_sigset(sigset, &d);
191 }
192
193 /* Wrapper for sigprocmask function
194 * Emulates a sigprocmask in a safe way for the guest. Note that set and oldset
195 * are host signal set, not guest ones. This wraps the sigprocmask host calls
196 * that should be protected (calls originated from guest)
197 */
198 int do_sigprocmask(int how, const sigset_t *set, sigset_t *oldset)
199 {
200 int ret;
201 sigset_t val;
202 sigset_t *temp = NULL;
203 CPUState *cpu = thread_cpu;
204 TaskState *ts = (TaskState *)cpu->opaque;
205 bool segv_was_blocked = ts->sigsegv_blocked;
206
207 if (set) {
208 bool has_sigsegv = sigismember(set, SIGSEGV);
209 val = *set;
210 temp = &val;
211
212 sigdelset(temp, SIGSEGV);
213
214 switch (how) {
215 case SIG_BLOCK:
216 if (has_sigsegv) {
217 ts->sigsegv_blocked = true;
218 }
219 break;
220 case SIG_UNBLOCK:
221 if (has_sigsegv) {
222 ts->sigsegv_blocked = false;
223 }
224 break;
225 case SIG_SETMASK:
226 ts->sigsegv_blocked = has_sigsegv;
227 break;
228 default:
229 g_assert_not_reached();
230 }
231 }
232
233 ret = sigprocmask(how, temp, oldset);
234
235 if (oldset && segv_was_blocked) {
236 sigaddset(oldset, SIGSEGV);
237 }
238
239 return ret;
240 }
241
242 /* siginfo conversion */
243
244 static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo,
245 const siginfo_t *info)
246 {
247 int sig = host_to_target_signal(info->si_signo);
248 tinfo->si_signo = sig;
249 tinfo->si_errno = 0;
250 tinfo->si_code = info->si_code;
251
252 if (sig == TARGET_SIGILL || sig == TARGET_SIGFPE || sig == TARGET_SIGSEGV
253 || sig == TARGET_SIGBUS || sig == TARGET_SIGTRAP) {
254 /* Should never come here, but who knows. The information for
255 the target is irrelevant. */
256 tinfo->_sifields._sigfault._addr = 0;
257 } else if (sig == TARGET_SIGIO) {
258 tinfo->_sifields._sigpoll._band = info->si_band;
259 tinfo->_sifields._sigpoll._fd = info->si_fd;
260 } else if (sig == TARGET_SIGCHLD) {
261 tinfo->_sifields._sigchld._pid = info->si_pid;
262 tinfo->_sifields._sigchld._uid = info->si_uid;
263 tinfo->_sifields._sigchld._status
264 = host_to_target_waitstatus(info->si_status);
265 tinfo->_sifields._sigchld._utime = info->si_utime;
266 tinfo->_sifields._sigchld._stime = info->si_stime;
267 } else if (sig >= TARGET_SIGRTMIN) {
268 tinfo->_sifields._rt._pid = info->si_pid;
269 tinfo->_sifields._rt._uid = info->si_uid;
270 /* XXX: potential problem if 64 bit */
271 tinfo->_sifields._rt._sigval.sival_ptr
272 = (abi_ulong)(unsigned long)info->si_value.sival_ptr;
273 }
274 }
275
276 static void tswap_siginfo(target_siginfo_t *tinfo,
277 const target_siginfo_t *info)
278 {
279 int sig = info->si_signo;
280 tinfo->si_signo = tswap32(sig);
281 tinfo->si_errno = tswap32(info->si_errno);
282 tinfo->si_code = tswap32(info->si_code);
283
284 if (sig == TARGET_SIGILL || sig == TARGET_SIGFPE || sig == TARGET_SIGSEGV
285 || sig == TARGET_SIGBUS || sig == TARGET_SIGTRAP) {
286 tinfo->_sifields._sigfault._addr
287 = tswapal(info->_sifields._sigfault._addr);
288 } else if (sig == TARGET_SIGIO) {
289 tinfo->_sifields._sigpoll._band
290 = tswap32(info->_sifields._sigpoll._band);
291 tinfo->_sifields._sigpoll._fd = tswap32(info->_sifields._sigpoll._fd);
292 } else if (sig == TARGET_SIGCHLD) {
293 tinfo->_sifields._sigchld._pid
294 = tswap32(info->_sifields._sigchld._pid);
295 tinfo->_sifields._sigchld._uid
296 = tswap32(info->_sifields._sigchld._uid);
297 tinfo->_sifields._sigchld._status
298 = tswap32(info->_sifields._sigchld._status);
299 tinfo->_sifields._sigchld._utime
300 = tswapal(info->_sifields._sigchld._utime);
301 tinfo->_sifields._sigchld._stime
302 = tswapal(info->_sifields._sigchld._stime);
303 } else if (sig >= TARGET_SIGRTMIN) {
304 tinfo->_sifields._rt._pid = tswap32(info->_sifields._rt._pid);
305 tinfo->_sifields._rt._uid = tswap32(info->_sifields._rt._uid);
306 tinfo->_sifields._rt._sigval.sival_ptr
307 = tswapal(info->_sifields._rt._sigval.sival_ptr);
308 }
309 }
310
311
312 void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
313 {
314 host_to_target_siginfo_noswap(tinfo, info);
315 tswap_siginfo(tinfo, tinfo);
316 }
317
318 /* XXX: we support only POSIX RT signals are used. */
319 /* XXX: find a solution for 64 bit (additional malloced data is needed) */
320 void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)
321 {
322 info->si_signo = tswap32(tinfo->si_signo);
323 info->si_errno = tswap32(tinfo->si_errno);
324 info->si_code = tswap32(tinfo->si_code);
325 info->si_pid = tswap32(tinfo->_sifields._rt._pid);
326 info->si_uid = tswap32(tinfo->_sifields._rt._uid);
327 info->si_value.sival_ptr =
328 (void *)(long)tswapal(tinfo->_sifields._rt._sigval.sival_ptr);
329 }
330
331 static int fatal_signal (int sig)
332 {
333 switch (sig) {
334 case TARGET_SIGCHLD:
335 case TARGET_SIGURG:
336 case TARGET_SIGWINCH:
337 /* Ignored by default. */
338 return 0;
339 case TARGET_SIGCONT:
340 case TARGET_SIGSTOP:
341 case TARGET_SIGTSTP:
342 case TARGET_SIGTTIN:
343 case TARGET_SIGTTOU:
344 /* Job control signals. */
345 return 0;
346 default:
347 return 1;
348 }
349 }
350
351 /* returns 1 if given signal should dump core if not handled */
352 static int core_dump_signal(int sig)
353 {
354 switch (sig) {
355 case TARGET_SIGABRT:
356 case TARGET_SIGFPE:
357 case TARGET_SIGILL:
358 case TARGET_SIGQUIT:
359 case TARGET_SIGSEGV:
360 case TARGET_SIGTRAP:
361 case TARGET_SIGBUS:
362 return (1);
363 default:
364 return (0);
365 }
366 }
367
368 void signal_init(void)
369 {
370 struct sigaction act;
371 struct sigaction oact;
372 int i, j;
373 int host_sig;
374
375 /* generate signal conversion tables */
376 for(i = 1; i < _NSIG; i++) {
377 if (host_to_target_signal_table[i] == 0)
378 host_to_target_signal_table[i] = i;
379 }
380 for(i = 1; i < _NSIG; i++) {
381 j = host_to_target_signal_table[i];
382 target_to_host_signal_table[j] = i;
383 }
384
385 /* set all host signal handlers. ALL signals are blocked during
386 the handlers to serialize them. */
387 memset(sigact_table, 0, sizeof(sigact_table));
388
389 sigfillset(&act.sa_mask);
390 act.sa_flags = SA_SIGINFO;
391 act.sa_sigaction = host_signal_handler;
392 for(i = 1; i <= TARGET_NSIG; i++) {
393 host_sig = target_to_host_signal(i);
394 sigaction(host_sig, NULL, &oact);
395 if (oact.sa_sigaction == (void *)SIG_IGN) {
396 sigact_table[i - 1]._sa_handler = TARGET_SIG_IGN;
397 } else if (oact.sa_sigaction == (void *)SIG_DFL) {
398 sigact_table[i - 1]._sa_handler = TARGET_SIG_DFL;
399 }
400 /* If there's already a handler installed then something has
401 gone horribly wrong, so don't even try to handle that case. */
402 /* Install some handlers for our own use. We need at least
403 SIGSEGV and SIGBUS, to detect exceptions. We can not just
404 trap all signals because it affects syscall interrupt
405 behavior. But do trap all default-fatal signals. */
406 if (fatal_signal (i))
407 sigaction(host_sig, &act, NULL);
408 }
409 }
410
411 /* signal queue handling */
412
413 static inline struct sigqueue *alloc_sigqueue(CPUArchState *env)
414 {
415 CPUState *cpu = ENV_GET_CPU(env);
416 TaskState *ts = cpu->opaque;
417 struct sigqueue *q = ts->first_free;
418 if (!q)
419 return NULL;
420 ts->first_free = q->next;
421 return q;
422 }
423
424 static inline void free_sigqueue(CPUArchState *env, struct sigqueue *q)
425 {
426 CPUState *cpu = ENV_GET_CPU(env);
427 TaskState *ts = cpu->opaque;
428
429 q->next = ts->first_free;
430 ts->first_free = q;
431 }
432
433 /* abort execution with signal */
434 static void QEMU_NORETURN force_sig(int target_sig)
435 {
436 CPUState *cpu = thread_cpu;
437 CPUArchState *env = cpu->env_ptr;
438 TaskState *ts = (TaskState *)cpu->opaque;
439 int host_sig, core_dumped = 0;
440 struct sigaction act;
441
442 host_sig = target_to_host_signal(target_sig);
443 trace_user_force_sig(env, target_sig, host_sig);
444 gdb_signalled(env, target_sig);
445
446 /* dump core if supported by target binary format */
447 if (core_dump_signal(target_sig) && (ts->bprm->core_dump != NULL)) {
448 stop_all_tasks();
449 core_dumped =
450 ((*ts->bprm->core_dump)(target_sig, env) == 0);
451 }
452 if (core_dumped) {
453 /* we already dumped the core of target process, we don't want
454 * a coredump of qemu itself */
455 struct rlimit nodump;
456 getrlimit(RLIMIT_CORE, &nodump);
457 nodump.rlim_cur=0;
458 setrlimit(RLIMIT_CORE, &nodump);
459 (void) fprintf(stderr, "qemu: uncaught target signal %d (%s) - %s\n",
460 target_sig, strsignal(host_sig), "core dumped" );
461 }
462
463 /* The proper exit code for dying from an uncaught signal is
464 * -<signal>. The kernel doesn't allow exit() or _exit() to pass
465 * a negative value. To get the proper exit code we need to
466 * actually die from an uncaught signal. Here the default signal
467 * handler is installed, we send ourself a signal and we wait for
468 * it to arrive. */
469 sigfillset(&act.sa_mask);
470 act.sa_handler = SIG_DFL;
471 act.sa_flags = 0;
472 sigaction(host_sig, &act, NULL);
473
474 /* For some reason raise(host_sig) doesn't send the signal when
475 * statically linked on x86-64. */
476 kill(getpid(), host_sig);
477
478 /* Make sure the signal isn't masked (just reuse the mask inside
479 of act) */
480 sigdelset(&act.sa_mask, host_sig);
481 sigsuspend(&act.sa_mask);
482
483 /* unreachable */
484 abort();
485 }
486
487 /* queue a signal so that it will be send to the virtual CPU as soon
488 as possible */
489 int queue_signal(CPUArchState *env, int sig, target_siginfo_t *info)
490 {
491 CPUState *cpu = ENV_GET_CPU(env);
492 TaskState *ts = cpu->opaque;
493 struct emulated_sigtable *k;
494 struct sigqueue *q, **pq;
495 abi_ulong handler;
496 int queue;
497
498 trace_user_queue_signal(env, sig);
499 k = &ts->sigtab[sig - 1];
500 queue = gdb_queuesig ();
501 handler = sigact_table[sig - 1]._sa_handler;
502
503 if (ts->sigsegv_blocked && sig == TARGET_SIGSEGV) {
504 /* Guest has blocked SIGSEGV but we got one anyway. Assume this
505 * is a forced SIGSEGV (ie one the kernel handles via force_sig_info
506 * because it got a real MMU fault). A blocked SIGSEGV in that
507 * situation is treated as if using the default handler. This is
508 * not correct if some other process has randomly sent us a SIGSEGV
509 * via kill(), but that is not easy to distinguish at this point,
510 * so we assume it doesn't happen.
511 */
512 handler = TARGET_SIG_DFL;
513 }
514
515 if (!queue && handler == TARGET_SIG_DFL) {
516 if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
517 kill(getpid(),SIGSTOP);
518 return 0;
519 } else
520 /* default handler : ignore some signal. The other are fatal */
521 if (sig != TARGET_SIGCHLD &&
522 sig != TARGET_SIGURG &&
523 sig != TARGET_SIGWINCH &&
524 sig != TARGET_SIGCONT) {
525 force_sig(sig);
526 } else {
527 return 0; /* indicate ignored */
528 }
529 } else if (!queue && handler == TARGET_SIG_IGN) {
530 /* ignore signal */
531 return 0;
532 } else if (!queue && handler == TARGET_SIG_ERR) {
533 force_sig(sig);
534 } else {
535 pq = &k->first;
536 if (sig < TARGET_SIGRTMIN) {
537 /* if non real time signal, we queue exactly one signal */
538 if (!k->pending)
539 q = &k->info;
540 else
541 return 0;
542 } else {
543 if (!k->pending) {
544 /* first signal */
545 q = &k->info;
546 } else {
547 q = alloc_sigqueue(env);
548 if (!q)
549 return -EAGAIN;
550 while (*pq != NULL)
551 pq = &(*pq)->next;
552 }
553 }
554 *pq = q;
555 q->info = *info;
556 q->next = NULL;
557 k->pending = 1;
558 /* signal that a new signal is pending */
559 ts->signal_pending = 1;
560 return 1; /* indicates that the signal was queued */
561 }
562 }
563
564 static void host_signal_handler(int host_signum, siginfo_t *info,
565 void *puc)
566 {
567 CPUArchState *env = thread_cpu->env_ptr;
568 int sig;
569 target_siginfo_t tinfo;
570
571 /* the CPU emulator uses some host signals to detect exceptions,
572 we forward to it some signals */
573 if ((host_signum == SIGSEGV || host_signum == SIGBUS)
574 && info->si_code > 0) {
575 if (cpu_signal_handler(host_signum, info, puc))
576 return;
577 }
578
579 /* get target signal number */
580 sig = host_to_target_signal(host_signum);
581 if (sig < 1 || sig > TARGET_NSIG)
582 return;
583 trace_user_host_signal(env, host_signum, sig);
584 host_to_target_siginfo_noswap(&tinfo, info);
585 if (queue_signal(env, sig, &tinfo) == 1) {
586 /* interrupt the virtual CPU as soon as possible */
587 cpu_exit(thread_cpu);
588 }
589 }
590
591 /* do_sigaltstack() returns target values and errnos. */
592 /* compare linux/kernel/signal.c:do_sigaltstack() */
593 abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp)
594 {
595 int ret;
596 struct target_sigaltstack oss;
597
598 /* XXX: test errors */
599 if(uoss_addr)
600 {
601 __put_user(target_sigaltstack_used.ss_sp, &oss.ss_sp);
602 __put_user(target_sigaltstack_used.ss_size, &oss.ss_size);
603 __put_user(sas_ss_flags(sp), &oss.ss_flags);
604 }
605
606 if(uss_addr)
607 {
608 struct target_sigaltstack *uss;
609 struct target_sigaltstack ss;
610 size_t minstacksize = TARGET_MINSIGSTKSZ;
611
612 #if defined(TARGET_PPC64)
613 /* ELF V2 for PPC64 has a 4K minimum stack size for signal handlers */
614 struct image_info *image = ((TaskState *)thread_cpu->opaque)->info;
615 if (get_ppc64_abi(image) > 1) {
616 minstacksize = 4096;
617 }
618 #endif
619
620 ret = -TARGET_EFAULT;
621 if (!lock_user_struct(VERIFY_READ, uss, uss_addr, 1)) {
622 goto out;
623 }
624 __get_user(ss.ss_sp, &uss->ss_sp);
625 __get_user(ss.ss_size, &uss->ss_size);
626 __get_user(ss.ss_flags, &uss->ss_flags);
627 unlock_user_struct(uss, uss_addr, 0);
628
629 ret = -TARGET_EPERM;
630 if (on_sig_stack(sp))
631 goto out;
632
633 ret = -TARGET_EINVAL;
634 if (ss.ss_flags != TARGET_SS_DISABLE
635 && ss.ss_flags != TARGET_SS_ONSTACK
636 && ss.ss_flags != 0)
637 goto out;
638
639 if (ss.ss_flags == TARGET_SS_DISABLE) {
640 ss.ss_size = 0;
641 ss.ss_sp = 0;
642 } else {
643 ret = -TARGET_ENOMEM;
644 if (ss.ss_size < minstacksize) {
645 goto out;
646 }
647 }
648
649 target_sigaltstack_used.ss_sp = ss.ss_sp;
650 target_sigaltstack_used.ss_size = ss.ss_size;
651 }
652
653 if (uoss_addr) {
654 ret = -TARGET_EFAULT;
655 if (copy_to_user(uoss_addr, &oss, sizeof(oss)))
656 goto out;
657 }
658
659 ret = 0;
660 out:
661 return ret;
662 }
663
664 /* do_sigaction() return host values and errnos */
665 int do_sigaction(int sig, const struct target_sigaction *act,
666 struct target_sigaction *oact)
667 {
668 struct target_sigaction *k;
669 struct sigaction act1;
670 int host_sig;
671 int ret = 0;
672
673 if (sig < 1 || sig > TARGET_NSIG || sig == TARGET_SIGKILL || sig == TARGET_SIGSTOP)
674 return -EINVAL;
675 k = &sigact_table[sig - 1];
676 if (oact) {
677 __put_user(k->_sa_handler, &oact->_sa_handler);
678 __put_user(k->sa_flags, &oact->sa_flags);
679 #if !defined(TARGET_MIPS)
680 __put_user(k->sa_restorer, &oact->sa_restorer);
681 #endif
682 /* Not swapped. */
683 oact->sa_mask = k->sa_mask;
684 }
685 if (act) {
686 /* FIXME: This is not threadsafe. */
687 __get_user(k->_sa_handler, &act->_sa_handler);
688 __get_user(k->sa_flags, &act->sa_flags);
689 #if !defined(TARGET_MIPS)
690 __get_user(k->sa_restorer, &act->sa_restorer);
691 #endif
692 /* To be swapped in target_to_host_sigset. */
693 k->sa_mask = act->sa_mask;
694
695 /* we update the host linux signal state */
696 host_sig = target_to_host_signal(sig);
697 if (host_sig != SIGSEGV && host_sig != SIGBUS) {
698 sigfillset(&act1.sa_mask);
699 act1.sa_flags = SA_SIGINFO;
700 if (k->sa_flags & TARGET_SA_RESTART)
701 act1.sa_flags |= SA_RESTART;
702 /* NOTE: it is important to update the host kernel signal
703 ignore state to avoid getting unexpected interrupted
704 syscalls */
705 if (k->_sa_handler == TARGET_SIG_IGN) {
706 act1.sa_sigaction = (void *)SIG_IGN;
707 } else if (k->_sa_handler == TARGET_SIG_DFL) {
708 if (fatal_signal (sig))
709 act1.sa_sigaction = host_signal_handler;
710 else
711 act1.sa_sigaction = (void *)SIG_DFL;
712 } else {
713 act1.sa_sigaction = host_signal_handler;
714 }
715 ret = sigaction(host_sig, &act1, NULL);
716 }
717 }
718 return ret;
719 }
720
721 #if defined(TARGET_I386) && TARGET_ABI_BITS == 32
722
723 /* from the Linux kernel */
724
725 struct target_fpreg {
726 uint16_t significand[4];
727 uint16_t exponent;
728 };
729
730 struct target_fpxreg {
731 uint16_t significand[4];
732 uint16_t exponent;
733 uint16_t padding[3];
734 };
735
736 struct target_xmmreg {
737 abi_ulong element[4];
738 };
739
740 struct target_fpstate {
741 /* Regular FPU environment */
742 abi_ulong cw;
743 abi_ulong sw;
744 abi_ulong tag;
745 abi_ulong ipoff;
746 abi_ulong cssel;
747 abi_ulong dataoff;
748 abi_ulong datasel;
749 struct target_fpreg _st[8];
750 uint16_t status;
751 uint16_t magic; /* 0xffff = regular FPU data only */
752
753 /* FXSR FPU environment */
754 abi_ulong _fxsr_env[6]; /* FXSR FPU env is ignored */
755 abi_ulong mxcsr;
756 abi_ulong reserved;
757 struct target_fpxreg _fxsr_st[8]; /* FXSR FPU reg data is ignored */
758 struct target_xmmreg _xmm[8];
759 abi_ulong padding[56];
760 };
761
762 #define X86_FXSR_MAGIC 0x0000
763
764 struct target_sigcontext {
765 uint16_t gs, __gsh;
766 uint16_t fs, __fsh;
767 uint16_t es, __esh;
768 uint16_t ds, __dsh;
769 abi_ulong edi;
770 abi_ulong esi;
771 abi_ulong ebp;
772 abi_ulong esp;
773 abi_ulong ebx;
774 abi_ulong edx;
775 abi_ulong ecx;
776 abi_ulong eax;
777 abi_ulong trapno;
778 abi_ulong err;
779 abi_ulong eip;
780 uint16_t cs, __csh;
781 abi_ulong eflags;
782 abi_ulong esp_at_signal;
783 uint16_t ss, __ssh;
784 abi_ulong fpstate; /* pointer */
785 abi_ulong oldmask;
786 abi_ulong cr2;
787 };
788
789 struct target_ucontext {
790 abi_ulong tuc_flags;
791 abi_ulong tuc_link;
792 target_stack_t tuc_stack;
793 struct target_sigcontext tuc_mcontext;
794 target_sigset_t tuc_sigmask; /* mask last for extensibility */
795 };
796
797 struct sigframe
798 {
799 abi_ulong pretcode;
800 int sig;
801 struct target_sigcontext sc;
802 struct target_fpstate fpstate;
803 abi_ulong extramask[TARGET_NSIG_WORDS-1];
804 char retcode[8];
805 };
806
807 struct rt_sigframe
808 {
809 abi_ulong pretcode;
810 int sig;
811 abi_ulong pinfo;
812 abi_ulong puc;
813 struct target_siginfo info;
814 struct target_ucontext uc;
815 struct target_fpstate fpstate;
816 char retcode[8];
817 };
818
819 /*
820 * Set up a signal frame.
821 */
822
823 /* XXX: save x87 state */
824 static void setup_sigcontext(struct target_sigcontext *sc,
825 struct target_fpstate *fpstate, CPUX86State *env, abi_ulong mask,
826 abi_ulong fpstate_addr)
827 {
828 CPUState *cs = CPU(x86_env_get_cpu(env));
829 uint16_t magic;
830
831 /* already locked in setup_frame() */
832 __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs);
833 __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs);
834 __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es);
835 __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds);
836 __put_user(env->regs[R_EDI], &sc->edi);
837 __put_user(env->regs[R_ESI], &sc->esi);
838 __put_user(env->regs[R_EBP], &sc->ebp);
839 __put_user(env->regs[R_ESP], &sc->esp);
840 __put_user(env->regs[R_EBX], &sc->ebx);
841 __put_user(env->regs[R_EDX], &sc->edx);
842 __put_user(env->regs[R_ECX], &sc->ecx);
843 __put_user(env->regs[R_EAX], &sc->eax);
844 __put_user(cs->exception_index, &sc->trapno);
845 __put_user(env->error_code, &sc->err);
846 __put_user(env->eip, &sc->eip);
847 __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs);
848 __put_user(env->eflags, &sc->eflags);
849 __put_user(env->regs[R_ESP], &sc->esp_at_signal);
850 __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss);
851
852 cpu_x86_fsave(env, fpstate_addr, 1);
853 fpstate->status = fpstate->sw;
854 magic = 0xffff;
855 __put_user(magic, &fpstate->magic);
856 __put_user(fpstate_addr, &sc->fpstate);
857
858 /* non-iBCS2 extensions.. */
859 __put_user(mask, &sc->oldmask);
860 __put_user(env->cr[2], &sc->cr2);
861 }
862
863 /*
864 * Determine which stack to use..
865 */
866
867 static inline abi_ulong
868 get_sigframe(struct target_sigaction *ka, CPUX86State *env, size_t frame_size)
869 {
870 unsigned long esp;
871
872 /* Default to using normal stack */
873 esp = env->regs[R_ESP];
874 /* This is the X/Open sanctioned signal stack switching. */
875 if (ka->sa_flags & TARGET_SA_ONSTACK) {
876 if (sas_ss_flags(esp) == 0) {
877 esp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
878 }
879 } else {
880
881 /* This is the legacy signal stack switching. */
882 if ((env->segs[R_SS].selector & 0xffff) != __USER_DS &&
883 !(ka->sa_flags & TARGET_SA_RESTORER) &&
884 ka->sa_restorer) {
885 esp = (unsigned long) ka->sa_restorer;
886 }
887 }
888 return (esp - frame_size) & -8ul;
889 }
890
891 /* compare linux/arch/i386/kernel/signal.c:setup_frame() */
892 static void setup_frame(int sig, struct target_sigaction *ka,
893 target_sigset_t *set, CPUX86State *env)
894 {
895 abi_ulong frame_addr;
896 struct sigframe *frame;
897 int i;
898
899 frame_addr = get_sigframe(ka, env, sizeof(*frame));
900 trace_user_setup_frame(env, frame_addr);
901
902 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
903 goto give_sigsegv;
904
905 __put_user(sig, &frame->sig);
906
907 setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0],
908 frame_addr + offsetof(struct sigframe, fpstate));
909
910 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
911 __put_user(set->sig[i], &frame->extramask[i - 1]);
912 }
913
914 /* Set up to return from userspace. If provided, use a stub
915 already in userspace. */
916 if (ka->sa_flags & TARGET_SA_RESTORER) {
917 __put_user(ka->sa_restorer, &frame->pretcode);
918 } else {
919 uint16_t val16;
920 abi_ulong retcode_addr;
921 retcode_addr = frame_addr + offsetof(struct sigframe, retcode);
922 __put_user(retcode_addr, &frame->pretcode);
923 /* This is popl %eax ; movl $,%eax ; int $0x80 */
924 val16 = 0xb858;
925 __put_user(val16, (uint16_t *)(frame->retcode+0));
926 __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2));
927 val16 = 0x80cd;
928 __put_user(val16, (uint16_t *)(frame->retcode+6));
929 }
930
931
932 /* Set up registers for signal handler */
933 env->regs[R_ESP] = frame_addr;
934 env->eip = ka->_sa_handler;
935
936 cpu_x86_load_seg(env, R_DS, __USER_DS);
937 cpu_x86_load_seg(env, R_ES, __USER_DS);
938 cpu_x86_load_seg(env, R_SS, __USER_DS);
939 cpu_x86_load_seg(env, R_CS, __USER_CS);
940 env->eflags &= ~TF_MASK;
941
942 unlock_user_struct(frame, frame_addr, 1);
943
944 return;
945
946 give_sigsegv:
947 if (sig == TARGET_SIGSEGV) {
948 ka->_sa_handler = TARGET_SIG_DFL;
949 }
950 force_sig(TARGET_SIGSEGV /* , current */);
951 }
952
953 /* compare linux/arch/i386/kernel/signal.c:setup_rt_frame() */
954 static void setup_rt_frame(int sig, struct target_sigaction *ka,
955 target_siginfo_t *info,
956 target_sigset_t *set, CPUX86State *env)
957 {
958 abi_ulong frame_addr, addr;
959 struct rt_sigframe *frame;
960 int i;
961
962 frame_addr = get_sigframe(ka, env, sizeof(*frame));
963 trace_user_setup_rt_frame(env, frame_addr);
964
965 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
966 goto give_sigsegv;
967
968 __put_user(sig, &frame->sig);
969 addr = frame_addr + offsetof(struct rt_sigframe, info);
970 __put_user(addr, &frame->pinfo);
971 addr = frame_addr + offsetof(struct rt_sigframe, uc);
972 __put_user(addr, &frame->puc);
973 tswap_siginfo(&frame->info, info);
974
975 /* Create the ucontext. */
976 __put_user(0, &frame->uc.tuc_flags);
977 __put_user(0, &frame->uc.tuc_link);
978 __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
979 __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
980 &frame->uc.tuc_stack.ss_flags);
981 __put_user(target_sigaltstack_used.ss_size,
982 &frame->uc.tuc_stack.ss_size);
983 setup_sigcontext(&frame->uc.tuc_mcontext, &frame->fpstate, env,
984 set->sig[0], frame_addr + offsetof(struct rt_sigframe, fpstate));
985
986 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
987 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
988 }
989
990 /* Set up to return from userspace. If provided, use a stub
991 already in userspace. */
992 if (ka->sa_flags & TARGET_SA_RESTORER) {
993 __put_user(ka->sa_restorer, &frame->pretcode);
994 } else {
995 uint16_t val16;
996 addr = frame_addr + offsetof(struct rt_sigframe, retcode);
997 __put_user(addr, &frame->pretcode);
998 /* This is movl $,%eax ; int $0x80 */
999 __put_user(0xb8, (char *)(frame->retcode+0));
1000 __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1));
1001 val16 = 0x80cd;
1002 __put_user(val16, (uint16_t *)(frame->retcode+5));
1003 }
1004
1005 /* Set up registers for signal handler */
1006 env->regs[R_ESP] = frame_addr;
1007 env->eip = ka->_sa_handler;
1008
1009 cpu_x86_load_seg(env, R_DS, __USER_DS);
1010 cpu_x86_load_seg(env, R_ES, __USER_DS);
1011 cpu_x86_load_seg(env, R_SS, __USER_DS);
1012 cpu_x86_load_seg(env, R_CS, __USER_CS);
1013 env->eflags &= ~TF_MASK;
1014
1015 unlock_user_struct(frame, frame_addr, 1);
1016
1017 return;
1018
1019 give_sigsegv:
1020 if (sig == TARGET_SIGSEGV) {
1021 ka->_sa_handler = TARGET_SIG_DFL;
1022 }
1023 force_sig(TARGET_SIGSEGV /* , current */);
1024 }
1025
1026 static int
1027 restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc)
1028 {
1029 unsigned int err = 0;
1030 abi_ulong fpstate_addr;
1031 unsigned int tmpflags;
1032
1033 cpu_x86_load_seg(env, R_GS, tswap16(sc->gs));
1034 cpu_x86_load_seg(env, R_FS, tswap16(sc->fs));
1035 cpu_x86_load_seg(env, R_ES, tswap16(sc->es));
1036 cpu_x86_load_seg(env, R_DS, tswap16(sc->ds));
1037
1038 env->regs[R_EDI] = tswapl(sc->edi);
1039 env->regs[R_ESI] = tswapl(sc->esi);
1040 env->regs[R_EBP] = tswapl(sc->ebp);
1041 env->regs[R_ESP] = tswapl(sc->esp);
1042 env->regs[R_EBX] = tswapl(sc->ebx);
1043 env->regs[R_EDX] = tswapl(sc->edx);
1044 env->regs[R_ECX] = tswapl(sc->ecx);
1045 env->regs[R_EAX] = tswapl(sc->eax);
1046 env->eip = tswapl(sc->eip);
1047
1048 cpu_x86_load_seg(env, R_CS, lduw_p(&sc->cs) | 3);
1049 cpu_x86_load_seg(env, R_SS, lduw_p(&sc->ss) | 3);
1050
1051 tmpflags = tswapl(sc->eflags);
1052 env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
1053 // regs->orig_eax = -1; /* disable syscall checks */
1054
1055 fpstate_addr = tswapl(sc->fpstate);
1056 if (fpstate_addr != 0) {
1057 if (!access_ok(VERIFY_READ, fpstate_addr,
1058 sizeof(struct target_fpstate)))
1059 goto badframe;
1060 cpu_x86_frstor(env, fpstate_addr, 1);
1061 }
1062
1063 return err;
1064 badframe:
1065 return 1;
1066 }
1067
1068 long do_sigreturn(CPUX86State *env)
1069 {
1070 struct sigframe *frame;
1071 abi_ulong frame_addr = env->regs[R_ESP] - 8;
1072 target_sigset_t target_set;
1073 sigset_t set;
1074 int i;
1075
1076 trace_user_do_sigreturn(env, frame_addr);
1077 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1078 goto badframe;
1079 /* set blocked signals */
1080 __get_user(target_set.sig[0], &frame->sc.oldmask);
1081 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1082 __get_user(target_set.sig[i], &frame->extramask[i - 1]);
1083 }
1084
1085 target_to_host_sigset_internal(&set, &target_set);
1086 do_sigprocmask(SIG_SETMASK, &set, NULL);
1087
1088 /* restore registers */
1089 if (restore_sigcontext(env, &frame->sc))
1090 goto badframe;
1091 unlock_user_struct(frame, frame_addr, 0);
1092 return -TARGET_QEMU_ESIGRETURN;
1093
1094 badframe:
1095 unlock_user_struct(frame, frame_addr, 0);
1096 force_sig(TARGET_SIGSEGV);
1097 return 0;
1098 }
1099
1100 long do_rt_sigreturn(CPUX86State *env)
1101 {
1102 abi_ulong frame_addr;
1103 struct rt_sigframe *frame;
1104 sigset_t set;
1105
1106 frame_addr = env->regs[R_ESP] - 4;
1107 trace_user_do_rt_sigreturn(env, frame_addr);
1108 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1109 goto badframe;
1110 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
1111 do_sigprocmask(SIG_SETMASK, &set, NULL);
1112
1113 if (restore_sigcontext(env, &frame->uc.tuc_mcontext)) {
1114 goto badframe;
1115 }
1116
1117 if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe, uc.tuc_stack), 0,
1118 get_sp_from_cpustate(env)) == -EFAULT) {
1119 goto badframe;
1120 }
1121
1122 unlock_user_struct(frame, frame_addr, 0);
1123 return -TARGET_QEMU_ESIGRETURN;
1124
1125 badframe:
1126 unlock_user_struct(frame, frame_addr, 0);
1127 force_sig(TARGET_SIGSEGV);
1128 return 0;
1129 }
1130
1131 #elif defined(TARGET_AARCH64)
1132
1133 struct target_sigcontext {
1134 uint64_t fault_address;
1135 /* AArch64 registers */
1136 uint64_t regs[31];
1137 uint64_t sp;
1138 uint64_t pc;
1139 uint64_t pstate;
1140 /* 4K reserved for FP/SIMD state and future expansion */
1141 char __reserved[4096] __attribute__((__aligned__(16)));
1142 };
1143
1144 struct target_ucontext {
1145 abi_ulong tuc_flags;
1146 abi_ulong tuc_link;
1147 target_stack_t tuc_stack;
1148 target_sigset_t tuc_sigmask;
1149 /* glibc uses a 1024-bit sigset_t */
1150 char __unused[1024 / 8 - sizeof(target_sigset_t)];
1151 /* last for future expansion */
1152 struct target_sigcontext tuc_mcontext;
1153 };
1154
1155 /*
1156 * Header to be used at the beginning of structures extending the user
1157 * context. Such structures must be placed after the rt_sigframe on the stack
1158 * and be 16-byte aligned. The last structure must be a dummy one with the
1159 * magic and size set to 0.
1160 */
1161 struct target_aarch64_ctx {
1162 uint32_t magic;
1163 uint32_t size;
1164 };
1165
1166 #define TARGET_FPSIMD_MAGIC 0x46508001
1167
1168 struct target_fpsimd_context {
1169 struct target_aarch64_ctx head;
1170 uint32_t fpsr;
1171 uint32_t fpcr;
1172 uint64_t vregs[32 * 2]; /* really uint128_t vregs[32] */
1173 };
1174
1175 /*
1176 * Auxiliary context saved in the sigcontext.__reserved array. Not exported to
1177 * user space as it will change with the addition of new context. User space
1178 * should check the magic/size information.
1179 */
1180 struct target_aux_context {
1181 struct target_fpsimd_context fpsimd;
1182 /* additional context to be added before "end" */
1183 struct target_aarch64_ctx end;
1184 };
1185
1186 struct target_rt_sigframe {
1187 struct target_siginfo info;
1188 struct target_ucontext uc;
1189 uint64_t fp;
1190 uint64_t lr;
1191 uint32_t tramp[2];
1192 };
1193
1194 static int target_setup_sigframe(struct target_rt_sigframe *sf,
1195 CPUARMState *env, target_sigset_t *set)
1196 {
1197 int i;
1198 struct target_aux_context *aux =
1199 (struct target_aux_context *)sf->uc.tuc_mcontext.__reserved;
1200
1201 /* set up the stack frame for unwinding */
1202 __put_user(env->xregs[29], &sf->fp);
1203 __put_user(env->xregs[30], &sf->lr);
1204
1205 for (i = 0; i < 31; i++) {
1206 __put_user(env->xregs[i], &sf->uc.tuc_mcontext.regs[i]);
1207 }
1208 __put_user(env->xregs[31], &sf->uc.tuc_mcontext.sp);
1209 __put_user(env->pc, &sf->uc.tuc_mcontext.pc);
1210 __put_user(pstate_read(env), &sf->uc.tuc_mcontext.pstate);
1211
1212 __put_user(env->exception.vaddress, &sf->uc.tuc_mcontext.fault_address);
1213
1214 for (i = 0; i < TARGET_NSIG_WORDS; i++) {
1215 __put_user(set->sig[i], &sf->uc.tuc_sigmask.sig[i]);
1216 }
1217
1218 for (i = 0; i < 32; i++) {
1219 #ifdef TARGET_WORDS_BIGENDIAN
1220 __put_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2 + 1]);
1221 __put_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2]);
1222 #else
1223 __put_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2]);
1224 __put_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2 + 1]);
1225 #endif
1226 }
1227 __put_user(vfp_get_fpsr(env), &aux->fpsimd.fpsr);
1228 __put_user(vfp_get_fpcr(env), &aux->fpsimd.fpcr);
1229 __put_user(TARGET_FPSIMD_MAGIC, &aux->fpsimd.head.magic);
1230 __put_user(sizeof(struct target_fpsimd_context),
1231 &aux->fpsimd.head.size);
1232
1233 /* set the "end" magic */
1234 __put_user(0, &aux->end.magic);
1235 __put_user(0, &aux->end.size);
1236
1237 return 0;
1238 }
1239
1240 static int target_restore_sigframe(CPUARMState *env,
1241 struct target_rt_sigframe *sf)
1242 {
1243 sigset_t set;
1244 int i;
1245 struct target_aux_context *aux =
1246 (struct target_aux_context *)sf->uc.tuc_mcontext.__reserved;
1247 uint32_t magic, size, fpsr, fpcr;
1248 uint64_t pstate;
1249
1250 target_to_host_sigset(&set, &sf->uc.tuc_sigmask);
1251 do_sigprocmask(SIG_SETMASK, &set, NULL);
1252
1253 for (i = 0; i < 31; i++) {
1254 __get_user(env->xregs[i], &sf->uc.tuc_mcontext.regs[i]);
1255 }
1256
1257 __get_user(env->xregs[31], &sf->uc.tuc_mcontext.sp);
1258 __get_user(env->pc, &sf->uc.tuc_mcontext.pc);
1259 __get_user(pstate, &sf->uc.tuc_mcontext.pstate);
1260 pstate_write(env, pstate);
1261
1262 __get_user(magic, &aux->fpsimd.head.magic);
1263 __get_user(size, &aux->fpsimd.head.size);
1264
1265 if (magic != TARGET_FPSIMD_MAGIC
1266 || size != sizeof(struct target_fpsimd_context)) {
1267 return 1;
1268 }
1269
1270 for (i = 0; i < 32; i++) {
1271 #ifdef TARGET_WORDS_BIGENDIAN
1272 __get_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2 + 1]);
1273 __get_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2]);
1274 #else
1275 __get_user(env->vfp.regs[i * 2], &aux->fpsimd.vregs[i * 2]);
1276 __get_user(env->vfp.regs[i * 2 + 1], &aux->fpsimd.vregs[i * 2 + 1]);
1277 #endif
1278 }
1279 __get_user(fpsr, &aux->fpsimd.fpsr);
1280 vfp_set_fpsr(env, fpsr);
1281 __get_user(fpcr, &aux->fpsimd.fpcr);
1282 vfp_set_fpcr(env, fpcr);
1283
1284 return 0;
1285 }
1286
1287 static abi_ulong get_sigframe(struct target_sigaction *ka, CPUARMState *env)
1288 {
1289 abi_ulong sp;
1290
1291 sp = env->xregs[31];
1292
1293 /*
1294 * This is the X/Open sanctioned signal stack switching.
1295 */
1296 if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp)) {
1297 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1298 }
1299
1300 sp = (sp - sizeof(struct target_rt_sigframe)) & ~15;
1301
1302 return sp;
1303 }
1304
1305 static void target_setup_frame(int usig, struct target_sigaction *ka,
1306 target_siginfo_t *info, target_sigset_t *set,
1307 CPUARMState *env)
1308 {
1309 struct target_rt_sigframe *frame;
1310 abi_ulong frame_addr, return_addr;
1311
1312 frame_addr = get_sigframe(ka, env);
1313 trace_user_setup_frame(env, frame_addr);
1314 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
1315 goto give_sigsegv;
1316 }
1317
1318 __put_user(0, &frame->uc.tuc_flags);
1319 __put_user(0, &frame->uc.tuc_link);
1320
1321 __put_user(target_sigaltstack_used.ss_sp,
1322 &frame->uc.tuc_stack.ss_sp);
1323 __put_user(sas_ss_flags(env->xregs[31]),
1324 &frame->uc.tuc_stack.ss_flags);
1325 __put_user(target_sigaltstack_used.ss_size,
1326 &frame->uc.tuc_stack.ss_size);
1327 target_setup_sigframe(frame, env, set);
1328 if (ka->sa_flags & TARGET_SA_RESTORER) {
1329 return_addr = ka->sa_restorer;
1330 } else {
1331 /* mov x8,#__NR_rt_sigreturn; svc #0 */
1332 __put_user(0xd2801168, &frame->tramp[0]);
1333 __put_user(0xd4000001, &frame->tramp[1]);
1334 return_addr = frame_addr + offsetof(struct target_rt_sigframe, tramp);
1335 }
1336 env->xregs[0] = usig;
1337 env->xregs[31] = frame_addr;
1338 env->xregs[29] = env->xregs[31] + offsetof(struct target_rt_sigframe, fp);
1339 env->pc = ka->_sa_handler;
1340 env->xregs[30] = return_addr;
1341 if (info) {
1342 tswap_siginfo(&frame->info, info);
1343 env->xregs[1] = frame_addr + offsetof(struct target_rt_sigframe, info);
1344 env->xregs[2] = frame_addr + offsetof(struct target_rt_sigframe, uc);
1345 }
1346
1347 unlock_user_struct(frame, frame_addr, 1);
1348 return;
1349
1350 give_sigsegv:
1351 unlock_user_struct(frame, frame_addr, 1);
1352 force_sig(TARGET_SIGSEGV);
1353 }
1354
1355 static void setup_rt_frame(int sig, struct target_sigaction *ka,
1356 target_siginfo_t *info, target_sigset_t *set,
1357 CPUARMState *env)
1358 {
1359 target_setup_frame(sig, ka, info, set, env);
1360 }
1361
1362 static void setup_frame(int sig, struct target_sigaction *ka,
1363 target_sigset_t *set, CPUARMState *env)
1364 {
1365 target_setup_frame(sig, ka, 0, set, env);
1366 }
1367
1368 long do_rt_sigreturn(CPUARMState *env)
1369 {
1370 struct target_rt_sigframe *frame = NULL;
1371 abi_ulong frame_addr = env->xregs[31];
1372
1373 trace_user_do_rt_sigreturn(env, frame_addr);
1374 if (frame_addr & 15) {
1375 goto badframe;
1376 }
1377
1378 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
1379 goto badframe;
1380 }
1381
1382 if (target_restore_sigframe(env, frame)) {
1383 goto badframe;
1384 }
1385
1386 if (do_sigaltstack(frame_addr +
1387 offsetof(struct target_rt_sigframe, uc.tuc_stack),
1388 0, get_sp_from_cpustate(env)) == -EFAULT) {
1389 goto badframe;
1390 }
1391
1392 unlock_user_struct(frame, frame_addr, 0);
1393 return -TARGET_QEMU_ESIGRETURN;
1394
1395 badframe:
1396 unlock_user_struct(frame, frame_addr, 0);
1397 force_sig(TARGET_SIGSEGV);
1398 return 0;
1399 }
1400
1401 long do_sigreturn(CPUARMState *env)
1402 {
1403 return do_rt_sigreturn(env);
1404 }
1405
1406 #elif defined(TARGET_ARM)
1407
1408 struct target_sigcontext {
1409 abi_ulong trap_no;
1410 abi_ulong error_code;
1411 abi_ulong oldmask;
1412 abi_ulong arm_r0;
1413 abi_ulong arm_r1;
1414 abi_ulong arm_r2;
1415 abi_ulong arm_r3;
1416 abi_ulong arm_r4;
1417 abi_ulong arm_r5;
1418 abi_ulong arm_r6;
1419 abi_ulong arm_r7;
1420 abi_ulong arm_r8;
1421 abi_ulong arm_r9;
1422 abi_ulong arm_r10;
1423 abi_ulong arm_fp;
1424 abi_ulong arm_ip;
1425 abi_ulong arm_sp;
1426 abi_ulong arm_lr;
1427 abi_ulong arm_pc;
1428 abi_ulong arm_cpsr;
1429 abi_ulong fault_address;
1430 };
1431
1432 struct target_ucontext_v1 {
1433 abi_ulong tuc_flags;
1434 abi_ulong tuc_link;
1435 target_stack_t tuc_stack;
1436 struct target_sigcontext tuc_mcontext;
1437 target_sigset_t tuc_sigmask; /* mask last for extensibility */
1438 };
1439
1440 struct target_ucontext_v2 {
1441 abi_ulong tuc_flags;
1442 abi_ulong tuc_link;
1443 target_stack_t tuc_stack;
1444 struct target_sigcontext tuc_mcontext;
1445 target_sigset_t tuc_sigmask; /* mask last for extensibility */
1446 char __unused[128 - sizeof(target_sigset_t)];
1447 abi_ulong tuc_regspace[128] __attribute__((__aligned__(8)));
1448 };
1449
1450 struct target_user_vfp {
1451 uint64_t fpregs[32];
1452 abi_ulong fpscr;
1453 };
1454
1455 struct target_user_vfp_exc {
1456 abi_ulong fpexc;
1457 abi_ulong fpinst;
1458 abi_ulong fpinst2;
1459 };
1460
1461 struct target_vfp_sigframe {
1462 abi_ulong magic;
1463 abi_ulong size;
1464 struct target_user_vfp ufp;
1465 struct target_user_vfp_exc ufp_exc;
1466 } __attribute__((__aligned__(8)));
1467
1468 struct target_iwmmxt_sigframe {
1469 abi_ulong magic;
1470 abi_ulong size;
1471 uint64_t regs[16];
1472 /* Note that not all the coprocessor control registers are stored here */
1473 uint32_t wcssf;
1474 uint32_t wcasf;
1475 uint32_t wcgr0;
1476 uint32_t wcgr1;
1477 uint32_t wcgr2;
1478 uint32_t wcgr3;
1479 } __attribute__((__aligned__(8)));
1480
1481 #define TARGET_VFP_MAGIC 0x56465001
1482 #define TARGET_IWMMXT_MAGIC 0x12ef842a
1483
1484 struct sigframe_v1
1485 {
1486 struct target_sigcontext sc;
1487 abi_ulong extramask[TARGET_NSIG_WORDS-1];
1488 abi_ulong retcode;
1489 };
1490
1491 struct sigframe_v2
1492 {
1493 struct target_ucontext_v2 uc;
1494 abi_ulong retcode;
1495 };
1496
1497 struct rt_sigframe_v1
1498 {
1499 abi_ulong pinfo;
1500 abi_ulong puc;
1501 struct target_siginfo info;
1502 struct target_ucontext_v1 uc;
1503 abi_ulong retcode;
1504 };
1505
1506 struct rt_sigframe_v2
1507 {
1508 struct target_siginfo info;
1509 struct target_ucontext_v2 uc;
1510 abi_ulong retcode;
1511 };
1512
1513 #define TARGET_CONFIG_CPU_32 1
1514
1515 /*
1516 * For ARM syscalls, we encode the syscall number into the instruction.
1517 */
1518 #define SWI_SYS_SIGRETURN (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
1519 #define SWI_SYS_RT_SIGRETURN (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
1520
1521 /*
1522 * For Thumb syscalls, we pass the syscall number via r7. We therefore
1523 * need two 16-bit instructions.
1524 */
1525 #define SWI_THUMB_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
1526 #define SWI_THUMB_RT_SIGRETURN (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
1527
1528 static const abi_ulong retcodes[4] = {
1529 SWI_SYS_SIGRETURN, SWI_THUMB_SIGRETURN,
1530 SWI_SYS_RT_SIGRETURN, SWI_THUMB_RT_SIGRETURN
1531 };
1532
1533
1534 static inline int valid_user_regs(CPUARMState *regs)
1535 {
1536 return 1;
1537 }
1538
1539 static void
1540 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1541 CPUARMState *env, abi_ulong mask)
1542 {
1543 __put_user(env->regs[0], &sc->arm_r0);
1544 __put_user(env->regs[1], &sc->arm_r1);
1545 __put_user(env->regs[2], &sc->arm_r2);
1546 __put_user(env->regs[3], &sc->arm_r3);
1547 __put_user(env->regs[4], &sc->arm_r4);
1548 __put_user(env->regs[5], &sc->arm_r5);
1549 __put_user(env->regs[6], &sc->arm_r6);
1550 __put_user(env->regs[7], &sc->arm_r7);
1551 __put_user(env->regs[8], &sc->arm_r8);
1552 __put_user(env->regs[9], &sc->arm_r9);
1553 __put_user(env->regs[10], &sc->arm_r10);
1554 __put_user(env->regs[11], &sc->arm_fp);
1555 __put_user(env->regs[12], &sc->arm_ip);
1556 __put_user(env->regs[13], &sc->arm_sp);
1557 __put_user(env->regs[14], &sc->arm_lr);
1558 __put_user(env->regs[15], &sc->arm_pc);
1559 #ifdef TARGET_CONFIG_CPU_32
1560 __put_user(cpsr_read(env), &sc->arm_cpsr);
1561 #endif
1562
1563 __put_user(/* current->thread.trap_no */ 0, &sc->trap_no);
1564 __put_user(/* current->thread.error_code */ 0, &sc->error_code);
1565 __put_user(/* current->thread.address */ 0, &sc->fault_address);
1566 __put_user(mask, &sc->oldmask);
1567 }
1568
1569 static inline abi_ulong
1570 get_sigframe(struct target_sigaction *ka, CPUARMState *regs, int framesize)
1571 {
1572 unsigned long sp = regs->regs[13];
1573
1574 /*
1575 * This is the X/Open sanctioned signal stack switching.
1576 */
1577 if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp)) {
1578 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1579 }
1580 /*
1581 * ATPCS B01 mandates 8-byte alignment
1582 */
1583 return (sp - framesize) & ~7;
1584 }
1585
1586 static void
1587 setup_return(CPUARMState *env, struct target_sigaction *ka,
1588 abi_ulong *rc, abi_ulong frame_addr, int usig, abi_ulong rc_addr)
1589 {
1590 abi_ulong handler = ka->_sa_handler;
1591 abi_ulong retcode;
1592 int thumb = handler & 1;
1593 uint32_t cpsr = cpsr_read(env);
1594
1595 cpsr &= ~CPSR_IT;
1596 if (thumb) {
1597 cpsr |= CPSR_T;
1598 } else {
1599 cpsr &= ~CPSR_T;
1600 }
1601
1602 if (ka->sa_flags & TARGET_SA_RESTORER) {
1603 retcode = ka->sa_restorer;
1604 } else {
1605 unsigned int idx = thumb;
1606
1607 if (ka->sa_flags & TARGET_SA_SIGINFO) {
1608 idx += 2;
1609 }
1610
1611 __put_user(retcodes[idx], rc);
1612
1613 retcode = rc_addr + thumb;
1614 }
1615
1616 env->regs[0] = usig;
1617 env->regs[13] = frame_addr;
1618 env->regs[14] = retcode;
1619 env->regs[15] = handler & (thumb ? ~1 : ~3);
1620 cpsr_write(env, cpsr, CPSR_IT | CPSR_T, CPSRWriteByInstr);
1621 }
1622
1623 static abi_ulong *setup_sigframe_v2_vfp(abi_ulong *regspace, CPUARMState *env)
1624 {
1625 int i;
1626 struct target_vfp_sigframe *vfpframe;
1627 vfpframe = (struct target_vfp_sigframe *)regspace;
1628 __put_user(TARGET_VFP_MAGIC, &vfpframe->magic);
1629 __put_user(sizeof(*vfpframe), &vfpframe->size);
1630 for (i = 0; i < 32; i++) {
1631 __put_user(float64_val(env->vfp.regs[i]), &vfpframe->ufp.fpregs[i]);
1632 }
1633 __put_user(vfp_get_fpscr(env), &vfpframe->ufp.fpscr);
1634 __put_user(env->vfp.xregs[ARM_VFP_FPEXC], &vfpframe->ufp_exc.fpexc);
1635 __put_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst);
1636 __put_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2);
1637 return (abi_ulong*)(vfpframe+1);
1638 }
1639
1640 static abi_ulong *setup_sigframe_v2_iwmmxt(abi_ulong *regspace,
1641 CPUARMState *env)
1642 {
1643 int i;
1644 struct target_iwmmxt_sigframe *iwmmxtframe;
1645 iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace;
1646 __put_user(TARGET_IWMMXT_MAGIC, &iwmmxtframe->magic);
1647 __put_user(sizeof(*iwmmxtframe), &iwmmxtframe->size);
1648 for (i = 0; i < 16; i++) {
1649 __put_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]);
1650 }
1651 __put_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf);
1652 __put_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf);
1653 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0);
1654 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1);
1655 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2);
1656 __put_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3);
1657 return (abi_ulong*)(iwmmxtframe+1);
1658 }
1659
1660 static void setup_sigframe_v2(struct target_ucontext_v2 *uc,
1661 target_sigset_t *set, CPUARMState *env)
1662 {
1663 struct target_sigaltstack stack;
1664 int i;
1665 abi_ulong *regspace;
1666
1667 /* Clear all the bits of the ucontext we don't use. */
1668 memset(uc, 0, offsetof(struct target_ucontext_v2, tuc_mcontext));
1669
1670 memset(&stack, 0, sizeof(stack));
1671 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1672 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1673 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
1674 memcpy(&uc->tuc_stack, &stack, sizeof(stack));
1675
1676 setup_sigcontext(&uc->tuc_mcontext, env, set->sig[0]);
1677 /* Save coprocessor signal frame. */
1678 regspace = uc->tuc_regspace;
1679 if (arm_feature(env, ARM_FEATURE_VFP)) {
1680 regspace = setup_sigframe_v2_vfp(regspace, env);
1681 }
1682 if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
1683 regspace = setup_sigframe_v2_iwmmxt(regspace, env);
1684 }
1685
1686 /* Write terminating magic word */
1687 __put_user(0, regspace);
1688
1689 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1690 __put_user(set->sig[i], &uc->tuc_sigmask.sig[i]);
1691 }
1692 }
1693
1694 /* compare linux/arch/arm/kernel/signal.c:setup_frame() */
1695 static void setup_frame_v1(int usig, struct target_sigaction *ka,
1696 target_sigset_t *set, CPUARMState *regs)
1697 {
1698 struct sigframe_v1 *frame;
1699 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
1700 int i;
1701
1702 trace_user_setup_frame(regs, frame_addr);
1703 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
1704 return;
1705 }
1706
1707 setup_sigcontext(&frame->sc, regs, set->sig[0]);
1708
1709 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1710 __put_user(set->sig[i], &frame->extramask[i - 1]);
1711 }
1712
1713 setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1714 frame_addr + offsetof(struct sigframe_v1, retcode));
1715
1716 unlock_user_struct(frame, frame_addr, 1);
1717 }
1718
1719 static void setup_frame_v2(int usig, struct target_sigaction *ka,
1720 target_sigset_t *set, CPUARMState *regs)
1721 {
1722 struct sigframe_v2 *frame;
1723 abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
1724
1725 trace_user_setup_frame(regs, frame_addr);
1726 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
1727 return;
1728 }
1729
1730 setup_sigframe_v2(&frame->uc, set, regs);
1731
1732 setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1733 frame_addr + offsetof(struct sigframe_v2, retcode));
1734
1735 unlock_user_struct(frame, frame_addr, 1);
1736 }
1737
1738 static void setup_frame(int usig, struct target_sigaction *ka,
1739 target_sigset_t *set, CPUARMState *regs)
1740 {
1741 if (get_osversion() >= 0x020612) {
1742 setup_frame_v2(usig, ka, set, regs);
1743 } else {
1744 setup_frame_v1(usig, ka, set, regs);
1745 }
1746 }
1747
1748 /* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */
1749 static void setup_rt_frame_v1(int usig, struct target_sigaction *ka,
1750 target_siginfo_t *info,
1751 target_sigset_t *set, CPUARMState *env)
1752 {
1753 struct rt_sigframe_v1 *frame;
1754 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
1755 struct target_sigaltstack stack;
1756 int i;
1757 abi_ulong info_addr, uc_addr;
1758
1759 trace_user_setup_rt_frame(env, frame_addr);
1760 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
1761 return /* 1 */;
1762 }
1763
1764 info_addr = frame_addr + offsetof(struct rt_sigframe_v1, info);
1765 __put_user(info_addr, &frame->pinfo);
1766 uc_addr = frame_addr + offsetof(struct rt_sigframe_v1, uc);
1767 __put_user(uc_addr, &frame->puc);
1768 tswap_siginfo(&frame->info, info);
1769
1770 /* Clear all the bits of the ucontext we don't use. */
1771 memset(&frame->uc, 0, offsetof(struct target_ucontext_v1, tuc_mcontext));
1772
1773 memset(&stack, 0, sizeof(stack));
1774 __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1775 __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1776 __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
1777 memcpy(&frame->uc.tuc_stack, &stack, sizeof(stack));
1778
1779 setup_sigcontext(&frame->uc.tuc_mcontext, env, set->sig[0]);
1780 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1781 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
1782 }
1783
1784 setup_return(env, ka, &frame->retcode, frame_addr, usig,
1785 frame_addr + offsetof(struct rt_sigframe_v1, retcode));
1786
1787 env->regs[1] = info_addr;
1788 env->regs[2] = uc_addr;
1789
1790 unlock_user_struct(frame, frame_addr, 1);
1791 }
1792
1793 static void setup_rt_frame_v2(int usig, struct target_sigaction *ka,
1794 target_siginfo_t *info,
1795 target_sigset_t *set, CPUARMState *env)
1796 {
1797 struct rt_sigframe_v2 *frame;
1798 abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
1799 abi_ulong info_addr, uc_addr;
1800
1801 trace_user_setup_rt_frame(env, frame_addr);
1802 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
1803 return /* 1 */;
1804 }
1805
1806 info_addr = frame_addr + offsetof(struct rt_sigframe_v2, info);
1807 uc_addr = frame_addr + offsetof(struct rt_sigframe_v2, uc);
1808 tswap_siginfo(&frame->info, info);
1809
1810 setup_sigframe_v2(&frame->uc, set, env);
1811
1812 setup_return(env, ka, &frame->retcode, frame_addr, usig,
1813 frame_addr + offsetof(struct rt_sigframe_v2, retcode));
1814
1815 env->regs[1] = info_addr;
1816 env->regs[2] = uc_addr;
1817
1818 unlock_user_struct(frame, frame_addr, 1);
1819 }
1820
1821 static void setup_rt_frame(int usig, struct target_sigaction *ka,
1822 target_siginfo_t *info,
1823 target_sigset_t *set, CPUARMState *env)
1824 {
1825 if (get_osversion() >= 0x020612) {
1826 setup_rt_frame_v2(usig, ka, info, set, env);
1827 } else {
1828 setup_rt_frame_v1(usig, ka, info, set, env);
1829 }
1830 }
1831
1832 static int
1833 restore_sigcontext(CPUARMState *env, struct target_sigcontext *sc)
1834 {
1835 int err = 0;
1836 uint32_t cpsr;
1837
1838 __get_user(env->regs[0], &sc->arm_r0);
1839 __get_user(env->regs[1], &sc->arm_r1);
1840 __get_user(env->regs[2], &sc->arm_r2);
1841 __get_user(env->regs[3], &sc->arm_r3);
1842 __get_user(env->regs[4], &sc->arm_r4);
1843 __get_user(env->regs[5], &sc->arm_r5);
1844 __get_user(env->regs[6], &sc->arm_r6);
1845 __get_user(env->regs[7], &sc->arm_r7);
1846 __get_user(env->regs[8], &sc->arm_r8);
1847 __get_user(env->regs[9], &sc->arm_r9);
1848 __get_user(env->regs[10], &sc->arm_r10);
1849 __get_user(env->regs[11], &sc->arm_fp);
1850 __get_user(env->regs[12], &sc->arm_ip);
1851 __get_user(env->regs[13], &sc->arm_sp);
1852 __get_user(env->regs[14], &sc->arm_lr);
1853 __get_user(env->regs[15], &sc->arm_pc);
1854 #ifdef TARGET_CONFIG_CPU_32
1855 __get_user(cpsr, &sc->arm_cpsr);
1856 cpsr_write(env, cpsr, CPSR_USER | CPSR_EXEC, CPSRWriteByInstr);
1857 #endif
1858
1859 err |= !valid_user_regs(env);
1860
1861 return err;
1862 }
1863
1864 static long do_sigreturn_v1(CPUARMState *env)
1865 {
1866 abi_ulong frame_addr;
1867 struct sigframe_v1 *frame = NULL;
1868 target_sigset_t set;
1869 sigset_t host_set;
1870 int i;
1871
1872 /*
1873 * Since we stacked the signal on a 64-bit boundary,
1874 * then 'sp' should be word aligned here. If it's
1875 * not, then the user is trying to mess with us.
1876 */
1877 frame_addr = env->regs[13];
1878 trace_user_do_sigreturn(env, frame_addr);
1879 if (frame_addr & 7) {
1880 goto badframe;
1881 }
1882
1883 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
1884 goto badframe;
1885 }
1886
1887 __get_user(set.sig[0], &frame->sc.oldmask);
1888 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1889 __get_user(set.sig[i], &frame->extramask[i - 1]);
1890 }
1891
1892 target_to_host_sigset_internal(&host_set, &set);
1893 do_sigprocmask(SIG_SETMASK, &host_set, NULL);
1894
1895 if (restore_sigcontext(env, &frame->sc)) {
1896 goto badframe;
1897 }
1898
1899 #if 0
1900 /* Send SIGTRAP if we're single-stepping */
1901 if (ptrace_cancel_bpt(current))
1902 send_sig(SIGTRAP, current, 1);
1903 #endif
1904 unlock_user_struct(frame, frame_addr, 0);
1905 return -TARGET_QEMU_ESIGRETURN;
1906
1907 badframe:
1908 force_sig(TARGET_SIGSEGV /* , current */);
1909 return 0;
1910 }
1911
1912 static abi_ulong *restore_sigframe_v2_vfp(CPUARMState *env, abi_ulong *regspace)
1913 {
1914 int i;
1915 abi_ulong magic, sz;
1916 uint32_t fpscr, fpexc;
1917 struct target_vfp_sigframe *vfpframe;
1918 vfpframe = (struct target_vfp_sigframe *)regspace;
1919
1920 __get_user(magic, &vfpframe->magic);
1921 __get_user(sz, &vfpframe->size);
1922 if (magic != TARGET_VFP_MAGIC || sz != sizeof(*vfpframe)) {
1923 return 0;
1924 }
1925 for (i = 0; i < 32; i++) {
1926 __get_user(float64_val(env->vfp.regs[i]), &vfpframe->ufp.fpregs[i]);
1927 }
1928 __get_user(fpscr, &vfpframe->ufp.fpscr);
1929 vfp_set_fpscr(env, fpscr);
1930 __get_user(fpexc, &vfpframe->ufp_exc.fpexc);
1931 /* Sanitise FPEXC: ensure VFP is enabled, FPINST2 is invalid
1932 * and the exception flag is cleared
1933 */
1934 fpexc |= (1 << 30);
1935 fpexc &= ~((1 << 31) | (1 << 28));
1936 env->vfp.xregs[ARM_VFP_FPEXC] = fpexc;
1937 __get_user(env->vfp.xregs[ARM_VFP_FPINST], &vfpframe->ufp_exc.fpinst);
1938 __get_user(env->vfp.xregs[ARM_VFP_FPINST2], &vfpframe->ufp_exc.fpinst2);
1939 return (abi_ulong*)(vfpframe + 1);
1940 }
1941
1942 static abi_ulong *restore_sigframe_v2_iwmmxt(CPUARMState *env,
1943 abi_ulong *regspace)
1944 {
1945 int i;
1946 abi_ulong magic, sz;
1947 struct target_iwmmxt_sigframe *iwmmxtframe;
1948 iwmmxtframe = (struct target_iwmmxt_sigframe *)regspace;
1949
1950 __get_user(magic, &iwmmxtframe->magic);
1951 __get_user(sz, &iwmmxtframe->size);
1952 if (magic != TARGET_IWMMXT_MAGIC || sz != sizeof(*iwmmxtframe)) {
1953 return 0;
1954 }
1955 for (i = 0; i < 16; i++) {
1956 __get_user(env->iwmmxt.regs[i], &iwmmxtframe->regs[i]);
1957 }
1958 __get_user(env->vfp.xregs[ARM_IWMMXT_wCSSF], &iwmmxtframe->wcssf);
1959 __get_user(env->vfp.xregs[ARM_IWMMXT_wCASF], &iwmmxtframe->wcssf);
1960 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR0], &iwmmxtframe->wcgr0);
1961 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR1], &iwmmxtframe->wcgr1);
1962 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR2], &iwmmxtframe->wcgr2);
1963 __get_user(env->vfp.xregs[ARM_IWMMXT_wCGR3], &iwmmxtframe->wcgr3);
1964 return (abi_ulong*)(iwmmxtframe + 1);
1965 }
1966
1967 static int do_sigframe_return_v2(CPUARMState *env, target_ulong frame_addr,
1968 struct target_ucontext_v2 *uc)
1969 {
1970 sigset_t host_set;
1971 abi_ulong *regspace;
1972
1973 target_to_host_sigset(&host_set, &uc->tuc_sigmask);
1974 do_sigprocmask(SIG_SETMASK, &host_set, NULL);
1975
1976 if (restore_sigcontext(env, &uc->tuc_mcontext))
1977 return 1;
1978
1979 /* Restore coprocessor signal frame */
1980 regspace = uc->tuc_regspace;
1981 if (arm_feature(env, ARM_FEATURE_VFP)) {
1982 regspace = restore_sigframe_v2_vfp(env, regspace);
1983 if (!regspace) {
1984 return 1;
1985 }
1986 }
1987 if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
1988 regspace = restore_sigframe_v2_iwmmxt(env, regspace);
1989 if (!regspace) {
1990 return 1;
1991 }
1992 }
1993
1994 if (do_sigaltstack(frame_addr + offsetof(struct target_ucontext_v2, tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
1995 return 1;
1996
1997 #if 0
1998 /* Send SIGTRAP if we're single-stepping */
1999 if (ptrace_cancel_bpt(current))
2000 send_sig(SIGTRAP, current, 1);
2001 #endif
2002
2003 return 0;
2004 }
2005
2006 static long do_sigreturn_v2(CPUARMState *env)
2007 {
2008 abi_ulong frame_addr;
2009 struct sigframe_v2 *frame = NULL;
2010
2011 /*
2012 * Since we stacked the signal on a 64-bit boundary,
2013 * then 'sp' should be word aligned here. If it's
2014 * not, then the user is trying to mess with us.
2015 */
2016 frame_addr = env->regs[13];
2017 trace_user_do_sigreturn(env, frame_addr);
2018 if (frame_addr & 7) {
2019 goto badframe;
2020 }
2021
2022 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
2023 goto badframe;
2024 }
2025
2026 if (do_sigframe_return_v2(env, frame_addr, &frame->uc)) {
2027 goto badframe;
2028 }
2029
2030 unlock_user_struct(frame, frame_addr, 0);
2031 return -TARGET_QEMU_ESIGRETURN;
2032
2033 badframe:
2034 unlock_user_struct(frame, frame_addr, 0);
2035 force_sig(TARGET_SIGSEGV /* , current */);
2036 return 0;
2037 }
2038
2039 long do_sigreturn(CPUARMState *env)
2040 {
2041 if (get_osversion() >= 0x020612) {
2042 return do_sigreturn_v2(env);
2043 } else {
2044 return do_sigreturn_v1(env);
2045 }
2046 }
2047
2048 static long do_rt_sigreturn_v1(CPUARMState *env)
2049 {
2050 abi_ulong frame_addr;
2051 struct rt_sigframe_v1 *frame = NULL;
2052 sigset_t host_set;
2053
2054 /*
2055 * Since we stacked the signal on a 64-bit boundary,
2056 * then 'sp' should be word aligned here. If it's
2057 * not, then the user is trying to mess with us.
2058 */
2059 frame_addr = env->regs[13];
2060 trace_user_do_rt_sigreturn(env, frame_addr);
2061 if (frame_addr & 7) {
2062 goto badframe;
2063 }
2064
2065 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
2066 goto badframe;
2067 }
2068
2069 target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask);
2070 do_sigprocmask(SIG_SETMASK, &host_set, NULL);
2071
2072 if (restore_sigcontext(env, &frame->uc.tuc_mcontext)) {
2073 goto badframe;
2074 }
2075
2076 if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe_v1, uc.tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
2077 goto badframe;
2078
2079 #if 0
2080 /* Send SIGTRAP if we're single-stepping */
2081 if (ptrace_cancel_bpt(current))
2082 send_sig(SIGTRAP, current, 1);
2083 #endif
2084 unlock_user_struct(frame, frame_addr, 0);
2085 return -TARGET_QEMU_ESIGRETURN;
2086
2087 badframe:
2088 unlock_user_struct(frame, frame_addr, 0);
2089 force_sig(TARGET_SIGSEGV /* , current */);
2090 return 0;
2091 }
2092
2093 static long do_rt_sigreturn_v2(CPUARMState *env)
2094 {
2095 abi_ulong frame_addr;
2096 struct rt_sigframe_v2 *frame = NULL;
2097
2098 /*
2099 * Since we stacked the signal on a 64-bit boundary,
2100 * then 'sp' should be word aligned here. If it's
2101 * not, then the user is trying to mess with us.
2102 */
2103 frame_addr = env->regs[13];
2104 trace_user_do_rt_sigreturn(env, frame_addr);
2105 if (frame_addr & 7) {
2106 goto badframe;
2107 }
2108
2109 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
2110 goto badframe;
2111 }
2112
2113 if (do_sigframe_return_v2(env, frame_addr, &frame->uc)) {
2114 goto badframe;
2115 }
2116
2117 unlock_user_struct(frame, frame_addr, 0);
2118 return -TARGET_QEMU_ESIGRETURN;
2119
2120 badframe:
2121 unlock_user_struct(frame, frame_addr, 0);
2122 force_sig(TARGET_SIGSEGV /* , current */);
2123 return 0;
2124 }
2125
2126 long do_rt_sigreturn(CPUARMState *env)
2127 {
2128 if (get_osversion() >= 0x020612) {
2129 return do_rt_sigreturn_v2(env);
2130 } else {
2131 return do_rt_sigreturn_v1(env);
2132 }
2133 }
2134
2135 #elif defined(TARGET_SPARC)
2136
2137 #define __SUNOS_MAXWIN 31
2138
2139 /* This is what SunOS does, so shall I. */
2140 struct target_sigcontext {
2141 abi_ulong sigc_onstack; /* state to restore */
2142
2143 abi_ulong sigc_mask; /* sigmask to restore */
2144 abi_ulong sigc_sp; /* stack pointer */
2145 abi_ulong sigc_pc; /* program counter */
2146 abi_ulong sigc_npc; /* next program counter */
2147 abi_ulong sigc_psr; /* for condition codes etc */
2148 abi_ulong sigc_g1; /* User uses these two registers */
2149 abi_ulong sigc_o0; /* within the trampoline code. */
2150
2151 /* Now comes information regarding the users window set
2152 * at the time of the signal.
2153 */
2154 abi_ulong sigc_oswins; /* outstanding windows */
2155
2156 /* stack ptrs for each regwin buf */
2157 char *sigc_spbuf[__SUNOS_MAXWIN];
2158
2159 /* Windows to restore after signal */
2160 struct {
2161 abi_ulong locals[8];
2162 abi_ulong ins[8];
2163 } sigc_wbuf[__SUNOS_MAXWIN];
2164 };
2165 /* A Sparc stack frame */
2166 struct sparc_stackf {
2167 abi_ulong locals[8];
2168 abi_ulong ins[8];
2169 /* It's simpler to treat fp and callers_pc as elements of ins[]
2170 * since we never need to access them ourselves.
2171 */
2172 char *structptr;
2173 abi_ulong xargs[6];
2174 abi_ulong xxargs[1];
2175 };
2176
2177 typedef struct {
2178 struct {
2179 abi_ulong psr;
2180 abi_ulong pc;
2181 abi_ulong npc;
2182 abi_ulong y;
2183 abi_ulong u_regs[16]; /* globals and ins */
2184 } si_regs;
2185 int si_mask;
2186 } __siginfo_t;
2187
2188 typedef struct {
2189 abi_ulong si_float_regs[32];
2190 unsigned long si_fsr;
2191 unsigned long si_fpqdepth;
2192 struct {
2193 unsigned long *insn_addr;
2194 unsigned long insn;
2195 } si_fpqueue [16];
2196 } qemu_siginfo_fpu_t;
2197
2198
2199 struct target_signal_frame {
2200 struct sparc_stackf ss;
2201 __siginfo_t info;
2202 abi_ulong fpu_save;
2203 abi_ulong insns[2] __attribute__ ((aligned (8)));
2204 abi_ulong extramask[TARGET_NSIG_WORDS - 1];
2205 abi_ulong extra_size; /* Should be 0 */
2206 qemu_siginfo_fpu_t fpu_state;
2207 };
2208 struct target_rt_signal_frame {
2209 struct sparc_stackf ss;
2210 siginfo_t info;
2211 abi_ulong regs[20];
2212 sigset_t mask;
2213 abi_ulong fpu_save;
2214 unsigned int insns[2];
2215 stack_t stack;
2216 unsigned int extra_size; /* Should be 0 */
2217 qemu_siginfo_fpu_t fpu_state;
2218 };
2219
2220 #define UREG_O0 16
2221 #define UREG_O6 22
2222 #define UREG_I0 0
2223 #define UREG_I1 1
2224 #define UREG_I2 2
2225 #define UREG_I3 3
2226 #define UREG_I4 4
2227 #define UREG_I5 5
2228 #define UREG_I6 6
2229 #define UREG_I7 7
2230 #define UREG_L0 8
2231 #define UREG_FP UREG_I6
2232 #define UREG_SP UREG_O6
2233
2234 static inline abi_ulong get_sigframe(struct target_sigaction *sa,
2235 CPUSPARCState *env,
2236 unsigned long framesize)
2237 {
2238 abi_ulong sp;
2239
2240 sp = env->regwptr[UREG_FP];
2241
2242 /* This is the X/Open sanctioned signal stack switching. */
2243 if (sa->sa_flags & TARGET_SA_ONSTACK) {
2244 if (!on_sig_stack(sp)
2245 && !((target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size) & 7)) {
2246 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
2247 }
2248 }
2249 return sp - framesize;
2250 }
2251
2252 static int
2253 setup___siginfo(__siginfo_t *si, CPUSPARCState *env, abi_ulong mask)
2254 {
2255 int err = 0, i;
2256
2257 __put_user(env->psr, &si->si_regs.psr);
2258 __put_user(env->pc, &si->si_regs.pc);
2259 __put_user(env->npc, &si->si_regs.npc);
2260 __put_user(env->y, &si->si_regs.y);
2261 for (i=0; i < 8; i++) {
2262 __put_user(env->gregs[i], &si->si_regs.u_regs[i]);
2263 }
2264 for (i=0; i < 8; i++) {
2265 __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]);
2266 }
2267 __put_user(mask, &si->si_mask);
2268 return err;
2269 }
2270
2271 #if 0
2272 static int
2273 setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
2274 CPUSPARCState *env, unsigned long mask)
2275 {
2276 int err = 0;
2277
2278 __put_user(mask, &sc->sigc_mask);
2279 __put_user(env->regwptr[UREG_SP], &sc->sigc_sp);
2280 __put_user(env->pc, &sc->sigc_pc);
2281 __put_user(env->npc, &sc->sigc_npc);
2282 __put_user(env->psr, &sc->sigc_psr);
2283 __put_user(env->gregs[1], &sc->sigc_g1);
2284 __put_user(env->regwptr[UREG_O0], &sc->sigc_o0);
2285
2286 return err;
2287 }
2288 #endif
2289 #define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7)))
2290
2291 static void setup_frame(int sig, struct target_sigaction *ka,
2292 target_sigset_t *set, CPUSPARCState *env)
2293 {
2294 abi_ulong sf_addr;
2295 struct target_signal_frame *sf;
2296 int sigframe_size, err, i;
2297
2298 /* 1. Make sure everything is clean */
2299 //synchronize_user_stack();
2300
2301 sigframe_size = NF_ALIGNEDSZ;
2302 sf_addr = get_sigframe(ka, env, sigframe_size);
2303 trace_user_setup_frame(env, sf_addr);
2304
2305 sf = lock_user(VERIFY_WRITE, sf_addr,
2306 sizeof(struct target_signal_frame), 0);
2307 if (!sf) {
2308 goto sigsegv;
2309 }
2310 #if 0
2311 if (invalid_frame_pointer(sf, sigframe_size))
2312 goto sigill_and_return;
2313 #endif
2314 /* 2. Save the current process state */
2315 err = setup___siginfo(&sf->info, env, set->sig[0]);
2316 __put_user(0, &sf->extra_size);
2317
2318 //save_fpu_state(regs, &sf->fpu_state);
2319 //__put_user(&sf->fpu_state, &sf->fpu_save);
2320
2321 __put_user(set->sig[0], &sf->info.si_mask);
2322 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
2323 __put_user(set->sig[i + 1], &sf->extramask[i]);
2324 }
2325
2326 for (i = 0; i < 8; i++) {
2327 __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]);
2328 }
2329 for (i = 0; i < 8; i++) {
2330 __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]);
2331 }
2332 if (err)
2333 goto sigsegv;
2334
2335 /* 3. signal handler back-trampoline and parameters */
2336 env->regwptr[UREG_FP] = sf_addr;
2337 env->regwptr[UREG_I0] = sig;
2338 env->regwptr[UREG_I1] = sf_addr +
2339 offsetof(struct target_signal_frame, info);
2340 env->regwptr[UREG_I2] = sf_addr +
2341 offsetof(struct target_signal_frame, info);
2342
2343 /* 4. signal handler */
2344 env->pc = ka->_sa_handler;
2345 env->npc = (env->pc + 4);
2346 /* 5. return to kernel instructions */
2347 if (ka->sa_restorer) {
2348 env->regwptr[UREG_I7] = ka->sa_restorer;
2349 } else {
2350 uint32_t val32;
2351
2352 env->regwptr[UREG_I7] = sf_addr +
2353 offsetof(struct target_signal_frame, insns) - 2 * 4;
2354
2355 /* mov __NR_sigreturn, %g1 */
2356 val32 = 0x821020d8;
2357 __put_user(val32, &sf->insns[0]);
2358
2359 /* t 0x10 */
2360 val32 = 0x91d02010;
2361 __put_user(val32, &sf->insns[1]);
2362 if (err)
2363 goto sigsegv;
2364
2365 /* Flush instruction space. */
2366 // flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
2367 // tb_flush(env);
2368 }
2369 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
2370 return;
2371 #if 0
2372 sigill_and_return:
2373 force_sig(TARGET_SIGILL);
2374 #endif
2375 sigsegv:
2376 unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
2377 force_sig(TARGET_SIGSEGV);
2378 }
2379
2380 static void setup_rt_frame(int sig, struct target_sigaction *ka,
2381 target_siginfo_t *info,
2382 target_sigset_t *set, CPUSPARCState *env)
2383 {
2384 fprintf(stderr, "setup_rt_frame: not implemented\n");
2385 }
2386
2387 long do_sigreturn(CPUSPARCState *env)
2388 {
2389 abi_ulong sf_addr;
2390 struct target_signal_frame *sf;
2391 uint32_t up_psr, pc, npc;
2392 target_sigset_t set;
2393 sigset_t host_set;
2394 int err=0, i;
2395
2396 sf_addr = env->regwptr[UREG_FP];
2397 trace_user_do_sigreturn(env, sf_addr);
2398 if (!lock_user_struct(VERIFY_READ, sf, sf_addr, 1)) {
2399 goto segv_and_exit;
2400 }
2401
2402 /* 1. Make sure we are not getting garbage from the user */
2403
2404 if (sf_addr & 3)
2405 goto segv_and_exit;
2406
2407 __get_user(pc, &sf->info.si_regs.pc);
2408 __get_user(npc, &sf->info.si_regs.npc);
2409
2410 if ((pc | npc) & 3) {
2411 goto segv_and_exit;
2412 }
2413
2414 /* 2. Restore the state */
2415 __get_user(up_psr, &sf->info.si_regs.psr);
2416
2417 /* User can only change condition codes and FPU enabling in %psr. */
2418 env->psr = (up_psr & (PSR_ICC /* | PSR_EF */))
2419 | (env->psr & ~(PSR_ICC /* | PSR_EF */));
2420
2421 env->pc = pc;
2422 env->npc = npc;
2423 __get_user(env->y, &sf->info.si_regs.y);
2424 for (i=0; i < 8; i++) {
2425 __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]);
2426 }
2427 for (i=0; i < 8; i++) {
2428 __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]);
2429 }
2430
2431 /* FIXME: implement FPU save/restore:
2432 * __get_user(fpu_save, &sf->fpu_save);
2433 * if (fpu_save)
2434 * err |= restore_fpu_state(env, fpu_save);
2435 */
2436
2437 /* This is pretty much atomic, no amount locking would prevent
2438 * the races which exist anyways.
2439 */
2440 __get_user(set.sig[0], &sf->info.si_mask);
2441 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
2442 __get_user(set.sig[i], &sf->extramask[i - 1]);
2443 }
2444
2445 target_to_host_sigset_internal(&host_set, &set);
2446 do_sigprocmask(SIG_SETMASK, &host_set, NULL);
2447
2448 if (err) {
2449 goto segv_and_exit;
2450 }
2451 unlock_user_struct(sf, sf_addr, 0);
2452 return env->regwptr[0];
2453
2454 segv_and_exit:
2455 unlock_user_struct(sf, sf_addr, 0);
2456 force_sig(TARGET_SIGSEGV);
2457 }
2458
2459 long do_rt_sigreturn(CPUSPARCState *env)
2460 {
2461 trace_user_do_rt_sigreturn(env, 0);
2462 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
2463 return -TARGET_ENOSYS;
2464 }
2465
2466 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
2467 #define MC_TSTATE 0
2468 #define MC_PC 1
2469 #define MC_NPC 2
2470 #define MC_Y 3
2471 #define MC_G1 4
2472 #define MC_G2 5
2473 #define MC_G3 6
2474 #define MC_G4 7
2475 #define MC_G5 8
2476 #define MC_G6 9
2477 #define MC_G7 10
2478 #define MC_O0 11
2479 #define MC_O1 12
2480 #define MC_O2 13
2481 #define MC_O3 14
2482 #define MC_O4 15
2483 #define MC_O5 16
2484 #define MC_O6 17
2485 #define MC_O7 18
2486 #define MC_NGREG 19
2487
2488 typedef abi_ulong target_mc_greg_t;
2489 typedef target_mc_greg_t target_mc_gregset_t[MC_NGREG];
2490
2491 struct target_mc_fq {
2492 abi_ulong *mcfq_addr;
2493 uint32_t mcfq_insn;
2494 };
2495
2496 struct target_mc_fpu {
2497 union {
2498 uint32_t sregs[32];
2499 uint64_t dregs[32];
2500 //uint128_t qregs[16];
2501 } mcfpu_fregs;
2502 abi_ulong mcfpu_fsr;
2503 abi_ulong mcfpu_fprs;
2504 abi_ulong mcfpu_gsr;
2505 struct target_mc_fq *mcfpu_fq;
2506 unsigned char mcfpu_qcnt;
2507 unsigned char mcfpu_qentsz;
2508 unsigned char mcfpu_enab;
2509 };
2510 typedef struct target_mc_fpu target_mc_fpu_t;
2511
2512 typedef struct {
2513 target_mc_gregset_t mc_gregs;
2514 target_mc_greg_t mc_fp;
2515 target_mc_greg_t mc_i7;
2516 target_mc_fpu_t mc_fpregs;
2517 } target_mcontext_t;
2518
2519 struct target_ucontext {
2520 struct target_ucontext *tuc_link;
2521 abi_ulong tuc_flags;
2522 target_sigset_t tuc_sigmask;
2523 target_mcontext_t tuc_mcontext;
2524 };
2525
2526 /* A V9 register window */
2527 struct target_reg_window {
2528 abi_ulong locals[8];
2529 abi_ulong ins[8];
2530 };
2531
2532 #define TARGET_STACK_BIAS 2047
2533
2534 /* {set, get}context() needed for 64-bit SparcLinux userland. */
2535 void sparc64_set_context(CPUSPARCState *env)
2536 {
2537 abi_ulong ucp_addr;
2538 struct target_ucontext *ucp;
2539 target_mc_gregset_t *grp;
2540 abi_ulong pc, npc, tstate;
2541 abi_ulong fp, i7, w_addr;
2542 unsigned int i;
2543
2544 ucp_addr = env->regwptr[UREG_I0];
2545 if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1)) {
2546 goto do_sigsegv;
2547 }
2548 grp = &ucp->tuc_mcontext.mc_gregs;
2549 __get_user(pc, &((*grp)[MC_PC]));
2550 __get_user(npc, &((*grp)[MC_NPC]));
2551 if ((pc | npc) & 3) {
2552 goto do_sigsegv;
2553 }
2554 if (env->regwptr[UREG_I1]) {
2555 target_sigset_t target_set;
2556 sigset_t set;
2557
2558 if (TARGET_NSIG_WORDS == 1) {
2559 __get_user(target_set.sig[0], &ucp->tuc_sigmask.sig[0]);
2560 } else {
2561 abi_ulong *src, *dst;
2562 src = ucp->tuc_sigmask.sig;
2563 dst = target_set.sig;
2564 for (i = 0; i < TARGET_NSIG_WORDS; i++, dst++, src++) {
2565 __get_user(*dst, src);
2566 }
2567 }
2568 target_to_host_sigset_internal(&set, &target_set);
2569 do_sigprocmask(SIG_SETMASK, &set, NULL);
2570 }
2571 env->pc = pc;
2572 env->npc = npc;
2573 __get_user(env->y, &((*grp)[MC_Y]));
2574 __get_user(tstate, &((*grp)[MC_TSTATE]));
2575 env->asi = (tstate >> 24) & 0xff;
2576 cpu_put_ccr(env, tstate >> 32);
2577 cpu_put_cwp64(env, tstate & 0x1f);
2578 __get_user(env->gregs[1], (&(*grp)[MC_G1]));
2579 __get_user(env->gregs[2], (&(*grp)[MC_G2]));
2580 __get_user(env->gregs[3], (&(*grp)[MC_G3]));
2581 __get_user(env->gregs[4], (&(*grp)[MC_G4]));
2582 __get_user(env->gregs[5], (&(*grp)[MC_G5]));
2583 __get_user(env->gregs[6], (&(*grp)[MC_G6]));
2584 __get_user(env->gregs[7], (&(*grp)[MC_G7]));
2585 __get_user(env->regwptr[UREG_I0], (&(*grp)[MC_O0]));
2586 __get_user(env->regwptr[UREG_I1], (&(*grp)[MC_O1]));
2587 __get_user(env->regwptr[UREG_I2], (&(*grp)[MC_O2]));
2588 __get_user(env->regwptr[UREG_I3], (&(*grp)[MC_O3]));
2589 __get_user(env->regwptr[UREG_I4], (&(*grp)[MC_O4]));
2590 __get_user(env->regwptr[UREG_I5], (&(*grp)[MC_O5]));
2591 __get_user(env->regwptr[UREG_I6], (&(*grp)[MC_O6]));
2592 __get_user(env->regwptr[UREG_I7], (&(*grp)[MC_O7]));
2593
2594 __get_user(fp, &(ucp->tuc_mcontext.mc_fp));
2595 __get_user(i7, &(ucp->tuc_mcontext.mc_i7));
2596
2597 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2598 if (put_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
2599 abi_ulong) != 0) {
2600 goto do_sigsegv;
2601 }
2602 if (put_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]),
2603 abi_ulong) != 0) {
2604 goto do_sigsegv;
2605 }
2606 /* FIXME this does not match how the kernel handles the FPU in
2607 * its sparc64_set_context implementation. In particular the FPU
2608 * is only restored if fenab is non-zero in:
2609 * __get_user(fenab, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_enab));
2610 */
2611 __get_user(env->fprs, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fprs));
2612 {
2613 uint32_t *src = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2614 for (i = 0; i < 64; i++, src++) {
2615 if (i & 1) {
2616 __get_user(env->fpr[i/2].l.lower, src);
2617 } else {
2618 __get_user(env->fpr[i/2].l.upper, src);
2619 }
2620 }
2621 }
2622 __get_user(env->fsr,
2623 &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fsr));
2624 __get_user(env->gsr,
2625 &(ucp->tuc_mcontext.mc_fpregs.mcfpu_gsr));
2626 unlock_user_struct(ucp, ucp_addr, 0);
2627 return;
2628 do_sigsegv:
2629 unlock_user_struct(ucp, ucp_addr, 0);
2630 force_sig(TARGET_SIGSEGV);
2631 }
2632
2633 void sparc64_get_context(CPUSPARCState *env)
2634 {
2635 abi_ulong ucp_addr;
2636 struct target_ucontext *ucp;
2637 target_mc_gregset_t *grp;
2638 target_mcontext_t *mcp;
2639 abi_ulong fp, i7, w_addr;
2640 int err;
2641 unsigned int i;
2642 target_sigset_t target_set;
2643 sigset_t set;
2644
2645 ucp_addr = env->regwptr[UREG_I0];
2646 if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0)) {
2647 goto do_sigsegv;
2648 }
2649
2650 mcp = &ucp->tuc_mcontext;
2651 grp = &mcp->mc_gregs;
2652
2653 /* Skip over the trap instruction, first. */
2654 env->pc = env->npc;
2655 env->npc += 4;
2656
2657 err = 0;
2658
2659 do_sigprocmask(0, NULL, &set);
2660 host_to_target_sigset_internal(&target_set, &set);
2661 if (TARGET_NSIG_WORDS == 1) {
2662 __put_user(target_set.sig[0],
2663 (abi_ulong *)&ucp->tuc_sigmask);
2664 } else {
2665 abi_ulong *src, *dst;
2666 src = target_set.sig;
2667 dst = ucp->tuc_sigmask.sig;
2668 for (i = 0; i < TARGET_NSIG_WORDS; i++, dst++, src++) {
2669 __put_user(*src, dst);
2670 }
2671 if (err)
2672 goto do_sigsegv;
2673 }
2674
2675 /* XXX: tstate must be saved properly */
2676 // __put_user(env->tstate, &((*grp)[MC_TSTATE]));
2677 __put_user(env->pc, &((*grp)[MC_PC]));
2678 __put_user(env->npc, &((*grp)[MC_NPC]));
2679 __put_user(env->y, &((*grp)[MC_Y]));
2680 __put_user(env->gregs[1], &((*grp)[MC_G1]));
2681 __put_user(env->gregs[2], &((*grp)[MC_G2]));
2682 __put_user(env->gregs[3], &((*grp)[MC_G3]));
2683 __put_user(env->gregs[4], &((*grp)[MC_G4]));
2684 __put_user(env->gregs[5], &((*grp)[MC_G5]));
2685 __put_user(env->gregs[6], &((*grp)[MC_G6]));
2686 __put_user(env->gregs[7], &((*grp)[MC_G7]));
2687 __put_user(env->regwptr[UREG_I0], &((*grp)[MC_O0]));
2688 __put_user(env->regwptr[UREG_I1], &((*grp)[MC_O1]));
2689 __put_user(env->regwptr[UREG_I2], &((*grp)[MC_O2]));
2690 __put_user(env->regwptr[UREG_I3], &((*grp)[MC_O3]));
2691 __put_user(env->regwptr[UREG_I4], &((*grp)[MC_O4]));
2692 __put_user(env->regwptr[UREG_I5], &((*grp)[MC_O5]));
2693 __put_user(env->regwptr[UREG_I6], &((*grp)[MC_O6]));
2694 __put_user(env->regwptr[UREG_I7], &((*grp)[MC_O7]));
2695
2696 w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2697 fp = i7 = 0;
2698 if (get_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]),
2699 abi_ulong) != 0) {
2700 goto do_sigsegv;
2701 }
2702 if (get_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]),
2703 abi_ulong) != 0) {
2704 goto do_sigsegv;
2705 }
2706 __put_user(fp, &(mcp->mc_fp));
2707 __put_user(i7, &(mcp->mc_i7));
2708
2709 {
2710 uint32_t *dst = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2711 for (i = 0; i < 64; i++, dst++) {
2712 if (i & 1) {
2713 __put_user(env->fpr[i/2].l.lower, dst);
2714 } else {
2715 __put_user(env->fpr[i/2].l.upper, dst);
2716 }
2717 }
2718 }
2719 __put_user(env->fsr, &(mcp->mc_fpregs.mcfpu_fsr));
2720 __put_user(env->gsr, &(mcp->mc_fpregs.mcfpu_gsr));
2721 __put_user(env->fprs, &(mcp->mc_fpregs.mcfpu_fprs));
2722
2723 if (err)
2724 goto do_sigsegv;
2725 unlock_user_struct(ucp, ucp_addr, 1);
2726 return;
2727 do_sigsegv:
2728 unlock_user_struct(ucp, ucp_addr, 1);
2729 force_sig(TARGET_SIGSEGV);
2730 }
2731 #endif
2732 #elif defined(TARGET_MIPS) || defined(TARGET_MIPS64)
2733
2734 # if defined(TARGET_ABI_MIPSO32)
2735 struct target_sigcontext {
2736 uint32_t sc_regmask; /* Unused */
2737 uint32_t sc_status;
2738 uint64_t sc_pc;
2739 uint64_t sc_regs[32];
2740 uint64_t sc_fpregs[32];
2741 uint32_t sc_ownedfp; /* Unused */
2742 uint32_t sc_fpc_csr;
2743 uint32_t sc_fpc_eir; /* Unused */
2744 uint32_t sc_used_math;
2745 uint32_t sc_dsp; /* dsp status, was sc_ssflags */
2746 uint32_t pad0;
2747 uint64_t sc_mdhi;
2748 uint64_t sc_mdlo;
2749 target_ulong sc_hi1; /* Was sc_cause */
2750 target_ulong sc_lo1; /* Was sc_badvaddr */
2751 target_ulong sc_hi2; /* Was sc_sigset[4] */
2752 target_ulong sc_lo2;
2753 target_ulong sc_hi3;
2754 target_ulong sc_lo3;
2755 };
2756 # else /* N32 || N64 */
2757 struct target_sigcontext {
2758 uint64_t sc_regs[32];
2759 uint64_t sc_fpregs[32];
2760 uint64_t sc_mdhi;
2761 uint64_t sc_hi1;
2762 uint64_t sc_hi2;
2763 uint64_t sc_hi3;
2764 uint64_t sc_mdlo;
2765 uint64_t sc_lo1;
2766 uint64_t sc_lo2;
2767 uint64_t sc_lo3;
2768 uint64_t sc_pc;
2769 uint32_t sc_fpc_csr;
2770 uint32_t sc_used_math;
2771 uint32_t sc_dsp;
2772 uint32_t sc_reserved;
2773 };
2774 # endif /* O32 */
2775
2776 struct sigframe {
2777 uint32_t sf_ass[4]; /* argument save space for o32 */
2778 uint32_t sf_code[2]; /* signal trampoline */
2779 struct target_sigcontext sf_sc;
2780 target_sigset_t sf_mask;
2781 };
2782
2783 struct target_ucontext {
2784 target_ulong tuc_flags;
2785 target_ulong tuc_link;
2786 target_stack_t tuc_stack;
2787 target_ulong pad0;
2788 struct target_sigcontext tuc_mcontext;
2789 target_sigset_t tuc_sigmask;
2790 };
2791
2792 struct target_rt_sigframe {
2793 uint32_t rs_ass[4]; /* argument save space for o32 */
2794 uint32_t rs_code[2]; /* signal trampoline */
2795 struct target_siginfo rs_info;
2796 struct target_ucontext rs_uc;
2797 };
2798
2799 /* Install trampoline to jump back from signal handler */
2800 static inline int install_sigtramp(unsigned int *tramp, unsigned int syscall)
2801 {
2802 int err = 0;
2803
2804 /*
2805 * Set up the return code ...
2806 *
2807 * li v0, __NR__foo_sigreturn
2808 * syscall
2809 */
2810
2811 __put_user(0x24020000 + syscall, tramp + 0);
2812 __put_user(0x0000000c , tramp + 1);
2813 return err;
2814 }
2815
2816 static inline void setup_sigcontext(CPUMIPSState *regs,
2817 struct target_sigcontext *sc)
2818 {
2819 int i;
2820
2821 __put_user(exception_resume_pc(regs), &sc->sc_pc);
2822 regs->hflags &= ~MIPS_HFLAG_BMASK;
2823
2824 __put_user(0, &sc->sc_regs[0]);
2825 for (i = 1; i < 32; ++i) {
2826 __put_user(regs->active_tc.gpr[i], &sc->sc_regs[i]);
2827 }
2828
2829 __put_user(regs->active_tc.HI[0], &sc->sc_mdhi);
2830 __put_user(regs->active_tc.LO[0], &sc->sc_mdlo);
2831
2832 /* Rather than checking for dsp existence, always copy. The storage
2833 would just be garbage otherwise. */
2834 __put_user(regs->active_tc.HI[1], &sc->sc_hi1);
2835 __put_user(regs->active_tc.HI[2], &sc->sc_hi2);
2836 __put_user(regs->active_tc.HI[3], &sc->sc_hi3);
2837 __put_user(regs->active_tc.LO[1], &sc->sc_lo1);
2838 __put_user(regs->active_tc.LO[2], &sc->sc_lo2);
2839 __put_user(regs->active_tc.LO[3], &sc->sc_lo3);
2840 {
2841 uint32_t dsp = cpu_rddsp(0x3ff, regs);
2842 __put_user(dsp, &sc->sc_dsp);
2843 }
2844
2845 __put_user(1, &sc->sc_used_math);
2846
2847 for (i = 0; i < 32; ++i) {
2848 __put_user(regs->active_fpu.fpr[i].d, &sc->sc_fpregs[i]);
2849 }
2850 }
2851
2852 static inline void
2853 restore_sigcontext(CPUMIPSState *regs, struct target_sigcontext *sc)
2854 {
2855 int i;
2856
2857 __get_user(regs->CP0_EPC, &sc->sc_pc);
2858
2859 __get_user(regs->active_tc.HI[0], &sc->sc_mdhi);
2860 __get_user(regs->active_tc.LO[0], &sc->sc_mdlo);
2861
2862 for (i = 1; i < 32; ++i) {
2863 __get_user(regs->active_tc.gpr[i], &sc->sc_regs[i]);
2864 }
2865
2866 __get_user(regs->active_tc.HI[1], &sc->sc_hi1);
2867 __get_user(regs->active_tc.HI[2], &sc->sc_hi2);
2868 __get_user(regs->active_tc.HI[3], &sc->sc_hi3);
2869 __get_user(regs->active_tc.LO[1], &sc->sc_lo1);
2870 __get_user(regs->active_tc.LO[2], &sc->sc_lo2);
2871 __get_user(regs->active_tc.LO[3], &sc->sc_lo3);
2872 {
2873 uint32_t dsp;
2874 __get_user(dsp, &sc->sc_dsp);
2875 cpu_wrdsp(dsp, 0x3ff, regs);
2876 }
2877
2878 for (i = 0; i < 32; ++i) {
2879 __get_user(regs->active_fpu.fpr[i].d, &sc->sc_fpregs[i]);
2880 }
2881 }
2882
2883 /*
2884 * Determine which stack to use..
2885 */
2886 static inline abi_ulong
2887 get_sigframe(struct target_sigaction *ka, CPUMIPSState *regs, size_t frame_size)
2888 {
2889 unsigned long sp;
2890
2891 /* Default to using normal stack */
2892 sp = regs->active_tc.gpr[29];
2893
2894 /*
2895 * FPU emulator may have its own trampoline active just
2896 * above the user stack, 16-bytes before the next lowest
2897 * 16 byte boundary. Try to avoid trashing it.
2898 */
2899 sp -= 32;
2900
2901 /* This is the X/Open sanctioned signal stack switching. */
2902 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
2903 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
2904 }
2905
2906 return (sp - frame_size) & ~7;
2907 }
2908
2909 static void mips_set_hflags_isa_mode_from_pc(CPUMIPSState *env)
2910 {
2911 if (env->insn_flags & (ASE_MIPS16 | ASE_MICROMIPS)) {
2912 env->hflags &= ~MIPS_HFLAG_M16;
2913 env->hflags |= (env->active_tc.PC & 1) << MIPS_HFLAG_M16_SHIFT;
2914 env->active_tc.PC &= ~(target_ulong) 1;
2915 }
2916 }
2917
2918 # if defined(TARGET_ABI_MIPSO32)
2919 /* compare linux/arch/mips/kernel/signal.c:setup_frame() */
2920 static void setup_frame(int sig, struct target_sigaction * ka,
2921 target_sigset_t *set, CPUMIPSState *regs)
2922 {
2923 struct sigframe *frame;
2924 abi_ulong frame_addr;
2925 int i;
2926
2927 frame_addr = get_sigframe(ka, regs, sizeof(*frame));
2928 trace_user_setup_frame(regs, frame_addr);
2929 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
2930 goto give_sigsegv;
2931 }
2932
2933 install_sigtramp(frame->sf_code, TARGET_NR_sigreturn);
2934
2935 setup_sigcontext(regs, &frame->sf_sc);
2936
2937 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2938 __put_user(set->sig[i], &frame->sf_mask.sig[i]);
2939 }
2940
2941 /*
2942 * Arguments to signal handler:
2943 *
2944 * a0 = signal number
2945 * a1 = 0 (should be cause)
2946 * a2 = pointer to struct sigcontext
2947 *
2948 * $25 and PC point to the signal handler, $29 points to the
2949 * struct sigframe.
2950 */
2951 regs->active_tc.gpr[ 4] = sig;
2952 regs->active_tc.gpr[ 5] = 0;
2953 regs->active_tc.gpr[ 6] = frame_addr + offsetof(struct sigframe, sf_sc);
2954 regs->active_tc.gpr[29] = frame_addr;
2955 regs->active_tc.gpr[31] = frame_addr + offsetof(struct sigframe, sf_code);
2956 /* The original kernel code sets CP0_EPC to the handler
2957 * since it returns to userland using eret
2958 * we cannot do this here, and we must set PC directly */
2959 regs->active_tc.PC = regs->active_tc.gpr[25] = ka->_sa_handler;
2960 mips_set_hflags_isa_mode_from_pc(regs);
2961 unlock_user_struct(frame, frame_addr, 1);
2962 return;
2963
2964 give_sigsegv:
2965 force_sig(TARGET_SIGSEGV/*, current*/);
2966 }
2967
2968 long do_sigreturn(CPUMIPSState *regs)
2969 {
2970 struct sigframe *frame;
2971 abi_ulong frame_addr;
2972 sigset_t blocked;
2973 target_sigset_t target_set;
2974 int i;
2975
2976 frame_addr = regs->active_tc.gpr[29];
2977 trace_user_do_sigreturn(regs, frame_addr);
2978 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2979 goto badframe;
2980
2981 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2982 __get_user(target_set.sig[i], &frame->sf_mask.sig[i]);
2983 }
2984
2985 target_to_host_sigset_internal(&blocked, &target_set);
2986 do_sigprocmask(SIG_SETMASK, &blocked, NULL);
2987
2988 restore_sigcontext(regs, &frame->sf_sc);
2989
2990 #if 0
2991 /*
2992 * Don't let your children do this ...
2993 */
2994 __asm__ __volatile__(
2995 "move\t$29, %0\n\t"
2996 "j\tsyscall_exit"
2997 :/* no outputs */
2998 :"r" (&regs));
2999 /* Unreached */
3000 #endif
3001
3002 regs->active_tc.PC = regs->CP0_EPC;
3003 mips_set_hflags_isa_mode_from_pc(regs);
3004 /* I am not sure this is right, but it seems to work
3005 * maybe a problem with nested signals ? */
3006 regs->CP0_EPC = 0;
3007 return -TARGET_QEMU_ESIGRETURN;
3008
3009 badframe:
3010 force_sig(TARGET_SIGSEGV/*, current*/);
3011 return 0;
3012 }
3013 # endif /* O32 */
3014
3015 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3016 target_siginfo_t *info,
3017 target_sigset_t *set, CPUMIPSState *env)
3018 {
3019 struct target_rt_sigframe *frame;
3020 abi_ulong frame_addr;
3021 int i;
3022
3023 frame_addr = get_sigframe(ka, env, sizeof(*frame));
3024 trace_user_setup_rt_frame(env, frame_addr);
3025 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
3026 goto give_sigsegv;
3027 }
3028
3029 install_sigtramp(frame->rs_code, TARGET_NR_rt_sigreturn);
3030
3031 tswap_siginfo(&frame->rs_info, info);
3032
3033 __put_user(0, &frame->rs_uc.tuc_flags);
3034 __put_user(0, &frame->rs_uc.tuc_link);
3035 __put_user(target_sigaltstack_used.ss_sp, &frame->rs_uc.tuc_stack.ss_sp);
3036 __put_user(target_sigaltstack_used.ss_size, &frame->rs_uc.tuc_stack.ss_size);
3037 __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
3038 &frame->rs_uc.tuc_stack.ss_flags);
3039
3040 setup_sigcontext(env, &frame->rs_uc.tuc_mcontext);
3041
3042 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
3043 __put_user(set->sig[i], &frame->rs_uc.tuc_sigmask.sig[i]);
3044 }
3045
3046 /*
3047 * Arguments to signal handler:
3048 *
3049 * a0 = signal number
3050 * a1 = pointer to siginfo_t
3051 * a2 = pointer to struct ucontext
3052 *
3053 * $25 and PC point to the signal handler, $29 points to the
3054 * struct sigframe.
3055 */
3056 env->active_tc.gpr[ 4] = sig;
3057 env->active_tc.gpr[ 5] = frame_addr
3058 + offsetof(struct target_rt_sigframe, rs_info);
3059 env->active_tc.gpr[ 6] = frame_addr
3060 + offsetof(struct target_rt_sigframe, rs_uc);
3061 env->active_tc.gpr[29] = frame_addr;
3062 env->active_tc.gpr[31] = frame_addr
3063 + offsetof(struct target_rt_sigframe, rs_code);
3064 /* The original kernel code sets CP0_EPC to the handler
3065 * since it returns to userland using eret
3066 * we cannot do this here, and we must set PC directly */
3067 env->active_tc.PC = env->active_tc.gpr[25] = ka->_sa_handler;
3068 mips_set_hflags_isa_mode_from_pc(env);
3069 unlock_user_struct(frame, frame_addr, 1);
3070 return;
3071
3072 give_sigsegv:
3073 unlock_user_struct(frame, frame_addr, 1);
3074 force_sig(TARGET_SIGSEGV/*, current*/);
3075 }
3076
3077 long do_rt_sigreturn(CPUMIPSState *env)
3078 {
3079 struct target_rt_sigframe *frame;
3080 abi_ulong frame_addr;
3081 sigset_t blocked;
3082
3083 frame_addr = env->active_tc.gpr[29];
3084 trace_user_do_rt_sigreturn(env, frame_addr);
3085 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
3086 goto badframe;
3087 }
3088
3089 target_to_host_sigset(&blocked, &frame->rs_uc.tuc_sigmask);
3090 do_sigprocmask(SIG_SETMASK, &blocked, NULL);
3091
3092 restore_sigcontext(env, &frame->rs_uc.tuc_mcontext);
3093
3094 if (do_sigaltstack(frame_addr +
3095 offsetof(struct target_rt_sigframe, rs_uc.tuc_stack),
3096 0, get_sp_from_cpustate(env)) == -EFAULT)
3097 goto badframe;
3098
3099 env->active_tc.PC = env->CP0_EPC;
3100 mips_set_hflags_isa_mode_from_pc(env);
3101 /* I am not sure this is right, but it seems to work
3102 * maybe a problem with nested signals ? */
3103 env->CP0_EPC = 0;
3104 return -TARGET_QEMU_ESIGRETURN;
3105
3106 badframe:
3107 force_sig(TARGET_SIGSEGV/*, current*/);
3108 return 0;
3109 }
3110
3111 #elif defined(TARGET_SH4)
3112
3113 /*
3114 * code and data structures from linux kernel:
3115 * include/asm-sh/sigcontext.h
3116 * arch/sh/kernel/signal.c
3117 */
3118
3119 struct target_sigcontext {
3120 target_ulong oldmask;
3121
3122 /* CPU registers */
3123 target_ulong sc_gregs[16];
3124 target_ulong sc_pc;
3125 target_ulong sc_pr;
3126 target_ulong sc_sr;
3127 target_ulong sc_gbr;
3128 target_ulong sc_mach;
3129 target_ulong sc_macl;
3130
3131 /* FPU registers */
3132 target_ulong sc_fpregs[16];
3133 target_ulong sc_xfpregs[16];
3134 unsigned int sc_fpscr;
3135 unsigned int sc_fpul;
3136 unsigned int sc_ownedfp;
3137 };
3138
3139 struct target_sigframe
3140 {
3141 struct target_sigcontext sc;
3142 target_ulong extramask[TARGET_NSIG_WORDS-1];
3143 uint16_t retcode[3];
3144 };
3145
3146
3147 struct target_ucontext {
3148 target_ulong tuc_flags;
3149 struct target_ucontext *tuc_link;
3150 target_stack_t tuc_stack;
3151 struct target_sigcontext tuc_mcontext;
3152 target_sigset_t tuc_sigmask; /* mask last for extensibility */
3153 };
3154
3155 struct target_rt_sigframe
3156 {
3157 struct target_siginfo info;
3158 struct target_ucontext uc;
3159 uint16_t retcode[3];
3160 };
3161
3162
3163 #define MOVW(n) (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */
3164 #define TRAP_NOARG 0xc310 /* Syscall w/no args (NR in R3) SH3/4 */
3165
3166 static abi_ulong get_sigframe(struct target_sigaction *ka,
3167 unsigned long sp, size_t frame_size)
3168 {
3169 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags(sp) == 0)) {
3170 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3171 }
3172
3173 return (sp - frame_size) & -8ul;
3174 }
3175
3176 static void setup_sigcontext(struct target_sigcontext *sc,
3177 CPUSH4State *regs, unsigned long mask)
3178 {
3179 int i;
3180
3181 #define COPY(x) __put_user(regs->x, &sc->sc_##x)
3182 COPY(gregs[0]); COPY(gregs[1]);
3183 COPY(gregs[2]); COPY(gregs[3]);
3184 COPY(gregs[4]); COPY(gregs[5]);
3185 COPY(gregs[6]); COPY(gregs[7]);
3186 COPY(gregs[8]); COPY(gregs[9]);
3187 COPY(gregs[10]); COPY(gregs[11]);
3188 COPY(gregs[12]); COPY(gregs[13]);
3189 COPY(gregs[14]); COPY(gregs[15]);
3190 COPY(gbr); COPY(mach);
3191 COPY(macl); COPY(pr);
3192 COPY(sr); COPY(pc);
3193 #undef COPY
3194
3195 for (i=0; i<16; i++) {
3196 __put_user(regs->fregs[i], &sc->sc_fpregs[i]);
3197 }
3198 __put_user(regs->fpscr, &sc->sc_fpscr);
3199 __put_user(regs->fpul, &sc->sc_fpul);
3200
3201 /* non-iBCS2 extensions.. */
3202 __put_user(mask, &sc->oldmask);
3203 }
3204
3205 static void restore_sigcontext(CPUSH4State *regs, struct target_sigcontext *sc,
3206 target_ulong *r0_p)
3207 {
3208 int i;
3209
3210 #define COPY(x) __get_user(regs->x, &sc->sc_##x)
3211 COPY(gregs[1]);
3212 COPY(gregs[2]); COPY(gregs[3]);
3213 COPY(gregs[4]); COPY(gregs[5]);
3214 COPY(gregs[6]); COPY(gregs[7]);
3215 COPY(gregs[8]); COPY(gregs[9]);
3216 COPY(gregs[10]); COPY(gregs[11]);
3217 COPY(gregs[12]); COPY(gregs[13]);
3218 COPY(gregs[14]); COPY(gregs[15]);
3219 COPY(gbr); COPY(mach);
3220 COPY(macl); COPY(pr);
3221 COPY(sr); COPY(pc);
3222 #undef COPY
3223
3224 for (i=0; i<16; i++) {
3225 __get_user(regs->fregs[i], &sc->sc_fpregs[i]);
3226 }
3227 __get_user(regs->fpscr, &sc->sc_fpscr);
3228 __get_user(regs->fpul, &sc->sc_fpul);
3229
3230 regs->tra = -1; /* disable syscall checks */
3231 __get_user(*r0_p, &sc->sc_gregs[0]);
3232 }
3233
3234 static void setup_frame(int sig, struct target_sigaction *ka,
3235 target_sigset_t *set, CPUSH4State *regs)
3236 {
3237 struct target_sigframe *frame;
3238 abi_ulong frame_addr;
3239 int i;
3240
3241 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
3242 trace_user_setup_frame(regs, frame_addr);
3243 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
3244 goto give_sigsegv;
3245 }
3246
3247 setup_sigcontext(&frame->sc, regs, set->sig[0]);
3248
3249 for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
3250 __put_user(set->sig[i + 1], &frame->extramask[i]);
3251 }
3252
3253 /* Set up to return from userspace. If provided, use a stub
3254 already in userspace. */
3255 if (ka->sa_flags & TARGET_SA_RESTORER) {
3256 regs->pr = (unsigned long) ka->sa_restorer;
3257 } else {
3258 /* Generate return code (system call to sigreturn) */
3259 abi_ulong retcode_addr = frame_addr +
3260 offsetof(struct target_sigframe, retcode);
3261 __put_user(MOVW(2), &frame->retcode[0]);
3262 __put_user(TRAP_NOARG, &frame->retcode[1]);
3263 __put_user((TARGET_NR_sigreturn), &frame->retcode[2]);
3264 regs->pr = (unsigned long) retcode_addr;
3265 }
3266
3267 /* Set up registers for signal handler */
3268 regs->gregs[15] = frame_addr;
3269 regs->gregs[4] = sig; /* Arg for signal handler */
3270 regs->gregs[5] = 0;
3271 regs->gregs[6] = frame_addr += offsetof(typeof(*frame), sc);
3272 regs->pc = (unsigned long) ka->_sa_handler;
3273
3274 unlock_user_struct(frame, frame_addr, 1);
3275 return;
3276
3277 give_sigsegv:
3278 unlock_user_struct(frame, frame_addr, 1);
3279 force_sig(TARGET_SIGSEGV);
3280 }
3281
3282 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3283 target_siginfo_t *info,
3284 target_sigset_t *set, CPUSH4State *regs)
3285 {
3286 struct target_rt_sigframe *frame;
3287 abi_ulong frame_addr;
3288 int i;
3289
3290 frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
3291 trace_user_setup_rt_frame(regs, frame_addr);
3292 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
3293 goto give_sigsegv;
3294 }
3295
3296 tswap_siginfo(&frame->info, info);
3297
3298 /* Create the ucontext. */
3299 __put_user(0, &frame->uc.tuc_flags);
3300 __put_user(0, (unsigned long *)&frame->uc.tuc_link);
3301 __put_user((unsigned long)target_sigaltstack_used.ss_sp,
3302 &frame->uc.tuc_stack.ss_sp);
3303 __put_user(sas_ss_flags(regs->gregs[15]),
3304 &frame->uc.tuc_stack.ss_flags);
3305 __put_user(target_sigaltstack_used.ss_size,
3306 &frame->uc.tuc_stack.ss_size);
3307 setup_sigcontext(&frame->uc.tuc_mcontext,
3308 regs, set->sig[0]);
3309 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
3310 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
3311 }
3312
3313 /* Set up to return from userspace. If provided, use a stub
3314 already in userspace. */
3315 if (ka->sa_flags & TARGET_SA_RESTORER) {
3316 regs->pr = (unsigned long) ka->sa_restorer;
3317 } else {
3318 /* Generate return code (system call to sigreturn) */
3319 abi_ulong retcode_addr = frame_addr +
3320 offsetof(struct target_rt_sigframe, retcode);
3321 __put_user(MOVW(2), &frame->retcode[0]);
3322 __put_user(TRAP_NOARG, &frame->retcode[1]);
3323 __put_user((TARGET_NR_rt_sigreturn), &frame->retcode[2]);
3324 regs->pr = (unsigned long) retcode_addr;
3325 }
3326
3327 /* Set up registers for signal handler */
3328 regs->gregs[15] = frame_addr;
3329 regs->gregs[4] = sig; /* Arg for signal handler */
3330 regs->gregs[5] = frame_addr + offsetof(typeof(*frame), info);
3331 regs->gregs[6] = frame_addr + offsetof(typeof(*frame), uc);
3332 regs->pc = (unsigned long) ka->_sa_handler;
3333
3334 unlock_user_struct(frame, frame_addr, 1);
3335 return;
3336
3337 give_sigsegv:
3338 unlock_user_struct(frame, frame_addr, 1);
3339 force_sig(TARGET_SIGSEGV);
3340 }
3341
3342 long do_sigreturn(CPUSH4State *regs)
3343 {
3344 struct target_sigframe *frame;
3345 abi_ulong frame_addr;
3346 sigset_t blocked;
3347 target_sigset_t target_set;
3348 target_ulong r0;
3349 int i;
3350 int err = 0;
3351
3352 frame_addr = regs->gregs[15];
3353 trace_user_do_sigreturn(regs, frame_addr);
3354 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
3355 goto badframe;
3356 }
3357
3358 __get_user(target_set.sig[0], &frame->sc.oldmask);
3359 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3360 __get_user(target_set.sig[i], &frame->extramask[i - 1]);
3361 }
3362
3363 if (err)
3364 goto badframe;
3365
3366 target_to_host_sigset_internal(&blocked, &target_set);
3367 do_sigprocmask(SIG_SETMASK, &blocked, NULL);
3368
3369 restore_sigcontext(regs, &frame->sc, &r0);
3370
3371 unlock_user_struct(frame, frame_addr, 0);
3372 return r0;
3373
3374 badframe:
3375 unlock_user_struct(frame, frame_addr, 0);
3376 force_sig(TARGET_SIGSEGV);
3377 return 0;
3378 }
3379
3380 long do_rt_sigreturn(CPUSH4State *regs)
3381 {
3382 struct target_rt_sigframe *frame;
3383 abi_ulong frame_addr;
3384 sigset_t blocked;
3385 target_ulong r0;
3386
3387 frame_addr = regs->gregs[15];
3388 trace_user_do_rt_sigreturn(regs, frame_addr);
3389 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
3390 goto badframe;
3391 }
3392
3393 target_to_host_sigset(&blocked, &frame->uc.tuc_sigmask);
3394 do_sigprocmask(SIG_SETMASK, &blocked, NULL);
3395
3396 restore_sigcontext(regs, &frame->uc.tuc_mcontext, &r0);
3397
3398 if (do_sigaltstack(frame_addr +
3399 offsetof(struct target_rt_sigframe, uc.tuc_stack),
3400 0, get_sp_from_cpustate(regs)) == -EFAULT) {
3401 goto badframe;
3402 }
3403
3404 unlock_user_struct(frame, frame_addr, 0);
3405 return r0;
3406
3407 badframe:
3408 unlock_user_struct(frame, frame_addr, 0);
3409 force_sig(TARGET_SIGSEGV);
3410 return 0;
3411 }
3412 #elif defined(TARGET_MICROBLAZE)
3413
3414 struct target_sigcontext {
3415 struct target_pt_regs regs; /* needs to be first */
3416 uint32_t oldmask;
3417 };
3418
3419 struct target_stack_t {
3420 abi_ulong ss_sp;
3421 int ss_flags;
3422 unsigned int ss_size;
3423 };
3424
3425 struct target_ucontext {
3426 abi_ulong tuc_flags;
3427 abi_ulong tuc_link;
3428 struct target_stack_t tuc_stack;
3429 struct target_sigcontext tuc_mcontext;
3430 uint32_t tuc_extramask[TARGET_NSIG_WORDS - 1];
3431 };
3432
3433 /* Signal frames. */
3434 struct target_signal_frame {
3435 struct target_ucontext uc;
3436 uint32_t extramask[TARGET_NSIG_WORDS - 1];
3437 uint32_t tramp[2];
3438 };
3439
3440 struct rt_signal_frame {
3441 siginfo_t info;
3442 struct ucontext uc;
3443 uint32_t tramp[2];
3444 };
3445
3446 static void setup_sigcontext(struct target_sigcontext *sc, CPUMBState *env)
3447 {
3448 __put_user(env->regs[0], &sc->regs.r0);
3449 __put_user(env->regs[1], &sc->regs.r1);
3450 __put_user(env->regs[2], &sc->regs.r2);
3451 __put_user(env->regs[3], &sc->regs.r3);
3452 __put_user(env->regs[4], &sc->regs.r4);
3453 __put_user(env->regs[5], &sc->regs.r5);
3454 __put_user(env->regs[6], &sc->regs.r6);
3455 __put_user(env->regs[7], &sc->regs.r7);
3456 __put_user(env->regs[8], &sc->regs.r8);
3457 __put_user(env->regs[9], &sc->regs.r9);
3458 __put_user(env->regs[10], &sc->regs.r10);
3459 __put_user(env->regs[11], &sc->regs.r11);
3460 __put_user(env->regs[12], &sc->regs.r12);
3461 __put_user(env->regs[13], &sc->regs.r13);
3462 __put_user(env->regs[14], &sc->regs.r14);
3463 __put_user(env->regs[15], &sc->regs.r15);
3464 __put_user(env->regs[16], &sc->regs.r16);
3465 __put_user(env->regs[17], &sc->regs.r17);
3466 __put_user(env->regs[18], &sc->regs.r18);
3467 __put_user(env->regs[19], &sc->regs.r19);
3468 __put_user(env->regs[20], &sc->regs.r20);
3469 __put_user(env->regs[21], &sc->regs.r21);
3470 __put_user(env->regs[22], &sc->regs.r22);
3471 __put_user(env->regs[23], &sc->regs.r23);
3472 __put_user(env->regs[24], &sc->regs.r24);
3473 __put_user(env->regs[25], &sc->regs.r25);
3474 __put_user(env->regs[26], &sc->regs.r26);
3475 __put_user(env->regs[27], &sc->regs.r27);
3476 __put_user(env->regs[28], &sc->regs.r28);
3477 __put_user(env->regs[29], &sc->regs.r29);
3478 __put_user(env->regs[30], &sc->regs.r30);
3479 __put_user(env->regs[31], &sc->regs.r31);
3480 __put_user(env->sregs[SR_PC], &sc->regs.pc);
3481 }
3482
3483 static void restore_sigcontext(struct target_sigcontext *sc, CPUMBState *env)
3484 {
3485 __get_user(env->regs[0], &sc->regs.r0);
3486 __get_user(env->regs[1], &sc->regs.r1);
3487 __get_user(env->regs[2], &sc->regs.r2);
3488 __get_user(env->regs[3], &sc->regs.r3);
3489 __get_user(env->regs[4], &sc->regs.r4);
3490 __get_user(env->regs[5], &sc->regs.r5);
3491 __get_user(env->regs[6], &sc->regs.r6);
3492 __get_user(env->regs[7], &sc->regs.r7);
3493 __get_user(env->regs[8], &sc->regs.r8);
3494 __get_user(env->regs[9], &sc->regs.r9);
3495 __get_user(env->regs[10], &sc->regs.r10);
3496 __get_user(env->regs[11], &sc->regs.r11);
3497 __get_user(env->regs[12], &sc->regs.r12);
3498 __get_user(env->regs[13], &sc->regs.r13);
3499 __get_user(env->regs[14], &sc->regs.r14);
3500 __get_user(env->regs[15], &sc->regs.r15);
3501 __get_user(env->regs[16], &sc->regs.r16);
3502 __get_user(env->regs[17], &sc->regs.r17);
3503 __get_user(env->regs[18], &sc->regs.r18);
3504 __get_user(env->regs[19], &sc->regs.r19);
3505 __get_user(env->regs[20], &sc->regs.r20);
3506 __get_user(env->regs[21], &sc->regs.r21);
3507 __get_user(env->regs[22], &sc->regs.r22);
3508 __get_user(env->regs[23], &sc->regs.r23);
3509 __get_user(env->regs[24], &sc->regs.r24);
3510 __get_user(env->regs[25], &sc->regs.r25);
3511 __get_user(env->regs[26], &sc->regs.r26);
3512 __get_user(env->regs[27], &sc->regs.r27);
3513 __get_user(env->regs[28], &sc->regs.r28);
3514 __get_user(env->regs[29], &sc->regs.r29);
3515 __get_user(env->regs[30], &sc->regs.r30);
3516 __get_user(env->regs[31], &sc->regs.r31);
3517 __get_user(env->sregs[SR_PC], &sc->regs.pc);
3518 }
3519
3520 static abi_ulong get_sigframe(struct target_sigaction *ka,
3521 CPUMBState *env, int frame_size)
3522 {
3523 abi_ulong sp = env->regs[1];
3524
3525 if ((ka->sa_flags & TARGET_SA_ONSTACK) != 0 && !on_sig_stack(sp)) {
3526 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3527 }
3528
3529 return ((sp - frame_size) & -8UL);
3530 }
3531
3532 static void setup_frame(int sig, struct target_sigaction *ka,
3533 target_sigset_t *set, CPUMBState *env)
3534 {
3535 struct target_signal_frame *frame;
3536 abi_ulong frame_addr;
3537 int i;
3538
3539 frame_addr = get_sigframe(ka, env, sizeof *frame);
3540 trace_user_setup_frame(env, frame_addr);
3541 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3542 goto badframe;
3543
3544 /* Save the mask. */
3545 __put_user(set->sig[0], &frame->uc.tuc_mcontext.oldmask);
3546
3547 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3548 __put_user(set->sig[i], &frame->extramask[i - 1]);
3549 }
3550
3551 setup_sigcontext(&frame->uc.tuc_mcontext, env);
3552
3553 /* Set up to return from userspace. If provided, use a stub
3554 already in userspace. */
3555 /* minus 8 is offset to cater for "rtsd r15,8" offset */
3556 if (ka->sa_flags & TARGET_SA_RESTORER) {
3557 env->regs[15] = ((unsigned long)ka->sa_restorer)-8;
3558 } else {
3559 uint32_t t;
3560 /* Note, these encodings are _big endian_! */
3561 /* addi r12, r0, __NR_sigreturn */
3562 t = 0x31800000UL | TARGET_NR_sigreturn;
3563 __put_user(t, frame->tramp + 0);
3564 /* brki r14, 0x8 */
3565 t = 0xb9cc0008UL;
3566 __put_user(t, frame->tramp + 1);
3567
3568 /* Return from sighandler will jump to the tramp.
3569 Negative 8 offset because return is rtsd r15, 8 */
3570 env->regs[15] = ((unsigned long)frame->tramp) - 8;
3571 }
3572
3573 /* Set up registers for signal handler */
3574 env->regs[1] = frame_addr;
3575 /* Signal handler args: */
3576 env->regs[5] = sig; /* Arg 0: signum */
3577 env->regs[6] = 0;
3578 /* arg 1: sigcontext */
3579 env->regs[7] = frame_addr += offsetof(typeof(*frame), uc);
3580
3581 /* Offset of 4 to handle microblaze rtid r14, 0 */
3582 env->sregs[SR_PC] = (unsigned long)ka->_sa_handler;
3583
3584 unlock_user_struct(frame, frame_addr, 1);
3585 return;
3586 badframe:
3587 force_sig(TARGET_SIGSEGV);
3588 }
3589
3590 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3591 target_siginfo_t *info,
3592 target_sigset_t *set, CPUMBState *env)
3593 {
3594 fprintf(stderr, "Microblaze setup_rt_frame: not implemented\n");
3595 }
3596
3597 long do_sigreturn(CPUMBState *env)
3598 {
3599 struct target_signal_frame *frame;
3600 abi_ulong frame_addr;
3601 target_sigset_t target_set;
3602 sigset_t set;
3603 int i;
3604
3605 frame_addr = env->regs[R_SP];
3606 trace_user_do_sigreturn(env, frame_addr);
3607 /* Make sure the guest isn't playing games. */
3608 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
3609 goto badframe;
3610
3611 /* Restore blocked signals */
3612 __get_user(target_set.sig[0], &frame->uc.tuc_mcontext.oldmask);
3613 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3614 __get_user(target_set.sig[i], &frame->extramask[i - 1]);
3615 }
3616 target_to_host_sigset_internal(&set, &target_set);
3617 do_sigprocmask(SIG_SETMASK, &set, NULL);
3618
3619 restore_sigcontext(&frame->uc.tuc_mcontext, env);
3620 /* We got here through a sigreturn syscall, our path back is via an
3621 rtb insn so setup r14 for that. */
3622 env->regs[14] = env->sregs[SR_PC];
3623
3624 unlock_user_struct(frame, frame_addr, 0);
3625 return env->regs[10];
3626 badframe:
3627 force_sig(TARGET_SIGSEGV);
3628 }
3629
3630 long do_rt_sigreturn(CPUMBState *env)
3631 {
3632 trace_user_do_rt_sigreturn(env, 0);
3633 fprintf(stderr, "Microblaze do_rt_sigreturn: not implemented\n");
3634 return -TARGET_ENOSYS;
3635 }
3636
3637 #elif defined(TARGET_CRIS)
3638
3639 struct target_sigcontext {
3640 struct target_pt_regs regs; /* needs to be first */
3641 uint32_t oldmask;
3642 uint32_t usp; /* usp before stacking this gunk on it */
3643 };
3644
3645 /* Signal frames. */
3646 struct target_signal_frame {
3647 struct target_sigcontext sc;
3648 uint32_t extramask[TARGET_NSIG_WORDS - 1];
3649 uint16_t retcode[4]; /* Trampoline code. */
3650 };
3651
3652 struct rt_signal_frame {
3653 siginfo_t *pinfo;
3654 void *puc;
3655 siginfo_t info;
3656 struct ucontext uc;
3657 uint16_t retcode[4]; /* Trampoline code. */
3658 };
3659
3660 static void setup_sigcontext(struct target_sigcontext *sc, CPUCRISState *env)
3661 {
3662 __put_user(env->regs[0], &sc->regs.r0);
3663 __put_user(env->regs[1], &sc->regs.r1);
3664 __put_user(env->regs[2], &sc->regs.r2);
3665 __put_user(env->regs[3], &sc->regs.r3);
3666 __put_user(env->regs[4], &sc->regs.r4);
3667 __put_user(env->regs[5], &sc->regs.r5);
3668 __put_user(env->regs[6], &sc->regs.r6);
3669 __put_user(env->regs[7], &sc->regs.r7);
3670 __put_user(env->regs[8], &sc->regs.r8);
3671 __put_user(env->regs[9], &sc->regs.r9);
3672 __put_user(env->regs[10], &sc->regs.r10);
3673 __put_user(env->regs[11], &sc->regs.r11);
3674 __put_user(env->regs[12], &sc->regs.r12);
3675 __put_user(env->regs[13], &sc->regs.r13);
3676 __put_user(env->regs[14], &sc->usp);
3677 __put_user(env->regs[15], &sc->regs.acr);
3678 __put_user(env->pregs[PR_MOF], &sc->regs.mof);
3679 __put_user(env->pregs[PR_SRP], &sc->regs.srp);
3680 __put_user(env->pc, &sc->regs.erp);
3681 }
3682
3683 static void restore_sigcontext(struct target_sigcontext *sc, CPUCRISState *env)
3684 {
3685 __get_user(env->regs[0], &sc->regs.r0);
3686 __get_user(env->regs[1], &sc->regs.r1);
3687 __get_user(env->regs[2], &sc->regs.r2);
3688 __get_user(env->regs[3], &sc->regs.r3);
3689 __get_user(env->regs[4], &sc->regs.r4);
3690 __get_user(env->regs[5], &sc->regs.r5);
3691 __get_user(env->regs[6], &sc->regs.r6);
3692 __get_user(env->regs[7], &sc->regs.r7);
3693 __get_user(env->regs[8], &sc->regs.r8);
3694 __get_user(env->regs[9], &sc->regs.r9);
3695 __get_user(env->regs[10], &sc->regs.r10);
3696 __get_user(env->regs[11], &sc->regs.r11);
3697 __get_user(env->regs[12], &sc->regs.r12);
3698 __get_user(env->regs[13], &sc->regs.r13);
3699 __get_user(env->regs[14], &sc->usp);
3700 __get_user(env->regs[15], &sc->regs.acr);
3701 __get_user(env->pregs[PR_MOF], &sc->regs.mof);
3702 __get_user(env->pregs[PR_SRP], &sc->regs.srp);
3703 __get_user(env->pc, &sc->regs.erp);
3704 }
3705
3706 static abi_ulong get_sigframe(CPUCRISState *env, int framesize)
3707 {
3708 abi_ulong sp;
3709 /* Align the stack downwards to 4. */
3710 sp = (env->regs[R_SP] & ~3);
3711 return sp - framesize;
3712 }
3713
3714 static void setup_frame(int sig, struct target_sigaction *ka,
3715 target_sigset_t *set, CPUCRISState *env)
3716 {
3717 struct target_signal_frame *frame;
3718 abi_ulong frame_addr;
3719 int i;
3720
3721 frame_addr = get_sigframe(env, sizeof *frame);
3722 trace_user_setup_frame(env, frame_addr);
3723 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3724 goto badframe;
3725
3726 /*
3727 * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't
3728 * use this trampoline anymore but it sets it up for GDB.
3729 * In QEMU, using the trampoline simplifies things a bit so we use it.
3730 *
3731 * This is movu.w __NR_sigreturn, r9; break 13;
3732 */
3733 __put_user(0x9c5f, frame->retcode+0);
3734 __put_user(TARGET_NR_sigreturn,
3735 frame->retcode + 1);
3736 __put_user(0xe93d, frame->retcode + 2);
3737
3738 /* Save the mask. */
3739 __put_user(set->sig[0], &frame->sc.oldmask);
3740
3741 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3742 __put_user(set->sig[i], &frame->extramask[i - 1]);
3743 }
3744
3745 setup_sigcontext(&frame->sc, env);
3746
3747 /* Move the stack and setup the arguments for the handler. */
3748 env->regs[R_SP] = frame_addr;
3749 env->regs[10] = sig;
3750 env->pc = (unsigned long) ka->_sa_handler;
3751 /* Link SRP so the guest returns through the trampoline. */
3752 env->pregs[PR_SRP] = frame_addr + offsetof(typeof(*frame), retcode);
3753
3754 unlock_user_struct(frame, frame_addr, 1);
3755 return;
3756 badframe:
3757 force_sig(TARGET_SIGSEGV);
3758 }
3759
3760 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3761 target_siginfo_t *info,
3762 target_sigset_t *set, CPUCRISState *env)
3763 {
3764 fprintf(stderr, "CRIS setup_rt_frame: not implemented\n");
3765 }
3766
3767 long do_sigreturn(CPUCRISState *env)
3768 {
3769 struct target_signal_frame *frame;
3770 abi_ulong frame_addr;
3771 target_sigset_t target_set;
3772 sigset_t set;
3773 int i;
3774
3775 frame_addr = env->regs[R_SP];
3776 trace_user_do_sigreturn(env, frame_addr);
3777 /* Make sure the guest isn't playing games. */
3778 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1)) {
3779 goto badframe;
3780 }
3781
3782 /* Restore blocked signals */
3783 __get_user(target_set.sig[0], &frame->sc.oldmask);
3784 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3785 __get_user(target_set.sig[i], &frame->extramask[i - 1]);
3786 }
3787 target_to_host_sigset_internal(&set, &target_set);
3788 do_sigprocmask(SIG_SETMASK, &set, NULL);
3789
3790 restore_sigcontext(&frame->sc, env);
3791 unlock_user_struct(frame, frame_addr, 0);
3792 return env->regs[10];
3793 badframe:
3794 force_sig(TARGET_SIGSEGV);
3795 }
3796
3797 long do_rt_sigreturn(CPUCRISState *env)
3798 {
3799 trace_user_do_rt_sigreturn(env, 0);
3800 fprintf(stderr, "CRIS do_rt_sigreturn: not implemented\n");
3801 return -TARGET_ENOSYS;
3802 }
3803
3804 #elif defined(TARGET_OPENRISC)
3805
3806 struct target_sigcontext {
3807 struct target_pt_regs regs;
3808 abi_ulong oldmask;
3809 abi_ulong usp;
3810 };
3811
3812 struct target_ucontext {
3813 abi_ulong tuc_flags;
3814 abi_ulong tuc_link;
3815 target_stack_t tuc_stack;
3816 struct target_sigcontext tuc_mcontext;
3817 target_sigset_t tuc_sigmask; /* mask last for extensibility */
3818 };
3819
3820 struct target_rt_sigframe {
3821 abi_ulong pinfo;
3822 uint64_t puc;
3823 struct target_siginfo info;
3824 struct target_sigcontext sc;
3825 struct target_ucontext uc;
3826 unsigned char retcode[16]; /* trampoline code */
3827 };
3828
3829 /* This is the asm-generic/ucontext.h version */
3830 #if 0
3831 static int restore_sigcontext(CPUOpenRISCState *regs,
3832 struct target_sigcontext *sc)
3833 {
3834 unsigned int err = 0;
3835 unsigned long old_usp;
3836
3837 /* Alwys make any pending restarted system call return -EINTR */
3838 current_thread_info()->restart_block.fn = do_no_restart_syscall;
3839
3840 /* restore the regs from &sc->regs (same as sc, since regs is first)
3841 * (sc is already checked for VERIFY_READ since the sigframe was
3842 * checked in sys_sigreturn previously)
3843 */
3844
3845 if (copy_from_user(regs, &sc, sizeof(struct target_pt_regs))) {
3846 goto badframe;
3847 }
3848
3849 /* make sure the U-flag is set so user-mode cannot fool us */
3850
3851 regs->sr &= ~SR_SM;
3852
3853 /* restore the old USP as it was before we stacked the sc etc.
3854 * (we cannot just pop the sigcontext since we aligned the sp and
3855 * stuff after pushing it)
3856 */
3857
3858 __get_user(old_usp, &sc->usp);
3859 phx_signal("old_usp 0x%lx", old_usp);
3860
3861 __PHX__ REALLY /* ??? */
3862 wrusp(old_usp);
3863 regs->gpr[1] = old_usp;
3864
3865 /* TODO: the other ports use regs->orig_XX to disable syscall checks
3866 * after this completes, but we don't use that mechanism. maybe we can
3867 * use it now ?
3868 */
3869
3870 return err;
3871
3872 badframe:
3873 return 1;
3874 }
3875 #endif
3876
3877 /* Set up a signal frame. */
3878
3879 static void setup_sigcontext(struct target_sigcontext *sc,
3880 CPUOpenRISCState *regs,
3881 unsigned long mask)
3882 {
3883 unsigned long usp = regs->gpr[1];
3884
3885 /* copy the regs. they are first in sc so we can use sc directly */
3886
3887 /*copy_to_user(&sc, regs, sizeof(struct target_pt_regs));*/
3888
3889 /* Set the frametype to CRIS_FRAME_NORMAL for the execution of
3890 the signal handler. The frametype will be restored to its previous
3891 value in restore_sigcontext. */
3892 /*regs->frametype = CRIS_FRAME_NORMAL;*/
3893
3894 /* then some other stuff */
3895 __put_user(mask, &sc->oldmask);
3896 __put_user(usp, &sc->usp);
3897 }
3898
3899 static inline unsigned long align_sigframe(unsigned long sp)
3900 {
3901 unsigned long i;
3902 i = sp & ~3UL;
3903 return i;
3904 }
3905
3906 static inline abi_ulong get_sigframe(struct target_sigaction *ka,
3907 CPUOpenRISCState *regs,
3908 size_t frame_size)
3909 {
3910 unsigned long sp = regs->gpr[1];
3911 int onsigstack = on_sig_stack(sp);
3912
3913 /* redzone */
3914 /* This is the X/Open sanctioned signal stack switching. */
3915 if ((ka->sa_flags & TARGET_SA_ONSTACK) != 0 && !onsigstack) {
3916 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3917 }
3918
3919 sp = align_sigframe(sp - frame_size);
3920
3921 /*
3922 * If we are on the alternate signal stack and would overflow it, don't.
3923 * Return an always-bogus address instead so we will die with SIGSEGV.
3924 */
3925
3926 if (onsigstack && !likely(on_sig_stack(sp))) {
3927 return -1L;
3928 }
3929
3930 return sp;
3931 }
3932
3933 static void setup_rt_frame(int sig, struct target_sigaction *ka,
3934 target_siginfo_t *info,
3935 target_sigset_t *set, CPUOpenRISCState *env)
3936 {
3937 int err = 0;
3938 abi_ulong frame_addr;
3939 unsigned long return_ip;
3940 struct target_rt_sigframe *frame;
3941 abi_ulong info_addr, uc_addr;
3942
3943 frame_addr = get_sigframe(ka, env, sizeof(*frame));
3944 trace_user_setup_rt_frame(env, frame_addr);
3945 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
3946 goto give_sigsegv;
3947 }
3948
3949 info_addr = frame_addr + offsetof(struct target_rt_sigframe, info);
3950 __put_user(info_addr, &frame->pinfo);
3951 uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc);
3952 __put_user(uc_addr, &frame->puc);
3953
3954 if (ka->sa_flags & SA_SIGINFO) {
3955 tswap_siginfo(&frame->info, info);
3956 }
3957
3958 /*err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));*/
3959 __put_user(0, &frame->uc.tuc_flags);
3960 __put_user(0, &frame->uc.tuc_link);
3961 __put_user(target_sigaltstack_used.ss_sp,
3962 &frame->uc.tuc_stack.ss_sp);
3963 __put_user(sas_ss_flags(env->gpr[1]), &frame->uc.tuc_stack.ss_flags);
3964 __put_user(target_sigaltstack_used.ss_size,
3965 &frame->uc.tuc_stack.ss_size);
3966 setup_sigcontext(&frame->sc, env, set->sig[0]);
3967
3968 /*err |= copy_to_user(frame->uc.tuc_sigmask, set, sizeof(*set));*/
3969
3970 /* trampoline - the desired return ip is the retcode itself */
3971 return_ip = (unsigned long)&frame->retcode;
3972 /* This is l.ori r11,r0,__NR_sigreturn, l.sys 1 */
3973 __put_user(0xa960, (short *)(frame->retcode + 0));
3974 __put_user(TARGET_NR_rt_sigreturn, (short *)(frame->retcode + 2));
3975 __put_user(0x20000001, (unsigned long *)(frame->retcode + 4));
3976 __put_user(0x15000000, (unsigned long *)(frame->retcode + 8));
3977
3978 if (err) {
3979 goto give_sigsegv;
3980 }
3981
3982 /* TODO what is the current->exec_domain stuff and invmap ? */
3983
3984 /* Set up registers for signal handler */
3985 env->pc = (unsigned long)ka->_sa_handler; /* what we enter NOW */
3986 env->gpr[9] = (unsigned long)return_ip; /* what we enter LATER */
3987 env->gpr[3] = (unsigned long)sig; /* arg 1: signo */
3988 env->gpr[4] = (unsigned long)&frame->info; /* arg 2: (siginfo_t*) */
3989 env->gpr[5] = (unsigned long)&frame->uc; /* arg 3: ucontext */
3990
3991 /* actually move the usp to reflect the stacked frame */
3992 env->gpr[1] = (unsigned long)frame;
3993
3994 return;
3995
3996 give_sigsegv:
3997 unlock_user_struct(frame, frame_addr, 1);
3998 if (sig == TARGET_SIGSEGV) {
3999 ka->_sa_handler = TARGET_SIG_DFL;
4000 }
4001 force_sig(TARGET_SIGSEGV);
4002 }
4003
4004 long do_sigreturn(CPUOpenRISCState *env)
4005 {
4006 trace_user_do_sigreturn(env, 0);
4007 fprintf(stderr, "do_sigreturn: not implemented\n");
4008 return -TARGET_ENOSYS;
4009 }
4010
4011 long do_rt_sigreturn(CPUOpenRISCState *env)
4012 {
4013 trace_user_do_rt_sigreturn(env, 0);
4014 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
4015 return -TARGET_ENOSYS;
4016 }
4017 /* TARGET_OPENRISC */
4018
4019 #elif defined(TARGET_S390X)
4020
4021 #define __NUM_GPRS 16
4022 #define __NUM_FPRS 16
4023 #define __NUM_ACRS 16
4024
4025 #define S390_SYSCALL_SIZE 2
4026 #define __SIGNAL_FRAMESIZE 160 /* FIXME: 31-bit mode -> 96 */
4027
4028 #define _SIGCONTEXT_NSIG 64
4029 #define _SIGCONTEXT_NSIG_BPW 64 /* FIXME: 31-bit mode -> 32 */
4030 #define _SIGCONTEXT_NSIG_WORDS (_SIGCONTEXT_NSIG / _SIGCONTEXT_NSIG_BPW)
4031 #define _SIGMASK_COPY_SIZE (sizeof(unsigned long)*_SIGCONTEXT_NSIG_WORDS)
4032 #define PSW_ADDR_AMODE 0x0000000000000000UL /* 0x80000000UL for 31-bit */
4033 #define S390_SYSCALL_OPCODE ((uint16_t)0x0a00)
4034
4035 typedef struct {
4036 target_psw_t psw;
4037 target_ulong gprs[__NUM_GPRS];
4038 unsigned int acrs[__NUM_ACRS];
4039 } target_s390_regs_common;
4040
4041 typedef struct {
4042 unsigned int fpc;
4043 double fprs[__NUM_FPRS];
4044 } target_s390_fp_regs;
4045
4046 typedef struct {
4047 target_s390_regs_common regs;
4048 target_s390_fp_regs fpregs;
4049 } target_sigregs;
4050
4051 struct target_sigcontext {
4052 target_ulong oldmask[_SIGCONTEXT_NSIG_WORDS];
4053 target_sigregs *sregs;
4054 };
4055
4056 typedef struct {
4057 uint8_t callee_used_stack[__SIGNAL_FRAMESIZE];
4058 struct target_sigcontext sc;
4059 target_sigregs sregs;
4060 int signo;
4061 uint8_t retcode[S390_SYSCALL_SIZE];
4062 } sigframe;
4063
4064 struct target_ucontext {
4065 target_ulong tuc_flags;
4066 struct target_ucontext *tuc_link;
4067 target_stack_t tuc_stack;
4068 target_sigregs tuc_mcontext;
4069 target_sigset_t tuc_sigmask; /* mask last for extensibility */
4070 };
4071
4072 typedef struct {
4073 uint8_t callee_used_stack[__SIGNAL_FRAMESIZE];
4074 uint8_t retcode[S390_SYSCALL_SIZE];
4075 struct target_siginfo info;
4076 struct target_ucontext uc;
4077 } rt_sigframe;
4078
4079 static inline abi_ulong
4080 get_sigframe(struct target_sigaction *ka, CPUS390XState *env, size_t frame_size)
4081 {
4082 abi_ulong sp;
4083
4084 /* Default to using normal stack */
4085 sp = env->regs[15];
4086
4087 /* This is the X/Open sanctioned signal stack switching. */
4088 if (ka->sa_flags & TARGET_SA_ONSTACK) {
4089 if (!sas_ss_flags(sp)) {
4090 sp = target_sigaltstack_used.ss_sp +
4091 target_sigaltstack_used.ss_size;
4092 }
4093 }
4094
4095 /* This is the legacy signal stack switching. */
4096 else if (/* FIXME !user_mode(regs) */ 0 &&
4097 !(ka->sa_flags & TARGET_SA_RESTORER) &&
4098 ka->sa_restorer) {
4099 sp = (abi_ulong) ka->sa_restorer;
4100 }
4101
4102 return (sp - frame_size) & -8ul;
4103 }
4104
4105 static void save_sigregs(CPUS390XState *env, target_sigregs *sregs)
4106 {
4107 int i;
4108 //save_access_regs(current->thread.acrs); FIXME
4109
4110 /* Copy a 'clean' PSW mask to the user to avoid leaking
4111 information about whether PER is currently on. */
4112 __put_user(env->psw.mask, &sregs->regs.psw.mask);
4113 __put_user(env->psw.addr, &sregs->regs.psw.addr);
4114 for (i = 0; i < 16; i++) {
4115 __put_user(env->regs[i], &sregs->regs.gprs[i]);
4116 }
4117 for (i = 0; i < 16; i++) {
4118 __put_user(env->aregs[i], &sregs->regs.acrs[i]);
4119 }
4120 /*
4121 * We have to store the fp registers to current->thread.fp_regs
4122 * to merge them with the emulated registers.
4123 */
4124 //save_fp_regs(&current->thread.fp_regs); FIXME
4125 for (i = 0; i < 16; i++) {
4126 __put_user(get_freg(env, i)->ll, &sregs->fpregs.fprs[i]);
4127 }
4128 }
4129
4130 static void setup_frame(int sig, struct target_sigaction *ka,
4131 target_sigset_t *set, CPUS390XState *env)
4132 {
4133 sigframe *frame;
4134 abi_ulong frame_addr;
4135
4136 frame_addr = get_sigframe(ka, env, sizeof(*frame));
4137 trace_user_setup_frame(env, frame_addr);
4138 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
4139 goto give_sigsegv;
4140 }
4141
4142 __put_user(set->sig[0], &frame->sc.oldmask[0]);
4143
4144 save_sigregs(env, &frame->sregs);
4145
4146 __put_user((abi_ulong)(unsigned long)&frame->sregs,
4147 (abi_ulong *)&frame->sc.sregs);
4148
4149 /* Set up to return from userspace. If provided, use a stub
4150 already in userspace. */
4151 if (ka->sa_flags & TARGET_SA_RESTORER) {
4152 env->regs[14] = (unsigned long)
4153 ka->sa_restorer | PSW_ADDR_AMODE;
4154 } else {
4155 env->regs[14] = (unsigned long)
4156 frame->retcode | PSW_ADDR_AMODE;
4157 __put_user(S390_SYSCALL_OPCODE | TARGET_NR_sigreturn,
4158 (uint16_t *)(frame->retcode));
4159 }
4160
4161 /* Set up backchain. */
4162 __put_user(env->regs[15], (abi_ulong *) frame);
4163
4164 /* Set up registers for signal handler */
4165 env->regs[15] = frame_addr;
4166 env->psw.addr = (target_ulong) ka->_sa_handler | PSW_ADDR_AMODE;
4167
4168 env->regs[2] = sig; //map_signal(sig);
4169 env->regs[3] = frame_addr += offsetof(typeof(*frame), sc);
4170
4171 /* We forgot to include these in the sigcontext.
4172 To avoid breaking binary compatibility, they are passed as args. */
4173 env->regs[4] = 0; // FIXME: no clue... current->thread.trap_no;
4174 env->regs[5] = 0; // FIXME: no clue... current->thread.prot_addr;
4175
4176 /* Place signal number on stack to allow backtrace from handler. */
4177 __put_user(env->regs[2], (int *) &frame->signo);
4178 unlock_user_struct(frame, frame_addr, 1);
4179 return;
4180
4181 give_sigsegv:
4182 force_sig(TARGET_SIGSEGV);
4183 }
4184
4185 static void setup_rt_frame(int sig, struct target_sigaction *ka,
4186 target_siginfo_t *info,
4187 target_sigset_t *set, CPUS390XState *env)
4188 {
4189 int i;
4190 rt_sigframe *frame;
4191 abi_ulong frame_addr;
4192
4193 frame_addr = get_sigframe(ka, env, sizeof *frame);
4194 trace_user_setup_rt_frame(env, frame_addr);
4195 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
4196 goto give_sigsegv;
4197 }
4198
4199 tswap_siginfo(&frame->info, info);
4200
4201 /* Create the ucontext. */
4202 __put_user(0, &frame->uc.tuc_flags);
4203 __put_user((abi_ulong)0, (abi_ulong *)&frame->uc.tuc_link);
4204 __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
4205 __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
4206 &frame->uc.tuc_stack.ss_flags);
4207 __put_user(target_sigaltstack_used.ss_size, &frame->uc.tuc_stack.ss_size);
4208 save_sigregs(env, &frame->uc.tuc_mcontext);
4209 for (i = 0; i < TARGET_NSIG_WORDS; i++) {
4210 __put_user((abi_ulong)set->sig[i],
4211 (abi_ulong *)&frame->uc.tuc_sigmask.sig[i]);
4212 }
4213
4214 /* Set up to return from userspace. If provided, use a stub
4215 already in userspace. */
4216 if (ka->sa_flags & TARGET_SA_RESTORER) {
4217 env->regs[14] = (unsigned long) ka->sa_restorer | PSW_ADDR_AMODE;
4218 } else {
4219 env->regs[14] = (unsigned long) frame->retcode | PSW_ADDR_AMODE;
4220 __put_user(S390_SYSCALL_OPCODE | TARGET_NR_rt_sigreturn,
4221 (uint16_t *)(frame->retcode));
4222 }
4223
4224 /* Set up backchain. */
4225 __put_user(env->regs[15], (abi_ulong *) frame);
4226
4227 /* Set up registers for signal handler */
4228 env->regs[15] = frame_addr;
4229 env->psw.addr = (target_ulong) ka->_sa_handler | PSW_ADDR_AMODE;
4230
4231 env->regs[2] = sig; //map_signal(sig);
4232 env->regs[3] = frame_addr + offsetof(typeof(*frame), info);
4233 env->regs[4] = frame_addr + offsetof(typeof(*frame), uc);
4234 return;
4235
4236 give_sigsegv:
4237 force_sig(TARGET_SIGSEGV);
4238 }
4239
4240 static int
4241 restore_sigregs(CPUS390XState *env, target_sigregs *sc)
4242 {
4243 int err = 0;
4244 int i;
4245
4246 for (i = 0; i < 16; i++) {
4247 __get_user(env->regs[i], &sc->regs.gprs[i]);
4248 }
4249
4250 __get_user(env->psw.mask, &sc->regs.psw.mask);
4251 trace_user_s390x_restore_sigregs(env, (unsigned long long)sc->regs.psw.addr,
4252 (unsigned long long)env->psw.addr);
4253 __get_user(env->psw.addr, &sc->regs.psw.addr);
4254 /* FIXME: 31-bit -> | PSW_ADDR_AMODE */
4255
4256 for (i = 0; i < 16; i++) {
4257 __get_user(env->aregs[i], &sc->regs.acrs[i]);
4258 }
4259 for (i = 0; i < 16; i++) {
4260 __get_user(get_freg(env, i)->ll, &sc->fpregs.fprs[i]);
4261 }
4262
4263 return err;
4264 }
4265
4266 long do_sigreturn(CPUS390XState *env)
4267 {
4268 sigframe *frame;
4269 abi_ulong frame_addr = env->regs[15];
4270 target_sigset_t target_set;
4271 sigset_t set;
4272
4273 trace_user_do_sigreturn(env, frame_addr);
4274 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
4275 goto badframe;
4276 }
4277 __get_user(target_set.sig[0], &frame->sc.oldmask[0]);
4278
4279 target_to_host_sigset_internal(&set, &target_set);
4280 do_sigprocmask(SIG_SETMASK, &set, NULL); /* ~_BLOCKABLE? */
4281
4282 if (restore_sigregs(env, &frame->sregs)) {
4283 goto badframe;
4284 }
4285
4286 unlock_user_struct(frame, frame_addr, 0);
4287 return env->regs[2];
4288
4289 badframe:
4290 force_sig(TARGET_SIGSEGV);
4291 return 0;
4292 }
4293
4294 long do_rt_sigreturn(CPUS390XState *env)
4295 {
4296 rt_sigframe *frame;
4297 abi_ulong frame_addr = env->regs[15];
4298 sigset_t set;
4299
4300 trace_user_do_rt_sigreturn(env, frame_addr);
4301 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
4302 goto badframe;
4303 }
4304 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
4305
4306 do_sigprocmask(SIG_SETMASK, &set, NULL); /* ~_BLOCKABLE? */
4307
4308 if (restore_sigregs(env, &frame->uc.tuc_mcontext)) {
4309 goto badframe;
4310 }
4311
4312 if (do_sigaltstack(frame_addr + offsetof(rt_sigframe, uc.tuc_stack), 0,
4313 get_sp_from_cpustate(env)) == -EFAULT) {
4314 goto badframe;
4315 }
4316 unlock_user_struct(frame, frame_addr, 0);
4317 return env->regs[2];
4318
4319 badframe:
4320 unlock_user_struct(frame, frame_addr, 0);
4321 force_sig(TARGET_SIGSEGV);
4322 return 0;
4323 }
4324
4325 #elif defined(TARGET_PPC)
4326
4327 /* Size of dummy stack frame allocated when calling signal handler.
4328 See arch/powerpc/include/asm/ptrace.h. */
4329 #if defined(TARGET_PPC64)
4330 #define SIGNAL_FRAMESIZE 128
4331 #else
4332 #define SIGNAL_FRAMESIZE 64
4333 #endif
4334
4335 /* See arch/powerpc/include/asm/ucontext.h. Only used for 32-bit PPC;
4336 on 64-bit PPC, sigcontext and mcontext are one and the same. */
4337 struct target_mcontext {
4338 target_ulong mc_gregs[48];
4339 /* Includes fpscr. */
4340 uint64_t mc_fregs[33];
4341 target_ulong mc_pad[2];
4342 /* We need to handle Altivec and SPE at the same time, which no
4343 kernel needs to do. Fortunately, the kernel defines this bit to
4344 be Altivec-register-large all the time, rather than trying to
4345 twiddle it based on the specific platform. */
4346 union {
4347 /* SPE vector registers. One extra for SPEFSCR. */
4348 uint32_t spe[33];
4349 /* Altivec vector registers. The packing of VSCR and VRSAVE
4350 varies depending on whether we're PPC64 or not: PPC64 splits
4351 them apart; PPC32 stuffs them together. */
4352 #if defined(TARGET_PPC64)
4353 #define QEMU_NVRREG 34
4354 #else
4355 #define QEMU_NVRREG 33
4356 #endif
4357 ppc_avr_t altivec[QEMU_NVRREG];
4358 #undef QEMU_NVRREG
4359 } mc_vregs __attribute__((__aligned__(16)));
4360 };
4361
4362 /* See arch/powerpc/include/asm/sigcontext.h. */
4363 struct target_sigcontext {
4364 target_ulong _unused[4];
4365 int32_t signal;
4366 #if defined(TARGET_PPC64)
4367 int32_t pad0;
4368 #endif
4369 target_ulong handler;
4370 target_ulong oldmask;
4371 target_ulong regs; /* struct pt_regs __user * */
4372 #if defined(TARGET_PPC64)
4373 struct target_mcontext mcontext;
4374 #endif
4375 };
4376
4377 /* Indices for target_mcontext.mc_gregs, below.
4378 See arch/powerpc/include/asm/ptrace.h for details. */
4379 enum {
4380 TARGET_PT_R0 = 0,
4381 TARGET_PT_R1 = 1,
4382 TARGET_PT_R2 = 2,
4383 TARGET_PT_R3 = 3,
4384 TARGET_PT_R4 = 4,
4385 TARGET_PT_R5 = 5,
4386 TARGET_PT_R6 = 6,
4387 TARGET_PT_R7 = 7,
4388 TARGET_PT_R8 = 8,
4389 TARGET_PT_R9 = 9,
4390 TARGET_PT_R10 = 10,
4391 TARGET_PT_R11 = 11,
4392 TARGET_PT_R12 = 12,
4393 TARGET_PT_R13 = 13,
4394 TARGET_PT_R14 = 14,
4395 TARGET_PT_R15 = 15,
4396 TARGET_PT_R16 = 16,
4397 TARGET_PT_R17 = 17,
4398 TARGET_PT_R18 = 18,
4399 TARGET_PT_R19 = 19,
4400 TARGET_PT_R20 = 20,
4401 TARGET_PT_R21 = 21,
4402 TARGET_PT_R22 = 22,
4403 TARGET_PT_R23 = 23,
4404 TARGET_PT_R24 = 24,
4405 TARGET_PT_R25 = 25,
4406 TARGET_PT_R26 = 26,
4407 TARGET_PT_R27 = 27,
4408 TARGET_PT_R28 = 28,
4409 TARGET_PT_R29 = 29,
4410 TARGET_PT_R30 = 30,
4411 TARGET_PT_R31 = 31,
4412 TARGET_PT_NIP = 32,
4413 TARGET_PT_MSR = 33,
4414 TARGET_PT_ORIG_R3 = 34,
4415 TARGET_PT_CTR = 35,
4416 TARGET_PT_LNK = 36,
4417 TARGET_PT_XER = 37,
4418 TARGET_PT_CCR = 38,
4419 /* Yes, there are two registers with #39. One is 64-bit only. */
4420 TARGET_PT_MQ = 39,
4421 TARGET_PT_SOFTE = 39,
4422 TARGET_PT_TRAP = 40,
4423 TARGET_PT_DAR = 41,
4424 TARGET_PT_DSISR = 42,
4425 TARGET_PT_RESULT = 43,
4426 TARGET_PT_REGS_COUNT = 44
4427 };
4428
4429
4430 struct target_ucontext {
4431 target_ulong tuc_flags;
4432 target_ulong tuc_link; /* struct ucontext __user * */
4433 struct target_sigaltstack tuc_stack;
4434 #if !defined(TARGET_PPC64)
4435 int32_t tuc_pad[7];
4436 target_ulong tuc_regs; /* struct mcontext __user *
4437 points to uc_mcontext field */
4438 #endif
4439 target_sigset_t tuc_sigmask;
4440 #if defined(TARGET_PPC64)
4441 target_sigset_t unused[15]; /* Allow for uc_sigmask growth */
4442 struct target_sigcontext tuc_sigcontext;
4443 #else
4444 int32_t tuc_maskext[30];
4445 int32_t tuc_pad2[3];
4446 struct target_mcontext tuc_mcontext;
4447 #endif
4448 };
4449
4450 /* See arch/powerpc/kernel/signal_32.c. */
4451 struct target_sigframe {
4452 struct target_sigcontext sctx;
4453 struct target_mcontext mctx;
4454 int32_t abigap[56];
4455 };
4456
4457 #if defined(TARGET_PPC64)
4458
4459 #define TARGET_TRAMP_SIZE 6
4460
4461 struct target_rt_sigframe {
4462 /* sys_rt_sigreturn requires the ucontext be the first field */
4463 struct target_ucontext uc;
4464 target_ulong _unused[2];
4465 uint32_t trampoline[TARGET_TRAMP_SIZE];
4466 target_ulong pinfo; /* struct siginfo __user * */
4467 target_ulong puc; /* void __user * */
4468 struct target_siginfo info;
4469 /* 64 bit ABI allows for 288 bytes below sp before decrementing it. */
4470 char abigap[288];
4471 } __attribute__((aligned(16)));
4472
4473 #else
4474
4475 struct target_rt_sigframe {
4476 struct target_siginfo info;
4477 struct target_ucontext uc;
4478 int32_t abigap[56];
4479 };
4480
4481 #endif
4482
4483 #if defined(TARGET_PPC64)
4484
4485 struct target_func_ptr {
4486 target_ulong entry;
4487 target_ulong toc;
4488 };
4489
4490 #endif
4491
4492 /* We use the mc_pad field for the signal return trampoline. */
4493 #define tramp mc_pad
4494
4495 /* See arch/powerpc/kernel/signal.c. */
4496 static target_ulong get_sigframe(struct target_sigaction *ka,
4497 CPUPPCState *env,
4498 int frame_size)
4499 {
4500 target_ulong oldsp, newsp;
4501
4502 oldsp = env->gpr[1];
4503
4504 if ((ka->sa_flags & TARGET_SA_ONSTACK) &&
4505 (sas_ss_flags(oldsp) == 0)) {
4506 oldsp = (target_sigaltstack_used.ss_sp
4507 + target_sigaltstack_used.ss_size);
4508 }
4509
4510 newsp = (oldsp - frame_size) & ~0xFUL;
4511
4512 return newsp;
4513 }
4514
4515 static void save_user_regs(CPUPPCState *env, struct target_mcontext *frame)
4516 {
4517 target_ulong msr = env->msr;
4518 int i;
4519 target_ulong ccr = 0;
4520
4521 /* In general, the kernel attempts to be intelligent about what it
4522 needs to save for Altivec/FP/SPE registers. We don't care that
4523 much, so we just go ahead and save everything. */
4524
4525 /* Save general registers. */
4526 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4527 __put_user(env->gpr[i], &frame->mc_gregs[i]);
4528 }
4529 __put_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP]);
4530 __put_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR]);
4531 __put_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK]);
4532 __put_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]);
4533
4534 for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
4535 ccr |= env->crf[i] << (32 - ((i + 1) * 4));
4536 }
4537 __put_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]);
4538
4539 /* Save Altivec registers if necessary. */
4540 if (env->insns_flags & PPC_ALTIVEC) {
4541 for (i = 0; i < ARRAY_SIZE(env->avr); i++) {
4542 ppc_avr_t *avr = &env->avr[i];
4543 ppc_avr_t *vreg = &frame->mc_vregs.altivec[i];
4544
4545 __put_user(avr->u64[0], &vreg->u64[0]);
4546 __put_user(avr->u64[1], &vreg->u64[1]);
4547 }
4548 /* Set MSR_VR in the saved MSR value to indicate that
4549 frame->mc_vregs contains valid data. */
4550 msr |= MSR_VR;
4551 __put_user((uint32_t)env->spr[SPR_VRSAVE],
4552 &frame->mc_vregs.altivec[32].u32[3]);
4553 }
4554
4555 /* Save floating point registers. */
4556 if (env->insns_flags & PPC_FLOAT) {
4557 for (i = 0; i < ARRAY_SIZE(env->fpr); i++) {
4558 __put_user(env->fpr[i], &frame->mc_fregs[i]);
4559 }
4560 __put_user((uint64_t) env->fpscr, &frame->mc_fregs[32]);
4561 }
4562
4563 /* Save SPE registers. The kernel only saves the high half. */
4564 if (env->insns_flags & PPC_SPE) {
4565 #if defined(TARGET_PPC64)
4566 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4567 __put_user(env->gpr[i] >> 32, &frame->mc_vregs.spe[i]);
4568 }
4569 #else
4570 for (i = 0; i < ARRAY_SIZE(env->gprh); i++) {
4571 __put_user(env->gprh[i], &frame->mc_vregs.spe[i]);
4572 }
4573 #endif
4574 /* Set MSR_SPE in the saved MSR value to indicate that
4575 frame->mc_vregs contains valid data. */
4576 msr |= MSR_SPE;
4577 __put_user(env->spe_fscr, &frame->mc_vregs.spe[32]);
4578 }
4579
4580 /* Store MSR. */
4581 __put_user(msr, &frame->mc_gregs[TARGET_PT_MSR]);
4582 }
4583
4584 static void encode_trampoline(int sigret, uint32_t *tramp)
4585 {
4586 /* Set up the sigreturn trampoline: li r0,sigret; sc. */
4587 if (sigret) {
4588 __put_user(0x38000000 | sigret, &tramp[0]);
4589 __put_user(0x44000002, &tramp[1]);
4590 }
4591 }
4592
4593 static void restore_user_regs(CPUPPCState *env,
4594 struct target_mcontext *frame, int sig)
4595 {
4596 target_ulong save_r2 = 0;
4597 target_ulong msr;
4598 target_ulong ccr;
4599
4600 int i;
4601
4602 if (!sig) {
4603 save_r2 = env->gpr[2];
4604 }
4605
4606 /* Restore general registers. */
4607 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4608 __get_user(env->gpr[i], &frame->mc_gregs[i]);
4609 }
4610 __get_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP]);
4611 __get_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR]);
4612 __get_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK]);
4613 __get_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]);
4614 __get_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]);
4615
4616 for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
4617 env->crf[i] = (ccr >> (32 - ((i + 1) * 4))) & 0xf;
4618 }
4619
4620 if (!sig) {
4621 env->gpr[2] = save_r2;
4622 }
4623 /* Restore MSR. */
4624 __get_user(msr, &frame->mc_gregs[TARGET_PT_MSR]);
4625
4626 /* If doing signal return, restore the previous little-endian mode. */
4627 if (sig)
4628 env->msr = (env->msr & ~MSR_LE) | (msr & MSR_LE);
4629
4630 /* Restore Altivec registers if necessary. */
4631 if (env->insns_flags & PPC_ALTIVEC) {
4632 for (i = 0; i < ARRAY_SIZE(env->avr); i++) {
4633 ppc_avr_t *avr = &env->avr[i];
4634 ppc_avr_t *vreg = &frame->mc_vregs.altivec[i];
4635
4636 __get_user(avr->u64[0], &vreg->u64[0]);
4637 __get_user(avr->u64[1], &vreg->u64[1]);
4638 }
4639 /* Set MSR_VEC in the saved MSR value to indicate that
4640 frame->mc_vregs contains valid data. */
4641 __get_user(env->spr[SPR_VRSAVE],
4642 (target_ulong *)(&frame->mc_vregs.altivec[32].u32[3]));
4643 }
4644
4645 /* Restore floating point registers. */
4646 if (env->insns_flags & PPC_FLOAT) {
4647 uint64_t fpscr;
4648 for (i = 0; i < ARRAY_SIZE(env->fpr); i++) {
4649 __get_user(env->fpr[i], &frame->mc_fregs[i]);
4650 }
4651 __get_user(fpscr, &frame->mc_fregs[32]);
4652 env->fpscr = (uint32_t) fpscr;
4653 }
4654
4655 /* Save SPE registers. The kernel only saves the high half. */
4656 if (env->insns_flags & PPC_SPE) {
4657 #if defined(TARGET_PPC64)
4658 for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
4659 uint32_t hi;
4660
4661 __get_user(hi, &frame->mc_vregs.spe[i]);
4662 env->gpr[i] = ((uint64_t)hi << 32) | ((uint32_t) env->gpr[i]);
4663 }
4664 #else
4665 for (i = 0; i < ARRAY_SIZE(env->gprh); i++) {
4666 __get_user(env->gprh[i], &frame->mc_vregs.spe[i]);
4667 }
4668 #endif
4669 __get_user(env->spe_fscr, &frame->mc_vregs.spe[32]);
4670 }
4671 }
4672
4673 static void setup_frame(int sig, struct target_sigaction *ka,
4674 target_sigset_t *set, CPUPPCState *env)
4675 {
4676 struct target_sigframe *frame;
4677 struct target_sigcontext *sc;
4678 target_ulong frame_addr, newsp;
4679 int err = 0;
4680 #if defined(TARGET_PPC64)
4681 struct image_info *image = ((TaskState *)thread_cpu->opaque)->info;
4682 #endif
4683
4684 frame_addr = get_sigframe(ka, env, sizeof(*frame));
4685 trace_user_setup_frame(env, frame_addr);
4686 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
4687 goto sigsegv;
4688 sc = &frame->sctx;
4689
4690 __put_user(ka->_sa_handler, &sc->handler);
4691 __put_user(set->sig[0], &sc->oldmask);
4692 #if TARGET_ABI_BITS == 64
4693 __put_user(set->sig[0] >> 32, &sc->_unused[3]);
4694 #else
4695 __put_user(set->sig[1], &sc->_unused[3]);
4696 #endif
4697 __put_user(h2g(&frame->mctx), &sc->regs);
4698 __put_user(sig, &sc->signal);
4699
4700 /* Save user regs. */
4701 save_user_regs(env, &frame->mctx);
4702
4703 /* Construct the trampoline code on the stack. */
4704 encode_trampoline(TARGET_NR_sigreturn, (uint32_t *)&frame->mctx.tramp);
4705
4706 /* The kernel checks for the presence of a VDSO here. We don't
4707 emulate a vdso, so use a sigreturn system call. */
4708 env->lr = (target_ulong) h2g(frame->mctx.tramp);
4709
4710 /* Turn off all fp exceptions. */
4711 env->fpscr = 0;
4712
4713 /* Create a stack frame for the caller of the handler. */
4714 newsp = frame_addr - SIGNAL_FRAMESIZE;
4715 err |= put_user(env->gpr[1], newsp, target_ulong);
4716
4717 if (err)
4718 goto sigsegv;
4719
4720 /* Set up registers for signal handler. */
4721 env->gpr[1] = newsp;
4722 env->gpr[3] = sig;
4723 env->gpr[4] = frame_addr + offsetof(struct target_sigframe, sctx);
4724
4725 #if defined(TARGET_PPC64)
4726 if (get_ppc64_abi(image) < 2) {
4727 /* ELFv1 PPC64 function pointers are pointers to OPD entries. */
4728 struct target_func_ptr *handler =
4729 (struct target_func_ptr *)g2h(ka->_sa_handler);
4730 env->nip = tswapl(handler->entry);
4731 env->gpr[2] = tswapl(handler->toc);
4732 } else {
4733 /* ELFv2 PPC64 function pointers are entry points, but R12
4734 * must also be set */
4735 env->nip = tswapl((target_ulong) ka->_sa_handler);
4736 env->gpr[12] = env->nip;
4737 }
4738 #else
4739 env->nip = (target_ulong) ka->_sa_handler;
4740 #endif
4741
4742 /* Signal handlers are entered in big-endian mode. */
4743 env->msr &= ~MSR_LE;
4744
4745 unlock_user_struct(frame, frame_addr, 1);
4746 return;
4747
4748 sigsegv:
4749 unlock_user_struct(frame, frame_addr, 1);
4750 force_sig(TARGET_SIGSEGV);
4751 }
4752
4753 static void setup_rt_frame(int sig, struct target_sigaction *ka,
4754 target_siginfo_t *info,
4755 target_sigset_t *set, CPUPPCState *env)
4756 {
4757 struct target_rt_sigframe *rt_sf;
4758 uint32_t *trampptr = 0;
4759 struct target_mcontext *mctx = 0;
4760 target_ulong rt_sf_addr, newsp = 0;
4761 int i, err = 0;
4762 #if defined(TARGET_PPC64)
4763 struct image_info *image = ((TaskState *)thread_cpu->opaque)->info;
4764 #endif
4765
4766 rt_sf_addr = get_sigframe(ka, env, sizeof(*rt_sf));
4767 if (!lock_user_struct(VERIFY_WRITE, rt_sf, rt_sf_addr, 1))
4768 goto sigsegv;
4769
4770 tswap_siginfo(&rt_sf->info, info);
4771
4772 __put_user(0, &rt_sf->uc.tuc_flags);
4773 __put_user(0, &rt_sf->uc.tuc_link);
4774 __put_user((target_ulong)target_sigaltstack_used.ss_sp,
4775 &rt_sf->uc.tuc_stack.ss_sp);
4776 __put_user(sas_ss_flags(env->gpr[1]),
4777 &rt_sf->uc.tuc_stack.ss_flags);
4778 __put_user(target_sigaltstack_used.ss_size,
4779 &rt_sf->uc.tuc_stack.ss_size);
4780 #if !defined(TARGET_PPC64)
4781 __put_user(h2g (&rt_sf->uc.tuc_mcontext),
4782 &rt_sf->uc.tuc_regs);
4783 #endif
4784 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
4785 __put_user(set->sig[i], &rt_sf->uc.tuc_sigmask.sig[i]);
4786 }
4787
4788 #if defined(TARGET_PPC64)
4789 mctx = &rt_sf->uc.tuc_sigcontext.mcontext;
4790 trampptr = &rt_sf->trampoline[0];
4791 #else
4792 mctx = &rt_sf->uc.tuc_mcontext;
4793 trampptr = (uint32_t *)&rt_sf->uc.tuc_mcontext.tramp;
4794 #endif
4795
4796 save_user_regs(env, mctx);
4797 encode_trampoline(TARGET_NR_rt_sigreturn, trampptr);
4798
4799 /* The kernel checks for the presence of a VDSO here. We don't
4800 emulate a vdso, so use a sigreturn system call. */
4801 env->lr = (target_ulong) h2g(trampptr);
4802
4803 /* Turn off all fp exceptions. */
4804 env->fpscr = 0;
4805
4806 /* Create a stack frame for the caller of the handler. */
4807 newsp = rt_sf_addr - (SIGNAL_FRAMESIZE + 16);
4808 err |= put_user(env->gpr[1], newsp, target_ulong);
4809
4810 if (err)
4811 goto sigsegv;
4812
4813 /* Set up registers for signal handler. */
4814 env->gpr[1] = newsp;
4815 env->gpr[3] = (target_ulong) sig;
4816 env->gpr[4] = (target_ulong) h2g(&rt_sf->info);
4817 env->gpr[5] = (target_ulong) h2g(&rt_sf->uc);
4818 env->gpr[6] = (target_ulong) h2g(rt_sf);
4819
4820 #if defined(TARGET_PPC64)
4821 if (get_ppc64_abi(image) < 2) {
4822 /* ELFv1 PPC64 function pointers are pointers to OPD entries. */
4823 struct target_func_ptr *handler =
4824 (struct target_func_ptr *)g2h(ka->_sa_handler);
4825 env->nip = tswapl(handler->entry);
4826 env->gpr[2] = tswapl(handler->toc);
4827 } else {
4828 /* ELFv2 PPC64 function pointers are entry points, but R12
4829 * must also be set */
4830 env->nip = tswapl((target_ulong) ka->_sa_handler);
4831 env->gpr[12] = env->nip;
4832 }
4833 #else
4834 env->nip = (target_ulong) ka->_sa_handler;
4835 #endif
4836
4837 /* Signal handlers are entered in big-endian mode. */
4838 env->msr &= ~MSR_LE;
4839
4840 unlock_user_struct(rt_sf, rt_sf_addr, 1);
4841 return;
4842
4843 sigsegv:
4844 unlock_user_struct(rt_sf, rt_sf_addr, 1);
4845 force_sig(TARGET_SIGSEGV);
4846
4847 }
4848
4849 long do_sigreturn(CPUPPCState *env)
4850 {
4851 struct target_sigcontext *sc = NULL;
4852 struct target_mcontext *sr = NULL;
4853 target_ulong sr_addr = 0, sc_addr;
4854 sigset_t blocked;
4855 target_sigset_t set;
4856
4857 sc_addr = env->gpr[1] + SIGNAL_FRAMESIZE;
4858 if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1))
4859 goto sigsegv;
4860
4861 #if defined(TARGET_PPC64)
4862 set.sig[0] = sc->oldmask + ((uint64_t)(sc->_unused[3]) << 32);
4863 #else
4864 __get_user(set.sig[0], &sc->oldmask);
4865 __get_user(set.sig[1], &sc->_unused[3]);
4866 #endif
4867 target_to_host_sigset_internal(&blocked, &set);
4868 do_sigprocmask(SIG_SETMASK, &blocked, NULL);
4869
4870 __get_user(sr_addr, &sc->regs);
4871 if (!lock_user_struct(VERIFY_READ, sr, sr_addr, 1))
4872 goto sigsegv;
4873 restore_user_regs(env, sr, 1);
4874
4875 unlock_user_struct(sr, sr_addr, 1);
4876 unlock_user_struct(sc, sc_addr, 1);
4877 return -TARGET_QEMU_ESIGRETURN;
4878
4879 sigsegv:
4880 unlock_user_struct(sr, sr_addr, 1);
4881 unlock_user_struct(sc, sc_addr, 1);
4882 force_sig(TARGET_SIGSEGV);
4883 return 0;
4884 }
4885
4886 /* See arch/powerpc/kernel/signal_32.c. */
4887 static int do_setcontext(struct target_ucontext *ucp, CPUPPCState *env, int sig)
4888 {
4889 struct target_mcontext *mcp;
4890 target_ulong mcp_addr;
4891 sigset_t blocked;
4892 target_sigset_t set;
4893
4894 if (copy_from_user(&set, h2g(ucp) + offsetof(struct target_ucontext, tuc_sigmask),
4895 sizeof (set)))
4896 return 1;
4897
4898 #if defined(TARGET_PPC64)
4899 mcp_addr = h2g(ucp) +
4900 offsetof(struct target_ucontext, tuc_sigcontext.mcontext);
4901 #else
4902 __get_user(mcp_addr, &ucp->tuc_regs);
4903 #endif
4904
4905 if (!lock_user_struct(VERIFY_READ, mcp, mcp_addr, 1))
4906 return 1;
4907
4908 target_to_host_sigset_internal(&blocked, &set);
4909 do_sigprocmask(SIG_SETMASK, &blocked, NULL);
4910 restore_user_regs(env, mcp, sig);
4911
4912 unlock_user_struct(mcp, mcp_addr, 1);
4913 return 0;
4914 }
4915
4916 long do_rt_sigreturn(CPUPPCState *env)
4917 {
4918 struct target_rt_sigframe *rt_sf = NULL;
4919 target_ulong rt_sf_addr;
4920
4921 rt_sf_addr = env->gpr[1] + SIGNAL_FRAMESIZE + 16;
4922 if (!lock_user_struct(VERIFY_READ, rt_sf, rt_sf_addr, 1))
4923 goto sigsegv;
4924
4925 if (do_setcontext(&rt_sf->uc, env, 1))
4926 goto sigsegv;
4927
4928 do_sigaltstack(rt_sf_addr
4929 + offsetof(struct target_rt_sigframe, uc.tuc_stack),
4930 0, env->gpr[1]);
4931
4932 unlock_user_struct(rt_sf, rt_sf_addr, 1);
4933 return -TARGET_QEMU_ESIGRETURN;
4934
4935 sigsegv:
4936 unlock_user_struct(rt_sf, rt_sf_addr, 1);
4937 force_sig(TARGET_SIGSEGV);
4938 return 0;
4939 }
4940
4941 #elif defined(TARGET_M68K)
4942
4943 struct target_sigcontext {
4944 abi_ulong sc_mask;
4945 abi_ulong sc_usp;
4946 abi_ulong sc_d0;
4947 abi_ulong sc_d1;
4948 abi_ulong sc_a0;
4949 abi_ulong sc_a1;
4950 unsigned short sc_sr;
4951 abi_ulong sc_pc;
4952 };
4953
4954 struct target_sigframe
4955 {
4956 abi_ulong pretcode;
4957 int sig;
4958 int code;
4959 abi_ulong psc;
4960 char retcode[8];
4961 abi_ulong extramask[TARGET_NSIG_WORDS-1];
4962 struct target_sigcontext sc;
4963 };
4964
4965 typedef int target_greg_t;
4966 #define TARGET_NGREG 18
4967 typedef target_greg_t target_gregset_t[TARGET_NGREG];
4968
4969 typedef struct target_fpregset {
4970 int f_fpcntl[3];
4971 int f_fpregs[8*3];
4972 } target_fpregset_t;
4973
4974 struct target_mcontext {
4975 int version;
4976 target_gregset_t gregs;
4977 target_fpregset_t fpregs;
4978 };
4979
4980 #define TARGET_MCONTEXT_VERSION 2
4981
4982 struct target_ucontext {
4983 abi_ulong tuc_flags;
4984 abi_ulong tuc_link;
4985 target_stack_t tuc_stack;
4986 struct target_mcontext tuc_mcontext;
4987 abi_long tuc_filler[80];
4988 target_sigset_t tuc_sigmask;
4989 };
4990
4991 struct target_rt_sigframe
4992 {
4993 abi_ulong pretcode;
4994 int sig;
4995 abi_ulong pinfo;
4996 abi_ulong puc;
4997 char retcode[8];
4998 struct target_siginfo info;
4999 struct target_ucontext uc;
5000 };
5001
5002 static void setup_sigcontext(struct target_sigcontext *sc, CPUM68KState *env,
5003 abi_ulong mask)
5004 {
5005 __put_user(mask, &sc->sc_mask);
5006 __put_user(env->aregs[7], &sc->sc_usp);
5007 __put_user(env->dregs[0], &sc->sc_d0);
5008 __put_user(env->dregs[1], &sc->sc_d1);
5009 __put_user(env->aregs[0], &sc->sc_a0);
5010 __put_user(env->aregs[1], &sc->sc_a1);
5011 __put_user(env->sr, &sc->sc_sr);
5012 __put_user(env->pc, &sc->sc_pc);
5013 }
5014
5015 static void
5016 restore_sigcontext(CPUM68KState *env, struct target_sigcontext *sc, int *pd0)
5017 {
5018 int temp;
5019
5020 __get_user(env->aregs[7], &sc->sc_usp);
5021 __get_user(env->dregs[1], &sc->sc_d1);
5022 __get_user(env->aregs[0], &sc->sc_a0);
5023 __get_user(env->aregs[1], &sc->sc_a1);
5024 __get_user(env->pc, &sc->sc_pc);
5025 __get_user(temp, &sc->sc_sr);
5026 env->sr = (env->sr & 0xff00) | (temp & 0xff);
5027
5028 *pd0 = tswapl(sc->sc_d0);
5029 }
5030
5031 /*
5032 * Determine which stack to use..
5033 */
5034 static inline abi_ulong
5035 get_sigframe(struct target_sigaction *ka, CPUM68KState *regs,
5036 size_t frame_size)
5037 {
5038 unsigned long sp;
5039
5040 sp = regs->aregs[7];
5041
5042 /* This is the X/Open sanctioned signal stack switching. */
5043 if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
5044 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
5045 }
5046
5047 return ((sp - frame_size) & -8UL);
5048 }
5049
5050 static void setup_frame(int sig, struct target_sigaction *ka,
5051 target_sigset_t *set, CPUM68KState *env)
5052 {
5053 struct target_sigframe *frame;
5054 abi_ulong frame_addr;
5055 abi_ulong retcode_addr;
5056 abi_ulong sc_addr;
5057 int i;
5058
5059 frame_addr = get_sigframe(ka, env, sizeof *frame);
5060 trace_user_setup_frame(env, frame_addr);
5061 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
5062 goto give_sigsegv;
5063 }
5064
5065 __put_user(sig, &frame->sig);
5066
5067 sc_addr = frame_addr + offsetof(struct target_sigframe, sc);
5068 __put_user(sc_addr, &frame->psc);
5069
5070 setup_sigcontext(&frame->sc, env, set->sig[0]);
5071
5072 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
5073 __put_user(set->sig[i], &frame->extramask[i - 1]);
5074 }
5075
5076 /* Set up to return from userspace. */
5077
5078 retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode);
5079 __put_user(retcode_addr, &frame->pretcode);
5080
5081 /* moveq #,d0; trap #0 */
5082
5083 __put_user(0x70004e40 + (TARGET_NR_sigreturn << 16),
5084 (uint32_t *)(frame->retcode));
5085
5086 /* Set up to return from userspace */
5087
5088 env->aregs[7] = frame_addr;
5089 env->pc = ka->_sa_handler;
5090
5091 unlock_user_struct(frame, frame_addr, 1);
5092 return;
5093
5094 give_sigsegv:
5095 force_sig(TARGET_SIGSEGV);
5096 }
5097
5098 static inline int target_rt_setup_ucontext(struct target_ucontext *uc,
5099 CPUM68KState *env)
5100 {
5101 target_greg_t *gregs = uc->tuc_mcontext.gregs;
5102
5103 __put_user(TARGET_MCONTEXT_VERSION, &uc->tuc_mcontext.version);
5104 __put_user(env->dregs[0], &gregs[0]);
5105 __put_user(env->dregs[1], &gregs[1]);
5106 __put_user(env->dregs[2], &gregs[2]);
5107 __put_user(env->dregs[3], &gregs[3]);
5108 __put_user(env->dregs[4], &gregs[4]);
5109 __put_user(env->dregs[5], &gregs[5]);
5110 __put_user(env->dregs[6], &gregs[6]);
5111 __put_user(env->dregs[7], &gregs[7]);
5112 __put_user(env->aregs[0], &gregs[8]);
5113 __put_user(env->aregs[1], &gregs[9]);
5114 __put_user(env->aregs[2], &gregs[10]);
5115 __put_user(env->aregs[3], &gregs[11]);
5116 __put_user(env->aregs[4], &gregs[12]);
5117 __put_user(env->aregs[5], &gregs[13]);
5118 __put_user(env->aregs[6], &gregs[14]);
5119 __put_user(env->aregs[7], &gregs[15]);
5120 __put_user(env->pc, &gregs[16]);
5121 __put_user(env->sr, &gregs[17]);
5122
5123 return 0;
5124 }
5125
5126 static inline int target_rt_restore_ucontext(CPUM68KState *env,
5127 struct target_ucontext *uc,
5128 int *pd0)
5129 {
5130 int temp;
5131 target_greg_t *gregs = uc->tuc_mcontext.gregs;
5132
5133 __get_user(temp, &uc->tuc_mcontext.version);
5134 if (temp != TARGET_MCONTEXT_VERSION)
5135 goto badframe;
5136
5137 /* restore passed registers */
5138 __get_user(env->dregs[0], &gregs[0]);
5139 __get_user(env->dregs[1], &gregs[1]);
5140 __get_user(env->dregs[2], &gregs[2]);
5141 __get_user(env->dregs[3], &gregs[3]);
5142 __get_user(env->dregs[4], &gregs[4]);
5143 __get_user(env->dregs[5], &gregs[5]);
5144 __get_user(env->dregs[6], &gregs[6]);
5145 __get_user(env->dregs[7], &gregs[7]);
5146 __get_user(env->aregs[0], &gregs[8]);
5147 __get_user(env->aregs[1], &gregs[9]);
5148 __get_user(env->aregs[2], &gregs[10]);
5149 __get_user(env->aregs[3], &gregs[11]);
5150 __get_user(env->aregs[4], &gregs[12]);
5151 __get_user(env->aregs[5], &gregs[13]);
5152 __get_user(env->aregs[6], &gregs[14]);
5153 __get_user(env->aregs[7], &gregs[15]);
5154 __get_user(env->pc, &gregs[16]);
5155 __get_user(temp, &gregs[17]);
5156 env->sr = (env->sr & 0xff00) | (temp & 0xff);
5157
5158 *pd0 = env->dregs[0];
5159 return 0;
5160
5161 badframe:
5162 return 1;
5163 }
5164
5165 static void setup_rt_frame(int sig, struct target_sigaction *ka,
5166 target_siginfo_t *info,
5167 target_sigset_t *set, CPUM68KState *env)
5168 {
5169 struct target_rt_sigframe *frame;
5170 abi_ulong frame_addr;
5171 abi_ulong retcode_addr;
5172 abi_ulong info_addr;
5173 abi_ulong uc_addr;
5174 int err = 0;
5175 int i;
5176
5177 frame_addr = get_sigframe(ka, env, sizeof *frame);
5178 trace_user_setup_rt_frame(env, frame_addr);
5179 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
5180 goto give_sigsegv;
5181 }
5182
5183 __put_user(sig, &frame->sig);
5184
5185 info_addr = frame_addr + offsetof(struct target_rt_sigframe, info);
5186 __put_user(info_addr, &frame->pinfo);
5187
5188 uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc);
5189 __put_user(uc_addr, &frame->puc);
5190
5191 tswap_siginfo(&frame->info, info);
5192
5193 /* Create the ucontext */
5194
5195 __put_user(0, &frame->uc.tuc_flags);
5196 __put_user(0, &frame->uc.tuc_link);
5197 __put_user(target_sigaltstack_used.ss_sp,
5198 &frame->uc.tuc_stack.ss_sp);
5199 __put_user(sas_ss_flags(env->aregs[7]),
5200 &frame->uc.tuc_stack.ss_flags);
5201 __put_user(target_sigaltstack_used.ss_size,
5202 &frame->uc.tuc_stack.ss_size);
5203 err |= target_rt_setup_ucontext(&frame->uc, env);
5204
5205 if (err)
5206 goto give_sigsegv;
5207
5208 for(i = 0; i < TARGET_NSIG_WORDS; i++) {
5209 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
5210 }
5211
5212 /* Set up to return from userspace. */
5213
5214 retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode);
5215 __put_user(retcode_addr, &frame->pretcode);
5216
5217 /* moveq #,d0; notb d0; trap #0 */
5218
5219 __put_user(0x70004600 + ((TARGET_NR_rt_sigreturn ^ 0xff) << 16),
5220 (uint32_t *)(frame->retcode + 0));
5221 __put_user(0x4e40, (uint16_t *)(frame->retcode + 4));
5222
5223 if (err)
5224 goto give_sigsegv;
5225
5226 /* Set up to return from userspace */
5227
5228 env->aregs[7] = frame_addr;
5229 env->pc = ka->_sa_handler;
5230
5231 unlock_user_struct(frame, frame_addr, 1);
5232 return;
5233
5234 give_sigsegv:
5235 unlock_user_struct(frame, frame_addr, 1);
5236 force_sig(TARGET_SIGSEGV);
5237 }
5238
5239 long do_sigreturn(CPUM68KState *env)
5240 {
5241 struct target_sigframe *frame;
5242 abi_ulong frame_addr = env->aregs[7] - 4;
5243 target_sigset_t target_set;
5244 sigset_t set;
5245 int d0, i;
5246
5247 trace_user_do_sigreturn(env, frame_addr);
5248 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
5249 goto badframe;
5250
5251 /* set blocked signals */
5252
5253 __get_user(target_set.sig[0], &frame->sc.sc_mask);
5254
5255 for(i = 1; i < TARGET_NSIG_WORDS; i++) {
5256 __get_user(target_set.sig[i], &frame->extramask[i - 1]);
5257 }
5258
5259 target_to_host_sigset_internal(&set, &target_set);
5260 do_sigprocmask(SIG_SETMASK, &set, NULL);
5261
5262 /* restore registers */
5263
5264 restore_sigcontext(env, &frame->sc, &d0);
5265
5266 unlock_user_struct(frame, frame_addr, 0);
5267 return d0;
5268
5269 badframe:
5270 force_sig(TARGET_SIGSEGV);
5271 return 0;
5272 }
5273
5274 long do_rt_sigreturn(CPUM68KState *env)
5275 {
5276 struct target_rt_sigframe *frame;
5277 abi_ulong frame_addr = env->aregs[7] - 4;
5278 target_sigset_t target_set;
5279 sigset_t set;
5280 int d0;
5281
5282 trace_user_do_rt_sigreturn(env, frame_addr);
5283 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
5284 goto badframe;
5285
5286 target_to_host_sigset_internal(&set, &target_set);
5287 do_sigprocmask(SIG_SETMASK, &set, NULL);
5288
5289 /* restore registers */
5290
5291 if (target_rt_restore_ucontext(env, &frame->uc, &d0))
5292 goto badframe;
5293
5294 if (do_sigaltstack(frame_addr +
5295 offsetof(struct target_rt_sigframe, uc.tuc_stack),
5296 0, get_sp_from_cpustate(env)) == -EFAULT)
5297 goto badframe;
5298
5299 unlock_user_struct(frame, frame_addr, 0);
5300 return d0;
5301
5302 badframe:
5303 unlock_user_struct(frame, frame_addr, 0);
5304 force_sig(TARGET_SIGSEGV);
5305 return 0;
5306 }
5307
5308 #elif defined(TARGET_ALPHA)
5309
5310 struct target_sigcontext {
5311 abi_long sc_onstack;
5312 abi_long sc_mask;
5313 abi_long sc_pc;
5314 abi_long sc_ps;
5315 abi_long sc_regs[32];
5316 abi_long sc_ownedfp;
5317 abi_long sc_fpregs[32];
5318 abi_ulong sc_fpcr;
5319 abi_ulong sc_fp_control;
5320 abi_ulong sc_reserved1;
5321 abi_ulong sc_reserved2;
5322 abi_ulong sc_ssize;
5323 abi_ulong sc_sbase;
5324 abi_ulong sc_traparg_a0;
5325 abi_ulong sc_traparg_a1;
5326 abi_ulong sc_traparg_a2;
5327 abi_ulong sc_fp_trap_pc;
5328 abi_ulong sc_fp_trigger_sum;
5329 abi_ulong sc_fp_trigger_inst;
5330 };
5331
5332 struct target_ucontext {
5333 abi_ulong tuc_flags;
5334 abi_ulong tuc_link;
5335 abi_ulong tuc_osf_sigmask;
5336 target_stack_t tuc_stack;
5337 struct target_sigcontext tuc_mcontext;
5338 target_sigset_t tuc_sigmask;
5339 };
5340
5341 struct target_sigframe {
5342 struct target_sigcontext sc;
5343 unsigned int retcode[3];
5344 };
5345
5346 struct target_rt_sigframe {
5347 target_siginfo_t info;
5348 struct target_ucontext uc;
5349 unsigned int retcode[3];
5350 };
5351
5352 #define INSN_MOV_R30_R16 0x47fe0410
5353 #define INSN_LDI_R0 0x201f0000
5354 #define INSN_CALLSYS 0x00000083
5355
5356 static void setup_sigcontext(struct target_sigcontext *sc, CPUAlphaState *env,
5357 abi_ulong frame_addr, target_sigset_t *set)
5358 {
5359 int i;
5360
5361 __put_user(on_sig_stack(frame_addr), &sc->sc_onstack);
5362 __put_user(set->sig[0], &sc->sc_mask);
5363 __put_user(env->pc, &sc->sc_pc);
5364 __put_user(8, &sc->sc_ps);
5365
5366 for (i = 0; i < 31; ++i) {
5367 __put_user(env->ir[i], &sc->sc_regs[i]);
5368 }
5369 __put_user(0, &sc->sc_regs[31]);
5370
5371 for (i = 0; i < 31; ++i) {
5372 __put_user(env->fir[i], &sc->sc_fpregs[i]);
5373 }
5374 __put_user(0, &sc->sc_fpregs[31]);
5375 __put_user(cpu_alpha_load_fpcr(env), &sc->sc_fpcr);
5376
5377 __put_user(0, &sc->sc_traparg_a0); /* FIXME */
5378 __put_user(0, &sc->sc_traparg_a1); /* FIXME */
5379 __put_user(0, &sc->sc_traparg_a2); /* FIXME */
5380 }
5381
5382 static void restore_sigcontext(CPUAlphaState *env,
5383 struct target_sigcontext *sc)
5384 {
5385 uint64_t fpcr;
5386 int i;
5387
5388 __get_user(env->pc, &sc->sc_pc);
5389
5390 for (i = 0; i < 31; ++i) {
5391 __get_user(env->ir[i], &sc->sc_regs[i]);
5392 }
5393 for (i = 0; i < 31; ++i) {
5394 __get_user(env->fir[i], &sc->sc_fpregs[i]);
5395 }
5396
5397 __get_user(fpcr, &sc->sc_fpcr);
5398 cpu_alpha_store_fpcr(env, fpcr);
5399 }
5400
5401 static inline abi_ulong get_sigframe(struct target_sigaction *sa,
5402 CPUAlphaState *env,
5403 unsigned long framesize)
5404 {
5405 abi_ulong sp = env->ir[IR_SP];
5406
5407 /* This is the X/Open sanctioned signal stack switching. */
5408 if ((sa->sa_flags & TARGET_SA_ONSTACK) != 0 && !sas_ss_flags(sp)) {
5409 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
5410 }
5411 return (sp - framesize) & -32;
5412 }
5413
5414 static void setup_frame(int sig, struct target_sigaction *ka,
5415 target_sigset_t *set, CPUAlphaState *env)
5416 {
5417 abi_ulong frame_addr, r26;
5418 struct target_sigframe *frame;
5419 int err = 0;
5420
5421 frame_addr = get_sigframe(ka, env, sizeof(*frame));
5422 trace_user_setup_frame(env, frame_addr);
5423 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
5424 goto give_sigsegv;
5425 }
5426
5427 setup_sigcontext(&frame->sc, env, frame_addr, set);
5428
5429 if (ka->sa_restorer) {
5430 r26 = ka->sa_restorer;
5431 } else {
5432 __put_user(INSN_MOV_R30_R16, &frame->retcode[0]);
5433 __put_user(INSN_LDI_R0 + TARGET_NR_sigreturn,
5434 &frame->retcode[1]);
5435 __put_user(INSN_CALLSYS, &frame->retcode[2]);
5436 /* imb() */
5437 r26 = frame_addr;
5438 }
5439
5440 unlock_user_struct(frame, frame_addr, 1);
5441
5442 if (err) {
5443 give_sigsegv:
5444 if (sig == TARGET_SIGSEGV) {
5445 ka->_sa_handler = TARGET_SIG_DFL;
5446 }
5447 force_sig(TARGET_SIGSEGV);
5448 }
5449
5450 env->ir[IR_RA] = r26;
5451 env->ir[IR_PV] = env->pc = ka->_sa_handler;
5452 env->ir[IR_A0] = sig;
5453 env->ir[IR_A1] = 0;
5454 env->ir[IR_A2] = frame_addr + offsetof(struct target_sigframe, sc);
5455 env->ir[IR_SP] = frame_addr;
5456 }
5457
5458 static void setup_rt_frame(int sig, struct target_sigaction *ka,
5459 target_siginfo_t *info,
5460 target_sigset_t *set, CPUAlphaState *env)
5461 {
5462 abi_ulong frame_addr, r26;
5463 struct target_rt_sigframe *frame;
5464 int i, err = 0;
5465
5466 frame_addr = get_sigframe(ka, env, sizeof(*frame));
5467 trace_user_setup_rt_frame(env, frame_addr);
5468 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
5469 goto give_sigsegv;
5470 }
5471
5472 tswap_siginfo(&frame->info, info);
5473
5474 __put_user(0, &frame->uc.tuc_flags);
5475 __put_user(0, &frame->uc.tuc_link);
5476 __put_user(set->sig[0], &frame->uc.tuc_osf_sigmask);
5477 __put_user(target_sigaltstack_used.ss_sp,
5478 &frame->uc.tuc_stack.ss_sp);
5479 __put_user(sas_ss_flags(env->ir[IR_SP]),
5480 &frame->uc.tuc_stack.ss_flags);
5481 __put_user(target_sigaltstack_used.ss_size,
5482 &frame->uc.tuc_stack.ss_size);
5483 setup_sigcontext(&frame->uc.tuc_mcontext, env, frame_addr, set);
5484 for (i = 0; i < TARGET_NSIG_WORDS; ++i) {
5485 __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
5486 }
5487
5488 if (ka->sa_restorer) {
5489 r26 = ka->sa_restorer;
5490 } else {
5491 __put_user(INSN_MOV_R30_R16, &frame->retcode[0]);
5492 __put_user(INSN_LDI_R0 + TARGET_NR_rt_sigreturn,
5493 &frame->retcode[1]);
5494 __put_user(INSN_CALLSYS, &frame->retcode[2]);
5495 /* imb(); */
5496 r26 = frame_addr;
5497 }
5498
5499 if (err) {
5500 give_sigsegv:
5501 if (sig == TARGET_SIGSEGV) {
5502 ka->_sa_handler = TARGET_SIG_DFL;
5503 }
5504 force_sig(TARGET_SIGSEGV);
5505 }
5506
5507 env->ir[IR_RA] = r26;
5508 env->ir[IR_PV] = env->pc = ka->_sa_handler;
5509 env->ir[IR_A0] = sig;
5510 env->ir[IR_A1] = frame_addr + offsetof(struct target_rt_sigframe, info);
5511 env->ir[IR_A2] = frame_addr + offsetof(struct target_rt_sigframe, uc);
5512 env->ir[IR_SP] = frame_addr;
5513 }
5514
5515 long do_sigreturn(CPUAlphaState *env)
5516 {
5517 struct target_sigcontext *sc;
5518 abi_ulong sc_addr = env->ir[IR_A0];
5519 target_sigset_t target_set;
5520 sigset_t set;
5521
5522 if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1)) {
5523 goto badframe;
5524 }
5525
5526 target_sigemptyset(&target_set);
5527 __get_user(target_set.sig[0], &sc->sc_mask);
5528
5529 target_to_host_sigset_internal(&set, &target_set);
5530 do_sigprocmask(SIG_SETMASK, &set, NULL);
5531
5532 restore_sigcontext(env, sc);
5533 unlock_user_struct(sc, sc_addr, 0);
5534 return env->ir[IR_V0];
5535
5536 badframe:
5537 force_sig(TARGET_SIGSEGV);
5538 }
5539
5540 long do_rt_sigreturn(CPUAlphaState *env)
5541 {
5542 abi_ulong frame_addr = env->ir[IR_A0];
5543 struct target_rt_sigframe *frame;
5544 sigset_t set;
5545
5546 trace_user_do_rt_sigreturn(env, frame_addr);
5547 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
5548 goto badframe;
5549 }
5550 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
5551 do_sigprocmask(SIG_SETMASK, &set, NULL);
5552
5553 restore_sigcontext(env, &frame->uc.tuc_mcontext);
5554 if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe,
5555 uc.tuc_stack),
5556 0, env->ir[IR_SP]) == -EFAULT) {
5557 goto badframe;
5558 }
5559
5560 unlock_user_struct(frame, frame_addr, 0);
5561 return env->ir[IR_V0];
5562
5563
5564 badframe:
5565 unlock_user_struct(frame, frame_addr, 0);
5566 force_sig(TARGET_SIGSEGV);
5567 }
5568
5569 #elif defined(TARGET_TILEGX)
5570
5571 struct target_sigcontext {
5572 union {
5573 /* General-purpose registers. */
5574 abi_ulong gregs[56];
5575 struct {
5576 abi_ulong __gregs[53];
5577 abi_ulong tp; /* Aliases gregs[TREG_TP]. */
5578 abi_ulong sp; /* Aliases gregs[TREG_SP]. */
5579 abi_ulong lr; /* Aliases gregs[TREG_LR]. */
5580 };
5581 };
5582 abi_ulong pc; /* Program counter. */
5583 abi_ulong ics; /* In Interrupt Critical Section? */
5584 abi_ulong faultnum; /* Fault number. */
5585 abi_ulong pad[5];
5586 };
5587
5588 struct target_ucontext {
5589 abi_ulong tuc_flags;
5590 abi_ulong tuc_link;
5591 target_stack_t tuc_stack;
5592 struct target_sigcontext tuc_mcontext;
5593 target_sigset_t tuc_sigmask; /* mask last for extensibility */
5594 };
5595
5596 struct target_rt_sigframe {
5597 unsigned char save_area[16]; /* caller save area */
5598 struct target_siginfo info;
5599 struct target_ucontext uc;
5600 };
5601
5602 static void setup_sigcontext(struct target_sigcontext *sc,
5603 CPUArchState *env, int signo)
5604 {
5605 int i;
5606
5607 for (i = 0; i < TILEGX_R_COUNT; ++i) {
5608 __put_user(env->regs[i], &sc->gregs[i]);
5609 }
5610
5611 __put_user(env->pc, &sc->pc);
5612 __put_user(0, &sc->ics);
5613 __put_user(signo, &sc->faultnum);
5614 }
5615
5616 static void restore_sigcontext(CPUTLGState *env, struct target_sigcontext *sc)
5617 {
5618 int i;
5619
5620 for (i = 0; i < TILEGX_R_COUNT; ++i) {
5621 __get_user(env->regs[i], &sc->gregs[i]);
5622 }
5623
5624 __get_user(env->pc, &sc->pc);
5625 }
5626
5627 static abi_ulong get_sigframe(struct target_sigaction *ka, CPUArchState *env,
5628 size_t frame_size)
5629 {
5630 unsigned long sp = env->regs[TILEGX_R_SP];
5631
5632 if (on_sig_stack(sp) && !likely(on_sig_stack(sp - frame_size))) {
5633 return -1UL;
5634 }
5635
5636 if ((ka->sa_flags & SA_ONSTACK) && !sas_ss_flags(sp)) {
5637 sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
5638 }
5639
5640 sp -= frame_size;
5641 sp &= -16UL;
5642 return sp;
5643 }
5644
5645 static void setup_rt_frame(int sig, struct target_sigaction *ka,
5646 target_siginfo_t *info,
5647 target_sigset_t *set, CPUArchState *env)
5648 {
5649 abi_ulong frame_addr;
5650 struct target_rt_sigframe *frame;
5651 unsigned long restorer;
5652
5653 frame_addr = get_sigframe(ka, env, sizeof(*frame));
5654 trace_user_setup_rt_frame(env, frame_addr);
5655 if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
5656 goto give_sigsegv;
5657 }
5658
5659 /* Always write at least the signal number for the stack backtracer. */
5660 if (ka->sa_flags & TARGET_SA_SIGINFO) {
5661 /* At sigreturn time, restore the callee-save registers too. */
5662 tswap_siginfo(&frame->info, info);
5663 /* regs->flags |= PT_FLAGS_RESTORE_REGS; FIXME: we can skip it? */
5664 } else {
5665 __put_user(info->si_signo, &frame->info.si_signo);
5666 }
5667
5668 /* Create the ucontext. */
5669 __put_user(0, &frame->uc.tuc_flags);
5670 __put_user(0, &frame->uc.tuc_link);
5671 __put_user(target_sigaltstack_used.ss_sp, &frame->uc.tuc_stack.ss_sp);
5672 __put_user(sas_ss_flags(env->regs[TILEGX_R_SP]),
5673 &frame->uc.tuc_stack.ss_flags);
5674 __put_user(target_sigaltstack_used.ss_size, &frame->uc.tuc_stack.ss_size);
5675 setup_sigcontext(&frame->uc.tuc_mcontext, env, info->si_signo);
5676
5677 restorer = (unsigned long) do_rt_sigreturn;
5678 if (ka->sa_flags & TARGET_SA_RESTORER) {
5679 restorer = (unsigned long) ka->sa_restorer;
5680 }
5681 env->pc = (unsigned long) ka->_sa_handler;
5682 env->regs[TILEGX_R_SP] = (unsigned long) frame;
5683 env->regs[TILEGX_R_LR] = restorer;
5684 env->regs[0] = (unsigned long) sig;
5685 env->regs[1] = (unsigned long) &frame->info;
5686 env->regs[2] = (unsigned long) &frame->uc;
5687 /* regs->flags |= PT_FLAGS_CALLER_SAVES; FIXME: we can skip it? */
5688
5689 unlock_user_struct(frame, frame_addr, 1);
5690 return;
5691
5692 give_sigsegv:
5693 if (sig == TARGET_SIGSEGV) {
5694 ka->_sa_handler = TARGET_SIG_DFL;
5695 }
5696 force_sig(TARGET_SIGSEGV /* , current */);
5697 }
5698
5699 long do_rt_sigreturn(CPUTLGState *env)
5700 {
5701 abi_ulong frame_addr = env->regs[TILEGX_R_SP];
5702 struct target_rt_sigframe *frame;
5703 sigset_t set;
5704
5705 trace_user_do_rt_sigreturn(env, frame_addr);
5706 if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
5707 goto badframe;
5708 }
5709 target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
5710 do_sigprocmask(SIG_SETMASK, &set, NULL);
5711
5712 restore_sigcontext(env, &frame->uc.tuc_mcontext);
5713 if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe,
5714 uc.tuc_stack),
5715 0, env->regs[TILEGX_R_SP]) == -EFAULT) {
5716 goto badframe;
5717 }
5718
5719 unlock_user_struct(frame, frame_addr, 0);
5720 return env->regs[TILEGX_R_RE];
5721
5722
5723 badframe:
5724 unlock_user_struct(frame, frame_addr, 0);
5725 force_sig(TARGET_SIGSEGV);
5726 }
5727
5728 #else
5729
5730 static void setup_frame(int sig, struct target_sigaction *ka,
5731 target_sigset_t *set, CPUArchState *env)
5732 {
5733 fprintf(stderr, "setup_frame: not implemented\n");
5734 }
5735
5736 static void setup_rt_frame(int sig, struct target_sigaction *ka,
5737 target_siginfo_t *info,
5738 target_sigset_t *set, CPUArchState *env)
5739 {
5740 fprintf(stderr, "setup_rt_frame: not implemented\n");
5741 }
5742
5743 long do_sigreturn(CPUArchState *env)
5744 {
5745 fprintf(stderr, "do_sigreturn: not implemented\n");
5746 return -TARGET_ENOSYS;
5747 }
5748
5749 long do_rt_sigreturn(CPUArchState *env)
5750 {
5751 fprintf(stderr, "do_rt_sigreturn: not implemented\n");
5752 return -TARGET_ENOSYS;
5753 }
5754
5755 #endif
5756
5757 void process_pending_signals(CPUArchState *cpu_env)
5758 {
5759 CPUState *cpu = ENV_GET_CPU(cpu_env);
5760 int sig;
5761 abi_ulong handler;
5762 sigset_t set, old_set;
5763 target_sigset_t target_old_set;
5764 struct emulated_sigtable *k;
5765 struct target_sigaction *sa;
5766 struct sigqueue *q;
5767 TaskState *ts = cpu->opaque;
5768
5769 if (!ts->signal_pending)
5770 return;
5771
5772 /* FIXME: This is not threadsafe. */
5773 k = ts->sigtab;
5774 for(sig = 1; sig <= TARGET_NSIG; sig++) {
5775 if (k->pending)
5776 goto handle_signal;
5777 k++;
5778 }
5779 /* if no signal is pending, just return */
5780 ts->signal_pending = 0;
5781 return;
5782
5783 handle_signal:
5784 trace_user_handle_signal(cpu_env, sig);
5785 /* dequeue signal */
5786 q = k->first;
5787 k->first = q->next;
5788 if (!k->first)
5789 k->pending = 0;
5790
5791 sig = gdb_handlesig(cpu, sig);
5792 if (!sig) {
5793 sa = NULL;
5794 handler = TARGET_SIG_IGN;
5795 } else {
5796 sa = &sigact_table[sig - 1];
5797 handler = sa->_sa_handler;
5798 }
5799
5800 if (ts->sigsegv_blocked && sig == TARGET_SIGSEGV) {
5801 /* Guest has blocked SIGSEGV but we got one anyway. Assume this
5802 * is a forced SIGSEGV (ie one the kernel handles via force_sig_info
5803 * because it got a real MMU fault), and treat as if default handler.
5804 */
5805 handler = TARGET_SIG_DFL;
5806 }
5807
5808 if (handler == TARGET_SIG_DFL) {
5809 /* default handler : ignore some signal. The other are job control or fatal */
5810 if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
5811 kill(getpid(),SIGSTOP);
5812 } else if (sig != TARGET_SIGCHLD &&
5813 sig != TARGET_SIGURG &&
5814 sig != TARGET_SIGWINCH &&
5815 sig != TARGET_SIGCONT) {
5816 force_sig(sig);
5817 }
5818 } else if (handler == TARGET_SIG_IGN) {
5819 /* ignore sig */
5820 } else if (handler == TARGET_SIG_ERR) {
5821 force_sig(sig);
5822 } else {
5823 /* compute the blocked signals during the handler execution */
5824 target_to_host_sigset(&set, &sa->sa_mask);
5825 /* SA_NODEFER indicates that the current signal should not be
5826 blocked during the handler */
5827 if (!(sa->sa_flags & TARGET_SA_NODEFER))
5828 sigaddset(&set, target_to_host_signal(sig));
5829
5830 /* block signals in the handler using Linux */
5831 do_sigprocmask(SIG_BLOCK, &set, &old_set);
5832 /* save the previous blocked signal state to restore it at the
5833 end of the signal execution (see do_sigreturn) */
5834 host_to_target_sigset_internal(&target_old_set, &old_set);
5835
5836 /* if the CPU is in VM86 mode, we restore the 32 bit values */
5837 #if defined(TARGET_I386) && !defined(TARGET_X86_64)
5838 {
5839 CPUX86State *env = cpu_env;
5840 if (env->eflags & VM_MASK)
5841 save_v86_state(env);
5842 }
5843 #endif
5844 /* prepare the stack frame of the virtual CPU */
5845 #if defined(TARGET_ABI_MIPSN32) || defined(TARGET_ABI_MIPSN64) \
5846 || defined(TARGET_OPENRISC) || defined(TARGET_TILEGX)
5847 /* These targets do not have traditional signals. */
5848 setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env);
5849 #else
5850 if (sa->sa_flags & TARGET_SA_SIGINFO)
5851 setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env);
5852 else
5853 setup_frame(sig, sa, &target_old_set, cpu_env);
5854 #endif
5855 if (sa->sa_flags & TARGET_SA_RESETHAND)
5856 sa->_sa_handler = TARGET_SIG_DFL;
5857 }
5858 if (q != &k->info)
5859 free_sigqueue(cpu_env, q);
5860 }
QEmu