Changed backend to accept wl_display.

3 files changed, 91 insertions, 90 deletions

diff --git a/backend/drm/backend.c b/backend/drm/backend.c
index 03e34d97..5d72d9dc 100644
--- a/backend/drm/backend.c
+++ b/backend/drm/backend.c
@@ -3,6 +3,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
+#include <wayland-server.h>
 
 #include <wlr/session.h>
 #include <wlr/common/list.h>
@@ -12,9 +13,10 @@
 #include "backend/drm/udev.h"
 #include "common/log.h"
 
-struct wlr_drm_backend *wlr_drm_backend_init(struct wlr_session *session,
-	struct wl_listener *add, struct wl_listener *rem, struct wl_listener *render)
-{
+struct wlr_drm_backend *wlr_drm_backend_init(struct wl_display *display,
+	struct wlr_session *session, struct wl_listener *add, struct wl_listener *rem,
+	struct wl_listener *render) {
+
 	struct wlr_drm_backend *backend = calloc(1, sizeof *backend);
 	if (!backend) {
 		wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno));
@@ -29,15 +31,9 @@ struct wlr_drm_backend *wlr_drm_backend_init(struct wlr_session *session,
 		goto error_backend;
 	}
 
-	backend->event_loop = wl_event_loop_create();
-	if (!backend->event_loop) {
-		wlr_log(L_ERROR, "Failed to create event loop");
-		goto error_list;
-	}
-
-	if (!wlr_udev_init(backend)) {
+	if (!wlr_udev_init(display, &backend->udev)) {
 		wlr_log(L_ERROR, "Failed to start udev");
-		goto error_loop;
+		goto error_list;
 	}
 
 	backend->fd = wlr_udev_find_gpu(&backend->udev, backend->session);
@@ -46,32 +42,44 @@ struct wlr_drm_backend *wlr_drm_backend_init(struct wlr_session *session,
 		goto error_udev;
 	}
 
-	if (!wlr_drm_renderer_init(&backend->renderer, backend, backend->fd)) {
-		wlr_log(L_ERROR, "Failed to initialize renderer");
+	struct wl_event_loop *event_loop = wl_display_get_event_loop(display);
+
+	backend->drm_event = wl_event_loop_add_fd(event_loop, backend->fd,
+		WL_EVENT_READABLE, wlr_drm_event, NULL);
+	if (!backend->drm_event) {
+		wlr_log(L_ERROR, "Failed to create DRM event source");
 		goto error_fd;
 	}
 
+	if (!wlr_drm_renderer_init(&backend->renderer, backend->fd)) {
+		wlr_log(L_ERROR, "Failed to initialize renderer");
+		goto error_event;
+	}
+
 	wl_signal_init(&backend->signals.output_add);
 	wl_signal_init(&backend->signals.output_rem);
 	wl_signal_init(&backend->signals.output_render);
 
-	if (add)
+	if (add) {
 		wl_signal_add(&backend->signals.output_add, add);
-	if (rem)
+	}
+	if (rem) {
 		wl_signal_add(&backend->signals.output_rem, rem);
-	if (render)
+	}
+	if (render) {
 		wl_signal_add(&backend->signals.output_render, render);
+	}
 
 	wlr_drm_scan_connectors(backend);
 
 	return backend;
 
+error_event:
+	wl_event_source_remove(backend->drm_event);
 error_fd:
 	wlr_session_close_file(backend->session, backend->fd);
 error_udev:
 	wlr_udev_free(&backend->udev);
-error_loop:
-	wl_event_loop_destroy(backend->event_loop);
 error_list:
 	list_free(backend->outputs);
 error_backend:
@@ -98,15 +106,8 @@ void wlr_drm_backend_free(struct wlr_drm_backend *backend)
 	wlr_session_close_file(backend->session, backend->fd);
 	wlr_session_finish(backend->session);
 
-	wl_event_source_remove(backend->event_src.drm);
-	wl_event_source_remove(backend->event_src.udev);
-	wl_event_loop_destroy(backend->event_loop);
+	wl_event_source_remove(backend->drm_event);
 
 	list_free(backend->outputs);
 	free(backend);
 }
-
-struct wl_event_loop *wlr_drm_backend_get_event_loop(struct wlr_drm_backend *backend)
-{
-	return backend->event_loop;
-}
diff --git a/backend/drm/drm.c b/backend/drm/drm.c
index 13971687..f636c42c 100644
--- a/backend/drm/drm.c
+++ b/backend/drm/drm.c
@@ -41,7 +41,7 @@ static void page_flip_handler(int fd, unsigned seq, unsigned tv_sec, unsigned tv
 	void *user) {
 
 	struct wlr_drm_output *out = user;
-	struct wlr_drm_backend *backend = out->renderer->backend;
+	struct wlr_drm_backend *backend = wl_container_of(out->renderer, backend, renderer);
 
 	out->pageflip_pending = true;
 	if (!out->cleanup) {
@@ -49,7 +49,7 @@ static void page_flip_handler(int fd, unsigned seq, unsigned tv_sec, unsigned tv
 	}
 }
 
-static int drm_event(int fd, uint32_t mask, void *data) {
+int wlr_drm_event(int fd, uint32_t mask, void *data) {
 	drmEventContext event = {
 		.version = DRM_EVENT_CONTEXT_VERSION,
 		.page_flip_handler = page_flip_handler,
@@ -60,8 +60,7 @@ static int drm_event(int fd, uint32_t mask, void *data) {
 	return 1;
 }
 
-bool wlr_drm_renderer_init(struct wlr_drm_renderer *renderer,
-	struct wlr_drm_backend *backend, int fd) {
+bool wlr_drm_renderer_init(struct wlr_drm_renderer *renderer, int fd) {
 
 	renderer->gbm = gbm_create_device(fd);
 	if (!renderer->gbm) {
@@ -70,28 +69,12 @@ bool wlr_drm_renderer_init(struct wlr_drm_renderer *renderer,
 	}
 
 	if (!wlr_egl_init(&renderer->egl, EGL_PLATFORM_GBM_MESA, renderer->gbm)) {
-		goto error_gbm;
-	}
-
-	backend->event_src.drm = wl_event_loop_add_fd(backend->event_loop,
-			backend->fd, WL_EVENT_READABLE, drm_event, NULL);
-	if (!backend->event_src.drm) {
-		wlr_log(L_ERROR, "Failed to create DRM event source");
-		goto error_egl;
+		gbm_device_destroy(renderer->gbm);
+		return false;
 	}
 
 	renderer->fd = fd;
-	renderer->backend = backend;
-
 	return true;
-
-error_egl:
-	wlr_egl_free(&renderer->egl);
-
-error_gbm:
-	gbm_device_destroy(renderer->gbm);
-
-	return false;
 }
 
 void wlr_drm_renderer_free(struct wlr_drm_renderer *renderer) {
@@ -296,7 +279,7 @@ static drmModeModeInfo *select_mode(size_t num_modes, drmModeModeInfo modes[stat
 }
 
 bool wlr_drm_output_modeset(struct wlr_drm_output *out, const char *str) {
-	struct wlr_drm_backend *backend = out->renderer->backend;
+	struct wlr_drm_backend *backend = wl_container_of(out->renderer, backend, renderer);
 	wlr_log(L_INFO, "Modesetting %s with '%s'", out->name, str);
 
 	drmModeConnector *conn = drmModeGetConnector(backend->fd, out->connector);
diff --git a/backend/drm/udev.c b/backend/drm/udev.c
index 6921a998..438047d6 100644
--- a/backend/drm/udev.c
+++ b/backend/drm/udev.c
@@ -16,36 +16,39 @@
 #include "backend/drm/drm.h"
 #include "common/log.h"
 
-static bool device_is_kms(struct wlr_udev *udev,
-		struct wlr_session *session,
-		struct udev_device *dev,
-		int *fd_out)
-{
-	const char *path = udev_device_get_devnode(dev);
+/* Tests if 'path' is KMS compatible by trying to open it.
+ * It leaves the open device in *fd_out it it succeeds.
+ */
+static bool device_is_kms(struct wlr_session *restrict session,
+	const char *restrict path, int *restrict fd_out) {
+
 	int fd;
 
-	if (!path)
+	if (!path) {
 		return false;
+	}
 
 	fd = wlr_session_open_file(session, path);
-	if (fd < 0)
+	if (fd < 0) {
 		return false;
+	}
 
 	drmModeRes *res = drmModeGetResources(fd);
-	if (!res)
+	if (!res) {
 		goto out_fd;
+	}
 
 	if (res->count_crtcs <= 0 || res->count_connectors <= 0 ||
-	    res->count_encoders <= 0)
+		res->count_encoders <= 0) {
+
 		goto out_res;
+	}
 
 	if (*fd_out >= 0) {
 		wlr_session_close_file(session, *fd_out);
-		free(udev->drm_path);
 	}
 
 	*fd_out = fd;
-	udev->drm_path = strdup(path);
 
 	drmModeFreeResources(res);
 	return true;
@@ -57,10 +60,10 @@ out_fd:
 	return false;
 }
 
-int wlr_udev_find_gpu(struct wlr_udev *udev, struct wlr_session *session)
-{
-	int fd = -1;
-
+/* Tries to find the primary GPU by checking for the "boot_vga" attribute.
+ * If it's not found, it returns the first valid GPU it finds.
+ */
+int wlr_udev_find_gpu(struct wlr_udev *udev, struct wlr_session *session) {
 	struct udev_enumerate *en = udev_enumerate_new(udev->udev);
 	if (!en) {
 		wlr_log(L_ERROR, "Failed to create udev enumeration");
@@ -69,16 +72,20 @@ int wlr_udev_find_gpu(struct wlr_udev *udev, struct wlr_session *session)
 
 	udev_enumerate_add_match_subsystem(en, "drm");
 	udev_enumerate_add_match_sysname(en, "card[0-9]*");
-
 	udev_enumerate_scan_devices(en);
+
 	struct udev_list_entry *entry;
+	int fd = -1;
+	char *drm_path = NULL;
+
 	udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(en)) {
 		bool is_boot_vga = false;
 
 		const char *path = udev_list_entry_get_name(entry);
 		struct udev_device *dev = udev_device_new_from_syspath(udev->udev, path);
-		if (!dev)
+		if (!dev) {
 			continue;
+		}
 
 		/*
 		const char *seat = udev_device_get_property_value(dev, "ID_SEAT");
@@ -90,14 +97,15 @@ int wlr_udev_find_gpu(struct wlr_udev *udev, struct wlr_session *session)
 		}
 		*/
 
+		// This is owned by 'dev', so we don't need to free it
 		struct udev_device *pci =
 			udev_device_get_parent_with_subsystem_devtype(dev, "pci", NULL);
 
 		if (pci) {
 			const char *id = udev_device_get_sysattr_value(pci, "boot_vga");
-			if (id && strcmp(id, "1") == 0)
+			if (id && strcmp(id, "1") == 0) {
 				is_boot_vga = true;
-			//udev_device_unref(pci);
+			}
 		}
 
 		// We already have a valid GPU
@@ -106,38 +114,47 @@ int wlr_udev_find_gpu(struct wlr_udev *udev, struct wlr_session *session)
 			continue;
 		}
 
-		if (!device_is_kms(udev, session, dev, &fd)) {
+		path = udev_device_get_devnode(dev);
+		if (!device_is_kms(session, path, &fd)) {
 			udev_device_unref(dev);
 			continue;
 		}
 
+		free(drm_path);
+		drm_path = strdup(path);
+
 		udev_device_unref(dev);
 
-		if (is_boot_vga)
+		// We've found the primary GPU
+		if (is_boot_vga) {
 			break;
+		}
 	}
 
 	udev_enumerate_unref(en);
 
+	udev->drm_path = drm_path;
 	return fd;
 }
 
-static int udev_event(int fd, uint32_t mask, void *data)
-{
-	struct wlr_drm_backend *backend = data;
-	struct wlr_udev *udev = &backend->udev;
+static int udev_event(int fd, uint32_t mask, void *data) {
+	struct wlr_udev *udev = data;
+	struct wlr_drm_backend *backend = wl_container_of(udev, backend, udev);
 
 	struct udev_device *dev = udev_monitor_receive_device(udev->mon);
-	if (!dev)
+	if (!dev) {
 		return 1;
+	}
 
 	const char *path = udev_device_get_devnode(dev);
-	if (!path || strcmp(path, udev->drm_path) != 0)
+	if (!path || strcmp(path, udev->drm_path) != 0) {
 		goto out;
+	}
 
 	const char *action = udev_device_get_action(dev);
-	if (!action || strcmp(action, "change") != 0)
+	if (!action || strcmp(action, "change") != 0) {
 		goto out;
+	}
 
 	wlr_drm_scan_connectors(backend);
 
@@ -146,10 +163,7 @@ out:
 	return 1;
 }
 
-bool wlr_udev_init(struct wlr_drm_backend *backend)
-{
-	struct wlr_udev *udev = &backend->udev;
-
+bool wlr_udev_init(struct wl_display *display, struct wlr_udev *udev) {
 	udev->udev = udev_new();
 	if (!udev->udev) {
 		wlr_log(L_ERROR, "Failed to create udev context");
@@ -165,10 +179,12 @@ bool wlr_udev_init(struct wlr_drm_backend *backend)
 	udev_monitor_filter_add_match_subsystem_devtype(udev->mon, "drm", NULL);
 	udev_monitor_enable_receiving(udev->mon);
 
-	backend->event_src.udev = wl_event_loop_add_fd(backend->event_loop,
-			udev_monitor_get_fd(udev->mon), WL_EVENT_READABLE,
-			udev_event, backend);
-	if (!backend->event_src.udev) {
+	struct wl_event_loop *event_loop = wl_display_get_event_loop(display);
+	int fd = udev_monitor_get_fd(udev->mon);
+
+	udev->event = wl_event_loop_add_fd(event_loop, fd, WL_EVENT_READABLE,
+		udev_event, udev);
+	if (!udev->event) {
 		wlr_log(L_ERROR, "Failed to create udev event source");
 		goto error_mon;
 	}
@@ -184,11 +200,12 @@ error_udev:
 	return false;
 }
 
-void wlr_udev_free(struct wlr_udev *udev)
-
-{
-	if (!udev)
+void wlr_udev_free(struct wlr_udev *udev) {
+	if (!udev) {
 		return;
+	}
+
+	wl_event_source_remove(udev->event);
 
 	udev_monitor_unref(udev->mon);
 	udev_unref(udev->udev);