Statistics
| Branch: | Revision:

root / linux-user / signal.c @ 5a834bb4

History | View | Annotate | Download (139.6 kB)

1
/*
2
 *  Emulation of Linux signals
3
 *
4
 *  Copyright (c) 2003 Fabrice Bellard
5
 *
6
 *  This program is free software; you can redistribute it and/or modify
7
 *  it under the terms of the GNU General Public License as published by
8
 *  the Free Software Foundation; either version 2 of the License, or
9
 *  (at your option) any later version.
10
 *
11
 *  This program is distributed in the hope that it will be useful,
12
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 *  GNU General Public License for more details.
15
 *
16
 *  You should have received a copy of the GNU General Public License
17
 *  along with this program; if not, see <http://www.gnu.org/licenses/>.
18
 */
19
#include <stdlib.h>
20
#include <stdio.h>
21
#include <string.h>
22
#include <stdarg.h>
23
#include <unistd.h>
24
#include <signal.h>
25
#include <errno.h>
26
#include <assert.h>
27
#include <sys/ucontext.h>
28
#include <sys/resource.h>
29

    
30
#include "qemu.h"
31
#include "qemu-common.h"
32
#include "target_signal.h"
33

    
34
//#define DEBUG_SIGNAL
35

    
36
static struct target_sigaltstack target_sigaltstack_used = {
37
    .ss_sp = 0,
38
    .ss_size = 0,
39
    .ss_flags = TARGET_SS_DISABLE,
40
};
41

    
42
static struct target_sigaction sigact_table[TARGET_NSIG];
43

    
44
static void host_signal_handler(int host_signum, siginfo_t *info,
45
                                void *puc);
46

    
47
static uint8_t host_to_target_signal_table[_NSIG] = {
48
    [SIGHUP] = TARGET_SIGHUP,
49
    [SIGINT] = TARGET_SIGINT,
50
    [SIGQUIT] = TARGET_SIGQUIT,
51
    [SIGILL] = TARGET_SIGILL,
52
    [SIGTRAP] = TARGET_SIGTRAP,
53
    [SIGABRT] = TARGET_SIGABRT,
54
/*    [SIGIOT] = TARGET_SIGIOT,*/
55
    [SIGBUS] = TARGET_SIGBUS,
56
    [SIGFPE] = TARGET_SIGFPE,
57
    [SIGKILL] = TARGET_SIGKILL,
58
    [SIGUSR1] = TARGET_SIGUSR1,
59
    [SIGSEGV] = TARGET_SIGSEGV,
60
    [SIGUSR2] = TARGET_SIGUSR2,
61
    [SIGPIPE] = TARGET_SIGPIPE,
62
    [SIGALRM] = TARGET_SIGALRM,
63
    [SIGTERM] = TARGET_SIGTERM,
64
#ifdef SIGSTKFLT
65
    [SIGSTKFLT] = TARGET_SIGSTKFLT,
66
#endif
67
    [SIGCHLD] = TARGET_SIGCHLD,
68
    [SIGCONT] = TARGET_SIGCONT,
69
    [SIGSTOP] = TARGET_SIGSTOP,
70
    [SIGTSTP] = TARGET_SIGTSTP,
71
    [SIGTTIN] = TARGET_SIGTTIN,
72
    [SIGTTOU] = TARGET_SIGTTOU,
73
    [SIGURG] = TARGET_SIGURG,
74
    [SIGXCPU] = TARGET_SIGXCPU,
75
    [SIGXFSZ] = TARGET_SIGXFSZ,
76
    [SIGVTALRM] = TARGET_SIGVTALRM,
77
    [SIGPROF] = TARGET_SIGPROF,
78
    [SIGWINCH] = TARGET_SIGWINCH,
79
    [SIGIO] = TARGET_SIGIO,
80
    [SIGPWR] = TARGET_SIGPWR,
81
    [SIGSYS] = TARGET_SIGSYS,
82
    /* next signals stay the same */
83
    /* Nasty hack: Reverse SIGRTMIN and SIGRTMAX to avoid overlap with
84
       host libpthread signals.  This assumes noone actually uses SIGRTMAX :-/
85
       To fix this properly we need to do manual signal delivery multiplexed
86
       over a single host signal.  */
87
    [__SIGRTMIN] = __SIGRTMAX,
88
    [__SIGRTMAX] = __SIGRTMIN,
89
};
90
static uint8_t target_to_host_signal_table[_NSIG];
91

    
92
static inline int on_sig_stack(unsigned long sp)
93
{
94
    return (sp - target_sigaltstack_used.ss_sp
95
            < target_sigaltstack_used.ss_size);
96
}
97

    
98
static inline int sas_ss_flags(unsigned long sp)
99
{
100
    return (target_sigaltstack_used.ss_size == 0 ? SS_DISABLE
101
            : on_sig_stack(sp) ? SS_ONSTACK : 0);
102
}
103

    
104
int host_to_target_signal(int sig)
105
{
106
    if (sig >= _NSIG)
107
        return sig;
108
    return host_to_target_signal_table[sig];
109
}
110

    
111
int target_to_host_signal(int sig)
112
{
113
    if (sig >= _NSIG)
114
        return sig;
115
    return target_to_host_signal_table[sig];
116
}
117

    
118
static inline void target_sigemptyset(target_sigset_t *set)
119
{
120
    memset(set, 0, sizeof(*set));
121
}
122

    
123
static inline void target_sigaddset(target_sigset_t *set, int signum)
124
{
125
    signum--;
126
    abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
127
    set->sig[signum / TARGET_NSIG_BPW] |= mask;
128
}
129

    
130
static inline int target_sigismember(const target_sigset_t *set, int signum)
131
{
132
    signum--;
133
    abi_ulong mask = (abi_ulong)1 << (signum % TARGET_NSIG_BPW);
134
    return ((set->sig[signum / TARGET_NSIG_BPW] & mask) != 0);
135
}
136

    
137
static void host_to_target_sigset_internal(target_sigset_t *d,
138
                                           const sigset_t *s)
139
{
140
    int i;
141
    target_sigemptyset(d);
142
    for (i = 1; i <= TARGET_NSIG; i++) {
143
        if (sigismember(s, i)) {
144
            target_sigaddset(d, host_to_target_signal(i));
145
        }
146
    }
147
}
148

    
149
void host_to_target_sigset(target_sigset_t *d, const sigset_t *s)
150
{
151
    target_sigset_t d1;
152
    int i;
153

    
154
    host_to_target_sigset_internal(&d1, s);
155
    for(i = 0;i < TARGET_NSIG_WORDS; i++)
156
        d->sig[i] = tswapl(d1.sig[i]);
157
}
158

    
159
static void target_to_host_sigset_internal(sigset_t *d,
160
                                           const target_sigset_t *s)
161
{
162
    int i;
163
    sigemptyset(d);
164
    for (i = 1; i <= TARGET_NSIG; i++) {
165
        if (target_sigismember(s, i)) {
166
            sigaddset(d, target_to_host_signal(i));
167
        }
168
     }
169
}
170

    
171
void target_to_host_sigset(sigset_t *d, const target_sigset_t *s)
172
{
173
    target_sigset_t s1;
174
    int i;
175

    
176
    for(i = 0;i < TARGET_NSIG_WORDS; i++)
177
        s1.sig[i] = tswapl(s->sig[i]);
178
    target_to_host_sigset_internal(d, &s1);
179
}
180

    
181
void host_to_target_old_sigset(abi_ulong *old_sigset,
182
                               const sigset_t *sigset)
183
{
184
    target_sigset_t d;
185
    host_to_target_sigset(&d, sigset);
186
    *old_sigset = d.sig[0];
187
}
188

    
189
void target_to_host_old_sigset(sigset_t *sigset,
190
                               const abi_ulong *old_sigset)
191
{
192
    target_sigset_t d;
193
    int i;
194

    
195
    d.sig[0] = *old_sigset;
196
    for(i = 1;i < TARGET_NSIG_WORDS; i++)
197
        d.sig[i] = 0;
198
    target_to_host_sigset(sigset, &d);
199
}
200

    
201
/* siginfo conversion */
202

    
203
static inline void host_to_target_siginfo_noswap(target_siginfo_t *tinfo,
204
                                                 const siginfo_t *info)
205
{
206
    int sig;
207
    sig = host_to_target_signal(info->si_signo);
208
    tinfo->si_signo = sig;
209
    tinfo->si_errno = 0;
210
    tinfo->si_code = info->si_code;
211
    if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
212
        sig == SIGBUS || sig == SIGTRAP) {
213
        /* should never come here, but who knows. The information for
214
           the target is irrelevant */
215
        tinfo->_sifields._sigfault._addr = 0;
216
    } else if (sig == SIGIO) {
217
        tinfo->_sifields._sigpoll._fd = info->si_fd;
218
    } else if (sig >= TARGET_SIGRTMIN) {
219
        tinfo->_sifields._rt._pid = info->si_pid;
220
        tinfo->_sifields._rt._uid = info->si_uid;
221
        /* XXX: potential problem if 64 bit */
222
        tinfo->_sifields._rt._sigval.sival_ptr =
223
            (abi_ulong)(unsigned long)info->si_value.sival_ptr;
224
    }
225
}
226

    
227
static void tswap_siginfo(target_siginfo_t *tinfo,
228
                          const target_siginfo_t *info)
229
{
230
    int sig;
231
    sig = info->si_signo;
232
    tinfo->si_signo = tswap32(sig);
233
    tinfo->si_errno = tswap32(info->si_errno);
234
    tinfo->si_code = tswap32(info->si_code);
235
    if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV ||
236
        sig == SIGBUS || sig == SIGTRAP) {
237
        tinfo->_sifields._sigfault._addr =
238
            tswapl(info->_sifields._sigfault._addr);
239
    } else if (sig == SIGIO) {
240
        tinfo->_sifields._sigpoll._fd = tswap32(info->_sifields._sigpoll._fd);
241
    } else if (sig >= TARGET_SIGRTMIN) {
242
        tinfo->_sifields._rt._pid = tswap32(info->_sifields._rt._pid);
243
        tinfo->_sifields._rt._uid = tswap32(info->_sifields._rt._uid);
244
        tinfo->_sifields._rt._sigval.sival_ptr =
245
            tswapl(info->_sifields._rt._sigval.sival_ptr);
246
    }
247
}
248

    
249

    
250
void host_to_target_siginfo(target_siginfo_t *tinfo, const siginfo_t *info)
251
{
252
    host_to_target_siginfo_noswap(tinfo, info);
253
    tswap_siginfo(tinfo, tinfo);
254
}
255

    
256
/* XXX: we support only POSIX RT signals are used. */
257
/* XXX: find a solution for 64 bit (additional malloced data is needed) */
258
void target_to_host_siginfo(siginfo_t *info, const target_siginfo_t *tinfo)
259
{
260
    info->si_signo = tswap32(tinfo->si_signo);
261
    info->si_errno = tswap32(tinfo->si_errno);
262
    info->si_code = tswap32(tinfo->si_code);
263
    info->si_pid = tswap32(tinfo->_sifields._rt._pid);
264
    info->si_uid = tswap32(tinfo->_sifields._rt._uid);
265
    info->si_value.sival_ptr =
266
            (void *)(long)tswapl(tinfo->_sifields._rt._sigval.sival_ptr);
267
}
268

    
269
static int fatal_signal (int sig)
270
{
271
    switch (sig) {
272
    case TARGET_SIGCHLD:
273
    case TARGET_SIGURG:
274
    case TARGET_SIGWINCH:
275
        /* Ignored by default.  */
276
        return 0;
277
    case TARGET_SIGCONT:
278
    case TARGET_SIGSTOP:
279
    case TARGET_SIGTSTP:
280
    case TARGET_SIGTTIN:
281
    case TARGET_SIGTTOU:
282
        /* Job control signals.  */
283
        return 0;
284
    default:
285
        return 1;
286
    }
287
}
288

    
289
/* returns 1 if given signal should dump core if not handled */
290
static int core_dump_signal(int sig)
291
{
292
    switch (sig) {
293
    case TARGET_SIGABRT:
294
    case TARGET_SIGFPE:
295
    case TARGET_SIGILL:
296
    case TARGET_SIGQUIT:
297
    case TARGET_SIGSEGV:
298
    case TARGET_SIGTRAP:
299
    case TARGET_SIGBUS:
300
        return (1);
301
    default:
302
        return (0);
303
    }
304
}
305

    
306
void signal_init(void)
307
{
308
    struct sigaction act;
309
    struct sigaction oact;
310
    int i, j;
311
    int host_sig;
312

    
313
    /* generate signal conversion tables */
314
    for(i = 1; i < _NSIG; i++) {
315
        if (host_to_target_signal_table[i] == 0)
316
            host_to_target_signal_table[i] = i;
317
    }
318
    for(i = 1; i < _NSIG; i++) {
319
        j = host_to_target_signal_table[i];
320
        target_to_host_signal_table[j] = i;
321
    }
322

    
323
    /* set all host signal handlers. ALL signals are blocked during
324
       the handlers to serialize them. */
325
    memset(sigact_table, 0, sizeof(sigact_table));
326

    
327
    sigfillset(&act.sa_mask);
328
    act.sa_flags = SA_SIGINFO;
329
    act.sa_sigaction = host_signal_handler;
330
    for(i = 1; i <= TARGET_NSIG; i++) {
331
        host_sig = target_to_host_signal(i);
332
        sigaction(host_sig, NULL, &oact);
333
        if (oact.sa_sigaction == (void *)SIG_IGN) {
334
            sigact_table[i - 1]._sa_handler = TARGET_SIG_IGN;
335
        } else if (oact.sa_sigaction == (void *)SIG_DFL) {
336
            sigact_table[i - 1]._sa_handler = TARGET_SIG_DFL;
337
        }
338
        /* If there's already a handler installed then something has
339
           gone horribly wrong, so don't even try to handle that case.  */
340
        /* Install some handlers for our own use.  We need at least
341
           SIGSEGV and SIGBUS, to detect exceptions.  We can not just
342
           trap all signals because it affects syscall interrupt
343
           behavior.  But do trap all default-fatal signals.  */
344
        if (fatal_signal (i))
345
            sigaction(host_sig, &act, NULL);
346
    }
347
}
348

    
349
/* signal queue handling */
350

    
351
static inline struct sigqueue *alloc_sigqueue(CPUState *env)
352
{
353
    TaskState *ts = env->opaque;
354
    struct sigqueue *q = ts->first_free;
355
    if (!q)
356
        return NULL;
357
    ts->first_free = q->next;
358
    return q;
359
}
360

    
361
static inline void free_sigqueue(CPUState *env, struct sigqueue *q)
362
{
363
    TaskState *ts = env->opaque;
364
    q->next = ts->first_free;
365
    ts->first_free = q;
366
}
367

    
368
/* abort execution with signal */
369
static void QEMU_NORETURN force_sig(int target_sig)
370
{
371
    TaskState *ts = (TaskState *)thread_env->opaque;
372
    int host_sig, core_dumped = 0;
373
    struct sigaction act;
374
    host_sig = target_to_host_signal(target_sig);
375
    gdb_signalled(thread_env, target_sig);
376

    
377
    /* dump core if supported by target binary format */
378
    if (core_dump_signal(target_sig) && (ts->bprm->core_dump != NULL)) {
379
        stop_all_tasks();
380
        core_dumped =
381
            ((*ts->bprm->core_dump)(target_sig, thread_env) == 0);
382
    }
383
    if (core_dumped) {
384
        /* we already dumped the core of target process, we don't want
385
         * a coredump of qemu itself */
386
        struct rlimit nodump;
387
        getrlimit(RLIMIT_CORE, &nodump);
388
        nodump.rlim_cur=0;
389
        setrlimit(RLIMIT_CORE, &nodump);
390
        (void) fprintf(stderr, "qemu: uncaught target signal %d (%s) - %s\n",
391
            target_sig, strsignal(host_sig), "core dumped" );
392
    }
393

    
394
    /* The proper exit code for dieing from an uncaught signal is
395
     * -<signal>.  The kernel doesn't allow exit() or _exit() to pass
396
     * a negative value.  To get the proper exit code we need to
397
     * actually die from an uncaught signal.  Here the default signal
398
     * handler is installed, we send ourself a signal and we wait for
399
     * it to arrive. */
400
    sigfillset(&act.sa_mask);
401
    act.sa_handler = SIG_DFL;
402
    sigaction(host_sig, &act, NULL);
403

    
404
    /* For some reason raise(host_sig) doesn't send the signal when
405
     * statically linked on x86-64. */
406
    kill(getpid(), host_sig);
407

    
408
    /* Make sure the signal isn't masked (just reuse the mask inside
409
    of act) */
410
    sigdelset(&act.sa_mask, host_sig);
411
    sigsuspend(&act.sa_mask);
412

    
413
    /* unreachable */
414
    abort();
415
}
416

    
417
/* queue a signal so that it will be send to the virtual CPU as soon
418
   as possible */
419
int queue_signal(CPUState *env, int sig, target_siginfo_t *info)
420
{
421
    TaskState *ts = env->opaque;
422
    struct emulated_sigtable *k;
423
    struct sigqueue *q, **pq;
424
    abi_ulong handler;
425
    int queue;
426

    
427
#if defined(DEBUG_SIGNAL)
428
    fprintf(stderr, "queue_signal: sig=%d\n",
429
            sig);
430
#endif
431
    k = &ts->sigtab[sig - 1];
432
    queue = gdb_queuesig ();
433
    handler = sigact_table[sig - 1]._sa_handler;
434
    if (!queue && handler == TARGET_SIG_DFL) {
435
        if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
436
            kill(getpid(),SIGSTOP);
437
            return 0;
438
        } else
439
        /* default handler : ignore some signal. The other are fatal */
440
        if (sig != TARGET_SIGCHLD &&
441
            sig != TARGET_SIGURG &&
442
            sig != TARGET_SIGWINCH &&
443
            sig != TARGET_SIGCONT) {
444
            force_sig(sig);
445
        } else {
446
            return 0; /* indicate ignored */
447
        }
448
    } else if (!queue && handler == TARGET_SIG_IGN) {
449
        /* ignore signal */
450
        return 0;
451
    } else if (!queue && handler == TARGET_SIG_ERR) {
452
        force_sig(sig);
453
    } else {
454
        pq = &k->first;
455
        if (sig < TARGET_SIGRTMIN) {
456
            /* if non real time signal, we queue exactly one signal */
457
            if (!k->pending)
458
                q = &k->info;
459
            else
460
                return 0;
461
        } else {
462
            if (!k->pending) {
463
                /* first signal */
464
                q = &k->info;
465
            } else {
466
                q = alloc_sigqueue(env);
467
                if (!q)
468
                    return -EAGAIN;
469
                while (*pq != NULL)
470
                    pq = &(*pq)->next;
471
            }
472
        }
473
        *pq = q;
474
        q->info = *info;
475
        q->next = NULL;
476
        k->pending = 1;
477
        /* signal that a new signal is pending */
478
        ts->signal_pending = 1;
479
        return 1; /* indicates that the signal was queued */
480
    }
481
}
482

    
483
static void host_signal_handler(int host_signum, siginfo_t *info,
484
                                void *puc)
485
{
486
    int sig;
487
    target_siginfo_t tinfo;
488

    
489
    /* the CPU emulator uses some host signals to detect exceptions,
490
       we forward to it some signals */
491
    if ((host_signum == SIGSEGV || host_signum == SIGBUS)
492
        && info->si_code > 0) {
493
        if (cpu_signal_handler(host_signum, info, puc))
494
            return;
495
    }
496

    
497
    /* get target signal number */
498
    sig = host_to_target_signal(host_signum);
499
    if (sig < 1 || sig > TARGET_NSIG)
500
        return;
501
#if defined(DEBUG_SIGNAL)
502
    fprintf(stderr, "qemu: got signal %d\n", sig);
503
#endif
504
    host_to_target_siginfo_noswap(&tinfo, info);
505
    if (queue_signal(thread_env, sig, &tinfo) == 1) {
506
        /* interrupt the virtual CPU as soon as possible */
507
        cpu_exit(thread_env);
508
    }
509
}
510

    
511
/* do_sigaltstack() returns target values and errnos. */
512
/* compare linux/kernel/signal.c:do_sigaltstack() */
513
abi_long do_sigaltstack(abi_ulong uss_addr, abi_ulong uoss_addr, abi_ulong sp)
514
{
515
    int ret;
516
    struct target_sigaltstack oss;
517

    
518
    /* XXX: test errors */
519
    if(uoss_addr)
520
    {
521
        __put_user(target_sigaltstack_used.ss_sp, &oss.ss_sp);
522
        __put_user(target_sigaltstack_used.ss_size, &oss.ss_size);
523
        __put_user(sas_ss_flags(sp), &oss.ss_flags);
524
    }
525

    
526
    if(uss_addr)
527
    {
528
        struct target_sigaltstack *uss;
529
        struct target_sigaltstack ss;
530

    
531
        ret = -TARGET_EFAULT;
532
        if (!lock_user_struct(VERIFY_READ, uss, uss_addr, 1)
533
            || __get_user(ss.ss_sp, &uss->ss_sp)
534
            || __get_user(ss.ss_size, &uss->ss_size)
535
            || __get_user(ss.ss_flags, &uss->ss_flags))
536
            goto out;
537
        unlock_user_struct(uss, uss_addr, 0);
538

    
539
        ret = -TARGET_EPERM;
540
        if (on_sig_stack(sp))
541
            goto out;
542

    
543
        ret = -TARGET_EINVAL;
544
        if (ss.ss_flags != TARGET_SS_DISABLE
545
            && ss.ss_flags != TARGET_SS_ONSTACK
546
            && ss.ss_flags != 0)
547
            goto out;
548

    
549
        if (ss.ss_flags == TARGET_SS_DISABLE) {
550
            ss.ss_size = 0;
551
            ss.ss_sp = 0;
552
        } else {
553
            ret = -TARGET_ENOMEM;
554
            if (ss.ss_size < MINSIGSTKSZ)
555
                goto out;
556
        }
557

    
558
        target_sigaltstack_used.ss_sp = ss.ss_sp;
559
        target_sigaltstack_used.ss_size = ss.ss_size;
560
    }
561

    
562
    if (uoss_addr) {
563
        ret = -TARGET_EFAULT;
564
        if (copy_to_user(uoss_addr, &oss, sizeof(oss)))
565
            goto out;
566
    }
567

    
568
    ret = 0;
569
out:
570
    return ret;
571
}
572

    
573
/* do_sigaction() return host values and errnos */
574
int do_sigaction(int sig, const struct target_sigaction *act,
575
                 struct target_sigaction *oact)
576
{
577
    struct target_sigaction *k;
578
    struct sigaction act1;
579
    int host_sig;
580
    int ret = 0;
581

    
582
    if (sig < 1 || sig > TARGET_NSIG || sig == TARGET_SIGKILL || sig == TARGET_SIGSTOP)
583
        return -EINVAL;
584
    k = &sigact_table[sig - 1];
585
#if defined(DEBUG_SIGNAL)
586
    fprintf(stderr, "sigaction sig=%d act=0x%p, oact=0x%p\n",
587
            sig, act, oact);
588
#endif
589
    if (oact) {
590
        oact->_sa_handler = tswapl(k->_sa_handler);
591
        oact->sa_flags = tswapl(k->sa_flags);
592
#if !defined(TARGET_MIPS)
593
        oact->sa_restorer = tswapl(k->sa_restorer);
594
#endif
595
        oact->sa_mask = k->sa_mask;
596
    }
597
    if (act) {
598
        /* FIXME: This is not threadsafe.  */
599
        k->_sa_handler = tswapl(act->_sa_handler);
600
        k->sa_flags = tswapl(act->sa_flags);
601
#if !defined(TARGET_MIPS)
602
        k->sa_restorer = tswapl(act->sa_restorer);
603
#endif
604
        k->sa_mask = act->sa_mask;
605

    
606
        /* we update the host linux signal state */
607
        host_sig = target_to_host_signal(sig);
608
        if (host_sig != SIGSEGV && host_sig != SIGBUS) {
609
            sigfillset(&act1.sa_mask);
610
            act1.sa_flags = SA_SIGINFO;
611
            if (k->sa_flags & TARGET_SA_RESTART)
612
                act1.sa_flags |= SA_RESTART;
613
            /* NOTE: it is important to update the host kernel signal
614
               ignore state to avoid getting unexpected interrupted
615
               syscalls */
616
            if (k->_sa_handler == TARGET_SIG_IGN) {
617
                act1.sa_sigaction = (void *)SIG_IGN;
618
            } else if (k->_sa_handler == TARGET_SIG_DFL) {
619
                if (fatal_signal (sig))
620
                    act1.sa_sigaction = host_signal_handler;
621
                else
622
                    act1.sa_sigaction = (void *)SIG_DFL;
623
            } else {
624
                act1.sa_sigaction = host_signal_handler;
625
            }
626
            ret = sigaction(host_sig, &act1, NULL);
627
        }
628
    }
629
    return ret;
630
}
631

    
632
static inline int copy_siginfo_to_user(target_siginfo_t *tinfo,
633
                                       const target_siginfo_t *info)
