GPU segfault for Wayland when using wgpu/Vulkan with multiple windows / multiple Pixels buffers

[merehap]

When I open two windows and close one of them, the other window causes a segfault during Pixels::render_with. This happened as a result of code restructurings that were needed to upgrade pixels from 0.15 to 0.17.

Steps to repro, using my reznez program, which uses pixels among other GUI libraries:

1. git pull https://github.com/merehap/reznez/tree/waylandbug
2. cargo run --release (this opens the primary window)
3. Open the reznez Status window by browsing the menu bar: "Debug Windows" >> "Status" 
4. Close the Status window by pressing its "X".

Actual result: A segfault occurs. Not on the window close, but when the primary window attempts to render again, even though no change occurred to primary window
Expected result: The Status window closes, no segfault occurs.

Notes:

• reznez is using pixels, egui, winit, and wgpu together.
• Pixels isn't the only thing drawing to each Window. egui_winit is used to draw text and form elements to the same Windows.
• In the repro steps above, nothing is actually being written to the Pixels buffers (since no game ROM has been loaded), they are only being created and destroyed.
• The primary window has special logic that closes all windows when it is closed. This occurs before the segfault can take place. If this logic is removed, then closing the primary window causes the Status window to segfault.
• The segfault occurs even if there are more than 2 windows open when a window is closed.
• I'm delaying window close until RedrawRequested in the linked code as part of the debugging process. Since I'm not delaying it in the master branch, but I'm still getting the segfault there, I'm pretty sure that delay is not causing the problem.

Diff showing the relevant file with the debug logging statements added: merehap/reznez@39ec7e9

Relevant struct (two irrelevant fields omitted). I create one of these per actual GUI window. There is no shared state between different EguiWindows, but pixels, window, and wgpu_renderer within an EguiWindow do share state. This debug drop implementation never fails, the failure is during a later render_with call.

struct EguiWindow<'a> {
    egui_state: egui_winit::State,
    screen_descriptor: ScreenDescriptor,
    
    paint_jobs: Vec<ClippedPrimitive>,
    textures: TexturesDelta,

    // Fields that share a Window using an Arc, or share other GPU resources. The ManuallyDrop wrappers are only present for debugging.
    pixels: ManuallyDrop<Pixels<'a>>,
    window: ManuallyDrop<Arc<Window>>,
    wgpu_renderer: ManuallyDrop<Renderer>,
}

impl<'a> Drop for EguiWindow<'a> {
    fn drop(&mut self) {
        unsafe {
            eprintln!("MANUAL DROP: renderer");
            ManuallyDrop::drop(&mut self.wgpu_renderer);

            eprintln!("MANUAL DROP: pixels");
            ManuallyDrop::drop(&mut self.pixels);

            eprintln!("MANUAL DROP: window");
            ManuallyDrop::drop(&mut self.window);

            eprintln!("MANUAL DROP: done");
        }
    }
}

Debug output demonstrating that this isn't just a drop order problem that is solvable in my code:

MANUAL DROP: renderer
MANUAL DROP: pixels
MANUAL DROP: window
MANUAL DROP: done
after close_pending WindowId(100476948890624)
before render_with
Segmentation fault (core dumped)

after render_with is never reached.

GDB stack trace

Thread 1 "reznez" received signal SIGSEGV, Segmentation fault.
0x0000000000000000 in ?? ()
(gdb) bt
#0  0x0000000000000000 in ?? ()
#1  0x00007fffe692c423 in ?? () from /lib/x86_64-linux-gnu/libnvidia-glcore.so.580.126.18
#2  0x00007fffe6bb9a60 in ?? () from /lib/x86_64-linux-gnu/libnvidia-glcore.so.580.126.18
#3  0x0000555557a9fa61 in ash::extensions_generated::khr::swapchain::Device::acquire_next_image (self=0x55555a2501d0, swapchain=..., timeout=1000000000, semaphore=..., fence=...)
    at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ash-0.38.0+1.3.281/src/extensions/khr/swapchain.rs:62
#4  0x0000555557a6e20d in wgpu_hal::vulkan::swapchain::native::{impl#2}::acquire (self=0x55555a250130, timeout=..., fence=0x555559e7abc0) at src/vulkan/swapchain/native.rs:432
#5  0x0000555557949b05 in wgpu_hal::vulkan::instance::{impl#6}::acquire_texture (self=0x555559c2c510, timeout=..., fence=0x555559e7abc0) at src/vulkan/instance.rs:1031
#6  0x0000555557663238 in wgpu_hal::dynamic::surface::{impl#0}::acquire_texture<wgpu_hal::vulkan::Surface> (self=0x555559c2c510, timeout=..., fence=...)
    at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/wgpu-hal-29.0.3/src/dynamic/surface.rs:59
