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         if (streq_ptr(udev_device_get_action(d), "remove")) {
 259
 260                 device = hashmap_get(m->devices, udev_device_get_syspath(d));
 261                 if (!device)
 262                         return 0;
 263
 264                 seat_add_to_gc_queue(device->seat);
 265                 device_free(device);
 266
 267         } else {
 268                 const char *sn;
 269                 Seat *seat;
 270
 271                 sn = udev_device_get_property_value(d, "SEAT");
 272                 if (!sn)
 273                         sn = "seat0";
 274
 275                 if (!startswith(sn, "seat"))
 276                         return -EINVAL;
 277
 278                 r = manager_add_device(m, udev_device_get_syspath(d), &device);
 279                 if (r < 0)
 280                         return r;
 281
 282                 r = manager_add_seat(m, sn, &seat);
 283                 if (r < 0) {
 284                         if (!device->seat)
 285                                 device_free(device);
 286
 287                         return r;
 288                 }
 289
 290                 device_attach(device, seat);
 291         }
 292
 293         return 0;
 294 }
 295
 296 int manager_enumerate_devices(Manager *m) {
 297         struct udev_list_entry *item = NULL, *first = NULL;
 298         struct udev_enumerate *e;
 299         int r;
 300
 301         assert(m);
 302
 303         /* Loads devices from udev and creates seats for them as
 304          * necessary */
 305
 306         e = udev_enumerate_new(m->udev);
 307         if (!e) {
 308                 r = -ENOMEM;
 309                 goto finish;
 310         }
 311
 312         r = udev_enumerate_add_match_subsystem(e, "graphics");
 313         if (r < 0)
 314                 goto finish;
 315
 316         r = udev_enumerate_add_match_tag(e, "seat");
 317         if (r < 0)
 318                 goto finish;
 319
 320         r = udev_enumerate_scan_devices(e);
 321         if (r < 0)
 322                 goto finish;
 323
 324         first = udev_enumerate_get_list_entry(e);
 325         udev_list_entry_foreach(item, first) {
 326                 struct udev_device *d;
 327                 int k;
 328
 329                 d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));
 330                 if (!d) {
 331                         r = -ENOMEM;
 332                         goto finish;
 333                 }
 334
 335                 k = manager_process_device(m, d);
 336                 udev_device_unref(d);
 337
 338                 if (k < 0)
 339                         r = k;
 340         }
 341
 342 finish:
 343         if (e)
 344                 udev_enumerate_unref(e);
 345
 346         return r;
 347 }
 348
 349 int manager_enumerate_seats(Manager *m) {
 350         DIR *d;
 351         struct dirent *de;
 352         int r = 0;
 353
 354         assert(m);
 355
 356         /* This loads data about seats stored on disk, but does not
 357          * actually create any seats. Removes data of seats that no
 358          * longer exist. */
 359
 360         d = opendir("/run/systemd/seats");
 361         if (!d) {
 362                 if (errno == ENOENT)
 363                         return 0;
 364
 365                 log_error("Failed to open /run/systemd/seats: %m");
 366                 return -errno;
 367         }
 368
 369         while ((de = readdir(d))) {
 370                 Seat *s;
 371                 int k;
 372
 373                 if (!dirent_is_file(de))
 374                         continue;
 375
 376                 if (!startswith(de->d_name, "seat"))
 377                         continue;
 378
 379                 s = hashmap_get(m->seats, de->d_name);
 380                 if (!s) {
 381                         unlinkat(dirfd(d), de->d_name, 0);
 382                         continue;
 383                 }
 384
 385                 k = seat_load(s);
 386                 if (k < 0)
 387                         r = k;
 388         }
 389
 390         closedir(d);
 391
 392         return r;
 393 }
 394
 395 static int manager_enumerate_users_from_cgroup(Manager *m) {
 396         int r = 0;
 397         char *name;
 398         DIR *d;
 399
 400         r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, m->cgroup_path, &d);
 401         if (r < 0) {
 402                 if (r == -ENOENT)
 403                         return 0;
 404
 405                 log_error("Failed to open %s: %s", m->cgroup_path, strerror(-r));
 406                 return r;
 407         }
 408
 409         while ((r = cg_read_subgroup(d, &name)) > 0) {
 410                 User *user;
 411                 int k;
 412
 413                 k = manager_add_user_by_name(m, name, &user);
 414                 if (k < 0) {
 415                         free(name);
 416                         r = k;
 417                         continue;
 418                 }
 419
 420                 user_add_to_gc_queue(user);
 421
 422                 if (!user->cgroup_path)
 423                         if (asprintf(&user->cgroup_path, "%s/%s", m->cgroup_path, name) < 0) {
 424                                 r = -ENOMEM;
 425                                 free(name);
 426                                 break;
 427                         }
 428
 429                 free(name);
 430         }
 431
 432         closedir(d);
 433
 434         return r;
 435 }
 436
 437
 438 static int manager_enumerate_linger_users(Manager *m) {
 439         DIR *d;
 440         struct dirent *de;
 441         int r = 0;
 442
 443         d = opendir("/var/lib/systemd/linger");
 444         if (!d) {
 445                 if (errno == ENOENT)
 446                         return 0;
 447
 448                 log_error("Failed to open /var/lib/systemd/linger/: %m");
 449                 return -errno;
 450         }
 451
 452         while ((de = readdir(d))) {
 453                 int k;
 454
 455                 if (!dirent_is_file(de))
 456                         continue;
 457
 458                 k = manager_add_user_by_name(m, de->d_name, NULL);
 459                 if (k < 0) {
 460                         log_notice("Couldn't add lingering user %s: %s", de->d_name, strerror(-k));
 461                         r = k;
 462                 }
 463         }
 464
 465         closedir(d);
 466
 467         return r;
 468 }
 469
 470 int manager_enumerate_users(Manager *m) {
 471         DIR *d;
 472         struct dirent *de;
 473         int r, k;
 474
 475         assert(m);
 476
 477         /* First, enumerate user cgroups */
 478         r = manager_enumerate_users_from_cgroup(m);
 479
 480         /* Second, add lingering users on top */
 481         k = manager_enumerate_linger_users(m);
 482         if (k < 0)
 483                 r = k;
 484
 485         /* Third, read in user data stored on disk */
 486         d = opendir("/run/systemd/users");
 487         if (!d) {
 488                 if (errno == ENOENT)
 489                         return 0;
 490
 491                 log_error("Failed to open /run/systemd/users: %m");
 492                 return -errno;
 493         }
 494
 495         while ((de = readdir(d))) {
 496                 unsigned long ul;
 497                 User *u;
 498
 499                 if (!dirent_is_file(de))
 500                         continue;
 501
 502                 k = safe_atolu(de->d_name, &ul);
 503                 if (k < 0) {
 504                         log_error("Failed to parse file name %s: %s", de->d_name, strerror(-k));
 505                         continue;
 506                 }
 507
 508                 u = hashmap_get(m->users, ULONG_TO_PTR(ul));
 509                 if (!u) {
 510                         unlinkat(dirfd(d), de->d_name, 0);
 511                         continue;
 512                 }
 513
 514                 k = user_load(u);
 515                 if (k < 0)
 516                         r = k;
 517         }
 518
 519         closedir(d);
 520
 521         return r;
 522 }
 523
 524 static int manager_enumerate_sessions_from_cgroup(Manager *m) {
 525         User *u;
 526         Iterator i;
 527         int r = 0;
 528
 529         HASHMAP_FOREACH(u, m->users, i) {
 530                 DIR *d;
 531                 char *name;
 532                 int k;
 533
 534                 if (!u->cgroup_path)
 535                         continue;
 536
 537                 k = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, &d);
 538                 if (k < 0) {
 539                         if (k == -ENOENT)
 540                                 continue;
 541
 542                         log_error("Failed to open %s: %s", u->cgroup_path, strerror(-k));
 543                         r = k;
 544                         continue;
 545                 }
 546
 547                 while ((k = cg_read_subgroup(d, &name)) > 0) {
 548                         Session *session;
 549
 550                         k = manager_add_session(m, u, name, &session);
 551                         if (k < 0) {
 552                                 free(name);
 553                                 break;
 554                         }
 555
 556                         session_add_to_gc_queue(session);
 557
 558                         if (!session->cgroup_path)
 559                                 if (asprintf(&session->cgroup_path, "%s/%s", u->cgroup_path, name) < 0) {
 560                                         k = -ENOMEM;
 561                                         free(name);
 562                                         break;
 563                                 }
 564
 565                         free(name);
 566                 }
 567
 568                 closedir(d);
 569
 570                 if (k < 0)
 571                         r = k;
 572         }
 573
 574         return r;
 575 }
 576
 577 int manager_enumerate_sessions(Manager *m) {
 578         DIR *d;
 579         struct dirent *de;
 580         int r = 0;
 581
 582         assert(m);
 583
 584         /* First enumerate session cgroups */
 585         r = manager_enumerate_sessions_from_cgroup(m);
 586
 587         /* Second, read in session data stored on disk */
 588         d = opendir("/run/systemd/sessions");
 589         if (!d) {
 590                 if (errno == ENOENT)
 591                         return 0;
 592
 593                 log_error("Failed to open /run/systemd/sessions: %m");
 594                 return -errno;
 595         }
 596
 597         while ((de = readdir(d))) {
 598                 struct Session *s;
 599                 int k;
 600
 601                 if (!dirent_is_file(de))
 602                         continue;
 603
 604                 s = hashmap_get(m->sessions, de->d_name);
 605                 if (!s) {
 606                         unlinkat(dirfd(d), de->d_name, 0);
 607                         continue;
 608                 }
 609
 610                 k = session_load(s);
 611                 if (k < 0)
 612                         r = k;
 613         }
 614
 615         closedir(d);
 616
 617         return r;
 618 }
 619
 620 int manager_dispatch_udev(Manager *m) {
 621         struct udev_device *d;
 622         int r;
 623
 624         assert(m);
 625
 626         d = udev_monitor_receive_device(m->udev_monitor);
 627         if (!d)
 628                 return -ENOMEM;
 629
 630         r = manager_process_device(m, d);
 631         udev_device_unref(d);
 632
 633         return r;
 634 }
 635
 636 int manager_dispatch_console(Manager *m) {
 637         assert(m);
 638
 639         if (m->vtconsole)
 640                 seat_read_active_vt(m->vtconsole);
 641
 642         return 0;
 643 }
 644
 645 static int vt_is_busy(int vtnr) {
 646         struct vt_stat vt_stat;
 647         int r = 0, fd;
 648
 649         assert(vtnr >= 1);
 650
 651         fd = open_terminal("/dev/tty0", O_RDWR|O_NOCTTY|O_CLOEXEC);
 652         if (fd < 0)
 653                 return -errno;
 654
 655         if (ioctl(fd, VT_GETSTATE, &vt_stat) < 0)
 656                 r = -errno;
 657         else
 658                 r = !!(vt_stat.v_state & (1 << vtnr));
 659
 660         close_nointr_nofail(fd);
 661
 662         return r;
 663 }
 664
 665 int manager_spawn_autovt(Manager *m, int vtnr) {
 666         int r;
 667
 668         assert(m);
 669
 670         r = vt_is_busy(vtnr);
 671         if (r != 0)
 672                 return r;
 673
 674         /* ... */
 675
 676         return 0;
 677 }
 678
 679 static DBusHandlerResult login_message_handler(
 680                 DBusConnection *connection,
 681                 DBusMessage *message,
 682                 void *userdata) {
 683
 684         return DBUS_HANDLER_RESULT_HANDLED;
 685 }
 686
 687 static DBusHandlerResult login_message_filter(
 688                 DBusConnection *connection,
 689                 DBusMessage *message,
 690                 void *userdata) {
 691
 692         return DBUS_HANDLER_RESULT_HANDLED;
 693 }
 694
 695 static int manager_connect_bus(Manager *m) {
 696         const DBusObjectPathVTable login_vtable = {
 697                 .message_function = login_message_handler
 698         };
 699
 700         DBusError error;
 701         int r;
 702         struct epoll_event ev;
 703
 704         assert(m);
 705         assert(!m->bus);
 706         assert(m->bus_fd < 0);
 707
 708         dbus_error_init(&error);
 709
 710         m->bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
 711         if (!m->bus) {
 712                 log_error("Failed to get system D-Bus connection: %s", error.message);
 713                 r = -ECONNREFUSED;
 714                 goto fail;
 715         }
 716
 717         if (!dbus_connection_register_object_path(m->bus, "/org/freedesktop/login1", &login_vtable, NULL)) {
 718                 log_error("Not enough memory");
 719                 r = -ENOMEM;
 720                 goto fail;
 721         }
 722
 723         if (!dbus_connection_add_filter(m->bus, login_message_filter, m, NULL)) {
 724                 log_error("Not enough memory");
 725                 r = -ENOMEM;
 726                 goto fail;
 727         }
 728
 729         dbus_bus_add_match(m->bus,
 730                            "type='signal',"
 731                            "interface='org.freedesktop.systemd1.Agent',"
 732                            "member='Released',"
 733                            "path='/org/freedesktop/systemd1/agent'",
 734                            &error);
 735
 736         if (dbus_error_is_set(&error)) {
 737                 log_error("Failed to register match: %s", error.message);
 738                 r = -EIO;
 739                 goto fail;
 740         }
 741
 742         if (dbus_bus_request_name(m->bus, "org.freedesktop.login1", DBUS_NAME_FLAG_DO_NOT_QUEUE, &error) < 0) {
 743                 log_error("Failed to register name on bus: %s", error.message);
 744                 r = -EEXIST;
 745                 goto fail;
 746         }
 747
 748         m->bus_fd = bus_loop_open(m->bus);
 749         if (m->bus_fd < 0) {
 750                 r = m->bus_fd;
 751                 goto fail;
 752         }
 753
 754         zero(ev);
 755         ev.events = EPOLLIN;
 756         ev.data.u32 = FD_BUS;
 757
 758         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->bus_fd, &ev) < 0)
 759                 goto fail;
 760
 761         return 0;
 762
 763 fail:
 764         dbus_error_free(&error);
 765
 766         return r;
 767 }
 768
 769 static int manager_connect_console(Manager *m) {
 770         struct epoll_event ev;
 771
 772         assert(m);
 773         assert(m->console_active_fd < 0);
 774
 775         m->console_active_fd = open("/sys/class/tty/tty0/active", O_RDONLY|O_NOCTTY|O_CLOEXEC);
 776         if (m->console_active_fd < 0) {
 777                 log_error("Failed to open /sys/class/tty/tty0/active: %m");
 778                 return -errno;
 779         }
 780
 781         zero(ev);
 782         ev.events = 0;
 783         ev.data.u32 = FD_CONSOLE;
 784
 785         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->console_active_fd, &ev) < 0)
 786                 return -errno;
 787
 788         return 0;
 789 }
 790
 791 static int manager_connect_udev(Manager *m) {
 792         struct epoll_event ev;
 793         int r;
 794
 795         assert(m);
 796         assert(!m->udev_monitor);
 797
 798         m->udev_monitor = udev_monitor_new_from_netlink(m->udev, "udev");
 799         if (!m->udev_monitor)
 800                 return -ENOMEM;
 801
 802         r = udev_monitor_filter_add_match_tag(m->udev_monitor, "seat");
 803         if (r < 0)
 804                 return r;
 805
 806         r = udev_monitor_filter_add_match_subsystem_devtype(m->udev_monitor, "graphics", NULL);
 807         if (r < 0)
 808                 return r;
 809
 810         r = udev_monitor_enable_receiving(m->udev_monitor);
 811         if (r < 0)
 812                 return r;
 813
 814         m->udev_fd = udev_monitor_get_fd(m->udev_monitor);
 815
 816         zero(ev);
 817         ev.events = EPOLLIN;
 818         ev.data.u32 = FD_UDEV;
 819
 820         if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->udev_fd, &ev) < 0)
 821                 return -errno;
 822
 823         return 0;
 824 }
 825
 826 void manager_gc(Manager *m) {
 827         Seat *seat;
 828         Session *session;
 829         User *user;
 830
 831         assert(m);
 832
 833         while ((seat = m->seat_gc_queue)) {
 834                 LIST_REMOVE(Seat, gc_queue, m->seat_gc_queue, seat);
 835                 seat->in_gc_queue = false;
 836
 837                 if (seat_check_gc(seat) == 0) {
 838                         seat_stop(seat);
 839                         seat_free(seat);
 840                 }
 841         }
 842
 843         while ((session = m->session_gc_queue)) {
 844                 LIST_REMOVE(Session, gc_queue, m->session_gc_queue, session);
 845                 session->in_gc_queue = false;
 846
 847                 if (session_check_gc(session) == 0) {
 848                         session_stop(session);
 849                         session_free(session);
 850                 }
 851         }
 852
 853         while ((user = m->user_gc_queue)) {
 854                 LIST_REMOVE(User, gc_queue, m->user_gc_queue, user);
 855                 user->in_gc_queue = false;
 856
 857                 if (user_check_gc(user) == 0) {
 858                         user_stop(user);
 859                         user_free(user);
 860                 }
 861         }
 862 }
 863
 864 int manager_startup(Manager *m) {
 865         int r;
 866         Seat *seat;
 867         Session *session;
 868         User *user;
 869         Iterator i;
 870
 871         assert(m);
 872         assert(m->epoll_fd <= 0);
 873
 874         m->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
 875         if (m->epoll_fd < 0)
 876                 return -errno;
 877
 878         /* Connect to udev */
 879         r = manager_connect_udev(m);
 880         if (r < 0)
 881                 return r;
 882
 883         /* Connect to console */
 884         r = manager_connect_console(m);
 885         if (r < 0)
 886                 return r;
 887
 888         /* Connect to the bus */
 889         r = manager_connect_bus(m);
 890         if (r < 0)
 891                 return r;
 892
 893         /* Instantiate magic seat 0 */
 894         r = manager_add_seat(m, "seat0", &m->vtconsole);
 895         if (r < 0)
 896                 return r;
 897
 898         /* Deserialize state */
 899         manager_enumerate_devices(m);
 900         manager_enumerate_seats(m);
 901         manager_enumerate_users(m);
 902         manager_enumerate_sessions(m);
 903
 904         /* Get rid of objects that are no longer used */
 905         manager_gc(m);
 906
 907         /* And start everything */
 908         HASHMAP_FOREACH(seat, m->seats, i)
 909                 seat_start(seat);
 910
 911         HASHMAP_FOREACH(user, m->users, i)
 912                 user_start(user);
 913
 914         HASHMAP_FOREACH(session, m->sessions, i)
 915                 session_start(session);
 916
 917         return 0;
 918 }
 919
 920 int manager_run(Manager *m) {
 921         assert(m);
 922
 923         for (;;) {
 924                 struct epoll_event event;
 925                 int n;
 926
 927                 manager_gc(m);
 928
 929                 if (dbus_connection_dispatch(m->bus) != DBUS_DISPATCH_COMPLETE)
 930                         continue;
 931
 932                 n = epoll_wait(m->epoll_fd, &event, 1, -1);
 933                 if (n < 0) {
 934                         log_error("epoll() failed: %m");
 935                         return -errno;
 936                 }
 937
 938                 switch (event.data.u32) {
 939
 940                 case FD_UDEV:
 941                         manager_dispatch_udev(m);
 942                         break;
 943
 944                 case FD_CONSOLE:
 945                         manager_dispatch_console(m);
 946                         break;
 947
 948                 case FD_BUS:
 949                         bus_loop_dispatch(m->bus_fd);
 950                         break;
 951                 }
 952         }
 953
 954         return 0;
 955 }
 956
 957 int main(int argc, char *argv[]) {
 958         Manager *m = NULL;
 959         int r;
 960
 961         log_set_target(LOG_TARGET_AUTO);
 962         log_parse_environment();
 963         log_open();
 964
 965         if (argc != 1) {
 966                 log_error("This program takes no arguments.");
 967                 r = -EINVAL;
 968                 goto finish;
 969         }
 970
 971         umask(0022);
 972
 973         m = manager_new();
 974         if (!m) {
 975                 log_error("Out of memory");
 976                 r = -ENOMEM;
 977                 goto finish;
 978         }
 979
 980         r = manager_startup(m);
 981         if (r < 0) {
 982                 log_error("Failed to fully start up daemon: %s", strerror(-r));
 983                 goto finish;
 984         }
 985
 986         r = manager_run(m);
 987
 988 finish:
 989         if (m)
 990                 manager_free(m);
 991
 992         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 993 }