Revision 60e99246

b/cpu-exec.c
81 81
    if (puc) {
82 82
        /* XXX: use siglongjmp ? */
83 83
#ifdef __linux__
84
#ifdef __ia64
85
        sigprocmask(SIG_SETMASK, (sigset_t *)&uc->uc_sigmask, NULL);
86
#else
84 87
        sigprocmask(SIG_SETMASK, &uc->uc_sigmask, NULL);
88
#endif
85 89
#elif defined(__OpenBSD__)
86 90
        sigprocmask(SIG_SETMASK, &uc->sc_mask, NULL);
87 91
#endif
......
1150 1154
    }
1151 1155
    return handle_cpu_signal(ip, (unsigned long)info->si_addr,
1152 1156
                             is_write,
1153
                             &uc->uc_sigmask, puc);
1157
                             (sigset_t *)&uc->uc_sigmask, puc);
1154 1158
}
1155 1159

  
1156 1160
#elif defined(__s390__)
b/linux-user/signal.c
2052 2052
} target_mcontext_t;
2053 2053

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

  
2061 2061
/* A V9 register window */
......
2081 2081
    ucp_addr = env->regwptr[UREG_I0];
2082 2082
    if (!lock_user_struct(VERIFY_READ, ucp, ucp_addr, 1))
2083 2083
        goto do_sigsegv;
2084
    grp  = &ucp->uc_mcontext.mc_gregs;
2084
    grp  = &ucp->tuc_mcontext.mc_gregs;
2085 2085
    err  = __get_user(pc, &((*grp)[MC_PC]));
2086 2086
    err |= __get_user(npc, &((*grp)[MC_NPC]));
2087 2087
    if (err || ((pc | npc) & 3))
......
2091 2091
        sigset_t set;
2092 2092

  
2093 2093
        if (TARGET_NSIG_WORDS == 1) {
2094
            if (__get_user(target_set.sig[0], &ucp->uc_sigmask.sig[0]))
2094
            if (__get_user(target_set.sig[0], &ucp->tuc_sigmask.sig[0]))
2095 2095
                goto do_sigsegv;
2096 2096
        } else {
2097 2097
            abi_ulong *src, *dst;
2098
            src = ucp->uc_sigmask.sig;
2098
            src = ucp->tuc_sigmask.sig;
2099 2099
            dst = target_set.sig;
2100 2100
            for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong);
2101 2101
                 i++, dst++, src++)
......
2129 2129
    err |= __get_user(env->regwptr[UREG_I6], (&(*grp)[MC_O6]));
2130 2130
    err |= __get_user(env->regwptr[UREG_I7], (&(*grp)[MC_O7]));
2131 2131

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

  
2135 2135
    w_addr = TARGET_STACK_BIAS+env->regwptr[UREG_I6];
2136 2136
    if (put_user(fp, w_addr + offsetof(struct target_reg_window, ins[6]), 
......
2139 2139
    if (put_user(i7, w_addr + offsetof(struct target_reg_window, ins[7]), 
2140 2140
                 abi_ulong) != 0)
2141 2141
        goto do_sigsegv;
2142
    err |= __get_user(fenab, &(ucp->uc_mcontext.mc_fpregs.mcfpu_enab));
2143
    err |= __get_user(env->fprs, &(ucp->uc_mcontext.mc_fpregs.mcfpu_fprs));
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 2144
    {
2145 2145
        uint32_t *src, *dst;
2146
        src = ucp->uc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2146
        src = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2147 2147
        dst = env->fpr;
2148 2148
        /* XXX: check that the CPU storage is the same as user context */
2149 2149
        for (i = 0; i < 64; i++, dst++, src++)
2150 2150
            err |= __get_user(*dst, src);
2151 2151
    }
2152 2152
    err |= __get_user(env->fsr,
2153
                      &(ucp->uc_mcontext.mc_fpregs.mcfpu_fsr));
2153
                      &(ucp->tuc_mcontext.mc_fpregs.mcfpu_fsr));
2154 2154
    err |= __get_user(env->gsr,
2155
                      &(ucp->uc_mcontext.mc_fpregs.mcfpu_gsr));
2155
                      &(ucp->tuc_mcontext.mc_fpregs.mcfpu_gsr));
