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                 log_warning_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                 log_warning_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                 log_warning_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                 log_warning_errno(r, "Failed to add match for Reloading: %m");
 662
 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_notice("Failed to enable subscription: %s", bus_error_message(&error, r));
 673
 674         r = sd_bus_request_name(m->bus, "org.freedesktop.login1", 0);
 675         if (r < 0)
 676                 return log_error_errno(r, "Failed to register name: %m");
 677
 678         r = sd_bus_attach_event(m->bus, m->event, 0);
 679         if (r < 0)
 680                 return log_error_errno(r, "Failed to attach bus to event loop: %m");
 681
 682         return 0;
 683 }
 684
 685 static int manager_vt_switch(sd_event_source *src, const struct signalfd_siginfo *si, void *data) {
 686         Manager *m = data;
 687         Session *active, *iter;
 688
 689         /*
 690          * We got a VT-switch signal and we have to acknowledge it immediately.
 691          * Preferably, we'd just use m->seat0->active->vtfd, but unfortunately,
 692          * old user-space might run multiple sessions on a single VT, *sigh*.
 693          * Therefore, we have to iterate all sessions and find one with a vtfd
 694          * on the requested VT.
 695          * As only VTs with active controllers have VT_PROCESS set, our current
 696          * notion of the active VT might be wrong (for instance if the switch
 697          * happens while we setup VT_PROCESS). Therefore, read the current VT
 698          * first and then use s->active->vtnr as reference. Note that this is
 699          * not racy, as no further VT-switch can happen as long as we're in
 700          * synchronous VT_PROCESS mode.
 701          */
 702
 703         assert(m->seat0);
 704         seat_read_active_vt(m->seat0);
 705
 706         active = m->seat0->active;
 707         if (!active || active->vtnr < 1) {
 708                 log_warning("Received VT_PROCESS signal without a registered session on that VT.");
 709                 return 0;
 710         }
 711
 712         if (active->vtfd >= 0) {
 713                 session_leave_vt(active);
 714         } else {
 715                 LIST_FOREACH(sessions_by_seat, iter, m->seat0->sessions) {
 716                         if (iter->vtnr == active->vtnr && iter->vtfd >= 0) {
 717                                 session_leave_vt(iter);
 718                                 break;
 719                         }
 720                 }
 721         }
 722
 723         return 0;
 724 }
 725
 726 static int manager_connect_console(Manager *m) {
 727         int r;
 728
 729         assert(m);
 730         assert(m->console_active_fd < 0);
 731
 732         /* On certain architectures (S390 and Xen, and containers),
 733            /dev/tty0 does not exist, so don't fail if we can't open
 734            it. */
 735         if (access("/dev/tty0", F_OK) < 0)
 736                 return 0;
 737
 738         m->console_active_fd = open("/sys/class/tty/tty0/active", O_RDONLY|O_NOCTTY|O_CLOEXEC);
 739         if (m->console_active_fd < 0) {
 740
 741                 /* On some systems the device node /dev/tty0 may exist
 742                  * even though /sys/class/tty/tty0 does not. */
 743                 if (errno == ENOENT)
 744                         return 0;
 745
 746                 log_error_errno(errno, "Failed to open /sys/class/tty/tty0/active: %m");
 747                 return -errno;
 748         }
 749
 750         r = sd_event_add_io(m->event, &m->console_active_event_source, m->console_active_fd, 0, manager_dispatch_console, m);
 751         if (r < 0) {
 752                 log_error("Failed to watch foreground console");
 753                 return r;
 754         }
 755
 756         /*
 757          * SIGRTMIN is used as global VT-release signal, SIGRTMIN + 1 is used
 758          * as VT-acquire signal. We ignore any acquire-events (yes, we still
 759          * have to provide a valid signal-number for it!) and acknowledge all
 760          * release events immediately.
 761          */
 762
 763         if (SIGRTMIN + 1 > SIGRTMAX) {
 764                 log_error("Not enough real-time signals available: %u-%u", SIGRTMIN, SIGRTMAX);
 765                 return -EINVAL;
 766         }
 767
 768         r = ignore_signals(SIGRTMIN + 1, -1);
 769         if (r < 0)
 770                 return log_error_errno(r, "Cannot ignore SIGRTMIN + 1: %m");
 771
 772         r = sigprocmask_many(SIG_BLOCK, SIGRTMIN, -1);
 773         if (r < 0)
 774                 return log_error_errno(r, "Cannot block SIGRTMIN: %m");
 775
 776         r = sd_event_add_signal(m->event, NULL, SIGRTMIN, manager_vt_switch, m);
 777         if (r < 0)
 778                 return r;
 779
 780         return 0;
 781 }
 782
 783 static int manager_connect_udev(Manager *m) {
 784         int r;
 785
 786         assert(m);
 787         assert(!m->udev_seat_monitor);
 788         assert(!m->udev_device_monitor);
 789         assert(!m->udev_vcsa_monitor);
 790         assert(!m->udev_button_monitor);
 791
 792         m->udev_seat_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 793         if (!m->udev_seat_monitor)
 794                 return -ENOMEM;
 795
 796         r = udev_monitor_filter_add_match_tag(m->udev_seat_monitor, "master-of-seat");
 797         if (r < 0)
 798                 return r;
 799
 800         r = udev_monitor_enable_receiving(m->udev_seat_monitor);
 801         if (r < 0)
 802                 return r;
 803
 804         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);
 805         if (r < 0)
 806                 return r;
 807
 808         m->udev_device_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 809         if (!m->udev_device_monitor)
 810                 return -ENOMEM;
 811
 812         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_device_monitor, "input", NULL);
 813         if (r < 0)
 814                 return r;
 815
 816         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_device_monitor, "graphics", NULL);
 817         if (r < 0)
 818                 return r;
 819
 820         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_device_monitor, "drm", NULL);
 821         if (r < 0)
 822                 return r;
 823
 824         r = udev_monitor_enable_receiving(m->udev_device_monitor);
 825         if (r < 0)
 826                 return r;
 827
 828         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);
 829         if (r < 0)
 830                 return r;
 831
 832         /* Don't watch keys if nobody cares */
 833         if (m->handle_power_key != HANDLE_IGNORE ||
 834             m->handle_suspend_key != HANDLE_IGNORE ||
 835             m->handle_hibernate_key != HANDLE_IGNORE ||
 836             m->handle_lid_switch != HANDLE_IGNORE ||
 837             m->handle_lid_switch_docked != HANDLE_IGNORE) {
 838
 839                 m->udev_button_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 840                 if (!m->udev_button_monitor)
 841                         return -ENOMEM;
 842
 843                 r = udev_monitor_filter_add_match_tag(m->udev_button_monitor, "power-switch");
 844                 if (r < 0)
 845                         return r;
 846
 847                 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_button_monitor, "input", NULL);
 848                 if (r < 0)
 849                         return r;
 850
 851                 r = udev_monitor_enable_receiving(m->udev_button_monitor);
 852                 if (r < 0)
 853                         return r;
 854
 855                 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);
 856                 if (r < 0)
 857                         return r;
 858         }
 859
 860         /* Don't bother watching VCSA devices, if nobody cares */
 861         if (m->n_autovts > 0 && m->console_active_fd >= 0) {
 862
 863                 m->udev_vcsa_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 864                 if (!m->udev_vcsa_monitor)
 865                         return -ENOMEM;
 866
 867                 r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_vcsa_monitor, "vc", NULL);
 868                 if (r < 0)
 869                         return r;
 870
 871                 r = udev_monitor_enable_receiving(m->udev_vcsa_monitor);
 872                 if (r < 0)
 873                         return r;
 874
 875                 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);
 876                 if (r < 0)
 877                         return r;
 878         }
 879
 880         return 0;
 881 }
 882
 883 static void manager_gc(Manager *m, bool drop_not_started) {
 884         Seat *seat;
 885         Session *session;
 886         User *user;
 887
 888         assert(m);
 889
 890         while ((seat = m->seat_gc_queue)) {
 891                 LIST_REMOVE(gc_queue, m->seat_gc_queue, seat);
 892                 seat->in_gc_queue = false;
 893
 894                 if (!seat_check_gc(seat, drop_not_started)) {
 895                         seat_stop(seat, false);
 896                         seat_free(seat);
 897                 }
 898         }
 899
 900         while ((session = m->session_gc_queue)) {
 901                 LIST_REMOVE(gc_queue, m->session_gc_queue, session);
 902                 session->in_gc_queue = false;
 903
 904                 /* First, if we are not closing yet, initiate stopping */
 905                 if (!session_check_gc(session, drop_not_started) &&
 906                     session_get_state(session) != SESSION_CLOSING)
 907                         session_stop(session, false);
 908
 909                 /* Normally, this should make the session referenced
 910                  * again, if it doesn't then let's get rid of it
 911                  * immediately */
 912                 if (!session_check_gc(session, drop_not_started)) {
 913                         session_finalize(session);
 914                         session_free(session);
 915                 }
 916         }
 917
 918         while ((user = m->user_gc_queue)) {
 919                 LIST_REMOVE(gc_queue, m->user_gc_queue, user);
 920                 user->in_gc_queue = false;
 921
 922                 /* First step: queue stop jobs */
 923                 if (!user_check_gc(user, drop_not_started))
 924                         user_stop(user, false);
 925
 926                 /* Second step: finalize user */
 927                 if (!user_check_gc(user, drop_not_started)) {
 928                         user_finalize(user);
 929                         user_free(user);
 930                 }
 931         }
 932 }
 933
 934 static int manager_dispatch_idle_action(sd_event_source *s, uint64_t t, void *userdata) {
 935         Manager *m = userdata;
 936         struct dual_timestamp since;
 937         usec_t n, elapse;
 938         int r;
 939
 940         assert(m);
 941
 942         if (m->idle_action == HANDLE_IGNORE ||
 943             m->idle_action_usec <= 0)
 944                 return 0;
 945
 946         n = now(CLOCK_MONOTONIC);
 947
 948         r = manager_get_idle_hint(m, &since);
 949         if (r <= 0)
 950                 /* Not idle. Let's check if after a timeout it might be idle then. */
 951                 elapse = n + m->idle_action_usec;
 952         else {
 953                 /* Idle! Let's see if it's time to do something, or if
 954                  * we shall sleep for longer. */
 955
 956                 if (n >= since.monotonic + m->idle_action_usec &&
 957                     (m->idle_action_not_before_usec <= 0 || n >= m->idle_action_not_before_usec + m->idle_action_usec)) {
 958                         log_info("System idle. Taking action.");
 959
 960                         manager_handle_action(m, 0, m->idle_action, false, false);
 961                         m->idle_action_not_before_usec = n;
 962                 }
 963
 964                 elapse = MAX(since.monotonic, m->idle_action_not_before_usec) + m->idle_action_usec;
 965         }
 966
 967         if (!m->idle_action_event_source) {
 968
 969                 r = sd_event_add_time(
 970                                 m->event,
 971                                 &m->idle_action_event_source,
 972                                 CLOCK_MONOTONIC,
 973                                 elapse, USEC_PER_SEC*30,
 974                                 manager_dispatch_idle_action, m);
 975                 if (r < 0)
 976                         return log_error_errno(r, "Failed to add idle event source: %m");
 977
 978                 r = sd_event_source_set_priority(m->idle_action_event_source, SD_EVENT_PRIORITY_IDLE+10);
 979                 if (r < 0)
 980                         return log_error_errno(r, "Failed to set idle event source priority: %m");
 981         } else {
 982                 r = sd_event_source_set_time(m->idle_action_event_source, elapse);
 983                 if (r < 0)
 984                         return log_error_errno(r, "Failed to set idle event timer: %m");
 985
 986                 r = sd_event_source_set_enabled(m->idle_action_event_source, SD_EVENT_ONESHOT);
 987                 if (r < 0)
 988                         return log_error_errno(r, "Failed to enable idle event timer: %m");
 989         }
 990
 991         return 0;
 992 }
 993
 994 static int manager_startup(Manager *m) {
 995         int r;
 996         Seat *seat;
 997         Session *session;
 998         User *user;
 999         Button *button;
1000         Inhibitor *inhibitor;
1001         Iterator i;
1002
1003         assert(m);
1004
1005         /* Connect to console */
1006         r = manager_connect_console(m);
1007         if (r < 0)
1008                 return r;
1009
1010         /* Connect to udev */
1011         r = manager_connect_udev(m);
1012         if (r < 0)
1013                 return log_error_errno(r, "Failed to create udev watchers: %m");
1014
1015         /* Connect to the bus */
1016         r = manager_connect_bus(m);
1017         if (r < 0)
1018                 return r;
1019
1020         /* Instantiate magic seat 0 */
1021         r = manager_add_seat(m, "seat0", &m->seat0);
1022         if (r < 0)
1023                 return log_error_errno(r, "Failed to add seat0: %m");
1024
1025         r = manager_set_lid_switch_ignore(m, 0 + m->holdoff_timeout_usec);
1026         if (r < 0)
1027                 log_warning_errno(r, "Failed to set up lid switch ignore event source: %m");
1028
1029         /* Deserialize state */
1030         r = manager_enumerate_devices(m);
1031         if (r < 0)
1032                 log_warning_errno(r, "Device enumeration failed: %m");
1033
1034         r = manager_enumerate_seats(m);
1035         if (r < 0)
1036                 log_warning_errno(r, "Seat enumeration failed: %m");
1037
1038         r = manager_enumerate_users(m);
1039         if (r < 0)
1040                 log_warning_errno(r, "User enumeration failed: %m");
1041
1042         r = manager_enumerate_sessions(m);
1043         if (r < 0)
1044                 log_warning_errno(r, "Session enumeration failed: %m");
1045
1046         r = manager_enumerate_inhibitors(m);
1047         if (r < 0)
1048                 log_warning_errno(r, "Inhibitor enumeration failed: %m");
1049
1050         r = manager_enumerate_buttons(m);
1051         if (r < 0)
1052                 log_warning_errno(r, "Button enumeration failed: %m");
1053
1054         /* Remove stale objects before we start them */
1055         manager_gc(m, false);
1056
1057         /* Reserve the special reserved VT */
1058         manager_reserve_vt(m);
1059
1060         /* And start everything */
1061         HASHMAP_FOREACH(seat, m->seats, i)
1062                 seat_start(seat);
1063
1064         HASHMAP_FOREACH(user, m->users, i)
1065                 user_start(user);
1066
1067         HASHMAP_FOREACH(session, m->sessions, i)
1068                 session_start(session);
1069
1070         HASHMAP_FOREACH(inhibitor, m->inhibitors, i)
1071                 inhibitor_start(inhibitor);
1072
1073         HASHMAP_FOREACH(button, m->buttons, i)
1074                 button_check_switches(button);
1075
1076         manager_dispatch_idle_action(NULL, 0, m);
1077
1078         return 0;
1079 }
1080
1081 static int manager_run(Manager *m) {
1082         int r;
1083
1084         assert(m);
1085
1086         for (;;) {
1087                 r = sd_event_get_state(m->event);
1088                 if (r < 0)
1089                         return r;
1090                 if (r == SD_EVENT_FINISHED)
1091                         return 0;
1092
1093                 manager_gc(m, true);
1094
1095                 r = sd_event_run(m->event, (uint64_t) -1);
1096                 if (r < 0)
1097                         return r;
1098         }
1099 }
1100
1101 static int manager_parse_config_file(Manager *m) {
1102         assert(m);
1103
1104         return config_parse_many("/etc/systemd/logind.conf",
1105                                  CONF_DIRS_NULSTR("systemd/logind.conf"),
1106                                  "Login\0",
1107                                  config_item_perf_lookup, logind_gperf_lookup,
1108                                  false, m);
1109 }
1110
1111 int main(int argc, char *argv[]) {
1112         Manager *m = NULL;
1113         int r;
1114
1115         log_set_target(LOG_TARGET_AUTO);
1116         log_set_facility(LOG_AUTH);
1117         log_parse_environment();
1118         log_open();
1119
1120         umask(0022);
1121
1122         if (argc != 1) {
1123                 log_error("This program takes no arguments.");
1124                 r = -EINVAL;
1125                 goto finish;
1126         }
1127
1128         /* Always create the directories people can create inotify
1129          * watches in. Note that some applications might check for the
1130          * existence of /run/systemd/seats/ to determine whether
1131          * logind is available, so please always make sure this check
1132          * stays in. */
1133         r = mkdir_label("/run/systemd", 0755);
1134         if ( (r < 0) && (-EEXIST != r) )
1135                 return log_error_errno(r, "Failed to create /run/systemd : %m");
1136         r = mkdir_label("/run/systemd/seats", 0755);
1137         if ( r < 0 && (-EEXIST != r) )
1138                 return log_error_errno(r, "Failed to create /run/systemd/seats : %m");
1139         r = mkdir_label("/run/systemd/users", 0755);
1140         if ( r < 0 && (-EEXIST != r) )
1141                 return log_error_errno(r, "Failed to create /run/systemd/users : %m");
1142         r = mkdir_label("/run/systemd/sessions", 0755);
1143         if ( r < 0 && (-EEXIST != r) )
1144                 return log_error_errno(r, "Failed to create /run/systemd/sessions : %m");
1145         r = mkdir_label("/run/systemd/machines", 0755);
1146         if ( r < 0 && (-EEXIST != r) )
1147                 return log_error_errno(r, "Failed to create /run/systemd/machines : %m");
1148
1149         m = manager_new();
1150         if (!m) {
1151                 r = log_oom();
1152                 goto finish;
1153         }
1154
1155         manager_parse_config_file(m);
1156
1157         r = manager_startup(m);
1158         if (r < 0) {
1159                 log_error_errno(r, "Failed to fully start up daemon: %m");
1160                 goto finish;
1161         }
1162
1163         log_debug("logind running as pid "PID_FMT, getpid());
1164
1165         sd_notify(false,
1166                   "READY=1\n"
1167                   "STATUS=Processing requests...");
1168
1169         r = manager_run(m);
1170
1171         log_debug("logind stopped as pid "PID_FMT, getpid());
1172
1173 finish:
1174         sd_notify(false,
1175                   "STOPPING=1\n"
1176                   "STATUS=Shutting down...");
1177
1178                 manager_free(m);
1179
1180         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1181 }