mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2024-12-28 11:57:28 +00:00
Code Issues Releases Activity
cdfce42c14
freebsd/usr.bin/doscmd/trap.c
Marcel Moolenaar a9b5952e50 Fix the breakage of doscmd that was caused by the rebirth 
of sigcontext and the change in mcontext_t.

Partial fix submitted by:
        Philipp Mergenthaler <un1i@rz.uni-karlsruhe.de>`
1999-10-08 09:02:39 +00:00

625 lines
14 KiB
C
Raw Blame History

/*
* Copyright (c) 1992, 1993, 1996
* Berkeley Software Design, Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by Berkeley Software
* Design, Inc.
*
* THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL Berkeley Software Design, Inc. BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* BSDI trap.c,v 2.3 1996/04/08 19:33:08 bostic Exp
*
* $FreeBSD$
*/
#include "doscmd.h"
#include "trap.h"
/*
** When the emulator is very busy, it's often common for
** SIGALRM to be missed, leading to missed screen updates.
**
** We update this counter every time a DOS interrupt is processed and
** if it hits a certain threshold, force an update.
**
** When updates occur, the counter is zeroed.
*/
static int update_counter = 0;
#define BUSY_UPDATES 2000
/*
** handle interrupts passed to us by the kernel
*/
void
fake_int(regcontext_t *REGS, int intnum)
{
if (R_CS == 0xF000 || (ivec[intnum] >> 16) == 0xF000) {
if (R_CS != 0xF000)
intnum = ((u_char *)VECPTR(ivec[intnum]))[1];
debug (D_ITRAPS|intnum, "int %02x:%02x %04x:%04x/%08x\n",
intnum, R_AH, R_CS, R_IP, ivec[intnum]);
switch (intnum) {
case 0x2f: /* multiplex interrupt */
int2f(&REGS->sc);
break;
case 0xff: /* doscmd special */
emuint(REGS);
break;
default: /* should not get here */
if (vflag) dump_regs(REGS);
fatal("no interrupt set up for 0x%02x\n", intnum);
}
debug (D_ITRAPS|intnum, "\n");
return;
}
user_int:
debug (D_TRAPS|intnum,
"INT %02x:%02x [%04x:%04x] %04x %04x %04x %04x from %04x:%04x\n",
intnum, R_AH, ivec[intnum] >> 16, ivec[intnum] & 0xffff,
R_AX, R_BX, R_CX, R_DX, R_CS, R_IP);
#if 0
if ((intnum == 0x13) && (*(u_char *)VECPTR(ivec[intnum]) != 0xf4)) {
#if 1
char *addr; /*= (char *)VECPTR(ivec[intnum]);*/
int i, l, j;
char buf[100];
R_CS = 0x2c7;
R_IP = 0x14f9;
addr = (char *)MAKEPTR(R_CS, R_IP);
printf("\n");
for (i = 0; i < 100; i++) {
l = i386dis(R_CS, R_IP, addr, buf, 0);
printf("%04x:%04x %s\t;",R_CS,R_IP,buf);
for (j = 0; j < l; j++)
printf(" %02x", (u_char)addr[j]);
printf("\n");
R_IP += l;
addr += l;
}
exit (0);
#else
tmode = 1;
#endif
}
#endif
if (intnum == 0)
dump_regs(REGS);
if (ivec[intnum] == 0) { /* uninitialised interrupt? */
if (vflag) dump_regs(REGS);
fatal("Call to uninitialised interrupt 0x%02x\n", intnum);
}
/*
* This is really ugly, but when DOS boots, it seems to loop
* for a while on INT 16:11 INT 21:3E INT 2A:82
* INT 21:3E is a close(), which seems like something one would
* not sit on for ever, so we will allow it to reset our POLL count.
*/
if (intnum == 0x21 && R_AX == 0x3E)
reset_poll();
/* stack for and call the interrupt in vm86 space */
PUSH((R_FLAGS & ~PSL_I) | (R_EFLAGS & PSL_VIF ? PSL_I : 0), REGS);
PUSH(R_CS, REGS);
PUSH(R_IP, REGS);
R_EFLAGS &= ~PSL_VIF; /* disable interrupts */
PUTVEC(R_CS, R_IP, ivec[intnum]);
}
/* make this read a little more intuitively */
#define ipadvance(c,n) SET16(c->sc_eip, GET16(c->sc_eip) + n) /* move %ip along */
#ifdef USE_VM86
/* entry from NetBSD-style vm86 */
void
sigurg(struct sigframe *sf)
{
#define sc (&sf->sf_sc)
int intnum;
u_char *addr;
int rep;
int port;
callback_t func;
#if 0
printf("ivec08 = %08x\n", ivec[0x08]);
#endif
if (tmode)
resettrace(sc);
switch (VM86_TYPE(sf->sf_code)) {
case VM86_INTx:
intnum = VM86_ARG(sf->sf_code);
switch (intnum) {
case 0x2f:
switch (GET8H(sc->sc_eax)) {
case 0x11:
debug (D_TRAPS|0x2f, "INT 2F:%04x\n", GET16(sc->sc_eax));
if (int2f_11(sc)) {
/* Skip over int 2f:11 */
goto out;
}
break;
case 0x43:
debug (D_TRAPS|0x2f, "INT 2F:%04x\n", GET16(sc->sc_eax));
if (int2f_43(sc)) {
/* Skip over int 2f:43 */
goto out;
}
break;
}
break;
}
fake_int(sc, intnum);
break;
case VM86_UNKNOWN:
/*XXXXX failed vector also gets here without IP adjust*/
addr = (u_char *)MAKEPTR(sc->sc_cs, sc->sc_eip);
rep = 1;
debug (D_TRAPS2, "%04x:%04x [%02x]", GET16(sc->sc_cs),
GET16(sc->sc_eip), addr[0]);
switch (addr[0]) {
case TRACETRAP:
ipadvance(sc,1);
fake_int(sc, 3);
break;
case INd:
port = addr[1];
ipadvance(sc,2);
inb(sc, port);
break;
case OUTd:
port = addr[1];
ipadvance(sc,2);
outb(sc, port);
break;
case INdX:
port = addr[1];
ipadvance(sc,2);
inx(sc, port);
break;
case OUTdX:
port = addr[1];
ipadvance(sc,2);
outx(sc, port);
break;
case IN:
ipadvance(sc,1);
inb(sc, GET16(sc->sc_edx));
break;
case INX:
ipadvance(sc,1);
inx(sc, GET16(sc->sc_edx));
break;
case OUT:
ipadvance(sc,1);
outb(sc, GET16(sc->sc_edx));
break;
case OUTX:
ipadvance(sc,1);
outx(sc, GET16(sc->sc_edx));
break;
case OUTSB:
ipadvance(sc,1);
while (rep-- > 0)
outsb(sc, GET16(sc->sc_edx));
break;
case OUTSW:
ipadvance(sc,1);
while (rep-- > 0)
outsx(sc, GET16(sc->sc_edx));
break;
case INSB:
ipadvance(sc,1);
while (rep-- > 0)
insb(sc, GET16(sc->sc_edx));
break;
case INSW:
ipadvance(sc,1);
while (rep-- > 0)
insx(sc, GET16(sc->sc_edx));
break;
case LOCK:
debug(D_TRAPS2, "lock\n");
ipadvance(sc,1);
break;
case HLT: /* BIOS entry points populated with HLT */
func = find_callback(GETVEC(sc->sc_cs, sc->sc_eip));
if (func) {
ipadvance(sc,);
SET16(sc->sc_eip, GET16(sc->sc_eip) + 1);
func(sc);
break;
}
default:
dump_regs(sc);
fatal("unsupported instruction\n");
}
break;
default:
dump_regs(sc);
printf("code = %04x\n", sf->sf_code);
fatal("unrecognized vm86 trap\n");
}
out:
if (tmode)
tracetrap(sc);
#undef sc
#undef ipadvance
}
#else /* USE_VM86 */
/* entry from FreeBSD, BSD/OS vm86 */
void
sigbus(struct sigframe *sf)
{
u_char *addr;
int tempflags,okflags;
int intnum;
int port;
callback_t func;
regcontext_t *REGS = (regcontext_t *)(&sf->sf_uc.uc_mcontext);
if (!(R_EFLAGS && PSL_VM))
fatal("SIGBUS in the emulator\n");
if ((int)sf->sf_siginfo != 0) {
fatal("SIGBUS code %d, trapno: %d, err: %d\n",
(int)sf->sf_siginfo, sf->sf_uc.uc_mcontext.mc_trapno,
sf->sf_uc.uc_mcontext.mc_err);
}
addr = (u_char *)MAKEPTR(R_CS, R_IP);
if (tmode)
resettrace(REGS);
if ((R_EFLAGS & (PSL_VIP | PSL_VIF)) == (PSL_VIP | PSL_VIF)) {
if (n_pending < 1) {
fatal("Pending interrupts out of sync\n");
exit(1);
}
resume_interrupt();
goto out;
}
/* printf("%p\n", addr); fflush(stdout); */
debug (D_TRAPS2, "%04x:%04x [%02x %02x %02x] ", R_CS, R_IP,
(int)addr[0], (int)addr[1], (int)addr[2]);
#if 0
if ((int)addr[0] == 0x67) {
int i;
printf("HERE\n"); fflush(stdout);
printf("addr: %p\n", REGS); fflush(stdout);
for (i = 0; i < 21 * 4; i++) {
printf("%d: %x\n", i, ((u_char *)REGS)[i]);
fflush(stdout);
}
printf("Trapno, error: %p %p\n", REGS->sc.sc_trapno, REGS->sc.sc_err);
fflush(stdout);
dump_regs(REGS);
}
#endif
switch (addr[0]) { /* what was that again dear? */
case CLI:
debug (D_TRAPS2, "cli\n");
R_IP++;
R_EFLAGS &= ~PSL_VIP;
break;
case STI:
debug (D_TRAPS2, "sti\n");
R_IP++;
R_EFLAGS |= PSL_VIP;
#if 0
if (update_counter++ > BUSY_UPDATES)
sigalrm(sf);
#endif
break;
case PUSHF:
debug (D_TRAPS2, "pushf <- 0x%x\n", R_EFLAGS);
R_IP++;
PUSH((R_FLAGS & ~PSL_I) | (R_EFLAGS & PSL_VIF ? PSL_I : 0),
REGS);
break;
case IRET:
R_IP = POP(REGS); /* get new cs:ip off the stack */
R_CS = POP(REGS);
debug (D_TRAPS2, "iret to %04x:%04x ", R_CS, R_IP);
/* FALLTHROUGH */ /* 'safe' flag pop operation */
case POPF:
/* XXX */
fatal("popf/iret in emulator");
if (addr[0] == POPF)
R_IP++;
/* get flags from stack */
tempflags = POP(REGS);
/* flags we consider OK */
okflags = (PSL_ALLCC | PSL_T | PSL_D | PSL_V);
/* keep state of non-OK flags */
R_FLAGS = ((R_FLAGS & ~okflags) |
/* pop state of OK flags */
(tempflags & okflags));
/* restore pseudo PSL_I flag */
IntState = tempflags & PSL_I;
debug(D_TRAPS2, "popf -> 0x%x\n", R_EFLAGS);
break;
case TRACETRAP:
debug(D_TRAPS2, "ttrap\n");
R_IP++;
fake_int(REGS, 3);
break;
case INTn:
intnum = addr[1];
R_IP += 2; /* nobody else will do it for us */
switch (intnum) {
case 0x2f:
switch (R_AH) { /* function number */
case 0x11:
debug (D_TRAPS|0x2f, "INT 2F:%04x\n", R_AX);
if (int2f_11(REGS)) {
/* Skip over int 2f:11 */
goto out;
}
break;
case 0x43:
debug (D_TRAPS|0x2f, "INT 2F:%04x\n", R_AX);
if (int2f_43(REGS)) {
/* Skip over int 2f:43 */
goto out;
}
break;
}
break;
}
fake_int(REGS, intnum);
break;
case INd: /* XXX implement in/out */
R_IP += 2;
port = addr[1];
inb(REGS, port);
break;
case IN:
R_IP++;
inb(REGS,R_DX);
break;
case INX:
R_IP++;
inx(REGS,R_DX);
break;
case INdX:
R_IP += 2;
port = addr[1];
inx(REGS, port);
break;
case INSB:
R_IP++;
printf("(missed) INSB <- 0x%02x\n",R_DX);
break;
case INSW:
R_IP++;
printf("(missed) INSW <- 0x%02x\n",R_DX);
break;
case OUTd:
R_IP += 2;
port = addr[1];
outb(REGS, port);
break;
case OUTdX:
R_IP += 2;
port = addr[1];
outx(REGS, port);
break;
case OUT:
R_IP++;
outb(REGS, R_DX);
break;
case OUTX:
R_IP++;
outx(REGS, R_DX);
break;
case OUTSB:
R_IP++;
printf("(missed) OUTSB -> 0x%02x\n",R_DX);
break;
case OUTSW:
R_IP++;
printf("(missed) OUTSW -> 0x%02x\n",R_DX);
/* tmode = 1; */
break;
case LOCK:
debug(D_TRAPS2, "lock\n");
R_IP++;
break;
case HLT: /* BIOS entry points populated with HLT */
func = find_callback(MAKEVEC(R_CS, R_IP));
if (func) {
R_IP++; /* pass HLT opcode */
func(REGS);
/* dump_regs(REGS); */
#if 0
update_counter += 5;
if (update_counter > BUSY_UPDATES)
sigalrm(sf);
#endif
break;
}
/* if (R_EFLAGS & PSL_VIF) { */
R_IP++;
tty_pause();
goto out;
/* } */
/* FALLTHRU */
default:
dump_regs(REGS);
fatal("unsupported instruction\n");
}
out:
if (tmode)
tracetrap(REGS);
}
#endif /* USE_VM86 */
void
sigtrace(struct sigframe *sf)
{
int x;
regcontext_t *REGS = (regcontext_t *)(&sf->sf_uc.uc_mcontext);
if (R_EFLAGS & PSL_VM) {
debug(D_ALWAYS, "Currently in DOS\n");
dump_regs(REGS);
for (x = 0; x < 16; ++x)
debug(D_ALWAYS, " %02x", *(unsigned char *)x);
putc('\n', debugf);
} else {
debug(D_ALWAYS, "Currently in the emulator\n");
sigalrm(sf);
}
}
void
sigtrap(struct sigframe *sf)
{
int intnum;
int trapno;
regcontext_t *REGS = (regcontext_t *)(&sf->sf_uc.uc_mcontext);
if ((R_EFLAGS & PSL_VM) == 0) {
dump_regs(REGS);
fatal("%04x:%08x Sigtrap in protected mode\n", R_CS, R_IP);
}
if (tmode)
if (resettrace(REGS))
goto doh;
#ifdef __FreeBSD__
trapno = (int)sf->sf_siginfo; /* XXX GROSTIC HACK ALERT */
#else
trapno = sc->sc_trapno;
#endif
if (trapno == T_BPTFLT)
intnum = 3;
else
intnum = 1;
PUSH((R_FLAGS & ~PSL_I) | (R_EFLAGS & PSL_VIF ? PSL_I : 0), REGS);
PUSH(R_CS, REGS);
PUSH(R_IP, REGS);
R_FLAGS &= ~PSL_T;
PUTVEC(R_CS, R_IP, ivec[intnum]);
doh:
if (tmode)
tracetrap(REGS);
}
void
breakpoint(struct sigframe *sf)
{
regcontext_t *REGS = (regcontext_t *)(&sf->sf_uc.uc_mcontext);
if (R_EFLAGS & PSL_VM)
printf("doscmd ");
printf("breakpoint: %04x\n", *(u_short *)0x8e64);
__asm__ volatile("mov 0, %eax");
__asm__ volatile(".byte 0x0f"); /* MOV DR6,EAX */
__asm__ volatile(".byte 0x21");
__asm__ volatile(".byte 0x1b");
}
/*
** periodic updates
*/
void
sigalrm(struct sigframe *sf)
{
regcontext_t *REGS = (regcontext_t *)(&sf->sf_uc.uc_mcontext);
if (tmode)
resettrace(REGS);
/* debug(D_ALWAYS,"tick %d", update_counter); */
update_counter = 0; /* remember we've updated */
video_update(&REGS->sc);
hardint(0x08);
/* debug(D_ALWAYS,"\n"); */
if (tmode)
tracetrap(REGS);
}
void
sigill(struct sigframe *sf)
{
regcontext_t *REGS = (regcontext_t *)(&sf->sf_uc.uc_mcontext);
fprintf(stderr, "Signal %d from DOS program\n", sf->sf_signum);
dump_regs(REGS);
fatal("%04x:%04x Illegal instruction\n", R_CS, R_IP);
}
void
sigfpe(struct sigframe *sf)
{
regcontext_t *REGS = (regcontext_t *)(&sf->sf_uc.uc_mcontext);
if (R_EFLAGS & PSL_VM) {
dump_regs(REGS);
debug(D_ALWAYS, "DOS program caused floating point fault\n");
/*XXX Look into that !! */
fake_int(REGS, 0); /* call handler XXX rather bogus, eh? */
return;
}
dump_regs(REGS);
fatal("%04x:%04x Floating point fault in emulator.\n", R_CS, R_IP);
}
Reference in New Issue View Git Blame Copy Permalink