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

[RFC PATCH 5/7] xeniface: Use GNTTAB v5 interface and retain failed mapping cleanup


  • To: win-pv-devel@xxxxxxxxxxxxxxxxxxxx
  • From: Rafał Wojdyła <omeg@xxxxxxxxxxxxxxxxxxxxxx>
  • Date: Tue, 10 Nov 2026 19:34:52 +0100
  • Authentication-results: eu.smtp.expurgate.cloud; dkim=pass header.s=fm3 header.d=invisiblethingslab.com header.i="@invisiblethingslab.com" header.h="Cc:Content-Transfer-Encoding:Content-Type:Date:From:In-Reply-To:Message-ID:MIME-Version:References:Subject:To"; dkim=pass header.s=fm3 header.d=messagingengine.com header.i="@messagingengine.com" header.h="Cc:Content-Transfer-Encoding:Content-Type:Date:Feedback-ID:From:In-Reply-To:Message-ID:MIME-Version:References:Subject:To:X-ME-Proxy:X-ME-Sender"
  • Cc: Rafał Wojdyła <omeg@xxxxxxx>, Rafał Wojdyła <omeg@xxxxxxxxxxxxxxxxxxxxxx>
  • Delivery-date: Tue, 10 Nov 2026 18:36:12 +0000
  • Dkim2-signature: i=1; m=1; t=1794335768; d=invisiblethingslab.com; mf=PG9tZWdAaW52aXNpYmxldGhpbmdzbGFiLmNvbT4=; rt=PHdpbi1wdi1kZXZlbEBsaXN0cy54ZW5wcm9qZWN0Lm9yZz4=; s=fm3:rsa-sha256:A/qboPcRoU0dztsivI80gYviYCyFXqP0SKe3sEqSNLI+E2I QNmEPHVstdglFaCBx+6laConMI5cGX5+5lmSzyHN9650sQgP+tvybVlyTSoHiy59 sb1/l9AD97aNS4+LUOMVmLDMPBysYL0sbOp+1arts5xxFNoFeAsdgbly28ByDGQZ 4gETbKebGT/2dsAdvZ71+jWKZkWn8IVXxdVLyVI9JwMfp3u+sVgg3/e85/uaj3Lw 2VuKLVESUt8APGN3Vm1kwj0s21RLrJrZuor5napvh7i7KTiTQCnAgESryEq1H9wv lGoTlwC4auijra9LxXFu4yucvfkCyCKX+Wkbm1g==;
  • Feedback-id: i409c4082:Fastmail
  • List-id: Developer list for the Windows PV Drivers subproject <win-pv-devel.lists.xenproject.org>
  • Message-instance: m=1; h=sha256:Uua8OjXnuY7o/QSMezqn8F88Q1QspjRkp+yPinV5JKM=:to3/mVqna9Jl3EnpnVzJvPA/UhPHpkU5VOL29xFYzpU=;

From: Rafał Wojdyła <omeg@xxxxxxx>

Require xenbus grant table interface v5 and PDO revision 0900000D,
while preserving the legacy grant/map IOCTL layouts and asynchronous
request lifetimes. Map whole regions in bounded batches and expose a user
view only after every page has been mapped.

Own mappings independently of individual requests. Remove virtual views
before unmapping grants, attempt every batch, and retain failed handles and
mapping destruction for a retry thread. Rollback preserves the original
failure and suppresses notifications from unsuccessful setup.

Bound driver-owned cleanup with a per-mapping no-progress deadline, defaulting
to 60 seconds and overridable at compile time. Track conservative remaining
page counts, reset the unbiased clock only on observed progress, and retain
resources on the fatal expiry path instead of recycling foreign mappings.

Serialize grant operations and cleanup, record file ownership, and account
for active and retained contexts. File cleanup drains its requests; device
power-down waits for cleanup before releasing provider interfaces. Grant
sharing retains its existing setup, revocation and notification behavior.

Retain mapping notification channels at setup. Legacy mappings notify only
while that original context remains registered, preventing late cleanup
from notifying another channel that reused the same port.

Assisted-by: LLM
Signed-off-by: Rafał Wojdyła <omeg@xxxxxxxxxxxxxxxxxxxxxx>
---
 include/gnttab_interface.h  | 266 +++++++++---
 src/xeniface.inf            |   6 +-
 src/xeniface/fdo.c          |  37 ++
 src/xeniface/fdo.h          |   9 +
 src/xeniface/ioctl_gnttab.c | 782 +++++++++++++++++++++++-------------
 src/xeniface/ioctls.c       |  20 +
 src/xeniface/ioctls.h       |  84 +++-
 src/xeniface/irp_queue.c    |  11 +-
 8 files changed, 867 insertions(+), 348 deletions(-)

diff --git a/include/gnttab_interface.h b/include/gnttab_interface.h
index 41c8444..b595ffd 100644
--- a/include/gnttab_interface.h
+++ b/include/gnttab_interface.h
@@ -53,6 +53,11 @@ typedef struct _XENBUS_GNTTAB_ENTRY XENBUS_GNTTAB_ENTRY, 
*PXENBUS_GNTTAB_ENTRY;
 */
 typedef struct _XENBUS_GNTTAB_CACHE XENBUS_GNTTAB_CACHE, *PXENBUS_GNTTAB_CACHE;
 
+/*! \typedef XENBUS_GNTTAB_MAPPING
+    \brief Mapping handle for a contiguous range of foreign pages
+*/
+typedef struct _XENBUS_GNTTAB_MAPPING XENBUS_GNTTAB_MAPPING, 
*PXENBUS_GNTTAB_MAPPING;
+
 /*! \typedef XENBUS_GNTTAB_ACQUIRE
     \brief Acquire a reference to the GNTTAB interface
 
@@ -143,10 +148,10 @@ typedef NTSTATUS
 */
 typedef NTSTATUS
 (*XENBUS_GNTTAB_REVOKE_FOREIGN_ACCESS)(
-    _In_ PINTERFACE             Interface,
-    _In_ PXENBUS_GNTTAB_CACHE   Cache,
-    _In_ BOOLEAN                Locked,
-    _In_ PXENBUS_GNTTAB_ENTRY   Entry
+    _In_ PINTERFACE                 Interface,
+    _In_ PXENBUS_GNTTAB_CACHE       Cache,
+    _In_ BOOLEAN                    Locked,
+    _In_ PXENBUS_GNTTAB_ENTRY       Entry
     );
 
 /*! \typedef XENBUS_GNTTAB_GET_REFERENCE
@@ -158,8 +163,8 @@ typedef NTSTATUS
 */
 typedef ULONG
 (*XENBUS_GNTTAB_GET_REFERENCE)(
-    _In_ PINTERFACE             Interface,
-    _In_ PXENBUS_GNTTAB_ENTRY   Entry
+    _In_ PINTERFACE                 Interface,
+    _In_ PXENBUS_GNTTAB_ENTRY       Entry
     );
 
 /*! \typedef XENBUS_GNTTAB_QUERY_REFERENCE
@@ -172,10 +177,10 @@ typedef ULONG
 */
 typedef NTSTATUS
 (*XENBUS_GNTTAB_QUERY_REFERENCE)(
-    _In_ PINTERFACE             Interface,
-    _In_ ULONG                  Reference,
-    _Out_opt_ PPFN_NUMBER       Pfn,
-    _Out_opt_ PBOOLEAN          ReadOnly
+    _In_ PINTERFACE         Interface,
+    _In_ ULONG              Reference,
+    _Out_opt_ PPFN_NUMBER   Pfn,
+    _Out_opt_ PBOOLEAN      ReadOnly
     );
 
 #define XENBUS_GNTTAB_CONSOLE_REFERENCE 0
@@ -197,37 +202,161 @@ typedef VOID
     _In_ PXENBUS_GNTTAB_CACHE   Cache
     );
 
-/*! \typedef XENBUS_GNTTAB_MAP_FOREIGN_PAGES
+/*! \typedef XENBUS_GNTTAB_MAP_FOREIGN_PAGES_V1
     \brief Map foreign memory pages into the system address space
 
     \param Interface The interface header
     \param Domain The domid of the foreign domain that granted the pages
-    \param NumberPages Number of pages to map
+    \param NumberPages Number of pages to map (1 to 
XENBUS_GNTTAB_MAP_COUNT_MAX)
     \param References Array of grant reference numbers shared by the foreign 
domain
     \param ReadOnly If TRUE, pages are mapped with read-only access
-    \param Address The physical address that the foreign pages are mapped under
+    \param Address Receives the physical address that the foreign pages
+    are mapped under, or zero if no mapping was allocated
+
+    On a page-level failure, successfully mapped pages are unmapped and Address
+    is set to zero.
+
+    All hypercall-level failures are fatal.
 */
+typedef NTSTATUS
+(*XENBUS_GNTTAB_MAP_FOREIGN_PAGES_V1)(
+    _In_ PINTERFACE             Interface,
+    _In_ USHORT                 Domain,
+    _In_ ULONG                  NumberPages,
+    _In_ PULONG                 References,
+    _In_ BOOLEAN                ReadOnly,
+    _Out_ PHYSICAL_ADDRESS      *Address
+    );
+
+// Total mapping size is limited by the MDL byte count (less than 4 GiB).
+#define XENBUS_GNTTAB_MAP_COUNT_MAX  0xFFFFF
+
+// Maximum number of pages accepted by the map/unmap functions.
+#define XENBUS_GNTTAB_MAP_BATCH_COUNT_MAX  256
+
+/*! \typedef XENBUS_GNTTAB_CREATE_MAPPING
+    \brief Create an empty mapping for a contiguous range of foreign pages
 
+    \param Interface The interface header
+    \param Domain The domid of the foreign domain that granted the pages
+    \param NumberPages Total page count (1 to XENBUS_GNTTAB_MAP_COUNT_MAX)
+    \param ReadOnly If TRUE, pages will be mapped with read-only access
+    \param Mapping Receives the mapping handle, or NULL on failure
+
+    Use XENBUS_GNTTAB_MAP_FOREIGN_PAGES_V2 to populate the mapping.
+    Domain and ReadOnly are constant for the lifetime of the mapping.
+    The mapping remains allocated until it's freed by
+    XENBUS_GNTTAB_DESTROY_MAPPING.
+*/
+_IRQL_requires_(PASSIVE_LEVEL)
 typedef NTSTATUS
