tree-wide: use -EBADF for fd initialization

[thirdparty/systemd.git] / src / login / logind-dbus.c

diff --git a/src/login/logind-dbus.c b/src/login/logind-dbus.c
index a426842bbb3aa9faf8456465d958626662af72e0..7024bba82daddce1d364f2f34a42a41174e4215c 100644 (file)
--- a/src/login/logind-dbus.c
+++ b/src/login/logind-dbus.c
@@ -65,7 +65,7 @@
  * to store arbitrary amounts either. As we are not stingy here, we
  * allow 4k.
  */
-#define WALL_MESSAGE_MAX 4096
+#define WALL_MESSAGE_MAX 4096U
 
 #define SHUTDOWN_SCHEDULE_FILE "/run/systemd/shutdown/scheduled"
 
@@ -268,11 +268,10 @@ static int property_get_idle_hint(
                 void *userdata,
                 sd_bus_error *error) {
 
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
 
         assert(bus);
         assert(reply);
-        assert(m);
 
         return sd_bus_message_append(reply, "b", manager_get_idle_hint(m, NULL) > 0);
 }
@@ -286,12 +285,11 @@ static int property_get_idle_since_hint(
                 void *userdata,
                 sd_bus_error *error) {
 
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         dual_timestamp t = DUAL_TIMESTAMP_NULL;
 
         assert(bus);
         assert(reply);
-        assert(m);
 
         manager_get_idle_hint(m, &t);
 
@@ -307,12 +305,11 @@ static int property_get_inhibited(
                 void *userdata,
                 sd_bus_error *error) {
 
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         InhibitWhat w;
 
         assert(bus);
         assert(reply);
-        assert(m);
 
         w = manager_inhibit_what(m, streq(property, "BlockInhibited") ? INHIBIT_BLOCK : INHIBIT_DELAY);
 
@@ -328,12 +325,11 @@ static int property_get_preparing(
                 void *userdata,
                 sd_bus_error *error) {
 
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         bool b = false;
 
         assert(bus);
         assert(reply);
-        assert(m);
 
         if (m->delayed_action) {
                 if (streq(property, "PreparingForShutdown"))
@@ -354,12 +350,11 @@ static int property_get_scheduled_shutdown(
                 void *userdata,
                 sd_bus_error *error) {
 
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         int r;
 
         assert(bus);
         assert(reply);
-        assert(m);
 
         r = sd_bus_message_open_container(reply, 'r', "st");
         if (r < 0)
@@ -377,19 +372,18 @@ static int property_get_scheduled_shutdown(
 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_handle_action, handle_action, HandleAction);
 static BUS_DEFINE_PROPERTY_GET(property_get_docked, "b", Manager, manager_is_docked_or_external_displays);
 static BUS_DEFINE_PROPERTY_GET(property_get_lid_closed, "b", Manager, manager_is_lid_closed);
-static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_on_external_power, "b", manager_is_on_external_power);
+static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_on_external_power, "b", manager_is_on_external_power());
 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_compat_user_tasks_max, "t", CGROUP_LIMIT_MAX);
 static BUS_DEFINE_PROPERTY_GET_REF(property_get_hashmap_size, "t", Hashmap *, (uint64_t) hashmap_size);
 
 static int method_get_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         _cleanup_free_ char *p = NULL;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         const char *name;
         Session *session;
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "s", &name);
         if (r < 0)
@@ -412,12 +406,11 @@ static int method_get_session(sd_bus_message *message, void *userdata, sd_bus_er
 static int method_get_session_by_pid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         _cleanup_free_ char *p = NULL;
         Session *session = NULL;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         pid_t pid;
         int r;
 
         assert(message);
-        assert(m);
 
         assert_cc(sizeof(pid_t) == sizeof(uint32_t));
 
@@ -450,13 +443,12 @@ static int method_get_session_by_pid(sd_bus_message *message, void *userdata, sd
 
 static int method_get_user(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         _cleanup_free_ char *p = NULL;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         uint32_t uid;
         User *user;
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "u", &uid);
         if (r < 0)
@@ -475,13 +467,12 @@ static int method_get_user(sd_bus_message *message, void *userdata, sd_bus_error
 
 static int method_get_user_by_pid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         _cleanup_free_ char *p = NULL;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         User *user = NULL;
         pid_t pid;
         int r;
 
         assert(message);
-        assert(m);
 
         assert_cc(sizeof(pid_t) == sizeof(uint32_t));
 
@@ -514,13 +505,12 @@ static int method_get_user_by_pid(sd_bus_message *message, void *userdata, sd_bu
 
 static int method_get_seat(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         _cleanup_free_ char *p = NULL;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         const char *name;
         Seat *seat;
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "s", &name);
         if (r < 0)
@@ -539,12 +529,11 @@ static int method_get_seat(sd_bus_message *message, void *userdata, sd_bus_error
 
 static int method_list_sessions(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         Session *session;
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_new_method_return(message, &reply);
         if (r < 0)
@@ -580,12 +569,11 @@ static int method_list_sessions(sd_bus_message *message, void *userdata, sd_bus_
 
 static int method_list_users(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         User *user;
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_new_method_return(message, &reply);
         if (r < 0)
@@ -619,12 +607,11 @@ static int method_list_users(sd_bus_message *message, void *userdata, sd_bus_err
 
 static int method_list_seats(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         Seat *seat;
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_new_method_return(message, &reply);
         if (r < 0)
@@ -655,12 +642,11 @@ static int method_list_seats(sd_bus_message *message, void *userdata, sd_bus_err
 
 static int method_list_inhibitors(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         Inhibitor *inhibitor;
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_new_method_return(message, &reply);
         if (r < 0)
@@ -695,7 +681,7 @@ static int method_create_session(sd_bus_message *message, void *userdata, sd_bus
         _cleanup_free_ char *id = NULL;
         Session *session = NULL;
         uint32_t audit_id = 0;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         User *user = NULL;
         Seat *seat = NULL;
         pid_t leader;
@@ -707,7 +693,6 @@ static int method_create_session(sd_bus_message *message, void *userdata, sd_bus
         int r;
 
         assert(message);
-        assert(m);
 
         assert_cc(sizeof(pid_t) == sizeof(uint32_t));
         assert_cc(sizeof(uid_t) == sizeof(uint32_t));
@@ -999,13 +984,12 @@ fail:
 }
 
 static int method_release_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         Session *session;
         const char *name;
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "s", &name);
         if (r < 0)
@@ -1023,13 +1007,12 @@ static int method_release_session(sd_bus_message *message, void *userdata, sd_bu
 }
 
 static int method_activate_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         Session *session;
         const char *name;
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "s", &name);
         if (r < 0)
@@ -1046,13 +1029,12 @@ static int method_activate_session(sd_bus_message *message, void *userdata, sd_b
 
 static int method_activate_session_on_seat(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         const char *session_name, *seat_name;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         Session *session;
         Seat *seat;
         int r;
 
         assert(message);
-        assert(m);
 
         /* Same as ActivateSession() but refuses to work if the seat doesn't match */
 
@@ -1086,13 +1068,12 @@ static int method_activate_session_on_seat(sd_bus_message *message, void *userda
 }
 
 static int method_lock_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         Session *session;
         const char *name;
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "s", &name);
         if (r < 0)
@@ -1106,11 +1087,10 @@ static int method_lock_session(sd_bus_message *message, void *userdata, sd_bus_e
 }
 
 static int method_lock_sessions(sd_bus_message *message, void *userdata, sd_bus_error *error) {
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         int r;
 
         assert(message);
-        assert(m);
 
         r = bus_verify_polkit_async(
                         message,
@@ -1135,12 +1115,11 @@ static int method_lock_sessions(sd_bus_message *message, void *userdata, sd_bus_
 
 static int method_kill_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         const char *name;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         Session *session;
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "s", &name);
         if (r < 0)
@@ -1154,13 +1133,12 @@ static int method_kill_session(sd_bus_message *message, void *userdata, sd_bus_e
 }
 
 static int method_kill_user(sd_bus_message *message, void *userdata, sd_bus_error *error) {
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         uint32_t uid;
         User *user;
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "u", &uid);
         if (r < 0)
@@ -1174,13 +1152,12 @@ static int method_kill_user(sd_bus_message *message, void *userdata, sd_bus_erro
 }
 
 static int method_terminate_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         const char *name;
         Session *session;
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "s", &name);
         if (r < 0)
@@ -1194,13 +1171,12 @@ static int method_terminate_session(sd_bus_message *message, void *userdata, sd_
 }
 
 static int method_terminate_user(sd_bus_message *message, void *userdata, sd_bus_error *error) {
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         uint32_t uid;
         User *user;
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "u", &uid);
         if (r < 0)
@@ -1214,13 +1190,12 @@ static int method_terminate_user(sd_bus_message *message, void *userdata, sd_bus
 }
 
 static int method_terminate_seat(sd_bus_message *message, void *userdata, sd_bus_error *error) {
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         const char *name;
         Seat *seat;
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "s", &name);
         if (r < 0)
@@ -1236,14 +1211,13 @@ static int method_terminate_seat(sd_bus_message *message, void *userdata, sd_bus
 static int method_set_user_linger(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
         _cleanup_free_ char *cc = NULL;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         int r, b, interactive;
         struct passwd *pw;
         const char *path;
         uint32_t uid, auth_uid;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "ubb", &uid, &b, &interactive);
         if (r < 0)
@@ -1414,11 +1388,10 @@ static int flush_devices(Manager *m) {
 
 static int method_attach_device(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         const char *sysfs, *seat;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         int interactive, r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "ssb", &seat, &sysfs, &interactive);
         if (r < 0)
@@ -1463,11 +1436,10 @@ static int method_attach_device(sd_bus_message *message, void *userdata, sd_bus_
 }
 
 static int method_flush_devices(sd_bus_message *message, void *userdata, sd_bus_error *error) {
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         int interactive, r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "b", &interactive);
         if (r < 0)
@@ -1532,10 +1504,9 @@ static int bus_manager_log_shutdown(
 }
 
 static int lid_switch_ignore_handler(sd_event_source *e, uint64_t usec, void *userdata) {
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
 
         assert(e);
-        assert(m);
 
         m->lid_switch_ignore_event_source = sd_event_source_unref(m->lid_switch_ignore_event_source);
         return 0;
@@ -1678,9 +1649,8 @@ static int manager_inhibit_timeout_handler(
                         uint64_t usec,
                         void *userdata) {
 
-        Manager *manager = userdata;
+        Manager *manager = ASSERT_PTR(userdata);
 
-        assert(manager);
         assert(manager->inhibit_timeout_source == s);
 
         return manager_dispatch_delayed(manager, true);
@@ -2191,11 +2161,9 @@ static int manager_scheduled_shutdown_handler(
 
         const HandleActionData *a = NULL;
         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         int r;
 
-        assert(m);
-
         a = m->scheduled_shutdown_action;
         assert(a);
 
@@ -2233,7 +2201,7 @@ error:
 }
 
 static int method_schedule_shutdown(sd_bus_message *message, void *userdata, sd_bus_error *error) {
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         HandleAction handle;
         const HandleActionData *a;
         uint64_t elapse;
@@ -2241,7 +2209,6 @@ static int method_schedule_shutdown(sd_bus_message *message, void *userdata, sd_
         int r;
         bool dry_run = false;
 
-        assert(m);
         assert(message);
 
         r = sd_bus_message_read(message, "st", &type, &elapse);
@@ -2314,12 +2281,11 @@ fail:
 }
 
 static int method_cancel_scheduled_shutdown(sd_bus_message *message, void *userdata, sd_bus_error *error) {
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         const HandleActionData *a;
         bool cancelled;
         int r;
 
-        assert(m);
         assert(message);
 
         cancelled = m->scheduled_shutdown_action
@@ -2361,7 +2327,7 @@ static int method_cancel_scheduled_shutdown(sd_bus_message *message, void *userd
                 log_struct(LOG_INFO,
                            LOG_MESSAGE("System shutdown has been cancelled"),
                            "ACTION=%s", handle_action_to_string(a->handle),
-                           "MESSAGE_ID=" SD_MESSAGE_LOGIND_SHUTDOWN_CANCELED_STR,
+                           "MESSAGE_ID=" SD_MESSAGE_SHUTDOWN_CANCELED_STR,
                            username ? "OPERATOR=%s" : NULL, username);
 
                 utmp_wall("System shutdown has been cancelled",
@@ -2562,12 +2528,11 @@ static int method_set_reboot_parameter(
                 void *userdata,
                 sd_bus_error *error) {
 
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         const char *arg;
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "s", &arg);
         if (r < 0)
@@ -2605,11 +2570,10 @@ static int method_can_reboot_parameter(
                 void *userdata,
                 sd_bus_error *error) {
 
-        _unused_ Manager *m = userdata;
+        _unused_ Manager *m = ASSERT_PTR(userdata);
         int r;
 
         assert(message);
-        assert(m);
 
         r = detect_container();
         if (r < 0)
@@ -2667,12 +2631,11 @@ static int method_set_reboot_to_firmware_setup(
                 void *userdata,
                 sd_bus_error *error) {
 
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         bool use_efi;
         int b, r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "b", &b);
         if (r < 0)
@@ -2737,11 +2700,10 @@ static int method_can_reboot_to_firmware_setup(
                 void *userdata,
                 sd_bus_error *error) {
 
-        _unused_ Manager *m = userdata;
+        _unused_ Manager *m = ASSERT_PTR(userdata);
         int r;
 
         assert(message);
-        assert(m);
 
         r = getenv_bool("SYSTEMD_REBOOT_TO_FIRMWARE_SETUP");
         if (r == -ENXIO) {
@@ -2830,13 +2792,12 @@ static int method_set_reboot_to_boot_loader_menu(
                 void *userdata,
                 sd_bus_error *error) {
 
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         bool use_efi;
         uint64_t x;
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "t", &x);
         if (r < 0)
@@ -2914,11 +2875,10 @@ static int method_can_reboot_to_boot_loader_menu(
                 void *userdata,
                 sd_bus_error *error) {
 
-        _unused_ Manager *m = userdata;
+        _unused_ Manager *m = ASSERT_PTR(userdata);
         int r;
 
         assert(message);
-        assert(m);
 
         r = getenv_bool("SYSTEMD_REBOOT_TO_BOOT_LOADER_MENU");
         if (r == -ENXIO) {
@@ -2960,13 +2920,12 @@ static int property_get_reboot_to_boot_loader_entry(
                 sd_bus_error *error) {
 
         _cleanup_free_ char *v = NULL;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         const char *x = NULL;
         int r;
 
         assert(bus);
         assert(reply);
-        assert(m);
 
         r = getenv_bool("SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY");
         if (r == -ENXIO) {
@@ -3021,13 +2980,12 @@ static int method_set_reboot_to_boot_loader_entry(
                 void *userdata,
                 sd_bus_error *error) {
 
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         bool use_efi;
         const char *v;
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "s", &v);
         if (r < 0)
@@ -3109,11 +3067,10 @@ static int method_can_reboot_to_boot_loader_entry(
                 void *userdata,
                 sd_bus_error *error) {
 
-        _unused_ Manager *m = userdata;
+        _unused_ Manager *m = ASSERT_PTR(userdata);
         int r;
 
         assert(message);
-        assert(m);
 
         r = getenv_bool("SYSTEMD_REBOOT_TO_BOOT_LOADER_ENTRY");
         if (r == -ENXIO) {
@@ -3155,13 +3112,12 @@ static int property_get_boot_loader_entries(
                 sd_bus_error *error) {
 
         _cleanup_(boot_config_free) BootConfig config = BOOT_CONFIG_NULL;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         size_t i;
         int r;
 
         assert(bus);
         assert(reply);
-        assert(m);
 
         r = boot_config_load_auto(&config, NULL, NULL);
         if (r < 0 && r != -ENOKEY) /* don't complain if there's no GPT found */
@@ -3192,12 +3148,11 @@ static int method_set_wall_message(
                 sd_bus_error *error) {
 
         int r;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         char *wall_message;
         int enable_wall_messages;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "sb", &wall_message, &enable_wall_messages);
         if (r < 0)
@@ -3241,8 +3196,8 @@ static int method_inhibit(sd_bus_message *message, void *userdata, sd_bus_error
         _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
         const char *who, *why, *what, *mode;
         _cleanup_free_ char *id = NULL;
-        _cleanup_close_ int fifo_fd = -1;
-        Manager *m = userdata;
+        _cleanup_close_ int fifo_fd = -EBADF;
+        Manager *m = ASSERT_PTR(userdata);
         InhibitMode mm;
         InhibitWhat w;
         pid_t pid;
@@ -3250,7 +3205,6 @@ static int method_inhibit(sd_bus_message *message, void *userdata, sd_bus_error
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "ssss", &what, &who, &why, &mode);
         if (r < 0)
@@ -3402,6 +3356,7 @@ static const sd_bus_vtable manager_vtable[] = {
         SD_BUS_PROPERTY("SessionsMax", "t", NULL, offsetof(Manager, sessions_max), SD_BUS_VTABLE_PROPERTY_CONST),
         SD_BUS_PROPERTY("NCurrentSessions", "t", property_get_hashmap_size, offsetof(Manager, sessions), 0),
         SD_BUS_PROPERTY("UserTasksMax", "t", property_get_compat_user_tasks_max, 0, SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
+        SD_BUS_PROPERTY("StopIdleSessionUSec", "t", NULL, offsetof(Manager, stop_idle_session_usec), SD_BUS_VTABLE_PROPERTY_CONST),
 
         SD_BUS_METHOD_WITH_ARGS("GetSession",
                                 SD_BUS_ARGS("s", session_id),
@@ -3771,14 +3726,13 @@ static int session_jobs_reply(Session *s, uint32_t jid, const char *unit, const
 
 int match_job_removed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         const char *path, *result, *unit;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         Session *session;
         uint32_t id;
         User *user;
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "uoss", &id, &path, &unit, &result);
         if (r < 0) {
@@ -3830,13 +3784,12 @@ int match_job_removed(sd_bus_message *message, void *userdata, sd_bus_error *err
 
 int match_unit_removed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         const char *path, *unit;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         Session *session;
         User *user;
         int r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "so", &unit, &path);
         if (r < 0) {
@@ -3857,14 +3810,13 @@ int match_unit_removed(sd_bus_message *message, void *userdata, sd_bus_error *er
 
 int match_properties_changed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
         _cleanup_free_ char *unit = NULL;
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         const char *path;
         Session *session;
         User *user;
         int r;
 
         assert(message);
-        assert(m);
 
         path = sd_bus_message_get_path(message);
         if (!path)
@@ -3890,12 +3842,11 @@ int match_properties_changed(sd_bus_message *message, void *userdata, sd_bus_err
 }
 
 int match_reloading(sd_bus_message *message, void *userdata, sd_bus_error *error) {
-        Manager *m = userdata;
+        Manager *m = ASSERT_PTR(userdata);
         Session *session;
         int b, r;
 
         assert(message);
-        assert(m);
 
         r = sd_bus_message_read(message, "b", &b);
         if (r < 0) {
@@ -4019,6 +3970,12 @@ int manager_start_scope(
         if (r < 0)
                 return r;
 
+        /* For login session scopes, if a process is OOM killed by the kernel, *don't* terminate the rest of
+           the scope */
+        r = sd_bus_message_append(m, "(sv)", "OOMPolicy", "s", "continue");
+        if (r < 0)
+                return r;
+
         /* disable TasksMax= for the session scope, rely on the slice setting for it */
         r = sd_bus_message_append(m, "(sv)", "TasksMax", "t", UINT64_MAX);
         if (r < 0)