/*** VDMM.H * * For include file hierarchy, see MVDM.H * * VDMM exports * * Description: * VDM Manager Exported Definitions */ /****************************************/ /* VDMM Defines */ /****************************************/ #define CURRENT_VDM ((HVDM)0) /***ET+ VDHAllocMem: flOptions */ #define VDHAM_FIXED 0x0000 #define VDHAM_SWAPPABLE 0x0001 /*end*/ /***ET+ VDHAllocPage: flOptions values */ #define VDHAP_SPECIFIC 0x0001 #define VDHAP_SYSTEM 0x0002 #define VDHAP_FIXED 0x0004 #define VDHAP_SWAPPABLE 0x0000 #define VDHAP_PHYSICAL 0x0008 /*end*/ /***ET+ VDHMapPages: flOptions values */ #define VDHMT_INVALID 0x0001 #define VDHMT_LINEAR 0x0002 #define VDHMT_PHYSICAL 0x0003 #define VDHMT_BLACK_HOLE 0x0004 /*end*/ /***ET+ VDHInstallFaultHook: flOptions values */ #define VDHIFH_ADDR 0x0001 /*end*/ /***ET+ VDHAllocMem Flags: flOptions Value */ #define VDHCBP_SWAPPABLE 0x0001 /*end*/ /***ET+ VDHSetPriority: flClass values */ #define VDHSP_NO_CHANGE 0x00000000 #define VDHSP_IDLE 0x00000001 #define VDHSP_REGULAR 0x00000002 #define VDHSP_TIME_CRITICAL 0x00000003 #define VDHSP_SERVER 0x00000004 #define VDHSP_SIMULATED_INTERRUPT 0x00000005 #define VDHSP_CLASS_MASK 0x0000ffff #define VDHSP_NUM_CLASSES 5 #define VDHSP_DEFAULT_ACTION 0x00000000 #define VDHSP_START_USE 0x00010000 #define VDHSP_CONTINUE_USE 0x00020000 #define VDHSP_END_USE 0x00030000 #define VDHSP_ACTION_MASK 0xffff0000 /*end*/ /***ET+ VDHYield - flags */ #define VDH_YIELD_TIME_CRITICAL 1 /*end*/ /***ET+ VDHLockMem flags - flOptions */ #define VDHLM_RESIDENT 0x0000 #define VDHLM_READ 0x0001 #define VDHLM_WRITE 0x0002 #define VDHLM_CONTIGUOUS 0x0004 #define VDHLM_NOBLOCK 0x0008 #define VDHLM_16M 0x0010 #define VDHLM_NO_ADDR -1 /*end*/ #define VDH_FAILURE 0 #define VDH_SUCCESS 1 /***ET+ VDM States and VDD Exit defines * * These are VDM states for which VDDs get notification. Few of them * like PDB_* are not truely VDM state changes but they are useful * events for which few VDDs may be intereseted. For arguments passed * and callable contexts see VDHInstallUserHook. */ #define VDM_CREATE 0 /* A VDM is being created */ #define VDM_TERMINATE 1 /* A VDM is being terminated */ #define VDM_FOREGROUND 2 /* A VDM coming to foreground */ #define VDM_BACKGROUND 3 /* A VDM going to background */ #define VDD_EXIT 4 /* MVDM shutting down */ #define VDM_VDD_CREATE_DONE 5 /* Called Soon after VDM_CREATE */ #define VDM_PDB_DESTROY 6 /* A PDB destroyed in a VDM */ #define VDM_PDB_CHANGE 7 /* A new PDB is switched to */ #define VDM_CODEPAGE_CHANGE 8 /* A new code page is activated */ #define VDM_TITLE_CHANGE 9 /* VDM Title change event */ #define VDM_MEMORY_MAPPED_IN 10 /* Memory mapped in */ #define VDM_MEMORY_UN_MAPPED 11 /* Memory unmapped */ #define VDM_CREATE_DONE 12 /* VDM created successfully */ /*end*/ /***ET+ VDHPopup Flags */ #define VDHP_FAIL 0x0001 #define VDHP_TERMINATE_SESSION 0x0002 #define VDHP_RETRY 0x0004 #define VDHP_IGNORE 0x0008 /*end*/ /***ET+ VDHOpen: ActionTaken Flags */ #define VDHOPEN_FILE_EXISTED 0x0001 #define VDHOPEN_FILE_CREATED 0x0002 #define VDHOPEN_FILE_TRUNCATED 0x0003 /*end*/ /***ET+ VDHOpen: FileAttribute Flags */ #define VDHOPEN_FILE_NORMAL 0x0000 #define VDHOPEN_FILE_READONLY 0x0001 #define VDHOPEN_FILE_HIDDEN 0x0002 #define VDHOPEN_FILE_SYSTEM 0x0004 #define VDHOPEN_FILE_DIRECTORY 0x0010 #define VDHOPEN_FILE_ARCHIVED 0x0020 /*end*/ /***ET+ VDHOpen: OpenFlag Flags */ #define VDHOPEN_FILE_OPEN 0x0001 #define VDHOPEN_FILE_REPLACE 0x0002 #define VDHOPEN_FILE_CREATE 0x0010 /* this nibble applies if file already exists xxxx */ #define VDHOPEN_ACTION_FAIL_IF_EXISTS 0x0000 /* ---- ---- ---- 0000 */ #define VDHOPEN_ACTION_OPEN_IF_EXISTS 0x0001 /* ---- ---- ---- 0001 */ #define VDHOPEN_ACTION_REPLACE_IF_EXISTS 0x0002 /* ---- ---- ---- 0010 */ /* this nibble applies if file does not exist xxxx */ #define VDHOPEN_ACTION_FAIL_IF_NEW 0x0000 /* ---- ---- 0000 ---- */ #define VDHOPEN_ACTION_CREATE_IF_NEW 0x0010 /* ---- ---- 0001 ---- */ /*end*/ /***ET+ VDHOpen: OpenMode Flags */ #define VDHOPEN_ACCESS_READONLY 0x0000 /* ---- ---- ---- -000 */ #define VDHOPEN_ACCESS_WRITEONLY 0x0001 /* ---- ---- ---- -001 */ #define VDHOPEN_ACCESS_READWRITE 0x0002 /* ---- ---- ---- -010 */ #define VDHOPEN_SHARE_DENYREADWRITE 0x0010 /* ---- ---- -001 ---- */ #define VDHOPEN_SHARE_DENYWRITE 0x0020 /* ---- ---- -010 ---- */ #define VDHOPEN_SHARE_DENYREAD 0x0030 /* ---- ---- -011 ---- */ #define VDHOPEN_SHARE_DENYNONE 0x0040 /* ---- ---- -100 ---- */ #define VDHOPEN_FLAGS_NOINHERIT 0x0080 /* ---- ---- 1--- ---- */ #define VDHOPEN_FLAGS_NO_LOCALITY 0x0000 /* ---- -000 ---- ---- */ #define VDHOPEN_FLAGS_SEQUENTIAL 0x0100 /* ---- -001 ---- ---- */ #define VDHOPEN_FLAGS_RANDOM 0x0200 /* ---- -010 ---- ---- */ #define VDHOPEN_FLAGS_RANDOMSEQUENTIAL 0x0300 /* ---- -011 ---- ---- */ #define VDHOPEN_FLAGS_NO_CACHE 0x1000 /* ---1 ---- ---- ---- */ #define VDHOPEN_FLAGS_FAIL_ON_ERROR 0x2000 /* --1- ---- ---- ---- */ #define VDHOPEN_FLAGS_WRITE_THROUGH 0x4000 /* -1-- ---- ---- ---- */ #define VDHOPEN_FLAGS_DASD 0x8000 /* 1--- ---- ---- ---- */ #define VDHOPEN_FLAGS_NONSPOOLED 0x00040000 /*end*/ /***ET+ VDHSeek: ultype options */ #define VDHSK_ABSOLUTE 0 #define VDHSK_CURRENT_POSITION 1 #define VDHSK_END_OF_FILE 2 /*end*/ /***ET+ VDHPhysicalDisk: functions */ #define VDHPHYD_GET_DISKS 1 #define VDHPHYD_GET_HANDLE 2 #define VDHPHYD_RELEASE_HANDLE 3 /*end*/ /***ET+ VDHCreateSem Flags */ #define VDH_EVENTSEM 0x0000 #define VDH_MUTEXSEM 0x0001 /*end*/ /***ET+ VDHArmTimerHook Flags */ #define VDH_TIMER_INTERRUPT_HOOK ((HVDM)1) #define VDH_TIMER_GLOBAL_CONTEXT ((HVDM)-1) /***ET+ VDHQuerySysValue ordinals */ /* Global Values Ordinal Type Units Range */ #define VDHGSV_DAY 0 // ULONG days 1 <= x <= 31 #define VDHGSV_MONTH 1 // ULONG months 1 <= x <= 12 #define VDHGSV_YEAR 2 // ULONG years 1980 <= x <= MAXULONG #define VDHGSV_DAYOFWEEK 3 // ULONG days 0 <= x <= 6 #define VDHGSV_HOUR 4 // ULONG hours 0 <= x < 24 #define VDHGSV_MINUTE 5 // ULONG minutes 0 <= x < 60 #define VDHGSV_SECOND 6 // ULONG secs 0 <= x < 60 #define VDHGSV_HUNDREDTH 7 // ULONG 1/100s 0 <= x < 100 #define VDHGSV_SECONDS1970 8 // ULONG secs 0 <= x <= MAXULONG #define VDHGSV_TIMEZONE 9 // ULONG minutes 0 <= x <= MAXULONG #define VDHGSV_MSECSBOOT 10 // ULONG ms 0 <= x <= MAXULONG #define VDHGSV_TIMERINTERVAL 11 // ULONG ms 0 <= x <= 1000 #define VDHGSV_DYNVARIATION 12 // BOOL TRUE/FALSE #define VDHGSV_MAXWAIT 13 // ULONG secs 0 <= x <= MAXULONG #define VDHGSV_MINTIMESLICE 14 // ULONG ms 0 <= x <= MAXULONG #define VDHGSV_MAXTIMESLICE 15 // ULONG ms 0 <= x <= MAXULONG #define VDHGSV_YIELD 16 // BOOL TRUE/FALSE #define VDHGSV_TCYIELD 17 // BOOL TRUE/FALSE #define VDHGSV_VERMAJOR 18 // ULONG 0 <= x <= MAXULONG #define VDHGSV_VERMINOR 19 // ULONG 0 <= x <= MAXULONG #define VDHGSV_VERREVISION 20 // CHAR A <= x <= Z #define VDHGSV_MACHINETYPE 21 // ULONG MACHINE_TYPE_* #define VDHGSV_BLACKHOLEADDR 22 // PVOID bytes 0 <= x <= MAXULONG #define VDHGSV_BLACKHOLESIZE 23 // ULONG bytes 0 <= x <= MAXULONG #define VDHGSV_FGNDSESSIONID 24 // ULONG 0 <= x < MAXSESSIONS #define VDHGSV_MAXFPSESSIONS 25 // ULONG //TO BE DELETED #define VDHGSV_MAXWPSESSIONS 26 // ULONG //TO BE DELETED #define VDHGSV_MAXPMSESSIONS 27 // ULONG //TO BE DELETED #define VDHGSV_RESERVESESSIONS 28 // Reserved //TO BE DELETED #define VDHGSV_ARPLADDR 29 // ULONG #define VDHGSV_MACHINEINFO 30 // ULONG ptr to System Configuration Table #define VDHGSV_PPOSREGS 31 // ULONG pointer to POS Regs structure #define VDHGSV_PICMASK 32 // ULONG original PIC mask values 6.13 /* if you add a new entry, please update GSVMAX in src\dos\mvdm\vdmvdh.h */ /* Local Values Ordinal Type Units Range */ #define VDHLSV_HVDM 4096 // HVDM #define VDHLSV_PID 4097 // PID #define VDHLSV_PCRF 4098 // PCRF #define VDHLSV_SESSIONID 4099 // ULONG N <= x < MAXSESSIONS #define VDHLSV_FOREGROUND 4100 // BOOL TRUE/FALSE #define VDHLSV_RMSIZE 4101 // ULONG kbytes 0 < x <= 640 #define VDHLSV_CODEPAGEID 4102 // ULONG See DosGetCP #define VDHLSV_PRIORITYCLASS 4103 // ULONG See VDHSetPriority #define VDHLSV_PRIORITYLEVEL 4104 // ULONG See VDHSetPriority #define VDHLSV_VPICBASE 4105 // UCHAR[4] /* * Locations of base vectors in PIC base vector array returned from * VDHQuerySysValue */ #define VPMMASTER_PORT_INDEX 0 #define VPMSLAVE_PORT_INDEX 1 /*end*/ /***ET+ Return values for VDHGSV_MACHINETYPE */ #define MACHINE_TYPE_AT 1 #define MACHINE_TYPE_PS2 2 #define MACHINE_TYPE_PARKCITY 3 /*end*/ /***ET+ Timeout values for semaphore services */ #define SEM_INDEFINITE_WAIT -1 #define SEM_IMMEDIATE_RETURN 0 /*end*/ /***ET+ VDD-to_PDD commands (used internally during VDHOpenPDD) */ #define PDDCMD_REGISTER 0 // to register VDD entry point with PDD #define PDDCMD_DEREGISTER 1 // To deregister a VDD at MVDM shutdown /*end*/ /*** VDHDecodeProperty defines ***/ #define VDH_DP_DECIMAL 10 #define VDH_DP_HEX 16 /****************************************/ /* VDMM Data Types */ /****************************************/ /***ET+ MISC VDMM data types */ typedef HANDLE HVDM; typedef HVDM *PHVDM; typedef HANDLE HBLOCK; // Block pool handle typedef ULONG HLOCK; // Memory lock handle typedef ULONG HVDD; // VDD Handle typedef PSZ *PPSZ; // Pointer to PSZ typedef HVDD *PHVDD; // VDD Handle Pointer typedef ULONG VDHSEM; // It should be VOID typedef VDHSEM *HVDHSEM; // but vddvdh.inc has typedef HVDHSEM *PHVDHSEM; // problems with it typedef VOID (* HOOKENTRY PFAULTHOOK)(PVDM); typedef VOID (* HOOKENTRY PTIMERHOOK)(ULONG); /*end*/ /***ET+ HHOOK - hook handle * * This is the handle return from the VDHAllocHook and used with * the VDHArm functions. */ typedef PVOID HHOOK; // hook handle typedef HHOOK *PHHOOK; // pointer to hook handle /*end*/ /***ET+ Pointer types for VDD-PDD communication and V86 address manipulation */ #define FAR16 NEAR // (pseudo 16:16 modifier) typedef VOID FAR16 *F16PVOID; // f16p (pseudo 16:16 pointer) #define FARV86 NEAR // (pseudo-V86 modifier) typedef VOID FARV86 *VPVOID; // vp (pseudo-V86 pointer) typedef VPVOID FAR *PVPVOID; // pvp /*end*/ //c-begin #define F16PNULL ((F16PVOID)0) #define F16PFROMP(p) ((F16PVOID)(((ULONG)VDHQuerySel(p)<<16) | (USHORT)(p))) #define F16PFROMSSP(p) ((F16PVOID)(((ULONG)VDHQuerySel(SSToDS(p))<<16) | (USHORT)(p))) //c-end /***ET+ FNPDD - PDD function for "standard" VDD-to-PDD communication * * ENTRY * ulFun - function code * * ul1 - function-specific; * if a pointer, it will generally be 16:16, and * will generally be an input buffer, the first * word of which is the length of the entire buffer * * ul2 - function-specific; * if a pointer, it will generally be 16:16, and * will generally be an output buffer, the first * word of which is the length of the entire buffer * * if uFunc == PDDCMD_REGISTER (from VDM Manager during VDHOpenPDD) * ul1.off == VDD's CS * ul1.sel == zero * ul2.off == low 16-bits of EIP for VDD entry point * ul2.sel == high 16-bits of EIP for VDD entry point * * EXIT * SUCCESS * !0 * FAILURE * 0 (the nature of the failure, such as an error code, * if needed, should be returned in the ul2 output buffer) * * CALLING CONVENTIONS * 32-bit PASCAL calling conventions. More specifically: * * Parameters are pushed on the stack from left to right, and are * removed by the callee. The callee preserves EBX, ESI, EDI, EBP, * DS and ES. Assuming the PDD function is completely 16-bit * (with the exception of any 16:32 calls back to the VDD, and the * 16:32 RETFD to return to the VDD), the high words of all the * extended registers are preserved by virtue of being unused by the * PDD. Therefore, only BX, SI, DI, BP, DS and ES need to be explicitly * preserved. * * Furthermore, the PDD is responsible for loading its own DS. To * do this, it must have a word in its code segment fixed-up to contain * its data segment selector. * * The return code from the PDD must be in AX; 0 implies failure, * whereas a non-zero (generally meaningful) value implies success. */ typedef SBOOL (* PDDENTRY FPFNPDD)(ULONG, F16PVOID, F16PVOID); /* fpfnpdd */ /*end*/ /***ET+ FNVDD - VDD function for "standard" PDD-to-VDD communication * * ENTRY * ulFun - function code * * ul1 - function-specific; * if a pointer, it will generally be 16:16, and * will generally be an input buffer, the first * word of which is the length of the entire buffer * * ul2 - function-specific; * if a pointer, it will generally be 16:16, and * will generally be an output buffer, the first * word of which is the length of the entire buffer * * EXIT * SUCCESS * !0 * FAILURE * 0 (the nature of the failure, such as an error code, * if needed, should be returned in the ul2 output buffer) * * CALLING CONVENTIONS * 32-bit PASCAL calling conventions. More specifically: * * Parameters are pushed on the stack from left to right, and are * removed by the callee. The callee must preserve EBX, ESI, EDI, EBP, * DS and ES. * * Furthermore, the VDD is responsible for loading its own DS and ES. * In C, this would be a "_loadds" function (or any function in a module * compiled with the Au rather than Aw option). * * The return code from the VDD must be in AX; 0 implies failure, * whereas a non-zero (generally meaningful) value implies success. */ typedef SBOOL (* VDDENTRY FPFNVDD)(ULONG, F16PVOID, F16PVOID); /* fpfnvdd */ /*end*/ #define VDDREQ_PASS -1 /***ET+ FNSYSREQ - DOS32RequestVDD VDD function-type * * ENTRY * sgid - screen group * ulFun - function code * nbIn - Input buffer size, in bytes (0 if no input buffer) * pIn - Input buffer * nbOut - Output buffer size, in bytes (0 if no output buffer) * pOut - Output buffer * EXIT * SUCCESS * Zero * FAILURE * Error code, or -1 to pass control to next VDD * * CALLING CONVENTIONS * 32-bit small-model PASCAL calling conventions. More specifically: * * Parameters are pushed on the stack from left to right, and are * removed by the callee. The callee will preserve EBX, ESI, EDI, EBP, * DS and ES. DS is assumed to contain the callee's DGROUP selector * on entry. EAX must be set to the return code on exit. */ typedef LONG (* EXPENTRY PFNSYSREQ)(SGID, ULONG, ULONG, PVOID, ULONG, PVOID); /*end*/ /***ET+ FNDEVREQ - VDHRequestVDD VDD function-type * * ENTRY * hvdm - handle to vdm * ulFun - function code * ul1 - function-specific; * if a pointer, it will generally be 0:32, and * will generally be an input buffer; if the size of the * buffer is not implied, the first dword of the buffer should * contain a total size * ul2 - function-specific; * if a pointer, it will generally be 0:32, and * will generally be an output buffer; if the size of the * buffer is not implied, the first dword of the buffer should * contain a total size * EXIT * SUCCESS * Non-zero value (other than -1) * FAILURE * FALSE, or -1 to pass control to next VDD (in the first case, * the VDD should use VDHSetError to describe the error condition) * * CALLING CONVENTIONS * 32-bit small-model PASCAL calling conventions. More specifically: * * Parameters are pushed on the stack from left to right, and are * removed by the callee. The callee will preserve EBX, ESI, EDI, EBP, * DS and ES. DS is assumed to contain the callee's DGROUP selector * on entry. EAX must be set to the return code on exit. */ typedef LONG (* EXPENTRY PFNDEVREQ)(HVDM, ULONG, PVOID, PVOID); /*end*/ /***ET+ PFNVDHRP - VDD property function * * This function performs property setting and validation. * * The set operation may be requested at any time after a VDM is created. * * The Validation operation may be requested at any time (even before * the a VDM is created. Validation will be requested only for * VDMP_STRING and VDMP_MLSTR types, since all other types can be * validated using the information supplied by VDHRegisterProperty. * * ENTRY op = Operation to perform (enumeration) * VDHPROP_VALIDATE * Validate property for any process. Only called * for VDMP_STRING and VDMP_MLSTR properties. * VDHPROP_SET * Set an already validated property for specified * HVDM. The return code is ignored. * hvdm = Handle of VDM. Undefined if op = VDHPROP_VALIDATE. * cb = Count of bytes pointed to by pch. * Value depends upon proptype: * VDMPROP_BOOL * Undefined. * VDMPROP_INT * Undefined. * VDMPROP_ENUM * Length of ASCIIZ string, including NULL terminator. * VDMPROP_STRING * Length of ASCIIZ string, including NULL terminator. * VDMPROP_MLSTR * Length of ASCIIZ string, including NULL terminator. * * pch = Value to set/validate. * The format depends on the proptype: * VDMPROP_BOOL * pch is interpreted as a BOOL. * Value 0 is FALSE; !0 is TRUE. * VDMPROP_INT * pch is interpreted as a ULONG. It is guaranteed * to meet the registered bounds. * VDMPROP_ENUM * pch points to an ASCIIZ string. It is guaranteed * to be one of the registered enumeration strings. * VDMPROP_STRING * pch points to an ASCIIZ string. It is guaranteed * to be less than or equal to the registered maximum * string length. * VDMPROP_MLSTR * pch points to an ASCIIZ string. Multiple lines * are separated by a line feed (0x0A). It is * guaranteed to be less than or equal to the * registered maximum string length. * * * EXIT-SUCCESS * returns 0 * * EXIT-FAILURE * returns non-zero error code * ERROR_INVALID_DATA * This should be returned if the value is not valid. * * CONTEXT * Task */ typedef ULONG (* EXPENTRY PFNVDHRP)(ULONG, HVDM, ULONG, PSZ); /*end*/ /***ET+ PENUMHOOK - VDD hooks for VDHEnumerateVDMs * * ENTRY * hvdm - VDM handle * ulData - Handler data * * EXIT * SUCCESS * TRUE * FAILURE * FALSE * * CALLING CONVENTIONS * 32-bit small-model PASCAL calling conventions. More specifically: * * Parameters are pushed on the stack from left to right, and are * removed by the callee. The callee will preserve EBX, ESI, EDI, EBP, * DS and ES. DS is assumed to contain the callee's DGROUP selector * on entry. EAX must be set to the return code on exit. */ typedef BOOL (* HOOKENTRY PENUMHOOK)(HVDM,ULONG); /* penumh */ /*end*/ /***ET+ USERHOOK - VDD user-event-hook function * * ENTRY * hvdm - VDM handle * * EXIT * SUCCESS * !0 * FAILURE * 0 (failure is only support for the VDM_CREATE hook, and * implies that the VDD cannot support/sustain another VDM). * * CALLING CONVENTIONS * 32-bit small-model PASCAL calling conventions. More specifically: * * Parameters are pushed on the stack from left to right, and are * removed by the callee. The callee will preserve EBX, ESI, EDI, EBP, * DS and ES. DS is assumed to contain the callee's DGROUP selector * on entry. EAX must be set to the return code on exit. */ typedef BOOL (* HOOKENTRY PUSERHOOK)(); /* puserh */ /*end*/ /***ET+ VDHPAGELIST - structure to describe dis-contiguous physical ranges * for VDHLockMem * * vdhpl_paddr - base physical address of one range * vdhpl_cb - bytes contiguously mapped from vdhpl_paddr */ typedef struct VDHPageList_s { /* vdhpl */ ULONG vdhpl_paddr; ULONG vdhpl_cb; } VDHPAGELIST; typedef VDHPAGELIST *PVDHPAGELIST; /* pvdhpl */ /***ET+ VDHMAPTARGET - target area definition for VDHMapPages * * vdhmt_laddr - Target address in V86-space (0 <= vdhmt_laddr < 1M+64K) * to be mapped. * vdhmt_cpg - Count of pages to map * vdhmt_hmap - Mapping handle */ typedef struct VDHMapTarget_s { /* vdhmt */ ULONG vdhmt_laddr; // address in v86-space for mapping ULONG vdhmt_cpg; // count of pages to map ULONG vdhmt_hmap; // handle of mapping. Must be zero on first call // to VDHMapPages for region. } VDHMAPTARGET; typedef VDHMAPTARGET *PVDHMAPTARGET; /* pvdhmt */ /*end*/ /***ET+ VDHMAPSOURCE - source area definition for VDHMapPages * * vdhms_laddr - Source address to be mapped. * vdhms_hobj - Object handle. */ typedef struct VDHMapSource_s { /* vdhms */ ULONG vdhms_laddr; // linear address of source memory object ULONG vdhms_hobj; // memory object handle } VDHMAPSOURCE; typedef VDHMAPSOURCE *PVDHMAPSOURCE; /* pvdhms */ /*end*/ /***ET+ VDHQuerySem: SemState structure */ typedef struct VDHSemState_s { UCHAR vss_SemType; // VDH_EVENTSEM/VDH_MUTEXSEM UCHAR vss_fOwned; // 0 -> Not Owned; 1 -> Owned USHORT vss_fWaiter; // 0 -> No one waiting; 1 -> Waiting USHORT vss_cRequest; // request count in mutex case TID vss_tid; // tid of the owner if owned }VDHSEMSTATE; typedef VDHSEMSTATE *PVDHSEMSTATE; /*end*/ /* Defines for POS Registers */ #define POS_MAX_SIZE 8 // Count of POS registers #define POS_MAX_SLOT 8 // Maximum number of slots in machine #define POS_CEN_ARB_REG 0x90 // Central Arbitration register #define POS_SEL_FDBK_REG 0x91 // Card Selected Feedback #define POS_SYS_CTRLA_REG 0x92 // System Control Port A #define POS_SYS_SETUP_REG 0x94 // System setup/enable register #define POS_ADP_SETUP_REG 0x96 // Adapter setup/enable register #define POS_BASE_REG 0x100 // Base POS register #define POS_TOP_REG 0x107 // Highest POS Register #define POS_NULLPORT 0xFF // null value for ports not active #define POS_CARDFEEDBACK 0xFE // pretend to send back card selected #define POS_PLANAR_SELECT 0x80 // port 94 bit value to select planar #define POS_VIDEO_SELECT 0x20 // port 94 bit value to select video #define POS_OPTION_SELECT 0x08 // port 96 bit value to select card /* Structure for POS Registers */ typedef struct _POS_s { BYTE aPOSReg[POS_MAX_SIZE]; } POS_s; typedef POS_s *PPOS; typedef struct _POSREGS { POS_s VideoPOS; // Video POS data POS_s PlanarPOS; // Planar POS data POS_s SlotPOS[POS_MAX_SLOT]; // Adapter POS data BYTE Port90; // Central Arbiter BYTE Port92; // System Control Port A BYTE Port94; // System setup/enable reg BYTE Port96; // Adapter setup/enable reg } POSREGS; typedef POSREGS *PPOSREGS; typedef struct _SYS_CONFIG_TABLE { USHORT Reserve; // Reserved BYTE Model; // Model byte BYTE Submodel; // Submodel byte BYTE BIOS_revision; // BIOS revision level BYTE Reserve1; // Reserved BYTE Reserve2; // Reserved BYTE Reserve3; // Reserved BYTE Reserve4; // Reserved BYTE Reserve5; // Reserved } SYS_CONFIG_TABLE; typedef SYS_CONFIG_TABLE *PSYS_CONFIG_TABLE; /* VDD initialization routine prototype */ BOOL EXPENTRY VDDInit(PSZ); /****************************************/ /* VDMM Macros */ /****************************************/ /* Accessing VDM data: * * If the context is the desired VDM, then the following works for * ROM BIOS data area access, using the dynamically-fixed-up-to-zero * VDMBase data structure: * * VDMBase.rb_field = 0; * * For instance data, if you put all of it inside a structure, the instance * of which is VDMData, and create a type, PVDMDATA, that points to such a * structure, you can reference instance data like so: * * VDMData.fFgnd = TRUE; * * And if you have a PVOID (p) created with PFROMVP or PFROMVADDR, use: * * *(PBYTE)p = 0; * * * If the context is NOT the desired VDM, then you have to use the * VDM's handle (hvdm). For ROM BIOS data area access, use the "pVDMBase" * macro: * * pVDMBase(hvdm)->rb_field = 0; * * For instance data, reference similarly with the "pVDMData" macro: * * pVDMData(hvdm)->fFgnd = TRUE; * * And if you have a PVOID (p) created with PFROMVP or PFROMVADDR, you can * use the "pVDM" macro to convert the pointer to one that is valid for the * given VDM and of the given type: * * *pVDM(hvdm,PBYTE,p) = 0; * * An alternative to "pVDMData" (but not preferred, because it is less * maintainable and overrides type-checking) if you don't want to put all * your instance data in a structure, is: * * REFHVDM(hvdm,BOOL,VDMData.fFgnd) = TRUE; * * Note that for any *resident* instance data, the same guidelines apply; * simply substitute VDMRESDATA for VDMDATA. */ //c-begin // To reference pre-defined VDM data (ie, ROM BIOS stuff) with an hvdm #define pVDMBase(hvdm) ((PVDMBASE)(hvdm)) // To reference instance data with an hvdm #define pVDMData(hvdm) ((PVDMDATA)((ULONG)&VDMData+(ULONG)(hvdm))) #define pVDMResData(hvdm) ((PVDMRESDATA)((ULONG)&VDMResData+(ULONG)(hvdm))) // To reference arbitrary VDM data with an hvdm and arbitrary pointer #define pVDM(hvdm,type,p) ((type)((PBYTE)(p)+(ULONG)(hvdm))) // To dereference an instance variable with a hvdm (not preferred) #define REFHVDM(hvdm,type,var) (*((type *)((PBYTE)&(var) + (ULONG)(hvdm)))) #ifdef VDHSTRICT #define ASSERTTASK VDHAssertTask() #define ASSERTVDMTASK VDHAssertVDMTask() #define ASSERTTASKONLY VDHAssertTaskOnly() #define ASSERTVDMTASKONLY VDHAssertVDMTaskOnly() #define ASSERTINITONLY VDHAssertInitOnly() #define CHECKHVDM(hvdm) VDHCheckHVDM(hvdm) #else #define ASSERTTASK // #define ASSERTVDMTASK // #define ASSERTTASKONLY // #define ASSERTVDMTASKONLY // #define ASSERTINITONLY // #define CHECKHVDM(hvdm) // #endif //c-end //masm-begin //ifdef VDHSTRICT // ASSERTTASK macro // PCall VDHAssertTask // endm // ASSERTVDMTASK macro // PCall VDHAssertVDMTask // endm // ASSERTTASKONLY macro // PCall VDHAssertTaskOnly // endm // ASSERTVDMTASKONLY macro // PCall VDHAssertVDMTaskOnly // endm // ASSERTINITONLY macro // PCall VDHAssertInitOnly // endm // CHECKHVDM macro hvdm // PCall VDHCheckHVDM, hvdm // endm //else // ASSERTTASK macro // endm // ASSERTVDMTASK macro // endm // ASSERTTASKONLY macro // endm // ASSERTVDMTASKONLY macro // endm // ASSERTINITONLY macro // endm // CHECKHVDM macro hvdm // endm //endif //masm-end /****************************************/ /* VDMM Function Prototype */ /****************************************/ // Memory Management Function Prototypes PVOID VDHENTRY VDHAllocMem(ULONG cb, ULONG flOptions); VOID VDHENTRY VDHFreeMem(PVOID); PVOID VDHENTRY VDHAllocDosMem(ULONG cb); HBLOCK VDHENTRY VDHCreateBlockPool(ULONG cbBlock, ULONG flOptions); PVOID VDHENTRY VDHAllocBlock(HBLOCK); VOID VDHENTRY VDHFreeBlock(HBLOCK,PVOID); VOID VDHENTRY VDHDestroyBlockPool(HBLOCK); VOID VDHENTRY VDHCopyMem(PVOID,PVOID,ULONG); BOOL VDHENTRY VDHExchangeMem(PVOID,PVOID,ULONG); HLOCK VDHENTRY VDHLockMem(PVOID,ULONG,ULONG,PVOID,PVOID); VOID VDHENTRY VDHUnlockMem(HLOCK); SEL VDHENTRY VDHQuerySel(PVOID); PVOID VDHENTRY VDHQueryLin(F16PVOID); SEL VDHENTRY VDHCreateSel(PVOID,ULONG); VOID VDHENTRY VDHDestroySel(SEL); ULONG VDHENTRY VDHGetCodePageFont(ULONG,ULONG,PPVOID); VOID VDHENTRY VDHReleaseCodePageFont(PVOID); // Page Management Function Prototypes PVOID VDHENTRY VDHAllocPages(PVOID,ULONG,ULONG); PVOID VDHENTRY VDHReallocPages(PVOID,ULONG,ULONG); VOID VDHENTRY VDHFreePages(PVOID); PVOID VDHENTRY VDHFindFreePages(PVOID,PULONG); ULONG VDHENTRY VDHGetDirtyPageInfo(HVDM,PVOID,ULONG); ULONG VDHENTRY VDHQueryFreePages(VOID); BOOL VDHENTRY VDHReservePages(PVOID,ULONG); VOID VDHENTRY VDHUnreservePages(PVOID,ULONG); BOOL VDHENTRY VDHMapPages(PVDHMAPSOURCE,PVDHMAPTARGET,ULONG); BOOL VDHENTRY VDHInstallFaultHook(HVDM,PVOID,ULONG,PFAULTHOOK,BOOL); VOID VDHENTRY VDHRemoveFaultHook(HVDM,PVOID,ULONG,PFAULTHOOK); PVOID VDHENTRY VDHAllocDMABuffer(ULONG,BOOL,PULONG); VOID VDHENTRY VDHFreeDMABuffer(PVOID); // Inter-DD Communication Function Prototypes FPFNPDD VDHENTRY VDHOpenPDD(PSZ,FPFNVDD); BOOL VDHENTRY VDHRegisterVDD(PSZ,PFNSYSREQ,PFNDEVREQ); HVDD VDHENTRY VDHOpenVDD(PSZ); VOID VDHENTRY VDHCloseVDD(HVDD); BOOL VDHENTRY VDHRequestVDD(HVDD,HVDM,ULONG,PVOID,PVOID); ULONG VDHENTRY VDHGetError(VOID); VOID VDHENTRY VDHSetError(ULONG); BOOL VDHENTRY VDHInstallUserHook(ULONG,PUSERHOOK); BOOL VDHENTRY VDHEnumerateVDMs(PENUMHOOK,ULONG); HVDM VDHENTRY VDHHandleFromSGID(SGID); HVDM VDHENTRY VDHHandleFromPID(PID); //TO BE DELETED ULONG VDHENTRY VDHQuerySysValue(HVDM,ULONG); VOID VDHENTRY VDHPutSysValue(ULONG,ULONG); BOOL VDHENTRY VDHOpen(PSZ,PHFILE,PULONG,ULONG,ULONG,ULONG,ULONG,PVOID); VOID VDHENTRY VDHClose(HFILE); ULONG VDHENTRY VDHRead(HFILE,PVOID,ULONG); ULONG VDHENTRY VDHWrite(HFILE,PVOID,ULONG); ULONG VDHENTRY VDHSeek(HFILE,ULONG,ULONG); BOOL VDHENTRY VDHDevIOCtl(HFILE,ULONG,ULONG,PVOID,ULONG,PULONG,PVOID,ULONG,PULONG); BOOL VDHENTRY VDHPhysicalDisk(ULONG,PULONG,ULONG,PULONG,ULONG); // Semaphore Function Prototypes BOOL VDHENTRY VDHCreateSem(PHVDHSEM, ULONG); VOID VDHENTRY VDHDestroySem(HVDHSEM); VOID VDHENTRY VDHQuerySem(HVDHSEM,PVDHSEMSTATE); VOID VDHENTRY VDHResetEventSem(HVDHSEM); VOID VDHENTRY VDHPostEventSem(HVDHSEM); BOOL VDHENTRY VDHWaitEventSem(HVDHSEM,ULONG); BOOL VDHENTRY VDHRequestMutexSem(HVDHSEM,ULONG); VOID VDHENTRY VDHReleaseMutexSem(HVDHSEM); // Timer Function Prototypes VOID VDHENTRY VDHArmTimerHook(HHOOK,ULONG,HVDM); BOOL VDHENTRY VDHDisarmTimerHook(HHOOK); // Sound Function Prototypes BOOL VDHENTRY VDHDevBeep(ULONG, ULONG); // Property Function Prototypes BOOL VDHENTRY VDHRegisterProperty(PSZ,PSZ,ULONG,VPTYPE,VPORD,ULONG,PVOID,PVOID,PFNVDHRP); ULONG VDHENTRY VDHQueryProperty(PSZ); BOOL VDHENTRY VDHDecodeProperty(PPSZ,PULONG,PULONG,ULONG); // Process Control Function Prototypes BOOL VDHENTRY VDHPopup(PSZZ,ULONG,ULONG,PULONG,ULONG,PSZ); VOID VDHENTRY VDHKillVDM(HVDM); VOID VDHENTRY VDHHaltSystem(VOID); VOID VDHENTRY VDHSetPriority(HVDM,ULONG,LONG); //TO BE "FIXED" BOOL VDHENTRY VDHFreezeVDM(HVDM); VOID VDHENTRY VDHThawVDM(HVDM); BOOL VDHENTRY VDHIsVDMFrozen(HVDM); VOID VDHENTRY VDHYield(BOOL); // Perfview Prototypes INT VDHENTRY VDHRegisterPerfCtrs(PBYTE,PBYTE,ULONG); // Miscellaneous Function Prototypes (for kernel debugging only) VOID VDHENTRY VDHAssertTask(VOID); VOID VDHENTRY VDHAssertVDMTask(VOID); VOID VDHENTRY VDHAssertTaskOnly(VOID); VOID VDHENTRY VDHAssertVDMTaskOnly(VOID); VOID VDHENTRY VDHAssertInitOnly(VOID); VOID VDHENTRY VDHCheckHVDM(HVDM); INT CENTRY VDHPanic(PCHAR, ...); VOID VDHENTRY VDHSetTimer0(ULONG); //c-begin #define PANIC VDHPanic //c-end //masm-begin //;*** PANICXX - Issue a panic if condition XX is set //; //; ENTRY //; msg quoted error message //; //; EXAMPLES //; PANIC <"VPICSetVIRR: invalid handle %u">, //; //; or //; //; IFDEF VDDSTRICT //; or ebx,ebx //; PANICZ <"em86ReflectInt: null pointer"> //; ENDIF //; // //?PANIC macro cond,msg,args // local l1,szMsg // ifndef VDHPanic // DefCode IMPORT,GLOBAL,C // DefFn VDHPanic // EndCode // endif // ifnb // j&cond short l1 // endif // ?a substr ,1,1 // % ifidn ,<"> // DefData LOCAL,CONST,C // SZ szMsg, // EndData // CallFn VDHPanic,,args // else // CallFn VDHPanic,,args // endif // ifnb //l1: // endif // endm // //PANIC equ //PANICC equ //PANICNC equ //PANICZ equ //PANICNZ equ //PANICE equ //PANICNE equ //PANICB equ //PANICBE equ //PANICA equ //PANICAE equ //masm-end #ifdef VDDDEBUG INT CENTRY printf(PCHAR, ...); //c-begin #define PRINTDEBUG printf //c-end //masm-begin //PRINTDEBUG macro msg,args // local szMsg // ifndef printf // DefCode IMPORT,GLOBAL,C // DefFn printf // EndCode // endif // ?a substr ,1,1 // % ifidn ,<"> // DefData LOCAL,CONST,C // SZ szMsg, // EndData // CallFn printf,< , > // else // CallFn printf,< , > // endif // endm //masm-end #else //c-begin #define PRINTDEBUG(x) //c-end //masm-begin //PRINTDEBUG macro msg // endm //masm-end #endif