Merge branch 'main' into bugfix/3073

Author: mattkae

README.md

@@ -39,7 +39,7 @@ For other questions and discussion about the Mir project:
 the [\#mirserver](https://web.libera.chat/?channels=#mir-server) IRC channel on Libera.Chat.
 
 For developer documentation, including installation and build instructions,
-see <https://mir-server.io/doc/index.html>.
+see <https://canonical-mir.readthedocs-hosted.com>.
 
 # Copyright
 Copyright © Canonical Ltd.

doc/sphinx/.sphinx/requirements.txt

@@ -1,16 +1,17 @@
-sphinx==7.1.2
-sphinx-autobuild
-sphinx-design
+breathe
+exhale
 furo
-sphinx-tabs
-sphinx-reredirects
-pyspelling
-sphinxext-opengraph
 lxd-sphinx-extensions
-sphinx-copybutton
 myst-parser
-sphinxcontrib-jquery
+pillow
+pyspelling
+sphinx-autobuild
+sphinx-copybutton
+sphinx-design
 sphinx-notfound-page
-breathe
-exhale
+sphinx-reredirects
+sphinx-tabs
+sphinx==7.1.2
+sphinxcontrib-jquery
 sphinxcontrib-mermaid
+sphinxext-opengraph

examples/client/wayland_client.c

@@ -27,6 +27,8 @@
 #include <stdio.h>
 #include <stdbool.h>
 #include <signal.h>
+#include <poll.h>
+#include <sys/eventfd.h>
 
 #include <wayland-client.h>
 #include <wayland-client-core.h>
@@ -218,11 +220,18 @@ find_free_buffer(draw_context* ctx)
     return NULL;
 }
 
-static void draw_new_stuff(void* data, struct wl_callback* callback, uint32_t time);
+static int draw_signal;
+static void trigger_draw(void* data, struct wl_callback* callback, uint32_t time)
+{
+    (void)data;
+    (void)callback;
+    (void)time;
+    eventfd_write(draw_signal, 1);
+}
 
 static const struct wl_callback_listener frame_listener =
 {
-    .done = &draw_new_stuff
+    .done = &trigger_draw
 };
 
 static void update_free_buffers(void* data, struct wl_buffer* buffer)
@@ -239,22 +248,15 @@ static void update_free_buffers(void* data, struct wl_buffer* buffer)
     if (ctx->waiting_for_buffer)
     {
         struct wl_callback* fake_frame = wl_display_sync(ctx->display);
-        wl_callback_add_listener(fake_frame, &frame_listener, ctx);
+        wl_callback_add_listener(fake_frame, &frame_listener, NULL);
     }
 
     ctx->waiting_for_buffer = false;
 }
 
-static void draw_new_stuff(
-    void* data,
-    struct wl_callback* callback,
-    uint32_t time)
+static void execute_draw(draw_context* ctx)
 {
-    (void)time;
     static unsigned char current_value = 128;
-    draw_context* ctx = data;
-
-    wl_callback_destroy(callback);
 
     buffer* ctx_buffer = find_free_buffer(ctx);
     if (!ctx_buffer)
@@ -267,7 +269,7 @@ static void draw_new_stuff(
     ++current_value;
 
     ctx->new_frame_signal = wl_surface_frame(ctx->surface);
-    wl_callback_add_listener(ctx->new_frame_signal, &frame_listener, ctx);
+    wl_callback_add_listener(ctx->new_frame_signal, &frame_listener, NULL);
     wl_surface_attach(ctx->surface, ctx_buffer->buffer, 0, 0);
     wl_surface_commit(ctx->surface);
 }
@@ -419,12 +421,16 @@ static struct wl_output_listener const output_listener = {
     .scale = &output_scale,
 };
 
-static volatile sig_atomic_t running = 0;
-static void shutdown(int signum)
+static int shutdown_signal;
+static void trigger_shutdown(int signum)
 {
-    if (running)
+    if (eventfd_write(shutdown_signal, 1) == -1)
+    {
+        printf("Failed to execute a shutdown");
+        exit(-1);
+    }
+    else
     {
-        running = 0;
         printf("Signal %d received. Good night.\n", signum);
     }
 }
@@ -482,6 +488,70 @@ static struct xdg_toplevel_listener const shell_toplevel_listener =
     handle_xdg_toplevel__capabilities,
 };
 
