[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: [RFC PATCH 2/2] xenbus: Add grant table interface v5 for resumable mappings
- To: Rafał Wojdyła <omeg@xxxxxxxxxxxxxxxxxxxxxx>
- From: Ngoc Tu Dinh <ngoc-tu.dinh@xxxxxxxxxx>
- Date: Mon, 16 Nov 2026 16:31:03 +0100
- Authentication-results: eu.smtp.expurgate.cloud; dkim=pass header.s=selector1 header.d=vates.tech header.i="@vates.tech" header.h="From:Subject:Date:Message-ID:To:Cc:MIME-Version:Content-Type:Feedback-ID"
- Cc: win-pv-devel@xxxxxxxxxxxxxxxxxxxx
- Delivery-date: Mon, 16 Nov 2026 15:31:25 +0000
- Feedback-id: default:8631fc262581453bbf619ec5b2062170:Sweego
- Importance: Normal
- List-id: Developer list for the Windows PV Drivers subproject <win-pv-devel.lists.xenproject.org>
Comments inline
On Nov 10, 2026 17:58, Rafał Wojdyła <omeg@xxxxxxxxxxxxxxxxxxxxxx> wrote:
Foreign page mappings now use an explicit lifecycle:
- allocate the mapping,
- populate it with batches of foreign pages (maximum 256 pages per batch),
- query the mapped address of the region after all pages are populated,
- unmap foreign pages in batches,
- destroy the mapping.
The caller is responsible for managing page state on page-level failures.
Successful pages are kept after partial failures, no automatic rollback
is performed. Overlapping regions inside a mapping are rejected. Partial
unmap failures can be retried (only successfully unmapped page handles
are invalidated).
Calls now require PASSIVE_LEVEL. The caller is responsible for serializing
operations on a mapping. Per-page results are written only when a hypercall
completes. Batch processing errors are reported by the return status.
Signed-off-by: Rafał Wojdyła <omeg@xxxxxxxxxxxxxxxxxxxxxx>
---
include/gnttab_interface.h | 236 +++++++++++++++++++++-----
include/revision.h | 3 +-
src/xenbus/gnttab.c | 336 ++++++++++++++++++++++++++++++++++++-
3 files changed, 524 insertions(+), 51 deletions(-)
diff --git a/include/gnttab_interface.h b/include/gnttab_interface.h
index 92a95a7..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
@@ -197,19 +202,24 @@ 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)(
+(*XENBUS_GNTTAB_MAP_FOREIGN_PAGES_V1)(
_In_ PINTERFACE Interface,
_In_ USHORT Domain,
_In_ ULONG NumberPages,
@@ -218,16 +228,135 @@ typedef NTSTATUS
_Out_ PHYSICAL_ADDRESS *Address
);
-/*! \typedef XENBUS_GNTTAB_UNMAP_FOREIGN_PAGES
+// 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_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_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.
I believe this requirement alone is not sufficient, as DestroyMapping can still race with later Map calls once it has released its lock?
+*/
+_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;
Please follow the convention for updating interfaces: the old functions gain a version number according to the oldest interface implementing it (XENBUS_GNTTAB_MAP_FOREIGN_PAGES_V2 GnttabMapForeignPagesV2 in this case), and the new functions shouldn't get any version numbers in the name or function pointer typedef.
};
-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/include/revision.h b/include/revision.h
index a63e550..c1ab047 100644
--- a/include/revision.h
+++ b/include/revision.h
@@ -52,6 +52,7 @@
DEFINE_REVISION(0x09000009, 1, 4, 9, 1, 2, 1, 2, 4, 1, 1, 2), \
DEFINE_REVISION(0x0900000A, 1, 4, 9, 1, 2, 1, 2, 4, 2, 1, 2), \
DEFINE_REVISION(0x0900000B, 1, 4, 9, 1, 2, 1, 2, 4, 3, 1, 2), \
- DEFINE_REVISION(0x0900000C, 1, 4, 9, 1, 2, 1, 2, 4, 3, 1, 3)
+ DEFINE_REVISION(0x0900000C, 1, 4, 9, 1, 2, 1, 2, 4, 3, 1, 3), \
+ DEFINE_REVISION(0x0900000D, 1, 4, 9, 1, 2, 1, 2, 5, 3, 1, 3)
#endif // _REVISION_H
diff --git a/src/xenbus/gnttab.c b/src/xenbus/gnttab.c
index 6a4dd48..b6b45d1 100644
--- a/src/xenbus/gnttab.c
+++ b/src/xenbus/gnttab.c
@@ -42,6 +42,7 @@
#include "assert.h"
#include "util.h"
#include "hash_table.h"
+#include "mutex.h"
#define XENBUS_GNTTAB_ENTRY_PER_FRAME (PAGE_SIZE / sizeof (grant_entry_v1_t))
@@ -74,6 +75,18 @@ typedef struct _XENBUS_GNTTAB_MAP_ENTRY {
ULONG MapHandles[1];
} XENBUS_GNTTAB_MAP_ENTRY, *PXENBUS_GNTTAB_MAP_ENTRY;
+struct _XENBUS_GNTTAB_MAPPING {
+ PXENBUS_GNTTAB_CONTEXT Context;
+ MUTEX Mutex;
+ PMDL Mdl;
+ PHYSICAL_ADDRESS Address;
+ ULONG NumberPages;
+ ULONG NumberMapped;
+ USHORT Domain;
+ BOOLEAN ReadOnly;
+ PULONG MapHandles;
+};
+
typedef struct _XENBUS_GNTTAB_FRAME {
PMDL Mdl;
grant_entry_v1_t *Entry;
@@ -94,6 +107,7 @@ struct _XENBUS_GNTTAB_CONTEXT {
XENBUS_DEBUG_INTERFACE DebugInterface;
PXENBUS_DEBUG_CALLBACK DebugCallback;
PXENBUS_HASH_TABLE MapTable;
+ LONG MappingCount;
LIST_ENTRY List;
};
@@ -654,8 +668,10 @@ fail1:
return status;
}
+C_ASSERT(XENBUS_GNTTAB_MAP_BATCH_COUNT_MAX == XEN_GNTTAB_MAP_BATCH_MAX);
+
static NTSTATUS
-GnttabMapForeignPages(
+GnttabMapForeignPagesVersion1(
_In_ PINTERFACE Interface,
_In_ USHORT Domain,
_In_ ULONG NumberPages,
@@ -760,7 +776,7 @@ fail1:
}
static NTSTATUS
-GnttabUnmapForeignPages(
+GnttabUnmapForeignPagesVersion1(
_In_ PINTERFACE Interface,
_In_ PHYSICAL_ADDRESS StartAddress
)
@@ -830,6 +846,275 @@ fail1:
return Status;
}
+// Resumable batch mappings
+_IRQL_requires_(PASSIVE_LEVEL)
+static NTSTATUS
+GnttabCreateMapping(
+ _In_ PINTERFACE Interface,
+ _In_ USHORT Domain,
+ _In_ ULONG NumberPages,
+ _In_ BOOLEAN ReadOnly,
+ _Outptr_ PXENBUS_GNTTAB_MAPPING *Mapping
+ )
+{
+ PXENBUS_GNTTAB_CONTEXT Context = Interface->Context;
+ ULONG Index;
+ NTSTATUS Status;
+
+ ASSERT3U(KeGetCurrentIrql(), ==, PASSIVE_LEVEL);
+ *Mapping = NULL;
+
+ Status = STATUS_INVALID_PARAMETER;
+ if (NumberPages == 0 || NumberPages > XENBUS_GNTTAB_MAP_COUNT_MAX)
+ goto fail1;
+
+ Status = STATUS_NO_MEMORY;
+ *Mapping = __GnttabAllocate(sizeof (XENBUS_GNTTAB_MAPPING));
+ if (*Mapping == NULL)
+ goto fail2;
+
+ // Persistent handles can be large, all accesses are at PASSIVE_LEVEL.
+ (*Mapping)->MapHandles = __AllocatePoolWithTag(PagedPool,
+ NumberPages * sizeof (ULONG),
+ XENBUS_GNTTAB_TAG);
+ if ((*Mapping)->MapHandles == NULL)
+ goto fail3;
+
+ for (Index = 0; Index < NumberPages; Index++)
+ (*Mapping)->MapHandles[Index] = XEN_GNTTAB_INVALID_HANDLE;
+
+ (*Mapping)->Mdl = FdoHoleAllocate(Context->Fdo, NumberPages);
+ if ((*Mapping)->Mdl == NULL)
+ goto fail4;
+
+ (*Mapping)->Context = Context;
+ (*Mapping)->NumberPages = NumberPages;
+ (*Mapping)->Domain = Domain;
+ (*Mapping)->ReadOnly = ReadOnly;
+ (*Mapping)->Address.QuadPart = MmGetMdlPfnArray((*Mapping)->Mdl)[0] << PAGE_SHIFT;
+ InitializeMutex(&(*Mapping)->Mutex);
+
+ InterlockedIncrement(&Context->MappingCount);
+
+ return STATUS_SUCCESS;
+
+fail4:
+ Error("fail4\n");
+ __FreePoolWithTag((*Mapping)->MapHandles, XENBUS_GNTTAB_TAG);
+
+fail3:
+ Error("fail3\n");
+ __GnttabFree(*Mapping);
+ *Mapping = NULL;
+
+fail2:
+ Error("fail2\n");
+
+fail1:
+ Error("fail1 (%08x)\n", Status);
+ return Status;
+}
+
+_IRQL_requires_(PASSIVE_LEVEL)
+static NTSTATUS
+GnttabMapForeignPages(
+ _In_ PINTERFACE Interface,
+ _In_ PXENBUS_GNTTAB_MAPPING Mapping,
+ _In_ ULONG Offset,
+ _In_ ULONG NumberPages,
+ _In_reads_(NumberPages) PULONG References,
+ _Out_writes_(NumberPages) PNTSTATUS Results
+ )
+{
+ PHYSICAL_ADDRESS Address;
+ ULONG Index;
+ NTSTATUS Status;
+
+ ASSERT3U(KeGetCurrentIrql(), ==, PASSIVE_LEVEL);
+
+ Status = STATUS_INVALID_PARAMETER;
+ if (NumberPages == 0 || NumberPages > XENBUS_GNTTAB_MAP_BATCH_COUNT_MAX || Results == NULL)
+ goto fail1;
+
+ if (Mapping == NULL || Mapping->Context != Interface->Context || References == NULL)
+ goto fail1;
+
+ // Subtraction avoids overflow when the caller supplies an arbitrary offset.
+ if (Offset >= Mapping->NumberPages || NumberPages > Mapping->NumberPages - Offset)
+ goto fail1;
+
+ AcquireMutex(&Mapping->Mutex);
+
+ Status = STATUS_DEVICE_BUSY;
+ for (Index = 0; Index < NumberPages; Index++) {
+ if (Mapping->MapHandles[Offset + Index] != XEN_GNTTAB_INVALID_HANDLE)
+ goto fail2;
+ }
+
+ Address.QuadPart = Mapping->Address.QuadPart + ((ULONGLONG)Offset << PAGE_SHIFT);
+ Status = GrantTableMapForeignPages(Mapping->Domain,
+ NumberPages,
+ References,
+ Address,
+ Mapping->ReadOnly,
+ &Mapping->MapHandles[Offset],
+ Results);
+ if (!NT_SUCCESS(Status))
+ goto fail2;
+
+ for (Index = 0; Index < NumberPages; Index++) {
+ if (NT_SUCCESS(Results[Index])) {
+ ASSERT3U(Mapping->MapHandles[Offset + Index], !=, XEN_GNTTAB_INVALID_HANDLE);
+ Mapping->NumberMapped++;
+ } else if (NT_SUCCESS(Status)) {
+ Status = Results[Index];
+ }
+ }
+
+ if (!NT_SUCCESS(Status))
+ goto fail2;
+
+ ReleaseMutex(&Mapping->Mutex);
+
+ return STATUS_SUCCESS;
+
+fail2:
+ Error("fail2\n");
+
+ ReleaseMutex(&Mapping->Mutex);
+
+fail1:
+ Error("fail1 (%08x)\n", Status);
+
+ return Status;
+}
+
+_IRQL_requires_(PASSIVE_LEVEL)
+static NTSTATUS
+GnttabGetMappingAddress(
+ _In_ PINTERFACE Interface,
+ _In_ PXENBUS_GNTTAB_MAPPING Mapping,
+ _Out_ PPHYSICAL_ADDRESS Address
+ )
+{
+ NTSTATUS Status;
+
+ ASSERT3U(KeGetCurrentIrql(), ==, PASSIVE_LEVEL);
+ Address->QuadPart = 0;
+
+ if (Mapping == NULL || Mapping->Context != Interface->Context)
+ return STATUS_INVALID_PARAMETER;
+
+ AcquireMutex(&Mapping->Mutex);
+
+ Status = STATUS_DEVICE_NOT_READY;
+ if (Mapping->NumberMapped == Mapping->NumberPages) {
+ *Address = Mapping->Address;
+ Status = STATUS_SUCCESS;
+ }
+
+ ReleaseMutex(&Mapping->Mutex);
+ return Status;
+}
+
+_IRQL_requires_(PASSIVE_LEVEL)
+static NTSTATUS
+GnttabUnmapForeignPages(
+ _In_ PINTERFACE Interface,
+ _In_ PXENBUS_GNTTAB_MAPPING Mapping,
+ _In_ ULONG Offset,
+ _In_ ULONG NumberPages,
+ _Out_writes_(NumberPages) PNTSTATUS Results
+ )
+{
+ PHYSICAL_ADDRESS Address;
+ ULONG Index;
+ NTSTATUS Status;
+
+ ASSERT3U(KeGetCurrentIrql(), ==, PASSIVE_LEVEL);
+
+ Status = STATUS_INVALID_PARAMETER;
+ if (NumberPages == 0 || NumberPages > XENBUS_GNTTAB_MAP_BATCH_COUNT_MAX || Results == NULL)
+ goto fail1;
+
+ if (Mapping == NULL || Mapping->Context != Interface->Context)
+ goto fail1;
+
+ if (Offset >= Mapping->NumberPages || NumberPages > Mapping->NumberPages - Offset)
+ goto fail1;
+
+ AcquireMutex(&Mapping->Mutex);
+
+ Address.QuadPart = Mapping->Address.QuadPart + ((ULONGLONG)Offset << PAGE_SHIFT);
+ Status = GrantTableUnmapForeignPages(NumberPages,
+ &Mapping->MapHandles[Offset],
+ Address,
+ Results);
+ if (!NT_SUCCESS(Status))
+ goto fail2;
+
+ for (Index = 0; Index < NumberPages; Index++) {
+ // An entirely empty batch succeeds without a hypercall or Results.
+ if (Mapping->MapHandles[Offset + Index] == XEN_GNTTAB_INVALID_HANDLE)
+ continue;
+
+ if (NT_SUCCESS(Results[Index])) {
+ Mapping->MapHandles[Offset + Index] = XEN_GNTTAB_INVALID_HANDLE;
+ ASSERT3U(Mapping->NumberMapped, >, 0);
+ Mapping->NumberMapped--;
+ } else if (NT_SUCCESS(Status)) {
+ Status = Results[Index];
+ }
+ }
+
+ if (!NT_SUCCESS(Status))
+ goto fail2;
+
+ ReleaseMutex(&Mapping->Mutex);
+
+ return STATUS_SUCCESS;
+
+fail2:
+ Error("fail2\n");
+
+ ReleaseMutex(&Mapping->Mutex);
+
+fail1:
+ Error("fail1 (%08x)\n", Status);
+
+ return Status;
+}
+
+_IRQL_requires_(PASSIVE_LEVEL)
+static NTSTATUS
+GnttabDestroyMapping(
+ _In_ PINTERFACE Interface,
+ _In_ PXENBUS_GNTTAB_MAPPING Mapping
+ )
+{
+ PXENBUS_GNTTAB_CONTEXT Context = Interface->Context;
+
+ ASSERT3U(KeGetCurrentIrql(), ==, PASSIVE_LEVEL);
+
+ if (Mapping == NULL || Mapping->Context != Context)
+ return STATUS_INVALID_PARAMETER;
+
+ AcquireMutex(&Mapping->Mutex);
+ if (Mapping->NumberMapped != 0) {
+ ReleaseMutex(&Mapping->Mutex);
+ return STATUS_DEVICE_BUSY;
+ }
+ ReleaseMutex(&Mapping->Mutex);
+
+ FdoHoleFree(Context->Fdo, Mapping->Mdl);
+ __FreePoolWithTag(Mapping->MapHandles, XENBUS_GNTTAB_TAG);
+ __GnttabFree(Mapping);
+
+ InterlockedDecrement(&Context->MappingCount);
+
+ return STATUS_SUCCESS;
+}
+
static VOID
GnttabSuspendCallbackEarly(
_In_ PVOID Argument
@@ -1039,6 +1324,9 @@ GnttabRelease(
if (!IsListEmpty(&Context->List))
BUG("OUTSTANDING CACHES");
+ if (Context->MappingCount != 0)
+ BUG("OUTSTANDING MAPPINGS");
+
XENBUS_DEBUG(Deregister,
&Context->DebugInterface,
Context->DebugCallback);
@@ -1087,8 +1375,8 @@ static struct _XENBUS_GNTTAB_INTERFACE_V2 GnttabInterfaceVersion2 = {
GnttabRevokeForeignAccess,
GnttabGetReference,
GnttabDestroyCache,
- GnttabMapForeignPages,
- GnttabUnmapForeignPages
+ GnttabMapForeignPagesVersion1,
+ GnttabUnmapForeignPagesVersion1
};
static struct _XENBUS_GNTTAB_INTERFACE_V3 GnttabInterfaceVersion3 = {
@@ -1101,8 +1389,8 @@ static struct _XENBUS_GNTTAB_INTERFACE_V3 GnttabInterfaceVersion3 = {
GnttabGetReference,
GnttabQueryReference,
GnttabDestroyCache,
- GnttabMapForeignPages,
- GnttabUnmapForeignPages
+ GnttabMapForeignPagesVersion1,
+ GnttabUnmapForeignPagesVersion1
};
static struct _XENBUS_GNTTAB_INTERFACE_V4 GnttabInterfaceVersion4 = {
@@ -1115,8 +1403,25 @@ static struct _XENBUS_GNTTAB_INTERFACE_V4 GnttabInterfaceVersion4 = {
GnttabGetReference,
GnttabQueryReference,
GnttabDestroyCache,
+ GnttabMapForeignPagesVersion1,
+ GnttabUnmapForeignPagesVersion1
+};
+
+static struct _XENBUS_GNTTAB_INTERFACE_V5 GnttabInterfaceVersion5 = {
+ { sizeof (struct _XENBUS_GNTTAB_INTERFACE_V5), 5, NULL, NULL, NULL },
+ GnttabAcquire,
+ GnttabRelease,
+ GnttabCreateCache,
+ GnttabPermitForeignAccess,
+ GnttabRevokeForeignAccess,
+ GnttabGetReference,
+ GnttabQueryReference,
+ GnttabDestroyCache,
+ GnttabCreateMapping,
GnttabMapForeignPages,
- GnttabUnmapForeignPages
+ GnttabGetMappingAddress,
+ GnttabUnmapForeignPages,
+ GnttabDestroyMapping
};
NTSTATUS
@@ -1252,6 +1557,23 @@ GnttabGetInterface(
status = STATUS_SUCCESS;
break;
}
+ case 5: {
+ struct _XENBUS_GNTTAB_INTERFACE_V5 *GnttabInterface;
+
+ GnttabInterface = (struct _XENBUS_GNTTAB_INTERFACE_V5 *)Interface;
+
+ status = STATUS_BUFFER_OVERFLOW;
+ if (Size < sizeof (struct _XENBUS_GNTTAB_INTERFACE_V5))
+ break;
+
+ *GnttabInterface = GnttabInterfaceVersion5;
+
+ ASSERT3U(Interface->Version, ==, Version);
+ Interface->Context = Context;
+
+ status = STATUS_SUCCESS;
+ break;
+ }
default:
status = STATUS_NOT_SUPPORTED;
break;
--
2.56.0
--
| |
Ngoc Tu Dinh | Vates XCP-ng Developer
XCP-ng & Xen Orchestra - Vates solutions
web:
https://vates.tech
|
|