gdk_x11_surface_get_xid Segmentation Fault when initializing Mousetrap

[ufechner7]

julia> using Mousetrap
[ Info: Precompiling Mousetrap [5deeb4b9-6e04-4da7-8b7f-c77fb1eae65e]

[25147] signal (11.1): Segmentation fault
in expression starting at /home/ufechner/.julia/packages/Mousetrap/k0X9u/src/Mousetrap.jl:39
gdk_x11_surface_get_xid at /home/ufechner/.julia/artifacts/5498f875c31a1b3422ce1b64ef770407109eff30/lib/libgtk-4.so (unknown line)
Allocations: 815336 (Pool: 814877; Big: 459); GC: 1
ERROR: Failed to precompile Mousetrap [5deeb4b9-6e04-4da7-8b7f-c77fb1eae65e] to "/home/ufechner/.julia/compiled/v1.9/Mousetrap/jl_9p08JE".
Stacktrace:
 [1] error(s::String)
   @ Base ./error.jl:35
 [2] compilecache(pkg::Base.PkgId, path::String, internal_stderr::IO, internal_stdout::IO, keep_loaded_modules::Bool)
   @ Base ./loading.jl:2300
 [3] compilecache
   @ ./loading.jl:2167 [inlined]
 [4] _require(pkg::Base.PkgId, env::String)
   @ Base ./loading.jl:1805
 [5] _require_prelocked(uuidkey::Base.PkgId, env::String)
   @ Base ./loading.jl:1660
 [6] macro expansion
   @ ./loading.jl:1648 [inlined]
 [7] macro expansion
   @ ./lock.jl:267 [inlined]
 [8] require(into::Module, mod::Symbol)
   @ Base ./loading.jl:1611

What I did:
a. rename .julia to .julia.bak
b. create a new project and install Mousetrap as described in the README.md

(Mouse) pkg> st
Status `~/repos/Mouse/Project.toml`
  [5deeb4b9] Mousetrap v0.2.0 `https://github.com/Clemapfel/mousetrap.jl#main`
  [7f2654e2] mousetrap_apple_jll v0.2.0+0 `https://github.com/Clemapfel/mousetrap_apple_jll#main`
  [b6bb2801] mousetrap_linux_jll v0.2.0+0 `https://github.com/Clemapfel/mousetrap_linux_jll#main`
  [1923bf96] mousetrap_windows_jll v0.2.0+0 `https://github.com/Clemapfel/mousetrap_windows_jll#main`

julia> versioninfo()
Julia Version 1.9.3
Commit bed2cd540a1 (2023-08-24 14:43 UTC)
Build Info:
  Official https://julialang.org/ release
Platform Info:
  OS: Linux (x86_64-linux-gnu)
  CPU: 32 × AMD Ryzen 9 7950X 16-Core Processor
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-14.0.6 (ORCJIT, znver3)
  Threads: 1 on 32 virtual cores
Environment:
  LD_LIBRARY_PATH = /lib:/usr/lib:/usr/local/lib

ufechner@ufryzen:~$ uname -a
Linux ufryzen 6.2.0-32-generic #32~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Fri Aug 18 10:40:13 UTC 2 x86_64 x86_64 x86_64 GNU/Linux

I tried mousetrap on a freshly installed virtual machine, and that worked. I could also install it successfully on Ubuntu 20.04.

Any idea how to debug this issue?

[ufechner7]

Perhaps related: https://discourse.gnome.org/t/gdk-x11-surface-get-xid-hard-crashes-on-ubuntu-22-04/16818

[Clemapfel]

This time it shouldn't be a mousetrap issue, this is with the GTK backend and something about your windowing system. I can still try to help you get it working, since the GNOME forums will assume you're using C or Vala.

I can't reproduce this on my 22.04 machine, I tried Xorg and Wayland, which windowing system are you using? Could you try switching to others and see if the error persists? You can swap windowing system by choosing "log out" from the shutdown menu, then on the screen where you enter your password there's a cog in the bottom right where you can switch.

[ufechner7]

Well, I am using X11, but I cannot easily switch the windowing system because I use an nvidia graphics card with the proprietary driver, and it does not support Wayland, so the selection of Wayland is disabled by default.

[ufechner7]

OK, I tried with different graphic drivers. Not working:
Nvidia-535 (tested by Ubuntu)
Nvidia-525

Working:
nouveau

Not the final solution because there is no OpenGL acceleration with the nouveau driver, but at least we know now better what works and what doesn't.

[ufechner7]

Might this be related:

I am now using gdk_x11_surface_get_xid(gtk_native_get_surface(GTK_NATIVE(window))) to get an XID from a GTK window widget. – 
[Ank i zle](https://stackoverflow.com/users/10696946/ank-i-zle)
[Mar 15, 2022 at 2:10](https://stackoverflow.com/questions/71461608/gtk-window-to-gdk-surface-in-gtk4#comment126333979_71461608)

[NittanyLion]

fwiw: I'm getting the same error as @ufechner7 on Ubuntu 23.04 with X.

[Clemapfel]

fwiw: I'm getting the same error as ufechner7 on Ubuntu 23.04 with X.

Is this new in mousetrap v0.2.0 or did you have the same issue in 0.1.0?

[Clemapfel]

I don't have access to an nvidia graphics card and unlike with an OS I can't just spin up a VM to test it, so this might be hard for me to fix.

Just to isolate whether it's a mousetrap issue, can you install libadwaita_jll from the Julia package registry, then:

import libadwaita_jll
ccall((:adw_init, libadwaita_jll.libadwaita), Cint, ())

If that works, exit the Julia runtime, install GTK4_jll, then:

import GTK4_jll
ccall((:gtk_init, GTK4_jll.libgtk4), Cint, ())

If both work, please run:

import GTK4_jll, libadwaita_jll
begin
    ccall((:adw_init, libadwaita_jll.libadwaita), Cvoid, ())
    local window = ccall((:adw_window_new, libadwaita_jll.libadwaita), Ptr{Cvoid}, ())
    local area = ccall((:gtk_gl_area_new, GTK4_jll.libgtk4), Ptr{Cvoid}, ())
    ccall((:adw_window_set_content, libadwaita_jll.libadwaita), Cvoid, (Ptr{Cvoid}, Ptr{Cvoid}), window, area)
    ccall((:gtk_window_present, GTK4_jll.libgtk4), Cvoid, (Ptr{Cvoid},), window)
    println(ccall((:gtk_widget_get_realized, GTK4_jll.libgtk4), Cint, (Ptr{Cvoid},), area) == true)
    exit()
end

It should print true to the console, with no other console output.

[NittanyLion]

fwiw: I'm getting the same error as ufechner7 on Ubuntu 23.04 with X.

Is this new in mousetrap v0.2.0 or did you have the same issue in 0.1.0?

First time I tried to install mousetrap.

[ufechner7]

I don't have access to an nvidia graphics card and unlike with an OS I can't just spin up a VM to test it, so this might be hard for me to fix.

Just to isolate whether it's a mousetrap issue, can you install libadwaita_jll from the Julia package registry, then:

import libadwaita_jll
ccall((:adw_init, libadwaita_jll.libadwaita), Cint, ())

If that works, exit the Julia runtime, install GTK4_jll, then:

import GTK4_jll
ccall((:gtk_init, GTK4_jll.libgtk4), Cint, ())

If both work, please run:

import GTK4_jll, libadwaita_jll
begin
    ccall((:adw_init, libadwaita_jll.libadwaita), Cvoid, ())
    local window = ccall((:adw_window_new, libadwaita_jll.libadwaita), Ptr{Cvoid}, ())
    local area = ccall((:gtk_gl_area_new, GTK4_jll.libgtk4), Ptr{Cvoid}, ())
    ccall((:adw_window_set_content, libadwaita_jll.libadwaita), Cvoid, (Ptr{Cvoid}, Ptr{Cvoid}), window, area)
    ccall((:gtk_window_present, GTK4_jll.libgtk4), Cvoid, (Ptr{Cvoid},), window)
    println(ccall((:gtk_widget_get_realized, GTK4_jll.libgtk4), Cint, (Ptr{Cvoid},), area) == true)
    exit()
end

It should print true to the console, with no other console output.

I tried the three tests, and all works fine, even when using the nvidia driver...
Just using Moustrapfails...

But I did not try the suggestion from Tim Holy yet: https://docs.julialang.org/en/v1/devdocs/backtraces/

[Clemapfel]

I'm sorry you're still having trouble, I'm kinda forced to make you do the debugging since I can't test it myself, I apologize.

Could you try the following?

import libadwaita_jll, mousetrap_linux_jll
ccall((:adw_init, libadwaita_jll.libadwaita), Cvoid, ())
ccall((:_ZN9mousetrap6detail17initialize_openglEv, mousetrap_linux_jll.mousetrap_julia_binding), Cvoid, ())

Does that still crash?

---

If it says _ZN9mousetrap6detail17initialize_openglEv is not defined, run the following in Julia:

println(mousetrap_linux_jll.mousetrap_julia_binding)

Which will return a path, for me it's /home/clem/.julia/artifacts/2670af70bf210b40d1e852d7b5d644c76c0e7d01/lib/libmousetrap_julia_binding.so

Then, in your bash console, not in julia, run:

nm /home/clem/.julia/artifacts/2670af70bf210b40d1e852d7b5d644c76c0e7d01/lib/libmousetrap_julia_binding.so | grep initialize_opengl`

With the path you got from mousetrap_linux_jll, for me it's _ZN9mousetrap6detail17initialize_openglEv, then use that in the ccall above. You may need to install nm, it's sudo apt-get install binutils.

We're calling a mangled C++ name like a C library so we can call mousetrap::initialize_opengl directly, it's the best candidate for what could be crashing. If I knew which line in the C++ shared library called gdk_x11_surface_get_xid that would help a lot but your stacktrace doesn't say.

[ufechner7]

Does that still crash?

Yes, it does:

julia> import libadwaita_jll, mousetrap_linux_jll

julia> ccall((:adw_init, libadwaita_jll.libadwaita), Cvoid, ())

julia> ccall((:_ZN9mousetrap6detail17initialize_openglEv, mousetrap_linux_jll.mousetrap_julia_binding), Cvoid, ())

[19474] signal (11.1): Segmentation fault
in expression starting at REPL[3]:1
gdk_x11_surface_get_xid at /home/ufechner/.julia/artifacts/5498f875c31a1b3422ce1b64ef770407109eff30/lib/libgtk-4.so (unknown line)
Allocations: 2998 (Pool: 2986; Big: 12); GC: 0
Segmentation fault (core dumped)

[Clemapfel]

Ok, perfect, I know how to work on a fix for this then. I'll try to get a hotfix out soon

[Clemapfel]

Hi, please run:

ENV["MOUSETRAP_DISABLE_OPENGL_COMPONENT"] = "TRUE"
import Pkg; Pkg.update("mousetrap_linux_jll")
using Mousetrap

Does that still crash?

[ufechner7]

Looks better:

julia> ENV["MOUSETRAP_DISABLE_OPENGL_COMPONENT"] = "TRUE"
"TRUE"

julia> import Pkg; Pkg.update("mousetrap_linux_jll")
    Updating registry at `~/.julia/registries/General.toml`
    Updating git-repo `https://github.com/Clemapfel/mousetrap_linux_jll`
  No Changes to `~/repos/Mouse/Project.toml`
  No Changes to `~/repos/Mouse/Manifest.toml`

julia> using Mousetrap

julia> 

But the nvidia driver should support OpenGL, shouldn't it?

[Clemapfel]

It's not disabling OpenGL, it's just turning off everything related to the RenderArea widget. Mousetrap will still use the OpenGL backend for rendering and you still get the same performance.

The issue isn't that OpenGL isn't supported, it's that during creation of the global OpenGL state that is only used to store all the data of Shape and Texture, either GTK4 or GLEW fails to correctly access the windows surface because of some reason related to X11 with your driver. This hotfix just turns that part off so you can still use mousetrap.

If you want you can unset MOUSETRAP_DISABLE_OPENGL_COMPONENT and see if you get a new error, I made the context creation function a little bit more resilient. If yes, then we just have to wait until I can get my hands on an nvidia card so I can reproduce this and reach out to GNOME.

[Clemapfel]

I'll keep this open for anyone else running into this.

Solution

TL;DR: Certain NVIDIA drivers are causing an error in GTK4 when trying to initialize everything needed for the RenderArea widget to work. The current fix for this is to just turn off RenderArea, which we do by setting an environment variable.

1. Set MOUSETRAP_DISABLE_OPENGL_COMPONENT

Add the following line to your startup.jl

ENV["MOUSETRAP_DISABLE_OPENGL_COMPONENT"] = "TRUE"

If you are unsure of where startup.jl is located, you can access the path by running the following in the Julia REPL:

something(Base._global_julia_startup_file(), Base._local_julia_startup_file())

If you are unwilling or unable to modify startup.jl, you can also set the environment variable using your IDE, or, on unix, by appending the following line to your ~/.bashrc file:

export MOUSETRAP_DISABLE_OPENGL_COMPONENT=TRUE

2. Update mousetrap jlls

Open a fresh terminal session, enter the REPL, then update the mousetrap jll:

begin
   import
   Pkg.update("mousetrap_jll")
   Pkg.update("Mousetrap")
end

This should set the jll to version 0.3.0 or newer, while Mousetrap should be 0.3.0 or newer.

You should now be able to use mousetrap, with the exception of the RenderArea widget, which will print a log message when instantiated, but should not crash or otherwise affect the rest of the application:

using Mousetrap
area = RenderArea()

(process:185604): mousetrap-CRITICAL **: 14:32:36.464: In RenderArea(): trying to instantiate RenderArea, but the OpenGL component is disabled.

[00krishna]

I am also running into this error on Ubuntu 22.04 LTS with an Nvidia graphics card and 535 driver. I am using Moustrap version 0.3.0. Here is the entry from the manifest.

  [5deeb4b9] Mousetrap v0.3.0 `https://github.com/clemapfel/mousetrap.jl#main`

When I set ENV["MOUSETRAP_DISABLE_OPENGL_COMPONENT"] = "TRUE" at the prompt, then the basic Mousetrap gui comes up. When I tried the area = RenderArea() I get the mousetrap-CRITICAL **: 21:48:43.254: In RenderArea(): trying to instantiate RenderArea, but the OpenGL component is disabled. message.

Is there a way to test the OpenGL piece? How would I test that?

[00krishna]

UPDATE: This code worked. So a user can test whether OpenGL works with the complete example below. The code was taken from the Mousetrap test cases.

ENV["MOUSETRAP_DISABLE_OPENGL_COMPONENT"] = "TRUE"

module MousetrapMakie

    export GLMakieArea, create_glmakie_screen

    using Mousetrap
    using ModernGL, GLMakie, Colors, GeometryBasics, ShaderAbstractions
    using GLMakie: empty_postprocessor, fxaa_postprocessor, OIT_postprocessor, to_screen_postprocessor
    using GLMakie.GLAbstraction
    using GLMakie.Makie

    """
    ## GLMakieArea <: Widget
    `GLArea` wrapper that automatically connects all necessary callbacks in order for it to be used as a GLMakie render target. 

    Use `create_glmakie_screen` to initialize a screen you can render to using Makie from this widget. Note that `create_glmakie_screen` needs to be 
    called **after** `GLMakieArea` has been realized, as only then will the internal OpenGL context be available. See the example below.

    ## Constructors
    `GLMakieArea()`

    ## Signals
    (no unique signals)

    ## Fields
    (no public fields)

    ## Example
    ```
    using Mousetrap, MousetrapMakie
    main() do app::Application
        window = Window(app)
        canvas = GLMakieArea()
        set_size_request!(canvas, Vector2f(200, 200))
        set_child!(window, canvas)
    
        # use optional ref to delay screen allocation after `realize`
        screen = Ref{Union{Nothing, GLMakie.Screen{GLMakieArea}}}(nothing)
        connect_signal_realize!(canvas) do self
            screen[] = create_glmakie_screen(canvas)
            display(screen[], scatter(1:4))
            return nothing
        end
        present!(window)
    end
    ```
    """
    mutable struct GLMakieArea <: Widget

        glarea::GLArea              # wrapped native widget
        framebuffer_id::Ref{Int}    # set by render callback, used in MousetrapMakie.create_glmakie_screen
        framebuffer_size::Vector2i  # set by resize callback, used in GLMakie.framebuffer_size

        function GLMakieArea()
            glarea = GLArea()
            set_auto_render!(glarea, false) # should `render` be emitted everytime the widget is drawn
            connect_signal_render!(on_makie_area_render, glarea)
            connect_signal_resize!(on_makie_area_resize, glarea)
            return new(glarea, Ref{Int}(0), Vector2i(0, 0))
        end
    end
    Mousetrap.get_top_level_widget(x::GLMakieArea) = x.glarea

    # maps hash(GLMakieArea) to GLMakie.Screen
    const screens = Dict{UInt64, GLMakie.Screen}()

    # maps hash(GLMakieArea) to Scene, used in `on_makie_area_resize`
    const scenes = Dict{UInt64, GLMakie.Scene}()

    # render callback: if screen is open, render frame to `GLMakieArea`s OpenGL context
    function on_makie_area_render(self, context)
        key = Base.hash(self)
        if haskey(screens, key)
            screen = screens[key]
            if !isopen(screen) return false end
            screen.render_tick[] = nothing
            glarea = screen.glscreen
            glarea.framebuffer_id[] = glGetIntegerv(GL_FRAMEBUFFER_BINDING)
            GLMakie.render_frame(screen) 
        end
        return true
    end

    # resize callback: update framebuffer size, necessary for `GLMakie.framebuffer_size`
    function on_makie_area_resize(self, w, h)
        key = Base.hash(self)
        if haskey(screens, key)
            screen = screens[key]
            glarea = screen.glscreen
            glarea.framebuffer_size.x = w
            glarea.framebuffer_size.y = h
            queue_render(glarea.glarea)
        end

        if haskey(scenes, key)
            scene = scenes[key]
            scene.events.window_area[] = Recti(0, 0, glarea.framebuffer_size.x, glarea.framebuffer_size.y)
            scene.events.window_dpi[] = Mousetrap.calculate_monitor_dpi(glarea)
        end
        return nothing
    end

    # resolution of `GLMakieArea` OpenGL framebuffer
    GLMakie.framebuffer_size(self::GLMakieArea) = (self.framebuffer_size.x, self.framebuffer_size.y)

    # forward retina scale factor from GTK4 back-end
    GLMakie.retina_scaling_factor(w::GLMakieArea) = Mousetrap.get_scale_factor(w)

    # resolution of `GLMakieArea` widget itself`
    function GLMakie.window_size(w::GLMakieArea)
        size = get_natural_size(w)
        size.x = size.x * GLMakie.retina_scaling_factor(w)
        size.y = size.y * GLMakie.retina_scaling_factor(w)
        return (size.x, size.y)
    end

    # calculate screen size and dpi
    function Makie.window_area(scene::Scene, screen::GLMakie.Screen{GLMakieArea})
        glarea = screen.glscreen
        scenes[hash(glarea)] = scene
    end

    # resize request by makie will be ignored
    function GLMakie.resize_native!(native::GLMakieArea, resolution...)
        # noop
    end

    # bind `GLMakieArea` OpenGL context
    ShaderAbstractions.native_switch_context!(a::GLMakieArea) = make_current(a.glarea)

    # check if `GLMakieArea` OpenGL context is still valid, it is while `GLMakieArea` widget stays realized
    ShaderAbstractions.native_context_alive(x::GLMakieArea) = get_is_realized(x)

    # destruction callback ignored, lifetime is managed by mousetrap instead
    function GLMakie.destroy!(w::GLMakieArea)
        # noop
    end

    # check if canvas is still realized
    GLMakie.was_destroyed(window::GLMakieArea) = !get_is_realized(window)

    # check if canvas should signal it is open
    Base.isopen(w::GLMakieArea) = !GLMakie.was_destroyed(w)

    # react to makie screen visibility request
    GLMakie.set_screen_visibility!(screen::GLMakieArea, bool) = bool ? show(screen.glarea) : hide!(screen.glarea)

    # apply glmakie config
    function GLMakie.apply_config!(screen::GLMakie.Screen{GLMakieArea}, config::GLMakie.ScreenConfig; start_renderloop=true) 
        @warn "In MousetrapMakie: GLMakie.apply_config!: This feature is not yet implemented, ignoring config"
        # cf https://github.com/JuliaGtk/Gtk4Makie.jl/blob/main/src/screen.jl#L111
        return screen
    end

    # screenshot framebuffer
    function Makie.colorbuffer(screen::GLMakie.Screen{GLMakieArea}, format::Makie.ImageStorageFormat = Makie.JuliaNative)
        @warn "In MousetrapMakie: GLMakie.colorbuffer: This feature is not yet implemented, returning framecache"
        # cf https://github.com/JuliaGtk/Gtk4Makie.jl/blob/main/src/screen.jl#L147
        return screen.framecache
    end

    # ignore makie event model, use the mousetrap event controllers instead
    Makie.window_open(::Scene, ::GLMakieArea) = nothing
    Makie.disconnect!(::GLMakieArea, f) = nothing
    GLMakie.pollevents(::GLMakie.Screen{GLMakieArea}) = nothing
    Makie.mouse_buttons(::Scene, ::GLMakieArea) = nothing
    Makie.keyboard_buttons(::Scene, ::GLMakieArea) = nothing
    Makie.dropped_files(::Scene, ::GLMakieArea) = nothing
    Makie.unicode_input(::Scene, ::GLMakieArea) = nothing
    Makie.mouse_position(::Scene, ::GLMakie.Screen{GLMakieArea}) = nothing
    Makie.scroll(::Scene, ::GLMakieArea) = nothing
    Makie.hasfocus(::Scene, ::GLMakieArea) = nothing
    Makie.entered_window(::Scene, ::GLMakieArea) = nothing

    """
    ```
    create_gl_makie_screen(::GLMakieArea; screen_config...) -> GLMakie.Screen{GLMakieArea}
    ```
    For a `GLMakieArea`, create a `GLMakie.Screen` that can be used to display makie graphics
    """
    function create_glmakie_screen(area::GLMakieArea; screen_config...)

        if !get_is_realized(area) 
            log_critical("MousetrapMakie", "In MousetrapMakie.create_glmakie_screen: GLMakieArea is not yet realized, it's internal OpenGL context cannot yet be accessed")
        end

        config = Makie.merge_screen_config(GLMakie.ScreenConfig, screen_config)

        set_is_visible!(area, config.visible)
        set_expand!(area, true)

        # quote from https://github.com/JuliaGtk/Gtk4Makie.jl/blob/main/src/screen.jl#L342
        shader_cache = GLAbstraction.ShaderCache(area)
        ShaderAbstractions.switch_context!(area)
        fb = GLMakie.GLFramebuffer((1, 1)) # resized on GLMakieArea realization later

        postprocessors = [
            config.ssao ? ssao_postprocessor(fb, shader_cache) : empty_postprocessor(),
            OIT_postprocessor(fb, shader_cache),
            config.fxaa ? fxaa_postprocessor(fb, shader_cache) : empty_postprocessor(),
            to_screen_postprocessor(fb, shader_cache, area.framebuffer_id)
        ]

        screen = GLMakie.Screen(
            area, shader_cache, fb,
            config, false,
            nothing,
            Dict{WeakRef, GLMakie.ScreenID}(),
            GLMakie.ScreenArea[],
            Tuple{GLMakie.ZIndex, GLMakie.ScreenID, GLMakie.RenderObject}[],
            postprocessors,
            Dict{UInt64, GLMakie.RenderObject}(),
            Dict{UInt32, Makie.AbstractPlot}(),
            false,
        )
        # end quote

        hash = Base.hash(area.glarea)
        screens[hash] = screen
        
        set_tick_callback!(area.glarea) do clock::FrameClock
            if GLMakie.requires_update(screen)
                queue_render(area.glarea)
            end

            if GLMakie.was_destroyed(area)
                return TICK_CALLBACK_RESULT_DISCONTINUE
            else
                return TICK_CALLBACK_RESULT_CONTINUE
            end
        end
        return screen
    end
end

# test
using Mousetrap, .MousetrapMakie, GLMakie
main() do app::Application
    window = Window(app)
    set_title!(window, "Mousetrap x Makie")
    canvas = GLMakieArea()
    set_size_request!(canvas, Vector2f(200, 200))
    set_child!(window, canvas)

    # use optional ref to delay screen allocation after `realize`
    screen = Ref{Union{Nothing, GLMakie.Screen{GLMakieArea}}}(nothing)
    connect_signal_realize!(canvas) do self
        screen[] = create_glmakie_screen(canvas)
        display(screen[], scatter(rand(123)))
        return nothing
    end
    present!(window)
end