From 450cc9d8aff9238132dbb2786a3c31d4a17ed7d6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Chosc=20=EA=A9=9C?= Date: Wed, 18 Nov 2026 13:41:05 +0200 Subject: [PATCH 1/3] fix(compositor): return None from create_exportable_staging without dmabuf extensions On a hybrid AMD + NVIDIA Linux laptop, wgpu picks the NVIDIA adapter, which is opened without VK_KHR_external_memory_fd / VK_EXT_external_memory_dma_buf, while VaapiEncoder::open succeeds on renderD128 (the AMD iGPU). The export then called vkGetMemoryFdKHR anyway: ash panicked with "Unable to load get_memory_fd_khr" in a non-unwinding context and the whole app aborted. Check the device's enabled extensions first and return None, as the doc comment already promised, so run_multi_inner falls back to the software encoder. Adds a regression test that opens a device through the standard request_device path; without the guard it reproduces the abort. Fixes #1622 Co-Authored-By: Claude Opus 5.5 --- crates/compositor/src/compositor_linux.rs | 64 +++++++++++++++++++++++ 1 file changed, 64 insertions(+) diff --git a/crates/compositor/src/compositor_linux.rs b/crates/compositor/src/compositor_linux.rs index 501eb9df0..9ec79c76a 100644 --- a/crates/compositor/src/compositor_linux.rs +++ b/crates/compositor/src/compositor_linux.rs @@ -4674,6 +4674,56 @@ mod tests { assert_eq!(got, pattern, "la memoire exportee ne porte pas ce que wgpu y a ecrit"); } + /// Un device ouvert SANS les extensions de memoire externe doit rendre `None`, pas + /// avorter le processus. C'est le cas d'un portable hybride AMD + NVIDIA : wgpu y + /// prend la NVIDIA sans export dmabuf, `VaapiEncoder::open` reussit sur l'AMD, et + /// l'appel suivant paniquait dans ash (« Unable to load get_memory_fd_khr ») au + /// clic sur Exporter (#1622). + /// + /// Le device est ouvert par `request_device`, le chemin standard de wgpu, qui + /// n'active pas ces extensions — exactement ce que `create_async` garde quand + /// `open_device_with_dmabuf_export` echoue. + #[test] + fn exportable_staging_without_external_memory_is_none_not_an_abort() { + let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor { + backends: wgpu::Backends::VULKAN, + ..Default::default() + }); + let Some(adapter) = pollster::block_on( + instance.request_adapter(&wgpu::RequestAdapterOptions::default()), + ) else { + eprintln!("pas d'adaptateur Vulkan — test saute"); + return; + }; + let (device, queue) = + pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor::default(), None)) + .expect("request_device"); + let has_both = unsafe { + device.as_hal::(|hal| { + hal.is_some_and(|hal| { + let enabled = hal.enabled_device_extensions(); + enabled.contains(&ash::khr::external_memory_fd::NAME) + && enabled.contains(&ash::ext::external_memory_dma_buf::NAME) + }) + }) + }; + if has_both { + eprintln!("wgpu active deja la memoire externe sur ce pilote — test saute"); + return; + } + let gpu = Gpu { + device, + context: queue, + backend: crate::d3d::Backend::Hardware, + feature_level: 0, + }; + let comp = Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized"); + assert!( + comp.create_exportable_staging(4096).is_none(), + "sans extensions de memoire externe, le staging exportable doit etre refuse", + ); + } + /// Un cran de padding en format Auto change la taille de rendu de la preview. `resized` /// realloue les cibles et garde le reste : le masque webcam, et la boite aux lettres ou le /// worker de segmentation depose les suivants. @@ -7385,6 +7435,20 @@ impl Compositor { unsafe { self.gpu.device.as_hal::(|hal| { let hal = hal?; + // LE `None` PROMIS PLUS HAUT DOIT ETRE TENU ICI, AVANT TOUT APPEL. Sans + // les deux extensions, `vkGetMemoryFdKHR` n'est pas charge : ash panique + // (« Unable to load get_memory_fd_khr ») dans un contexte qui ne deroule + // pas, et c'est tout le processus qui avorte au clic sur Exporter. + // Arrive sur un portable hybride AMD + NVIDIA : wgpu prend la NVIDIA, + // ouverte sans export dmabuf, tandis que `VaapiEncoder::open` reussit + // sur `renderD128`, l'AMD. Rendre `None` fait retomber l'export sur + // l'encodeur software, comme le prevoit `run_multi_inner`. + let enabled = hal.enabled_device_extensions(); + if !enabled.contains(&ash::khr::external_memory_fd::NAME) + || !enabled.contains(&ash::ext::external_memory_dma_buf::NAME) + { + return None; + } let dev = hal.raw_device().clone(); let phys = hal.raw_physical_device(); let instance = hal.shared_instance().raw_instance(); From decc1303d77d5346a6b33cafce375f395de9af15 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Chosc=20=EA=A9=9C?= Date: Wed, 18 Nov 2026 13:58:49 +0200 Subject: [PATCH 2/3] test(compositor): only skip the dmabuf round-trip when the device lacks the extensions The round-trip test skipped on any None from create_exportable_staging, so a guard that wrongly refused a capable device would have passed silently. Check the device's enabled extensions first, skip only when one is missing, and otherwise require Some. The check is shared with the regression test through a small has_external_memory helper. Addresses the CodeRabbit review on #1624. Co-Authored-By: Claude Opus 5.5 --- crates/compositor/src/compositor_linux.rs | 35 +++++++++++++++-------- 1 file changed, 23 insertions(+), 12 deletions(-) diff --git a/crates/compositor/src/compositor_linux.rs b/crates/compositor/src/compositor_linux.rs index 9ec79c76a..1195d9543 100644 --- a/crates/compositor/src/compositor_linux.rs +++ b/crates/compositor/src/compositor_linux.rs @@ -4561,6 +4561,20 @@ mod tests { gpu } + /// Vrai si le device a active les deux extensions dont depend l'export dmabuf — + /// la meme condition que la garde de `create_exportable_staging`. + fn has_external_memory(device: &wgpu::Device) -> bool { + unsafe { + device.as_hal::(|hal| { + hal.is_some_and(|hal| { + let enabled = hal.enabled_device_extensions(); + enabled.contains(&ash::khr::external_memory_fd::NAME) + && enabled.contains(&ash::ext::external_memory_dma_buf::NAME) + }) + }) + } + } + /// Deux `TextureView` NV12-split, comme `linux_frames::nv12_planes` en rend. /// /// Les textures ne sont pas retournees : en wgpu une `TextureView` garde la @@ -4655,10 +4669,16 @@ mod tests { let Some(gpu) = gpu() else { return }; let comp = Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized"); const N: u64 = 4096; - let Some(st) = comp.create_exportable_staging(N) else { + // On ne saute QUE si le device n'a pas les extensions. Sauter sur tout `None` + // laisserait passer en silence une garde de `create_exportable_staging` qui + // refuserait a tort un device capable. + if !has_external_memory(&gpu.device) { eprintln!("pas d'extensions de memoire externe — test saute"); return; - }; + } + let st = comp + .create_exportable_staging(N) + .expect("staging exportable attendu avec les extensions de memoire externe"); assert!(st.fd >= 0, "descripteur dmabuf invalide"); assert_eq!(st.size, N); @@ -4698,16 +4718,7 @@ mod tests { let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor::default(), None)) .expect("request_device"); - let has_both = unsafe { - device.as_hal::(|hal| { - hal.is_some_and(|hal| { - let enabled = hal.enabled_device_extensions(); - enabled.contains(&ash::khr::external_memory_fd::NAME) - && enabled.contains(&ash::ext::external_memory_dma_buf::NAME) - }) - }) - }; - if has_both { + if has_external_memory(&device) { eprintln!("wgpu active deja la memoire externe sur ce pilote — test saute"); return; } From d68ee5455daa1b89e35971624f9dd296aa4ed9a5 Mon Sep 17 00:00:00 2001 From: EtienneLescot Date: Thu, 19 Nov 2026 13:04:25 +0100 Subject: [PATCH 3/3] test(compositor): skip the dmabuf round-trip on buffer capability, not only extensions A device can enable both external-memory extensions yet refuse to export a TRANSFER_DST buffer as dmabuf, or offer no HOST_VISIBLE | HOST_COHERENT memory type for it. create_exportable_staging then returns None, which the round-trip test would report as a failed guard. The test now checks those capabilities and keeps its expect once they hold. Refs #1622 --- crates/compositor/src/compositor_linux.rs | 63 ++++++++++++++++++++--- 1 file changed, 57 insertions(+), 6 deletions(-) diff --git a/crates/compositor/src/compositor_linux.rs b/crates/compositor/src/compositor_linux.rs index 1195d9543..d79d85ab6 100644 --- a/crates/compositor/src/compositor_linux.rs +++ b/crates/compositor/src/compositor_linux.rs @@ -4575,6 +4575,57 @@ mod tests { } } + /// Vrai si le device sait exporter en dmabuf un buffer `TRANSFER_DST` de `size` + /// octets dans une memoire HOST_VISIBLE | HOST_COHERENT, ce qu'exige + /// `create_exportable_staging` apres sa garde d'extensions. Les extensions seules + /// ne le promettent pas : Vulkan rend ces capacites par parametres de buffer. + fn supports_exportable_staging(device: &wgpu::Device, size: u64) -> bool { + use ash::vk; + if !has_external_memory(device) { + return false; + } + unsafe { + device.as_hal::(|hal| { + let Some(hal) = hal else { return false }; + let dev = hal.raw_device(); + let phys = hal.raw_physical_device(); + let instance = hal.shared_instance().raw_instance(); + let usage = vk::BufferUsageFlags::TRANSFER_DST; + let handle = vk::ExternalMemoryHandleTypeFlags::DMA_BUF_EXT; + + let info = vk::PhysicalDeviceExternalBufferInfo::default() + .usage(usage) + .handle_type(handle); + let mut props = vk::ExternalBufferProperties::default(); + instance.get_physical_device_external_buffer_properties(phys, &info, &mut props); + if !props + .external_memory_properties + .external_memory_features + .contains(vk::ExternalMemoryFeatureFlags::EXPORTABLE) + { + return false; + } + + let mut ext_info = vk::ExternalMemoryBufferCreateInfo::default().handle_types(handle); + let bci = vk::BufferCreateInfo::default() + .push_next(&mut ext_info) + .size(size) + .usage(usage) + .sharing_mode(vk::SharingMode::EXCLUSIVE); + let Ok(raw) = dev.create_buffer(&bci, None) else { return false }; + let req = dev.get_buffer_memory_requirements(raw); + dev.destroy_buffer(raw, None); + let mem = instance.get_physical_device_memory_properties(phys); + let want = + vk::MemoryPropertyFlags::HOST_VISIBLE | vk::MemoryPropertyFlags::HOST_COHERENT; + (0..mem.memory_type_count).any(|i| { + req.memory_type_bits & (1 << i) != 0 + && mem.memory_types[i as usize].property_flags.contains(want) + }) + }) + } + } + /// Deux `TextureView` NV12-split, comme `linux_frames::nv12_planes` en rend. /// /// Les textures ne sont pas retournees : en wgpu une `TextureView` garde la @@ -4669,16 +4720,16 @@ mod tests { let Some(gpu) = gpu() else { return }; let comp = Compositor::new_sized(&gpu, 320, 180).expect("Compositor::new_sized"); const N: u64 = 4096; - // On ne saute QUE si le device n'a pas les extensions. Sauter sur tout `None` - // laisserait passer en silence une garde de `create_exportable_staging` qui - // refuserait a tort un device capable. - if !has_external_memory(&gpu.device) { - eprintln!("pas d'extensions de memoire externe — test saute"); + // On ne saute QUE si le device ne sait pas faire ce buffer. Sauter sur tout + // `None` laisserait passer en silence une garde de `create_exportable_staging` + // qui refuserait a tort un device capable. + if !supports_exportable_staging(&gpu.device, N) { + eprintln!("pas de buffer dmabuf exportable et coherent sur ce device — test saute"); return; } let st = comp .create_exportable_staging(N) - .expect("staging exportable attendu avec les extensions de memoire externe"); + .expect("staging exportable attendu sur un device qui le supporte"); assert!(st.fd >= 0, "descripteur dmabuf invalide"); assert_eq!(st.size, N);