system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-11-02 13:27:35 +00:00
Code Issues Projects Releases Packages Wiki Activity

Moved most global data out of the LPDOSTASK structure.

Browse source 
Allocate DPMI real-mode segments globally at startup.
Try to allocate DOS memory at address 0.
This commit is contained in:
Alexandre Julliard 2000-09-24 20:47:50 +00:00
parent 0ff083bab8
commit 770eb51ed5
14 changed files with 436 additions and 652 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
include/dosexe.h
View file

@ -11,38 +11,13 @@
#include "winbase.h" /* for LPSTARTUPINFO32A */ #include "winbase.h" /* for LPSTARTUPINFO32A */
#include "winnt.h" /* for PCONTEXT */ #include "winnt.h" /* for PCONTEXT */
typedef struct _DOSSYSTEM {
int id;
void *data;
struct _DOSSYSTEM *next;
} DOSSYSTEM;
struct _DOSEVENT; struct _DOSEVENT;
typedef struct _DOSTASK { typedef struct _DOSTASK {
LPVOID img; WORD psp_seg;
unsigned img_ofs; WORD dpmi_flag;
WORD psp_seg,load_seg;
WORD init_cs,init_ip,init_ss,init_sp;
WORD xms_seg;
WORD dpmi_seg,dpmi_sel,dpmi_flag;
char mm_name[128];
int mm_fd;
HANDLE hReadPipe,hXPipe,hConInput,hConOutput;
int read_pipe,write_pipe;
pid_t task;
int sig_sent,entered,idling;
struct _DOSEVENT *pending,*current;
DOSSYSTEM *sys;
} DOSTASK, *LPDOSTASK; } DOSTASK, *LPDOSTASK;
typedef struct _DOSEVENT {
int irq,priority;
void (*relay)(LPDOSTASK,CONTEXT86*,void*);
void *data;
struct _DOSEVENT *next;
} DOSEVENT, *LPDOSEVENT;
#define DOS_PRIORITY_REALTIME 0 /* IRQ0 */ #define DOS_PRIORITY_REALTIME 0 /* IRQ0 */
#define DOS_PRIORITY_KEYBOARD 1 /* IRQ1 */ #define DOS_PRIORITY_KEYBOARD 1 /* IRQ1 */
#define DOS_PRIORITY_VGA 2 /* IRQ9 */ #define DOS_PRIORITY_VGA 2 /* IRQ9 */
@ -50,26 +25,19 @@ typedef struct _DOSEVENT {
#define DOS_PRIORITY_SERIAL 10 /* IRQ4 */ #define DOS_PRIORITY_SERIAL 10 /* IRQ4 */
#if defined(linux) && defined(__i386__) #if defined(linux) && defined(__i386__)
#define MZ_SUPPORTED #define MZ_SUPPORTED
extern BOOL MZ_InitTask( LPDOSTASK lpDosTask );
extern void MZ_KillTask( LPDOSTASK lpDosTask );
extern LPDOSTASK MZ_AllocDPMITask( void );
#endif /* linux-i386 */ #endif /* linux-i386 */
#define V86_FLAG 0x00020000 #define V86_FLAG 0x00020000
extern BOOL MZ_LoadImage( HMODULE module, HANDLE hFile, LPCSTR filename ); extern BOOL MZ_LoadImage( HMODULE module, HANDLE hFile, LPCSTR filename );
extern LPDOSTASK MZ_Current( void ); extern LPDOSTASK MZ_Current( void );
extern LPDOSTASK MZ_AllocDPMITask( void );
extern int DOSVM_Enter( CONTEXT86 *context ); extern int DOSVM_Enter( CONTEXT86 *context );
extern void DOSVM_Wait( int read_pipe, HANDLE hObject ); extern void DOSVM_Wait( int read_pipe, HANDLE hObject );
extern void DOSVM_QueueEvent( int irq, int priority, void (*relay)(LPDOSTASK,CONTEXT86*,void*), void *data ); extern void DOSVM_QueueEvent( int irq, int priority, void (*relay)(CONTEXT86*,void*), void *data );
extern void DOSVM_PIC_ioport_out( WORD port, BYTE val ); extern void DOSVM_PIC_ioport_out( WORD port, BYTE val );
extern void DOSVM_SetTimer( unsigned ticks ); extern void DOSVM_SetTimer( unsigned ticks );
extern unsigned DOSVM_GetTimer( void ); extern unsigned DOSVM_GetTimer( void );
extern void DOSVM_SetSystemData( int id, void *data );
extern void* DOSVM_GetSystemData( int id );
#endif /* __WINE_DOSEXE_H */ #endif /* __WINE_DOSEXE_H */

2
include/ldt.h
View file

@ -60,6 +60,8 @@ extern ldt_copy_entry ldt_copy[LDT_SIZE];
#define PTR_SEG_OFF_TO_LIN(seg,off) \ #define PTR_SEG_OFF_TO_LIN(seg,off) \
((void*)(GET_SEL_BASE(seg) + (unsigned int)(off))) ((void*)(GET_SEL_BASE(seg) + (unsigned int)(off)))
#define PTR_REAL_TO_LIN(seg,off) \
((void*)(((unsigned int)(seg) << 4) + LOWORD(off)))
#define PTR_SEG_TO_LIN(ptr) \ #define PTR_SEG_TO_LIN(ptr) \
PTR_SEG_OFF_TO_LIN(SELECTOROF(ptr),OFFSETOF(ptr)) PTR_SEG_OFF_TO_LIN(SELECTOROF(ptr),OFFSETOF(ptr))
#define PTR_SEG_OFF_TO_SEGPTR(seg,off) \ #define PTR_SEG_OFF_TO_SEGPTR(seg,off) \

13
include/miscemu.h
View file

@ -128,8 +128,11 @@ extern BYTE * DOSMEM_BiosSys();
extern DWORD DOSMEM_CollateTable; extern DWORD DOSMEM_CollateTable;
extern DWORD DOSMEM_ErrorCall; /* various real-mode code stubs */
extern DWORD DOSMEM_ErrorBuffer; extern WORD DOSMEM_wrap_seg;
extern WORD DOSMEM_xms_seg;
extern WORD DOSMEM_dpmi_seg;
extern WORD DOSMEM_dpmi_sel;
extern DWORD DOS_LOLSeg; extern DWORD DOS_LOLSeg;
extern struct _DOS_LISTOFLISTS * DOSMEM_LOL(); extern struct _DOS_LISTOFLISTS * DOSMEM_LOL();
@ -249,7 +252,7 @@ extern void ASPI_DOS_HandleInt(CONTEXT86 *context);
* a *32-bit* general register as third parameter, e.g. * a *32-bit* general register as third parameter, e.g.
* CTX_SEG_OFF_TO_LIN( context, DS_reg(context), EDX_reg(context) ) * CTX_SEG_OFF_TO_LIN( context, DS_reg(context), EDX_reg(context) )
* This will generate a linear pointer in all three cases: * This will generate a linear pointer in all three cases:
* Real-Mode: Seg*16 + LOWORD(Offset) + V86BASE * Real-Mode: Seg*16 + LOWORD(Offset)
* 16-bit: convert (Seg, LOWORD(Offset)) to linear * 16-bit: convert (Seg, LOWORD(Offset)) to linear
* 32-bit: use Offset as linear address (DeviceIoControl!) * 32-bit: use Offset as linear address (DeviceIoControl!)
* *
@ -258,8 +261,8 @@ extern void ASPI_DOS_HandleInt(CONTEXT86 *context);
* (0 counts also as 32-bit segment). * (0 counts also as 32-bit segment).
*/ */
#define CTX_SEG_OFF_TO_LIN(context,seg,off) \ #define CTX_SEG_OFF_TO_LIN(context,seg,off) \
(ISV86(context) ? (void*)(V86BASE(context)+((seg)<<4)+(off&0xffff)) : \ (ISV86(context) ? PTR_REAL_TO_LIN((seg),(off)) : \
(!seg || IS_SELECTOR_SYSTEM(seg))? (void *)off : PTR_SEG_OFF_TO_LIN(seg,off&0xffff)) (!seg || IS_SELECTOR_SYSTEM(seg))? (void *)(off) : PTR_SEG_OFF_TO_LIN((seg),LOWORD(off)))
#define INT_BARF(context,num) \ #define INT_BARF(context,num) \
ERR( "int%x: unknown/not implemented parameters:\n" \ ERR( "int%x: unknown/not implemented parameters:\n" \

1
include/winnt.h
View file

@ -730,7 +730,6 @@ typedef HANDLE *PHANDLE;
#define RESET_ZFLAG(context) (EFL_reg(context) &= ~0x0040) #define RESET_ZFLAG(context) (EFL_reg(context) &= ~0x0040)
#define ISV86(context) (EFL_reg(context) & 0x00020000) #define ISV86(context) (EFL_reg(context) & 0x00020000)
#define V86BASE(context) DOSMEM_MemoryBase()
/* Macros to retrieve the current context */ /* Macros to retrieve the current context */

233
loader/dos/dosvm.c
View file

@ -58,6 +58,21 @@ DECLARE_DEBUG_CHANNEL(relay)
#undef TRY_PICRETURN #undef TRY_PICRETURN
typedef struct _DOSEVENT {
int irq,priority;
void (*relay)(CONTEXT86*,void*);
void *data;
struct _DOSEVENT *next;
} DOSEVENT, *LPDOSEVENT;
static struct _DOSEVENT *pending_event, *current_event;
static int sig_sent, entered;
/* from module.c */
extern int read_pipe, write_pipe;
extern HANDLE hReadPipe;
extern pid_t dosmod_pid;
static void do_exception( int signal, CONTEXT86 *context ) static void do_exception( int signal, CONTEXT86 *context )
{ {
EXCEPTION_RECORD rec; EXCEPTION_RECORD rec;
@ -77,10 +92,8 @@ static void do_exception( int signal, CONTEXT86 *context )
EXC_RtlRaiseException( &rec, context ); EXC_RtlRaiseException( &rec, context );
} }
static void DOSVM_Dump( LPDOSTASK lpDosTask, int fn, int sig, static void DOSVM_Dump( int fn, int sig, struct vm86plus_struct*VM86 )
struct vm86plus_struct*VM86 )
{ {
unsigned iofs;
BYTE*inst; BYTE*inst;
int x; int x;
@ -106,20 +119,17 @@ static void DOSVM_Dump( LPDOSTASK lpDosTask, int fn, int sig,
fprintf(stderr,"CS=%04X DS=%04X ES=%04X SS=%04X\n",REGS.cs,REGS.ds,REGS.es,REGS.ss); fprintf(stderr,"CS=%04X DS=%04X ES=%04X SS=%04X\n",REGS.cs,REGS.ds,REGS.es,REGS.ss);
fprintf(stderr,"IP=%04lX EFLAGS=%08lX\n",REGS.eip,REGS.eflags); fprintf(stderr,"IP=%04lX EFLAGS=%08lX\n",REGS.eip,REGS.eflags);
iofs=((DWORD)REGS.cs<<4)+REGS.eip; inst = PTR_REAL_TO_LIN( REGS.cs, REGS.eip );
#undef REGS #undef REGS
inst=(BYTE*)lpDosTask->img+iofs;
printf("Opcodes:"); printf("Opcodes:");
for (x=0; x<8; x++) printf(" %02x",inst[x]); for (x=0; x<8; x++) printf(" %02x",inst[x]);
printf("\n"); printf("\n");
} }
static int DOSVM_Int( int vect, CONTEXT86 *context, LPDOSTASK lpDosTask ) static int DOSVM_Int( int vect, CONTEXT86 *context )
{ {
extern UINT16 DPMI_wrap_seg;
if (vect==0x31) { if (vect==0x31) {
if (CS_reg(context)==DPMI_wrap_seg) { if (CS_reg(context)==DOSMEM_wrap_seg) {
/* exit from real-mode wrapper */ /* exit from real-mode wrapper */
return -1; return -1;
} }
@ -129,7 +139,7 @@ static int DOSVM_Int( int vect, CONTEXT86 *context, LPDOSTASK lpDosTask )
return 0; return 0;
} }
static void DOSVM_SimulateInt( int vect, CONTEXT86 *context, LPDOSTASK lpDosTask ) static void DOSVM_SimulateInt( int vect, CONTEXT86 *context )
{ {
FARPROC16 handler=INT_GetRMHandler(vect); FARPROC16 handler=INT_GetRMHandler(vect);
@ -137,7 +147,7 @@ static void DOSVM_SimulateInt( int vect, CONTEXT86 *context, LPDOSTASK lpDosTask
/* if internal interrupt, call it directly */ /* if internal interrupt, call it directly */
INT_RealModeInterrupt(vect,context); INT_RealModeInterrupt(vect,context);
} else { } else {
WORD*stack=(WORD*)(V86BASE(context)+(((DWORD)SS_reg(context))<<4)+LOWORD(ESP_reg(context))); WORD*stack= PTR_REAL_TO_LIN( context->SegSs, context->Esp );
WORD flag=LOWORD(EFL_reg(context)); WORD flag=LOWORD(EFL_reg(context));
if (IF_ENABLED(context)) flag|=IF_MASK; if (IF_ENABLED(context)) flag|=IF_MASK;
@ -154,51 +164,50 @@ static void DOSVM_SimulateInt( int vect, CONTEXT86 *context, LPDOSTASK lpDosTask
} }
#define SHOULD_PEND(x) \ #define SHOULD_PEND(x) \
(x && ((!lpDosTask->current) || (x->priority < lpDosTask->current->priority))) (x && ((!current_event) || (x->priority < current_event->priority)))
static void DOSVM_SendQueuedEvent(CONTEXT86 *context, LPDOSTASK lpDosTask) static void DOSVM_SendQueuedEvent(CONTEXT86 *context)
{ {
LPDOSEVENT event = lpDosTask->pending; LPDOSEVENT event = pending_event;
if (SHOULD_PEND(event)) { if (SHOULD_PEND(event)) {
/* remove from "pending" list */ /* remove from "pending" list */
lpDosTask->pending = event->next; pending_event = event->next;
/* process event */ /* process event */
if (event->irq>=0) { if (event->irq>=0) {
/* it's an IRQ, move it to "current" list */ /* it's an IRQ, move it to "current" list */
event->next = lpDosTask->current; event->next = current_event;
lpDosTask->current = event; current_event = event;
TRACE_(int)("dispatching IRQ %d\n",event->irq); TRACE_(int)("dispatching IRQ %d\n",event->irq);
/* note that if DOSVM_SimulateInt calls an internal interrupt directly, /* note that if DOSVM_SimulateInt calls an internal interrupt directly,
* lpDosTask->current might be cleared (and event freed) in this very call! */ * current_event might be cleared (and event freed) in this very call! */
DOSVM_SimulateInt((event->irq<8)?(event->irq+8):(event->irq-8+0x70),context,lpDosTask); DOSVM_SimulateInt((event->irq<8)?(event->irq+8):(event->irq-8+0x70),context);
} else { } else {
/* callback event */ /* callback event */
TRACE_(int)("dispatching callback event\n"); TRACE_(int)("dispatching callback event\n");
(*event->relay)(lpDosTask,context,event->data); (*event->relay)(context,event->data);
free(event); free(event);
} }
} }
if (!SHOULD_PEND(lpDosTask->pending)) { if (!SHOULD_PEND(pending_event)) {
TRACE_(int)("clearing Pending flag\n"); TRACE_(int)("clearing Pending flag\n");
CLR_PEND(context); CLR_PEND(context);
} }
} }
static void DOSVM_SendQueuedEvents(CONTEXT86 *context, LPDOSTASK lpDosTask) static void DOSVM_SendQueuedEvents(CONTEXT86 *context)
{ {
/* we will send all queued events as long as interrupts are enabled, /* we will send all queued events as long as interrupts are enabled,
* but IRQ events will disable interrupts again */ * but IRQ events will disable interrupts again */
while (IS_PEND(context) && IF_ENABLED(context)) while (IS_PEND(context) && IF_ENABLED(context))
DOSVM_SendQueuedEvent(context,lpDosTask); DOSVM_SendQueuedEvent(context);
} }
void DOSVM_QueueEvent( int irq, int priority, void (*relay)(LPDOSTASK,CONTEXT86*,void*), void *data) void DOSVM_QueueEvent( int irq, int priority, void (*relay)(CONTEXT86*,void*), void *data)
{ {
LPDOSTASK lpDosTask = MZ_Current();
LPDOSEVENT event, cur, prev; LPDOSEVENT event, cur, prev;
if (lpDosTask && lpDosTask->entered) { if (entered) {
event = malloc(sizeof(DOSEVENT)); event = malloc(sizeof(DOSEVENT));
if (!event) { if (!event) {
ERR_(int)("out of memory allocating event entry\n"); ERR_(int)("out of memory allocating event entry\n");
@ -209,20 +218,20 @@ void DOSVM_QueueEvent( int irq, int priority, void (*relay)(LPDOSTASK,CONTEXT86*
/* insert event into linked list, in order *after* /* insert event into linked list, in order *after*
* all earlier events of higher or equal priority */ * all earlier events of higher or equal priority */
cur = lpDosTask->pending; prev = NULL; cur = pending_event; prev = NULL;
while (cur && cur->priority<=priority) { while (cur && cur->priority<=priority) {
prev = cur; prev = cur;
cur = cur->next; cur = cur->next;
} }
event->next = cur; event->next = cur;
if (prev) prev->next = event; if (prev) prev->next = event;
else lpDosTask->pending = event; else pending_event = event;
/* get dosmod's attention to the new event, if necessary */ /* get dosmod's attention to the new event, if necessary */
if (!lpDosTask->sig_sent) { if (!sig_sent) {
TRACE_(int)("new event queued, signalling dosmod\n"); TRACE_(int)("new event queued, signalling dosmod\n");
kill(lpDosTask->task,SIGUSR2); kill(dosmod_pid,SIGUSR2);
lpDosTask->sig_sent++; sig_sent++;
} else { } else {
TRACE_(int)("new event queued\n"); TRACE_(int)("new event queued\n");
} }
@ -234,7 +243,7 @@ void DOSVM_QueueEvent( int irq, int priority, void (*relay)(LPDOSTASK,CONTEXT86*
/* callback event, perform it with dummy context */ /* callback event, perform it with dummy context */
CONTEXT86 context; CONTEXT86 context;
memset(&context,0,sizeof(context)); memset(&context,0,sizeof(context));
(*relay)(lpDosTask,&context,data); (*relay)(&context,data);
} else { } else {
ERR_(int)("IRQ without DOS task: should not happen"); ERR_(int)("IRQ without DOS task: should not happen");
} }
@ -247,8 +256,7 @@ void DOSVM_QueueEvent( int irq, int priority, void (*relay)(LPDOSTASK,CONTEXT86*
CP(ss,SS); CP(fs,FS); CP(gs,GS); \ CP(ss,SS); CP(fs,FS); CP(gs,GS); \
CP(eip,EIP); CP(eflags,EFL) CP(eip,EIP); CP(eflags,EFL)
static int DOSVM_Process( LPDOSTASK lpDosTask, int fn, int sig, static int DOSVM_Process( int fn, int sig, struct vm86plus_struct*VM86 )
struct vm86plus_struct*VM86 )
{ {
CONTEXT86 context; CONTEXT86 context;
int ret=0; int ret=0;
@ -270,7 +278,7 @@ static int DOSVM_Process( LPDOSTASK lpDosTask, int fn, int sig,
} }
#else #else
/* linux doesn't preserve pending flag on return */ /* linux doesn't preserve pending flag on return */
if (SHOULD_PEND(lpDosTask->pending)) { if (SHOULD_PEND(pending_event)) {
SET_PEND(&context); SET_PEND(&context);
} }
#endif #endif
@ -280,48 +288,48 @@ static int DOSVM_Process( LPDOSTASK lpDosTask, int fn, int sig,
TRACE_(int)("DOS module caught signal %d\n",sig); TRACE_(int)("DOS module caught signal %d\n",sig);
if ((sig==SIGALRM) || (sig==SIGUSR2)) { if ((sig==SIGALRM) || (sig==SIGUSR2)) {
if (sig==SIGALRM) { if (sig==SIGALRM) {
lpDosTask->sig_sent++; sig_sent++;
DOSVM_QueueEvent(0,DOS_PRIORITY_REALTIME,NULL,NULL); DOSVM_QueueEvent(0,DOS_PRIORITY_REALTIME,NULL,NULL);
} }
if (lpDosTask->pending) { if (pending_event) {
TRACE_(int)("setting Pending flag, interrupts are currently %s\n", TRACE_(int)("setting Pending flag, interrupts are currently %s\n",
IF_ENABLED(&context) ? "enabled" : "disabled"); IF_ENABLED(&context) ? "enabled" : "disabled");
SET_PEND(&context); SET_PEND(&context);
DOSVM_SendQueuedEvents(&context,lpDosTask); DOSVM_SendQueuedEvents(&context);
} else { } else {
TRACE_(int)("no events are pending, clearing Pending flag\n"); TRACE_(int)("no events are pending, clearing Pending flag\n");
CLR_PEND(&context); CLR_PEND(&context);
} }
lpDosTask->sig_sent--; sig_sent--;
} }
else if ((sig==SIGHUP) || (sig==SIGILL) || (sig==SIGSEGV)) { else if ((sig==SIGHUP) || (sig==SIGILL) || (sig==SIGSEGV)) {
do_exception( sig, &context ); do_exception( sig, &context );
} else { } else {
DOSVM_Dump(lpDosTask,fn,sig,VM86); DOSVM_Dump(fn,sig,VM86);
ret=-1; ret=-1;
} }
break; break;
case VM86_UNKNOWN: /* unhandled GPF */ case VM86_UNKNOWN: /* unhandled GPF */
DOSVM_Dump(lpDosTask,fn,sig,VM86); DOSVM_Dump(fn,sig,VM86);
do_exception( SIGSEGV, &context ); do_exception( SIGSEGV, &context );
break; break;
case VM86_INTx: case VM86_INTx:
if (TRACE_ON(relay)) if (TRACE_ON(relay))
DPRINTF("Call DOS int 0x%02x (EAX=%08lx) ret=%04lx:%04lx\n",VM86_ARG(fn),context.Eax,context.SegCs,context.Eip); DPRINTF("Call DOS int 0x%02x (EAX=%08lx) ret=%04lx:%04lx\n",VM86_ARG(fn),context.Eax,context.SegCs,context.Eip);
ret=DOSVM_Int(VM86_ARG(fn),&context,lpDosTask); ret=DOSVM_Int(VM86_ARG(fn),&context);
if (TRACE_ON(relay)) if (TRACE_ON(relay))
DPRINTF("Ret DOS int 0x%02x (EAX=%08lx) ret=%04lx:%04lx\n",VM86_ARG(fn),context.Eax,context.SegCs,context.Eip); DPRINTF("Ret DOS int 0x%02x (EAX=%08lx) ret=%04lx:%04lx\n",VM86_ARG(fn),context.Eax,context.SegCs,context.Eip);
break; break;
case VM86_STI: case VM86_STI:
case VM86_PICRETURN: case VM86_PICRETURN:
TRACE_(int)("DOS task enabled interrupts with events pending, sending events\n"); TRACE_(int)("DOS task enabled interrupts with events pending, sending events\n");
DOSVM_SendQueuedEvents(&context,lpDosTask); DOSVM_SendQueuedEvents(&context);
break; break;
case VM86_TRAP: case VM86_TRAP:
do_exception( SIGTRAP, &context ); do_exception( SIGTRAP, &context );
break; break;
default: default:
DOSVM_Dump(lpDosTask,fn,sig,VM86); DOSVM_Dump(fn,sig,VM86);
ret=-1; ret=-1;
} }
@ -335,7 +343,7 @@ static int DOSVM_Process( LPDOSTASK lpDosTask, int fn, int sig,
return ret; return ret;
} }
static void DOSVM_ProcessConsole(LPDOSTASK lpDosTask) static void DOSVM_ProcessConsole(void)
{ {
INPUT_RECORD msg; INPUT_RECORD msg;
DWORD res; DWORD res;
@ -360,7 +368,7 @@ static void DOSVM_ProcessConsole(LPDOSTASK lpDosTask)
} }
} }
static void DOSVM_ProcessMessage(LPDOSTASK lpDosTask,MSG *msg) static void DOSVM_ProcessMessage(MSG *msg)
{ {
BYTE scan = 0; BYTE scan = 0;
@ -391,21 +399,20 @@ static void DOSVM_ProcessMessage(LPDOSTASK lpDosTask,MSG *msg)
void DOSVM_Wait( int read_pipe, HANDLE hObject ) void DOSVM_Wait( int read_pipe, HANDLE hObject )
{ {
LPDOSTASK lpDosTask = MZ_Current();
MSG msg; MSG msg;
DWORD waitret; DWORD waitret;
HANDLE objs[2]; HANDLE objs[2];
int objc; int objc;
BOOL got_msg = FALSE; BOOL got_msg = FALSE;
objs[0]=lpDosTask->hConInput; objs[0]=GetStdHandle(STD_INPUT_HANDLE);
objs[1]=hObject; objs[1]=hObject;
objc=hObject?2:1; objc=hObject?2:1;
do { do {
/* check for messages (waste time before the response check below) */ /* check for messages (waste time before the response check below) */
while (Callout.PeekMessageA(&msg,0,0,0,PM_REMOVE|PM_NOYIELD)) { while (Callout.PeekMessageA(&msg,0,0,0,PM_REMOVE|PM_NOYIELD)) {
/* got a message */ /* got a message */
DOSVM_ProcessMessage(lpDosTask,&msg); DOSVM_ProcessMessage(&msg);
/* we don't need a TranslateMessage here */ /* we don't need a TranslateMessage here */
Callout.DispatchMessageA(&msg); Callout.DispatchMessageA(&msg);
got_msg = TRUE; got_msg = TRUE;
@ -415,7 +422,7 @@ void DOSVM_Wait( int read_pipe, HANDLE hObject )
INPUT_RECORD msg; INPUT_RECORD msg;
DWORD num; DWORD num;
if (PeekConsoleInputA(objs[0],&msg,1,&num) && num) { if (PeekConsoleInputA(objs[0],&msg,1,&num) && num) {
DOSVM_ProcessConsole(lpDosTask); DOSVM_ProcessConsole();
got_msg = TRUE; got_msg = TRUE;
} }
} }
@ -439,63 +446,42 @@ void DOSVM_Wait( int read_pipe, HANDLE hObject )
if (waitret==(WAIT_OBJECT_0+1)) break; if (waitret==(WAIT_OBJECT_0+1)) break;
} }
if (waitret==WAIT_OBJECT_0) { if (waitret==WAIT_OBJECT_0) {
DOSVM_ProcessConsole(lpDosTask); DOSVM_ProcessConsole();
} }
} while (TRUE); } while (TRUE);
} }
int DOSVM_Enter( CONTEXT86 *context ) int DOSVM_Enter( CONTEXT86 *context )
{ {
LPDOSTASK lpDosTask = MZ_Current();
struct vm86plus_struct VM86; struct vm86plus_struct VM86;
int stat,len,sig; int stat,len,sig;
if (!lpDosTask) {
/* MZ_CreateProcess or MZ_AllocDPMITask should have been called first */
ERR_(module)("dosmod has not been initialized!");
return -1;
}
if (context) {
#define CP(x,y) VM86.regs.x = y##_reg(context) #define CP(x,y) VM86.regs.x = y##_reg(context)
CV; CV;
#undef CP #undef CP
if (VM86.regs.eflags & IF_MASK) if (VM86.regs.eflags & IF_MASK)
VM86.regs.eflags |= VIF_MASK; VM86.regs.eflags |= VIF_MASK;
} else {
/* initial setup */
/* registers */
memset(&VM86,0,sizeof(VM86));
VM86.regs.cs=lpDosTask->init_cs;
VM86.regs.eip=lpDosTask->init_ip;
VM86.regs.ss=lpDosTask->init_ss;
VM86.regs.esp=lpDosTask->init_sp;
VM86.regs.ds=lpDosTask->psp_seg;
VM86.regs.es=lpDosTask->psp_seg;
VM86.regs.eflags=VIF_MASK;
/* hmm, what else do we need? */
}
/* main exchange loop */ /* main exchange loop */
lpDosTask->entered++; entered++;
do { do {
TRACE_(module)("thread is: %lx\n",GetCurrentThreadId()); TRACE_(module)("thread is: %lx\n",GetCurrentThreadId());
stat = VM86_ENTER; stat = VM86_ENTER;
errno = 0; errno = 0;
/* transmit VM86 structure to dosmod task */ /* transmit VM86 structure to dosmod task */
if (write(lpDosTask->write_pipe,&stat,sizeof(stat))!=sizeof(stat)) { if (write(write_pipe,&stat,sizeof(stat))!=sizeof(stat)) {
ERR_(module)("dosmod sync lost, errno=%d, fd=%d, pid=%d\n",errno,lpDosTask->write_pipe,getpid()); ERR_(module)("dosmod sync lost, errno=%d, fd=%d, pid=%d\n",errno,write_pipe,getpid());
return -1; return -1;
} }
if (write(lpDosTask->write_pipe,&VM86,sizeof(VM86))!=sizeof(VM86)) { if (write(write_pipe,&VM86,sizeof(VM86))!=sizeof(VM86)) {
ERR_(module)("dosmod sync lost, errno=%d\n",errno); ERR_(module)("dosmod sync lost, errno=%d\n",errno);
return -1; return -1;
} }
/* wait for response, doing other things in the meantime */ /* wait for response, doing other things in the meantime */
DOSVM_Wait(lpDosTask->read_pipe, lpDosTask->hReadPipe); DOSVM_Wait(read_pipe, hReadPipe);
/* read response */ /* read response */
while (1) { while (1) {
if ((len=read(lpDosTask->read_pipe,&stat,sizeof(stat)))==sizeof(stat)) break; if ((len=read(read_pipe,&stat,sizeof(stat)))==sizeof(stat)) break;
if (((errno==EINTR)||(errno==EAGAIN))&&(len<=0)) { if (((errno==EINTR)||(errno==EAGAIN))&&(len<=0)) {
WARN_(module)("rereading dosmod return code due to errno=%d, result=%d\n",errno,len); WARN_(module)("rereading dosmod return code due to errno=%d, result=%d\n",errno,len);
continue; continue;
@ -505,11 +491,10 @@ int DOSVM_Enter( CONTEXT86 *context )
} }
TRACE_(module)("dosmod return code=%d\n",stat); TRACE_(module)("dosmod return code=%d\n",stat);
if (stat==DOSMOD_LEFTIDLE) { if (stat==DOSMOD_LEFTIDLE) {
lpDosTask->idling--;
continue; continue;
} }
while (1) { while (1) {
if ((len=read(lpDosTask->read_pipe,&VM86,sizeof(VM86)))==sizeof(VM86)) break; if ((len=read(read_pipe,&VM86,sizeof(VM86)))==sizeof(VM86)) break;
if (((errno==EINTR)||(errno==EAGAIN))&&(len<=0)) { if (((errno==EINTR)||(errno==EAGAIN))&&(len<=0)) {
WARN_(module)("rereading dosmod VM86 structure due to errno=%d, result=%d\n",errno,len); WARN_(module)("rereading dosmod VM86 structure due to errno=%d, result=%d\n",errno,len);
continue; continue;
@ -519,7 +504,7 @@ int DOSVM_Enter( CONTEXT86 *context )
} }
if ((stat&0xff)==DOSMOD_SIGNAL) { if ((stat&0xff)==DOSMOD_SIGNAL) {
while (1) { while (1) {
if ((len=read(lpDosTask->read_pipe,&sig,sizeof(sig)))==sizeof(sig)) break; if ((len=read(read_pipe,&sig,sizeof(sig)))==sizeof(sig)) break;
if (((errno==EINTR)||(errno==EAGAIN))&&(len<=0)) { if (((errno==EINTR)||(errno==EAGAIN))&&(len<=0)) {
WARN_(module)("rereading dosmod signal due to errno=%d, result=%d\n",errno,len); WARN_(module)("rereading dosmod signal due to errno=%d, result=%d\n",errno,len);
continue; continue;
@ -529,8 +514,8 @@ int DOSVM_Enter( CONTEXT86 *context )
} while (0); } while (0);
} else sig=0; } else sig=0;
/* got response */ /* got response */
} while (DOSVM_Process(lpDosTask,stat,sig,&VM86)>=0); } while (DOSVM_Process(stat,sig,&VM86)>=0);
lpDosTask->entered--; entered--;
if (context) { if (context) {
#define CP(x,y) y##_reg(context) = VM86.regs.x #define CP(x,y) y##_reg(context) = VM86.regs.x
@ -542,27 +527,25 @@ int DOSVM_Enter( CONTEXT86 *context )
void DOSVM_PIC_ioport_out( WORD port, BYTE val) void DOSVM_PIC_ioport_out( WORD port, BYTE val)
{ {
LPDOSTASK lpDosTask = MZ_Current(); LPDOSEVENT event;
LPDOSEVENT event;
if (lpDosTask) {
if ((port==0x20) && (val==0x20)) { if ((port==0x20) && (val==0x20)) {
if (lpDosTask->current) { if (current_event) {
/* EOI (End Of Interrupt) */ /* EOI (End Of Interrupt) */
TRACE_(int)("received EOI for current IRQ, clearing\n"); TRACE_(int)("received EOI for current IRQ, clearing\n");
event = lpDosTask->current; event = current_event;
lpDosTask->current = event->next; current_event = event->next;
if (event->relay) if (event->relay)
(*event->relay)(lpDosTask,NULL,event->data); (*event->relay)(NULL,event->data);
free(event); free(event);
if (lpDosTask->pending && if (pending_event &&
!lpDosTask->sig_sent) { !sig_sent) {
/* another event is pending, which we should probably /* another event is pending, which we should probably
* be able to process now, so tell dosmod about it */ * be able to process now, so tell dosmod about it */
TRACE_(int)("another event pending, signalling dosmod\n"); TRACE_(int)("another event pending, signalling dosmod\n");
kill(lpDosTask->task,SIGUSR2); kill(dosmod_pid,SIGUSR2);
lpDosTask->sig_sent++; sig_sent++;
} }
} else { } else {
WARN_(int)("EOI without active IRQ\n"); WARN_(int)("EOI without active IRQ\n");
@ -570,27 +553,25 @@ void DOSVM_PIC_ioport_out( WORD port, BYTE val)
} else { } else {
FIXME_(int)("unrecognized PIC command %02x\n",val); FIXME_(int)("unrecognized PIC command %02x\n",val);
} }
}
} }
void DOSVM_SetTimer( unsigned ticks ) void DOSVM_SetTimer( unsigned ticks )
{ {
LPDOSTASK lpDosTask = MZ_Current();
int stat=DOSMOD_SET_TIMER; int stat=DOSMOD_SET_TIMER;
struct timeval tim; struct timeval tim;
if (lpDosTask) { if (MZ_Current()) {
/* the PC clocks ticks at 1193180 Hz */ /* the PC clocks ticks at 1193180 Hz */
tim.tv_sec=0; tim.tv_sec=0;
tim.tv_usec=((unsigned long long)ticks*1000000)/1193180; tim.tv_usec=((unsigned long long)ticks*1000000)/1193180;
/* sanity check */ /* sanity check */
if (!tim.tv_usec) tim.tv_usec=1; if (!tim.tv_usec) tim.tv_usec=1;
if (write(lpDosTask->write_pipe,&stat,sizeof(stat))!=sizeof(stat)) { if (write(write_pipe,&stat,sizeof(stat))!=sizeof(stat)) {
ERR_(module)("dosmod sync lost, errno=%d\n",errno); ERR_(module)("dosmod sync lost, errno=%d\n",errno);
return; return;
} }
if (write(lpDosTask->write_pipe,&tim,sizeof(tim))!=sizeof(tim)) { if (write(write_pipe,&tim,sizeof(tim))!=sizeof(tim)) {
ERR_(module)("dosmod sync lost, errno=%d\n",errno); ERR_(module)("dosmod sync lost, errno=%d\n",errno);
return; return;
} }
@ -600,18 +581,17 @@ void DOSVM_SetTimer( unsigned ticks )
unsigned DOSVM_GetTimer( void ) unsigned DOSVM_GetTimer( void )
{ {
LPDOSTASK lpDosTask = MZ_Current();
int stat=DOSMOD_GET_TIMER; int stat=DOSMOD_GET_TIMER;
struct timeval tim; struct timeval tim;
if (lpDosTask) { if (MZ_Current()) {
if (write(lpDosTask->write_pipe,&stat,sizeof(stat))!=sizeof(stat)) { if (write(write_pipe,&stat,sizeof(stat))!=sizeof(stat)) {
ERR_(module)("dosmod sync lost, errno=%d\n",errno); ERR_(module)("dosmod sync lost, errno=%d\n",errno);
return 0; return 0;
} }
/* read response */ /* read response */
while (1) { while (1) {
if (read(lpDosTask->read_pipe,&tim,sizeof(tim))==sizeof(tim)) break; if (read(read_pipe,&tim,sizeof(tim))==sizeof(tim)) break;
if ((errno==EINTR)||(errno==EAGAIN)) continue; if ((errno==EINTR)||(errno==EAGAIN)) continue;
ERR_(module)("dosmod sync lost, errno=%d\n",errno); ERR_(module)("dosmod sync lost, errno=%d\n",errno);
return 0; return 0;
@ -621,47 +601,6 @@ unsigned DOSVM_GetTimer( void )
return 0; return 0;
} }
void DOSVM_SetSystemData( int id, void *data )
{
LPDOSTASK lpDosTask = MZ_Current();
DOSSYSTEM *sys, *prev;
if (lpDosTask) {
sys = lpDosTask->sys;
prev = NULL;
while (sys && (sys->id != id)) {
prev = sys;
sys = sys->next;
}
if (sys) {
free(sys->data);
sys->data = data;
} else {
sys = malloc(sizeof(DOSSYSTEM));
sys->id = id;
sys->data = data;
sys->next = NULL;
if (prev) prev->next = sys;
else lpDosTask->sys = sys;
}
} else free(data);
}
void* DOSVM_GetSystemData( int id )
{
LPDOSTASK lpDosTask = MZ_Current();
DOSSYSTEM *sys;
if (lpDosTask) {
sys = lpDosTask->sys;
while (sys && (sys->id != id))
sys = sys->next;
if (sys)
return sys->data;
}
return NULL;
}
#else /* !MZ_SUPPORTED */ #else /* !MZ_SUPPORTED */
int DOSVM_Enter( CONTEXT86 *context ) int DOSVM_Enter( CONTEXT86 *context )
@ -674,15 +613,13 @@ void DOSVM_Wait( int read_pipe, HANDLE hObject) {}
void DOSVM_PIC_ioport_out( WORD port, BYTE val) {} void DOSVM_PIC_ioport_out( WORD port, BYTE val) {}
void DOSVM_SetTimer( unsigned ticks ) {} void DOSVM_SetTimer( unsigned ticks ) {}
unsigned DOSVM_GetTimer( void ) { return 0; } unsigned DOSVM_GetTimer( void ) { return 0; }
void DOSVM_SetSystemData( int id, void *data ) { free(data); } void DOSVM_QueueEvent( int irq, int priority, void (*relay)(CONTEXT86*,void*), void *data)
void* DOSVM_GetSystemData( int id ) { return NULL; }
void DOSVM_QueueEvent( int irq, int priority, void (*relay)(LPDOSTASK,CONTEXT86*,void*), void *data)
{ {
if (irq<0) { if (irq<0) {
/* callback event, perform it with dummy context */ /* callback event, perform it with dummy context */
CONTEXT86 context; CONTEXT86 context;
memset(&context,0,sizeof(context)); memset(&context,0,sizeof(context));
(*relay)(NULL,&context,data); (*relay)(&context,data);
} else { } else {
ERR_(int)("IRQ without DOS task: should not happen"); ERR_(int)("IRQ without DOS task: should not happen");
} }

295
loader/dos/module.c
View file

@ -37,6 +37,8 @@
DEFAULT_DEBUG_CHANNEL(module); DEFAULT_DEBUG_CHANNEL(module);
static LPDOSTASK dos_current;
#ifdef MZ_SUPPORTED #ifdef MZ_SUPPORTED
#ifdef HAVE_SYS_MMAN_H #ifdef HAVE_SYS_MMAN_H
@ -48,15 +50,21 @@ DEFAULT_DEBUG_CHANNEL(module);
#undef MZ_MAPSELF #undef MZ_MAPSELF
#define BIOS_DATA_SEGMENT 0x40 #define BIOS_DATA_SEGMENT 0x40
#define START_OFFSET 0
#define PSP_SIZE 0x10 #define PSP_SIZE 0x10
#define SEG16(ptr,seg) ((LPVOID)((BYTE*)ptr+((DWORD)(seg)<<4))) #define SEG16(ptr,seg) ((LPVOID)((BYTE*)ptr+((DWORD)(seg)<<4)))
#define SEGPTR16(ptr,segptr) ((LPVOID)((BYTE*)ptr+((DWORD)SELECTOROF(segptr)<<4)+OFFSETOF(segptr))) #define SEGPTR16(ptr,segptr) ((LPVOID)((BYTE*)ptr+((DWORD)SELECTOROF(segptr)<<4)+OFFSETOF(segptr)))
static LPDOSTASK dos_current; static WORD init_cs,init_ip,init_ss,init_sp;
static char mm_name[128];
int read_pipe, write_pipe;
HANDLE hReadPipe, hWritePipe;
pid_t dosmod_pid;
static void MZ_Launch(void); static void MZ_Launch(void);
static BOOL MZ_InitTask(void);
static void MZ_KillTask(void);
static void MZ_CreatePSP( LPVOID lpPSP, WORD env ) static void MZ_CreatePSP( LPVOID lpPSP, WORD env )
{ {
@ -107,68 +115,18 @@ static char int08[]={
0xCF /* iret */ 0xCF /* iret */
}; };
static void MZ_InitHandlers( LPDOSTASK lpDosTask ) static void MZ_InitHandlers(void)
{ {
WORD seg; WORD seg;
LPBYTE start=DOSMEM_GetBlock(sizeof(int08),&seg); LPBYTE start=DOSMEM_GetBlock(sizeof(int08),&seg);
memcpy(start,int08,sizeof(int08)); memcpy(start,int08,sizeof(int08));
/* INT 08: point it at our tick-incrementing handler */ /* INT 08: point it at our tick-incrementing handler */
((SEGPTR*)(lpDosTask->img))[0x08]=PTR_SEG_OFF_TO_SEGPTR(seg,0); ((SEGPTR*)0)[0x08]=PTR_SEG_OFF_TO_SEGPTR(seg,0);
/* INT 1C: just point it to IRET, we don't want to handle it ourselves */ /* INT 1C: just point it to IRET, we don't want to handle it ourselves */
((SEGPTR*)(lpDosTask->img))[0x1C]=PTR_SEG_OFF_TO_SEGPTR(seg,sizeof(int08)-1); ((SEGPTR*)0)[0x1C]=PTR_SEG_OFF_TO_SEGPTR(seg,sizeof(int08)-1);
} }
static char enter_xms[]={ static WORD MZ_InitEnvironment( LPCSTR env, LPCSTR name )
/* XMS hookable entry point */
0xEB,0x03, /* jmp entry */
0x90,0x90,0x90, /* nop;nop;nop */
/* entry: */
/* real entry point */
/* for simplicity, we'll just use the same hook as DPMI below */
0xCD,0x31, /* int $0x31 */
0xCB /* lret */
};
static void MZ_InitXMS( LPDOSTASK lpDosTask )
{
LPBYTE start=DOSMEM_GetBlock(sizeof(enter_xms),&(lpDosTask->xms_seg));
memcpy(start,enter_xms,sizeof(enter_xms));
}
static char enter_pm[]={
0x50, /* pushw %ax */
0x52, /* pushw %dx */
0x55, /* pushw %bp */
0x89,0xE5, /* movw %sp,%bp */
/* get return CS */
0x8B,0x56,0x08, /* movw 8(%bp),%dx */
/* just call int 31 here to get into protected mode... */
/* it'll check whether it was called from dpmi_seg... */
0xCD,0x31, /* int $0x31 */
/* we are now in the context of a 16-bit relay call */
/* need to fixup our stack;
* 16-bit relay return address will be lost, but we won't worry quite yet */
0x8E,0xD0, /* movw %ax,%ss */
0x66,0x0F,0xB7,0xE5, /* movzwl %bp,%esp */
/* set return CS */
0x89,0x56,0x08, /* movw %dx,8(%bp) */
0x5D, /* popw %bp */
0x5A, /* popw %dx */
0x58, /* popw %ax */
0xCB /* lret */
};
static void MZ_InitDPMI( LPDOSTASK lpDosTask )
{
unsigned size=sizeof(enter_pm);
LPBYTE start=DOSMEM_GetBlock(size,&(lpDosTask->dpmi_seg));
lpDosTask->dpmi_sel = SELECTOR_AllocBlock( start, size, SEGMENT_CODE, FALSE, FALSE );
memcpy(start,enter_pm,sizeof(enter_pm));
}
static WORD MZ_InitEnvironment( LPDOSTASK lpDosTask, LPCSTR env, LPCSTR name )
{ {
unsigned sz=0; unsigned sz=0;
WORD seg; WORD seg;
@ -191,39 +149,33 @@ static WORD MZ_InitEnvironment( LPDOSTASK lpDosTask, LPCSTR env, LPCSTR name )
return seg; return seg;
} }
static BOOL MZ_InitMemory( LPDOSTASK lpDosTask ) static BOOL MZ_InitMemory(void)
{ {
if (lpDosTask->img) return TRUE; /* already allocated */ int mm_fd;
void *img_base;
/* allocate 1MB+64K shared memory */ /* initialize the memory */
lpDosTask->img_ofs=START_OFFSET; TRACE("Initializing DOS memory structures\n");
#ifdef MZ_MAPSELF DOSMEM_Init(TRUE);
lpDosTask->img=VirtualAlloc(NULL,0x110000,MEM_COMMIT,PAGE_READWRITE);
/* make sure mmap accepts it */
((char*)lpDosTask->img)[0x10FFFF]=0;
#else
tmpnam(lpDosTask->mm_name);
/* strcpy(lpDosTask->mm_name,"/tmp/mydosimage"); */
lpDosTask->mm_fd=open(lpDosTask->mm_name,O_RDWR|O_CREAT /* |O_TRUNC */,S_IRUSR|S_IWUSR);
if (lpDosTask->mm_fd<0) ERR("file %s could not be opened\n",lpDosTask->mm_name);
/* expand file to 1MB+64K */
ftruncate(lpDosTask->mm_fd,0x110000);
/* map it in */
lpDosTask->img=mmap(NULL,0x110000-START_OFFSET,PROT_READ|PROT_WRITE,MAP_SHARED,lpDosTask->mm_fd,0);
#endif
if (lpDosTask->img==(LPVOID)-1) {
ERR("could not map shared memory, error=%s\n",strerror(errno));
return FALSE;
}
TRACE("DOS VM86 image mapped at %08lx\n",(DWORD)lpDosTask->img);
/* initialize the memory */ /* allocate 1MB+64K shared memory */
TRACE("Initializing DOS memory structures\n"); tmpnam(mm_name);
DOSMEM_Init(TRUE); /* strcpy(mm_name,"/tmp/mydosimage"); */
MZ_InitHandlers(lpDosTask); mm_fd = open(mm_name,O_RDWR|O_CREAT /* |O_TRUNC */,S_IRUSR|S_IWUSR);
MZ_InitXMS(lpDosTask); if (mm_fd < 0) ERR("file %s could not be opened\n",mm_name);
MZ_InitDPMI(lpDosTask); /* fill the file with the DOS memory */
return TRUE; if (write( mm_fd, NULL, 0x110000 ) != 0x110000) ERR("cannot write DOS mem\n");
/* map it in */
img_base = mmap(NULL,0x110000,PROT_READ|PROT_WRITE|PROT_EXEC,MAP_SHARED|MAP_FIXED,mm_fd,0);
close( mm_fd );
if (img_base)
{
ERR("could not map shared memory, error=%s\n",strerror(errno));
return FALSE;
}
MZ_InitHandlers();
return TRUE;
} }
BOOL MZ_LoadImage( HMODULE module, HANDLE hFile, LPCSTR filename ) BOOL MZ_LoadImage( HMODULE module, HANDLE hFile, LPCSTR filename )
@ -235,7 +187,7 @@ BOOL MZ_LoadImage( HMODULE module, HANDLE hFile, LPCSTR filename )
BYTE*psp_start,*load_start; BYTE*psp_start,*load_start;
int x, old_com=0, alloc=0; int x, old_com=0, alloc=0;
SEGPTR reloc; SEGPTR reloc;
WORD env_seg; WORD env_seg, load_seg;
DWORD len; DWORD len;
win_hdr->OptionalHeader.Subsystem = IMAGE_SUBSYSTEM_WINDOWS_CUI; win_hdr->OptionalHeader.Subsystem = IMAGE_SUBSYSTEM_WINDOWS_CUI;
@ -244,7 +196,6 @@ BOOL MZ_LoadImage( HMODULE module, HANDLE hFile, LPCSTR filename )
if (!lpDosTask) { if (!lpDosTask) {
alloc=1; alloc=1;
lpDosTask = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DOSTASK)); lpDosTask = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DOSTASK));
lpDosTask->mm_fd = -1;
dos_current = lpDosTask; dos_current = lpDosTask;
} }
@ -269,10 +220,10 @@ BOOL MZ_LoadImage( HMODULE module, HANDLE hFile, LPCSTR filename )
max_size=image_size+((DWORD)mz_header.e_maxalloc<<4)+(PSP_SIZE<<4); max_size=image_size+((DWORD)mz_header.e_maxalloc<<4)+(PSP_SIZE<<4);
} }
MZ_InitMemory(lpDosTask); MZ_InitMemory();
/* allocate environment block */ /* allocate environment block */
env_seg=MZ_InitEnvironment(lpDosTask,GetEnvironmentStringsA(),filename); env_seg=MZ_InitEnvironment(GetEnvironmentStringsA(),filename);
/* allocate memory for the executable */ /* allocate memory for the executable */
TRACE("Allocating DOS memory (min=%ld, max=%ld)\n",min_size,max_size); TRACE("Allocating DOS memory (min=%ld, max=%ld)\n",min_size,max_size);
@ -289,7 +240,7 @@ BOOL MZ_LoadImage( HMODULE module, HANDLE hFile, LPCSTR filename )
SetLastError(ERROR_NOT_ENOUGH_MEMORY); SetLastError(ERROR_NOT_ENOUGH_MEMORY);
goto load_error; goto load_error;
} }
lpDosTask->load_seg=lpDosTask->psp_seg+(old_com?0:PSP_SIZE); load_seg=lpDosTask->psp_seg+(old_com?0:PSP_SIZE);
load_start=psp_start+(PSP_SIZE<<4); load_start=psp_start+(PSP_SIZE<<4);
MZ_CreatePSP(psp_start, env_seg); MZ_CreatePSP(psp_start, env_seg);
@ -311,19 +262,19 @@ BOOL MZ_LoadImage( HMODULE module, HANDLE hFile, LPCSTR filename )
SetLastError(ERROR_BAD_FORMAT); SetLastError(ERROR_BAD_FORMAT);
goto load_error; goto load_error;
} }
*(WORD*)SEGPTR16(load_start,reloc)+=lpDosTask->load_seg; *(WORD*)SEGPTR16(load_start,reloc)+=load_seg;
} }
} }
lpDosTask->init_cs=lpDosTask->load_seg+mz_header.e_cs; init_cs = load_seg+mz_header.e_cs;
lpDosTask->init_ip=mz_header.e_ip; init_ip = mz_header.e_ip;
lpDosTask->init_ss=lpDosTask->load_seg+mz_header.e_ss; init_ss = load_seg+mz_header.e_ss;
lpDosTask->init_sp=mz_header.e_sp; init_sp = mz_header.e_sp;
TRACE("entry point: %04x:%04x\n",lpDosTask->init_cs,lpDosTask->init_ip); TRACE("entry point: %04x:%04x\n",init_cs,init_ip);
if (!MZ_InitTask(lpDosTask)) { if (!MZ_InitTask()) {
MZ_KillTask(lpDosTask); MZ_KillTask();
SetLastError(ERROR_GEN_FAILURE); SetLastError(ERROR_GEN_FAILURE);
return FALSE; return FALSE;
} }
@ -333,12 +284,7 @@ BOOL MZ_LoadImage( HMODULE module, HANDLE hFile, LPCSTR filename )
load_error: load_error:
if (alloc) { if (alloc) {
dos_current = NULL; dos_current = NULL;
if (lpDosTask->mm_name[0]!=0) { if (mm_name[0]!=0) unlink(mm_name);
if (lpDosTask->img!=NULL) munmap(lpDosTask->img,0x110000-START_OFFSET);
if (lpDosTask->mm_fd>=0) close(lpDosTask->mm_fd);
unlink(lpDosTask->mm_name);
} else
if (lpDosTask->img!=NULL) VirtualFree(lpDosTask->img,0x110000,MEM_RELEASE);
} }
return FALSE; return FALSE;
@ -349,14 +295,14 @@ LPDOSTASK MZ_AllocDPMITask( void )
LPDOSTASK lpDosTask = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DOSTASK)); LPDOSTASK lpDosTask = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DOSTASK));
if (lpDosTask) { if (lpDosTask) {
lpDosTask->mm_fd = -1;
dos_current = lpDosTask; dos_current = lpDosTask;
MZ_InitMemory(lpDosTask); MZ_InitMemory();
MZ_InitTask();
} }
return lpDosTask; return lpDosTask;
} }
static void MZ_InitTimer( LPDOSTASK lpDosTask, int ver ) static void MZ_InitTimer( int ver )
{ {
if (ver<1) { if (ver<1) {
/* can't make timer ticks */ /* can't make timer ticks */
@ -367,55 +313,42 @@ static void MZ_InitTimer( LPDOSTASK lpDosTask, int ver )
/* start dosmod timer at 55ms (18.2Hz) */ /* start dosmod timer at 55ms (18.2Hz) */
func=DOSMOD_SET_TIMER; func=DOSMOD_SET_TIMER;
tim.tv_sec=0; tim.tv_usec=54925; tim.tv_sec=0; tim.tv_usec=54925;
write(lpDosTask->write_pipe,&func,sizeof(func)); write(write_pipe,&func,sizeof(func));
write(lpDosTask->write_pipe,&tim,sizeof(tim)); write(write_pipe,&tim,sizeof(tim));
} }
} }
BOOL MZ_InitTask( LPDOSTASK lpDosTask ) static BOOL MZ_InitTask(void)
{ {
int write_fd[2],x_fd; int write_fd[2],x_fd;
pid_t child; pid_t child;
char *fname,*farg,arg[16],fproc[64],path[256],*fpath; char path[256],*fpath;
if (!lpDosTask) return FALSE;
/* create pipes */ /* create pipes */
if (!CreatePipe(&(lpDosTask->hReadPipe),&(lpDosTask->hXPipe),NULL,0)) return FALSE; if (!CreatePipe(&hReadPipe,&hWritePipe,NULL,0)) return FALSE;
if (pipe(write_fd)<0) { if (pipe(write_fd)<0) {
CloseHandle(lpDosTask->hReadPipe); CloseHandle(hReadPipe);
CloseHandle(lpDosTask->hXPipe); CloseHandle(hWritePipe);
return FALSE; return FALSE;
} }
lpDosTask->read_pipe = FILE_GetUnixHandle( lpDosTask->hReadPipe, GENERIC_READ ); read_pipe = FILE_GetUnixHandle( hReadPipe, GENERIC_READ );
x_fd = FILE_GetUnixHandle( lpDosTask->hXPipe, GENERIC_WRITE ); x_fd = FILE_GetUnixHandle( hWritePipe, GENERIC_WRITE );
TRACE("win32 pipe: read=%d, write=%d, unix pipe: read=%d, write=%d\n", TRACE("win32 pipe: read=%d, write=%d, unix pipe: read=%d, write=%d\n",
lpDosTask->hReadPipe,lpDosTask->hXPipe,lpDosTask->read_pipe,x_fd); hReadPipe,hWritePipe,read_pipe,x_fd);
TRACE("outbound unix pipe: read=%d, write=%d, pid=%d\n",write_fd[0],write_fd[1],getpid()); TRACE("outbound unix pipe: read=%d, write=%d, pid=%d\n",write_fd[0],write_fd[1],getpid());
lpDosTask->write_pipe=write_fd[1]; write_pipe=write_fd[1];
lpDosTask->hConInput=GetStdHandle(STD_INPUT_HANDLE);
lpDosTask->hConOutput=GetStdHandle(STD_OUTPUT_HANDLE);
/* if we have a mapping file, use it */
fname=lpDosTask->mm_name; farg=NULL;
if (!fname[0]) {
/* otherwise, map our own memory image */
sprintf(fproc,"/proc/%d/mem",getpid());
sprintf(arg,"%ld",(unsigned long)lpDosTask->img);
fname=fproc; farg=arg;
}
TRACE("Loading DOS VM support module\n"); TRACE("Loading DOS VM support module\n");
if ((child=fork())<0) { if ((child=fork())<0) {
close(write_fd[0]); close(write_fd[0]);
close(lpDosTask->read_pipe); close(read_pipe);
close(lpDosTask->write_pipe); close(write_pipe);
close(x_fd); close(x_fd);
CloseHandle(lpDosTask->hReadPipe); CloseHandle(hReadPipe);
CloseHandle(lpDosTask->hXPipe); CloseHandle(hWritePipe);
return FALSE; return FALSE;
} }
if (child!=0) { if (child!=0) {
@ -424,21 +357,21 @@ BOOL MZ_InitTask( LPDOSTASK lpDosTask )
close(write_fd[0]); close(write_fd[0]);
close(x_fd); close(x_fd);
lpDosTask->task=child; dosmod_pid = child;
/* wait for child process to signal readiness */ /* wait for child process to signal readiness */
while (1) { while (1) {
if (read(lpDosTask->read_pipe,&ret,sizeof(ret))==sizeof(ret)) break; if (read(read_pipe,&ret,sizeof(ret))==sizeof(ret)) break;
if ((errno==EINTR)||(errno==EAGAIN)) continue; if ((errno==EINTR)||(errno==EAGAIN)) continue;
/* failure */ /* failure */
ERR("dosmod has failed to initialize\n"); ERR("dosmod has failed to initialize\n");
if (lpDosTask->mm_name[0]!=0) unlink(lpDosTask->mm_name); if (mm_name[0]!=0) unlink(mm_name);
return FALSE; return FALSE;
} }
/* the child has now mmaped the temp file, it's now safe to unlink. /* the child has now mmaped the temp file, it's now safe to unlink.
* do it here to avoid leaving a mess in /tmp if/when Wine crashes... */ * do it here to avoid leaving a mess in /tmp if/when Wine crashes... */
if (lpDosTask->mm_name[0]!=0) unlink(lpDosTask->mm_name); if (mm_name[0]!=0) unlink(mm_name);
/* start simulated system timer */ /* start simulated system timer */
MZ_InitTimer(lpDosTask,ret); MZ_InitTimer(ret);
if (ret<2) { if (ret<2) {
ERR("dosmod version too old! Please install newer dosmod properly\n"); ERR("dosmod version too old! Please install newer dosmod properly\n");
ERR("If you don't, the new dosmod event handling system will not work\n"); ERR("If you don't, the new dosmod event handling system will not work\n");
@ -446,8 +379,8 @@ BOOL MZ_InitTask( LPDOSTASK lpDosTask )
/* all systems are now go */ /* all systems are now go */
} else { } else {
/* child process */ /* child process */
close(lpDosTask->read_pipe); close(read_pipe);
close(lpDosTask->write_pipe); close(write_pipe);
/* put our pipes somewhere dosmod can find them */ /* put our pipes somewhere dosmod can find them */
dup2(write_fd[0],0); /* stdin */ dup2(write_fd[0],0); /* stdin */
dup2(x_fd,1); /* stdout */ dup2(x_fd,1); /* stdout */
@ -457,16 +390,16 @@ BOOL MZ_InitTask( LPDOSTASK lpDosTask )
fpath=strrchr(strcpy(path,full_argv0),'/'); fpath=strrchr(strcpy(path,full_argv0),'/');
if (fpath) { if (fpath) {
strcpy(fpath,"/dosmod"); strcpy(fpath,"/dosmod");
execl(path,fname,farg,NULL); execl(path,mm_name,NULL);
strcpy(fpath,"/loader/dos/dosmod"); strcpy(fpath,"/loader/dos/dosmod");
execl(path,fname,farg,NULL); execl(path,mm_name,NULL);
} }
/* okay, it wasn't there, try in the path */ /* okay, it wasn't there, try in the path */
execlp("dosmod",fname,farg,NULL); execlp("dosmod",mm_name,NULL);
/* last desperate attempts: current directory */ /* last desperate attempts: current directory */
execl("dosmod",fname,farg,NULL); execl("dosmod",mm_name,NULL);
/* and, just for completeness... */ /* and, just for completeness... */
execl("loader/dos/dosmod",fname,farg,NULL); execl("loader/dos/dosmod",mm_name,NULL);
/* if failure, exit */ /* if failure, exit */
ERR("Failed to spawn dosmod, error=%s\n",strerror(errno)); ERR("Failed to spawn dosmod, error=%s\n",strerror(errno));
exit(1); exit(1);
@ -477,53 +410,29 @@ BOOL MZ_InitTask( LPDOSTASK lpDosTask )
static void MZ_Launch(void) static void MZ_Launch(void)
{ {
LPDOSTASK lpDosTask = MZ_Current(); LPDOSTASK lpDosTask = MZ_Current();
BYTE *psp_start = (BYTE*)lpDosTask->img + ((DWORD)lpDosTask->psp_seg << 4); CONTEXT context;
TDB *pTask = (TDB *)GlobalLock16( GetCurrentTask() );
BYTE *psp_start = PTR_REAL_TO_LIN( lpDosTask->psp_seg, 0 );
MZ_FillPSP(psp_start, GetCommandLineA()); MZ_FillPSP(psp_start, GetCommandLineA());
pTask->flags |= TDBF_WINOLDAP;
DOSVM_Enter(NULL); memset( &context, 0, sizeof(context) );
context.SegCs = init_cs;
context.Eip = init_ip;
context.SegSs = init_ss;
context.Esp = init_sp;
context.SegDs = lpDosTask->psp_seg;
context.SegEs = lpDosTask->psp_seg;
context.EFlags = 0x00080000; /* virtual interrupt flag */
DOSVM_Enter( &context );
} }
void MZ_KillTask( LPDOSTASK lpDosTask ) static void MZ_KillTask(void)
{ {
DOSEVENT *event,*p_event;
DOSSYSTEM *sys,*p_sys;
TRACE("killing DOS task\n"); TRACE("killing DOS task\n");
VGA_Clean(); VGA_Clean();
if (lpDosTask->mm_name[0]!=0) { kill(dosmod_pid,SIGTERM);
munmap(lpDosTask->img,0x110000-START_OFFSET);
close(lpDosTask->mm_fd);
} else VirtualFree(lpDosTask->img,0x110000,MEM_RELEASE);
close(lpDosTask->read_pipe);
close(lpDosTask->write_pipe);
CloseHandle(lpDosTask->hReadPipe);
CloseHandle(lpDosTask->hXPipe);
kill(lpDosTask->task,SIGTERM);
/* free memory allocated for events and systems */
#define DFREE(var,pvar,svar) \
var = lpDosTask->svar; \
while (var) { \
if (var->data) free(var->data); \
pvar = var->next; free(var); var = pvar; \
}
DFREE(event,p_event,pending)
DFREE(event,p_event,current)
DFREE(sys,p_sys,sys)
#undef DFREE
#if 0
/* FIXME: this seems to crash */
if (lpDosTask->dpmi_sel)
SELECTOR_FreeBlock(lpDosTask->dpmi_sel, 1);
#endif
}
LPDOSTASK MZ_Current( void )
{
return dos_current;
} }
#else /* !MZ_SUPPORTED */ #else /* !MZ_SUPPORTED */
@ -535,9 +444,15 @@ BOOL MZ_LoadImage( HMODULE module, HANDLE hFile, LPCSTR filename )
return FALSE; return FALSE;
} }
LPDOSTASK MZ_Current( void ) LPDOSTASK MZ_AllocDPMITask( void )
{ {
return NULL; ERR("Actual real-mode calls not supported on this architecture!\n");
return NULL;
} }
#endif #endif /* !MZ_SUPPORTED */
LPDOSTASK MZ_Current( void )
{
return dos_current;
}

9
loader/task.c
View file

@ -29,13 +29,13 @@
#include "winsock.h" #include "winsock.h"
#include "syslevel.h" #include "syslevel.h"
#include "debugtools.h" #include "debugtools.h"
#include "dosexe.h"
#include "services.h" #include "services.h"
#include "server.h" #include "server.h"
DEFAULT_DEBUG_CHANNEL(task)
DECLARE_DEBUG_CHANNEL(relay) DEFAULT_DEBUG_CHANNEL(task);
DECLARE_DEBUG_CHANNEL(toolhelp) DECLARE_DEBUG_CHANNEL(relay);
DECLARE_DEBUG_CHANNEL(toolhelp);
/* Min. number of thunks allocated when creating a new segment */ /* Min. number of thunks allocated when creating a new segment */
#define MIN_THUNKS 32 #define MIN_THUNKS 32
@ -243,7 +243,6 @@ BOOL TASK_Create( NE_MODULE *pModule, UINT16 cmdShow, TEB *teb, LPCSTR cmdline,
/* NOTE: for 16-bit tasks, the instance handles are updated later on /* NOTE: for 16-bit tasks, the instance handles are updated later on
in NE_InitProcess */ in NE_InitProcess */
} }
if (MZ_Current() && MZ_Current()->load_seg) pTask->flags |= TDBF_WINOLDAP;
pTask->version = pModule->expected_version; pTask->version = pModule->expected_version;
pTask->hModule = pModule->self; pTask->hModule = pModule->self;

4
memory/instr.c
View file

@ -29,7 +29,7 @@ inline static void add_stack( CONTEXT86 *context, int offset )
inline static void *make_ptr( CONTEXT86 *context, DWORD seg, DWORD off, int long_addr ) inline static void *make_ptr( CONTEXT86 *context, DWORD seg, DWORD off, int long_addr )
{ {
if (ISV86(context)) return DOSMEM_MemoryBase() + (seg << 4) + LOWORD(off); if (ISV86(context)) return PTR_REAL_TO_LIN( seg, off );
if (IS_SELECTOR_SYSTEM(seg)) return (void *)off; if (IS_SELECTOR_SYSTEM(seg)) return (void *)off;
if (!long_addr) off = LOWORD(off); if (!long_addr) off = LOWORD(off);
return PTR_SEG_OFF_TO_LIN( seg, off ); return PTR_SEG_OFF_TO_LIN( seg, off );
@ -38,7 +38,7 @@ inline static void *make_ptr( CONTEXT86 *context, DWORD seg, DWORD off, int long
inline static void *get_stack( CONTEXT86 *context ) inline static void *get_stack( CONTEXT86 *context )
{ {
if (ISV86(context)) if (ISV86(context))
return DOSMEM_MemoryBase() + (context->SegSs << 4) + LOWORD(context->Esp); return PTR_REAL_TO_LIN( context->SegSs, context->Esp );
if (IS_SELECTOR_SYSTEM(context->SegSs)) if (IS_SELECTOR_SYSTEM(context->SegSs))
return (void *)context->Esp; return (void *)context->Esp;
if (IS_SELECTOR_32BIT(context->SegSs)) if (IS_SELECTOR_32BIT(context->SegSs))

19
msdos/devices.c
View file

@ -47,8 +47,9 @@ typedef struct {
#define CON_BUFFER 128 #define CON_BUFFER 128
#define SYSTEM_STRATEGY_NUL 0x0100 enum strategy { SYSTEM_STRATEGY_NUL, SYSTEM_STRATEGY_CON, NB_SYSTEM_STRATEGIES };
#define SYSTEM_STRATEGY_CON 0x0101
static void *strategy_data[NB_SYSTEM_STRATEGIES];
#define NONEXT ((DWORD)-1) #define NONEXT ((DWORD)-1)
@ -150,20 +151,19 @@ static void do_lret(CONTEXT86*ctx)
static void do_strategy(CONTEXT86*ctx, int id, int extra) static void do_strategy(CONTEXT86*ctx, int id, int extra)
{ {
REQUEST_HEADER *hdr = CTX_SEG_OFF_TO_LIN(ctx, ES_reg(ctx), EBX_reg(ctx)); REQUEST_HEADER *hdr = CTX_SEG_OFF_TO_LIN(ctx, ES_reg(ctx), EBX_reg(ctx));
void **hdr_ptr = DOSVM_GetSystemData(id); void **hdr_ptr = strategy_data[id];
if (!hdr_ptr) { if (!hdr_ptr) {
hdr_ptr = calloc(1,sizeof(void *)+extra); hdr_ptr = calloc(1,sizeof(void *)+extra);
DOSVM_SetSystemData(id, hdr_ptr); strategy_data[id] = hdr_ptr;
} }
*hdr_ptr = hdr; *hdr_ptr = hdr;
do_lret(ctx); do_lret(ctx);
} }
static REQUEST_HEADER * get_hdr(int id, void**extra) static REQUEST_HEADER * get_hdr(int id, void**extra)
{ {
void **hdr_ptr = DOSVM_GetSystemData(id); void **hdr_ptr = strategy_data[id];
if (extra) if (extra)
*extra = hdr_ptr ? (void*)(hdr_ptr+1) : (void *)NULL; *extra = hdr_ptr ? (void*)(hdr_ptr+1) : (void *)NULL;
return hdr_ptr ? *hdr_ptr : (void *)NULL; return hdr_ptr ? *hdr_ptr : (void *)NULL;
@ -209,7 +209,6 @@ static void WINAPI con_interrupt(CONTEXT86*ctx)
BYTE *curbuffer = (lol->offs_unread_CON) ? BYTE *curbuffer = (lol->offs_unread_CON) ?
(((BYTE*)dataseg) + lol->offs_unread_CON) : (BYTE*)NULL; (((BYTE*)dataseg) + lol->offs_unread_CON) : (BYTE*)NULL;
DOS_DEVICE_HEADER *con = dataseg->dev; DOS_DEVICE_HEADER *con = dataseg->dev;
LPDOSTASK lpDosTask = MZ_Current();
switch (hdr->command) { switch (hdr->command) {
case CMD_INPUT: case CMD_INPUT:
@ -301,7 +300,7 @@ static void WINAPI con_interrupt(CONTEXT86*ctx)
/* a character */ /* a character */
if ((len+1)<CON_BUFFER) { if ((len+1)<CON_BUFFER) {
linebuffer[len] = LOBYTE(data); linebuffer[len] = LOBYTE(data);
WriteFile(lpDosTask->hConOutput, &linebuffer[len++], 1, NULL, NULL); WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), &linebuffer[len++], 1, NULL, NULL);
} }
/* else beep, but I don't like noise */ /* else beep, but I don't like noise */
} }
@ -309,7 +308,7 @@ static void WINAPI con_interrupt(CONTEXT86*ctx)
case '\b': case '\b':
if (len>0) { if (len>0) {
len--; len--;
WriteFile(lpDosTask->hConOutput, "\b \b", 3, NULL, NULL); WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), "\b \b", 3, NULL, NULL);
} }
break; break;
} }
@ -377,7 +376,7 @@ static void WINAPI con_interrupt(CONTEXT86*ctx)
SELECTOROF(io->buffer), SELECTOROF(io->buffer),
(DWORD)OFFSETOF(io->buffer)); (DWORD)OFFSETOF(io->buffer));
DWORD result = 0; DWORD result = 0;
WriteFile(lpDosTask->hConOutput, buffer, io->count, &result, NULL); WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buffer, io->count, &result, NULL);
io->count = result; io->count = result;
hdr->status = STAT_DONE; hdr->status = STAT_DONE;
} }

225
msdos/dosmem.c
View file

@ -5,30 +5,33 @@
* Copyright 1996 Marcus Meissner * Copyright 1996 Marcus Meissner
*/ */
#include "config.h"
#include <signal.h> #include <signal.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#ifdef HAVE_SYS_MMAN_H
# include <sys/mman.h>
#endif
#include "winbase.h" #include "winbase.h"
#include "wine/winbase16.h" #include "wine/winbase16.h"
#include "global.h" #include "global.h"
#include "ldt.h" #include "ldt.h"
#include "selectors.h"
#include "miscemu.h" #include "miscemu.h"
#include "vga.h" #include "vga.h"
#include "dosexe.h" #include "dosexe.h"
#include "debugtools.h" #include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(dosmem) DEFAULT_DEBUG_CHANNEL(dosmem);
DECLARE_DEBUG_CHANNEL(selector) DECLARE_DEBUG_CHANNEL(selector);
HANDLE16 DOSMEM_BiosDataSeg; /* BIOS data segment at 0x40:0 */ HANDLE16 DOSMEM_BiosDataSeg; /* BIOS data segment at 0x40:0 */
HANDLE16 DOSMEM_BiosSysSeg; /* BIOS ROM segment at 0xf000:0 */ HANDLE16 DOSMEM_BiosSysSeg; /* BIOS ROM segment at 0xf000:0 */
static char *DOSMEM_dosmem; DWORD DOSMEM_CollateTable;
DWORD DOSMEM_CollateTable;
DWORD DOSMEM_ErrorCall;
DWORD DOSMEM_ErrorBuffer;
/* use 2 low bits of 'size' for the housekeeping */ /* use 2 low bits of 'size' for the housekeeping */
@ -57,6 +60,17 @@ typedef struct {
#define VM_STUB(x) (0x90CF00CD|(x<<8)) /* INT x; IRET; NOP */ #define VM_STUB(x) (0x90CF00CD|(x<<8)) /* INT x; IRET; NOP */
#define VM_STUB_SEGMENT 0xf000 /* BIOS segment */ #define VM_STUB_SEGMENT 0xf000 /* BIOS segment */
/* DOS memory base */
static char *DOSMEM_dosmem;
/* bios area; normally at offset 0x400, but can be moved to trap NULL pointers */
static void *DOSMEM_biosdata;
/* various real-mode code stubs */
WORD DOSMEM_wrap_seg;
WORD DOSMEM_xms_seg;
WORD DOSMEM_dpmi_seg;
WORD DOSMEM_dpmi_sel;
/*********************************************************************** /***********************************************************************
* DOSMEM_MemoryBase * DOSMEM_MemoryBase
* *
@ -64,12 +78,7 @@ typedef struct {
*/ */
char *DOSMEM_MemoryBase(void) char *DOSMEM_MemoryBase(void)
{ {
LPDOSTASK lpDosTask = MZ_Current(); return DOSMEM_dosmem;
if (lpDosTask && lpDosTask->img)
return lpDosTask->img;
else
return DOSMEM_dosmem;
} }
/*********************************************************************** /***********************************************************************
@ -79,7 +88,7 @@ char *DOSMEM_MemoryBase(void)
*/ */
static char *DOSMEM_MemoryTop(void) static char *DOSMEM_MemoryTop(void)
{ {
return DOSMEM_MemoryBase()+0x9FFFC; /* 640K */ return DOSMEM_dosmem+0x9FFFC; /* 640K */
} }
/*********************************************************************** /***********************************************************************
@ -89,7 +98,7 @@ static char *DOSMEM_MemoryTop(void)
*/ */
static dosmem_info *DOSMEM_InfoBlock(void) static dosmem_info *DOSMEM_InfoBlock(void)
{ {
return (dosmem_info*)(DOSMEM_MemoryBase()+0x10000); /* 64K */ return (dosmem_info*)(DOSMEM_dosmem+0x10000); /* 64K */
} }
/*********************************************************************** /***********************************************************************
@ -118,7 +127,7 @@ static dosmem_entry *DOSMEM_RootBlock(void)
*/ */
static void DOSMEM_FillIsrTable(void) static void DOSMEM_FillIsrTable(void)
{ {
SEGPTR *isr = (SEGPTR*)DOSMEM_MemoryBase(); SEGPTR *isr = (SEGPTR*)DOSMEM_dosmem;
DWORD *stub = (DWORD*)((char*)isr + (VM_STUB_SEGMENT << 4)); DWORD *stub = (DWORD*)((char*)isr + (VM_STUB_SEGMENT << 4));
int x; int x;
@ -133,24 +142,66 @@ static void DOSMEM_FillIsrTable(void)
*/ */
static void DOSMEM_InitDPMI(void) static void DOSMEM_InitDPMI(void)
{ {
extern UINT16 DPMI_wrap_seg; LPSTR ptr;
static char wrap_code[]={
static const char wrap_code[]={
0xCD,0x31, /* int $0x31 */ 0xCD,0x31, /* int $0x31 */
0xCB /* lret */ 0xCB /* lret */
}; };
LPSTR wrapper = (LPSTR)DOSMEM_GetBlock(sizeof(wrap_code), &DPMI_wrap_seg);
memcpy(wrapper, wrap_code, sizeof(wrap_code)); static const char enter_xms[]=
{
/* XMS hookable entry point */
0xEB,0x03, /* jmp entry */
0x90,0x90,0x90, /* nop;nop;nop */
/* entry: */
/* real entry point */
/* for simplicity, we'll just use the same hook as DPMI below */
0xCD,0x31, /* int $0x31 */
0xCB /* lret */
};
static const char enter_pm[]=
{
0x50, /* pushw %ax */
0x52, /* pushw %dx */
0x55, /* pushw %bp */
0x89,0xE5, /* movw %sp,%bp */
/* get return CS */
0x8B,0x56,0x08, /* movw 8(%bp),%dx */
/* just call int 31 here to get into protected mode... */
/* it'll check whether it was called from dpmi_seg... */
0xCD,0x31, /* int $0x31 */
/* we are now in the context of a 16-bit relay call */
/* need to fixup our stack;
* 16-bit relay return address will be lost, but we won't worry quite yet */
0x8E,0xD0, /* movw %ax,%ss */
0x66,0x0F,0xB7,0xE5, /* movzwl %bp,%esp */
/* set return CS */
0x89,0x56,0x08, /* movw %dx,8(%bp) */
0x5D, /* popw %bp */
0x5A, /* popw %dx */
0x58, /* popw %ax */
0xCB /* lret */
};
ptr = DOSMEM_GetBlock( sizeof(wrap_code), &DOSMEM_wrap_seg );
memcpy( ptr, wrap_code, sizeof(wrap_code) );
ptr = DOSMEM_GetBlock( sizeof(enter_xms), &DOSMEM_xms_seg );
memcpy( ptr, enter_xms, sizeof(enter_xms) );
ptr = DOSMEM_GetBlock( sizeof(enter_pm), &DOSMEM_dpmi_seg );
memcpy( ptr, enter_pm, sizeof(enter_pm) );
DOSMEM_dpmi_sel = SELECTOR_AllocBlock( ptr, sizeof(enter_pm), SEGMENT_CODE, FALSE, FALSE );
} }
BIOSDATA * DOSMEM_BiosData() BIOSDATA * DOSMEM_BiosData()
{ {
return (BIOSDATA *)(DOSMEM_MemoryBase()+0x400); return (BIOSDATA *)DOSMEM_biosdata;
} }
BYTE * DOSMEM_BiosSys() BYTE * DOSMEM_BiosSys()
{ {
return DOSMEM_MemoryBase()+0xf0000; return DOSMEM_dosmem+0xf0000;
} }
struct _DOS_LISTOFLISTS * DOSMEM_LOL() struct _DOS_LISTOFLISTS * DOSMEM_LOL()
@ -293,6 +344,7 @@ static void DOSMEM_InitCollateTable()
*/ */
static void DOSMEM_InitErrorTable() static void DOSMEM_InitErrorTable()
{ {
#if 0 /* no longer used */
DWORD x; DWORD x;
char *call; char *call;
@ -336,7 +388,7 @@ static void DOSMEM_InitErrorTable()
call = DOSMEM_MapRealToLinear(DOSMEM_ErrorCall); call = DOSMEM_MapRealToLinear(DOSMEM_ErrorCall);
memset(call, 0, SIZE_TO_ALLOCATE); memset(call, 0, SIZE_TO_ALLOCATE);
#endif
/* Fixme - Copy assembly into buffer here */ /* Fixme - Copy assembly into buffer here */
} }
@ -368,28 +420,56 @@ static void DOSMEM_InitMemory(void)
; ;
} }
/*********************************************************************** /**********************************************************************
* DOSMEM_MovePointers * setup_dos_mem
* *
* Relocates any pointers into DOS memory to a new address space. * Setup the first megabyte for DOS memory access
*/ */
static void DOSMEM_MovePointers(LPVOID dest, LPVOID src, DWORD size) static void setup_dos_mem( int dos_init )
{ {
unsigned long delta = (char *) dest - (char *) src; int bios_offset = 0x400;
unsigned cnt; int page_size = VIRTUAL_GetPageSize();
ldt_entry ent; void *addr = VIRTUAL_mmap( -1, (void *)page_size, 0x110000-page_size, 0,
PROT_READ | PROT_WRITE | PROT_EXEC, 0 );
if (addr == (void *)page_size) /* we got what we wanted */
{
/* now map from address 0 */
addr = VIRTUAL_mmap( -1, NULL, 0x110000, 0,
PROT_READ | PROT_WRITE | PROT_EXEC, MAP_FIXED );
if (addr)
{
ERR("MAP_FIXED failed at address 0 for DOS address space\n" );
ExitProcess(1);
}
/* relocate base addresses of any selectors pointing into memory */ /* inform the memory manager that there is a mapping here */
for (cnt=FIRST_LDT_ENTRY_TO_ALLOC; cnt<LDT_SIZE; cnt++) { VirtualAlloc( addr, 0x110000, MEM_RESERVE | MEM_SYSTEM, PAGE_EXECUTE_READWRITE );
LDT_GetEntry(cnt, &ent);
if ((ent.base >= (unsigned long)src) && \ /* protect the first 64K to catch NULL pointers */
(ent.base < ((unsigned long)src + size))) { if (!dos_init)
ent.base += delta; {
LDT_SetEntry(cnt, &ent); VirtualProtect( addr, 0x10000, PAGE_NOACCESS, NULL );
/* move the BIOS data from 0x400 to 0xf0400 */
bios_offset += 0xf0000;
}
} }
} else
{
ERR("Cannot use first megabyte for DOS address space, please report\n" );
if (dos_init) ExitProcess(1);
/* allocate the DOS area somewhere else */
addr = VirtualAlloc( NULL, 0x110000, MEM_COMMIT, PAGE_EXECUTE_READWRITE );
if (!addr)
{
ERR( "Cannot allocate DOS memory\n" );
ExitProcess(1);
}
}
DOSMEM_dosmem = addr;
DOSMEM_biosdata = (char *)addr + bios_offset;
} }
/*********************************************************************** /***********************************************************************
* DOSMEM_Init * DOSMEM_Init
* *
@ -398,44 +478,41 @@ static void DOSMEM_MovePointers(LPVOID dest, LPVOID src, DWORD size)
*/ */
BOOL DOSMEM_Init(BOOL dos_init) BOOL DOSMEM_Init(BOOL dos_init)
{ {
LPVOID base = DOSMEM_MemoryBase(); static int already_done;
BOOL do_init = dos_init && !DOSMEM_dosmem;
if (!base) if (!already_done)
{ {
/* Allocate 1 MB dosmemory setup_dos_mem( dos_init );
*/
DOSMEM_dosmem = VirtualAlloc( NULL, 0x100000, MEM_COMMIT,
PAGE_EXECUTE_READWRITE );
if (!DOSMEM_dosmem)
{
WARN("Could not allocate DOS memory.\n" );
return FALSE;
}
DOSMEM_BiosDataSeg = GLOBAL_CreateBlock(GMEM_FIXED,DOSMEM_dosmem+0x400,
0x100, 0, FALSE, FALSE, FALSE );
DOSMEM_BiosSysSeg = GLOBAL_CreateBlock(GMEM_FIXED,DOSMEM_dosmem+0xf0000,
0x10000, 0, FALSE, FALSE, FALSE );
base = DOSMEM_dosmem;
do_init = TRUE;
}
if (do_init) { DOSMEM_BiosDataSeg = GLOBAL_CreateBlock(GMEM_FIXED,DOSMEM_biosdata,
DOSMEM_FillIsrTable(); 0x100, 0, FALSE, FALSE, FALSE );
DOSMEM_BiosSysSeg = GLOBAL_CreateBlock(GMEM_FIXED,DOSMEM_dosmem+0xf0000,
0x10000, 0, FALSE, FALSE, FALSE );
DOSMEM_FillBiosSegments(); DOSMEM_FillBiosSegments();
DOSMEM_InitMemory(); DOSMEM_InitMemory();
DOSMEM_InitCollateTable(); DOSMEM_InitCollateTable();
DOSMEM_InitErrorTable(); DOSMEM_InitErrorTable();
DOSMEM_InitDPMI(); DOSMEM_InitDPMI();
DOSDEV_InstallDOSDevices(); DOSDEV_InstallDOSDevices();
already_done = 1;
} }
else if (dos_init) else if (dos_init)
{ {
/* bootstrap the new V86 task with a copy of the "system" memory */ if (DOSMEM_dosmem)
memcpy(base, DOSMEM_dosmem, 0x100000); {
/* then move existing selectors to it */ ERR( "Needs access to the first megabyte for DOS mode\n" );
DOSMEM_MovePointers(base, DOSMEM_dosmem, 0x100000); ExitProcess(1);
}
MESSAGE( "Warning: unprotecting the first 64KB of memory to allow real-mode calls.\n"
" NULL pointer accesses will no longer be caught.\n" );
VirtualProtect( NULL, 0x10000, PAGE_EXECUTE_READWRITE, NULL );
/* copy the BIOS area down to 0x400 */
memcpy( DOSMEM_dosmem + 0x400, DOSMEM_biosdata, 0x100 );
DOSMEM_biosdata = DOSMEM_dosmem + 0x400;
SetSelectorBase( DOSMEM_BiosDataSeg, 0x400 );
} }
/* interrupt table is at addr 0, so only do this when setting up DOS mode */
if (dos_init) DOSMEM_FillIsrTable();
return TRUE; return TRUE;
} }
@ -513,7 +590,7 @@ LPVOID DOSMEM_GetBlock(UINT size, UINT16* pseg)
info_block->blocks++; info_block->blocks++;
info_block->free -= dm->size; info_block->free -= dm->size;
if( pseg ) *pseg = (block - DOSMEM_MemoryBase()) >> 4; if( pseg ) *pseg = (block - DOSMEM_dosmem) >> 4;
#ifdef __DOSMEM_DEBUG__ #ifdef __DOSMEM_DEBUG__
dm->size |= DM_BLOCK_DEBUG; dm->size |= DM_BLOCK_DEBUG;
#endif #endif
@ -535,7 +612,7 @@ BOOL DOSMEM_FreeBlock(void* ptr)
if( ptr >= (void*)(((char*)DOSMEM_RootBlock()) + sizeof(dosmem_entry)) && if( ptr >= (void*)(((char*)DOSMEM_RootBlock()) + sizeof(dosmem_entry)) &&
ptr < (void*)DOSMEM_MemoryTop() && !((((char*)ptr) ptr < (void*)DOSMEM_MemoryTop() && !((((char*)ptr)
- DOSMEM_MemoryBase()) & 0xf) ) - DOSMEM_dosmem) & 0xf) )
{ {
dosmem_entry *dm = (dosmem_entry*)(((char*)ptr) - sizeof(dosmem_entry)); dosmem_entry *dm = (dosmem_entry*)(((char*)ptr) - sizeof(dosmem_entry));
@ -565,11 +642,11 @@ LPVOID DOSMEM_ResizeBlock(void* ptr, UINT size, UINT16* pseg)
if( ptr >= (void*)(((char*)DOSMEM_RootBlock()) + sizeof(dosmem_entry)) && if( ptr >= (void*)(((char*)DOSMEM_RootBlock()) + sizeof(dosmem_entry)) &&
ptr < (void*)DOSMEM_MemoryTop() && !((((char*)ptr) ptr < (void*)DOSMEM_MemoryTop() && !((((char*)ptr)
- DOSMEM_MemoryBase()) & 0xf) ) - DOSMEM_dosmem) & 0xf) )
{ {
dosmem_entry *dm = (dosmem_entry*)(((char*)ptr) - sizeof(dosmem_entry)); dosmem_entry *dm = (dosmem_entry*)(((char*)ptr) - sizeof(dosmem_entry));
if( pseg ) *pseg = ((char*)ptr - DOSMEM_MemoryBase()) >> 4; if( pseg ) *pseg = ((char*)ptr - DOSMEM_dosmem) >> 4;
if( !(dm->size & (DM_BLOCK_FREE | DM_BLOCK_TERMINAL)) if( !(dm->size & (DM_BLOCK_FREE | DM_BLOCK_TERMINAL))
) )
@ -689,9 +766,9 @@ UINT DOSMEM_Available(void)
*/ */
UINT DOSMEM_MapLinearToDos(LPVOID ptr) UINT DOSMEM_MapLinearToDos(LPVOID ptr)
{ {
if (((char*)ptr >= DOSMEM_MemoryBase()) && if (((char*)ptr >= DOSMEM_dosmem) &&
((char*)ptr < DOSMEM_MemoryBase() + 0x100000)) ((char*)ptr < DOSMEM_dosmem + 0x100000))
return (UINT)ptr - (UINT)DOSMEM_MemoryBase(); return (UINT)ptr - (UINT)DOSMEM_dosmem;
return (UINT)ptr; return (UINT)ptr;
} }
@ -703,7 +780,7 @@ UINT DOSMEM_MapLinearToDos(LPVOID ptr)
*/ */
LPVOID DOSMEM_MapDosToLinear(UINT ptr) LPVOID DOSMEM_MapDosToLinear(UINT ptr)
{ {
if (ptr < 0x100000) return (LPVOID)(ptr + (UINT)DOSMEM_MemoryBase()); if (ptr < 0x100000) return (LPVOID)(ptr + (UINT)DOSMEM_dosmem);
return (LPVOID)ptr; return (LPVOID)ptr;
} }
@ -717,7 +794,7 @@ LPVOID DOSMEM_MapRealToLinear(DWORD x)
{ {
LPVOID lin; LPVOID lin;
lin=DOSMEM_MemoryBase()+(x&0xffff)+(((x&0xffff0000)>>16)*16); lin=DOSMEM_dosmem+(x&0xffff)+(((x&0xffff0000)>>16)*16);
TRACE_(selector)("(0x%08lx) returns 0x%p.\n", x, lin ); TRACE_(selector)("(0x%08lx) returns 0x%p.\n", x, lin );
return lin; return lin;
} }

135
msdos/dpmi.c
View file

@ -62,7 +62,6 @@ typedef struct tagRMCB {
static RMCB *FirstRMCB = NULL; static RMCB *FirstRMCB = NULL;
UINT16 DPMI_wrap_seg;
/********************************************************************** /**********************************************************************
* DPMI_xalloc * DPMI_xalloc
@ -261,7 +260,7 @@ static void DPMI_CallRMCBProc( CONTEXT86 *context, RMCB *rmcb, WORD flag )
DWORD esp,edi; DWORD esp,edi;
INT_SetRealModeContext((REALMODECALL *)PTR_SEG_OFF_TO_LIN( rmcb->regs_sel, rmcb->regs_ofs ), context); INT_SetRealModeContext((REALMODECALL *)PTR_SEG_OFF_TO_LIN( rmcb->regs_sel, rmcb->regs_ofs ), context);
ss = SELECTOR_AllocBlock( DOSMEM_MemoryBase() + (DWORD)(SS_reg(context)<<4), 0x10000, SEGMENT_DATA, FALSE, FALSE ); ss = SELECTOR_AllocBlock( (void *)(SS_reg(context)<<4), 0x10000, SEGMENT_DATA, FALSE, FALSE );
esp = ESP_reg(context); esp = ESP_reg(context);
FIXME("untested!\n"); FIXME("untested!\n");
@ -354,17 +353,12 @@ callrmproc_again:
CurrRMCB = CurrRMCB->next; CurrRMCB = CurrRMCB->next;
if (!(CurrRMCB || lpDosTask)) { if (!(CurrRMCB || lpDosTask)) {
#ifdef MZ_SUPPORTED
FIXME("DPMI real-mode call using DOS VM task system, not fully tested!\n"); FIXME("DPMI real-mode call using DOS VM task system, not fully tested!\n");
TRACE("creating VM86 task\n"); TRACE("creating VM86 task\n");
if (!MZ_InitTask( lpDosTask = MZ_AllocDPMITask() )) { if (!(lpDosTask = MZ_AllocDPMITask() )) {
ERR("could not setup VM86 task\n"); ERR("could not setup VM86 task\n");
return 1; return 1;
} }
#else
ERR("Actual real-mode calls not supported on this architecture!\n");
return 1;
#endif
} }
if (!already) { if (!already) {
if (!SS_reg(context)) { if (!SS_reg(context)) {
@ -388,7 +382,7 @@ callrmproc_again:
*stack16 = LOWORD(EFL_reg(context)); *stack16 = LOWORD(EFL_reg(context));
} }
/* push return address (return to interrupt wrapper) */ /* push return address (return to interrupt wrapper) */
*(--stack16) = DPMI_wrap_seg; *(--stack16) = DOSMEM_wrap_seg;
*(--stack16) = 0; *(--stack16) = 0;
/* adjust stack */ /* adjust stack */
ESP_reg(context) -= 2*sizeof(WORD); ESP_reg(context) -= 2*sizeof(WORD);
@ -399,21 +393,16 @@ callrmproc_again:
/* RMCB call, invoke protected-mode handler directly */ /* RMCB call, invoke protected-mode handler directly */
DPMI_CallRMCBProc(context, CurrRMCB, lpDosTask ? lpDosTask->dpmi_flag : 0); DPMI_CallRMCBProc(context, CurrRMCB, lpDosTask ? lpDosTask->dpmi_flag : 0);
/* check if we returned to where we thought we would */ /* check if we returned to where we thought we would */
if ((CS_reg(context) != DPMI_wrap_seg) || if ((CS_reg(context) != DOSMEM_wrap_seg) ||
(LOWORD(EIP_reg(context)) != 0)) { (LOWORD(EIP_reg(context)) != 0)) {
/* we need to continue at different address in real-mode space, /* we need to continue at different address in real-mode space,
so we need to set it all up for real mode again */ so we need to set it all up for real mode again */
goto callrmproc_again; goto callrmproc_again;
} }
} else { } else {
#ifdef MZ_SUPPORTED
TRACE("entering real mode...\n"); TRACE("entering real mode...\n");
DOSVM_Enter( context ); DOSVM_Enter( context );
TRACE("returned from real-mode call\n"); TRACE("returned from real-mode call\n");
#else
/* we should never get here, but... */
ERR("cannot perform real-mode call\n");
#endif
} }
if (alloc) DOSMEM_FreeBlock( addr ); if (alloc) DOSMEM_FreeBlock( addr );
return 0; return 0;
@ -585,16 +574,14 @@ void WINAPI DPMI_FreeInternalRMCB( FARPROC16 proc )
} }
#ifdef MZ_SUPPORTED /* (see dosmem.c, function DOSMEM_InitDPMI) */
/* (see loader/dos/module.c, function MZ_InitDPMI) */
static void StartPM( CONTEXT86 *context, LPDOSTASK lpDosTask ) static void StartPM( CONTEXT86 *context, LPDOSTASK lpDosTask )
{ {
char *base = DOSMEM_MemoryBase();
UINT16 cs, ss, ds, es; UINT16 cs, ss, ds, es;
CONTEXT86 pm_ctx; CONTEXT86 pm_ctx;
DWORD psp_ofs = (DWORD)(lpDosTask->psp_seg<<4); DWORD psp_ofs = (DWORD)(lpDosTask->psp_seg<<4);
PDB16 *psp = (PDB16 *)(base + psp_ofs); PDB16 *psp = (PDB16 *)psp_ofs;
HANDLE16 env_seg = psp->environment; HANDLE16 env_seg = psp->environment;
int is32; int is32;
@ -602,22 +589,22 @@ static void StartPM( CONTEXT86 *context, LPDOSTASK lpDosTask )
lpDosTask->dpmi_flag = AX_reg(context); lpDosTask->dpmi_flag = AX_reg(context);
is32 = lpDosTask->dpmi_flag & 1; is32 = lpDosTask->dpmi_flag & 1;
/* our mode switch wrapper have placed the desired CS into DX */ /* our mode switch wrapper have placed the desired CS into DX */
cs = SELECTOR_AllocBlock( base + (DWORD)(DX_reg(context)<<4), 0x10000, SEGMENT_CODE, FALSE, FALSE ); cs = SELECTOR_AllocBlock( (void *)(DX_reg(context)<<4), 0x10000, SEGMENT_CODE, FALSE, FALSE );
/* due to a flaw in some CPUs (at least mine), it is best to mark stack segments as 32-bit if they /* due to a flaw in some CPUs (at least mine), it is best to mark stack segments as 32-bit if they
can be used in 32-bit code. Otherwise, these CPUs may not set the high word of esp during a can be used in 32-bit code. Otherwise, these CPUs may not set the high word of esp during a
ring transition (from kernel code) to the 16-bit stack, and this causes trouble if executing ring transition (from kernel code) to the 16-bit stack, and this causes trouble if executing
32-bit code using this stack. */ 32-bit code using this stack. */
ss = SELECTOR_AllocBlock( base + (DWORD)(SS_reg(context)<<4), 0x10000, SEGMENT_DATA, is32, FALSE ); ss = SELECTOR_AllocBlock( (void *)(SS_reg(context)<<4), 0x10000, SEGMENT_DATA, is32, FALSE );
/* do the same for the data segments, just in case */ /* do the same for the data segments, just in case */
if (DS_reg(context) == SS_reg(context)) ds = ss; if (DS_reg(context) == SS_reg(context)) ds = ss;
else ds = SELECTOR_AllocBlock( base + (DWORD)(DS_reg(context)<<4), 0x10000, SEGMENT_DATA, is32, FALSE ); else ds = SELECTOR_AllocBlock( (void *)(DS_reg(context)<<4), 0x10000, SEGMENT_DATA, is32, FALSE );
es = SELECTOR_AllocBlock( base + psp_ofs, 0x100, SEGMENT_DATA, is32, FALSE ); es = SELECTOR_AllocBlock( psp, 0x100, SEGMENT_DATA, is32, FALSE );
/* convert environment pointer, as the spec says, but we're a bit lazy about the size here... */ /* convert environment pointer, as the spec says, but we're a bit lazy about the size here... */
psp->environment = SELECTOR_AllocBlock( base + (DWORD)(env_seg<<4), psp->environment = SELECTOR_AllocBlock( (void *)(env_seg<<4),
0x10000, SEGMENT_DATA, FALSE, FALSE ); 0x10000, SEGMENT_DATA, FALSE, FALSE );
pm_ctx = *context; pm_ctx = *context;
CS_reg(&pm_ctx) = lpDosTask->dpmi_sel; CS_reg(&pm_ctx) = DOSMEM_dpmi_sel;
/* our mode switch wrapper expects the new CS in DX, and the new SS in AX */ /* our mode switch wrapper expects the new CS in DX, and the new SS in AX */
EAX_reg(&pm_ctx) = ss; EAX_reg(&pm_ctx) = ss;
EDX_reg(&pm_ctx) = cs; EDX_reg(&pm_ctx) = cs;
@ -697,26 +684,6 @@ void WINAPI DPMI_RawModeSwitch( SIGCONTEXT *context )
} }
#endif #endif
#else
#if 0
void WINAPI DPMI_RawModeSwitch( SIGCONTEXT *context )
{
ERR("don't even think about DPMI raw mode switch without DOS support!\n");
ExitProcess(1);
}
#endif
#endif
#define DOS_APP_ISDOS(addr,base) ((addr) < 0x110000)
#define DOS_WINE_ISDOS(addr,base) (((addr) >= (base)) && ((addr) < (base) + 0x110000))
#define DOS_UC_APPTOWINE(addr,base) ((addr) + (base))
#define DOS_UC_WINETOAPP(addr,base) ((addr) - (base))
#define DOS_APPTOWINE(addr,base) (DOS_APP_ISDOS(addr,base) ? DOS_UC_APPTOWINE(addr,base) : (addr))
#define DOS_WINETOAPP(addr,base) (DOS_WINE_ISDOS(addr,base) ? DOS_UC_WINETOAPP(addr,base) : (addr))
#define DOS_BADLIMIT(addr,base,limit) \
((limit == 0xffffffff) || /* disallow "fat DS" for now */ \
(DOS_WINE_ISDOS(addr,base) && \
((addr) + (limit) > (base) + 0x110000)))
/********************************************************************** /**********************************************************************
* INT_Int31Handler * INT_Int31Handler
@ -738,16 +705,15 @@ void WINAPI INT_Int31Handler( CONTEXT86 *context )
LPDOSTASK lpDosTask = MZ_Current(); LPDOSTASK lpDosTask = MZ_Current();
#ifdef MZ_SUPPORTED
if (ISV86(context) && lpDosTask) { if (ISV86(context) && lpDosTask) {
/* Called from real mode, check if it's our wrapper */ /* Called from real mode, check if it's our wrapper */
TRACE("called from real mode\n"); TRACE("called from real mode\n");
if (CS_reg(context)==lpDosTask->dpmi_seg) { if (CS_reg(context)==DOSMEM_dpmi_seg) {
/* This is the protected mode switch */ /* This is the protected mode switch */
StartPM(context,lpDosTask); StartPM(context,lpDosTask);
return; return;
} else } else
if (CS_reg(context)==lpDosTask->xms_seg) { if (CS_reg(context)==DOSMEM_xms_seg) {
/* This is the XMS driver entry point */ /* This is the XMS driver entry point */
XMS_Handler(context); XMS_Handler(context);
return; return;
@ -766,7 +732,6 @@ void WINAPI INT_Int31Handler( CONTEXT86 *context )
} }
} }
} }
#endif
RESET_CFLAG(context); RESET_CFLAG(context);
switch(AX_reg(context)) switch(AX_reg(context))
@ -849,12 +814,6 @@ void WINAPI INT_Int31Handler( CONTEXT86 *context )
} }
else else
{ {
#ifdef MZ_SUPPORTED
if (lpDosTask) {
DWORD base = (DWORD)DOSMEM_MemoryBase();
dw = DOS_WINETOAPP(dw, base);
}
#endif
CX_reg(context) = HIWORD(W32S_WINE2APP(dw, offset)); CX_reg(context) = HIWORD(W32S_WINE2APP(dw, offset));
DX_reg(context) = LOWORD(W32S_WINE2APP(dw, offset)); DX_reg(context) = LOWORD(W32S_WINE2APP(dw, offset));
} }
@ -865,40 +824,12 @@ void WINAPI INT_Int31Handler( CONTEXT86 *context )
BX_reg(context), BX_reg(context),
W32S_APP2WINE(MAKELONG(DX_reg(context),CX_reg(context)), offset)); W32S_APP2WINE(MAKELONG(DX_reg(context),CX_reg(context)), offset));
dw = W32S_APP2WINE(MAKELONG(DX_reg(context), CX_reg(context)), offset); dw = W32S_APP2WINE(MAKELONG(DX_reg(context), CX_reg(context)), offset);
#ifdef MZ_SUPPORTED
if (lpDosTask) {
DWORD base = (DWORD)DOSMEM_MemoryBase();
dw = DOS_APPTOWINE(dw, base);
}
#endif
SetSelectorBase(BX_reg(context), dw); SetSelectorBase(BX_reg(context), dw);
break; break;
case 0x0008: /* Set selector limit */ case 0x0008: /* Set selector limit */
TRACE("set selector limit (0x%04x,0x%08lx)\n",BX_reg(context),MAKELONG(DX_reg(context),CX_reg(context))); TRACE("set selector limit (0x%04x,0x%08lx)\n",BX_reg(context),MAKELONG(DX_reg(context),CX_reg(context)));
dw = MAKELONG( DX_reg(context), CX_reg(context) ); dw = MAKELONG( DX_reg(context), CX_reg(context) );
#ifdef MZ_SUPPORTED
if (lpDosTask) {
DWORD base = (DWORD)DOSMEM_MemoryBase();
DWORD sbase = GetSelectorBase( BX_reg(context) );
if (!sbase) {
/* the app has set the limit without setting the base,
* it must be relying on that the default should be DOS space;
* so set the base address now */
SetSelectorBase( BX_reg(context), sbase = base );
if (dw == 0xffffffff) {
/* djgpp does this without checking (in _dos_ds setup, crt1.c),
* so we have to override the limit here */
dw = 0x110000;
}
}
if (DOS_BADLIMIT(sbase, base, dw)) {
AX_reg(context) = 0x8021; /* invalid value */
SET_CFLAG(context);
break;
}
}
#endif
SetSelectorLimit16( BX_reg(context), dw ); SetSelectorLimit16( BX_reg(context), dw );
break; break;
@ -921,12 +852,6 @@ void WINAPI INT_Int31Handler( CONTEXT86 *context )
{ {
ldt_entry entry; ldt_entry entry;
LDT_GetEntry( SELECTOR_TO_ENTRY( BX_reg(context) ), &entry ); LDT_GetEntry( SELECTOR_TO_ENTRY( BX_reg(context) ), &entry );
#ifdef MZ_SUPPORTED
if (lpDosTask) {
DWORD base = (DWORD)DOSMEM_MemoryBase();
entry.base = DOS_WINETOAPP(entry.base, base);
}
#endif
entry.base = W32S_WINE2APP(entry.base, offset); entry.base = W32S_WINE2APP(entry.base, offset);
/* FIXME: should use ES:EDI for 32-bit clients */ /* FIXME: should use ES:EDI for 32-bit clients */
@ -942,18 +867,6 @@ void WINAPI INT_Int31Handler( CONTEXT86 *context )
LDT_BytesToEntry( PTR_SEG_OFF_TO_LIN( ES_reg(context), LDT_BytesToEntry( PTR_SEG_OFF_TO_LIN( ES_reg(context),
DI_reg(context) ), &entry ); DI_reg(context) ), &entry );
entry.base = W32S_APP2WINE(entry.base, offset); entry.base = W32S_APP2WINE(entry.base, offset);
#ifdef MZ_SUPPORTED
if (lpDosTask) {
DWORD base = (DWORD)DOSMEM_MemoryBase();
entry.base = DOS_APPTOWINE(entry.base, base);
if (DOS_BADLIMIT(entry.base, base, entry.limit)) {
AX_reg(context) = 0x8021; /* invalid value */
SET_CFLAG(context);
break;
}
}
#endif
LDT_SetEntry( SELECTOR_TO_ENTRY( BX_reg(context) ), &entry ); LDT_SetEntry( SELECTOR_TO_ENTRY( BX_reg(context) ), &entry );
} }
break; break;
@ -1032,7 +945,7 @@ void WINAPI INT_Int31Handler( CONTEXT86 *context )
/* we probably won't need this kind of state saving */ /* we probably won't need this kind of state saving */
AX_reg(context) = 0; AX_reg(context) = 0;
/* real mode: just point to the lret */ /* real mode: just point to the lret */
BX_reg(context) = DPMI_wrap_seg; BX_reg(context) = DOSMEM_wrap_seg;
ECX_reg(context) = 2; ECX_reg(context) = 2;
/* protected mode: don't have any handler yet... */ /* protected mode: don't have any handler yet... */
FIXME("no protected-mode dummy state save/restore handler yet\n"); FIXME("no protected-mode dummy state save/restore handler yet\n");
@ -1042,18 +955,12 @@ void WINAPI INT_Int31Handler( CONTEXT86 *context )
case 0x0306: /* Get Raw Mode Switch Addresses */ case 0x0306: /* Get Raw Mode Switch Addresses */
TRACE("get raw mode switch addresses\n"); TRACE("get raw mode switch addresses\n");
if (lpDosTask) { /* real mode, point to standard DPMI return wrapper */
/* real mode, point to standard DPMI return wrapper */ BX_reg(context) = DOSMEM_wrap_seg;
BX_reg(context) = DPMI_wrap_seg; ECX_reg(context) = 0;
ECX_reg(context) = 0; /* protected mode, point to DPMI call wrapper */
/* protected mode, point to DPMI call wrapper */ SI_reg(context) = DOSMEM_dpmi_sel;
SI_reg(context) = lpDosTask->dpmi_sel; EDI_reg(context) = 8; /* offset of the INT 0x31 call */
EDI_reg(context) = 8; /* offset of the INT 0x31 call */
} else {
ERR("win app attempting to get raw mode switch!\n");
AX_reg(context) = 0x8001; /* unsupported function */
SET_CFLAG(context);
}
break; break;
case 0x0400: /* Get DPMI version */ case 0x0400: /* Get DPMI version */
TRACE("get DPMI version\n"); TRACE("get DPMI version\n");

39
msdos/int09.c
View file

@ -15,9 +15,11 @@ DEFAULT_DEBUG_CHANNEL(int);
#define QUEUELEN 31 #define QUEUELEN 31
typedef struct { static struct
{
BYTE queuelen,queue[QUEUELEN],ascii[QUEUELEN]; BYTE queuelen,queue[QUEUELEN],ascii[QUEUELEN];
} KBDSYSTEM; } kbdinfo;
/********************************************************************** /**********************************************************************
* INT_Int09Handler * INT_Int09Handler
@ -58,48 +60,35 @@ void WINAPI INT_Int09Handler( CONTEXT86 *context )
DOSVM_PIC_ioport_out(0x20, 0x20); /* send EOI */ DOSVM_PIC_ioport_out(0x20, 0x20); /* send EOI */
} }
static void KbdRelay( LPDOSTASK lpDosTask, CONTEXT86 *context, void *data ) static void KbdRelay( CONTEXT86 *context, void *data )
{ {
KBDSYSTEM *sys = (KBDSYSTEM *)DOSVM_GetSystemData(0x09); if (kbdinfo.queuelen) {
if (sys && sys->queuelen) {
/* cleanup operation, called from DOSVM_PIC_ioport_out: /* cleanup operation, called from DOSVM_PIC_ioport_out:
* we'll remove current scancode from keyboard buffer here, * we'll remove current scancode from keyboard buffer here,
* rather than in ReadScan, because some DOS apps depend on * rather than in ReadScan, because some DOS apps depend on
* the scancode being available for reading multiple times... */ * the scancode being available for reading multiple times... */
if (--sys->queuelen) { if (--kbdinfo.queuelen) {
memmove(sys->queue,sys->queue+1,sys->queuelen); memmove(kbdinfo.queue,kbdinfo.queue+1,kbdinfo.queuelen);
memmove(sys->ascii,sys->ascii+1,sys->queuelen); memmove(kbdinfo.ascii,kbdinfo.ascii+1,kbdinfo.queuelen);
} }
} }
} }
void WINAPI INT_Int09SendScan( BYTE scan, BYTE ascii ) void WINAPI INT_Int09SendScan( BYTE scan, BYTE ascii )
{ {
KBDSYSTEM *sys = (KBDSYSTEM *)DOSVM_GetSystemData(0x09); if (kbdinfo.queuelen == QUEUELEN) {
if (!sys) {
sys = calloc(1,sizeof(KBDSYSTEM));
DOSVM_SetSystemData(0x09,sys);
}
if (sys->queuelen == QUEUELEN) {
ERR("keyboard queue overflow\n"); ERR("keyboard queue overflow\n");
return; return;
} }
/* add scancode to queue */ /* add scancode to queue */
sys->queue[sys->queuelen] = scan; kbdinfo.queue[kbdinfo.queuelen] = scan;
sys->ascii[sys->queuelen++] = ascii; kbdinfo.ascii[kbdinfo.queuelen++] = ascii;
/* tell app to read it by triggering IRQ 1 (int 09) */ /* tell app to read it by triggering IRQ 1 (int 09) */
DOSVM_QueueEvent(1,DOS_PRIORITY_KEYBOARD,KbdRelay,NULL); DOSVM_QueueEvent(1,DOS_PRIORITY_KEYBOARD,KbdRelay,NULL);
} }
BYTE WINAPI INT_Int09ReadScan( BYTE*ascii ) BYTE WINAPI INT_Int09ReadScan( BYTE*ascii )
{ {
KBDSYSTEM *sys = (KBDSYSTEM *)DOSVM_GetSystemData(0x09); if (ascii) *ascii = kbdinfo.ascii[0];
if (sys) { return kbdinfo.queue[0];
if (ascii) *ascii = sys->ascii[0];
return sys->queue[0];
} else {
if (ascii) *ascii = 0;
return 0;
}
} }

21
msdos/int2f.c
View file

@ -115,9 +115,7 @@ void WINAPI INT_Int2fHandler( CONTEXT86 *context )
break; break;
case 0x10: /* XMS v2+ get driver address */ case 0x10: /* XMS v2+ get driver address */
{ {
LPDOSTASK lpDosTask = MZ_Current(); ES_reg(context) = DOSMEM_xms_seg;
ES_reg(context) = lpDosTask ? lpDosTask->xms_seg : 0;
BX_reg(context) = 0; BX_reg(context) = 0;
break; break;
} }
@ -349,15 +347,13 @@ static void do_int2f_16( CONTEXT86 *context )
#endif #endif
{ {
SYSTEM_INFO si; SYSTEM_INFO si;
LPDOSTASK lpDosTask = MZ_Current();
GetSystemInfo(&si); GetSystemInfo(&si);
AX_reg(context) = 0x0000; /* DPMI Installed */ AX_reg(context) = 0x0000; /* DPMI Installed */
BX_reg(context) = 0x0001; /* 32bits available */ BX_reg(context) = 0x0001; /* 32bits available */
CL_reg(context) = si.wProcessorLevel; CL_reg(context) = si.wProcessorLevel;
DX_reg(context) = 0x005a; /* DPMI major/minor 0.90 */ DX_reg(context) = 0x005a; /* DPMI major/minor 0.90 */
SI_reg(context) = 0; /* # of para. of DOS extended private data */ SI_reg(context) = 0; /* # of para. of DOS extended private data */
ES_reg(context) = lpDosTask ? lpDosTask->dpmi_seg : 0; ES_reg(context) = DOSMEM_dpmi_seg;
DI_reg(context) = 0; /* ES:DI is DPMI switch entry point */ DI_reg(context) = 0; /* ES:DI is DPMI switch entry point */
break; break;
} }
@ -402,9 +398,8 @@ static void MSCDEX_Dump(char* pfx, BYTE* req, int dorealmode)
case 3: case 3:
case 12: case 12:
ptr += sprintf(ptr, "\n\t\t\t\tIO_struct => "); ptr += sprintf(ptr, "\n\t\t\t\tIO_struct => ");
ios = (dorealmode) ? ios = (dorealmode) ? PTR_REAL_TO_LIN( PTR_AT(req, 16, WORD), PTR_AT(req, 14, WORD)) :
DOSMEM_MapRealToLinear(MAKELONG(PTR_AT(req, 14, WORD), PTR_AT(req, 16, WORD))) : PTR_SEG_OFF_TO_LIN(PTR_AT(req, 16, WORD), PTR_AT(req, 14, WORD));
PTR_SEG_OFF_TO_LIN(PTR_AT(req, 16, WORD), PTR_AT(req, 14, WORD));
for (i = 0; i < PTR_AT(req, 18, WORD); i++) { for (i = 0; i < PTR_AT(req, 18, WORD); i++) {
ptr += sprintf(ptr, "%02x ", ios[i]); ptr += sprintf(ptr, "%02x ", ios[i]);
@ -476,9 +471,7 @@ static void MSCDEX_Handler(CONTEXT86* context)
BYTE Error = 255; /* No Error */ BYTE Error = 255; /* No Error */
int dorealmode = ISV86(context); int dorealmode = ISV86(context);
driver_request = (dorealmode) ? driver_request = CTX_SEG_OFF_TO_LIN(context, context->SegEs, context->Ebx);
DOSMEM_MapRealToLinear(MAKELONG(BX_reg(context), ES_reg(context))) :
PTR_SEG_OFF_TO_LIN(ES_reg(context), BX_reg(context));
if (!driver_request) { if (!driver_request) {
/* FIXME - to be deleted ?? */ /* FIXME - to be deleted ?? */
@ -517,7 +510,7 @@ static void MSCDEX_Handler(CONTEXT86* context)
switch (driver_request[2]) { switch (driver_request[2]) {
case 3: case 3:
io_stru = (dorealmode) ? io_stru = (dorealmode) ?
DOSMEM_MapRealToLinear(MAKELONG(PTR_AT(driver_request, 14, WORD), PTR_AT(driver_request, 16, WORD))) : PTR_REAL_TO_LIN( PTR_AT(driver_request, 16, WORD), PTR_AT(driver_request, 14, WORD) ) :
PTR_SEG_OFF_TO_LIN(PTR_AT(driver_request, 16, WORD), PTR_AT(driver_request, 14, WORD)); PTR_SEG_OFF_TO_LIN(PTR_AT(driver_request, 16, WORD), PTR_AT(driver_request, 14, WORD));
TRACE(" --> IOCTL INPUT <%d>\n", io_stru[0]); TRACE(" --> IOCTL INPUT <%d>\n", io_stru[0]);
@ -682,7 +675,7 @@ static void MSCDEX_Handler(CONTEXT86* context)
case 12: case 12:
io_stru = (dorealmode) ? io_stru = (dorealmode) ?
DOSMEM_MapRealToLinear(MAKELONG(PTR_AT(driver_request, 14, WORD), PTR_AT(driver_request, 16, WORD))) : PTR_REAL_TO_LIN( PTR_AT(driver_request, 16, WORD), PTR_AT(driver_request, 14, WORD)) :
PTR_SEG_OFF_TO_LIN(PTR_AT(driver_request, 16, WORD), PTR_AT(driver_request, 14, WORD)); PTR_SEG_OFF_TO_LIN(PTR_AT(driver_request, 16, WORD), PTR_AT(driver_request, 14, WORD));
TRACE(" --> IOCTL OUTPUT <%d>\n", io_stru[0]); TRACE(" --> IOCTL OUTPUT <%d>\n", io_stru[0]);

52
msdos/int33.c
View file

@ -13,11 +13,12 @@
DEFAULT_DEBUG_CHANNEL(int) DEFAULT_DEBUG_CHANNEL(int)
typedef struct { static struct
{
DWORD x, y, but; DWORD x, y, but;
FARPROC16 callback; FARPROC16 callback;
WORD callmask; WORD callmask;
} MOUSESYSTEM; } mouse_info;
/********************************************************************** /**********************************************************************
* INT_Int33Handler * INT_Int33Handler
@ -26,15 +27,12 @@ typedef struct {
*/ */
void WINAPI INT_Int33Handler( CONTEXT86 *context ) void WINAPI INT_Int33Handler( CONTEXT86 *context )
{ {
MOUSESYSTEM *sys = (MOUSESYSTEM *)DOSVM_GetSystemData(0x33);
switch (AX_reg(context)) { switch (AX_reg(context)) {
case 0x00: case 0x00:
TRACE("Reset mouse driver and request status\n"); TRACE("Reset mouse driver and request status\n");
AX_reg(context) = 0xFFFF; /* installed */ AX_reg(context) = 0xFFFF; /* installed */
BX_reg(context) = 3; /* # of buttons */ BX_reg(context) = 3; /* # of buttons */
sys = calloc(1,sizeof(MOUSESYSTEM)); memset( &mouse_info, 0, sizeof(mouse_info) );
DOSVM_SetSystemData(0x33, sys);
break; break;
case 0x01: case 0x01:
FIXME("Show mouse cursor\n"); FIXME("Show mouse cursor\n");
@ -44,9 +42,9 @@ void WINAPI INT_Int33Handler( CONTEXT86 *context )
break; break;
case 0x03: case 0x03:
TRACE("Return mouse position and button status\n"); TRACE("Return mouse position and button status\n");
BX_reg(context) = sys->but; BX_reg(context) = mouse_info.but;
CX_reg(context) = sys->x; CX_reg(context) = mouse_info.x;
DX_reg(context) = sys->y; DX_reg(context) = mouse_info.y;
break; break;
case 0x04: case 0x04:
FIXME("Position mouse cursor\n"); FIXME("Position mouse cursor\n");
@ -65,8 +63,8 @@ void WINAPI INT_Int33Handler( CONTEXT86 *context )
break; break;
case 0x0C: case 0x0C:
TRACE("Define mouse interrupt subroutine\n"); TRACE("Define mouse interrupt subroutine\n");
sys->callmask = CX_reg(context); mouse_info.callmask = CX_reg(context);
sys->callback = (FARPROC16)PTR_SEG_OFF_TO_SEGPTR(ES_reg(context), DX_reg(context)); mouse_info.callback = (FARPROC16)PTR_SEG_OFF_TO_SEGPTR(ES_reg(context), DX_reg(context));
break; break;
case 0x10: case 0x10:
FIXME("Define screen region for update\n"); FIXME("Define screen region for update\n");
@ -81,7 +79,7 @@ typedef struct {
WORD mask,but,x,y,mx,my; WORD mask,but,x,y,mx,my;
} MCALLDATA; } MCALLDATA;
static void MouseRelay(LPDOSTASK lpDosTask,CONTEXT86 *context,void *mdata) static void MouseRelay(CONTEXT86 *context,void *mdata)
{ {
MCALLDATA *data = (MCALLDATA *)mdata; MCALLDATA *data = (MCALLDATA *)mdata;
CONTEXT86 ctx = *context; CONTEXT86 ctx = *context;
@ -100,58 +98,56 @@ static void MouseRelay(LPDOSTASK lpDosTask,CONTEXT86 *context,void *mdata)
void WINAPI INT_Int33Message(UINT message,WPARAM wParam,LPARAM lParam) void WINAPI INT_Int33Message(UINT message,WPARAM wParam,LPARAM lParam)
{ {
MOUSESYSTEM *sys = (MOUSESYSTEM *)DOSVM_GetSystemData(0x33);
WORD mask = 0; WORD mask = 0;
unsigned Height, Width, SX=1, SY=1; unsigned Height, Width, SX=1, SY=1;
if (!sys) return;
if (!VGA_GetMode(&Height,&Width,NULL)) { if (!VGA_GetMode(&Height,&Width,NULL)) {
/* may need to do some coordinate scaling */ /* may need to do some coordinate scaling */
SX = 640/Width; SX = 640/Width;
if (!SX) SX=1; if (!SX) SX=1;
} }
sys->x = LOWORD(lParam) * SX; mouse_info.x = LOWORD(lParam) * SX;
sys->y = HIWORD(lParam) * SY; mouse_info.y = HIWORD(lParam) * SY;
switch (message) { switch (message) {
case WM_MOUSEMOVE: case WM_MOUSEMOVE:
mask |= 0x01; mask |= 0x01;
break; break;
case WM_LBUTTONDOWN: case WM_LBUTTONDOWN:
case WM_LBUTTONDBLCLK: case WM_LBUTTONDBLCLK:
sys->but |= 0x01; mouse_info.but |= 0x01;
mask |= 0x02; mask |= 0x02;
break; break;
case WM_LBUTTONUP: case WM_LBUTTONUP:
sys->but &= ~0x01; mouse_info.but &= ~0x01;
mask |= 0x04; mask |= 0x04;
break; break;
case WM_RBUTTONDOWN: case WM_RBUTTONDOWN:
case WM_RBUTTONDBLCLK: case WM_RBUTTONDBLCLK:
sys->but |= 0x02; mouse_info.but |= 0x02;
mask |= 0x08; mask |= 0x08;
break; break;
case WM_RBUTTONUP: case WM_RBUTTONUP:
sys->but &= ~0x02; mouse_info.but &= ~0x02;
mask |= 0x10; mask |= 0x10;
break; break;
case WM_MBUTTONDOWN: case WM_MBUTTONDOWN:
case WM_MBUTTONDBLCLK: case WM_MBUTTONDBLCLK:
sys->but |= 0x04; mouse_info.but |= 0x04;
mask |= 0x20; mask |= 0x20;
break; break;
case WM_MBUTTONUP: case WM_MBUTTONUP:
sys->but &= ~0x04; mouse_info.but &= ~0x04;
mask |= 0x40; mask |= 0x40;
break; break;
} }
if ((mask & sys->callmask) && sys->callback) { if ((mask & mouse_info.callmask) && mouse_info.callback) {
MCALLDATA *data = calloc(1,sizeof(MCALLDATA)); MCALLDATA *data = calloc(1,sizeof(MCALLDATA));
data->proc = sys->callback; data->proc = mouse_info.callback;
data->mask = mask & sys->callmask; data->mask = mask & mouse_info.callmask;
data->but = sys->but; data->but = mouse_info.but;
data->x = sys->x; data->x = mouse_info.x;
data->y = sys->y; data->y = mouse_info.y;
DOSVM_QueueEvent(-1, DOS_PRIORITY_MOUSE, MouseRelay, data); DOSVM_QueueEvent(-1, DOS_PRIORITY_MOUSE, MouseRelay, data);
} }
} }