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