1 files changed, 220 insertions, 39 deletions

diff --git a/sway/server.c b/sway/server.c
index 627d80d6..180d3a6b 100644
--- a/sway/server.c
+++ b/sway/server.c
@@ -1,4 +1,3 @@
-#define _POSIX_C_SOURCE 200809L
 #include <assert.h>
 #include <stdbool.h>
 #include <stdlib.h>
@@ -7,23 +6,34 @@
 #include <wlr/backend.h>
 #include <wlr/backend/headless.h>
 #include <wlr/backend/multi.h>
-#include <wlr/backend/session.h>
 #include <wlr/config.h>
+#include <wlr/render/allocator.h>
 #include <wlr/render/wlr_renderer.h>
 #include <wlr/types/wlr_compositor.h>
+#include <wlr/types/wlr_content_type_v1.h>
+#include <wlr/types/wlr_cursor_shape_v1.h>
 #include <wlr/types/wlr_data_control_v1.h>
-#include <wlr/types/wlr_drm_lease_v1.h>
+#include <wlr/types/wlr_data_device.h>
 #include <wlr/types/wlr_drm.h>
 #include <wlr/types/wlr_export_dmabuf_v1.h>
+#include <wlr/types/wlr_ext_foreign_toplevel_list_v1.h>
+#include <wlr/types/wlr_foreign_toplevel_management_v1.h>
+#include <wlr/types/wlr_fractional_scale_v1.h>
 #include <wlr/types/wlr_gamma_control_v1.h>
-#include <wlr/types/wlr_idle.h>
+#include <wlr/types/wlr_idle_notify_v1.h>
 #include <wlr/types/wlr_layer_shell_v1.h>
 #include <wlr/types/wlr_linux_dmabuf_v1.h>
+#include <wlr/types/wlr_output_management_v1.h>
+#include <wlr/types/wlr_output_power_management_v1.h>
 #include <wlr/types/wlr_pointer_constraints_v1.h>
+#include <wlr/types/wlr_presentation_time.h>
 #include <wlr/types/wlr_primary_selection_v1.h>
 #include <wlr/types/wlr_relative_pointer_v1.h>
 #include <wlr/types/wlr_screencopy_v1.h>
+#include <wlr/types/wlr_security_context_v1.h>
 #include <wlr/types/wlr_server_decoration.h>
+#include <wlr/types/wlr_session_lock_v1.h>
+#include <wlr/types/wlr_single_pixel_buffer_v1.h>
 #include <wlr/types/wlr_subcompositor.h>
 #include <wlr/types/wlr_tablet_v2.h>
 #include <wlr/types/wlr_viewporter.h>
@@ -34,6 +44,7 @@
 #include <wlr/types/wlr_xdg_foreign_v1.h>
 #include <wlr/types/wlr_xdg_foreign_v2.h>
 #include <wlr/types/wlr_xdg_output_v1.h>
+#include <xf86drm.h>
 #include "config.h"
 #include "list.h"
 #include "log.h"
@@ -42,24 +53,25 @@
 #include "sway/input/input-manager.h"
 #include "sway/output.h"
 #include "sway/server.h"
+#include "sway/input/cursor.h"
 #include "sway/tree/root.h"
+
 #if HAVE_XWAYLAND
+#include <wlr/xwayland/shell.h>
 #include "sway/xwayland.h"
 #endif
 
-bool server_privileged_prepare(struct sway_server *server) {
-        sway_log(SWAY_DEBUG, "Preparing Wayland server initialization");
-        server->wl_display = wl_display_create();
-        server->wl_event_loop = wl_display_get_event_loop(server->wl_display);
-        server->backend = wlr_backend_autocreate(server->wl_display);
+#if WLR_HAS_DRM_BACKEND
+#include <wlr/types/wlr_drm_lease_v1.h>
+#endif
 
-        if (!server->backend) {
-                sway_log(SWAY_ERROR, "Unable to create backend");
-                return false;
-        }
-        return true;
-}
+#define SWAY_XDG_SHELL_VERSION 5
+#define SWAY_LAYER_SHELL_VERSION 4
+#define SWAY_FOREIGN_TOPLEVEL_LIST_VERSION 1
 
+bool allow_unsupported_gpu = false;
+
+#if WLR_HAS_DRM_BACKEND
 static void handle_drm_lease_request(struct wl_listener *listener, void *data) {
         /* We only offer non-desktop outputs, but in the future we might want to do
          * more logic here. */
@@ -71,11 +83,151 @@ static void handle_drm_lease_request(struct wl_listener *listener, void *data) {
                 wlr_drm_lease_request_v1_reject(req);
         }
 }