634
{
635
    tswap_siginfo(tinfo, info);
636
    return 0;
637
}
638

    
639
static inline int current_exec_domain_sig(int sig)
640
{
641
    return /* current->exec_domain && current->exec_domain->signal_invmap
642
              && sig < 32 ? current->exec_domain->signal_invmap[sig] : */ sig;
643
}
644

    
645
#if defined(TARGET_I386) && TARGET_ABI_BITS == 32
646

    
647
/* from the Linux kernel */
648

    
649
struct target_fpreg {
650
        uint16_t significand[4];
651
        uint16_t exponent;
652
};
653

    
654
struct target_fpxreg {
655
        uint16_t significand[4];
656
        uint16_t exponent;
657
        uint16_t padding[3];
658
};
659

    
660
struct target_xmmreg {
661
        abi_ulong element[4];
662
};
663

    
664
struct target_fpstate {
665
        /* Regular FPU environment */
666
        abi_ulong       cw;
667
        abi_ulong       sw;
668
        abi_ulong       tag;
669
        abi_ulong       ipoff;
670
        abi_ulong       cssel;
671
        abi_ulong       dataoff;
672
        abi_ulong       datasel;
673
        struct target_fpreg        _st[8];
674
        uint16_t        status;
675
        uint16_t        magic;                /* 0xffff = regular FPU data only */
676

    
677
        /* FXSR FPU environment */
678
        abi_ulong       _fxsr_env[6];   /* FXSR FPU env is ignored */
679
        abi_ulong       mxcsr;
680
        abi_ulong       reserved;
681
        struct target_fpxreg        _fxsr_st[8];        /* FXSR FPU reg data is ignored */
682
        struct target_xmmreg        _xmm[8];
683
        abi_ulong       padding[56];
684
};
685

    
686
#define X86_FXSR_MAGIC                0x0000
687

    
688
struct target_sigcontext {
689
        uint16_t gs, __gsh;
690
        uint16_t fs, __fsh;
691
        uint16_t es, __esh;
692
        uint16_t ds, __dsh;
693
        abi_ulong edi;
694
        abi_ulong esi;
695
        abi_ulong ebp;
696
        abi_ulong esp;
697
        abi_ulong ebx;
698
        abi_ulong edx;
699
        abi_ulong ecx;
700
        abi_ulong eax;
701
        abi_ulong trapno;
702
        abi_ulong err;
703
        abi_ulong eip;
704
        uint16_t cs, __csh;
705
        abi_ulong eflags;
706
        abi_ulong esp_at_signal;
707
        uint16_t ss, __ssh;
708
        abi_ulong fpstate; /* pointer */
709
        abi_ulong oldmask;
710
        abi_ulong cr2;
711
};
712

    
713
struct target_ucontext {
714
        abi_ulong         tuc_flags;
715
        abi_ulong         tuc_link;
716
        target_stack_t          tuc_stack;
717
        struct target_sigcontext tuc_mcontext;
718
        target_sigset_t          tuc_sigmask;        /* mask last for extensibility */
719
};
720

    
721
struct sigframe
722
{
723
    abi_ulong pretcode;
724
    int sig;
725
    struct target_sigcontext sc;
726
    struct target_fpstate fpstate;
727
    abi_ulong extramask[TARGET_NSIG_WORDS-1];
728
    char retcode[8];
729
};
730

    
731
struct rt_sigframe
732
{
733
    abi_ulong pretcode;
734
    int sig;
735
    abi_ulong pinfo;
736
    abi_ulong puc;
737
    struct target_siginfo info;
738
    struct target_ucontext uc;
739
    struct target_fpstate fpstate;
740
    char retcode[8];
741
};
742

    
743
/*
744
 * Set up a signal frame.
745
 */
746

    
747
/* XXX: save x87 state */
748
static int
749
setup_sigcontext(struct target_sigcontext *sc, struct target_fpstate *fpstate,
750
                 CPUX86State *env, abi_ulong mask, abi_ulong fpstate_addr)
751
{
752
        int err = 0;
753
        uint16_t magic;
754

    
755
        /* already locked in setup_frame() */
756
        err |= __put_user(env->segs[R_GS].selector, (unsigned int *)&sc->gs);
757
        err |= __put_user(env->segs[R_FS].selector, (unsigned int *)&sc->fs);
758
        err |= __put_user(env->segs[R_ES].selector, (unsigned int *)&sc->es);
759
        err |= __put_user(env->segs[R_DS].selector, (unsigned int *)&sc->ds);
760
        err |= __put_user(env->regs[R_EDI], &sc->edi);
761
        err |= __put_user(env->regs[R_ESI], &sc->esi);
762
        err |= __put_user(env->regs[R_EBP], &sc->ebp);
763
        err |= __put_user(env->regs[R_ESP], &sc->esp);
764
        err |= __put_user(env->regs[R_EBX], &sc->ebx);
765
        err |= __put_user(env->regs[R_EDX], &sc->edx);
766
        err |= __put_user(env->regs[R_ECX], &sc->ecx);
767
        err |= __put_user(env->regs[R_EAX], &sc->eax);
768
        err |= __put_user(env->exception_index, &sc->trapno);
769
        err |= __put_user(env->error_code, &sc->err);
770
        err |= __put_user(env->eip, &sc->eip);
771
        err |= __put_user(env->segs[R_CS].selector, (unsigned int *)&sc->cs);
772
        err |= __put_user(env->eflags, &sc->eflags);
773
        err |= __put_user(env->regs[R_ESP], &sc->esp_at_signal);
774
        err |= __put_user(env->segs[R_SS].selector, (unsigned int *)&sc->ss);
775

    
776
        cpu_x86_fsave(env, fpstate_addr, 1);
777
        fpstate->status = fpstate->sw;
778
        magic = 0xffff;
779
        err |= __put_user(magic, &fpstate->magic);
780
        err |= __put_user(fpstate_addr, &sc->fpstate);
781

    
782
        /* non-iBCS2 extensions.. */
783
        err |= __put_user(mask, &sc->oldmask);
784
        err |= __put_user(env->cr[2], &sc->cr2);
785
        return err;
786
}
787

    
788
/*
789
 * Determine which stack to use..
790
 */
791

    
792
static inline abi_ulong
793
get_sigframe(struct target_sigaction *ka, CPUX86State *env, size_t frame_size)
794
{
795
        unsigned long esp;
796

    
797
        /* Default to using normal stack */
798
        esp = env->regs[R_ESP];
799
        /* This is the X/Open sanctioned signal stack switching.  */
800
        if (ka->sa_flags & TARGET_SA_ONSTACK) {
801
            if (sas_ss_flags(esp) == 0)
802
                esp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
803
        }
804

    
805
        /* This is the legacy signal stack switching. */
806
        else
807
        if ((env->segs[R_SS].selector & 0xffff) != __USER_DS &&
808
            !(ka->sa_flags & TARGET_SA_RESTORER) &&
809
            ka->sa_restorer) {
810
            esp = (unsigned long) ka->sa_restorer;
811
        }
812
        return (esp - frame_size) & -8ul;
813
}
814

    
815
/* compare linux/arch/i386/kernel/signal.c:setup_frame() */
816
static void setup_frame(int sig, struct target_sigaction *ka,
817
                        target_sigset_t *set, CPUX86State *env)
818
{
819
        abi_ulong frame_addr;
820
        struct sigframe *frame;
821
        int i, err = 0;
822

    
823
        frame_addr = get_sigframe(ka, env, sizeof(*frame));
824

    
825
        if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
826
                goto give_sigsegv;
827

    
828
        err |= __put_user(current_exec_domain_sig(sig),
829
                          &frame->sig);
830
        if (err)
831
                goto give_sigsegv;
832

    
833
        setup_sigcontext(&frame->sc, &frame->fpstate, env, set->sig[0],
834
                         frame_addr + offsetof(struct sigframe, fpstate));
835
        if (err)
836
                goto give_sigsegv;
837

    
838
        for(i = 1; i < TARGET_NSIG_WORDS; i++) {
839
            if (__put_user(set->sig[i], &frame->extramask[i - 1]))
840
                goto give_sigsegv;
841
        }
842

    
843
        /* Set up to return from userspace.  If provided, use a stub
844
           already in userspace.  */
845
        if (ka->sa_flags & TARGET_SA_RESTORER) {
846
                err |= __put_user(ka->sa_restorer, &frame->pretcode);
847
        } else {
848
                uint16_t val16;
849
                abi_ulong retcode_addr;
850
                retcode_addr = frame_addr + offsetof(struct sigframe, retcode);
851
                err |= __put_user(retcode_addr, &frame->pretcode);
852
                /* This is popl %eax ; movl $,%eax ; int $0x80 */
853
                val16 = 0xb858;
854
                err |= __put_user(val16, (uint16_t *)(frame->retcode+0));
855
                err |= __put_user(TARGET_NR_sigreturn, (int *)(frame->retcode+2));
856
                val16 = 0x80cd;
857
                err |= __put_user(val16, (uint16_t *)(frame->retcode+6));
858
        }
859

    
860
        if (err)
861
                goto give_sigsegv;
862

    
863
        /* Set up registers for signal handler */
864
        env->regs[R_ESP] = frame_addr;
865
        env->eip = ka->_sa_handler;
866

    
867
        cpu_x86_load_seg(env, R_DS, __USER_DS);
868
        cpu_x86_load_seg(env, R_ES, __USER_DS);
869
        cpu_x86_load_seg(env, R_SS, __USER_DS);
870
        cpu_x86_load_seg(env, R_CS, __USER_CS);
871
        env->eflags &= ~TF_MASK;
872

    
873
        unlock_user_struct(frame, frame_addr, 1);
874

    
875
        return;
876

    
877
give_sigsegv:
878
        unlock_user_struct(frame, frame_addr, 1);
879
        if (sig == TARGET_SIGSEGV)
880
                ka->_sa_handler = TARGET_SIG_DFL;
881
        force_sig(TARGET_SIGSEGV /* , current */);
882
}
883

    
884
/* compare linux/arch/i386/kernel/signal.c:setup_rt_frame() */
885
static void setup_rt_frame(int sig, struct target_sigaction *ka,
886
                           target_siginfo_t *info,
887
                           target_sigset_t *set, CPUX86State *env)
888
{
889
        abi_ulong frame_addr, addr;
890
        struct rt_sigframe *frame;
891
        int i, err = 0;
892

    
893
        frame_addr = get_sigframe(ka, env, sizeof(*frame));
894

    
895
        if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
896
                goto give_sigsegv;
897

    
898
        err |= __put_user(current_exec_domain_sig(sig),
899
                          &frame->sig);
900
        addr = frame_addr + offsetof(struct rt_sigframe, info);
901
        err |= __put_user(addr, &frame->pinfo);
902
        addr = frame_addr + offsetof(struct rt_sigframe, uc);
903
        err |= __put_user(addr, &frame->puc);
904
        err |= copy_siginfo_to_user(&frame->info, info);
905
        if (err)
906
                goto give_sigsegv;
907

    
908
        /* Create the ucontext.  */
909
        err |= __put_user(0, &frame->uc.tuc_flags);
910
        err |= __put_user(0, &frame->uc.tuc_link);
911
        err |= __put_user(target_sigaltstack_used.ss_sp,
912
                          &frame->uc.tuc_stack.ss_sp);
913
        err |= __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
914
                          &frame->uc.tuc_stack.ss_flags);
915
        err |= __put_user(target_sigaltstack_used.ss_size,
916
                          &frame->uc.tuc_stack.ss_size);
917
        err |= setup_sigcontext(&frame->uc.tuc_mcontext, &frame->fpstate,
918
                                env, set->sig[0], 
919
                                frame_addr + offsetof(struct rt_sigframe, fpstate));
920
        for(i = 0; i < TARGET_NSIG_WORDS; i++) {
921
            if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
922
                goto give_sigsegv;
923
        }
924

    
925
        /* Set up to return from userspace.  If provided, use a stub
926
           already in userspace.  */
927
        if (ka->sa_flags & TARGET_SA_RESTORER) {
928
                err |= __put_user(ka->sa_restorer, &frame->pretcode);
929
        } else {
930
                uint16_t val16;
931
                addr = frame_addr + offsetof(struct rt_sigframe, retcode);
932
                err |= __put_user(addr, &frame->pretcode);
933
                /* This is movl $,%eax ; int $0x80 */
934
                err |= __put_user(0xb8, (char *)(frame->retcode+0));
935
                err |= __put_user(TARGET_NR_rt_sigreturn, (int *)(frame->retcode+1));
936
                val16 = 0x80cd;
937
                err |= __put_user(val16, (uint16_t *)(frame->retcode+5));
938
        }
939

    
940
        if (err)
941
                goto give_sigsegv;
942

    
943
        /* Set up registers for signal handler */
944
        env->regs[R_ESP] = frame_addr;
945
        env->eip = ka->_sa_handler;
946

    
947
        cpu_x86_load_seg(env, R_DS, __USER_DS);
948
        cpu_x86_load_seg(env, R_ES, __USER_DS);
949
        cpu_x86_load_seg(env, R_SS, __USER_DS);
950
        cpu_x86_load_seg(env, R_CS, __USER_CS);
951
        env->eflags &= ~TF_MASK;
952

    
953
        unlock_user_struct(frame, frame_addr, 1);
954

    
955
        return;
956

    
957
give_sigsegv:
958
        unlock_user_struct(frame, frame_addr, 1);
959
        if (sig == TARGET_SIGSEGV)
960
                ka->_sa_handler = TARGET_SIG_DFL;
961
        force_sig(TARGET_SIGSEGV /* , current */);
962
}
963

    
964
static int
965
restore_sigcontext(CPUX86State *env, struct target_sigcontext *sc, int *peax)
966
{
967
        unsigned int err = 0;
968
        abi_ulong fpstate_addr;
969
        unsigned int tmpflags;
970

    
971
        cpu_x86_load_seg(env, R_GS, tswap16(sc->gs));
972
        cpu_x86_load_seg(env, R_FS, tswap16(sc->fs));
973
        cpu_x86_load_seg(env, R_ES, tswap16(sc->es));
974
        cpu_x86_load_seg(env, R_DS, tswap16(sc->ds));
975

    
976
        env->regs[R_EDI] = tswapl(sc->edi);
977
        env->regs[R_ESI] = tswapl(sc->esi);
978
        env->regs[R_EBP] = tswapl(sc->ebp);
979
        env->regs[R_ESP] = tswapl(sc->esp);
980
        env->regs[R_EBX] = tswapl(sc->ebx);
981
        env->regs[R_EDX] = tswapl(sc->edx);
982
        env->regs[R_ECX] = tswapl(sc->ecx);
983
        env->eip = tswapl(sc->eip);
984

    
985
        cpu_x86_load_seg(env, R_CS, lduw(&sc->cs) | 3);
986
        cpu_x86_load_seg(env, R_SS, lduw(&sc->ss) | 3);
987

    
988
        tmpflags = tswapl(sc->eflags);
989
        env->eflags = (env->eflags & ~0x40DD5) | (tmpflags & 0x40DD5);
990
        //                regs->orig_eax = -1;                /* disable syscall checks */
991

    
992
        fpstate_addr = tswapl(sc->fpstate);
993
        if (fpstate_addr != 0) {
994
                if (!access_ok(VERIFY_READ, fpstate_addr, 
995
                               sizeof(struct target_fpstate)))
996
                        goto badframe;
997
                cpu_x86_frstor(env, fpstate_addr, 1);
998
        }
999

    
1000
        *peax = tswapl(sc->eax);
1001
        return err;
1002
badframe:
1003
        return 1;
1004
}
1005

    
1006
long do_sigreturn(CPUX86State *env)
1007
{
1008
    struct sigframe *frame;
1009
    abi_ulong frame_addr = env->regs[R_ESP] - 8;
1010
    target_sigset_t target_set;
1011
    sigset_t set;
1012
    int eax, i;
1013

    
1014
#if defined(DEBUG_SIGNAL)
1015
    fprintf(stderr, "do_sigreturn\n");
1016
#endif
1017
    if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1018
        goto badframe;
1019
    /* set blocked signals */
1020
    if (__get_user(target_set.sig[0], &frame->sc.oldmask))
1021
        goto badframe;
1022
    for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1023
        if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
1024
            goto badframe;
1025
    }
1026

    
1027
    target_to_host_sigset_internal(&set, &target_set);
1028
    sigprocmask(SIG_SETMASK, &set, NULL);
1029

    
1030
    /* restore registers */
1031
    if (restore_sigcontext(env, &frame->sc, &eax))
1032
        goto badframe;
1033
    unlock_user_struct(frame, frame_addr, 0);
1034
    return eax;
1035

    
1036
badframe:
1037
    unlock_user_struct(frame, frame_addr, 0);
1038
    force_sig(TARGET_SIGSEGV);
1039
    return 0;
1040
}
1041

    
1042
long do_rt_sigreturn(CPUX86State *env)
1043
{
1044
        abi_ulong frame_addr;
1045
        struct rt_sigframe *frame;
1046
        sigset_t set;
1047
        int eax;
1048

    
1049
        frame_addr = env->regs[R_ESP] - 4;
1050
        if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1051
                goto badframe;
1052
        target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
1053
        sigprocmask(SIG_SETMASK, &set, NULL);
1054

    
1055
        if (restore_sigcontext(env, &frame->uc.tuc_mcontext, &eax))
1056
                goto badframe;
1057

    
1058
        if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe, uc.tuc_stack), 0, 
1059
                           get_sp_from_cpustate(env)) == -EFAULT)
1060
                goto badframe;
1061

    
1062
        unlock_user_struct(frame, frame_addr, 0);
1063
        return eax;
1064

    
1065
badframe:
1066
        unlock_user_struct(frame, frame_addr, 0);
1067
        force_sig(TARGET_SIGSEGV);
1068
        return 0;
1069
}
1070

    
1071
#elif defined(TARGET_ARM)
1072

    
1073
struct target_sigcontext {
1074
        abi_ulong trap_no;
1075
        abi_ulong error_code;
1076
        abi_ulong oldmask;
1077
        abi_ulong arm_r0;
1078
        abi_ulong arm_r1;
1079
        abi_ulong arm_r2;
1080
        abi_ulong arm_r3;
1081
        abi_ulong arm_r4;
1082
        abi_ulong arm_r5;
1083
        abi_ulong arm_r6;
1084
        abi_ulong arm_r7;
1085
        abi_ulong arm_r8;
1086
        abi_ulong arm_r9;
1087
        abi_ulong arm_r10;
1088
        abi_ulong arm_fp;
1089
        abi_ulong arm_ip;
1090
        abi_ulong arm_sp;
1091
        abi_ulong arm_lr;
1092
        abi_ulong arm_pc;
1093
        abi_ulong arm_cpsr;
1094
        abi_ulong fault_address;
1095
};
1096

    
1097
struct target_ucontext_v1 {
1098
    abi_ulong tuc_flags;
1099
    abi_ulong tuc_link;
1100
    target_stack_t tuc_stack;
1101
    struct target_sigcontext tuc_mcontext;
1102
    target_sigset_t  tuc_sigmask;        /* mask last for extensibility */
1103
};
1104

    
1105
struct target_ucontext_v2 {
1106
    abi_ulong tuc_flags;
1107
    abi_ulong tuc_link;
1108
    target_stack_t tuc_stack;
1109
    struct target_sigcontext tuc_mcontext;
1110
    target_sigset_t  tuc_sigmask;        /* mask last for extensibility */
1111
    char __unused[128 - sizeof(sigset_t)];
1112
    abi_ulong tuc_regspace[128] __attribute__((__aligned__(8)));
1113
};
1114

    
1115
struct sigframe_v1
1116
{
1117
    struct target_sigcontext sc;
1118
    abi_ulong extramask[TARGET_NSIG_WORDS-1];
1119
    abi_ulong retcode;
1120
};
1121

    
1122
struct sigframe_v2
1123
{
1124
    struct target_ucontext_v2 uc;
1125
    abi_ulong retcode;
1126
};
1127

    
1128
struct rt_sigframe_v1
1129
{
1130
    abi_ulong pinfo;
1131
    abi_ulong puc;
1132
    struct target_siginfo info;
1133
    struct target_ucontext_v1 uc;
1134
    abi_ulong retcode;
1135
};
1136

    
1137
struct rt_sigframe_v2
1138
{
1139
    struct target_siginfo info;
1140
    struct target_ucontext_v2 uc;
1141
    abi_ulong retcode;
1142
};
1143

    
1144
#define TARGET_CONFIG_CPU_32 1
1145

    
1146
/*
1147
 * For ARM syscalls, we encode the syscall number into the instruction.
1148
 */
1149
#define SWI_SYS_SIGRETURN        (0xef000000|(TARGET_NR_sigreturn + ARM_SYSCALL_BASE))
1150
#define SWI_SYS_RT_SIGRETURN        (0xef000000|(TARGET_NR_rt_sigreturn + ARM_SYSCALL_BASE))
1151

    
1152
/*
1153
 * For Thumb syscalls, we pass the syscall number via r7.  We therefore
1154
 * need two 16-bit instructions.
1155
 */
1156
#define SWI_THUMB_SIGRETURN        (0xdf00 << 16 | 0x2700 | (TARGET_NR_sigreturn))
1157
#define SWI_THUMB_RT_SIGRETURN        (0xdf00 << 16 | 0x2700 | (TARGET_NR_rt_sigreturn))
1158

    
1159
static const abi_ulong retcodes[4] = {
1160
        SWI_SYS_SIGRETURN,        SWI_THUMB_SIGRETURN,
1161
        SWI_SYS_RT_SIGRETURN,        SWI_THUMB_RT_SIGRETURN
1162
};
1163

    
1164

    
1165
#define __get_user_error(x,p,e) __get_user(x, p)
1166

    
1167
static inline int valid_user_regs(CPUState *regs)
1168
{
1169
    return 1;
1170
}
1171

    
1172
static void
1173
setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1174
                 CPUState *env, abi_ulong mask)
1175
{
1176
        __put_user(env->regs[0], &sc->arm_r0);
1177
        __put_user(env->regs[1], &sc->arm_r1);
1178
        __put_user(env->regs[2], &sc->arm_r2);
1179
        __put_user(env->regs[3], &sc->arm_r3);
1180
        __put_user(env->regs[4], &sc->arm_r4);
1181
        __put_user(env->regs[5], &sc->arm_r5);
1182
        __put_user(env->regs[6], &sc->arm_r6);
1183
        __put_user(env->regs[7], &sc->arm_r7);
1184
        __put_user(env->regs[8], &sc->arm_r8);
1185
        __put_user(env->regs[9], &sc->arm_r9);
1186
        __put_user(env->regs[10], &sc->arm_r10);
1187
        __put_user(env->regs[11], &sc->arm_fp);
1188
        __put_user(env->regs[12], &sc->arm_ip);
1189
        __put_user(env->regs[13], &sc->arm_sp);
1190
        __put_user(env->regs[14], &sc->arm_lr);
1191
        __put_user(env->regs[15], &sc->arm_pc);
1192
#ifdef TARGET_CONFIG_CPU_32
1193
        __put_user(cpsr_read(env), &sc->arm_cpsr);
1194
#endif
1195

    
1196
        __put_user(/* current->thread.trap_no */ 0, &sc->trap_no);
1197
        __put_user(/* current->thread.error_code */ 0, &sc->error_code);
1198
        __put_user(/* current->thread.address */ 0, &sc->fault_address);
1199
        __put_user(mask, &sc->oldmask);
1200
}
1201

    
1202
static inline abi_ulong
1203
get_sigframe(struct target_sigaction *ka, CPUState *regs, int framesize)
1204
{
1205
        unsigned long sp = regs->regs[13];
1206

    
1207
        /*
1208
         * This is the X/Open sanctioned signal stack switching.
1209
         */
1210
        if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp))
1211
            sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1212
        /*
1213
         * ATPCS B01 mandates 8-byte alignment
1214
         */
1215
        return (sp - framesize) & ~7;
1216
}
1217

    
1218
static int
1219
setup_return(CPUState *env, struct target_sigaction *ka,
1220
             abi_ulong *rc, abi_ulong frame_addr, int usig, abi_ulong rc_addr)
