src/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 General Public License as published by
  10   the Free Software Foundation; either version 2 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   General Public License for more details.
  17
  18   You should have received a copy of the GNU General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <errno.h>
  23 #include <pwd.h>
  24 #include <libudev.h>
  25 #include <fcntl.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <sys/epoll.h>
  29 #include <sys/ioctl.h>
  30 #include <linux/vt.h>
  31
  32 #include "logind.h"
  33 #include "dbus-common.h"
  34 #include "dbus-loop.h"
  35
  36 enum {
  37         FD_UDEV,
  38         FD_CONSOLE,
  39         FD_BUS
  40 };
  41
  42 Manager *manager_new(void) {
  43         Manager *m;
  44
  45         m = new0(Manager, 1);
  46         if (!m)
  47                 return NULL;
  48
  49         m->console_active_fd = -1;
  50         m->bus_fd = -1;
  51         m->udev_fd = -1;
  52         m->epoll_fd = -1;
  53         m->n_autovts = 6;
  54
  55         m->devices = hashmap_new(string_hash_func, string_compare_func);
  56         m->seats = hashmap_new(string_hash_func, string_compare_func);
  57         m->sessions = hashmap_new(string_hash_func, string_compare_func);
  58         m->users = hashmap_new(trivial_hash_func, trivial_compare_func);
  59
  60         if (!m->devices || !m->seats || !m->sessions || !m->users) {
  61                 manager_free(m);
  62                 return NULL;
  63         }
  64
  65         m->udev = udev_new();
  66         if (!m->udev) {
  67                 manager_free(m);
  68                 return NULL;
  69         }
  70
  71         if (cg_get_user_path(&m->cgroup_path) < 0) {
  72                 manager_free(m);
  73                 return NULL;
  74         }
  75
  76         return m;
  77 }
  78
  79 void manager_free(Manager *m) {
  80         Session *session;
  81         User *u;
  82         Device *d;
  83         Seat *s;
  84
  85         assert(m);
  86
  87         while ((session = hashmap_first(m->sessions)))
  88                 session_free(session);
  89
  90         while ((u = hashmap_first(m->users)))
  91                 user_free(u);
  92
  93         while ((d = hashmap_first(m->devices)))
  94                 device_free(d);
  95
  96         while ((s = hashmap_first(m->seats)))
  97                 seat_free(s);
  98
  99         hashmap_free(m->sessions);
 100         hashmap_free(m->users);
 101         hashmap_free(m->devices);
 102         hashmap_free(m->seats);
 103
 104         if (m->console_active_fd >= 0)
 105                 close_nointr_nofail(m->console_active_fd);
 106
 107         if (m->udev_monitor)
 108                 udev_monitor_unref(m->udev_monitor);
 109
 110         if (m->udev)
 111                 udev_unref(m->udev);
 112
 113         if (m->bus) {
 114                 dbus_connection_flush(m->bus);
 115                 dbus_connection_close(m->bus);
 116                 dbus_connection_unref(m->bus);
 117         }
 118
 119         if (m->bus_fd >= 0)
 120                 close_nointr_nofail(m->bus_fd);
 121
 122         if (m->epoll_fd >= 0)
 123                 close_nointr_nofail(m->epoll_fd);
 124
 125         free(m->cgroup_path);
 126         free(m);
 127 }
 128
 129 int manager_add_device(Manager *m, const char *sysfs, Device **_device) {
 130         Device *d;
 131
 132         assert(m);
 133         assert(sysfs);
 134
 135         d = hashmap_get(m->devices, sysfs);
 136         if (d) {
 137                 if (_device)
 138                         *_device = d;
 139
 140                 return 0;
 141         }
 142
 143         d = device_new(m, sysfs);
 144         if (!d)
 145                 return -ENOMEM;
 146
 147         if (_device)
 148                 *_device = d;
 149
 150         return 0;
 151 }
 152
 153 int manager_add_seat(Manager *m, const char *id, Seat **_seat) {
 154         Seat *s;
 155
 156         assert(m);
 157         assert(id);
 158
 159         s = hashmap_get(m->seats, id);
 160         if (s) {
 161                 if (_seat)
 162                         *_seat = s;
 163
 164                 return 0;
 165         }
 166
 167         s = seat_new(m, id);
 168         if (!s)
 169                 return -ENOMEM;
 170
 171         if (_seat)
 172                 *_seat = s;
 173
 174         return 0;
 175 }
 176
 177 int manager_add_session(Manager *m, User *u, const char *id, Session **_session) {
 178         Session *s;
 179
 180         assert(m);
 181         assert(id);
 182
 183         s = hashmap_get(m->sessions, id);
 184         if (s) {
 185                 if (_session)
 186                         *_session = s;
 187
 188                 return 0;
 189         }
 190
 191         s = session_new(m, u, id);
 192         if (!s)
 193                 return -ENOMEM;
 194
 195         if (_session)
 196                 *_session = s;
 197
 198         return 0;
 199 }
 200
 201 int manager_add_user(Manager *m, uid_t uid, gid_t gid, const char *name, User **_user) {
 202         User *u;
 203
 204         assert(m);
 205         assert(name);
 206
 207         u = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
 208         if (u) {
 209                 if (_user)
 210                         *_user = u;
 211
 212                 return 0;
 213         }
 214
 215         u = user_new(m, uid, gid, name);
 216         if (!u)
 217                 return -ENOMEM;
 218
 219         if (_user)
 220                 *_user = u;
 221
 222         return 0;
 223 }
 224
 225 int manager_add_user_by_name(Manager *m, const char *name, User **_user) {
 226         struct passwd *p;
 227
 228         assert(m);
 229         assert(name);
 230
 231         errno = 0;
 232         p = getpwnam(name);
 233         if (!p)
 234                 return errno ? -errno : -ENOENT;
 235
 236         return manager_add_user(m, p->pw_uid, p->pw_gid, name, _user);
 237 }
 238
 239 int manager_add_user_by_uid(Manager *m, uid_t uid, User **_user) {
 240         struct passwd *p;
 241
 242         assert(m);
 243
 244         errno = 0;
 245         p = getpwuid(uid);
 246         if (!p)
 247                 return errno ? -errno : -ENOENT;
 248
 249         return manager_add_user(m, uid, p->pw_gid, p->pw_name, _user);
 250 }
 251
 252 int manager_process_device(Manager *m, struct udev_device *d) {
 253         Device *device;
 254         int r;
 255
 256         assert(m);
 257
 258         /* FIXME: drop this check as soon as libudev's enum support
 259          * honours tags and subsystem matches at the same time */
 260         if (!streq_ptr(udev_device_get_subsystem(d), "graphics"))
 261                 return 0;
 262
 263         if (streq_ptr(udev_device_get_action(d), "remove")) {
 264
 265                 /* FIXME: use syspath instead of sysname here, as soon as fb driver is fixed */
 266                 device = hashmap_get(m->devices, udev_device_get_sysname(d));
 267                 if (!device)
 268                         return 0;
 269
 270                 seat_add_to_gc_queue(device->seat);
 271                 device_free(device);
 272
 273         } else {
 274                 const char *sn;
 275                 Seat *seat;
 276
 277                 sn = udev_device_get_property_value(d, "ID_SEAT");
 278                 if (!sn)
 279                         sn = "seat0";
 280
 281                 if (!seat_name_is_valid(sn)) {
 282                         log_warning("Device with invalid seat name %s found, ignoring.", sn);
 283                         return 0;
 284                 }
 285
 286                 r = manager_add_device(m, udev_device_get_sysname(d), &device);
 287                 if (r < 0)
 288                         return r;
 289
 290                 r = manager_add_seat(m, sn, &seat);
 291                 if (r < 0) {
 292                         if (!device->seat)
 293                                 device_free(device);
 294
 295                         return r;
 296                 }
 297
 298                 device_attach(device, seat);
 299                 seat_start(seat);
 300         }
 301
 302         return 0;
 303 }
 304
 305 int manager_enumerate_devices(Manager *m) {
 306         struct udev_list_entry *item = NULL, *first = NULL;
 307         struct udev_enumerate *e;
 308         int r;
 309
 310         assert(m);
 311
 312         /* Loads devices from udev and creates seats for them as
 313          * necessary */
 314
 315         e = udev_enumerate_new(m->udev);
 316         if (!e) {
 317                 r = -ENOMEM;
 318                 goto finish;
 319         }
 320
 321         r = udev_enumerate_add_match_subsystem(e, "graphics");
 322         if (r < 0)
 323                 goto finish;
 324
 325         r = udev_enumerate_add_match_tag(e, "seat");
 326         if (r < 0)
 327                 goto finish;
 328
 329         r = udev_enumerate_scan_devices(e);
 330         if (r < 0)
 331                 goto finish;
 332
 333         first = udev_enumerate_get_list_entry(e);
 334         udev_list_entry_foreach(item, first) {
 335                 struct udev_device *d;
 336                 int k;
 337
 338                 d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));
 339                 if (!d) {
 340                         r = -ENOMEM;
 341                         goto finish;
 342                 }
 343
 344                 k = manager_process_device(m, d);
 345                 udev_device_unref(d);
 346
 347                 if (k < 0)
 348                         r = k;
 349         }
 350
 351 finish:
 352         if (e)
 353                 udev_enumerate_unref(e);
 354
 355         return r;
 356 }
 357
 358 int manager_enumerate_seats(Manager *m) {
 359         DIR *d;
 360         struct dirent *de;
 361         int r = 0;
 362
 363         assert(m);
 364
 365         /* This loads data about seats stored on disk, but does not
 366          * actually create any seats. Removes data of seats that no
 367          * longer exist. */
 368
 369         d = opendir("/run/systemd/seats");
 370         if (!d) {
 371                 if (errno == ENOENT)
 372                         return 0;
 373
 374                 log_error("Failed to open /run/systemd/seats: %m");
 375                 return -errno;
 376         }
 377
 378         while ((de = readdir(d))) {
 379                 Seat *s;
 380                 int k;
 381
 382                 if (!dirent_is_file(de))
 383                         continue;
 384
 385                 s = hashmap_get(m->seats, de->d_name);
 386                 if (!s) {
 387                         unlinkat(dirfd(d), de->d_name, 0);
 388                         continue;
 389                 }
 390
 391                 k = seat_load(s);
 392                 if (k < 0)
 393                         r = k;
 394         }
 395
 396         closedir(d);
 397
 398         return r;
 399 }
 400
 401 static int manager_enumerate_users_from_cgroup(Manager *m) {
 402         int r = 0;
 403         char *name;
 404         DIR *d;
 405
 406         r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_path, &d);
 407         if (r < 0) {
 408                 if (r == -ENOENT)
 409                         return 0;
 410
 411                 log_error("Failed to open %s: %s", m->cgroup_path, strerror(-r));
 412                 return r;
 413         }
 414
 415         while ((r = cg_read_subgroup(d, &name)) > 0) {
 416                 User *user;
 417                 int k;
 418
 419                 k = manager_add_user_by_name(m, name, &user);
 420                 if (k < 0) {
 421                         free(name);
 422                         r = k;
 423                         continue;
 424                 }
 425
 426                 user_add_to_gc_queue(user);
 427
 428                 if (!user->cgroup_path)
 429                         if (asprintf(&user->cgroup_path, "%s/%s", m->cgroup_path, name) < 0) {
 430                                 r = -ENOMEM;
 431                                 free(name);
 432                                 break;
 433                         }
 434
 435                 free(name);
 436         }
 437
 438         closedir(d);
 439
 440         return r;
 441 }
 442
 443
 444 static int manager_enumerate_linger_users(Manager *m) {
 445         DIR *d;
 446         struct dirent *de;
 447         int r = 0;
 448
 449         d = opendir("/var/lib/systemd/linger");
 450         if (!d) {
 451                 if (errno == ENOENT)
 452                         return 0;
 453
 454                 log_error("Failed to open /var/lib/systemd/linger/: %m");
 455                 return -errno;
 456         }
 457
 458         while ((de = readdir(d))) {
 459                 int k;
 460
 461                 if (!dirent_is_file(de))
 462                         continue;
 463
 464                 k = manager_add_user_by_name(m, de->d_name, NULL);
 465                 if (k < 0) {
 466                         log_notice("Couldn't add lingering user %s: %s", de->d_name, strerror(-k));
 467                         r = k;
 468                 }
 469         }
 470
 471         closedir(d);
 472
 473         return r;
 474 }
 475
 476 int manager_enumerate_users(Manager *m) {
 477         DIR *d;
 478         struct dirent *de;
 479         int r, k;
 480
 481         assert(m);
 482
 483         /* First, enumerate user cgroups */
 484         r = manager_enumerate_users_from_cgroup(m);
 485
 486         /* Second, add lingering users on top */
 487         k = manager_enumerate_linger_users(m);
 488         if (k < 0)
 489                 r = k;
 490
 491         /* Third, read in user data stored on disk */
 492         d = opendir("/run/systemd/users");
 493         if (!d) {
 494                 if (errno == ENOENT)
 495                         return 0;
 496
 497                 log_error("Failed to open /run/systemd/users: %m");
 498                 return -errno;
 499         }
 500
 501         while ((de = readdir(d))) {
 502                 unsigned long ul;
 503                 User *u;
 504
 505                 if (!dirent_is_file(de))
 506                         continue;
 507
 508                 k = safe_atolu(de->d_name, &ul);
 509                 if (k < 0) {
 510                         log_error("Failed to parse file name %s: %s", de->d_name, strerror(-k));
 511                         continue;
 512                 }
 513
 514                 u = hashmap_get(m->users, ULONG_TO_PTR(ul));
 515                 if (!u) {
 516                         unlinkat(dirfd(d), de->d_name, 0);
 517                         continue;
 518                 }
 519
 520                 k = user_load(u);
 521                 if (k < 0)
 522                         r = k;
 523         }
 524
 525         closedir(d);
 526
 527         return r;
 528 }
 529
 530 static int manager_enumerate_sessions_from_cgroup(Manager *m) {
 531         User *u;
 532         Iterator i;
 533         int r = 0;
 534
 535         HASHMAP_FOREACH(u, m->users, i) {
 536                 DIR *d;
 537                 char *name;
 538                 int k;
 539
 540                 if (!u->cgroup_path)
 541                         continue;
 542
 543                 k = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, &d);
 544                 if (k < 0) {
 545                         if (k == -ENOENT)
 546                                 continue;
 547
 548                         log_error("Failed to open %s: %s", u->cgroup_path, strerror(-k));
 549                         r = k;
 550                         continue;
 551                 }
 552
 553                 while ((k = cg_read_subgroup(d, &name)) > 0) {
 554                         Session *session;
 555
 556                         k = manager_add_session(m, u, name, &session);
 557                         if (k < 0) {
 558                                 free(name);
 559                                 break;
 560                         }
 561
 562                         session_add_to_gc_queue(session);
 563
 564                         if (!session->cgroup_path)
 565                                 if (asprintf(&session->cgroup_path, "%s/%s", u->cgroup_path, name) < 0) {
 566                                         k = -ENOMEM;
 567                                         free(name);
 568                                         break;
 569                                 }
 570
 571                         free(name);
 572                 }
 573
 574                 closedir(d);
 575
 576                 if (k < 0)
 577                         r = k;
 578         }
 579
 580         return r;
 581 }
 582
 583 int manager_enumerate_sessions(Manager *m) {
 584         DIR *d;
 585         struct dirent *de;
 586         int r = 0;
 587
 588         assert(m);
 589
 590         /* First enumerate session cgroups */
 591         r = manager_enumerate_sessions_from_cgroup(m);
 592
 593         /* Second, read in session data stored on disk */
 594         d = opendir("/run/systemd/sessions");
 595         if (!d) {
 596                 if (errno == ENOENT)
 597                         return 0;
 598
 599                 log_error("Failed to open /run/systemd/sessions: %m");
 600                 return -errno;
 601         }
 602
 603         while ((de = readdir(d))) {
 604                 struct Session *s;
 605                 int k;
 606
 607                 if (!dirent_is_file(de))
 608                         continue;
 609
 610                 s = hashmap_get(m->sessions, de->d_name);
 611                 if (!s) {
 612                         unlinkat(dirfd(d), de->d_name, 0);
 613                         continue;
 614                 }
 615
 616                 k = session_load(s);
 617                 if (k < 0)
 618                         r = k;
 619         }
 620
 621         closedir(d);
 622
 623         return r;
 624 }
 625
 626 int manager_dispatch_udev(Manager *m) {
 627         struct udev_device *d;
 628         int r;
 629
 630         assert(m);
 631
 632         d = udev_monitor_receive_device(m->udev_monitor);
 633         if (!d)
 634                 return -ENOMEM;
 635
 636         r = manager_process_device(m, d);
 637         udev_device_unref(d);
 638
 639         return r;
 640 }
 641
 642 int manager_dispatch_console(Manager *m) {
 643         assert(m);
 644
 645         if (m->vtconsole)
 646                 seat_read_active_vt(m->vtconsole);
 647
 648         return 0;
 649 }
 650
 651 static int vt_is_busy(int vtnr) {
 652         struct vt_stat vt_stat;
 653         int r = 0, fd;
 654
 655         assert(vtnr >= 1);
 656
 657         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
 658         if (fd < 0)
 659                 return -errno;
 660
 661         if (ioctl(fd, VT_GETSTATE, &vt_stat) < 0)
 662                 r = -errno;
 663         else
 664                 r = !!(vt_stat.v_state & (1 << vtnr));
 665
 666         close_nointr_nofail(fd);
 667
 668         return r;
 669 }
 670
 671 int manager_spawn_autovt(Manager *m, int vtnr) {
 672         int r;
 673
 674         assert(m);
 675
 676         r = vt_is_busy(vtnr);
 677         if (r != 0)
 678                 return r;
 679
 680         /* ... */
 681
 682         return 0;
 683 }
 684
 685 static DBusHandlerResult login_message_filter(
 686                 DBusConnection *connection,
 687                 DBusMessage *message,
 688                 void *userdata) {
 689
 690         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 691 }
 692
 693 static int manager_connect_bus(Manager *m) {
 694         DBusError error;
 695         int r;
 696         struct epoll_event ev;
 697
 698         assert(m);
 699         assert(!m->bus);
 700         assert(m->bus_fd < 0);
 701
 702         dbus_error_init(&error);
 703
 704         m->bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
 705         if (!m->bus) {
 706                 log_error("Failed to get system D-Bus connection: %s", error.message);
 707                 r = -ECONNREFUSED;
 708                 goto fail;
 709         }
 710
 711         if (!dbus_connection_register_object_path(m->bus, "/org/freedesktop/login1", &bus_manager_vtable, m) ||
 712             !dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/seat", &bus_seat_vtable, m) ||
 713             !dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/session", &bus_session_vtable, m) ||
 714             !dbus_connection_register_fallback(m->bus, "/org/freedesktop/login1/user", &bus_user_vtable, m) ||
 715             !dbus_connection_add_filter(m->bus, login_message_filter, m, NULL)) {
 716                 log_error("Not enough memory");
 717                 r = -ENOMEM;
 718                 goto fail;
 719         }
 720
 721         dbus_bus_add_match(m->bus,
 722                            "type='signal',"
 723                            "interface='org.freedesktop.systemd1.Agent',"
 724                            "member='Released',"
 725                            "path='/org/freedesktop/systemd1/agent'",
 726                            &error);
 727
 728         if (dbus_error_is_set(&error)) {
 729                 log_error("Failed to register match: %s", error.message);
 730                 r = -EIO;
 731                 goto fail;
 732         }
 733
 734         if (dbus_bus_request_name(m->bus, "org.freedesktop.login1", DBUS_NAME_FLAG_DO_NOT_QUEUE, &error) < 0) {
 735                 log_error("Failed to register name on bus: %s", error.message);
 736                 r = -EEXIST;
 737                 goto fail;
 738         }
 739
 740         m->bus_fd = bus_loop_open(m->bus);
 741         if (m->bus_fd < 0) {
 742                 r = m->bus_fd;
 743                 goto fail;
 744         }
 745
 746         zero(ev);
 747         ev.events = EPOLLIN;
 748         ev.data.u32 = FD_BUS;
 749
 750         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->bus_fd, &ev) < 0)
 751                 goto fail;
 752
 753         return 0;
 754
 755 fail:
 756         dbus_error_free(&error);
 757
 758         return r;
 759 }
 760
 761 static int manager_connect_console(Manager *m) {
 762         struct epoll_event ev;
 763
 764         assert(m);
 765         assert(m->console_active_fd < 0);
 766
 767         m->console_active_fd = open("/sys/class/tty/tty0/active", O_RDONLY|O_NOCTTY|O_CLOEXEC);
 768         if (m->console_active_fd < 0) {
 769                 log_error("Failed to open /sys/class/tty/tty0/active: %m");
 770                 return -errno;
 771         }
 772
 773         zero(ev);
 774         ev.events = 0;
 775         ev.data.u32 = FD_CONSOLE;
 776
 777         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->console_active_fd, &ev) < 0)
 778                 return -errno;
 779
 780         return 0;
 781 }
 782
 783 static int manager_connect_udev(Manager *m) {
 784         struct epoll_event ev;
 785         int r;
 786
 787         assert(m);
 788         assert(!m->udev_monitor);
 789
 790         m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 791         if (!m->udev_monitor)
 792                 return -ENOMEM;
 793
 794         r = udev_monitor_filter_add_match_tag(m->udev_monitor, "seat");
 795         if (r < 0)
 796                 return r;
 797
 798         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_monitor, "graphics", NULL);
 799         if (r < 0)
 800                 return r;
 801
 802         r = udev_monitor_enable_receiving(m->udev_monitor);
 803         if (r < 0)
 804                 return r;
 805
 806         m->udev_fd = udev_monitor_get_fd(m->udev_monitor);
 807
 808         zero(ev);
 809         ev.events = EPOLLIN;
 810         ev.data.u32 = FD_UDEV;
 811
 812         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_fd, &ev) < 0)
 813                 return -errno;
 814
 815         return 0;
 816 }
 817
 818 void manager_gc(Manager *m) {
 819         Seat *seat;
 820         Session *session;
 821         User *user;
 822
 823         assert(m);
 824
 825         while ((seat = m->seat_gc_queue)) {
 826                 LIST_REMOVE(Seat, gc_queue, m->seat_gc_queue, seat);
 827                 seat->in_gc_queue = false;
 828
 829                 if (seat_check_gc(seat) == 0) {
 830                         seat_stop(seat);
 831                         seat_free(seat);
 832                 }
 833         }
 834
 835         while ((session = m->session_gc_queue)) {
 836                 LIST_REMOVE(Session, gc_queue, m->session_gc_queue, session);
 837                 session->in_gc_queue = false;
 838
 839                 if (session_check_gc(session) == 0) {
 840                         session_stop(session);
 841                         session_free(session);
 842                 }
 843         }
 844
 845         while ((user = m->user_gc_queue)) {
 846                 LIST_REMOVE(User, gc_queue, m->user_gc_queue, user);
 847                 user->in_gc_queue = false;
 848
 849                 if (user_check_gc(user) == 0) {
 850                         user_stop(user);
 851                         user_free(user);
 852                 }
 853         }
 854 }
 855
 856 int manager_get_idle_hint(Manager *m, dual_timestamp *t) {
 857         Session *s;
 858         bool idle_hint = true;
 859         dual_timestamp ts = { 0, 0 };
 860         Iterator i;
 861
 862         assert(m);
 863
 864         HASHMAP_FOREACH(s, m->sessions, i) {
 865                 dual_timestamp k;
 866                 int ih;
 867
 868                 ih = session_get_idle_hint(s, &k);
 869                 if (ih < 0)
 870                         return ih;
 871
 872                 if (!ih) {
 873                         if (!idle_hint) {
 874                                 if (k.monotonic < ts.monotonic)
 875                                         ts = k;
 876                         } else {
 877                                 idle_hint = false;
 878                                 ts = k;
 879                         }
 880                 } else if (idle_hint) {
 881
 882                         if (k.monotonic > ts.monotonic)
 883                                 ts = k;
 884                 }
 885         }
 886
 887         if (t)
 888                 *t = ts;
 889
 890         return idle_hint;
 891 }
 892
 893 int manager_startup(Manager *m) {
 894         int r;
 895         Seat *seat;
 896         Session *session;
 897         User *user;
 898         Iterator i;
 899
 900         assert(m);
 901         assert(m->epoll_fd <= 0);
 902
 903         m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
 904         if (m->epoll_fd < 0)
 905                 return -errno;
 906
 907         /* Connect to udev */
 908         r = manager_connect_udev(m);
 909         if (r < 0)
 910                 return r;
 911
 912         /* Connect to console */
 913         r = manager_connect_console(m);
 914         if (r < 0)
 915                 return r;
 916
 917         /* Connect to the bus */
 918         r = manager_connect_bus(m);
 919         if (r < 0)
 920                 return r;
 921
 922         /* Instantiate magic seat 0 */
 923         r = manager_add_seat(m, "seat0", &m->vtconsole);
 924         if (r < 0)
 925                 return r;
 926
 927         /* Deserialize state */
 928         manager_enumerate_devices(m);
 929         manager_enumerate_seats(m);
 930         manager_enumerate_users(m);
 931         manager_enumerate_sessions(m);
 932
 933         /* Get rid of objects that are no longer used */
 934         manager_gc(m);
 935
 936         /* And start everything */
 937         HASHMAP_FOREACH(seat, m->seats, i)
 938                 seat_start(seat);
 939
 940         HASHMAP_FOREACH(user, m->users, i)
 941                 user_start(user);
 942
 943         HASHMAP_FOREACH(session, m->sessions, i)
 944                 session_start(session);
 945
 946         return 0;
 947 }
 948
 949 int manager_run(Manager *m) {
 950         assert(m);
 951
 952         for (;;) {
 953                 struct epoll_event event;
 954                 int n;
 955
 956                 manager_gc(m);
 957
 958                 if (dbus_connection_dispatch(m->bus) != DBUS_DISPATCH_COMPLETE)
 959                         continue;
 960
 961                 n = epoll_wait(m->epoll_fd, &event, 1, -1);
 962                 if (n < 0) {
 963                         if (errno == EINTR || errno == EAGAIN)
 964                                 continue;
 965
 966                         log_error("epoll() failed: %m");
 967                         return -errno;
 968                 }
 969
 970                 switch (event.data.u32) {
 971
 972                 case FD_UDEV:
 973                         manager_dispatch_udev(m);
 974                         break;
 975
 976                 case FD_CONSOLE:
 977                         manager_dispatch_console(m);
 978                         break;
 979
 980                 case FD_BUS:
 981                         bus_loop_dispatch(m->bus_fd);
 982                         break;
 983                 }
 984         }
 985
 986         return 0;
 987 }
 988
 989 int main(int argc, char *argv[]) {
 990         Manager *m = NULL;
 991         int r;
 992
 993         log_set_target(LOG_TARGET_AUTO);
 994         log_parse_environment();
 995         log_open();
 996
 997         if (argc != 1) {
 998                 log_error("This program takes no arguments.");
 999                 r = -EINVAL;
1000                 goto finish;
1001         }
1002
1003         umask(0022);
1004
1005         m = manager_new();
1006         if (!m) {
1007                 log_error("Out of memory");
1008                 r = -ENOMEM;
1009                 goto finish;
1010         }
1011
1012         r = manager_startup(m);
1013         if (r < 0) {
1014                 log_error("Failed to fully start up daemon: %s", strerror(-r));
1015                 goto finish;
1016         }
1017
1018         r = manager_run(m);
1019
1020 finish:
1021         if (m)
1022                 manager_free(m);
1023
1024         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
1025 }