src/nspawn/nspawn.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 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 <signal.h>
  23 #include <sched.h>
  24 #include <unistd.h>
  25 #include <sys/types.h>
  26 #include <sys/syscall.h>
  27 #include <sys/mount.h>
  28 #include <sys/wait.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <stdio.h>
  32 #include <errno.h>
  33 #include <sys/prctl.h>
  34 #include <sys/capability.h>
  35 #include <getopt.h>
  36 #include <sys/epoll.h>
  37 #include <termios.h>
  38 #include <sys/signalfd.h>
  39 #include <grp.h>
  40 #include <linux/fs.h>
  41 #include <sys/un.h>
  42 #include <sys/socket.h>
  43
  44 #include <systemd/sd-daemon.h>
  45
  46 #include "log.h"
  47 #include "util.h"
  48 #include "mkdir.h"
  49 #include "macro.h"
  50 #include "audit.h"
  51 #include "missing.h"
  52 #include "cgroup-util.h"
  53 #include "strv.h"
  54 #include "path-util.h"
  55 #include "loopback-setup.h"
  56 #include "sd-id128.h"
  57 #include "dev-setup.h"
  58 #include "fdset.h"
  59
  60 typedef enum LinkJournal {
  61         LINK_NO,
  62         LINK_AUTO,
  63         LINK_HOST,
  64         LINK_GUEST
  65 } LinkJournal;
  66
  67 static char *arg_directory = NULL;
  68 static char *arg_user = NULL;
  69 static char **arg_controllers = NULL;
  70 static char *arg_uuid = NULL;
  71 static bool arg_private_network = false;
  72 static bool arg_read_only = false;
  73 static bool arg_boot = false;
  74 static LinkJournal arg_link_journal = LINK_AUTO;
  75 static uint64_t arg_retain =
  76         (1ULL << CAP_CHOWN) |
  77         (1ULL << CAP_DAC_OVERRIDE) |
  78         (1ULL << CAP_DAC_READ_SEARCH) |
  79         (1ULL << CAP_FOWNER) |
  80         (1ULL << CAP_FSETID) |
  81         (1ULL << CAP_IPC_OWNER) |
  82         (1ULL << CAP_KILL) |
  83         (1ULL << CAP_LEASE) |
  84         (1ULL << CAP_LINUX_IMMUTABLE) |
  85         (1ULL << CAP_NET_BIND_SERVICE) |
  86         (1ULL << CAP_NET_BROADCAST) |
  87         (1ULL << CAP_NET_RAW) |
  88         (1ULL << CAP_SETGID) |
  89         (1ULL << CAP_SETFCAP) |
  90         (1ULL << CAP_SETPCAP) |
  91         (1ULL << CAP_SETUID) |
  92         (1ULL << CAP_SYS_ADMIN) |
  93         (1ULL << CAP_SYS_CHROOT) |
  94         (1ULL << CAP_SYS_NICE) |
  95         (1ULL << CAP_SYS_PTRACE) |
  96         (1ULL << CAP_SYS_TTY_CONFIG) |
  97         (1ULL << CAP_SYS_RESOURCE) |
  98         (1ULL << CAP_SYS_BOOT);
  99
 100 static int help(void) {
 101
 102         printf("%s [OPTIONS...] [PATH] [ARGUMENTS...]\n\n"
 103                "Spawn a minimal namespace container for debugging, testing and building.\n\n"
 104                "  -h --help               Show this help\n"
 105                "  -D --directory=NAME     Root directory for the container\n"
 106                "  -b --boot               Boot up full system (i.e. invoke init)\n"
 107                "  -u --user=USER          Run the command under specified user or uid\n"
 108                "  -C --controllers=LIST   Put the container in specified comma-separated cgroup hierarchies\n"
 109                "     --uuid=UUID          Set a specific machine UUID for the container\n"
 110                "     --private-network    Disable network in container\n"
 111                "     --read-only          Mount the root directory read-only\n"
 112                "     --capability=CAP     In addition to the default, retain specified capability\n"
 113                "     --link-journal=MODE  Link up guest journal, one of no, auto, guest, host\n"
 114                "  -j                      Equivalent to --link-journal=host\n",
 115                program_invocation_short_name);
 116
 117         return 0;
 118 }
 119
 120 static int parse_argv(int argc, char *argv[]) {
 121
 122         enum {
 123                 ARG_PRIVATE_NETWORK = 0x100,
 124                 ARG_UUID,
 125                 ARG_READ_ONLY,
 126                 ARG_CAPABILITY,
 127                 ARG_LINK_JOURNAL
 128         };
 129
 130         static const struct option options[] = {
 131                 { "help",            no_argument,       NULL, 'h'                 },
 132                 { "directory",       required_argument, NULL, 'D'                 },
 133                 { "user",            required_argument, NULL, 'u'                 },
 134                 { "controllers",     required_argument, NULL, 'C'                 },
 135                 { "private-network", no_argument,       NULL, ARG_PRIVATE_NETWORK },
 136                 { "boot",            no_argument,       NULL, 'b'                 },
 137                 { "uuid",            required_argument, NULL, ARG_UUID            },
 138                 { "read-only",       no_argument,       NULL, ARG_READ_ONLY       },
 139                 { "capability",      required_argument, NULL, ARG_CAPABILITY      },
 140                 { "link-journal",    required_argument, NULL, ARG_LINK_JOURNAL    },
 141                 { NULL,              0,                 NULL, 0                   }
 142         };
 143
 144         int c;
 145
 146         assert(argc >= 0);
 147         assert(argv);
 148
 149         while ((c = getopt_long(argc, argv, "+hD:u:C:bj", options, NULL)) >= 0) {
 150
 151                 switch (c) {
 152
 153                 case 'h':
 154                         help();
 155                         return 0;
 156
 157                 case 'D':
 158                         free(arg_directory);
 159                         arg_directory = canonicalize_file_name(optarg);
 160                         if (!arg_directory) {
 161                                 log_error("Failed to canonicalize root directory.");
 162                                 return -ENOMEM;
 163                         }
 164
 165                         break;
 166
 167                 case 'u':
 168                         free(arg_user);
 169                         if (!(arg_user = strdup(optarg))) {
 170                                 log_error("Failed to duplicate user name.");
 171                                 return -ENOMEM;
 172                         }
 173
 174                         break;
 175
 176                 case 'C':
 177                         strv_free(arg_controllers);
 178                         arg_controllers = strv_split(optarg, ",");
 179                         if (!arg_controllers) {
 180                                 log_error("Failed to split controllers list.");
 181                                 return -ENOMEM;
 182                         }
 183                         strv_uniq(arg_controllers);
 184
 185                         break;
 186
 187                 case ARG_PRIVATE_NETWORK:
 188                         arg_private_network = true;
 189                         break;
 190
 191                 case 'b':
 192                         arg_boot = true;
 193                         break;
 194
 195                 case ARG_UUID:
 196                         arg_uuid = optarg;
 197                         break;
 198
 199                 case ARG_READ_ONLY:
 200                         arg_read_only = true;
 201                         break;
 202
 203                 case ARG_CAPABILITY: {
 204                         char *state, *word;
 205                         size_t length;
 206
 207                         FOREACH_WORD_SEPARATOR(word, length, optarg, ",", state) {
 208                                 cap_value_t cap;
 209                                 char *t;
 210
 211                                 t = strndup(word, length);
 212                                 if (!t)
 213                                         return log_oom();
 214
 215                                 if (cap_from_name(t, &cap) < 0) {
 216                                         log_error("Failed to parse capability %s.", t);
 217                                         free(t);
 218                                         return -EINVAL;
 219                                 }
 220
 221                                 free(t);
 222                                 arg_retain |= 1ULL << (uint64_t) cap;
 223                         }
 224
 225                         break;
 226                 }
 227
 228                 case 'j':
 229                         arg_link_journal = LINK_GUEST;
 230                         break;
 231
 232                 case ARG_LINK_JOURNAL:
 233                         if (streq(optarg, "auto"))
 234                                 arg_link_journal = LINK_AUTO;
 235                         else if (streq(optarg, "no"))
 236                                 arg_link_journal = LINK_NO;
 237                         else if (streq(optarg, "guest"))
 238                                 arg_link_journal = LINK_GUEST;
 239                         else if (streq(optarg, "host"))
 240                                 arg_link_journal = LINK_HOST;
 241                         else {
 242                                 log_error("Failed to parse link journal mode %s", optarg);
 243                                 return -EINVAL;
 244                         }
 245
 246                         break;
 247
 248                 case '?':
 249                         return -EINVAL;
 250
 251                 default:
 252                         log_error("Unknown option code %c", c);
 253                         return -EINVAL;
 254                 }
 255         }
 256
 257         return 1;
 258 }
 259
 260 static int mount_all(const char *dest) {
 261
 262         typedef struct MountPoint {
 263                 const char *what;
 264                 const char *where;
 265                 const char *type;
 266                 const char *options;
 267                 unsigned long flags;
 268                 bool fatal;
 269         } MountPoint;
 270
 271         static const MountPoint mount_table[] = {
 272                 { "proc",      "/proc",     "proc",  NULL,       MS_NOSUID|MS_NOEXEC|MS_NODEV, true  },
 273                 { "/proc/sys", "/proc/sys", NULL,    NULL,       MS_BIND, true                       },   /* Bind mount first */
 274                 { NULL,        "/proc/sys", NULL,    NULL,       MS_BIND|MS_RDONLY|MS_REMOUNT, true  },   /* Then, make it r/o */
 275                 { "sysfs",     "/sys",      "sysfs", NULL,       MS_RDONLY|MS_NOSUID|MS_NOEXEC|MS_NODEV, true  },
 276                 { "tmpfs",     "/dev",      "tmpfs", "mode=755", MS_NOSUID|MS_STRICTATIME,     true  },
 277                 { "/dev/pts",  "/dev/pts",  NULL,    NULL,       MS_BIND,                      true  },
 278                 { "tmpfs",     "/dev/shm",  "tmpfs", "mode=1777", MS_NOSUID|MS_NODEV|MS_STRICTATIME, true  },
 279                 { "tmpfs",     "/run",      "tmpfs", "mode=755", MS_NOSUID|MS_NODEV|MS_STRICTATIME, true  },
 280 #ifdef HAVE_SELINUX
 281                 { "/sys/fs/selinux", "/sys/fs/selinux", NULL, NULL, MS_BIND,                      false },  /* Bind mount first */
 282                 { NULL,              "/sys/fs/selinux", NULL, NULL, MS_BIND|MS_RDONLY|MS_REMOUNT, false },  /* Then, make it r/o */
 283 #endif
 284         };
 285
 286         unsigned k;
 287         int r = 0;
 288
 289         for (k = 0; k < ELEMENTSOF(mount_table); k++) {
 290                 char _cleanup_free_ *where = NULL;
 291                 int t;
 292
 293                 if (asprintf(&where, "%s/%s", dest, mount_table[k].where) < 0) {
 294                         log_oom();
 295
 296                         if (r == 0)
 297                                 r = -ENOMEM;
 298
 299                         break;
 300                 }
 301
 302                 t = path_is_mount_point(where, true);
 303                 if (t < 0) {
 304                         log_error("Failed to detect whether %s is a mount point: %s", where, strerror(-t));
 305
 306                         if (r == 0)
 307                                 r = t;
 308
 309                         continue;
 310                 }
 311
 312                 /* Skip this entry if it is not a remount. */
 313                 if (mount_table[k].what && t > 0)
 314                         continue;
 315
 316                 mkdir_p_label(where, 0755);
 317
 318                 if (mount(mount_table[k].what,
 319                           where,
 320                           mount_table[k].type,
 321                           mount_table[k].flags,
 322                           mount_table[k].options) < 0 &&
 323                     mount_table[k].fatal) {
 324
 325                         log_error("mount(%s) failed: %m", where);
 326
 327                         if (r == 0)
 328                                 r = -errno;
 329                 }
 330         }
 331
 332         return r;
 333 }
 334
 335 static int setup_timezone(const char *dest) {
 336         _cleanup_free_ char *where = NULL, *p = NULL, *q = NULL, *check = NULL, *what = NULL;
 337         char *z, *y;
 338         int r;
 339
 340         assert(dest);
 341
 342         /* Fix the timezone, if possible */
 343         r = readlink_malloc("/etc/localtime", &p);
 344         if (r < 0) {
 345                 log_warning("/etc/localtime is not a symlink, not updating container timezone.");
 346                 return 0;
 347         }
 348
 349         z = path_startswith(p, "../usr/share/zoneinfo/");
 350         if (!z)
 351                 z = path_startswith(p, "/usr/share/zoneinfo/");
 352         if (!z) {
 353                 log_warning("/etc/localtime does not point into /usr/share/zoneinfo/, not updating container timezone.");
 354                 return 0;
 355         }
 356
 357         where = strappend(dest, "/etc/localtime");
 358         if (!where)
 359                 return log_oom();
 360
 361         r = readlink_malloc(where, &q);
 362         if (r >= 0) {
 363                 y = path_startswith(q, "../usr/share/zoneinfo/");
 364                 if (!y)
 365                         y = path_startswith(q, "/usr/share/zoneinfo/");
 366
 367
 368                 /* Already pointing to the right place? Then do nothing .. */
 369                 if (y && streq(y, z))
 370                         return 0;
 371         }
 372
 373         check = strjoin(dest, "/usr/share/zoneinfo/", z, NULL);
 374         if (!check)
 375                 return log_oom();
 376
 377         if (access(check, F_OK) < 0) {
 378                 log_warning("Timezone %s does not exist in container, not updating container timezone.", z);
 379                 return 0;
 380         }
 381
 382         what = strappend("../usr/share/zoneinfo/", z);
 383         if (!what)
 384                 return log_oom();
 385
 386         unlink(where);
 387         if (symlink(what, where) < 0) {
 388                 log_error("Failed to correct timezone of container: %m");
 389                 return 0;
 390         }
 391
 392         return 0;
 393 }
 394
 395 static int setup_resolv_conf(const char *dest) {
 396         char *where;
 397
 398         assert(dest);
 399
 400         if (arg_private_network)
 401                 return 0;
 402
 403         /* Fix resolv.conf, if possible */
 404         where = strappend(dest, "/etc/resolv.conf");
 405         if (!where)
 406                 return log_oom();
 407
 408         /* We don't really care for the results of this really. If it
 409          * fails, it fails, but meh... */
 410         if (mount("/etc/resolv.conf", where, "bind", MS_BIND, NULL) >= 0)
 411                 mount("/etc/resolv.conf", where, "bind", MS_BIND|MS_REMOUNT|MS_RDONLY, NULL);
 412
 413         free(where);
 414
 415         return 0;
 416 }
 417
 418 static int setup_boot_id(const char *dest) {
 419         char _cleanup_free_ *from = NULL, *to = NULL;
 420         sd_id128_t rnd;
 421         char as_uuid[37];
 422         int r;
 423
 424         assert(dest);
 425
 426         /* Generate a new randomized boot ID, so that each boot-up of
 427          * the container gets a new one */
 428
 429         from = strappend(dest, "/dev/proc-sys-kernel-random-boot-id");
 430         to = strappend(dest, "/proc/sys/kernel/random/boot_id");
 431         if (!from || !to)
 432                 return log_oom();
 433
 434         r = sd_id128_randomize(&rnd);
 435         if (r < 0) {
 436                 log_error("Failed to generate random boot id: %s", strerror(-r));
 437                 return r;
 438         }
 439
 440         snprintf(as_uuid, sizeof(as_uuid),
 441                  "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
 442                  SD_ID128_FORMAT_VAL(rnd));
 443         char_array_0(as_uuid);
 444
 445         r = write_one_line_file(from, as_uuid);
 446         if (r < 0) {
 447                 log_error("Failed to write boot id: %s", strerror(-r));
 448                 return r;
 449         }
 450
 451         if (mount(from, to, "bind", MS_BIND, NULL) < 0) {
 452                 log_error("Failed to bind mount boot id: %m");
 453                 r = -errno;
 454         } else
 455                 mount(from, to, "bind", MS_BIND|MS_REMOUNT|MS_RDONLY, NULL);
 456
 457         unlink(from);
 458         return r;
 459 }
 460
 461 static int copy_devnodes(const char *dest) {
 462
 463         static const char devnodes[] =
 464                 "null\0"
 465                 "zero\0"
 466                 "full\0"
 467                 "random\0"
 468                 "urandom\0"
 469                 "tty\0"
 470                 "ptmx\0";
 471
 472         const char *d;
 473         int r = 0;
 474         mode_t _cleanup_umask_ u;
 475
 476         assert(dest);
 477
 478         u = umask(0000);
 479
 480         NULSTR_FOREACH(d, devnodes) {
 481                 struct stat st;
 482                 char _cleanup_free_ *from = NULL, *to = NULL;
 483
 484                 asprintf(&from, "/dev/%s", d);
 485                 asprintf(&to, "%s/dev/%s", dest, d);
 486
 487                 if (!from || !to) {
 488                         log_oom();
 489
 490                         if (r == 0)
 491                                 r = -ENOMEM;
 492
 493                         break;
 494                 }
 495
 496                 if (stat(from, &st) < 0) {
 497
 498                         if (errno != ENOENT) {
 499                                 log_error("Failed to stat %s: %m", from);
 500                                 if (r == 0)
 501                                         r = -errno;
 502                         }
 503
 504                 } else if (!S_ISCHR(st.st_mode) && !S_ISBLK(st.st_mode)) {
 505
 506                         log_error("%s is not a char or block device, cannot copy", from);
 507                         if (r == 0)
 508                                 r = -EIO;
 509
 510                 } else if (mknod(to, st.st_mode, st.st_rdev) < 0) {
 511
 512                         log_error("mknod(%s) failed: %m", dest);
 513                         if (r == 0)
 514                                 r = -errno;
 515                 }
 516         }
 517
 518         return r;
 519 }
 520
 521 static int setup_dev_console(const char *dest, const char *console) {
 522         struct stat st;
 523         char _cleanup_free_ *to = NULL;
 524         int r;
 525         mode_t _cleanup_umask_ u;
 526
 527         assert(dest);
 528         assert(console);
 529
 530         u = umask(0000);
 531
 532         if (stat(console, &st) < 0) {
 533                 log_error("Failed to stat %s: %m", console);
 534                 return -errno;
 535
 536         } else if (!S_ISCHR(st.st_mode)) {
 537                 log_error("/dev/console is not a char device");
 538                 return -EIO;
 539         }
 540
 541         r = chmod_and_chown(console, 0600, 0, 0);
 542         if (r < 0) {
 543                 log_error("Failed to correct access mode for TTY: %s", strerror(-r));
 544                 return r;
 545         }
 546
 547         if (asprintf(&to, "%s/dev/console", dest) < 0)
 548                 return log_oom();
 549
 550         /* We need to bind mount the right tty to /dev/console since
 551          * ptys can only exist on pts file systems. To have something
 552          * to bind mount things on we create a device node first, that
 553          * has the right major/minor (note that the major minor
 554          * doesn't actually matter here, since we mount it over
 555          * anyway). */
 556
 557         if (mknod(to, (st.st_mode & ~07777) | 0600, st.st_rdev) < 0) {
 558                 log_error("mknod() for /dev/console failed: %m");
 559                 return -errno;
 560         }
 561
 562         if (mount(console, to, "bind", MS_BIND, NULL) < 0) {
 563                 log_error("Bind mount for /dev/console failed: %m");
 564                 return -errno;
 565         }
 566
 567         return 0;
 568 }
 569
 570 static int setup_kmsg(const char *dest, int kmsg_socket) {
 571         char _cleanup_free_ *from = NULL, *to = NULL;
 572         int r, fd, k;
 573         mode_t _cleanup_umask_ u;
 574         union {
 575                 struct cmsghdr cmsghdr;
 576                 uint8_t buf[CMSG_SPACE(sizeof(int))];
 577         } control;
 578         struct msghdr mh;
 579         struct cmsghdr *cmsg;
 580
 581         assert(dest);
 582         assert(kmsg_socket >= 0);
 583
 584         u = umask(0000);
 585
 586         /* We create the kmsg FIFO as /dev/kmsg, but immediately
 587          * delete it after bind mounting it to /proc/kmsg. While FIFOs
 588          * on the reading side behave very similar to /proc/kmsg,
 589          * their writing side behaves differently from /dev/kmsg in
 590          * that writing blocks when nothing is reading. In order to
 591          * avoid any problems with containers deadlocking due to this
 592          * we simply make /dev/kmsg unavailable to the container. */
 593         if (asprintf(&from, "%s/dev/kmsg", dest) < 0 ||
 594             asprintf(&to, "%s/proc/kmsg", dest) < 0)
 595                 return log_oom();
 596
 597         if (mkfifo(from, 0600) < 0) {
 598                 log_error("mkfifo() for /dev/kmsg failed: %m");
 599                 return -errno;
 600         }
 601
 602         r = chmod_and_chown(from, 0600, 0, 0);
 603         if (r < 0) {
 604                 log_error("Failed to correct access mode for /dev/kmsg: %s", strerror(-r));
 605                 return r;
 606         }
 607
 608         if (mount(from, to, "bind", MS_BIND, NULL) < 0) {
 609                 log_error("Bind mount for /proc/kmsg failed: %m");
 610                 return -errno;
 611         }
 612
 613         fd = open(from, O_RDWR|O_NDELAY|O_CLOEXEC);
 614         if (fd < 0) {
 615                 log_error("Failed to open fifo: %m");
 616                 return -errno;
 617         }
 618
 619         zero(mh);
 620         zero(control);
 621
 622         mh.msg_control = &control;
 623         mh.msg_controllen = sizeof(control);
 624
 625         cmsg = CMSG_FIRSTHDR(&mh);
 626         cmsg->cmsg_level = SOL_SOCKET;
 627         cmsg->cmsg_type = SCM_RIGHTS;
 628         cmsg->cmsg_len = CMSG_LEN(sizeof(int));
 629         memcpy(CMSG_DATA(cmsg), &fd, sizeof(int));
 630
 631         mh.msg_controllen = cmsg->cmsg_len;
 632
 633         /* Store away the fd in the socket, so that it stays open as
 634          * long as we run the child */
 635         k = sendmsg(kmsg_socket, &mh, MSG_DONTWAIT|MSG_NOSIGNAL);
 636         close_nointr_nofail(fd);
 637
 638         if (k < 0) {
 639                 log_error("Failed to send FIFO fd: %m");
 640                 return -errno;
 641         }
 642
 643         /* And now make the FIFO unavailable as /dev/kmsg... */
 644         unlink(from);
 645         return 0;
 646 }
 647
 648 static int setup_hostname(void) {
 649         char *hn;
 650         int r = 0;
 651
 652         hn = path_get_file_name(arg_directory);
 653         if (hn) {
 654                 hn = strdup(hn);
 655                 if (!hn)
 656                         return -ENOMEM;
 657
 658                 hostname_cleanup(hn);
 659
 660                 if (!isempty(hn))
 661                         if (sethostname(hn, strlen(hn)) < 0)
 662                                 r = -errno;
 663
 664                 free(hn);
 665         }
 666
 667         return r;
 668 }
 669
 670 static int setup_journal(const char *directory) {
 671         sd_id128_t machine_id;
 672         char _cleanup_free_ *p = NULL, *b = NULL, *q = NULL, *d = NULL;
 673         char *id;
 674         int r;
 675
 676         if (arg_link_journal == LINK_NO)
 677                 return 0;
 678
 679         p = strappend(directory, "/etc/machine-id");
 680         if (!p)
 681                 return log_oom();
 682
 683         r = read_one_line_file(p, &b);
 684         if (r == -ENOENT && arg_link_journal == LINK_AUTO)
 685                 return 0;
 686         else if (r < 0) {
 687                 log_error("Failed to read machine ID from %s: %s", p, strerror(-r));
 688                 return r;
 689         }
 690
 691         id = strstrip(b);
 692         if (isempty(id) && arg_link_journal == LINK_AUTO)
 693                 return 0;
 694
 695         /* Verify validity */
 696         r = sd_id128_from_string(id, &machine_id);
 697         if (r < 0) {
 698                 log_error("Failed to parse machine ID from %s: %s", p, strerror(-r));
 699                 return r;
 700         }
 701
 702         free(p);
 703         p = strappend("/var/log/journal/", id);
 704         q = strjoin(directory, "/var/log/journal/", id, NULL);
 705         if (!p || !q)
 706                 return log_oom();
 707
 708         if (path_is_mount_point(p, false) > 0) {
 709                 if (arg_link_journal != LINK_AUTO) {
 710                         log_error("%s: already a mount point, refusing to use for journal", p);
 711                         return -EEXIST;
 712                 }
 713
 714                 return 0;
 715         }
 716
 717         if (path_is_mount_point(q, false) > 0) {
 718                 if (arg_link_journal != LINK_AUTO) {
 719                         log_error("%s: already a mount point, refusing to use for journal", q);
 720                         return -EEXIST;
 721                 }
 722
 723                 return 0;
 724         }
 725
 726         r = readlink_and_make_absolute(p, &d);
 727         if (r >= 0) {
 728                 if ((arg_link_journal == LINK_GUEST ||
 729                      arg_link_journal == LINK_AUTO) &&
 730                     path_equal(d, q)) {
 731
 732                         r = mkdir_p(q, 0755);
 733                         if (r < 0)
 734                                 log_warning("failed to create directory %s: %m", q);
 735                         return 0;
 736                 }
 737
 738                 if (unlink(p) < 0) {
 739                         log_error("Failed to remove symlink %s: %m", p);
 740                         return -errno;
 741                 }
 742         } else if (r == -EINVAL) {
 743
 744                 if (arg_link_journal == LINK_GUEST &&
 745                     rmdir(p) < 0) {
 746
 747                         if (errno == ENOTDIR) {
 748                                 log_error("%s already exists and is neither a symlink nor a directory", p);
 749                                 return r;
 750                         } else {
 751                                 log_error("Failed to remove %s: %m", p);
 752                                 return -errno;
 753                         }
 754                 }
 755         } else if (r != -ENOENT) {
 756                 log_error("readlink(%s) failed: %m", p);
 757                 return r;
 758         }
 759
 760         if (arg_link_journal == LINK_GUEST) {
 761
 762                 if (symlink(q, p) < 0) {
 763                         log_error("Failed to symlink %s to %s: %m", q, p);
 764                         return -errno;
 765                 }
 766
 767                 r = mkdir_p(q, 0755);
 768                 if (r < 0)
 769                         log_warning("failed to create directory %s: %m", q);
 770                 return 0;
 771         }
 772
 773         if (arg_link_journal == LINK_HOST) {
 774                 r = mkdir_p(p, 0755);
 775                 if (r < 0) {
 776                         log_error("Failed to create %s: %m", p);
 777                         return r;
 778                 }
 779
 780         } else if (access(p, F_OK) < 0)
 781                 return 0;
 782
 783         if (dir_is_empty(q) == 0) {
 784                 log_error("%s not empty.", q);
 785                 return -ENOTEMPTY;
 786         }
 787
 788         r = mkdir_p(q, 0755);
 789         if (r < 0) {
 790                 log_error("Failed to create %s: %m", q);
 791                 return r;
 792         }
 793
 794         if (mount(p, q, "bind", MS_BIND, NULL) < 0) {
 795                 log_error("Failed to bind mount journal from host into guest: %m");
 796                 return -errno;
 797         }
 798
 799         return 0;
 800 }
 801
 802 static int drop_capabilities(void) {
 803         return capability_bounding_set_drop(~arg_retain, false);
 804 }
 805
 806 static int is_os_tree(const char *path) {
 807         int r;
 808         char *p;
 809         /* We use /bin/sh as flag file if something is an OS */
 810
 811         if (asprintf(&p, "%s/bin/sh", path) < 0)
 812                 return -ENOMEM;
 813
 814         r = access(p, F_OK);
 815         free(p);
 816
 817         return r < 0 ? 0 : 1;
 818 }
 819
 820 static int process_pty(int master, sigset_t *mask) {
 821
 822         char in_buffer[LINE_MAX], out_buffer[LINE_MAX];
 823         size_t in_buffer_full = 0, out_buffer_full = 0;
 824         struct epoll_event stdin_ev, stdout_ev, master_ev, signal_ev;
 825         bool stdin_readable = false, stdout_writable = false, master_readable = false, master_writable = false;
 826         int ep = -1, signal_fd = -1, r;
 827
 828         fd_nonblock(STDIN_FILENO, 1);
 829         fd_nonblock(STDOUT_FILENO, 1);
 830         fd_nonblock(master, 1);
 831
 832         signal_fd = signalfd(-1, mask, SFD_NONBLOCK|SFD_CLOEXEC);
 833         if (signal_fd < 0) {
 834                 log_error("signalfd(): %m");
 835                 r = -errno;
 836                 goto finish;
 837         }
 838
 839         ep = epoll_create1(EPOLL_CLOEXEC);
 840         if (ep < 0) {
 841                 log_error("Failed to create epoll: %m");
 842                 r = -errno;
 843                 goto finish;
 844         }
 845
 846         /* We read from STDIN only if this is actually a TTY,
 847          * otherwise we assume non-interactivity. */
 848         if (isatty(STDIN_FILENO)) {
 849                 zero(stdin_ev);
 850                 stdin_ev.events = EPOLLIN|EPOLLET;
 851                 stdin_ev.data.fd = STDIN_FILENO;
 852
 853                 if (epoll_ctl(ep, EPOLL_CTL_ADD, STDIN_FILENO, &stdin_ev) < 0) {
 854                         log_error("Failed to register STDIN in epoll: %m");
 855                         r = -errno;
 856                         goto finish;
 857                 }
 858         }
 859
 860         zero(stdout_ev);
 861         stdout_ev.events = EPOLLOUT|EPOLLET;
 862         stdout_ev.data.fd = STDOUT_FILENO;
 863
 864         zero(master_ev);
 865         master_ev.events = EPOLLIN|EPOLLOUT|EPOLLET;
 866         master_ev.data.fd = master;
 867
 868         zero(signal_ev);
 869         signal_ev.events = EPOLLIN;
 870         signal_ev.data.fd = signal_fd;
 871
 872         if (epoll_ctl(ep, EPOLL_CTL_ADD, STDOUT_FILENO, &stdout_ev) < 0 ||
 873             epoll_ctl(ep, EPOLL_CTL_ADD, master, &master_ev) < 0 ||
 874             epoll_ctl(ep, EPOLL_CTL_ADD, signal_fd, &signal_ev) < 0) {
 875                 log_error("Failed to register fds in epoll: %m");
 876                 r = -errno;
 877                 goto finish;
 878         }
 879
 880         for (;;) {
 881                 struct epoll_event ev[16];
 882                 ssize_t k;
 883                 int i, nfds;
 884
 885                 nfds = epoll_wait(ep, ev, ELEMENTSOF(ev), -1);
 886                 if (nfds < 0) {
 887
 888                         if (errno == EINTR || errno == EAGAIN)
 889                                 continue;
 890
 891                         log_error("epoll_wait(): %m");
 892                         r = -errno;
 893                         goto finish;
 894                 }
 895
 896                 assert(nfds >= 1);
 897
 898                 for (i = 0; i < nfds; i++) {
 899                         if (ev[i].data.fd == STDIN_FILENO) {
 900
 901                                 if (ev[i].events & (EPOLLIN|EPOLLHUP))
 902                                         stdin_readable = true;
 903
 904                         } else if (ev[i].data.fd == STDOUT_FILENO) {
 905
 906                                 if (ev[i].events & (EPOLLOUT|EPOLLHUP))
 907                                         stdout_writable = true;
 908
 909                         } else if (ev[i].data.fd == master) {
 910
 911                                 if (ev[i].events & (EPOLLIN|EPOLLHUP))
 912                                         master_readable = true;
 913
 914                                 if (ev[i].events & (EPOLLOUT|EPOLLHUP))
 915                                         master_writable = true;
 916
 917                         } else if (ev[i].data.fd == signal_fd) {
 918                                 struct signalfd_siginfo sfsi;
 919                                 ssize_t n;
 920
 921                                 n = read(signal_fd, &sfsi, sizeof(sfsi));
 922                                 if (n != sizeof(sfsi)) {
 923
 924                                         if (n >= 0) {
 925                                                 log_error("Failed to read from signalfd: invalid block size");
 926                                                 r = -EIO;
 927                                                 goto finish;
 928                                         }
 929
 930                                         if (errno != EINTR && errno != EAGAIN) {
 931                                                 log_error("Failed to read from signalfd: %m");
 932                                                 r = -errno;
 933                                                 goto finish;
 934                                         }
 935                                 } else {
 936
 937                                         if (sfsi.ssi_signo == SIGWINCH) {
 938                                                 struct winsize ws;
 939
 940                                                 /* The window size changed, let's forward that. */
 941                                                 if (ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) >= 0)
 942                                                         ioctl(master, TIOCSWINSZ, &ws);
 943                                         } else {
 944                                                 r = 0;
 945                                                 goto finish;
 946                                         }
 947                                 }
 948                         }
 949                 }
 950
 951                 while ((stdin_readable && in_buffer_full <= 0) ||
 952                        (master_writable && in_buffer_full > 0) ||
 953                        (master_readable && out_buffer_full <= 0) ||
 954                        (stdout_writable && out_buffer_full > 0)) {
 955
 956                         if (stdin_readable && in_buffer_full < LINE_MAX) {
 957
 958                                 k = read(STDIN_FILENO, in_buffer + in_buffer_full, LINE_MAX - in_buffer_full);
 959                                 if (k < 0) {
 960
 961                                         if (errno == EAGAIN || errno == EPIPE || errno == ECONNRESET || errno == EIO)
 962                                                 stdin_readable = false;
 963                                         else {
 964                                                 log_error("read(): %m");
 965                                                 r = -errno;
 966                                                 goto finish;
 967                                         }
 968                                 } else
 969                                         in_buffer_full += (size_t) k;
 970                         }
 971
 972                         if (master_writable && in_buffer_full > 0) {
 973
 974                                 k = write(master, in_buffer, in_buffer_full);
 975                                 if (k < 0) {
 976
 977                                         if (errno == EAGAIN || errno == EPIPE || errno == ECONNRESET || errno == EIO)
 978                                                 master_writable = false;
 979                                         else {
 980                                                 log_error("write(): %m");
 981                                                 r = -errno;
 982                                                 goto finish;
 983                                         }
 984
 985                                 } else {
 986                                         assert(in_buffer_full >= (size_t) k);
 987                                         memmove(in_buffer, in_buffer + k, in_buffer_full - k);
 988                                         in_buffer_full -= k;
 989                                 }
 990                         }
 991
 992                         if (master_readable && out_buffer_full < LINE_MAX) {
 993
 994                                 k = read(master, out_buffer + out_buffer_full, LINE_MAX - out_buffer_full);
 995                                 if (k < 0) {
 996
 997                                         if (errno == EAGAIN || errno == EPIPE || errno == ECONNRESET || errno == EIO)
 998                                                 master_readable = false;
 999                                         else {
1000                                                 log_error("read(): %m");
1001                                                 r = -errno;
1002                                                 goto finish;
1003                                         }
1004                                 }  else
1005                                         out_buffer_full += (size_t) k;
1006                         }
1007
1008                         if (stdout_writable && out_buffer_full > 0) {
1009
1010                                 k = write(STDOUT_FILENO, out_buffer, out_buffer_full);
1011                                 if (k < 0) {
1012
1013                                         if (errno == EAGAIN || errno == EPIPE || errno == ECONNRESET || errno == EIO)
1014                                                 stdout_writable = false;
1015                                         else {
1016                                                 log_error("write(): %m");
1017                                                 r = -errno;
1018                                                 goto finish;
1019                                         }
1020
1021                                 } else {
1022                                         assert(out_buffer_full >= (size_t) k);
1023                                         memmove(out_buffer, out_buffer + k, out_buffer_full - k);
1024                                         out_buffer_full -= k;
1025                                 }
1026                         }
1027                 }
1028         }
1029
1030 finish:
1031         if (ep >= 0)
1032                 close_nointr_nofail(ep);
1033
1034         if (signal_fd >= 0)
1035                 close_nointr_nofail(signal_fd);
1036
1037         return r;
1038 }
1039
1040 int main(int argc, char *argv[]) {
1041         pid_t pid = 0;
1042         int r = EXIT_FAILURE, k;
1043         char *oldcg = NULL, *newcg = NULL;
1044         char **controller = NULL;
1045         int master = -1, n_fd_passed;
1046         const char *console = NULL;
1047         struct termios saved_attr, raw_attr;
1048         sigset_t mask;
1049         bool saved_attr_valid = false;
1050         struct winsize ws;
1051         int kmsg_socket_pair[2] = { -1, -1 };
1052         FDSet *fds = NULL;
1053
1054         log_parse_environment();
1055         log_open();
1056
1057         r = parse_argv(argc, argv);
1058         if (r <= 0)
1059                 goto finish;
1060
1061         if (arg_directory) {
1062                 char *p;
1063
1064                 p = path_make_absolute_cwd(arg_directory);
1065                 free(arg_directory);
1066                 arg_directory = p;
1067         } else
1068                 arg_directory = get_current_dir_name();
1069
1070         if (!arg_directory) {
1071                 log_error("Failed to determine path");
1072                 goto finish;
1073         }
1074
1075         path_kill_slashes(arg_directory);
1076
1077         if (geteuid() != 0) {
1078                 log_error("Need to be root.");
1079                 goto finish;
1080         }
1081
1082         if (sd_booted() <= 0) {
1083                 log_error("Not running on a systemd system.");
1084                 goto finish;
1085         }
1086
1087         if (path_equal(arg_directory, "/")) {
1088                 log_error("Spawning container on root directory not supported.");
1089                 goto finish;
1090         }
1091
1092         if (is_os_tree(arg_directory) <= 0) {
1093                 log_error("Directory %s doesn't look like an OS root directory. Refusing.", arg_directory);
1094                 goto finish;
1095         }
1096
1097         log_close();
1098         n_fd_passed = sd_listen_fds(false);
1099         if (n_fd_passed > 0) {
1100                 k = fdset_new_listen_fds(&fds, false);
1101                 if (k < 0) {
1102                         log_error("Failed to collect file descriptors: %s", strerror(-k));
1103                         goto finish;
1104                 }
1105         }
1106         fdset_close_others(fds);
1107         log_open();
1108
1109         k = cg_get_by_pid(SYSTEMD_CGROUP_CONTROLLER, 0, &oldcg);
1110         if (k < 0) {
1111                 log_error("Failed to determine current cgroup: %s", strerror(-k));
1112                 goto finish;
1113         }
1114
1115         if (asprintf(&newcg, "%s/nspawn-%lu", oldcg, (unsigned long) getpid()) < 0) {
1116                 log_error("Failed to allocate cgroup path.");
1117                 goto finish;
1118         }
1119
1120         k = cg_create_and_attach(SYSTEMD_CGROUP_CONTROLLER, newcg, 0);
1121         if (k < 0)  {
1122                 log_error("Failed to create cgroup: %s", strerror(-k));
1123                 goto finish;
1124         }
1125
1126         STRV_FOREACH(controller, arg_controllers) {
1127                 k = cg_create_and_attach(*controller, newcg, 0);
1128                 if (k < 0)
1129                         log_warning("Failed to create cgroup in controller %s: %s", *controller, strerror(-k));
1130         }
1131
1132         master = posix_openpt(O_RDWR|O_NOCTTY|O_CLOEXEC|O_NDELAY);
1133         if (master < 0) {
1134                 log_error("Failed to acquire pseudo tty: %m");
1135                 goto finish;
1136         }
1137
1138         console = ptsname(master);
1139         if (!console) {
1140                 log_error("Failed to determine tty name: %m");
1141                 goto finish;
1142         }
1143
1144         log_info("Spawning namespace container on %s (console is %s).", arg_directory, console);
1145
1146         if (ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) >= 0)
1147                 ioctl(master, TIOCSWINSZ, &ws);
1148
1149         if (unlockpt(master) < 0) {
1150                 log_error("Failed to unlock tty: %m");
1151                 goto finish;
1152         }
1153
1154         if (tcgetattr(STDIN_FILENO, &saved_attr) >= 0) {
1155                 saved_attr_valid = true;
1156
1157                 raw_attr = saved_attr;
1158                 cfmakeraw(&raw_attr);
1159                 raw_attr.c_lflag &= ~ECHO;
1160         }
1161
1162         if (socketpair(AF_UNIX, SOCK_DGRAM|SOCK_NONBLOCK|SOCK_CLOEXEC, 0, kmsg_socket_pair) < 0) {
1163                 log_error("Failed to create kmsg socket pair");
1164                 goto finish;
1165         }
1166
1167         assert_se(sigemptyset(&mask) == 0);
1168         sigset_add_many(&mask, SIGCHLD, SIGWINCH, SIGTERM, SIGINT, -1);
1169         assert_se(sigprocmask(SIG_BLOCK, &mask, NULL) == 0);
1170
1171         for (;;) {
1172                 siginfo_t status;
1173
1174                 if (saved_attr_valid) {
1175                         if (tcsetattr(STDIN_FILENO, TCSANOW, &raw_attr) < 0) {
1176                                 log_error("Failed to set terminal attributes: %m");
1177                                 goto finish;
1178                         }
1179                 }
1180
1181                 pid = syscall(__NR_clone, SIGCHLD|CLONE_NEWIPC|CLONE_NEWNS|CLONE_NEWPID|CLONE_NEWUTS|(arg_private_network ? CLONE_NEWNET : 0), NULL);
1182                 if (pid < 0) {
1183                         if (errno == EINVAL)
1184                                 log_error("clone() failed, do you have namespace support enabled in your kernel? (You need UTS, IPC, PID and NET namespacing built in): %m");
1185                         else
1186                                 log_error("clone() failed: %m");
1187
1188                         goto finish;
1189                 }
1190
1191                 if (pid == 0) {
1192                         /* child */
1193
1194                         const char *home = NULL;
1195                         uid_t uid = (uid_t) -1;
1196                         gid_t gid = (gid_t) -1;
1197                         unsigned n_env = 0;
1198                         const char *envp[] = {
1199                                 "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
1200                                 "container=systemd-nspawn", /* LXC sets container=lxc, so follow the scheme here */
1201                                 NULL, /* TERM */
1202                                 NULL, /* HOME */
1203                                 NULL, /* USER */
1204                                 NULL, /* LOGNAME */
1205                                 NULL, /* container_uuid */
1206                                 NULL, /* LISTEN_FDS */
1207                                 NULL, /* LISTEN_PID */
1208                                 NULL
1209                         };
1210
1211                         envp[2] = strv_find_prefix(environ, "TERM=");
1212                         n_env = 3;
1213
1214                         close_nointr_nofail(master);
1215                         master = -1;
1216
1217                         close_nointr(STDIN_FILENO);
1218                         close_nointr(STDOUT_FILENO);
1219                         close_nointr(STDERR_FILENO);
1220
1221                         close_nointr_nofail(kmsg_socket_pair[0]);
1222                         kmsg_socket_pair[0] = -1;
1223
1224                         reset_all_signal_handlers();
1225
1226                         assert_se(sigemptyset(&mask) == 0);
1227                         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
1228
1229                         k = open_terminal(console, O_RDWR);
1230                         if (k != STDIN_FILENO) {
1231                                 if (k >= 0) {
1232                                         close_nointr_nofail(k);
1233                                         k = -EINVAL;
1234                                 }
1235
1236                                 log_error("Failed to open console: %s", strerror(-k));
1237                                 goto child_fail;
1238                         }
1239
1240                         if (dup2(STDIN_FILENO, STDOUT_FILENO) != STDOUT_FILENO ||
1241                             dup2(STDIN_FILENO, STDERR_FILENO) != STDERR_FILENO) {
1242                                 log_error("Failed to duplicate console: %m");
1243                                 goto child_fail;
1244                         }
1245
1246                         if (setsid() < 0) {
1247                                 log_error("setsid() failed: %m");
1248                                 goto child_fail;
1249                         }
1250
1251                         if (prctl(PR_SET_PDEATHSIG, SIGKILL) < 0) {
1252                                 log_error("PR_SET_PDEATHSIG failed: %m");
1253                                 goto child_fail;
1254                         }
1255
1256                         /* Mark everything as slave, so that we still
1257                          * receive mounts from the real root, but don't
1258                          * propagate mounts to the real root. */
1259                         if (mount(NULL, "/", NULL, MS_SLAVE|MS_REC, NULL) < 0) {
1260                                 log_error("MS_SLAVE|MS_REC failed: %m");
1261                                 goto child_fail;
1262                         }
1263
1264                         /* Turn directory into bind mount */
1265                         if (mount(arg_directory, arg_directory, "bind", MS_BIND|MS_REC, NULL) < 0) {
1266                                 log_error("Failed to make bind mount.");
1267                                 goto child_fail;
1268                         }
1269
1270                         if (arg_read_only)
1271                                 if (mount(arg_directory, arg_directory, "bind", MS_BIND|MS_REMOUNT|MS_RDONLY|MS_REC, NULL) < 0) {
1272                                         log_error("Failed to make read-only.");
1273                                         goto child_fail;
1274                                 }
1275
1276                         if (mount_all(arg_directory) < 0)
1277                                 goto child_fail;
1278
1279                         if (copy_devnodes(arg_directory) < 0)
1280                                 goto child_fail;
1281
1282                         dev_setup(arg_directory);
1283
1284                         if (setup_dev_console(arg_directory, console) < 0)
1285                                 goto child_fail;
1286
1287                         if (setup_kmsg(arg_directory, kmsg_socket_pair[1]) < 0)
1288                                 goto child_fail;
1289
1290                         close_nointr_nofail(kmsg_socket_pair[1]);
1291                         kmsg_socket_pair[1] = -1;
1292
1293                         if (setup_boot_id(arg_directory) < 0)
1294                                 goto child_fail;
1295
1296                         if (setup_timezone(arg_directory) < 0)
1297                                 goto child_fail;
1298
1299                         if (setup_resolv_conf(arg_directory) < 0)
1300                                 goto child_fail;
1301
1302                         if (setup_journal(arg_directory) < 0)
1303                                 goto child_fail;
1304
1305                         if (chdir(arg_directory) < 0) {
1306                                 log_error("chdir(%s) failed: %m", arg_directory);
1307                                 goto child_fail;
1308                         }
1309
1310                         if (mount(arg_directory, "/", NULL, MS_MOVE, NULL) < 0) {
1311                                 log_error("mount(MS_MOVE) failed: %m");
1312                                 goto child_fail;
1313                         }
1314
1315                         if (chroot(".") < 0) {
1316                                 log_error("chroot() failed: %m");
1317                                 goto child_fail;
1318                         }
1319
1320                         if (chdir("/") < 0) {
1321                                 log_error("chdir() failed: %m");
1322                                 goto child_fail;
1323                         }
1324
1325                         umask(0022);
1326
1327                         loopback_setup();
1328
1329                         if (drop_capabilities() < 0) {
1330                                 log_error("drop_capabilities() failed: %m");
1331                                 goto child_fail;
1332                         }
1333
1334                         if (arg_user) {
1335
1336                                 /* Note that this resolves user names
1337                                  * inside the container, and hence
1338                                  * accesses the NSS modules from the
1339                                  * container and not the host. This is
1340                                  * a bit weird... */
1341
1342                                 if (get_user_creds((const char**)&arg_user, &uid, &gid, &home, NULL) < 0) {
1343                                         log_error("get_user_creds() failed: %m");
1344                                         goto child_fail;
1345                                 }
1346
1347                                 if (mkdir_parents_label(home, 0775) < 0) {
1348                                         log_error("mkdir_parents_label() failed: %m");
1349                                         goto child_fail;
1350                                 }
1351
1352                                 if (mkdir_safe_label(home, 0775, uid, gid) < 0) {
1353                                         log_error("mkdir_safe_label() failed: %m");
1354                                         goto child_fail;
1355                                 }
1356
1357                                 if (initgroups((const char*)arg_user, gid) < 0) {
1358                                         log_error("initgroups() failed: %m");
1359                                         goto child_fail;
1360                                 }
1361
1362                                 if (setresgid(gid, gid, gid) < 0) {
1363                                         log_error("setregid() failed: %m");
1364                                         goto child_fail;
1365                                 }
1366
1367                                 if (setresuid(uid, uid, uid) < 0) {
1368                                         log_error("setreuid() failed: %m");
1369                                         goto child_fail;
1370                                 }
1371                         } else {
1372                                 /* Reset everything fully to 0, just in case */
1373
1374                                 if (setgroups(0, NULL) < 0) {
1375                                         log_error("setgroups() failed: %m");
1376                                         goto child_fail;
1377                                 }
1378
1379                                 if (setresgid(0, 0, 0) < 0) {
1380                                         log_error("setregid() failed: %m");
1381                                         goto child_fail;
1382                                 }
1383
1384                                 if (setresuid(0, 0, 0) < 0) {
1385                                         log_error("setreuid() failed: %m");
1386                                         goto child_fail;
1387                                 }
1388                         }
1389
1390                         if ((asprintf((char**)(envp + n_env++), "HOME=%s", home ? home: "/root") < 0) ||
1391                             (asprintf((char**)(envp + n_env++), "USER=%s", arg_user ? arg_user : "root") < 0) ||
1392                             (asprintf((char**)(envp + n_env++), "LOGNAME=%s", arg_user ? arg_user : "root") < 0)) {
1393                                 log_oom();
1394                                 goto child_fail;
1395                         }
1396
1397                         if (arg_uuid) {
1398                                 if (asprintf((char**)(envp + n_env++), "container_uuid=%s", arg_uuid) < 0) {
1399                                         log_oom();
1400                                         goto child_fail;
1401                                 }
1402                         }
1403
1404                         if (fdset_size(fds) > 0) {
1405                                 k = fdset_cloexec(fds, false);
1406                                 if (k < 0) {
1407                                         log_error("Failed to unset O_CLOEXEC for file descriptors.");
1408                                         goto child_fail;
1409                                 }
1410
1411                                 if ((asprintf((char **)(envp + n_env++), "LISTEN_FDS=%u", n_fd_passed) < 0) ||
1412                                     (asprintf((char **)(envp + n_env++), "LISTEN_PID=%lu", (unsigned long) getpid()) < 0)) {
1413                                         log_oom();
1414                                         goto child_fail;
1415                                 }
1416                         }
1417
1418                         setup_hostname();
1419
1420                         if (arg_boot) {
1421                                 char **a;
1422                                 size_t l;
1423
1424                                 /* Automatically search for the init system */
1425
1426                                 l = 1 + argc - optind;
1427                                 a = newa(char*, l + 1);
1428                                 memcpy(a + 1, argv + optind, l * sizeof(char*));
1429
1430                                 a[0] = (char*) "/usr/lib/systemd/systemd";
1431                                 execve(a[0], a, (char**) envp);
1432
1433                                 a[0] = (char*) "/lib/systemd/systemd";
1434                                 execve(a[0], a, (char**) envp);
1435
1436                                 a[0] = (char*) "/sbin/init";
1437                                 execve(a[0], a, (char**) envp);
1438                         } else if (argc > optind)
1439                                 execvpe(argv[optind], argv + optind, (char**) envp);
1440                         else {
1441                                 chdir(home ? home : "/root");
1442                                 execle("/bin/bash", "-bash", NULL, (char**) envp);
1443                         }
1444
1445                         log_error("execv() failed: %m");
1446
1447                 child_fail:
1448                         _exit(EXIT_FAILURE);
1449                 }
1450
1451                 fdset_free(fds);
1452                 fds = NULL;
1453
1454                 if (process_pty(master, &mask) < 0)
1455                         goto finish;
1456
1457                 if (saved_attr_valid)
1458                         tcsetattr(STDIN_FILENO, TCSANOW, &saved_attr);
1459
1460                 r = wait_for_terminate(pid, &status);
1461                 if (r < 0) {
1462                         r = EXIT_FAILURE;
1463                         break;
1464                 }
1465
1466                 if (status.si_code == CLD_EXITED) {
1467                         if (status.si_status != 0) {
1468                                 log_error("Container failed with error code %i.", status.si_status);
1469                                 r = status.si_status;
1470                                 break;
1471                         }
1472
1473                         log_debug("Container exited successfully.");
1474                         break;
1475                 } else if (status.si_code == CLD_KILLED &&
1476                            status.si_status == SIGINT) {
1477                         log_info("Container has been shut down.");
1478                         r = 0;
1479                         break;
1480                 } else if (status.si_code == CLD_KILLED &&
1481                            status.si_status == SIGHUP) {
1482                         log_info("Container is being rebooted.");
1483                         continue;
1484                 } else if (status.si_code == CLD_KILLED ||
1485                            status.si_code == CLD_DUMPED) {
1486
1487                         log_error("Container terminated by signal %s.", signal_to_string(status.si_status));
1488                         r = EXIT_FAILURE;
1489                         break;
1490                 } else {
1491                         log_error("Container failed due to unknown reason.");
1492                         r = EXIT_FAILURE;
1493                         break;
1494                 }
1495         }
1496
1497 finish:
1498         if (saved_attr_valid)
1499                 tcsetattr(STDIN_FILENO, TCSANOW, &saved_attr);
1500
1501         if (master >= 0)
1502                 close_nointr_nofail(master);
1503
1504         close_pipe(kmsg_socket_pair);
1505
1506         if (oldcg)
1507                 cg_attach(SYSTEMD_CGROUP_CONTROLLER, oldcg, 0);
1508
1509         if (newcg)
1510                 cg_kill_recursive_and_wait(SYSTEMD_CGROUP_CONTROLLER, newcg, true);
1511
1512         free(arg_directory);
1513         strv_free(arg_controllers);
1514         free(oldcg);
1515         free(newcg);
1516
1517         fdset_free(fds);
1518
1519         return r;
1520 }