1221
{
1222
        abi_ulong handler = ka->_sa_handler;
1223
        abi_ulong retcode;
1224
        int thumb = handler & 1;
1225

    
1226
        if (ka->sa_flags & TARGET_SA_RESTORER) {
1227
                retcode = ka->sa_restorer;
1228
        } else {
1229
                unsigned int idx = thumb;
1230

    
1231
                if (ka->sa_flags & TARGET_SA_SIGINFO)
1232
                        idx += 2;
1233

    
1234
                if (__put_user(retcodes[idx], rc))
1235
                        return 1;
1236
#if 0
1237
                flush_icache_range((abi_ulong)rc,
1238
                                   (abi_ulong)(rc + 1));
1239
#endif
1240
                retcode = rc_addr + thumb;
1241
        }
1242

    
1243
        env->regs[0] = usig;
1244
        env->regs[13] = frame_addr;
1245
        env->regs[14] = retcode;
1246
        env->regs[15] = handler & (thumb ? ~1 : ~3);
1247
        env->thumb = thumb;
1248

    
1249
#if 0
1250
#ifdef TARGET_CONFIG_CPU_32
1251
        env->cpsr = cpsr;
1252
#endif
1253
#endif
1254

    
1255
        return 0;
1256
}
1257

    
1258
static void setup_sigframe_v2(struct target_ucontext_v2 *uc,
1259
                              target_sigset_t *set, CPUState *env)
1260
{
1261
    struct target_sigaltstack stack;
1262
    int i;
1263

    
1264
    /* Clear all the bits of the ucontext we don't use.  */
1265
    memset(uc, 0, offsetof(struct target_ucontext_v2, tuc_mcontext));
1266

    
1267
    memset(&stack, 0, sizeof(stack));
1268
    __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1269
    __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1270
    __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
1271
    memcpy(&uc->tuc_stack, &stack, sizeof(stack));
1272

    
1273
    setup_sigcontext(&uc->tuc_mcontext, env, set->sig[0]);
1274
    /* FIXME: Save coprocessor signal frame.  */
1275
    for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1276
        __put_user(set->sig[i], &uc->tuc_sigmask.sig[i]);
1277
    }
1278
}
1279

    
1280
/* compare linux/arch/arm/kernel/signal.c:setup_frame() */
1281
static void setup_frame_v1(int usig, struct target_sigaction *ka,
1282
                           target_sigset_t *set, CPUState *regs)
1283
{
1284
        struct sigframe_v1 *frame;
1285
        abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
1286
        int i;
1287

    
1288
        if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1289
                return;
1290

    
1291
        setup_sigcontext(&frame->sc, regs, set->sig[0]);
1292

    
1293
        for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1294
            if (__put_user(set->sig[i], &frame->extramask[i - 1]))
1295
                goto end;
1296
        }
1297

    
1298
        setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1299
                     frame_addr + offsetof(struct sigframe_v1, retcode));
1300

    
1301
end:
1302
        unlock_user_struct(frame, frame_addr, 1);
1303
}
1304

    
1305
static void setup_frame_v2(int usig, struct target_sigaction *ka,
1306
                           target_sigset_t *set, CPUState *regs)
1307
{
1308
        struct sigframe_v2 *frame;
1309
        abi_ulong frame_addr = get_sigframe(ka, regs, sizeof(*frame));
1310

    
1311
        if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1312
                return;
1313

    
1314
        setup_sigframe_v2(&frame->uc, set, regs);
1315

    
1316
        setup_return(regs, ka, &frame->retcode, frame_addr, usig,
1317
                     frame_addr + offsetof(struct sigframe_v2, retcode));
1318

    
1319
        unlock_user_struct(frame, frame_addr, 1);
1320
}
1321

    
1322
static void setup_frame(int usig, struct target_sigaction *ka,
1323
                        target_sigset_t *set, CPUState *regs)
1324
{
1325
    if (get_osversion() >= 0x020612) {
1326
        setup_frame_v2(usig, ka, set, regs);
1327
    } else {
1328
        setup_frame_v1(usig, ka, set, regs);
1329
    }
1330
}
1331

    
1332
/* compare linux/arch/arm/kernel/signal.c:setup_rt_frame() */
1333
static void setup_rt_frame_v1(int usig, struct target_sigaction *ka,
1334
                              target_siginfo_t *info,
1335
                              target_sigset_t *set, CPUState *env)
1336
{
1337
        struct rt_sigframe_v1 *frame;
1338
        abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
1339
        struct target_sigaltstack stack;
1340
        int i;
1341
        abi_ulong info_addr, uc_addr;
1342

    
1343
        if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1344
            return /* 1 */;
1345

    
1346
        info_addr = frame_addr + offsetof(struct rt_sigframe_v1, info);
1347
        __put_user(info_addr, &frame->pinfo);
1348
        uc_addr = frame_addr + offsetof(struct rt_sigframe_v1, uc);
1349
        __put_user(uc_addr, &frame->puc);
1350
        copy_siginfo_to_user(&frame->info, info);
1351

    
1352
        /* Clear all the bits of the ucontext we don't use.  */
1353
        memset(&frame->uc, 0, offsetof(struct target_ucontext_v1, tuc_mcontext));
1354

    
1355
        memset(&stack, 0, sizeof(stack));
1356
        __put_user(target_sigaltstack_used.ss_sp, &stack.ss_sp);
1357
        __put_user(target_sigaltstack_used.ss_size, &stack.ss_size);
1358
        __put_user(sas_ss_flags(get_sp_from_cpustate(env)), &stack.ss_flags);
1359
        memcpy(&frame->uc.tuc_stack, &stack, sizeof(stack));
1360

    
1361
        setup_sigcontext(&frame->uc.tuc_mcontext, env, set->sig[0]);
1362
        for(i = 0; i < TARGET_NSIG_WORDS; i++) {
1363
            if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
1364
                goto end;
1365
        }
1366

    
1367
        setup_return(env, ka, &frame->retcode, frame_addr, usig,
1368
                     frame_addr + offsetof(struct rt_sigframe_v1, retcode));
1369

    
1370
        env->regs[1] = info_addr;
1371
        env->regs[2] = uc_addr;
1372

    
1373
end:
1374
        unlock_user_struct(frame, frame_addr, 1);
1375
}
1376

    
1377
static void setup_rt_frame_v2(int usig, struct target_sigaction *ka,
1378
                              target_siginfo_t *info,
1379
                              target_sigset_t *set, CPUState *env)
1380
{
1381
        struct rt_sigframe_v2 *frame;
1382
        abi_ulong frame_addr = get_sigframe(ka, env, sizeof(*frame));
1383
        abi_ulong info_addr, uc_addr;
1384

    
1385
        if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
1386
            return /* 1 */;
1387

    
1388
        info_addr = frame_addr + offsetof(struct rt_sigframe_v2, info);
1389
        uc_addr = frame_addr + offsetof(struct rt_sigframe_v2, uc);
1390
        copy_siginfo_to_user(&frame->info, info);
1391

    
1392
        setup_sigframe_v2(&frame->uc, set, env);
1393

    
1394
        setup_return(env, ka, &frame->retcode, frame_addr, usig,
1395
                     frame_addr + offsetof(struct rt_sigframe_v2, retcode));
1396

    
1397
        env->regs[1] = info_addr;
1398
        env->regs[2] = uc_addr;
1399

    
1400
        unlock_user_struct(frame, frame_addr, 1);
1401
}
1402

    
1403
static void setup_rt_frame(int usig, struct target_sigaction *ka,
1404
                           target_siginfo_t *info,
1405
                           target_sigset_t *set, CPUState *env)
1406
{
1407
    if (get_osversion() >= 0x020612) {
1408
        setup_rt_frame_v2(usig, ka, info, set, env);
1409
    } else {
1410
        setup_rt_frame_v1(usig, ka, info, set, env);
1411
    }
1412
}
1413

    
1414
static int
1415
restore_sigcontext(CPUState *env, struct target_sigcontext *sc)
1416
{
1417
        int err = 0;
1418
        uint32_t cpsr;
1419

    
1420
        __get_user_error(env->regs[0], &sc->arm_r0, err);
1421
        __get_user_error(env->regs[1], &sc->arm_r1, err);
1422
        __get_user_error(env->regs[2], &sc->arm_r2, err);
1423
        __get_user_error(env->regs[3], &sc->arm_r3, err);
1424
        __get_user_error(env->regs[4], &sc->arm_r4, err);
1425
        __get_user_error(env->regs[5], &sc->arm_r5, err);
1426
        __get_user_error(env->regs[6], &sc->arm_r6, err);
1427
        __get_user_error(env->regs[7], &sc->arm_r7, err);
1428
        __get_user_error(env->regs[8], &sc->arm_r8, err);
1429
        __get_user_error(env->regs[9], &sc->arm_r9, err);
1430
        __get_user_error(env->regs[10], &sc->arm_r10, err);
1431
        __get_user_error(env->regs[11], &sc->arm_fp, err);
1432
        __get_user_error(env->regs[12], &sc->arm_ip, err);
1433
        __get_user_error(env->regs[13], &sc->arm_sp, err);
1434
        __get_user_error(env->regs[14], &sc->arm_lr, err);
1435
        __get_user_error(env->regs[15], &sc->arm_pc, err);
1436
#ifdef TARGET_CONFIG_CPU_32
1437
        __get_user_error(cpsr, &sc->arm_cpsr, err);
1438
        cpsr_write(env, cpsr, CPSR_USER | CPSR_EXEC);
1439
#endif
1440

    
1441
        err |= !valid_user_regs(env);
1442

    
1443
        return err;
1444
}
1445

    
1446
static long do_sigreturn_v1(CPUState *env)
1447
{
1448
        abi_ulong frame_addr;
1449
        struct sigframe_v1 *frame;
1450
        target_sigset_t set;
1451
        sigset_t host_set;
1452
        int i;
1453

    
1454
        /*
1455
         * Since we stacked the signal on a 64-bit boundary,
1456
         * then 'sp' should be word aligned here.  If it's
1457
         * not, then the user is trying to mess with us.
1458
         */
1459
        if (env->regs[13] & 7)
1460
                goto badframe;
1461

    
1462
        frame_addr = env->regs[13];
1463
        if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1464
                goto badframe;
1465

    
1466
        if (__get_user(set.sig[0], &frame->sc.oldmask))
1467
            goto badframe;
1468
        for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1469
            if (__get_user(set.sig[i], &frame->extramask[i - 1]))
1470
                goto badframe;
1471
        }
1472

    
1473
        target_to_host_sigset_internal(&host_set, &set);
1474
        sigprocmask(SIG_SETMASK, &host_set, NULL);
1475

    
1476
        if (restore_sigcontext(env, &frame->sc))
1477
                goto badframe;
1478

    
1479
#if 0
1480
        /* Send SIGTRAP if we're single-stepping */
1481
        if (ptrace_cancel_bpt(current))
1482
                send_sig(SIGTRAP, current, 1);
1483
#endif
1484
        unlock_user_struct(frame, frame_addr, 0);
1485
        return env->regs[0];
1486

    
1487
badframe:
1488
        unlock_user_struct(frame, frame_addr, 0);
1489
        force_sig(TARGET_SIGSEGV /* , current */);
1490
        return 0;
1491
}
1492

    
1493
static int do_sigframe_return_v2(CPUState *env, target_ulong frame_addr,
1494
                                 struct target_ucontext_v2 *uc)
1495
{
1496
    sigset_t host_set;
1497

    
1498
    target_to_host_sigset(&host_set, &uc->tuc_sigmask);
1499
    sigprocmask(SIG_SETMASK, &host_set, NULL);
1500

    
1501
    if (restore_sigcontext(env, &uc->tuc_mcontext))
1502
        return 1;
1503

    
1504
    if (do_sigaltstack(frame_addr + offsetof(struct target_ucontext_v2, tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
1505
        return 1;
1506

    
1507
#if 0
1508
    /* Send SIGTRAP if we're single-stepping */
1509
    if (ptrace_cancel_bpt(current))
1510
            send_sig(SIGTRAP, current, 1);
1511
#endif
1512

    
1513
    return 0;
1514
}
1515

    
1516
static long do_sigreturn_v2(CPUState *env)
1517
{
1518
        abi_ulong frame_addr;
1519
        struct sigframe_v2 *frame;
1520

    
1521
        /*
1522
         * Since we stacked the signal on a 64-bit boundary,
1523
         * then 'sp' should be word aligned here.  If it's
1524
         * not, then the user is trying to mess with us.
1525
         */
1526
        if (env->regs[13] & 7)
1527
                goto badframe;
1528

    
1529
        frame_addr = env->regs[13];
1530
        if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1531
                goto badframe;
1532

    
1533
        if (do_sigframe_return_v2(env, frame_addr, &frame->uc))
1534
                goto badframe;
1535

    
1536
        unlock_user_struct(frame, frame_addr, 0);
1537
        return env->regs[0];
1538

    
1539
badframe:
1540
        unlock_user_struct(frame, frame_addr, 0);
1541
        force_sig(TARGET_SIGSEGV /* , current */);
1542
        return 0;
1543
}
1544

    
1545
long do_sigreturn(CPUState *env)
1546
{
1547
    if (get_osversion() >= 0x020612) {
1548
        return do_sigreturn_v2(env);
1549
    } else {
1550
        return do_sigreturn_v1(env);
1551
    }
1552
}
1553

    
1554
static long do_rt_sigreturn_v1(CPUState *env)
1555
{
1556
        abi_ulong frame_addr;
1557
        struct rt_sigframe_v1 *frame;
1558
        sigset_t host_set;
1559

    
1560
        /*
1561
         * Since we stacked the signal on a 64-bit boundary,
1562
         * then 'sp' should be word aligned here.  If it's
1563
         * not, then the user is trying to mess with us.
1564
         */
1565
        if (env->regs[13] & 7)
1566
                goto badframe;
1567

    
1568
        frame_addr = env->regs[13];
1569
        if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1570
                goto badframe;
1571

    
1572
        target_to_host_sigset(&host_set, &frame->uc.tuc_sigmask);
1573
        sigprocmask(SIG_SETMASK, &host_set, NULL);
1574

    
1575
        if (restore_sigcontext(env, &frame->uc.tuc_mcontext))
1576
                goto badframe;
1577

    
1578
        if (do_sigaltstack(frame_addr + offsetof(struct rt_sigframe_v1, uc.tuc_stack), 0, get_sp_from_cpustate(env)) == -EFAULT)
1579
                goto badframe;
1580

    
1581
#if 0
1582
        /* Send SIGTRAP if we're single-stepping */
1583
        if (ptrace_cancel_bpt(current))
1584
                send_sig(SIGTRAP, current, 1);
1585
#endif
1586
        unlock_user_struct(frame, frame_addr, 0);
1587
        return env->regs[0];
1588

    
1589
badframe:
1590
        unlock_user_struct(frame, frame_addr, 0);
1591
        force_sig(TARGET_SIGSEGV /* , current */);
1592
        return 0;
1593
}
1594

    
1595
static long do_rt_sigreturn_v2(CPUState *env)
1596
{
1597
        abi_ulong frame_addr;
1598
        struct rt_sigframe_v2 *frame;
1599

    
1600
        /*
1601
         * Since we stacked the signal on a 64-bit boundary,
1602
         * then 'sp' should be word aligned here.  If it's
1603
         * not, then the user is trying to mess with us.
1604
         */
1605
        if (env->regs[13] & 7)
1606
                goto badframe;
1607

    
1608
        frame_addr = env->regs[13];
1609
        if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
1610
                goto badframe;
1611

    
1612
        if (do_sigframe_return_v2(env, frame_addr, &frame->uc))
1613
                goto badframe;
1614

    
1615
        unlock_user_struct(frame, frame_addr, 0);
1616
        return env->regs[0];
1617

    
1618
badframe:
1619
        unlock_user_struct(frame, frame_addr, 0);
1620
        force_sig(TARGET_SIGSEGV /* , current */);
1621
        return 0;
1622
}
1623

    
1624
long do_rt_sigreturn(CPUState *env)
1625
{
1626
    if (get_osversion() >= 0x020612) {
1627
        return do_rt_sigreturn_v2(env);
1628
    } else {
1629
        return do_rt_sigreturn_v1(env);
1630
    }
1631
}
1632

    
1633
#elif defined(TARGET_SPARC)
1634

    
1635
#define __SUNOS_MAXWIN   31
1636

    
1637
/* This is what SunOS does, so shall I. */
1638
struct target_sigcontext {
1639
        abi_ulong sigc_onstack;      /* state to restore */
1640

    
1641
        abi_ulong sigc_mask;         /* sigmask to restore */
1642
        abi_ulong sigc_sp;           /* stack pointer */
1643
        abi_ulong sigc_pc;           /* program counter */
1644
        abi_ulong sigc_npc;          /* next program counter */
1645
        abi_ulong sigc_psr;          /* for condition codes etc */
1646
        abi_ulong sigc_g1;           /* User uses these two registers */
1647
        abi_ulong sigc_o0;           /* within the trampoline code. */
1648

    
1649
        /* Now comes information regarding the users window set
1650
         * at the time of the signal.
1651
         */
1652
        abi_ulong sigc_oswins;       /* outstanding windows */
1653

    
1654
        /* stack ptrs for each regwin buf */
1655
        char *sigc_spbuf[__SUNOS_MAXWIN];
1656

    
1657
        /* Windows to restore after signal */
1658
        struct {
1659
                abi_ulong locals[8];
1660
                abi_ulong ins[8];
1661
        } sigc_wbuf[__SUNOS_MAXWIN];
1662
};
1663
/* A Sparc stack frame */
1664
struct sparc_stackf {
1665
        abi_ulong locals[8];
1666
        abi_ulong ins[6];
1667
        struct sparc_stackf *fp;
1668
        abi_ulong callers_pc;
1669
        char *structptr;
1670
        abi_ulong xargs[6];
1671
        abi_ulong xxargs[1];
1672
};
1673

    
1674
typedef struct {
1675
        struct {
1676
                abi_ulong psr;
1677
                abi_ulong pc;
1678
                abi_ulong npc;
1679
                abi_ulong y;
1680
                abi_ulong u_regs[16]; /* globals and ins */
1681
        }               si_regs;
1682
        int             si_mask;
1683
} __siginfo_t;
1684

    
1685
typedef struct {
1686
        unsigned   long si_float_regs [32];
1687
        unsigned   long si_fsr;
1688
        unsigned   long si_fpqdepth;
1689
        struct {
1690
                unsigned long *insn_addr;
1691
                unsigned long insn;
1692
        } si_fpqueue [16];
1693
} qemu_siginfo_fpu_t;
1694

    
1695

    
1696
struct target_signal_frame {
1697
        struct sparc_stackf        ss;
1698
        __siginfo_t                info;
1699
        abi_ulong               fpu_save;
1700
        abi_ulong                insns[2] __attribute__ ((aligned (8)));
1701
        abi_ulong                extramask[TARGET_NSIG_WORDS - 1];
1702
        abi_ulong                extra_size; /* Should be 0 */
1703
        qemu_siginfo_fpu_t        fpu_state;
1704
};
1705
struct target_rt_signal_frame {
1706
        struct sparc_stackf        ss;
1707
        siginfo_t                info;
1708
        abi_ulong                regs[20];
1709
        sigset_t                mask;
1710
        abi_ulong               fpu_save;
1711
        unsigned int                insns[2];
1712
        stack_t                        stack;
1713
        unsigned int                extra_size; /* Should be 0 */
1714
        qemu_siginfo_fpu_t        fpu_state;
1715
};
1716

    
1717
#define UREG_O0        16
1718
#define UREG_O6        22
1719
#define UREG_I0        0
1720
#define UREG_I1        1
1721
#define UREG_I2        2
1722
#define UREG_I3        3
1723
#define UREG_I4        4
1724
#define UREG_I5        5
1725
#define UREG_I6        6
1726
#define UREG_I7        7
1727
#define UREG_L0               8
1728
#define UREG_FP        UREG_I6
1729
#define UREG_SP        UREG_O6
1730

    
1731
static inline abi_ulong get_sigframe(struct target_sigaction *sa, 
1732
                                     CPUState *env, unsigned long framesize)
1733
{
1734
        abi_ulong sp;
1735

    
1736
        sp = env->regwptr[UREG_FP];
1737

    
1738
        /* This is the X/Open sanctioned signal stack switching.  */
1739
        if (sa->sa_flags & TARGET_SA_ONSTACK) {
1740
            if (!on_sig_stack(sp)
1741
                && !((target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size) & 7))
1742
                sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
1743
        }
1744
        return sp - framesize;
1745
}
1746

    
1747
static int
1748
setup___siginfo(__siginfo_t *si, CPUState *env, abi_ulong mask)
1749
{
1750
        int err = 0, i;
1751

    
1752
        err |= __put_user(env->psr, &si->si_regs.psr);
1753
        err |= __put_user(env->pc, &si->si_regs.pc);
1754
        err |= __put_user(env->npc, &si->si_regs.npc);
1755
        err |= __put_user(env->y, &si->si_regs.y);
1756
        for (i=0; i < 8; i++) {
1757
                err |= __put_user(env->gregs[i], &si->si_regs.u_regs[i]);
1758
        }
1759
        for (i=0; i < 8; i++) {
1760
                err |= __put_user(env->regwptr[UREG_I0 + i], &si->si_regs.u_regs[i+8]);
1761
        }
1762
        err |= __put_user(mask, &si->si_mask);
1763
        return err;
1764
}
1765

    
1766
#if 0
1767
static int
1768
setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/
1769
                 CPUState *env, unsigned long mask)
1770
{
1771
        int err = 0;
1772

1773
        err |= __put_user(mask, &sc->sigc_mask);
1774
        err |= __put_user(env->regwptr[UREG_SP], &sc->sigc_sp);
1775
        err |= __put_user(env->pc, &sc->sigc_pc);
1776
        err |= __put_user(env->npc, &sc->sigc_npc);
1777
        err |= __put_user(env->psr, &sc->sigc_psr);
1778
        err |= __put_user(env->gregs[1], &sc->sigc_g1);
1779
        err |= __put_user(env->regwptr[UREG_O0], &sc->sigc_o0);
1780

1781
        return err;
1782
}
1783
#endif
1784
#define NF_ALIGNEDSZ  (((sizeof(struct target_signal_frame) + 7) & (~7)))
1785

    
1786
static void setup_frame(int sig, struct target_sigaction *ka,
1787
                        target_sigset_t *set, CPUState *env)
1788
{
1789
        abi_ulong sf_addr;
1790
        struct target_signal_frame *sf;
1791
        int sigframe_size, err, i;
1792

    
1793
        /* 1. Make sure everything is clean */
1794
        //synchronize_user_stack();
1795

    
1796
        sigframe_size = NF_ALIGNEDSZ;
1797
        sf_addr = get_sigframe(ka, env, sigframe_size);
1798

    
1799
        sf = lock_user(VERIFY_WRITE, sf_addr, 
1800
                       sizeof(struct target_signal_frame), 0);
1801
        if (!sf)
1802
                goto sigsegv;
1803
                
1804
        //fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1805
#if 0
1806
        if (invalid_frame_pointer(sf, sigframe_size))
1807
                goto sigill_and_return;
1808
#endif
1809
        /* 2. Save the current process state */
1810
        err = setup___siginfo(&sf->info, env, set->sig[0]);
1811
        err |= __put_user(0, &sf->extra_size);
1812

    
1813
        //err |= save_fpu_state(regs, &sf->fpu_state);
1814
        //err |= __put_user(&sf->fpu_state, &sf->fpu_save);
1815

    
1816
        err |= __put_user(set->sig[0], &sf->info.si_mask);
1817
        for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
1818
                err |= __put_user(set->sig[i + 1], &sf->extramask[i]);
1819
        }
1820

    
1821
        for (i = 0; i < 8; i++) {
1822
                  err |= __put_user(env->regwptr[i + UREG_L0], &sf->ss.locals[i]);
1823
        }
1824
        for (i = 0; i < 8; i++) {
1825
                  err |= __put_user(env->regwptr[i + UREG_I0], &sf->ss.ins[i]);
1826
        }
1827
        if (err)
1828
                goto sigsegv;
1829

    
1830
        /* 3. signal handler back-trampoline and parameters */
1831
        env->regwptr[UREG_FP] = sf_addr;
1832
        env->regwptr[UREG_I0] = sig;
1833
        env->regwptr[UREG_I1] = sf_addr + 
1834
                offsetof(struct target_signal_frame, info);
1835
        env->regwptr[UREG_I2] = sf_addr + 
1836
                offsetof(struct target_signal_frame, info);
1837

    
1838
        /* 4. signal handler */
1839
        env->pc = ka->_sa_handler;
1840
        env->npc = (env->pc + 4);
1841
        /* 5. return to kernel instructions */
1842
        if (ka->sa_restorer)
1843
                env->regwptr[UREG_I7] = ka->sa_restorer;
1844
        else {
1845
                uint32_t val32;
1846

    
1847
                env->regwptr[UREG_I7] = sf_addr + 
1848
                        offsetof(struct target_signal_frame, insns) - 2 * 4;
1849

    
1850
                /* mov __NR_sigreturn, %g1 */
1851
                val32 = 0x821020d8;
1852
                err |= __put_user(val32, &sf->insns[0]);
1853

    
1854
                /* t 0x10 */
1855
                val32 = 0x91d02010;
1856
                err |= __put_user(val32, &sf->insns[1]);
1857
                if (err)
1858
                        goto sigsegv;
1859

    
1860
                /* Flush instruction space. */
1861
                //flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0]));
1862
                //                tb_flush(env);
1863
        }
1864
        unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
1865
        return;
1866
#if 0
1867
sigill_and_return:
1868
        force_sig(TARGET_SIGILL);
1869
#endif
1870
sigsegv:
1871
        //fprintf(stderr, "force_sig\n");
1872
        unlock_user(sf, sf_addr, sizeof(struct target_signal_frame));
1873
        force_sig(TARGET_SIGSEGV);
1874
}
1875
static inline int
1876
restore_fpu_state(CPUState *env, qemu_siginfo_fpu_t *fpu)
1877
{
1878
        int err;
1879
#if 0
1880
#ifdef CONFIG_SMP
1881
        if (current->flags & PF_USEDFPU)
1882
                regs->psr &= ~PSR_EF;
1883
#else
1884
        if (current == last_task_used_math) {
1885
                last_task_used_math = 0;
1886
                regs->psr &= ~PSR_EF;
1887
        }
1888
#endif
1889
        current->used_math = 1;
1890
        current->flags &= ~PF_USEDFPU;
1891
#endif
1892
#if 0
1893
        if (verify_area (VERIFY_READ, fpu, sizeof(*fpu)))
1894
                return -EFAULT;
1895
#endif
1896

    
1897
#if 0
1898
        /* XXX: incorrect */
1899
        err = __copy_from_user(&env->fpr[0], &fpu->si_float_regs[0],
1900
                                     (sizeof(unsigned long) * 32));
1901
#endif
1902
        err |= __get_user(env->fsr, &fpu->si_fsr);
1903
#if 0
1904
        err |= __get_user(current->thread.fpqdepth, &fpu->si_fpqdepth);
1905
        if (current->thread.fpqdepth != 0)
1906
                err |= __copy_from_user(&current->thread.fpqueue[0],
1907
                                        &fpu->si_fpqueue[0],
1908
                                        ((sizeof(unsigned long) +
1909
                                        (sizeof(unsigned long *)))*16));
1910
#endif
1911
        return err;
1912
}
1913

    
1914

    
1915
static void setup_rt_frame(int sig, struct target_sigaction *ka,
1916
                           target_siginfo_t *info,
1917
                           target_sigset_t *set, CPUState *env)
1918
{
1919
    fprintf(stderr, "setup_rt_frame: not implemented\n");
1920
}
1921

    
1922
long do_sigreturn(CPUState *env)
1923
{
1924
        abi_ulong sf_addr;
1925
        struct target_signal_frame *sf;
1926
        uint32_t up_psr, pc, npc;
1927
        target_sigset_t set;
1928
        sigset_t host_set;
1929
        abi_ulong fpu_save_addr;
1930
        int err, i;
1931

    
1932
        sf_addr = env->regwptr[UREG_FP];
1933
        if (!lock_user_struct(VERIFY_READ, sf, sf_addr, 1))
1934
                goto segv_and_exit;
1935
#if 0
1936
        fprintf(stderr, "sigreturn\n");
1937
        fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1938
#endif
1939
        //cpu_dump_state(env, stderr, fprintf, 0);
1940

    
1941
        /* 1. Make sure we are not getting garbage from the user */
1942

    
1943
        if (sf_addr & 3)
1944
                goto segv_and_exit;
1945

    
1946
        err = __get_user(pc,  &sf->info.si_regs.pc);
1947
        err |= __get_user(npc, &sf->info.si_regs.npc);
1948

    
1949
        if ((pc | npc) & 3)
1950
                goto segv_and_exit;
1951

    
1952
        /* 2. Restore the state */
1953
        err |= __get_user(up_psr, &sf->info.si_regs.psr);
1954

    
1955
        /* User can only change condition codes and FPU enabling in %psr. */
1956
        env->psr = (up_psr & (PSR_ICC /* | PSR_EF */))
1957
                  | (env->psr & ~(PSR_ICC /* | PSR_EF */));
1958

    
1959
        env->pc = pc;
1960
        env->npc = npc;
1961
        err |= __get_user(env->y, &sf->info.si_regs.y);
1962
        for (i=0; i < 8; i++) {
1963
                err |= __get_user(env->gregs[i], &sf->info.si_regs.u_regs[i]);
1964
        }
1965
        for (i=0; i < 8; i++) {
1966
                err |= __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]);
1967
        }
