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