#7  0x0000555557898da7 in wgpu_core::instance::Surface::get_current_texture (self=0x555559bc2750) at src/present.rs:169
#8  0x000055555789b4f6 in wgpu_core::global::Global::surface_get_current_texture (self=0x555559e6f2b0, surface_id=..., texture_id_in=...) at src/present.rs:373
#9  0x00005555575b1505 in wgpu::backend::wgpu_core::{impl#57}::get_current_texture (self=0x555559e70560) at src/backend/wgpu_core.rs:3906
#10 0x00005555575dbc39 in wgpu::api::surface::Surface::get_current_texture (self=0x55555a5d0390) at src/api/surface.rs:121
#11 0x00005555568c2770 in pixels::Pixels::render_with<reznez::gui::egui_gui::{impl#7}::draw::{closure_env#2}> (self=0x55555a5d0240, render_function=...)
    at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/pixels-0.17.1/src/lib.rs:556
#12 0x0000555556a19c4f in reznez::gui::egui_gui::EguiWindow::draw (self=0x55555a5cff28, world=0x5555597383a0) at src/gui/egui_gui.rs:348
#13 0x0000555556a1a743 in reznez::gui::egui_gui::WindowManager::draw (self=0x55555973a498, world=0x5555597383a0, window_id=...) at src/gui/egui_gui.rs:494
#14 0x0000555556a1bab0 in reznez::gui::egui_gui::{impl#2}::window_event (self=0x5555597383a0, event_loop=0x5555597455c0, window_id=..., event=...) at src/gui/egui_gui.rs:156
#15 0x0000555556a80681 in winit::event_loop::dispatch_event_for_app<(), reznez::gui::egui_gui::EguiGui> (app=0x5555597383a0, event_loop=0x5555597455c0, event=<optimized out>)
    at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winit-0.30.13/src/event_loop.rs:642
#16 winit::event_loop::{impl#6}::run_app::{closure#0}<(), reznez::gui::egui_gui::EguiGui> (event=..., event_loop=0x5555597455c0)
    at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winit-0.30.13/src/event_loop.rs:265
#17 0x0000555556a814bf in core::ops::function::impls::{impl#3}::call_mut<(winit::event::Event<()>, &winit::event_loop::ActiveEventLoop), winit::event_loop::{impl#6}::run_app::{closure_env#0}<(), reznez::gui::egui_gui::EguiGui>> (self=0x7fffffff79b0, args=...) at /home/sean/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/ops/function.rs:298
#18 0x0000555556a8151f in core::ops::function::impls::{impl#3}::call_mut<(winit::event::Event<()>, &winit::event_loop::ActiveEventLoop), &mut winit::event_loop::{impl#6}::run_app::{closure_env#0}<(), reznez::gui::egui_gui::EguiGui>> (self=0x7fffffff77a8, args=...) at /home/sean/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/ops/function.rs:298
#19 0x00005555568ef516 in winit::platform_impl::linux::wayland::event_loop::EventLoop<()>::single_iteration<(), &mut &mut winit::event_loop::{impl#6}::run_app::{closure_env#0}<(), reznez::gui::egui_gui::EguiGui>> (
    self=0x555559745510, callback=0x7fffffff77a8, cause=...) at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winit-0.30.13/src/platform_impl/linux/wayland/event_loop/mod.rs:502
#20 0x00005555568f0356 in winit::platform_impl::linux::wayland::event_loop::EventLoop<()>::poll_events_with_timeout<(), &mut &mut winit::event_loop::{impl#6}::run_app::{closure_env#0}<(), reznez::gui::egui_gui::EguiGui>> (
    self=0x555559745510, timeout=..., callback=0x7fffffff79b0) at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winit-0.30.13/src/platform_impl/linux/wayland/event_loop/mod.rs:328
#21 0x00005555568ecb0f in winit::platform_impl::linux::wayland::event_loop::EventLoop<()>::pump_events<(), &mut winit::event_loop::{impl#6}::run_app::{closure_env#0}<(), reznez::gui::egui_gui::EguiGui>> (
    self=0x555559745510, timeout=..., callback=0x7fffffff7c38) at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winit-0.30.13/src/platform_impl/linux/wayland/event_loop/mod.rs:226
#22 0x00005555568ed1b7 in winit::platform_impl::linux::wayland::event_loop::EventLoop<()>::run_on_demand<(), winit::event_loop::{impl#6}::run_app::{closure_env#0}<(), reznez::gui::egui_gui::EguiGui>> (self=0x555559745510,
    event_handler=...) at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winit-0.30.13/src/platform_impl/linux/wayland/event_loop/mod.rs:190
#23 0x00005555569eeee5 in winit::platform_impl::linux::EventLoop<()>::run_on_demand<(), winit::event_loop::{impl#6}::run_app::{closure_env#0}<(), reznez::gui::egui_gui::EguiGui>> (self=0x7fffffff7df0, callback=...)
    at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winit-0.30.13/src/platform_impl/linux/mod.rs:820
#24 0x00005555569eef1a in winit::platform_impl::linux::EventLoop<()>::run<(), winit::event_loop::{impl#6}::run_app::{closure_env#0}<(), reznez::gui::egui_gui::EguiGui>> (self=..., callback=...)
    at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winit-0.30.13/src/platform_impl/linux/mod.rs:813
#25 0x0000555556a80541 in winit::event_loop::EventLoop<()>::run_app<(), reznez::gui::egui_gui::EguiGui> (self=..., app=0x5555597383a0)
    at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winit-0.30.13/src/event_loop.rs:265