1968

    
1969
        err |= __get_user(fpu_save_addr, &sf->fpu_save);
1970

    
1971
        //if (fpu_save)
1972
        //        err |= restore_fpu_state(env, fpu_save);
1973

    
1974
        /* This is pretty much atomic, no amount locking would prevent
1975
         * the races which exist anyways.
1976
         */
1977
        err |= __get_user(set.sig[0], &sf->info.si_mask);
1978
        for(i = 1; i < TARGET_NSIG_WORDS; i++) {
1979
            err |= (__get_user(set.sig[i], &sf->extramask[i - 1]));
1980
        }
1981

    
1982
        target_to_host_sigset_internal(&host_set, &set);
1983
        sigprocmask(SIG_SETMASK, &host_set, NULL);
1984

    
1985
        if (err)
1986
                goto segv_and_exit;
1987
        unlock_user_struct(sf, sf_addr, 0);
1988
        return env->regwptr[0];
1989

    
1990
segv_and_exit:
1991
        unlock_user_struct(sf, sf_addr, 0);
1992
        force_sig(TARGET_SIGSEGV);
1993
}
1994

    
1995
long do_rt_sigreturn(CPUState *env)
1996
{
1997
    fprintf(stderr, "do_rt_sigreturn: not implemented\n");
1998
    return -TARGET_ENOSYS;
1999
}
2000

    
2001
#if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
2002
#define MC_TSTATE 0
2003
#define MC_PC 1
2004
#define MC_NPC 2
2005
#define MC_Y 3
2006
#define MC_G1 4
2007
#define MC_G2 5
2008
#define MC_G3 6
2009
#define MC_G4 7
2010
#define MC_G5 8
2011
#define MC_G6 9
2012
#define MC_G7 10
2013
#define MC_O0 11
2014
#define MC_O1 12
2015
#define MC_O2 13
2016
#define MC_O3 14
2017
#define MC_O4 15
2018
#define MC_O5 16
2019
#define MC_O6 17
2020
#define MC_O7 18
2021
#define MC_NGREG 19
2022

    
2023
typedef abi_ulong target_mc_greg_t;
2024
typedef target_mc_greg_t target_mc_gregset_t[MC_NGREG];
2025

    
2026
struct target_mc_fq {
2027
    abi_ulong *mcfq_addr;
2028
    uint32_t mcfq_insn;
2029
};
2030

    
2031
struct target_mc_fpu {
2032
    union {
2033
        uint32_t sregs[32];
2034
        uint64_t dregs[32];
2035
        //uint128_t qregs[16];
2036
    } mcfpu_fregs;
2037
    abi_ulong mcfpu_fsr;
2038
    abi_ulong mcfpu_fprs;
2039
    abi_ulong mcfpu_gsr;
2040
    struct target_mc_fq *mcfpu_fq;
2041
    unsigned char mcfpu_qcnt;
2042
    unsigned char mcfpu_qentsz;
2043
    unsigned char mcfpu_enab;
2044
};
2045
typedef struct target_mc_fpu target_mc_fpu_t;
2046

    
2047
typedef struct {
2048
    target_mc_gregset_t mc_gregs;
2049
    target_mc_greg_t mc_fp;
2050
    target_mc_greg_t mc_i7;
2051
    target_mc_fpu_t mc_fpregs;
2052
} target_mcontext_t;
2053

    
2054
struct target_ucontext {
2055
    struct target_ucontext *tuc_link;
2056
    abi_ulong tuc_flags;
2057
    target_sigset_t tuc_sigmask;
2058
    target_mcontext_t tuc_mcontext;
2059
};
2060

    
2061
/* A V9 register window */
2062
struct target_reg_window {
2063
    abi_ulong locals[8];
2064
    abi_ulong ins[8];
2065
};
2066

    
2067
#define TARGET_STACK_BIAS 2047
2068

    
2069
/* {set, get}context() needed for 64-bit SparcLinux userland. */
2070
void sparc64_set_context(CPUSPARCState *env)
2071
{
2072
    abi_ulong ucp_addr;
2073
    struct target_ucontext *ucp;
2074
    target_mc_gregset_t *grp;
2075
    abi_ulong pc, npc, tstate;
2076
    abi_ulong fp, i7, w_addr;
2077
    unsigned char fenab;
2078
    int err;
2079
    unsigned int i;
2080

    
2081
    ucp_addr = env->regwptr[UREG_I0];
2082
    if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1))
2083
        goto do_sigsegv;
2084
    grp  = &ucp->tuc_mcontext.mc_gregs;
2085
    err  = __get_user(pc, &((*grp)[MC_PC]));
2086
    err |= __get_user(npc, &((*grp)[MC_NPC]));
2087
    if (err || ((pc | npc) & 3))
2088
        goto do_sigsegv;
2089
    if (env->regwptr[UREG_I1]) {
2090
        target_sigset_t target_set;
2091
        sigset_t set;
2092

    
2093
        if (TARGET_NSIG_WORDS == 1) {
2094
            if (__get_user(target_set.sig[0], &ucp->tuc_sigmask.sig[0]))
2095
                goto do_sigsegv;
2096
        } else {
2097
            abi_ulong *src, *dst;
2098
            src = ucp->tuc_sigmask.sig;
2099
            dst = target_set.sig;
2100
            for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong);
2101
                 i++, dst++, src++)
2102
                err |= __get_user(*dst, src);
2103
            if (err)
2104
                goto do_sigsegv;
2105
        }
2106
        target_to_host_sigset_internal(&set, &target_set);
2107
        sigprocmask(SIG_SETMASK, &set, NULL);
2108
    }
2109
    env->pc = pc;
2110
    env->npc = npc;
2111
    err |= __get_user(env->y, &((*grp)[MC_Y]));
2112
    err |= __get_user(tstate, &((*grp)[MC_TSTATE]));
2113
    env->asi = (tstate >> 24) & 0xff;
2114
    cpu_put_ccr(env, tstate >> 32);
2115
    cpu_put_cwp64(env, tstate & 0x1f);
2116
    err |= __get_user(env->gregs[1], (&(*grp)[MC_G1]));
2117
    err |= __get_user(env->gregs[2], (&(*grp)[MC_G2]));
2118
    err |= __get_user(env->gregs[3], (&(*grp)[MC_G3]));
2119
    err |= __get_user(env->gregs[4], (&(*grp)[MC_G4]));
2120
    err |= __get_user(env->gregs[5], (&(*grp)[MC_G5]));
2121
    err |= __get_user(env->gregs[6], (&(*grp)[MC_G6]));
2122
    err |= __get_user(env->gregs[7], (&(*grp)[MC_G7]));
2123
    err |= __get_user(env->regwptr[UREG_I0], (&(*grp)[MC_O0]));
2124
    err |= __get_user(env->regwptr[UREG_I1], (&(*grp)[MC_O1]));
2125
    err |= __get_user(env->regwptr[UREG_I2], (&(*grp)[MC_O2]));
2126
    err |= __get_user(env->regwptr[UREG_I3], (&(*grp)[MC_O3]));
2127
    err |= __get_user(env->regwptr[UREG_I4], (&(*grp)[MC_O4]));
2128
    err |= __get_user(env->regwptr[UREG_I5], (&(*grp)[MC_O5]));
2129
    err |= __get_user(env->regwptr[UREG_I6], (&(*grp)[MC_O6]));
2130
    err |= __get_user(env->regwptr[UREG_I7], (&(*grp)[MC_O7]));
2131

    
2132
    err |= __get_user(fp, &(ucp->tuc_mcontext.mc_fp));
2133
    err |= __get_user(i7, &(ucp->tuc_mcontext.mc_i7));
2134

    
2135
    w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2136
    if (put_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]), 
2137
                 abi_ulong) != 0)
2138
        goto do_sigsegv;
2139
    if (put_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]), 
2140
                 abi_ulong) != 0)
2141
        goto do_sigsegv;
2142
    err |= __get_user(fenab, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_enab));
2143
    err |= __get_user(env->fprs, &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fprs));
2144
    {
2145
        uint32_t *src, *dst;
2146
        src = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2147
        dst = env->fpr;
2148
        /* XXX: check that the CPU storage is the same as user context */
2149
        for (i = 0; i < 64; i++, dst++, src++)
2150
            err |= __get_user(*dst, src);
2151
    }
2152
    err |= __get_user(env->fsr,
2153
                      &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fsr));
2154
    err |= __get_user(env->gsr,
2155
                      &(ucp->tuc_mcontext.mc_fpregs.mcfpu_gsr));
2156
    if (err)
2157
        goto do_sigsegv;
2158
    unlock_user_struct(ucp, ucp_addr, 0);
2159
    return;
2160
 do_sigsegv:
2161
    unlock_user_struct(ucp, ucp_addr, 0);
2162
    force_sig(TARGET_SIGSEGV);
2163
}
2164

    
2165
void sparc64_get_context(CPUSPARCState *env)
2166
{
2167
    abi_ulong ucp_addr;
2168
    struct target_ucontext *ucp;
2169
    target_mc_gregset_t *grp;
2170
    target_mcontext_t *mcp;
2171
    abi_ulong fp, i7, w_addr;
2172
    int err;
2173
    unsigned int i;
2174
    target_sigset_t target_set;
2175
    sigset_t set;
2176

    
2177
    ucp_addr = env->regwptr[UREG_I0];
2178
    if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0))
2179
        goto do_sigsegv;
2180
    
2181
    mcp = &ucp->tuc_mcontext;
2182
    grp = &mcp->mc_gregs;
2183

    
2184
    /* Skip over the trap instruction, first. */
2185
    env->pc = env->npc;
2186
    env->npc += 4;
2187

    
2188
    err = 0;
2189

    
2190
    sigprocmask(0, NULL, &set);
2191
    host_to_target_sigset_internal(&target_set, &set);
2192
    if (TARGET_NSIG_WORDS == 1) {
2193
        err |= __put_user(target_set.sig[0],
2194
                          (abi_ulong *)&ucp->tuc_sigmask);
2195
    } else {
2196
        abi_ulong *src, *dst;
2197
        src = target_set.sig;
2198
        dst = ucp->tuc_sigmask.sig;
2199
        for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong);
2200
             i++, dst++, src++)
2201
            err |= __put_user(*src, dst);
2202
        if (err)
2203
            goto do_sigsegv;
2204
    }
2205

    
2206
    /* XXX: tstate must be saved properly */
2207
    //    err |= __put_user(env->tstate, &((*grp)[MC_TSTATE]));
2208
    err |= __put_user(env->pc, &((*grp)[MC_PC]));
2209
    err |= __put_user(env->npc, &((*grp)[MC_NPC]));
2210
    err |= __put_user(env->y, &((*grp)[MC_Y]));
2211
    err |= __put_user(env->gregs[1], &((*grp)[MC_G1]));
2212
    err |= __put_user(env->gregs[2], &((*grp)[MC_G2]));
2213
    err |= __put_user(env->gregs[3], &((*grp)[MC_G3]));
2214
    err |= __put_user(env->gregs[4], &((*grp)[MC_G4]));
2215
    err |= __put_user(env->gregs[5], &((*grp)[MC_G5]));
2216
    err |= __put_user(env->gregs[6], &((*grp)[MC_G6]));
2217
    err |= __put_user(env->gregs[7], &((*grp)[MC_G7]));
2218
    err |= __put_user(env->regwptr[UREG_I0], &((*grp)[MC_O0]));
2219
    err |= __put_user(env->regwptr[UREG_I1], &((*grp)[MC_O1]));
2220
    err |= __put_user(env->regwptr[UREG_I2], &((*grp)[MC_O2]));
2221
    err |= __put_user(env->regwptr[UREG_I3], &((*grp)[MC_O3]));
2222
    err |= __put_user(env->regwptr[UREG_I4], &((*grp)[MC_O4]));
2223
    err |= __put_user(env->regwptr[UREG_I5], &((*grp)[MC_O5]));
2224
    err |= __put_user(env->regwptr[UREG_I6], &((*grp)[MC_O6]));
2225
    err |= __put_user(env->regwptr[UREG_I7], &((*grp)[MC_O7]));
2226

    
2227
    w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2228
    fp = i7 = 0;
2229
    if (get_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]), 
2230
                 abi_ulong) != 0)
2231
        goto do_sigsegv;
2232
    if (get_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]), 
2233
                 abi_ulong) != 0)
2234
        goto do_sigsegv;
2235
    err |= __put_user(fp, &(mcp->mc_fp));
2236
    err |= __put_user(i7, &(mcp->mc_i7));
2237

    
2238
    {
2239
        uint32_t *src, *dst;
2240
        src = env->fpr;
2241
        dst = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2242
        /* XXX: check that the CPU storage is the same as user context */
2243
        for (i = 0; i < 64; i++, dst++, src++)
2244
            err |= __put_user(*src, dst);
2245
    }
2246
    err |= __put_user(env->fsr, &(mcp->mc_fpregs.mcfpu_fsr));
2247
    err |= __put_user(env->gsr, &(mcp->mc_fpregs.mcfpu_gsr));
2248
    err |= __put_user(env->fprs, &(mcp->mc_fpregs.mcfpu_fprs));
2249

    
2250
    if (err)
2251
        goto do_sigsegv;
2252
    unlock_user_struct(ucp, ucp_addr, 1);
2253
    return;
2254
 do_sigsegv:
2255
    unlock_user_struct(ucp, ucp_addr, 1);
2256
    force_sig(TARGET_SIGSEGV);
2257
}
2258
#endif
2259
#elif defined(TARGET_ABI_MIPSN64)
2260

    
2261
# warning signal handling not implemented
2262

    
2263
static void setup_frame(int sig, struct target_sigaction *ka,
2264
                        target_sigset_t *set, CPUState *env)
2265
{
2266
    fprintf(stderr, "setup_frame: not implemented\n");
2267
}
2268

    
2269
static void setup_rt_frame(int sig, struct target_sigaction *ka,
2270
                           target_siginfo_t *info,
2271
                           target_sigset_t *set, CPUState *env)
2272
{
2273
    fprintf(stderr, "setup_rt_frame: not implemented\n");
2274
}
2275

    
2276
long do_sigreturn(CPUState *env)
2277
{
2278
    fprintf(stderr, "do_sigreturn: not implemented\n");
2279
    return -TARGET_ENOSYS;
2280
}
2281

    
2282
long do_rt_sigreturn(CPUState *env)
2283
{
2284
    fprintf(stderr, "do_rt_sigreturn: not implemented\n");
2285
    return -TARGET_ENOSYS;
2286
}
2287

    
2288
#elif defined(TARGET_ABI_MIPSN32)
2289

    
2290
# warning signal handling not implemented
2291

    
2292
static void setup_frame(int sig, struct target_sigaction *ka,
2293
                        target_sigset_t *set, CPUState *env)
2294
{
2295
    fprintf(stderr, "setup_frame: not implemented\n");
2296
}
2297

    
2298
static void setup_rt_frame(int sig, struct target_sigaction *ka,
2299
                           target_siginfo_t *info,
2300
                           target_sigset_t *set, CPUState *env)
2301
{
2302
    fprintf(stderr, "setup_rt_frame: not implemented\n");
2303
}
2304

    
2305
long do_sigreturn(CPUState *env)
2306
{
2307
    fprintf(stderr, "do_sigreturn: not implemented\n");
2308
    return -TARGET_ENOSYS;
2309
}
2310

    
2311
long do_rt_sigreturn(CPUState *env)
2312
{
2313
    fprintf(stderr, "do_rt_sigreturn: not implemented\n");
2314
    return -TARGET_ENOSYS;
2315
}
2316

    
2317
#elif defined(TARGET_ABI_MIPSO32)
2318

    
2319
struct target_sigcontext {
2320
    uint32_t   sc_regmask;     /* Unused */
2321
    uint32_t   sc_status;
2322
    uint64_t   sc_pc;
2323
    uint64_t   sc_regs[32];
2324
    uint64_t   sc_fpregs[32];
2325
    uint32_t   sc_ownedfp;     /* Unused */
2326
    uint32_t   sc_fpc_csr;
2327
    uint32_t   sc_fpc_eir;     /* Unused */
2328
    uint32_t   sc_used_math;
2329
    uint32_t   sc_dsp;         /* dsp status, was sc_ssflags */
2330
    uint32_t   pad0;
2331
    uint64_t   sc_mdhi;
2332
    uint64_t   sc_mdlo;
2333
    target_ulong   sc_hi1;         /* Was sc_cause */
2334
    target_ulong   sc_lo1;         /* Was sc_badvaddr */
2335
    target_ulong   sc_hi2;         /* Was sc_sigset[4] */
2336
    target_ulong   sc_lo2;
2337
    target_ulong   sc_hi3;
2338
    target_ulong   sc_lo3;
2339
};
2340

    
2341
struct sigframe {
2342
    uint32_t sf_ass[4];                        /* argument save space for o32 */
2343
    uint32_t sf_code[2];                        /* signal trampoline */
2344
    struct target_sigcontext sf_sc;
2345
    target_sigset_t sf_mask;
2346
};
2347

    
2348
struct target_ucontext {
2349
    target_ulong tuc_flags;
2350
    target_ulong tuc_link;
2351
    target_stack_t tuc_stack;
2352
    target_ulong pad0;
2353
    struct target_sigcontext tuc_mcontext;
2354
    target_sigset_t tuc_sigmask;
2355
};
2356

    
2357
struct target_rt_sigframe {
2358
    uint32_t rs_ass[4];               /* argument save space for o32 */
2359
    uint32_t rs_code[2];              /* signal trampoline */
2360
    struct target_siginfo rs_info;
2361
    struct target_ucontext rs_uc;
2362
};
2363

    
2364
/* Install trampoline to jump back from signal handler */
2365
static inline int install_sigtramp(unsigned int *tramp,   unsigned int syscall)
2366
{
2367
    int err;
2368

    
2369
    /*
2370
    * Set up the return code ...
2371
    *
2372
    *         li      v0, __NR__foo_sigreturn
2373
    *         syscall
2374
    */
2375

    
2376
    err = __put_user(0x24020000 + syscall, tramp + 0);
2377
    err |= __put_user(0x0000000c          , tramp + 1);
2378
    /* flush_cache_sigtramp((unsigned long) tramp); */
2379
    return err;
2380
}
2381

    
2382
static inline int
2383
setup_sigcontext(CPUState *regs, struct target_sigcontext *sc)
2384
{
2385
    int err = 0;
2386

    
2387
    err |= __put_user(regs->active_tc.PC, &sc->sc_pc);
2388

    
2389
#define save_gp_reg(i) do {                                                   \
2390
        err |= __put_user(regs->active_tc.gpr[i], &sc->sc_regs[i]);        \
2391
    } while(0)
2392
    __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
2393
    save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
2394
    save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
2395
    save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
2396
    save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
2397
    save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
2398
    save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
2399
    save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
2400
    save_gp_reg(31);
2401
#undef save_gp_reg
2402

    
2403
    err |= __put_user(regs->active_tc.HI[0], &sc->sc_mdhi);
2404
    err |= __put_user(regs->active_tc.LO[0], &sc->sc_mdlo);
2405

    
2406
    /* Not used yet, but might be useful if we ever have DSP suppport */
2407
#if 0
2408
    if (cpu_has_dsp) {
2409
        err |= __put_user(mfhi1(), &sc->sc_hi1);
2410
        err |= __put_user(mflo1(), &sc->sc_lo1);
2411
        err |= __put_user(mfhi2(), &sc->sc_hi2);
2412
        err |= __put_user(mflo2(), &sc->sc_lo2);
2413
        err |= __put_user(mfhi3(), &sc->sc_hi3);
2414
        err |= __put_user(mflo3(), &sc->sc_lo3);
2415
        err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
2416
    }
2417
    /* same with 64 bit */
2418
#ifdef CONFIG_64BIT
2419
    err |= __put_user(regs->hi, &sc->sc_hi[0]);
2420
    err |= __put_user(regs->lo, &sc->sc_lo[0]);
2421
    if (cpu_has_dsp) {
2422
        err |= __put_user(mfhi1(), &sc->sc_hi[1]);
2423
        err |= __put_user(mflo1(), &sc->sc_lo[1]);
2424
        err |= __put_user(mfhi2(), &sc->sc_hi[2]);
2425
        err |= __put_user(mflo2(), &sc->sc_lo[2]);
2426
        err |= __put_user(mfhi3(), &sc->sc_hi[3]);
2427
        err |= __put_user(mflo3(), &sc->sc_lo[3]);
2428
        err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
2429
    }
2430
#endif
2431
#endif
2432

    
2433
#if 0
2434
    err |= __put_user(!!used_math(), &sc->sc_used_math);
2435

2436
    if (!used_math())
2437
        goto out;
2438

2439
    /*
2440
    * Save FPU state to signal context.  Signal handler will "inherit"
2441
    * current FPU state.
2442
    */
2443
    preempt_disable();
2444

