* 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"
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);
}
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);
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);
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"))
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)
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)
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));
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)
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));
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)
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)
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)
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)
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)
_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;
int r;
assert(message);
- assert(m);
assert_cc(sizeof(pid_t) == sizeof(uint32_t));
assert_cc(sizeof(uid_t) == sizeof(uint32_t));
}
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)
}
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)
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 */
}
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)
}
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,
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)
}
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)
}
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)
}
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)
}
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)
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)
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)
}
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)
}
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;
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);
if (r < 0)
return r;
if ((flags & ~SD_LOGIND_SHUTDOWN_AND_SLEEP_FLAGS_PUBLIC) != 0)
- return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid flags parameter");
+ return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS,
+ "Invalid flags parameter");
if (a->handle != HANDLE_REBOOT && (flags & SD_LOGIND_REBOOT_VIA_KEXEC))
- return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Reboot via kexec is only applicable with reboot operations");
+ return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS,
+ "Reboot via kexec is only applicable with reboot operations");
} else {
/* Old style method: no flags parameter, but interactive bool passed as boolean in
* payload. Let's convert this argument to the new-style flags parameter for our internal
"Not enough swap space for hibernation");
if (r == 0)
return sd_bus_error_setf(error, BUS_ERROR_SLEEP_VERB_NOT_SUPPORTED,
- "Sleep verb \"%s\" not supported", sleep_operation_to_string(a->sleep_operation));
+ "Sleep verb \"%s\" not supported",
+ sleep_operation_to_string(a->sleep_operation));
if (r < 0)
return r;
}
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);
}
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;
int r;
bool dry_run = false;
- assert(m);
assert(message);
r = sd_bus_message_read(message, "st", &type, &elapse);
}
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
if (r == 0)
return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
- reset_scheduled_shutdown(m);
-
if (m->enable_wall_messages) {
_cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
- _cleanup_free_ char *username = NULL;
const char *tty = NULL;
uid_t uid = 0;
(void) sd_bus_creds_get_tty(creds, &tty);
}
- username = uid_to_name(uid);
- utmp_wall("The system shutdown has been cancelled",
+ _cleanup_free_ char *username = uid_to_name(uid);
+
+ log_struct(LOG_INFO,
+ LOG_MESSAGE("System shutdown has been cancelled"),
+ "ACTION=%s", handle_action_to_string(a->handle),
+ "MESSAGE_ID=" SD_MESSAGE_SHUTDOWN_CANCELED_STR,
+ username ? "OPERATOR=%s" : NULL, username);
+
+ utmp_wall("System shutdown has been cancelled",
username, tty, logind_wall_tty_filter, m);
}
+ reset_scheduled_shutdown(m);
+
return sd_bus_reply_method_return(message, "b", true);
}
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)
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)
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)
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) {
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)
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) {
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) {
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)
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) {
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 */
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)
_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;
int r;
assert(message);
- assert(m);
r = sd_bus_message_read(message, "ssss", &what, &who, &why, &mode);
if (r < 0)
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),
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) {
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) {
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)
}
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) {
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)
projects / thirdparty / systemd.git / blobdiff