示例#1
0
static void do_call(int cs, int ip, struct RealModeCallStructure *rmreg,
		    int rmask)
{
    unsigned int ssp, sp;

    ssp = SEGOFF2LINEAR(READ_RMREG(ss, rmask), 0);
    sp = READ_RMREG(sp, rmask);

    g_printf("fake_call() CS:IP %04x:%04x\n", cs, ip);
    pushw(ssp, sp, cs);
    pushw(ssp, sp, ip);
    RMREG(sp) -= 4;
}
示例#2
0
文件: inte6.c 项目: 0ida/coreboot
int intE6_handler()
{
#if 0
	pciVideoPtr pvp;

	if ((pvp = xf86GetPciInfoForEntity(pInt->entityIndex)))
		X86_AX = (pvp->bus << 8) | (pvp->device << 3) | (pvp->func & 0x7);
	pushw(X86_CS);
	pushw(X86_IP);
	X86_CS = pInt->BIOSseg;
	X86_EIP = 0x0003;
	X86_ES = 0;		/* standard pc es */
#endif
	printf("intE6 not supported right now.\n");
	return 1;
}
示例#3
0
文件: virt86.c 项目: rickcaudill/Pyro
static void do_int( Virtual86Regs_s * regs, int i, unsigned char *ssp, unsigned long sp )
{
	unsigned long *intr_ptr, segoffs;

	intr_ptr = ( unsigned long * )( i << 2 );

	segoffs = *intr_ptr;

	pushw( ssp, sp, regs->eflags & 0xffff );
	pushw( ssp, sp, regs->cs );
	pushw( ssp, sp, regs->eip & 0xffff );

	regs->eflags &= ~EFLG_IF;

	regs->cs = segoffs >> 16;
	regs->esp = ( regs->esp - 6 ) & 0xffff;
	regs->eip = segoffs & 0xffff;

/*	clear_IF(regs); */
}
示例#4
0
文件: inst68.c 项目: QaDeS/droidsound
void exception68(emu68_t * const emu68, const int vector, const int level)
{
  if ( vector & 0x100 ) {
    /* Those are specific to EMU68 */
    switch (vector) {
    case HWBREAK_VECTOR:
    case HWTRACE_VECTOR:
      break;
    default:
      assert(!"invalid eception vector");
    }
  } else {
    int savesr = REG68.sr;
    int savest = emu68->status;

    emu68->status = EMU68_XCT;         /* enter exception stat      */
    REG68.sr &= ~SR_T;                 /* no TRACE                  */
    REG68.sr |=  SR_S;                 /* Supervisor                */

    if ( savest == EMU68_XCT &&
         ( vector == BUSERR_VECTOR || vector == ADRERR_VECTOR ) ) {
      /* Double fault ! */
      emu68->status = EMU68_ERR;        /* Halt processor */
    } else if ( vector == RESET_VECTOR ) {
      REG68.sr  |= SR_I;
      REG68.a[7] = read_L(RESET_SP_VECTOR << 2);
      REG68.pc   = read_L(RESET_PC_VECTOR << 2);
    } else {
      if ( (unsigned int)level < 8u ) {
        SET_IPL(REG68.sr,level);
      }
      pushl(REG68.pc);
      pushw(savesr);
      REG68.pc  = read_L(vector << 2);
      emu68->status = EMU68_NRM;        /* Back to normal mode */
    }
  }
  if (emu68->handler && emu68->handler(emu68, vector, emu68->cookie) ) {
    emu68->status = EMU68_BRK;        /* User forced exit */
  }
}
示例#5
0
文件: virt86.c 项目: rickcaudill/Pyro
void handle_v86_fault( Virtual86Regs_s * regs, uint32 nErrorCode )
{
	unsigned char *csp, *ssp;
	unsigned long ip, sp;
	int nInst;

//  if ( 0xffff == (regs->eip & 0xffff) && 0xffff == regs->cs ) {
//    return_to_32bit( regs, 0 );
//    return;
//  }


	csp = ( unsigned char * )( regs->cs << 4 );
	ssp = ( unsigned char * )( regs->ss << 4 );

	sp = regs->esp & 0xffff;
	ip = regs->eip & 0xffff;

	nInst = popb( csp, ip );
	switch ( nInst )
	{
		/* Operand size override */
	case 0x66:
		printk( "WARNING : 32 bit code run in v86 mode! Flags are not handled properly!\n" );
		nInst = popb( csp, ip );
		switch ( nInst )
		{
			/* pushfd */
		case 0x9c:
			regs->esp = ( regs->esp - 4 ) & 0xffff;
			regs->eip = ( regs->eip + 2 ) & 0xffff;
			pushl( ssp, sp, regs->eflags );
			return;

			/* popfd */
		case 0x9d:
			regs->esp = ( regs->esp + 4 ) & 0xffff;
			regs->eip = ( regs->eip + 2 ) & 0xffff;
			regs->eflags = popl( ssp, sp );
			return;

			/* iretd */
		case 0xcf:
			regs->esp = ( regs->esp + 12 ) & 0xffff;
			regs->eip = ( uint16 )( popl( ssp, sp ) & 0xffff );
			regs->cs = ( uint16 )popl( ssp, sp );
			return;
			/* need this to avoid a fallthrough */
		default:
			printk( "ERROR : unknown v86 32 bit instruction %x\n", nInst );
			return_to_32bit( regs, -EFAULT );
		}

		/* pushf */
	case 0x9c:
		regs->esp = ( regs->esp - 2 ) & 0xffff;
		regs->eip = ( regs->eip + 1 ) & 0xffff;
		pushw( ssp, sp, regs->eflags & 0xffff );
		return;

		/* popf */
	case 0x9d:
		regs->esp = ( regs->esp + 2 ) & 0xffff;
		regs->eip = ( regs->eip + 1 ) & 0xffff;
		regs->eflags = ( regs->eflags & 0xffff0000 ) | ( popw( ssp, sp ) & 0xffff );
		return;

		/* int xx */
	case 0xcd:
		{
			int intno = popb( csp, ip );

			regs->eip = ( regs->eip + 2 ) & 0xffff;
			do_int( regs, intno, ssp, sp );
			return;
		}

		/* iret */
	case 0xcf:
		regs->esp = ( regs->esp + 6 ) & 0xffff;
		regs->eip = popw( ssp, sp ) & 0xffff;
		regs->cs = popw( ssp, sp );

		regs->eflags = ( regs->eflags & 0xffff0000 ) | ( popw( ssp, sp ) & 0xffff );

		if ( 0xffff == ( regs->eip & 0xffff ) && 0xffff == regs->cs )
		{
			return_to_32bit( regs, 0 );
		}

		return;

		/* cli */
	case 0xfa:
		regs->eip = ( regs->eip + 1 ) & 0xffff;
		regs->eflags &= ~EFLG_IF;
		return;

		/* sti */
	case 0xfb:
		/* The interrupts should actually be restored after the NEXT instruction!
		 * Hope this works. As long as no DOS/BIOS code swaps the stack,
		 * nothing bad should happen.
		 */
		regs->eip = ( regs->eip + 1 ) & 0xffff;
		regs->eflags |= EFLG_IF;
		return;
	default:
		printk( "ERROR : unknown v86 16 bit instruction %x\n", nInst );
		return_to_32bit( regs, -EFAULT );
	}
}
示例#6
0
int exception(struct trapdata *framedata)
{
	ptptr proc;
	unsigned int frame, fsize;
	uint8_t trap = framedata->trap;
	unsigned int sig = 0;
	uint16_t m;
	uint16_t *sp = (uint16_t *)framedata;
	uint16_t *usp = get_usp();
	uint16_t *unwind, *context;
	uint8_t err = 0;
	int i;

	/* We translate debug to SIGIOT and A and F line to SIGILL
	   We will need to fix up 68000 v 68010 move to/from SR */
	static const uint8_t trap_to_sig[] = {
		0, 0, SIGSEGV, SIGBUS, SIGILL, SIGFPE,
		SIGABRT/*CHK*/, SIGTRAP/*TRAPV */,
		SIGILL, SIGIOT, SIGILL, SIGFPE };

	proc = udata.u_ptab;

	if (sysinfo.cpu[0] == 10) {
		/* Long or short frame: the CPU tells us the frame format */
		if (framedata->exception[3] & 0x8000) {
			fsize = 29;
			frame = FRAME_C;
		} else  {
			fsize = 4;
			frame = FRAME_D;
		}
	} else {
		frame = FRAME_B;
		fsize = 3;
	}
	if (trap == 0) {
		sig = udata.u_cursig;
		udata.u_cursig = 0;
	} else if (trap < 12) {
		if (trap < 4) {
			/* On a 68010 this frame is 29 words and the event is
			   restartable (although not always usefully). We need to
			   decide whether to set the restart flag case by case */
			if (sysinfo.cpu[0] == 0) {
				frame = FRAME_A;
				fsize = 7;
			}
		}
		sig = trap_to_sig[trap];
	} else if (trap >= 32 && trap < 48)
		sig = SIGTRAP;
	/* This processing only applies to synchronous hardware exceptions */
	if (trap) {
		/* Went boom in kernel space or without a user recovery */
		if (kernel_flag || sig == 0) {
			explode(framedata, frame);
			panic("trap");
		}

		/* Cheating here .. all our exceptions are low 16 signal */
		m = 1 << sig;
		/*
		 *	The caller is ignoring our signal. In some cases this is fine
		 *	but in others it's less clear (eg division by zero) and we
		 *	may need to take different action.
		 */
		if (proc->p_sig[0].s_ignored & m)
			return 0;
		/* Weird case - we took a sync signal and the caller wants us to
		   report it later. */
		if (proc->p_sig[0].s_held & m) {
			/* TODO: if it's not meaningfully restartable we should
			   probably treat this as a kill */
			ssig(proc, sig);
			return 0;
		}
		recalc_cursig();	/* Put any async signal back */
	}
	if (udata.u_sigvec[sig] == SIG_DFL) {
		/* Default action for our signal ? */
		doexit(dump_core(sig));
		/* This will never return. We will go schedule new work */
		panic("exret");
	}
	/* build signal frame

		Our unwinder code does
		move.l 8(sp),sp
		movem.l a0-a1/d0-d1,(sp)+
		move.w (sp)+,ccr
		rts */


	/* Now update the user stack */
	/* - Push the recovery PC */
	/* - Patch the kernel exception frame */
	if (sysinfo.cpu[0]) {
		/* FIXME */
		err |= pushw(&usp, sp[34]);
		err |= pushw(&usp, sp[33]);
		*(uint32_t *)(&sp[33]) = (uint32_t)udata.u_sigvec[sig];
	} else {
		err |= pushw(&usp, sp[31 + fsize]);
		err |= pushw(&usp, sp[30 + fsize]);
		*(uint32_t *)(&sp[30 + fsize]) = (uint32_t)udata.u_sigvec[sig];
	}

	/* FIXME: when we do ptrace we will need to support adding the T
	   flag back here as the exception cleared it */
	err |= pushw(&usp,  framedata->sr);
	/* Push A1 A0 D1 D0 to match MOVEM.L */
	err |= pushl(&usp, framedata->a[1]);
	err |= pushl(&usp, framedata->a[0]);
	err |= pushl(&usp, framedata->d[1]);
	err |= pushl(&usp, framedata->d[0]);

	/* Remember the target for undoing the frame */
	unwind = usp;

	/* Copy in the signal context itself. 30 words of registers, 2 of
	   trap code and then the hardware exception */
	for (i = 0; i < 30 + 2 + fsize; i++)
		err |= pushw(&usp, *sp++);
	context = usp;
	err |= pushl(&usp, (uint32_t)unwind);
	/* Signal context is a secret extra non portable argument */
	err |= pushl(&usp, (uint32_t)context);
	/* We end it with the call frame as seen from the signal handler, a
	   single argument and a return address */
	err |= pushl(&usp, sig);
	err |= pushl(&usp, udata.u_codebase + 0x04);

	set_usp(usp);

	if (err) {
		doexit(dump_core(SIGSTKFLT));
		panic("exret2");
	}
	/* Once built clear the restart state */
	udata.u_sigvec[sig] = SIG_DFL;
	/* Return, RTE and end up on the signal frame */
	return 1;
}