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