← Back to branch summary

~ubuntu-branches/ubuntu/edgy/qemu/edgy

« back to all changes in this revision

Viewing changes to linux-user/signal.c

  • Committer: Bazaar Package Importer
  • Author(s): Rodrigo Parra Novo
  • Date: 2006-08-04 22:50:15 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20060804225015-g0tvbozshau6e1oo
Tags: 0.8.2-0ubuntu1
* Merged with Debian unstable
* New Upstream release
* Dropped debian/patches/12_signal_powerpc_support.patch (broken for qemu
  0.8.2)
* Redid debian/patches/21_net_sockopt.patch
* Redid debian/patches/35_syscall_sockaddr.patch
* Redid debian/patches/42_arm_tls.patch
* Dropped debian/patches/50_missing_keycodes.patch (applied upstream)
* Redid debian/patches/61_safe_64bit_int.patch
* Dropped debian/patches/63_sparc_build.patch (applied upstream)
* Added new patch 65_no-linux_types_h.patch (unnecessary kernel header
  breaking compilation of linux-user/syscall.c)
* Added new patch 66_no-linux_compiler_h.patch (unnecessary kernel header
  breaking compilation of linux-usb.c)

Show diffs side-by-side

added added

removed removed

Lines of Context:
linux-user/signal.c
135
135
 
136
136
    host_to_target_sigset_internal(&d1, s);
137
137
    for(i = 0;i < TARGET_NSIG_WORDS; i++)
138
 
        __put_user(d1.sig[i], &d->sig[i]);
 
138
        d->sig[i] = tswapl(d1.sig[i]);
139
139
}
140
140
 
141
141
void target_to_host_sigset_internal(sigset_t *d, const target_sigset_t *s)
168
168
    int i;
169
169
 
170
170
    for(i = 0;i < TARGET_NSIG_WORDS; i++)
171
 
        __get_user(s1.sig[i], &s->sig[i]);
 
171
        s1.sig[i] = tswapl(s->sig[i]);
172
172
    target_to_host_sigset_internal(d, &s1);
173
173
}
174
174
    
432
432
    if (oact) {
433
433
        oact->_sa_handler = tswapl(k->sa._sa_handler);
434
434
        oact->sa_flags = tswapl(k->sa.sa_flags);
435
 
        oact->sa_restorer = tswapl(k->sa.sa_restorer);
 
435
        #if !defined(TARGET_MIPS)
 
436
                oact->sa_restorer = tswapl(k->sa.sa_restorer);
 
437
        #endif
436
438
        oact->sa_mask = k->sa.sa_mask;
437
439
    }
438
440
    if (act) {
439
441
        k->sa._sa_handler = tswapl(act->_sa_handler);
440
442
        k->sa.sa_flags = tswapl(act->sa_flags);
441
 
        k->sa.sa_restorer = tswapl(act->sa_restorer);
 
443
        #if !defined(TARGET_MIPS)
 
444
                k->sa.sa_restorer = tswapl(act->sa_restorer);
 
445
        #endif
442
446
        k->sa.sa_mask = act->sa_mask;
443
447
 
444
448
        /* we update the host linux signal state */
647
651
            ka->sa.sa_restorer) {
648
652
            esp = (unsigned long) ka->sa.sa_restorer;
649
653
        }
650
 
        return (void *)((esp - frame_size) & -8ul);
 
654
        return g2h((esp - frame_size) & -8ul);
651
655
}
652
656
 
