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/>.
22 #include <sys/types.h>
23 #include <sys/ioctl.h>
29 #include "cgroup-util.h"
31 #include "bus-error.h"
32 #include "udev-util.h"
34 #include "terminal-util.h"
36 int manager_add_device(Manager
*m
, const char *sysfs
, bool master
, Device
**_device
) {
42 d
= hashmap_get(m
->devices
, sysfs
);
44 /* we support adding master-flags, but not removing them */
45 d
->master
= d
->master
|| master
;
47 d
= device_new(m
, sysfs
, master
);
58 int manager_add_seat(Manager
*m
, const char *id
, Seat
**_seat
) {
64 s
= hashmap_get(m
->seats
, id
);
77 int manager_add_session(Manager
*m
, const char *id
, Session
**_session
) {
83 s
= hashmap_get(m
->sessions
, id
);
85 s
= session_new(m
, id
);
96 int manager_add_user(Manager
*m
, uid_t uid
, gid_t gid
, const char *name
, User
**_user
) {
102 u
= hashmap_get(m
->users
, UID_TO_PTR(uid
));
104 u
= user_new(m
, uid
, gid
, name
);
115 int manager_add_user_by_name(Manager
*m
, const char *name
, User
**_user
) {
123 r
= get_user_creds(&name
, &uid
, &gid
, NULL
, NULL
);
127 return manager_add_user(m
, uid
, gid
, name
, _user
);
130 int manager_add_user_by_uid(Manager
*m
, uid_t uid
, User
**_user
) {
138 return errno
? -errno
: -ENOENT
;
140 return manager_add_user(m
, uid
, p
->pw_gid
, p
->pw_name
, _user
);
143 int manager_add_inhibitor(Manager
*m
, const char* id
, Inhibitor
**_inhibitor
) {
149 i
= hashmap_get(m
->inhibitors
, id
);
157 i
= inhibitor_new(m
, id
);
167 int manager_add_button(Manager
*m
, const char *name
, Button
**_button
) {
173 b
= hashmap_get(m
->buttons
, name
);
175 b
= button_new(m
, name
);
186 int manager_watch_busname(Manager
*m
, const char *name
) {
193 if (set_get(m
->busnames
, (char*) name
))
200 r
= set_put(m
->busnames
, n
);
209 void manager_drop_busname(Manager
*m
, const char *name
) {
216 /* keep it if the name still owns a controller */
217 HASHMAP_FOREACH(session
, m
->sessions
, i
)
218 if (session_is_controller(session
, name
))
221 free(set_remove(m
->busnames
, (char*) name
));
224 int manager_process_seat_device(Manager
*m
, struct udev_device
*d
) {
230 if (streq_ptr(udev_device_get_action(d
), "remove")) {
232 device
= hashmap_get(m
->devices
, udev_device_get_syspath(d
));
236 seat_add_to_gc_queue(device
->seat
);
244 sn
= udev_device_get_property_value(d
, "ID_SEAT");
248 if (!seat_name_is_valid(sn
)) {
249 log_warning("Device with invalid seat name %s found, ignoring.", sn
);
253 seat
= hashmap_get(m
->seats
, sn
);
254 master
= udev_device_has_tag(d
, "master-of-seat");
256 /* Ignore non-master devices for unknown seats */
257 if (!master
&& !seat
)
260 r
= manager_add_device(m
, udev_device_get_syspath(d
), master
, &device
);
265 r
= manager_add_seat(m
, sn
, &seat
);
274 device_attach(device
, seat
);
281 int manager_process_button_device(Manager
*m
, struct udev_device
*d
) {
288 if (streq_ptr(udev_device_get_action(d
), "remove")) {
290 b
= hashmap_get(m
->buttons
, udev_device_get_sysname(d
));
299 r
= manager_add_button(m
, udev_device_get_sysname(d
), &b
);
303 sn
= udev_device_get_property_value(d
, "ID_SEAT");
307 button_set_seat(b
, sn
);
314 int manager_get_session_by_pid(Manager
*m
, pid_t pid
, Session
**session
) {
315 _cleanup_free_
char *unit
= NULL
;
324 r
= cg_pid_get_unit(pid
, &unit
);
328 s
= hashmap_get(m
->session_units
, unit
);
337 int manager_get_user_by_pid(Manager
*m
, pid_t pid
, User
**user
) {
338 _cleanup_free_
char *unit
= NULL
;
348 r
= cg_pid_get_slice(pid
, &unit
);
352 u
= hashmap_get(m
->user_units
, unit
);
360 int manager_get_idle_hint(Manager
*m
, dual_timestamp
*t
) {
363 dual_timestamp ts
= DUAL_TIMESTAMP_NULL
;
368 idle_hint
= !manager_is_inhibited(m
, INHIBIT_IDLE
, INHIBIT_BLOCK
, t
, false, false, 0, NULL
);
370 HASHMAP_FOREACH(s
, m
->sessions
, i
) {
374 ih
= session_get_idle_hint(s
, &k
);
380 if (k
.monotonic
< ts
.monotonic
)
386 } else if (idle_hint
) {
388 if (k
.monotonic
> ts
.monotonic
)
399 bool manager_shall_kill(Manager
*m
, const char *user
) {
403 if (!m
->kill_user_processes
)
406 if (strv_contains(m
->kill_exclude_users
, user
))
409 if (strv_isempty(m
->kill_only_users
))
412 return strv_contains(m
->kill_only_users
, user
);
415 static int vt_is_busy(unsigned int vtnr
) {
416 struct vt_stat vt_stat
;
418 _cleanup_close_
int fd
;
422 /* We explicitly open /dev/tty1 here instead of /dev/tty0. If
423 * we'd open the latter we'd open the foreground tty which
424 * hence would be unconditionally busy. By opening /dev/tty1
425 * we avoid this. Since tty1 is special and needs to be an
426 * explicitly loaded getty or DM this is safe. */
428 fd
= open_terminal("/dev/tty1", O_RDWR
|O_NOCTTY
|O_CLOEXEC
);
432 if (ioctl(fd
, VT_GETSTATE
, &vt_stat
) < 0)
435 r
= !!(vt_stat
.v_state
& (1 << vtnr
));
440 int manager_spawn_autovt(Manager
*m
, unsigned int vtnr
) {
441 _cleanup_bus_error_free_ sd_bus_error error
= SD_BUS_ERROR_NULL
;
442 char name
[sizeof("autovt@tty.service") + DECIMAL_STR_MAX(unsigned int)];
448 if (vtnr
> m
->n_autovts
&&
449 vtnr
!= m
->reserve_vt
)
452 if (vtnr
!= m
->reserve_vt
) {
453 /* If this is the reserved TTY, we'll start the getty
454 * on it in any case, but otherwise only if it is not
457 r
= vt_is_busy(vtnr
);
464 snprintf(name
, sizeof(name
), "autovt@tty%u.service", vtnr
);
465 r
= sd_bus_call_method(
467 "org.freedesktop.systemd1",
468 "/org/freedesktop/systemd1",
469 "org.freedesktop.systemd1.Manager",
475 log_error("Failed to start %s: %s", name
, bus_error_message(&error
, r
));
480 static bool manager_is_docked(Manager
*m
) {
484 HASHMAP_FOREACH(b
, m
->buttons
, i
)
491 static int manager_count_external_displays(Manager
*m
) {
492 _cleanup_udev_enumerate_unref_
struct udev_enumerate
*e
= NULL
;
493 struct udev_list_entry
*item
= NULL
, *first
= NULL
;
497 e
= udev_enumerate_new(m
->udev
);
501 r
= udev_enumerate_add_match_subsystem(e
, "drm");
505 r
= udev_enumerate_scan_devices(e
);
509 first
= udev_enumerate_get_list_entry(e
);
510 udev_list_entry_foreach(item
, first
) {
511 _cleanup_udev_device_unref_
struct udev_device
*d
= NULL
;
512 struct udev_device
*p
;
513 const char *status
, *enabled
, *dash
, *nn
, *i
;
514 bool external
= false;
516 d
= udev_device_new_from_syspath(m
->udev
, udev_list_entry_get_name(item
));
520 p
= udev_device_get_parent(d
);
524 /* If the parent shares the same subsystem as the
525 * device we are looking at then it is a connector,
526 * which is what we are interested in. */
527 if (!streq_ptr(udev_device_get_subsystem(p
), "drm"))
530 nn
= udev_device_get_sysname(d
);
534 /* Ignore internal displays: the type is encoded in
535 * the sysfs name, as the second dash seperated item
536 * (the first is the card name, the last the connector
537 * number). We implement a whitelist of external
538 * displays here, rather than a whitelist, to ensure
539 * we don't block suspends too eagerly. */
540 dash
= strchr(nn
, '-');
545 FOREACH_STRING(i
, "VGA-", "DVI-I-", "DVI-D-", "DVI-A-"
546 "Composite-", "SVIDEO-", "Component-",
547 "DIN-", "DP-", "HDMI-A-", "HDMI-B-", "TV-") {
549 if (startswith(dash
, i
)) {
557 /* Ignore ports that are not enabled */
558 enabled
= udev_device_get_sysattr_value(d
, "enabled");
561 if (!streq_ptr(enabled
, "enabled"))
564 /* We count any connector which is not explicitly
565 * "disconnected" as connected. */
566 status
= udev_device_get_sysattr_value(d
, "status");
567 if (!streq_ptr(status
, "disconnected"))
574 bool manager_is_docked_or_external_displays(Manager
*m
) {
577 /* If we are docked don't react to lid closing */
578 if (manager_is_docked(m
)) {
579 log_debug("System is docked.");
583 /* If we have more than one display connected,
584 * assume that we are docked. */
585 n
= manager_count_external_displays(m
);
587 log_warning_errno(n
, "Display counting failed: %m");
589 log_debug("External (%i) displays connected.", n
);