@@ -144,8 +144,8 @@ 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. 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
@@ -203,8 +203,9 @@ what makes that safe: the allocation is released exactly once, when its last map
 
 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;
-`is_ipc_enabled` reports it). The exporter calls `cuMemExportToShareableHandle`
+`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
 
@@ -293,10 +293,12 @@ cdef class VirtualMemoryIPCBufferDescriptor(IPCBufferDescriptor):
                 continue
             dup = os.dup(operator.index(item))
             try:
-                handles.append(IPCAllocationHandle._init(dup, None))
+                handle = IPCAllocationHandle._init(dup, None)
             except:  # noqa: E722  rollback-then-raise: the duplicate is not owned yet
                 os.close(dup)
                 raise
+            # The handle owns the duplicate now; if append fails, the handle closes it once.
+            handles.append(handle)
         return VirtualMemoryIPCBufferDescriptor._from_exports(driver_type, sizes_t, tuple(handles), size)
 
     @property
 
@@ -329,18 +329,20 @@ class VirtualMemoryResource(MemoryResource):
     def is_ipc_enabled(self) -> bool:
         """Whether buffers of this resource can be shared with other processes.
 
-        True when ``config.handle_type`` is ``"posix_fd"`` on Linux;
-        ``handle_type`` is the only switch, there is no separate option. With
-        ``handle_type=None`` the allocations cannot be exported, Win32 KMT
-        handles are not transported by cuda.core, and fabric handles are not
-        supported yet.
+        True when ``config.handle_type`` is ``"posix_fd"`` on Linux and the
+        memory lives on a device; ``handle_type`` is the only switch, there is
+        no separate option. With ``handle_type=None`` the allocations cannot
+        be exported, Win32 KMT handles are not transported by cuda.core, and
+        fabric handles are not supported yet. Host-located virtual memory
+        (``location_type`` ``"host"``, ``"host_numa"``, or
+        ``"host_numa_current"``) is not shared yet.
         """
     def _import_ipc_buffer(self, desc: VirtualMemoryIPCBufferDescriptor, stream) -> VirtualMemoryBuffer:
         """Import a buffer that another process exported; see :meth:`Buffer.from_ipc_descriptor`.
 
         Every exported allocation is imported with this resource's handle
-        type and checked to live where this resource allocates (its device,
-        or its host location). The allocations are then mapped in order into
+        type and checked to live on this resource's device. The allocations
+        are then mapped in order into
         one new address reservation with the access descriptors this
         resource's options produce for its device and peers, and the
         deallocation stream is recorded as :meth:`allocate` does. The
 
@@ -885,20 +885,25 @@ cdef class VirtualMemoryResource(MemoryResource):
     def is_ipc_enabled(self) -> bool:
         """Whether buffers of this resource can be shared with other processes.
 
-        True when ``config.handle_type`` is ``"posix_fd"`` on Linux;
-        ``handle_type`` is the only switch, there is no separate option. With
-        ``handle_type=None`` the allocations cannot be exported, Win32 KMT
-        handles are not transported by cuda.core, and fabric handles are not
-        supported yet.
+        True when ``config.handle_type`` is ``"posix_fd"`` on Linux and the
+        memory lives on a device; ``handle_type`` is the only switch, there is
+        no separate option. With ``handle_type=None`` the allocations cannot
+        be exported, Win32 KMT handles are not transported by cuda.core, and
+        fabric handles are not supported yet. Host-located virtual memory
+        (``location_type`` ``"host"``, ``"host_numa"``, or
+        ``"host_numa_current"``) is not shared yet.
         """
-        return self.config.handle_type in _IPC_HANDLE_TYPES
+        return (
+            self.config.handle_type in _IPC_HANDLE_TYPES
+            and self.config.location_type not in _HOST_LOCATION_TYPES
+        )
 
     def _import_ipc_buffer(self, VirtualMemoryIPCBufferDescriptor desc not None, stream) -> VirtualMemoryBuffer:
         """Import a buffer that another process exported; see :meth:`Buffer.from_ipc_descriptor`.
 
         Every exported allocation is imported with this resource's handle
-        type and checked to live where this resource allocates (its device,
-        or its host location). The allocations are then mapped in order into
+        type and checked to live on this resource's device. The allocations
+        are then mapped in order into
         one new address reservation with the access descriptors this
         resource's options produce for its device and peers, and the
         deallocation stream is recorded as :meth:`allocate` does. The
@@ -919,7 +924,7 @@ cdef class VirtualMemoryResource(MemoryResource):
         cdef VmmRangeHandle rng
         cdef DevicePtrHandle h_ptr
         cdef Buffer buf
-        cdef size_t gran, addr_align, chunk, total = 0, offset = 0
+        cdef size_t gran, gran_min = 0, addr_align, chunk, total = 0, offset = 0
         cdef Py_ssize_t n, i
         cdef cydriver.CUdeviceptr hint
         cdef int handle_type, fd
@@ -955,11 +960,17 @@ cdef class VirtualMemoryResource(MemoryResource):
         self._fill_prop(cfg, &prop)
         self._fill_access(cfg, &prop, descs)
         gran = self._granularity(cfg, &prop)
+        # cuMemMap requires the minimum granularity, whatever this resource's
+        # granularity option says; the exporter may have used either.
+        with nogil:
+            HANDLE_RETURN(cydriver.cuMemGetAllocationGranularity(
+                &gran_min, &prop, cydriver.CU_MEM_ALLOC_GRANULARITY_MINIMUM))
         for chunk_obj in desc._chunk_sizes:
             chunk = chunk_obj
-            if chunk == 0 or chunk % gran != 0:
+            if chunk == 0 or chunk % gran_min != 0:
                 raise ValueError(
-                    f"descriptor chunk size {chunk} is not a positive multiple of the {gran}-byte granularity"
+                    f"descriptor chunk size {chunk} is not a positive multiple of the {gran_min}-byte minimum "
+                    "granularity"
                 )
             if chunk > <size_t>-1 - total:
                 raise OverflowError("the descriptor's chunk sizes do not fit in size_t")
@@ -988,9 +999,10 @@ cdef class VirtualMemoryResource(MemoryResource):
                     os_handle, <cydriver.CUmemAllocationHandleType>handle_type, chunk, descs.data(), descs.size())
             if not h_alloc:
                 _raise_last_error_noting(
-                    f"while importing chunk {i + 1} of {n} of a VirtualMemoryResource buffer descriptor; the "
-                    "shared handle may not refer to a CUDA allocation exported with "
-                    f"handle_type={str(cfg.handle_type)!r}"
+                    f"while importing chunk {i + 1} of {n} of a VirtualMemoryResource buffer descriptor; either "
+                    "the shared handle does not refer to a CUDA allocation exported with "
+                    f"handle_type={str(cfg.handle_type)!r}, or the device that owns the memory is not usable in "
+                    "this process (for example, CUDA_VISIBLE_DEVICES hides it)"
                 )
             # The exporter chose where the memory lives. This resource must map
             # memory of that kind on that device, or its access descriptors
@@ -1106,9 +1118,11 @@ cdef VirtualMemoryIPCBufferDescriptor _export_ipc_descriptor(Buffer buf):
             "allocation takes one file descriptor, so a process near its file descriptor limit fails here",
         )
         try:
-            handles.append(IPCAllocationHandle._init(fd, None))
+            handle = IPCAllocationHandle._init(fd, None)
         except:  # noqa: E722  rollback-then-raise: the fd is not owned yet
             os.close(fd)
             raise
+        # The handle owns the fd now; if append fails, the handle closes it once.
+        handles.append(handle)
         sizes.append(chunk)
     return VirtualMemoryIPCBufferDescriptor._from_exports(handle_type, tuple(sizes), tuple(handles), buf._size)
@@ -86,7 +86,8 @@ New features
   device that owns the memory, and a buffer or its descriptor can be sent
   through ``multiprocessing`` directly (plain ``pickle`` cannot carry file
   descriptors). :attr:`VirtualMemoryResource.is_ipc_enabled` is ``True`` when
-  the resource's ``handle_type`` is ``"posix_fd"`` on Linux. A grown buffer
+  the resource's ``handle_type`` is ``"posix_fd"`` on Linux and the memory
+  lives on a device; host-located virtual memory is not shared yet. A grown buffer
   imports as one contiguous range. A descriptor holds one file descriptor per
   physical allocation and pins the memory while it exists; nothing else does.
   A buffer that contains imported memory cannot be exported again. For a
 
@@ -181,11 +181,14 @@ def _on_queue_feeder_error(e, _obj):
         pytest.param({"handle_type": "fabric"}, False, id="fabric"),
         pytest.param({"handle_type": "win32_kmt"}, False, id="win32_kmt"),
         pytest.param({"location_type": "host", "handle_type": None}, False, id="host"),
-        pytest.param({"location_type": "host_numa", "handle_type": "posix_fd"}, True, id="host_numa-posix_fd"),
+        pytest.param({"location_type": "host_numa", "handle_type": "posix_fd"}, False, id="host_numa-posix_fd"),
+        pytest.param(
+            {"location_type": "host_numa_current", "handle_type": "posix_fd"}, False, id="host_numa_current-posix_fd"
+        ),
     ],
 )
 def test_is_ipc_enabled(vmm_ipc_device, options, expected):
-    """Only POSIX file descriptors have a transport; the location does not matter."""
+    """Only POSIX file descriptors on device memory have a transport; host-located memory is not shared yet."""
     mr = VirtualMemoryResource(vmm_ipc_device, config=VirtualMemoryResourceOptions(**options))
     assert mr.is_ipc_enabled is expected