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

[RFC PATCH 2/2] xenbus: Add grant table interface v5 for resumable mappings


  • To: win-pv-devel@xxxxxxxxxxxxxxxxxxxx
  • From: Rafał Wojdyła <omeg@xxxxxxxxxxxxxxxxxxxxxx>
  • Date: Tue, 10 Nov 2026 17:57:15 +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@xxxxxxxxxxxxxxxxxxxxxx>
  • Delivery-date: Tue, 10 Nov 2026 16:58:07 +0000
  • Dkim2-signature: i=1; m=1; t=1794329883; d=invisiblethingslab.com; mf=PG9tZWdAaW52aXNpYmxldGhpbmdzbGFiLmNvbT4=; rt=PHdpbi1wdi1kZXZlbEBsaXN0cy54ZW5wcm9qZWN0Lm9yZz4=; s=fm3:rsa-sha256:CgZYx21BZLkvZCkeFbCoYYyf04JHm8iCEhyfNVcJXkFhkyf g9HxypeSIGu7q2uLe+AmJMYGvjrQGOZ5IISYNI2lJE/Qd28Xbt+tsmxk/4LiB0Zq xnOld8UePuYdag7iXEKMjxHvX319GSDVDW/Noui3k0QMNiwFRUGc66yhxoLjm/aP 0pjxYHrWLwDKUWUcSsrg0E5f5o/bUdUopsTiGdf2cLnwgk008NJa5a51snQWe4nF LHnKjbUsssJywRwnIyHr4XaFVlvAd/CiM0ugmQ1Q4AKDT30Akr6nJdPReD7RGyqc vROw1qiCX6bQSkg1CU/YSgZNtiOv+IcpnoePaxA==;
  • 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:KrukXlKlhip0nV+DsRIO7PuCFtcJD7Fnht9OIT66ooQ=:edTHvMyLvxKHhUsHS2Z6PR8wK0IIGZHglw4mXvGm5CE=;

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.
+*/
+_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/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




 


Rackspace

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