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         if (mount("/etc/resolv.conf", where, "bind", MS_BIND, NULL) >= 0)
 408                 mount("/etc/resolv.conf", where, "bind", MS_BIND|MS_REMOUNT|MS_RDONLY, NULL);
 409
 410         free(where);
 411
 412         return 0;
 413 }
 414
 415 static int setup_boot_id(const char *dest) {
 416         char _cleanup_free_ *from = NULL, *to = NULL;
 417         sd_id128_t rnd;
 418         char as_uuid[37];
 419         int r;
 420
 421         assert(dest);
 422
 423         /* Generate a new randomized boot ID, so that each boot-up of
 424          * the container gets a new one */
 425
 426         from = strappend(dest, "/dev/proc-sys-kernel-random-boot-id");
 427         to = strappend(dest, "/proc/sys/kernel/random/boot_id");
 428         if (!from || !to)
 429                 return log_oom();
 430
 431         r = sd_id128_randomize(&rnd);
 432         if (r < 0) {
 433                 log_error("Failed to generate random boot id: %s", strerror(-r));
 434                 return r;
 435         }
 436
 437         snprintf(as_uuid, sizeof(as_uuid),
 438                  "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
 439                  SD_ID128_FORMAT_VAL(rnd));
 440         char_array_0(as_uuid);
 441
 442         r = write_one_line_file(from, as_uuid);
 443         if (r < 0) {
 444                 log_error("Failed to write boot id: %s", strerror(-r));
 445                 return r;
 446         }
 447
 448         if (mount(from, to, "bind", MS_BIND, NULL) < 0) {
 449                 log_error("Failed to bind mount boot id: %m");
 450                 r = -errno;
 451         } else
 452                 mount(from, to, "bind", MS_BIND|MS_REMOUNT|MS_RDONLY, NULL);
 453
 454         unlink(from);
 455         return r;
 456 }
 457
 458 static int copy_devnodes(const char *dest) {
 459
 460         static const char devnodes[] =
 461                 "null\0"
 462                 "zero\0"
 463                 "full\0"
 464                 "random\0"
 465                 "urandom\0"
 466                 "tty\0"
 467                 "ptmx\0";
 468
 469         const char *d;
 470         int r = 0;
 471         mode_t _cleanup_umask_ u;
 472
 473         assert(dest);
 474
 475         u = umask(0000);
 476
 477         NULSTR_FOREACH(d, devnodes) {
 478                 struct stat st;
 479                 char _cleanup_free_ *from = NULL, *to = NULL;
 480
 481                 asprintf(&from, "/dev/%s", d);
 482                 asprintf(&to, "%s/dev/%s", dest, d);
 483
 484                 if (!from || !to) {
 485                         log_oom();
 486
 487                         if (r == 0)
 488                                 r = -ENOMEM;
 489
 490                         break;
 491                 }
 492
 493                 if (stat(from, &st) < 0) {
 494
 495                         if (errno != ENOENT) {
 496                                 log_error("Failed to stat %s: %m", from);
 497                                 if (r == 0)
 498                                         r = -errno;
 499                         }
 500
 501                 } else if (!S_ISCHR(st.st_mode) && !S_ISBLK(st.st_mode)) {
 502
 503                         log_error("%s is not a char or block device, cannot copy", from);
 504                         if (r == 0)
 505                                 r = -EIO;
 506
 507                 } else if (mknod(to, st.st_mode, st.st_rdev) < 0) {
 508
 509                         log_error("mknod(%s) failed: %m", dest);
 510                         if (r == 0)
 511                                 r = -errno;
 512                 }
 513         }
 514
 515         return r;
 516 }
 517
 518 static int setup_dev_console(const char *dest, const char *console) {
 519         struct stat st;
 520         char _cleanup_free_ *to = NULL;
 521         int r;
 522         mode_t _cleanup_umask_ u;
 523
 524         assert(dest);
 525         assert(console);
 526
 527         u = umask(0000);
 528
 529         if (stat(console, &st) < 0) {
 530                 log_error("Failed to stat %s: %m", console);
 531                 return -errno;
 532
 533         } else if (!S_ISCHR(st.st_mode)) {
 534                 log_error("/dev/console is not a char device");
 535                 return -EIO;
 536         }
 537
 538         r = chmod_and_chown(console, 0600, 0, 0);
 539         if (r < 0) {
 540                 log_error("Failed to correct access mode for TTY: %s", strerror(-r));
 541                 return r;
 542         }
 543
 544         if (asprintf(&to, "%s/dev/console", dest) < 0)
 545                 return log_oom();
 546
 547         /* We need to bind mount the right tty to /dev/console since
 548          * ptys can only exist on pts file systems. To have something
 549          * to bind mount things on we create a device node first, that
 550          * has the right major/minor (note that the major minor
 551          * doesn't actually matter here, since we mount it over
 552          * anyway). */
 553
 554         if (mknod(to, (st.st_mode & ~07777) | 0600, st.st_rdev) < 0) {
 555                 log_error("mknod() for /dev/console failed: %m");
 556                 return -errno;
 557         }
 558
 559         if (mount(console, to, "bind", MS_BIND, NULL) < 0) {
 560                 log_error("Bind mount for /dev/console failed: %m");
 561                 return -errno;
 562         }
 563
 564         return 0;
 565 }
 566
 567 static int setup_kmsg(const char *dest, int kmsg_socket) {
 568         char _cleanup_free_ *from = NULL, *to = NULL;
 569         int r, fd, k;
 570         mode_t _cleanup_umask_ u;
 571         union {
 572                 struct cmsghdr cmsghdr;
 573                 uint8_t buf[CMSG_SPACE(sizeof(int))];
 574         } control;
 575         struct msghdr mh;
 576         struct cmsghdr *cmsg;
 577
 578         assert(dest);
 579         assert(kmsg_socket >= 0);
 580
 581         u = umask(0000);
 582
 583         /* We create the kmsg FIFO as /dev/kmsg, but immediately
 584          * delete it after bind mounting it to /proc/kmsg. While FIFOs
 585          * on the reading side behave very similar to /proc/kmsg,
 586          * their writing side behaves differently from /dev/kmsg in
 587          * that writing blocks when nothing is reading. In order to
 588          * avoid any problems with containers deadlocking due to this
 589          * we simply make /dev/kmsg unavailable to the container. */
 590         if (asprintf(&from, "%s/dev/kmsg", dest) < 0 ||
 591             asprintf(&to, "%s/proc/kmsg", dest) < 0)
 592                 return log_oom();
 593
 594         if (mkfifo(from, 0600) < 0) {
 595                 log_error("mkfifo() for /dev/kmsg failed: %m");
 596                 return -errno;
 597         }
 598
 599         r = chmod_and_chown(from, 0600, 0, 0);
 600         if (r < 0) {
 601                 log_error("Failed to correct access mode for /dev/kmsg: %s", strerror(-r));
 602                 return r;
 603         }
 604
 605         if (mount(from, to, "bind", MS_BIND, NULL) < 0) {
 606                 log_error("Bind mount for /proc/kmsg failed: %m");
 607                 return -errno;
 608         }
 609
 610         fd = open(from, O_RDWR|O_NDELAY|O_CLOEXEC);
 611         if (fd < 0) {
 612                 log_error("Failed to open fifo: %m");
 613                 return -errno;
 614         }
 615
 616         zero(mh);
 617         zero(control);
 618
 619         mh.msg_control = &control;
 620         mh.msg_controllen = sizeof(control);
 621
 622         cmsg = CMSG_FIRSTHDR(&mh);
 623         cmsg->cmsg_level = SOL_SOCKET;
 624         cmsg->cmsg_type = SCM_RIGHTS;
 625         cmsg->cmsg_len = CMSG_LEN(sizeof(int));
 626         memcpy(CMSG_DATA(cmsg), &fd, sizeof(int));
 627
 628         mh.msg_controllen = cmsg->cmsg_len;
 629
 630         /* Store away the fd in the socket, so that it stays open as
 631          * long as we run the child */
 632         k = sendmsg(kmsg_socket, &mh, MSG_DONTWAIT|MSG_NOSIGNAL);
 633         close_nointr_nofail(fd);
 634
 635         if (k < 0) {
 636                 log_error("Failed to send FIFO fd: %m");
 637                 return -errno;
 638         }
 639
 640         /* And now make the FIFO unavailable as /dev/kmsg... */
 641         unlink(from);
 642         return 0;
 643 }
 644
 645 static int setup_hostname(void) {
 646         char *hn;
 647         int r = 0;
 648
 649         hn = path_get_file_name(arg_directory);
 650         if (hn) {
 651                 hn = strdup(hn);
 652                 if (!hn)
 653                         return -ENOMEM;
 654
 655                 hostname_cleanup(hn);
 656
 657                 if (!isempty(hn))
 658                         if (sethostname(hn, strlen(hn)) < 0)
 659                                 r = -errno;
 660
 661                 free(hn);
 662         }
 663
 664         return r;
 665 }
 666
 667 static int setup_journal(const char *directory) {
 668         sd_id128_t machine_id;
 669         char *p = NULL, *b = NULL, *l, *q = NULL, *d = NULL;
 670         int r;
 671
 672         if (arg_link_journal == LINK_NO)
 673                 return 0;
 674
 675         p = strappend(directory, "/etc/machine-id");
 676         if (!p) {
 677                 r = log_oom();
 678                 goto finish;
 679         }
 680
 681         r = read_one_line_file(p, &b);
 682         if (r == -ENOENT && arg_link_journal == LINK_AUTO) {
 683                 r = 0;
 684                 goto finish;
 685         } else if (r < 0) {
 686                 log_error("Failed to read machine ID: %s", strerror(-r));
 687                 return r;
 688         }
 689
 690         l = strstrip(b);
 691         if (isempty(l) && arg_link_journal == LINK_AUTO) {
 692                 r = 0;
 693                 goto finish;
 694         }
 695
 696         /* Verify validaty */
 697         r = sd_id128_from_string(l, &machine_id);
 698         if (r < 0) {
 699                 log_error("Failed to parse machine ID: %s", strerror(-r));
 700                 goto finish;
 701         }
 702
 703         free(p);
 704         p = strappend("/var/log/journal/", l);
 705         q = strjoin(directory, "/var/log/journal/", l, NULL);
 706         if (!p || !q) {
 707                 r = log_oom();
 708                 goto finish;
 709         }
 710
 711         if (path_is_mount_point(p, false) > 0 ||
 712             path_is_mount_point(q, false) > 0) {
 713                 if (arg_link_journal != LINK_AUTO) {
 714                         log_error("Journal already a mount point, refusing.");
 715                         r = -EEXIST;
 716                         goto finish;
 717                 }
 718
 719                 r = 0;
 720                 goto finish;
 721         }
 722
 723         r = readlink_and_make_absolute(p, &d);
 724         if (r >= 0) {
 725                 if ((arg_link_journal == LINK_GUEST ||
 726                      arg_link_journal == LINK_AUTO) &&
 727                     path_equal(d, q)) {
 728
 729                         mkdir_p(q, 0755);
 730
 731                         r = 0;
 732                         goto finish;
 733                 }
 734
 735                 if (unlink(p) < 0) {
 736                         log_error("Failed to remove symlink %s: %m", p);
 737                         r = -errno;
 738                         goto finish;
 739                 }
 740         } else if (r == -EINVAL) {
 741
 742                 if (arg_link_journal == LINK_GUEST &&
 743                     rmdir(p) < 0) {
 744
 745                         if (errno == ENOTDIR)
 746                                 log_error("%s already exists and is neither symlink nor directory.", p);
 747                         else {
 748                                 log_error("Failed to remove %s: %m", p);
 749                                 r = -errno;
 750                         }
 751
 752                         goto finish;
 753                 }
 754         } else if (r != -ENOENT) {
 755                 log_error("readlink(%s) failed: %m", p);
 756                 goto finish;
 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                         r = -errno;
 764                         goto finish;
 765                 }
 766
 767                 mkdir_p(q, 0755);
 768
 769                 r = 0;
 770                 goto finish;
 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                         goto finish;
 778                 }
 779
 780         } else if (access(p, F_OK) < 0) {
 781                 r = 0;
 782                 goto finish;
 783         }
 784
 785         if (dir_is_empty(q) == 0) {
 786                 log_error("%s not empty.", q);
 787                 r = -ENOTEMPTY;
 788                 goto finish;
 789         }
 790
 791         r = mkdir_p(q, 0755);
 792         if (r < 0) {
 793                 log_error("Failed to create %s: %m", q);
 794                 goto finish;
 795         }
 796
 797         if (mount(p, q, "bind", MS_BIND, NULL) < 0) {
 798                 log_error("Failed to bind mount journal from host into guest: %m");
 799                 r = -errno;
 800                 goto finish;
 801         }
 802
 803         r = 0;
 804
 805 finish:
 806         free(p);
 807         free(q);
 808         free(d);
 809         free(b);
 810         return r;
 811
 812 }
 813
 814 static int drop_capabilities(void) {
 815         return capability_bounding_set_drop(~arg_retain, false);
 816 }
 817
 818 static int is_os_tree(const char *path) {
 819         int r;
 820         char *p;
 821         /* We use /bin/sh as flag file if something is an OS */
 822
 823         if (asprintf(&p, "%s/bin/sh", path) < 0)
 824                 return -ENOMEM;
 825
 826         r = access(p, F_OK);
 827         free(p);
 828
 829         return r < 0 ? 0 : 1;
 830 }
 831
 832 static int process_pty(int master, sigset_t *mask) {
 833
 834         char in_buffer[LINE_MAX], out_buffer[LINE_MAX];
 835         size_t in_buffer_full = 0, out_buffer_full = 0;
 836         struct epoll_event stdin_ev, stdout_ev, master_ev, signal_ev;
 837         bool stdin_readable = false, stdout_writable = false, master_readable = false, master_writable = false;
 838         int ep = -1, signal_fd = -1, r;
 839
 840         fd_nonblock(STDIN_FILENO, 1);
 841         fd_nonblock(STDOUT_FILENO, 1);
 842         fd_nonblock(master, 1);
 843
 844         signal_fd = signalfd(-1, mask, SFD_NONBLOCK|SFD_CLOEXEC);
 845         if (signal_fd < 0) {
 846                 log_error("signalfd(): %m");
 847                 r = -errno;
 848                 goto finish;
 849         }
 850
 851         ep = epoll_create1(EPOLL_CLOEXEC);
 852         if (ep < 0) {
 853                 log_error("Failed to create epoll: %m");
 854                 r = -errno;
 855                 goto finish;
 856         }
 857
 858         zero(stdin_ev);
 859         stdin_ev.events = EPOLLIN|EPOLLET;
 860         stdin_ev.data.fd = STDIN_FILENO;
 861
 862         zero(stdout_ev);
 863         stdout_ev.events = EPOLLOUT|EPOLLET;
 864         stdout_ev.data.fd = STDOUT_FILENO;
 865
 866         zero(master_ev);
 867         master_ev.events = EPOLLIN|EPOLLOUT|EPOLLET;
 868         master_ev.data.fd = master;
 869
 870         zero(signal_ev);
 871         signal_ev.events = EPOLLIN;
 872         signal_ev.data.fd = signal_fd;
 873
 874         if (epoll_ctl(ep, EPOLL_CTL_ADD, STDIN_FILENO, &stdin_ev) < 0 ||
 875             epoll_ctl(ep, EPOLL_CTL_ADD, STDOUT_FILENO, &stdout_ev) < 0 ||
 876             epoll_ctl(ep, EPOLL_CTL_ADD, master, &master_ev) < 0 ||
 877             epoll_ctl(ep, EPOLL_CTL_ADD, signal_fd, &signal_ev) < 0) {
 878                 log_error("Failed to regiser fds in epoll: %m");
 879                 r = -errno;
 880                 goto finish;
 881         }
 882
 883         for (;;) {
 884                 struct epoll_event ev[16];
 885                 ssize_t k;
 886                 int i, nfds;
 887
 888                 nfds = epoll_wait(ep, ev, ELEMENTSOF(ev), -1);
 889                 if (nfds < 0) {
 890
 891                         if (errno == EINTR || errno == EAGAIN)
 892                                 continue;
 893
 894                         log_error("epoll_wait(): %m");
 895                         r = -errno;
 896                         goto finish;
 897                 }
 898
 899                 assert(nfds >= 1);
 900
 901                 for (i = 0; i < nfds; i++) {
 902                         if (ev[i].data.fd == STDIN_FILENO) {
 903
 904                                 if (ev[i].events & (EPOLLIN|EPOLLHUP))
 905                                         stdin_readable = true;
 906
 907                         } else if (ev[i].data.fd == STDOUT_FILENO) {
 908
 909                                 if (ev[i].events & (EPOLLOUT|EPOLLHUP))
 910                                         stdout_writable = true;
 911
 912                         } else if (ev[i].data.fd == master) {
 913
 914                                 if (ev[i].events & (EPOLLIN|EPOLLHUP))
 915                                         master_readable = true;
 916
 917                                 if (ev[i].events & (EPOLLOUT|EPOLLHUP))
 918                                         master_writable = true;
 919
 920                         } else if (ev[i].data.fd == signal_fd) {
 921                                 struct signalfd_siginfo sfsi;
 922                                 ssize_t n;
 923
 924                                 n = read(signal_fd, &sfsi, sizeof(sfsi));
 925                                 if (n != sizeof(sfsi)) {
 926
 927                                         if (n >= 0) {
 928                                                 log_error("Failed to read from signalfd: invalid block size");
 929                                                 r = -EIO;
 930                                                 goto finish;
 931                                         }
 932
 933                                         if (errno != EINTR && errno != EAGAIN) {
 934                                                 log_error("Failed to read from signalfd: %m");
 935                                                 r = -errno;
 936                                                 goto finish;
 937                                         }
 938                                 } else {
 939
 940                                         if (sfsi.ssi_signo == SIGWINCH) {
 941                                                 struct winsize ws;
 942
 943                                                 /* The window size changed, let's forward that. */
 944                                                 if (ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) >= 0)
 945                                                         ioctl(master, TIOCSWINSZ, &ws);
 946                                         } else {
 947                                                 r = 0;
 948                                                 goto finish;
 949                                         }
 950                                 }
 951                         }
 952                 }
 953
 954                 while ((stdin_readable && in_buffer_full <= 0) ||
 955                        (master_writable && in_buffer_full > 0) ||
 956                        (master_readable && out_buffer_full <= 0) ||
 957                        (stdout_writable && out_buffer_full > 0)) {
 958
 959                         if (stdin_readable && in_buffer_full < LINE_MAX) {
 960
 961                                 k = read(STDIN_FILENO, in_buffer + in_buffer_full, LINE_MAX - in_buffer_full);
 962                                 if (k < 0) {
 963
 964                                         if (errno == EAGAIN || errno == EPIPE || errno == ECONNRESET || errno == EIO)
 965                                                 stdin_readable = false;
 966                                         else {
 967                                                 log_error("read(): %m");
 968                                                 r = -errno;
 969                                                 goto finish;
 970                                         }
 971                                 } else
 972                                         in_buffer_full += (size_t) k;
 973                         }
 974
 975                         if (master_writable && in_buffer_full > 0) {
 976
 977                                 k = write(master, in_buffer, in_buffer_full);
 978                                 if (k < 0) {
 979
 980                                         if (errno == EAGAIN || errno == EPIPE || errno == ECONNRESET || errno == EIO)
 981                                                 master_writable = false;
 982                                         else {
 983                                                 log_error("write(): %m");
 984                                                 r = -errno;
 985                                                 goto finish;
 986                                         }
 987
 988                                 } else {
 989                                         assert(in_buffer_full >= (size_t) k);
 990                                         memmove(in_buffer, in_buffer + k, in_buffer_full - k);
 991                                         in_buffer_full -= k;
 992                                 }
 993                         }
 994
 995                         if (master_readable && out_buffer_full < LINE_MAX) {
 996
 997                                 k = read(master, out_buffer + out_buffer_full, LINE_MAX - out_buffer_full);
 998                                 if (k < 0) {
 999
1000                                         if (errno == EAGAIN || errno == EPIPE || errno == ECONNRESET || errno == EIO)
1001                                                 master_readable = false;
1002                                         else {
1003                                                 log_error("read(): %m");
1004                                                 r = -errno;
1005                                                 goto finish;
1006                                         }
1007                                 }  else
1008                                         out_buffer_full += (size_t) k;
1009                         }
1010
1011                         if (stdout_writable && out_buffer_full > 0) {
1012
1013                                 k = write(STDOUT_FILENO, out_buffer, out_buffer_full);
1014                                 if (k < 0) {
1015
1016                                         if (errno == EAGAIN || errno == EPIPE || errno == ECONNRESET || errno == EIO)
1017                                                 stdout_writable = false;
1018                                         else {
1019                                                 log_error("write(): %m");
1020                                                 r = -errno;
1021                                                 goto finish;
1022                                         }
1023
1024                                 } else {
1025                                         assert(out_buffer_full >= (size_t) k);
1026                                         memmove(out_buffer, out_buffer + k, out_buffer_full - k);
1027                                         out_buffer_full -= k;
1028                                 }
1029                         }
1030                 }
1031         }
1032
1033 finish:
1034         if (ep >= 0)
1035                 close_nointr_nofail(ep);
1036
1037         if (signal_fd >= 0)
1038                 close_nointr_nofail(signal_fd);
1039
1040         return r;
1041 }
1042
1043 int main(int argc, char *argv[]) {
1044         pid_t pid = 0;
1045         int r = EXIT_FAILURE, k;
1046         char *oldcg = NULL, *newcg = NULL;
1047         char **controller = NULL;
1048         int master = -1;
1049         const char *console = NULL;
1050         struct termios saved_attr, raw_attr;
1051         sigset_t mask;
1052         bool saved_attr_valid = false;
1053         struct winsize ws;
1054         int kmsg_socket_pair[2] = { -1, -1 };
1055
1056         log_parse_environment();
1057         log_open();
1058
1059         r = parse_argv(argc, argv);
1060         if (r <= 0)
1061                 goto finish;
1062
1063         if (arg_directory) {
1064                 char *p;
1065
1066                 p = path_make_absolute_cwd(arg_directory);
1067                 free(arg_directory);
1068                 arg_directory = p;
1069         } else
1070                 arg_directory = get_current_dir_name();
1071
1072         if (!arg_directory) {
1073                 log_error("Failed to determine path");
1074                 goto finish;
1075         }
1076
1077         path_kill_slashes(arg_directory);
1078
1079         if (geteuid() != 0) {
1080                 log_error("Need to be root.");
1081                 goto finish;
1082         }
1083
1084         if (sd_booted() <= 0) {
1085                 log_error("Not running on a systemd system.");
1086                 goto finish;
1087         }
1088
1089         if (path_equal(arg_directory, "/")) {
1090                 log_error("Spawning container on root directory not supported.");
1091                 goto finish;
1092         }
1093
1094         if (is_os_tree(arg_directory) <= 0) {
1095                 log_error("Directory %s doesn't look like an OS root directory. Refusing.", arg_directory);
1096                 goto finish;
1097         }
1098
1099         k = cg_get_by_pid(SYSTEMD_CGROUP_CONTROLLER, 0, &oldcg);
1100         if (k < 0) {
1101                 log_error("Failed to determine current cgroup: %s", strerror(-k));
1102                 goto finish;
1103         }
1104
1105         if (asprintf(&newcg, "%s/nspawn-%lu", oldcg, (unsigned long) getpid()) < 0) {
1106                 log_error("Failed to allocate cgroup path.");
1107                 goto finish;
1108         }
1109
1110         k = cg_create_and_attach(SYSTEMD_CGROUP_CONTROLLER, newcg, 0);
1111         if (k < 0)  {
1112                 log_error("Failed to create cgroup: %s", strerror(-k));
1113                 goto finish;
1114         }
1115
1116         STRV_FOREACH(controller, arg_controllers) {
1117                 k = cg_create_and_attach(*controller, newcg, 0);
1118                 if (k < 0)
1119                         log_warning("Failed to create cgroup in controller %s: %s", *controller, strerror(-k));
1120         }
1121
1122         master = posix_openpt(O_RDWR|O_NOCTTY|O_CLOEXEC|O_NDELAY);
1123         if (master < 0) {
1124                 log_error("Failed to acquire pseudo tty: %m");
1125                 goto finish;
1126         }
1127
1128         console = ptsname(master);
1129         if (!console) {
1130                 log_error("Failed to determine tty name: %m");
1131                 goto finish;
1132         }
1133
1134         log_info("Spawning namespace container on %s (console is %s).", arg_directory, console);
1135
1136         if (ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) >= 0)
1137                 ioctl(master, TIOCSWINSZ, &ws);
1138
1139         if (unlockpt(master) < 0) {
1140                 log_error("Failed to unlock tty: %m");
1141                 goto finish;
1142         }
1143
1144         if (tcgetattr(STDIN_FILENO, &saved_attr) < 0) {
1145                 log_error("Failed to get terminal attributes: %m");
1146                 goto finish;
1147         }
1148
1149         saved_attr_valid = true;
1150
1151         raw_attr = saved_attr;
1152         cfmakeraw(&raw_attr);
1153         raw_attr.c_lflag &= ~ECHO;
1154
1155         if (socketpair(AF_UNIX, SOCK_DGRAM|SOCK_NONBLOCK|SOCK_CLOEXEC, 0, kmsg_socket_pair) < 0) {
1156                 log_error("Failed to create kmsg socket pair");
1157                 goto finish;
1158         }
1159
1160         assert_se(sigemptyset(&mask) == 0);
1161         sigset_add_many(&mask, SIGCHLD, SIGWINCH, SIGTERM, SIGINT, -1);
1162         assert_se(sigprocmask(SIG_BLOCK, &mask, NULL) == 0);
1163
1164         for (;;) {
1165                 siginfo_t status;
1166
1167                 if (tcsetattr(STDIN_FILENO, TCSANOW, &raw_attr) < 0) {
1168                         log_error("Failed to set terminal attributes: %m");
1169                         goto finish;
1170                 }
1171
1172                 pid = syscall(__NR_clone, SIGCHLD|CLONE_NEWIPC|CLONE_NEWNS|CLONE_NEWPID|CLONE_NEWUTS|(arg_private_network ? CLONE_NEWNET : 0), NULL);
1173                 if (pid < 0) {
1174                         if (errno == EINVAL)
1175                                 log_error("clone() failed, do you have namespace support enabled in your kernel? (You need UTS, IPC, PID and NET namespacing built in): %m");
1176                         else
1177                                 log_error("clone() failed: %m");
1178
1179                         goto finish;
1180                 }
1181
1182                 if (pid == 0) {
1183                         /* child */
1184
1185                         const char *home = NULL;
1186                         uid_t uid = (uid_t) -1;
1187                         gid_t gid = (gid_t) -1;
1188                         const char *envp[] = {
1189                                 "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
1190                                 "container=systemd-nspawn", /* LXC sets container=lxc, so follow the scheme here */
1191                                 NULL, /* TERM */
1192                                 NULL, /* HOME */
1193                                 NULL, /* USER */
1194                                 NULL, /* LOGNAME */
1195                                 NULL, /* container_uuid */
1196                                 NULL
1197                         };
1198
1199                         envp[2] = strv_find_prefix(environ, "TERM=");
1200
1201                         close_nointr_nofail(master);
1202
1203                         close_nointr(STDIN_FILENO);
1204                         close_nointr(STDOUT_FILENO);
1205                         close_nointr(STDERR_FILENO);
1206
1207                         close_all_fds(&kmsg_socket_pair[1], 1);
1208
1209                         reset_all_signal_handlers();
1210
1211                         assert_se(sigemptyset(&mask) == 0);
1212                         assert_se(sigprocmask(SIG_SETMASK, &mask, NULL) == 0);
1213
1214                         if (open_terminal(console, O_RDWR) != STDIN_FILENO ||
1215                             dup2(STDIN_FILENO, STDOUT_FILENO) != STDOUT_FILENO ||
1216                             dup2(STDIN_FILENO, STDERR_FILENO) != STDERR_FILENO)
1217                                 goto child_fail;
1218
1219                         if (setsid() < 0) {
1220                                 log_error("setsid() failed: %m");
1221                                 goto child_fail;
1222                         }
1223
1224                         if (prctl(PR_SET_PDEATHSIG, SIGKILL) < 0) {
1225                                 log_error("PR_SET_PDEATHSIG failed: %m");
1226                                 goto child_fail;
1227                         }
1228
1229                         /* Mark everything as slave, so that we still
1230                          * receive mounts from the real root, but don't
1231                          * propagate mounts to the real root. */
1232                         if (mount(NULL, "/", NULL, MS_SLAVE|MS_REC, NULL) < 0) {
1233                                 log_error("MS_SLAVE|MS_REC failed: %m");
1234                                 goto child_fail;
1235                         }
1236
1237                         /* Turn directory into bind mount */
1238                         if (mount(arg_directory, arg_directory, "bind", MS_BIND|MS_REC, NULL) < 0) {
1239                                 log_error("Failed to make bind mount.");
1240                                 goto child_fail;
1241                         }
1242
1243                         if (arg_read_only)
1244                                 if (mount(arg_directory, arg_directory, "bind", MS_BIND|MS_REMOUNT|MS_RDONLY|MS_REC, NULL) < 0) {
1245                                         log_error("Failed to make read-only.");
1246                                         goto child_fail;
1247                                 }
1248
1249                         if (mount_all(arg_directory) < 0)
1250                                 goto child_fail;
1251
1252                         if (copy_devnodes(arg_directory) < 0)
1253                                 goto child_fail;
1254
1255                         dev_setup(arg_directory);
1256
1257                         if (setup_dev_console(arg_directory, console) < 0)
1258                                 goto child_fail;
1259
1260                         if (setup_kmsg(arg_directory, kmsg_socket_pair[1]) < 0)
1261                                 goto child_fail;
1262
1263                         close_nointr_nofail(kmsg_socket_pair[1]);
1264
1265                         if (setup_boot_id(arg_directory) < 0)
1266                                 goto child_fail;
1267
1268                         if (setup_timezone(arg_directory) < 0)
1269                                 goto child_fail;
1270
1271                         if (setup_resolv_conf(arg_directory) < 0)
1272                                 goto child_fail;
1273
1274                         if (setup_journal(arg_directory) < 0)
1275                                 goto child_fail;
1276
1277                         if (chdir(arg_directory) < 0) {
1278                                 log_error("chdir(%s) failed: %m", arg_directory);
1279                                 goto child_fail;
1280                         }
1281
1282                         if (mount(arg_directory, "/", NULL, MS_MOVE, NULL) < 0) {
1283                                 log_error("mount(MS_MOVE) failed: %m");
1284                                 goto child_fail;
1285                         }
1286
1287                         if (chroot(".") < 0) {
1288                                 log_error("chroot() failed: %m");
1289                                 goto child_fail;
1290                         }
1291
1292                         if (chdir("/") < 0) {
1293                                 log_error("chdir() failed: %m");
1294                                 goto child_fail;
1295                         }
1296
1297                         umask(0022);
1298
1299                         loopback_setup();
1300
1301                         if (drop_capabilities() < 0) {
1302                                 log_error("drop_capabilities() failed: %m");
1303                                 goto child_fail;
1304                         }
1305
1306                         if (arg_user) {
1307
1308                                 if (get_user_creds((const char**)&arg_user, &uid, &gid, &home, NULL) < 0) {
1309                                         log_error("get_user_creds() failed: %m");
1310                                         goto child_fail;
1311                                 }
1312
1313                                 if (mkdir_parents_label(home, 0775) < 0) {
1314                                         log_error("mkdir_parents_label() failed: %m");
1315                                         goto child_fail;
1316                                 }
1317
1318                                 if (mkdir_safe_label(home, 0775, uid, gid) < 0) {
1319                                         log_error("mkdir_safe_label() failed: %m");
1320                                         goto child_fail;
1321                                 }
1322
1323                                 if (initgroups((const char*)arg_user, gid) < 0) {
1324                                         log_error("initgroups() failed: %m");
1325                                         goto child_fail;
1326                                 }
1327
1328                                 if (setresgid(gid, gid, gid) < 0) {
1329                                         log_error("setregid() failed: %m");
1330                                         goto child_fail;
1331                                 }
1332
1333                                 if (setresuid(uid, uid, uid) < 0) {
1334                                         log_error("setreuid() failed: %m");
1335                                         goto child_fail;
1336                                 }
1337                         }
1338
1339                         if ((asprintf((char**)(envp + 3), "HOME=%s", home ? home: "/root") < 0) ||
1340                             (asprintf((char**)(envp + 4), "USER=%s", arg_user ? arg_user : "root") < 0) ||
1341                             (asprintf((char**)(envp + 5), "LOGNAME=%s", arg_user ? arg_user : "root") < 0)) {
1342                                 log_oom();
1343                                 goto child_fail;
1344                         }
1345
1346                         if (arg_uuid) {
1347                                 if (asprintf((char**)(envp + 6), "container_uuid=%s", arg_uuid) < 0) {
1348                                         log_oom();
1349                                         goto child_fail;
1350                                 }
1351                         }
1352
1353                         setup_hostname();
1354
1355                         if (arg_boot) {
1356                                 char **a;
1357                                 size_t l;
1358
1359                                 /* Automatically search for the init system */
1360
1361                                 l = 1 + argc - optind;
1362                                 a = newa(char*, l + 1);
1363                                 memcpy(a + 1, argv + optind, l * sizeof(char*));
1364
1365                                 a[0] = (char*) "/usr/lib/systemd/systemd";
1366                                 execve(a[0], a, (char**) envp);
1367
1368                                 a[0] = (char*) "/lib/systemd/systemd";
1369                                 execve(a[0], a, (char**) envp);
1370
1371                                 a[0] = (char*) "/sbin/init";
1372                                 execve(a[0], a, (char**) envp);
1373                         } else if (argc > optind)
1374                                 execvpe(argv[optind], argv + optind, (char**) envp);
1375                         else {
1376                                 chdir(home ? home : "/root");
1377                                 execle("/bin/bash", "-bash", NULL, (char**) envp);
1378                         }
1379
1380                         log_error("execv() failed: %m");
1381
1382                 child_fail:
1383                         _exit(EXIT_FAILURE);
1384                 }
1385
1386                 if (process_pty(master, &mask) < 0)
1387                         goto finish;
1388
1389
1390                 if (saved_attr_valid)
1391                         tcsetattr(STDIN_FILENO, TCSANOW, &saved_attr);
1392
1393                 r = wait_for_terminate(pid, &status);
1394                 if (r < 0) {
1395                         r = EXIT_FAILURE;
1396                         break;
1397                 }
1398
1399                 if (status.si_code == CLD_EXITED) {
1400                         if (status.si_status != 0) {
1401                                 log_error("Container failed with error code %i.", status.si_status);
1402                                 r = status.si_status;
1403                                 break;
1404                         }
1405
1406                         log_debug("Container exited successfully.");
1407                         break;
1408                 } else if (status.si_code == CLD_KILLED &&
1409                            status.si_status == SIGINT) {
1410                         log_info("Container has been shut down.");
1411                         r = 0;
1412                         break;
1413                 } else if (status.si_code == CLD_KILLED &&
1414                            status.si_status == SIGHUP) {
1415                         log_info("Container is being rebooted.");
1416                         continue;
1417                 } else if (status.si_code == CLD_KILLED ||
1418                            status.si_code == CLD_DUMPED) {
1419
1420                         log_error("Container terminated by signal %s.", signal_to_string(status.si_status));
1421                         r = EXIT_FAILURE;
1422                         break;
1423                 } else {
1424                         log_error("Container failed due to unknown reason.");
1425                         r = EXIT_FAILURE;
1426                         break;
1427                 }
1428         }
1429
1430 finish:
1431         if (saved_attr_valid)
1432                 tcsetattr(STDIN_FILENO, TCSANOW, &saved_attr);
1433
1434         if (master >= 0)
1435                 close_nointr_nofail(master);
1436
1437         close_pipe(kmsg_socket_pair);
1438
1439         if (oldcg)
1440                 cg_attach(SYSTEMD_CGROUP_CONTROLLER, oldcg, 0);
1441
1442         if (newcg)
1443                 cg_kill_recursive_and_wait(SYSTEMD_CGROUP_CONTROLLER, newcg, true);
1444
1445         free(arg_directory);
1446         strv_free(arg_controllers);
1447         free(oldcg);
1448         free(newcg);
1449
1450         return r;
1451 }