Revision 80a9d035
| b/linux-user/main.c | ||
|---|---|---|
| 181 | 181 |
void cpu_loop(CPUX86State *env) |
| 182 | 182 |
{
|
| 183 | 183 |
int trapnr; |
| 184 |
uint8_t *pc;
|
|
| 184 |
target_ulong pc;
|
|
| 185 | 185 |
target_siginfo_t info; |
| 186 | 186 |
|
| 187 | 187 |
for(;;) {
|
| ... | ... | |
| 440 | 440 |
env->wim = new_wim; |
| 441 | 441 |
} |
| 442 | 442 |
|
| 443 |
#if 0 |
|
| 443 | 444 |
static void flush_windows(CPUSPARCState *env) |
| 444 | 445 |
{
|
| 445 | 446 |
int offset, cwp1; |
| ... | ... | |
| 459 | 460 |
offset++; |
| 460 | 461 |
} |
| 461 | 462 |
} |
| 463 |
#endif |
|
| 462 | 464 |
|
| 463 | 465 |
void cpu_loop (CPUSPARCState *env) |
| 464 | 466 |
{
|
| ... | ... | |
| 1067 | 1069 |
env->eip = regs->eip; |
| 1068 | 1070 |
|
| 1069 | 1071 |
/* linux interrupt setup */ |
| 1070 |
env->idt.base = (void *)idt_table;
|
|
| 1072 |
env->idt.base = (long)idt_table;
|
|
| 1071 | 1073 |
env->idt.limit = sizeof(idt_table) - 1; |
| 1072 | 1074 |
set_idt(0, 0); |
| 1073 | 1075 |
set_idt(1, 0); |
| ... | ... | |
| 1092 | 1094 |
set_idt(0x80, 3); |
| 1093 | 1095 |
|
| 1094 | 1096 |
/* linux segment setup */ |
| 1095 |
env->gdt.base = (void *)gdt_table;
|
|
| 1097 |
env->gdt.base = (long)gdt_table;
|
|
| 1096 | 1098 |
env->gdt.limit = sizeof(gdt_table) - 1; |
| 1097 | 1099 |
write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff, |
| 1098 | 1100 |
DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK | |
| b/linux-user/signal.c | ||
|---|---|---|
| 1272 | 1272 |
} |
| 1273 | 1273 |
|
| 1274 | 1274 |
#elif defined(TARGET_SPARC) |
| 1275 |
|
|
| 1275 | 1276 |
#define __SUNOS_MAXWIN 31 |
| 1276 | 1277 |
|
| 1277 | 1278 |
/* This is what SunOS does, so shall I. */ |
| ... | ... | |
| 1400 | 1401 |
return err; |
| 1401 | 1402 |
} |
| 1402 | 1403 |
|
| 1404 |
#if 0 |
|
| 1403 | 1405 |
static int |
| 1404 | 1406 |
setup_sigcontext(struct target_sigcontext *sc, /*struct _fpstate *fpstate,*/ |
| 1405 | 1407 |
CPUState *env, unsigned long mask) |
| ... | ... | |
| 1416 | 1418 |
|
| 1417 | 1419 |
return err; |
| 1418 | 1420 |
} |
| 1421 |
#endif |
|
| 1419 | 1422 |
#define NF_ALIGNEDSZ (((sizeof(struct target_signal_frame) + 7) & (~7))) |
| 1420 | 1423 |
|
| 1421 | 1424 |
static void setup_frame(int sig, struct emulated_sigaction *ka, |
| ... | ... | |
| 1483 | 1486 |
|
| 1484 | 1487 |
/* Flush instruction space. */ |
| 1485 | 1488 |
//flush_sig_insns(current->mm, (unsigned long) &(sf->insns[0])); |
| 1486 |
tb_flush(env); |
|
| 1489 |
// tb_flush(env);
|
|
| 1487 | 1490 |
} |
| 1488 | 1491 |
//cpu_dump_state(env, stderr, fprintf, 0); |
| 1489 | 1492 |
return; |
| 1490 | 1493 |
|
| 1491 |
sigill_and_return: |
|
| 1494 |
//sigill_and_return:
|
|
| 1492 | 1495 |
force_sig(TARGET_SIGILL); |
| 1493 | 1496 |
sigsegv: |
| 1494 | 1497 |
//fprintf(stderr, "force_sig\n"); |
| ... | ... | |
| 1544 | 1547 |
uint32_t up_psr, pc, npc; |
| 1545 | 1548 |
target_sigset_t set; |
| 1546 | 1549 |
sigset_t host_set; |
| 1547 |
__siginfo_fpu_t *fpu_save;
|
|
| 1550 |
target_ulong fpu_save;
|
|
| 1548 | 1551 |
int err, i; |
| 1549 | 1552 |
|
| 1550 | 1553 |
sf = (struct target_signal_frame *) env->regwptr[UREG_FP]; |
| 1554 |
#if 0 |
|
| 1551 | 1555 |
fprintf(stderr, "sigreturn\n"); |
| 1552 | 1556 |
fprintf(stderr, "sf: %x pc %x fp %x sp %x\n", sf, env->pc, env->regwptr[UREG_FP], env->regwptr[UREG_SP]); |
| 1557 |
#endif |
|
| 1553 | 1558 |
//cpu_dump_state(env, stderr, fprintf, 0); |
| 1554 | 1559 |
|
| 1555 | 1560 |
/* 1. Make sure we are not getting garbage from the user */ |
| ... | ... | |
| 1564 | 1569 |
err = __get_user(pc, &sf->info.si_regs.pc); |
| 1565 | 1570 |
err |= __get_user(npc, &sf->info.si_regs.npc); |
| 1566 | 1571 |
|
| 1567 |
fprintf(stderr, "pc: %lx npc %lx\n", pc, npc); |
|
| 1572 |
// fprintf(stderr, "pc: %lx npc %lx\n", pc, npc);
|
|
| 1568 | 1573 |
if ((pc | npc) & 3) |
| 1569 | 1574 |
goto segv_and_exit; |
| 1570 | 1575 |
|
| ... | ... | |
| 1585 | 1590 |
err |= __get_user(env->regwptr[i + UREG_I0], &sf->info.si_regs.u_regs[i+8]); |
| 1586 | 1591 |
} |
| 1587 | 1592 |
|
| 1588 |
err |= __get_user(fpu_save, &sf->fpu_save); |
|
| 1593 |
err |= __get_user(fpu_save, (target_ulong *)&sf->fpu_save);
|
|
| 1589 | 1594 |
|
| 1590 | 1595 |
//if (fpu_save) |
| 1591 | 1596 |
// err |= restore_fpu_state(env, fpu_save); |
| ... | ... | |
| 1604 | 1609 |
if (err) |
| 1605 | 1610 |
goto segv_and_exit; |
| 1606 | 1611 |
|
| 1607 |
fprintf(stderr, "returning %lx\n", env->regwptr[0]); |
|
| 1612 |
// fprintf(stderr, "returning %lx\n", env->regwptr[0]);
|
|
| 1608 | 1613 |
return env->regwptr[0]; |
| 1609 | 1614 |
|
| 1610 | 1615 |
segv_and_exit: |
| b/linux-user/syscall.c | ||
|---|---|---|
| 1326 | 1326 |
if (!ldt_table) |
| 1327 | 1327 |
return -ENOMEM; |
| 1328 | 1328 |
memset(ldt_table, 0, TARGET_LDT_ENTRIES * TARGET_LDT_ENTRY_SIZE); |
| 1329 |
env->ldt.base = ldt_table; |
|
| 1329 |
env->ldt.base = (long)ldt_table;
|
|
| 1330 | 1330 |
env->ldt.limit = 0xffff; |
| 1331 | 1331 |
} |
| 1332 | 1332 |
|
| ... | ... | |
| 2502 | 2502 |
tnamelen = treclen - (2 * sizeof(target_long) + 2); |
| 2503 | 2503 |
if (tnamelen > 256) |
| 2504 | 2504 |
tnamelen = 256; |
| 2505 |
/* XXX: may not be correct */ |
|
| 2505 | 2506 |
strncpy(tde->d_name, de->d_name, tnamelen); |
| 2506 | 2507 |
de = (struct dirent *)((char *)de + reclen); |
| 2507 | 2508 |
len -= reclen; |
| ... | ... | |
| 3046 | 3047 |
default: |
| 3047 | 3048 |
unimplemented: |
| 3048 | 3049 |
gemu_log("qemu: Unsupported syscall: %d\n", num);
|
| 3050 |
#if defined(TARGET_NR_setxattr) || defined(TARGET_NR_set_thread_area) |
|
| 3049 | 3051 |
unimplemented_nowarn: |
| 3052 |
#endif |
|
| 3050 | 3053 |
ret = -ENOSYS; |
| 3051 | 3054 |
break; |
| 3052 | 3055 |
} |
Also available in: Unified diff