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