1 /* SPDX-License-Identifier: LGPL-2.1+ */
9 #include "alloc-util.h"
10 #include "bus-error.h"
12 #include "cgroup-util.h"
13 //#include "conf-parser.h"
16 #include "parse-util.h"
17 #include "process-util.h"
19 #include "terminal-util.h"
20 #include "udev-util.h"
21 #include "user-util.h"
23 void manager_reset_config(Manager *m) {
26 #if 0 /// elogind does not support autospawning of vts
31 m->inhibit_delay_max = 5 * USEC_PER_SEC;
32 m->handle_power_key = HANDLE_POWEROFF;
33 m->handle_suspend_key = HANDLE_SUSPEND;
34 m->handle_hibernate_key = HANDLE_HIBERNATE;
35 m->handle_lid_switch = HANDLE_SUSPEND;
36 m->handle_lid_switch_ep = _HANDLE_ACTION_INVALID;
37 m->handle_lid_switch_docked = HANDLE_IGNORE;
38 m->power_key_ignore_inhibited = false;
39 m->suspend_key_ignore_inhibited = false;
40 m->hibernate_key_ignore_inhibited = false;
41 m->lid_switch_ignore_inhibited = true;
43 m->holdoff_timeout_usec = 30 * USEC_PER_SEC;
45 m->idle_action_usec = 30 * USEC_PER_MINUTE;
46 m->idle_action = HANDLE_IGNORE;
48 m->runtime_dir_size = physical_memory_scale(10U, 100U); /* 10% */
49 m->user_tasks_max = system_tasks_max_scale(DEFAULT_USER_TASKS_MAX_PERCENTAGE, 100U); /* 33% */
50 m->sessions_max = 8192;
51 m->inhibitors_max = 8192;
53 m->kill_user_processes = KILL_USER_PROCESSES;
55 m->kill_only_users = strv_free(m->kill_only_users);
56 m->kill_exclude_users = strv_free(m->kill_exclude_users);
59 int manager_parse_config_file(Manager *m) {
62 #if 0 /// elogind parses its own config file
63 return config_parse_many_nulstr(PKGSYSCONFDIR "/logind.conf",
64 CONF_PATHS_NULSTR("systemd/logind.conf.d"),
66 config_item_perf_lookup, logind_gperf_lookup,
68 const char* logind_conf = getenv("ELOGIND_CONF_FILE");
73 logind_conf = PKGSYSCONFDIR "/logind.conf";
75 return config_parse(NULL, logind_conf, NULL, "Login\0Sleep\0",
76 config_item_perf_lookup, logind_gperf_lookup,
78 CONFIG_PARSE_WARN, m);
81 int manager_add_device(Manager *m, const char *sysfs, bool master, Device **_device) {
87 d = hashmap_get(m->devices, sysfs);
89 /* we support adding master-flags, but not removing them */
90 d->master = d->master || master;
92 d = device_new(m, sysfs, master);
103 int manager_add_seat(Manager *m, const char *id, Seat **_seat) {
109 s = hashmap_get(m->seats, id);
122 int manager_add_session(Manager *m, const char *id, Session **_session) {
128 s = hashmap_get(m->sessions, id);
130 s = session_new(m, id);
141 int manager_add_user(Manager *m, uid_t uid, gid_t gid, const char *name, User **_user) {
148 u = hashmap_get(m->users, UID_TO_PTR(uid));
150 r = user_new(&u, m, uid, gid, name);
161 int manager_add_user_by_name(Manager *m, const char *name, User **_user) {
169 r = get_user_creds(&name, &uid, &gid, NULL, NULL);
173 return manager_add_user(m, uid, gid, name, _user);
176 int manager_add_user_by_uid(Manager *m, uid_t uid, User **_user) {
184 return errno > 0 ? -errno : -ENOENT;
186 return manager_add_user(m, uid, p->pw_gid, p->pw_name, _user);
189 int manager_add_inhibitor(Manager *m, const char* id, Inhibitor **_inhibitor) {
195 i = hashmap_get(m->inhibitors, id);
203 i = inhibitor_new(m, id);
213 int manager_add_button(Manager *m, const char *name, Button **_button) {
219 b = hashmap_get(m->buttons, name);
221 b = button_new(m, name);
232 int manager_process_seat_device(Manager *m, struct udev_device *d) {
238 if (streq_ptr(udev_device_get_action(d), "remove")) {
240 device = hashmap_get(m->devices, udev_device_get_syspath(d));
244 seat_add_to_gc_queue(device->seat);
252 sn = udev_device_get_property_value(d, "ID_SEAT");
256 if (!seat_name_is_valid(sn)) {
257 log_warning("Device with invalid seat name %s found, ignoring.", sn);
261 seat = hashmap_get(m->seats, sn);
262 master = udev_device_has_tag(d, "master-of-seat");
264 /* Ignore non-master devices for unknown seats */
265 if (!master && !seat)
268 r = manager_add_device(m, udev_device_get_syspath(d), master, &device);
273 r = manager_add_seat(m, sn, &seat);
282 device_attach(device, seat);
289 int manager_process_button_device(Manager *m, struct udev_device *d) {
296 if (streq_ptr(udev_device_get_action(d), "remove")) {
298 b = hashmap_get(m->buttons, udev_device_get_sysname(d));
307 r = manager_add_button(m, udev_device_get_sysname(d), &b);
311 sn = udev_device_get_property_value(d, "ID_SEAT");
315 button_set_seat(b, sn);
318 if (r < 0) /* event device doesn't have any keys or switches relevant to us? (or any other error
319 * opening the device?) let's close the button again. */
326 int manager_get_session_by_pid(Manager *m, pid_t pid, Session **ret) {
327 #if 0 /// elogind does not support systemd units, but its own session system
328 _cleanup_free_ char *unit = NULL;
330 _cleanup_free_ char *session_name = NULL;
337 if (!pid_is_valid(pid))
340 #if 0 /// elogind does not support systemd units, but its own session system
341 r = cg_pid_get_unit(pid, &unit);
345 s = hashmap_get(m->session_units, unit);
349 log_debug_elogind("Searching session for PID %u", pid);
350 r = cg_pid_get_session(pid, &session_name);
354 s = hashmap_get(m->sessions, session_name);
355 log_debug_elogind("Session Name \"%s\" -> Session \"%s\"",
356 session_name, s && s->id ? s->id : "NULL");
372 int manager_get_user_by_pid(Manager *m, pid_t pid, User **ret) {
373 #if 0 /// elogind does not support systemd units, but its own session system
374 _cleanup_free_ char *unit = NULL;
383 if (!pid_is_valid(pid))
386 #if 0 /// elogind does not support systemd units, but its own session system
387 r = cg_pid_get_slice(pid, &unit);
391 u = hashmap_get(m->user_units, unit);
399 r = manager_get_session_by_pid (m, pid, &s);
415 int manager_get_idle_hint(Manager *m, dual_timestamp *t) {
418 dual_timestamp ts = DUAL_TIMESTAMP_NULL;
423 idle_hint = !manager_is_inhibited(m, INHIBIT_IDLE, INHIBIT_BLOCK, t, false, false, 0, NULL);
425 HASHMAP_FOREACH(s, m->sessions, i) {
429 ih = session_get_idle_hint(s, &k);
435 if (k.monotonic < ts.monotonic)
441 } else if (idle_hint) {
443 if (k.monotonic > ts.monotonic)
454 bool manager_shall_kill(Manager *m, const char *user) {
458 if (!m->kill_exclude_users && streq(user, "root"))
461 if (strv_contains(m->kill_exclude_users, user))
464 if (!strv_isempty(m->kill_only_users))
465 return strv_contains(m->kill_only_users, user);
467 return m->kill_user_processes;
470 #if 0 /// UNNEEDED by elogind
471 int config_parse_n_autovts(
473 const char *filename,
476 unsigned section_line,
492 r = safe_atou(rvalue, &o);
494 log_syntax(unit, LOG_ERR, filename, line, r, "Failed to parse number of autovts, ignoring: %s", rvalue);
499 log_syntax(unit, LOG_ERR, filename, line, r, "A maximum of 15 autovts are supported, ignoring: %s", rvalue);
507 static int vt_is_busy(unsigned int vtnr) {
508 struct vt_stat vt_stat;
510 _cleanup_close_ int fd;
514 /* VT_GETSTATE "cannot return state for more than 16 VTs, since v_state is short" */
517 /* We explicitly open /dev/tty1 here instead of /dev/tty0. If
518 * we'd open the latter we'd open the foreground tty which
519 * hence would be unconditionally busy. By opening /dev/tty1
520 * we avoid this. Since tty1 is special and needs to be an
521 * explicitly loaded getty or DM this is safe. */
523 fd = open_terminal("/dev/tty1", O_RDWR|O_NOCTTY|O_CLOEXEC);
527 if (ioctl(fd, VT_GETSTATE, &vt_stat) < 0)
530 r = !!(vt_stat.v_state & (1 << vtnr));
535 int manager_spawn_autovt(Manager *m, unsigned int vtnr) {
536 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
537 char name[sizeof("autovt@tty.service") + DECIMAL_STR_MAX(unsigned int)];
543 if (vtnr > m->n_autovts &&
544 vtnr != m->reserve_vt)
547 if (vtnr != m->reserve_vt) {
548 /* If this is the reserved TTY, we'll start the getty
549 * on it in any case, but otherwise only if it is not
552 r = vt_is_busy(vtnr);
559 snprintf(name, sizeof(name), "autovt@tty%u.service", vtnr);
560 r = sd_bus_call_method(
562 "org.freedesktop.systemd1",
563 "/org/freedesktop/systemd1",
564 "org.freedesktop.systemd1.Manager",
570 log_error("Failed to start %s: %s", name, bus_error_message(&error, r));
576 static bool manager_is_docked(Manager *m) {
580 HASHMAP_FOREACH(b, m->buttons, i)
587 static int manager_count_external_displays(Manager *m) {
588 _cleanup_(udev_enumerate_unrefp) struct udev_enumerate *e = NULL;
589 struct udev_list_entry *item = NULL, *first = NULL;
593 e = udev_enumerate_new(m->udev);
597 r = udev_enumerate_add_match_subsystem(e, "drm");
601 r = udev_enumerate_scan_devices(e);
605 first = udev_enumerate_get_list_entry(e);
606 udev_list_entry_foreach(item, first) {
607 _cleanup_(udev_device_unrefp) struct udev_device *d = NULL;
608 struct udev_device *p;
609 const char *status, *enabled, *dash, *nn, *i;
610 bool external = false;
612 d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));
616 p = udev_device_get_parent(d);
620 /* If the parent shares the same subsystem as the
621 * device we are looking at then it is a connector,
622 * which is what we are interested in. */
623 if (!streq_ptr(udev_device_get_subsystem(p), "drm"))
626 nn = udev_device_get_sysname(d);
630 /* Ignore internal displays: the type is encoded in
631 * the sysfs name, as the second dash separated item
632 * (the first is the card name, the last the connector
633 * number). We implement a whitelist of external
634 * displays here, rather than a whitelist, to ensure
635 * we don't block suspends too eagerly. */
636 dash = strchr(nn, '-');
641 FOREACH_STRING(i, "VGA-", "DVI-I-", "DVI-D-", "DVI-A-"
642 "Composite-", "SVIDEO-", "Component-",
643 "DIN-", "DP-", "HDMI-A-", "HDMI-B-", "TV-") {
645 if (startswith(dash, i)) {
653 /* Ignore ports that are not enabled */
654 enabled = udev_device_get_sysattr_value(d, "enabled");
657 if (!streq_ptr(enabled, "enabled"))
660 /* We count any connector which is not explicitly
661 * "disconnected" as connected. */
662 status = udev_device_get_sysattr_value(d, "status");
663 if (!streq_ptr(status, "disconnected"))
670 bool manager_is_docked_or_external_displays(Manager *m) {
673 /* If we are docked don't react to lid closing */
674 if (manager_is_docked(m)) {
675 log_debug("System is docked.");
679 /* If we have more than one display connected,
680 * assume that we are docked. */
681 n = manager_count_external_displays(m);
683 log_warning_errno(n, "Display counting failed: %m");
685 log_debug("External (%i) displays connected.", n);
692 bool manager_is_on_external_power(void) {
695 /* For now we only check for AC power, but 'external power' can apply
696 * to anything that isn't an internal battery */
699 log_warning_errno(r, "Failed to read AC power status: %m");
706 bool manager_all_buttons_ignored(Manager *m) {
709 if (m->handle_power_key != HANDLE_IGNORE)
711 if (m->handle_suspend_key != HANDLE_IGNORE)
713 if (m->handle_hibernate_key != HANDLE_IGNORE)
715 if (m->handle_lid_switch != HANDLE_IGNORE)
717 if (m->handle_lid_switch_ep != _HANDLE_ACTION_INVALID &&
718 m->handle_lid_switch_ep != HANDLE_IGNORE)
720 if (m->handle_lid_switch_docked != HANDLE_IGNORE)