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