2 This file is part of systemd.
4 Copyright 2011 Lennart Poettering
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
22 #include <sys/ioctl.h>
23 #include <sys/types.h>
26 #include "alloc-util.h"
27 #include "bus-error.h"
29 #include "cgroup-util.h"
33 #include "terminal-util.h"
34 #include "udev-util.h"
35 #include "user-util.h"
37 int manager_add_device(Manager *m, const char *sysfs, bool master, Device **_device) {
43 d = hashmap_get(m->devices, sysfs);
45 /* we support adding master-flags, but not removing them */
46 d->master = d->master || master;
48 d = device_new(m, sysfs, master);
59 int manager_add_seat(Manager *m, const char *id, Seat **_seat) {
65 s = hashmap_get(m->seats, id);
78 int manager_add_session(Manager *m, const char *id, Session **_session) {
84 s = hashmap_get(m->sessions, id);
86 s = session_new(m, id);
97 int manager_add_user(Manager *m, uid_t uid, gid_t gid, const char *name, User **_user) {
104 u = hashmap_get(m->users, UID_TO_PTR(uid));
106 r = user_new(&u, m, uid, gid, name);
117 int manager_add_user_by_name(Manager *m, const char *name, User **_user) {
125 r = get_user_creds(&name, &uid, &gid, NULL, NULL);
129 return manager_add_user(m, uid, gid, name, _user);
132 int manager_add_user_by_uid(Manager *m, uid_t uid, User **_user) {
140 return errno > 0 ? -errno : -ENOENT;
142 return manager_add_user(m, uid, p->pw_gid, p->pw_name, _user);
145 int manager_add_inhibitor(Manager *m, const char* id, Inhibitor **_inhibitor) {
151 i = hashmap_get(m->inhibitors, id);
159 i = inhibitor_new(m, id);
169 int manager_add_button(Manager *m, const char *name, Button **_button) {
175 b = hashmap_get(m->buttons, name);
177 b = button_new(m, name);
188 int manager_process_seat_device(Manager *m, struct udev_device *d) {
194 if (streq_ptr(udev_device_get_action(d), "remove")) {
196 device = hashmap_get(m->devices, udev_device_get_syspath(d));
200 seat_add_to_gc_queue(device->seat);
208 sn = udev_device_get_property_value(d, "ID_SEAT");
212 if (!seat_name_is_valid(sn)) {
213 log_warning("Device with invalid seat name %s found, ignoring.", sn);
217 seat = hashmap_get(m->seats, sn);
218 master = udev_device_has_tag(d, "master-of-seat");
220 /* Ignore non-master devices for unknown seats */
221 if (!master && !seat)
224 r = manager_add_device(m, udev_device_get_syspath(d), master, &device);
229 r = manager_add_seat(m, sn, &seat);
238 device_attach(device, seat);
245 int manager_process_button_device(Manager *m, struct udev_device *d) {
252 if (streq_ptr(udev_device_get_action(d), "remove")) {
254 b = hashmap_get(m->buttons, udev_device_get_sysname(d));
263 r = manager_add_button(m, udev_device_get_sysname(d), &b);
267 sn = udev_device_get_property_value(d, "ID_SEAT");
271 button_set_seat(b, sn);
274 if (r < 0) /* event device doesn't have any keys or switches relevant to us? (or any other error
275 * opening the device?) let's close the button again. */
282 int manager_get_session_by_pid(Manager *m, pid_t pid, Session **session) {
283 #if 0 /// elogind does not support systemd units, but its own session system
284 _cleanup_free_ char *unit = NULL;
286 _cleanup_free_ char *session_name = NULL;
296 #if 0 /// elogind does not support systemd units, but its own session system
297 r = cg_pid_get_unit(pid, &unit);
301 s = hashmap_get(m->session_units, unit);
303 log_debug_elogind("Searching session for PID %u", pid);
304 r = cg_pid_get_session(pid, &session_name);
308 s = hashmap_get(m->sessions, session_name);
309 log_debug_elogind("Session Name \"%s\" -> Session \"%s\"",
310 session_name, s && s->id ? s->id : "NULL");
320 int manager_get_user_by_pid(Manager *m, pid_t pid, User **user) {
321 #if 0 /// elogind does not support systemd units, but its own session system
322 _cleanup_free_ char *unit = NULL;
335 #if 0 /// elogind does not support systemd units, but its own session system
336 r = cg_pid_get_slice(pid, &unit);
340 u = hashmap_get(m->user_units, unit);
346 r = manager_get_session_by_pid (m, pid, &s);
355 int manager_get_idle_hint(Manager *m, dual_timestamp *t) {
358 dual_timestamp ts = DUAL_TIMESTAMP_NULL;
363 idle_hint = !manager_is_inhibited(m, INHIBIT_IDLE, INHIBIT_BLOCK, t, false, false, 0, NULL);
365 HASHMAP_FOREACH(s, m->sessions, i) {
369 ih = session_get_idle_hint(s, &k);
375 if (k.monotonic < ts.monotonic)
381 } else if (idle_hint) {
383 if (k.monotonic > ts.monotonic)
394 bool manager_shall_kill(Manager *m, const char *user) {
398 if (!m->kill_exclude_users && streq(user, "root"))
401 if (strv_contains(m->kill_exclude_users, user))
404 if (!strv_isempty(m->kill_only_users))
405 return strv_contains(m->kill_only_users, user);
407 return m->kill_user_processes;
410 #if 0 /// UNNEEDED by elogind
411 static int vt_is_busy(unsigned int vtnr) {
412 struct vt_stat vt_stat;
414 _cleanup_close_ int fd;
418 /* We explicitly open /dev/tty1 here instead of /dev/tty0. If
419 * we'd open the latter we'd open the foreground tty which
420 * hence would be unconditionally busy. By opening /dev/tty1
421 * we avoid this. Since tty1 is special and needs to be an
422 * explicitly loaded getty or DM this is safe. */
424 fd = open_terminal("/dev/tty1", O_RDWR|O_NOCTTY|O_CLOEXEC);
428 if (ioctl(fd, VT_GETSTATE, &vt_stat) < 0)
431 r = !!(vt_stat.v_state & (1 << vtnr));
436 int manager_spawn_autovt(Manager *m, unsigned int vtnr) {
437 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
438 char name[sizeof("autovt@tty.service") + DECIMAL_STR_MAX(unsigned int)];
444 if (vtnr > m->n_autovts &&
445 vtnr != m->reserve_vt)
448 if (vtnr != m->reserve_vt) {
449 /* If this is the reserved TTY, we'll start the getty
450 * on it in any case, but otherwise only if it is not
453 r = vt_is_busy(vtnr);
460 snprintf(name, sizeof(name), "autovt@tty%u.service", vtnr);
461 r = sd_bus_call_method(
463 "org.freedesktop.systemd1",
464 "/org/freedesktop/systemd1",
465 "org.freedesktop.systemd1.Manager",
471 log_error("Failed to start %s: %s", name, bus_error_message(&error, r));
477 static bool manager_is_docked(Manager *m) {
481 HASHMAP_FOREACH(b, m->buttons, i)
488 static int manager_count_external_displays(Manager *m) {
489 _cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL;
490 struct udev_list_entry *item = NULL, *first = NULL;
494 e = udev_enumerate_new(m->udev);
498 r = udev_enumerate_add_match_subsystem(e, "drm");
502 r = udev_enumerate_scan_devices(e);
506 first = udev_enumerate_get_list_entry(e);
507 udev_list_entry_foreach(item, first) {
508 _cleanup_udev_device_unref_ struct udev_device *d = NULL;
509 struct udev_device *p;
510 const char *status, *enabled, *dash, *nn, *i;
511 bool external = false;
513 d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));
517 p = udev_device_get_parent(d);
521 /* If the parent shares the same subsystem as the
522 * device we are looking at then it is a connector,
523 * which is what we are interested in. */
524 if (!streq_ptr(udev_device_get_subsystem(p), "drm"))
527 nn = udev_device_get_sysname(d);
531 /* Ignore internal displays: the type is encoded in
532 * the sysfs name, as the second dash separated item
533 * (the first is the card name, the last the connector
534 * number). We implement a whitelist of external
535 * displays here, rather than a whitelist, to ensure
536 * we don't block suspends too eagerly. */
537 dash = strchr(nn, '-');
542 FOREACH_STRING(i, "VGA-", "DVI-I-", "DVI-D-", "DVI-A-"
543 "Composite-", "SVIDEO-", "Component-",
544 "DIN-", "DP-", "HDMI-A-", "HDMI-B-", "TV-") {
546 if (startswith(dash, i)) {
554 /* Ignore ports that are not enabled */
555 enabled = udev_device_get_sysattr_value(d, "enabled");
558 if (!streq_ptr(enabled, "enabled"))
561 /* We count any connector which is not explicitly
562 * "disconnected" as connected. */
563 status = udev_device_get_sysattr_value(d, "status");
564 if (!streq_ptr(status, "disconnected"))
571 bool manager_is_docked_or_external_displays(Manager *m) {
574 /* If we are docked don't react to lid closing */
575 if (manager_is_docked(m)) {
576 log_debug("System is docked.");
580 /* If we have more than one display connected,
581 * assume that we are docked. */
582 n = manager_count_external_displays(m);
584 log_warning_errno(n, "Display counting failed: %m");
586 log_debug("External (%i) displays connected.", n);