2156 2156
    if (err)
2157 2157
        goto do_sigsegv;
2158 2158
    unlock_user_struct(ucp, ucp_addr, 0);
......
2178 2178
    if (!lock_user_struct(VERIFY_WRITE, ucp, ucp_addr, 0))
2179 2179
        goto do_sigsegv;
2180 2180
    
2181
    mcp = &ucp->uc_mcontext;
2181
    mcp = &ucp->tuc_mcontext;
2182 2182
    grp = &mcp->mc_gregs;
2183 2183

  
2184 2184
    /* Skip over the trap instruction, first. */
......
2191 2191
    host_to_target_sigset_internal(&target_set, &set);
2192 2192
    if (TARGET_NSIG_WORDS == 1) {
2193 2193
        err |= __put_user(target_set.sig[0],
2194
                          (abi_ulong *)&ucp->uc_sigmask);
2194
                          (abi_ulong *)&ucp->tuc_sigmask);
2195 2195
    } else {
2196 2196
        abi_ulong *src, *dst;
2197 2197
        src = target_set.sig;
2198
        dst = ucp->uc_sigmask.sig;
2198
        dst = ucp->tuc_sigmask.sig;
2199 2199
        for (i = 0; i < sizeof(target_sigset_t) / sizeof(abi_ulong);
2200 2200
             i++, dst++, src++)
2201 2201
            err |= __put_user(*src, dst);
......
2238 2238
    {
2239 2239
        uint32_t *src, *dst;
2240 2240
        src = env->fpr;
2241
        dst = ucp->uc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2241
        dst = ucp->tuc_mcontext.mc_fpregs.mcfpu_fregs.sregs;
2242 2242
        /* XXX: check that the CPU storage is the same as user context */
2243 2243
        for (i = 0; i < 64; i++, dst++, src++)
2244 2244
            err |= __put_user(*src, dst);
......
2346 2346
};
2347 2347

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

  
2357 2357
struct target_rt_sigframe {
......
2663 2663

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

  
2666
    __put_user(0, &frame->rs_uc.uc_flags);
2667
    __put_user(0, &frame->rs_uc.uc_link);
2668
    __put_user(target_sigaltstack_used.ss_sp, &frame->rs_uc.uc_stack.ss_sp);
2669
    __put_user(target_sigaltstack_used.ss_size, &frame->rs_uc.uc_stack.ss_size);
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 2670
    __put_user(sas_ss_flags(get_sp_from_cpustate(env)),
2671
               &frame->rs_uc.uc_stack.ss_flags);
2671
               &frame->rs_uc.tuc_stack.ss_flags);
2672 2672

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

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

  
2679 2679
    /*
......
2720 2720
    if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
2721 2721
   	goto badframe;
2722 2722

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

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

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

  
......
2779 2779

  
2780 2780

  
2781 2781
struct target_ucontext {
2782
    target_ulong uc_flags;
2783
    struct target_ucontext *uc_link;
2784
    target_stack_t uc_stack;
2785
    struct target_sigcontext uc_mcontext;
2786
    target_sigset_t uc_sigmask;	/* mask last for extensibility */
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 2787
};
2788 2788

  
2789 2789
struct target_rt_sigframe
......
2940 2940
    err |= copy_siginfo_to_user(&frame->info, info);
