@@ -144,8 +144,9 @@ what makes that safe: the allocation is released exactly once, when its last map
   `location_type="host"` with a handle type other than `None`, which the driver rejects, and a
   request for GPUDirect RDMA on a device without support. `__init__` runs it after the VMM-support
   check; `modify_allocation` runs it on a per-call configuration, which must also name the
-  resource's location. The resource reports `is_ipc_enabled = False`, which
-  `Buffer.ipc_descriptor` reads.
+  resource's location and `handle_type`. The resource reports `is_ipc_enabled` (True for
+  `posix_fd` on Linux with device-located memory), which `Buffer.ipc_descriptor` and
+  `Buffer.from_ipc_descriptor` check.
 - `cdef class VirtualMemoryBuffer(Buffer)` carries no extra state. It is created with
   `Buffer_from_deviceptr_handle(h_ptr, size, self, cls=VirtualMemoryBuffer)` and documented in
   `api.rst` like `ManagedBuffer`. It overrides `close(stream=None)` to reject a capturing stream
@@ -199,6 +200,115 @@ what makes that safe: the allocation is released exactly once, when its last map
   its own `cuMemCreate` reference. It is not called for buffers from `allocate()`, whose ranges
   free themselves. A subclass override of `deallocate()` therefore does not run for them.
 
