src/login/logind.c

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