+#endif
+
+static bool is_privileged(const struct wl_global *global) {
+#if WLR_HAS_DRM_BACKEND
+        if (server.drm_lease_manager != NULL) {
+                struct wlr_drm_lease_device_v1 *drm_lease_dev;
+                wl_list_for_each(drm_lease_dev, &server.drm_lease_manager->devices, link) {
+                        if (drm_lease_dev->global == global) {
+                                return true;
+                        }
+                }
+        }
+#endif
+
+        return
+                global == server.output_manager_v1->global ||
+                global == server.output_power_manager_v1->global ||
+                global == server.input_method->global ||
+                global == server.foreign_toplevel_list->global ||
+                global == server.foreign_toplevel_manager->global ||
+                global == server.data_control_manager_v1->global ||
+                global == server.screencopy_manager_v1->global ||
+                global == server.export_dmabuf_manager_v1->global ||
+                global == server.security_context_manager_v1->global ||
+                global == server.gamma_control_manager_v1->global ||
+                global == server.layer_shell->global ||
+                global == server.session_lock.manager->global ||
+                global == server.input->keyboard_shortcuts_inhibit->global ||
+                global == server.input->virtual_keyboard->global ||
+                global == server.input->virtual_pointer->global ||
+                global == server.input->transient_seat_manager->global;
+}
+
+static bool filter_global(const struct wl_client *client,
+                const struct wl_global *global, void *data) {
+#if HAVE_XWAYLAND
+        struct wlr_xwayland *xwayland = server.xwayland.wlr_xwayland;
+        if (xwayland && global == xwayland->shell_v1->global) {
+                return xwayland->server != NULL && client == xwayland->server->client;
+        }
+#endif
+
+        // Restrict usage of privileged protocols to unsandboxed clients
+        // TODO: add a way for users to configure an allow-list
+        const struct wlr_security_context_v1_state *security_context =
+                wlr_security_context_manager_v1_lookup_client(
+                server.security_context_manager_v1, (struct wl_client *)client);
+        if (is_privileged(global)) {
+                return security_context == NULL;
+        }
+
+        return true;
+}
 
