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