From c4d704db1a65b29ad29eb4a7d795e9f4405f5a51 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/2] 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 82833d649eeaf872f62be41aa690d10de1714d64 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/2] 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; }