[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [RFC PATCH 6/7] xeniface: Expose batch foreign page mappings to user mode


  • To: Rafał Wojdyła <omeg@xxxxxxxxxxxxxxxxxxxxxx>, win-pv-devel@xxxxxxxxxxxxxxxxxxxx
  • From: Tu Dinh <ngoc-tu.dinh@xxxxxxxxxx>
  • Date: Sun, 22 Nov 2026 18:16:59 +0100
  • Authentication-results: eu.smtp.expurgate.cloud; dkim=pass header.s=selector1 header.d=vates.tech header.i="@vates.tech" header.h="From:Subject:Date:Message-ID:To:Cc:MIME-Version:Content-Type:In-Reply-To:References:Feedback-ID"
  • Cc: Rafał Wojdyła <omeg@xxxxxxx>
  • Delivery-date: Sun, 22 Nov 2026 17:17:06 +0000
  • Feedback-id: default:8631fc262581453bbf619ec5b2062170:Sweego
  • List-id: Developer list for the Windows PV Drivers subproject <win-pv-devel.lists.xenproject.org>

On 10/11/2026 19:37, Rafał Wojdyła wrote:
> From: Rafał Wojdyła <omeg@xxxxxxx>
> 
> Add buffered IOCTLs and synchronous xencontrol wrappers for creating
> a mapping, mapping and unmapping batches, obtaining a user view, destroying
> an empty mapping and transferring whole mapping cleanup to the driver.
> 
> Use opaque 64-bit IDs scoped to the creating process and open file object.
> Validate counts, ranges, flags and exact buffer lengths, and deliver batch
> status separately from page-level NTSTATUS values. Keep successful maps
> after partial failures so clients can retry only failed slots; unmaps may
> retry the original range and revoke the whole user view before any attempt.
> 
> Fix notification settings at creation and retain channels owned by the same
> file. Clear the notification byte before removing a view and notify the
> retained channel only after mapping destruction, including deferred cleanup.
> 
> Allow UnmapPages to invalidate the ID and hand remaining cleanup and retries
> to the driver for empty, partial or full mappings of any supported size.
> Success acknowledges release ownership, not completion of all Xen unmaps;
> port notification follows destruction of that mapping only. Keep the result-
> bearing batch teardown operations available for explicit continuation.
> 
> Keep the xencontrol buffers and OVERLAPPED event alive until completion, and
> release a returned ID if response validation fails.

With the new mapping-based API, mapped views are not bound to an IRP any 
more. This is unsafe because the handle could have been shared across 
multiple processes. While GnttabAllocateContext holds a reference to the 
process context, this is not sufficient because once the process has 
died, it's already too late to call MmUnmapLockedPages. The 
LLM-suggested fix is to release the mapping from a process notify 
routine instead.

> 
> Assisted-by: LLM
> Signed-off-by: Rafał Wojdyła <omeg@xxxxxxxxxxxxxxxxxxxxxx>
> ---
>   include/xencontrol.h        | 144 ++++++++++++++++++
>   include/xeniface_ioctls.h   | 160 +++++++++++++++++++-
>   src/xencontrol/xencontrol.c | 209 ++++++++++++++++++++++++++
>   src/xeniface/ioctl_gnttab.c | 286 ++++++++++++++++++++++++++++++++++++
>   src/xeniface/ioctls.c       |  28 +++-
>   src/xeniface/ioctls.h       |  65 ++++++++
>   6 files changed, 890 insertions(+), 2 deletions(-)
> 
> diff --git a/include/xencontrol.h b/include/xencontrol.h
> index 4b916ec..348bc44 100644
> --- a/include/xencontrol.h
> +++ b/include/xencontrol.h
> @@ -263,6 +263,150 @@ XcGnttabUnmapForeignPages(
>       _In_ PVOID                  Address
>       );
>   
> +/*! \brief Create an empty mapping for foreign memory pages
> +    \param Xc Xencontrol handle returned by XcOpen()
> +    \param RemoteDomain ID of a remote domain that has granted access to the 
> pages
> +    \param NumberPages Number of 4k pages in the mapping, from 1 to 
> XENIFACE_GNTTAB_MAPPING_COUNT_MAX
> +    \param NotifyOffset Offset of a byte in the mapped region that will be 
> set to 0 when the view is removed, if enabled
> +    \param NotifyPort Local port number of an open event channel that will 
> be notified after mapping destruction, if enabled
> +    \param Flags Map and notification options
> +    \param Id Opaque mapping ID
> +    \return Win32 error code
> +
> +    The batched mapping functions complete synchronously. Mapping IDs are 
> scoped
> +    to \a Xc and its creating process. Populate the mapping with 
> XcGnttabMapBatch(),
> +    then obtain a user-mode view with XcGnttabCreateUserView(). The caller 
> must
> +    stop all memory accesses before releasing the entire mapping with
> +    XcGnttabUnmapPages(). Closing \a Xc also releases every remaining mapping
> +    through the driver's cleanup/retry path.
> +
> +    The notification byte is cleared when a view is removed, and the retained
> +    event channel is notified after the mapping is destroyed.
> +*/
> +XENCONTROL_API
> +_Success_(return == ERROR_SUCCESS)
> +DWORD
> +XcGnttabCreateMapping(
> +    _In_ PXENCONTROL_CONTEXT        Xc,
> +    _In_ USHORT                     RemoteDomain,
> +    _In_ ULONG                      NumberPages,
> +    _In_ ULONG                      NotifyOffset,
> +    _In_ ULONG                      NotifyPort,
> +    _In_ XENIFACE_GNTTAB_PAGE_FLAGS Flags,
> +    _Out_ ULONGLONG                 *Id
> +    );
> +
> +/*! \brief Map a batch of foreign pages into an existing mapping
> +    \param Xc Xencontrol handle returned by XcOpen()
> +    \param Id Mapping ID returned by XcGnttabCreateMapping()
> +    \param Offset Starting page index in the mapping
> +    \param NumberPages Number of 4k pages to map, from 1 to 
> XENIFACE_GNTTAB_BATCH_COUNT_MAX
> +    \param References An array of Xen grant numbers for every page in the 
> batch
> +    \param BatchStatus NTSTATUS value for batch processing
> +    \param Results An array of page-level hypercall NTSTATUS values for 
> every page in the batch
> +    \return Win32 error code
> +
> +    On ERROR_SUCCESS, \a BatchStatus and \a Results contain NTSTATUS values,
> +    including partial failures. Map only failed slots when retrying a map.
> +*/
> +XENCONTROL_API
> +_Success_(return == ERROR_SUCCESS)
> +DWORD
> +XcGnttabMapBatch(
> +    _In_ PXENCONTROL_CONTEXT             Xc,
> +    _In_ ULONGLONG                       Id,
> +    _In_ ULONG                           Offset,
> +    _In_ ULONG                           NumberPages,
> +    _In_reads_(NumberPages) const ULONG  *References,
> +    _Out_ LONG                           *BatchStatus,
> +    _Out_writes_(NumberPages) LONG       *Results
> +    );
> +
> +/*! \brief Create a user-mode view of a fully populated mapping
> +    \param Xc Xencontrol handle returned by XcOpen()
> +    \param Id Mapping ID returned by XcGnttabCreateMapping()
> +    \param Address Local user mode address of the mapped memory region
> +    \return Win32 error code
> +
> +    Every page must be mapped before creating a view. Repeated calls return 
> the
> +    existing view. A batch unmap removes the view; it can be recreated after
> +    every page has been mapped again. Stop all accesses before unmap or 
> release.
> +*/
> +XENCONTROL_API
> +_Success_(return == ERROR_SUCCESS)
> +DWORD
> +XcGnttabCreateUserView(
> +    _In_ PXENCONTROL_CONTEXT Xc,
> +    _In_ ULONGLONG           Id,
> +    _Outptr_ PVOID           *Address
> +    );
> +
> +/*! \brief Unmap a batch of foreign pages from an existing mapping
> +    \param Xc Xencontrol handle returned by XcOpen()
> +    \param Id Mapping ID returned by XcGnttabCreateMapping()
> +    \param Offset Starting page index in the mapping
> +    \param NumberPages Number of 4k pages to unmap, from 1 to 
> XENIFACE_GNTTAB_BATCH_COUNT_MAX
> +    \param BatchStatus NTSTATUS value for batch processing
> +    \param Results An array of page-level hypercall NTSTATUS values for 
> every page in the batch
> +    \return Win32 error code
> +
> +    Make one attempt to unmap \a NumberPages slots starting at the page \a 
> Offset.
> +    Stop all memory accesses first. Every valid unmap removes the whole user 
> view
> +    before attempting to unmap pages, including when the batch later fails.
> +    \a BatchStatus and \a Results contain NTSTATUS values only on 
> ERROR_SUCCESS.
> +    Empty slots succeed, so callers may retry the original range after a 
> partial
> +    failure. Failed pages remain mapped and the caller owns retry policy.
> +
> +    This call does not destroy the mapping. Use XcGnttabDestroyMapping() 
> after all
> +    pages are unmapped, or XcGnttabUnmapPages() or XcClose() to hand 
> remaining
> +    cleanup and retries to the driver.
> +*/
> +XENCONTROL_API
> +_Success_(return == ERROR_SUCCESS)
> +DWORD
> +XcGnttabUnmapBatch(
> +    _In_ PXENCONTROL_CONTEXT        Xc,
> +    _In_ ULONGLONG                  Id,
> +    _In_ ULONG                      Offset,
> +    _In_ ULONG                      NumberPages,
> +    _Out_ LONG                      *BatchStatus,
> +    _Out_writes_(NumberPages) LONG  *Results
> +    );
> +
> +/*! \brief Destroy an empty mapping and invalidate its ID
> +    \param Xc Xencontrol handle returned by XcOpen()
> +    \param Id Mapping ID returned by XcGnttabCreateMapping()
> +    \return Win32 error code
> +
> +    All pages must be unmapped. A successful call frees the mapping and sends
> +    any configured event channel notification.
> +*/
> +XENCONTROL_API
> +DWORD
> +XcGnttabDestroyMapping(
> +    _In_ PXENCONTROL_CONTEXT Xc,
> +    _In_ ULONGLONG           Id
> +    );
> +
> +/*! \brief Unmap all foreign pages and destroy the mapping
> +    \param Xc Xencontrol handle returned by XcOpen()
> +    \param Id Mapping ID returned by XcGnttabCreateMapping()
> +    \return Win32 error code
> +
> +    Stop all memory accesses before calling. On ERROR_SUCCESS the address 
> and ID
> +    are invalid, and the driver owns any remaining grant cleanup/retries.
> +    Accepts empty, partially populated and fully populated mappings of any 
> size.
> +    Success acknowledges release, not completion of all Xen grant unmaps.
> +    The configured port notification follows actual destruction of this 
> mapping;
> +    it does not wait for cleanup of other mappings.
> +*/
> +XENCONTROL_API
> +DWORD
> +XcGnttabUnmapPages(
> +    _In_ PXENCONTROL_CONTEXT Xc,
> +    _In_ ULONGLONG           Id
> +    );
> +
>   /*! \brief Read a XenStore key
>       \param Xc Xencontrol handle returned by XcOpen()
>       \param Path Path to the key
> diff --git a/include/xeniface_ioctls.h b/include/xeniface_ioctls.h
> index 67deedf..decace5 100644
> --- a/include/xeniface_ioctls.h
> +++ b/include/xeniface_ioctls.h
> @@ -237,7 +237,7 @@ typedef struct _XENIFACE_EVTCHN_UNMASK_IN {
>       ULONG LocalPort; /*!< Local port number that is assigned to the event 
> channel */
>   } XENIFACE_EVTCHN_UNMASK_IN, *PXENIFACE_EVTCHN_UNMASK_IN;
>   
> -/*! \brief Bitmask of XenStore key permissions */
> +/*! \brief Bitmask of grant and foreign page mapping flags */
>   typedef enum _XENIFACE_GNTTAB_PAGE_FLAGS {
>       XENIFACE_GNTTAB_READONLY          = 1 << 0, /*!< If set, the 
> granted/mapped pages are read-only */
>       XENIFACE_GNTTAB_USE_NOTIFY_OFFSET = 1 << 1, /*!< If set, the 
> NotifyOffset member of the grant/map IOCTL input is used */
> @@ -414,6 +414,164 @@ typedef struct 
> _XENIFACE_GNTTAB_UNMAP_FOREIGN_PAGES_IN_V2 {
>       PVOID Address; /*!< User-mode address of the shared memory region */
>   } XENIFACE_GNTTAB_UNMAP_FOREIGN_PAGES_IN_V2, 
> *PXENIFACE_GNTTAB_UNMAP_FOREIGN_PAGES_IN_V2;
>   
> +/*! \brief Maximum number of pages in a single map request or batch */
> +#define XENIFACE_GNTTAB_BATCH_COUNT_MAX 256
> +
> +/*! \brief Maximum number of pages in a mapping */
> +#define XENIFACE_GNTTAB_MAPPING_COUNT_MAX 0xFFFFF
> +
> +/*! \brief Create an empty mapping for foreign pages
> +
> +    Populate the mapping with IOCTL_XENIFACE_GNTTAB_MAP_BATCH, then obtain
> +    a user-mode view with IOCTL_XENIFACE_GNTTAB_CREATE_USER_VIEW. The remote
> +    domain, access flags and cleanup notifications are fixed for the lifetime
> +    of the mapping. A notify byte requires a writable mapping and is cleared
> +    before its view is removed. The event channel must belong to the same 
> open
> +    handle and is retained until mapping release. Its notification is sent 
> only
> +    after all pages are unmapped and the mapping is destroyed.
> +
> +    The batched mapping IOCTLs use METHOD_BUFFERED and complete 
> synchronously.
> +    Mapping IDs belong to the creating process and open file handle. Closing
> +    the handle releases its mappings, the driver retries failed cleanup.
> +
> +    Input: XENIFACE_GNTTAB_CREATE_MAPPING_IN
> +
> +    Output: XENIFACE_GNTTAB_MAPPING_ID
> +*/
> +#define IOCTL_XENIFACE_GNTTAB_CREATE_MAPPING \
> +    CTL_CODE(FILE_DEVICE_UNKNOWN, 0x828, METHOD_BUFFERED, FILE_ANY_ACCESS)
> +
> +/*! \brief Map a batch of foreign pages into an existing mapping
> +
> +    Batches may be mapped in any order at the requested page offset. A batch
> +    overlapping any mapped page fails with STATUS_DEVICE_BUSY. Successful
> +    pages remain mapped after a partial failure. To retry failed pages, 
> submit
> +    new batches covering only their unmapped slots.
> +
> +    The IOCTL succeeds when its output is delivered, even if mapping failed.
> +    Status contains batch processing errors, Results contains per-page
> +    hypervisor errors.
> +
> +    Input: XENIFACE_GNTTAB_MAP_BATCH_IN
> +
> +    Output: XENIFACE_GNTTAB_BATCH_OUT
> +*/
> +#define IOCTL_XENIFACE_GNTTAB_MAP_BATCH \
> +    CTL_CODE(FILE_DEVICE_UNKNOWN, 0x829, METHOD_BUFFERED, FILE_ANY_ACCESS)
> +
> +/*! \brief Create a user-mode view of a fully populated mapping
> +
> +    Returns STATUS_DEVICE_NOT_READY if any page is unmapped. Repeated calls
> +    reuse the existing view. After a batch unmap removes the view, another 
> view
> +    can be created only after all pages are mapped again.
> +
> +    Stop all accesses to the view before unmapping, releasing the mapping,
> +    or closing its owning file handle.
> +
> +    Input: XENIFACE_GNTTAB_MAPPING_ID
> +
> +    Output: XENIFACE_GNTTAB_CREATE_USER_VIEW_OUT
> +*/
> +#define IOCTL_XENIFACE_GNTTAB_CREATE_USER_VIEW \
> +    CTL_CODE(FILE_DEVICE_UNKNOWN, 0x82A, METHOD_BUFFERED, FILE_ANY_ACCESS)
> +
> +/*! \brief Unmap a batch of foreign pages from an existing mapping
> +
> +    Stop all accesses to the user-mode view before calling. A valid unmap
> +    removes the entire view before attempting any grant unmaps, even if some
> +    pages fail to unmap. Empty slots succeed, so the entire batch can safely
> +    be retried after a partial failure. The mapping and ID remain valid.
> +
> +    The IOCTL succeeds when its output is delivered, even if the batch 
> failed.
> +    Status contains batch processing errors, Results contains per-page
> +    hypervisor errors.
> +
> +    Input: XENIFACE_GNTTAB_UNMAP_BATCH_IN
> +
> +    Output: XENIFACE_GNTTAB_BATCH_OUT
> +*/
> +#define IOCTL_XENIFACE_GNTTAB_UNMAP_BATCH \
> +    CTL_CODE(FILE_DEVICE_UNKNOWN, 0x82B, METHOD_BUFFERED, FILE_ANY_ACCESS)
> +
> +/*! \brief Destroy an empty mapping and invalidate its ID
> +
> +    All pages must be unmapped. A successful call frees the mapping
> +    and sends any configured port notification.
> +
> +    Input: XENIFACE_GNTTAB_MAPPING_ID
> +
> +    Output: None
> +*/
> +#define IOCTL_XENIFACE_GNTTAB_DESTROY_MAPPING \
> +    CTL_CODE(FILE_DEVICE_UNKNOWN, 0x82C, METHOD_BUFFERED, FILE_ANY_ACCESS)
> +
> +/*! \brief Unmap all foreign pages and destroy the mapping
> +
> +    Stop all accesses to the user-mode view before calling. Removes the view
> +    and invalidates the ID before returning success. The driver takes 
> ownership
> +    of failed unmaps or mapping destruction and retries them during cleanup.
> +    Accepts empty, partially populated and fully populated mappings of any 
> size.
> +    Success acknowledges release; it does not guarantee that all foreign 
> grant
> +    handles are already unmapped. A configured port notification follows 
> actual
> +    destruction of this mapping only, not cleanup of other mappings.
> +
> +    Input: XENIFACE_GNTTAB_MAPPING_ID
> +
> +    Output: None
> +*/
> +#define IOCTL_XENIFACE_GNTTAB_UNMAP_PAGES \
> +    CTL_CODE(FILE_DEVICE_UNKNOWN, 0x82F, METHOD_BUFFERED, FILE_ANY_ACCESS)
> +
> +/*! \brief Input for IOCTL_XENIFACE_GNTTAB_CREATE_MAPPING */
> +typedef struct _XENIFACE_GNTTAB_CREATE_MAPPING_IN {
> +    ULONG NumberPages;  /*!< Number of pages, from 1 to 
> XENIFACE_GNTTAB_MAPPING_COUNT_MAX */
> +    USHORT RemoteDomain; /*!< Remote domain granting access to the pages */
> +    USHORT Reserved;     /*!< Must be zero */
> +    ULONG Flags;         /*!< XENIFACE_GNTTAB_READONLY and 
> XENIFACE_GNTTAB_USE_NOTIFY_* */
> +    ULONG NotifyOffset;  /*!< Byte to clear before removing the view, if 
> enabled */
> +    ULONG NotifyPort;    /*!< Local event channel port to notify after 
> release, if enabled */
> +} XENIFACE_GNTTAB_CREATE_MAPPING_IN;
> +
> +/*! \brief Output for IOCTL_XENIFACE_GNTTAB_CREATE_MAPPING and input for
> +           IOCTL_XENIFACE_GNTTAB_CREATE_USER_VIEW,
> +           IOCTL_XENIFACE_GNTTAB_DESTROY_MAPPING, and 
> IOCTL_XENIFACE_GNTTAB_UNMAP_PAGES
> +*/
> +typedef struct _XENIFACE_GNTTAB_MAPPING_ID {
> +    ULONGLONG Id; /*!< Opaque mapping ID; zero is invalid */
> +} XENIFACE_GNTTAB_MAPPING_ID;
> +
> +/*! \brief Input for IOCTL_XENIFACE_GNTTAB_MAP_BATCH
> +    Buffer size: FIELD_OFFSET(XENIFACE_GNTTAB_MAP_BATCH_IN, 
> References[NumberPages]) bytes
> +*/
> +typedef struct _XENIFACE_GNTTAB_MAP_BATCH_IN {
> +    ULONGLONG Id;                    /*!< Mapping ID returned by a create or 
> map request */
> +    ULONG Offset;                    /*!< Starting page index in the mapping 
> */
> +    ULONG NumberPages;               /*!< Number of pages, from 1 to 
> XENIFACE_GNTTAB_BATCH_COUNT_MAX */
> +    ULONG References[ANYSIZE_ARRAY]; /*!< Xen grant references in page order 
> */
> +} XENIFACE_GNTTAB_MAP_BATCH_IN;
> +
> +/*! \brief Input for IOCTL_XENIFACE_GNTTAB_UNMAP_BATCH */
> +typedef struct _XENIFACE_GNTTAB_UNMAP_BATCH_IN {
> +    ULONGLONG Id;      /*!< Mapping ID returned by a create or map request */
> +    ULONG Offset;      /*!< Starting page index in the mapping */
> +    ULONG NumberPages; /*!< Number of pages, from 1 to 
> XENIFACE_GNTTAB_BATCH_COUNT_MAX */
> +} XENIFACE_GNTTAB_UNMAP_BATCH_IN;
> +
> +/*! \brief Output for IOCTL_XENIFACE_GNTTAB_MAP_BATCH and 
> IOCTL_XENIFACE_GNTTAB_UNMAP_BATCH
> +
> +    Buffer size: FIELD_OFFSET(XENIFACE_GNTTAB_BATCH_OUT, 
> Results[NumberPages]) bytes.
> +    Status and Results contain  NTSTATUS values.
> +*/
> +typedef struct _XENIFACE_GNTTAB_BATCH_OUT {
> +    LONG Status;                 /*!< Overall batch status, including batch 
> processing errors */
> +    LONG Results[ANYSIZE_ARRAY]; /*!< Page-level hypercall results; 
> STATUS_SUCCESS if no hypercall runs */
> +} XENIFACE_GNTTAB_BATCH_OUT;
> +
> +/*! \brief Output for IOCTL_XENIFACE_GNTTAB_CREATE_USER_VIEW */
> +typedef struct _XENIFACE_GNTTAB_CREATE_USER_VIEW_OUT {
> +    ULONGLONG Address; /*!< User-mode address */
> +} XENIFACE_GNTTAB_CREATE_USER_VIEW_OUT;
> +
>   /*! \brief Gets the current suspend count.
>   
>       Input: None
> diff --git a/src/xencontrol/xencontrol.c b/src/xencontrol/xencontrol.c
> index a68dcf6..7b995ed 100644
> --- a/src/xencontrol/xencontrol.c
> +++ b/src/xencontrol/xencontrol.c
> @@ -589,6 +589,215 @@ XcGnttabUnmapForeignPages(
>       return Status;
>   }
>   
> +/* XcOpen uses FILE_FLAG_OVERLAPPED for legacy grant/map requests, which stay
> + * pending until revoke/unmap. The synchronous APIs below share that handle 
> and
> + * must still supply an OVERLAPPED and event.
> + */
> +_Success_(return == ERROR_SUCCESS)
> +static DWORD
> +XcGnttabControl(
> +    _In_ PXENCONTROL_CONTEXT              Xc,
> +    _In_ DWORD                            Code,
> +    _In_reads_bytes_(InSize) PVOID        In,
> +    _In_ DWORD                            InSize,
> +    _Out_writes_bytes_opt_(OutSize) PVOID Out,
> +    _In_ DWORD                            OutSize
> +    )
> +{
> +    OVERLAPPED Overlapped = {0};
> +    DWORD Returned = 0, Status = ERROR_SUCCESS;
> +    BOOL Success;
> +
> +    Overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
> +    if (Overlapped.hEvent == NULL)
> +        return GetLastError();
> +
> +    Success = DeviceIoControl(Xc->XenIface, Code, In, InSize, Out, OutSize,
> +                              &Returned, &Overlapped);
> +    if (!Success) {
> +        Status = GetLastError();
> +        if (Status == ERROR_IO_PENDING) {
> +            Success = GetOverlappedResult(Xc->XenIface, &Overlapped, 
> &Returned, TRUE);
> +            Status = Success ? ERROR_SUCCESS : GetLastError();
> +        }
> +    }
> +
> +    if (Status == ERROR_SUCCESS && Returned != OutSize)
> +        Status = ERROR_INVALID_DATA;
> +
> +    CloseHandle(Overlapped.hEvent);
> +    return Status;
> +}
> +
> +_Success_(return == ERROR_SUCCESS)
> +DWORD
> +XcGnttabCreateMapping(
> +    _In_ PXENCONTROL_CONTEXT        Xc,
> +    _In_ USHORT                     RemoteDomain,
> +    _In_ ULONG                      NumberPages,
> +    _In_ ULONG                      NotifyOffset,
> +    _In_ ULONG                      NotifyPort,
> +    _In_ XENIFACE_GNTTAB_PAGE_FLAGS Flags,
> +    _Out_ ULONGLONG                 *Id
> +    )
> +{
> +    XENIFACE_GNTTAB_CREATE_MAPPING_IN In = {0};
> +    XENIFACE_GNTTAB_MAPPING_ID Out = {0};
> +    DWORD Status;
> +
> +    if (Id != NULL)
> +        *Id = 0;
> +
> +    if (Xc == NULL || Id == NULL || NumberPages == 0 ||
> +        NumberPages > XENIFACE_GNTTAB_MAPPING_COUNT_MAX)
> +        return ERROR_INVALID_PARAMETER;
> +
> +    In.NumberPages = NumberPages;
> +    In.RemoteDomain = RemoteDomain;
> +    In.Flags = Flags;
> +    In.NotifyOffset = NotifyOffset;
> +    In.NotifyPort = NotifyPort;
> +    Status = XcGnttabControl(Xc, IOCTL_XENIFACE_GNTTAB_CREATE_MAPPING,
> +                             &In, sizeof(In), &Out, sizeof(Out));
> +
> +    if (Status == ERROR_SUCCESS && Out.Id == 0)
> +        Status = ERROR_INVALID_DATA;
> +
> +    if (Status == ERROR_INVALID_DATA && Out.Id != 0)
> +        (VOID)XcGnttabUnmapPages(Xc, Out.Id);
> +
> +    if (Status == ERROR_SUCCESS)
> +        *Id = Out.Id;
> +
> +    return Status;
> +}
> +
> +_Success_(return == ERROR_SUCCESS)
> +DWORD
> +XcGnttabMapBatch(
> +    _In_ PXENCONTROL_CONTEXT            Xc,
> +    _In_ ULONGLONG                      Id,
> +    _In_ ULONG                          Offset,
> +    _In_ ULONG                          NumberPages,
> +    _In_reads_(NumberPages) const ULONG *References,
> +    _Out_ LONG                          *BatchStatus,
> +    _Out_writes_(NumberPages) LONG      *Results
> +    )
> +{
> +    // Keep 64-bit alignment: two ULONGLONGs for Id, Offset and NumberPages.
> +    // Each remaining ULONGLONG holds two 32-bit grant references.
> +    ULONGLONG InBuffer[2 + XENIFACE_GNTTAB_BATCH_COUNT_MAX / 2];
> +    // One LONG for the overall batch status, followed by per-page results.
> +    LONG OutBuffer[1 + XENIFACE_GNTTAB_BATCH_COUNT_MAX];
> +    XENIFACE_GNTTAB_MAP_BATCH_IN *In = (PVOID)InBuffer;
> +    XENIFACE_GNTTAB_BATCH_OUT *Out = (PVOID)OutBuffer;
> +    DWORD Status, InSize, OutSize;
> +
> +    if (NumberPages == 0 || NumberPages > XENIFACE_GNTTAB_BATCH_COUNT_MAX ||
> +        References == NULL || BatchStatus == NULL || Results == NULL)
> +        return ERROR_INVALID_PARAMETER;
> +
> +    In->Id = Id;
> +    In->Offset = Offset;
> +    In->NumberPages = NumberPages;
> +    memcpy(In->References, References, NumberPages * sizeof(ULONG));
> +    InSize = (DWORD)FIELD_OFFSET(XENIFACE_GNTTAB_MAP_BATCH_IN, 
> References[NumberPages]);
> +    OutSize = (DWORD)FIELD_OFFSET(XENIFACE_GNTTAB_BATCH_OUT, 
> Results[NumberPages]);
> +    Status = XcGnttabControl(Xc, IOCTL_XENIFACE_GNTTAB_MAP_BATCH, In, 
> InSize, Out, OutSize);
> +
> +    if (Status == ERROR_SUCCESS) {
> +        *BatchStatus = Out->Status;
> +        memcpy(Results, Out->Results, NumberPages * sizeof(LONG));
> +    }
> +    return Status;
> +}
> +
> +_Success_(return == ERROR_SUCCESS)
> +DWORD
> +XcGnttabCreateUserView(
> +    _In_ PXENCONTROL_CONTEXT Xc,
> +    _In_ ULONGLONG           Id,
> +    _Outptr_ PVOID           *Address
> +    )
> +{
> +    XENIFACE_GNTTAB_MAPPING_ID In;
> +    XENIFACE_GNTTAB_CREATE_USER_VIEW_OUT Out;
> +    DWORD Status;
> +
> +    if (Address == NULL)
> +        return ERROR_INVALID_PARAMETER;
> +
> +    *Address = NULL;
> +    In.Id = Id;
> +    Status = XcGnttabControl(Xc, IOCTL_XENIFACE_GNTTAB_CREATE_USER_VIEW,
> +                             &In, sizeof(In), &Out, sizeof(Out));
> +
> +    if (Status == ERROR_SUCCESS)
> +        *Address = (PVOID)Out.Address;
> +    return Status;
> +}
> +
> +_Success_(return == ERROR_SUCCESS)
> +DWORD
> +XcGnttabUnmapBatch(
> +    _In_ PXENCONTROL_CONTEXT       Xc,
> +    _In_ ULONGLONG                 Id,
> +    _In_ ULONG                     Offset,
> +    _In_ ULONG                     NumberPages,
> +    _Out_ LONG                     *BatchStatus,
> +    _Out_writes_(NumberPages) LONG *Results
> +    )
> +{
> +    XENIFACE_GNTTAB_UNMAP_BATCH_IN In;
> +    // One LONG for the overall batch status, followed by per-page results.
> +    LONG OutBuffer[1 + XENIFACE_GNTTAB_BATCH_COUNT_MAX];
> +    XENIFACE_GNTTAB_BATCH_OUT *Out = (PVOID)OutBuffer;
> +    DWORD Status, OutSize;
> +
> +    if (NumberPages == 0 || NumberPages > XENIFACE_GNTTAB_BATCH_COUNT_MAX ||
> +        BatchStatus == NULL || Results == NULL)
> +        return ERROR_INVALID_PARAMETER;
> +
> +    In.Id = Id;
> +    In.Offset = Offset;
> +    In.NumberPages = NumberPages;
> +    OutSize = (DWORD)FIELD_OFFSET(XENIFACE_GNTTAB_BATCH_OUT, 
> Results[NumberPages]);
> +    Status = XcGnttabControl(Xc, IOCTL_XENIFACE_GNTTAB_UNMAP_BATCH, &In, 
> sizeof(In), Out, OutSize);
> +
> +    if (Status == ERROR_SUCCESS) {
> +        *BatchStatus = Out->Status;
> +        memcpy(Results, Out->Results, NumberPages * sizeof(LONG));
> +    }
> +    return Status;
> +}
> +
> +DWORD
> +XcGnttabDestroyMapping(
> +    _In_ PXENCONTROL_CONTEXT Xc,
> +    _In_ ULONGLONG           Id
> +    )
> +{
> +    XENIFACE_GNTTAB_MAPPING_ID In;
> +    In.Id = Id;
> +    return XcGnttabControl(Xc, IOCTL_XENIFACE_GNTTAB_DESTROY_MAPPING, &In, 
> sizeof(In), NULL, 0);
> +}
> +
> +DWORD
> +XcGnttabUnmapPages(
> +    _In_ PXENCONTROL_CONTEXT Xc,
> +    _In_ ULONGLONG           Id
> +    )
> +{
> +    XENIFACE_GNTTAB_MAPPING_ID In;
> +
> +    if (Xc == NULL || Id == 0)
> +        return ERROR_INVALID_PARAMETER;
> +
> +    In.Id = Id;
> +    return XcGnttabControl(Xc, IOCTL_XENIFACE_GNTTAB_UNMAP_PAGES,
> +                           &In, sizeof(In), NULL, 0);
> +}
> +
>   DWORD
>   XcStoreRead(
>       _In_ PXENCONTROL_CONTEXT    Xc,
> diff --git a/src/xeniface/ioctl_gnttab.c b/src/xeniface/ioctl_gnttab.c
> index 44b7809..38730ee 100644
> --- a/src/xeniface/ioctl_gnttab.c
> +++ b/src/xeniface/ioctl_gnttab.c
> @@ -38,6 +38,9 @@
>   
>   #define GNTTAB_MAX_PAGES    (MAXULONG / PAGE_SIZE)
>   
> +C_ASSERT(XENIFACE_GNTTAB_BATCH_COUNT_MAX == 
> XENBUS_GNTTAB_MAP_BATCH_COUNT_MAX);
> +C_ASSERT(XENIFACE_GNTTAB_MAPPING_COUNT_MAX == XENBUS_GNTTAB_MAP_COUNT_MAX);
> +
>   #ifndef XENIFACE_GNTTAB_CLEANUP_TIMEOUT_SECONDS
>   #define XENIFACE_GNTTAB_CLEANUP_TIMEOUT_SECONDS 60
>   #endif
> @@ -437,6 +440,289 @@ GnttabCleanup(
>       }
>   }
>   
> +_IRQL_requires_(PASSIVE_LEVEL)
> +_Ret_maybenull_
> +static PXENIFACE_GNTTAB_CONTEXT
> +GnttabFindMapping(
> +    _In_ PXENIFACE_FDO        Fdo,
> +    _In_ ULONGLONG            Id,
> +    _In_opt_ PFILE_OBJECT     FileObject
> +    )
> +{
> +    PLIST_ENTRY               Entry;
> +    PXENIFACE_GNTTAB_CONTEXT  Context;
> +
> +    for (Entry = Fdo->MappingList.Flink; Entry != &Fdo->MappingList; Entry = 
> Entry->Flink) {
> +        Context = CONTAINING_RECORD(Entry, XENIFACE_GNTTAB_CONTEXT, Entry);
> +        if (Context->Map.MappingId == Id && Context->FileObject == 
> FileObject &&
> +            Context->Process == PsGetCurrentProcess())
> +            return Context;
> +    }
> +    return NULL;
> +}
> +
> +_IRQL_requires_(PASSIVE_LEVEL)
> +static NTSTATUS
> +GnttabAllocateMappingContext(
> +    _In_ PXENIFACE_FDO                            Fdo,
> +    _In_ const XENIFACE_GNTTAB_CREATE_MAPPING_IN  *In,
> +    _In_opt_ PFILE_OBJECT                         FileObject,
> +    _Out_ PXENIFACE_GNTTAB_CONTEXT                *ContextOut
> +    )
> +{
> +    PXENIFACE_GNTTAB_CONTEXT                      Context;
> +
> +    *ContextOut = NULL;
> +    if (In->NumberPages == 0 || In->NumberPages > 
> XENBUS_GNTTAB_MAP_COUNT_MAX ||
> +        In->Reserved != 0 || Fdo->LastMappingId == MAXULONGLONG ||
> +        (In->Flags & ~(XENIFACE_GNTTAB_READONLY | 
> XENIFACE_GNTTAB_USE_NOTIFY_OFFSET |
> +                       XENIFACE_GNTTAB_USE_NOTIFY_PORT)))
> +        return STATUS_INVALID_PARAMETER;
> +
> +    if ((In->Flags & XENIFACE_GNTTAB_USE_NOTIFY_OFFSET) &&
> +        (In->NotifyOffset >= In->NumberPages * PAGE_SIZE ||
> +         (In->Flags & XENIFACE_GNTTAB_READONLY)))
> +        return STATUS_INVALID_PARAMETER;
> +
> +    Context = GnttabAllocateContext(Fdo);
> +    if (Context == NULL)
> +        return STATUS_NO_MEMORY;
> +
> +    Context->Type = XENIFACE_GNTTAB_CONTEXT_MAP;
> +    Context->FileObject = FileObject;
> +    Context->RemoteDomain = In->RemoteDomain;
> +    Context->NumberPages = In->NumberPages;
> +    Context->Flags = In->Flags;
> +    Context->NotifyOffset = In->NotifyOffset;
> +    Context->NotifyPort = In->NotifyPort;
> +    if (In->Flags & XENIFACE_GNTTAB_USE_NOTIFY_PORT) {
> +        Context->Map.NotifyChannel = EvtchnReference(Fdo, In->NotifyPort, 
> FileObject);
> +        if (Context->Map.NotifyChannel == NULL) {
> +            GnttabFreeContext(Fdo, Context);
> +            return STATUS_NOT_FOUND;
> +        }
> +    }
> +
> +    // Enable notifications only when the request returns a valid mapping.
> +    *ContextOut = Context;
> +    return STATUS_SUCCESS;
> +}
> +
> +_IRQL_requires_(PASSIVE_LEVEL)
> +NTSTATUS
> +IoctlGnttabCreateMapping(
> +    _In_ PXENIFACE_FDO                 Fdo,
> +    _Inout_ PVOID                      Buffer,
> +    _In_ ULONG                         InLen,
> +    _In_ ULONG                         OutLen,
> +    _In_opt_ PFILE_OBJECT              FileObject,
> +    _Out_ PULONG_PTR                   Info
> +    )
> +{
> +    XENIFACE_GNTTAB_CREATE_MAPPING_IN  *Create = Buffer;
> +    XENIFACE_GNTTAB_MAPPING_ID         *Out = Buffer;
> +    PXENIFACE_GNTTAB_CONTEXT           Context;
> +    NTSTATUS                           Status;
> +
> +    *Info = 0;
> +    if (InLen != sizeof(*Create) || OutLen != sizeof(*Out))
> +        return STATUS_INVALID_BUFFER_SIZE;
> +
> +    Status = GnttabAllocateMappingContext(Fdo, Create, FileObject, &Context);
> +    if (!NT_SUCCESS(Status))
> +        return Status;
> +
> +    Status = GnttabCreateMap(Fdo, Context);
> +    if (!NT_SUCCESS(Status)) {
> +        GnttabFreeContext(Fdo, Context);
> +        return Status;
> +    }
> +
> +    Context->Map.MappingId = ++Fdo->LastMappingId;
> +    Context->Map.NotifyOnCleanup = TRUE;
> +    InsertTailList(&Fdo->MappingList, &Context->Entry);
> +    Out->Id = Context->Map.MappingId;
> +    *Info = sizeof(*Out);
> +    return STATUS_SUCCESS;
> +}
> +
> +_IRQL_requires_(PASSIVE_LEVEL)
> +static NTSTATUS
> +GnttabProcessBatch(
> +    _In_ PXENIFACE_FDO              Fdo,
> +    _Inout_ PVOID                   Buffer,
> +    _In_ ULONG                      InLen,
> +    _In_ ULONG                      OutLen,
> +    _In_opt_ PFILE_OBJECT           FileObject,
> +    _Out_ PULONG_PTR                Info,
> +    _In_ BOOLEAN                    MapPages
> +    )
> +{
> +    XENIFACE_GNTTAB_MAP_BATCH_IN    *Map = Buffer;
> +    XENIFACE_GNTTAB_UNMAP_BATCH_IN  *Unmap = Buffer;
> +    XENIFACE_GNTTAB_BATCH_OUT       *Out = Buffer;
> +    PXENIFACE_GNTTAB_CONTEXT        Context;
> +    NTSTATUS                        Status;
> +    NTSTATUS                        
> Results[XENBUS_GNTTAB_MAP_BATCH_COUNT_MAX];
> +    ULONG                           Count, Offset, Size;
> +    ULONGLONG                       Id;
> +
> +    *Info = 0;
> +    if (InLen < sizeof(*Unmap))
> +        return STATUS_INVALID_BUFFER_SIZE;
> +
> +    Id = Unmap->Id;
> +    Offset = Unmap->Offset;
> +    Count = Unmap->NumberPages;
> +    if (Count == 0 || Count > XENBUS_GNTTAB_MAP_BATCH_COUNT_MAX)
> +        return STATUS_INVALID_PARAMETER;
> +
> +    Size = (ULONG)FIELD_OFFSET(XENIFACE_GNTTAB_BATCH_OUT, Results[Count]);
> +    if (OutLen != Size || InLen != (MapPages ?
> +        (ULONG)FIELD_OFFSET(XENIFACE_GNTTAB_MAP_BATCH_IN, References[Count]) 
> : sizeof(*Unmap)))
> +        return STATUS_INVALID_BUFFER_SIZE;
> +
> +    Context = GnttabFindMapping(Fdo, Id, FileObject);
> +    if (Context == NULL)
> +        return STATUS_NOT_FOUND;
> +
> +    if (Offset >= Context->NumberPages || Count > Context->NumberPages - 
> Offset)
> +        return STATUS_INVALID_PARAMETER;
> +
> +    RtlZeroMemory(Results, Count * sizeof(Results[0]));
> +    if (MapPages) {
> +        Status = XENBUS_GNTTAB(MapForeignPages, &Fdo->GnttabInterface,
> +                               Context->Map.Mapping, Offset, Count, 
> Map->References, Results);
> +    } else {
> +        GnttabUnmapView(Context);
> +        Status = XENBUS_GNTTAB(UnmapForeignPages, &Fdo->GnttabInterface,
> +                               Context->Map.Mapping, Offset, Count, Results);
> +    }
> +
> +    Out->Status = Status;
> +    RtlCopyMemory(Out->Results, Results, Count * sizeof(Results[0]));
> +    *Info = Size;
> +    // Potential page errors are in Results.
> +    return STATUS_SUCCESS;
> +}
> +
> +_IRQL_requires_(PASSIVE_LEVEL)
> +NTSTATUS
> +IoctlGnttabMapBatch(
> +    _In_ PXENIFACE_FDO     Fdo,
> +    _Inout_ PVOID          Buffer,
> +    _In_ ULONG             InLen,
> +    _In_ ULONG             OutLen,
> +    _In_opt_ PFILE_OBJECT  FileObject,
> +    _Out_ PULONG_PTR       Info
> +    )
> +{
> +    return GnttabProcessBatch(Fdo, Buffer, InLen, OutLen, FileObject, Info, 
> TRUE);
> +}
> +
> +_IRQL_requires_(PASSIVE_LEVEL)
> +NTSTATUS
> +IoctlGnttabCreateUserView(
> +    _In_ PXENIFACE_FDO                    Fdo,
> +    _Inout_ PVOID                         Buffer,
> +    _In_ ULONG                            InLen,
> +    _In_ ULONG                            OutLen,
> +    _In_opt_ PFILE_OBJECT                 FileObject,
> +    _Out_ PULONG_PTR                      Info
> +    )
> +{
> +    XENIFACE_GNTTAB_MAPPING_ID            *In = Buffer;
> +    XENIFACE_GNTTAB_CREATE_USER_VIEW_OUT  *Out = Buffer;
> +    PXENIFACE_GNTTAB_CONTEXT              Context;
> +    NTSTATUS                              Status;
> +
> +    *Info = 0;
> +    if (InLen != sizeof(*In) || OutLen != sizeof(*Out))
> +        return STATUS_INVALID_BUFFER_SIZE;
> +
> +    Context = GnttabFindMapping(Fdo, In->Id, FileObject);
> +    if (Context == NULL)
> +        return STATUS_NOT_FOUND;
> +
> +    Status = GnttabCreateUserView(Fdo, Context);
> +    if (NT_SUCCESS(Status)) {
> +        Out->Address = (ULONGLONG)Context->UserVa;
> +        *Info = sizeof(*Out);
> +    }
> +
> +    return Status;
> +}
> +
> +_IRQL_requires_(PASSIVE_LEVEL)
> +NTSTATUS
> +IoctlGnttabUnmapBatch(
> +    _In_ PXENIFACE_FDO     Fdo,
> +    _Inout_ PVOID          Buffer,
> +    _In_ ULONG             InLen,
> +    _In_ ULONG             OutLen,
> +    _In_opt_ PFILE_OBJECT  FileObject,
> +    _Out_ PULONG_PTR       Info
> +    )
> +{
> +    return GnttabProcessBatch(Fdo, Buffer, InLen, OutLen, FileObject, Info, 
> FALSE);
> +}
> +
> +_IRQL_requires_(PASSIVE_LEVEL)
> +NTSTATUS
> +IoctlGnttabDestroyMapping(
> +    _In_ PXENIFACE_FDO          Fdo,
> +    _In_ PVOID                  Buffer,
> +    _In_ ULONG                  InLen,
> +    _In_ ULONG                  OutLen,
> +    _In_opt_ PFILE_OBJECT       FileObject
> +    )
> +{
> +    XENIFACE_GNTTAB_MAPPING_ID  *In = Buffer;
> +    PXENIFACE_GNTTAB_CONTEXT    Context;
> +    NTSTATUS                    Status;
> +
> +    if (InLen != sizeof(*In) || OutLen != 0)
> +        return STATUS_INVALID_BUFFER_SIZE;
> +
> +    Context = GnttabFindMapping(Fdo, In->Id, FileObject);
> +    if (Context == NULL)
> +        return STATUS_NOT_FOUND;
> +
> +    Status = XENBUS_GNTTAB(DestroyMapping, &Fdo->GnttabInterface, 
> Context->Map.Mapping);
> +    if (NT_SUCCESS(Status)) {
> +        Context->Map.Mapping = NULL;
> +        RemoveEntryList(&Context->Entry);
> +        GnttabFinishMapCleanup(Fdo, Context);
> +    }
> +
> +    return Status;
> +}
> +
> +_IRQL_requires_(PASSIVE_LEVEL)
> +NTSTATUS
> +IoctlGnttabUnmapPages(
> +    _In_ PXENIFACE_FDO          Fdo,
> +    _In_ PVOID                  Buffer,
> +    _In_ ULONG                  InLen,
> +    _In_ ULONG                  OutLen,
> +    _In_opt_ PFILE_OBJECT       FileObject
> +    )
> +{
> +    XENIFACE_GNTTAB_MAPPING_ID  *In = Buffer;
> +    PXENIFACE_GNTTAB_CONTEXT    Context;
> +
> +    if (InLen != sizeof(*In) || OutLen != 0)
> +        return STATUS_INVALID_BUFFER_SIZE;
> +
> +    Context = GnttabFindMapping(Fdo, In->Id, FileObject);
> +    if (Context == NULL)
> +        return STATUS_NOT_FOUND;
> +
> +    RemoveEntryList(&Context->Entry);
> +    GnttabReleaseMap(Fdo, Context);
> +    return STATUS_SUCCESS;
> +}
> +
>   // Complete a canceled gnttab IRP, cleanup associated grant/map.
>   _Function_class_(IO_WORKITEM_ROUTINE)
>   VOID
> diff --git a/src/xeniface/ioctls.c b/src/xeniface/ioctls.c
> index d0b2132..7bc9cc0 100644
> --- a/src/xeniface/ioctls.c
> +++ b/src/xeniface/ioctls.c
> @@ -266,7 +266,7 @@ XenIfaceIoctl(
>           goto done;
>   
>       if (ControlCode >= IOCTL_XENIFACE_GNTTAB_PERMIT_FOREIGN_ACCESS &&
> -        ControlCode <= IOCTL_XENIFACE_GNTTAB_UNMAP_FOREIGN_PAGES_V2) {
> +        ControlCode <= IOCTL_XENIFACE_GNTTAB_UNMAP_PAGES) {
>           AcquireMutex(&Fdo->GnttabLock);
>           GnttabLocked = TRUE;
>           status = STATUS_DEVICE_NOT_READY;
> @@ -362,6 +362,32 @@ XenIfaceIoctl(
>           status = IoctlGnttabUnmapForeignPages(Fdo, Buffer, InLen, OutLen, 
> ControlCode);
>           break;
>   
> +    case IOCTL_XENIFACE_GNTTAB_CREATE_MAPPING:
> +        status = IoctlGnttabCreateMapping(Fdo, Buffer, InLen, OutLen, 
> Stack->FileObject, &Irp->IoStatus.Information);
> +        break;
> +
> +    case IOCTL_XENIFACE_GNTTAB_MAP_BATCH:
> +        status = IoctlGnttabMapBatch(Fdo, Buffer, InLen, OutLen, 
> Stack->FileObject, &Irp->IoStatus.Information);
> +        break;
> +
> +    case IOCTL_XENIFACE_GNTTAB_CREATE_USER_VIEW:
> +        status = IoctlGnttabCreateUserView(Fdo, Buffer, InLen, OutLen, 
> Stack->FileObject, &Irp->IoStatus.Information);
> +        break;
> +
> +    case IOCTL_XENIFACE_GNTTAB_UNMAP_BATCH:
> +        status = IoctlGnttabUnmapBatch(Fdo, Buffer, InLen, OutLen, 
> Stack->FileObject, &Irp->IoStatus.Information);
> +        break;
> +
> +    case IOCTL_XENIFACE_GNTTAB_DESTROY_MAPPING:
> +        Irp->IoStatus.Information = 0;
> +        status = IoctlGnttabDestroyMapping(Fdo, Buffer, InLen, OutLen, 
> Stack->FileObject);
> +        break;
> +
> +    case IOCTL_XENIFACE_GNTTAB_UNMAP_PAGES:
> +        Irp->IoStatus.Information = 0;
> +        status = IoctlGnttabUnmapPages(Fdo, Buffer, InLen, OutLen, 
> Stack->FileObject);
> +        break;
> +
>           // suspend
>       case IOCTL_XENIFACE_SUSPEND_GET_COUNT:
>           status = IoctlSuspendGetCount(Fdo, Buffer, InLen, OutLen, 
> &Irp->IoStatus.Information);
> diff --git a/src/xeniface/ioctls.h b/src/xeniface/ioctls.h
> index daca4fa..d52a893 100644
> --- a/src/xeniface/ioctls.h
> +++ b/src/xeniface/ioctls.h
> @@ -376,6 +376,71 @@ GnttabFreeMap(
>       _Inout_ PXENIFACE_GNTTAB_CONTEXT  Context
>       );
>   
> +_IRQL_requires_(PASSIVE_LEVEL)
> +NTSTATUS
> +IoctlGnttabCreateMapping(
> +    _In_ PXENIFACE_FDO                 Fdo,
> +    _Inout_ PVOID                      Buffer,
> +    _In_ ULONG                         InLen,
> +    _In_ ULONG                         OutLen,
> +    _In_opt_ PFILE_OBJECT              FileObject,
> +    _Out_ PULONG_PTR                   Info
> +    );
> +
> +_IRQL_requires_(PASSIVE_LEVEL)
> +NTSTATUS
> +IoctlGnttabMapBatch(
> +    _In_ PXENIFACE_FDO     Fdo,
> +    _Inout_ PVOID          Buffer,
> +    _In_ ULONG             InLen,
> +    _In_ ULONG             OutLen,
> +    _In_opt_ PFILE_OBJECT  FileObject,
> +    _Out_ PULONG_PTR       Info
> +    );
> +
> +_IRQL_requires_(PASSIVE_LEVEL)
> +NTSTATUS
> +IoctlGnttabCreateUserView(
> +    _In_ PXENIFACE_FDO                    Fdo,
> +    _Inout_ PVOID                         Buffer,
> +    _In_ ULONG                            InLen,
> +    _In_ ULONG                            OutLen,
> +    _In_opt_ PFILE_OBJECT                 FileObject,
> +    _Out_ PULONG_PTR                      Info
> +    );
> +
> +_IRQL_requires_(PASSIVE_LEVEL)
> +NTSTATUS
> +IoctlGnttabUnmapBatch(
> +    _In_ PXENIFACE_FDO     Fdo,
> +    _Inout_ PVOID          Buffer,
> +    _In_ ULONG             InLen,
> +    _In_ ULONG             OutLen,
> +    _In_opt_ PFILE_OBJECT  FileObject,
> +    _Out_ PULONG_PTR       Info
> +    );
> +
> +_IRQL_requires_(PASSIVE_LEVEL)
> +NTSTATUS
> +IoctlGnttabDestroyMapping(
> +    _In_ PXENIFACE_FDO          Fdo,
> +    _In_ PVOID                  Buffer,
> +    _In_ ULONG                  InLen,
> +    _In_ ULONG                  OutLen,
> +    _In_opt_ PFILE_OBJECT       FileObject
> +    );
> +
> +// Release the mapping, retaining failed cleanup for retry.
> +_IRQL_requires_(PASSIVE_LEVEL)
> +NTSTATUS
> +IoctlGnttabUnmapPages(
> +    _In_ PXENIFACE_FDO          Fdo,
> +    _In_ PVOID                  Buffer,
> +    _In_ ULONG                  InLen,
> +    _In_ ULONG                  OutLen,
> +    _In_opt_ PFILE_OBJECT       FileObject
> +    );
> +
>   _IRQL_requires_(PASSIVE_LEVEL)
>   VOID
>   GnttabCleanup(



--
Ngoc Tu Dinh | Vates XCP-ng Developer

XCP-ng & Xen Orchestra - Vates solutions

web: https://vates.tech

 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.