+## Sharing across processes
+
+A `VirtualMemoryBuffer` is shared the way pool-backed buffers are, through
+`Buffer.ipc_descriptor` and `Buffer.from_ipc_descriptor`, when the resource's
+`handle_type` can travel between processes (`posix_fd` on Linux) and the memory
+lives on a device (`is_ipc_enabled` reports both; host-located memory is not
+shared yet). The exporter calls `cuMemExportToShareableHandle`
+once per mapping that covers the buffer's size, in address order, and the
+descriptor carries the handles with each allocation's size. Each file
+descriptor is owned by an `IPCAllocationHandle` and closed when the descriptor
+goes; `multiprocessing` duplicates it into the receiving process. The sizes
+travel because the OS handle does not expose them to the importer; a wrong size
+fails the importer's `cuMemMap`.
+
+The importer is a `VirtualMemoryResource` of the receiving process with the
+same `handle_type`, for the device that owns the memory. `import_mem_allocation_handle`
+calls `cuMemImportFromShareableHandle` and wraps the result in the same box and
+deleter as `create_mem_allocation_handle`: the driver gives an imported handle
+one reference and frees the memory when all references are released and no
+mapping remains, so `cuMemRelease` is the right teardown for both. After each
+import, `cuMemGetAllocationPropertiesFromHandle` must report the resource's
+location (the same device, or the same host location type); a mismatch is a
+`ValueError` before anything is mapped, because the access descriptors would
+describe the wrong location. The access descriptors stored in the box are the
+importer's, built from its options for its device and peers; the exporter's
+access does not travel. The import then reserves `sum(sizes)` with the
+importer's alignment, maps each allocation in order, and builds a range and a
+`VirtualMemoryBuffer` exactly as `allocate()` does, so a grown buffer imports
+as one contiguous range with the same byte layout, and the imported buffer
+frees itself through the same deleters. A descriptor imported in the exporting
+process yields an alias of the exporter's memory at a new address. A
+`VirtualMemoryResource` pickles as (device, options), which is what lets a
+`Buffer` pickle as (resource, descriptor).
+
+File descriptors and memory. A descriptor pins the physical memory while it
+exists, in every process that holds one, and nothing else does. The exporting
+buffer keeps no descriptor: `ipc_descriptor` exports again on every access and
+returns a new descriptor that owns one file descriptor per allocation, and
+`VirtualMemoryBuffer.__reduce__` builds a transient one while `multiprocessing`
+pickles the buffer, so a sender holds no file descriptors between sends. The
+numbers set that rule: PyTorch's expandable segments grow in 2 MB to 20 MB
+chunks, so a buffer of several GB holds several hundred allocations, against a
+default process limit of 1024 file descriptors. One
+transport needs more: a `Queue`, `Pipe`, or `Pool` duplicates the file
+descriptors while pickling (the resource sharer), but a spawned `Process`
+records their numbers during pickling and passes them to the child only when
+it is created (`spawnv_passfds`), so `__reduce__` keeps the transient
+descriptor on the spawning `Popen` object, which dies with the `Process`
+object. Without that, the numbers are reused by the spawn's own pipes
+("bad value(s) in fds_to_keep") or the child imports a stranger's fd. That
+machinery (`spawnv_passfds`, `get_spawning_popen()`) has not changed since
+Python 3.4 (2014). The
+driver copies
+each shared allocation into a handle of its own during the import and keeps no
+reference to the file descriptor, so the imported buffer does not keep the
+descriptor either; it records only that it was imported (`is_mapped`). A
+descriptor parked in a `Queue` or sent to a `Pool` pins the memory in the
+sender until the receiver unpickles it. Besides `multiprocessing`, a process
+with its own file descriptor passing sends the descriptor's `fds`, `sizes`,
+and `size` and rebuilds it with `VirtualMemoryIPCBufferDescriptor.from_fds()`,
+which duplicates the integers it is given and always builds a `posix_fd`
+descriptor.
+
+Re-export. The driver exports only allocations this process created with the
+requested handle type; an imported allocation has none, and the driver reports
+INVALID_VALUE. cuda.core does not rely on that: `MemAllocationBox.imported`
+records provenance per allocation (`mem_allocation_is_imported`), and since
+`modify_allocation` reuses the allocation handles of the input, the mark
+travels into every alias, in-place grow, and move. `_export_ipc_descriptor`
+checks the allocations that cover the buffer before any driver call and raises
+a RuntimeError that says the buffer contains memory imported from another
+process, that such memory cannot be exported again, and that the caller should
+forward the descriptor it imported from or copy into a buffer it owns. The same
+exception surfaces from `pickle`/`multiprocessing` (a `Queue` feeder thread
+reports it through `Queue._on_queue_feeder_error` and drops the item; the queue
+stays usable). PyTorch applies the same contract to received CUDA tensors
+("Attempted to send CUDA tensor received from another process"). There is no
+retention option.
+
+Forwarding an imported buffer would need the received file descriptors, because
+they are the only exportable form of imported memory. The design, not
+implemented because nothing needs it yet: a `VirtualMemoryResourceOptions`
+field that makes imports through that resource keep their received
+`IPCAllocationHandle`s with the imported buffer, and an export loop that uses
+the provenance mark to duplicate the kept handle for imported allocations while
+exporting created ones through the driver. The option belongs on the resource
+rather than on `from_ipc_descriptor`, because a pickled buffer imports through
+the resource it carries and the shared `Buffer.from_ipc_descriptor` signature
+stays unchanged; the consequence is that the sender's options decide whether a
+receiver can forward a pickled buffer. The cost is one open file descriptor per
+imported allocation for the imported buffer's lifetime, the same pressure on
+the process limit that the no-cache export rule avoids, which is why it would
+stay opt-in.
+
+A `modify_allocation` config must keep the resource's `handle_type`: every
+chunk of a buffer must be exportable the same way.
+
+Fabric handles. `CU_MEM_HANDLE_TYPE_FABRIC` exports a `CUmemFabricHandle`, 64
+bytes of plain data that travel through `pickle`, MPI, or a socket, need no
+close, and cannot hold a reference to the allocation while in flight. The
+importer needs access to the exporter's IMEX channel rather than a matching
+device index, and the memory may live on another node. The file-descriptor
+rules above (ownership, pinning, `pickle` raising, the same-device check) do
+not hold for it, so fabric sharing gets a descriptor class of its own instead
+of a widened `VirtualMemoryIPCBufferDescriptor`, whose `handles` stay
+`IPCAllocationHandle`s. `from_fds()` is POSIX-only by construction for the
+same reason and takes no handle type; a fabric descriptor is plain data and
+needs no out-of-band constructor. Tracked on the VMM epic (#2980).
+
 ## Why `modify_allocation` returns a new buffer
 
 The input buffer stays open and aliases the result. The chunks the input already mapped are
 
@@ -262,6 +262,25 @@ MemAllocationHandle create_mem_allocation_handle(size_t size, const CUmemAllocat
 // Size of the allocation; the only size cuMemMap accepts for it.
 size_t mem_allocation_size(const MemAllocationHandle& h) noexcept;
 
+// Whether cuMemImportFromShareableHandle produced the allocation. The driver
+// exports only allocations this process created with a handle type, so an
+// imported allocation cannot be exported again; callers check this before
+// cuMemExportToShareableHandle instead of relying on the driver's error. The
+// mark travels with the allocation into every range that maps it.
+bool mem_allocation_is_imported(const MemAllocationHandle& h) noexcept;
+
+// Import a physical allocation that another process exported with
+// cuMemExportToShareableHandle. `os_handle` is the shareable handle in the
+// form cuMemImportFromShareableHandle expects for `handle_type` (a POSIX file
+// descriptor is its value cast to void*). `size` is the allocation's size,
+// which the OS handle does not expose to the importer; the caller takes it
+// from the exporter, and a wrong size fails the later cuMemMap. The result is
+// a MemAllocationHandle like one from create_mem_allocation_handle: the
+// access descriptors are applied to every mapping, and the last reference
+// calls cuMemRelease. Returns empty handle on error (caller must check).
+MemAllocationHandle import_mem_allocation_handle(void* os_handle, CUmemAllocationHandleType handle_type,
+                                                 size_t size, const CUmemAccessDesc* descs, size_t count);
+
 // Reserve an address range via cuMemAddressReserve. Pass alignment 0 for the
 // driver default. When the last reference is released, cuMemAddressFree is
 // called with the exact reserved pair. Returns empty handle on error.
 
@@ -135,6 +135,7 @@ namespace cuda_core::rt {
     X(cuMemMap, 10020)                           \
     X(cuMemUnmap, 10020)                         \
     X(cuMemSetAccess, 10020)                     \
+    X(cuMemImportFromShareableHandle, 10020)     \
     /* cuda-bindings requests 7000 (PTDS) or 2000 (legacy) */ \
     X(cuStreamSynchronize, 7000)                 \
     X(cuStreamIsCapturing, 10000)                \
 
@@ -29,9 +29,10 @@ using namespace detail;
 namespace {
 
 struct MemAllocationBox {
-    MemAllocationValue resource;          // from cuMemCreate
+    MemAllocationValue resource;          // from cuMemCreate or cuMemImportFromShareableHandle
     size_t size;                          // the only size cuMemMap accepts for it
     std::vector<CUmemAccessDesc> access;  // applied to every mapping of this allocation
+    bool imported;                        // another process created it; it cannot be exported again
 };
 
 struct VaReservationBox {
@@ -61,6 +62,22 @@ const Box* box_of(const Handle& h) noexcept {
         reinterpret_cast<const char*>(h.get()) - offsetof(Box, resource));
 }
 
+// Wrap an allocation handle this process holds one reference to, whether
+// cuMemCreate or cuMemImportFromShareableHandle produced it. The last
+// reference releases it; the memory is freed once no mapping remains.
+MemAllocationHandle wrap_mem_allocation(CUmemGenericAllocationHandle handle, size_t size,
+                                        std::vector<CUmemAccessDesc>&& access, bool imported) {
+    auto box = std::shared_ptr<const MemAllocationBox>(
+        new MemAllocationBox{{handle}, size, std::move(access), imported},
+        [](const MemAllocationBox* b) {
+            GILReleaseGuard gil;
+            pw_cuMemRelease(b->resource.raw);
+            delete b;
+        }
+    );
+    return MemAllocationHandle(box, &box->resource);
+}
+
 }  // namespace
 
 // ============================================================================
@@ -77,21 +94,30 @@ MemAllocationHandle create_mem_allocation_handle(size_t size, const CUmemAllocat
     if (CUDA_SUCCESS != (err = DRIVER_CALL(cuMemCreate, &handle, size, &prop, 0))) {
         return {};
     }
-    auto box = std::shared_ptr<const MemAllocationBox>(
-        new MemAllocationBox{{handle}, size, std::move(access)},
-        [](const MemAllocationBox* b) {
-            GILReleaseGuard gil;
-            pw_cuMemRelease(b->resource.raw);
-            delete b;
-        }
-    );
-    return MemAllocationHandle(box, &box->resource);
+    return wrap_mem_allocation(handle, size, std::move(access), false);
+}
+
+MemAllocationHandle import_mem_allocation_handle(void* os_handle, CUmemAllocationHandleType handle_type,
+                                                 size_t size, const CUmemAccessDesc* descs, size_t count) {
+    // Copy the descriptors before the driver call so a failed copy leaves
+    // nothing to undo.
+    std::vector<CUmemAccessDesc> access(descs, descs + count);
+    GILReleaseGuard gil;
+    CUmemGenericAllocationHandle handle = 0;
+    if (CUDA_SUCCESS != (err = DRIVER_CALL(cuMemImportFromShareableHandle, &handle, os_handle, handle_type))) {
+        return {};
+    }
+    return wrap_mem_allocation(handle, size, std::move(access), true);
 }
 
 size_t mem_allocation_size(const MemAllocationHandle& h) noexcept {
     return h ? box_of<MemAllocationBox>(h)->size : 0;
 }
 
+bool mem_allocation_is_imported(const MemAllocationHandle& h) noexcept {
+    return h ? box_of<MemAllocationBox>(h)->imported : false;
+}
+
 // ============================================================================
 // Address reservations
 // ============================================================================
 
@@ -6,6 +6,7 @@ from cuda.core._memory._copy_enums import CopyOptions
 from cuda.core._memory._device_memory_resource import DeviceMemoryResource
 from cuda.core._memory._ipc import IPCBufferDescriptor
 from cuda.core._memory._pinned_memory_resource import PinnedMemoryResource
+from cuda.core._memory._virtual_memory_resource import VirtualMemoryResource
 from cuda.core._stream import Stream
 from cuda.core._utils.pycompat import BufferProtocol
 from cuda.core.graph import GraphBuilder
@@ -82,13 +83,18 @@ class Buffer:
         :class:`Buffer` is closed or garbage collected.
         """
     @classmethod
-    def from_ipc_descriptor(cls, mr: DeviceMemoryResource | PinnedMemoryResource, ipc_descriptor: IPCBufferDescriptor, *, stream: Stream) -> Buffer:
+    def from_ipc_descriptor(cls, mr: DeviceMemoryResource | PinnedMemoryResource | VirtualMemoryResource, ipc_descriptor: IPCBufferDescriptor, *, stream: Stream) -> Buffer:
         """Import a buffer that was exported from another process.
 
         Parameters
         ----------
-        mr : :obj:`~_memory.DeviceMemoryResource` | :obj:`~_memory.PinnedMemoryResource`
-            The IPC-enabled memory resource matching the exporting process.
+        mr : :obj:`~_memory.DeviceMemoryResource` | :obj:`~_memory.PinnedMemoryResource` | :obj:`~_memory.VirtualMemoryResource`
+            The IPC-enabled memory resource matching the exporting process. A
+            descriptor exported from a :class:`VirtualMemoryBuffer` is imported
+            with a :class:`VirtualMemoryResource` of this process whose
+            ``handle_type`` matches the exporter's; the import maps the shared
+            physical memory for that resource's device with that resource's
+            access options.
         ipc_descriptor : :obj:`~_memory.IPCBufferDescriptor`
             The descriptor exported from another process.
         stream : :obj:`~_stream.Stream`
@@ -103,7 +109,11 @@ class Buffer:
         """
     @property
     def ipc_descriptor(self) -> IPCBufferDescriptor:
-        """Descriptor for sharing this buffer with other processes."""
+        """Descriptor for sharing this buffer with other processes.
+
+        A pool-backed buffer caches its descriptor; a
+        :class:`VirtualMemoryBuffer` exports a new one on every access.
+        """
     def close(self, stream: Stream | GraphBuilder | None=None) -> None:
         """Deallocate this buffer asynchronously on the given stream.
 
 
@@ -58,6 +58,7 @@ from cuda.core._dlpack import classify_dl_device, make_py_capsule
 from cuda.core._device import Device
 
 if TYPE_CHECKING:
+    from cuda.core._memory._virtual_memory_resource import VirtualMemoryResource
     from cuda.core.graph import GraphBuilder
 
 
@@ -402,15 +403,21 @@ cdef class Buffer:
 
     @classmethod
     def from_ipc_descriptor(
-        cls, mr: DeviceMemoryResource | PinnedMemoryResource, ipc_descriptor: IPCBufferDescriptor,
+        cls, mr: DeviceMemoryResource | PinnedMemoryResource | VirtualMemoryResource,
+        ipc_descriptor: IPCBufferDescriptor,
         *, stream: Stream
     ) -> Buffer:
         """Import a buffer that was exported from another process.
 
         Parameters
         ----------
-        mr : :obj:`~_memory.DeviceMemoryResource` | :obj:`~_memory.PinnedMemoryResource`
-            The IPC-enabled memory resource matching the exporting process.
+        mr : :obj:`~_memory.DeviceMemoryResource` | :obj:`~_memory.PinnedMemoryResource` | :obj:`~_memory.VirtualMemoryResource`
+            The IPC-enabled memory resource matching the exporting process. A
+            descriptor exported from a :class:`VirtualMemoryBuffer` is imported
+            with a :class:`VirtualMemoryResource` of this process whose
+            ``handle_type`` matches the exporter's; the import maps the shared
+            physical memory for that resource's device with that resource's
+            access options.
         ipc_descriptor : :obj:`~_memory.IPCBufferDescriptor`
             The descriptor exported from another process.
         stream : :obj:`~_stream.Stream`
@@ -428,7 +435,11 @@ cdef class Buffer:
     @property
     @cython.critical_section
     def ipc_descriptor(self) -> IPCBufferDescriptor:
-        """Descriptor for sharing this buffer with other processes."""
+        """Descriptor for sharing this buffer with other processes.
+
+        A pool-backed buffer caches its descriptor; a
+        :class:`VirtualMemoryBuffer` exports a new one on every access.
+        """
         Buffer_check_open(self)
         cdef object ipc_data
         if self._ipc_data is None:
 
@@ -53,10 +53,18 @@ cdef class IPCAllocationHandle:
     cpdef close(self)
 
 
+# Descriptor of a VirtualMemoryResource buffer: one exported handle per
+# physical allocation that backs the buffer, in address order.
+cdef class VirtualMemoryIPCBufferDescriptor(IPCBufferDescriptor):
+    cdef readonly int   _handle_type
+    cdef readonly tuple _chunk_sizes
+    cdef readonly tuple _handles
+
+
 # Buffer IPC Implementation
 # -------------------------
 cdef IPCBufferDescriptor Buffer_get_ipc_descriptor(Buffer)
-cdef Buffer Buffer_from_ipc_descriptor(cls, _MemPool, IPCBufferDescriptor, stream)
+cdef Buffer Buffer_from_ipc_descriptor(cls, object, IPCBufferDescriptor, stream)
 
 
 # _MemPool IPC Implementation