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