653
657
static void setup_frame(int sig, struct emulated_sigaction *ka,
694
698
                goto give_sigsegv;
695
699
 
696
700
        /* Set up registers for signal handler */
697
 
        env->regs[R_ESP] = (unsigned long) frame;
 
701
        env->regs[R_ESP] = h2g(frame);
698
702
        env->eip = (unsigned long) ka->sa._sa_handler;
699
703
 
700
704
        cpu_x86_load_seg(env, R_DS, __USER_DS);
835
839
 
836
840
long do_sigreturn(CPUX86State *env)
837
841
{
838
 
    struct sigframe *frame = (struct sigframe *)(env->regs[R_ESP] - 8);
 
842
    struct sigframe *frame = (struct sigframe *)g2h(env->regs[R_ESP] - 8);
839
843
    target_sigset_t target_set;
840
844
    sigset_t set;
841
845
    int eax, i;
866
870
 
867
871
long do_rt_sigreturn(CPUX86State *env)
868
872
{
869
 
        struct rt_sigframe *frame = (struct rt_sigframe *)(env->regs[R_ESP] - 4);
 
873
        struct rt_sigframe *frame = (struct rt_sigframe *)g2h(env->regs[R_ESP] - 4);
870
874
        sigset_t set;
871
875
        //      stack_t st;
872
876
        int eax;
1029
1033
        /*
1030
1034
         * ATPCS B01 mandates 8-byte alignment
1031
1035
         */
1032
 
        return (void *)((sp - framesize) & ~7);
 
1036
        return g2h((sp - framesize) & ~7);
1033
1037
}
1034
1038
 
1035
1039
static int
1084
1088
        }
1085
1089
 
1086
1090
        env->regs[0] = usig;
1087
 
        env->regs[13] = (target_ulong)frame;
 
1091
        env->regs[13] = h2g(frame);
1088
1092
        env->regs[14] = retcode;
1089
1093
        env->regs[15] = handler & (thumb ? ~1 : ~3);
1090
1094
 
1130
1134
        err |= copy_siginfo_to_user(&frame->info, info);
1131
1135
 
1132
1136
        /* Clear all the bits of the ucontext we don't use.  */
1133
 
        err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));
 
1137
        memset(&frame->uc, 0, offsetof(struct target_ucontext, tuc_mcontext));
1134
1138
 
1135
1139
        err |= setup_sigcontext(&frame->uc.tuc_mcontext, /*&frame->fpstate,*/
1136
1140
                                env, set->sig[0]);
1202
1206
        if (env->regs[13] & 7)
1203
1207
                goto badframe;
1204
1208
 
1205
 
        frame = (struct sigframe *)env->regs[13];
 
1209
        frame = (struct sigframe *)g2h(env->regs[13]);
1206
1210
 
1207
1211
#if 0
1208
1212
        if (verify_area(VERIFY_READ, frame, sizeof (*frame)))
1330
1334
                unsigned long *insn_addr;
1331
1335
                unsigned long insn;
1332
1336
        } si_fpqueue [16];
1333
 
} __siginfo_fpu_t;
 
1337
} qemu_siginfo_fpu_t;
1334
1338
 
1335
1339
 
1336
1340
struct target_signal_frame {
1337
1341
        struct sparc_stackf     ss;
1338
1342
        __siginfo_t             info;
1339
 
        __siginfo_fpu_t         *fpu_save;
 
1343
        qemu_siginfo_fpu_t      *fpu_save;
1340
1344
        target_ulong            insns[2] __attribute__ ((aligned (8)));
1341
1345
        target_ulong            extramask[TARGET_NSIG_WORDS - 1];
1342
1346
        target_ulong            extra_size; /* Should be 0 */
1343
 
        __siginfo_fpu_t         fpu_state;
 
1347
        qemu_siginfo_fpu_t      fpu_state;
1344
1348
};
1345
1349
struct target_rt_signal_frame {
1346
1350
        struct sparc_stackf     ss;
1347
1351
        siginfo_t               info;
1348
1352
        target_ulong            regs[20];
1349
1353
        sigset_t                mask;
1350
 
        __siginfo_fpu_t         *fpu_save;
 
1354
        qemu_siginfo_fpu_t      *fpu_save;
1351
1355
        unsigned int            insns[2];
1352
1356
        stack_t                 stack;
1353
1357
        unsigned int            extra_size; /* Should be 0 */
1354
 
        __siginfo_fpu_t         fpu_state;
 
1358
        qemu_siginfo_fpu_t      fpu_state;
1355
1359
};
1356
1360
 
1357
1361
#define UREG_O0        16
1378
1382
                        sp = current->sas_ss_sp + current->sas_ss_size;
1379
1383
        }
1380
1384
#endif
1381
 
        return (void *)(sp - framesize);
 
1385
        return g2h(sp - framesize);
1382
1386
}
1383
1387
 
1384
1388
static int
1461
1465
                goto sigsegv;