2445
    if (!is_fpu_owner()) {
2446
        own_fpu();
2447
        restore_fp(current);
2448
    }
2449
    err |= save_fp_context(sc);
2450

2451
    preempt_enable();
2452
    out:
2453
#endif
2454
    return err;
2455
}
2456

    
2457
static inline int
2458
restore_sigcontext(CPUState *regs, struct target_sigcontext *sc)
2459
{
2460
    int err = 0;
2461

    
2462
    err |= __get_user(regs->CP0_EPC, &sc->sc_pc);
2463

    
2464
    err |= __get_user(regs->active_tc.HI[0], &sc->sc_mdhi);
2465
    err |= __get_user(regs->active_tc.LO[0], &sc->sc_mdlo);
2466

    
2467
#define restore_gp_reg(i) do {                                                           \
2468
        err |= __get_user(regs->active_tc.gpr[i], &sc->sc_regs[i]);                \
2469
    } while(0)
2470
    restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
2471
    restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
2472
    restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
2473
    restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
2474
    restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
2475
    restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
2476
    restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
2477
    restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
2478
    restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
2479
    restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
2480
    restore_gp_reg(31);
2481
#undef restore_gp_reg
2482

    
2483
#if 0
2484
    if (cpu_has_dsp) {
2485
        err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
2486
        err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
2487
        err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
2488
        err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
2489
        err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
2490
        err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
2491
        err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
2492
    }
2493
#ifdef CONFIG_64BIT
2494
    err |= __get_user(regs->hi, &sc->sc_hi[0]);
2495
    err |= __get_user(regs->lo, &sc->sc_lo[0]);
2496
    if (cpu_has_dsp) {
2497
        err |= __get_user(treg, &sc->sc_hi[1]); mthi1(treg);
2498
        err |= __get_user(treg, &sc->sc_lo[1]); mthi1(treg);
2499
        err |= __get_user(treg, &sc->sc_hi[2]); mthi2(treg);
2500
        err |= __get_user(treg, &sc->sc_lo[2]); mthi2(treg);
2501
        err |= __get_user(treg, &sc->sc_hi[3]); mthi3(treg);
2502
        err |= __get_user(treg, &sc->sc_lo[3]); mthi3(treg);
2503
        err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
2504
    }
2505
#endif
2506

    
2507
    err |= __get_user(used_math, &sc->sc_used_math);
2508
    conditional_used_math(used_math);
2509

    
2510
    preempt_disable();
2511

    
2512
    if (used_math()) {
2513
        /* restore fpu context if we have used it before */
2514
        own_fpu();
2515
        err |= restore_fp_context(sc);
2516
    } else {
2517
        /* signal handler may have used FPU.  Give it up. */
2518
        lose_fpu();
2519
    }
2520

    
2521
    preempt_enable();
2522
#endif
2523
    return err;
2524
}
2525
/*
2526
 * Determine which stack to use..
2527
 */
2528
static inline abi_ulong
2529
get_sigframe(struct target_sigaction *ka, CPUState *regs, size_t frame_size)
2530
{
2531
    unsigned long sp;
2532

    
2533
    /* Default to using normal stack */
2534
    sp = regs->active_tc.gpr[29];
2535

    
2536
    /*
2537
     * FPU emulator may have it's own trampoline active just
2538
     * above the user stack, 16-bytes before the next lowest
2539
     * 16 byte boundary.  Try to avoid trashing it.
2540
     */
2541
    sp -= 32;
2542

    
2543
    /* This is the X/Open sanctioned signal stack switching.  */
2544
    if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
2545
        sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
2546
    }
2547

    
2548
    return (sp - frame_size) & ~7;
2549
}
2550

    
2551
/* compare linux/arch/mips/kernel/signal.c:setup_frame() */
2552
static void setup_frame(int sig, struct target_sigaction * ka,
2553
                        target_sigset_t *set, CPUState *regs)
2554
{
2555
    struct sigframe *frame;
2556
    abi_ulong frame_addr;
2557
    int i;
2558

    
2559
    frame_addr = get_sigframe(ka, regs, sizeof(*frame));
2560
    if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
2561
        goto give_sigsegv;
2562

    
2563
    install_sigtramp(frame->sf_code, TARGET_NR_sigreturn);
2564

    
2565
    if(setup_sigcontext(regs, &frame->sf_sc))
2566
        goto give_sigsegv;
2567

    
2568
    for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2569
        if(__put_user(set->sig[i], &frame->sf_mask.sig[i]))
2570
            goto give_sigsegv;
2571
    }
2572

    
2573
    /*
2574
    * Arguments to signal handler:
2575
    *
2576
    *   a0 = signal number
2577
    *   a1 = 0 (should be cause)
2578
    *   a2 = pointer to struct sigcontext
2579
    *
2580
    * $25 and PC point to the signal handler, $29 points to the
2581
    * struct sigframe.
2582
    */
2583
    regs->active_tc.gpr[ 4] = sig;
2584
    regs->active_tc.gpr[ 5] = 0;
2585
    regs->active_tc.gpr[ 6] = frame_addr + offsetof(struct sigframe, sf_sc);
2586
    regs->active_tc.gpr[29] = frame_addr;
2587
    regs->active_tc.gpr[31] = frame_addr + offsetof(struct sigframe, sf_code);
2588
    /* The original kernel code sets CP0_EPC to the handler
2589
    * since it returns to userland using eret
2590
    * we cannot do this here, and we must set PC directly */
2591
    regs->active_tc.PC = regs->active_tc.gpr[25] = ka->_sa_handler;
2592
    unlock_user_struct(frame, frame_addr, 1);
2593
    return;
2594

    
2595
give_sigsegv:
2596
    unlock_user_struct(frame, frame_addr, 1);
2597
    force_sig(TARGET_SIGSEGV/*, current*/);
2598
    return;
2599
}
2600

    
2601
long do_sigreturn(CPUState *regs)
2602
{
2603
    struct sigframe *frame;
2604
    abi_ulong frame_addr;
2605
    sigset_t blocked;
2606
    target_sigset_t target_set;
2607
    int i;
2608

    
2609
#if defined(DEBUG_SIGNAL)
2610
    fprintf(stderr, "do_sigreturn\n");
2611
#endif
2612
    frame_addr = regs->active_tc.gpr[29];
2613
    if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2614
           goto badframe;
2615

    
2616
    for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2617
           if(__get_user(target_set.sig[i], &frame->sf_mask.sig[i]))
2618
            goto badframe;
2619
    }
2620

    
2621
    target_to_host_sigset_internal(&blocked, &target_set);
2622
    sigprocmask(SIG_SETMASK, &blocked, NULL);
2623

    
2624
    if (restore_sigcontext(regs, &frame->sf_sc))
2625
           goto badframe;
2626

    
2627
#if 0
2628
    /*
2629
     * Don't let your children do this ...
2630
     */
2631
    __asm__ __volatile__(
2632
           "move\t$29, %0\n\t"
2633
           "j\tsyscall_exit"
2634
           :/* no outputs */
2635
           :"r" (&regs));
2636
    /* Unreached */
2637
#endif
2638

    
2639
    regs->active_tc.PC = regs->CP0_EPC;
2640
    /* I am not sure this is right, but it seems to work
2641
    * maybe a problem with nested signals ? */
2642
    regs->CP0_EPC = 0;
2643
    return -TARGET_QEMU_ESIGRETURN;
2644

    
2645
badframe:
2646
    force_sig(TARGET_SIGSEGV/*, current*/);
2647
    return 0;
2648
}
2649

    
2650
static void setup_rt_frame(int sig, struct target_sigaction *ka,
2651
                           target_siginfo_t *info,
2652
                           target_sigset_t *set, CPUState *env)
2653
{
2654
    struct target_rt_sigframe *frame;
2655
    abi_ulong frame_addr;
2656
    int i;
2657

    
2658
    frame_addr = get_sigframe(ka, env, sizeof(*frame));
2659
    if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
2660
        goto give_sigsegv;
2661

    
2662
    install_sigtramp(frame->rs_code, TARGET_NR_rt_sigreturn);
2663

    
2664
    copy_siginfo_to_user(&frame->rs_info, info);
2665

    
2666
    __put_user(0, &frame->rs_uc.tuc_flags);
2667
    __put_user(0, &frame->rs_uc.tuc_link);
2668
    __put_user(target_sigaltstack_used.ss_sp, &frame->rs_uc.tuc_stack.ss_sp);
2669
    __put_user(target_sigaltstack_used.ss_size, &frame->rs_uc.tuc_stack.ss_size);
2670
    __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
2671
               &frame->rs_uc.tuc_stack.ss_flags);
2672

    
2673
    setup_sigcontext(env, &frame->rs_uc.tuc_mcontext);
2674

    
2675
    for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2676
        __put_user(set->sig[i], &frame->rs_uc.tuc_sigmask.sig[i]);
2677
    }
2678

    
2679
    /*
2680
    * Arguments to signal handler:
2681
    *
2682
    *   a0 = signal number
2683
    *   a1 = pointer to struct siginfo
2684
    *   a2 = pointer to struct ucontext
2685
    *
2686
    * $25 and PC point to the signal handler, $29 points to the
2687
    * struct sigframe.
2688
    */
2689
    env->active_tc.gpr[ 4] = sig;
2690
    env->active_tc.gpr[ 5] = frame_addr
2691
                             + offsetof(struct target_rt_sigframe, rs_info);
2692
    env->active_tc.gpr[ 6] = frame_addr
2693
                             + offsetof(struct target_rt_sigframe, rs_uc);
2694
    env->active_tc.gpr[29] = frame_addr;
2695
    env->active_tc.gpr[31] = frame_addr
2696
                             + offsetof(struct target_rt_sigframe, rs_code);
2697
    /* The original kernel code sets CP0_EPC to the handler
2698
    * since it returns to userland using eret
2699
    * we cannot do this here, and we must set PC directly */
2700
    env->active_tc.PC = env->active_tc.gpr[25] = ka->_sa_handler;
2701
    unlock_user_struct(frame, frame_addr, 1);
2702
    return;
2703

    
2704
give_sigsegv:
2705
    unlock_user_struct(frame, frame_addr, 1);
2706
    force_sig(TARGET_SIGSEGV/*, current*/);
2707
    return;
2708
}
2709

    
2710
long do_rt_sigreturn(CPUState *env)
2711
{
2712
    struct target_rt_sigframe *frame;
2713
    abi_ulong frame_addr;
2714
    sigset_t blocked;
2715

    
2716
#if defined(DEBUG_SIGNAL)
2717
    fprintf(stderr, "do_rt_sigreturn\n");
2718
#endif
2719
    frame_addr = env->active_tc.gpr[29];
2720
    if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2721
           goto badframe;
2722

    
2723
    target_to_host_sigset(&blocked, &frame->rs_uc.tuc_sigmask);
2724
    sigprocmask(SIG_SETMASK, &blocked, NULL);
2725

    
2726
    if (restore_sigcontext(env, &frame->rs_uc.tuc_mcontext))
2727
        goto badframe;
2728

    
2729
    if (do_sigaltstack(frame_addr +
2730
                       offsetof(struct target_rt_sigframe, rs_uc.tuc_stack),
2731
                       0, get_sp_from_cpustate(env)) == -EFAULT)
2732
        goto badframe;
2733

    
2734
    env->active_tc.PC = env->CP0_EPC;
2735
    /* I am not sure this is right, but it seems to work
2736
    * maybe a problem with nested signals ? */
2737
    env->CP0_EPC = 0;
2738
    return -TARGET_QEMU_ESIGRETURN;
2739

    
2740
badframe:
2741
    force_sig(TARGET_SIGSEGV/*, current*/);
2742
    return 0;
2743
}
2744

    
2745
#elif defined(TARGET_SH4)
2746

    
2747
/*
2748
 * code and data structures from linux kernel:
2749
 * include/asm-sh/sigcontext.h
2750
 * arch/sh/kernel/signal.c
2751
 */
2752

    
2753
struct target_sigcontext {
2754
    target_ulong  oldmask;
2755

    
2756
    /* CPU registers */
2757
    target_ulong  sc_gregs[16];
2758
    target_ulong  sc_pc;
2759
    target_ulong  sc_pr;
2760
    target_ulong  sc_sr;
2761
    target_ulong  sc_gbr;
2762
    target_ulong  sc_mach;
2763
    target_ulong  sc_macl;
2764

    
2765
    /* FPU registers */
2766
    target_ulong  sc_fpregs[16];
2767
    target_ulong  sc_xfpregs[16];
2768
    unsigned int sc_fpscr;
2769
    unsigned int sc_fpul;
2770
    unsigned int sc_ownedfp;
2771
};
2772

    
2773
struct target_sigframe
2774
{
2775
    struct target_sigcontext sc;
2776
    target_ulong extramask[TARGET_NSIG_WORDS-1];
2777
    uint16_t retcode[3];
2778
};
2779

    
2780

    
2781
struct target_ucontext {
2782
    target_ulong tuc_flags;
2783
    struct target_ucontext *tuc_link;
2784
    target_stack_t tuc_stack;
2785
    struct target_sigcontext tuc_mcontext;
2786
    target_sigset_t tuc_sigmask;        /* mask last for extensibility */
2787
};
2788

    
2789
struct target_rt_sigframe
2790
{
2791
    struct target_siginfo info;
2792
    struct target_ucontext uc;
2793
    uint16_t retcode[3];
2794
};
2795

    
2796

    
2797
#define MOVW(n)  (0x9300|((n)-2)) /* Move mem word at PC+n to R3 */
2798
#define TRAP_NOARG 0xc310         /* Syscall w/no args (NR in R3) SH3/4 */
2799

    
2800
static abi_ulong get_sigframe(struct target_sigaction *ka,
2801
                         unsigned long sp, size_t frame_size)
2802
{
2803
    if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags(sp) == 0)) {
2804
        sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
2805
    }
2806

    
2807
    return (sp - frame_size) & -8ul;
2808
}
2809

    
2810
static int setup_sigcontext(struct target_sigcontext *sc,
2811
                            CPUState *regs, unsigned long mask)
2812
{
2813
    int err = 0;
2814
    int i;
2815

    
2816
#define COPY(x)         err |= __put_user(regs->x, &sc->sc_##x)
2817
    COPY(gregs[0]); COPY(gregs[1]);
2818
    COPY(gregs[2]); COPY(gregs[3]);
2819
    COPY(gregs[4]); COPY(gregs[5]);
2820
    COPY(gregs[6]); COPY(gregs[7]);
2821
    COPY(gregs[8]); COPY(gregs[9]);
2822
    COPY(gregs[10]); COPY(gregs[11]);
2823
    COPY(gregs[12]); COPY(gregs[13]);
2824
    COPY(gregs[14]); COPY(gregs[15]);
2825
    COPY(gbr); COPY(mach);
2826
    COPY(macl); COPY(pr);
2827
    COPY(sr); COPY(pc);
2828
#undef COPY
2829

    
2830
    for (i=0; i<16; i++) {
2831
        err |= __put_user(regs->fregs[i], &sc->sc_fpregs[i]);
2832
    }
2833
    err |= __put_user(regs->fpscr, &sc->sc_fpscr);
2834
    err |= __put_user(regs->fpul, &sc->sc_fpul);
2835

    
2836
    /* non-iBCS2 extensions.. */
2837
    err |= __put_user(mask, &sc->oldmask);
2838

    
2839
    return err;
2840
}
2841

    
2842
static int restore_sigcontext(CPUState *regs, struct target_sigcontext *sc,
2843
                              target_ulong *r0_p)
2844
{
2845
    unsigned int err = 0;
2846
    int i;
2847

    
2848
#define COPY(x)         err |= __get_user(regs->x, &sc->sc_##x)
2849
    COPY(gregs[1]);
2850
    COPY(gregs[2]); COPY(gregs[3]);
2851
    COPY(gregs[4]); COPY(gregs[5]);
2852
    COPY(gregs[6]); COPY(gregs[7]);
2853
    COPY(gregs[8]); COPY(gregs[9]);
2854
    COPY(gregs[10]); COPY(gregs[11]);
2855
    COPY(gregs[12]); COPY(gregs[13]);
2856
    COPY(gregs[14]); COPY(gregs[15]);
2857
    COPY(gbr); COPY(mach);
2858
    COPY(macl); COPY(pr);
2859
    COPY(sr); COPY(pc);
2860
#undef COPY
2861

    
2862
    for (i=0; i<16; i++) {
2863
        err |= __get_user(regs->fregs[i], &sc->sc_fpregs[i]);
2864
    }
2865
    err |= __get_user(regs->fpscr, &sc->sc_fpscr);
2866
    err |= __get_user(regs->fpul, &sc->sc_fpul);
2867

    
2868
    regs->tra = -1;         /* disable syscall checks */
2869
    err |= __get_user(*r0_p, &sc->sc_gregs[0]);
2870
    return err;
2871
}
2872

    
2873
static void setup_frame(int sig, struct target_sigaction *ka,
2874
                        target_sigset_t *set, CPUState *regs)
2875
{
2876
    struct target_sigframe *frame;
2877
    abi_ulong frame_addr;
2878
    int i;
2879
    int err = 0;
2880
    int signal;
2881

    
2882
    frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
2883
    if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
2884
        goto give_sigsegv;
2885

    
2886
    signal = current_exec_domain_sig(sig);
2887

    
2888
    err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
2889

    
2890
    for (i = 0; i < TARGET_NSIG_WORDS - 1; i++) {
2891
        err |= __put_user(set->sig[i + 1], &frame->extramask[i]);
2892
    }
2893

    
2894
    /* Set up to return from userspace.  If provided, use a stub
2895
       already in userspace.  */
2896
    if (ka->sa_flags & TARGET_SA_RESTORER) {
2897
        regs->pr = (unsigned long) ka->sa_restorer;
2898
    } else {
2899
        /* Generate return code (system call to sigreturn) */
2900
        err |= __put_user(MOVW(2), &frame->retcode[0]);
2901
        err |= __put_user(TRAP_NOARG, &frame->retcode[1]);
2902
        err |= __put_user((TARGET_NR_sigreturn), &frame->retcode[2]);
2903
        regs->pr = (unsigned long) frame->retcode;
2904
    }
2905

    
2906
    if (err)
2907
        goto give_sigsegv;
2908

    
2909
    /* Set up registers for signal handler */
2910
    regs->gregs[15] = (unsigned long) frame;
2911
    regs->gregs[4] = signal; /* Arg for signal handler */
2912
    regs->gregs[5] = 0;
2913
    regs->gregs[6] = (unsigned long) &frame->sc;
2914
    regs->pc = (unsigned long) ka->_sa_handler;
2915

    
2916
    unlock_user_struct(frame, frame_addr, 1);
2917
    return;
2918

    
2919
give_sigsegv:
2920
    unlock_user_struct(frame, frame_addr, 1);
2921
    force_sig(TARGET_SIGSEGV);
2922
}
2923

    
2924
static void setup_rt_frame(int sig, struct target_sigaction *ka,
2925
                           target_siginfo_t *info,
2926
                           target_sigset_t *set, CPUState *regs)
2927
{
2928
    struct target_rt_sigframe *frame;
2929
    abi_ulong frame_addr;
2930
    int i;
2931
    int err = 0;
2932
    int signal;
2933

    
2934
    frame_addr = get_sigframe(ka, regs->gregs[15], sizeof(*frame));
2935
    if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
2936
        goto give_sigsegv;
2937

    
2938
    signal = current_exec_domain_sig(sig);
2939

    
2940
    err |= copy_siginfo_to_user(&frame->info, info);
2941

    
2942
    /* Create the ucontext.  */
2943
    err |= __put_user(0, &frame->uc.tuc_flags);
2944
    err |= __put_user(0, (unsigned long *)&frame->uc.tuc_link);
2945
    err |= __put_user((unsigned long)target_sigaltstack_used.ss_sp,
2946
                      &frame->uc.tuc_stack.ss_sp);
2947
    err |= __put_user(sas_ss_flags(regs->gregs[15]),
2948
                      &frame->uc.tuc_stack.ss_flags);
2949
    err |= __put_user(target_sigaltstack_used.ss_size,
2950
                      &frame->uc.tuc_stack.ss_size);
2951
    err |= setup_sigcontext(&frame->uc.tuc_mcontext,
2952
                            regs, set->sig[0]);
2953
    for(i = 0; i < TARGET_NSIG_WORDS; i++) {
2954
        err |= __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
2955
    }
2956

    
2957
    /* Set up to return from userspace.  If provided, use a stub
2958
       already in userspace.  */
2959
    if (ka->sa_flags & TARGET_SA_RESTORER) {
2960
        regs->pr = (unsigned long) ka->sa_restorer;
2961
    } else {
2962
        /* Generate return code (system call to sigreturn) */
2963
        err |= __put_user(MOVW(2), &frame->retcode[0]);
2964
        err |= __put_user(TRAP_NOARG, &frame->retcode[1]);
2965
        err |= __put_user((TARGET_NR_rt_sigreturn), &frame->retcode[2]);
2966
        regs->pr = (unsigned long) frame->retcode;
2967
    }
2968

    
2969
    if (err)
2970
        goto give_sigsegv;
2971

    
2972
    /* Set up registers for signal handler */
2973
    regs->gregs[15] = (unsigned long) frame;
2974
    regs->gregs[4] = signal; /* Arg for signal handler */
2975
    regs->gregs[5] = (unsigned long) &frame->info;
2976
    regs->gregs[6] = (unsigned long) &frame->uc;
2977
    regs->pc = (unsigned long) ka->_sa_handler;
2978

    
2979
    unlock_user_struct(frame, frame_addr, 1);
2980
    return;
2981

    
2982
give_sigsegv:
2983
    unlock_user_struct(frame, frame_addr, 1);
2984
    force_sig(TARGET_SIGSEGV);
2985
}
2986

    
2987
long do_sigreturn(CPUState *regs)
2988
{
2989
    struct target_sigframe *frame;
2990
    abi_ulong frame_addr;
2991
    sigset_t blocked;
2992
    target_sigset_t target_set;
2993
    target_ulong r0;
2994
    int i;
2995
    int err = 0;
2996

    
2997
#if defined(DEBUG_SIGNAL)
2998
    fprintf(stderr, "do_sigreturn\n");
2999
#endif
3000
    frame_addr = regs->gregs[15];
3001
    if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
3002
           goto badframe;
3003

    
3004
    err |= __get_user(target_set.sig[0], &frame->sc.oldmask);
3005
    for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3006
        err |= (__get_user(target_set.sig[i], &frame->extramask[i - 1]));
3007
    }
3008

    
3009
    if (err)
3010
        goto badframe;
3011

    
3012
    target_to_host_sigset_internal(&blocked, &target_set);
3013
    sigprocmask(SIG_SETMASK, &blocked, NULL);
3014

    
3015
    if (restore_sigcontext(regs, &frame->sc, &r0))
3016
        goto badframe;
3017

    
3018
    unlock_user_struct(frame, frame_addr, 0);
3019
    return r0;
3020

    
3021
badframe:
3022
    unlock_user_struct(frame, frame_addr, 0);
3023
    force_sig(TARGET_SIGSEGV);
3024
    return 0;
