src/login/logind-session.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 <string.h>
  24 #include <unistd.h>
  25 #include <sys/epoll.h>
  26 #include <fcntl.h>
  27
  28 #include "logind-session.h"
  29 #include "strv.h"
  30 #include "util.h"
  31 #include "cgroup-util.h"
  32
  33 #define IDLE_THRESHOLD_USEC (5*USEC_PER_MINUTE)
  34
  35 Session* session_new(Manager *m, User *u, const char *id) {
  36         Session *s;
  37
  38         assert(m);
  39         assert(id);
  40
  41         s = new0(Session, 1);
  42         if (!s)
  43                 return NULL;
  44
  45         s->state_file = strappend("/run/systemd/sessions/", id);
  46         if (!s->state_file) {
  47                 free(s);
  48                 return NULL;
  49         }
  50
  51         s->id = file_name_from_path(s->state_file);
  52
  53         if (hashmap_put(m->sessions, s->id, s) < 0) {
  54                 free(s->id);
  55                 free(s);
  56                 return NULL;
  57         }
  58
  59         s->manager = m;
  60         s->fifo_fd = -1;
  61         s->user = u;
  62
  63         LIST_PREPEND(Session, sessions_by_user, u->sessions, s);
  64
  65         return s;
  66 }
  67
  68 void session_free(Session *s) {
  69         assert(s);
  70
  71         if (s->in_gc_queue)
  72                 LIST_REMOVE(Session, gc_queue, s->manager->session_gc_queue, s);
  73
  74         if (s->user) {
  75                 LIST_REMOVE(Session, sessions_by_user, s->user->sessions, s);
  76
  77                 if (s->user->display == s)
  78                         s->user->display = NULL;
  79         }
  80
  81         if (s->seat) {
  82                 if (s->seat->active == s)
  83                         s->seat->active = NULL;
  84
  85                 LIST_REMOVE(Session, sessions_by_seat, s->seat->sessions, s);
  86         }
  87
  88         if (s->cgroup_path)
  89                 hashmap_remove(s->manager->cgroups, s->cgroup_path);
  90
  91         free(s->cgroup_path);
  92         strv_free(s->controllers);
  93
  94         free(s->tty);
  95         free(s->display);
  96         free(s->remote_host);
  97         free(s->remote_user);
  98         free(s->service);
  99
 100         hashmap_remove(s->manager->sessions, s->id);
 101
 102         session_remove_fifo(s);
 103
 104         free(s->state_file);
 105         free(s);
 106 }
 107
 108 int session_save(Session *s) {
 109         FILE *f;
 110         int r = 0;
 111         char *temp_path;
 112
 113         assert(s);
 114
 115         if (!s->started)
 116                 return 0;
 117
 118         r = safe_mkdir("/run/systemd/sessions", 0755, 0, 0);
 119         if (r < 0)
 120                 goto finish;
 121
 122         r = fopen_temporary(s->state_file, &f, &temp_path);
 123         if (r < 0)
 124                 goto finish;
 125
 126         assert(s->user);
 127
 128         fchmod(fileno(f), 0644);
 129
 130         fprintf(f,
 131                 "# This is private data. Do not parse.\n"
 132                 "UID=%lu\n"
 133                 "USER=%s\n"
 134                 "ACTIVE=%i\n"
 135                 "REMOTE=%i\n"
 136                 "KILL_PROCESSES=%i\n",
 137                 (unsigned long) s->user->uid,
 138                 s->user->name,
 139                 session_is_active(s),
 140                 s->remote,
 141                 s->kill_processes);
 142
 143         if (s->type >= 0)
 144                 fprintf(f,
 145                         "TYPE=%s\n",
 146                         session_type_to_string(s->type));
 147
 148         if (s->class >= 0)
 149                 fprintf(f,
 150                         "CLASS=%s\n",
 151                         session_class_to_string(s->class));
 152
 153         if (s->cgroup_path)
 154                 fprintf(f,
 155                         "CGROUP=%s\n",
 156                         s->cgroup_path);
 157
 158         if (s->fifo_path)
 159                 fprintf(f,
 160                         "FIFO=%s\n",
 161                         s->fifo_path);
 162
 163         if (s->seat)
 164                 fprintf(f,
 165                         "SEAT=%s\n",
 166                         s->seat->id);
 167
 168         if (s->tty)
 169                 fprintf(f,
 170                         "TTY=%s\n",
 171                         s->tty);
 172
 173         if (s->display)
 174                 fprintf(f,
 175                         "DISPLAY=%s\n",
 176                         s->display);
 177
 178         if (s->remote_host)
 179                 fprintf(f,
 180                         "REMOTE_HOST=%s\n",
 181                         s->remote_host);
 182
 183         if (s->remote_user)
 184                 fprintf(f,
 185                         "REMOTE_USER=%s\n",
 186                         s->remote_user);
 187
 188         if (s->service)
 189                 fprintf(f,
 190                         "SERVICE=%s\n",
 191                         s->service);
 192
 193         if (s->seat && seat_can_multi_session(s->seat))
 194                 fprintf(f,
 195                         "VTNR=%i\n",
 196                         s->vtnr);
 197
 198         if (s->leader > 0)
 199                 fprintf(f,
 200                         "LEADER=%lu\n",
 201                         (unsigned long) s->leader);
 202
 203         if (s->audit_id > 0)
 204                 fprintf(f,
 205                         "AUDIT=%llu\n",
 206                         (unsigned long long) s->audit_id);
 207
 208         fflush(f);
 209
 210         if (ferror(f) || rename(temp_path, s->state_file) < 0) {
 211                 r = -errno;
 212                 unlink(s->state_file);
 213                 unlink(temp_path);
 214         }
 215
 216         fclose(f);
 217         free(temp_path);
 218
 219 finish:
 220         if (r < 0)
 221                 log_error("Failed to save session data for %s: %s", s->id, strerror(-r));
 222
 223         return r;
 224 }
 225
 226 int session_load(Session *s) {
 227         char *remote = NULL,
 228                 *kill_processes = NULL,
 229                 *seat = NULL,
 230                 *vtnr = NULL,
 231                 *leader = NULL,
 232                 *audit_id = NULL,
 233                 *type = NULL,
 234                 *class = NULL;
 235
 236         int k, r;
 237
 238         assert(s);
 239
 240         r = parse_env_file(s->state_file, NEWLINE,
 241                            "REMOTE",         &remote,
 242                            "KILL_PROCESSES", &kill_processes,
 243                            "CGROUP",         &s->cgroup_path,
 244                            "FIFO",           &s->fifo_path,
 245                            "SEAT",           &seat,
 246                            "TTY",            &s->tty,
 247                            "DISPLAY",        &s->display,
 248                            "REMOTE_HOST",    &s->remote_host,
 249                            "REMOTE_USER",    &s->remote_user,
 250                            "SERVICE",        &s->service,
 251                            "VTNR",           &vtnr,
 252                            "LEADER",         &leader,
 253                            "TYPE",           &type,
 254                            "CLASS",          &class,
 255                            NULL);
 256
 257         if (r < 0)
 258                 goto finish;
 259
 260         if (remote) {
 261                 k = parse_boolean(remote);
 262                 if (k >= 0)
 263                         s->remote = k;
 264         }
 265
 266         if (kill_processes) {
 267                 k = parse_boolean(kill_processes);
 268                 if (k >= 0)
 269                         s->kill_processes = k;
 270         }
 271
 272         if (seat && !s->seat) {
 273                 Seat *o;
 274
 275                 o = hashmap_get(s->manager->seats, seat);
 276                 if (o)
 277                         seat_attach_session(o, s);
 278         }
 279
 280         if (vtnr && s->seat && seat_can_multi_session(s->seat)) {
 281                 int v;
 282
 283                 k = safe_atoi(vtnr, &v);
 284                 if (k >= 0 && v >= 1)
 285                         s->vtnr = v;
 286         }
 287
 288         if (leader) {
 289                 pid_t pid;
 290
 291                 k = parse_pid(leader, &pid);
 292                 if (k >= 0 && pid >= 1) {
 293                         s->leader = pid;
 294
 295                         audit_session_from_pid(pid, &s->audit_id);
 296                 }
 297         }
 298
 299         if (type) {
 300                 SessionType t;
 301
 302                 t = session_type_from_string(type);
 303                 if (t >= 0)
 304                         s->type = t;
 305         }
 306
 307         if (class) {
 308                 SessionClass c;
 309
 310                 c = session_class_from_string(class);
 311                 if (c >= 0)
 312                         s->class = c;
 313         }
 314
 315         if (s->fifo_path) {
 316                 int fd;
 317
 318                 /* If we open an unopened pipe for reading we will not
 319                    get an EOF. to trigger an EOF we hence open it for
 320                    reading, but close it right-away which then will
 321                    trigger the EOF. */
 322
 323                 fd = session_create_fifo(s);
 324                 if (fd >= 0)
 325                         close_nointr_nofail(fd);
 326         }
 327
 328
 329 finish:
 330         free(remote);
 331         free(kill_processes);
 332         free(seat);
 333         free(vtnr);
 334         free(leader);
 335         free(audit_id);
 336
 337         return r;
 338 }
 339
 340 int session_activate(Session *s) {
 341         int r;
 342
 343         assert(s);
 344
 345         if (s->vtnr < 0)
 346                 return -ENOTSUP;
 347
 348         if (!s->seat)
 349                 return -ENOTSUP;
 350
 351         if (s->seat->active == s)
 352                 return 0;
 353
 354         assert(seat_is_vtconsole(s->seat));
 355
 356         r = chvt(s->vtnr);
 357         if (r < 0)
 358                 return r;
 359
 360         return seat_set_active(s->seat, s);
 361 }
 362
 363 static int session_link_x11_socket(Session *s) {
 364         char *t, *f, *c;
 365         size_t k;
 366
 367         assert(s);
 368         assert(s->user);
 369         assert(s->user->runtime_path);
 370
 371         if (s->user->display)
 372                 return 0;
 373
 374         if (!s->display || !display_is_local(s->display))
 375                 return 0;
 376
 377         k = strspn(s->display+1, "0123456789");
 378         f = new(char, sizeof("/tmp/.X11-unix/X") + k);
 379         if (!f) {
 380                 log_error("Out of memory");
 381                 return -ENOMEM;
 382         }
 383
 384         c = stpcpy(f, "/tmp/.X11-unix/X");
 385         memcpy(c, s->display+1, k);
 386         c[k] = 0;
 387
 388         if (access(f, F_OK) < 0) {
 389                 log_warning("Session %s has display %s with nonexisting socket %s.", s->id, s->display, f);
 390                 free(f);
 391                 return -ENOENT;
 392         }
 393
 394         /* Note that this cannot be in a subdir to avoid
 395          * vulnerabilities since we are privileged but the runtime
 396          * path is owned by the user */
 397
 398         t = strappend(s->user->runtime_path, "/X11-display");
 399         if (!t) {
 400                 log_error("Out of memory");
 401                 free(f);
 402                 return -ENOMEM;
 403         }
 404
 405         if (link(f, t) < 0) {
 406                 if (errno == EEXIST) {
 407                         unlink(t);
 408
 409                         if (link(f, t) >= 0)
 410                                 goto done;
 411                 }
 412
 413                 if (symlink(f, t) < 0) {
 414
 415                         if (errno == EEXIST) {
 416                                 unlink(t);
 417
 418                                 if (symlink(f, t) >= 0)
 419                                         goto done;
 420                         }
 421
 422                         log_error("Failed to link %s to %s: %m", f, t);
 423                         free(f);
 424                         free(t);
 425                         return -errno;
 426                 }
 427         }
 428
 429 done:
 430         log_info("Linked %s to %s.", f, t);
 431         free(f);
 432         free(t);
 433
 434         s->user->display = s;
 435
 436         return 0;
 437 }
 438
 439 static int session_create_one_group(Session *s, const char *controller, const char *path) {
 440         int r;
 441
 442         assert(s);
 443         assert(controller);
 444         assert(path);
 445
 446         if (s->leader > 0) {
 447                 r = cg_create_and_attach(controller, path, s->leader);
 448                 if (r < 0)
 449                         r = cg_create(controller, path);
 450         } else
 451                 r = cg_create(controller, path);
 452
 453         if (r < 0)
 454                 return r;
 455
 456         r = cg_set_task_access(controller, path, 0644, s->user->uid, s->user->gid, -1);
 457         if (r >= 0)
 458                 r = cg_set_group_access(controller, path, 0755, s->user->uid, s->user->gid);
 459
 460         return r;
 461 }
 462
 463 static int session_create_cgroup(Session *s) {
 464         char **k;
 465         char *p;
 466         int r;
 467
 468         assert(s);
 469         assert(s->user);
 470         assert(s->user->cgroup_path);
 471
 472         if (!s->cgroup_path) {
 473                 if (asprintf(&p, "%s/%s", s->user->cgroup_path, s->id) < 0) {
 474                         log_error("Out of memory");
 475                         return -ENOMEM;
 476                 }
 477         } else
 478                 p = s->cgroup_path;
 479
 480         r = session_create_one_group(s, SYSTEMD_CGROUP_CONTROLLER, p);
 481         if (r < 0) {
 482                 log_error("Failed to create "SYSTEMD_CGROUP_CONTROLLER":%s: %s", p, strerror(-r));
 483                 free(p);
 484                 s->cgroup_path = NULL;
 485                 return r;
 486         }
 487
 488         s->cgroup_path = p;
 489
 490         STRV_FOREACH(k, s->controllers) {
 491
 492                 if (strv_contains(s->reset_controllers, *k))
 493                         continue;
 494
 495                 r = session_create_one_group(s, *k, p);
 496                 if (r < 0)
 497                         log_warning("Failed to create %s:%s: %s", *k, p, strerror(-r));
 498         }
 499
 500         STRV_FOREACH(k, s->manager->controllers) {
 501
 502                 if (strv_contains(s->reset_controllers, *k) ||
 503                     strv_contains(s->manager->reset_controllers, *k) ||
 504                     strv_contains(s->controllers, *k))
 505                         continue;
 506
 507                 r = session_create_one_group(s, *k, p);
 508                 if (r < 0)
 509                         log_warning("Failed to create %s:%s: %s", *k, p, strerror(-r));
 510         }
 511
 512         if (s->leader > 0) {
 513
 514                 STRV_FOREACH(k, s->reset_controllers) {
 515                         r = cg_attach(*k, "/", s->leader);
 516                         if (r < 0)
 517                                 log_warning("Failed to reset controller %s: %s", *k, strerror(-r));
 518
 519                 }
 520
 521                 STRV_FOREACH(k, s->manager->reset_controllers) {
 522
 523                         if (strv_contains(s->reset_controllers, *k) ||
 524                             strv_contains(s->controllers, *k))
 525                                 continue;
 526
 527                         r = cg_attach(*k, "/", s->leader);
 528                         if (r < 0)
 529                                 log_warning("Failed to reset controller %s: %s", *k, strerror(-r));
 530
 531                 }
 532         }
 533
 534         hashmap_put(s->manager->cgroups, s->cgroup_path, s);
 535
 536         return 0;
 537 }
 538
 539 int session_start(Session *s) {
 540         int r;
 541
 542         assert(s);
 543         assert(s->user);
 544
 545         if (s->started)
 546                 return 0;
 547
 548         r = user_start(s->user);
 549         if (r < 0)
 550                 return r;
 551
 552         log_full(s->type == SESSION_TTY || s->type == SESSION_X11 ? LOG_INFO : LOG_DEBUG,
 553                  "New session %s of user %s.", s->id, s->user->name);
 554
 555         /* Create cgroup */
 556         r = session_create_cgroup(s);
 557         if (r < 0)
 558                 return r;
 559
 560         /* Create X11 symlink */
 561         session_link_x11_socket(s);
 562
 563         dual_timestamp_get(&s->timestamp);
 564
 565         if (s->seat)
 566                 seat_read_active_vt(s->seat);
 567
 568         s->started = true;
 569
 570         /* Save session data */
 571         session_save(s);
 572         user_save(s->user);
 573
 574         session_send_signal(s, true);
 575
 576         if (s->seat) {
 577                 seat_save(s->seat);
 578
 579                 if (s->seat->active == s)
 580                         seat_send_changed(s->seat, "Sessions\0ActiveSession\0");
 581                 else
 582                         seat_send_changed(s->seat, "Sessions\0");
 583         }
 584
 585         user_send_changed(s->user, "Sessions\0");
 586
 587         return 0;
 588 }
 589
 590 static bool session_shall_kill(Session *s) {
 591         assert(s);
 592
 593         if (!s->kill_processes)
 594                 return false;
 595
 596         if (strv_contains(s->manager->kill_exclude_users, s->user->name))
 597                 return false;
 598
 599         if (strv_isempty(s->manager->kill_only_users))
 600                 return true;
 601
 602         return strv_contains(s->manager->kill_only_users, s->user->name);
 603 }
 604
 605 static int session_terminate_cgroup(Session *s) {
 606         int r;
 607         char **k;
 608
 609         assert(s);
 610
 611         if (!s->cgroup_path)
 612                 return 0;
 613
 614         cg_trim(SYSTEMD_CGROUP_CONTROLLER, s->cgroup_path, false);
 615
 616         if (session_shall_kill(s)) {
 617
 618                 r = cg_kill_recursive_and_wait(SYSTEMD_CGROUP_CONTROLLER, s->cgroup_path, true);
 619                 if (r < 0)
 620                         log_error("Failed to kill session cgroup: %s", strerror(-r));
 621
 622         } else {
 623                 if (s->leader > 0) {
 624                         Session *t;
 625
 626                         /* We still send a HUP to the leader process,
 627                          * even if we are not supposed to kill the
 628                          * whole cgroup. But let's first check the
 629                          * leader still exists and belongs to our
 630                          * session... */
 631
 632                         r = manager_get_session_by_pid(s->manager, s->leader, &t);
 633                         if (r > 0 && t == s) {
 634                                 kill(s->leader, SIGTERM); /* for normal processes */
 635                                 kill(s->leader, SIGHUP);  /* for shells */
 636                                 kill(s->leader, SIGCONT); /* in case they are stopped */
 637                         }
 638                 }
 639
 640                 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, s->cgroup_path, true);
 641                 if (r < 0)
 642                         log_error("Failed to check session cgroup: %s", strerror(-r));
 643                 else if (r > 0) {
 644                         r = cg_delete(SYSTEMD_CGROUP_CONTROLLER, s->cgroup_path);
 645                         if (r < 0)
 646                                 log_error("Failed to delete session cgroup: %s", strerror(-r));
 647                 }
 648         }
 649
 650         STRV_FOREACH(k, s->user->manager->controllers)
 651                 cg_trim(*k, s->cgroup_path, true);
 652
 653         hashmap_remove(s->manager->cgroups, s->cgroup_path);
 654
 655         free(s->cgroup_path);
 656         s->cgroup_path = NULL;
 657
 658         return 0;
 659 }
 660
 661 static int session_unlink_x11_socket(Session *s) {
 662         char *t;
 663         int r;
 664
 665         assert(s);
 666         assert(s->user);
 667
 668         if (s->user->display != s)
 669                 return 0;
 670
 671         s->user->display = NULL;
 672
 673         t = strappend(s->user->runtime_path, "/X11-display");
 674         if (!t) {
 675                 log_error("Out of memory");
 676                 return -ENOMEM;
 677         }
 678
 679         r = unlink(t);
 680         free(t);
 681
 682         return r < 0 ? -errno : 0;
 683 }
 684
 685 int session_stop(Session *s) {
 686         int r = 0, k;
 687
 688         assert(s);
 689
 690         if (s->started)
 691                 log_full(s->type == SESSION_TTY || s->type == SESSION_X11 ? LOG_INFO : LOG_DEBUG,
 692                          "Removed session %s.", s->id);
 693
 694         /* Kill cgroup */
 695         k = session_terminate_cgroup(s);
 696         if (k < 0)
 697                 r = k;
 698
 699         /* Remove X11 symlink */
 700         session_unlink_x11_socket(s);
 701
 702         unlink(s->state_file);
 703         session_add_to_gc_queue(s);
 704         user_add_to_gc_queue(s->user);
 705
 706         if (s->started)
 707                 session_send_signal(s, false);
 708
 709         if (s->seat) {
 710                 if (s->seat->active == s)
 711                         seat_set_active(s->seat, NULL);
 712
 713                 seat_send_changed(s->seat, "Sessions\0");
 714         }
 715
 716         user_send_changed(s->user, "Sessions\0");
 717
 718         s->started = false;
 719
 720         return r;
 721 }
 722
 723 bool session_is_active(Session *s) {
 724         assert(s);
 725
 726         if (!s->seat)
 727                 return true;
 728
 729         return s->seat->active == s;
 730 }
 731
 732 int session_get_idle_hint(Session *s, dual_timestamp *t) {
 733         char *p;
 734         struct stat st;
 735         usec_t u, n;
 736         bool b;
 737         int k;
 738
 739         assert(s);
 740
 741         if (s->idle_hint) {
 742                 if (t)
 743                         *t = s->idle_hint_timestamp;
 744
 745                 return s->idle_hint;
 746         }
 747
 748         if (isempty(s->tty))
 749                 goto dont_know;
 750
 751         if (s->tty[0] != '/') {
 752                 p = strappend("/dev/", s->tty);
 753                 if (!p)
 754                         return -ENOMEM;
 755         } else
 756                 p = NULL;
 757
 758         if (!startswith(p ? p : s->tty, "/dev/")) {
 759                 free(p);
 760                 goto dont_know;
 761         }
 762
 763         k = lstat(p ? p : s->tty, &st);
 764         free(p);
 765
 766         if (k < 0)
 767                 goto dont_know;
 768
 769         u = timespec_load(&st.st_atim);
 770         n = now(CLOCK_REALTIME);
 771         b = u + IDLE_THRESHOLD_USEC < n;
 772
 773         if (t)
 774                 dual_timestamp_from_realtime(t, u + b ? IDLE_THRESHOLD_USEC : 0);
 775
 776         return b;
 777
 778 dont_know:
 779         if (t)
 780                 *t = s->idle_hint_timestamp;
 781
 782         return 0;
 783 }
 784
 785 void session_set_idle_hint(Session *s, bool b) {
 786         assert(s);
 787
 788         if (s->idle_hint == b)
 789                 return;
 790
 791         s->idle_hint = b;
 792         dual_timestamp_get(&s->idle_hint_timestamp);
 793
 794         session_send_changed(s,
 795                              "IdleHint\0"
 796                              "IdleSinceHint\0"
 797                              "IdleSinceHintMonotonic\0");
 798
 799         if (s->seat)
 800                 seat_send_changed(s->seat,
 801                                   "IdleHint\0"
 802                                   "IdleSinceHint\0"
 803                                   "IdleSinceHintMonotonic\0");
 804
 805         user_send_changed(s->user,
 806                           "IdleHint\0"
 807                           "IdleSinceHint\0"
 808                           "IdleSinceHintMonotonic\0");
 809
 810         manager_send_changed(s->manager,
 811                              "IdleHint\0"
 812                              "IdleSinceHint\0"
 813                              "IdleSinceHintMonotonic\0");
 814 }
 815
 816 int session_create_fifo(Session *s) {
 817         int r;
 818
 819         assert(s);
 820
 821         /* Create FIFO */
 822         if (!s->fifo_path) {
 823                 r = safe_mkdir("/run/systemd/sessions", 0755, 0, 0);
 824                 if (r < 0)
 825                         return r;
 826
 827                 if (asprintf(&s->fifo_path, "/run/systemd/sessions/%s.ref", s->id) < 0)
 828                         return -ENOMEM;
 829
 830                 if (mkfifo(s->fifo_path, 0600) < 0 && errno != EEXIST)
 831                         return -errno;
 832         }
 833
 834         /* Open reading side */
 835         if (s->fifo_fd < 0) {
 836                 struct epoll_event ev;
 837
 838                 s->fifo_fd = open(s->fifo_path, O_RDONLY|O_CLOEXEC|O_NDELAY);
 839                 if (s->fifo_fd < 0)
 840                         return -errno;
 841
 842                 r = hashmap_put(s->manager->fifo_fds, INT_TO_PTR(s->fifo_fd + 1), s);
 843                 if (r < 0)
 844                         return r;
 845
 846                 zero(ev);
 847                 ev.events = 0;
 848                 ev.data.u32 = FD_FIFO_BASE + s->fifo_fd;
 849
 850                 if (epoll_ctl(s->manager->epoll_fd, EPOLL_CTL_ADD, s->fifo_fd, &ev) < 0)
 851                         return -errno;
 852         }
 853
 854         /* Open writing side */
 855         r = open(s->fifo_path, O_WRONLY|O_CLOEXEC|O_NDELAY);
 856         if (r < 0)
 857                 return -errno;
 858
 859         return r;
 860 }
 861
 862 void session_remove_fifo(Session *s) {
 863         assert(s);
 864
 865         if (s->fifo_fd >= 0) {
 866                 assert_se(hashmap_remove(s->manager->fifo_fds, INT_TO_PTR(s->fifo_fd + 1)) == s);
 867                 assert_se(epoll_ctl(s->manager->epoll_fd, EPOLL_CTL_DEL, s->fifo_fd, NULL) == 0);
 868                 close_nointr_nofail(s->fifo_fd);
 869                 s->fifo_fd = -1;
 870         }
 871
 872         if (s->fifo_path) {
 873                 unlink(s->fifo_path);
 874                 free(s->fifo_path);
 875                 s->fifo_path = NULL;
 876         }
 877 }
 878
 879 int session_check_gc(Session *s, bool drop_not_started) {
 880         int r;
 881
 882         assert(s);
 883
 884         if (drop_not_started && !s->started)
 885                 return 0;
 886
 887         if (s->fifo_fd >= 0) {
 888
 889                 r = pipe_eof(s->fifo_fd);
 890                 if (r < 0)
 891                         return r;
 892
 893                 if (r == 0)
 894                         return 1;
 895         }
 896
 897         if (s->cgroup_path) {
 898
 899                 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, s->cgroup_path, false);
 900                 if (r < 0)
 901                         return r;
 902
 903                 if (r <= 0)
 904                         return 1;
 905         }
 906
 907         return 0;
 908 }
 909
 910 void session_add_to_gc_queue(Session *s) {
 911         assert(s);
 912
 913         if (s->in_gc_queue)
 914                 return;
 915
 916         LIST_PREPEND(Session, gc_queue, s->manager->session_gc_queue, s);
 917         s->in_gc_queue = true;
 918 }
 919
 920 int session_kill(Session *s, KillWho who, int signo) {
 921         int r = 0;
 922         Set *pid_set = NULL;
 923
 924         assert(s);
 925
 926         if (!s->cgroup_path)
 927                 return -ESRCH;
 928
 929         if (s->leader <= 0 && who == KILL_LEADER)
 930                 return -ESRCH;
 931
 932         if (s->leader > 0)
 933                 if (kill(s->leader, signo) < 0)
 934                         r = -errno;
 935
 936         if (who == KILL_ALL) {
 937                 int q;
 938
 939                 pid_set = set_new(trivial_hash_func, trivial_compare_func);
 940                 if (!pid_set)
 941                         return -ENOMEM;
 942
 943                 if (s->leader > 0) {
 944                         q = set_put(pid_set, LONG_TO_PTR(s->leader));
 945                         if (q < 0)
 946                                 r = q;
 947                 }
 948
 949                 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, s->cgroup_path, signo, false, true, false, pid_set);
 950                 if (q < 0)
 951                         if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
 952                                 r = q;
 953         }
 954
 955         if (pid_set)
 956                 set_free(pid_set);
 957
 958         return r;
 959 }
 960
 961 static const char* const session_type_table[_SESSION_TYPE_MAX] = {
 962         [SESSION_TTY] = "tty",
 963         [SESSION_X11] = "x11",
 964         [SESSION_UNSPECIFIED] = "unspecified"
 965 };
 966
 967 DEFINE_STRING_TABLE_LOOKUP(session_type, SessionType);
 968
 969 static const char* const session_class_table[_SESSION_CLASS_MAX] = {
 970         [SESSION_USER] = "user",
 971         [SESSION_GREETER] = "greeter",
 972         [SESSION_LOCK_SCREEN] = "lock-screen"
 973 };
 974
 975 DEFINE_STRING_TABLE_LOOKUP(session_class, SessionClass);
 976
 977 static const char* const kill_who_table[_KILL_WHO_MAX] = {
 978         [KILL_LEADER] = "leader",
 979         [KILL_ALL] = "all"
 980 };
 981
 982 DEFINE_STRING_TABLE_LOOKUP(kill_who, KillWho);