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 "sd-daemon.h"
  29 #include "strv.h"
  30 #include "conf-parser.h"
  31 #include "bus-util.h"
  32 #include "bus-error.h"
  33 #include "logind.h"
  34 #include "udev-util.h"
  35 #include "formats-util.h"
  36
  37 static void manager_free(Manager *m);
  38
  39 static Manager *manager_new(void) {
  40         Manager *m;
  41         int r;
  42
  43         m = new0(Manager, 1);
  44         if (!m)
  45                 return NULL;
  46
  47         m->console_active_fd = -1;
  48         m->reserve_vt_fd = -1;
  49
  50         m->n_autovts = 6;
  51         m->reserve_vt = 6;
  52         m->remove_ipc = true;
  53         m->inhibit_delay_max = 5 * USEC_PER_SEC;
  54         m->handle_power_key = HANDLE_POWEROFF;
  55         m->handle_suspend_key = HANDLE_SUSPEND;
  56         m->handle_hibernate_key = HANDLE_HIBERNATE;
  57         m->handle_lid_switch = HANDLE_SUSPEND;
  58         m->handle_lid_switch_docked = HANDLE_IGNORE;
  59         m->lid_switch_ignore_inhibited = true;
  60         m->holdoff_timeout_usec = 30 * USEC_PER_SEC;
  61
  62         m->idle_action_usec = 30 * USEC_PER_MINUTE;
  63         m->idle_action = HANDLE_IGNORE;
  64         m->idle_action_not_before_usec = now(CLOCK_MONOTONIC);
  65
  66         m->runtime_dir_size = PAGE_ALIGN((size_t) (physical_memory() / 10)); /* 10% */
  67
  68         m->devices = hashmap_new(&string_hash_ops);
  69         m->seats = hashmap_new(&string_hash_ops);
  70         m->sessions = hashmap_new(&string_hash_ops);
  71         m->users = hashmap_new(NULL);
  72         m->inhibitors = hashmap_new(&string_hash_ops);
  73         m->buttons = hashmap_new(&string_hash_ops);
  74
  75         m->user_units = hashmap_new(&string_hash_ops);
  76         m->session_units = hashmap_new(&string_hash_ops);
  77
  78         m->busnames = set_new(&string_hash_ops);
  79
  80         if (!m->devices || !m->seats || !m->sessions || !m->users || !m->inhibitors || !m->buttons || !m->busnames ||
  81             !m->user_units || !m->session_units)
  82                 goto fail;
  83
  84         m->kill_exclude_users = strv_new("root", NULL);
  85         if (!m->kill_exclude_users)
  86                 goto fail;
  87
  88         m->udev = udev_new();
  89         if (!m->udev)
  90                 goto fail;
  91
  92         r = sd_event_default(&m->event);
  93         if (r < 0)
  94                 goto fail;
  95
  96         sd_event_set_watchdog(m->event, true);
  97
  98         return m;
  99
 100 fail:
 101         manager_free(m);
 102         return NULL;
 103 }
 104
 105 static void manager_free(Manager *m) {
 106         Session *session;
 107         User *u;
 108         Device *d;
 109         Seat *s;
 110         Inhibitor *i;
 111         Button *b;
 112
 113         assert(m);
 114
 115         while ((session = hashmap_first(m->sessions)))
 116                 session_free(session);
 117
 118         while ((u = hashmap_first(m->users)))
 119                 user_free(u);
 120
 121         while ((d = hashmap_first(m->devices)))
 122                 device_free(d);
 123
 124         while ((s = hashmap_first(m->seats)))
 125                 seat_free(s);
 126
 127         while ((i = hashmap_first(m->inhibitors)))
 128                 inhibitor_free(i);
 129
 130         while ((b = hashmap_first(m->buttons)))
 131                 button_free(b);
 132
 133         hashmap_free(m->devices);
 134         hashmap_free(m->seats);
 135         hashmap_free(m->sessions);
 136         hashmap_free(m->users);
 137         hashmap_free(m->inhibitors);
 138         hashmap_free(m->buttons);
 139
 140         hashmap_free(m->user_units);
 141         hashmap_free(m->session_units);
 142
 143         set_free_free(m->busnames);
 144
 145         sd_event_source_unref(m->idle_action_event_source);
 146         sd_event_source_unref(m->inhibit_timeout_source);
 147         sd_event_source_unref(m->scheduled_shutdown_timeout_source);
 148         sd_event_source_unref(m->nologin_timeout_source);
 149         sd_event_source_unref(m->wall_message_timeout_source);
 150
 151         sd_event_source_unref(m->console_active_event_source);
 152         sd_event_source_unref(m->udev_seat_event_source);
 153         sd_event_source_unref(m->udev_device_event_source);
 154         sd_event_source_unref(m->udev_vcsa_event_source);
 155         sd_event_source_unref(m->udev_button_event_source);
 156         sd_event_source_unref(m->lid_switch_ignore_event_source);
 157
 158         safe_close(m->console_active_fd);
 159
 160         if (m->udev_seat_monitor)
 161                 udev_monitor_unref(m->udev_seat_monitor);
 162         if (m->udev_device_monitor)
 163                 udev_monitor_unref(m->udev_device_monitor);
 164         if (m->udev_vcsa_monitor)
 165                 udev_monitor_unref(m->udev_vcsa_monitor);
 166         if (m->udev_button_monitor)
 167                 udev_monitor_unref(m->udev_button_monitor);
 168
 169         if (m->udev)
 170                 udev_unref(m->udev);
 171
 172         if (m->unlink_nologin)
 173                 unlink("/run/nologin");
 174
 175         bus_verify_polkit_async_registry_free(m->polkit_registry);
 176
 177         sd_bus_unref(m->bus);
 178         sd_event_unref(m->event);
 179
 180         safe_close(m->reserve_vt_fd);
 181
 182         strv_free(m->kill_only_users);
 183         strv_free(m->kill_exclude_users);
 184
 185         free(m->scheduled_shutdown_type);
 186         free(m->scheduled_shutdown_tty);
 187         free(m->wall_message);
 188         free(m->action_job);
 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_vcsa_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         const char *name;
 523
 524         assert(m);
 525
 526         d = udev_monitor_receive_device(m->udev_vcsa_monitor);
 527         if (!d)
 528                 return -ENOMEM;
 529
 530         name = udev_device_get_sysname(d);
 531
 532         /* Whenever a VCSA device is removed try to reallocate our
 533          * VTs, to make sure our auto VTs never go away. */
 534
 535         if (name && startswith(name, "vcsa") && streq_ptr(udev_device_get_action(d), "remove"))
 536                 seat_preallocate_vts(m->seat0);
 537
 538         return 0;
 539 }
 540
 541 static int manager_dispatch_button_udev(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 542         _cleanup_udev_device_unref_ struct udev_device *d = NULL;
 543         Manager *m = userdata;
 544
 545         assert(m);
 546
 547         d = udev_monitor_receive_device(m->udev_button_monitor);
 548         if (!d)
 549                 return -ENOMEM;
 550
 551         manager_process_button_device(m, d);
 552         return 0;
 553 }
 554
 555 static int manager_dispatch_console(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 556         Manager *m = userdata;
 557
 558         assert(m);
 559         assert(m->seat0);
 560         assert(m->console_active_fd == fd);
 561
 562         seat_read_active_vt(m->seat0);
 563         return 0;
 564 }
 565
 566 static int manager_reserve_vt(Manager *m) {
 567         _cleanup_free_ char *p = NULL;
 568
 569         assert(m);
 570
 571         if (m->reserve_vt <= 0)
 572                 return 0;
 573
 574         if (asprintf(&p, "/dev/tty%u", m->reserve_vt) < 0)
 575                 return log_oom();
 576
 577         m->reserve_vt_fd = open(p, O_RDWR|O_NOCTTY|O_CLOEXEC|O_NONBLOCK);
 578         if (m->reserve_vt_fd < 0) {
 579
 580                 /* Don't complain on VT-less systems */
 581                 if (errno != ENOENT)
 582                         log_warning_errno(errno, "Failed to pin reserved VT: %m");
 583                 return -errno;
 584         }
 585
 586         return 0;
 587 }
 588
 589 static int manager_connect_bus(Manager *m) {
 590         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 591         int r;
 592
 593         assert(m);
 594         assert(!m->bus);
 595
 596         r = sd_bus_default_system(&m->bus);
 597         if (r < 0)
 598                 return log_error_errno(r, "Failed to connect to system bus: %m");
 599
 600         r = sd_bus_add_object_vtable(m->bus, NULL, "/org/freedesktop/login1", "org.freedesktop.login1.Manager", manager_vtable, m);
 601         if (r < 0)
 602                 return log_error_errno(r, "Failed to add manager object vtable: %m");
 603
 604         r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/login1/seat", "org.freedesktop.login1.Seat", seat_vtable, seat_object_find, m);
 605         if (r < 0)
 606                 return log_error_errno(r, "Failed to add seat object vtable: %m");
 607
 608         r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/login1/seat", seat_node_enumerator, m);
 609         if (r < 0)
 610                 return log_error_errno(r, "Failed to add seat enumerator: %m");
 611
 612         r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/login1/session", "org.freedesktop.login1.Session", session_vtable, session_object_find, m);
 613         if (r < 0)
 614                 return log_error_errno(r, "Failed to add session object vtable: %m");
 615
 616         r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/login1/session", session_node_enumerator, m);
 617         if (r < 0)
 618                 return log_error_errno(r, "Failed to add session enumerator: %m");
 619
 620         r = sd_bus_add_fallback_vtable(m->bus, NULL, "/org/freedesktop/login1/user", "org.freedesktop.login1.User", user_vtable, user_object_find, m);
 621         if (r < 0)
 622                 return log_error_errno(r, "Failed to add user object vtable: %m");
 623
 624         r = sd_bus_add_node_enumerator(m->bus, NULL, "/org/freedesktop/login1/user", user_node_enumerator, m);
 625         if (r < 0)
 626                 return log_error_errno(r, "Failed to add user enumerator: %m");
 627
 628         r = sd_bus_add_match(m->bus,
 629                              NULL,
 630                              "type='signal',"
 631                              "sender='org.freedesktop.DBus',"
 632                              "interface='org.freedesktop.DBus',"
 633                              "member='NameOwnerChanged',"
 634                              "path='/org/freedesktop/DBus'",
 635                              match_name_owner_changed, m);
 636         if (r < 0)
 637                 return log_error_errno(r, "Failed to add match for NameOwnerChanged: %m");
 638
 639         r = sd_bus_add_match(m->bus,
 640                              NULL,
 641                              "type='signal',"
 642                              "sender='org.freedesktop.systemd1',"
 643                              "interface='org.freedesktop.systemd1.Manager',"
 644                              "member='JobRemoved',"
 645                              "path='/org/freedesktop/systemd1'",
 646                              match_job_removed, m);
 647         if (r < 0)
 648                 return log_error_errno(r, "Failed to add match for JobRemoved: %m");
 649
 650         r = sd_bus_add_match(m->bus,
 651                              NULL,
 652                              "type='signal',"
 653                              "sender='org.freedesktop.systemd1',"
 654                              "interface='org.freedesktop.systemd1.Manager',"
 655                              "member='UnitRemoved',"
 656                              "path='/org/freedesktop/systemd1'",
 657                              match_unit_removed, m);
 658         if (r < 0)
 659                 return log_error_errno(r, "Failed to add match for UnitRemoved: %m");
 660
 661         r = sd_bus_add_match(m->bus,
 662                              NULL,
 663                              "type='signal',"
 664                              "sender='org.freedesktop.systemd1',"
 665                              "interface='org.freedesktop.DBus.Properties',"
 666                              "member='PropertiesChanged'",
 667                              match_properties_changed, m);
 668         if (r < 0)
 669                 return log_error_errno(r, "Failed to add match for PropertiesChanged: %m");
 670
 671         r = sd_bus_add_match(m->bus,
 672                              NULL,
 673                              "type='signal',"
 674                              "sender='org.freedesktop.systemd1',"
 675                              "interface='org.freedesktop.systemd1.Manager',"
 676                              "member='Reloading',"
 677                              "path='/org/freedesktop/systemd1'",
 678                              match_reloading, m);
 679         if (r < 0)
 680                 return log_error_errno(r, "Failed to add match for Reloading: %m");
 681
 682         r = sd_bus_call_method(
 683                         m->bus,
 684                         "org.freedesktop.systemd1",
 685                         "/org/freedesktop/systemd1",
 686                         "org.freedesktop.systemd1.Manager",
 687                         "Subscribe",
 688                         &error,
 689                         NULL, NULL);
 690         if (r < 0) {
 691                 log_error("Failed to enable subscription: %s", bus_error_message(&error, r));
 692                 return r;
 693         }
 694
 695         r = sd_bus_request_name(m->bus, "org.freedesktop.login1", 0);
 696         if (r < 0)
 697                 return log_error_errno(r, "Failed to register name: %m");
 698
 699         r = sd_bus_attach_event(m->bus, m->event, 0);
 700         if (r < 0)
 701                 return log_error_errno(r, "Failed to attach bus to event loop: %m");
 702
 703         return 0;
 704 }
 705
 706 static int manager_vt_switch(sd_event_source *src, const struct signalfd_siginfo *si, void *data) {
 707         Manager *m = data;
 708         Session *active, *iter;
 709
 710         /*
 711          * We got a VT-switch signal and we have to acknowledge it immediately.
 712          * Preferably, we'd just use m->seat0->active->vtfd, but unfortunately,
 713          * old user-space might run multiple sessions on a single VT, *sigh*.
 714          * Therefore, we have to iterate all sessions and find one with a vtfd
 715          * on the requested VT.
 716          * As only VTs with active controllers have VT_PROCESS set, our current
 717          * notion of the active VT might be wrong (for instance if the switch
 718          * happens while we setup VT_PROCESS). Therefore, read the current VT
 719          * first and then use s->active->vtnr as reference. Note that this is
 720          * not racy, as no further VT-switch can happen as long as we're in
 721          * synchronous VT_PROCESS mode.
 722          */
 723
 724         assert(m->seat0);
 725         seat_read_active_vt(m->seat0);
 726
 727         active = m->seat0->active;
 728         if (!active || active->vtnr < 1) {
 729                 log_warning("Received VT_PROCESS signal without a registered session on that VT.");
 730                 return 0;
 731         }
 732
 733         if (active->vtfd >= 0) {
 734                 session_leave_vt(active);
 735         } else {
 736                 LIST_FOREACH(sessions_by_seat, iter, m->seat0->sessions) {
 737                         if (iter->vtnr == active->vtnr && iter->vtfd >= 0) {
 738                                 session_leave_vt(iter);
 739                                 break;
 740                         }
 741                 }
 742         }
 743
 744         return 0;
 745 }
 746
 747 static int manager_connect_console(Manager *m) {
 748         int r;
 749
 750         assert(m);
 751         assert(m->console_active_fd < 0);
 752
 753         /* On certain architectures (S390 and Xen, and containers),
 754            /dev/tty0 does not exist, so don't fail if we can't open
 755            it. */
 756         if (access("/dev/tty0", F_OK) < 0)
 757                 return 0;
 758
 759         m->console_active_fd = open("/sys/class/tty/tty0/active", O_RDONLY|O_NOCTTY|O_CLOEXEC);
 760         if (m->console_active_fd < 0) {
 761
 762                 /* On some systems the device node /dev/tty0 may exist
 763                  * even though /sys/class/tty/tty0 does not. */
 764                 if (errno == ENOENT)
 765                         return 0;
 766
 767                 log_error_errno(errno, "Failed to open /sys/class/tty/tty0/active: %m");
 768                 return -errno;
 769         }
 770
 771         r = sd_event_add_io(m->event, &m->console_active_event_source, m->console_active_fd, 0, manager_dispatch_console, m);
 772         if (r < 0) {
 773                 log_error("Failed to watch foreground console");
 774                 return r;
 775         }
 776
 777         /*
 778          * SIGRTMIN is used as global VT-release signal, SIGRTMIN + 1 is used
 779          * as VT-acquire signal. We ignore any acquire-events (yes, we still
 780          * have to provide a valid signal-number for it!) and acknowledge all
 781          * release events immediately.
 782          */
 783
 784         if (SIGRTMIN + 1 > SIGRTMAX) {
 785                 log_error("Not enough real-time signals available: %u-%u", SIGRTMIN, SIGRTMAX);
 786                 return -EINVAL;
 787         }
 788
 789         r = ignore_signals(SIGRTMIN + 1, -1);
 790         if (r < 0)
 791                 return log_error_errno(r, "Cannot ignore SIGRTMIN + 1: %m");
 792
 793         r = sigprocmask_many(SIG_BLOCK, SIGRTMIN, -1);
 794         if (r < 0)
 795                 return log_error_errno(r, "Cannot block SIGRTMIN: %m");
 796
 797         r = sd_event_add_signal(m->event, NULL, SIGRTMIN, manager_vt_switch, m);
 798         if (r < 0)
 799                 return r;
 800
 801         return 0;
 802 }
 803
 804 static int manager_connect_udev(Manager *m) {
 805         int r;
 806
 807         assert(m);
 808         assert(!m->udev_seat_monitor);
 809         assert(!m->udev_device_monitor);
 810         assert(!m->udev_vcsa_monitor);
 811         assert(!m->udev_button_monitor);
 812
 813         m->udev_seat_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 814         if (!m->udev_seat_monitor)
 815                 return -ENOMEM;
 816
 817         r = udev_monitor_filter_add_match_tag(m->udev_seat_monitor, "master-of-seat");
 818         if (r < 0)
 819                 return r;
 820
 821         r = udev_monitor_enable_receiving(m->udev_seat_monitor);
 822         if (r < 0)
 823                 return r;
 824
 825         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);
 826         if (r < 0)
 827                 return r;
 828
 829         m->udev_device_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 830         if (!m->udev_device_monitor)
 831                 return -ENOMEM;
 832
 833         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_device_monitor, "input", NULL);
 834         if (r < 0)
 835                 return r;
 836
 837         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_device_monitor, "graphics", NULL);
 838         if (r < 0)
 839                 return r;
 840
 841         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_device_monitor, "drm", NULL);
 842         if (r < 0)
 843                 return r;
 844
 845         r = udev_monitor_enable_receiving(m->udev_device_monitor);
 846         if (r < 0)
 847                 return r;
 848
 849         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);
 850         if (r < 0)
 851                 return r;
 852
 853         /* Don't watch keys if nobody cares */
 854         if (m->handle_power_key != HANDLE_IGNORE ||
 855             m->handle_suspend_key != HANDLE_IGNORE ||
 856             m->handle_hibernate_key != HANDLE_IGNORE ||
 857             m->handle_lid_switch != HANDLE_IGNORE ||
 858             m->handle_lid_switch_docked != HANDLE_IGNORE) {
 859
 860                 m->udev_button_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 861                 if (!m->udev_button_monitor)
 862                         return -ENOMEM;
 863
 864                 r = udev_monitor_filter_add_match_tag(m->udev_button_monitor, "power-switch");
 865                 if (r < 0)
 866                         return r;
 867
 868                 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_button_monitor, "input", NULL);
 869                 if (r < 0)
 870                         return r;
 871
 872                 r = udev_monitor_enable_receiving(m->udev_button_monitor);
 873                 if (r < 0)
 874                         return r;
 875
 876                 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);
 877                 if (r < 0)
 878                         return r;
 879         }
 880
 881         /* Don't bother watching VCSA devices, if nobody cares */
 882         if (m->n_autovts > 0 && m->console_active_fd >= 0) {
 883
 884                 m->udev_vcsa_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 885                 if (!m->udev_vcsa_monitor)
 886                         return -ENOMEM;
 887
 888                 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_vcsa_monitor, "vc", NULL);
 889                 if (r < 0)
 890                         return r;
 891
 892                 r = udev_monitor_enable_receiving(m->udev_vcsa_monitor);
 893                 if (r < 0)
 894                         return r;
 895
 896                 r = sd_event_add_io(m->event, &m->udev_vcsa_event_source, udev_monitor_get_fd(m->udev_vcsa_monitor), EPOLLIN, manager_dispatch_vcsa_udev, m);
 897                 if (r < 0)
 898                         return r;
 899         }
 900
 901         return 0;
 902 }
 903
 904 static void manager_gc(Manager *m, bool drop_not_started) {
 905         Seat *seat;
 906         Session *session;
 907         User *user;
 908
 909         assert(m);
 910
 911         while ((seat = m->seat_gc_queue)) {
 912                 LIST_REMOVE(gc_queue, m->seat_gc_queue, seat);
 913                 seat->in_gc_queue = false;
 914
 915                 if (!seat_check_gc(seat, drop_not_started)) {
 916                         seat_stop(seat, false);
 917                         seat_free(seat);
 918                 }
 919         }
 920
 921         while ((session = m->session_gc_queue)) {
 922                 LIST_REMOVE(gc_queue, m->session_gc_queue, session);
 923                 session->in_gc_queue = false;
 924
 925                 /* First, if we are not closing yet, initiate stopping */
 926                 if (!session_check_gc(session, drop_not_started) &&
 927                     session_get_state(session) != SESSION_CLOSING)
 928                         session_stop(session, false);
 929
 930                 /* Normally, this should make the session busy again,
 931                  * if it doesn't then let's get rid of it
 932                  * immediately */
 933                 if (!session_check_gc(session, drop_not_started)) {
 934                         session_finalize(session);
 935                         session_free(session);
 936                 }
 937         }
 938
 939         while ((user = m->user_gc_queue)) {
 940                 LIST_REMOVE(gc_queue, m->user_gc_queue, user);
 941                 user->in_gc_queue = false;
 942
 943                 /* First step: queue stop jobs */
 944                 if (!user_check_gc(user, drop_not_started))
 945                         user_stop(user, false);
 946
 947                 /* Second step: finalize user */
 948                 if (!user_check_gc(user, drop_not_started)) {
 949                         user_finalize(user);
 950                         user_free(user);
 951                 }
 952         }
 953 }
 954
 955 static int manager_dispatch_idle_action(sd_event_source *s, uint64_t t, void *userdata) {
 956         Manager *m = userdata;
 957         struct dual_timestamp since;
 958         usec_t n, elapse;
 959         int r;
 960
 961         assert(m);
 962
 963         if (m->idle_action == HANDLE_IGNORE ||
 964             m->idle_action_usec <= 0)
 965                 return 0;
 966
 967         n = now(CLOCK_MONOTONIC);
 968
 969         r = manager_get_idle_hint(m, &since);
 970         if (r <= 0)
 971                 /* Not idle. Let's check if after a timeout it might be idle then. */
 972                 elapse = n + m->idle_action_usec;
 973         else {
 974                 /* Idle! Let's see if it's time to do something, or if
 975                  * we shall sleep for longer. */
 976
 977                 if (n >= since.monotonic + m->idle_action_usec &&
 978                     (m->idle_action_not_before_usec <= 0 || n >= m->idle_action_not_before_usec + m->idle_action_usec)) {
 979                         log_info("System idle. Taking action.");
 980
 981                         manager_handle_action(m, 0, m->idle_action, false, false);
 982                         m->idle_action_not_before_usec = n;
 983                 }
 984
 985                 elapse = MAX(since.monotonic, m->idle_action_not_before_usec) + m->idle_action_usec;
 986         }
 987
 988         if (!m->idle_action_event_source) {
 989
 990                 r = sd_event_add_time(
 991                                 m->event,
 992                                 &m->idle_action_event_source,
 993                                 CLOCK_MONOTONIC,
 994                                 elapse, USEC_PER_SEC*30,
 995                                 manager_dispatch_idle_action, m);
 996                 if (r < 0)
 997                         return log_error_errno(r, "Failed to add idle event source: %m");
 998
 999                 r = sd_event_source_set_priority(m->idle_action_event_source, SD_EVENT_PRIORITY_IDLE+10);
1000                 if (r < 0)
1001                         return log_error_errno(r, "Failed to set idle event source priority: %m");
1002         } else {
1003                 r = sd_event_source_set_time(m->idle_action_event_source, elapse);
1004                 if (r < 0)
1005                         return log_error_errno(r, "Failed to set idle event timer: %m");
1006
1007                 r = sd_event_source_set_enabled(m->idle_action_event_source, SD_EVENT_ONESHOT);
1008                 if (r < 0)
1009                         return log_error_errno(r, "Failed to enable idle event timer: %m");
1010         }
1011
1012         return 0;
1013 }
1014
1015 static int manager_startup(Manager *m) {
1016         int r;
1017         Seat *seat;
1018         Session *session;
1019         User *user;
1020         Button *button;
1021         Inhibitor *inhibitor;
1022         Iterator i;
1023
1024         assert(m);
1025
1026         /* Connect to console */
1027         r = manager_connect_console(m);
1028         if (r < 0)
1029                 return r;
1030
1031         /* Connect to udev */
1032         r = manager_connect_udev(m);
1033         if (r < 0)
1034                 return log_error_errno(r, "Failed to create udev watchers: %m");
1035
1036         /* Connect to the bus */
1037         r = manager_connect_bus(m);
1038         if (r < 0)
1039                 return r;
1040
1041         /* Instantiate magic seat 0 */
1042         r = manager_add_seat(m, "seat0", &m->seat0);
1043         if (r < 0)
1044                 return log_error_errno(r, "Failed to add seat0: %m");
1045
1046         r = manager_set_lid_switch_ignore(m, 0 + m->holdoff_timeout_usec);
1047         if (r < 0)
1048                 log_warning_errno(r, "Failed to set up lid switch ignore event source: %m");
1049
1050         /* Deserialize state */
1051         r = manager_enumerate_devices(m);
1052         if (r < 0)
1053                 log_warning_errno(r, "Device enumeration failed: %m");
1054
1055         r = manager_enumerate_seats(m);
1056         if (r < 0)
1057                 log_warning_errno(r, "Seat enumeration failed: %m");
1058
1059         r = manager_enumerate_users(m);
1060         if (r < 0)
1061                 log_warning_errno(r, "User enumeration failed: %m");
1062
1063         r = manager_enumerate_sessions(m);
1064         if (r < 0)
1065                 log_warning_errno(r, "Session enumeration failed: %m");
1066
1067         r = manager_enumerate_inhibitors(m);
1068         if (r < 0)
1069                 log_warning_errno(r, "Inhibitor enumeration failed: %m");
1070
1071         r = manager_enumerate_buttons(m);
1072         if (r < 0)
1073                 log_warning_errno(r, "Button enumeration failed: %m");
1074
1075         /* Remove stale objects before we start them */
1076         manager_gc(m, false);
1077
1078         /* Reserve the special reserved VT */
1079         manager_reserve_vt(m);
1080
1081         /* And start everything */
1082         HASHMAP_FOREACH(seat, m->seats, i)
1083                 seat_start(seat);
1084
1085         HASHMAP_FOREACH(user, m->users, i)
1086                 user_start(user);
1087
1088         HASHMAP_FOREACH(session, m->sessions, i)
1089                 session_start(session);
1090
1091         HASHMAP_FOREACH(inhibitor, m->inhibitors, i)
1092                 inhibitor_start(inhibitor);
1093
1094         HASHMAP_FOREACH(button, m->buttons, i)
1095                 button_check_switches(button);
1096
1097         manager_dispatch_idle_action(NULL, 0, m);
1098
1099         return 0;
1100 }
1101
1102 static int manager_run(Manager *m) {
1103         int r;
1104
1105         assert(m);
1106
1107         for (;;) {
1108                 r = sd_event_get_state(m->event);
1109                 if (r < 0)
1110                         return r;
1111                 if (r == SD_EVENT_FINISHED)
1112                         return 0;
1113
1114                 manager_gc(m, true);
1115
1116                 r = sd_event_run(m->event, (uint64_t) -1);
1117                 if (r < 0)
1118                         return r;
1119         }
1120 }
1121
1122 static int manager_parse_config_file(Manager *m) {
1123         assert(m);
1124
1125         return config_parse_many("/etc/systemd/logind.conf",
1126                                  CONF_DIRS_NULSTR("systemd/logind.conf"),
1127                                  "Login\0",
1128                                  config_item_perf_lookup, logind_gperf_lookup,
1129                                  false, m);
1130 }
1131
1132 int main(int argc, char *argv[]) {
1133         Manager *m = NULL;
1134         int r;
1135
1136         log_set_target(LOG_TARGET_AUTO);
1137         log_set_facility(LOG_AUTH);
1138         log_parse_environment();
1139         log_open();
1140
1141         umask(0022);
1142
1143         if (argc != 1) {
1144                 log_error("This program takes no arguments.");
1145                 r = -EINVAL;
1146                 goto finish;
1147         }
1148
1149         /* Always create the directories people can create inotify
1150          * watches in. Note that some applications might check for the
1151          * existence of /run/systemd/seats/ to determine whether
1152          * logind is available, so please always make sure this check
1153          * stays in. */
1154         mkdir_label("/run/systemd/seats", 0755);
1155         mkdir_label("/run/systemd/users", 0755);
1156         mkdir_label("/run/systemd/sessions", 0755);
1157
1158         m = manager_new();
1159         if (!m) {
1160                 r = log_oom();
1161                 goto finish;
1162         }
1163
1164         manager_parse_config_file(m);
1165
1166         r = manager_startup(m);
1167         if (r < 0) {
1168                 log_error_errno(r, "Failed to fully start up daemon: %m");
1169                 goto finish;
1170         }
1171
1172         log_debug("logind running as pid "PID_FMT, getpid());
1173
1174         sd_notify(false,
1175                   "READY=1\n"
1176                   "STATUS=Processing requests...");
1177
1178         r = manager_run(m);
1179
1180         log_debug("logind stopped as pid "PID_FMT, getpid());
1181
1182 finish:
1183         sd_notify(false,
1184                   "STOPPING=1\n"
1185                   "STATUS=Shutting down...");
1186
1187         if (m)
1188                 manager_free(m);
1189
1190         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1191 }