|
[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
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
|
![]() |
Lists.xenproject.org is hosted with RackSpace, monitoring our |