1462
1466
 
1463
1467
        /* 3. signal handler back-trampoline and parameters */
1464
 
        env->regwptr[UREG_FP] = (target_ulong) sf;
 
1468
        env->regwptr[UREG_FP] = h2g(sf);
1465
1469
        env->regwptr[UREG_I0] = sig;
1466
 
        env->regwptr[UREG_I1] = (target_ulong) &sf->info;
1467
 
        env->regwptr[UREG_I2] = (target_ulong) &sf->info;
 
1470
        env->regwptr[UREG_I1] = h2g(&sf->info);
 
1471
        env->regwptr[UREG_I2] = h2g(&sf->info);
1468
1472
 
1469
1473
        /* 4. signal handler */
1470
1474
        env->pc = (unsigned long) ka->sa._sa_handler;
1473
1477
        if (ka->sa.sa_restorer)
1474
1478
                env->regwptr[UREG_I7] = (unsigned long)ka->sa.sa_restorer;
1475
1479
        else {
1476
 
                env->regwptr[UREG_I7] = (unsigned long)(&(sf->insns[0]) - 2);
 
1480
                env->regwptr[UREG_I7] = h2g(&(sf->insns[0]) - 2);
1477
1481
 
1478
1482
                /* mov __NR_sigreturn, %g1 */
1479
1483
                err |= __put_user(0x821020d8, &sf->insns[0]);
1496
1500
        force_sig(TARGET_SIGSEGV);
1497
1501
}
1498
1502
static inline int
1499
 
restore_fpu_state(CPUState *env, __siginfo_fpu_t *fpu)
 
1503
restore_fpu_state(CPUState *env, qemu_siginfo_fpu_t *fpu)
1500
1504
{
1501
1505
        int err;
1502
1506
#if 0
1548
1552
        target_ulong fpu_save;
1549
1553
        int err, i;
1550
1554
 
1551
 
        sf = (struct target_signal_frame *) env->regwptr[UREG_FP];
 
1555
        sf = (struct target_signal_frame *)g2h(env->regwptr[UREG_FP]);
1552
1556
#if 0
1553
1557
        fprintf(stderr, "sigreturn\n");
1554
1558
        fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]);
1618
1622
    return -ENOSYS;
1619
1623
}
1620
1624
 
 
1625
#elif defined(TARGET_MIPS)
 
1626
 
 
1627
struct target_sigcontext {
 
1628
    uint32_t   sc_regmask;     /* Unused */
 
1629
    uint32_t   sc_status;
 
1630
    uint64_t   sc_pc;
 
1631
    uint64_t   sc_regs[32];
 
1632
    uint64_t   sc_fpregs[32];
 
1633
    uint32_t   sc_ownedfp;     /* Unused */
 
1634
    uint32_t   sc_fpc_csr;
 
1635
    uint32_t   sc_fpc_eir;     /* Unused */
 
1636
    uint32_t   sc_used_math;
 
1637
    uint32_t   sc_dsp;         /* dsp status, was sc_ssflags */
 
1638
    uint64_t   sc_mdhi;
 
1639
    uint64_t   sc_mdlo;
 
1640
    target_ulong   sc_hi1;         /* Was sc_cause */
 
1641
    target_ulong   sc_lo1;         /* Was sc_badvaddr */
 
1642
    target_ulong   sc_hi2;         /* Was sc_sigset[4] */
 
1643
    target_ulong   sc_lo2;
 
1644
    target_ulong   sc_hi3;
 
1645
    target_ulong   sc_lo3;
 
1646
};
 
1647
 
 
1648
struct sigframe {
 
1649
    uint32_t sf_ass[4];                 /* argument save space for o32 */
 
1650
    uint32_t sf_code[2];                        /* signal trampoline */
 
1651
    struct target_sigcontext sf_sc;
 
1652
    target_sigset_t sf_mask;
 
1653
};
 
1654
 
 
1655
/* Install trampoline to jump back from signal handler */
 
1656
static inline int install_sigtramp(unsigned int *tramp,   unsigned int syscall)
 
