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