qemu

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

26
struct target_sigcontext {
27
    abi_ulong sc_flags;
28
    abi_ulong sc_gr[32];
29
    abi_ullong sc_fr[32];
30
    abi_ulong sc_iasq[2];
31
    abi_ulong sc_iaoq[2];
32
    abi_ulong sc_sar;
33
};
34

35
struct target_ucontext {
36
    abi_uint tuc_flags;
37
    abi_ulong tuc_link;
38
    target_stack_t tuc_stack;
39
    abi_uint pad[1];
40
    struct target_sigcontext tuc_mcontext;
41
    target_sigset_t tuc_sigmask;
42
};
43

44
struct target_rt_sigframe {
45
    abi_uint tramp[2];  /* syscall restart return address */
46
    target_siginfo_t info;
47
    struct target_ucontext uc;
48
    /* hidden location of upper halves of pa2.0 64-bit gregs */
49
};
50

51
QEMU_BUILD_BUG_ON(sizeof(struct target_rt_sigframe) != sizeof_rt_sigframe);
52
QEMU_BUILD_BUG_ON(offsetof(struct target_rt_sigframe, uc.tuc_mcontext)
53
                  != offsetof_sigcontext);
54
QEMU_BUILD_BUG_ON(offsetof(struct target_sigcontext, sc_gr)
55
                  != offsetof_sigcontext_gr);
56
QEMU_BUILD_BUG_ON(offsetof(struct target_sigcontext, sc_fr)
57
                  != offsetof_sigcontext_fr);
58
QEMU_BUILD_BUG_ON(offsetof(struct target_sigcontext, sc_iaoq)
59
                  != offsetof_sigcontext_iaoq);
60
QEMU_BUILD_BUG_ON(offsetof(struct target_sigcontext, sc_sar)
61
                  != offsetof_sigcontext_sar);
62

63

64
static void setup_sigcontext(struct target_sigcontext *sc, CPUArchState *env)
65
{
66
    int i;
67

68
    __put_user(env->iaoq_f, &sc->sc_iaoq[0]);
69
    __put_user(env->iaoq_b, &sc->sc_iaoq[1]);
70
    __put_user(0, &sc->sc_iasq[0]);
71
    __put_user(0, &sc->sc_iasq[1]);
72
    __put_user(0, &sc->sc_flags);
73

74
    __put_user(cpu_hppa_get_psw(env), &sc->sc_gr[0]);
75
    for (i = 1; i < 32; ++i) {
76
        __put_user(env->gr[i], &sc->sc_gr[i]);
77
    }
78

79
    __put_user((uint64_t)env->fr0_shadow << 32, &sc->sc_fr[0]);
80
    for (i = 1; i < 32; ++i) {
81
        __put_user(env->fr[i], &sc->sc_fr[i]);
82
    }
83

84
    __put_user(env->cr[CR_SAR], &sc->sc_sar);
85
}
86

87
static void restore_sigcontext(CPUArchState *env, struct target_sigcontext *sc)
88
{
89
    abi_ulong psw;
90
    int i;
91

92
    __get_user(psw, &sc->sc_gr[0]);
93
    cpu_hppa_put_psw(env, psw);
94

95
    for (i = 1; i < 32; ++i) {
96
        __get_user(env->gr[i], &sc->sc_gr[i]);
97
    }
98
    for (i = 0; i < 32; ++i) {
99
        __get_user(env->fr[i], &sc->sc_fr[i]);
100
    }
101
    cpu_hppa_loaded_fr0(env);
102

103
    __get_user(env->iaoq_f, &sc->sc_iaoq[0]);
104
    env->iaoq_f |= PRIV_USER;
105
    __get_user(env->iaoq_b, &sc->sc_iaoq[1]);
106
    env->iaoq_b |= PRIV_USER;
107
    __get_user(env->cr[CR_SAR], &sc->sc_sar);
108
}
109

110
void setup_rt_frame(int sig, struct target_sigaction *ka,
111
                    target_siginfo_t *info,
112
                    target_sigset_t *set, CPUArchState *env)
