/********************************************************************** * DOSVM_RawModeSwitchHandler * * DPMI Raw Mode Switch handler */ void WINAPI DOSVM_RawModeSwitchHandler( CONTEXT86 *context ) { CONTEXT86 rm_ctx; int ret; /* initialize real-mode context as per spec */ memset(&rm_ctx, 0, sizeof(rm_ctx)); rm_ctx.SegDs = AX_reg(context); rm_ctx.SegEs = CX_reg(context); rm_ctx.SegSs = DX_reg(context); rm_ctx.Esp = context->Ebx; rm_ctx.SegCs = SI_reg(context); rm_ctx.Eip = context->Edi; rm_ctx.Ebp = context->Ebp; rm_ctx.SegFs = 0; rm_ctx.SegGs = 0; /* Copy interrupt state. */ if (get_vm86_teb_info()->dpmi_vif) rm_ctx.EFlags = V86_FLAG | VIF_MASK; else rm_ctx.EFlags = V86_FLAG; /* enter real mode again */ TRACE("re-entering real mode at %04x:%04x\n",rm_ctx.SegCs,rm_ctx.Eip); ret = DOSVM_Enter( &rm_ctx ); /* when the real-mode stuff call its mode switch address, DOSVM_Enter will return and we will continue here */ if (ret<0) { ERR("Sync lost!\n"); /* if the sync was lost, there's no way to recover */ ExitProcess(1); } /* alter protected-mode context as per spec */ context->SegDs = LOWORD(rm_ctx.Eax); context->SegEs = LOWORD(rm_ctx.Ecx); context->SegSs = LOWORD(rm_ctx.Edx); context->Esp = rm_ctx.Ebx; context->SegCs = LOWORD(rm_ctx.Esi); context->Eip = rm_ctx.Edi; context->Ebp = rm_ctx.Ebp; context->SegFs = 0; context->SegGs = 0; /* Copy interrupt state. */ if (rm_ctx.EFlags & VIF_MASK) get_vm86_teb_info()->dpmi_vif = 1; else get_vm86_teb_info()->dpmi_vif = 0; /* Return to new address and hope that we didn't mess up */ TRACE("re-entering protected mode at %04x:%08x\n", context->SegCs, context->Eip); }
/********************************************************************** * DPMI_CallRMCBProc * * This routine does the hard work of calling a callback procedure. */ static void DPMI_CallRMCBProc( CONTEXT86 *context, RMCB *rmcb, WORD flag ) { DWORD old_vif = get_vm86_teb_info()->dpmi_vif; /* Disable virtual interrupts. */ get_vm86_teb_info()->dpmi_vif = 0; if (wine_ldt_is_system( rmcb->proc_sel )) { /* Wine-internal RMCB, call directly */ ((RMCBPROC)rmcb->proc_ofs)(context); } else __TRY { UINT16 ss,es; DWORD esp,edi; INT_SetRealModeContext(MapSL(MAKESEGPTR( rmcb->regs_sel, rmcb->regs_ofs )), context); ss = alloc_pm_selector( context->SegSs, WINE_LDT_FLAGS_DATA ); esp = context->Esp; FIXME("untested!\n"); /* The called proc ends with an IRET, and takes these parameters: * DS:ESI = pointer to real-mode SS:SP * ES:EDI = pointer to real-mode call structure * It returns: * ES:EDI = pointer to real-mode call structure (may be a copy) * It is the proc's responsibility to change the return CS:IP in the * real-mode call structure. */ if (flag & 1) { /* 32-bit DPMI client */ DPMI_CallRMCB32(rmcb, ss, esp, &es, &edi); } else { /* 16-bit DPMI client */ CONTEXT86 ctx = *context; ctx.SegCs = rmcb->proc_sel; ctx.Eip = rmcb->proc_ofs; ctx.SegDs = ss; ctx.Esi = esp; ctx.SegEs = rmcb->regs_sel; ctx.Edi = rmcb->regs_ofs; /* FIXME: I'm pretty sure this isn't right - should push flags first */ WOWCallback16Ex( 0, WCB16_REGS, 0, NULL, (DWORD *)&ctx ); es = ctx.SegEs; edi = ctx.Edi; } wine_ldt_free_entries( ss, 1 ); INT_GetRealModeContext( MapSL( MAKESEGPTR( es, edi )), context); } __EXCEPT(dpmi_exception_handler) { } __ENDTRY /* Restore virtual interrupt flag. */ get_vm86_teb_info()->dpmi_vif = old_vif; }
/*********************************************************************** * DOSVM_SendQueuedEvents * * As long as context instruction pointer stays unmodified, * process all pending events that are not blocked by currently * active event. * * This routine assumes that caller has already cleared TEB.vm86_pending * and checked that interrupts are enabled. */ void DOSVM_SendQueuedEvents( CONTEXT86 *context ) { DWORD old_cs = context->SegCs; DWORD old_ip = context->Eip; EnterCriticalSection(&qcrit); TRACE( "Called in %s mode %s events pending (time=%d)\n", ISV86(context) ? "real" : "protected", DOSVM_HasPendingEvents() ? "with" : "without", GetTickCount() ); TRACE( "cs:ip=%04x:%08x, ss:sp=%04x:%08x\n", context->SegCs, context->Eip, context->SegSs, context->Esp); while (context->SegCs == old_cs && context->Eip == old_ip && DOSVM_HasPendingEvents()) { DOSVM_SendOneEvent(context); /* * Event handling may have turned pending events flag on. * We disable it here because this prevents some * unnecessary calls to this function. */ get_vm86_teb_info()->vm86_pending = 0; } #ifdef MZ_SUPPORTED if (DOSVM_HasPendingEvents()) { /* * Interrupts disabled, but there are still * pending events, make sure that pending flag is turned on. */ TRACE( "Another event is pending, setting VIP flag.\n" ); get_vm86_teb_info()->vm86_pending |= VIP_MASK; } #else FIXME("No DOS .exe file support on this platform (yet)\n"); #endif /* MZ_SUPPORTED */ LeaveCriticalSection(&qcrit); }
/************************************************************* * call16_handler * * Handler for exceptions occurring in 16-bit code. */ static DWORD call16_handler( EXCEPTION_RECORD *record, EXCEPTION_REGISTRATION_RECORD *frame, CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **pdispatcher ) { if (record->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND)) { /* unwinding: restore the stack pointer in the TEB, and leave the Win16 mutex */ STACK32FRAME *frame32 = (STACK32FRAME *)((char *)frame - offsetof(STACK32FRAME,frame)); NtCurrentTeb()->WOW32Reserved = (void *)frame32->frame16; _LeaveWin16Lock(); } else if (record->ExceptionCode == EXCEPTION_ACCESS_VIOLATION || record->ExceptionCode == EXCEPTION_PRIV_INSTRUCTION) { if (wine_ldt_is_system(context->SegCs)) { if (fix_selector( context )) return ExceptionContinueExecution; } else { SEGPTR gpHandler; DWORD ret = __wine_emulate_instruction( record, context ); /* * Insert check for pending DPMI events. Note that this * check must be inserted after instructions have been * emulated because the instruction emulation requires * original CS:IP and the emulation may change TEB.dpmi_vif. */ if(get_vm86_teb_info()->dpmi_vif) insert_event_check( context ); if (ret != ExceptionContinueSearch) return ret; /* check for Win16 __GP handler */ if ((gpHandler = HasGPHandler16( MAKESEGPTR( context->SegCs, context->Eip ) ))) { WORD *stack = wine_ldt_get_ptr( context->SegSs, context->Esp ); *--stack = context->SegCs; *--stack = context->Eip; if (!IS_SELECTOR_32BIT(context->SegSs)) context->Esp = MAKELONG( LOWORD(context->Esp - 2*sizeof(WORD)), HIWORD(context->Esp) ); else context->Esp -= 2*sizeof(WORD); context->SegCs = SELECTOROF( gpHandler ); context->Eip = OFFSETOF( gpHandler ); return ExceptionContinueExecution; } } } else if (record->ExceptionCode == EXCEPTION_VM86_STI) { insert_event_check( context ); } return ExceptionContinueSearch; }
/********************************************************************** * DOSVM_AcknowledgeIRQ * * This routine should be called by all internal IRQ handlers. */ void WINAPI DOSVM_AcknowledgeIRQ( CONTEXT86 *context ) { /* * Send EOI to PIC. */ DOSVM_PIC_ioport_out( 0x20, 0x20 ); /* * Protected mode IRQ handlers are supposed * to turn VIF flag on before they return. */ if (!ISV86(context)) get_vm86_teb_info()->dpmi_vif = 1; }
/*********************************************************************** * OutPIC (WINEDOS.@) */ void WINAPI DOSVM_PIC_ioport_out( WORD port, BYTE val) { if (port != 0x20) { FIXME( "Unsupported PIC port %04x\n", port ); } else if (val == 0x20 || (val >= 0x60 && val <= 0x67)) { EnterCriticalSection(&qcrit); if (!current_event) { WARN( "%s without active IRQ\n", val == 0x20 ? "EOI" : "Specific EOI" ); } else if (val != 0x20 && val - 0x60 != current_event->irq) { WARN( "Specific EOI but current IRQ %d is not %d\n", current_event->irq, val - 0x60 ); } else { LPDOSEVENT event = current_event; TRACE( "Received %s for current IRQ %d, clearing event\n", val == 0x20 ? "EOI" : "Specific EOI", event->irq ); current_event = event->next; if (event->relay) (*event->relay)(NULL,event->data); free(event); if (DOSVM_HasPendingEvents()) { TRACE( "Another event pending, setting pending flag\n" ); get_vm86_teb_info()->vm86_pending |= VIP_MASK; } } LeaveCriticalSection(&qcrit); } else { FIXME( "Unrecognized PIC command %02x\n", val ); } }
/********************************************************************** * DOSVM_PrepareIRQ * */ static void DOSVM_PrepareIRQ( CONTEXT86 *context, BOOL isbuiltin ) { /* Disable virtual interrupts. */ get_vm86_teb_info()->dpmi_vif = 0; if (!isbuiltin) { DWORD *stack = CTX_SEG_OFF_TO_LIN(context, context->SegSs, context->Esp); /* Push return address to stack. */ *(--stack) = context->SegCs; *(--stack) = context->Eip; context->Esp += -8; /* Jump to enable interrupts stub. */ context->SegCs = DOSVM_dpmi_segments->relay_code_sel; context->Eip = 5; } }
/********************************************************************** * DOSVM_Int31Handler * * Handler for int 31h (DPMI). */ void WINAPI DOSVM_Int31Handler( CONTEXT86 *context ) { RESET_CFLAG(context); switch(AX_reg(context)) { case 0x0000: /* Allocate LDT descriptors */ TRACE( "allocate LDT descriptors (%d)\n", CX_reg(context) ); { WORD sel = AllocSelectorArray16( CX_reg(context) ); if(!sel) { TRACE( "failed\n" ); SET_AX( context, 0x8011 ); /* descriptor unavailable */ SET_CFLAG( context ); } else { TRACE( "success, array starts at 0x%04x\n", sel ); SET_AX( context, sel ); } } break; case 0x0001: /* Free LDT descriptor */ TRACE( "free LDT descriptor (0x%04x)\n", BX_reg(context) ); if (FreeSelector16( BX_reg(context) )) { SET_AX( context, 0x8022 ); /* invalid selector */ SET_CFLAG( context ); } else { /* If a segment register contains the selector being freed, */ /* set it to zero. */ if (!((context->SegDs^BX_reg(context)) & ~3)) context->SegDs = 0; if (!((context->SegEs^BX_reg(context)) & ~3)) context->SegEs = 0; if (!((context->SegFs^BX_reg(context)) & ~3)) context->SegFs = 0; if (!((context->SegGs^BX_reg(context)) & ~3)) context->SegGs = 0; } break; case 0x0002: /* Real mode segment to descriptor */ TRACE( "real mode segment to descriptor (0x%04x)\n", BX_reg(context) ); { WORD entryPoint = 0; /* KERNEL entry point for descriptor */ switch(BX_reg(context)) { case 0x0000: entryPoint = 183; break; /* __0000H */ case 0x0040: entryPoint = 193; break; /* __0040H */ case 0xa000: entryPoint = 174; break; /* __A000H */ case 0xb000: entryPoint = 181; break; /* __B000H */ case 0xb800: entryPoint = 182; break; /* __B800H */ case 0xc000: entryPoint = 195; break; /* __C000H */ case 0xd000: entryPoint = 179; break; /* __D000H */ case 0xe000: entryPoint = 190; break; /* __E000H */ case 0xf000: entryPoint = 194; break; /* __F000H */ default: FIXME("Real mode segment (%x) to descriptor: no longer supported\n", BX_reg(context)); SET_CFLAG( context ); break; } if (entryPoint) { FARPROC16 proc = GetProcAddress16( GetModuleHandle16( "KERNEL" ), (LPCSTR)(ULONG_PTR)entryPoint ); SET_AX( context, LOWORD(proc) ); } } break; case 0x0003: /* Get next selector increment */ TRACE("get selector increment (__AHINCR)\n"); context->Eax = __AHINCR; break; case 0x0004: /* Lock selector (not supported) */ FIXME("lock selector not supported\n"); context->Eax = 0; /* FIXME: is this a correct return value? */ break; case 0x0005: /* Unlock selector (not supported) */ FIXME("unlock selector not supported\n"); context->Eax = 0; /* FIXME: is this a correct return value? */ break; case 0x0006: /* Get selector base address */ TRACE( "get selector base address (0x%04x)\n", BX_reg(context) ); { LDT_ENTRY entry; WORD sel = BX_reg(context); wine_ldt_get_entry( sel, &entry ); if (wine_ldt_is_empty(&entry)) { context->Eax = 0x8022; /* invalid selector */ SET_CFLAG(context); } else { void *base = wine_ldt_get_base(&entry); SET_CX( context, HIWORD(base) ); SET_DX( context, LOWORD(base) ); } } break; case 0x0007: /* Set selector base address */ { DWORD base = MAKELONG( DX_reg(context), CX_reg(context) ); WORD sel = BX_reg(context); TRACE( "set selector base address (0x%04x,0x%08x)\n", sel, base ); /* check if Win16 app wants to access lower 64K of DOS memory */ if (base < 0x10000 && DOSVM_IsWin16()) DOSMEM_MapDosLayout(); SetSelectorBase( sel, base ); } break; case 0x0008: /* Set selector limit */ { DWORD limit = MAKELONG( DX_reg(context), CX_reg(context) ); TRACE( "set selector limit (0x%04x,0x%08x)\n", BX_reg(context), limit ); SetSelectorLimit16( BX_reg(context), limit ); } break; case 0x0009: /* Set selector access rights */ TRACE( "set selector access rights(0x%04x,0x%04x)\n", BX_reg(context), CX_reg(context) ); SelectorAccessRights16( BX_reg(context), 1, CX_reg(context) ); break; case 0x000a: /* Allocate selector alias */ TRACE( "allocate selector alias (0x%04x)\n", BX_reg(context) ); SET_AX( context, AllocCStoDSAlias16( BX_reg(context) ) ); if (!AX_reg(context)) { SET_AX( context, 0x8011 ); /* descriptor unavailable */ SET_CFLAG(context); } break; case 0x000b: /* Get descriptor */ TRACE( "get descriptor (0x%04x)\n", BX_reg(context) ); { LDT_ENTRY *entry = CTX_SEG_OFF_TO_LIN( context, context->SegEs, context->Edi ); wine_ldt_get_entry( BX_reg(context), entry ); } break; case 0x000c: /* Set descriptor */ TRACE( "set descriptor (0x%04x)\n", BX_reg(context) ); { LDT_ENTRY *entry = CTX_SEG_OFF_TO_LIN( context, context->SegEs, context->Edi ); wine_ldt_set_entry( BX_reg(context), entry ); } break; case 0x000d: /* Allocate specific LDT descriptor */ FIXME( "allocate descriptor (0x%04x), stub!\n", BX_reg(context) ); SET_AX( context, 0x8011 ); /* descriptor unavailable */ SET_CFLAG( context ); break; case 0x000e: /* Get Multiple Descriptors (1.0) */ FIXME( "get multiple descriptors - unimplemented\n" ); break; case 0x000f: /* Set Multiple Descriptors (1.0) */ FIXME( "set multiple descriptors - unimplemented\n" ); break; case 0x0100: /* Allocate DOS memory block */ TRACE( "allocate DOS memory block (0x%x paragraphs)\n", BX_reg(context) ); { DWORD dw = GlobalDOSAlloc16( (DWORD)BX_reg(context) << 4 ); if (dw) { SET_AX( context, HIWORD(dw) ); SET_DX( context, LOWORD(dw) ); } else { SET_AX( context, 0x0008 ); /* insufficient memory */ SET_BX( context, DOSMEM_Available() >> 4 ); SET_CFLAG(context); } break; } case 0x0101: /* Free DOS memory block */ TRACE( "free DOS memory block (0x%04x)\n", DX_reg(context) ); { WORD error = GlobalDOSFree16( DX_reg(context) ); if (error) { SET_AX( context, 0x0009 ); /* memory block address invalid */ SET_CFLAG( context ); } } break; case 0x0102: /* Resize DOS Memory Block */ FIXME( "resize DOS memory block (0x%04x, 0x%x paragraphs) - unimplemented\n", DX_reg(context), BX_reg(context) ); break; case 0x0200: /* get real mode interrupt vector */ TRACE( "get realmode interrupt vector (0x%02x)\n", BL_reg(context) ); { FARPROC16 proc = DOSVM_GetRMHandler( BL_reg(context) ); SET_CX( context, SELECTOROF(proc) ); SET_DX( context, OFFSETOF(proc) ); } break; case 0x0201: /* set real mode interrupt vector */ TRACE( "set realmode interrupt vector (0x%02x, 0x%04x:0x%04x)\n", BL_reg(context), CX_reg(context), DX_reg(context) ); DOSVM_SetRMHandler( BL_reg(context), (FARPROC16)MAKESEGPTR(CX_reg(context), DX_reg(context)) ); break; case 0x0202: /* Get Processor Exception Handler Vector */ FIXME( "Get Processor Exception Handler Vector (0x%02x)\n", BL_reg(context) ); if (DOSVM_IsDos32()) { SET_CX( context, 0 ); context->Edx = 0; } else { SET_CX( context, 0 ); SET_DX( context, 0 ); } break; case 0x0203: /* Set Processor Exception Handler Vector */ FIXME( "Set Processor Exception Handler Vector (0x%02x)\n", BL_reg(context) ); break; case 0x0204: /* Get protected mode interrupt vector */ TRACE("get protected mode interrupt handler (0x%02x)\n", BL_reg(context)); if (DOSVM_IsDos32()) { FARPROC48 handler = DOSVM_GetPMHandler48( BL_reg(context) ); SET_CX( context, handler.selector ); context->Edx = handler.offset; } else { FARPROC16 handler = DOSVM_GetPMHandler16( BL_reg(context) ); SET_CX( context, SELECTOROF(handler) ); SET_DX( context, OFFSETOF(handler) ); } break; case 0x0205: /* Set protected mode interrupt vector */ TRACE("set protected mode interrupt handler (0x%02x,0x%04x:0x%08x)\n", BL_reg(context), CX_reg(context), context->Edx); if (DOSVM_IsDos32()) { FARPROC48 handler; handler.selector = CX_reg(context); handler.offset = context->Edx; DOSVM_SetPMHandler48( BL_reg(context), handler ); } else { FARPROC16 handler; handler = (FARPROC16)MAKESEGPTR( CX_reg(context), DX_reg(context)); DOSVM_SetPMHandler16( BL_reg(context), handler ); } break; case 0x0300: /* Simulate real mode interrupt */ TRACE( "Simulate real mode interrupt %02x.\n", BL_reg(context)); DOSVM_CallRMInt( context ); break; case 0x0301: /* Call real mode procedure with far return */ TRACE( "Call real mode procedure with far return.\n" ); DOSVM_CallRMProc( context, FALSE ); break; case 0x0302: /* Call real mode procedure with interrupt return */ TRACE( "Call real mode procedure with interrupt return.\n" ); DOSVM_CallRMProc( context, TRUE ); break; case 0x0303: /* Allocate Real Mode Callback Address */ TRACE( "Allocate real mode callback address.\n" ); DOSVM_AllocRMCB( context ); break; case 0x0304: /* Free Real Mode Callback Address */ TRACE( "Free real mode callback address.\n" ); DOSVM_FreeRMCB( context ); break; case 0x0305: /* Get State Save/Restore Addresses */ TRACE("get state save/restore addresses\n"); /* we probably won't need this kind of state saving */ SET_AX( context, 0 ); /* real mode: just point to the lret */ SET_BX( context, DOSVM_dpmi_segments->wrap_seg ); SET_CX( context, 2 ); /* protected mode: don't have any handler yet... */ /* FIXME: Use DI in 16-bit DPMI and EDI in 32-bit DPMI */ FIXME("no protected-mode dummy state save/restore handler yet\n"); SET_SI( context, 0 ); context->Edi = 0; break; case 0x0306: /* Get Raw Mode Switch Addresses */ TRACE("get raw mode switch addresses\n"); /* real mode, point to standard DPMI return wrapper */ SET_BX( context, DOSVM_dpmi_segments->wrap_seg ); SET_CX( context, 0 ); /* protected mode, point to DPMI call wrapper */ /* FIXME: Use DI in 16-bit DPMI and EDI in 32-bit DPMI */ /* FIXME: Doesn't work in DPMI32... */ SET_SI( context, DOSVM_dpmi_segments->dpmi_sel ); context->Edi = 8; /* offset of the INT 0x31 call */ break; case 0x0400: /* Get DPMI version */ TRACE("get DPMI version\n"); { SYSTEM_INFO si; GetSystemInfo(&si); SET_AX( context, 0x005a ); /* DPMI version 0.90 */ SET_BX( context, 0x0005 ); /* Flags: 32-bit, virtual memory */ SET_CL( context, si.wProcessorLevel ); SET_DX( context, 0x0870 ); /* Master/slave interrupt controller base */ } break; case 0x0401: /* Get DPMI Capabilities (1.0) */ FIXME( "get dpmi capabilities - unimplemented\n"); break; case 0x0500: /* Get free memory information */ TRACE("get free memory information\n"); { MEMORYSTATUS status; /* the layout is just the same as MEMMANINFO, but without * the dwSize entry. */ struct { DWORD dwLargestFreeBlock; DWORD dwMaxPagesAvailable; DWORD dwMaxPagesLockable; DWORD dwTotalLinearSpace; DWORD dwTotalUnlockedPages; DWORD dwFreePages; DWORD dwTotalPages; DWORD dwFreeLinearSpace; DWORD dwSwapFilePages; WORD wPageSize; } *info = CTX_SEG_OFF_TO_LIN( context, context->SegEs, context->Edi ); GlobalMemoryStatus( &status ); info->wPageSize = getpagesize(); info->dwLargestFreeBlock = status.dwAvailVirtual; info->dwMaxPagesAvailable = info->dwLargestFreeBlock / info->wPageSize; info->dwMaxPagesLockable = info->dwMaxPagesAvailable; info->dwTotalLinearSpace = status.dwTotalVirtual / info->wPageSize; info->dwTotalUnlockedPages = info->dwTotalLinearSpace; info->dwFreePages = info->dwMaxPagesAvailable; info->dwTotalPages = info->dwTotalLinearSpace; info->dwFreeLinearSpace = info->dwMaxPagesAvailable; info->dwSwapFilePages = status.dwTotalPageFile / info->wPageSize; break; } case 0x0501: /* Allocate memory block */ { DWORD size = MAKELONG( CX_reg(context), BX_reg(context) ); BYTE *ptr; TRACE( "allocate memory block (%d bytes)\n", size ); ptr = DPMI_xalloc( size ); if (!ptr) { SET_AX( context, 0x8012 ); /* linear memory not available */ SET_CFLAG(context); } else { SET_BX( context, HIWORD(ptr) ); SET_CX( context, LOWORD(ptr) ); SET_SI( context, HIWORD(ptr) ); SET_DI( context, LOWORD(ptr) ); } break; } case 0x0502: /* Free memory block */ { DWORD handle = MAKELONG( DI_reg(context), SI_reg(context) ); TRACE( "free memory block (0x%08x)\n", handle ); DPMI_xfree( (void *)handle ); } break; case 0x0503: /* Resize memory block */ { DWORD size = MAKELONG( CX_reg(context), BX_reg(context) ); DWORD handle = MAKELONG( DI_reg(context), SI_reg(context) ); BYTE *ptr; TRACE( "resize memory block (0x%08x, %d bytes)\n", handle, size ); ptr = DPMI_xrealloc( (void *)handle, size ); if (!ptr) { SET_AX( context, 0x8012 ); /* linear memory not available */ SET_CFLAG(context); } else { SET_BX( context, HIWORD(ptr) ); SET_CX( context, LOWORD(ptr) ); SET_SI( context, HIWORD(ptr) ); SET_DI( context, LOWORD(ptr) ); } } break; case 0x0507: /* Set page attributes (1.0) */ FIXME( "set page attributes - unimplemented\n" ); break; /* Just ignore it */ case 0x0600: /* Lock linear region */ TRACE( "lock linear region - ignored (no paging)\n" ); break; case 0x0601: /* Unlock linear region */ TRACE( "unlock linear region - ignored (no paging)\n" ); break; case 0x0602: /* Mark real mode region as pageable */ TRACE( "mark real mode region as pageable - ignored (no paging)\n" ); break; case 0x0603: /* Relock real mode region */ TRACE( "relock real mode region - ignored (no paging)\n" ); break; case 0x0604: /* Get page size */ TRACE("get pagesize\n"); SET_BX( context, HIWORD(getpagesize()) ); SET_CX( context, LOWORD(getpagesize()) ); break; case 0x0700: /* Mark pages as paging candidates */ TRACE( "mark pages as paging candidates - ignored (no paging)\n" ); break; case 0x0701: /* Discard pages */ TRACE( "discard pages - ignored (no paging)\n" ); break; case 0x0702: /* Mark page as demand-paging candidate */ TRACE( "mark page as demand-paging candidate - ignored (no paging)\n" ); break; case 0x0703: /* Discard page contents */ TRACE( "discard page contents - ignored (no paging)\n" ); break; case 0x0800: /* Physical address mapping */ FIXME( "physical address mapping (0x%08x) - unimplemented\n", MAKELONG(CX_reg(context),BX_reg(context)) ); break; case 0x0900: /* Get and Disable Virtual Interrupt State */ TRACE( "Get and Disable Virtual Interrupt State: %d\n", get_vm86_teb_info()->dpmi_vif ); SET_AL( context, get_vm86_teb_info()->dpmi_vif ? 1 : 0 ); get_vm86_teb_info()->dpmi_vif = 0; break; case 0x0901: /* Get and Enable Virtual Interrupt State */ TRACE( "Get and Enable Virtual Interrupt State: %d\n", get_vm86_teb_info()->dpmi_vif ); SET_AL( context, get_vm86_teb_info()->dpmi_vif ? 1 : 0 ); get_vm86_teb_info()->dpmi_vif = 1; break; case 0x0902: /* Get Virtual Interrupt State */ TRACE( "Get Virtual Interrupt State: %d\n", get_vm86_teb_info()->dpmi_vif ); SET_AL( context, get_vm86_teb_info()->dpmi_vif ? 1 : 0 ); break; case 0x0e00: /* Get Coprocessor Status (1.0) */ /* * Return status in AX bits: * B0 - MPv (MP bit in the virtual MSW/CR0) * 0 = numeric coprocessor is disabled for this client * 1 = numeric coprocessor is enabled for this client * B1 - EMv (EM bit in the virtual MSW/CR0) * 0 = client is not emulating coprocessor instructions * 1 = client is emulating coprocessor instructions * B2 - MPr (MP bit from the actual MSW/CR0) * 0 = numeric coprocessor is not present * 1 = numeric coprocessor is present * B3 - EMr (EM bit from the actual MSW/CR0) * 0 = host is not emulating coprocessor instructions * 1 = host is emulating coprocessor instructions * B4-B7 - coprocessor type * 00H = no coprocessor * 02H = 80287 * 03H = 80387 * 04H = 80486 with numeric coprocessor * 05H-0FH = reserved for future numeric processors */ TRACE( "Get Coprocessor Status\n" ); SET_AX( context, 69 ); /* 486, coprocessor present and enabled */ break; case 0x0e01: /* Set Coprocessor Emulation (1.0) */ /* * See function 0x0e00. * BX bit B0 is new value for MPv. * BX bit B1 is new value for EMv. */ if (BX_reg(context) != 1) FIXME( "Set Coprocessor Emulation to %d - unimplemented\n", BX_reg(context) ); else TRACE( "Set Coprocessor Emulation - ignored\n" ); break; default: INT_BARF( context, 0x31 ); SET_AX( context, 0x8001 ); /* unsupported function */ SET_CFLAG(context); break; } }
/********************************************************************** * K32WOWCallback16Ex (KERNEL32.55) */ BOOL WINAPI K32WOWCallback16Ex( DWORD vpfn16, DWORD dwFlags, DWORD cbArgs, LPVOID pArgs, LPDWORD pdwRetCode ) { /* * Arguments must be prepared in the correct order by the caller * (both for PASCAL and CDECL calling convention), so we simply * copy them to the 16-bit stack ... */ char *stack = (char *)CURRENT_STACK16 - cbArgs; memcpy( stack, pArgs, cbArgs ); if (dwFlags & (WCB16_REGS|WCB16_REGS_LONG)) { CONTEXT *context = (CONTEXT *)pdwRetCode; if (TRACE_ON(relay)) { DWORD count = cbArgs / sizeof(WORD); WORD * wstack = (WORD *)stack; DPRINTF("%04x:CallTo16(func=%04x:%04x,ds=%04x", GetCurrentThreadId(), context->SegCs, LOWORD(context->Eip), context->SegDs ); while (count) DPRINTF( ",%04x", wstack[--count] ); DPRINTF(") ss:sp=%04x:%04x", SELECTOROF(NtCurrentTeb()->WOW32Reserved), OFFSETOF(NtCurrentTeb()->WOW32Reserved) ); DPRINTF(" ax=%04x bx=%04x cx=%04x dx=%04x si=%04x di=%04x bp=%04x es=%04x fs=%04x\n", (WORD)context->Eax, (WORD)context->Ebx, (WORD)context->Ecx, (WORD)context->Edx, (WORD)context->Esi, (WORD)context->Edi, (WORD)context->Ebp, (WORD)context->SegEs, (WORD)context->SegFs ); SYSLEVEL_CheckNotLevel( 2 ); } if (context->EFlags & 0x00020000) /* v86 mode */ { EXCEPTION_REGISTRATION_RECORD frame; frame.Handler = vm86_handler; errno = 0; __wine_push_frame( &frame ); __wine_enter_vm86( context ); __wine_pop_frame( &frame ); if (errno != 0) /* enter_vm86 will fall with ENOSYS on x64 kernels */ { WARN("__wine_enter_vm86 failed (errno=%d)\n", errno); if (errno == ENOSYS) SetLastError(ERROR_NOT_SUPPORTED); else SetLastError(ERROR_GEN_FAILURE); return FALSE; } } else { /* push return address */ if (dwFlags & WCB16_REGS_LONG) { stack -= sizeof(DWORD); *((DWORD *)stack) = HIWORD(call16_ret_addr); stack -= sizeof(DWORD); *((DWORD *)stack) = LOWORD(call16_ret_addr); cbArgs += 2 * sizeof(DWORD); } else { stack -= sizeof(SEGPTR); *((SEGPTR *)stack) = call16_ret_addr; cbArgs += sizeof(SEGPTR); } /* * Start call by checking for pending events. * Note that wine_call_to_16_regs overwrites context stack * pointer so we may modify it here without a problem. */ if (get_vm86_teb_info()->dpmi_vif) { context->SegSs = wine_get_ds(); context->Esp = (DWORD)stack; insert_event_check( context ); cbArgs += (DWORD)stack - context->Esp; } _EnterWin16Lock(); wine_call_to_16_regs( context, cbArgs, call16_handler ); _LeaveWin16Lock(); } if (TRACE_ON(relay)) { DPRINTF("%04x:RetFrom16() ss:sp=%04x:%04x ", GetCurrentThreadId(), SELECTOROF(NtCurrentTeb()->WOW32Reserved), OFFSETOF(NtCurrentTeb()->WOW32Reserved)); DPRINTF(" ax=%04x bx=%04x cx=%04x dx=%04x bp=%04x sp=%04x\n", (WORD)context->Eax, (WORD)context->Ebx, (WORD)context->Ecx, (WORD)context->Edx, (WORD)context->Ebp, (WORD)context->Esp ); SYSLEVEL_CheckNotLevel( 2 ); } } else { DWORD ret; if (TRACE_ON(relay)) { DWORD count = cbArgs / sizeof(WORD); WORD * wstack = (WORD *)stack; DPRINTF("%04x:CallTo16(func=%04x:%04x,ds=%04x", GetCurrentThreadId(), HIWORD(vpfn16), LOWORD(vpfn16), SELECTOROF(NtCurrentTeb()->WOW32Reserved) ); while (count) DPRINTF( ",%04x", wstack[--count] ); DPRINTF(") ss:sp=%04x:%04x\n", SELECTOROF(NtCurrentTeb()->WOW32Reserved), OFFSETOF(NtCurrentTeb()->WOW32Reserved) ); SYSLEVEL_CheckNotLevel( 2 ); } /* push return address */ stack -= sizeof(SEGPTR); *((SEGPTR *)stack) = call16_ret_addr; cbArgs += sizeof(SEGPTR); /* * Actually, we should take care whether the called routine cleans up * its stack or not. Fortunately, our wine_call_to_16 core doesn't rely on * the callee to do so; after the routine has returned, the 16-bit * stack pointer is always reset to the position it had before. */ _EnterWin16Lock(); ret = wine_call_to_16( (FARPROC16)vpfn16, cbArgs, call16_handler ); if (pdwRetCode) *pdwRetCode = ret; _LeaveWin16Lock(); if (TRACE_ON(relay)) { DPRINTF("%04x:RetFrom16() ss:sp=%04x:%04x retval=%08x\n", GetCurrentThreadId(), SELECTOROF(NtCurrentTeb()->WOW32Reserved), OFFSETOF(NtCurrentTeb()->WOW32Reserved), ret); SYSLEVEL_CheckNotLevel( 2 ); } } return TRUE; /* success */ }