3025
}
3026

    
3027
long do_rt_sigreturn(CPUState *regs)
3028
{
3029
    struct target_rt_sigframe *frame;
3030
    abi_ulong frame_addr;
3031
    sigset_t blocked;
3032
    target_ulong r0;
3033

    
3034
#if defined(DEBUG_SIGNAL)
3035
    fprintf(stderr, "do_rt_sigreturn\n");
3036
#endif
3037
    frame_addr = regs->gregs[15];
3038
    if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
3039
           goto badframe;
3040

    
3041
    target_to_host_sigset(&blocked, &frame->uc.tuc_sigmask);
3042
    sigprocmask(SIG_SETMASK, &blocked, NULL);
3043

    
3044
    if (restore_sigcontext(regs, &frame->uc.tuc_mcontext, &r0))
3045
        goto badframe;
3046

    
3047
    if (do_sigaltstack(frame_addr +
3048
                       offsetof(struct target_rt_sigframe, uc.tuc_stack),
3049
                       0, get_sp_from_cpustate(regs)) == -EFAULT)
3050
        goto badframe;
3051

    
3052
    unlock_user_struct(frame, frame_addr, 0);
3053
    return r0;
3054

    
3055
badframe:
3056
    unlock_user_struct(frame, frame_addr, 0);
3057
    force_sig(TARGET_SIGSEGV);
3058
    return 0;
3059
}
3060
#elif defined(TARGET_MICROBLAZE)
3061

    
3062
struct target_sigcontext {
3063
    struct target_pt_regs regs;  /* needs to be first */
3064
    uint32_t oldmask;
3065
};
3066

    
3067
/* Signal frames. */
3068
struct target_signal_frame {
3069
    struct target_sigcontext sc;
3070
    uint32_t extramask[TARGET_NSIG_WORDS - 1];
3071
    uint32_t tramp[2];
3072
};
3073

    
3074
struct rt_signal_frame {
3075
    struct siginfo info;
3076
    struct ucontext uc;
3077
    uint32_t tramp[2];
3078
};
3079

    
3080
static void setup_sigcontext(struct target_sigcontext *sc, CPUState *env)
3081
{
3082
    __put_user(env->regs[0], &sc->regs.r0);
3083
    __put_user(env->regs[1], &sc->regs.r1);
3084
    __put_user(env->regs[2], &sc->regs.r2);
3085
    __put_user(env->regs[3], &sc->regs.r3);
3086
    __put_user(env->regs[4], &sc->regs.r4);
3087
    __put_user(env->regs[5], &sc->regs.r5);
3088
    __put_user(env->regs[6], &sc->regs.r6);
3089
    __put_user(env->regs[7], &sc->regs.r7);
3090
    __put_user(env->regs[8], &sc->regs.r8);
3091
    __put_user(env->regs[9], &sc->regs.r9);
3092
    __put_user(env->regs[10], &sc->regs.r10);
3093
    __put_user(env->regs[11], &sc->regs.r11);
3094
    __put_user(env->regs[12], &sc->regs.r12);
3095
    __put_user(env->regs[13], &sc->regs.r13);
3096
    __put_user(env->regs[14], &sc->regs.r14);
3097
    __put_user(env->regs[15], &sc->regs.r15);
3098
    __put_user(env->regs[16], &sc->regs.r16);
3099
    __put_user(env->regs[17], &sc->regs.r17);
3100
    __put_user(env->regs[18], &sc->regs.r18);
3101
    __put_user(env->regs[19], &sc->regs.r19);
3102
    __put_user(env->regs[20], &sc->regs.r20);
3103
    __put_user(env->regs[21], &sc->regs.r21);
3104
    __put_user(env->regs[22], &sc->regs.r22);
3105
    __put_user(env->regs[23], &sc->regs.r23);
3106
    __put_user(env->regs[24], &sc->regs.r24);
3107
    __put_user(env->regs[25], &sc->regs.r25);
3108
    __put_user(env->regs[26], &sc->regs.r26);
3109
    __put_user(env->regs[27], &sc->regs.r27);
3110
    __put_user(env->regs[28], &sc->regs.r28);
3111
    __put_user(env->regs[29], &sc->regs.r29);
3112
    __put_user(env->regs[30], &sc->regs.r30);
3113
    __put_user(env->regs[31], &sc->regs.r31);
3114
    __put_user(env->sregs[SR_PC], &sc->regs.pc);
3115
}
3116

    
3117
static void restore_sigcontext(struct target_sigcontext *sc, CPUState *env)
3118
{
3119
    __get_user(env->regs[0], &sc->regs.r0);
3120
    __get_user(env->regs[1], &sc->regs.r1);
3121
    __get_user(env->regs[2], &sc->regs.r2);
3122
    __get_user(env->regs[3], &sc->regs.r3);
3123
    __get_user(env->regs[4], &sc->regs.r4);
3124
    __get_user(env->regs[5], &sc->regs.r5);
3125
    __get_user(env->regs[6], &sc->regs.r6);
3126
    __get_user(env->regs[7], &sc->regs.r7);
3127
    __get_user(env->regs[8], &sc->regs.r8);
3128
    __get_user(env->regs[9], &sc->regs.r9);
3129
    __get_user(env->regs[10], &sc->regs.r10);
3130
    __get_user(env->regs[11], &sc->regs.r11);
3131
    __get_user(env->regs[12], &sc->regs.r12);
3132
    __get_user(env->regs[13], &sc->regs.r13);
3133
    __get_user(env->regs[14], &sc->regs.r14);
3134
    __get_user(env->regs[15], &sc->regs.r15);
3135
    __get_user(env->regs[16], &sc->regs.r16);
3136
    __get_user(env->regs[17], &sc->regs.r17);
3137
    __get_user(env->regs[18], &sc->regs.r18);
3138
    __get_user(env->regs[19], &sc->regs.r19);
3139
    __get_user(env->regs[20], &sc->regs.r20);
3140
    __get_user(env->regs[21], &sc->regs.r21);
3141
    __get_user(env->regs[22], &sc->regs.r22);
3142
    __get_user(env->regs[23], &sc->regs.r23);
3143
    __get_user(env->regs[24], &sc->regs.r24);
3144
    __get_user(env->regs[25], &sc->regs.r25);
3145
    __get_user(env->regs[26], &sc->regs.r26);
3146
    __get_user(env->regs[27], &sc->regs.r27);
3147
    __get_user(env->regs[28], &sc->regs.r28);
3148
    __get_user(env->regs[29], &sc->regs.r29);
3149
    __get_user(env->regs[30], &sc->regs.r30);
3150
    __get_user(env->regs[31], &sc->regs.r31);
3151
    __get_user(env->sregs[SR_PC], &sc->regs.pc);
3152
}
3153

    
3154
static abi_ulong get_sigframe(struct target_sigaction *ka,
3155
                              CPUState *env, int frame_size)
3156
{
3157
    abi_ulong sp = env->regs[1];
3158

    
3159
    if ((ka->sa_flags & SA_ONSTACK) != 0 && !on_sig_stack(sp))
3160
        sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
3161

    
3162
    return ((sp - frame_size) & -8UL);
3163
}
3164

    
3165
static void setup_frame(int sig, struct target_sigaction *ka,
3166
                        target_sigset_t *set, CPUState *env)
3167
{
3168
    struct target_signal_frame *frame;
3169
    abi_ulong frame_addr;
3170
    int err = 0;
3171
    int i;
3172

    
3173
    frame_addr = get_sigframe(ka, env, sizeof *frame);
3174
    if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3175
        goto badframe;
3176

    
3177
    /* Save the mask.  */
3178
    err |= __put_user(set->sig[0], &frame->sc.oldmask);
3179
    if (err)
3180
        goto badframe;
3181

    
3182
    for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3183
        if (__put_user(set->sig[i], &frame->extramask[i - 1]))
3184
            goto badframe;
3185
    }
3186

    
3187
    setup_sigcontext(&frame->sc, env);
3188

    
3189
    /* Set up to return from userspace. If provided, use a stub
3190
       already in userspace. */
3191
    /* minus 8 is offset to cater for "rtsd r15,8" offset */
3192
    if (ka->sa_flags & TARGET_SA_RESTORER) {
3193
        env->regs[15] = ((unsigned long)ka->sa_restorer)-8;
3194
    } else {
3195
        uint32_t t;
3196
        /* Note, these encodings are _big endian_! */
3197
        /* addi r12, r0, __NR_sigreturn */
3198
        t = 0x31800000UL | TARGET_NR_sigreturn;
3199
        err |= __put_user(t, frame->tramp + 0);
3200
        /* brki r14, 0x8 */
3201
        t = 0xb9cc0008UL;
3202
        err |= __put_user(t, frame->tramp + 1);
3203

    
3204
        /* Return from sighandler will jump to the tramp.
3205
           Negative 8 offset because return is rtsd r15, 8 */
3206
        env->regs[15] = ((unsigned long)frame->tramp) - 8;
3207
    }
3208

    
3209
    if (err)
3210
        goto badframe;
3211

    
3212
    /* Set up registers for signal handler */
3213
    env->regs[1] = (unsigned long) frame;
3214
    /* Signal handler args: */
3215
    env->regs[5] = sig; /* Arg 0: signum */
3216
    env->regs[6] = (unsigned long) &frame->sc; /* arg 1: sigcontext */
3217

    
3218
    /* Offset of 4 to handle microblaze rtid r14, 0 */
3219
    env->sregs[SR_PC] = (unsigned long)ka->_sa_handler;
3220

    
3221
    unlock_user_struct(frame, frame_addr, 1);
3222
    return;
3223
  badframe:
3224
    unlock_user_struct(frame, frame_addr, 1);
3225
    force_sig(TARGET_SIGSEGV);
3226
}
3227

    
3228
static void setup_rt_frame(int sig, struct target_sigaction *ka,
3229
                           target_siginfo_t *info,
3230
                           target_sigset_t *set, CPUState *env)
3231
{
3232
    fprintf(stderr, "Microblaze setup_rt_frame: not implemented\n");
3233
}
3234

    
3235
long do_sigreturn(CPUState *env)
3236
{
3237
    struct target_signal_frame *frame;
3238
    abi_ulong frame_addr;
3239
    target_sigset_t target_set;
3240
    sigset_t set;
3241
    int i;
3242

    
3243
    frame_addr = env->regs[R_SP];
3244
    /* Make sure the guest isn't playing games.  */
3245
    if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
3246
        goto badframe;
3247

    
3248
    /* Restore blocked signals */
3249
    if (__get_user(target_set.sig[0], &frame->sc.oldmask))
3250
        goto badframe;
3251
    for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3252
        if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
3253
            goto badframe;
3254
    }
3255
    target_to_host_sigset_internal(&set, &target_set);
3256
    sigprocmask(SIG_SETMASK, &set, NULL);
3257

    
3258
    restore_sigcontext(&frame->sc, env);
3259
    /* We got here through a sigreturn syscall, our path back is via an
3260
       rtb insn so setup r14 for that.  */
3261
    env->regs[14] = env->sregs[SR_PC];
3262
 
3263
    unlock_user_struct(frame, frame_addr, 0);
3264
    return env->regs[10];
3265
  badframe:
3266
    unlock_user_struct(frame, frame_addr, 0);
3267
    force_sig(TARGET_SIGSEGV);
3268
}
3269

    
3270
long do_rt_sigreturn(CPUState *env)
3271
{
3272
    fprintf(stderr, "Microblaze do_rt_sigreturn: not implemented\n");
3273
    return -TARGET_ENOSYS;
3274
}
3275

    
3276
#elif defined(TARGET_CRIS)
3277

    
3278
struct target_sigcontext {
3279
        struct target_pt_regs regs;  /* needs to be first */
3280
        uint32_t oldmask;
3281
        uint32_t usp;    /* usp before stacking this gunk on it */
3282
};
3283

    
3284
/* Signal frames. */
3285
struct target_signal_frame {
3286
        struct target_sigcontext sc;
3287
        uint32_t extramask[TARGET_NSIG_WORDS - 1];
3288
        uint8_t retcode[8];       /* Trampoline code. */
3289
};
3290

    
3291
struct rt_signal_frame {
3292
        struct siginfo *pinfo;
3293
        void *puc;
3294
        struct siginfo info;
3295
        struct ucontext uc;
3296
        uint8_t retcode[8];       /* Trampoline code. */
3297
};
3298

    
3299
static void setup_sigcontext(struct target_sigcontext *sc, CPUState *env)
3300
{
3301
        __put_user(env->regs[0], &sc->regs.r0);
3302
        __put_user(env->regs[1], &sc->regs.r1);
3303
        __put_user(env->regs[2], &sc->regs.r2);
3304
        __put_user(env->regs[3], &sc->regs.r3);
3305
        __put_user(env->regs[4], &sc->regs.r4);
3306
        __put_user(env->regs[5], &sc->regs.r5);
3307
        __put_user(env->regs[6], &sc->regs.r6);
3308
        __put_user(env->regs[7], &sc->regs.r7);
3309
        __put_user(env->regs[8], &sc->regs.r8);
3310
        __put_user(env->regs[9], &sc->regs.r9);
3311
        __put_user(env->regs[10], &sc->regs.r10);
3312
        __put_user(env->regs[11], &sc->regs.r11);
3313
        __put_user(env->regs[12], &sc->regs.r12);
3314
        __put_user(env->regs[13], &sc->regs.r13);
3315
        __put_user(env->regs[14], &sc->usp);
3316
        __put_user(env->regs[15], &sc->regs.acr);
3317
        __put_user(env->pregs[PR_MOF], &sc->regs.mof);
3318
        __put_user(env->pregs[PR_SRP], &sc->regs.srp);
3319
        __put_user(env->pc, &sc->regs.erp);
3320
}
3321

    
3322
static void restore_sigcontext(struct target_sigcontext *sc, CPUState *env)
3323
{
3324
        __get_user(env->regs[0], &sc->regs.r0);
3325
        __get_user(env->regs[1], &sc->regs.r1);
3326
        __get_user(env->regs[2], &sc->regs.r2);
3327
        __get_user(env->regs[3], &sc->regs.r3);
3328
        __get_user(env->regs[4], &sc->regs.r4);
3329
        __get_user(env->regs[5], &sc->regs.r5);
3330
        __get_user(env->regs[6], &sc->regs.r6);
3331
        __get_user(env->regs[7], &sc->regs.r7);
3332
        __get_user(env->regs[8], &sc->regs.r8);
3333
        __get_user(env->regs[9], &sc->regs.r9);
3334
        __get_user(env->regs[10], &sc->regs.r10);
3335
        __get_user(env->regs[11], &sc->regs.r11);
3336
        __get_user(env->regs[12], &sc->regs.r12);
3337
        __get_user(env->regs[13], &sc->regs.r13);
3338
        __get_user(env->regs[14], &sc->usp);
3339
        __get_user(env->regs[15], &sc->regs.acr);
3340
        __get_user(env->pregs[PR_MOF], &sc->regs.mof);
3341
        __get_user(env->pregs[PR_SRP], &sc->regs.srp);
3342
        __get_user(env->pc, &sc->regs.erp);
3343
}
3344

    
3345
static abi_ulong get_sigframe(CPUState *env, int framesize)
3346
{
3347
        abi_ulong sp;
3348
        /* Align the stack downwards to 4.  */
3349
        sp = (env->regs[R_SP] & ~3);
3350
        return sp - framesize;
3351
}
3352

    
3353
static void setup_frame(int sig, struct target_sigaction *ka,
3354
                        target_sigset_t *set, CPUState *env)
3355
{
3356
        struct target_signal_frame *frame;
3357
        abi_ulong frame_addr;
3358
        int err = 0;
3359
        int i;
3360

    
3361
        frame_addr = get_sigframe(env, sizeof *frame);
3362
        if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
3363
                goto badframe;
3364

    
3365
        /*
3366
         * The CRIS signal return trampoline. A real linux/CRIS kernel doesn't
3367
         * use this trampoline anymore but it sets it up for GDB.
3368
         * In QEMU, using the trampoline simplifies things a bit so we use it.
3369
         *
3370
         * This is movu.w __NR_sigreturn, r9; break 13;
3371
         */
3372
        err |= __put_user(0x9c5f, frame->retcode+0);
3373
        err |= __put_user(TARGET_NR_sigreturn, 
3374
                          frame->retcode+2);
3375
        err |= __put_user(0xe93d, frame->retcode+4);
3376

    
3377
        /* Save the mask.  */
3378
        err |= __put_user(set->sig[0], &frame->sc.oldmask);
3379
        if (err)
3380
                goto badframe;
3381

    
3382
        for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3383
                if (__put_user(set->sig[i], &frame->extramask[i - 1]))
3384
                        goto badframe;
3385
        }
3386

    
3387
        setup_sigcontext(&frame->sc, env);
3388

    
3389
        /* Move the stack and setup the arguments for the handler.  */
3390
        env->regs[R_SP] = (uint32_t) (unsigned long) frame;
3391
        env->regs[10] = sig;
3392
        env->pc = (unsigned long) ka->_sa_handler;
3393
        /* Link SRP so the guest returns through the trampoline.  */
3394
        env->pregs[PR_SRP] = (uint32_t) (unsigned long) &frame->retcode[0];
3395

    
3396
        unlock_user_struct(frame, frame_addr, 1);
3397
        return;
3398
  badframe:
3399
        unlock_user_struct(frame, frame_addr, 1);
3400
        force_sig(TARGET_SIGSEGV);
3401
}
3402

    
3403
static void setup_rt_frame(int sig, struct target_sigaction *ka,
3404
                           target_siginfo_t *info,
3405
                           target_sigset_t *set, CPUState *env)
3406
{
3407
    fprintf(stderr, "CRIS setup_rt_frame: not implemented\n");
3408
}
3409

    
3410
long do_sigreturn(CPUState *env)
3411
{
3412
        struct target_signal_frame *frame;
3413
        abi_ulong frame_addr;
3414
        target_sigset_t target_set;
3415
        sigset_t set;
3416
        int i;
3417

    
3418
        frame_addr = env->regs[R_SP];
3419
        /* Make sure the guest isn't playing games.  */
3420
        if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
3421
                goto badframe;
3422

    
3423
        /* Restore blocked signals */
3424
        if (__get_user(target_set.sig[0], &frame->sc.oldmask))
3425
                goto badframe;
3426
        for(i = 1; i < TARGET_NSIG_WORDS; i++) {
3427
                if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
3428
                        goto badframe;
3429
        }
3430
        target_to_host_sigset_internal(&set, &target_set);
3431
        sigprocmask(SIG_SETMASK, &set, NULL);
3432

    
3433
        restore_sigcontext(&frame->sc, env);
3434
        unlock_user_struct(frame, frame_addr, 0);
3435
        return env->regs[10];
3436
  badframe:
3437
        unlock_user_struct(frame, frame_addr, 0);
3438
        force_sig(TARGET_SIGSEGV);
3439
}
3440

    
3441
long do_rt_sigreturn(CPUState *env)
3442
{
3443
    fprintf(stderr, "CRIS do_rt_sigreturn: not implemented\n");
3444
    return -TARGET_ENOSYS;
3445
}
3446

    
3447
#elif defined(TARGET_PPC) && !defined(TARGET_PPC64)
3448

    
3449
/* FIXME: Many of the structures are defined for both PPC and PPC64, but
3450
   the signal handling is different enough that we haven't implemented
3451
   support for PPC64 yet.  Hence the restriction above.
3452

3453
   There are various #if'd blocks for code for TARGET_PPC64.  These
3454
   blocks should go away so that we can successfully run 32-bit and
3455
   64-bit binaries on a QEMU configured for PPC64.  */
3456

    
3457
/* Size of dummy stack frame allocated when calling signal handler.
3458
   See arch/powerpc/include/asm/ptrace.h.  */
3459
#if defined(TARGET_PPC64)
3460
#define SIGNAL_FRAMESIZE 128
3461
#else
3462
#define SIGNAL_FRAMESIZE 64
3463
#endif
3464

    
3465
/* See arch/powerpc/include/asm/sigcontext.h.  */
3466
struct target_sigcontext {
3467
    target_ulong _unused[4];
3468
    int32_t signal;
3469
#if defined(TARGET_PPC64)
3470
    int32_t pad0;
3471
#endif
3472
    target_ulong handler;
3473
    target_ulong oldmask;
3474
    target_ulong regs;      /* struct pt_regs __user * */
3475
    /* TODO: PPC64 includes extra bits here.  */
3476
};
3477

    
3478
/* Indices for target_mcontext.mc_gregs, below.
3479
   See arch/powerpc/include/asm/ptrace.h for details.  */
3480
enum {
3481
    TARGET_PT_R0 = 0,
3482
    TARGET_PT_R1 = 1,
3483
    TARGET_PT_R2 = 2,
3484
    TARGET_PT_R3 = 3,
3485
    TARGET_PT_R4 = 4,
3486
    TARGET_PT_R5 = 5,
3487
    TARGET_PT_R6 = 6,
3488
    TARGET_PT_R7 = 7,
3489
    TARGET_PT_R8 = 8,
3490
    TARGET_PT_R9 = 9,
3491
    TARGET_PT_R10 = 10,
3492
    TARGET_PT_R11 = 11,
3493
    TARGET_PT_R12 = 12,
3494
    TARGET_PT_R13 = 13,
3495
    TARGET_PT_R14 = 14,
3496
    TARGET_PT_R15 = 15,
3497
    TARGET_PT_R16 = 16,
3498
    TARGET_PT_R17 = 17,
3499
    TARGET_PT_R18 = 18,
3500
    TARGET_PT_R19 = 19,
3501
    TARGET_PT_R20 = 20,
3502
    TARGET_PT_R21 = 21,
3503
    TARGET_PT_R22 = 22,
3504
    TARGET_PT_R23 = 23,
3505
    TARGET_PT_R24 = 24,
3506
    TARGET_PT_R25 = 25,
3507
    TARGET_PT_R26 = 26,
3508
    TARGET_PT_R27 = 27,
3509
    TARGET_PT_R28 = 28,
3510
    TARGET_PT_R29 = 29,
3511
    TARGET_PT_R30 = 30,
3512
    TARGET_PT_R31 = 31,
3513
    TARGET_PT_NIP = 32,
3514
    TARGET_PT_MSR = 33,
3515
    TARGET_PT_ORIG_R3 = 34,
3516
    TARGET_PT_CTR = 35,
3517
    TARGET_PT_LNK = 36,
3518
    TARGET_PT_XER = 37,
3519
    TARGET_PT_CCR = 38,
3520
    /* Yes, there are two registers with #39.  One is 64-bit only.  */
3521
    TARGET_PT_MQ = 39,
3522
    TARGET_PT_SOFTE = 39,
3523
    TARGET_PT_TRAP = 40,
3524
    TARGET_PT_DAR = 41,
3525
    TARGET_PT_DSISR = 42,
3526
    TARGET_PT_RESULT = 43,
3527
    TARGET_PT_REGS_COUNT = 44
3528
};
3529

    
3530
/* See arch/powerpc/include/asm/ucontext.h.  Only used for 32-bit PPC;
3531
   on 64-bit PPC, sigcontext and mcontext are one and the same.  */
3532
struct target_mcontext {
3533
    target_ulong mc_gregs[48];
3534
    /* Includes fpscr.  */
3535
    uint64_t mc_fregs[33];
3536
    target_ulong mc_pad[2];
3537
    /* We need to handle Altivec and SPE at the same time, which no
3538
       kernel needs to do.  Fortunately, the kernel defines this bit to
3539
       be Altivec-register-large all the time, rather than trying to
3540
       twiddle it based on the specific platform.  */
3541
    union {
3542
        /* SPE vector registers.  One extra for SPEFSCR.  */
3543
        uint32_t spe[33];
3544
        /* Altivec vector registers.  The packing of VSCR and VRSAVE
3545
           varies depending on whether we're PPC64 or not: PPC64 splits
3546
           them apart; PPC32 stuffs them together.  */
3547
#if defined(TARGET_PPC64)
3548
#define QEMU_NVRREG 34
3549
#else
3550
#define QEMU_NVRREG 33
3551
#endif
3552
        ppc_avr_t altivec[QEMU_NVRREG];
3553
#undef QEMU_NVRREG
3554
    } mc_vregs __attribute__((__aligned__(16)));
3555
};
3556

    
3557
struct target_ucontext {
3558
    target_ulong tuc_flags;
3559
    target_ulong tuc_link;    /* struct ucontext __user * */
3560
    struct target_sigaltstack tuc_stack;
3561
#if !defined(TARGET_PPC64)
3562
    int32_t tuc_pad[7];
3563
    target_ulong tuc_regs;    /* struct mcontext __user *
3564
                                points to uc_mcontext field */
3565
#endif
3566
    target_sigset_t tuc_sigmask;
3567
#if defined(TARGET_PPC64)
3568
    target_sigset_t unused[15]; /* Allow for uc_sigmask growth */
3569
    struct target_sigcontext tuc_mcontext;
3570
#else
3571
    int32_t tuc_maskext[30];
3572
    int32_t tuc_pad2[3];
3573
    struct target_mcontext tuc_mcontext;
3574
#endif
3575
};
3576

    
3577
/* See arch/powerpc/kernel/signal_32.c.  */
3578
struct target_sigframe {
3579
    struct target_sigcontext sctx;
3580
    struct target_mcontext mctx;
3581
    int32_t abigap[56];
3582
};
3583

    
3584
struct target_rt_sigframe {
3585
    struct target_siginfo info;
3586
    struct target_ucontext uc;
3587
    int32_t abigap[56];
3588
};
3589

    
3590
/* We use the mc_pad field for the signal return trampoline.  */
3591
#define tramp mc_pad
3592

    
3593
/* See arch/powerpc/kernel/signal.c.  */
3594
static target_ulong get_sigframe(struct target_sigaction *ka,
3595
                                 CPUState *env,
3596
                                 int frame_size)
3597
{
3598
    target_ulong oldsp, newsp;
3599

    
3600
    oldsp = env->gpr[1];
3601

    
3602
    if ((ka->sa_flags & TARGET_SA_ONSTACK) &&
3603
        (sas_ss_flags(oldsp))) {
3604
        oldsp = (target_sigaltstack_used.ss_sp
3605
                 + target_sigaltstack_used.ss_size);
3606
    }
3607

    
3608
    newsp = (oldsp - frame_size) & ~0xFUL;
3609

    
3610
    return newsp;
3611
}
3612

    
3613
static int save_user_regs(CPUState *env, struct target_mcontext *frame,
3614
                          int sigret)
3615
{
3616
    target_ulong msr = env->msr;
3617
    int i;
3618
    target_ulong ccr = 0;
3619

    
3620
    /* In general, the kernel attempts to be intelligent about what it
3621
       needs to save for Altivec/FP/SPE registers.  We don't care that
3622
       much, so we just go ahead and save everything.  */
3623

    
3624
    /* Save general registers.  */
3625
    for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
3626
        if (__put_user(env->gpr[i], &frame->mc_gregs[i])) {
3627
            return 1;
3628
        }
3629
    }
