src/login/logind.c

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