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