3630
    if (__put_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP])
3631
        || __put_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR])
3632
        || __put_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK])
3633
        || __put_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]))
3634
        return 1;
3635

    
3636
    for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
3637
        ccr |= env->crf[i] << (32 - ((i + 1) * 4));
3638
    }
3639
    if (__put_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]))
3640
        return 1;
3641

    
3642
    /* Save Altivec registers if necessary.  */
3643
    if (env->insns_flags & PPC_ALTIVEC) {
3644
        for (i = 0; i < ARRAY_SIZE(env->avr); i++) {
3645
            ppc_avr_t *avr = &env->avr[i];
3646
            ppc_avr_t *vreg = &frame->mc_vregs.altivec[i];
3647

    
3648
            if (__put_user(avr->u64[0], &vreg->u64[0]) ||
3649
                __put_user(avr->u64[1], &vreg->u64[1])) {
3650
                return 1;
3651
            }
3652
        }
3653
        /* Set MSR_VR in the saved MSR value to indicate that
3654
           frame->mc_vregs contains valid data.  */
3655
        msr |= MSR_VR;
3656
        if (__put_user((uint32_t)env->spr[SPR_VRSAVE],
3657
                       &frame->mc_vregs.altivec[32].u32[3]))
3658
            return 1;
3659
    }
3660

    
3661
    /* Save floating point registers.  */
3662
    if (env->insns_flags & PPC_FLOAT) {
3663
        for (i = 0; i < ARRAY_SIZE(env->fpr); i++) {
3664
            if (__put_user(env->fpr[i], &frame->mc_fregs[i])) {
3665
                return 1;
3666
            }
3667
        }
3668
        if (__put_user((uint64_t) env->fpscr, &frame->mc_fregs[32]))
3669
            return 1;
3670
    }
3671

    
3672
    /* Save SPE registers.  The kernel only saves the high half.  */
3673
    if (env->insns_flags & PPC_SPE) {
3674
#if defined(TARGET_PPC64)
3675
        for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
3676
            if (__put_user(env->gpr[i] >> 32, &frame->mc_vregs.spe[i])) {
3677
                return 1;
3678
            }
3679
        }
3680
#else
3681
        for (i = 0; i < ARRAY_SIZE(env->gprh); i++) {
3682
            if (__put_user(env->gprh[i], &frame->mc_vregs.spe[i])) {
3683
                return 1;
3684
            }
3685
        }
3686
#endif
3687
        /* Set MSR_SPE in the saved MSR value to indicate that
3688
           frame->mc_vregs contains valid data.  */
3689
        msr |= MSR_SPE;
3690
        if (__put_user(env->spe_fscr, &frame->mc_vregs.spe[32]))
3691
            return 1;
3692
    }
3693

    
3694
    /* Store MSR.  */
3695
    if (__put_user(msr, &frame->mc_gregs[TARGET_PT_MSR]))
3696
        return 1;
3697

    
3698
    /* Set up the sigreturn trampoline: li r0,sigret; sc.  */
3699
    if (sigret) {
3700
        if (__put_user(0x38000000UL | sigret, &frame->tramp[0]) ||
3701
            __put_user(0x44000002UL, &frame->tramp[1])) {
3702
            return 1;
3703
        }
3704
    }
3705

    
3706
    return 0;
3707
}
3708

    
3709
static int restore_user_regs(CPUState *env,
3710
                             struct target_mcontext *frame, int sig)
3711
{
3712
    target_ulong save_r2 = 0;
3713
    target_ulong msr;
3714
    target_ulong ccr;
3715

    
3716
    int i;
3717

    
3718
    if (!sig) {
3719
        save_r2 = env->gpr[2];
3720
    }
3721

    
3722
    /* Restore general registers.  */
3723
    for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
3724
        if (__get_user(env->gpr[i], &frame->mc_gregs[i])) {
3725
            return 1;
3726
        }
3727
    }
3728
    if (__get_user(env->nip, &frame->mc_gregs[TARGET_PT_NIP])
3729
        || __get_user(env->ctr, &frame->mc_gregs[TARGET_PT_CTR])
3730
        || __get_user(env->lr, &frame->mc_gregs[TARGET_PT_LNK])
3731
        || __get_user(env->xer, &frame->mc_gregs[TARGET_PT_XER]))
3732
        return 1;
3733
    if (__get_user(ccr, &frame->mc_gregs[TARGET_PT_CCR]))
3734
        return 1;
3735

    
3736
    for (i = 0; i < ARRAY_SIZE(env->crf); i++) {
3737
        env->crf[i] = (ccr >> (32 - ((i + 1) * 4))) & 0xf;
3738
    }
3739

    
3740
    if (!sig) {
3741
        env->gpr[2] = save_r2;
3742
    }
3743
    /* Restore MSR.  */
3744
    if (__get_user(msr, &frame->mc_gregs[TARGET_PT_MSR]))
3745
        return 1;
3746

    
3747
    /* If doing signal return, restore the previous little-endian mode.  */
3748
    if (sig)
3749
        env->msr = (env->msr & ~MSR_LE) | (msr & MSR_LE);
3750

    
3751
    /* Restore Altivec registers if necessary.  */
3752
    if (env->insns_flags & PPC_ALTIVEC) {
3753
        for (i = 0; i < ARRAY_SIZE(env->avr); i++) {
3754
            ppc_avr_t *avr = &env->avr[i];
3755
            ppc_avr_t *vreg = &frame->mc_vregs.altivec[i];
3756

    
3757
            if (__get_user(avr->u64[0], &vreg->u64[0]) ||
3758
                __get_user(avr->u64[1], &vreg->u64[1])) {
3759
                return 1;
3760
            }
3761
        }
3762
        /* Set MSR_VEC in the saved MSR value to indicate that
3763
           frame->mc_vregs contains valid data.  */
3764
        if (__get_user(env->spr[SPR_VRSAVE],
3765
                       (target_ulong *)(&frame->mc_vregs.altivec[32].u32[3])))
3766
            return 1;
3767
    }
3768

    
3769
    /* Restore floating point registers.  */
3770
    if (env->insns_flags & PPC_FLOAT) {
3771
        uint64_t fpscr;
3772
        for (i = 0; i < ARRAY_SIZE(env->fpr); i++) {
3773
            if (__get_user(env->fpr[i], &frame->mc_fregs[i])) {
3774
                return 1;
3775
            }
3776
        }
3777
        if (__get_user(fpscr, &frame->mc_fregs[32]))
3778
            return 1;
3779
        env->fpscr = (uint32_t) fpscr;
3780
    }
3781

    
3782
    /* Save SPE registers.  The kernel only saves the high half.  */
3783
    if (env->insns_flags & PPC_SPE) {
3784
#if defined(TARGET_PPC64)
3785
        for (i = 0; i < ARRAY_SIZE(env->gpr); i++) {
3786
            uint32_t hi;
3787

    
3788
            if (__get_user(hi, &frame->mc_vregs.spe[i])) {
3789
                return 1;
3790
            }
3791
            env->gpr[i] = ((uint64_t)hi << 32) | ((uint32_t) env->gpr[i]);
3792
        }
3793
#else
3794
        for (i = 0; i < ARRAY_SIZE(env->gprh); i++) {
3795
            if (__get_user(env->gprh[i], &frame->mc_vregs.spe[i])) {
3796
                return 1;
3797
            }
3798
        }
3799
#endif
3800
        if (__get_user(env->spe_fscr, &frame->mc_vregs.spe[32]))
3801
            return 1;
3802
    }
3803

    
3804
    return 0;
3805
}
3806

    
3807
static void setup_frame(int sig, struct target_sigaction *ka,
3808
                        target_sigset_t *set, CPUState *env)
3809
{
3810
    struct target_sigframe *frame;
3811
    struct target_sigcontext *sc;
3812
    target_ulong frame_addr, newsp;
3813
    int err = 0;
3814
    int signal;
3815

    
3816
    frame_addr = get_sigframe(ka, env, sizeof(*frame));
3817
    if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))
3818
        goto sigsegv;
3819
    sc = &frame->sctx;
3820

    
3821
    signal = current_exec_domain_sig(sig);
3822

    
3823
    err |= __put_user(h2g(ka->_sa_handler), &sc->handler);
3824
    err |= __put_user(set->sig[0], &sc->oldmask);
3825
#if defined(TARGET_PPC64)
3826
    err |= __put_user(set->sig[0] >> 32, &sc->_unused[3]);
3827
#else
3828
    err |= __put_user(set->sig[1], &sc->_unused[3]);
3829
#endif
3830
    err |= __put_user(h2g(&frame->mctx), &sc->regs);
3831
    err |= __put_user(sig, &sc->signal);
3832

    
3833
    /* Save user regs.  */
3834
    err |= save_user_regs(env, &frame->mctx, TARGET_NR_sigreturn);
3835

    
3836
    /* The kernel checks for the presence of a VDSO here.  We don't
3837
       emulate a vdso, so use a sigreturn system call.  */
3838
    env->lr = (target_ulong) h2g(frame->mctx.tramp);
3839

    
3840
    /* Turn off all fp exceptions.  */
3841
    env->fpscr = 0;
3842

    
3843
    /* Create a stack frame for the caller of the handler.  */
3844
    newsp = frame_addr - SIGNAL_FRAMESIZE;
3845
    err |= __put_user(env->gpr[1], (target_ulong *)(uintptr_t) newsp);
3846

    
3847
    if (err)
3848
        goto sigsegv;
3849

    
3850
    /* Set up registers for signal handler.  */
3851
    env->gpr[1] = newsp;
3852
    env->gpr[3] = signal;
3853
    env->gpr[4] = (target_ulong) h2g(sc);
3854
    env->nip = (target_ulong) ka->_sa_handler;
3855
    /* Signal handlers are entered in big-endian mode.  */
3856
    env->msr &= ~MSR_LE;
3857

    
3858
    unlock_user_struct(frame, frame_addr, 1);
3859
    return;
3860

    
3861
sigsegv:
3862
    unlock_user_struct(frame, frame_addr, 1);
3863
    if (logfile)
3864
        fprintf (logfile, "segfaulting from setup_frame\n");
3865
    force_sig(TARGET_SIGSEGV);
3866
}
3867

    
3868
static void setup_rt_frame(int sig, struct target_sigaction *ka,
3869
                           target_siginfo_t *info,
3870
                           target_sigset_t *set, CPUState *env)
3871
{
3872
    struct target_rt_sigframe *rt_sf;
3873
    struct target_mcontext *frame;
3874
    target_ulong rt_sf_addr, newsp = 0;
3875
    int i, err = 0;
3876
    int signal;
3877

    
3878
    rt_sf_addr = get_sigframe(ka, env, sizeof(*rt_sf));
3879
    if (!lock_user_struct(VERIFY_WRITE, rt_sf, rt_sf_addr, 1))
3880
        goto sigsegv;
3881

    
3882
    signal = current_exec_domain_sig(sig);
3883

    
3884
    err |= copy_siginfo_to_user(&rt_sf->info, info);
3885

    
3886
    err |= __put_user(0, &rt_sf->uc.tuc_flags);
3887
    err |= __put_user(0, &rt_sf->uc.tuc_link);
3888
    err |= __put_user((target_ulong)target_sigaltstack_used.ss_sp,
3889
                      &rt_sf->uc.tuc_stack.ss_sp);
3890
    err |= __put_user(sas_ss_flags(env->gpr[1]),
3891
                      &rt_sf->uc.tuc_stack.ss_flags);
3892
    err |= __put_user(target_sigaltstack_used.ss_size,
3893
                      &rt_sf->uc.tuc_stack.ss_size);
3894
    err |= __put_user(h2g (&rt_sf->uc.tuc_mcontext),
3895
                      &rt_sf->uc.tuc_regs);
3896
    for(i = 0; i < TARGET_NSIG_WORDS; i++) {
3897
        err |= __put_user(set->sig[i], &rt_sf->uc.tuc_sigmask.sig[i]);
3898
    }
3899

    
3900
    frame = &rt_sf->uc.tuc_mcontext;
3901
    err |= save_user_regs(env, frame, TARGET_NR_rt_sigreturn);
3902

    
3903
    /* The kernel checks for the presence of a VDSO here.  We don't
3904
       emulate a vdso, so use a sigreturn system call.  */
3905
    env->lr = (target_ulong) h2g(frame->tramp);
3906

    
3907
    /* Turn off all fp exceptions.  */
3908
    env->fpscr = 0;
3909

    
3910
    /* Create a stack frame for the caller of the handler.  */
3911
    newsp = rt_sf_addr - (SIGNAL_FRAMESIZE + 16);
3912
    err |= __put_user(env->gpr[1], (target_ulong *)(uintptr_t) newsp);
3913

    
3914
    if (err)
3915
        goto sigsegv;
3916

    
3917
    /* Set up registers for signal handler.  */
3918
    env->gpr[1] = newsp;
3919
    env->gpr[3] = (target_ulong) signal;
3920
    env->gpr[4] = (target_ulong) h2g(&rt_sf->info);
3921
    env->gpr[5] = (target_ulong) h2g(&rt_sf->uc);
3922
    env->gpr[6] = (target_ulong) h2g(rt_sf);
3923
    env->nip = (target_ulong) ka->_sa_handler;
3924
    /* Signal handlers are entered in big-endian mode.  */
3925
    env->msr &= ~MSR_LE;
3926

    
3927
    unlock_user_struct(rt_sf, rt_sf_addr, 1);
3928
    return;
3929

    
3930
sigsegv:
3931
    unlock_user_struct(rt_sf, rt_sf_addr, 1);
3932
    if (logfile)
3933
        fprintf (logfile, "segfaulting from setup_rt_frame\n");
3934
    force_sig(TARGET_SIGSEGV);
3935

    
3936
}
3937

    
3938
long do_sigreturn(CPUState *env)
3939
{
3940
    struct target_sigcontext *sc = NULL;
3941
    struct target_mcontext *sr = NULL;
3942
    target_ulong sr_addr, sc_addr;
3943
    sigset_t blocked;
3944
    target_sigset_t set;
3945

    
3946
    sc_addr = env->gpr[1] + SIGNAL_FRAMESIZE;
3947
    if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1))
3948
        goto sigsegv;
3949

    
3950
#if defined(TARGET_PPC64)
3951
    set.sig[0] = sc->oldmask + ((long)(sc->_unused[3]) << 32);
3952
#else
3953
    if(__get_user(set.sig[0], &sc->oldmask) ||
3954
       __get_user(set.sig[1], &sc->_unused[3]))
3955
       goto sigsegv;
3956
#endif
3957
    target_to_host_sigset_internal(&blocked, &set);
3958
    sigprocmask(SIG_SETMASK, &blocked, NULL);
3959

    
3960
    if (__get_user(sr_addr, &sc->regs))
3961
        goto sigsegv;
3962
    if (!lock_user_struct(VERIFY_READ, sr, sr_addr, 1))
3963
        goto sigsegv;
3964
    if (restore_user_regs(env, sr, 1))
3965
        goto sigsegv;
3966

    
3967
    unlock_user_struct(sr, sr_addr, 1);
3968
    unlock_user_struct(sc, sc_addr, 1);
3969
    return -TARGET_QEMU_ESIGRETURN;
3970

    
3971
sigsegv:
3972
    unlock_user_struct(sr, sr_addr, 1);
3973
    unlock_user_struct(sc, sc_addr, 1);
3974
    if (logfile)
3975
        fprintf (logfile, "segfaulting from do_sigreturn\n");
3976
    force_sig(TARGET_SIGSEGV);
3977
    return 0;
3978
}
3979

    
3980
/* See arch/powerpc/kernel/signal_32.c.  */
3981
static int do_setcontext(struct target_ucontext *ucp, CPUState *env, int sig)
3982
{
3983
    struct target_mcontext *mcp;
3984
    target_ulong mcp_addr;
3985
    sigset_t blocked;
3986
    target_sigset_t set;
3987

    
3988
    if (copy_from_user(&set, h2g(ucp) + offsetof(struct target_ucontext, tuc_sigmask),
3989
                       sizeof (set)))
3990
        return 1;
3991

    
3992
#if defined(TARGET_PPC64)
3993
    fprintf (stderr, "do_setcontext: not implemented\n");
3994
    return 0;
3995
#else
3996
    if (__get_user(mcp_addr, &ucp->tuc_regs))
3997
        return 1;
3998

    
3999
    if (!lock_user_struct(VERIFY_READ, mcp, mcp_addr, 1))
4000
        return 1;
4001

    
4002
    target_to_host_sigset_internal(&blocked, &set);
4003
    sigprocmask(SIG_SETMASK, &blocked, NULL);
4004
    if (restore_user_regs(env, mcp, sig))
4005
        goto sigsegv;
4006

    
4007
    unlock_user_struct(mcp, mcp_addr, 1);
4008
    return 0;
4009

    
4010
sigsegv:
4011
    unlock_user_struct(mcp, mcp_addr, 1);
4012
    return 1;
4013
#endif
4014
}
4015

    
4016
long do_rt_sigreturn(CPUState *env)
4017
{
4018
    struct target_rt_sigframe *rt_sf = NULL;
4019
    target_ulong rt_sf_addr;
4020

    
4021
    rt_sf_addr = env->gpr[1] + SIGNAL_FRAMESIZE + 16;
4022
    if (!lock_user_struct(VERIFY_READ, rt_sf, rt_sf_addr, 1))
4023
        goto sigsegv;
4024

    
4025
    if (do_setcontext(&rt_sf->uc, env, 1))
4026
        goto sigsegv;
4027

    
4028
    do_sigaltstack(rt_sf_addr
4029
                   + offsetof(struct target_rt_sigframe, uc.tuc_stack),
4030
                   0, env->gpr[1]);
4031

    
4032
    unlock_user_struct(rt_sf, rt_sf_addr, 1);
4033
    return -TARGET_QEMU_ESIGRETURN;
4034

    
4035
sigsegv:
4036
    unlock_user_struct(rt_sf, rt_sf_addr, 1);
4037
    if (logfile)
4038
        fprintf (logfile, "segfaulting from do_rt_sigreturn\n");
4039
    force_sig(TARGET_SIGSEGV);
4040
    return 0;
4041
}
4042

    
4043
#elif defined(TARGET_M68K)
4044

    
4045
struct target_sigcontext {
4046
    abi_ulong  sc_mask;
4047
    abi_ulong  sc_usp;
4048
    abi_ulong  sc_d0;
4049
    abi_ulong  sc_d1;
4050
    abi_ulong  sc_a0;
4051
    abi_ulong  sc_a1;
4052
    unsigned short sc_sr;
4053
    abi_ulong  sc_pc;
4054
};
4055

    
4056
struct target_sigframe
4057
{
4058
    abi_ulong pretcode;
4059
    int sig;
4060
    int code;
4061
    abi_ulong psc;
4062
    char retcode[8];
4063
    abi_ulong extramask[TARGET_NSIG_WORDS-1];
4064
    struct target_sigcontext sc;
4065
};
4066
 
4067
typedef int target_greg_t;
4068
#define TARGET_NGREG 18
4069
typedef target_greg_t target_gregset_t[TARGET_NGREG];
4070

    
4071
typedef struct target_fpregset {
4072
    int f_fpcntl[3];
4073
    int f_fpregs[8*3];
4074
} target_fpregset_t;
4075

    
4076
struct target_mcontext {
4077
    int version;
4078
    target_gregset_t gregs;
4079
    target_fpregset_t fpregs;
4080
};
4081

    
4082
#define TARGET_MCONTEXT_VERSION 2
4083

    
4084
struct target_ucontext {
4085
    abi_ulong tuc_flags;
4086
    abi_ulong tuc_link;
4087
    target_stack_t tuc_stack;
4088
    struct target_mcontext tuc_mcontext;
4089
    abi_long tuc_filler[80];
4090
    target_sigset_t tuc_sigmask;
4091
};
4092

    
4093
struct target_rt_sigframe
4094
{
4095
    abi_ulong pretcode;
4096
    int sig;
4097
    abi_ulong pinfo;
4098
    abi_ulong puc;
4099
    char retcode[8];
4100
    struct target_siginfo info;
4101
    struct target_ucontext uc;
4102
};
4103

    
4104
static int
4105
setup_sigcontext(struct target_sigcontext *sc, CPUState *env, abi_ulong mask)
4106
{
4107
    int err = 0;
4108

    
4109
    err |= __put_user(mask, &sc->sc_mask);
4110
    err |= __put_user(env->aregs[7], &sc->sc_usp);
4111
    err |= __put_user(env->dregs[0], &sc->sc_d0);
4112
    err |= __put_user(env->dregs[1], &sc->sc_d1);
4113
    err |= __put_user(env->aregs[0], &sc->sc_a0);
4114
    err |= __put_user(env->aregs[1], &sc->sc_a1);
4115
    err |= __put_user(env->sr, &sc->sc_sr);
4116
    err |= __put_user(env->pc, &sc->sc_pc);
4117

    
4118
    return err;
4119
}
4120

    
4121
static int
4122
restore_sigcontext(CPUState *env, struct target_sigcontext *sc, int *pd0)
4123
{
4124
    int err = 0;
4125
    int temp;
4126

    
4127
    err |= __get_user(env->aregs[7], &sc->sc_usp);
4128
    err |= __get_user(env->dregs[1], &sc->sc_d1);
4129
    err |= __get_user(env->aregs[0], &sc->sc_a0);
4130
    err |= __get_user(env->aregs[1], &sc->sc_a1);
4131
    err |= __get_user(env->pc, &sc->sc_pc);
4132
    err |= __get_user(temp, &sc->sc_sr);
4133
    env->sr = (env->sr & 0xff00) | (temp & 0xff);
4134

    
4135
    *pd0 = tswapl(sc->sc_d0);
4136

    
4137
    return err;
4138
}
4139

    
4140
/*
4141
 * Determine which stack to use..
4142
 */
4143
static inline abi_ulong
4144
get_sigframe(struct target_sigaction *ka, CPUState *regs, size_t frame_size)
4145
{
4146
    unsigned long sp;
4147

    
4148
    sp = regs->aregs[7];
4149

    
4150
    /* This is the X/Open sanctioned signal stack switching.  */
4151
    if ((ka->sa_flags & TARGET_SA_ONSTACK) && (sas_ss_flags (sp) == 0)) {
4152
        sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
4153
    }
4154

    
4155
    return ((sp - frame_size) & -8UL);
4156
}
4157

    
4158
static void setup_frame(int sig, struct target_sigaction *ka,
4159
                        target_sigset_t *set, CPUState *env)
4160
{
4161
    struct target_sigframe *frame;
4162
    abi_ulong frame_addr;
4163
    abi_ulong retcode_addr;
4164
    abi_ulong sc_addr;
4165
    int err = 0;
4166
    int i;
4167

    
4168
    frame_addr = get_sigframe(ka, env, sizeof *frame);
4169
    if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
4170
        goto give_sigsegv;
4171

    
4172
    err |= __put_user(sig, &frame->sig);
4173

    
4174
    sc_addr = frame_addr + offsetof(struct target_sigframe, sc);
4175
    err |= __put_user(sc_addr, &frame->psc);
4176

    
4177
    err |= setup_sigcontext(&frame->sc, env, set->sig[0]);
4178
    if (err)
4179
        goto give_sigsegv;
4180

    
4181
    for(i = 1; i < TARGET_NSIG_WORDS; i++) {
4182
        if (__put_user(set->sig[i], &frame->extramask[i - 1]))
4183
            goto give_sigsegv;
4184
    }
4185

    
4186
    /* Set up to return from userspace.  */
4187

    
4188
    retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode);
4189
    err |= __put_user(retcode_addr, &frame->pretcode);
4190

    
4191
    /* moveq #,d0; trap #0 */
4192

    
4193
    err |= __put_user(0x70004e40 + (TARGET_NR_sigreturn << 16),
4194
                      (long *)(frame->retcode));
4195

    
4196
    if (err)
4197
        goto give_sigsegv;
4198

    
4199
    /* Set up to return from userspace */
4200

    
4201
    env->aregs[7] = frame_addr;
4202
    env->pc = ka->_sa_handler;
4203

    
4204
    unlock_user_struct(frame, frame_addr, 1);
4205
    return;
4206

    
4207
give_sigsegv:
4208
    unlock_user_struct(frame, frame_addr, 1);
4209
    force_sig(TARGET_SIGSEGV);
4210
}
4211

    
4212
static inline int target_rt_setup_ucontext(struct target_ucontext *uc,
4213
                                           CPUState *env)
