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