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