src/login/logind.c

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