1657
{
 
1658
    int err;
 
1659
 
 
1660
    /*
 
1661
    * Set up the return code ...
 
1662
    *
 
1663
    *         li      v0, __NR__foo_sigreturn
 
1664
    *         syscall
 
1665
    */
 
1666
 
 
1667
    err = __put_user(0x24020000 + syscall, tramp + 0);
 
1668
    err |= __put_user(0x0000000c          , tramp + 1);
 
1669
    /* flush_cache_sigtramp((unsigned long) tramp); */
 
1670
    return err;
 
1671
}
 
1672
 
 
1673
static inline int
 
1674
setup_sigcontext(CPUState *regs, struct target_sigcontext *sc)
 
1675
{
 
1676
    int err = 0;
 
1677
 
 
1678
    err |= __put_user(regs->PC, &sc->sc_pc);
 
1679
 
 
1680
    #define save_gp_reg(i) do {                                         \
 
1681
        err |= __put_user(regs->gpr[i], &sc->sc_regs[i]);               \
 
1682
    } while(0)
 
1683
    __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
 
1684
    save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
 
1685
    save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
 
1686
    save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
 
1687
    save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
 
1688
    save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
 
1689
    save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
 
1690
    save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
 
1691
    save_gp_reg(31);
 
1692
    #undef save_gp_reg
 
1693
 
 
1694
    err |= __put_user(regs->HI, &sc->sc_mdhi);
 
1695
    err |= __put_user(regs->LO, &sc->sc_mdlo);
 
1696
 
 
1697
    /* Not used yet, but might be useful if we ever have DSP suppport */
 
1698
#if 0
 
1699
    if (cpu_has_dsp) {
 
1700
        err |= __put_user(mfhi1(), &sc->sc_hi1);
 
1701
        err |= __put_user(mflo1(), &sc->sc_lo1);
 
1702
        err |= __put_user(mfhi2(), &sc->sc_hi2);
 
1703
        err |= __put_user(mflo2(), &sc->sc_lo2);
 
1704
        err |= __put_user(mfhi3(), &sc->sc_hi3);
 
1705
        err |= __put_user(mflo3(), &sc->sc_lo3);
 
1706
        err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
 
1707
    }
 
1708
    /* same with 64 bit */
 
1709
    #ifdef CONFIG_64BIT
 
1710
    err |= __put_user(regs->hi, &sc->sc_hi[0]);
 
1711
    err |= __put_user(regs->lo, &sc->sc_lo[0]);
 
1712
    if (cpu_has_dsp) {
 
1713
        err |= __put_user(mfhi1(), &sc->sc_hi[1]);
 
1714
        err |= __put_user(mflo1(), &sc->sc_lo[1]);
 
1715
        err |= __put_user(mfhi2(), &sc->sc_hi[2]);
 
1716
        err |= __put_user(mflo2(), &sc->sc_lo[2]);
 
1717
        err |= __put_user(mfhi3(), &sc->sc_hi[3]);
 
1718
        err |= __put_user(mflo3(), &sc->sc_lo[3]);
 
1719
        err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
 
1720
    }
 
1721
    #endif
 
1722
 
 
1723
 
 
1724
    #endif
 
1725
 
 
1726
 
 
1727
    #if 0
 
1728
    err |= __put_user(!!used_math(), &sc->sc_used_math);
 
1729
 
 
1730
    if (!used_math())
 
1731
        goto out;
 
1732
 
 
1733
    /*
 
1734
    * Save FPU state to signal context.  Signal handler will "inherit"
 
1735
    * current FPU state.
 
1736
    */
 
1737
    preempt_disable();
 
1738
 
 
1739
    if (!is_fpu_owner()) {
 
1740
        own_fpu();
 
1741
        restore_fp(current);
 
1742
    }
 
1743
    err |= save_fp_context(sc);
 
1744
 
 
1745
    preempt_enable();
 
1746
    out:
 
1747
#endif
 
1748
    return err;
 
1749
}
 
1750
 
 
1751
static inline int
 
1752
restore_sigcontext(CPUState *regs, struct target_sigcontext *sc)
 
