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