home *** CD-ROM | disk | FTP | other *** search
/ The Developer Connection…ice Driver Kit for OS/2 3 / DEV3-D1.ISO / devtools / toolkt21 / c / os2h / vdd / vpmx2.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-12  |  21.4 KB  |  588 lines
  1. /***************************************************************************
  2. *
  3. * Module Name: vpmx2.h
  4. *
  5. *
  6. * Copyright (c) 1993  IBM Corporation
  7. *
  8. *
  9. *      DPMI host per task data
  10. *
  11. *      Description:
  12. *
  13. *      Contains the vpm definitions
  14. *
  15. */
  16. #pragma checkout( suspend )
  17.    #ifndef __CHKHDR__
  18.       #pragma checkout( suspend )
  19.    #endif
  20. #pragma checkout( resume )
  21.  
  22. #ifndef VPMX2DEFINED
  23.  
  24. #define VPMX2DEFINED
  25.  
  26. #define VPMDBG_X  0x00010000    /* Execute   */
  27. #define VPMDBG_W  0x00020000    /* Write     */
  28. #define VPMDBG_R  0x00030000    /* ReadWrite */
  29.  
  30. /* Definitions used to determine if DPX initialization was successful */
  31. #define     VPMINITOK      0x01              // VDPX and DPMI initialized OK
  32. #define     DPXLEAVEV86    0x02              // DPX will switch VDM into VPM
  33.  
  34. /***ET+ PFNVPMDBGWPALLOCVDM - allocate a watchpoint for a VDM
  35.  *
  36.  *      This type is a pointer to a function that allocates
  37.  *      a local watchpointfor the current VDM process.
  38.  *
  39.  *      (*PFNVPMDBGALLOCVDM) (laddr, cb, type, piwp)
  40.  *
  41.  *      ENTRY   laddr           - linear address of watchpoint
  42.  *              cb              - size of watchpoint (1, 2, or 4 bytes)
  43.  *              type            - type of watchpoint
  44.  *              piwp            - place to return watchpoint index
  45.  *      RETURN  int             - return code (NO_ERROR if successful)
  46.  */
  47. typedef INT (*PFNVPMDBGWPALLOCVDM)(ULONG,ULONG,ULONG,PULONG);
  48. /*end*/
  49.  
  50. /***ET+ PFNVPMDBGWPFREEVDM - free a watchpoint for a VDM
  51.  *
  52.  *      This type is a pointer to a function that frees
  53.  *      a local watchpointfor the current VDM process.
  54.  *
  55.  *      (*PFNVPMDBGWPFREEVDM) (iwp)
  56.  *
  57.  *      ENTRY   iwp             - watchpoint index
  58.  *      RETURN  int             - return code (NO_ERROR if successful)
  59.  */
  60. typedef INT (*PFNVPMDBGWPFREEVDM)(ULONG);
  61. /*end*/
  62.  
  63. /***ET+ PFNVPMDBGDR6QUERYVDM - query/update DR6 for a VDM process
  64.  *
  65.  *      This type is a pointer to a function that is used to query
  66.  *      bits B0-B3 in DR6 for the current VDM process.  It is also
  67.  *      used to reset any of those bits.
  68.  *
  69.  *      (*PFNVPMDBGDR6QUERYVDM) (flquery, flreset, pfl)
  70.  *
  71.  *      ENTRY   flquery         - bit mask of bits to query
  72.  *              flreset         - bit mask of bits to reset
  73.  *              pfl             - place to return bits
  74.  *      RETURN  int             - return code (NO_ERROR if successful)
  75.  */
  76. typedef INT (*PFNVPMDBGDR6QUERYVDM)(ULONG,ULONG,PULONG);
  77. /*end*/
  78.  
  79. /***ET+ PFNVPMSELCREATEVDMLDT - allocate an LDT for a VDM
  80.  *
  81.  *      This type is a pointer to a function that allocates
  82.  *      an LDT object for a DPMI VDM process.
  83.  *
  84.  *      This routine must be called in the context of the VDM we are
  85.  *      allocating the LDT for.
  86.  *
  87.  *      (*PFNVPMSELCREATEVDMLDT) (pladdr)
  88.  *
  89.  *      ENTRY:  pladdr - pointer to location to return
  90.  *                       pointer to the new ldt
  91.  *      EXIT:   NO_ERROR if success, else error code
  92.  *
  93.  */
  94. typedef INT (*PFNVPMSELCREATEVDMLDT)(PVOID*);
  95. /*end*/
  96.  
  97. /***ET+ PFNVPMSELDESTROYVDMLDT - free VDM protected mode LDT
  98.  *
  99.  *      This type is a pointer to a function that frees the
  100.  *      VDM's protected mode LDT.
  101.  *
  102.  *      (*PFNVPMSELDESTROYVDMLDT) ()
  103.  *
  104.  *      ENTRY   NONE
  105.  *
  106.  *      EXIT    NONE
  107.  *
  108.  *      CONTEXT VDM Task
  109.  *
  110.  */
  111. typedef VOID (*PFNVPMSELDESTROYVDMLDT)(VOID);
  112. /*end*/
  113.  
  114. /***ET+ PFNVPMSELALLOCVDM - allocate consecutive LDT selectors
  115.  *
  116.  *      This type is a pointer to a function that returns "csel"
  117.  *      consecutive free selectors from the current process's LDT.
  118.  *
  119.  *      (*PFNVPMSELALLOCVDM) (csel,psel)
  120.  *
  121.  *      ENTRY:  csel - number of contiguous selectors to allocate.
  122.  *              psel - on entry: if *psel == -1, allocate any selector,
  123.  *                            otherwise allocate that specific selector
  124.  *      EXIT:   NO_ERROR if success, else error code
  125.  */
  126. typedef INT (*PFNVPMSELALLOCVDM)(ULONG,PSEL);
  127. /*end*/
  128.  
  129. /***ET+ PFNVPMSELFREEVDM - free a DPMI LDT selector
  130.  *
  131.  *      This type is a pointer to a function that marks a single LDT
  132.  *      selector in the current process as free.
  133.  *
  134.  *      (*PFNVPMSELFREEVDM) (sel)
  135.  *
  136.  *      ENTRY:  sel - selector to free
  137.  *      EXIT:   NO_ERROR if success, else error
  138.  */
  139. typedef INT (*PFNVPMSELFREEVDM)(SEL);
  140. /*end*/
  141.  
  142. /***ET+ VPMVMINF - data returned by *PFNVPMSELGETVDMINFO */
  143.  
  144. typedef struct vpmvminfo_s {
  145.         ULONG  vpmsel_linmax;       /* top linear address in user space   */
  146.         ULONG  vpmsel_cphysranges;  /* number of entries in array below   */
  147.         PULONG vpmsel_physranges;   /* pointer to array of physical frame */
  148. } VPMINF;
  149.  
  150. typedef VPMINF *PVPMINF;
  151. /*end*/
  152.  
  153. /***ET+ PFNVPMSELGETVDMINFO - return memory manager info for VDM use
  154.  *
  155.  *      This type is a pointer to a function that fills in the
  156.  *      vpmvminfo_s structure.
  157.  *
  158.  *      (*PFNVPMSELGETVDMINFO) (psvi)
  159.  *
  160.  *      ENTRY:  psvi - pointer to vpmvminfo_s struction to fill in
  161.  *      EXIT:   none
  162.  */
  163. typedef INT (*PFNVPMSELGETVDMINFO)(PVPMINF);
  164. /*end*/
  165.  
  166. /***ET+ PFNVPMPGMOVE - move page table entries.
  167.  *
  168.  *      This type is a pointer to a function that moves page table
  169.  *      entries in the virtual address space. The destination must
  170.  *      invalid pages.
  171.  *
  172.  *      Locked pages cannot be moved and will cause an internal error.
  173.  *
  174.  *      (*PFNVPMPGMOVE) (pagesrc, dummy1, pagedst, dummy2, npages, hob)
  175.  *
  176.  *      ENTRY   pagesrc - source virtual page
  177.  *              reserved - must be NULL
  178.  *              pagedst - destination virtual page
  179.  *              reserved - must be NULL
  180.  *              npages - number of pages
  181.  *              hob - object handle for destination
  182.  *      EXIT    0 on success, else error code
  183.  */
  184. typedef INT (*PFNVPMPGMOVE)(ULONG,PVOID,ULONG,PVOID,INT,USHORT);
  185. /*end*/
  186.  
  187. /***ET+ PFNVPMPGGETACCESS - query access permissions for range of pages
  188.  *
  189.  *      This type is a pointer to a function that returns the permission
  190.  *      bits for a range of pages in a byte array. The high bit of the
  191.  *      byte is set if the page is unallocated. The caller must verify that
  192.  *      the buffer is of the correct size and accessible.
  193.  *
  194.  *      (*PFNVPMPGGETACCESS) (page, reserved, npages, flags, pbuf)
  195.  *
  196.  *      ENTRY:  page - target virtual page number
  197.  *              reserved - must be NULL
  198.  *              npages - number of pages to query
  199.  *              flags - VPMPG_SKIPFREE
  200.  *                      - do not stop when invalid page is found
  201.  *              pbuf - pointer to return array of bytes
  202.  *      EXIT:   0 if success, else error code
  203.  */
  204. typedef INT (*PFNVPMPGGETACCESS)(ULONG,PVOID,INT,INT,PCHAR);
  205. /*end*/
  206.  
  207. /***ET+ PFNVPMPGALLOCSIZEQUERY - return number of allocatable pages.
  208.  *
  209.  *      This type is a pointer to a function that returns the number
  210.  *      of pages the page manager believes could be allocated as swappable.
  211.  *      The returned value approximates a snapshot of reality and should
  212.  *      only be used as a guide; its accuracy is not to be relied upon.
  213.  *
  214.  *      This routine is swappable.
  215.  *
  216.  *      (*PFNVPMPGALLOCSIZEQUERY) (pnpages)
  217.  *
  218.  *      ENTRY   pnpages - pointer to unitialized integer
  219.  *      EXIT    0 on success
  220.  *                  *pnpages = number of pages believed to be allocatable
  221.  *              else error code
  222.  *
  223.  */
  224. typedef INT (*PFNVPMPGALLOCSIZEQUERY)(PINT);
  225. /*end*/
  226.  
  227. /* Structures and defines for *PFNVPMVMALLOCMEM */
  228.  
  229. /***ET+ VPMVMAC - VPMVMAllocMem packet structure */
  230.  
  231. typedef struct vpmvmac_s {
  232.         ULONG  vpmac_va;            /* Object's virtual address */
  233.         USHORT vpmac_res;           /* Reserved */
  234.         USHORT vpmac_hob;           /* Object's handle */
  235. } VPMVMAC;
  236.  
  237. typedef VPMVMAC *PVPMVMAC;
  238. /*end*/
  239.  
  240. /* VPMPG_W, VPMPG_U,VPMPG_X, VPMPG_R  - see v8086.h */
  241. #define VPMPG_SWAPPABLE    0x00000000      /* Swappable */
  242. #define VPMVMAC_OBSHIFT    23              /* Object record flag shift */
  243. #define VPMOB_SHRINKABLE   0x0001          /* Object is Shrinkable */
  244. #define VPMVMAC_OBSHRINK   ((LONG) VPMOB_SHRINKABLE << VPMVMAC_OBSHIFT)
  245. #define VPMVMAC_ALIGNPAGE  0x18000000L     /* Page alignment */
  246. #define VPMVMAC_ARENAPRV   0x02000000L     /* Private arena */
  247. #define VPMVMAC_LOCABOVE   0x40000000L     /* Allocate above address */
  248. #define VPMVMAC_LOCSPECIFIC 0x80000000L    /* Allocate at specific address */
  249. #define VPMVMAC_VDM        (0x00040000L)   /* VDM allocation */
  250. #define VPMVMFM_VDM        (0x00000004L)   /* Request on behalf of VDM */
  251.  
  252. //c-begin
  253. /***ET+ PFNVPMVMALLOCMEM - Reserve/commit virtual memory
  254.  *
  255.  *      This type is a pointer to a function that is used
  256.  *      to allocate virtual address space and optionally commit
  257.  *      physical storage to a contiguous region of the address
  258.  *      space beginning at the base of the object.
  259.  *
  260.  *      WARNING: This function is in swappable code.
  261.  *
  262.  *      (*PFNVPMVMALLOCMEM) (cb, cbCommit, fl, dummy1, dummy2, dummy3,
  263.  *                                              dummy4, dummy5, pac)
  264.  *
  265.  *      ENTRY  cb          - Size of virtual memory object in
  266.  *                           bytes.  This may not be changed
  267.  *                           subsequently.  Note that the size
  268.  *                           will be rounded up to page
  269.  *                           granularity, by adding the offset of
  270.  *                           the specific base address (if any)
  271.  *                           and rounding the result up to a
  272.  *                           multiple of the page size (4K).
  273.  *             cbCommit    - Amount of physical storage to be
  274.  *                           committed to contiguous virtual
  275.  *                           space  starting from the base of the
  276.  *                           object.
  277.  *             fl          - Allocation flags (see notes below)
  278.  *             reserved    - Must be NULL.
  279.  *             reserved    - Must be NULL.
  280.  *             reserved    - Must be NULL.
  281.  *             reserved    - Must be NULL.
  282.  *             reserved    - Must be NULL.
  283.  *             pac         - Address of output buffer.
  284.  *                           The buffer has the following format:
  285.  *
  286.  *                         struct vpmvmac_s
  287.  *                           {
  288.  *                             ulong_t ac_va;
  289.  *                             - Base virtual address
  290.  *                               A specific base virtual address
  291.  *                               or minimum base virtual address
  292.  *                               may be requested by setting its
  293.  *                               value here and specifying
  294.  *                               VPMVMAC_LOCSPECIFIC/VPMVMAC_LOCANY in
  295.  *                               the allocation flags.  The base
  296.  *                               address is rounded down to the
  297.  *                               nearest page boundary.  In all
  298.  *                               cases, the actual base address
  299.  *                               allocated to the object is
  300.  *                               returned.
  301.  *                             VMHOB ac_hob;
  302.  *                             - Object's handle
  303.  *                               The handle allocated to the object
  304.  *                               is returned.
  305.  *                             SEL dummy;
  306.  *                           }
  307.  *
  308.  *      EXIT            int       - Result code (NO_ERROR if successful)
  309.  *
  310.  *      NOTES on flags usage and calling VMAllocMem
  311.  *
  312.  *      (1) Give information about the base virtual address
  313.  *          of the object
  314.  *
  315.  *          VPMVMAC_LOCABOVE  - Base address must be above that given
  316.  *                              Not valid for heap allocs.
  317.  *
  318.  *      (2) Indicate the alignment of the base address
  319.  *          (4K page alignment is enforced; input addresses,
  320.  *          byte counts will be rounded automatically so that
  321.  *          the actual region allocated contains the whole of
  322.  *          its first and last page)
  323.  *
  324.  *          VPMVMAC_ALIGNPAGE - Page granularity
  325.  *
  326.  *      (3) Specify properties of object.
  327.  *
  328.  *          VPMVMAC_OBSHRINK  - Object is shrinkable
  329.  *          (physical commitment only, not virtual address space)
  330.  *
  331.  *      (4) Specify Page Manager information
  332.  *
  333.  *          Select one of each of the VPMPG_ state flags
  334.  *          and zero or more VPMPG_ permission and modifier flags.
  335.  *
  336.  */
  337. typedef INT (*PFNVPMVMALLOCMEM)(ULONG,ULONG,ULONG,USHORT,USHORT,USHORT, \
  338.                 ULONG,ULONG,PVPMVMAC);
  339. /*end*/
  340. //c-end
  341. //masm-begin
  342. /* DefType PFNVPMVMALLOCMEM,dd */
  343. //masm-end
  344.  
  345. #define VPMVMS_COMMIT      (0x00100000L)    /* Commit physical storage */
  346. #define VPMVMS_DECOMMIT    (0x00080000L)    /* Reserved for VMS_DECOMMIT */
  347. #define VPMVMS_DFLTPERM    VPMVMAC_LOCABOVE /* Use (initial) permissions */
  348. #define VPMPG_SKIPFREE     0x00008000       /* ignore free pages */
  349.  
  350. /***ET+ PFNVPMVMSETMEM - Commit/Decommit/Set Protection for Region
  351.  *
  352.  *      This type is a pointer to a function that performs one of three
  353.  *      functions:
  354.  *
  355.  *      Commit memory resources for region
  356.  *      Decommit memory resources for region
  357.  *      Set protection for memory region
  358.  *
  359.  *      Attempts to commit memory that is already committed
  360.  *      will return error.
  361.  *
  362.  *      WARNING: This procedure is in swappable code
  363.  *
  364.  *      (*PFNVPMVMSETMEM) (p, cb, reserved, fl, blkno)
  365.  *
  366.  *      ENTRY   p           - region's virtual address
  367.  *              cb          - region's size in bytes
  368.  *              reserved            - must be NULL
  369.  *              fl          - flags
  370.  *                            VPMVMS_COMMIT
  371.  *                              Commit memory resources
  372.  *                              NOTE:  The Page Manager storage
  373.  *                                     type and state must also be
  374.  *                                     specified using the appropriate
  375.  *                                     VPMPG_x and PAS_y flags, see
  376.  *                                     pgexport.h.
  377.  *                            VPMVMS_DECOMMIT
  378.  *                              Decommit memory resources
  379.  *                            VPMVMS_DFLTPERM
  380.  *                              Set access permissions to the default
  381.  *                              value (initial).
  382.  *                            VPMPG_SKIPFREE
  383.  *                              Ignore non-committed pages when setting
  384.  *                              access permissions or decommitting.  If
  385.  *                              not specified, attempting to decommit or
  386.  *                              set access permissions on uncommitted memory
  387.  *                              will return error.
  388.  *              dumm1       - reserved and must be 0.
  389.  *
  390.  *      RETURN  int         - return code (NO_ERROR if successful)
  391.  */
  392. typedef INT (*PFNVPMVMSETMEM)(ULONG,ULONG,USHORT,ULONG,ULONG);
  393. /*end*/
  394.  
  395. /***ET+ PFNVPMVMFREEMEM - Free reference to an object given base address.
  396.  *
  397.  *      This type is a pointer to a function that frees a reference to an
  398.  *      object from a given context given the base virtual address of the
  399.  *      object.
  400.  *
  401.  *      If there are memory resources committed to the region, they are freed
  402.  *      To decommit memory resources without dereserving address space a task
  403.  *      must use the VPMVMSetMem function.
  404.  *
  405.  *      WARNING: This function is in swappable code
  406.  *
  407.  *      (*PFNVPMVMFREEMEM) (p, reserved, fl)
  408.  *
  409.  *      ENTRY   p           - region's virtual address
  410.  *              reserved    - must be NULL
  411.  *              fl          - Flags
  412.  *                            VPMVMFM_VDM - call on behalf of VDM
  413.  *      RETURN  int         - Result code
  414.  *                              NO_ERROR = success
  415.  *                              non-zero = failure
  416.  *                              NOTE: ERROR_INTERRUPT will not
  417.  *                              be returned.  All free operations
  418.  *                              ignore interrupts.
  419.  *
  420.  */
  421. typedef INT (*PFNVPMVMFREEMEM)(ULONG,USHORT,ULONG);
  422. /*end*/
  423.  
  424.  
  425. /***ET+ PFNVPMDPMITASKSWITCH - report task switch
  426.  *
  427.  *      This type is a pointer to a function that reports a DPMI
  428.  *      task switch.
  429.  *
  430.  *      (*PFNVPMDPMITASKSWITCH) (pdhd)
  431.  *
  432.  *      ENTRY:  pdhd - pointer to new task
  433.  *      EXIT:   NONE
  434.  *
  435.  *
  436.  */
  437. typedef VOID (*PFNVPMDPMITASKSWITCH)(PVOID);
  438. /*end*/
  439.  
  440.  /* Definitions for the possible values returned in vpmx_CpuType */
  441. #define VPMCPU_286            0               /* processor is a 286 */
  442. #define VPMCPU_386            1               /* processor is a 386 */
  443. #define VPMCPU_486            2               /* processor is a 486 */
  444.  
  445. /***ET+ PFNVPMPGSWAP - note that page can be swapped out
  446.  *
  447.  *      This type is a pointer to a function that receives
  448.  *      notification that a page can be swapped.  The
  449.  *      kernel can choose to ignore the call or it can
  450.  *      arrange to swap out the page.
  451.  *
  452.  *      (*PFNVPMPGSWAP)(ipg, cpg)
  453.  *
  454.  *      ENTRY:  ipg      - target virtual page number
  455.  *              npages   - number of pages to query
  456.  *
  457.  *      EXIT:   NONE
  458.  */
  459. typedef VOID (*PFNVPMPGSWAP)(ULONG,ULONG);
  460. /*end*/
  461.  
  462. /***ET+ PFNVPMPGDISCARD - note that page can be discarded
  463.  *
  464.  *      This type is a pointer to a function that receives
  465.  *      notification that a page can be discarded.  The
  466.  *      kernel can choose to ignore the call or it can
  467.  *      free the page and mark it as allocated on access.
  468.  *
  469.  *      (*PFNVPMPGDISCARD)(ipg, cpg)
  470.  *
  471.  *      ENTRY:  ipg      - target virtual page number
  472.  *              npages   - number of pages to query
  473.  *
  474.  *      EXIT:   NONE
  475.  */
  476. typedef VOID (*PFNVPMPGDISCARD)(ULONG,ULONG);
  477. /*end*/
  478.  
  479. /***ET+ PFNVPMPGMAPPHYS - map physical page
  480.  *
  481.  *      This type is a pointer to a function that receives
  482.  *      requests to map physical pages in the VDM for
  483.  *      use by the client.  The kernel can decide whether
  484.  *      honoring a request is safe and refuse to honor
  485.  *      those that are not.
  486.  *
  487.  *      (*PFNVPMPGMAPPHYS)(pladdr, ulPhys, cb)
  488.  *
  489.  *      ENTRY:  pladdr    - pointer to target linear address
  490.  *                          *pladdr == -1 means any arbitrary address
  491.  *                          (must be on page boundary)
  492.  *              ulPhys    - physical address to map
  493.  *              cb        - count of bytes
  494.  *
  495.  *      EXIT:   TRUE     - indicates success
  496.  *              FALSE    - indicates request was refused
  497.  */
  498. typedef BOOL (*PFNVPMPGMAPPHYS)(PULONG,ULONG,ULONG);
  499. /*end*/
  500.  
  501. /***ET+ PFNVPMNPXSTATUS - get NPX status
  502.  *
  503.  *      This type is a pointer to a function that returns
  504.  *      the information passed back for DPMI 1.0 function
  505.  *      0E01H.
  506.  *
  507.  *      (*PFNVPMNPXSTATUS)(pfl)
  508.  *
  509.  *      ENTRY:  pfl       - pointer to flags variable
  510.  *
  511.  *      EXIT:   TRUE     - indicates success
  512.  *                  *pfl filled as follows (see DPMI 1.0 spec)
  513.  *                      bit 0 set == coprocessor enabled for client
  514.  *                      bit 1 set == client is emulating
  515.  *                      bit 2 set == numeric coprocessor is present
  516.  *                      bit 3 set == host is emulating coprocessor
  517.  *                      bits 4-7  == 00h nocoprocessor
  518.  *                                   02h 80287
  519.  *                                   03h 80387
  520.  *                                   04h 80486 with coprocessor
  521.  *                      bits 8-31 == 0
  522.  *              FALSE    - indicates request was refused
  523.  */
  524. typedef BOOL (*PFNVPMNPXSTATUS)(PULONG);
  525. /*end*/
  526.  
  527. /***ET+ PFNVPMNPXSET - set NPX status
  528.  *
  529.  *      This type is a pointer to a function that turns
  530.  *      emulation on or off for a protect mode client.
  531.  *
  532.  *      (*PFNVPMNPXSET)(fl)
  533.  *
  534.  *      ENTRY:  fl       - flags variable
  535.  *                         bit 0 reset == disable coprocessor (ignore)
  536.  *                         bit 0 set   == enable coprocessor  (ignore)
  537.  *                         bit 1 reset == turn EM bit off
  538.  *                         bit 1 set   == turn EM bit on
  539.  *
  540.  *      EXIT:   TRUE     - indicates success
  541.  *              FALSE    - indicates request was refused
  542.  */
  543. typedef BOOL (*PFNVPMNPXSET)(ULONG);
  544. /*end*/
  545.  
  546. /***ET+ VPMEXP - kernel exports to DPMI VDD for VDHRegisterDPMI
  547.  *
  548.  *      These entry points are passed from the kernel during the
  549.  *      exchange of entry points in VDHRegisterDPMI.
  550.  */
  551. typedef struct vpmx_s {
  552. PFNVPMDBGWPALLOCVDM        vpmx_DBGWPAllocVDM;
  553. PFNVPMDBGWPFREEVDM         vpmx_DBGWPFreeVDM;
  554. PFNVPMDBGDR6QUERYVDM       vpmx_DBGDR6QueryVDM;
  555. PFNVPMSELCREATEVDMLDT      vpmx_SELCreateVdmLDT;
  556. PFNVPMSELDESTROYVDMLDT     vpmx_SELDestroyVdmLDT;
  557. PFNVPMSELALLOCVDM          vpmx_SELAllocVdm;
  558. PFNVPMSELFREEVDM           vpmx_SELFreeVdm;
  559. PFNVPMSELGETVDMINFO        vpmx_SELGetVdmInfo;
  560. PFNVPMPGMOVE               vpmx_PGMove;
  561. PFNVPMPGGETACCESS          vpmx_PGGetAccess;
  562. PFNVPMPGALLOCSIZEQUERY     vpmx_PGAllocSizeQuery;
  563. PFNVPMVMALLOCMEM           vpmx_VMAllocMem;
  564. PFNVPMVMSETMEM             vpmx_VMSetMem;
  565. PFNVPMVMFREEMEM            vpmx_VMFreeMem;
  566. PFNVPMDPMITASKSWITCH       vpmx_em86DPMITaskSwitch;
  567. ULONG                      vpmx_SEL_VDM_LDT_INCR;
  568. ULONG                      vpmx_CpuType;
  569. ULONG                      vpmx_MaxAppLinAddr;
  570. ULONG                      vpmx_V86StackSize;
  571. PFNVPMPGSWAP               vpmx_pfnVPMPgSwap;
  572. PFNVPMPGDISCARD            vpmx_pfnVPMPgDiscard;
  573. PFNVPMPGMAPPHYS            vpmx_pfnVPMPgMapPhys;
  574. PFNVPMNPXSTATUS            vpmx_pfnVPMNpxStatus;
  575. PFNVPMNPXSET               vpmx_pfnVPMNpxSet;
  576. } VPMX;      /* vpmx */
  577.  
  578. typedef VPMX *PVPMX;  /* pvpmx */
  579. /*end*/
  580.  
  581. #endif
  582.  
  583. #pragma checkout( suspend )
  584.    #ifndef __CHKHDR__
  585.       #pragma checkout( resume )
  586.    #endif
  587. #pragma checkout( resume )
  588.