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