1753
{
 
1754
    int err = 0;
 
1755
 
 
1756
    err |= __get_user(regs->CP0_EPC, &sc->sc_pc);
 
1757
 
 
1758
    err |= __get_user(regs->HI, &sc->sc_mdhi);
 
1759
    err |= __get_user(regs->LO, &sc->sc_mdlo);
 
1760
 
 
1761
    #define restore_gp_reg(i) do {                                      \
 
1762
        err |= __get_user(regs->gpr[i], &sc->sc_regs[i]);               \
 
1763
    } while(0)
 
1764
    restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
 
1765
    restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
 
1766
    restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
 
1767
    restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
 
1768
    restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
 
1769
    restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
 
1770
    restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
 
1771
    restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
 
1772
    restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
 
1773
    restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
 
1774
    restore_gp_reg(31);
 
1775
    #undef restore_gp_reg
 
1776
 
 
1777
#if 0
 
1778
    if (cpu_has_dsp) {
 
1779
        err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
 
1780
        err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
 
1781
        err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
 
1782
        err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
 
1783
        err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
 
1784
        err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
 
1785
        err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
 
1786
    }
 
1787
    #ifdef CONFIG_64BIT
 
1788
    err |= __get_user(regs->hi, &sc->sc_hi[0]);
 
1789
    err |= __get_user(regs->lo, &sc->sc_lo[0]);
 
1790
    if (cpu_has_dsp) {
 
1791
        err |= __get_user(treg, &sc->sc_hi[1]); mthi1(treg);
 
1792
        err |= __get_user(treg, &sc->sc_lo[1]); mthi1(treg);
 
1793
        err |= __get_user(treg, &sc->sc_hi[2]); mthi2(treg);
 
1794
        err |= __get_user(treg, &sc->sc_lo[2]); mthi2(treg);
 
1795
        err |= __get_user(treg, &sc->sc_hi[3]); mthi3(treg);
 
1796
        err |= __get_user(treg, &sc->sc_lo[3]); mthi3(treg);
 
1797
        err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
 
1798
    }
 
1799
    #endif
 
1800
 
 
1801
    err |= __get_user(used_math, &sc->sc_used_math);
 
1802
    conditional_used_math(used_math);
 
1803
 
 
1804
    preempt_disable();
 
1805
 
 
1806
    if (used_math()) {
 
1807
        /* restore fpu context if we have used it before */
 
1808
        own_fpu();
 
1809
        err |= restore_fp_context(sc);
 
1810
    } else {
 
1811
        /* signal handler may have used FPU.  Give it up. */
 
1812
        lose_fpu();
 
1813
    }
 
1814
 
 
1815
    preempt_enable();
 
1816
#endif
 
1817
    return err;
 
1818
}
 
1819
/*
 
1820
 * Determine which stack to use..
 
1821
 */
 
1822
static inline void *
 
1823
get_sigframe(struct emulated_sigaction *ka, CPUState *regs, size_t frame_size)
 
1824
{
 
1825
    unsigned long sp;
 
1826
 
 
1827
    /* Default to using normal stack */
 
1828
    sp = regs->gpr[29];
 
1829
 
 
1830
    /*
 
1831
     * FPU emulator may have it's own trampoline active just
 
1832
     * above the user stack, 16-bytes before the next lowest
 
1833
     * 16 byte boundary.  Try to avoid trashing it.
 
1834
     */
 
1835
    sp -= 32;
 
1836
 
 
1837
#if 0
 
1838
    /* This is the X/Open sanctioned signal stack switching.  */
 
1839
    if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags (sp) == 0))
 
1840
        sp = current->sas_ss_sp + current->sas_ss_size;
 
1841
#endif
 
1842
 
 
1843
    return g2h((sp - frame_size) & ~7);
 
1844
}
 
1845
 
 
1846
static void setup_frame(int sig, struct emulated_sigaction * ka, 
 
1847
                target_sigset_t *set, CPUState *regs)
 
