diff --git a/include/labwc.h b/include/labwc.h
index ed858e64..a47b3a39 100644
--- a/include/labwc.h
+++ b/include/labwc.h
@@ -314,7 +314,7 @@ struct server {
 	struct wlr_gamma_control_manager_v1 *gamma_control_manager_v1;
 	struct wl_listener gamma_control_set_gamma;
 
-	struct session_lock *session_lock;
+	struct session_lock_manager *session_lock_manager;
 
 	struct wlr_foreign_toplevel_manager_v1 *foreign_toplevel_manager;
 
diff --git a/include/session-lock.h b/include/session-lock.h
index d43003c7..0a11e7b4 100644
--- a/include/session-lock.h
+++ b/include/session-lock.h
@@ -7,20 +7,30 @@
 struct output;
 struct server;
 
-struct session_lock {
-	struct wlr_session_lock_v1 *lock;
+struct session_lock_manager {
+	struct server *server;
+	struct wlr_session_lock_manager_v1 *wlr_manager;
 	struct wlr_surface *focused;
-	bool abandoned;
+	/*
+	 * When not locked: lock=NULL, locked=false
+	 * When locked: lock=non-NULL, locked=true
+	 * When lock is destroyed without being unlocked: lock=NULL, locked=true
+	 */
+	struct wlr_session_lock_v1 *lock;
+	bool locked;
 
 	struct wl_list session_lock_outputs;
 
-	struct wl_listener new_surface;
-	struct wl_listener unlock;
+	struct wl_listener new_lock;
 	struct wl_listener destroy;
+
+	struct wl_listener lock_new_surface;
+	struct wl_listener lock_unlock;
+	struct wl_listener lock_destroy;
 };
 
 void session_lock_init(struct server *server);
-void session_lock_output_create(struct session_lock *lock, struct output *output);
-void session_lock_update_for_layout_change(void);
+void session_lock_output_create(struct session_lock_manager *manager, struct output *output);
+void session_lock_update_for_layout_change(struct server *server);
 
 #endif /* LABWC_SESSION_LOCK_H */
diff --git a/src/input/keyboard.c b/src/input/keyboard.c
index 59761681..1d1467ce 100644
--- a/src/input/keyboard.c
+++ b/src/input/keyboard.c
@@ -424,7 +424,7 @@ handle_compositor_keybindings(struct keyboard *keyboard,
 	if (seat->active_client_while_inhibited) {
 		return false;
 	}
-	if (seat->server->session_lock) {
+	if (seat->server->session_lock_manager->locked) {
 		return false;
 	}
 
diff --git a/src/output.c b/src/output.c
index 67d8de77..bb2b9760 100644
--- a/src/output.c
+++ b/src/output.c
@@ -395,8 +395,8 @@ new_output_notify(struct wl_listener *listener, void *data)
 	/* Create regions from config */
 	regions_reconfigure_output(output);
 
-	if (server->session_lock) {
-		session_lock_output_create(server->session_lock, output);
+	if (server->session_lock_manager->locked) {
+		session_lock_output_create(server->session_lock_manager, output);
 	}
 
 	server->pending_output_layout_change--;
@@ -442,7 +442,7 @@ static void
 output_update_for_layout_change(struct server *server)
 {
 	output_update_all_usable_areas(server, /*layout_changed*/ true);
-	session_lock_update_for_layout_change();
+	session_lock_update_for_layout_change(server);
 
 	/*
 	 * "Move" each wlr_output_cursor (in per-output coordinates) to
diff --git a/src/seat.c b/src/seat.c
index 4ba5fa30..e850694c 100644
--- a/src/seat.c
+++ b/src/seat.c
@@ -621,7 +621,7 @@ seat_focus(struct seat *seat, struct wlr_surface *surface, bool is_lock_surface)
 	 * lock screen may lose focus and become impossible to unlock.
 	 */
 	struct server *server = seat->server;
-	if (server->session_lock && !is_lock_surface) {
+	if (server->session_lock_manager->locked && !is_lock_surface) {
 		return;
 	}
 
diff --git a/src/session-lock.c b/src/session-lock.c
index ba0d407a..11f0c587 100644
--- a/src/session-lock.c
+++ b/src/session-lock.c
@@ -4,20 +4,14 @@
 #include "common/mem.h"
 #include "labwc.h"
 
-static struct wl_listener new_lock;
-static struct wl_listener manager_destroy;
-static struct wlr_session_lock_manager_v1 *wlr_session_lock_manager;
-
-static struct server *g_server;
-
 struct session_lock_output {
 	struct wlr_scene_tree *tree;
 	struct wlr_scene_rect *background;
-	struct session_lock *lock;
+	struct session_lock_manager *manager;
 	struct output *output;
 	struct wlr_session_lock_surface_v1 *surface;
 
-	struct wl_list link; /* session_lock.outputs */
+	struct wl_list link; /* session_lock_manager.outputs */
 
 	struct wl_listener destroy;
 	struct wl_listener commit;
@@ -26,39 +20,40 @@ struct session_lock_output {
 };
 
 static void
-focus_surface(struct session_lock *lock, struct wlr_surface *focused)
+focus_surface(struct session_lock_manager *manager, struct wlr_surface *focused)
 {
-	lock->focused = focused;
-	seat_focus_lock_surface(&g_server->seat, focused);
+	manager->focused = focused;
+	seat_focus_lock_surface(&manager->server->seat, focused);
 }
 
 static void
 refocus_output(struct session_lock_output *output)
 {
 	/* Try to focus another session-lock surface */
-	if (output->lock->focused != output->surface->surface) {
+	if (output->manager->focused != output->surface->surface) {
 		return;
 	}
 
 	struct session_lock_output *iter;
-	wl_list_for_each(iter, &output->lock->session_lock_outputs, link) {
+	wl_list_for_each(iter, &output->manager->session_lock_outputs, link) {
 		if (iter == output || !iter->surface || !iter->surface->surface) {
 			continue;
 		}
 		if (iter->surface->surface->mapped) {
-			focus_surface(output->lock, iter->surface->surface);
+			focus_surface(output->manager, iter->surface->surface);
 			return;
 		}
 	}
-	focus_surface(output->lock, NULL);
+	focus_surface(output->manager, NULL);
 }
 
 static void
 handle_surface_map(struct wl_listener *listener, void *data)
 {
-	struct session_lock_output *surf = wl_container_of(listener, surf, surface_map);
-	if (!surf->lock->focused) {
-		focus_surface(surf->lock, surf->surface->surface);
+	struct session_lock_output *output =
+		wl_container_of(listener, output, surface_map);
+	if (!output->manager->focused) {
+		focus_surface(output->manager, output->surface->surface);
 	}
 }
 
@@ -79,21 +74,24 @@ static void
 lock_output_reconfigure(struct session_lock_output *output)
 {
 	struct wlr_box box;
-	wlr_output_layout_get_box(g_server->output_layout, output->output->wlr_output, &box);
+	wlr_output_layout_get_box(output->manager->server->output_layout,
+		output->output->wlr_output, &box);
 	wlr_scene_rect_set_size(output->background, box.width, box.height);
 	if (output->surface) {
-		wlr_session_lock_surface_v1_configure(output->surface, box.width, box.height);
+		wlr_session_lock_surface_v1_configure(
+			output->surface, box.width, box.height);
 	}
 }
 
 static void
 handle_new_surface(struct wl_listener *listener, void *data)
 {
-	struct session_lock *lock = wl_container_of(listener, lock, new_surface);
+	struct session_lock_manager *manager =
+		wl_container_of(listener, manager, lock_new_surface);
 	struct wlr_session_lock_surface_v1 *lock_surface = data;
 	struct output *output = lock_surface->output->data;
 	struct session_lock_output *lock_output;
-	wl_list_for_each(lock_output, &lock->session_lock_outputs, link) {
+	wl_list_for_each(lock_output, &manager->session_lock_outputs, link) {
 		if (lock_output->output == output) {
 			goto found_lock_output;
 		}
@@ -130,14 +128,14 @@ session_lock_output_destroy(struct session_lock_output *output)
 }
 
 static void
-handle_destroy(struct wl_listener *listener, void *data)
+handle_output_destroy(struct wl_listener *listener, void *data)
 {
 	struct session_lock_output *output = wl_container_of(listener, output, destroy);
 	session_lock_output_destroy(output);
 }
 
 static void
-handle_commit(struct wl_listener *listener, void *data)
+handle_output_commit(struct wl_listener *listener, void *data)
 {
 	struct wlr_output_event_commit *event = data;
 	struct session_lock_output *output = wl_container_of(listener, output, commit);
@@ -152,18 +150,15 @@ static void
 align_session_lock_tree(struct output *output)
 {
 	struct wlr_box box;
-	wlr_output_layout_get_box(g_server->output_layout, output->wlr_output, &box);
+	wlr_output_layout_get_box(output->server->output_layout,
+		output->wlr_output, &box);
 	wlr_scene_node_set_position(&output->session_lock_tree->node, box.x, box.y);
 }
 
 void
-session_lock_output_create(struct session_lock *lock, struct output *output)
+session_lock_output_create(struct session_lock_manager *manager, struct output *output)
 {
 	struct session_lock_output *lock_output = znew(*lock_output);
-	if (!lock_output) {
-		wlr_log(WLR_ERROR, "session-lock: out of memory");
-		goto exit_session;
-	}
 
 	struct wlr_scene_tree *tree = wlr_scene_tree_create(output->session_lock_tree);
 	if (!tree) {
@@ -191,17 +186,17 @@ session_lock_output_create(struct session_lock *lock, struct output *output)
 	lock_output->output = output;
 	lock_output->tree = tree;
 	lock_output->background = background;
-	lock_output->lock = lock;
+	lock_output->manager = manager;
 
-	lock_output->destroy.notify = handle_destroy;
+	lock_output->destroy.notify = handle_output_destroy;
 	wl_signal_add(&tree->node.events.destroy, &lock_output->destroy);
 
-	lock_output->commit.notify = handle_commit;
+	lock_output->commit.notify = handle_output_commit;
 	wl_signal_add(&output->wlr_output->events.commit, &lock_output->commit);
 
 	lock_output_reconfigure(lock_output);
 
-	wl_list_insert(&lock->session_lock_outputs, &lock_output->link);
+	wl_list_insert(&manager->session_lock_outputs, &lock_output->link);
 	return;
 
 exit_session:
@@ -211,130 +206,126 @@ exit_session:
 }
 
 static void
-session_lock_destroy(struct session_lock *lock)
+session_lock_destroy(struct session_lock_manager *manager)
 {
 	struct session_lock_output *lock_output, *next;
-	wl_list_for_each_safe(lock_output, next, &lock->session_lock_outputs, link) {
+	wl_list_for_each_safe(lock_output, next, &manager->session_lock_outputs, link) {
 		wlr_scene_node_destroy(&lock_output->tree->node);
 	}
-	if (g_server->session_lock == lock) {
-		g_server->session_lock = NULL;
+	if (manager->lock) {
+		wl_list_remove(&manager->lock_destroy.link);
+		wl_list_remove(&manager->lock_unlock.link);
+		wl_list_remove(&manager->lock_new_surface.link);
 	}
-	if (!lock->abandoned) {
-		wl_list_remove(&lock->destroy.link);
-		wl_list_remove(&lock->unlock.link);
-		wl_list_remove(&lock->new_surface.link);
-	}
-	free(lock);
+	manager->lock = NULL;
 }
 
 static void
-handle_unlock(struct wl_listener *listener, void *data)
+handle_lock_unlock(struct wl_listener *listener, void *data)
 {
-	struct session_lock *lock = wl_container_of(listener, lock, unlock);
-	session_lock_destroy(lock);
-	desktop_focus_topmost_view(g_server);
+	struct session_lock_manager *manager =
+		wl_container_of(listener, manager, lock_unlock);
+	session_lock_destroy(manager);
+	manager->locked = false;
+	desktop_focus_topmost_view(manager->server);
 }
 
 static void
-handle_session_lock_destroy(struct wl_listener *listener, void *data)
+handle_lock_destroy(struct wl_listener *listener, void *data)
 {
-	struct session_lock *lock = wl_container_of(listener, lock, destroy);
+	struct session_lock_manager *manager =
+		wl_container_of(listener, manager, lock_destroy);
 
 	float *black = (float[4]) { 0.f, 0.f, 0.f, 1.f };
 	struct session_lock_output *lock_output;
-	wl_list_for_each(lock_output, &lock->session_lock_outputs, link) {
+	wl_list_for_each(lock_output, &manager->session_lock_outputs, link) {
 		wlr_scene_rect_set_color(lock_output->background, black);
 	}
 
-	lock->abandoned = true;
-	wl_list_remove(&lock->destroy.link);
-	wl_list_remove(&lock->unlock.link);
-	wl_list_remove(&lock->new_surface.link);
+	wl_list_remove(&manager->lock_destroy.link);
+	wl_list_remove(&manager->lock_unlock.link);
+	wl_list_remove(&manager->lock_new_surface.link);
 }
 
 static void
 handle_new_session_lock(struct wl_listener *listener, void *data)
 {
+	struct session_lock_manager *manager =
+		wl_container_of(listener, manager, new_lock);
 	struct wlr_session_lock_v1 *lock = data;
 
-	/* One already exists */
-	if (g_server->session_lock) {
-		if (g_server->session_lock->abandoned) {
-			wlr_log(WLR_INFO, "replacing abandoned lock");
-			session_lock_destroy(g_server->session_lock);
-		} else {
-			wlr_log(WLR_ERROR, "session already locked");
-			wlr_session_lock_v1_destroy(lock);
-			return;
-		}
-	}
-
-	struct session_lock *session_lock = znew(*session_lock);
-	if (!session_lock) {
-		wlr_log(WLR_ERROR, "session-lock: out of memory");
+	if (manager->lock) {
+		wlr_log(WLR_ERROR, "session already locked");
 		wlr_session_lock_v1_destroy(lock);
 		return;
 	}
+	if (manager->locked) {
+		wlr_log(WLR_INFO, "replacing abandoned lock");
+		session_lock_destroy(manager);
+	}
+	assert(wl_list_empty(&manager->session_lock_outputs));
 
-	wl_list_init(&session_lock->session_lock_outputs);
 	struct output *output;
-	wl_list_for_each(output, &g_server->outputs, link) {
-		session_lock_output_create(session_lock, output);
+	wl_list_for_each(output, &manager->server->outputs, link) {
+		session_lock_output_create(manager, output);
 	}
 
-	session_lock->new_surface.notify = handle_new_surface;
-	wl_signal_add(&lock->events.new_surface, &session_lock->new_surface);
+	manager->lock_new_surface.notify = handle_new_surface;
+	wl_signal_add(&lock->events.new_surface, &manager->lock_new_surface);
 
-	session_lock->unlock.notify = handle_unlock;
-	wl_signal_add(&lock->events.unlock, &session_lock->unlock);
+	manager->lock_unlock.notify = handle_lock_unlock;
+	wl_signal_add(&lock->events.unlock, &manager->lock_unlock);
 
-	session_lock->destroy.notify = handle_session_lock_destroy;
-	wl_signal_add(&lock->events.destroy, &session_lock->destroy);
+	manager->lock_destroy.notify = handle_lock_destroy;
+	wl_signal_add(&lock->events.destroy, &manager->lock_destroy);
 
+	manager->locked = true;
 	wlr_session_lock_v1_send_locked(lock);
-	g_server->session_lock = session_lock;
 }
 
 static void
 handle_manager_destroy(struct wl_listener *listener, void *data)
 {
-	if (g_server->session_lock) {
-		session_lock_destroy(g_server->session_lock);
-	}
-	wl_list_remove(&new_lock.link);
-	wl_list_remove(&manager_destroy.link);
-	wlr_session_lock_manager = NULL;
+	struct session_lock_manager *manager =
+		wl_container_of(listener, manager, destroy);
+	session_lock_destroy(manager);
+	wl_list_remove(&manager->new_lock.link);
+	wl_list_remove(&manager->destroy.link);
+	manager->server->session_lock_manager = NULL;
+	free(manager);
 }
 
 void
 session_lock_init(struct server *server)
 {
-	g_server = server;
-	wlr_session_lock_manager = wlr_session_lock_manager_v1_create(server->wl_display);
+	struct session_lock_manager *manager = znew(*manager);
+	server->session_lock_manager = manager;
+	manager->server = server;
+	manager->wlr_manager = wlr_session_lock_manager_v1_create(server->wl_display);
+	wl_list_init(&manager->session_lock_outputs);
 
-	new_lock.notify = handle_new_session_lock;
-	wl_signal_add(&wlr_session_lock_manager->events.new_lock, &new_lock);
+	manager->new_lock.notify = handle_new_session_lock;
+	wl_signal_add(&manager->wlr_manager->events.new_lock, &manager->new_lock);
 
-	manager_destroy.notify = handle_manager_destroy;
-	wl_signal_add(&wlr_session_lock_manager->events.destroy, &manager_destroy);
+	manager->destroy.notify = handle_manager_destroy;
+	wl_signal_add(&manager->wlr_manager->events.destroy, &manager->destroy);
 }
 
 void
-session_lock_update_for_layout_change(void)
+session_lock_update_for_layout_change(struct server *server)
 {
-	if (!g_server->session_lock) {
+	if (!server->session_lock_manager->locked) {
 		return;
 	}
 
 	struct output *output;
-	wl_list_for_each(output, &g_server->outputs, link) {
+	wl_list_for_each(output, &server->outputs, link) {
 		align_session_lock_tree(output);
 	}
 
-	struct session_lock *lock = g_server->session_lock;
+	struct session_lock_manager *manager = server->session_lock_manager;
 	struct session_lock_output *lock_output;
-	wl_list_for_each(lock_output, &lock->session_lock_outputs, link) {
+	wl_list_for_each(lock_output, &manager->session_lock_outputs, link) {
 		lock_output_reconfigure(lock_output);
 	}
 }