#26 0x0000555556a1c203 in reznez::gui::egui_gui::{impl#1}::run (self=0x5555597383a0, nes=...) at src/gui/egui_gui.rs:110
#27 0x00005555569e79f2 in reznez::main () at src/main.rs:79

Pixels::render_with calls wgpu::api::surface::Surface::get_current_texture calls Vulcan calls libnvidia which seems to crash on a null pointer.

Relevant Cargo.toml entries:

egui = "0.34.1"
egui-wgpu = "0.34.1"
egui_extras = { version = "0.34.1", features = ["svg"] }
egui-winit = { version = "0.34.1", default-features = false, features = ["links"] }
egui_plot = "0.35.0"
egui_file = "0.26.0"

pixels = "0.17.1"

winit = "0.30.13"
winit_input_helper = "0.17"

I'm running Wayland running on PopOS 24.04 (Linux). @xNomadx1 confirmed this does NOT repro on X11 nor Mac.

I'll try to come up with a more minimal repro case for you as I assume that would be helpful. Let me know if you need any other info from me.

[merehap]

Here is a much more minimal repro: https://github.com/merehap/waylandpixelsbug

90% of the code is just egui/winit/pixels glue code. The remaining 10% displays the menu bar and adds and removes Windows from a BTreeMap. Note that

Maybe it can be simplified further by removing egui from the picture (or maybe not?), but this is as far as I'll go from now.

Note that the pixels frame buffer is not ever copied to (in this example repo). It is only created and destroyed.

Don't get confused by my custom WindowRenderer types: they have little to do with wgpu::Renderer.

Repro steps are

1. git pull https://github.com/merehap/waylandpixelsbug
2. cargo run (this opens the primary window)
3. Open the Status window by browsing the menu bar: "Debug Windows" >> "Status"
4. Close either window window by pressing its "X".

[parasyte]

'a is equivalent to 'static in:

struct EguiWindow<'a> {
    // ...
    pixels: ManuallyDrop<Pixels<'a>>,
    window: ManuallyDrop<Arc<Window>>,
    // ...
}

Due to Pixels<'_> owning Arc<Window> (conceptually, anyway; see below for the caveat). With that, you can remove the lifetime annotation from EguiWindow. Thus, also removing the remaining annotations all the way up the type hierarchy.

---

I'm not entirely certain what's going on, but it looks like there might be a problem with Pixels<'_> not owning the W that the PixelsBuilder<W> gets from SurfaceTexture<W>. Internally, a Surface<'static> is created from SurfaceTarget<'static>, where SurfaceTarget<'static> is created from Arc<Window>. But that Arc<Window> is dropped before PixelsBuilder::build() returns.

And that makes drop order sensitive, causing problems with Wayland specifically as seen in gfx-rs/wgpu#7665. It is disappointing that Surface<'_> has this problem. It's been worked around in wgpu and related projects quite a bit (gfx-rs/wgpu#6997, among others).

Please try this patch and see if it helps. This will guarantee that the surface is dropped before the window.

diff --git a/src/builder.rs b/src/builder.rs
index 8670fd5..d15f7b9 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -19,8 +19,9 @@ pub struct PixelsBuilder<'req, 'dev, 'win, W: wgpu::WindowHandle + 'win> {
     alpha_mode: wgpu::CompositeAlphaMode,
 }
 
-impl<'req, 'dev, 'win, W: wgpu::WindowHandle + raw_window_handle::HasDisplayHandle + 'win>
-    PixelsBuilder<'req, 'dev, 'win, W>
+impl<'req, 'dev, 'win, W> PixelsBuilder<'req, 'dev, 'win, W>
+where
+    W: Clone + wgpu::WindowHandle + raw_window_handle::HasDisplayHandle + 'win,
 {
     /// Create a builder that can be finalized into a [`Pixels`] pixel buffer.
     ///
@@ -269,14 +270,14 @@ impl<'req, 'dev, 'win, W: wgpu::WindowHandle + raw_window_handle::HasDisplayHand
     /// # Errors
     ///
     /// Returns an error when a [`wgpu::Adapter`] cannot be found.
-    async fn build_impl(self) -> Result<Pixels<'win>, Error> {
+    async fn build_impl(self) -> Result<Pixels<'win, W>, Error> {
         let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
             backends: self.backend,
             ..wgpu::InstanceDescriptor::new_without_display_handle().with_env()
         });
 
         // TODO: Use `options.pixel_aspect_ratio` to stretch the scaled texture
-        let surface = instance.create_surface(self.surface_texture.window)?;
+        let surface = instance.create_surface(self.surface_texture.window.clone())?;
         let compatible_surface = Some(&surface);
         let request_adapter_options = &self.request_adapter_options;
         let adapter = match wgpu::util::initialize_adapter_from_env(&instance, compatible_surface)
@@ -380,6 +381,7 @@ impl<'req, 'dev, 'win, W: wgpu::WindowHandle + raw_window_handle::HasDisplayHand
         let alpha_mode = self.alpha_mode;
         let pixels = Pixels {
             context,
+            _window: self.surface_texture.window,
             adapter,
             surface_size,
             present_mode,
@@ -404,7 +406,7 @@ impl<'req, 'dev, 'win, W: wgpu::WindowHandle + raw_window_handle::HasDisplayHand
     ///
     /// Returns an error when a [`wgpu::Adapter`] or [`wgpu::Device`] cannot be found.
     #[cfg(not(target_arch = "wasm32"))]
-    pub fn build(self) -> Result<Pixels<'win>, Error> {
+    pub fn build(self) -> Result<Pixels<'win, W>, Error> {
         pollster::block_on(self.build_impl())
     }
 
