]> git.proxmox.com Git - qemu.git/blob - linux-user/signal.c
projects / qemu.git / blob
? search:


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