]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/login/logind.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #4419 from keszybz/install-specifiers
[thirdparty/systemd.git] / src / login / logind.c
1 /***
2 This file is part of systemd.
3
4 Copyright 2011 Lennart Poettering
5
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.
10
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.
15
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/>.
18 ***/
19
20 #include <errno.h>
21 #include <fcntl.h>
22 #include <string.h>
23 #include <unistd.h>
24
25 #include "libudev.h"
26 #include "sd-daemon.h"
27
28 #include "alloc-util.h"
29 #include "bus-error.h"
30 #include "bus-util.h"
31 #include "conf-parser.h"
32 #include "def.h"
33 #include "dirent-util.h"
34 #include "fd-util.h"
35 #include "formats-util.h"
36 #include "logind.h"
37 #include "selinux-util.h"
38 #include "signal-util.h"
39 #include "strv.h"
40 #include "udev-util.h"
41 #include "cgroup-util.h"
42
43 static void manager_free(Manager *m);
44
45 static void manager_reset_config(Manager *m) {
46 m->n_autovts = 6;
47 m->reserve_vt = 6;
48 m->remove_ipc = true;
49 m->inhibit_delay_max = 5 * USEC_PER_SEC;
50 m->handle_power_key = HANDLE_POWEROFF;
51 m->handle_suspend_key = HANDLE_SUSPEND;
52 m->handle_hibernate_key = HANDLE_HIBERNATE;
53 m->handle_lid_switch = HANDLE_SUSPEND;
54 m->handle_lid_switch_docked = HANDLE_IGNORE;
55 m->power_key_ignore_inhibited = false;
56 m->suspend_key_ignore_inhibited = false;
57 m->hibernate_key_ignore_inhibited = false;
58 m->lid_switch_ignore_inhibited = true;
59
60 m->holdoff_timeout_usec = 30 * USEC_PER_SEC;
61
62 m->idle_action_usec = 30 * USEC_PER_MINUTE;
63 m->idle_action = HANDLE_IGNORE;
64
65 m->runtime_dir_size = physical_memory_scale(10U, 100U); /* 10% */
66 m->user_tasks_max = system_tasks_max_scale(DEFAULT_USER_TASKS_MAX_PERCENTAGE, 100U); /* 33% */
67 m->sessions_max = 8192;
68 m->inhibitors_max = 8192;
69
70 m->kill_user_processes = KILL_USER_PROCESSES;
71
72 m->kill_only_users = strv_free(m->kill_only_users);
73 m->kill_exclude_users = strv_free(m->kill_exclude_users);
74 }
75
76 static Manager *manager_new(void) {
77 Manager *m;
78 int r;
79
80 m = new0(Manager, 1);
81 if (!m)
82 return NULL;
83
84 m->console_active_fd = -1;
85 m->reserve_vt_fd = -1;
86
87 m->idle_action_not_before_usec = now(CLOCK_MONOTONIC);
88
89 m->devices = hashmap_new(&string_hash_ops);
90 m->seats = hashmap_new(&string_hash_ops);
91 m->sessions = hashmap_new(&string_hash_ops);
92 m->users = hashmap_new(NULL);
93 m->inhibitors = hashmap_new(&string_hash_ops);
94 m->buttons = hashmap_new(&string_hash_ops);
95
96 m->user_units = hashmap_new(&string_hash_ops);
97 m->session_units = hashmap_new(&string_hash_ops);
98
99 if (!m->devices || !m->seats || !m->sessions || !m->users || !m->inhibitors || !m->buttons || !m->user_units || !m->session_units)
100 goto fail;
101
102 m->udev = udev_new();
103 if (!m->udev)
104 goto fail;
105
106 r = sd_event_default(&m->event);
107 if (r < 0)
108 goto fail;
109
110 sd_event_set_watchdog(m->event, true);
111
112 manager_reset_config(m);
113
114 return m;
115
116 fail:
117 manager_free(m);
118 return NULL;
119 }
120
121 static void manager_free(Manager *m) {
122 Session *session;
123 User *u;
124 Device *d;
125 Seat *s;
126 Inhibitor *i;
127 Button *b;
128
129 if (!m)
130 return;
131
132 while ((session = hashmap_first(m->sessions)))
133 session_free(session);
134
135 while ((u = hashmap_first(m->users)))
136 user_free(u);
137
138 while ((d = hashmap_first(m->devices)))
139 device_free(d);
140
141 while ((s = hashmap_first(m->seats)))
142 seat_free(s);
143
144 while ((i = hashmap_first(m->inhibitors)))
145 inhibitor_free(i);
146
147 while ((b = hashmap_first(m->buttons)))
148 button_free(b);
149
150 hashmap_free(m->devices);
151 hashmap_free(m->seats);
152 hashmap_free(m->sessions);
153 hashmap_free(m->users);
154 hashmap_free(m->inhibitors);
155 hashmap_free(m->buttons);
156
157 hashmap_free(m->user_units);
158 hashmap_free(m->session_units);
159
160 sd_event_source_unref(m->idle_action_event_source);
161 sd_event_source_unref(m->inhibit_timeout_source);
162 sd_event_source_unref(m->scheduled_shutdown_timeout_source);
163 sd_event_source_unref(m->nologin_timeout_source);
164 sd_event_source_unref(m->wall_message_timeout_source);
165
166 sd_event_source_unref(m->console_active_event_source);
167 sd_event_source_unref(m->udev_seat_event_source);
168 sd_event_source_unref(m->udev_device_event_source);
169 sd_event_source_unref(m->udev_vcsa_event_source);
170 sd_event_source_unref(m->udev_button_event_source);
171 sd_event_source_unref(m->lid_switch_ignore_event_source);
172
173 safe_close(m->console_active_fd);
174
175 udev_monitor_unref(m->udev_seat_monitor);
176 udev_monitor_unref(m->udev_device_monitor);
177 udev_monitor_unref(m->udev_vcsa_monitor);
178 udev_monitor_unref(m->udev_button_monitor);
179
180 udev_unref(m->udev);
181
182 if (m->unlink_nologin)
183 (void) unlink("/run/nologin");
184
185 bus_verify_polkit_async_registry_free(m->polkit_registry);
186
187 sd_bus_unref(m->bus);
188 sd_event_unref(m->event);
189
190 safe_close(m->reserve_vt_fd);
191
192 strv_free(m->kill_only_users);
193 strv_free(m->kill_exclude_users);
194
195 free(m->scheduled_shutdown_type);
196 free(m->scheduled_shutdown_tty);
197 free(m->wall_message);
198 free(m->action_job);
199 free(m);
200 }
201
202 static int manager_enumerate_devices(Manager *m) {
203 struct udev_list_entry *item = NULL, *first = NULL;
204 _cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL;
205 int r;
206
207 assert(m);
208
209 /* Loads devices from udev and creates seats for them as
210 * necessary */
211
212 e = udev_enumerate_new(m->udev);
213 if (!e)
214 return -ENOMEM;
215
216 r = udev_enumerate_add_match_tag(e, "master-of-seat");
217 if (r < 0)
218 return r;
219
220 r = udev_enumerate_add_match_is_initialized(e);
221 if (r < 0)
222 return r;
223
224 r = udev_enumerate_scan_devices(e);
225 if (r < 0)
226 return r;
227
228 first = udev_enumerate_get_list_entry(e);
229 udev_list_entry_foreach(item, first) {
230 _cleanup_udev_device_unref_ struct udev_device *d = NULL;
231 int k;
232
233 d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));
234 if (!d)
235 return -ENOMEM;
236
237 k = manager_process_seat_device(m, d);
238 if (k < 0)
239 r = k;
240 }
241
242 return r;
243 }
244
245 static int manager_enumerate_buttons(Manager *m) {
246 _cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL;
247 struct udev_list_entry *item = NULL, *first = NULL;
248 int r;
249
250 assert(m);
251
252 /* Loads buttons from udev */
253
254 if (m->handle_power_key == HANDLE_IGNORE &&
255 m->handle_suspend_key == HANDLE_IGNORE &&
256 m->handle_hibernate_key == HANDLE_IGNORE &&
257 m->handle_lid_switch == HANDLE_IGNORE &&
258 m->handle_lid_switch_docked == HANDLE_IGNORE)
259 return 0;
260
261 e = udev_enumerate_new(m->udev);
262 if (!e)
263 return -ENOMEM;
264
265 r = udev_enumerate_add_match_subsystem(e, "input");
266 if (r < 0)
267 return r;
268
269 r = udev_enumerate_add_match_tag(e, "power-switch");
270 if (r < 0)
271 return r;
272
273 r = udev_enumerate_add_match_is_initialized(e);
274 if (r < 0)
275 return r;
276
277 r = udev_enumerate_scan_devices(e);
278 if (r < 0)
279 return r;
280
281 first = udev_enumerate_get_list_entry(e);
282 udev_list_entry_foreach(item, first) {
283 _cleanup_udev_device_unref_ struct udev_device *d = NULL;
284 int k;
285
286 d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));
287 if (!d)
288 return -ENOMEM;
289
290 k = manager_process_button_device(m, d);
291 if (k < 0)
292 r = k;
293 }
294
295 return r;
296 }
297
298 static int manager_enumerate_seats(Manager *m) {
299 _cleanup_closedir_ DIR *d = NULL;
300 struct dirent *de;
301 int r = 0;
302
303 assert(m);
304
305 /* This loads data about seats stored on disk, but does not
306 * actually create any seats. Removes data of seats that no
307 * longer exist. */
308
309 d = opendir("/run/systemd/seats");
310 if (!d) {
311 if (errno == ENOENT)
312 return 0;
313
314 return log_error_errno(errno, "Failed to open /run/systemd/seats: %m");
315 }
316
317 FOREACH_DIRENT(de, d, return -errno) {
318 Seat *s;
319 int k;
320
321 if (!dirent_is_file(de))
322 continue;
323
324 s = hashmap_get(m->seats, de->d_name);
325 if (!s) {
326 unlinkat(dirfd(d), de->d_name, 0);
327 continue;
328 }
329
330 k = seat_load(s);
331 if (k < 0)
332 r = k;
333 }
334
335 return r;
336 }
337
338 static int manager_enumerate_linger_users(Manager *m) {
339 _cleanup_closedir_ DIR *d = NULL;
340 struct dirent *de;
341 int r = 0;
342
343 assert(m);
344
345 d = opendir("/var/lib/systemd/linger");
346 if (!d) {
347 if (errno == ENOENT)
348 return 0;
349
350 return log_error_errno(errno, "Failed to open /var/lib/systemd/linger/: %m");
351 }
352
353 FOREACH_DIRENT(de, d, return -errno) {
354 int k;
355
356 if (!dirent_is_file(de))
357 continue;
358
359 k = manager_add_user_by_name(m, de->d_name, NULL);
360 if (k < 0) {
361 log_notice_errno(k, "Couldn't add lingering user %s: %m", de->d_name);
362 r = k;
363 }
364 }
365
366 return r;
367 }
368
369 static int manager_enumerate_users(Manager *m) {
370 _cleanup_closedir_ DIR *d = NULL;
371 struct dirent *de;
372 int r, k;
373
374 assert(m);
375
376 /* Add lingering users */
377 r = manager_enumerate_linger_users(m);
378
379 /* Read in user data stored on disk */
380 d = opendir("/run/systemd/users");
381 if (!d) {
382 if (errno == ENOENT)
383 return 0;
384
385 return log_error_errno(errno, "Failed to open /run/systemd/users: %m");
386 }
387
388 FOREACH_DIRENT(de, d, return -errno) {
389 User *u;
390
391 if (!dirent_is_file(de))
392 continue;
393
394 k = manager_add_user_by_name(m, de->d_name, &u);
395 if (k < 0) {
396 log_error_errno(k, "Failed to add user by file name %s: %m", de->d_name);
397
398 r = k;
399 continue;
400 }
401
402 user_add_to_gc_queue(u);
403
404 k = user_load(u);
405 if (k < 0)
406 r = k;
407 }
408
409 return r;
410 }
411
412 static int manager_enumerate_sessions(Manager *m) {
413 _cleanup_closedir_ DIR *d = NULL;
414 struct dirent *de;
415 int r = 0;
416
417 assert(m);
418
419 /* Read in session data stored on disk */
420 d = opendir("/run/systemd/sessions");
421 if (!d) {
422 if (errno == ENOENT)
423 return 0;
424
425 return log_error_errno(errno, "Failed to open /run/systemd/sessions: %m");
426 }
427
428 FOREACH_DIRENT(de, d, return -errno) {
429 struct Session *s;
430 int k;
431
432 if (!dirent_is_file(de))
433 continue;
434
435 if (!session_id_valid(de->d_name)) {
436 log_warning("Invalid session file name '%s', ignoring.", de->d_name);
437 r = -EINVAL;
438 continue;
439 }
440
441 k = manager_add_session(m, de->d_name, &s);
442 if (k < 0) {
443 log_error_errno(k, "Failed to add session by file name %s: %m", de->d_name);
444
445 r = k;
446 continue;
447 }
448
449 session_add_to_gc_queue(s);
450
451 k = session_load(s);
452 if (k < 0)
453 r = k;
454 }
455
456 return r;
457 }
458
459 static int manager_enumerate_inhibitors(Manager *m) {
460 _cleanup_closedir_ DIR *d = NULL;
461 struct dirent *de;
462 int r = 0;
463
464 assert(m);
465
466 d = opendir("/run/systemd/inhibit");
467 if (!d) {
468 if (errno == ENOENT)
469 return 0;
470
471 return log_error_errno(errno, "Failed to open /run/systemd/inhibit: %m");
472 }
473
474 FOREACH_DIRENT(de, d, return -errno) {
475 int k;
476 Inhibitor *i;
477
478 if (!dirent_is_file(de))
479 continue;
480
481 k = manager_add_inhibitor(m, de->d_name, &i);
482 if (k < 0) {
483 log_notice_errno(k, "Couldn't add inhibitor %s: %m", de->d_name);
484 r = k;
485 continue;
486 }
487
488 k = inhibitor_load(i);
489 if (k < 0)
490 r = k;
491 }
492
493 return r;
494 }
495
496 static int manager_dispatch_seat_udev(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
497 _cleanup_udev_device_unref_ struct udev_device *d = NULL;
498 Manager *m = userdata;
499
500 assert(m);
501
502 d = udev_monitor_receive_device(m->udev_seat_monitor);
503 if (!d)
504 return -ENOMEM;
505
506 manager_process_seat_device(m, d);
507 return 0;
508 }
509
510 static int manager_dispatch_device_udev(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
511 _cleanup_udev_device_unref_ struct udev_device *d = NULL;
512 Manager *m = userdata;
513
514 assert(m);
515
516 d = udev_monitor_receive_device(m->udev_device_monitor);
517 if (!d)
518 return -ENOMEM;
519
520 manager_process_seat_device(m, d);
521 return 0;
522 }
523
524 static int manager_dispatch_vcsa_udev(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
525 _cleanup_udev_device_unref_ struct udev_device *d = NULL;
526 Manager *m = userdata;
527 const char *name;
528
529 assert(m);
530
531 d = udev_monitor_receive_device(m->udev_vcsa_monitor);
532 if (!d)
533 return -ENOMEM;
534
535 name = udev_device_get_sysname(d);
536
537 /* Whenever a VCSA device is removed try to reallocate our
538 * VTs, to make sure our auto VTs never go away. */
539
540 if (name && startswith(name, "vcsa") && streq_ptr(udev_device_get_action(d), "remove"))
541 seat_preallocate_vts(m->seat0);
542
543 return 0;
544 }
545
546 static int manager_dispatch_button_udev(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
547 _cleanup_udev_device_unref_ struct udev_device *d = NULL;
548 Manager *m = userdata;
549
550 assert(m);
551
552 d = udev_monitor_receive_device(m->udev_button_monitor);
553 if (!d)
554 return -ENOMEM;
555
556 manager_process_button_device(m, d);
557 return 0;
558 }
559
560 static int manager_dispatch_console(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
561 Manager *m = userdata;
562
563 assert(m);
564 assert(m->seat0);
565 assert(m->console_active_fd == fd);
566
567 seat_read_active_vt(m->seat0);
568 return 0;
569 }
570
571 static int manager_reserve_vt(Manager *m) {
572 _cleanup_free_ char *p = NULL;
573
574 assert(m);
575
576 if (m->reserve_vt <= 0)
577 return 0;
578
579 if (asprintf(&p, "/dev/tty%u", m->reserve_vt) < 0)
580 return log_oom();
581
582 m->reserve_vt_fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC|O_NONBLOCK);
583 if (m->reserve_vt_fd < 0) {
584
585 /* Don't complain on VT-less systems */
586 if (errno != ENOENT)
587 log_warning_errno(errno, "Failed to pin reserved VT: %m");
588 return -errno;
589 }
590
591 return 0;
592 }
593
594 static int manager_connect_bus(Manager *m) {
595 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
596 int r;
597
598 assert(m);
599 assert(!m->bus);
600
601 r = sd_bus_default_system(&m->bus);
602 if (r < 0)
603 return log_error_errno(r, "Failed to connect to system bus: %m");
604
605 r = sd_bus_add_object_vtable(m->bus, NULL, "/org/freedesktop/login1", "org.freedesktop.login1.Manager", manager_vtable, m);
606 if (r < 0)
607 return log_error_errno(r, "Failed to add manager object vtable: %m");
608
609 r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/login1/seat", "org.freedesktop.login1.Seat", seat_vtable, seat_object_find, m);
610 if (r < 0)
611 return log_error_errno(r, "Failed to add seat object vtable: %m");
612
613 r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/login1/seat", seat_node_enumerator, m);
614 if (r < 0)
615 return log_error_errno(r, "Failed to add seat enumerator: %m");
616
617 r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/login1/session", "org.freedesktop.login1.Session", session_vtable, session_object_find, m);
618 if (r < 0)
619 return log_error_errno(r, "Failed to add session object vtable: %m");
620
621 r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/login1/session", session_node_enumerator, m);
622 if (r < 0)
623 return log_error_errno(r, "Failed to add session enumerator: %m");
624
625 r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/login1/user", "org.freedesktop.login1.User", user_vtable, user_object_find, m);
626 if (r < 0)
627 return log_error_errno(r, "Failed to add user object vtable: %m");
628
629 r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/login1/user", user_node_enumerator, m);
630 if (r < 0)
631 return log_error_errno(r, "Failed to add user enumerator: %m");
632
633 r = sd_bus_add_match(m->bus,
634 NULL,
635 "type='signal',"
636 "sender='org.freedesktop.systemd1',"
637 "interface='org.freedesktop.systemd1.Manager',"
638 "member='JobRemoved',"
639 "path='/org/freedesktop/systemd1'",
640 match_job_removed, m);
641 if (r < 0)
642 return log_error_errno(r, "Failed to add match for JobRemoved: %m");
643
644 r = sd_bus_add_match(m->bus,
645 NULL,
646 "type='signal',"
647 "sender='org.freedesktop.systemd1',"
648 "interface='org.freedesktop.systemd1.Manager',"
649 "member='UnitRemoved',"
650 "path='/org/freedesktop/systemd1'",
651 match_unit_removed, m);
652 if (r < 0)
653 return log_error_errno(r, "Failed to add match for UnitRemoved: %m");
654
655 r = sd_bus_add_match(m->bus,
656 NULL,
657 "type='signal',"
658 "sender='org.freedesktop.systemd1',"
659 "interface='org.freedesktop.DBus.Properties',"
660 "member='PropertiesChanged'",
661 match_properties_changed, m);
662 if (r < 0)
663 return log_error_errno(r, "Failed to add match for PropertiesChanged: %m");
664
665 r = sd_bus_add_match(m->bus,
666 NULL,
667 "type='signal',"
668 "sender='org.freedesktop.systemd1',"
669 "interface='org.freedesktop.systemd1.Manager',"
670 "member='Reloading',"
671 "path='/org/freedesktop/systemd1'",
672 match_reloading, m);
673 if (r < 0)
674 return log_error_errno(r, "Failed to add match for Reloading: %m");
675
676 r = sd_bus_call_method(
677 m->bus,
678 "org.freedesktop.systemd1",
679 "/org/freedesktop/systemd1",
680 "org.freedesktop.systemd1.Manager",
681 "Subscribe",
682 &error,
683 NULL, NULL);
684 if (r < 0) {
685 log_error("Failed to enable subscription: %s", bus_error_message(&error, r));
686 return r;
687 }
688
689 r = sd_bus_request_name(m->bus, "org.freedesktop.login1", 0);
690 if (r < 0)
691 return log_error_errno(r, "Failed to register name: %m");
692
693 r = sd_bus_attach_event(m->bus, m->event, SD_EVENT_PRIORITY_NORMAL);
694 if (r < 0)
695 return log_error_errno(r, "Failed to attach bus to event loop: %m");
696
697 return 0;
698 }
699
700 static int manager_vt_switch(sd_event_source *src, const struct signalfd_siginfo *si, void *data) {
701 Manager *m = data;
702 Session *active, *iter;
703
704 /*
705 * We got a VT-switch signal and we have to acknowledge it immediately.
706 * Preferably, we'd just use m->seat0->active->vtfd, but unfortunately,
707 * old user-space might run multiple sessions on a single VT, *sigh*.
708 * Therefore, we have to iterate all sessions and find one with a vtfd
709 * on the requested VT.
710 * As only VTs with active controllers have VT_PROCESS set, our current
711 * notion of the active VT might be wrong (for instance if the switch
712 * happens while we setup VT_PROCESS). Therefore, read the current VT
713 * first and then use s->active->vtnr as reference. Note that this is
714 * not racy, as no further VT-switch can happen as long as we're in
715 * synchronous VT_PROCESS mode.
716 */
717
718 assert(m->seat0);
719 seat_read_active_vt(m->seat0);
720
721 active = m->seat0->active;
722 if (!active || active->vtnr < 1) {
723 log_warning("Received VT_PROCESS signal without a registered session on that VT.");
724 return 0;
725 }
726
727 if (active->vtfd >= 0) {
728 session_leave_vt(active);
729 } else {
730 LIST_FOREACH(sessions_by_seat, iter, m->seat0->sessions) {
731 if (iter->vtnr == active->vtnr && iter->vtfd >= 0) {
732 session_leave_vt(iter);
733 break;
734 }
735 }
736 }
737
738 return 0;
739 }
740
741 static int manager_connect_console(Manager *m) {
742 int r;
743
744 assert(m);
745 assert(m->console_active_fd < 0);
746
747 /* On certain architectures (S390 and Xen, and containers),
748 /dev/tty0 does not exist, so don't fail if we can't open
749 it. */
750 if (access("/dev/tty0", F_OK) < 0)
751 return 0;
752
753 m->console_active_fd = open("/sys/class/tty/tty0/active", O_RDONLY|O_NOCTTY|O_CLOEXEC);
754 if (m->console_active_fd < 0) {
755
756 /* On some systems the device node /dev/tty0 may exist
757 * even though /sys/class/tty/tty0 does not. */
758 if (errno == ENOENT)
759 return 0;
760
761 return log_error_errno(errno, "Failed to open /sys/class/tty/tty0/active: %m");
762 }
763
764 r = sd_event_add_io(m->event, &m->console_active_event_source, m->console_active_fd, 0, manager_dispatch_console, m);
765 if (r < 0) {
766 log_error("Failed to watch foreground console");
767 return r;
768 }
769
770 /*
771 * SIGRTMIN is used as global VT-release signal, SIGRTMIN + 1 is used
772 * as VT-acquire signal. We ignore any acquire-events (yes, we still
773 * have to provide a valid signal-number for it!) and acknowledge all
774 * release events immediately.
775 */
776
777 if (SIGRTMIN + 1 > SIGRTMAX) {
778 log_error("Not enough real-time signals available: %u-%u", SIGRTMIN, SIGRTMAX);
779 return -EINVAL;
780 }
781
782 assert_se(ignore_signals(SIGRTMIN + 1, -1) >= 0);
783 assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGRTMIN, -1) >= 0);
784
785 r = sd_event_add_signal(m->event, NULL, SIGRTMIN, manager_vt_switch, m);
786 if (r < 0)
787 return r;
788
789 return 0;
790 }
791
792 static int manager_connect_udev(Manager *m) {
793 int r;
794
795 assert(m);
796 assert(!m->udev_seat_monitor);
797 assert(!m->udev_device_monitor);
798 assert(!m->udev_vcsa_monitor);
799 assert(!m->udev_button_monitor);
800
801 m->udev_seat_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
802 if (!m->udev_seat_monitor)
803 return -ENOMEM;
804
805 r = udev_monitor_filter_add_match_tag(m->udev_seat_monitor, "master-of-seat");
806 if (r < 0)
807 return r;
808
809 r = udev_monitor_enable_receiving(m->udev_seat_monitor);
810 if (r < 0)
811 return r;
812
813 r = sd_event_add_io(m->event, &m->udev_seat_event_source, udev_monitor_get_fd(m->udev_seat_monitor), EPOLLIN, manager_dispatch_seat_udev, m);
814 if (r < 0)
815 return r;
816
817 m->udev_device_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
818 if (!m->udev_device_monitor)
819 return -ENOMEM;
820
821 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_device_monitor, "input", NULL);
822 if (r < 0)
823 return r;
824
825 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_device_monitor, "graphics", NULL);
826 if (r < 0)
827 return r;
828
829 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_device_monitor, "drm", NULL);
830 if (r < 0)
831 return r;
832
833 r = udev_monitor_enable_receiving(m->udev_device_monitor);
834 if (r < 0)
835 return r;
836
837 r = sd_event_add_io(m->event, &m->udev_device_event_source, udev_monitor_get_fd(m->udev_device_monitor), EPOLLIN, manager_dispatch_device_udev, m);
838 if (r < 0)
839 return r;
840
841 /* Don't watch keys if nobody cares */
842 if (m->handle_power_key != HANDLE_IGNORE ||
843 m->handle_suspend_key != HANDLE_IGNORE ||
844 m->handle_hibernate_key != HANDLE_IGNORE ||
845 m->handle_lid_switch != HANDLE_IGNORE ||
846 m->handle_lid_switch_docked != HANDLE_IGNORE) {
847
848 m->udev_button_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
849 if (!m->udev_button_monitor)
850 return -ENOMEM;
851
852 r = udev_monitor_filter_add_match_tag(m->udev_button_monitor, "power-switch");
853 if (r < 0)
854 return r;
855
856 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_button_monitor, "input", NULL);
857 if (r < 0)
858 return r;
859
860 r = udev_monitor_enable_receiving(m->udev_button_monitor);
861 if (r < 0)
862 return r;
863
864 r = sd_event_add_io(m->event, &m->udev_button_event_source, udev_monitor_get_fd(m->udev_button_monitor), EPOLLIN, manager_dispatch_button_udev, m);
865 if (r < 0)
866 return r;
867 }
868
869 /* Don't bother watching VCSA devices, if nobody cares */
870 if (m->n_autovts > 0 && m->console_active_fd >= 0) {
871
872 m->udev_vcsa_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
873 if (!m->udev_vcsa_monitor)
874 return -ENOMEM;
875
876 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_vcsa_monitor, "vc", NULL);
877 if (r < 0)
878 return r;
879
880 r = udev_monitor_enable_receiving(m->udev_vcsa_monitor);
881 if (r < 0)
882 return r;
883
884 r = sd_event_add_io(m->event, &m->udev_vcsa_event_source, udev_monitor_get_fd(m->udev_vcsa_monitor), EPOLLIN, manager_dispatch_vcsa_udev, m);
885 if (r < 0)
886 return r;
887 }
888
889 return 0;
890 }
891
892 static void manager_gc(Manager *m, bool drop_not_started) {
893 Seat *seat;
894 Session *session;
895 User *user;
896
897 assert(m);
898
899 while ((seat = m->seat_gc_queue)) {
900 LIST_REMOVE(gc_queue, m->seat_gc_queue, seat);
901 seat->in_gc_queue = false;
902
903 if (!seat_check_gc(seat, drop_not_started)) {
904 seat_stop(seat, false);
905 seat_free(seat);
906 }
907 }
908
909 while ((session = m->session_gc_queue)) {
910 LIST_REMOVE(gc_queue, m->session_gc_queue, session);
911 session->in_gc_queue = false;
912
913 /* First, if we are not closing yet, initiate stopping */
914 if (!session_check_gc(session, drop_not_started) &&
915 session_get_state(session) != SESSION_CLOSING)
916 session_stop(session, false);
917
918 /* Normally, this should make the session referenced
919 * again, if it doesn't then let's get rid of it
920 * immediately */
921 if (!session_check_gc(session, drop_not_started)) {
922 session_finalize(session);
923 session_free(session);
924 }
925 }
926
927 while ((user = m->user_gc_queue)) {
928 LIST_REMOVE(gc_queue, m->user_gc_queue, user);
929 user->in_gc_queue = false;
930
931 /* First step: queue stop jobs */
932 if (!user_check_gc(user, drop_not_started))
933 user_stop(user, false);
934
935 /* Second step: finalize user */
936 if (!user_check_gc(user, drop_not_started)) {
937 user_finalize(user);
938 user_free(user);
939 }
940 }
941 }
942
943 static int manager_dispatch_idle_action(sd_event_source *s, uint64_t t, void *userdata) {
944 Manager *m = userdata;
945 struct dual_timestamp since;
946 usec_t n, elapse;
947 int r;
948
949 assert(m);
950
951 if (m->idle_action == HANDLE_IGNORE ||
952 m->idle_action_usec <= 0)
953 return 0;
954
955 n = now(CLOCK_MONOTONIC);
956
957 r = manager_get_idle_hint(m, &since);
958 if (r <= 0)
959 /* Not idle. Let's check if after a timeout it might be idle then. */
960 elapse = n + m->idle_action_usec;
961 else {
962 /* Idle! Let's see if it's time to do something, or if
963 * we shall sleep for longer. */
964
965 if (n >= since.monotonic + m->idle_action_usec &&
966 (m->idle_action_not_before_usec <= 0 || n >= m->idle_action_not_before_usec + m->idle_action_usec)) {
967 log_info("System idle. Taking action.");
968
969 manager_handle_action(m, 0, m->idle_action, false, false);
970 m->idle_action_not_before_usec = n;
971 }
972
973 elapse = MAX(since.monotonic, m->idle_action_not_before_usec) + m->idle_action_usec;
974 }
975
976 if (!m->idle_action_event_source) {
977
978 r = sd_event_add_time(
979 m->event,
980 &m->idle_action_event_source,
981 CLOCK_MONOTONIC,
982 elapse, USEC_PER_SEC*30,
983 manager_dispatch_idle_action, m);
984 if (r < 0)
985 return log_error_errno(r, "Failed to add idle event source: %m");
986
987 r = sd_event_source_set_priority(m->idle_action_event_source, SD_EVENT_PRIORITY_IDLE+10);
988 if (r < 0)
989 return log_error_errno(r, "Failed to set idle event source priority: %m");
990 } else {
991 r = sd_event_source_set_time(m->idle_action_event_source, elapse);
992 if (r < 0)
993 return log_error_errno(r, "Failed to set idle event timer: %m");
994
995 r = sd_event_source_set_enabled(m->idle_action_event_source, SD_EVENT_ONESHOT);
996 if (r < 0)
997 return log_error_errno(r, "Failed to enable idle event timer: %m");
998 }
999
1000 return 0;
1001 }
1002
1003 static int manager_parse_config_file(Manager *m) {
1004 assert(m);
1005
1006 return config_parse_many_nulstr(PKGSYSCONFDIR "/logind.conf",
1007 CONF_PATHS_NULSTR("systemd/logind.conf.d"),
1008 "Login\0",
1009 config_item_perf_lookup, logind_gperf_lookup,
1010 false, m);
1011 }
1012
1013 static int manager_dispatch_reload_signal(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
1014 Manager *m = userdata;
1015 int r;
1016
1017 manager_reset_config(m);
1018 r = manager_parse_config_file(m);
1019 if (r < 0)
1020 log_warning_errno(r, "Failed to parse config file, using defaults: %m");
1021 else
1022 log_info("Config file reloaded.");
1023
1024 return 0;
1025 }
1026
1027 static int manager_startup(Manager *m) {
1028 int r;
1029 Seat *seat;
1030 Session *session;
1031 User *user;
1032 Button *button;
1033 Inhibitor *inhibitor;
1034 Iterator i;
1035
1036 assert(m);
1037
1038 assert_se(sigprocmask_many(SIG_SETMASK, NULL, SIGHUP, -1) >= 0);
1039
1040 r = sd_event_add_signal(m->event, NULL, SIGHUP, manager_dispatch_reload_signal, m);
1041 if (r < 0)
1042 return log_error_errno(r, "Failed to register SIGHUP handler: %m");
1043
1044 /* Connect to console */
1045 r = manager_connect_console(m);
1046 if (r < 0)
1047 return r;
1048
1049 /* Connect to udev */
1050 r = manager_connect_udev(m);
1051 if (r < 0)
1052 return log_error_errno(r, "Failed to create udev watchers: %m");
1053
1054 /* Connect to the bus */
1055 r = manager_connect_bus(m);
1056 if (r < 0)
1057 return r;
1058
1059 /* Instantiate magic seat 0 */
1060 r = manager_add_seat(m, "seat0", &m->seat0);
1061 if (r < 0)
1062 return log_error_errno(r, "Failed to add seat0: %m");
1063
1064 r = manager_set_lid_switch_ignore(m, 0 + m->holdoff_timeout_usec);
1065 if (r < 0)
1066 log_warning_errno(r, "Failed to set up lid switch ignore event source: %m");
1067
1068 /* Deserialize state */
1069 r = manager_enumerate_devices(m);
1070 if (r < 0)
1071 log_warning_errno(r, "Device enumeration failed: %m");
1072
1073 r = manager_enumerate_seats(m);
1074 if (r < 0)
1075 log_warning_errno(r, "Seat enumeration failed: %m");
1076
1077 r = manager_enumerate_users(m);
1078 if (r < 0)
1079 log_warning_errno(r, "User enumeration failed: %m");
1080
1081 r = manager_enumerate_sessions(m);
1082 if (r < 0)
1083 log_warning_errno(r, "Session enumeration failed: %m");
1084
1085 r = manager_enumerate_inhibitors(m);
1086 if (r < 0)
1087 log_warning_errno(r, "Inhibitor enumeration failed: %m");
1088
1089 r = manager_enumerate_buttons(m);
1090 if (r < 0)
1091 log_warning_errno(r, "Button enumeration failed: %m");
1092
1093 /* Remove stale objects before we start them */
1094 manager_gc(m, false);
1095
1096 /* Reserve the special reserved VT */
1097 manager_reserve_vt(m);
1098
1099 /* And start everything */
1100 HASHMAP_FOREACH(seat, m->seats, i)
1101 seat_start(seat);
1102
1103 HASHMAP_FOREACH(user, m->users, i)
1104 user_start(user);
1105
1106 HASHMAP_FOREACH(session, m->sessions, i)
1107 session_start(session);
1108
1109 HASHMAP_FOREACH(inhibitor, m->inhibitors, i)
1110 inhibitor_start(inhibitor);
1111
1112 HASHMAP_FOREACH(button, m->buttons, i)
1113 button_check_switches(button);
1114
1115 manager_dispatch_idle_action(NULL, 0, m);
1116
1117 return 0;
1118 }
1119
1120 static int manager_run(Manager *m) {
1121 int r;
1122
1123 assert(m);
1124
1125 for (;;) {
1126 r = sd_event_get_state(m->event);
1127 if (r < 0)
1128 return r;
1129 if (r == SD_EVENT_FINISHED)
1130 return 0;
1131
1132 manager_gc(m, true);
1133
1134 r = manager_dispatch_delayed(m, false);
1135 if (r < 0)
1136 return r;
1137 if (r > 0)
1138 continue;
1139
1140 r = sd_event_run(m->event, (uint64_t) -1);
1141 if (r < 0)
1142 return r;
1143 }
1144 }
1145
1146 int main(int argc, char *argv[]) {
1147 Manager *m = NULL;
1148 int r;
1149
1150 log_set_target(LOG_TARGET_AUTO);
1151 log_set_facility(LOG_AUTH);
1152 log_parse_environment();
1153 log_open();
1154
1155 umask(0022);
1156
1157 if (argc != 1) {
1158 log_error("This program takes no arguments.");
1159 r = -EINVAL;
1160 goto finish;
1161 }
1162
1163 r = mac_selinux_init();
1164 if (r < 0) {
1165 log_error_errno(r, "Could not initialize labelling: %m");
1166 goto finish;
1167 }
1168
1169 /* Always create the directories people can create inotify
1170 * watches in. Note that some applications might check for the
1171 * existence of /run/systemd/seats/ to determine whether
1172 * logind is available, so please always make sure this check
1173 * stays in. */
1174 mkdir_label("/run/systemd/seats", 0755);
1175 mkdir_label("/run/systemd/users", 0755);
1176 mkdir_label("/run/systemd/sessions", 0755);
1177
1178 m = manager_new();
1179 if (!m) {
1180 r = log_oom();
1181 goto finish;
1182 }
1183
1184 manager_parse_config_file(m);
1185
1186 r = manager_startup(m);
1187 if (r < 0) {
1188 log_error_errno(r, "Failed to fully start up daemon: %m");
1189 goto finish;
1190 }
1191
1192 log_debug("systemd-logind running as pid "PID_FMT, getpid());
1193
1194 sd_notify(false,
1195 "READY=1\n"
1196 "STATUS=Processing requests...");
1197
1198 r = manager_run(m);
1199
1200 log_debug("systemd-logind stopped as pid "PID_FMT, getpid());
1201
1202 finish:
1203 sd_notify(false,
1204 "STOPPING=1\n"
1205 "STATUS=Shutting down...");
1206
1207 manager_free(m);
1208
1209 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1210 }
Unnamed repository; edit this file 'description' to name the repository.