Merge pull request #902 from emersion/various-memory-leaks

Various memory leaks

backend/headless/backend.c

@@ -54,6 +54,7 @@ static void backend_destroy(struct wlr_backend *wlr_backend) {
 
 	wlr_signal_emit_safe(&wlr_backend->events.destroy, backend);
 
+	wlr_renderer_destroy(backend->renderer);
 	wlr_egl_finish(&backend->egl);
 	free(backend);
 }

backend/wayland/backend.c

@@ -88,6 +88,7 @@ static void backend_destroy(struct wlr_backend *wlr_backend) {
 	free(backend->seat_name);
 
 	wl_event_source_remove(backend->remote_display_src);
+	wlr_renderer_destroy(backend->renderer);
 	wlr_egl_finish(&backend->egl);
 	if (backend->seat) {
 		wl_seat_destroy(backend->seat);

backend/x11/backend.c

@@ -239,6 +239,7 @@ static void backend_destroy(struct wlr_backend *backend) {
 	}
 	wl_list_remove(&x11->display_destroy.link);
 
+	wlr_renderer_destroy(x11->renderer);
 	wlr_egl_finish(&x11->egl);
 
 	if (x11->cursor) {

include/wlr/render/interface.h

@@ -11,12 +11,6 @@
 #include <wlr/types/wlr_linux_dmabuf.h>
 #include <wlr/types/wlr_output.h>
 
-struct wlr_renderer_impl;
-
-struct wlr_renderer {
-	const struct wlr_renderer_impl *impl;
-};
-
 struct wlr_renderer_impl {
 	void (*begin)(struct wlr_renderer *renderer, uint32_t width,
 		uint32_t height);

include/wlr/render/wlr_renderer.h

@@ -6,9 +6,15 @@
 #include <wlr/render/wlr_texture.h>
 #include <wlr/types/wlr_box.h>
 
-struct wlr_output;
+struct wlr_renderer_impl;
 
-struct wlr_renderer;
+struct wlr_renderer {
+	const struct wlr_renderer_impl *impl;
+
+	struct {
+		struct wl_signal destroy;
+	} events;
+};
 
 void wlr_renderer_begin(struct wlr_renderer *r, int width, int height);
 void wlr_renderer_end(struct wlr_renderer *r);

include/wlr/types/wlr_compositor.h

@@ -9,13 +9,15 @@ struct wlr_surface;
 struct wlr_subcompositor {
 	struct wl_global *wl_global;
 	struct wl_list wl_resources;
+	struct wl_list subsurface_resources;
 };
 
 struct wlr_compositor {
 	struct wl_global *wl_global;
 	struct wl_list wl_resources;
 	struct wlr_renderer *renderer;
-	struct wl_list surfaces;
+	struct wl_list surface_resources;
+	struct wl_list region_resources;
 
 	struct wlr_subcompositor subcompositor;
 

include/wlr/types/wlr_region.h

@@ -8,8 +8,7 @@ struct wl_resource;
 /*
  * Implements the given resource as region.
  */
-void wlr_region_create(struct wl_client *client, struct wl_resource *res,
+struct wl_resource *wlr_region_create(struct wl_client *client, uint32_t id);
-	uint32_t id);
 
 pixman_region32_t *wlr_region_from_resource(struct wl_resource *resource);
 

include/wlr/types/wlr_surface.h

@@ -93,6 +93,8 @@ struct wlr_surface {
 	// wlr_subsurface::parent_pending_link
 	struct wl_list subsurface_pending_list;
 
+	struct wl_listener renderer_destroy;
+
 	void *data;
 };
 
@@ -121,7 +123,7 @@ bool wlr_surface_has_buffer(struct wlr_surface *surface);
 /**
  * Create the subsurface implementation for this surface.
  */
-void wlr_surface_make_subsurface(struct wlr_surface *surface,
+struct wlr_subsurface *wlr_surface_make_subsurface(struct wlr_surface *surface,
 		struct wlr_surface *parent, uint32_t id);
 
 /**

render/wlr_renderer.c

@@ -5,6 +5,7 @@
 #include <wlr/render/wlr_renderer.h>
 #include <wlr/types/wlr_matrix.h>
 #include <wlr/util/log.h>
+#include "util/signal.h"
 
 void wlr_renderer_init(struct wlr_renderer *renderer,
 		const struct wlr_renderer_impl *impl) {
@@ -18,9 +19,13 @@ void wlr_renderer_init(struct wlr_renderer *renderer,
 	assert(impl->format_supported);
 	assert(impl->texture_from_pixels);
 	renderer->impl = impl;
+
+	wl_signal_init(&renderer->events.destroy);
 }
 
 void wlr_renderer_destroy(struct wlr_renderer *r) {
+	wlr_signal_emit_safe(&r->events.destroy, r);
+
 	if (r && r->impl && r->impl->destroy) {
 		r->impl->destroy(r);
 	} else {

types/wlr_compositor.c

@@ -20,6 +20,15 @@ struct wlr_subsurface *wlr_subsurface_from_surface(
 	return (struct wlr_subsurface *)surface->role_data;
 }
 
+static const struct wl_subcompositor_interface subcompositor_impl;
+
+static struct wlr_subcompositor *subcompositor_from_resource(
+		struct wl_resource *resource) {
+	assert(wl_resource_instance_of(resource, &wl_subcompositor_interface,
+		&subcompositor_impl));
+	return wl_resource_get_user_data(resource);
+}
+
 static void subcompositor_handle_destroy(struct wl_client *client,
 		struct wl_resource *resource) {
 	wl_resource_destroy(resource);
@@ -29,6 +38,8 @@ static void subcompositor_handle_get_subsurface(struct wl_client *client,
 		struct wl_resource *resource, uint32_t id,
 		struct wl_resource *surface_resource,
 		struct wl_resource *parent_resource) {
+	struct wlr_subcompositor *subcompositor =
+		subcompositor_from_resource(resource);
 	struct wlr_surface *surface = wlr_surface_from_resource(surface_resource);
 	struct wlr_surface *parent = wlr_surface_from_resource(parent_resource);
 
@@ -64,14 +75,25 @@ static void subcompositor_handle_get_subsurface(struct wl_client *client,
 		return;
 	}
 
-	wlr_surface_make_subsurface(surface, parent, id);
+	struct wlr_subsurface *subsurface =
+		wlr_surface_make_subsurface(surface, parent, id);
+	if (subsurface == NULL) {
+		return;
+	}
+
+	wl_list_insert(&subcompositor->subsurface_resources,
+		wl_resource_get_link(subsurface->resource));
 }
 
-static const struct wl_subcompositor_interface subcompositor_interface = {
+static const struct wl_subcompositor_interface subcompositor_impl = {
 	.destroy = subcompositor_handle_destroy,
 	.get_subsurface = subcompositor_handle_get_subsurface,
 };
 
+static void subcompositor_resource_destroy(struct wl_resource *resource) {
+	wl_list_remove(wl_resource_get_link(resource));
+}
+
 static void subcompositor_bind(struct wl_client *client, void *data,
 		uint32_t version, uint32_t id) {
 	struct wlr_subcompositor *subcompositor = data;
@@ -81,8 +103,8 @@ static void subcompositor_bind(struct wl_client *client, void *data,
 		wl_client_post_no_memory(client);
 		return;
 	}
-	wl_resource_set_implementation(resource, &subcompositor_interface,
+	wl_resource_set_implementation(resource, &subcompositor_impl,
-		subcompositor, NULL);
+		subcompositor, subcompositor_resource_destroy);
 	wl_list_insert(&subcompositor->wl_resources, wl_resource_get_link(resource));
 }
 
@@ -95,23 +117,33 @@ static void subcompositor_init(struct wlr_subcompositor *subcompositor,
 		return;
 	}
 	wl_list_init(&subcompositor->wl_resources);
+	wl_list_init(&subcompositor->subsurface_resources);
 }
 
 static void subcompositor_finish(struct wlr_subcompositor *subcompositor) {
 	wl_global_destroy(subcompositor->wl_global);
+	struct wl_resource *resource, *tmp;
+	wl_resource_for_each_safe(resource, tmp,
+			&subcompositor->subsurface_resources) {
+		wl_resource_destroy(resource);
+	}
+	wl_resource_for_each_safe(resource, tmp, &subcompositor->wl_resources) {
+		wl_resource_destroy(resource);
+	}
 }
 
 
-static const struct wl_compositor_interface wl_compositor_impl;
+static const struct wl_compositor_interface compositor_impl;
 
 static struct wlr_compositor *compositor_from_resource(
 		struct wl_resource *resource) {
 	assert(wl_resource_instance_of(resource, &wl_compositor_interface,
-		&wl_compositor_impl));
+		&compositor_impl));
 	return wl_resource_get_user_data(resource);
 }
 
-static void destroy_surface_listener(struct wl_listener *listener, void *data) {
+static void compositor_handle_surface_destroy(struct wl_listener *listener,
+		void *data) {
 	wl_list_remove(wl_resource_get_link(data));
 }
 
@@ -134,35 +166,36 @@ static void wl_compositor_create_surface(struct wl_client *client,
 		return;
 	}
 	surface->compositor_data = compositor;
-	surface->compositor_listener.notify = &destroy_surface_listener;
+	surface->compositor_listener.notify = compositor_handle_surface_destroy;
 	wl_resource_add_destroy_listener(surface_resource,
 		&surface->compositor_listener);
 
-	wl_list_insert(&compositor->surfaces,
+	wl_list_insert(&compositor->surface_resources,
 		wl_resource_get_link(surface_resource));
 	wlr_signal_emit_safe(&compositor->events.new_surface, surface);
 }
 
 static void wl_compositor_create_region(struct wl_client *client,
 		struct wl_resource *resource, uint32_t id) {
-	wlr_region_create(client, resource, id);
+	struct wlr_compositor *compositor = compositor_from_resource(resource);
+
+	struct wl_resource *region_resource = wlr_region_create(client, id);
+	if (region_resource == NULL) {
+		wl_resource_post_no_memory(resource);
+		return;
+	}
+
+	wl_list_insert(&compositor->region_resources,
+		wl_resource_get_link(region_resource));
 }
 
-static const struct wl_compositor_interface wl_compositor_impl = {
+static const struct wl_compositor_interface compositor_impl = {
 	.create_surface = wl_compositor_create_surface,
-	.create_region = wl_compositor_create_region
+	.create_region = wl_compositor_create_region,
 };
 
-static void wl_compositor_destroy(struct wl_resource *resource) {
+static void compositor_resource_destroy(struct wl_resource *resource) {
-	struct wlr_compositor *compositor = compositor_from_resource(resource);
+	wl_list_remove(wl_resource_get_link(resource));
-	struct wl_resource *_resource = NULL;
-	wl_resource_for_each(_resource, &compositor->wl_resources) {
-		if (_resource == resource) {
-			struct wl_list *link = wl_resource_get_link(_resource);
-			wl_list_remove(link);
-			break;
-		}
-	}
 }
 
 static void wl_compositor_bind(struct wl_client *wl_client, void *data,
@@ -176,8 +209,8 @@ static void wl_compositor_bind(struct wl_client *wl_client, void *data,
 		wl_client_post_no_memory(wl_client);
 		return;
 	}
-	wl_resource_set_implementation(resource, &wl_compositor_impl,
+	wl_resource_set_implementation(resource, &compositor_impl,
-		compositor, wl_compositor_destroy);
+		compositor, compositor_resource_destroy);
 	wl_list_insert(&compositor->wl_resources, wl_resource_get_link(resource));
 }
 
@@ -189,6 +222,16 @@ void wlr_compositor_destroy(struct wlr_compositor *compositor) {
 	subcompositor_finish(&compositor->subcompositor);
 	wl_list_remove(&compositor->display_destroy.link);
 	wl_global_destroy(compositor->wl_global);
+	struct wl_resource *resource, *tmp;
+	wl_resource_for_each_safe(resource, tmp, &compositor->surface_resources) {
+		wl_resource_destroy(resource);
+	}
+	wl_resource_for_each_safe(resource, tmp, &compositor->region_resources) {
+		wl_resource_destroy(resource);
+	}
+	wl_resource_for_each_safe(resource, tmp, &compositor->wl_resources) {
+		wl_resource_destroy(resource);
+	}
 	free(compositor);
 }
 
@@ -218,7 +261,8 @@ struct wlr_compositor *wlr_compositor_create(struct wl_display *display,
 	compositor->renderer = renderer;
 
 	wl_list_init(&compositor->wl_resources);
-	wl_list_init(&compositor->surfaces);
+	wl_list_init(&compositor->surface_resources);
+	wl_list_init(&compositor->region_resources);
 	wl_signal_init(&compositor->events.new_surface);
 	wl_signal_init(&compositor->events.destroy);
 

types/wlr_region.c

@@ -32,18 +32,19 @@ static const struct wl_region_interface region_impl = {
 	.subtract = region_subtract,
 };
 
-static void destroy_region(struct wl_resource *resource) {
+static void region_handle_resource_destroy(struct wl_resource *resource) {
 	pixman_region32_t *reg = wlr_region_from_resource(resource);
 	pixman_region32_fini(reg);
 	free(reg);
+
+	// Set by wlr_compositor
+	wl_list_remove(wl_resource_get_link(resource));
 }
 
-void wlr_region_create(struct wl_client *client, struct wl_resource *res,
+struct wl_resource *wlr_region_create(struct wl_client *client, uint32_t id) {
-		uint32_t id) {
 	pixman_region32_t *region = calloc(1, sizeof(pixman_region32_t));
 	if (region == NULL) {
-		wl_resource_post_no_memory(res);
+		return NULL;
-		return;
 	}
 
 	pixman_region32_init(region);
@@ -52,11 +53,11 @@ void wlr_region_create(struct wl_client *client, struct wl_resource *res,
 		&wl_region_interface, 1, id);
 	if (region_resource == NULL) {
 		free(region);
-		wl_resource_post_no_memory(res);
+		return NULL;
-		return;
 	}
 	wl_resource_set_implementation(region_resource, &region_impl, region,
-		destroy_region);
+		region_handle_resource_destroy);
+	return region_resource;
 }
 
 pixman_region32_t *wlr_region_from_resource(struct wl_resource *resource) {

types/wlr_surface.c

@@ -622,7 +622,7 @@ static void subsurface_destroy(struct wlr_subsurface *subsurface) {
 	free(subsurface);
 }
 
-static void destroy_surface(struct wl_resource *resource) {
+static void surface_handle_resource_destroy(struct wl_resource *resource) {
 	struct wlr_surface *surface = wlr_surface_from_resource(resource);
 
 	wlr_signal_emit_safe(&surface->events.destroy, surface);
@@ -634,6 +634,13 @@ static void destroy_surface(struct wl_resource *resource) {
 	free(surface);
 }
 
+static void surface_handle_renderer_destroy(struct wl_listener *listener,
+		void *data) {
+	struct wlr_surface *surface =
+		wl_container_of(listener, surface, renderer_destroy);
+	wl_resource_destroy(surface->resource);
+}
+
 struct wlr_surface *wlr_surface_create(struct wl_resource *res,
 		struct wlr_renderer *renderer) {
 	struct wlr_surface *surface = calloc(1, sizeof(struct wlr_surface));
@@ -654,7 +661,11 @@ struct wlr_surface *wlr_surface_create(struct wl_resource *res,
 	wl_list_init(&surface->subsurfaces);
 	wl_list_init(&surface->subsurface_pending_list);
 	wl_resource_set_implementation(res, &surface_interface,
-		surface, destroy_surface);
+		surface, surface_handle_resource_destroy);
+
+	wl_signal_add(&renderer->events.destroy, &surface->renderer_destroy);
+	surface->renderer_destroy.notify = surface_handle_renderer_destroy;
+
 	return surface;
 }
 
@@ -827,7 +838,7 @@ static void subsurface_handle_surface_destroy(struct wl_listener *listener,
 	subsurface_destroy(subsurface);
 }
 
-void wlr_surface_make_subsurface(struct wlr_surface *surface,
+struct wlr_subsurface *wlr_surface_make_subsurface(struct wlr_surface *surface,
 		struct wlr_surface *parent, uint32_t id) {
 	struct wl_client *client = wl_resource_get_client(surface->resource);
 
@@ -835,13 +846,13 @@ void wlr_surface_make_subsurface(struct wlr_surface *surface,
 		calloc(1, sizeof(struct wlr_subsurface));
 	if (!subsurface) {
 		wl_client_post_no_memory(client);
-		return;
+		return NULL;
 	}
 	subsurface->cached = surface_state_create();
 	if (subsurface->cached == NULL) {
 		free(subsurface);
 		wl_client_post_no_memory(client);
-		return;
+		return NULL;
 	}
 	subsurface->synchronized = true;
 	subsurface->surface = surface;
@@ -863,7 +874,7 @@ void wlr_surface_make_subsurface(struct wlr_surface *surface,
 		surface_state_destroy(subsurface->cached);
 		free(subsurface);
 		wl_client_post_no_memory(client);
-		return;
+		return NULL;
 	}
 
 	wl_resource_set_implementation(subsurface->resource,
@@ -873,6 +884,8 @@ void wlr_surface_make_subsurface(struct wlr_surface *surface,
 	surface->role_data = subsurface;
 
 	wlr_signal_emit_safe(&parent->events.new_subsurface, subsurface);
+
+	return subsurface;
 }