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