-(*XENBUS_GNTTAB_MAP_FOREIGN_PAGES)(
-    _In_ PINTERFACE         Interface,
-    _In_ USHORT             Domain,
-    _In_ ULONG              NumberPages,
-    _In_ PULONG             References,
-    _In_ BOOLEAN            ReadOnly,
-    _Out_ PHYSICAL_ADDRESS  *Address
+(*XENBUS_GNTTAB_CREATE_MAPPING)(
+    _In_ PINTERFACE                  Interface,
+    _In_ USHORT                      Domain,
+    _In_ ULONG                       NumberPages,
+    _In_ BOOLEAN                     ReadOnly,
+    _Outptr_ PXENBUS_GNTTAB_MAPPING  *Mapping
+    );
+
+/*! \typedef XENBUS_GNTTAB_MAP_FOREIGN_PAGES_V2
+    \brief Map a batch of foreign pages within an existing mapping
+
+    \param Interface The interface header
+    \param Mapping The mapping handle
+    \param Offset Index of the first page within the mapping
+    \param NumberPages Batch size (1 to XENBUS_GNTTAB_MAP_BATCH_COUNT_MAX)
+    \param References Array of grant reference numbers shared by the foreign 
domain
+    \param Results One status per page, in reference order, set only after
+    a successful hypercall
+    \return The first failed page hypervisor error, or an error processing the 
batch
+
+    The batch must not contain any pages that are already mapped.
+    Successful pages remain mapped on partial failure, the caller is 
responsible
+    for managing page state. Failed pages may be retried using their offsets.
+
+    All hypercall-level failures are fatal.
+*/
+_IRQL_requires_(PASSIVE_LEVEL)
+typedef NTSTATUS
+(*XENBUS_GNTTAB_MAP_FOREIGN_PAGES_V2)(
+    _In_ PINTERFACE                      Interface,
+    _In_ PXENBUS_GNTTAB_MAPPING          Mapping,
+    _In_ ULONG                           Offset,
+    _In_ ULONG                           NumberPages,
+    _In_reads_(NumberPages) PULONG       References,
+    _Out_writes_(NumberPages) PNTSTATUS  Results
     );
 
-/*! \typedef XENBUS_GNTTAB_UNMAP_FOREIGN_PAGES
+/*! \typedef XENBUS_GNTTAB_GET_MAPPING_ADDRESS
+    \brief Get the base address of a fully mapped memory range
+
+    \param Interface The interface header
+    \param Mapping The mapping handle
+    \param Address Receives the physical address, or zero on failure
+
+    All pages in the memory range must be successfully mapped.
+*/
+_IRQL_requires_(PASSIVE_LEVEL)
+typedef NTSTATUS
+(*XENBUS_GNTTAB_GET_MAPPING_ADDRESS)(
+    _In_ PINTERFACE              Interface,
+    _In_ PXENBUS_GNTTAB_MAPPING  Mapping,
+    _Out_ PPHYSICAL_ADDRESS      Address
+    );
+
+/*! \typedef XENBUS_GNTTAB_UNMAP_FOREIGN_PAGES_V1
     \brief Unmap foreign memory pages from the system address space
 
     \param Interface The interface header
     \param Address The physical address that the foreign pages are mapped under
+
+    All page-level unmap failures are fatal.
+    All hypercall-level failures are fatal.
 */
 typedef NTSTATUS
-(*XENBUS_GNTTAB_UNMAP_FOREIGN_PAGES)(
-    _In_ PINTERFACE         Interface,
-    _In_ PHYSICAL_ADDRESS   Address
+(*XENBUS_GNTTAB_UNMAP_FOREIGN_PAGES_V1)(
+    _In_ PINTERFACE        Interface,
+    _In_ PHYSICAL_ADDRESS  Address
+    );
+
+/*! \typedef XENBUS_GNTTAB_UNMAP_FOREIGN_PAGES_V2
+    \brief Unmap a batch of foreign pages from an existing mapping
+
+    \param Interface The interface header
+    \param Mapping The mapping handle
+    \param Offset Index of the first page within the mapping
+    \param NumberPages Batch size (1 to XENBUS_GNTTAB_MAP_BATCH_COUNT_MAX)
+    \param Results One status per page, in batch order, set only after
+    a successful hypercall (not mapped pages report STATUS_SUCCESS)
+    \return The first failed page hypervisor error, or an error processing the 
batch
+
+    The same batch can be retried after a partial failure.
+
+    All hypercall-level failures are fatal.
+*/
+_IRQL_requires_(PASSIVE_LEVEL)
+typedef NTSTATUS
+(*XENBUS_GNTTAB_UNMAP_FOREIGN_PAGES_V2)(
+    _In_ PINTERFACE                      Interface,
+    _In_ PXENBUS_GNTTAB_MAPPING          Mapping,
+    _In_ ULONG                           Offset,
+    _In_ ULONG                           NumberPages,
+    _Out_writes_(NumberPages) PNTSTATUS  Results
+    );
+
+/*! \typedef XENBUS_GNTTAB_DESTROY_MAPPING
+    \brief Free an empty mapping and invalidate its handle
+
+    \param Interface The interface header
+    \param Mapping The mapping handle
+
+    All pages in the mapping must be already unmapped.
+*/
+_IRQL_requires_(PASSIVE_LEVEL)
+typedef NTSTATUS
+(*XENBUS_GNTTAB_DESTROY_MAPPING)(
+    _In_ PINTERFACE              Interface,
+    _In_ PXENBUS_GNTTAB_MAPPING  Mapping
     );
 
 // {763679C5-E5C2-4A6D-8B88-6BB02EC42D8E}
@@ -239,16 +368,16 @@ DEFINE_GUID(GUID_XENBUS_GNTTAB_INTERFACE,
     \ingroup interfaces
 */
 struct _XENBUS_GNTTAB_INTERFACE_V2 {
-    INTERFACE                           Interface;
-    XENBUS_GNTTAB_ACQUIRE               GnttabAcquire;
-    XENBUS_GNTTAB_RELEASE               GnttabRelease;
-    XENBUS_GNTTAB_CREATE_CACHE_V1       GnttabCreateCacheVersion1;
-    XENBUS_GNTTAB_PERMIT_FOREIGN_ACCESS GnttabPermitForeignAccess;
-    XENBUS_GNTTAB_REVOKE_FOREIGN_ACCESS GnttabRevokeForeignAccess;
-    XENBUS_GNTTAB_GET_REFERENCE         GnttabGetReference;
-    XENBUS_GNTTAB_DESTROY_CACHE         GnttabDestroyCache;
-    XENBUS_GNTTAB_MAP_FOREIGN_PAGES     GnttabMapForeignPages;
-    XENBUS_GNTTAB_UNMAP_FOREIGN_PAGES   GnttabUnmapForeignPages;
+    INTERFACE                             Interface;
+    XENBUS_GNTTAB_ACQUIRE                 GnttabAcquire;
+    XENBUS_GNTTAB_RELEASE                 GnttabRelease;
+    XENBUS_GNTTAB_CREATE_CACHE_V1         GnttabCreateCacheVersion1;
+    XENBUS_GNTTAB_PERMIT_FOREIGN_ACCESS   GnttabPermitForeignAccess;
+    XENBUS_GNTTAB_REVOKE_FOREIGN_ACCESS   GnttabRevokeForeignAccess;
+    XENBUS_GNTTAB_GET_REFERENCE           GnttabGetReference;
+    XENBUS_GNTTAB_DESTROY_CACHE           GnttabDestroyCache;
+    XENBUS_GNTTAB_MAP_FOREIGN_PAGES_V1    GnttabMapForeignPagesV4;
+    XENBUS_GNTTAB_UNMAP_FOREIGN_PAGES_V1  GnttabUnmapForeignPagesV4;
 };
 
 /*! \struct _XENBUS_GNTTAB_INTERFACE_V3
@@ -256,17 +385,17 @@ struct _XENBUS_GNTTAB_INTERFACE_V2 {
     \ingroup interfaces
 */
 struct _XENBUS_GNTTAB_INTERFACE_V3 {
-    INTERFACE                           Interface;
-    XENBUS_GNTTAB_ACQUIRE               GnttabAcquire;
-    XENBUS_GNTTAB_RELEASE               GnttabRelease;
-    XENBUS_GNTTAB_CREATE_CACHE_V1       GnttabCreateCacheVersion1;
-    XENBUS_GNTTAB_PERMIT_FOREIGN_ACCESS GnttabPermitForeignAccess;
-    XENBUS_GNTTAB_REVOKE_FOREIGN_ACCESS GnttabRevokeForeignAccess;
-    XENBUS_GNTTAB_GET_REFERENCE         GnttabGetReference;
-    XENBUS_GNTTAB_QUERY_REFERENCE       GnttabQueryReference;
-    XENBUS_GNTTAB_DESTROY_CACHE         GnttabDestroyCache;
-    XENBUS_GNTTAB_MAP_FOREIGN_PAGES     GnttabMapForeignPages;
-    XENBUS_GNTTAB_UNMAP_FOREIGN_PAGES   GnttabUnmapForeignPages;
+    INTERFACE                             Interface;
+    XENBUS_GNTTAB_ACQUIRE                 GnttabAcquire;
+    XENBUS_GNTTAB_RELEASE                 GnttabRelease;
+    XENBUS_GNTTAB_CREATE_CACHE_V1         GnttabCreateCacheVersion1;
+    XENBUS_GNTTAB_PERMIT_FOREIGN_ACCESS   GnttabPermitForeignAccess;
+    XENBUS_GNTTAB_REVOKE_FOREIGN_ACCESS   GnttabRevokeForeignAccess;
+    XENBUS_GNTTAB_GET_REFERENCE           GnttabGetReference;
+    XENBUS_GNTTAB_QUERY_REFERENCE         GnttabQueryReference;
+    XENBUS_GNTTAB_DESTROY_CACHE           GnttabDestroyCache;
+    XENBUS_GNTTAB_MAP_FOREIGN_PAGES_V1    GnttabMapForeignPagesV4;
+    XENBUS_GNTTAB_UNMAP_FOREIGN_PAGES_V1  GnttabUnmapForeignPagesV4;
 };
 
 /*! \struct _XENBUS_GNTTAB_INTERFACE_V4
@@ -274,20 +403,41 @@ struct _XENBUS_GNTTAB_INTERFACE_V3 {
     \ingroup interfaces
 */
 struct _XENBUS_GNTTAB_INTERFACE_V4 {
-    INTERFACE                           Interface;
-    XENBUS_GNTTAB_ACQUIRE               GnttabAcquire;
-    XENBUS_GNTTAB_RELEASE               GnttabRelease;
-    XENBUS_GNTTAB_CREATE_CACHE          GnttabCreateCache;
-    XENBUS_GNTTAB_PERMIT_FOREIGN_ACCESS GnttabPermitForeignAccess;
-    XENBUS_GNTTAB_REVOKE_FOREIGN_ACCESS GnttabRevokeForeignAccess;
-    XENBUS_GNTTAB_GET_REFERENCE         GnttabGetReference;
-    XENBUS_GNTTAB_QUERY_REFERENCE       GnttabQueryReference;
-    XENBUS_GNTTAB_DESTROY_CACHE         GnttabDestroyCache;
-    XENBUS_GNTTAB_MAP_FOREIGN_PAGES     GnttabMapForeignPages;
-    XENBUS_GNTTAB_UNMAP_FOREIGN_PAGES   GnttabUnmapForeignPages;
+    INTERFACE                             Interface;
+    XENBUS_GNTTAB_ACQUIRE                 GnttabAcquire;
+    XENBUS_GNTTAB_RELEASE                 GnttabRelease;
+    XENBUS_GNTTAB_CREATE_CACHE            GnttabCreateCache;
+    XENBUS_GNTTAB_PERMIT_FOREIGN_ACCESS   GnttabPermitForeignAccess;
+    XENBUS_GNTTAB_REVOKE_FOREIGN_ACCESS   GnttabRevokeForeignAccess;
+    XENBUS_GNTTAB_GET_REFERENCE           GnttabGetReference;
+    XENBUS_GNTTAB_QUERY_REFERENCE         GnttabQueryReference;
+    XENBUS_GNTTAB_DESTROY_CACHE           GnttabDestroyCache;
+    XENBUS_GNTTAB_MAP_FOREIGN_PAGES_V1    GnttabMapForeignPagesV4;
+    XENBUS_GNTTAB_UNMAP_FOREIGN_PAGES_V1  GnttabUnmapForeignPagesV4;
+};
+
+/*! \struct _XENBUS_GNTTAB_INTERFACE_V5
+    \brief GNTTAB interface version 5
+    \ingroup interfaces
+*/
+struct _XENBUS_GNTTAB_INTERFACE_V5 {
+    INTERFACE                             Interface;
+    XENBUS_GNTTAB_ACQUIRE                 GnttabAcquire;
+    XENBUS_GNTTAB_RELEASE                 GnttabRelease;
+    XENBUS_GNTTAB_CREATE_CACHE            GnttabCreateCache;
+    XENBUS_GNTTAB_PERMIT_FOREIGN_ACCESS   GnttabPermitForeignAccess;
+    XENBUS_GNTTAB_REVOKE_FOREIGN_ACCESS   GnttabRevokeForeignAccess;
+    XENBUS_GNTTAB_GET_REFERENCE           GnttabGetReference;
+    XENBUS_GNTTAB_QUERY_REFERENCE         GnttabQueryReference;
+    XENBUS_GNTTAB_DESTROY_CACHE           GnttabDestroyCache;
+    XENBUS_GNTTAB_CREATE_MAPPING          GnttabCreateMapping;
+    XENBUS_GNTTAB_MAP_FOREIGN_PAGES_V2    GnttabMapForeignPages;
+    XENBUS_GNTTAB_GET_MAPPING_ADDRESS     GnttabGetMappingAddress;
+    XENBUS_GNTTAB_UNMAP_FOREIGN_PAGES_V2  GnttabUnmapForeignPages;
+    XENBUS_GNTTAB_DESTROY_MAPPING         GnttabDestroyMapping;
 };
 
-typedef struct _XENBUS_GNTTAB_INTERFACE_V4 XENBUS_GNTTAB_INTERFACE, 
*PXENBUS_GNTTAB_INTERFACE;
+typedef struct _XENBUS_GNTTAB_INTERFACE_V5 XENBUS_GNTTAB_INTERFACE, 
*PXENBUS_GNTTAB_INTERFACE;
 
 /*! \def XENBUS_GNTTAB
     \brief Macro at assist in method invocation
@@ -298,6 +448,6 @@ typedef struct _XENBUS_GNTTAB_INTERFACE_V4 
XENBUS_GNTTAB_INTERFACE, *PXENBUS_GNT
 #endif  // _WINDLL
 
 #define XENBUS_GNTTAB_INTERFACE_VERSION_MIN 2
-#define XENBUS_GNTTAB_INTERFACE_VERSION_MAX 4
+#define XENBUS_GNTTAB_INTERFACE_VERSION_MAX 5
 
 #endif  // _XENBUS_GNTTAB_INTERFACE_H
diff --git a/src/xeniface.inf b/src/xeniface.inf
index 142f5a5..20fcf1f 100644
--- a/src/xeniface.inf
+++ b/src/xeniface.inf
@@ -63,9 +63,9 @@ 
xenagent_@MAJOR_VERSION@_@MINOR_VERSION@_@MICRO_VERSION@_@BUILD_NUMBER@.dll,xena
 
 [Inst.NT@INF_ARCH@]
 %XenIfaceName%=XenIface_Inst,\
-XENBUS\VEN_@VENDOR_PREFIX@@VENDOR_DEVICE_ID@&DEV_IFACE&REV_0900000B,\
-XENBUS\VEN_@VENDOR_PREFIX@0001&DEV_IFACE&REV_0900000B,\
-XENBUS\VEN_@VENDOR_PREFIX@0002&DEV_IFACE&REV_0900000B
+XENBUS\VEN_@VENDOR_PREFIX@@VENDOR_DEVICE_ID@&DEV_IFACE&REV_0900000D,\
+XENBUS\VEN_@VENDOR_PREFIX@0001&DEV_IFACE&REV_0900000D,\
+XENBUS\VEN_@VENDOR_PREFIX@0002&DEV_IFACE&REV_0900000D
 
 [XenIface_Inst]
 CopyFiles=XenIface_CopyFiles
diff --git a/src/xeniface/fdo.c b/src/xeniface/fdo.c
index 8911eac..ae3ebf1 100644
--- a/src/xeniface/fdo.c
+++ b/src/xeniface/fdo.c
@@ -858,6 +858,10 @@ FdoD3ToD0(
 
     KeLowerIrql(Irql);
 
+    AcquireMutex(&Fdo->GnttabLock);
+    Fdo->GnttabBusy = FALSE;
+    ReleaseMutex(&Fdo->GnttabLock);
+
     __FdoSetDevicePowerState(Fdo, PowerDeviceD0);
 
     PowerState.DeviceState = PowerDeviceD0;
@@ -2482,6 +2486,11 @@ FdoCreate(
     InitializeListHead(&Fdo->IrpList);
 
     KeInitializeSpinLock(&Fdo->GnttabCacheLock);
+    InitializeMutex(&Fdo->GnttabLock);
+    InitializeListHead(&Fdo->MappingList);
+    InitializeListHead(&Fdo->GnttabRetryList);
+    KeInitializeEvent(&Fdo->GnttabContextsEmpty, NotificationEvent, TRUE);
+    Fdo->GnttabBusy = TRUE;
 
     status = IoCsqInitializeEx(&Fdo->IrpQueue,
                                CsqInsertIrpEx,
@@ -2493,6 +2502,10 @@ FdoCreate(
     if (!NT_SUCCESS(status))
         goto fail14;
 
+    status = ThreadCreate(GnttabRetryThread, Fdo, &Fdo->GnttabRetryThread);
+    if (!NT_SUCCESS(status))
+        goto fail14;
+
     Info("%p (%s)\n",
          FunctionDeviceObject,
          __FdoGetName(Fdo));
@@ -2505,6 +2518,16 @@ FdoCreate(
 fail14:
     Error("fail14\n");
 
+    ASSERT(Fdo->GnttabContextCount == 0);
+    ASSERT(IsListEmpty(&Fdo->MappingList));
+    ASSERT(IsListEmpty(&Fdo->GnttabRetryList));
+    RtlZeroMemory(&Fdo->GnttabLock, sizeof(Fdo->GnttabLock));
+    RtlZeroMemory(&Fdo->MappingList, sizeof(Fdo->MappingList));
+    RtlZeroMemory(&Fdo->GnttabRetryList, sizeof(Fdo->GnttabRetryList));
+    RtlZeroMemory(&Fdo->GnttabContextsEmpty, sizeof(Fdo->GnttabContextsEmpty));
+    Fdo->GnttabBusy = FALSE;
+    Fdo->LastMappingId = 0;
+
     RtlZeroMemory(&Fdo->GnttabCacheLock, sizeof (KSPIN_LOCK));
     ASSERT(IsListEmpty(&Fdo->IrpList));
     RtlZeroMemory(&Fdo->IrpList, sizeof (LIST_ENTRY));
@@ -2625,8 +2648,22 @@ FdoDestroy(
          FunctionDeviceObject,
          __FdoGetName(Fdo));
 
+    ThreadAlert(Fdo->GnttabRetryThread);
+    ThreadJoin(Fdo->GnttabRetryThread);
+    Fdo->GnttabRetryThread = NULL;
+
     Dx->Fdo = NULL;
 
+    ASSERT(Fdo->GnttabContextCount == 0);
+    ASSERT(IsListEmpty(&Fdo->MappingList));
+    ASSERT(IsListEmpty(&Fdo->GnttabRetryList));
+    RtlZeroMemory(&Fdo->GnttabLock, sizeof(Fdo->GnttabLock));
+    RtlZeroMemory(&Fdo->MappingList, sizeof(Fdo->MappingList));
+    RtlZeroMemory(&Fdo->GnttabRetryList, sizeof(Fdo->GnttabRetryList));
+    RtlZeroMemory(&Fdo->GnttabContextsEmpty, sizeof(Fdo->GnttabContextsEmpty));
+    Fdo->GnttabBusy = FALSE;
+    Fdo->LastMappingId = 0;
+
     RtlZeroMemory(&Fdo->GnttabCacheLock, sizeof (KSPIN_LOCK));
     ASSERT(IsListEmpty(&Fdo->IrpList));
     RtlZeroMemory(&Fdo->IrpList, sizeof (LIST_ENTRY));
diff --git a/src/xeniface/fdo.h b/src/xeniface/fdo.h
index 69070cb..413e6c4 100644
--- a/src/xeniface/fdo.h
+++ b/src/xeniface/fdo.h
@@ -102,6 +102,15 @@ typedef struct _XENIFACE_FDO {
 
     PXENBUS_GNTTAB_CACHE            GnttabCache;
 
+    BOOLEAN                         GnttabBusy;
+    XENIFACE_MUTEX                  GnttabLock;
+    LIST_ENTRY                      MappingList;
+    LIST_ENTRY                      GnttabRetryList;
+    PXENIFACE_THREAD                GnttabRetryThread;
+    KEVENT                          GnttabContextsEmpty;
+    ULONG                           GnttabContextCount;
+    ULONGLONG                       LastMappingId;
+
     #define MAX_SESSIONS    (65536)
 
     int                             WmiReady;
diff --git a/src/xeniface/ioctl_gnttab.c b/src/xeniface/ioctl_gnttab.c
index 12b1c0a..44b7809 100644
--- a/src/xeniface/ioctl_gnttab.c
+++ b/src/xeniface/ioctl_gnttab.c
@@ -38,6 +38,405 @@
 
 #define GNTTAB_MAX_PAGES    (MAXULONG / PAGE_SIZE)
 
+#ifndef XENIFACE_GNTTAB_CLEANUP_TIMEOUT_SECONDS
+#define XENIFACE_GNTTAB_CLEANUP_TIMEOUT_SECONDS 60
+#endif
+
+C_ASSERT(XENIFACE_GNTTAB_CLEANUP_TIMEOUT_SECONDS > 0);
+C_ASSERT(XENIFACE_GNTTAB_CLEANUP_TIMEOUT_SECONDS <= MAXULONG);
+
+#define GNTTAB_CLEANUP_TIMEOUT 
((ULONGLONG)XENIFACE_GNTTAB_CLEANUP_TIMEOUT_SECONDS * 10000000)
+
+_IRQL_requires_(PASSIVE_LEVEL)
+_Ret_maybenull_
+PXENIFACE_GNTTAB_CONTEXT
+GnttabAllocateContext(
+    _In_ PXENIFACE_FDO        Fdo
+    )
+{
+    PXENIFACE_GNTTAB_CONTEXT  Context;
+
+    Context = __AllocatePoolWithTag(NonPagedPool, sizeof(*Context), 
XENIFACE_POOL_TAG);
+    if (Context != NULL) {
+        Context->Process = PsGetCurrentProcess();
+        ObReferenceObject(Context->Process);
+        Fdo->GnttabContextCount++;
+        KeClearEvent(&Fdo->GnttabContextsEmpty);
+    }
+
+    return Context;
+}
+
+_IRQL_requires_(PASSIVE_LEVEL)
+VOID
+GnttabFreeContext(
+    _In_ PXENIFACE_FDO                Fdo,
+    _Inout_ PXENIFACE_GNTTAB_CONTEXT  Context
+    )
+{
+    switch (Context->Type) {
+    case XENIFACE_GNTTAB_CONTEXT_GRANT:
+        break;
+
+    case XENIFACE_GNTTAB_CONTEXT_MAP:
+        ASSERT(Context->Map.Mapping == NULL);
+        if (Context->Map.NotifyChannel != NULL)
+            EvtchnDereference(Fdo, Context->Map.NotifyChannel);
+        break;
+
+    default:
+        ASSERT(FALSE);
+        break;
+    }
+
+    if (Context->CancelWorkItem != NULL)
+        IoFreeWorkItem(Context->CancelWorkItem);
+
+    ObDereferenceObject(Context->Process);
+    RtlZeroMemory(Context, sizeof(*Context));
+    __FreePoolWithTag(Context, XENIFACE_POOL_TAG);
+
+    ASSERT(Fdo->GnttabContextCount != 0);
+    if (--Fdo->GnttabContextCount == 0)
+        KeSetEvent(&Fdo->GnttabContextsEmpty, IO_NO_INCREMENT, FALSE);
+}
+
+_IRQL_requires_(PASSIVE_LEVEL)
+NTSTATUS
+GnttabCreateMap(
+    _In_ PXENIFACE_FDO                Fdo,
+    _Inout_ PXENIFACE_GNTTAB_CONTEXT  Context
+    )
+{
+    return XENBUS_GNTTAB(CreateMapping, &Fdo->GnttabInterface,
+                         Context->RemoteDomain, Context->NumberPages,
+                         (Context->Flags & XENIFACE_GNTTAB_READONLY) != 0,
+                         &Context->Map.Mapping);
+}
+
+_IRQL_requires_(PASSIVE_LEVEL)
+NTSTATUS
+GnttabMapBatch(
+    _In_ PXENIFACE_FDO                       Fdo,
+    _Inout_ PXENIFACE_GNTTAB_CONTEXT         Context,
+    _In_reads_(Context->NumberPages) PULONG  References
+    )
+{
+    NTSTATUS                                 
Results[XENBUS_GNTTAB_MAP_BATCH_COUNT_MAX];
+    ULONG                                    Offset;
+    ULONG                                    Count;
+    NTSTATUS                                 Status;
+
+    Status = GnttabCreateMap(Fdo, Context);
+    if (!NT_SUCCESS(Status))
+        return Status;
+
+    for (Offset = 0; Offset < Context->NumberPages; Offset += Count) {
+        Count = min(Context->NumberPages - Offset, 
XENBUS_GNTTAB_MAP_BATCH_COUNT_MAX);
+        Status = XENBUS_GNTTAB(MapForeignPages, &Fdo->GnttabInterface,
+                               Context->Map.Mapping, Offset, Count, 
&References[Offset], Results);
+        if (!NT_SUCCESS(Status))
+            return Status; // ReleaseMap owns rollback, including this partial 
batch
+    }
+    return STATUS_SUCCESS;
+}
+
+_IRQL_requires_(PASSIVE_LEVEL)
+NTSTATUS
+GnttabCreateUserView(
+    _In_ PXENIFACE_FDO                Fdo,
+    _Inout_ PXENIFACE_GNTTAB_CONTEXT  Context
+    )
+{
+    PHYSICAL_ADDRESS                  Address;
+    NTSTATUS                          Status;
+
+    Status = XENBUS_GNTTAB(GetMappingAddress, &Fdo->GnttabInterface,
+                           Context->Map.Mapping, &Address);
+    if (!NT_SUCCESS(Status) || Context->UserVa != NULL)
+        return Status;
+
+    Context->KernelVa = MmMapIoSpace(Address, Context->NumberPages * 
PAGE_SIZE, MmCached);
+    if (Context->KernelVa == NULL)
+        return STATUS_INSUFFICIENT_RESOURCES;
+
+    Context->Mdl = IoAllocateMdl(Context->KernelVa, Context->NumberPages * 
PAGE_SIZE, FALSE, FALSE, NULL);
+    if (Context->Mdl == NULL) {
+        Status = STATUS_NO_MEMORY;
+        goto fail;
+    }
+
+    MmBuildMdlForNonPagedPool(Context->Mdl);
+
+#pragma prefast(suppress:6320)
+    try {
+        Context->UserVa = MmMapLockedPagesSpecifyCache(Context->Mdl, UserMode,
+                                                       MmCached, NULL, FALSE,
+                                                       NormalPagePriority |
+                                                       ((Context->Flags & 
XENIFACE_GNTTAB_READONLY) ? MdlMappingNoWrite : 0));
+        Status = Context->UserVa != NULL ? STATUS_SUCCESS : STATUS_NO_MEMORY;
+    } except (EXCEPTION_EXECUTE_HANDLER) {
+        Status = GetExceptionCode();
+    }
+
+    if (NT_SUCCESS(Status))
+        return Status;
+
+    IoFreeMdl(Context->Mdl);
+    Context->Mdl = NULL;
+fail:
+    MmUnmapIoSpace(Context->KernelVa, Context->NumberPages * PAGE_SIZE);
+    Context->KernelVa = NULL;
+    return Status;
+}
+
+_IRQL_requires_(PASSIVE_LEVEL)
+static VOID
+GnttabUnmapView(
+    _Inout_ PXENIFACE_GNTTAB_CONTEXT  Context
+    )
+{
+    KAPC_STATE                        ApcState;
+    BOOLEAN                           Attach = Context->UserVa != NULL && 
PsGetCurrentProcess() != Context->Process;
+
+    if (Context->Map.NotifyOnCleanup && Context->KernelVa != NULL &&
+        (Context->Flags & XENIFACE_GNTTAB_USE_NOTIFY_OFFSET)) {
+        ((volatile CHAR *)Context->KernelVa)[Context->NotifyOffset] = 0;
+        KeMemoryBarrier();
+    }
+
+    if (Attach)
+        KeStackAttachProcess(Context->Process, &ApcState);
+
+    if (Context->UserVa != NULL) {
+        MmUnmapLockedPages(Context->UserVa, Context->Mdl);
+        Context->UserVa = NULL;
+    }
+
+    if (Attach)
+        KeUnstackDetachProcess(&ApcState);
+
+    if (Context->Mdl != NULL) {
+        IoFreeMdl(Context->Mdl);
+        Context->Mdl = NULL;
+    }
+
+    if (Context->KernelVa != NULL) {
+        MmUnmapIoSpace(Context->KernelVa, Context->NumberPages * PAGE_SIZE);
+        Context->KernelVa = NULL;
+    }
+}
+
+_IRQL_requires_(PASSIVE_LEVEL)
+static NTSTATUS
+GnttabUnmapBatch(
+    _In_ PXENIFACE_FDO                Fdo,
+    _Inout_ PXENIFACE_GNTTAB_CONTEXT  Context
+    )
+{
+    NTSTATUS                          
Results[XENBUS_GNTTAB_MAP_BATCH_COUNT_MAX];
+    NTSTATUS                          Status;
+    NTSTATUS                          FirstError = STATUS_SUCCESS;
+    ULONG                             Offset;
+    ULONG                             Count;
+    ULONG                             Index;
+    ULONG                             Remaining = 0;
+
+    for (Offset = 0; Offset < Context->NumberPages; Offset += Count) {
+        Count = min(Context->NumberPages - Offset, 
XENBUS_GNTTAB_MAP_BATCH_COUNT_MAX);
+        // A xenbus batch failure may leave Results unmodified.
+        for (Index = 0; Index < Count; Index++)
+            Results[Index] = STATUS_UNSUCCESSFUL;
+        Status = XENBUS_GNTTAB(UnmapForeignPages, &Fdo->GnttabInterface,
+                               Context->Map.Mapping, Offset, Count, Results);
+        if (!NT_SUCCESS(Status)) {
+            if (NT_SUCCESS(FirstError))
+                FirstError = Status;
+            for (Index = 0; Index < Count; Index++) {
+                if (!NT_SUCCESS(Results[Index]))
+                    Remaining++;
+            }
+        }
+        // Continue after errors. Xenbus invalidates handles for successfully
+        // unmapped pages, so repeated  passes are safe.
+    }
+
+    // Reset the deadline only when the remaining page count decreases.
+    if (Remaining < Context->Map.CleanupRemaining) {
+        Context->Map.CleanupRemaining = Remaining;
+        Context->Map.CleanupProgressTime = KeQueryUnbiasedInterruptTime();
+    }
+
+    Status = FirstError;
+    if (NT_SUCCESS(Status)) {
+        Status = XENBUS_GNTTAB(DestroyMapping, &Fdo->GnttabInterface, 
Context->Map.Mapping);
+        if (NT_SUCCESS(Status))
+            Context->Map.Mapping = NULL;
+    }
+
+    if (!NT_SUCCESS(Status) &&
+        KeQueryUnbiasedInterruptTime() - Context->Map.CleanupProgressTime >= 
GNTTAB_CLEANUP_TIMEOUT)
+        BUG("foreign mapping cleanup made no progress before deadline");
+
+    return Status;
+}
+
+_IRQL_requires_(PASSIVE_LEVEL)
+static VOID
+GnttabFinishMapCleanup(
+    _In_ PXENIFACE_FDO                Fdo,
+    _Inout_ PXENIFACE_GNTTAB_CONTEXT  Context
+    )
+{
+    NTSTATUS                          Status;
+
+    if (Context->Map.NotifyOnCleanup && (Context->Flags & 
XENIFACE_GNTTAB_USE_NOTIFY_PORT)) {
+        // Legacy maps have no mapping ID and notify only while the original
+        // channel is registered. Batched maps may send after owner close.
+        Status = Context->Map.NotifyChannel != NULL ?
+            EvtchnSend(Fdo, Context->Map.NotifyChannel, Context->Map.MappingId 
== 0) : STATUS_NOT_FOUND;
+
+        if (!NT_SUCCESS(Status))
+            Error("failed to notify port %lu: 0x%x\n", Context->NotifyPort, 
Status);
+    }
+    GnttabFreeContext(Fdo, Context);
+}
+
+_IRQL_requires_(PASSIVE_LEVEL)
+VOID
+GnttabReleaseMap(
+    _In_ PXENIFACE_FDO                Fdo,
+    _Inout_ PXENIFACE_GNTTAB_CONTEXT  Context
+    )
+{
+    NTSTATUS                          Status;
+
+    GnttabUnmapView(Context);
+    if (Context->Map.Mapping != NULL) {
+        Context->Map.CleanupRemaining = Context->NumberPages;
+        Context->Map.CleanupProgressTime = KeQueryUnbiasedInterruptTime();
+        Status = GnttabUnmapBatch(Fdo, Context);
+        if (!NT_SUCCESS(Status)) {
+            // This context is no longer reachable by a client. Keep both its
+            // mapping and interface lifetime until the retry thread finishes.
+            Context->FileObject = NULL;
+            Error("grant unmap failed: 0x%x; retaining mapping %llu for 
cleanup retry\n",
+                  Status, Context->Map.MappingId);
+            InsertTailList(&Fdo->GnttabRetryList, &Context->Entry);
+            ThreadWake(Fdo->GnttabRetryThread);
+            return;
+        }
+    }
+    GnttabFinishMapCleanup(Fdo, Context);
+}
+
+_IRQL_requires_(PASSIVE_LEVEL)
+NTSTATUS
+GnttabRetryThread(
+    _In_ PXENIFACE_THREAD     Self,
+    _In_ PVOID                Argument
+    )
+{
+    PXENIFACE_FDO             Fdo = Argument;
+    PKEVENT                   Event = ThreadGetEvent(Self);
+    LARGE_INTEGER             Delay;
+    PLIST_ENTRY               Entry, Next;
+    PXENIFACE_GNTTAB_CONTEXT  Context;
+    BOOLEAN                   Retry;
+
+    Delay.QuadPart = -10000000; // One second between failed cleanup passes.
+    Retry = FALSE;
+    do {
+        (VOID)KeWaitForSingleObject(Event, Executive, KernelMode, FALSE, Retry 
? &Delay : NULL);
+        KeClearEvent(Event);
+        AcquireMutex(&Fdo->GnttabLock);
+        for (Entry = Fdo->GnttabRetryList.Flink; Entry != 
&Fdo->GnttabRetryList; Entry = Next) {
+            Next = Entry->Flink;
+            Context = CONTAINING_RECORD(Entry, XENIFACE_GNTTAB_CONTEXT, Entry);
+            if (NT_SUCCESS(GnttabUnmapBatch(Fdo, Context))) {
+                RemoveEntryList(Entry);
+                GnttabFinishMapCleanup(Fdo, Context);
+            }
+        }
+
+        Retry = !IsListEmpty(&Fdo->GnttabRetryList);
+        ReleaseMutex(&Fdo->GnttabLock);
+    } while (!ThreadIsAlerted(Self) || Retry);
+    return STATUS_SUCCESS;
+}
+
+_IRQL_requires_(PASSIVE_LEVEL)
+VOID
+GnttabCleanup(
+    _In_ PXENIFACE_FDO        Fdo,
+    _In_opt_ PFILE_OBJECT     FileObject
+    )
+{
+    PLIST_ENTRY               Entry, Next;
+    PXENIFACE_GNTTAB_CONTEXT  Context;
+    XENIFACE_GNTTAB_CONTEXT   Seek = {0};
+    PIRP                      Irp;
+    KAPC_STATE                ApcState;
+    BOOLEAN                   Attach;
+    PEPROCESS                 Process;
+
+    AcquireMutex(&Fdo->GnttabLock);
+    if (FileObject == NULL)
+        Fdo->GnttabBusy = TRUE;
+
+    for (Entry = Fdo->MappingList.Flink; Entry != &Fdo->MappingList; Entry = 
Next) {
+        Next = Entry->Flink;
+        Context = CONTAINING_RECORD(Entry, XENIFACE_GNTTAB_CONTEXT, Entry);
+        if (FileObject != NULL && Context->FileObject != FileObject)
+            continue;
+
+        RemoveEntryList(Entry);
+        GnttabReleaseMap(Fdo, Context);
+    }
+
+    Seek.Cleanup = TRUE;
+    Seek.FileObject = FileObject;
+    for (Seek.Type = XENIFACE_GNTTAB_CONTEXT_GRANT; Seek.Type <= 
XENIFACE_GNTTAB_CONTEXT_MAP; Seek.Type++) {
+        while ((Irp = IoCsqRemoveNextIrp(&Fdo->IrpQueue, &Seek)) != NULL) {
+            Context = Irp->Tail.Overlay.DriverContext[0];
+            Process = Context->Process;
+            Attach = PsGetCurrentProcess() != Process;
+            if (Attach) {
+                ObReferenceObject(Process);
+                KeStackAttachProcess(Process, &ApcState);
+            }
+
+            if (Context->Type == XENIFACE_GNTTAB_CONTEXT_GRANT) {
+                GnttabFreeGrant(Fdo, Context);
+                IoFreeWorkItem(Irp->Tail.Overlay.DriverContext[1]);
+            } else {
+                GnttabFreeMap(Fdo, Context);
+            }
+
+            if (Attach) {
+                KeUnstackDetachProcess(&ApcState);
+                ObDereferenceObject(Process);
+            }
+
+            Irp->IoStatus.Status = STATUS_CANCELLED;
+            Irp->IoStatus.Information = 0;
+            IoCompleteRequest(Irp, IO_NO_INCREMENT);
+        }
+    }
+    ReleaseMutex(&Fdo->GnttabLock);
+
+    if (FileObject == NULL) {
+        // Keep the provider interfaces alive until deferred cleanup finishes.
+        // The retry thread needs GnttabLock, so wait with the mutex released.
+        (VOID)KeWaitForSingleObject(&Fdo->GnttabContextsEmpty, Executive, 
KernelMode, FALSE, NULL);
+        // The last cleanup signals while holding GnttabLock. Join that 
critical
+        // section before the FDO can tear down the lock or its provider 
interfaces.
+        AcquireMutex(&Fdo->GnttabLock);
+        ASSERT(Fdo->GnttabContextCount == 0);
+        ReleaseMutex(&Fdo->GnttabLock);
+    }
+}
+
 // Complete a canceled gnttab IRP, cleanup associated grant/map.
 _Function_class_(IO_WORKITEM_ROUTINE)
 VOID
@@ -50,7 +449,7 @@ CompleteGnttabIrp(
     PXENIFACE_FDO               Fdo = Dx->Fdo;
     PIRP                        Irp = Context;
     PXENIFACE_GNTTAB_CONTEXT    GnttabContext;
-    PIO_WORKITEM                WorkItem;
+    PIO_WORKITEM                CancelWorkItem;
     PEPROCESS                   Process;
     KAPC_STATE                  ApcState;
     BOOLEAN                     ChangeProcess;
@@ -58,7 +457,7 @@ CompleteGnttabIrp(
     ASSERT(Context != NULL);
 
     GnttabContext = Irp->Tail.Overlay.DriverContext[0];
-    WorkItem = Irp->Tail.Overlay.DriverContext[1];
+    CancelWorkItem = Irp->Tail.Overlay.DriverContext[1];
     Process = GnttabContext->Process;
 
     // The context is freed before we detach, so hold another process 
reference.
@@ -75,6 +474,9 @@ CompleteGnttabIrp(
     Trace("Irp %p, Process %p, Id %lu, Type %d, IRQL %d\n",
           Irp, GnttabContext->Process, GnttabContext->RequestId, 
GnttabContext->Type, KeGetCurrentIrql());
 
+    GnttabContext->CancelWorkItem = NULL; // The callback owns this work item 
now.
+    AcquireMutex(&Fdo->GnttabLock);
+
     switch (GnttabContext->Type) {
 
     case XENIFACE_GNTTAB_CONTEXT_GRANT:
@@ -89,11 +491,13 @@ CompleteGnttabIrp(
         ASSERT(FALSE);
     }
 
+    ReleaseMutex(&Fdo->GnttabLock);
+
     if (ChangeProcess)
         KeUnstackDetachProcess(&ApcState);
 
     ObDereferenceObject(Process);
-    IoFreeWorkItem(WorkItem);
+    IoFreeWorkItem(CancelWorkItem);
 
     Irp->IoStatus.Status = STATUS_CANCELLED;
     Irp->IoStatus.Information = 0;
@@ -371,7 +775,7 @@ IoctlGnttabPermitForeignAccess(
     // This IOCTL uses METHOD_NEITHER so we directly access user memory.
     if (ControlCode == IOCTL_XENIFACE_GNTTAB_PERMIT_FOREIGN_ACCESS) {
         // legacy IOCTL, convert the input to v2
-        Status = __CaptureUserBuffer(Buffer, InLen, &In1);
+        Status = __CaptureUserBuffer(Buffer, InLen, (PVOID *)&In1);
         if (!NT_SUCCESS(Status))
             goto fail2;
 
@@ -387,7 +791,7 @@ IoctlGnttabPermitForeignAccess(
         In->NotifyOffset = In1->NotifyOffset;
         In->NotifyPort = In1->NotifyPort;
     } else {
-        Status = __CaptureUserBuffer(Buffer, InLen, &In);
+        Status = __CaptureUserBuffer(Buffer, InLen, (PVOID *)&In);
         if (!NT_SUCCESS(Status))
             goto fail2;
     }
@@ -411,13 +815,12 @@ IoctlGnttabPermitForeignAccess(
         goto fail6;
 
     Status = STATUS_NO_MEMORY;
-    Context = __AllocatePoolWithTag(NonPagedPool, 
sizeof(XENIFACE_GNTTAB_CONTEXT), XENIFACE_POOL_TAG);
+    Context = GnttabAllocateContext(Fdo);
     if (Context == NULL)
         goto fail7;
 
     Context->Type = XENIFACE_GNTTAB_CONTEXT_GRANT;
-    Context->Process = PsGetCurrentProcess();
-    ObReferenceObject(Context->Process);
+    Context->FileObject = IoGetCurrentIrpStackLocation(Irp)->FileObject;
     Context->RemoteDomain = In->RemoteDomain;
     Context->UserVa = In->Address;
     Context->NumberPages = In->NumberPages;
@@ -493,9 +896,7 @@ fail9:
 
 fail8:
     Error("Fail8\n");
-    ObDereferenceObject(Context->Process);
-    RtlZeroMemory(Context, sizeof(*Context));
-    __FreePoolWithTag(Context, XENIFACE_POOL_TAG);
+    GnttabFreeContext(Fdo, Context);
 
 fail7:
     Error("Fail7\n");
@@ -522,7 +923,7 @@ fail1:
     return Status;
 }
 
-_IRQL_requires_max_(APC_LEVEL)
+_IRQL_requires_(PASSIVE_LEVEL)
 VOID
 GnttabFreeGrant(
     _In_ PXENIFACE_FDO                  Fdo,
@@ -534,7 +935,7 @@ GnttabFreeGrant(
     Trace("Context %p\n", Context);
 
     ASSERT(Context->Type == XENIFACE_GNTTAB_CONTEXT_GRANT);
-    ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
+    ASSERT(KeGetCurrentIrql() == PASSIVE_LEVEL);
 
     if (Context->Flags & XENIFACE_GNTTAB_USE_NOTIFY_OFFSET) {
         if (Context->KernelVa != NULL) {
@@ -559,9 +960,7 @@ GnttabFreeGrant(
 
     GnttabStopSharing(Fdo, Context, Context->NumberPages);
 
-    ObDereferenceObject(Context->Process);
-    RtlZeroMemory(Context, sizeof(*Context));
-    __FreePoolWithTag(Context, XENIFACE_POOL_TAG);
+    GnttabFreeContext(Fdo, Context);
 }
 
 DECLSPEC_NOINLINE
@@ -575,7 +974,7 @@ IoctlGnttabRevokeForeignAccess(
     )
 {
     NTSTATUS                    Status;
-    XENIFACE_GNTTAB_CONTEXT     SeekContext;
+    XENIFACE_GNTTAB_CONTEXT     SeekContext = {0};
     PIRP                        PendingIrp;
     PXENIFACE_GNTTAB_CONTEXT    Context = NULL;
 
@@ -628,295 +1027,127 @@ fail1:
 DECLSPEC_NOINLINE
 NTSTATUS
 IoctlGnttabMapForeignPages(
-    _In_ PXENIFACE_FDO                          Fdo,
-    _In_ PVOID                                  Buffer,
-    _In_ ULONG                                  InLen,
-    _In_ ULONG                                  OutLen,
-    _Inout_ PIRP                                Irp
+    _In_    PXENIFACE_FDO                     Fdo,
+    _In_    PVOID                             Buffer,
+    _In_    ULONG                             InLen,
+    _In_    ULONG                             OutLen,
+    _Inout_ PIRP                              Irp
     )
 {
-    NTSTATUS                                    status;
-    PXENIFACE_GNTTAB_MAP_FOREIGN_PAGES_IN       In1 = NULL;
-    PXENIFACE_GNTTAB_MAP_FOREIGN_PAGES_IN_V2    In = NULL;
-    // XENIFACE_GNTTAB_MAP_FOREIGN_PAGES_OUT_V2 is the same as 
XENIFACE_GNTTAB_MAP_FOREIGN_PAGES_OUT
-    PXENIFACE_GNTTAB_MAP_FOREIGN_PAGES_OUT Out = Irp->UserBuffer;
-    ULONG ReferenceSize;
-    PXENIFACE_GNTTAB_CONTEXT Context;
-    ULONG ControlCode = 
IoGetCurrentIrpStackLocation(Irp)->Parameters.DeviceIoControl.IoControlCode;
-
-    ASSERT(ControlCode == IOCTL_XENIFACE_GNTTAB_MAP_FOREIGN_PAGES || 
ControlCode == IOCTL_XENIFACE_GNTTAB_MAP_FOREIGN_PAGES_V2);
+    NTSTATUS                                  Status;
+    PVOID                                     Captured = NULL;
+    PXENIFACE_GNTTAB_MAP_FOREIGN_PAGES_IN     In1;
+    PXENIFACE_GNTTAB_MAP_FOREIGN_PAGES_IN_V2  In2;
+    PXENIFACE_GNTTAB_MAP_FOREIGN_PAGES_OUT    Out = Irp->UserBuffer;
+    PXENIFACE_GNTTAB_CONTEXT                  Context;
+    PULONG                                    References;
+    ULONG                                     Offset;
+    ULONG                                     Count;
+    PIO_STACK_LOCATION                        Stack = 
IoGetCurrentIrpStackLocation(Irp);
+    BOOLEAN Legacy = Stack->Parameters.DeviceIoControl.IoControlCode == 
IOCTL_XENIFACE_GNTTAB_MAP_FOREIGN_PAGES;
+
+    Offset = Legacy ? 
(ULONG)FIELD_OFFSET(XENIFACE_GNTTAB_MAP_FOREIGN_PAGES_IN, References) :
+                      
(ULONG)FIELD_OFFSET(XENIFACE_GNTTAB_MAP_FOREIGN_PAGES_IN_V2, References);
+    if (InLen < Offset + sizeof(ULONG) || OutLen != sizeof(*Out))
+        return STATUS_INVALID_BUFFER_SIZE;
+
+    if (InLen - Offset > GNTTAB_MAX_PAGES * sizeof(ULONG))
+        return STATUS_INVALID_PARAMETER;
+
+    Count = (InLen - Offset) / sizeof(ULONG);
+
+    Status = __CaptureUserBuffer(Buffer, InLen, &Captured);
+    if (!NT_SUCCESS(Status))
+        return Status;
 
-    status = STATUS_NO_MEMORY;
-    Context = __AllocatePoolWithTag(NonPagedPool, sizeof(*Context), 
XENIFACE_POOL_TAG);
-    if (Context == NULL)
-        goto fail1;
+    Context = GnttabAllocateContext(Fdo);
+    if (Context == NULL) {
+        __FreeCapturedBuffer(Captured);
+        return STATUS_NO_MEMORY;
+    }
 
     Context->Type = XENIFACE_GNTTAB_CONTEXT_MAP;
-    Context->Process = PsGetCurrentProcess();
-    ObReferenceObject(Context->Process);
-
-    // This IOCTL uses METHOD_NEITHER so we directly access user memory.
-    if (ControlCode == IOCTL_XENIFACE_GNTTAB_MAP_FOREIGN_PAGES) {
-        status = STATUS_INVALID_BUFFER_SIZE;
-        if (InLen < sizeof(XENIFACE_GNTTAB_MAP_FOREIGN_PAGES_IN)
-            || OutLen != sizeof(XENIFACE_GNTTAB_MAP_FOREIGN_PAGES_OUT))
-            goto fail2;
-
-        In1 = Buffer;
-        ReferenceSize = InLen - 
(ULONG)FIELD_OFFSET(XENIFACE_GNTTAB_MAP_FOREIGN_PAGES_IN, References);
-        if (ReferenceSize > GNTTAB_MAX_PAGES * sizeof(ULONG))
-            goto fail3;
-        status = __CaptureUserBuffer(Buffer, InLen, &In1);
-        if (!NT_SUCCESS(status))
-            goto fail4;
+    Context->FileObject = Stack->FileObject;
+    Context->UseRequestId = Legacy;
 
-        Context->UseRequestId = TRUE;
+    if (Legacy) {
+        In1 = Captured;
         Context->RequestId = In1->RequestId;
-
-        // legacy IOCTL, convert the input to v2
-        status = STATUS_NO_MEMORY;
-        In = __AllocatePoolWithTag(NonPagedPool,
-                                   
(ULONG)FIELD_OFFSET(XENIFACE_GNTTAB_MAP_FOREIGN_PAGES_IN_V2, References) + 
ReferenceSize,
-                                   XENIFACE_POOL_TAG);
-        if (In == NULL)
-            goto fail5;
-
-        In->RemoteDomain = In1->RemoteDomain;
-        In->NumberPages = In1->NumberPages;
-        In->NotifyOffset = In1->NotifyOffset;
-        In->NotifyPort = In1->NotifyPort;
-        In->Flags = In1->Flags;
-        memcpy(&In->References, &In1->References, ReferenceSize);
-
-        __FreeCapturedBuffer(In1);
-        In1 = NULL;
+        Context->RemoteDomain = In1->RemoteDomain;
+        Context->NumberPages = In1->NumberPages;
+        Context->Flags = In1->Flags;
+        Context->NotifyOffset = In1->NotifyOffset;
+        Context->NotifyPort = In1->NotifyPort;
+        References = In1->References;
     } else {
-        status = STATUS_INVALID_BUFFER_SIZE;
-        if (InLen < sizeof(XENIFACE_GNTTAB_MAP_FOREIGN_PAGES_IN_V2)
-            || OutLen != sizeof(XENIFACE_GNTTAB_MAP_FOREIGN_PAGES_OUT_V2))
-            goto fail2;
-
-        In = Buffer;
-        ReferenceSize = InLen - 
(ULONG)FIELD_OFFSET(XENIFACE_GNTTAB_MAP_FOREIGN_PAGES_IN_V2, References);
-        if (ReferenceSize > GNTTAB_MAX_PAGES * sizeof(ULONG))
-            goto fail3;
-        status = __CaptureUserBuffer(Buffer, InLen, &In);
-        if (!NT_SUCCESS(status))
-            goto fail4;
-
-        Context->UseRequestId = FALSE;
-        Context->RequestId = 0;
-    }
-
-    // At this point we only access In.
-    status = STATUS_INVALID_PARAMETER;
-    if (In->NumberPages == 0 ||
-        In->NumberPages > GNTTAB_MAX_PAGES ||
-        In->NumberPages * sizeof(ULONG) > ReferenceSize) {
-        goto fail6;
-    }
-
-    if ((In->Flags & XENIFACE_GNTTAB_USE_NOTIFY_OFFSET) &&
-        (In->NotifyOffset >= In->NumberPages * PAGE_SIZE ||
-         (In->Flags & XENIFACE_GNTTAB_READONLY))) {
-        goto fail7;
+        In2 = Captured;
+        Context->RemoteDomain = In2->RemoteDomain;
+        Context->NumberPages = In2->NumberPages;
+        Context->Flags = In2->Flags;
+        Context->NotifyOffset = In2->NotifyOffset;
+        Context->NotifyPort = In2->NotifyPort;
+        References = In2->References;
     }
 
-    Context->RemoteDomain = In->RemoteDomain;
-    Context->NumberPages = In->NumberPages;
-    Context->Flags = In->Flags;
-    Context->NotifyOffset = In->NotifyOffset;
-    Context->NotifyPort = In->NotifyPort;
-
-    Trace("> RemoteDomain %d, NumberPages %lu, Flags 0x%x, Offset 0x%x, Port 
%d, Process %p, Id %lu\n",
-          Context->RemoteDomain, Context->NumberPages, Context->Flags, 
Context->NotifyOffset, Context->NotifyPort,
-          Context->Process, Context->RequestId);
-
-#if DBG
-    for (ULONG PageIndex = 0; PageIndex < In->NumberPages; PageIndex++)
-        Info("> Ref %d\n", In->References[PageIndex]);
-#endif
-
-    status = STATUS_INVALID_PARAMETER;
-    if (FindGnttabIrp(Fdo, Context) != NULL)
-        goto fail8;
-
-    status = XENBUS_GNTTAB(MapForeignPages,
-                           &Fdo->GnttabInterface,
-                           Context->RemoteDomain,
-                           Context->NumberPages,
-                           In->References,
-                           Context->Flags & XENIFACE_GNTTAB_READONLY,
-                           &Context->Address);
-
-    if (!NT_SUCCESS(status))
-        goto fail9;
-
-    status = STATUS_INSUFFICIENT_RESOURCES;
-    Context->KernelVa = MmMapIoSpace(Context->Address, Context->NumberPages * 
PAGE_SIZE, MmCached);
-    if (Context->KernelVa == NULL)
-        goto fail10;
+    Status = STATUS_INVALID_PARAMETER;
+    if (Context->NumberPages == 0 || Context->NumberPages > Count ||
+        ((Context->Flags & XENIFACE_GNTTAB_USE_NOTIFY_OFFSET) &&
+         (Context->NotifyOffset >= Context->NumberPages * PAGE_SIZE || 
(Context->Flags & XENIFACE_GNTTAB_READONLY))) ||
+        (Legacy && FindGnttabIrp(Fdo, Context) != NULL))
+        goto fail;
 
-    status = STATUS_NO_MEMORY;
-    Context->Mdl = IoAllocateMdl(Context->KernelVa, Context->NumberPages * 
PAGE_SIZE, FALSE, FALSE, NULL);
-    if (Context->Mdl == NULL)
-        goto fail11;
+    if (Context->Flags & XENIFACE_GNTTAB_USE_NOTIFY_PORT)
+        Context->Map.NotifyChannel = EvtchnReference(Fdo, Context->NotifyPort, 
NULL);
 
-    MmBuildMdlForNonPagedPool(Context->Mdl);
+    // Allocate cancellation resources before queuing a pending request.
+    Context->CancelWorkItem = IoAllocateWorkItem(Fdo->Dx->DeviceObject);
+    Status = STATUS_NO_MEMORY;
+    if (Context->CancelWorkItem == NULL)
+        goto fail;
 
-    // map into user mode
-#pragma prefast(suppress: 6320) // we want to catch all exceptions
-    try {
-        Context->UserVa = MmMapLockedPagesSpecifyCache(Context->Mdl,
-                                                       UserMode,
-                                                       MmCached,
-                                                       NULL,
-                                                       FALSE,
-                                                       NormalPagePriority |
-                                                       ((Context->Flags & 
XENIFACE_GNTTAB_READONLY) ? MdlMappingNoWrite : 0));
-    } except (EXCEPTION_EXECUTE_HANDLER) {
-        status = GetExceptionCode();
-        goto fail12;
-    }
+    Status = GnttabMapBatch(Fdo, Context, References);
+    if (!NT_SUCCESS(Status))
+        goto fail;
 
-    Trace("< Context %p, Irp %p, Address %p, KernelVa %p, UserVa %p\n",
-          Context, Irp, Context->Address, Context->KernelVa, Context->UserVa);
+    Status = GnttabCreateUserView(Fdo, Context);
+    if (!NT_SUCCESS(Status))
+        goto fail;
 
-    // Pass the result to user mode.
-#pragma prefast(suppress: 6320) // we want to catch all exceptions
+#pragma prefast(suppress:6320)
     try {
         ProbeForWrite(Out, OutLen, 1);
         Out->Address = Context->UserVa;
-    } except(EXCEPTION_EXECUTE_HANDLER) {
-        status = GetExceptionCode();
-        Error("Exception 0x%lx while probing/writing output buffer at %p, size 
0x%lx\n", status, Out, OutLen);
-        goto fail13;
+    } except (EXCEPTION_EXECUTE_HANDLER) {
+        Status = GetExceptionCode();
+        goto fail;
     }
 
-    // Insert the IRP/context into the pending queue.
-    // This also checks (again) if the request ID is unique for the calling 
process.
-    // Pre-allocate the cancel work item now (PASSIVE_LEVEL) so 
CsqCompleteCanceledIrp
-    // doesn't need to allocate at DISPATCH_LEVEL.
     Irp->Tail.Overlay.DriverContext[0] = Context;
-    Irp->Tail.Overlay.DriverContext[1] = 
IoAllocateWorkItem(Fdo->Dx->DeviceObject);
-
-    status = STATUS_INSUFFICIENT_RESOURCES;
-    if (Irp->Tail.Overlay.DriverContext[1] == NULL)
-        goto fail14;
-
-    status = IoCsqInsertIrpEx(&Fdo->IrpQueue, Irp, NULL, Context);
-    if (!NT_SUCCESS(status))
-        goto fail15;
-
-    __FreeCapturedBuffer(In);
+    Irp->Tail.Overlay.DriverContext[1] = Context->CancelWorkItem;
+    Status = IoCsqInsertIrpEx(&Fdo->IrpQueue, Irp, NULL, Context);
+    if (!NT_SUCCESS(Status))
+        goto fail;
 
+    __FreeCapturedBuffer(Captured);
     return STATUS_PENDING;
 
-fail15:
-    Error("Fail15\n");
-    IoFreeWorkItem(Irp->Tail.Overlay.DriverContext[1]);
-
-fail14:
-    Error("Fail14\n");
-
-fail13:
-    Error("Fail13\n");
-    MmUnmapLockedPages(Context->UserVa, Context->Mdl);
-
-fail12:
-    Error("Fail12\n");
-    IoFreeMdl(Context->Mdl);
-
-fail11:
-    Error("Fail11\n");
-    MmUnmapIoSpace(Context->KernelVa, Context->NumberPages * PAGE_SIZE);
-
-fail10:
-    Error("Fail10\n");
-    XENBUS_GNTTAB(UnmapForeignPages,
-                  &Fdo->GnttabInterface,
-                  Context->Address);
-
-fail9:
-    Error("Fail9\n");
-
-fail8:
-    Error("Fail8\n");
-
-fail7:
-    Error("Fail7\n");
-
-fail6:
-    Error("Fail6\n");
-    __FreeCapturedBuffer(In);
-
-fail5:
-    Error("Fail5\n");
-    __FreeCapturedBuffer(In1);
-
-fail4:
-    Error("Fail4\n");
-
-fail3:
-    Error("Fail3\n");
-
-fail2:
-    Error("Fail2\n");
-    ObDereferenceObject(Context->Process);
-    RtlZeroMemory(Context, sizeof(*Context));
-    __FreePoolWithTag(Context, XENIFACE_POOL_TAG);
-
-fail1:
-    Error("Fail1 (%08x)\n", status);
-    return status;
+fail:
+    __FreeCapturedBuffer(Captured);
+    GnttabReleaseMap(Fdo, Context); // Also retains partial mappings for retry.
+    return Status;
 }
 
-_IRQL_requires_max_(APC_LEVEL)
+_IRQL_requires_(PASSIVE_LEVEL)
 DECLSPEC_NOINLINE
 VOID
 GnttabFreeMap(
-    _In_ PXENIFACE_FDO                  Fdo,
-    _Inout_ PXENIFACE_GNTTAB_CONTEXT    Context
+    _In_ PXENIFACE_FDO                Fdo,
+    _Inout_ PXENIFACE_GNTTAB_CONTEXT  Context
     )
 {
-    NTSTATUS                            status;
-
     ASSERT(Context->Type == XENIFACE_GNTTAB_CONTEXT_MAP);
-    ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
-
-    Trace("Context %p\n", Context);
-
-    // Write the notify value while the grant is still mapped.
-    if (Context->Flags & XENIFACE_GNTTAB_USE_NOTIFY_OFFSET) {
-        ((PCHAR)Context->KernelVa)[Context->NotifyOffset] = 0;
-    }
-
-    // unmap from user address space
-    MmUnmapLockedPages(Context->UserVa, Context->Mdl);
-
-    IoFreeMdl(Context->Mdl);
-
-    // unmap from system space
-    MmUnmapIoSpace(Context->KernelVa, Context->NumberPages * PAGE_SIZE);
-
-    // undo mapping
-    status = XENBUS_GNTTAB(UnmapForeignPages,
-                           &Fdo->GnttabInterface,
-                           Context->Address);
-
-    ASSERT(NT_SUCCESS(status));
-
-    // Notify the peer after the map is fully gone.
-    if (Context->Flags & XENIFACE_GNTTAB_USE_NOTIFY_PORT) {
-        status = EvtchnNotify(Fdo, Context->NotifyPort, NULL);
-
-        if (!NT_SUCCESS(status)) // non-fatal, we must free memory
-            Error("failed to notify port %lu: 0x%x\n", Context->NotifyPort, 
status);
-    }
-
-    ObDereferenceObject(Context->Process);
-    RtlZeroMemory(Context, sizeof(*Context));
-    __FreePoolWithTag(Context, XENIFACE_POOL_TAG);
+    Context->Map.NotifyOnCleanup = TRUE;
+    GnttabReleaseMap(Fdo, Context);
 }
 
 DECLSPEC_NOINLINE
@@ -930,7 +1161,7 @@ IoctlGnttabUnmapForeignPages(
     )
 {
     NTSTATUS                    status;
-    XENIFACE_GNTTAB_CONTEXT     SeekContext;
+    XENIFACE_GNTTAB_CONTEXT     SeekContext = {0};
     PXENIFACE_GNTTAB_CONTEXT    Context;
     PIRP                        PendingIrp;
 
@@ -971,7 +1202,6 @@ IoctlGnttabUnmapForeignPages(
 
     Context = PendingIrp->Tail.Overlay.DriverContext[0];
     GnttabFreeMap(Fdo, Context);
-    IoFreeWorkItem(PendingIrp->Tail.Overlay.DriverContext[1]);
 
     PendingIrp->IoStatus.Status = STATUS_SUCCESS;
     PendingIrp->IoStatus.Information = 0;
diff --git a/src/xeniface/ioctls.c b/src/xeniface/ioctls.c
index 9a054ae..d0b2132 100644
--- a/src/xeniface/ioctls.c
+++ b/src/xeniface/ioctls.c
@@ -165,6 +165,10 @@ XenIfaceCleanup(
     KIRQL                       Irql;
     LIST_ENTRY                  ToFree;
 
+    // Clean up grants and mappings before closing event channels.
+    // For device cleanup, finish deferred work before releasing the 
interfaces.
+    GnttabCleanup(Fdo, FileObject);
+
     // store watches
     InitializeListHead(&ToFree);
     KeAcquireSpinLock(&Fdo->StoreWatchLock, &Irql);
@@ -246,6 +250,7 @@ XenIfaceIoctl(
     )
 {
     NTSTATUS            status;
+    BOOLEAN             GnttabLocked = FALSE;
     PIO_STACK_LOCATION  Stack = IoGetCurrentIrpStackLocation(Irp);
     PVOID               Buffer = Irp->AssociatedIrp.SystemBuffer;
     ULONG               InLen = 
Stack->Parameters.DeviceIoControl.InputBufferLength;
@@ -260,6 +265,19 @@ XenIfaceIoctl(
     if (status != STATUS_SUCCESS)
         goto done;
 
+    if (ControlCode >= IOCTL_XENIFACE_GNTTAB_PERMIT_FOREIGN_ACCESS &&
+        ControlCode <= IOCTL_XENIFACE_GNTTAB_UNMAP_FOREIGN_PAGES_V2) {
+        AcquireMutex(&Fdo->GnttabLock);
+        GnttabLocked = TRUE;
+        status = STATUS_DEVICE_NOT_READY;
+        if (Fdo->GnttabBusy || !Fdo->InterfacesAcquired)
+            goto done;
+
+        status = STATUS_FILE_CLOSED;
+        if (Stack->FileObject != NULL && (Stack->FileObject->Flags & 
FO_CLEANUP_COMPLETE))
+            goto done;
+    }
+
     switch (ControlCode) {
         // store
     case IOCTL_XENIFACE_STORE_READ:
@@ -373,6 +391,8 @@ XenIfaceIoctl(
     }
 
 done:
+    if (GnttabLocked)
+        ReleaseMutex(&Fdo->GnttabLock);
 
     // A pending request can already belong to a cancellation/cleanup worker.
     if (status != STATUS_PENDING) {
diff --git a/src/xeniface/ioctls.h b/src/xeniface/ioctls.h
index a3a1339..daca4fa 100644
--- a/src/xeniface/ioctls.h
+++ b/src/xeniface/ioctls.h
@@ -73,6 +73,8 @@ typedef struct _XENIFACE_GNTTAB_CONTEXT {
     LIST_ENTRY                   Entry;
     XENIFACE_GNTTAB_CONTEXT_TYPE Type;
     BOOLEAN                      UseRequestId; // true for legacy IOCTLs
+    BOOLEAN                      Cleanup; // flag for queue search to ignore 
request ID/address
+                                          // during cleanup
     ULONG                        RequestId;
     PEPROCESS                    Process;
     USHORT                       RemoteDomain;
@@ -80,13 +82,22 @@ typedef struct _XENIFACE_GNTTAB_CONTEXT {
     XENIFACE_GNTTAB_PAGE_FLAGS   Flags;
     ULONG                        NotifyOffset;
     ULONG                        NotifyPort;
-    union {
-        PXENBUS_GNTTAB_ENTRY     *Grants; // permit
-        PHYSICAL_ADDRESS         Address; // map
-    };
     PVOID                        KernelVa;
     PVOID                        UserVa;
     PMDL                         Mdl;
+    PFILE_OBJECT                 FileObject;
+    PIO_WORKITEM                 CancelWorkItem;
+    union {
+        PXENBUS_GNTTAB_ENTRY     *Grants; // permit
+        struct {
+            PXENBUS_GNTTAB_MAPPING   Mapping;
+            ULONGLONG                MappingId;
+            ULONGLONG                CleanupProgressTime;
+            ULONG                    CleanupRemaining; // conservative upper 
bound, never increases after release
+            PXENIFACE_EVTCHN_CONTEXT NotifyChannel; // retained by mappings 
with port notifications
+            BOOLEAN                  NotifyOnCleanup;
+        } Map;
+    };
 } XENIFACE_GNTTAB_CONTEXT, *PXENIFACE_GNTTAB_CONTEXT;
 #pragma warning(pop)
 
@@ -351,18 +362,75 @@ CompleteGnttabIrp(
     _In_opt_ PVOID      Context
     );
 
-_IRQL_requires_max_(APC_LEVEL)
+_IRQL_requires_(PASSIVE_LEVEL)
 VOID
 GnttabFreeGrant(
     _In_ PXENIFACE_FDO                  Fdo,
     _Inout_ PXENIFACE_GNTTAB_CONTEXT    Context
     );
 
-_IRQL_requires_max_(APC_LEVEL)
+_IRQL_requires_(PASSIVE_LEVEL)
 VOID
 GnttabFreeMap(
-    _In_ PXENIFACE_FDO                  Fdo,
-    _Inout_ PXENIFACE_GNTTAB_CONTEXT    Context
+    _In_ PXENIFACE_FDO                Fdo,
+    _Inout_ PXENIFACE_GNTTAB_CONTEXT  Context
+    );
+
+_IRQL_requires_(PASSIVE_LEVEL)
+VOID
+GnttabCleanup(
+    _In_ PXENIFACE_FDO        Fdo,
+    _In_opt_ PFILE_OBJECT     FileObject
+    );
+
+_IRQL_requires_(PASSIVE_LEVEL)
+NTSTATUS
+GnttabRetryThread(
+    _In_ PXENIFACE_THREAD     Self,
+    _In_ PVOID                Argument
+    );
+
+_IRQL_requires_(PASSIVE_LEVEL)
+_Ret_maybenull_
+PXENIFACE_GNTTAB_CONTEXT
+GnttabAllocateContext(
+    _In_ PXENIFACE_FDO        Fdo
+    );
+
+_IRQL_requires_(PASSIVE_LEVEL)
+VOID
+GnttabFreeContext(
+    _In_ PXENIFACE_FDO                Fdo,
+    _Inout_ PXENIFACE_GNTTAB_CONTEXT  Context
+    );
+
+_IRQL_requires_(PASSIVE_LEVEL)
+NTSTATUS
+GnttabCreateMap(
+    _In_ PXENIFACE_FDO                Fdo,
+    _Inout_ PXENIFACE_GNTTAB_CONTEXT  Context
+    );
+
+_IRQL_requires_(PASSIVE_LEVEL)
+NTSTATUS
+GnttabMapBatch(
+    _In_ PXENIFACE_FDO                       Fdo,
+    _Inout_ PXENIFACE_GNTTAB_CONTEXT         Context,
+    _In_reads_(Context->NumberPages) PULONG  References
+    );
+
+_IRQL_requires_(PASSIVE_LEVEL)
+NTSTATUS
+GnttabCreateUserView(
+    _In_ PXENIFACE_FDO                Fdo,
+    _Inout_ PXENIFACE_GNTTAB_CONTEXT  Context
+    );
+
+_IRQL_requires_(PASSIVE_LEVEL)
+VOID
+GnttabReleaseMap(
+    _In_ PXENIFACE_FDO                Fdo,
+    _Inout_ PXENIFACE_GNTTAB_CONTEXT  Context
     );
 
 NTSTATUS
diff --git a/src/xeniface/irp_queue.c b/src/xeniface/irp_queue.c
index e2506b6..67d912b 100644
--- a/src/xeniface/irp_queue.c
+++ b/src/xeniface/irp_queue.c
@@ -99,10 +99,15 @@ CsqPeekNextIrp(
             Context = NextIrp->Tail.Overlay.DriverContext[0];
 
             BOOL Match = TargetContext->Type == Context->Type &&
-                         TargetContext->Process == Context->Process;
-            if (TargetContext->UseRequestId != Context->UseRequestId)
+                         (TargetContext->Process == NULL ||
+                          TargetContext->Process == Context->Process) &&
+                         (TargetContext->FileObject == NULL ||
+                          TargetContext->FileObject == Context->FileObject);
+            if (TargetContext->Cleanup) {
+                // File/device cleanup matches every request owned by the file.
+            } else if (TargetContext->UseRequestId != Context->UseRequestId) {
                 Match = FALSE;
-            else if (TargetContext->UseRequestId)
+            } else if (TargetContext->UseRequestId)
                 Match = Match && (TargetContext->RequestId == 
Context->RequestId);
             else
                 Match = Match && (TargetContext->UserVa == Context->UserVa);
-- 
2.56.0




 


Rackspace

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