@@ -430,7 +432,7 @@ impl<'req, 'dev, 'win, W: wgpu::WindowHandle + raw_window_handle::HasDisplayHand
     /// # Errors
     ///
     /// Returns an error when a [`wgpu::Adapter`] or [`wgpu::Device`] cannot be found.
-    pub async fn build_async(self) -> Result<Pixels<'win>, Error> {
+    pub async fn build_async(self) -> Result<Pixels<'win, W>, Error> {
         self.build_impl().await
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 6b02064..0f35bdb 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -106,8 +106,9 @@ pub struct PixelsContext<'win> {
 ///
 /// See [`PixelsBuilder`] for building a customized pixel buffer.
 #[derive(Debug)]
-pub struct Pixels<'win> {
+pub struct Pixels<'win, W: 'win> {
     context: PixelsContext<'win>,
+    _window: W,
     surface_size: SurfaceSize,
     present_mode: wgpu::PresentMode,
     render_texture_format: wgpu::TextureFormat,
@@ -199,7 +200,10 @@ impl<W: wgpu::WindowHandle> SurfaceTexture<W> {
     }
 }
 
-impl<'win> Pixels<'win> {
+impl<'win, W> Pixels<'win, W>
+where
+    W: Clone + wgpu::WindowHandle + raw_window_handle::HasDisplayHandle + 'win,
+{
     /// Create a pixel buffer instance with default options.
     ///
     /// Any ratio differences between the pixel buffer texture size and surface texture size will
@@ -222,7 +226,7 @@ impl<'win> Pixels<'win> {
     /// # use pixels::{Pixels, SurfaceTexture};
     /// # let window = pixels_mocks::Window;
     /// let surface_texture = SurfaceTexture::new(320, 240, &window);
-    /// let mut pixels: Pixels<'_> = Pixels::new(320, 240, surface_texture)?;
+    /// let mut pixels: Pixels<'_, _> = Pixels::new(320, 240, surface_texture)?;
     /// # Ok::<(), pixels::Error>(())
     /// ```
     ///
@@ -235,7 +239,7 @@ impl<'win> Pixels<'win> {
     /// # let window = pixels_mocks::Window;
     /// let arc = Arc::new(window);
     /// let surface_texture = SurfaceTexture::new(320, 240, arc.clone());
-    /// let mut pixels: Pixels<'static> = Pixels::new(320, 240, surface_texture)?;
+    /// let mut pixels: Pixels<'static, _> = Pixels::new(320, 240, surface_texture)?;
     /// # Ok::<(), pixels::Error>(())
     /// ```
     ///
@@ -247,11 +251,7 @@ impl<'win> Pixels<'win> {
     ///
     /// Panics when `width` or `height` are 0.
     #[cfg(not(target_arch = "wasm32"))]
-    pub fn new<W: wgpu::WindowHandle + raw_window_handle::HasDisplayHandle + 'win>(
-        width: u32,
-        height: u32,
-        surface_texture: SurfaceTexture<W>,
-    ) -> Result<Self, Error> {
+    pub fn new(width: u32, height: u32, surface_texture: SurfaceTexture<W>) -> Result<Self, Error> {
         PixelsBuilder::new(width, height, surface_texture).build()
     }
 
@@ -278,7 +278,7 @@ impl<'win> Pixels<'win> {
     /// # Panics
     ///
     /// Panics when `width` or `height` are 0.
-    pub async fn new_async<W: wgpu::WindowHandle + raw_window_handle::HasDisplayHandle + 'win>(
+    pub async fn new_async(
         width: u32,
         height: u32,
         surface_texture: SurfaceTexture<W>,

[merehap]

I applied your patch to a local version of pixels, and then updated my minimal repro project to use it. I'm not sure the proper way to update my project, but using Arc Window as the generic parameter didn't fix it (the generic parameter can't just be inferred for struct fields). Using just Window without Arc doesn't compile for the same reason I'm using an Arc in the first place.

Note that I went ahead and applied your suggested 'static lifetime improvement. I'm assuming that's not really relevant here.

Sorry if I misunderstood how I was supposed to update my code. Me being in the loop might just be adding friction for you at this point, so you might just want to pull waylandpixelsbug to experiment directly. However, if setting up a box with Wayland on it will be too much of a hassle for you, then I'm happy to keep going.

Here's my diff to waylandpixelsbug:

diff --git a/Cargo.toml b/Cargo.toml
index 7ec0aa4..7816823 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,3 +16,6 @@ winit = "0.30.13"

 [profile.release]
 debug = true
+
+[patch.crates-io]
+pixels = { path = "../pixels" }
diff --git a/src/gui/egui_gui.rs b/src/gui/egui_gui.rs
index e348ade..649443f 100644
--- a/src/gui/egui_gui.rs
+++ b/src/gui/egui_gui.rs
@@ -110,7 +110,7 @@ struct EguiWindow {

     // State for the GUI
     window: Arc<Window>,
-    pixels: Pixels<'static>,
+    pixels: Pixels<'static, Arc<Window>>,
     window_renderer: Box<dyn WindowRenderer>,
 }

@@ -153,7 +153,7 @@ impl EguiWindow {
         height: u32,
         scale_factor: f32,
         window: Arc<Window>,
-        pixels: pixels::Pixels<'static>,
+        pixels: pixels::Pixels<'static, Arc<Window>>,
         window_renderer: Box<dyn WindowRenderer>,
     ) -> Self {
         let egui_state = egui_winit::State::new(

cargo build lines showing I am picking up the patch:

   Compiling pixels v0.17.1 (/home/sean/projects/pixels)
   Compiling egui-wgpu v0.34.3
   Compiling waylandpixelsbug v0.0.0 (/home/sean/projects/waylandpixelsbug)

Same GDB stack trace as before:

Thread 1 "waylandpixelsbu" received signal SIGSEGV, Segmentation fault.
0x0000000000000000 in ?? ()
(gdb) bt
#0  0x0000000000000000 in ?? ()
#1  0x00007ffff1b2c423 in ?? () from /lib/x86_64-linux-gnu/libnvidia-glcore.so.580.126.18
#2  0x00007ffff1db9a60 in ?? () from /lib/x86_64-linux-gnu/libnvidia-glcore.so.580.126.18
#3  0x000055555699bfe1 in ash::extensions_generated::khr::swapchain::Device::acquire_next_image (self=0x555558ce3ac0, swapchain=..., timeout=1000000000, semaphore=..., fence=...)
    at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ash-0.38.0+1.3.281/src/extensions/khr/swapchain.rs:62
#4  0x00005555569b682d in wgpu_hal::vulkan::swapchain::native::{impl#2}::acquire (self=0x555558ce3a20, timeout=..., fence=0x55555895f7b0) at src/vulkan/swapchain/native.rs:432
#5  0x0000555556869865 in wgpu_hal::vulkan::instance::{impl#6}::acquire_texture (self=0x555558710f40, timeout=..., fence=0x55555895f7b0) at src/vulkan/instance.rs:1031
#6  0x000055555664f7f8 in wgpu_hal::dynamic::surface::{impl#0}::acquire_texture<wgpu_hal::vulkan::Surface> (self=0x555558710f40, timeout=..., fence=...)
    at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/wgpu-hal-29.0.3/src/dynamic/surface.rs:59
#7  0x000055555659aba7 in wgpu_core::instance::Surface::get_current_texture (self=0x5555586a7220) at src/present.rs:169
#8  0x000055555659d416 in wgpu_core::global::Global::surface_get_current_texture (self=0x555558953b00, surface_id=..., texture_id_in=...) at src/present.rs:373
#9  0x00005555564d1225 in wgpu::backend::wgpu_core::{impl#57}::get_current_texture (self=0x555558954db0) at src/backend/wgpu_core.rs:3906
#10 0x000055555650dc59 in wgpu::api::surface::Surface::get_current_texture (self=0x555559170e48) at src/api/surface.rs:121
#11 0x0000555555fa3b40 in pixels::Pixels<alloc::sync::Arc<winit::window::Window, alloc::alloc::Global>>::render_with<alloc::sync::Arc<winit::window::Window, alloc::alloc::Global>, waylandpixelsbug::gui::egui_gui::{impl#2}::draw::{closure_env#1}> (self=0x555559170cf8, render_function=...) at /home/sean/projects/pixels/src/lib.rs:556
#12 0x0000555555f6b232 in waylandpixelsbug::gui::egui_gui::EguiWindow::draw (self=0x5555591709f0) at src/gui/egui_gui.rs:208
#13 0x0000555555f6a39e in waylandpixelsbug::gui::egui_gui::EguiGui::draw (self=0x7fffffffda80, window_id=...) at src/gui/egui_gui.rs:56
#14 0x0000555555f6b4d4 in waylandpixelsbug::gui::egui_gui::{impl#1}::window_event (self=0x7fffffffda80, event_loop=0x555558240440, window_id=..., event=...) at src/gui/egui_gui.rs:77
#15 0x0000555555f23621 in winit::event_loop::dispatch_event_for_app<(), waylandpixelsbug::gui::egui_gui::EguiGui> (app=0x7fffffffda80, event_loop=0x555558240440, event=<optimized out>)
    at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winit-0.30.13/src/event_loop.rs:642
#16 winit::event_loop::{impl#6}::run_app::{closure#0}<(), waylandpixelsbug::gui::egui_gui::EguiGui> (event=..., event_loop=0x555558240440)
    at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winit-0.30.13/src/event_loop.rs:265
#17 0x0000555555f23dff in core::ops::function::impls::{impl#3}::call_mut<(winit::event::Event<()>, &winit::event_loop::ActiveEventLoop), winit::event_loop::{impl#6}::run_app::{closure_env#0}<(), waylandpixelsbug::gui::egui_gui::EguiGui>> (self=0x7fffffffb5b0, args=...) at /home/sean/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/ops/function.rs:298
#18 0x0000555555f23e5f in core::ops::function::impls::{impl#3}::call_mut<(winit::event::Event<()>, &winit::event_loop::ActiveEventLoop), &mut winit::event_loop::{impl#6}::run_app::{closure_env#0}<(), waylandpixelsbug::gui::egui_gui::EguiGui>> (self=0x7fffffffb3a8, args=...) at /home/sean/.rustup/toolchains/nightly-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/ops/function.rs:298
#19 0x0000555555f1d5c6 in winit::platform_impl::linux::wayland::event_loop::EventLoop<()>::single_iteration<(), &mut &mut winit::event_loop::{impl#6}::run_app::{closure_env#0}<(), waylandpixelsbug::gui::egui_gui::EguiGui>> (
    self=0x555558240390, callback=0x7fffffffb3a8, cause=...) at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winit-0.30.13/src/platform_impl/linux/wayland/event_loop/mod.rs:502
#20 0x0000555555f1e3fb in winit::platform_impl::linux::wayland::event_loop::EventLoop<()>::poll_events_with_timeout<(), &mut &mut winit::event_loop::{impl#6}::run_app::{closure_env#0}<(), waylandpixelsbug::gui::egui_gui::EguiGui>> (self=0x555558240390, timeout=..., callback=0x7fffffffb5b0) at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winit-0.30.13/src/platform_impl/linux/wayland/event_loop/mod.rs:328
#21 0x0000555555f1abbf in winit::platform_impl::linux::wayland::event_loop::EventLoop<()>::pump_events<(), &mut winit::event_loop::{impl#6}::run_app::{closure_env#0}<(), waylandpixelsbug::gui::egui_gui::EguiGui>> (
    self=0x555558240390, timeout=..., callback=0x7fffffffb838) at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winit-0.30.13/src/platform_impl/linux/wayland/event_loop/mod.rs:226
#22 0x0000555555f1b267 in winit::platform_impl::linux::wayland::event_loop::EventLoop<()>::run_on_demand<(), winit::event_loop::{impl#6}::run_app::{closure_env#0}<(), waylandpixelsbug::gui::egui_gui::EguiGui>> (
    self=0x555558240390, event_handler=...) at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winit-0.30.13/src/platform_impl/linux/wayland/event_loop/mod.rs:190
#23 0x0000555555f18685 in winit::platform_impl::linux::EventLoop<()>::run_on_demand<(), winit::event_loop::{impl#6}::run_app::{closure_env#0}<(), waylandpixelsbug::gui::egui_gui::EguiGui>> (self=0x7fffffffb9f0, callback=...)
    at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winit-0.30.13/src/platform_impl/linux/mod.rs:820
#24 0x0000555555f186ba in winit::platform_impl::linux::EventLoop<()>::run<(), winit::event_loop::{impl#6}::run_app::{closure_env#0}<(), waylandpixelsbug::gui::egui_gui::EguiGui>> (self=..., callback=...)
    at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winit-0.30.13/src/platform_impl/linux/mod.rs:813
#25 0x0000555555f234e1 in winit::event_loop::EventLoop<()>::run_app<(), waylandpixelsbug::gui::egui_gui::EguiGui> (self=..., app=0x7fffffffda80)
    at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winit-0.30.13/src/event_loop.rs:265
#26 0x0000555555f6a211 in waylandpixelsbug::gui::egui_gui::EguiGui::run (self=0x7fffffffda80) at src/gui/egui_gui.rs:33
#27 0x0000555555f5966d in waylandpixelsbug::main () at src/main.rs:6
(gdb)

[parasyte]

I'm assuming that's not really relevant here.

Correct. It just simplifies the lifetimes. If anything, that helps with analysis.

you might just want to pull waylandpixelsbug to experiment directly.

I don't currently have a way to reproduce the crash, since it is environment specific. (I don't have Wayland easily accessible.)

Your diff looks like the right way to apply the patched library. (Pixels<'static, Arc<Window>> is the correct type to use.) Since this does not solve the problem, it strongly suggests that the lifetime on Surface<'_> is not the issue. Ordering the pixels field before window in your EguiWindow struct would have the same effect. So it wasn't exactly a likely candidate in the first place. It was just an issue I noticed which should be fixed anyway.

I don't know what the best next troubleshooting step is. The segfault occurring while acquiring the Vulkan swapchain is absurd. As long as the window handle is alive, getting the texture from the window surface should always succeed (the patched pixels ensures that the window handle is alive). And EguiWindow is guaranteed to not be dropped while its draw method is running. I really don't think surface drop order has anything to do with what you are seeing (I could be wrong, but everything is pointing away from it). Something else is going on.

[merehap]

I was going to offer to let you SSH into my machine to investigate, but apparently my ISP's NAT setup doesn't support port forwarding, so I can't set that up for you.

Unfortunately I don't think there's anything else I can do at this point. I'll leave that minimal repro branch open for you to use at your convenience.

[parasyte]

GPT-5.5 found an NVIDIA forum post that reports a very similar crash: https://forums.developer.nvidia.com/t/crash-on-wayland-wsi-functions-with-multiple-vulkan-instances-570-144-575-51-02/331981 - No additional information.

This may by a bug in the NVIDIA driver, and could have already been fixed. You're on an older version (580.126.18) and the most recent "production branch" version seems to be 595.80. There is also a "new feature branch" at version 610.43. Upgrading the driver is a long-shot for addressing this crash, but probably a good thing to do, if you can.

I also asked GPT-5.5 to provide some troubleshooting steps for you to try, to help narrow down the root cause. Here's the complete list of suggestions:

Troubleshooting steps

Additional diagnostics I'd ask the reporter for:

1. Test whether keeping the closed window's GPU resources alive avoids the crash

   Instead of dropping the closed window's Pixels, egui_wgpu::Renderer, and Window, remove it from the visible/window-manager list but intentionally keep the whole EguiWindow alive until process exit.

   If that avoids the crash, it strongly supports “tearing down one Wayland Vulkan swapchain poisons another swapchain” rather than a pixels::render_with logic bug.

2. Test whether the second window needs a Pixels swapchain

   Try these variants:

   • two windows, both with Pixels: expected current crash
   • two windows, primary with Pixels, secondary with egui only
   • two windows, primary with egui only, secondary with Pixels
   • two windows, both with wgpu/egui but only one creates/configures a surface

   The NVIDIA report says the trigger is specifically the second instance creating a Wayland surface and swapchain, then being torn down. So the key diagnostic is whether merely creating a second window is enough, or whether configuring/acquiring/presenting a second Vulkan surface is required.

3. Confirm whether every window owns a separate wgpu instance/device

   In reznez, log whether each EguiWindow creates its own Pixels, and whether egui rendering uses the pixels.device()/pixels.queue() for that same window or creates another independent wgpu::Device.

   The useful output is something like:

   window A: pixels device ptr/id = ...
   window A: egui renderer uses same device = yes/no
   window B: pixels device ptr/id = ...
   window B: egui renderer uses same device = yes/no

   If each window has one independent Pixels, then each window effectively has an independent wgpu/Vulkan instance path.

4. Try a pure wgpu repro without pixels or egui

   Minimal repro shape:

   • create winit window A
   • create wgpu instance/device/surface/swapchain for A
   • render/acquire/present A once
   • create winit window B
   • create a separate wgpu instance/device/surface/swapchain for B
   • render/acquire/present B once
   • drop B's surface/device/window
   • acquire/present A again

   If this crashes, it is a clean upstream wgpu/NVIDIA repro. If it does not crash, add egui back. If it still does not crash, compare against pixels resource creation/configuration.

5. Try a pure ash repro from the NVIDIA thread

   The NVIDIA forum thread includes MREs for the same multi-instance Wayland WSI crash. Ask the reporter to run that MRE on the same PopOS/NVIDIA 580.126.18 machine.

   Outcomes:

   • NVIDIA MRE crashes too: almost certainly driver/WSI.
   • NVIDIA MRE does not crash, but reznez does: look for a difference in wgpu usage, device selection, compositor, or teardown order.
   • NVIDIA MRE crashes only on 580: useful data for NVIDIA.

6. Test single shared instance architecture in a minimal repro

   Not necessarily easy with current pixels public API, but useful in a standalone wgpu test:

   • one wgpu::Instance
   • two windows
   • two surfaces created from the same instance
   • ideally one shared adapter/device/queue
   • drop one surface/window
   • continue acquiring/presenting on the other

   If shared-instance works but separate-instance crashes, that aligns almost exactly with the NVIDIA bug pattern and points to a possible long-term pixels API/design consideration: allowing callers to share a wgpu context across multiple Pixels surfaces.

7. Force backend/device variants

   Ask for this matrix:

   WGPU_BACKEND=vulkan cargo run --release
   WGPU_BACKEND=gl cargo run --release
   WGPU_POWER_PREF=low cargo run --release
   WGPU_POWER_PREF=high cargo run --release

   If gl works and Vulkan fails, that reinforces Vulkan WSI. If low works on an iGPU but high/NVIDIA fails, that further isolates NVIDIA.

8. Try NVIDIA driver versions

   Since the crash is inside libnvidia-glcore.so.580.126.18, driver version matters. Useful tests:

   • current 580.126.18
   • latest available production/beta driver
   • an older 575 or 570 driver, if practical
   • Nouveau/NVK only if they already have a safe way to test it

   The result should be reported as a matrix: driver version, compositor, backend, crash yes/no.

9. Collect NVIDIA-specific diagnostics

   Ask them to attach:

   nvidia-smi -q
   vulkaninfo --summary
   nvidia-bug-report.sh

   And the compositor/session info:

   echo "$XDG_SESSION_TYPE"
   echo "$XDG_CURRENT_DESKTOP"
   echo "$WAYLAND_DISPLAY"
   loginctl show-session "$XDG_SESSION_ID" -p Type -p Desktop

10. Check whether GPU-idle synchronization changes the crash

    Before dropping the window being closed, try waiting for GPU work to finish on that window's device:

    let _ = pixels.device().poll(wgpu::PollType::Wait);

    Also try polling the surviving window's device before its next render. If this changes the crash, it suggests teardown while the driver still has outstanding WSI work. If it does not, it still helps rule out an in-flight command lifetime issue.

11. Enable Vulkan validation and loader logging

    VK_INSTANCE_LAYERS=VK_LAYER_KHRONOS_validation \
    VK_LOADER_DEBUG=all \
    RUST_LOG=wgpu_core=trace,wgpu_hal=trace,wgpu=trace,winit=trace \
    WGPU_BACKEND=vulkan \
    cargo run --release 2> wayland-vulkan-close.log

    Validation layers may not catch a driver null call, but they can reveal invalid destroy/acquire/present ordering before the crash.

12. Use API dump around the crash

    If installed:

    VK_INSTANCE_LAYERS=VK_LAYER_LUNARG_api_dump \
    WGPU_BACKEND=vulkan \
    cargo run --release 2> vk-api-dump.log

    The last few Vulkan calls before the segfault are valuable: especially vkDestroySwapchainKHR, vkDestroySurfaceKHR, vkAcquireNextImageKHR, and which handles are involved.

The highest-signal next step is probably: run the NVIDIA multi-instance Wayland WSI MRE on the same machine, then test whether reznez stops crashing if the closed window's Pixels/surface/device are kept alive until app exit. Those two results would tell us whether this is likely a driver bug with a possible pixels multi-window workaround, or whether we need to keep digging in the app's resource wiring.

---

If there is anything in there that seems reasonable (and you have the time to dedicate to it), I would be interested in anything you discover from it.

The hypothesis that the bug may be caused by multiple device/instance/surface paths is compelling. If that is the case, while we could do the work to share instances in pixels, I suspect doing the work upstream in wgpu would be even better. But there are other ideas to explore as well, and it may not come to that.

[merehap]

Thankfully, a driver update fixed it, and whatever fix was backported so no major version upgrade was needed:
I went from 580.126.18 to 580.159.03 .

Thanks for your help! Should I follow up with wgpu to see if they can emit a warning when older versions of nvidia drivers are used on Wayland? Or do you think that would be a wasted effort?

[merehap]

Disregard the previous message.

The driver update silently failed initially, and fell back to software rendering where the issue obviously doesn't exist.

Upon system restart, the driver was properly installed, and the issue was not fixed.

(gdb) bt
#0  0x0000000000000000 in ?? ()
#1  0x00007fffe692f623 in ?? () from /lib/x86_64-linux-gnu/libnvidia-glcore.so.580.159.03
#2  0x00007fffe6bbcd70 in ?? () from /lib/x86_64-linux-gnu/libnvidia-glcore.so.580.159.03
#3  0x000055555670ba1f in ash::extensions_generated::khr::swapchain::Device::acquire_next_image (
    self=0x5555579372b0, swapchain=..., timeout=1000000000, semaphore=..., fence=...)
    at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ash-0.38.0+1.3.281/src/extensions/khr/swapchain.rs:62
#4  wgpu_hal::vulkan::swapchain::native::{impl#2}::acquire (self=0x555557937210, timeout=..., fence=<optimized out>)
    at src/vulkan/swapchain/native.rs:432
#5  0x00005555566ab5d8 in wgpu_hal::vulkan::instance::{impl#6}::acquire_texture (self=<optimized out>, timeout=...,
    fence=<optimized out>) at src/vulkan/instance.rs:1031
#6  0x00005555565bd1cd in wgpu_hal::dynamic::surface::{impl#0}::acquire_texture<wgpu_hal::vulkan::Surface> (
    self=0x55555730f440, timeout=..., fence=...)
    at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/wgpu-hal-29.0.3/src/dynamic/surface.rs:59
#7  0x00005555565d2eca in wgpu_core::instance::Surface::get_current_texture (self=0x5555572a5cb0)
    at src/present.rs:169
#8  0x00005555566776a2 in wgpu_core::global::Global::surface_get_current_texture (self=<optimized out>,
    surface_id=..., texture_id_in=...) at src/present.rs:373
#9  0x000055555654137b in wgpu::backend::wgpu_core::{impl#57}::get_current_texture (self=0x555557553610)
    at src/backend/wgpu_core.rs:3906
#10 0x0000555556552893 in wgpu::api::surface::Surface::get_current_texture (self=0x555557cad700)
    at src/api/surface.rs:121
#11 0x0000555556098955 in pixels::Pixels::render_with<reznez::gui::egui_gui::{impl#3}::draw::{closure_env#2}> (
    self=0x555557cad5b0, render_function=...)
    at /home/sean/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/pixels-0.17.1/src/lib.rs:556
#12 0x0000555556123239 in reznez::gui::egui_gui::EguiWindow::draw (world=0x555556e18310,
    self=<error reading variable: Cannot access memory at address 0x0>) at src/gui/egui_gui.rs:316
#13 reznez::gui::egui_gui::WindowManager::draw (self=0x555556e1a408, world=0x555556e18310, window_id=...)
    at src/gui/egui_gui.rs:441
#14 reznez::gui::egui_gui::{impl#2}::window_event (self=0x555556e18310, event_loop=0x555556e253c0, window_id=...,
    event=...) at src/gui/egui_gui.rs:154
#15 winit::event_loop::dispatch_event_for_app<(), reznez::gui::egui_gui::EguiGui> (app=0x555556e18310,
    event=<error reading variable: Cannot access memory at address 0x0>,