-#define SWAY_XDG_SHELL_VERSION  2
+static void detect_proprietary(struct wlr_backend *backend, void *data) {
+        int drm_fd = wlr_backend_get_drm_fd(backend);
+        if (drm_fd < 0) {
+                return;
+        }
+
+        drmVersion *version = drmGetVersion(drm_fd);
+        if (version == NULL) {
+                sway_log(SWAY_ERROR, "drmGetVersion() failed");
+                return;
+        }
+
+        bool is_unsupported = false;
+        if (strcmp(version->name, "nvidia-drm") == 0) {
+                is_unsupported = true;
+                sway_log(SWAY_ERROR, "!!! Proprietary Nvidia drivers are in use !!!");
+                if (!allow_unsupported_gpu) {
+                        sway_log(SWAY_ERROR, "Use Nouveau instead");
+                }
+        }
+
+        if (strcmp(version->name, "evdi") == 0) {
+                is_unsupported = true;
+                sway_log(SWAY_ERROR, "!!! Proprietary DisplayLink drivers are in use !!!");
+        }
+
+        if (!allow_unsupported_gpu && is_unsupported) {
+                sway_log(SWAY_ERROR,
+                        "Proprietary drivers are NOT supported. To launch sway anyway, "
+                        "launch with --unsupported-gpu and DO NOT report issues.");
+                exit(EXIT_FAILURE);
+        }
+
+        drmFreeVersion(version);
+}
+
+static void handle_renderer_lost(struct wl_listener *listener, void *data) {
+        struct sway_server *server = wl_container_of(listener, server, renderer_lost);
+
+        sway_log(SWAY_INFO, "Re-creating renderer after GPU reset");
+
+        struct wlr_renderer *renderer = wlr_renderer_autocreate(server->backend);
+        if (renderer == NULL) {
+                sway_log(SWAY_ERROR, "Unable to create renderer");
+                return;
+        }
+
+        struct wlr_allocator *allocator =
+                wlr_allocator_autocreate(server->backend, renderer);
+        if (allocator == NULL) {
+                sway_log(SWAY_ERROR, "Unable to create allocator");
+                wlr_renderer_destroy(renderer);
+                return;
+        }
+
+        struct wlr_renderer *old_renderer = server->renderer;
+        struct wlr_allocator *old_allocator = server->allocator;
+        server->renderer = renderer;
+        server->allocator = allocator;
+
+        wl_list_remove(&server->renderer_lost.link);
+        wl_signal_add(&server->renderer->events.lost, &server->renderer_lost);
+
+        wlr_compositor_set_renderer(server->compositor, renderer);
+
+        for (int i = 0; i < root->outputs->length; ++i) {
+                struct sway_output *output = root->outputs->items[i];
+                wlr_output_init_render(output->wlr_output,
+                        server->allocator, server->renderer);
+        }
+
+        wlr_allocator_destroy(old_allocator);
+        wlr_renderer_destroy(old_renderer);
+}
 
 bool server_init(struct sway_server *server) {
         sway_log(SWAY_DEBUG, "Initializing Wayland server");
+        server->wl_display = wl_display_create();
+        server->wl_event_loop = wl_display_get_event_loop(server->wl_display);
+
+        wl_display_set_global_filter(server->wl_display, filter_global, NULL);
+
+        root = root_create(server->wl_display);
+
+        server->backend = wlr_backend_autocreate(server->wl_event_loop, &server->session);
+        if (!server->backend) {
+                sway_log(SWAY_ERROR, "Unable to create backend");
+                return false;
+        }
+
+        wlr_multi_for_each_backend(server->backend, detect_proprietary, NULL);
 
         server->renderer = wlr_renderer_autocreate(server->backend);
         if (!server->renderer) {
@@ -83,12 +235,17 @@ bool server_init(struct sway_server *server) {
                 return false;
         }
 
+        server->renderer_lost.notify = handle_renderer_lost;
+        wl_signal_add(&server->renderer->events.lost, &server->renderer_lost);
+
         wlr_renderer_init_wl_shm(server->renderer, server->wl_display);
 
-        if (wlr_renderer_get_dmabuf_texture_formats(server->renderer) != NULL) {
-                wlr_drm_create(server->wl_display, server->renderer);
-                server->linux_dmabuf_v1 =
-                        wlr_linux_dmabuf_v1_create(server->wl_display, server->renderer);
+        if (wlr_renderer_get_texture_formats(server->renderer, WLR_BUFFER_CAP_DMABUF) != NULL) {
+                server->linux_dmabuf_v1 = wlr_linux_dmabuf_v1_create_with_renderer(
+                        server->wl_display, 4, server->renderer);
+                if (debug.legacy_wl_drm) {
+                        wlr_drm_create(server->wl_display, server->renderer);
+                }
         }
 
         server->allocator = wlr_allocator_autocreate(server->backend,
@@ -98,18 +255,19 @@ bool server_init(struct sway_server *server) {
                 return false;
         }
 
-        server->compositor = wlr_compositor_create(server->wl_display,
+        server->compositor = wlr_compositor_create(server->wl_display, 6,
                 server->renderer);
-        server->compositor_new_surface.notify = handle_compositor_new_surface;
-        wl_signal_add(&server->compositor->events.new_surface,
-                &server->compositor_new_surface);
 
         wlr_subcompositor_create(server->wl_display);
 
         server->data_device_manager =
                 wlr_data_device_manager_create(server->wl_display);
 
-        wlr_gamma_control_manager_v1_create(server->wl_display);
+        server->gamma_control_manager_v1 =
+                wlr_gamma_control_manager_v1_create(server->wl_display);
+        server->gamma_control_set_gamma.notify = handle_gamma_control_set_gamma;
+        wl_signal_add(&server->gamma_control_manager_v1->events.set_gamma,
+                &server->gamma_control_set_gamma);
 
         server->new_output.notify = handle_new_output;
         wl_signal_add(&server->backend->events.new_output, &server->new_output);
@@ -119,20 +277,20 @@ bool server_init(struct sway_server *server) {
 
         wlr_xdg_output_manager_v1_create(server->wl_display, root->output_layout);
 
-        server->idle = wlr_idle_create(server->wl_display);
-        server->idle_inhibit_manager_v1 =
-                sway_idle_inhibit_manager_v1_create(server->wl_display, server->idle);
+        server->idle_notifier_v1 = wlr_idle_notifier_v1_create(server->wl_display);
+        sway_idle_inhibit_manager_v1_init();
 
-        server->layer_shell = wlr_layer_shell_v1_create(server->wl_display);
+        server->layer_shell = wlr_layer_shell_v1_create(server->wl_display,
+                SWAY_LAYER_SHELL_VERSION);
         wl_signal_add(&server->layer_shell->events.new_surface,
                 &server->layer_shell_surface);
         server->layer_shell_surface.notify = handle_layer_shell_surface;
 
         server->xdg_shell = wlr_xdg_shell_create(server->wl_display,
                 SWAY_XDG_SHELL_VERSION);
-        wl_signal_add(&server->xdg_shell->events.new_surface,
-                &server->xdg_shell_surface);
-        server->xdg_shell_surface.notify = handle_xdg_shell_surface;
+        wl_signal_add(&server->xdg_shell->events.new_toplevel,
+                &server->xdg_shell_toplevel);
+        server->xdg_shell_toplevel.notify = handle_xdg_shell_toplevel;
 
         server->tablet_v2 = wlr_tablet_v2_create(server->wl_display);
 
@@ -163,8 +321,7 @@ bool server_init(struct sway_server *server) {
         wl_signal_add(&server->pointer_constraints->events.new_constraint,
                 &server->pointer_constraint);
 
-        server->presentation =
-                wlr_presentation_create(server->wl_display, server->backend);
+        wlr_presentation_create(server->wl_display, server->backend);
 
         server->output_manager_v1 =
                 wlr_output_manager_v1_create(server->wl_display);
@@ -183,11 +340,14 @@ bool server_init(struct sway_server *server) {
                 &server->output_power_manager_set_mode);
         server->input_method = wlr_input_method_manager_v2_create(server->wl_display);
         server->text_input = wlr_text_input_manager_v3_create(server->wl_display);
+        server->foreign_toplevel_list =
+                wlr_ext_foreign_toplevel_list_v1_create(server->wl_display, SWAY_FOREIGN_TOPLEVEL_LIST_VERSION);
         server->foreign_toplevel_manager =
                 wlr_foreign_toplevel_manager_v1_create(server->wl_display);
 
         sway_session_lock_init();
 
+#if WLR_HAS_DRM_BACKEND
         server->drm_lease_manager=
                 wlr_drm_lease_v1_manager_create(server->wl_display, server->backend);
         if (server->drm_lease_manager) {
@@ -198,12 +358,17 @@ bool server_init(struct sway_server *server) {
                 sway_log(SWAY_DEBUG, "Failed to create wlr_drm_lease_device_v1");
                 sway_log(SWAY_INFO, "VR will not be available");
         }
+#endif
 
-        wlr_export_dmabuf_manager_v1_create(server->wl_display);
-        wlr_screencopy_manager_v1_create(server->wl_display);
-        wlr_data_control_manager_v1_create(server->wl_display);
-        wlr_primary_selection_v1_device_manager_create(server->wl_display);
+        server->export_dmabuf_manager_v1 = wlr_export_dmabuf_manager_v1_create(server->wl_display);
+        server->screencopy_manager_v1 = wlr_screencopy_manager_v1_create(server->wl_display);
+        server->data_control_manager_v1 = wlr_data_control_manager_v1_create(server->wl_display);
+        server->security_context_manager_v1 = wlr_security_context_manager_v1_create(server->wl_display);
         wlr_viewporter_create(server->wl_display);
+        wlr_single_pixel_buffer_manager_v1_create(server->wl_display);
+        server->content_type_manager_v1 =
+                wlr_content_type_manager_v1_create(server->wl_display, 1);
+        wlr_fractional_scale_manager_v1_create(server->wl_display, 1);
 
         struct wlr_xdg_foreign_registry *foreign_registry =
                 wlr_xdg_foreign_registry_create(server->wl_display);
@@ -215,6 +380,17 @@ bool server_init(struct sway_server *server) {
                 xdg_activation_v1_handle_request_activate;
         wl_signal_add(&server->xdg_activation_v1->events.request_activate,
                 &server->xdg_activation_v1_request_activate);
+        server->xdg_activation_v1_new_token.notify =
+                xdg_activation_v1_handle_new_token;
+        wl_signal_add(&server->xdg_activation_v1->events.new_token,
+                &server->xdg_activation_v1_new_token);
+
+        struct wlr_cursor_shape_manager_v1 *cursor_shape_manager =
+                wlr_cursor_shape_manager_v1_create(server->wl_display, 1);
+        server->request_set_cursor_shape.notify = handle_request_set_cursor_shape;
+        wl_signal_add(&cursor_shape_manager->events.request_set_shape, &server->request_set_cursor_shape);
+
+        wl_list_init(&server->pending_launcher_ctxs);
 
         // Avoid using "wayland-0" as display socket
         char name_candidate[16];
@@ -232,7 +408,7 @@ bool server_init(struct sway_server *server) {
                 return false;
         }
 
-        server->headless_backend = wlr_headless_backend_create(server->wl_display);
+        server->headless_backend = wlr_headless_backend_create(server->wl_event_loop);
         if (!server->headless_backend) {
                 sway_log(SWAY_ERROR, "Failed to create secondary headless backend");
                 wlr_backend_destroy(server->backend);
@@ -265,6 +441,7 @@ void server_fini(struct sway_server *server) {
         wlr_xwayland_destroy(server->xwayland.wlr_xwayland);
 #endif
         wl_display_destroy_clients(server->wl_display);
+        wlr_backend_destroy(server->backend);
         wl_display_destroy(server->wl_display);
         list_free(server->dirty_nodes);
 }
@@ -295,6 +472,10 @@ bool server_start(struct sway_server *server) {
         }
 #endif
 
+        if (config->primary_selection) {
+                wlr_primary_selection_v1_device_manager_create(server->wl_display);
+        }
+
         sway_log(SWAY_INFO, "Starting backend on wayland display '%s'",
                         server->socket);
         if (!wlr_backend_start(server->backend)) {