113
{
114
    abi_ulong frame_addr, sp, haddr;
115
    struct target_rt_sigframe *frame;
116
    int i;
117
    TaskState *ts = get_task_state(thread_cpu);
118

119
    sp = get_sp_from_cpustate(env);
120
    if ((ka->sa_flags & TARGET_SA_ONSTACK) && !sas_ss_flags(sp)) {
121
        sp = (ts->sigaltstack_used.ss_sp + 0x7f) & ~0x3f;
122
    }
123
    frame_addr = QEMU_ALIGN_UP(sp, SIGFRAME);
124
    sp = frame_addr + PARISC_RT_SIGFRAME_SIZE32;
125

126
    trace_user_setup_rt_frame(env, frame_addr);
127

128
    if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) {
129
        goto give_sigsegv;
130
    }
131

132
    frame->info = *info;
133
    frame->uc.tuc_flags = 0;
134
    frame->uc.tuc_link = 0;
135

136
    target_save_altstack(&frame->uc.tuc_stack, env);
137

138
    for (i = 0; i < TARGET_NSIG_WORDS; i++) {
139
        __put_user(set->sig[i], &frame->uc.tuc_sigmask.sig[i]);
140
    }
141

142
    setup_sigcontext(&frame->uc.tuc_mcontext, env);
143

144
    unlock_user_struct(frame, frame_addr, 1);
145

146
    env->gr[2] = default_rt_sigreturn;
147
    env->gr[30] = sp;
148
    env->gr[26] = sig;
149
    env->gr[25] = h2g(&frame->info);
150
    env->gr[24] = h2g(&frame->uc);
151

152
    haddr = ka->_sa_handler;
153
    if (haddr & 2) {
154
        /* Function descriptor.  */
155
        abi_ptr *fdesc, dest;
156

157
        haddr &= -4;
158
        fdesc = lock_user(VERIFY_READ, haddr, 2 * sizeof(abi_ptr), 1);
159
        if (!fdesc) {
160
            goto give_sigsegv;
161
        }
162
        __get_user(dest, fdesc);
163
        __get_user(env->gr[19], fdesc + 1);
164
        unlock_user(fdesc, haddr, 0);
165
        haddr = dest;
166
    }
167
    env->iaoq_f = haddr | PRIV_USER;
168
    env->iaoq_b = env->iaoq_f + 4;
169
    env->psw_n = 0;
170
    return;
171

172
 give_sigsegv:
173
    force_sigsegv(sig);
174
}
175

176
long do_rt_sigreturn(CPUArchState *env)
177
{
178
    abi_ulong frame_addr = env->gr[30] - PARISC_RT_SIGFRAME_SIZE32;
179
    struct target_rt_sigframe *frame;
180
    sigset_t set;
181

182
    trace_user_do_rt_sigreturn(env, frame_addr);
183
    if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
184
        goto badframe;
185
    }
186
    target_to_host_sigset(&set, &frame->uc.tuc_sigmask);
187
    set_sigmask(&set);
188

189
    restore_sigcontext(env, &frame->uc.tuc_mcontext);
190
    target_restore_altstack(&frame->uc.tuc_stack, env);
191

192
    unlock_user_struct(frame, frame_addr, 0);
193
    return -QEMU_ESIGRETURN;
194

195
 badframe:
196
    force_sig(TARGET_SIGSEGV);
197
    return -QEMU_ESIGRETURN;
198
}
199

200
void setup_sigtramp(abi_ulong sigtramp_page)
201
{
202
    uint32_t *tramp = lock_user(VERIFY_WRITE, sigtramp_page, 6*4, 0);
203
    abi_ulong SIGFRAME_CONTEXT_REGS32;
204
    assert(tramp != NULL);
205

206
    SIGFRAME_CONTEXT_REGS32 = offsetof(struct target_rt_sigframe, uc.tuc_mcontext);
207
    SIGFRAME_CONTEXT_REGS32 -= PARISC_RT_SIGFRAME_SIZE32;
208

209
    __put_user(SIGFRAME_CONTEXT_REGS32, tramp + 0);
210
    __put_user(0x08000240, tramp + 1);  /* nop - b/c dwarf2 unwind routines */
211
    __put_user(0x34190000, tramp + 2);  /* ldi 0, %r25 (in_syscall=0) */
212
    __put_user(0x3414015a, tramp + 3);  /* ldi __NR_rt_sigreturn, %r20 */
213
    __put_user(0xe4008200, tramp + 4);  /* ble 0x100(%sr2, %r0) */
214
    __put_user(0x08000240, tramp + 5);  /* nop */
215

216
    default_rt_sigreturn = (sigtramp_page + 8) | 3;
217
    unlock_user(tramp, sigtramp_page, 6*4);
218
}
219