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