+void run(struct wl_display* display, draw_context* ctx)
+{
+    draw_signal = eventfd(0, EFD_SEMAPHORE);
+    shutdown_signal = eventfd(0, EFD_CLOEXEC);
+
+    enum FdIndices {
+        display_fd = 0,
+        draw,
+        shutdown,
+        indices
+    };
+
+    struct pollfd fds[indices] = {
+        {wl_display_get_fd(display), POLLIN, 0},
+        {draw_signal,                POLLIN, 0},
+        {shutdown_signal,            POLLIN, 0},
+    };
+
+    wl_display_roundtrip(display);
+    wl_display_roundtrip(display);
+    while (!(fds[shutdown].revents & (POLLIN | POLLERR)))
+    {
+        while (wl_display_prepare_read(display) != 0)
+        {
+            if (wl_display_dispatch_pending(display) == -1)
+            {
+                fprintf(stderr, "Failed to dispatch Wayland events\n");
+            }
+        }
+
+        if (poll(fds, indices, -1) == -1)
+        {
+            wl_display_cancel_read(display);
+        }
+
+        if (fds[display_fd].revents & (POLLIN | POLLERR))
+        {
+            if (wl_display_read_events(display))
+            {
+                fprintf(stderr, "Failed to read Wayland events\n");
+            }
+        }
+        else
+        {
+            wl_display_cancel_read(display);
+        }
+
+        bool redraw = false;
+
+        if (fds[draw].revents & (POLLIN | POLLERR))
+        {
+            eventfd_t foo;
+            eventfd_read(draw_signal, &foo);
+            redraw = true;
+        }
+
+        if (redraw)
+        {
+            execute_draw(ctx);
+            wl_display_flush(display);
+        }
+    }
+}
+
 int main(int argc, char** argv)
 {
     (void)argc;
@@ -518,23 +588,20 @@ int main(int argc, char** argv)
     xdg_toplevel_add_listener(shell_toplevel, &shell_toplevel_listener, ctx);
 
     struct wl_callback* first_frame = wl_display_sync(display);
-    wl_callback_add_listener(first_frame, &frame_listener, ctx);
+    wl_callback_add_listener(first_frame, &frame_listener, NULL);
 
     wl_output_add_listener(globals.output, &output_listener, NULL);
-
     struct sigaction sig_handler_new;
     sigfillset(&sig_handler_new.sa_mask);
     sig_handler_new.sa_flags = 0;
-    sig_handler_new.sa_handler = shutdown;
+    sig_handler_new.sa_handler = trigger_shutdown;
 
     sigaction(SIGINT, &sig_handler_new, NULL);
     sigaction(SIGTERM, &sig_handler_new, NULL);
     sigaction(SIGHUP, &sig_handler_new, NULL);
 
-    running = 1;
-
-    while (wl_display_dispatch(display) && running)
-        ;
+    run(display, ctx);
 
     return 0;
 }
+

include/platform/mir/graphics/display_buffer.h

@@ -17,6 +17,7 @@
 #ifndef MIR_GRAPHICS_DISPLAY_BUFFER_H_
 #define MIR_GRAPHICS_DISPLAY_BUFFER_H_
 
+#include "mir/graphics/platform.h"
 #include <mir/geometry/rectangle.h>
 #include <mir/graphics/renderable.h>
 #include <mir_toolkit/common.h>
@@ -61,9 +62,9 @@ class DisplayBuffer
     /** The size in pixels of the underlying display */
     virtual auto pixel_size() const -> geometry::Size = 0;
 
-    /** This will render renderlist to the screen and post the result to the 
+    /** This will render renderlist to the screen and post the result to the
      *  screen if there is a hardware optimization that can be done.
-     *  \param [in] renderlist 
+     *  \param [in] renderlist
      *      The renderables that should appear on the screen if the hardware
      *      is capable of optmizing that list somehow. If what you want
      *      displayed on the screen cannot be represented by a RenderableList,
@@ -98,8 +99,56 @@ class DisplayBuffer
      */
     virtual glm::mat2 transformation() const = 0;
 
-    virtual auto display_provider() const -> std::shared_ptr<DisplayInterfaceProvider> = 0;
+    /**
+     * Attempt to acquire a platform-specific provider from this DisplayBuffer
+     *
+     * Any given platform is not guaranteed to implement any specific interface,
+     * and the set of supported interfaces may depend on the runtime environment.
+     *
+     * Since this may result in a runtime probe the call may be costly, and the
+     * result should be saved rather than re-acquiring an interface each time.
+     *
+     * \tparam Allocator
+     * \return  On success: a non-null pointer to an Allocator implementation.
+     *                      The lifetime of this Allocator implementation is bound
+     *                      to that of the parent DisplayBuffer.
+     *          On failure: nullptr
+     */
+    template<typename Allocator>
+    auto acquire_allocator() -> Allocator*
+    {
+        static_assert(
+            std::is_convertible_v<Allocator*, DisplayAllocator*>,
+            "Can only acquire a DisplayAllocator; Provider must implement DisplayAllocator");
+
+        if (auto const base_interface = maybe_create_allocator(typename Allocator::Tag{}))
+        {
+            if (auto const requested_interface = dynamic_cast<Allocator*>(base_interface))
+            {
+                return requested_interface;
+            }
+            BOOST_THROW_EXCEPTION((std::logic_error{
+                "Implementation error! Platform returned object that does not support requested interface"}));
+        }
+        return nullptr;
+    }
+
 protected:
+    /**
+     * Acquire a specific hardware interface
+     *
+     * This should perform any runtime checks necessary to verify the requested interface is
+     * expected to work and return a pointer to an implementation of that interface.
+     *
+     * \param type_tag  [in]    An instance of the Tag type for the requested interface.
+     *                          Implementations are expected to dynamic_cast<> this to
+     *                          discover the specific interface being requested.
+     * \return      A pointer to an implementation of the DisplayAllocator-derived
+     *              interface that corresponds to the most-derived type of tag_type.
+     */
+    virtual auto maybe_create_allocator(DisplayAllocator::Tag const& type_tag)
+        -> DisplayAllocator* = 0;
+
     DisplayBuffer() = default;
     DisplayBuffer(DisplayBuffer const& c) = delete;
     DisplayBuffer& operator=(DisplayBuffer const& c) = delete;