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