4214
{
4215
    target_greg_t *gregs = uc->tuc_mcontext.gregs;
4216
    int err;
4217

    
4218
    err = __put_user(TARGET_MCONTEXT_VERSION, &uc->tuc_mcontext.version);
4219
    err |= __put_user(env->dregs[0], &gregs[0]);
4220
    err |= __put_user(env->dregs[1], &gregs[1]);
4221
    err |= __put_user(env->dregs[2], &gregs[2]);
4222
    err |= __put_user(env->dregs[3], &gregs[3]);
4223
    err |= __put_user(env->dregs[4], &gregs[4]);
4224
    err |= __put_user(env->dregs[5], &gregs[5]);
4225
    err |= __put_user(env->dregs[6], &gregs[6]);
4226
    err |= __put_user(env->dregs[7], &gregs[7]);
4227
    err |= __put_user(env->aregs[0], &gregs[8]);
4228
    err |= __put_user(env->aregs[1], &gregs[9]);
4229
    err |= __put_user(env->aregs[2], &gregs[10]);
4230
    err |= __put_user(env->aregs[3], &gregs[11]);
4231
    err |= __put_user(env->aregs[4], &gregs[12]);
4232
    err |= __put_user(env->aregs[5], &gregs[13]);
4233
    err |= __put_user(env->aregs[6], &gregs[14]);
4234
    err |= __put_user(env->aregs[7], &gregs[15]);
4235
    err |= __put_user(env->pc, &gregs[16]);
4236
    err |= __put_user(env->sr, &gregs[17]);
4237

    
4238
    return err;
4239
}
4240
 
4241
static inline int target_rt_restore_ucontext(CPUState *env,
4242
                                             struct target_ucontext *uc,
4243
                                             int *pd0)
4244
{
4245
    int temp;
4246
    int err;
4247
    target_greg_t *gregs = uc->tuc_mcontext.gregs;
4248
    
4249
    err = __get_user(temp, &uc->tuc_mcontext.version);
4250
    if (temp != TARGET_MCONTEXT_VERSION)
4251
        goto badframe;
4252

    
4253
    /* restore passed registers */
4254
    err |= __get_user(env->dregs[0], &gregs[0]);
4255
    err |= __get_user(env->dregs[1], &gregs[1]);
4256
    err |= __get_user(env->dregs[2], &gregs[2]);
4257
    err |= __get_user(env->dregs[3], &gregs[3]);
4258
    err |= __get_user(env->dregs[4], &gregs[4]);
4259
    err |= __get_user(env->dregs[5], &gregs[5]);
4260
    err |= __get_user(env->dregs[6], &gregs[6]);
4261
    err |= __get_user(env->dregs[7], &gregs[7]);
4262
    err |= __get_user(env->aregs[0], &gregs[8]);
4263
    err |= __get_user(env->aregs[1], &gregs[9]);
4264
    err |= __get_user(env->aregs[2], &gregs[10]);
4265
    err |= __get_user(env->aregs[3], &gregs[11]);
4266
    err |= __get_user(env->aregs[4], &gregs[12]);
4267
    err |= __get_user(env->aregs[5], &gregs[13]);
4268
    err |= __get_user(env->aregs[6], &gregs[14]);
4269
    err |= __get_user(env->aregs[7], &gregs[15]);
4270
    err |= __get_user(env->pc, &gregs[16]);
4271
    err |= __get_user(temp, &gregs[17]);
4272
    env->sr = (env->sr & 0xff00) | (temp & 0xff);
4273

    
4274
    *pd0 = env->dregs[0];
4275
    return err;
4276

    
4277
badframe:
4278
    return 1;
4279
}
4280

    
4281
static void setup_rt_frame(int sig, struct target_sigaction *ka,
4282
                           target_siginfo_t *info,
4283
                           target_sigset_t *set, CPUState *env)
4284
{
4285
    struct target_rt_sigframe *frame;
4286
    abi_ulong frame_addr;
4287
    abi_ulong retcode_addr;
4288
    abi_ulong info_addr;
4289
    abi_ulong uc_addr;
4290
    int err = 0;
4291
    int i;
4292

    
4293
    frame_addr = get_sigframe(ka, env, sizeof *frame);
4294
    if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0))
4295
        goto give_sigsegv;
4296

    
4297
    err |= __put_user(sig, &frame->sig);
4298

    
4299
    info_addr = frame_addr + offsetof(struct target_rt_sigframe, info);
4300
    err |= __put_user(info_addr, &frame->pinfo);
4301

    
4302
    uc_addr = frame_addr + offsetof(struct target_rt_sigframe, uc);
4303
    err |= __put_user(uc_addr, &frame->puc);
4304

    
4305
    err |= copy_siginfo_to_user(&frame->info, info);
4306

    
4307
    /* Create the ucontext */
4308

    
4309
    err |= __put_user(0, &frame->uc.tuc_flags);
4310
    err |= __put_user(0, &frame->uc.tuc_link);
4311
    err |= __put_user(target_sigaltstack_used.ss_sp,
4312
                      &frame->uc.tuc_stack.ss_sp);
4313
    err |= __put_user(sas_ss_flags(env->aregs[7]),
4314
                      &frame->uc.tuc_stack.ss_flags);
4315
    err |= __put_user(target_sigaltstack_used.ss_size,
4316
                      &frame->uc.tuc_stack.ss_size);
4317
    err |= target_rt_setup_ucontext(&frame->uc, env);
4318

    
4319
    if (err)
4320
            goto give_sigsegv;
4321

    
4322
    for(i = 0; i < TARGET_NSIG_WORDS; i++) {
4323
        if (__put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]))
4324
            goto give_sigsegv;
4325
    }
4326

    
4327
    /* Set up to return from userspace.  */
4328

    
4329
    retcode_addr = frame_addr + offsetof(struct target_sigframe, retcode);
4330
    err |= __put_user(retcode_addr, &frame->pretcode);
4331

    
4332
    /* moveq #,d0; notb d0; trap #0 */
4333

    
4334
    err |= __put_user(0x70004600 + ((TARGET_NR_rt_sigreturn ^ 0xff) << 16),
4335
                      (long *)(frame->retcode + 0));
4336
    err |= __put_user(0x4e40, (short *)(frame->retcode + 4));
4337

    
4338
    if (err)
4339
        goto give_sigsegv;
4340

    
4341
    /* Set up to return from userspace */
4342

    
4343
    env->aregs[7] = frame_addr;
4344
    env->pc = ka->_sa_handler;
4345

    
4346
    unlock_user_struct(frame, frame_addr, 1);
4347
    return;
4348

    
4349
give_sigsegv:
4350
    unlock_user_struct(frame, frame_addr, 1);
4351
    force_sig(TARGET_SIGSEGV);
4352
}
4353

    
4354
long do_sigreturn(CPUState *env)
4355
{
4356
    struct target_sigframe *frame;
4357
    abi_ulong frame_addr = env->aregs[7] - 4;
4358
    target_sigset_t target_set;
4359
    sigset_t set;
4360
    int d0, i;
4361

    
4362
    if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
4363
        goto badframe;
4364

    
4365
    /* set blocked signals */
4366

    
4367
    if (__get_user(target_set.sig[0], &frame->sc.sc_mask))
4368
        goto badframe;
4369

    
4370
    for(i = 1; i < TARGET_NSIG_WORDS; i++) {
4371
        if (__get_user(target_set.sig[i], &frame->extramask[i - 1]))
4372
            goto badframe;
4373
    }
4374

    
4375
    target_to_host_sigset_internal(&set, &target_set);
4376
    sigprocmask(SIG_SETMASK, &set, NULL);
4377

    
4378
    /* restore registers */
4379

    
4380
    if (restore_sigcontext(env, &frame->sc, &d0))
4381
        goto badframe;
4382

    
4383
    unlock_user_struct(frame, frame_addr, 0);
4384
    return d0;
4385

    
4386
badframe:
4387
    unlock_user_struct(frame, frame_addr, 0);
4388
    force_sig(TARGET_SIGSEGV);
4389
    return 0;
4390
}
4391

    
4392
long do_rt_sigreturn(CPUState *env)
4393
{
4394
    struct target_rt_sigframe *frame;
4395
    abi_ulong frame_addr = env->aregs[7] - 4;
4396
    target_sigset_t target_set;
4397
    sigset_t set;
4398
    int d0;
4399

    
4400
    if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
4401
        goto badframe;
4402

    
4403
    target_to_host_sigset_internal(&set, &target_set);
4404
    sigprocmask(SIG_SETMASK, &set, NULL);
4405

    
4406
    /* restore registers */
4407

    
4408
    if (target_rt_restore_ucontext(env, &frame->uc, &d0))
4409
        goto badframe;
4410

    
4411
    if (do_sigaltstack(frame_addr +
4412
                       offsetof(struct target_rt_sigframe, uc.tuc_stack),
4413
                       0, get_sp_from_cpustate(env)) == -EFAULT)
4414
        goto badframe;
4415

    
4416
    unlock_user_struct(frame, frame_addr, 0);
4417
    return d0;
4418

    
4419
badframe:
4420
    unlock_user_struct(frame, frame_addr, 0);
4421
    force_sig(TARGET_SIGSEGV);
4422
    return 0;
4423
}
4424

    
4425
#elif defined(TARGET_ALPHA)
4426

    
4427
struct target_sigcontext {
4428
    abi_long sc_onstack;
4429
    abi_long sc_mask;
4430
    abi_long sc_pc;
4431
    abi_long sc_ps;
4432
    abi_long sc_regs[32];
4433
    abi_long sc_ownedfp;
4434
    abi_long sc_fpregs[32];
4435
    abi_ulong sc_fpcr;
4436
    abi_ulong sc_fp_control;
4437
    abi_ulong sc_reserved1;
4438
    abi_ulong sc_reserved2;
4439
    abi_ulong sc_ssize;
4440
    abi_ulong sc_sbase;
4441
    abi_ulong sc_traparg_a0;
4442
    abi_ulong sc_traparg_a1;
4443
    abi_ulong sc_traparg_a2;
4444
    abi_ulong sc_fp_trap_pc;
4445
    abi_ulong sc_fp_trigger_sum;
4446
    abi_ulong sc_fp_trigger_inst;
4447
};
4448

    
4449
struct target_ucontext {
4450
    abi_ulong tuc_flags;
4451
    abi_ulong tuc_link;
4452
    abi_ulong tuc_osf_sigmask;
4453
    target_stack_t tuc_stack;
4454
    struct target_sigcontext tuc_mcontext;
4455
    target_sigset_t tuc_sigmask;
4456
};
4457

    
4458
struct target_sigframe {
4459
    struct target_sigcontext sc;
4460
    unsigned int retcode[3];
4461
};
4462

    
4463
struct target_rt_sigframe {
4464
    target_siginfo_t info;
4465
    struct target_ucontext uc;
4466
    unsigned int retcode[3];
4467
};
4468

    
4469
#define INSN_MOV_R30_R16        0x47fe0410
4470
#define INSN_LDI_R0             0x201f0000
4471
#define INSN_CALLSYS            0x00000083
4472

    
4473
static int setup_sigcontext(struct target_sigcontext *sc, CPUState *env,
4474
                            abi_ulong frame_addr, target_sigset_t *set)
4475
{
4476
    int i, err = 0;
4477

    
4478
    err |= __put_user(on_sig_stack(frame_addr), &sc->sc_onstack);
4479
    err |= __put_user(set->sig[0], &sc->sc_mask);
4480
    err |= __put_user(env->pc, &sc->sc_pc);
4481
    err |= __put_user(8, &sc->sc_ps);
4482

    
4483
    for (i = 0; i < 31; ++i) {
4484
        err |= __put_user(env->ir[i], &sc->sc_regs[i]);
4485
    }
4486
    err |= __put_user(0, &sc->sc_regs[31]);
4487

    
4488
    for (i = 0; i < 31; ++i) {
4489
        err |= __put_user(env->fir[i], &sc->sc_fpregs[i]);
4490
    }
4491
    err |= __put_user(0, &sc->sc_fpregs[31]);
4492
    err |= __put_user(cpu_alpha_load_fpcr(env), &sc->sc_fpcr);
4493

    
4494
    err |= __put_user(0, &sc->sc_traparg_a0); /* FIXME */
4495
    err |= __put_user(0, &sc->sc_traparg_a1); /* FIXME */
4496
    err |= __put_user(0, &sc->sc_traparg_a2); /* FIXME */
4497

    
4498
    return err;
4499
}
4500

    
4501
static int restore_sigcontext(CPUState *env, struct target_sigcontext *sc)
4502
{
4503
    uint64_t fpcr;
4504
    int i, err = 0;
4505

    
4506
    err |= __get_user(env->pc, &sc->sc_pc);
4507

    
4508
    for (i = 0; i < 31; ++i) {
4509
        err |= __get_user(env->ir[i], &sc->sc_regs[i]);
4510
    }
4511
    for (i = 0; i < 31; ++i) {
4512
        err |= __get_user(env->fir[i], &sc->sc_fpregs[i]);
4513
    }
4514

    
4515
    err |= __get_user(fpcr, &sc->sc_fpcr);
4516
    cpu_alpha_store_fpcr(env, fpcr);
4517

    
4518
    return err;
4519
}
4520

    
4521
static inline abi_ulong get_sigframe(struct target_sigaction *sa,
4522
                                     CPUState *env, unsigned long framesize)
4523
{
4524
    abi_ulong sp = env->ir[IR_SP];
4525

    
4526
    /* This is the X/Open sanctioned signal stack switching.  */
4527
    if ((sa->sa_flags & TARGET_SA_ONSTACK) != 0 && !sas_ss_flags(sp)) {
4528
        sp = target_sigaltstack_used.ss_sp + target_sigaltstack_used.ss_size;
4529
    }
4530
    return (sp - framesize) & -32;
4531
}
4532

    
4533
static void setup_frame(int sig, struct target_sigaction *ka,
4534
                        target_sigset_t *set, CPUState *env)
4535
{
4536
    abi_ulong frame_addr, r26;
4537
    struct target_sigframe *frame;
4538
    int err = 0;
4539

    
4540
    frame_addr = get_sigframe(ka, env, sizeof(*frame));
4541
    if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
4542
        goto give_sigsegv;
4543
    }
4544

    
4545
    err |= setup_sigcontext(&frame->sc, env, frame_addr, set);
4546

    
4547
    if (ka->sa_restorer) {
4548
        r26 = ka->sa_restorer;
4549
    } else {
4550
        err |= __put_user(INSN_MOV_R30_R16, &frame->retcode[0]);
4551
        err |= __put_user(INSN_LDI_R0 + TARGET_NR_sigreturn,
4552
                          &frame->retcode[1]);
4553
        err |= __put_user(INSN_CALLSYS, &frame->retcode[2]);
4554
        /* imb() */
4555
        r26 = frame_addr;
4556
    }
4557

    
4558
    unlock_user_struct(frame, frame_addr, 1);
4559

    
4560
    if (err) {
4561
    give_sigsegv:
4562
        if (sig == TARGET_SIGSEGV) {
4563
            ka->_sa_handler = TARGET_SIG_DFL;
4564
        }
4565
        force_sig(TARGET_SIGSEGV);
4566
    }
4567

    
4568
    env->ir[IR_RA] = r26;
4569
    env->ir[IR_PV] = env->pc = ka->_sa_handler;
4570
    env->ir[IR_A0] = sig;
4571
    env->ir[IR_A1] = 0;
4572
    env->ir[IR_A2] = frame_addr + offsetof(struct target_sigframe, sc);
4573
    env->ir[IR_SP] = frame_addr;
4574
}
4575

    
4576
static void setup_rt_frame(int sig, struct target_sigaction *ka,
4577
                           target_siginfo_t *info,
4578
                           target_sigset_t *set, CPUState *env)
4579
{
4580
    abi_ulong frame_addr, r26;
4581
    struct target_rt_sigframe *frame;
4582
    int i, err = 0;
4583

    
4584
    frame_addr = get_sigframe(ka, env, sizeof(*frame));
4585
    if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
4586
        goto give_sigsegv;
4587
    }
4588

    
4589
    err |= copy_siginfo_to_user(&frame->info, info);
4590

    
4591
    err |= __put_user(0, &frame->uc.tuc_flags);
4592
    err |= __put_user(0, &frame->uc.tuc_link);
4593
    err |= __put_user(set->sig[0], &frame->uc.tuc_osf_sigmask);
4594
    err |= __put_user(target_sigaltstack_used.ss_sp,
4595
                      &frame->uc.tuc_stack.ss_sp);
4596
    err |= __put_user(sas_ss_flags(env->ir[IR_SP]),
4597
                      &frame->uc.tuc_stack.ss_flags);
4598
    err |= __put_user(target_sigaltstack_used.ss_size,
4599
                      &frame->uc.tuc_stack.ss_size);
4600
    err |= setup_sigcontext(&frame->uc.tuc_mcontext, env, frame_addr, set);
4601
    for (i = 0; i < TARGET_NSIG_WORDS; ++i) {
4602
        err |= __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
4603
    }
4604

    
4605
    if (ka->sa_restorer) {
4606
        r26 = ka->sa_restorer;
4607
    } else {
4608
        err |= __put_user(INSN_MOV_R30_R16, &frame->retcode[0]);
4609
        err |= __put_user(INSN_LDI_R0 + TARGET_NR_rt_sigreturn,
4610
                          &frame->retcode[1]);
4611
        err |= __put_user(INSN_CALLSYS, &frame->retcode[2]);
4612
        /* imb(); */
4613
        r26 = frame_addr;
4614
    }
4615

    
4616
    if (err) {
4617
    give_sigsegv:
4618
       if (sig == TARGET_SIGSEGV) {
4619
            ka->_sa_handler = TARGET_SIG_DFL;
4620
        }
4621
        force_sig(TARGET_SIGSEGV);
4622
    }
4623

    
4624
    env->ir[IR_RA] = r26;
4625
    env->ir[IR_PV] = env->pc = ka->_sa_handler;
4626
    env->ir[IR_A0] = sig;
4627
    env->ir[IR_A1] = frame_addr + offsetof(struct target_rt_sigframe, info);
4628
    env->ir[IR_A2] = frame_addr + offsetof(struct target_rt_sigframe, uc);
4629
    env->ir[IR_SP] = frame_addr;
4630
}
4631

    
4632
long do_sigreturn(CPUState *env)
4633
{
4634
    struct target_sigcontext *sc;
4635
    abi_ulong sc_addr = env->ir[IR_A0];
4636
    target_sigset_t target_set;
4637
    sigset_t set;
4638

    
4639
    if (!lock_user_struct(VERIFY_READ, sc, sc_addr, 1)) {
4640
        goto badframe;
4641
    }
4642

    
4643
    target_sigemptyset(&target_set);
4644
    if (__get_user(target_set.sig[0], &sc->sc_mask)) {
4645
        goto badframe;
4646
    }
4647

    
4648
    target_to_host_sigset_internal(&set, &target_set);
4649
    sigprocmask(SIG_SETMASK, &set, NULL);
4650

    
4651
    if (restore_sigcontext(env, sc)) {
4652
        goto badframe;
4653
    }
4654
    unlock_user_struct(sc, sc_addr, 0);
4655
    return env->ir[IR_V0];
4656

    
4657
 badframe:
4658
    unlock_user_struct(sc, sc_addr, 0);
4659
    force_sig(TARGET_SIGSEGV);
4660
}
4661

    
4662
long do_rt_sigreturn(CPUState *env)
4663
{
4664
    abi_ulong frame_addr = env->ir[IR_A0];
4665
    struct target_rt_sigframe *frame;
4666
    sigset_t set;
4667

    
4668
    if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
4669
        goto badframe;
4670
    }
4671
    target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
4672
    sigprocmask(SIG_SETMASK, &set, NULL);
4673

    
4674
    if (restore_sigcontext(env, &frame->uc.tuc_mcontext)) {
4675
        goto badframe;
4676
    }
4677
    if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe,
4678
                                             uc.tuc_stack),
4679
                       0, env->ir[IR_SP]) == -EFAULT) {
4680
        goto badframe;
4681
    }
4682

    
4683
    unlock_user_struct(frame, frame_addr, 0);
4684
    return env->ir[IR_V0];
4685

    
4686

    
4687
 badframe:
4688
    unlock_user_struct(frame, frame_addr, 0);
4689
    force_sig(TARGET_SIGSEGV);
4690
}
4691

    
4692
#else
4693

    
4694
static void setup_frame(int sig, struct target_sigaction *ka,
4695
                        target_sigset_t *set, CPUState *env)
4696
{
4697
    fprintf(stderr, "setup_frame: not implemented\n");
4698
}
4699

    
4700
static void setup_rt_frame(int sig, struct target_sigaction *ka,
4701
                           target_siginfo_t *info,
4702
                           target_sigset_t *set, CPUState *env)
4703
{
4704
    fprintf(stderr, "setup_rt_frame: not implemented\n");
4705
}
4706

    
4707
long do_sigreturn(CPUState *env)
4708
{
4709
    fprintf(stderr, "do_sigreturn: not implemented\n");
4710
    return -TARGET_ENOSYS;
4711
}
4712

    
4713
long do_rt_sigreturn(CPUState *env)
4714
{
4715
    fprintf(stderr, "do_rt_sigreturn: not implemented\n");
4716
    return -TARGET_ENOSYS;
4717
}
4718

    
4719
#endif
4720

    
4721
void process_pending_signals(CPUState *cpu_env)
4722
{
4723
    int sig;
4724
    abi_ulong handler;
4725
    sigset_t set, old_set;
4726
    target_sigset_t target_old_set;
4727
    struct emulated_sigtable *k;
4728
    struct target_sigaction *sa;
4729
    struct sigqueue *q;
4730
    TaskState *ts = cpu_env->opaque;
4731

    
4732
    if (!ts->signal_pending)
4733
        return;
4734

    
4735
    /* FIXME: This is not threadsafe.  */
4736
    k = ts->sigtab;
4737
    for(sig = 1; sig <= TARGET_NSIG; sig++) {
4738
        if (k->pending)
4739
            goto handle_signal;
4740
        k++;
4741
    }
4742
    /* if no signal is pending, just return */
4743
    ts->signal_pending = 0;
4744
    return;
4745

    
4746
 handle_signal:
4747
#ifdef DEBUG_SIGNAL
4748
    fprintf(stderr, "qemu: process signal %d\n", sig);
4749
#endif
4750
    /* dequeue signal */
4751
    q = k->first;
4752
    k->first = q->next;
4753
    if (!k->first)
4754
        k->pending = 0;
4755

    
4756
    sig = gdb_handlesig (cpu_env, sig);
4757
    if (!sig) {
4758
        sa = NULL;
4759
        handler = TARGET_SIG_IGN;
4760
    } else {
4761
        sa = &sigact_table[sig - 1];
4762
        handler = sa->_sa_handler;
4763
    }
4764

    
4765
    if (handler == TARGET_SIG_DFL) {
4766
        /* default handler : ignore some signal. The other are job control or fatal */
4767
        if (sig == TARGET_SIGTSTP || sig == TARGET_SIGTTIN || sig == TARGET_SIGTTOU) {
4768
            kill(getpid(),SIGSTOP);
4769
        } else if (sig != TARGET_SIGCHLD &&
4770
                   sig != TARGET_SIGURG &&
4771
                   sig != TARGET_SIGWINCH &&
4772
                   sig != TARGET_SIGCONT) {
4773
            force_sig(sig);
4774
        }
4775
    } else if (handler == TARGET_SIG_IGN) {
4776
        /* ignore sig */
4777
    } else if (handler == TARGET_SIG_ERR) {
4778
        force_sig(sig);
4779
    } else {
4780
        /* compute the blocked signals during the handler execution */
4781
        target_to_host_sigset(&set, &sa->sa_mask);
4782
        /* SA_NODEFER indicates that the current signal should not be
4783
           blocked during the handler */
4784
        if (!(sa->sa_flags & TARGET_SA_NODEFER))
4785
            sigaddset(&set, target_to_host_signal(sig));
4786

    
4787
        /* block signals in the handler using Linux */
4788
        sigprocmask(SIG_BLOCK, &set, &old_set);
4789
        /* save the previous blocked signal state to restore it at the
4790
           end of the signal execution (see do_sigreturn) */
4791
        host_to_target_sigset_internal(&target_old_set, &old_set);
4792

    
4793
        /* if the CPU is in VM86 mode, we restore the 32 bit values */
4794
#if defined(TARGET_I386) && !defined(TARGET_X86_64)
4795
        {
4796
            CPUX86State *env = cpu_env;
4797
            if (env->eflags & VM_MASK)
4798
                save_v86_state(env);
4799
        }
4800
#endif
4801
        /* prepare the stack frame of the virtual CPU */
4802
        if (sa->sa_flags & TARGET_SA_SIGINFO)
4803
            setup_rt_frame(sig, sa, &q->info, &target_old_set, cpu_env);
4804
        else
4805
            setup_frame(sig, sa, &target_old_set, cpu_env);
4806
        if (sa->sa_flags & TARGET_SA_RESETHAND)
4807
            sa->_sa_handler = TARGET_SIG_DFL;
4808
    }
4809
    if (q != &k->info)
4810
        free_sigqueue(cpu_env, q);
4811
}