Merge branch 'master' into feature/data-device-selection

10 files changed, 189 insertions, 208 deletions

diff --git a/backend/drm/backend.c b/backend/drm/backend.c
index d7e2e616..40b559e2 100644
--- a/backend/drm/backend.c
+++ b/backend/drm/backend.c
@@ -9,9 +9,9 @@
 #include <wlr/backend/session.h>
 #include <wlr/backend/interface.h>
 #include <wlr/interfaces/wlr_output.h>
-#include <wlr/util/list.h>
+#include <wlr/types/wlr_list.h>
 #include <wlr/util/log.h>
-#include <wlr/egl.h>
+#include <wlr/render/egl.h>
 #include "backend/drm/drm.h"
 
 static bool wlr_drm_backend_start(struct wlr_backend *backend) {
@@ -29,8 +29,8 @@ static void wlr_drm_backend_destroy(struct wlr_backend *backend) {
 
 	wlr_drm_restore_outputs(drm);
 
-	for (size_t i = 0; drm->outputs && i < drm->outputs->length; ++i) {
-		struct wlr_drm_connector *conn = drm->outputs->items[i];
+	struct wlr_drm_connector *conn;
+	wl_list_for_each(conn, &drm->outputs, link) {
 		wlr_output_destroy(&conn->output);
 	}
 
@@ -38,7 +38,6 @@ static void wlr_drm_backend_destroy(struct wlr_backend *backend) {
 	wlr_drm_renderer_finish(&drm->renderer);
 	wlr_session_close_file(drm->session, drm->fd);
 	wl_event_source_remove(drm->drm_event);
-	list_free(drm->outputs);
 	free(drm);
 }
 
@@ -63,10 +62,13 @@ static void session_signal(struct wl_listener *listener, void *data) {
 
 	if (session->active) {
 		wlr_log(L_INFO, "DRM fd resumed");
+		wlr_drm_scan_connectors(drm);
 
-		for (size_t i = 0; i < drm->outputs->length; ++i) {
-			struct wlr_drm_connector *conn = drm->outputs->items[i];
-			wlr_drm_connector_start_renderer(conn);
+		struct wlr_drm_connector *conn;
+		wl_list_for_each(conn, &drm->outputs, link){
+			if (conn->output.current_mode) {
+				wlr_output_set_mode(&conn->output, conn->output.current_mode);
+			}
 
 			if (!conn->crtc) {
 				continue;
@@ -110,11 +112,7 @@ struct wlr_backend *wlr_drm_backend_create(struct wl_display *display,
 	wlr_backend_init(&drm->backend, &backend_impl);
 
 	drm->session = session;
-	drm->outputs = list_create();
-	if (!drm->outputs) {
-		wlr_log(L_ERROR, "Failed to allocate list");
-		goto error_backend;
-	}
+	wl_list_init(&drm->outputs);
 
 	drm->fd = gpu_fd;
 	drm->parent = (struct wlr_drm_backend *)parent;
@@ -158,8 +156,6 @@ error_event:
 	wl_event_source_remove(drm->drm_event);
 error_fd:
 	wlr_session_close_file(drm->session, drm->fd);
-	list_free(drm->outputs);
-error_backend:
 	free(drm);
 	return NULL;
 }
diff --git a/backend/drm/drm.c b/backend/drm/drm.c
index ff4dc7f6..441ba24e 100644
--- a/backend/drm/drm.c
+++ b/backend/drm/drm.c
@@ -177,9 +177,6 @@ void wlr_drm_resources_free(struct wlr_drm_backend *drm) {
 		if (plane->wlr_tex) {
 			wlr_texture_destroy(plane->wlr_tex);
 		}
-		if (plane->wlr_rend) {
-			wlr_renderer_destroy(plane->wlr_rend);
-		}
 	}
 
 	free(drm->crtcs);
@@ -193,7 +190,7 @@ static void wlr_drm_connector_make_current(struct wlr_output *output) {
 
 static void wlr_drm_connector_swap_buffers(struct wlr_output *output) {
 	struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output;
-	struct wlr_drm_backend *drm = conn->drm;
+	struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend;
 
 	struct wlr_drm_crtc *crtc = conn->crtc;
 	struct wlr_drm_plane *plane = crtc->primary;
@@ -214,12 +211,13 @@ static void wlr_drm_connector_swap_buffers(struct wlr_output *output) {
 }
 
 static void wlr_drm_connector_set_gamma(struct wlr_output *output,
-		uint16_t size, uint16_t *r, uint16_t *g, uint16_t *b) {
+		uint32_t size, uint16_t *r, uint16_t *g, uint16_t *b) {
 	struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output;
-	drmModeCrtcSetGamma(conn->drm->fd, conn->crtc->id, size, r, g, b);
+	struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend;
+	drmModeCrtcSetGamma(drm->fd, conn->crtc->id, size, r, g, b);
 }
 
-static uint16_t wlr_drm_connector_get_gamma_size(struct wlr_output *output) {
+static uint32_t wlr_drm_connector_get_gamma_size(struct wlr_output *output) {
 	struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output;
 	drmModeCrtc *crtc = conn->old_crtc;
 	return crtc ? crtc->gamma_size : 0;
@@ -230,7 +228,7 @@ void wlr_drm_connector_start_renderer(struct wlr_drm_connector *conn) {
 		return;
 	}
 
-	struct wlr_drm_backend *drm = conn->drm;
+	struct wlr_drm_backend *drm = (struct wlr_drm_backend *)conn->output.backend;
 	struct wlr_drm_crtc *crtc = conn->crtc;
 	struct wlr_drm_plane *plane = crtc->primary;
 
@@ -253,7 +251,7 @@ static void wlr_drm_connector_enable(struct wlr_output *output, bool enable) {
 		return;
 	}
 
-	struct wlr_drm_backend *drm = conn->drm;
+	struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend;
 	drm->iface->conn_enable(drm, conn, enable);
 
 	if (enable) {
@@ -261,7 +259,8 @@ static void wlr_drm_connector_enable(struct wlr_output *output, bool enable) {
 	}
 }
 
-static void realloc_planes(struct wlr_drm_backend *drm, const uint32_t *crtc_in) {
+static void realloc_planes(struct wlr_drm_backend *drm, const uint32_t *crtc_in,
+		bool *changed_outputs) {
 	// overlay, primary, cursor
 	for (int type = 0; type < 3; ++type) {
 		if (drm->num_type_planes[type] == 0) {
@@ -300,6 +299,7 @@ static void realloc_planes(struct wlr_drm_backend *drm, const uint32_t *crtc_in)
 			struct wlr_drm_plane *new = &drm->type_planes[type][crtc_res[i]];
 
 			if (*old != new) {
+				changed_outputs[crtc_res[i]] = true;
 				if (*old) {
 					wlr_drm_surface_finish(&(*old)->surf);
 				}
@@ -310,10 +310,12 @@ static void realloc_planes(struct wlr_drm_backend *drm, const uint32_t *crtc_in)
 	}
 }
 
-static void realloc_crtcs(struct wlr_drm_backend *drm, struct wlr_drm_connector *conn) {
+static void realloc_crtcs(struct wlr_drm_backend *drm,
+		struct wlr_drm_connector *conn, bool *changed_outputs) {
 	uint32_t crtc[drm->num_crtcs];
 	uint32_t crtc_res[drm->num_crtcs];
-	uint32_t possible_crtc[drm->outputs->length];
+	ssize_t num_outputs = wl_list_length(&drm->outputs);
+	uint32_t possible_crtc[num_outputs];
 
 	for (size_t i = 0; i < drm->num_crtcs; ++i) {
 		crtc[i] = UNMATCHED;
@@ -321,54 +323,71 @@ static void realloc_crtcs(struct wlr_drm_backend *drm, struct wlr_drm_connector
 
 	memset(possible_crtc, 0, sizeof(possible_crtc));
 
-	ssize_t index = -1;
-	for (size_t i = 0; i < drm->outputs->length; ++i) {
-		struct wlr_drm_connector *c = drm->outputs->items[i];
+	ssize_t index = -1, i = -1;
+	struct wlr_drm_connector *c;
+	wl_list_for_each(c, &drm->outputs, link) {
+		i++;
 		if (c == conn) {
 			index = i;
 		}
 
-		if (c->state != WLR_DRM_CONN_CONNECTED) {
-			continue;
+		if (c->crtc) {
+			crtc[c->crtc - drm->crtcs] = i;
+		}
+
+		if (c->state == WLR_DRM_CONN_CONNECTED) {
+			possible_crtc[i] = c->possible_crtc;
 		}
 
-		possible_crtc[i] = c->possible_crtc;
-		crtc[c->crtc - drm->crtcs] = i;
 	}
 	assert(index != -1);
 
 	possible_crtc[index] = conn->possible_crtc;
-	match_obj(drm->outputs->length, possible_crtc, drm->num_crtcs,
-		crtc, crtc_res);
+	match_obj(wl_list_length(&drm->outputs), possible_crtc,
+		drm->num_crtcs, crtc, crtc_res);
 
-	bool matched = false;
+	bool matched[num_outputs];
+	memset(matched, false, sizeof(matched));
 	for (size_t i = 0; i < drm->num_crtcs; ++i) {
-		// We don't want any of the current monitors to be deactivated.
-		if (crtc[i] != UNMATCHED && crtc_res[i] == UNMATCHED) {
-			return;
-		}
-		if (crtc_res[i] == index) {
-			matched = true;
+		if (crtc_res[i] != UNMATCHED) {
+			matched[crtc_res[i]] = true;
 		}
 	}
 
 	// There is no point doing anything if this monitor doesn't get activated
-	if (!matched) {
+	if (!matched[index]) {
 		return;
 	}
 
 	for (size_t i = 0; i < drm->num_crtcs; ++i) {
+		// We don't want any of the current monitors to be deactivated.
+		if (crtc[i] != UNMATCHED && !matched[crtc[i]]) {
+			return;
+		}
+	}
+
+	changed_outputs[index] = true;
+
+	for (size_t i = 0; i < drm->num_crtcs; ++i) {
 		if (crtc_res[i] == UNMATCHED) {
 			continue;
 		}
 
 		if (crtc_res[i] != crtc[i]) {
-			struct wlr_drm_connector *c = drm->outputs->items[crtc_res[i]];
+			changed_outputs[crtc_res[i]] = true;
+			struct wlr_drm_connector *c;
+			size_t pos = 0;
+			wl_list_for_each(c, &drm->outputs, link) {
+				if (pos == crtc_res[i]) {
+					break;
+				}
+				pos++;
+			}
 			c->crtc = &drm->crtcs[i];
 		}
 	}
 
-	realloc_planes(drm, crtc_res);
+	realloc_planes(drm, crtc_res, changed_outputs);
 }
 
 static uint32_t get_possible_crtcs(int fd, uint32_t conn_id) {
@@ -406,7 +425,8 @@ error_conn:
 static bool wlr_drm_connector_set_mode(struct wlr_output *output,
 		struct wlr_output_mode *mode) {
 	struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output;
-	struct wlr_drm_backend *drm = conn->drm;
+	struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend;
+	bool changed_outputs[wl_list_length(&drm->outputs)];
 
 	wlr_log(L_INFO, "Modesetting '%s' with '%ux%u@%u mHz'", conn->output.name,
 			mode->width, mode->height, mode->refresh);
@@ -416,7 +436,8 @@ static bool wlr_drm_connector_set_mode(struct wlr_output *output,
 		goto error_conn;
 	}
 
-	realloc_crtcs(drm, conn);
+	memset(changed_outputs, false, sizeof(changed_outputs));
+	realloc_crtcs(drm, conn, changed_outputs);
 
 	if (!conn->crtc) {
 		wlr_log(L_ERROR, "Unable to match %s with a CRTC", conn->output.name);
@@ -431,19 +452,23 @@ static bool wlr_drm_connector_set_mode(struct wlr_output *output,
 		crtc->cursor ? crtc->cursor - drm->cursor_planes : -1);
 
 	conn->state = WLR_DRM_CONN_CONNECTED;
-	conn->output.width = mode->width;
-	conn->output.height = mode->height;
 	conn->output.current_mode = mode;
-	wl_signal_emit(&conn->output.events.resolution, &conn->output);
+	if (conn->output.width != mode->width || conn->output.height != mode->height) {
+		conn->output.width = mode->width;
+		conn->output.height = mode->height;
+		wl_signal_emit(&conn->output.events.resolution, &conn->output);
+	}
 
 	// Since realloc_crtcs can deallocate planes on OTHER outputs,
-	// we actually need to reinitalise all of them
-	for (size_t i = 0; i < drm->outputs->length; ++i) {
-		struct wlr_drm_connector *conn = drm->outputs->items[i];
+	// we actually need to reinitalise any than has changed
+	ssize_t output_index = -1;
+	wl_list_for_each(conn, &drm->outputs, link) {
+		output_index += 1;
 		struct wlr_output_mode *mode = conn->output.current_mode;
 		struct wlr_drm_crtc *crtc = conn->crtc;
 
-		if (conn->state != WLR_DRM_CONN_CONNECTED) {
+		if (conn->state != WLR_DRM_CONN_CONNECTED ||
+				!changed_outputs[output_index]) {
 			continue;
 		}
 
@@ -472,7 +497,7 @@ static bool wlr_drm_connector_set_cursor(struct wlr_output *output,
 		const uint8_t *buf, int32_t stride, uint32_t width, uint32_t height,
 		int32_t hotspot_x, int32_t hotspot_y, bool update_pixels) {
 	struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output;
-	struct wlr_drm_backend *drm = conn->drm;
+	struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend;
 	struct wlr_drm_renderer *renderer = &drm->renderer;
 
 	struct wlr_drm_crtc *crtc = conn->crtc;
@@ -525,12 +550,7 @@ static bool wlr_drm_connector_set_cursor(struct wlr_output *output,
 
 		// TODO the image needs to be rotated depending on the output rotation
 
-		plane->wlr_rend = wlr_gles2_renderer_create(&drm->backend);
-		if (!plane->wlr_rend) {
-			return false;
-		}
-
-		plane->wlr_tex = wlr_render_texture_create(plane->wlr_rend);
+		plane->wlr_tex = wlr_render_texture_create(plane->surf.renderer->wlr_rend);
 		if (!plane->wlr_tex) {
 			return false;
 		}
@@ -595,7 +615,7 @@ static bool wlr_drm_connector_set_cursor(struct wlr_output *output,
 
 	float matrix[16];
 	wlr_texture_get_matrix(plane->wlr_tex, &matrix, &plane->matrix, 0, 0);
-	wlr_render_with_matrix(plane->wlr_rend, plane->wlr_tex, &matrix);
+	wlr_render_with_matrix(plane->surf.renderer->wlr_rend, plane->wlr_tex, &matrix);
 
 	glFinish();
 	glPixelStorei(GL_UNPACK_ROW_LENGTH_EXT, bo_stride);
@@ -612,7 +632,7 @@ static bool wlr_drm_connector_set_cursor(struct wlr_output *output,
 static bool wlr_drm_connector_move_cursor(struct wlr_output *output,
 		int x, int y) {
 	struct wlr_drm_connector *conn = (struct wlr_drm_connector *)output;
-	struct wlr_drm_backend *drm = conn->drm;
+	struct wlr_drm_backend *drm = (struct wlr_drm_backend *)output->backend;
 
 	int width, height, tmp;
 	wlr_output_effective_resolution(output, &width, &height);
@@ -667,13 +687,6 @@ static int retry_pageflip(void *data) {
 	return 0;
 }
 
-static int find_id(const void *item, const void *cmp_to) {
-	const struct wlr_drm_connector *conn = item;
-	const uint32_t *id = cmp_to;
-
-	return (int)conn->id - (int)*id;
-}
-
 static const int32_t subpixel_map[] = {
 	[DRM_MODE_SUBPIXEL_UNKNOWN] = WL_OUTPUT_SUBPIXEL_UNKNOWN,
 	[DRM_MODE_SUBPIXEL_HORIZONTAL_RGB] = WL_OUTPUT_SUBPIXEL_HORIZONTAL_RGB,
@@ -692,8 +705,9 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
 		return;
 	}
 
-	size_t seen_len = drm->outputs->length;
-	// +1 so it can never be 0
+	size_t seen_len = wl_list_length(&drm->outputs);
+	// +1 so length can never be 0, which is undefined behaviour.
+	// Last element isn't used.
 	bool seen[seen_len + 1];
 	memset(seen, 0, sizeof(seen));
 
@@ -704,33 +718,39 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
 			wlr_log_errno(L_ERROR, "Failed to get DRM connector");
 			continue;
 		}
+		drmModeEncoder *curr_enc = drmModeGetEncoder(drm->fd,
+			drm_conn->encoder_id);
 
-		struct wlr_drm_connector *wlr_conn;
-		int index = list_seq_find(drm->outputs, find_id, &drm_conn->connector_id);
+		int index = -1;
+		struct wlr_drm_connector *c, *wlr_conn = NULL;
+		wl_list_for_each(c, &drm->outputs, link) {
+			index++;
+			if (c->id == drm_conn->connector_id) {
+				wlr_conn = c;
+				break;
+			}
+		}
 
-		if (index == -1) {
+		if (!wlr_conn) {
 			wlr_conn = calloc(1, sizeof(*wlr_conn));
 			if (!wlr_conn) {
 				wlr_log_errno(L_ERROR, "Allocation failed");
+				drmModeFreeEncoder(curr_enc);
 				drmModeFreeConnector(drm_conn);
 				continue;
 			}
-			wlr_output_init(&wlr_conn->output, &output_impl);
+			wlr_output_init(&wlr_conn->output, &drm->backend, &output_impl);
 
 			struct wl_event_loop *ev = wl_display_get_event_loop(drm->display);
 			wlr_conn->retry_pageflip = wl_event_loop_add_timer(ev, retry_pageflip,
 				wlr_conn);
 
 
-			wlr_conn->drm = drm;
 			wlr_conn->state = WLR_DRM_CONN_DISCONNECTED;
 			wlr_conn->id = drm_conn->connector_id;
 
-			drmModeEncoder *curr_enc = drmModeGetEncoder(drm->fd,
-					drm_conn->encoder_id);
 			if (curr_enc) {
 				wlr_conn->old_crtc = drmModeGetCrtc(drm->fd, curr_enc->crtc_id);
-				drmModeFreeEncoder(curr_enc);
 			}
 
 			wlr_conn->output.phys_width = drm_conn->mmWidth;
@@ -749,23 +769,25 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
 			parse_edid(&wlr_conn->output, edid_len, edid);
 			free(edid);
 
-			if (list_add(drm->outputs, wlr_conn) == -1) {
-				wlr_log_errno(L_ERROR, "Allocation failed");
-				drmModeFreeConnector(drm_conn);
-				wl_event_source_remove(wlr_conn->retry_pageflip);
-				free(wlr_conn);
-				continue;
-			}
-			wlr_output_create_global(&wlr_conn->output, drm->display);
+			wl_list_insert(&drm->outputs, &wlr_conn->link);
 			wlr_log(L_INFO, "Found display '%s'", wlr_conn->output.name);
 		} else {
-			wlr_conn = drm->outputs->items[index];
 			seen[index] = true;
 		}
 
+		if (curr_enc) {
+			for (size_t i = 0; i < drm->num_crtcs; ++i) {
+				if (drm->crtcs[i].id == curr_enc->crtc_id) {
+					wlr_conn->crtc = &drm->crtcs[i];
+					break;
+				}
+			}
+		} else {
+			wlr_conn->crtc = NULL;
+		}
+
 		if (wlr_conn->state == WLR_DRM_CONN_DISCONNECTED &&
 				drm_conn->connection == DRM_MODE_CONNECTED) {
-
 			wlr_log(L_INFO, "'%s' connected", wlr_conn->output.name);
 			wlr_log(L_INFO, "Detected modes:");
 
@@ -784,51 +806,50 @@ void wlr_drm_scan_connectors(struct wlr_drm_backend *drm) {
 					mode->wlr_mode.width, mode->wlr_mode.height,
 					mode->wlr_mode.refresh);
 
-				if (list_add(wlr_conn->output.modes, mode) == -1) {
-					wlr_log_errno(L_ERROR, "Allocation failed");
-					free(mode);
-					continue;
-				}
+				wl_list_insert(&wlr_conn->output.modes, &mode->wlr_mode.link);
 			}
 
+			wlr_output_create_global(&wlr_conn->output, drm->display);
+
 			wlr_conn->state = WLR_DRM_CONN_NEEDS_MODESET;
 			wlr_log(L_INFO, "Sending modesetting signal for '%s'",
 				wlr_conn->output.name);
 			wl_signal_emit(&drm->backend.events.output_add, &wlr_conn->output);
 		} else if (wlr_conn->state == WLR_DRM_CONN_CONNECTED &&
 				drm_conn->connection != DRM_MODE_CONNECTED) {
-
 			wlr_log(L_INFO, "'%s' disconnected", wlr_conn->output.name);
+
+			wlr_output_destroy_global(&wlr_conn->output);
 			wlr_drm_connector_cleanup(wlr_conn);
 		}
 
+		drmModeFreeEncoder(curr_enc);
 		drmModeFreeConnector(drm_conn);
 	}
 
 	drmModeFreeResources(res);
 
-	for (size_t i = seen_len; i-- > 0;) {
-		if (seen[i]) {
+	struct wlr_drm_connector *conn, *tmp_conn;
+	size_t index = wl_list_length(&drm->outputs);
+	wl_list_for_each_safe(conn, tmp_conn, &drm->outputs, link) {
+		index--;
+		if (index >= seen_len || seen[index]) {
 			continue;
 		}
 
-		struct wlr_drm_connector *conn = drm->outputs->items[i];
-
 		wlr_log(L_INFO, "'%s' disappeared", conn->output.name);
 		wlr_drm_connector_cleanup(conn);
 
 		drmModeFreeCrtc(conn->old_crtc);
 		wl_event_source_remove(conn->retry_pageflip);
 		free(conn);
-
-		list_del(drm->outputs, i);
 	}
 }
 
 static void page_flip_handler(int fd, unsigned seq,
 		unsigned tv_sec, unsigned tv_usec, void *user) {
 	struct wlr_drm_connector *conn = user;
-	struct wlr_drm_backend *drm = conn->drm;
+	struct wlr_drm_backend *drm = (struct wlr_drm_backend *)conn->output.backend;
 
 	conn->pageflip_pending = false;
 	if (conn->state != WLR_DRM_CONN_CONNECTED) {
@@ -856,10 +877,10 @@ int wlr_drm_event(int fd, uint32_t mask, void *data) {
 }
 
 void wlr_drm_restore_outputs(struct wlr_drm_backend *drm) {
-	uint64_t to_close = (1 << drm->outputs->length) - 1;
+	uint64_t to_close = (1 << wl_list_length(&drm->outputs)) - 1;
 
-	for (size_t i = 0; i < drm->outputs->length; ++i) {
-		struct wlr_drm_connector *conn = drm->outputs->items[i];
+	struct wlr_drm_connector *conn;
+	wl_list_for_each(conn, &drm->outputs, link) {
 		if (conn->state == WLR_DRM_CONN_CONNECTED) {
 			conn->state = WLR_DRM_CONN_CLEANUP;
 		}
@@ -869,11 +890,13 @@ void wlr_drm_restore_outputs(struct wlr_drm_backend *drm) {
 
 	while (to_close && time(NULL) < timeout) {
 		wlr_drm_event(drm->fd, 0, NULL);
-		for (size_t i = 0; i < drm->outputs->length; ++i) {
-			struct wlr_drm_connector *conn = drm->outputs->items[i];
+		size_t i = 0;
+		struct wlr_drm_connector *conn;
+		wl_list_for_each(conn, &drm->outputs, link) {
 			if (conn->state != WLR_DRM_CONN_CLEANUP || !conn->pageflip_pending) {
 				to_close &= ~(1 << i);
 			}
+			i++;
 		}
 	}
 
@@ -881,8 +904,7 @@ void wlr_drm_restore_outputs(struct wlr_drm_backend *drm) {
 		wlr_log(L_ERROR, "Timed out stopping output renderers");
 	}
 
-	for (size_t i = 0; i < drm->outputs->length; ++i) {
-		struct wlr_drm_connector *conn = drm->outputs->items[i];
+	wl_list_for_each(conn, &drm->outputs, link) {
 		drmModeCrtc *crtc = conn->old_crtc;
 		if (!crtc) {
 			continue;
@@ -899,7 +921,7 @@ void wlr_drm_connector_cleanup(struct wlr_drm_connector *conn) {
 		return;
 	}
 
-	struct wlr_drm_backend *drm = conn->drm;
+	struct wlr_drm_backend *drm = (struct wlr_drm_backend *)conn->output.backend;
 
 	switch (conn->state) {
 	case WLR_DRM_CONN_CONNECTED:
diff --git a/backend/drm/renderer.c b/backend/drm/renderer.c
index 0d338490..d53acaa8 100644
--- a/backend/drm/renderer.c
+++ b/backend/drm/renderer.c
@@ -8,8 +8,8 @@
 #include <EGL/eglext.h>
 #include <wayland-util.h>
 
-#include <wlr/egl.h>
 #include <wlr/util/log.h>
+#include <wlr/render/egl.h>
 #include <wlr/render/matrix.h>
 #include <wlr/render/gles2.h>
 #include <wlr/render.h>
diff --git a/backend/libinput/backend.c b/backend/libinput/backend.c
index 3d3c90ce..781314a3 100644
--- a/backend/libinput/backend.c
+++ b/backend/libinput/backend.c
@@ -99,15 +99,15 @@ static void wlr_libinput_backend_destroy(struct wlr_backend *_backend) {
 	}
 	struct wlr_libinput_backend *backend = (struct wlr_libinput_backend *)_backend;
 	for (size_t i = 0; i < backend->wlr_device_lists->length; i++) {
-		list_t *wlr_devices = backend->wlr_device_lists->items[i];
+		struct wlr_list *wlr_devices = backend->wlr_device_lists->items[i];
 		for (size_t j = 0; j < wlr_devices->length; j++) {
 			struct wlr_input_device *wlr_dev = wlr_devices->items[j];
 			wl_signal_emit(&backend->backend.events.input_remove, wlr_dev);
 			wlr_input_device_destroy(wlr_dev);
 		}
-		list_free(wlr_devices);
+		wlr_list_free(wlr_devices);
 	}
-	list_free(backend->wlr_device_lists);
+	wlr_list_free(backend->wlr_device_lists);
 	wl_event_source_remove(backend->input_event);
 	libinput_unref(backend->libinput_context);
 	free(backend);
@@ -148,7 +148,7 @@ struct wlr_backend *wlr_libinput_backend_create(struct wl_display *display,
 	}
 	wlr_backend_init(&backend->backend, &backend_impl);
 
-	if (!(backend->wlr_device_lists = list_create())) {
+	if (!(backend->wlr_device_lists = wlr_list_create())) {
 		wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno));
 		goto error_backend;
 	}
diff --git a/backend/libinput/events.c b/backend/libinput/events.c
index 2a396536..053cab02 100644
--- a/backend/libinput/events.c
+++ b/backend/libinput/events.c
@@ -3,19 +3,19 @@
 #include <libinput.h>
 #include <wlr/backend/session.h>
 #include <wlr/interfaces/wlr_input_device.h>
-#include <wlr/util/list.h>
 #include <wlr/util/log.h>
+#include <wayland-util.h>
 #include "backend/libinput.h"
 
 struct wlr_input_device *get_appropriate_device(
 		enum wlr_input_device_type desired_type,
 		struct libinput_device *libinput_dev) {
-	list_t *wlr_devices = libinput_device_get_user_data(libinput_dev);
+	struct wl_list *wlr_devices = libinput_device_get_user_data(libinput_dev);
 	if (!wlr_devices) {
 		return NULL;
 	}
-	for (size_t i = 0; i < wlr_devices->length; ++i) {
-		struct wlr_input_device *dev = wlr_devices->items[i];
+	struct wlr_input_device *dev;
+	wl_list_for_each(dev, wlr_devices, link) {
 		if (dev->type == desired_type) {
 			return dev;
 		}
@@ -35,7 +35,7 @@ static struct wlr_input_device_impl input_device_impl = {
 
 static struct wlr_input_device *allocate_device(
 		struct wlr_libinput_backend *backend, struct libinput_device *libinput_dev,
-		list_t *wlr_devices, enum wlr_input_device_type type) {
+		struct wl_list *wlr_devices, enum wlr_input_device_type type) {
 	int vendor = libinput_device_get_id_vendor(libinput_dev);
 	int product = libinput_device_get_id_product(libinput_dev);
 	const char *name = libinput_device_get_name(libinput_dev);
@@ -44,10 +44,7 @@ static struct wlr_input_device *allocate_device(
 		return NULL;
 	}
 	struct wlr_input_device *wlr_dev = &wlr_libinput_dev->wlr_input_device;
-	if (list_add(wlr_devices, wlr_dev) == -1) {
-		free(wlr_libinput_dev);
-		return NULL;
-	}
+	wl_list_insert(wlr_devices, &wlr_dev->link);
 	wlr_libinput_dev->handle = libinput_dev;
 	libinput_device_ref(libinput_dev);
 	wlr_input_device_init(wlr_dev, type, &input_device_impl,
@@ -67,7 +64,8 @@ static void handle_device_added(struct wlr_libinput_backend *backend,
 	int vendor = libinput_device_get_id_vendor(libinput_dev);
 	int product = libinput_device_get_id_product(libinput_dev);
 	const char *name = libinput_device_get_name(libinput_dev);
-	list_t *wlr_devices = list_create();
+	struct wl_list *wlr_devices = calloc(1, sizeof(struct wl_list));
+	wl_list_init(wlr_devices);
 	if (!wlr_devices) {
 		goto fail;
 	}
@@ -145,23 +143,26 @@ static void handle_device_added(struct wlr_libinput_backend *backend,
 		// TODO
 	}
 
-	if (wlr_devices->length > 0) {
+	if (wl_list_length(wlr_devices) > 0) {
 		libinput_device_set_user_data(libinput_dev, wlr_devices);
-		list_add(backend->wlr_device_lists, wlr_devices);
+		wlr_list_add(backend->wlr_device_lists, wlr_devices);
 	} else {
-		list_free(wlr_devices);
+		free(wlr_devices);
 	}
 	return;
 
 fail:
 	wlr_log(L_ERROR, "Could not allocate new device");
-	list_foreach(wlr_devices, free);
-	list_free(wlr_devices);
+	struct wlr_input_device *dev, *tmp_dev;
+	wl_list_for_each_safe(dev, tmp_dev, wlr_devices, link) {
+		free(dev);
+	}
+	free(wlr_devices);
 }
 
 static void handle_device_removed(struct wlr_libinput_backend *backend,
 		struct libinput_device *libinput_dev) {
-	list_t *wlr_devices = libinput_device_get_user_data(libinput_dev);
+	struct wl_list *wlr_devices = libinput_device_get_user_data(libinput_dev);
 	int vendor = libinput_device_get_id_vendor(libinput_dev);
 	int product = libinput_device_get_id_product(libinput_dev);
 	const char *name = libinput_device_get_name(libinput_dev);
@@ -169,18 +170,18 @@ static void handle_device_removed(struct wlr_libinput_backend *backend,
 	if (!wlr_devices) {
 		return;
 	}
-	for (size_t i = 0; i < wlr_devices->length; i++) {
-		struct wlr_input_device *wlr_dev = wlr_devices->items[i];
-		wl_signal_emit(&backend->backend.events.input_remove, wlr_dev);
-		wlr_input_device_destroy(wlr_dev);
+	struct wlr_input_device *dev, *tmp_dev;
+	wl_list_for_each_safe(dev, tmp_dev, wlr_devices, link) {
+		wl_signal_emit(&backend->backend.events.input_remove, dev);
+		wlr_input_device_destroy(dev);
 	}
 	for (size_t i = 0; i < backend->wlr_device_lists->length; i++) {
 		if (backend->wlr_device_lists->items[i] == wlr_devices) {
-			list_del(backend->wlr_device_lists, i);
+			wlr_list_del(backend->wlr_device_lists, i);
 			break;
 		}
 	}
-	list_free(wlr_devices);
+	free(wlr_devices);
 }
 
 void wlr_libinput_event(struct wlr_libinput_backend *backend,
diff --git a/backend/multi/backend.c b/backend/multi/backend.c
index ae1d6803..a7ee648c 100644
--- a/backend/multi/backend.c
+++ b/backend/multi/backend.c
@@ -13,14 +13,15 @@ struct subbackend_state {
 	struct wl_listener input_remove;
 	struct wl_listener output_add;
 	struct wl_listener output_remove;
+	struct wl_list link;
 };
 
 static bool multi_backend_start(struct wlr_backend *_backend) {
 	struct wlr_multi_backend *backend = (struct wlr_multi_backend *)_backend;
-	for (size_t i = 0; i < backend->backends->length; ++i) {
-		struct subbackend_state *sub = backend->backends->items[i];
+	struct subbackend_state *sub;
+	wl_list_for_each(sub, &backend->backends, link) {
 		if (!wlr_backend_start(sub->backend)) {
-			wlr_log(L_ERROR, "Failed to initialize backend %zd", i);
+			wlr_log(L_ERROR, "Failed to initialize backend.");
 			return false;
 		}
 	}
@@ -29,20 +30,19 @@ static bool multi_backend_start(struct wlr_backend *_backend) {
 
 static void multi_backend_destroy(struct wlr_backend *_backend) {
 	struct wlr_multi_backend *backend = (struct wlr_multi_backend *)_backend;
-	for (size_t i = 0; i < backend->backends->length; ++i) {
-		struct subbackend_state *sub = backend->backends->items[i];
+	struct subbackend_state *sub;
+	wl_list_for_each(sub, &backend->backends, link) {
 		wlr_backend_destroy(sub->backend);
 		free(sub);
 	}
-	list_free(backend->backends);
 	wlr_session_destroy(backend->session);
 	free(backend);
 }
 
 static struct wlr_egl *multi_backend_get_egl(struct wlr_backend *_backend) {
 	struct wlr_multi_backend *backend = (struct wlr_multi_backend *)_backend;
-	for (size_t i = 0; i < backend->backends->length; ++i) {
-		struct subbackend_state *sub = backend->backends->items[i];
+	struct subbackend_state *sub;
+	wl_list_for_each(sub, &backend->backends, link) {
 		struct wlr_egl *egl = wlr_backend_get_egl(sub->backend);
 		if (egl) {
 			return egl;
@@ -65,13 +65,7 @@ struct wlr_backend *wlr_multi_backend_create(struct wlr_session *session) {
 		return NULL;
 	}
 
-	backend->backends = list_create();
-	if (!backend->backends) {
-		free(backend);
-		wlr_log(L_ERROR, "Backend allocation failed");
-		return NULL;
-	}
-
+	wl_list_init(&backend->backends);
 	wlr_backend_init(&backend->backend, &backend_impl);
 
 	backend->session = session;
@@ -116,11 +110,7 @@ void wlr_multi_backend_add(struct wlr_backend *_multi,
 		wlr_log(L_ERROR, "Could not add backend: allocation failed");
 		return;
 	}
-	if (list_add(multi->backends, sub) == -1) {
-		wlr_log(L_ERROR, "Could not add backend: allocation failed");
-		free(sub);
-		return;
-	}
+	wl_list_insert(&multi->backends, &sub->link);
 
 	sub->backend = backend;
 	sub->container = &multi->backend;
diff --git a/backend/wayland/backend.c b/backend/wayland/backend.c
index e57f3583..532935b8 100644
--- a/backend/wayland/backend.c
+++ b/backend/wayland/backend.c
@@ -4,7 +4,7 @@
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
 #include <wayland-server.h>
-#include <wlr/egl.h>
+#include <wlr/render/egl.h>
 #include <wlr/backend/interface.h>
 #include <wlr/interfaces/wlr_output.h>
 #include <wlr/interfaces/wlr_input_device.h>
@@ -64,16 +64,16 @@ static void wlr_wl_backend_destroy(struct wlr_backend *_backend) {
 		return;
 	}
 
-	for (size_t i = 0; i < backend->outputs->length; ++i) {
-		wlr_output_destroy(backend->outputs->items[i]);
+	struct wlr_wl_backend_output *output, *tmp_output;
+	wl_list_for_each_safe(output, tmp_output, &backend->outputs, link) {
+		wlr_output_destroy(&output->wlr_output);
 	}
 
-	for (size_t i = 0; i < backend->devices->length; ++i) {
-		wlr_input_device_destroy(backend->devices->items[i]);
+	struct wlr_input_device *input_device, *tmp_input_device;
+	wl_list_for_each_safe(input_device, tmp_input_device, &backend->devices, link) {
+		wlr_input_device_destroy(input_device);
 	}
 
-	list_free(backend->devices);
-	list_free(backend->outputs);
 	free(backend->seat_name);
 
 	wl_event_source_remove(backend->remote_display_src);
@@ -104,8 +104,8 @@ bool wlr_backend_is_wl(struct wlr_backend *b) {
 
 struct wlr_wl_backend_output *wlr_wl_output_for_surface(
 		struct wlr_wl_backend *backend, struct wl_surface *surface) {
-	for (size_t i = 0; i < backend->outputs->length; ++i) {
-		struct wlr_wl_backend_output *output = backend->outputs->items[i];
+	struct wlr_wl_backend_output *output;
+	wl_list_for_each(output, &backend->outputs, link) {
 		if (output->surface == surface) {
 			return output;
 		}
@@ -123,15 +123,8 @@ struct wlr_backend *wlr_wl_backend_create(struct wl_display *display) {
 	}
 	wlr_backend_init(&backend->backend, &backend_impl);
 
-	if (!(backend->devices = list_create())) {
-		wlr_log(L_ERROR, "Could not allocate devices list");
-		goto error;
-	}
-
-	if (!(backend->outputs = list_create())) {
-		wlr_log(L_ERROR, "Could not allocate outputs list");
-		goto error;
-	}
+	wl_list_init(&backend->devices);
+	wl_list_init(&backend->outputs);
 
 	backend->local_display = display;
 
@@ -150,12 +143,4 @@ struct wlr_backend *wlr_wl_backend_create(struct wl_display *display) {
 	wlr_egl_bind_display(&backend->egl, backend->local_display);
 
 	return &backend->backend;
-
-error:
-	if (backend) {
-		list_free(backend->devices);
-		list_free(backend->outputs);
-	}
-	free(backend);
-	return NULL;
 }
diff --git a/backend/wayland/output.c b/backend/wayland/output.c
index e1138ee1..0dde343c 100644
--- a/backend/wayland/output.c
+++ b/backend/wayland/output.c
@@ -210,9 +210,7 @@ static void xdg_toplevel_handle_configure(void *data, struct zxdg_toplevel_v6 *x
 	}
 	// loop over states for maximized etc?
 	wl_egl_window_resize(output->egl_window, width, height, 0, 0);
-	output->wlr_output.width = width;
-	output->wlr_output.height = height;
-	wlr_output_update_matrix(&output->wlr_output);
+	wlr_output_update_size(&output->wlr_output, width, height);
 	wl_signal_emit(&output->wlr_output.events.resolution, output);
 }
 
@@ -241,16 +239,14 @@ struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) {
 		wlr_log(L_ERROR, "Failed to allocate wlr_wl_backend_output");
 		return NULL;
 	}
-	wlr_output_init(&output->wlr_output, &output_impl);
+	wlr_output_init(&output->wlr_output, &backend->backend, &output_impl);
 	struct wlr_output *wlr_output = &output->wlr_output;
 
-	wlr_output->width = 640;
-	wlr_output->height = 480;
+	wlr_output_update_size(wlr_output, 640, 480);
 	strncpy(wlr_output->make, "wayland", sizeof(wlr_output->make));
 	strncpy(wlr_output->model, "wayland", sizeof(wlr_output->model));
-	snprintf(wlr_output->name, sizeof(wlr_output->name), "WL-%zd",
-			backend->outputs->length + 1);
-	wlr_output_update_matrix(wlr_output);
+	snprintf(wlr_output->name, sizeof(wlr_output->name), "WL-%d",
+		wl_list_length(&backend->outputs) + 1);
 
 	output->backend = backend;
 
@@ -306,10 +302,7 @@ struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) {
 		goto error;
 	}
 
-	if (list_add(backend->outputs, wlr_output) == -1) {
-		wlr_log(L_ERROR, "Allocation failed");
-		goto error;
-	}
+	wl_list_insert(&backend->outputs, &output->link);
 	wlr_output_create_global(wlr_output, backend->local_display);
 	wl_signal_emit(&backend->backend.events.output_add, wlr_output);
 	return wlr_output;
diff --git a/backend/wayland/wl_seat.c b/backend/wayland/wl_seat.c
index d3ff9b64..30074abd 100644
--- a/backend/wayland/wl_seat.c
+++ b/backend/wayland/wl_seat.c
@@ -204,11 +204,7 @@ static struct wlr_input_device *allocate_device(struct wlr_wl_backend *backend,
 	struct wlr_input_device *wlr_device = &wlr_wl_dev->wlr_input_device;
 	wlr_input_device_init(wlr_device, type, &input_device_impl,
 			name, vendor, product);
-	if (list_add(backend->devices, wlr_device) == -1) {
-		wlr_log_errno(L_ERROR, "Allocation failed");
-		free(wlr_wl_dev);
-		return NULL;
-	}
+	wl_list_insert(&backend->devices, &wlr_device->link);
 	return wlr_device;
 }
 
diff --git a/backend/x11/backend.c b/backend/x11/backend.c
index 11dd8568..0e98b8d9 100644
--- a/backend/x11/backend.c
+++ b/backend/x11/backend.c
@@ -15,7 +15,7 @@
 #endif
 #include <wlr/backend/interface.h>
 #include <wlr/backend/x11.h>
-#include <wlr/egl.h>
+#include <wlr/render/egl.h>
 #include <wlr/interfaces/wlr_output.h>
 #include <wlr/interfaces/wlr_input_device.h>
 #include <wlr/interfaces/wlr_keyboard.h>
@@ -121,9 +121,7 @@ static bool handle_x11_event(struct wlr_x11_backend *x11, xcb_generic_event_t *e
 	case XCB_CONFIGURE_NOTIFY: {
 		xcb_configure_notify_event_t *ev = (xcb_configure_notify_event_t *)event;
 
-		output->wlr_output.width = ev->width;
-		output->wlr_output.height = ev->height;
-		wlr_output_update_matrix(&output->wlr_output);
+		wlr_output_update_size(&output->wlr_output, ev->width, ev->height);
 		wl_signal_emit(&output->wlr_output.events.resolution, output);
 
 		// Move the pointer to its new location
@@ -264,7 +262,7 @@ static bool wlr_x11_backend_start(struct wlr_backend *backend) {
 
 	output->x11 = x11;
 
-	wlr_output_init(&output->wlr_output, &output_impl);
+	wlr_output_init(&output->wlr_output, &x11->backend, &output_impl);
 	snprintf(output->wlr_output.name, sizeof(output->wlr_output.name), "X11-1");
 
 	output->win = xcb_generate_id(x11->xcb_conn);