1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2011 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
24 #include <sys/ioctl.h>
25 #include <sys/types.h>
28 #include "alloc-util.h"
29 #include "bus-error.h"
31 #include "cgroup-util.h"
35 #include "terminal-util.h"
36 #include "udev-util.h"
37 #include "user-util.h"
39 int manager_add_device(Manager *m, const char *sysfs, bool master, Device **_device) {
45 d = hashmap_get(m->devices, sysfs);
47 /* we support adding master-flags, but not removing them */
48 d->master = d->master || master;
50 d = device_new(m, sysfs, master);
61 int manager_add_seat(Manager *m, const char *id, Seat **_seat) {
67 s = hashmap_get(m->seats, id);
80 int manager_add_session(Manager *m, const char *id, Session **_session) {
86 s = hashmap_get(m->sessions, id);
88 s = session_new(m, id);
99 int manager_add_user(Manager *m, uid_t uid, gid_t gid, const char *name, User **_user) {
106 u = hashmap_get(m->users, UID_TO_PTR(uid));
108 r = user_new(&u, m, uid, gid, name);
119 int manager_add_user_by_name(Manager *m, const char *name, User **_user) {
127 r = get_user_creds(&name, &uid, &gid, NULL, NULL);
131 return manager_add_user(m, uid, gid, name, _user);
134 int manager_add_user_by_uid(Manager *m, uid_t uid, User **_user) {
142 return errno ? -errno : -ENOENT;
144 return manager_add_user(m, uid, p->pw_gid, p->pw_name, _user);
147 int manager_add_inhibitor(Manager *m, const char* id, Inhibitor **_inhibitor) {
153 i = hashmap_get(m->inhibitors, id);
161 i = inhibitor_new(m, id);
171 int manager_add_button(Manager *m, const char *name, Button **_button) {
177 b = hashmap_get(m->buttons, name);
179 b = button_new(m, name);
190 int manager_process_seat_device(Manager *m, struct udev_device *d) {
196 if (streq_ptr(udev_device_get_action(d), "remove")) {
198 device = hashmap_get(m->devices, udev_device_get_syspath(d));
202 seat_add_to_gc_queue(device->seat);
210 sn = udev_device_get_property_value(d, "ID_SEAT");
214 if (!seat_name_is_valid(sn)) {
215 log_warning("Device with invalid seat name %s found, ignoring.", sn);
219 seat = hashmap_get(m->seats, sn);
220 master = udev_device_has_tag(d, "master-of-seat");
222 /* Ignore non-master devices for unknown seats */
223 if (!master && !seat)
226 r = manager_add_device(m, udev_device_get_syspath(d), master, &device);
231 r = manager_add_seat(m, sn, &seat);
240 device_attach(device, seat);
247 int manager_process_button_device(Manager *m, struct udev_device *d) {
254 if (streq_ptr(udev_device_get_action(d), "remove")) {
256 b = hashmap_get(m->buttons, udev_device_get_sysname(d));
265 r = manager_add_button(m, udev_device_get_sysname(d), &b);
269 sn = udev_device_get_property_value(d, "ID_SEAT");
273 button_set_seat(b, sn);
280 int manager_get_session_by_pid(Manager *m, pid_t pid, Session **session) {
281 #if 0 /// elogind does not support systemd units, but its own session system
282 _cleanup_free_ char *unit = NULL;
284 _cleanup_free_ char *session_name = NULL;
294 #if 0 /// elogind does not support systemd units, but its own session system
295 r = cg_pid_get_unit(pid, &unit);
299 s = hashmap_get(m->session_units, unit);
301 log_debug_elogind("Searching session for PID %u", pid);
302 r = cg_pid_get_session(pid, &session_name);
306 s = hashmap_get(m->sessions, session_name);
307 log_debug_elogind("Session Name \"%s\" -> Session \"%s\"",
308 session_name, s && s->id ? s->id : "NULL");
318 int manager_get_user_by_pid(Manager *m, pid_t pid, User **user) {
319 #if 0 /// elogind does not support systemd units, but its own session system
320 _cleanup_free_ char *unit = NULL;
333 #if 0 /// elogind does not support systemd units, but its own session system
334 r = cg_pid_get_slice(pid, &unit);
338 u = hashmap_get(m->user_units, unit);
344 r = manager_get_session_by_pid (m, pid, &s);
354 int manager_get_idle_hint(Manager *m, dual_timestamp *t) {
357 dual_timestamp ts = DUAL_TIMESTAMP_NULL;
362 idle_hint = !manager_is_inhibited(m, INHIBIT_IDLE, INHIBIT_BLOCK, t, false, false, 0, NULL);
364 HASHMAP_FOREACH(s, m->sessions, i) {
368 ih = session_get_idle_hint(s, &k);
374 if (k.monotonic < ts.monotonic)
380 } else if (idle_hint) {
382 if (k.monotonic > ts.monotonic)
393 bool manager_shall_kill(Manager *m, const char *user) {
397 if (!m->kill_user_processes)
400 if (strv_contains(m->kill_exclude_users, user))
403 if (strv_isempty(m->kill_only_users))
406 return strv_contains(m->kill_only_users, user);
409 #if 0 /// UNNEEDED by elogind
410 static int vt_is_busy(unsigned int vtnr) {
411 struct vt_stat vt_stat;
413 _cleanup_close_ int fd;
417 /* We explicitly open /dev/tty1 here instead of /dev/tty0. If
418 * we'd open the latter we'd open the foreground tty which
419 * hence would be unconditionally busy. By opening /dev/tty1
420 * we avoid this. Since tty1 is special and needs to be an
421 * explicitly loaded getty or DM this is safe. */
423 fd = open_terminal("/dev/tty1", O_RDWR|O_NOCTTY|O_CLOEXEC);
427 if (ioctl(fd, VT_GETSTATE, &vt_stat) < 0)
430 r = !!(vt_stat.v_state & (1 << vtnr));
435 int manager_spawn_autovt(Manager *m, unsigned int vtnr) {
436 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
437 char name[sizeof("autovt@tty.service") + DECIMAL_STR_MAX(unsigned int)];
443 if (vtnr > m->n_autovts &&
444 vtnr != m->reserve_vt)
447 if (vtnr != m->reserve_vt) {
448 /* If this is the reserved TTY, we'll start the getty
449 * on it in any case, but otherwise only if it is not
452 r = vt_is_busy(vtnr);
459 snprintf(name, sizeof(name), "autovt@tty%u.service", vtnr);
460 r = sd_bus_call_method(
462 "org.freedesktop.systemd1",
463 "/org/freedesktop/systemd1",
464 "org.freedesktop.systemd1.Manager",
470 log_error("Failed to start %s: %s", name, bus_error_message(&error, r));
476 static bool manager_is_docked(Manager *m) {
480 HASHMAP_FOREACH(b, m->buttons, i)
487 static int manager_count_external_displays(Manager *m) {
488 _cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL;
489 struct udev_list_entry *item = NULL, *first = NULL;
493 e = udev_enumerate_new(m->udev);
497 r = udev_enumerate_add_match_subsystem(e, "drm");
501 r = udev_enumerate_scan_devices(e);
505 first = udev_enumerate_get_list_entry(e);
506 udev_list_entry_foreach(item, first) {
507 _cleanup_udev_device_unref_ struct udev_device *d = NULL;
508 struct udev_device *p;
509 const char *status, *enabled, *dash, *nn, *i;
510 bool external = false;
512 d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));
516 p = udev_device_get_parent(d);
520 /* If the parent shares the same subsystem as the
521 * device we are looking at then it is a connector,
522 * which is what we are interested in. */
523 if (!streq_ptr(udev_device_get_subsystem(p), "drm"))
526 nn = udev_device_get_sysname(d);
530 /* Ignore internal displays: the type is encoded in
531 * the sysfs name, as the second dash seperated item
532 * (the first is the card name, the last the connector
533 * number). We implement a whitelist of external
534 * displays here, rather than a whitelist, to ensure
535 * we don't block suspends too eagerly. */
536 dash = strchr(nn, '-');
541 FOREACH_STRING(i, "VGA-", "DVI-I-", "DVI-D-", "DVI-A-"
542 "Composite-", "SVIDEO-", "Component-",
543 "DIN-", "DP-", "HDMI-A-", "HDMI-B-", "TV-") {
545 if (startswith(dash, i)) {
553 /* Ignore ports that are not enabled */
554 enabled = udev_device_get_sysattr_value(d, "enabled");
557 if (!streq_ptr(enabled, "enabled"))
560 /* We count any connector which is not explicitly
561 * "disconnected" as connected. */
562 status = udev_device_get_sysattr_value(d, "status");
563 if (!streq_ptr(status, "disconnected"))
570 bool manager_is_docked_or_external_displays(Manager *m) {
573 /* If we are docked don't react to lid closing */
574 if (manager_is_docked(m)) {
575 log_debug("System is docked.");
579 /* If we have more than one display connected,
580 * assume that we are docked. */
581 n = manager_count_external_displays(m);
583 log_warning_errno(n, "Display counting failed: %m");
585 log_debug("External (%i) displays connected.", n);