2941 2941

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

  
2957 2957
    /* Set up to return from userspace.  If provided, use a stub
......
3038 3038
    if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1))
3039 3039
   	goto badframe;
3040 3040

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

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

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

  
......
3555 3555
};
3556 3556

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

  
......
3883 3883

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

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

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

  
3903 3903
    /* The kernel checks for the presence of a VDSO here.  We don't
......
3985 3985
    sigset_t blocked;
3986 3986
    target_sigset_t set;
3987 3987

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

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

  
3999 3999
    if (!lock_user_struct(VERIFY_READ, mcp, mcp_addr, 1))
......
4026 4026
        goto sigsegv;
4027 4027

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

  
4032 4032
    unlock_user_struct(rt_sf, rt_sf_addr, 1);
......
4082 4082
#define TARGET_MCONTEXT_VERSION 2
4083 4083

  
4084 4084
struct target_ucontext {
4085
    abi_ulong uc_flags;
4086
    abi_ulong uc_link;
4087
    target_stack_t uc_stack;
4088
    struct target_mcontext uc_mcontext;
4089
    abi_long uc_filler[80];
4090
    target_sigset_t uc_sigmask;
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 4091
};
4092 4092

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

  
4218
    err = __put_user(TARGET_MCONTEXT_VERSION, &uc->uc_mcontext.version);
4218
    err = __put_user(TARGET_MCONTEXT_VERSION, &uc->tuc_mcontext.version);
4219 4219
    err |= __put_user(env->dregs[0], &gregs[0]);
4220 4220
    err |= __put_user(env->dregs[1], &gregs[1]);
4221 4221
    err |= __put_user(env->dregs[2], &gregs[2]);
......
4244 4244
{
4245 4245
    int temp;
4246 4246
    int err;
4247
    target_greg_t *gregs = uc->uc_mcontext.gregs;
4247
    target_greg_t *gregs = uc->tuc_mcontext.gregs;
4248 4248
    
4249
    err = __get_user(temp, &uc->uc_mcontext.version);
4249
    err = __get_user(temp, &uc->tuc_mcontext.version);
4250 4250
    if (temp != TARGET_MCONTEXT_VERSION)
4251 4251
        goto badframe;
4252 4252

  
......
4306 4306

  
4307 4307
    /* Create the ucontext */
4308 4308

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

  
4319 4319
    if (err)
4320 4320
            goto give_sigsegv;
4321 4321

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

  
......
4409 4409
        goto badframe;
4410 4410

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

  
......
4447 4447
};
4448 4448

  
4449 4449
struct target_ucontext {
4450
    abi_ulong uc_flags;
4451
    abi_ulong uc_link;
4452
    abi_ulong uc_osf_sigmask;
4453
    target_stack_t uc_stack;
4454
    struct target_sigcontext uc_mcontext;
4455
    target_sigset_t uc_sigmask;
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 4456
};
4457 4457

  
4458 4458
struct target_sigframe {
......
4588 4588

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

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

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

  
4674
    if (restore_sigcontext(env, &frame->uc.uc_mcontext)) {
4674
    if (restore_sigcontext(env, &frame->uc.tuc_mcontext)) {
4675 4675
        goto badframe;
4676 4676
    }
4677 4677
    if (do_sigaltstack(frame_addr + offsetof(struct target_rt_sigframe,
4678
                                             uc.uc_stack),
4678
                                             uc.tuc_stack),
4679 4679
                       0, env->ir[IR_SP]) == -EFAULT) {
4680 4680
        goto badframe;
4681 4681
    }
b/linux-user/syscall.c
41 41
#include <sys/swap.h>
42 42
#include <signal.h>
43 43
#include <sched.h>
44
#ifdef __ia64__
45
int __clone2(int (*fn)(void *), void *child_stack_base,
46
             size_t stack_size, int flags, void *arg, ...);
47
#endif
44 48
#include <sys/socket.h>
45 49
#include <sys/un.h>
46 50
#include <sys/uio.h>
......
3628 3632
            return -EINVAL;
3629 3633
        /* This is probably going to die very quickly, but do it anyway.  */
3630 3634
#ifdef __ia64__
3631
        ret = __clone2(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env);
3635
        ret = __clone2(clone_func, new_stack, NEW_STACK_SIZE, flags, new_env);
3632 3636
#else
3633 3637
	ret = clone(clone_func, new_stack + NEW_STACK_SIZE, flags, new_env);
3634 3638
#endif

Also available in: Unified diff