]> 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 nss-myhostname
[thirdparty/systemd.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 <pwd.h>
24 #include <libudev.h>
25 #include <fcntl.h>
26 #include <string.h>
27 #include <unistd.h>
28 #include <sys/epoll.h>
29 #include <sys/ioctl.h>
30 #include <linux/vt.h>
31 #include <sys/timerfd.h>
32
33 #include <systemd/sd-daemon.h>
34
35 #include "logind.h"
36 #include "dbus-common.h"
37 #include "dbus-loop.h"
38 #include "strv.h"
39 #include "conf-parser.h"
40
41 Manager *manager_new(void) {
42 Manager *m;
43
44 m = new0(Manager, 1);
45 if (!m)
46 return NULL;
47
48 m->console_active_fd = -1;
49 m->bus_fd = -1;
50 m->udev_seat_fd = -1;
51 m->udev_vcsa_fd = -1;
52 m->udev_button_fd = -1;
53 m->epoll_fd = -1;
54 m->reserve_vt_fd = -1;
55
56 m->n_autovts = 6;
57 m->reserve_vt = 6;
58 m->inhibit_delay_max = 5 * USEC_PER_SEC;
59 m->handle_power_key = HANDLE_POWEROFF;
60 m->handle_suspend_key = HANDLE_SUSPEND;
61 m->handle_hibernate_key = HANDLE_HIBERNATE;
62 m->handle_lid_switch = HANDLE_SUSPEND;
63 m->lid_switch_ignore_inhibited = true;
64
65 m->idle_action_fd = -1;
66 m->idle_action_usec = 30 * USEC_PER_MINUTE;
67 m->idle_action = HANDLE_IGNORE;
68 m->idle_action_not_before_usec = now(CLOCK_MONOTONIC);
69
70 m->devices = hashmap_new(string_hash_func, string_compare_func);
71 m->seats = hashmap_new(string_hash_func, string_compare_func);
72 m->sessions = hashmap_new(string_hash_func, string_compare_func);
73 m->users = hashmap_new(trivial_hash_func, trivial_compare_func);
74 m->inhibitors = hashmap_new(string_hash_func, string_compare_func);
75 m->buttons = hashmap_new(string_hash_func, string_compare_func);
76
77 m->user_cgroups = hashmap_new(string_hash_func, string_compare_func);
78 m->session_cgroups = hashmap_new(string_hash_func, string_compare_func);
79
80 m->session_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
81 m->inhibitor_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
82 m->button_fds = hashmap_new(trivial_hash_func, trivial_compare_func);
83
84 if (!m->devices || !m->seats || !m->sessions || !m->users || !m->inhibitors || !m->buttons ||
85 !m->user_cgroups || !m->session_cgroups ||
86 !m->session_fds || !m->inhibitor_fds || !m->button_fds) {
87 manager_free(m);
88 return NULL;
89 }
90
91 m->reset_controllers = strv_new("cpu", NULL);
92 m->kill_exclude_users = strv_new("root", NULL);
93 if (!m->reset_controllers || !m->kill_exclude_users) {
94 manager_free(m);
95 return NULL;
96 }
97
98 m->udev = udev_new();
99 if (!m->udev) {
100 manager_free(m);
101 return NULL;
102 }
103
104 if (cg_get_user_path(&m->cgroup_path) < 0) {
105 manager_free(m);
106 return NULL;
107 }
108
109 return m;
110 }
111
112 void manager_free(Manager *m) {
113 Session *session;
114 User *u;
115 Device *d;
116 Seat *s;
117 Inhibitor *i;
118 Button *b;
119
120 assert(m);
121
122 while ((session = hashmap_first(m->sessions)))
123 session_free(session);
124
125 while ((u = hashmap_first(m->users)))
126 user_free(u);
127
128 while ((d = hashmap_first(m->devices)))
129 device_free(d);
130
131 while ((s = hashmap_first(m->seats)))
132 seat_free(s);
133
134 while ((i = hashmap_first(m->inhibitors)))
135 inhibitor_free(i);
136
137 while ((b = hashmap_first(m->buttons)))
138 button_free(b);
139
140 hashmap_free(m->devices);
141 hashmap_free(m->seats);
142 hashmap_free(m->sessions);
143 hashmap_free(m->users);
144 hashmap_free(m->inhibitors);
145 hashmap_free(m->buttons);
146
147 hashmap_free(m->user_cgroups);
148 hashmap_free(m->session_cgroups);
149
150 hashmap_free(m->session_fds);
151 hashmap_free(m->inhibitor_fds);
152 hashmap_free(m->button_fds);
153
154 if (m->console_active_fd >= 0)
155 close_nointr_nofail(m->console_active_fd);
156
157 if (m->udev_seat_monitor)
158 udev_monitor_unref(m->udev_seat_monitor);
159 if (m->udev_vcsa_monitor)
160 udev_monitor_unref(m->udev_vcsa_monitor);
161 if (m->udev_button_monitor)
162 udev_monitor_unref(m->udev_button_monitor);
163
164 if (m->udev)
165 udev_unref(m->udev);
166
167 if (m->bus) {
168 dbus_connection_flush(m->bus);
169 dbus_connection_close(m->bus);
170 dbus_connection_unref(m->bus);
171 }
172
173 if (m->bus_fd >= 0)
174 close_nointr_nofail(m->bus_fd);
175
176 if (m->epoll_fd >= 0)
177 close_nointr_nofail(m->epoll_fd);
178
179 if (m->reserve_vt_fd >= 0)
180 close_nointr_nofail(m->reserve_vt_fd);
181
182 if (m->idle_action_fd >= 0)
183 close_nointr_nofail(m->idle_action_fd);
184
185 strv_free(m->controllers);
186 strv_free(m->reset_controllers);
187 strv_free(m->kill_only_users);
188 strv_free(m->kill_exclude_users);
189
190 free(m->cgroup_path);
191 free(m);
192 }
193
194 int manager_add_device(Manager *m, const char *sysfs, Device **_device) {
195 Device *d;
196
197 assert(m);
198 assert(sysfs);
199
200 d = hashmap_get(m->devices, sysfs);
201 if (d) {
202 if (_device)
203 *_device = d;
204
205 return 0;
206 }
207
208 d = device_new(m, sysfs);
209 if (!d)
210 return -ENOMEM;
211
212 if (_device)
213 *_device = d;
214
215 return 0;
216 }
217
218 int manager_add_seat(Manager *m, const char *id, Seat **_seat) {
219 Seat *s;
220
221 assert(m);
222 assert(id);
223
224 s = hashmap_get(m->seats, id);
225 if (s) {
226 if (_seat)
227 *_seat = s;
228
229 return 0;
230 }
231
232 s = seat_new(m, id);
233 if (!s)
234 return -ENOMEM;
235
236 if (_seat)
237 *_seat = s;
238
239 return 0;
240 }
241
242 int manager_add_session(Manager *m, User *u, const char *id, Session **_session) {
243 Session *s;
244
245 assert(m);
246 assert(id);
247
248 s = hashmap_get(m->sessions, id);
249 if (s) {
250 if (_session)
251 *_session = s;
252
253 return 0;
254 }
255
256 s = session_new(m, u, id);
257 if (!s)
258 return -ENOMEM;
259
260 if (_session)
261 *_session = s;
262
263 return 0;
264 }
265
266 int manager_add_user(Manager *m, uid_t uid, gid_t gid, const char *name, User **_user) {
267 User *u;
268
269 assert(m);
270 assert(name);
271
272 u = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
273 if (u) {
274 if (_user)
275 *_user = u;
276
277 return 0;
278 }
279
280 u = user_new(m, uid, gid, name);
281 if (!u)
282 return -ENOMEM;
283
284 if (_user)
285 *_user = u;
286
287 return 0;
288 }
289
290 int manager_add_user_by_name(Manager *m, const char *name, User **_user) {
291 uid_t uid;
292 gid_t gid;
293 int r;
294
295 assert(m);
296 assert(name);
297
298 r = get_user_creds(&name, &uid, &gid, NULL, NULL);
299 if (r < 0)
300 return r;
301
302 return manager_add_user(m, uid, gid, name, _user);
303 }
304
305 int manager_add_user_by_uid(Manager *m, uid_t uid, User **_user) {
306 struct passwd *p;
307
308 assert(m);
309
310 errno = 0;
311 p = getpwuid(uid);
312 if (!p)
313 return errno ? -errno : -ENOENT;
314
315 return manager_add_user(m, uid, p->pw_gid, p->pw_name, _user);
316 }
317
318 int manager_add_inhibitor(Manager *m, const char* id, Inhibitor **_inhibitor) {
319 Inhibitor *i;
320
321 assert(m);
322 assert(id);
323
324 i = hashmap_get(m->inhibitors, id);
325 if (i) {
326 if (_inhibitor)
327 *_inhibitor = i;
328
329 return 0;
330 }
331
332 i = inhibitor_new(m, id);
333 if (!i)
334 return -ENOMEM;
335
336 if (_inhibitor)
337 *_inhibitor = i;
338
339 return 0;
340 }
341
342 int manager_add_button(Manager *m, const char *name, Button **_button) {
343 Button *b;
344
345 assert(m);
346 assert(name);
347
348 b = hashmap_get(m->buttons, name);
349 if (b) {
350 if (_button)
351 *_button = b;
352
353 return 0;
354 }
355
356 b = button_new(m, name);
357 if (!b)
358 return -ENOMEM;
359
360 if (_button)
361 *_button = b;
362
363 return 0;
364 }
365
366 int manager_process_seat_device(Manager *m, struct udev_device *d) {
367 Device *device;
368 int r;
369
370 assert(m);
371
372 if (streq_ptr(udev_device_get_action(d), "remove")) {
373
374 device = hashmap_get(m->devices, udev_device_get_syspath(d));
375 if (!device)
376 return 0;
377
378 seat_add_to_gc_queue(device->seat);
379 device_free(device);
380
381 } else {
382 const char *sn;
383 Seat *seat;
384
385 sn = udev_device_get_property_value(d, "ID_SEAT");
386 if (isempty(sn))
387 sn = "seat0";
388
389 if (!seat_name_is_valid(sn)) {
390 log_warning("Device with invalid seat name %s found, ignoring.", sn);
391 return 0;
392 }
393
394 r = manager_add_device(m, udev_device_get_syspath(d), &device);
395 if (r < 0)
396 return r;
397
398 r = manager_add_seat(m, sn, &seat);
399 if (r < 0) {
400 if (!device->seat)
401 device_free(device);
402
403 return r;
404 }
405
406 device_attach(device, seat);
407 seat_start(seat);
408 }
409
410 return 0;
411 }
412
413 int manager_process_button_device(Manager *m, struct udev_device *d) {
414 Button *b;
415
416 int r;
417
418 assert(m);
419
420 if (streq_ptr(udev_device_get_action(d), "remove")) {
421
422 b = hashmap_get(m->buttons, udev_device_get_sysname(d));
423 if (!b)
424 return 0;
425
426 button_free(b);
427
428 } else {
429 const char *sn;
430
431 r = manager_add_button(m, udev_device_get_sysname(d), &b);
432 if (r < 0)
433 return r;
434
435 sn = udev_device_get_property_value(d, "ID_SEAT");
436 if (isempty(sn))
437 sn = "seat0";
438
439 button_set_seat(b, sn);
440 button_open(b);
441 }
442
443 return 0;
444 }
445
446 int manager_enumerate_devices(Manager *m) {
447 struct udev_list_entry *item = NULL, *first = NULL;
448 struct udev_enumerate *e;
449 int r;
450
451 assert(m);
452
453 /* Loads devices from udev and creates seats for them as
454 * necessary */
455
456 e = udev_enumerate_new(m->udev);
457 if (!e) {
458 r = -ENOMEM;
459 goto finish;
460 }
461
462 r = udev_enumerate_add_match_subsystem(e, "graphics");
463 if (r < 0)
464 goto finish;
465
466 r = udev_enumerate_add_match_tag(e, "seat");
467 if (r < 0)
468 goto finish;
469
470 r = udev_enumerate_scan_devices(e);
471 if (r < 0)
472 goto finish;
473
474 first = udev_enumerate_get_list_entry(e);
475 udev_list_entry_foreach(item, first) {
476 struct udev_device *d;
477 int k;
478
479 d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));
480 if (!d) {
481 r = -ENOMEM;
482 goto finish;
483 }
484
485 k = manager_process_seat_device(m, d);
486 udev_device_unref(d);
487
488 if (k < 0)
489 r = k;
490 }
491
492 finish:
493 if (e)
494 udev_enumerate_unref(e);
495
496 return r;
497 }
498
499 int manager_enumerate_buttons(Manager *m) {
500 struct udev_list_entry *item = NULL, *first = NULL;
501 struct udev_enumerate *e;
502 int r;
503
504 assert(m);
505
506 /* Loads buttons from udev */
507
508 if (m->handle_power_key == HANDLE_IGNORE &&
509 m->handle_suspend_key == HANDLE_IGNORE &&
510 m->handle_hibernate_key == HANDLE_IGNORE &&
511 m->handle_lid_switch == HANDLE_IGNORE)
512 return 0;
513
514 e = udev_enumerate_new(m->udev);
515 if (!e) {
516 r = -ENOMEM;
517 goto finish;
518 }
519
520 r = udev_enumerate_add_match_subsystem(e, "input");
521 if (r < 0)
522 goto finish;
523
524 r = udev_enumerate_add_match_tag(e, "power-switch");
525 if (r < 0)
526 goto finish;
527
528 r = udev_enumerate_scan_devices(e);
529 if (r < 0)
530 goto finish;
531
532 first = udev_enumerate_get_list_entry(e);
533 udev_list_entry_foreach(item, first) {
534 struct udev_device *d;
535 int k;
536
537 d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));
538 if (!d) {
539 r = -ENOMEM;
540 goto finish;
541 }
542
543 k = manager_process_button_device(m, d);
544 udev_device_unref(d);
545
546 if (k < 0)
547 r = k;
548 }
549
550 finish:
551 if (e)
552 udev_enumerate_unref(e);
553
554 return r;
555 }
556
557 int manager_enumerate_seats(Manager *m) {
558 DIR *d;
559 struct dirent *de;
560 int r = 0;
561
562 assert(m);
563
564 /* This loads data about seats stored on disk, but does not
565 * actually create any seats. Removes data of seats that no
566 * longer exist. */
567
568 d = opendir("/run/systemd/seats");
569 if (!d) {
570 if (errno == ENOENT)
571 return 0;
572
573 log_error("Failed to open /run/systemd/seats: %m");
574 return -errno;
575 }
576
577 while ((de = readdir(d))) {
578 Seat *s;
579 int k;
580
581 if (!dirent_is_file(de))
582 continue;
583
584 s = hashmap_get(m->seats, de->d_name);
585 if (!s) {
586 unlinkat(dirfd(d), de->d_name, 0);
587 continue;
588 }
589
590 k = seat_load(s);
591 if (k < 0)
592 r = k;
593 }
594
595 closedir(d);
596
597 return r;
598 }
599
600 static int manager_enumerate_users_from_cgroup(Manager *m) {
601 int r = 0, k;
602 char *name;
603 DIR *d;
604
605 r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_path, &d);
606 if (r < 0) {
607 if (r == -ENOENT)
608 return 0;
609
610 log_error("Failed to open %s: %s", m->cgroup_path, strerror(-r));
611 return r;
612 }
613
614 while ((k = cg_read_subgroup(d, &name)) > 0) {
615 User *user;
616
617 k = manager_add_user_by_name(m, name, &user);
618 if (k < 0) {
619 free(name);
620 r = k;
621 continue;
622 }
623
624 user_add_to_gc_queue(user);
625
626 if (!user->cgroup_path)
627 if (asprintf(&user->cgroup_path, "%s/%s", m->cgroup_path, name) < 0) {
628 r = -ENOMEM;
629 free(name);
630 break;
631 }
632
633 free(name);
634 }
635
636 if (r >= 0 && k < 0)
637 r = k;
638
639 closedir(d);
640
641 return r;
642 }
643
644 static int manager_enumerate_linger_users(Manager *m) {
645 DIR *d;
646 struct dirent *de;
647 int r = 0;
648
649 d = opendir("/var/lib/systemd/linger");
650 if (!d) {
651 if (errno == ENOENT)
652 return 0;
653
654 log_error("Failed to open /var/lib/systemd/linger/: %m");
655 return -errno;
656 }
657
658 while ((de = readdir(d))) {
659 int k;
660
661 if (!dirent_is_file(de))
662 continue;
663
664 k = manager_add_user_by_name(m, de->d_name, NULL);
665 if (k < 0) {
666 log_notice("Couldn't add lingering user %s: %s", de->d_name, strerror(-k));
667 r = k;
668 }
669 }
670
671 closedir(d);
672
673 return r;
674 }
675
676 int manager_enumerate_users(Manager *m) {
677 DIR *d;
678 struct dirent *de;
679 int r, k;
680
681 assert(m);
682
683 /* First, enumerate user cgroups */
684 r = manager_enumerate_users_from_cgroup(m);
685
686 /* Second, add lingering users on top */
687 k = manager_enumerate_linger_users(m);
688 if (k < 0)
689 r = k;
690
691 /* Third, read in user data stored on disk */
692 d = opendir("/run/systemd/users");
693 if (!d) {
694 if (errno == ENOENT)
695 return 0;
696
697 log_error("Failed to open /run/systemd/users: %m");
698 return -errno;
699 }
700
701 while ((de = readdir(d))) {
702 uid_t uid;
703 User *u;
704
705 if (!dirent_is_file(de))
706 continue;
707
708 k = parse_uid(de->d_name, &uid);
709 if (k < 0) {
710 log_error("Failed to parse file name %s: %s", de->d_name, strerror(-k));
711 continue;
712 }
713
714 u = hashmap_get(m->users, ULONG_TO_PTR(uid));
715 if (!u) {
716 unlinkat(dirfd(d), de->d_name, 0);
717 continue;
718 }
719
720 k = user_load(u);
721 if (k < 0)
722 r = k;
723 }
724
725 closedir(d);
726
727 return r;
728 }
729
730 static int manager_enumerate_sessions_from_cgroup(Manager *m) {
731 User *u;
732 Iterator i;
733 int r = 0;
734
735 HASHMAP_FOREACH(u, m->users, i) {
736 DIR *d;
737 char *name;
738 int k;
739
740 if (!u->cgroup_path)
741 continue;
742
743 k = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, &d);
744 if (k < 0) {
745 if (k == -ENOENT)
746 continue;
747
748 log_error("Failed to open %s: %s", u->cgroup_path, strerror(-k));
749 r = k;
750 continue;
751 }
752
753 while ((k = cg_read_subgroup(d, &name)) > 0) {
754 Session *session;
755
756 if (streq(name, "shared"))
757 continue;
758
759 k = manager_add_session(m, u, name, &session);
760 if (k < 0) {
761 free(name);
762 break;
763 }
764
765 session_add_to_gc_queue(session);
766
767 if (!session->cgroup_path)
768 if (asprintf(&session->cgroup_path, "%s/%s", u->cgroup_path, name) < 0) {
769 k = -ENOMEM;
770 free(name);
771 break;
772 }
773
774 free(name);
775 }
776
777 closedir(d);
778
779 if (k < 0)
780 r = k;
781 }
782
783 return r;
784 }
785
786 int manager_enumerate_sessions(Manager *m) {
787 DIR *d;
788 struct dirent *de;
789 int r = 0;
790
791 assert(m);
792
793 /* First enumerate session cgroups */
794 r = manager_enumerate_sessions_from_cgroup(m);
795
796 /* Second, read in session data stored on disk */
797 d = opendir("/run/systemd/sessions");
798 if (!d) {
799 if (errno == ENOENT)
800 return 0;
801
802 log_error("Failed to open /run/systemd/sessions: %m");
803 return -errno;
804 }
805
806 while ((de = readdir(d))) {
807 struct Session *s;
808 int k;
809
810 if (!dirent_is_file(de))
811 continue;
812
813 s = hashmap_get(m->sessions, de->d_name);
814 if (!s) {
815 unlinkat(dirfd(d), de->d_name, 0);
816 continue;
817 }
818
819 k = session_load(s);
820 if (k < 0)
821 r = k;
822 }
823
824 closedir(d);
825
826 return r;
827 }
828
829 int manager_enumerate_inhibitors(Manager *m) {
830 DIR *d;
831 struct dirent *de;
832 int r = 0;
833
834 assert(m);
835
836 d = opendir("/run/systemd/inhibit");
837 if (!d) {
838 if (errno == ENOENT)
839 return 0;
840
841 log_error("Failed to open /run/systemd/inhibit: %m");
842 return -errno;
843 }
844
845 while ((de = readdir(d))) {
846 int k;
847 Inhibitor *i;
848
849 if (!dirent_is_file(de))
850 continue;
851
852 k = manager_add_inhibitor(m, de->d_name, &i);
853 if (k < 0) {
854 log_notice("Couldn't add inhibitor %s: %s", de->d_name, strerror(-k));
855 r = k;
856 continue;
857 }
858
859 k = inhibitor_load(i);
860 if (k < 0)
861 r = k;
862 }
863
864 closedir(d);
865
866 return r;
867 }
868
869 int manager_dispatch_seat_udev(Manager *m) {
870 struct udev_device *d;
871 int r;
872
873 assert(m);
874
875 d = udev_monitor_receive_device(m->udev_seat_monitor);
876 if (!d)
877 return -ENOMEM;
878
879 r = manager_process_seat_device(m, d);
880 udev_device_unref(d);
881
882 return r;
883 }
884
885 int manager_dispatch_vcsa_udev(Manager *m) {
886 struct udev_device *d;
887 int r = 0;
888 const char *name;
889
890 assert(m);
891
892 d = udev_monitor_receive_device(m->udev_vcsa_monitor);
893 if (!d)
894 return -ENOMEM;
895
896 name = udev_device_get_sysname(d);
897
898 /* Whenever a VCSA device is removed try to reallocate our
899 * VTs, to make sure our auto VTs never go away. */
900
901 if (name && startswith(name, "vcsa") && streq_ptr(udev_device_get_action(d), "remove"))
902 r = seat_preallocate_vts(m->vtconsole);
903
904 udev_device_unref(d);
905
906 return r;
907 }
908
909 int manager_dispatch_button_udev(Manager *m) {
910 struct udev_device *d;
911 int r;
912
913 assert(m);
914
915 d = udev_monitor_receive_device(m->udev_button_monitor);
916 if (!d)
917 return -ENOMEM;
918
919 r = manager_process_button_device(m, d);
920 udev_device_unref(d);
921
922 return r;
923 }
924
925 int manager_dispatch_console(Manager *m) {
926 assert(m);
927
928 if (m->vtconsole)
929 seat_read_active_vt(m->vtconsole);
930
931 return 0;
932 }
933
934 static int vt_is_busy(int vtnr) {
935 struct vt_stat vt_stat;
936 int r = 0, fd;
937
938 assert(vtnr >= 1);
939
940 /* We explicitly open /dev/tty1 here instead of /dev/tty0. If
941 * we'd open the latter we'd open the foreground tty which
942 * hence would be unconditionally busy. By opening /dev/tty1
943 * we avoid this. Since tty1 is special and needs to be an
944 * explicitly loaded getty or DM this is safe. */
945
946 fd = open_terminal("/dev/tty1", O_RDWR|O_NOCTTY|O_CLOEXEC);
947 if (fd < 0)
948 return -errno;
949
950 if (ioctl(fd, VT_GETSTATE, &vt_stat) < 0)
951 r = -errno;
952 else
953 r = !!(vt_stat.v_state & (1 << vtnr));
954
955 close_nointr_nofail(fd);
956
957 return r;
958 }
959
960 int manager_spawn_autovt(Manager *m, int vtnr) {
961 int r;
962 char *name = NULL;
963 const char *mode = "fail";
964
965 assert(m);
966 assert(vtnr >= 1);
967
968 if ((unsigned) vtnr > m->n_autovts &&
969 (unsigned) vtnr != m->reserve_vt)
970 return 0;
971
972 if ((unsigned) vtnr != m->reserve_vt) {
973 /* If this is the reserved TTY, we'll start the getty
974 * on it in any case, but otherwise only if it is not
975 * busy. */
976
977 r = vt_is_busy(vtnr);
978 if (r < 0)
979 return r;
980 else if (r > 0)
981 return -EBUSY;
982 }
983
984 if (asprintf(&name, "autovt@tty%i.service", vtnr) < 0) {
985 log_error("Could not allocate service name.");
986 r = -ENOMEM;
987 goto finish;
988 }
989
990 r = bus_method_call_with_reply (
991 m->bus,
992 "org.freedesktop.systemd1",
993 "/org/freedesktop/systemd1",
994 "org.freedesktop.systemd1.Manager",
995 "StartUnit",
996 NULL,
997 NULL,
998 DBUS_TYPE_STRING, &name,
999 DBUS_TYPE_STRING, &mode,
1000 DBUS_TYPE_INVALID);
1001
1002 finish:
1003 free(name);
1004
1005 return r;
1006 }
1007
1008 static int manager_reserve_vt(Manager *m) {
1009 _cleanup_free_ char *p = NULL;
1010
1011 assert(m);
1012
1013 if (m->reserve_vt <= 0)
1014 return 0;
1015
1016 if (asprintf(&p, "/dev/tty%u", m->reserve_vt) < 0)
1017 return log_oom();
1018
1019 m->reserve_vt_fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC|O_NONBLOCK);
1020 if (m->reserve_vt_fd < 0) {
1021
1022 /* Don't complain on VT-less systems */
1023 if (errno != ENOENT)
1024 log_warning("Failed to pin reserved VT: %m");
1025 return -errno;
1026 }
1027
1028 return 0;
1029 }
1030
1031 int manager_get_session_by_cgroup(Manager *m, const char *cgroup, Session **session) {
1032 Session *s;
1033 char *p;
1034
1035 assert(m);
1036 assert(cgroup);
1037 assert(session);
1038
1039 s = hashmap_get(m->session_cgroups, cgroup);
1040 if (s) {
1041 *session = s;
1042 return 1;
1043 }
1044
1045 p = strdup(cgroup);
1046 if (!p)
1047 return log_oom();
1048
1049 for (;;) {
1050 char *e;
1051
1052 e = strrchr(p, '/');
1053 if (!e || e == p) {
1054 free(p);
1055 *session = NULL;
1056 return 0;
1057 }
1058
1059 *e = 0;
1060
1061 s = hashmap_get(m->session_cgroups, p);
1062 if (s) {
1063 free(p);
1064 *session = s;
1065 return 1;
1066 }
1067 }
1068 }
1069
1070 int manager_get_user_by_cgroup(Manager *m, const char *cgroup, User **user) {
1071 User *u;
1072 char *p;
1073
1074 assert(m);
1075 assert(cgroup);
1076 assert(user);
1077
1078 u = hashmap_get(m->user_cgroups, cgroup);
1079 if (u) {
1080 *user = u;
1081 return 1;
1082 }
1083
1084 p = strdup(cgroup);
1085 if (!p)
1086 return log_oom();
1087
1088 for (;;) {
1089 char *e;
1090
1091 e = strrchr(p, '/');
1092 if (!e || e == p) {
1093 free(p);
1094 *user = NULL;
1095 return 0;
1096 }
1097
1098 *e = 0;
1099
1100 u = hashmap_get(m->user_cgroups, p);
1101 if (u) {
1102 free(p);
1103 *user = u;
1104 return 1;
1105 }
1106 }
1107 }
1108
1109 int manager_get_session_by_pid(Manager *m, pid_t pid, Session **session) {
1110 char *p;
1111 int r;
1112
1113 assert(m);
1114 assert(pid >= 1);
1115 assert(session);
1116
1117 r = cg_get_by_pid(SYSTEMD_CGROUP_CONTROLLER, pid, &p);
1118 if (r < 0)
1119 return r;
1120
1121 r = manager_get_session_by_cgroup(m, p, session);
1122 free(p);
1123
1124 return r;
1125 }
1126
1127 void manager_cgroup_notify_empty(Manager *m, const char *cgroup) {
1128 Session *s;
1129 User *u;
1130 int r;
1131
1132 r = manager_get_session_by_cgroup(m, cgroup, &s);
1133 if (r > 0)
1134 session_add_to_gc_queue(s);
1135
1136 r = manager_get_user_by_cgroup(m, cgroup, &u);
1137 if (r > 0)
1138 user_add_to_gc_queue(u);
1139 }
1140
1141 static void manager_dispatch_other(Manager *m, int fd) {
1142 Session *s;
1143 Inhibitor *i;
1144 Button *b;
1145
1146 assert_se(m);
1147 assert_se(fd >= 0);
1148
1149 s = hashmap_get(m->session_fds, INT_TO_PTR(fd + 1));
1150 if (s) {
1151 assert(s->fifo_fd == fd);
1152 session_remove_fifo(s);
1153 session_stop(s);
1154 return;
1155 }
1156
1157 i = hashmap_get(m->inhibitor_fds, INT_TO_PTR(fd + 1));
1158 if (i) {
1159 assert(i->fifo_fd == fd);
1160 inhibitor_stop(i);
1161 inhibitor_free(i);
1162 return;
1163 }
1164
1165 b = hashmap_get(m->button_fds, INT_TO_PTR(fd + 1));
1166 if (b) {
1167 assert(b->fd == fd);
1168 button_process(b);
1169 return;
1170 }
1171
1172 assert_not_reached("Got event for unknown fd");
1173 }
1174
1175 static int manager_connect_bus(Manager *m) {
1176 DBusError error;
1177 int r;
1178 struct epoll_event ev;
1179
1180 assert(m);
1181 assert(!m->bus);
1182 assert(m->bus_fd < 0);
1183
1184 dbus_error_init(&error);
1185
1186 m->bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
1187 if (!m->bus) {
1188 log_error("Failed to get system D-Bus connection: %s", bus_error_message(&error));
1189 r = -ECONNREFUSED;
1190 goto fail;
1191 }
1192
1193 if (!dbus_connection_register_object_path(m->bus, "/org/freedesktop/login1", &bus_manager_vtable, m) ||
1194 !dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/seat", &bus_seat_vtable, m) ||
1195 !dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/session", &bus_session_vtable, m) ||
1196 !dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/user", &bus_user_vtable, m) ||
1197 !dbus_connection_add_filter(m->bus, bus_message_filter, m, NULL)) {
1198 r = log_oom();
1199 goto fail;
1200 }
1201
1202 dbus_bus_add_match(m->bus,
1203 "type='signal',"
1204 "interface='org.freedesktop.systemd1.Agent',"
1205 "member='Released',"
1206 "path='/org/freedesktop/systemd1/agent'",
1207 &error);
1208
1209 if (dbus_error_is_set(&error)) {
1210 log_error("Failed to register match: %s", bus_error_message(&error));
1211 r = -EIO;
1212 goto fail;
1213 }
1214
1215 r = dbus_bus_request_name(m->bus, "org.freedesktop.login1", DBUS_NAME_FLAG_DO_NOT_QUEUE, &error);
1216 if (dbus_error_is_set(&error)) {
1217 log_error("Failed to register name on bus: %s", bus_error_message(&error));
1218 r = -EIO;
1219 goto fail;
1220 }
1221
1222 if (r != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
1223 log_error("Failed to acquire name.");
1224 r = -EEXIST;
1225 goto fail;
1226 }
1227
1228 m->bus_fd = bus_loop_open(m->bus);
1229 if (m->bus_fd < 0) {
1230 r = m->bus_fd;
1231 goto fail;
1232 }
1233
1234 zero(ev);
1235 ev.events = EPOLLIN;
1236 ev.data.u32 = FD_BUS;
1237
1238 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->bus_fd, &ev) < 0)
1239 goto fail;
1240
1241 return 0;
1242
1243 fail:
1244 dbus_error_free(&error);
1245
1246 return r;
1247 }
1248
1249 static int manager_connect_console(Manager *m) {
1250 struct epoll_event ev;
1251
1252 assert(m);
1253 assert(m->console_active_fd < 0);
1254
1255 /* On certain architectures (S390 and Xen, and containers),
1256 /dev/tty0 does not exist, so don't fail if we can't open
1257 it. */
1258 if (access("/dev/tty0", F_OK) < 0) {
1259 m->console_active_fd = -1;
1260 return 0;
1261 }
1262
1263 m->console_active_fd = open("/sys/class/tty/tty0/active", O_RDONLY|O_NOCTTY|O_CLOEXEC);
1264 if (m->console_active_fd < 0) {
1265
1266 /* On some systems the device node /dev/tty0 may exist
1267 * even though /sys/class/tty/tty0 does not. */
1268 if (errno == ENOENT)
1269 return 0;
1270
1271 log_error("Failed to open /sys/class/tty/tty0/active: %m");
1272 return -errno;
1273 }
1274
1275 zero(ev);
1276 ev.events = 0;
1277 ev.data.u32 = FD_CONSOLE;
1278
1279 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->console_active_fd, &ev) < 0)
1280 return -errno;
1281
1282 return 0;
1283 }
1284
1285 static int manager_connect_udev(Manager *m) {
1286 struct epoll_event ev;
1287 int r;
1288
1289 assert(m);
1290 assert(!m->udev_seat_monitor);
1291 assert(!m->udev_vcsa_monitor);
1292 assert(!m->udev_button_monitor);
1293
1294 m->udev_seat_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
1295 if (!m->udev_seat_monitor)
1296 return -ENOMEM;
1297
1298 r = udev_monitor_filter_add_match_tag(m->udev_seat_monitor, "seat");
1299 if (r < 0)
1300 return r;
1301
1302 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_seat_monitor, "graphics", NULL);
1303 if (r < 0)
1304 return r;
1305
1306 r = udev_monitor_enable_receiving(m->udev_seat_monitor);
1307 if (r < 0)
1308 return r;
1309
1310 m->udev_seat_fd = udev_monitor_get_fd(m->udev_seat_monitor);
1311
1312 zero(ev);
1313 ev.events = EPOLLIN;
1314 ev.data.u32 = FD_SEAT_UDEV;
1315 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_seat_fd, &ev) < 0)
1316 return -errno;
1317
1318 /* Don't watch keys if nobody cares */
1319 if (m->handle_power_key != HANDLE_IGNORE ||
1320 m->handle_suspend_key != HANDLE_IGNORE ||
1321 m->handle_hibernate_key != HANDLE_IGNORE ||
1322 m->handle_lid_switch != HANDLE_IGNORE) {
1323
1324 m->udev_button_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
1325 if (!m->udev_button_monitor)
1326 return -ENOMEM;
1327
1328 r = udev_monitor_filter_add_match_tag(m->udev_button_monitor, "power-switch");
1329 if (r < 0)
1330 return r;
1331
1332 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_button_monitor, "input", NULL);
1333 if (r < 0)
1334 return r;
1335
1336 r = udev_monitor_enable_receiving(m->udev_button_monitor);
1337 if (r < 0)
1338 return r;
1339
1340 m->udev_button_fd = udev_monitor_get_fd(m->udev_button_monitor);
1341
1342 zero(ev);
1343 ev.events = EPOLLIN;
1344 ev.data.u32 = FD_BUTTON_UDEV;
1345 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_button_fd, &ev) < 0)
1346 return -errno;
1347 }
1348
1349 /* Don't bother watching VCSA devices, if nobody cares */
1350 if (m->n_autovts > 0 && m->console_active_fd >= 0) {
1351
1352 m->udev_vcsa_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
1353 if (!m->udev_vcsa_monitor)
1354 return -ENOMEM;
1355
1356 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_vcsa_monitor, "vc", NULL);
1357 if (r < 0)
1358 return r;
1359
1360 r = udev_monitor_enable_receiving(m->udev_vcsa_monitor);
1361 if (r < 0)
1362 return r;
1363
1364 m->udev_vcsa_fd = udev_monitor_get_fd(m->udev_vcsa_monitor);
1365
1366 zero(ev);
1367 ev.events = EPOLLIN;
1368 ev.data.u32 = FD_VCSA_UDEV;
1369 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_vcsa_fd, &ev) < 0)
1370 return -errno;
1371 }
1372
1373 return 0;
1374 }
1375
1376 void manager_gc(Manager *m, bool drop_not_started) {
1377 Seat *seat;
1378 Session *session;
1379 User *user;
1380
1381 assert(m);
1382
1383 while ((seat = m->seat_gc_queue)) {
1384 LIST_REMOVE(Seat, gc_queue, m->seat_gc_queue, seat);
1385 seat->in_gc_queue = false;
1386
1387 if (seat_check_gc(seat, drop_not_started) == 0) {
1388 seat_stop(seat);
1389 seat_free(seat);
1390 }
1391 }
1392
1393 while ((session = m->session_gc_queue)) {
1394 LIST_REMOVE(Session, gc_queue, m->session_gc_queue, session);
1395 session->in_gc_queue = false;
1396
1397 if (session_check_gc(session, drop_not_started) == 0) {
1398 session_stop(session);
1399 session_free(session);
1400 }
1401 }
1402
1403 while ((user = m->user_gc_queue)) {
1404 LIST_REMOVE(User, gc_queue, m->user_gc_queue, user);
1405 user->in_gc_queue = false;
1406
1407 if (user_check_gc(user, drop_not_started) == 0) {
1408 user_stop(user);
1409 user_free(user);
1410 }
1411 }
1412 }
1413
1414 int manager_get_idle_hint(Manager *m, dual_timestamp *t) {
1415 Session *s;
1416 bool idle_hint;
1417 dual_timestamp ts = { 0, 0 };
1418 Iterator i;
1419
1420 assert(m);
1421
1422 idle_hint = !manager_is_inhibited(m, INHIBIT_IDLE, INHIBIT_BLOCK, t, false, false, 0);
1423
1424 HASHMAP_FOREACH(s, m->sessions, i) {
1425 dual_timestamp k;
1426 int ih;
1427
1428 ih = session_get_idle_hint(s, &k);
1429 if (ih < 0)
1430 return ih;
1431
1432 if (!ih) {
1433 if (!idle_hint) {
1434 if (k.monotonic < ts.monotonic)
1435 ts = k;
1436 } else {
1437 idle_hint = false;
1438 ts = k;
1439 }
1440 } else if (idle_hint) {
1441
1442 if (k.monotonic > ts.monotonic)
1443 ts = k;
1444 }
1445 }
1446
1447 if (t)
1448 *t = ts;
1449
1450 return idle_hint;
1451 }
1452
1453 int manager_dispatch_idle_action(Manager *m) {
1454 struct dual_timestamp since;
1455 struct itimerspec its;
1456 int r;
1457 usec_t n;
1458
1459 assert(m);
1460
1461 if (m->idle_action == HANDLE_IGNORE ||
1462 m->idle_action_usec <= 0) {
1463 r = 0;
1464 goto finish;
1465 }
1466
1467 zero(its);
1468 n = now(CLOCK_MONOTONIC);
1469
1470 r = manager_get_idle_hint(m, &since);
1471 if (r <= 0)
1472 /* Not idle. Let's check if after a timeout it it might be idle then. */
1473 timespec_store(&its.it_value, n + m->idle_action_usec);
1474 else {
1475 /* Idle! Let's see if it's time to do something, or if
1476 * we shall sleep for longer. */
1477
1478 if (n >= since.monotonic + m->idle_action_usec &&
1479 (m->idle_action_not_before_usec <= 0 || n >= m->idle_action_not_before_usec + m->idle_action_usec)) {
1480 log_info("System idle. Taking action.");
1481
1482 manager_handle_action(m, 0, m->idle_action, false, false);
1483 m->idle_action_not_before_usec = n;
1484 }
1485
1486 timespec_store(&its.it_value, MAX(since.monotonic, m->idle_action_not_before_usec) + m->idle_action_usec);
1487 }
1488
1489 if (m->idle_action_fd < 0) {
1490 struct epoll_event ev;
1491
1492 m->idle_action_fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
1493 if (m->idle_action_fd < 0) {
1494 log_error("Failed to create idle action timer: %m");
1495 r = -errno;
1496 goto finish;
1497 }
1498
1499 zero(ev);
1500 ev.events = EPOLLIN;
1501 ev.data.u32 = FD_IDLE_ACTION;
1502
1503 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->idle_action_fd, &ev) < 0) {
1504 log_error("Failed to add idle action timer to epoll: %m");
1505 r = -errno;
1506 goto finish;
1507 }
1508 }
1509
1510 if (timerfd_settime(m->idle_action_fd, TFD_TIMER_ABSTIME, &its, NULL) < 0) {
1511 log_error("Failed to reset timerfd: %m");
1512 r = -errno;
1513 goto finish;
1514 }
1515
1516 return 0;
1517
1518 finish:
1519 if (m->idle_action_fd >= 0) {
1520 close_nointr_nofail(m->idle_action_fd);
1521 m->idle_action_fd = -1;
1522 }
1523
1524 return r;
1525 }
1526 int manager_startup(Manager *m) {
1527 int r;
1528 Seat *seat;
1529 Session *session;
1530 User *user;
1531 Inhibitor *inhibitor;
1532 Iterator i;
1533
1534 assert(m);
1535 assert(m->epoll_fd <= 0);
1536
1537 cg_shorten_controllers(m->reset_controllers);
1538 cg_shorten_controllers(m->controllers);
1539
1540 m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
1541 if (m->epoll_fd < 0)
1542 return -errno;
1543
1544 /* Connect to console */
1545 r = manager_connect_console(m);
1546 if (r < 0)
1547 return r;
1548
1549 /* Connect to udev */
1550 r = manager_connect_udev(m);
1551 if (r < 0)
1552 return r;
1553
1554 /* Connect to the bus */
1555 r = manager_connect_bus(m);
1556 if (r < 0)
1557 return r;
1558
1559 /* Instantiate magic seat 0 */
1560 r = manager_add_seat(m, "seat0", &m->vtconsole);
1561 if (r < 0)
1562 return r;
1563
1564 /* Deserialize state */
1565 manager_enumerate_devices(m);
1566 manager_enumerate_seats(m);
1567 manager_enumerate_users(m);
1568 manager_enumerate_sessions(m);
1569 manager_enumerate_inhibitors(m);
1570 manager_enumerate_buttons(m);
1571
1572 /* Remove stale objects before we start them */
1573 manager_gc(m, false);
1574
1575 /* Reserve the special reserved VT */
1576 manager_reserve_vt(m);
1577
1578 /* And start everything */
1579 HASHMAP_FOREACH(seat, m->seats, i)
1580 seat_start(seat);
1581
1582 HASHMAP_FOREACH(user, m->users, i)
1583 user_start(user);
1584
1585 HASHMAP_FOREACH(session, m->sessions, i)
1586 session_start(session);
1587
1588 HASHMAP_FOREACH(inhibitor, m->inhibitors, i)
1589 inhibitor_start(inhibitor);
1590
1591 manager_dispatch_idle_action(m);
1592
1593 return 0;
1594 }
1595
1596 static int manager_recheck_buttons(Manager *m) {
1597 Iterator i;
1598 Button *b;
1599 int r = 0;
1600
1601 assert(m);
1602
1603 HASHMAP_FOREACH(b, m->buttons, i) {
1604 int q;
1605
1606 q = button_recheck(b);
1607 if (q > 0)
1608 return 1;
1609 if (q < 0)
1610 r = q;
1611 }
1612
1613 return r;
1614 }
1615
1616 int manager_run(Manager *m) {
1617 assert(m);
1618
1619 for (;;) {
1620 struct epoll_event event;
1621 int n;
1622 int msec = -1;
1623
1624 manager_gc(m, true);
1625
1626 if (manager_dispatch_delayed(m) > 0)
1627 continue;
1628
1629 if (manager_recheck_buttons(m) > 0)
1630 continue;
1631
1632 if (dbus_connection_dispatch(m->bus) != DBUS_DISPATCH_COMPLETE)
1633 continue;
1634
1635 manager_gc(m, true);
1636
1637 if (m->delayed_unit) {
1638 usec_t x, y;
1639
1640 x = now(CLOCK_MONOTONIC);
1641 y = m->delayed_timestamp + m->inhibit_delay_max;
1642
1643 msec = x >= y ? 0 : (int) ((y - x) / USEC_PER_MSEC);
1644 }
1645
1646 n = epoll_wait(m->epoll_fd, &event, 1, msec);
1647 if (n < 0) {
1648 if (errno == EINTR || errno == EAGAIN)
1649 continue;
1650
1651 log_error("epoll() failed: %m");
1652 return -errno;
1653 }
1654
1655 if (n == 0)
1656 continue;
1657
1658 switch (event.data.u32) {
1659
1660 case FD_SEAT_UDEV:
1661 manager_dispatch_seat_udev(m);
1662 break;
1663
1664 case FD_VCSA_UDEV:
1665 manager_dispatch_vcsa_udev(m);
1666 break;
1667
1668 case FD_BUTTON_UDEV:
1669 manager_dispatch_button_udev(m);
1670 break;
1671
1672 case FD_CONSOLE:
1673 manager_dispatch_console(m);
1674 break;
1675
1676 case FD_IDLE_ACTION:
1677 manager_dispatch_idle_action(m);
1678 break;
1679
1680 case FD_BUS:
1681 bus_loop_dispatch(m->bus_fd);
1682 break;
1683
1684 default:
1685 if (event.data.u32 >= FD_OTHER_BASE)
1686 manager_dispatch_other(m, event.data.u32 - FD_OTHER_BASE);
1687 }
1688 }
1689
1690 return 0;
1691 }
1692
1693 static int manager_parse_config_file(Manager *m) {
1694 FILE *f;
1695 const char *fn;
1696 int r;
1697
1698 assert(m);
1699
1700 fn = "/etc/systemd/logind.conf";
1701 f = fopen(fn, "re");
1702 if (!f) {
1703 if (errno == ENOENT)
1704 return 0;
1705
1706 log_warning("Failed to open configuration file %s: %m", fn);
1707 return -errno;
1708 }
1709
1710 r = config_parse(fn, f, "Login\0", config_item_perf_lookup, (void*) logind_gperf_lookup, false, m);
1711 if (r < 0)
1712 log_warning("Failed to parse configuration file: %s", strerror(-r));
1713
1714 fclose(f);
1715
1716 return r;
1717 }
1718
1719 int main(int argc, char *argv[]) {
1720 Manager *m = NULL;
1721 int r;
1722
1723 log_set_target(LOG_TARGET_AUTO);
1724 log_set_facility(LOG_AUTH);
1725 log_parse_environment();
1726 log_open();
1727
1728 umask(0022);
1729
1730 if (argc != 1) {
1731 log_error("This program takes no arguments.");
1732 r = -EINVAL;
1733 goto finish;
1734 }
1735
1736 m = manager_new();
1737 if (!m) {
1738 r = log_oom();
1739 goto finish;
1740 }
1741
1742 manager_parse_config_file(m);
1743
1744 r = manager_startup(m);
1745 if (r < 0) {
1746 log_error("Failed to fully start up daemon: %s", strerror(-r));
1747 goto finish;
1748 }
1749
1750 log_debug("systemd-logind running as pid %lu", (unsigned long) getpid());
1751
1752 sd_notify(false,
1753 "READY=1\n"
1754 "STATUS=Processing requests...");
1755
1756 r = manager_run(m);
1757
1758 log_debug("systemd-logind stopped as pid %lu", (unsigned long) getpid());
1759
1760 finish:
1761 sd_notify(false,
1762 "STATUS=Shutting down...");
1763
1764 if (m)
1765 manager_free(m);
1766
1767 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1768 }
Unnamed repository; edit this file 'description' to name the repository.