1848
{
 
1849
    struct sigframe *frame;
 
1850
    int i;
 
1851
 
 
1852
    frame = get_sigframe(ka, regs, sizeof(*frame));
 
1853
    if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
 
1854
        goto give_sigsegv;
 
1855
 
 
1856
    install_sigtramp(frame->sf_code, TARGET_NR_sigreturn);
 
1857
 
 
1858
    if(setup_sigcontext(regs, &frame->sf_sc))
 
1859
        goto give_sigsegv;
 
1860
 
 
1861
    for(i = 0; i < TARGET_NSIG_WORDS; i++) {
 
1862
        if(__put_user(set->sig[i], &frame->sf_mask.sig[i]))
 
1863
            goto give_sigsegv;
 
1864
    }
 
1865
 
 
1866
    /*
 
1867
    * Arguments to signal handler:
 
1868
    *
 
1869
    *   a0 = signal number
 
1870
    *   a1 = 0 (should be cause)
 
1871
    *   a2 = pointer to struct sigcontext
 
1872
    *
 
1873
    * $25 and PC point to the signal handler, $29 points to the
 
1874
    * struct sigframe.
 
1875
    */
 
1876
    regs->gpr[ 4] = sig;
 
1877
    regs->gpr[ 5] = 0;
 
1878
    regs->gpr[ 6] = h2g(&frame->sf_sc);
 
1879
    regs->gpr[29] = h2g(frame);
 
1880
    regs->gpr[31] = h2g(frame->sf_code);
 
1881
    /* The original kernel code sets CP0_EPC to the handler
 
1882
    * since it returns to userland using eret
 
1883
    * we cannot do this here, and we must set PC directly */
 
1884
    regs->PC = regs->gpr[25] = ka->sa._sa_handler;
 
1885
    return;
 
1886
 
 
1887
give_sigsegv:
 
1888
    force_sig(TARGET_SIGSEGV/*, current*/);
 
1889
    return;     
 
1890
}
 
1891
 
 
1892
long do_sigreturn(CPUState *regs)
 
1893
{
 
1894
   struct sigframe *frame;
 
1895
   sigset_t blocked;
 
1896
   target_sigset_t target_set;
 
1897
   int i;
 
1898
 
 
1899
#if defined(DEBUG_SIGNAL)
 
1900
   fprintf(stderr, "do_sigreturn\n");
 
1901
#endif
 
1902
   frame = (struct sigframe *) regs->gpr[29];
 
1903
   if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 
1904
        goto badframe;
 
1905
 
 
1906
   for(i = 0; i < TARGET_NSIG_WORDS; i++) {
 
1907
        if(__get_user(target_set.sig[i], &frame->sf_mask.sig[i]))
 
1908
            goto badframe;
 
1909
   }            
 
1910
 
 
1911
   target_to_host_sigset_internal(&blocked, &target_set);
 
1912
   sigprocmask(SIG_SETMASK, &blocked, NULL);
 
1913
 
 
1914
   if (restore_sigcontext(regs, &frame->sf_sc))
 
1915
        goto badframe;
 
1916
 
 
1917
#if 0
 
1918
   /*
 
1919
    * Don't let your children do this ...
 
1920
    */
 
1921
   __asm__ __volatile__(
 
1922
        "move\t$29, %0\n\t"
 
1923
        "j\tsyscall_exit"
 
1924
        :/* no outputs */
 
1925
        :"r" (&regs));
 
1926
   /* Unreached */
 
1927
#endif
 
1928
    
 
1929
    regs->PC = regs->CP0_EPC;
 
1930
   /* I am not sure this is right, but it seems to work
 
1931
    * maybe a problem with nested signals ? */
 
1932
    regs->CP0_EPC = 0;
 
1933
    return 0;
 
1934
 
 
1935
badframe:
 
1936
   force_sig(TARGET_SIGSEGV/*, current*/);
 
1937
   return 0;    
 
1938
 
 
1939
}
 
1940
 
 
1941
static void setup_rt_frame(int sig, struct emulated_sigaction *ka, 
 
1942
                           target_siginfo_t *info,
 
1943
                           target_sigset_t *set, CPUState *env)
 
1944
{
 
1945
    fprintf(stderr, "setup_rt_frame: not implemented\n");
 
1946
}
 
1947
 
 
1948
long do_rt_sigreturn(CPUState *env)
 
1949
{
 
1950
    fprintf(stderr, "do_rt_sigreturn: not implemented\n");
 
1951
    return -ENOSYS;
 
1952
}
1621
1953
 
1622
1954
#else
1623
1955