diff --git a/compositor/text-backend.c b/compositor/text-backend.c
index 5424242..4b2e854 100644
--- a/compositor/text-backend.c
+++ b/compositor/text-backend.c
@@ -452,6 +452,7 @@
 			     struct text_input_manager,
 			     destroy_listener);
 
+	wl_list_remove(&text_input_manager->destroy_listener.link);
 	wl_global_destroy(text_input_manager->text_input_manager_global);
 
 	free(text_input_manager);
@@ -1060,6 +1061,8 @@
 WL_EXPORT void
 text_backend_destroy(struct text_backend *text_backend)
 {
+	wl_list_remove(&text_backend->seat_created_listener.link);
+
 	if (text_backend->input_method.client) {
 		/* disable respawn */
 		wl_list_remove(&text_backend->client_listener.link);
diff --git a/compositor/weston-screenshooter.c b/compositor/weston-screenshooter.c
index 0994cb4..981aff8 100644
--- a/compositor/weston-screenshooter.c
+++ b/compositor/weston-screenshooter.c
@@ -162,6 +162,8 @@
 	struct screenshooter *shooter =
 		container_of(listener, struct screenshooter, destroy_listener);
 
+	wl_list_remove(&shooter->destroy_listener.link);
+
 	wl_global_destroy(shooter->global);
 	free(shooter);
 }
diff --git a/desktop-shell/shell.c b/desktop-shell/shell.c
index ea3c453..9a44715 100644
--- a/desktop-shell/shell.c
+++ b/desktop-shell/shell.c
@@ -4911,6 +4911,7 @@
 		wl_client_destroy(shell->child.client);
 	}
 
+	wl_list_remove(&shell->destroy_listener.link);
 	wl_list_remove(&shell->idle_listener.link);
 	wl_list_remove(&shell->wake_listener.link);
 	wl_list_remove(&shell->transform_listener.link);
