<term><option>--directory=</option></term>
<listitem><para>Directory to use as
- file system root for the container. If
- neither <option>--directory=</option>
- nor <option>--image=</option> are
+ file system root for the container.</para>
+
+ <para>If neither
+ <option>--directory=</option>, nor
+ <option>--image=</option> is specified
+ the directory is determined as
+ <filename>/var/lib/container/</filename>
+ suffixed by the machine name as
+ specified with
+ <option>--machine=</option>. If
+ neither <option>--directory=</option>,
+ <option>--image=</option>, nor
+ <option>--machine=</option> are
specified, the current directory will
- be used. May not be specified together with
+ be used. May not be specified together
+ with
<option>--image=</option>.</para></listitem>
</varlistentry>
+ <varlistentry>
+ <term><option>--template=</option></term>
+
+ <listitem><para>Directory or
+ <literal>btrfs</literal> subvolume to
+ use as template for the container's
+ root directory. If this is specified
+ and the container's root directory (as
+ configured by
+ <option>--directory=</option>) does
+ not yet exist it is created as
+ <literal>btrfs</literal> subvolume and
+ populated from this template
+ tree. Ideally, the specified template
+ path refers to the root of a
+ <literal>btrfs</literal> subvolume, in
+ which case a simple copy-on-write
+ snapshot is taken, and populating the
+ root directory is instant. If the
+ specified template path does not refer
+ to the root of a
+ <literal>btrfs</literal> subvolume (or
+ not even to a <literal>btrfs</literal>
+ file system at all), the tree is
+ copied, which can be substantially
+ more time-consuming. Note that if this
+ option is used the container's root
+ directory (in contrast to the template
+ directory!) must be located on a
+ <literal>btrfs</literal> file system,
+ so that the <literal>btrfs</literal>
+ subvolume may be created. May not be
+ specified together with
+ <option>--image=</option> or
+ <option>--ephemeral</option>.</para></listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term><option>-x</option></term>
+ <term><option>--ephemeral</option></term>
+
+ <listitem><para>If specified, the
+ container is run with a temporary
+ <literal>btrfs</literal> snapshot of
+ its root directory (as configured with
+ <option>--directory=</option>), that
+ is removed immediately when the
+ container terminates. May not be
+ specified together with
+ <option>--image=</option> or
+ <option>--template=</option>.</para></listitem>
+ </varlistentry>
+
<varlistentry>
<term><option>-i</option></term>
<term><option>--image=</option></term>
partitions, swap partitions or EFI
system partitions are not mounted. May
not be specified together with
- <option>--directory=</option>.</para></listitem>
+ <option>--directory=</option>,
+ <option>--template=</option> or
+ <option>--ephemeral</option>.</para></listitem>
</varlistentry>
<varlistentry>
<term><option>--volatile</option><replaceable>=MODE</replaceable></term>
<listitem><para>Boots the container in
- volatile (ephemeral) mode. When no
- mode parameter is passed or when mode
- is specified as <literal>yes</literal>
- full volatile mode is enabled. This
- means the root directory is mounted as
- mostly unpopulated
- <literal>tmpfs</literal> instance, and
+ volatile mode. When no mode parameter
+ is passed or when mode is specified as
+ <literal>yes</literal> full volatile
+ mode is enabled. This means the root
+ directory is mounted as mostly
+ unpopulated <literal>tmpfs</literal>
+ instance, and
<filename>/usr</filename> from the OS
tree is mounted into it, read-only
(the system thus starts up with
changes to the latter are lost on
shutdown). When the mode parameter is
specified as <literal>no</literal>
- (the default) the whole OS tree is made
- available writable.</para>
+ (the default) the whole OS tree is
+ made available writable.</para>
<para>Note that setting this to
<literal>yes</literal> or
</example>
<example>
- <title>Boot into a btrfs snapshot of the host system</title>
+ <title>Boot into a <literal>btrfs</literal> snapshot of the host system</title>
<programlisting># btrfs subvolume snapshot / /.tmp
# systemd-nspawn --private-network -D /.tmp -b</programlisting>
<para>This runs a copy of the host system in a
- btrfs snapshot.</para>
+ <literal>btrfs</literal> snapshot.</para>
</example>
<example>
#include "barrier.h"
#include "event-util.h"
#include "cap-list.h"
+#include "btrfs-util.h"
#ifdef HAVE_SECCOMP
#include "seccomp-util.h"
} Volatile;
static char *arg_directory = NULL;
+static char *arg_template = NULL;
static char *arg_user = NULL;
static sd_id128_t arg_uuid = {};
static char *arg_machine = NULL;
static bool arg_private_network = false;
static bool arg_read_only = false;
static bool arg_boot = false;
+static bool arg_ephemeral = false;
static LinkJournal arg_link_journal = LINK_AUTO;
static bool arg_link_journal_try = false;
static uint64_t arg_retain =
static bool arg_network_veth = false;
static const char *arg_network_bridge = NULL;
static unsigned long arg_personality = 0xffffffffLU;
-static const char *arg_image = NULL;
+static char *arg_image = NULL;
static Volatile arg_volatile = VOLATILE_NO;
static void help(void) {
" --version Print version string\n"
" -q --quiet Do not show status information\n"
" -D --directory=PATH Root directory for the container\n"
- " -i --image=PATH File system device or image for the container\n"
+ " --template=PATH Initialize root directory from template directory,\n"
+ " if missing\n"
+ " -x --ephemeral Run container with snapshot of root directory, and\n"
+ " remove it after exit\n"
+ " -i --image=PATH File system device or disk image for the container\n"
" -b --boot Boot up full system (i.e. invoke init)\n"
" -u --user=USER Run the command under specified user or uid\n"
" -M --machine=NAME Set the machine name for the container\n"
program_invocation_short_name);
}
+static int set_sanitized_path(char **b, const char *path) {
+ char *p;
+
+ assert(b);
+ assert(path);
+
+ p = canonicalize_file_name(path);
+ if (!p) {
+ if (errno != ENOENT)
+ return -errno;
+
+ p = path_make_absolute_cwd(path);
+ if (!p)
+ return -ENOMEM;
+ }
+
+ free(*b);
+ *b = path_kill_slashes(p);
+ return 0;
+}
+
static int parse_argv(int argc, char *argv[]) {
enum {
ARG_NETWORK_BRIDGE,
ARG_PERSONALITY,
ARG_VOLATILE,
+ ARG_TEMPLATE,
};
static const struct option options[] = {
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, ARG_VERSION },
{ "directory", required_argument, NULL, 'D' },
+ { "template", required_argument, NULL, ARG_TEMPLATE },
+ { "ephemeral", no_argument, NULL, 'x' },
{ "user", required_argument, NULL, 'u' },
{ "private-network", no_argument, NULL, ARG_PRIVATE_NETWORK },
{ "boot", no_argument, NULL, 'b' },
assert(argc >= 0);
assert(argv);
- while ((c = getopt_long(argc, argv, "+hD:u:bL:M:jS:Z:qi:", options, NULL)) >= 0)
+ while ((c = getopt_long(argc, argv, "+hD:u:bL:M:jS:Z:qi:x", options, NULL)) >= 0)
switch (c) {
return 0;
case 'D':
- free(arg_directory);
- arg_directory = canonicalize_file_name(optarg);
- if (!arg_directory) {
- log_error_errno(errno, "Invalid root directory: %m");
- return -ENOMEM;
- }
+ r = set_sanitized_path(&arg_directory, optarg);
+ if (r < 0)
+ return log_error_errno(r, "Invalid root directory: %m");
+
+ break;
+
+ case ARG_TEMPLATE:
+ r = set_sanitized_path(&arg_template, optarg);
+ if (r < 0)
+ return log_error_errno(r, "Invalid template directory: %m");
break;
case 'i':
- arg_image = optarg;
+ r = set_sanitized_path(&arg_image, optarg);
+ if (r < 0)
+ return log_error_errno(r, "Invalid image path: %m");
+
+ break;
+
+ case 'x':
+ arg_ephemeral = true;
break;
case 'u':
return -EINVAL;
}
+ if (arg_template && arg_image) {
+ log_error("--template= and --image= may not be combined.");
+ return -EINVAL;
+ }
+
+ if (arg_template && !(arg_directory || arg_machine)) {
+ log_error("--template= needs --directory= or --machine=.");
+ return -EINVAL;
+ }
+
+ if (arg_ephemeral && arg_template) {
+ log_error("--ephemeral and --template= may not be combined.");
+ return -EINVAL;
+ }
+
+ if (arg_ephemeral && arg_image) {
+ log_error("--ephemeral and --image= may not be combined.");
+ return -EINVAL;
+ }
+
if (arg_volatile != VOLATILE_NO && arg_read_only) {
log_error("Cannot combine --read-only with --volatile. Note that --volatile already implies a read-only base hierarchy.");
return -EINVAL;
assert(device_path);
assert(loop_nr);
+ assert(arg_image);
fd = open(arg_image, O_CLOEXEC|(arg_read_only ? O_RDONLY : O_RDWR)|O_NONBLOCK|O_NOCTTY);
if (fd < 0)
assert(home_device);
assert(srv_device);
assert(secondary);
+ assert(arg_image);
b = blkid_new_probe();
if (!b)
return 0;
}
+static int determine_names(void) {
+
+ if (!arg_image && !arg_directory) {
+ if (arg_machine)
+ arg_directory = strappend("/var/lib/container/", arg_machine);
+ else
+ arg_directory = get_current_dir_name();
+
+ if (!arg_directory) {
+ log_error("Failed to determine path, please use -D.");
+ return -EINVAL;
+ }
+ }
+
+ if (!arg_machine) {
+ arg_machine = strdup(basename(arg_image ?: arg_directory));
+ if (!arg_machine)
+ return log_oom();
+
+ hostname_cleanup(arg_machine, false);
+ if (!machine_name_is_valid(arg_machine)) {
+ log_error("Failed to determine machine name automatically, please use -M.");
+ return -EINVAL;
+ }
+ }
+
+ return 0;
+}
+
int main(int argc, char *argv[]) {
_cleanup_free_ char *device_path = NULL, *root_device = NULL, *home_device = NULL, *srv_device = NULL;
_cleanup_close_ int master = -1, image_fd = -1;
_cleanup_close_pair_ int kmsg_socket_pair[2] = { -1, -1 };
_cleanup_fdset_free_ FDSet *fds = NULL;
- int r = EXIT_FAILURE, k, n_fd_passed, loop_nr = -1;
+ int r, n_fd_passed, loop_nr = -1;
const char *console = NULL;
char veth_name[IFNAMSIZ];
- bool secondary = false;
+ bool secondary = false, remove_subvol = false;
sigset_t mask, mask_chld;
pid_t pid = 0;
+ int ret = EXIT_SUCCESS;
log_parse_environment();
log_open();
- k = parse_argv(argc, argv);
- if (k < 0)
+ r = parse_argv(argc, argv);
+ if (r <= 0)
goto finish;
- else if (k == 0) {
- r = EXIT_SUCCESS;
- goto finish;
- }
-
- if (!arg_image) {
- if (arg_directory) {
- char *p;
- p = path_make_absolute_cwd(arg_directory);
- free(arg_directory);
- arg_directory = p;
- } else
- arg_directory = get_current_dir_name();
-
- if (!arg_directory) {
- log_error("Failed to determine path, please use -D.");
- goto finish;
- }
- path_kill_slashes(arg_directory);
- }
-
- if (!arg_machine) {
- arg_machine = strdup(basename(arg_image ? arg_image : arg_directory));
- if (!arg_machine) {
- log_oom();
- goto finish;
- }
-
- hostname_cleanup(arg_machine, false);
- if (isempty(arg_machine)) {
- log_error("Failed to determine machine name automatically, please use -M.");
- goto finish;
- }
- }
+ r = determine_names();
+ if (r < 0)
+ goto finish;
if (geteuid() != 0) {
log_error("Need to be root.");
+ r = -EPERM;
goto finish;
}
if (sd_booted() <= 0) {
log_error("Not running on a systemd system.");
+ r = -EINVAL;
goto finish;
}
log_close();
n_fd_passed = sd_listen_fds(false);
if (n_fd_passed > 0) {
- k = fdset_new_listen_fds(&fds, false);
- if (k < 0) {
- log_error_errno(k, "Failed to collect file descriptors: %m");
+ r = fdset_new_listen_fds(&fds, false);
+ if (r < 0) {
+ log_error_errno(r, "Failed to collect file descriptors: %m");
goto finish;
}
}
log_open();
if (arg_directory) {
+ assert(!arg_image);
+
if (path_equal(arg_directory, "/")) {
log_error("Spawning container on root directory not supported.");
+ r = -EINVAL;
goto finish;
}
+ if (arg_template) {
+ r = btrfs_subvol_snapshot(arg_template, arg_directory, arg_read_only, true);
+ if (r == -EEXIST) {
+ if (!arg_quiet)
+ log_info("Directory %s already exists, not populating from template %s.", arg_directory, arg_template);
+ } else if (r < 0) {
+ log_error_errno(r, "Couldn't create snapshort %s from %s: %m", arg_directory, arg_template);
+ goto finish;
+ } else {
+ if (!arg_quiet)
+ log_info("Populated %s from template %s.", arg_directory, arg_template);
+ }
+
+ } else if (arg_ephemeral) {
+ char *np;
+
+ r = tempfn_random(arg_directory, &np);
+ if (r < 0) {
+ log_error_errno(r, "Failed to generate name for snapshot: %m");
+ goto finish;
+ }
+
+ r = btrfs_subvol_snapshot(arg_directory, np, arg_read_only, true);
+ if (r < 0) {
+ free(np);
+ log_error_errno(r, "Failed to create snapshot %s from %s: %m", np, arg_directory);
+ goto finish;
+ }
+
+ free(arg_directory);
+ arg_directory = np;
+
+ remove_subvol = true;
+ }
+
if (arg_boot) {
if (path_is_os_tree(arg_directory) <= 0) {
log_error("Directory %s doesn't look like an OS root directory (os-release file is missing). Refusing.", arg_directory);
+ r = -EINVAL;
goto finish;
}
} else {
argc > optind && path_is_absolute(argv[optind]) ? argv[optind] : "/usr/bin/");
if (access(p, F_OK) < 0) {
log_error("Directory %s lacks the binary to execute or doesn't look like a binary tree. Refusing.", arg_directory);
+ r = -EINVAL;
goto finish;
-
}
}
+
} else {
char template[] = "/tmp/nspawn-root-XXXXXX";
+ assert(arg_image);
+ assert(!arg_template);
+
if (!mkdtemp(template)) {
log_error_errno(errno, "Failed to create temporary directory: %m");
r = -errno;
master = posix_openpt(O_RDWR|O_NOCTTY|O_CLOEXEC|O_NDELAY);
if (master < 0) {
- log_error_errno(errno, "Failed to acquire pseudo tty: %m");
+ r = log_error_errno(errno, "Failed to acquire pseudo tty: %m");
goto finish;
}
console = ptsname(master);
if (!console) {
- log_error_errno(errno, "Failed to determine tty name: %m");
+ r = log_error_errno(errno, "Failed to determine tty name: %m");
goto finish;
}
if (!arg_quiet)
log_info("Spawning container %s on %s.\nPress ^] three times within 1s to kill container.",
- arg_machine, arg_image ? arg_image : arg_directory);
+ arg_machine, arg_image ?: arg_directory);
if (unlockpt(master) < 0) {
- log_error_errno(errno, "Failed to unlock tty: %m");
+ r = log_error_errno(errno, "Failed to unlock tty: %m");
goto finish;
}
if (socketpair(AF_UNIX, SOCK_DGRAM|SOCK_NONBLOCK|SOCK_CLOEXEC, 0, kmsg_socket_pair) < 0) {
- log_error_errno(errno, "Failed to create kmsg socket pair: %m");
+ r = log_error_errno(errno, "Failed to create kmsg socket pair: %m");
goto finish;
}
* give it a chance to call wait() and terminate. */
r = sigprocmask(SIG_UNBLOCK, &mask_chld, NULL);
if (r < 0) {
- log_error_errno(errno, "Failed to change the signal mask: %m");
+ r = log_error_errno(errno, "Failed to change the signal mask: %m");
goto finish;
}
r = sigaction(SIGCHLD, &sa, NULL);
if (r < 0) {
- log_error_errno(errno, "Failed to install SIGCHLD handler: %m");
+ r = log_error_errno(errno, "Failed to install SIGCHLD handler: %m");
goto finish;
}
(arg_private_network ? CLONE_NEWNET : 0), NULL);
if (pid < 0) {
if (errno == EINVAL)
- log_error_errno(errno, "clone() failed, do you have namespace support enabled in your kernel? (You need UTS, IPC, PID and NET namespacing built in): %m");
+ r = log_error_errno(errno, "clone() failed, do you have namespace support enabled in your kernel? (You need UTS, IPC, PID and NET namespacing built in): %m");
else
- log_error_errno(errno, "clone() failed: %m");
+ r = log_error_errno(errno, "clone() failed: %m");
- r = pid;
goto finish;
}
reset_all_signal_handlers();
reset_signal_mask();
- k = open_terminal(console, O_RDWR);
- if (k != STDIN_FILENO) {
- if (k >= 0) {
- safe_close(k);
- k = -EINVAL;
+ r = open_terminal(console, O_RDWR);
+ if (r != STDIN_FILENO) {
+ if (r >= 0) {
+ safe_close(r);
+ r = -EINVAL;
}
- log_error_errno(k, "Failed to open console: %m");
+ log_error_errno(r, "Failed to open console: %m");
_exit(EXIT_FAILURE);
}
_exit(EXIT_FAILURE);
if (arg_read_only) {
- k = bind_remount_recursive(arg_directory, true);
- if (k < 0) {
- log_error_errno(k, "Failed to make tree read-only: %m");
+ r = bind_remount_recursive(arg_directory, true);
+ if (r < 0) {
+ log_error_errno(r, "Failed to make tree read-only: %m");
_exit(EXIT_FAILURE);
}
}
}
if (fdset_size(fds) > 0) {
- k = fdset_cloexec(fds, false);
- if (k < 0) {
- log_error("Failed to unset O_CLOEXEC for file descriptors.");
+ r = fdset_cloexec(fds, false);
+ if (r < 0) {
+ log_error_errno(r, "Failed to unset O_CLOEXEC for file descriptors.");
_exit(EXIT_FAILURE);
}
}
r = sd_event_loop(event);
- if (r < 0)
- return log_error_errno(r, "Failed to run event loop: %m");
+ if (r < 0) {
+ log_error_errno(r, "Failed to run event loop: %m");
+ goto finish;
+ }
forward = pty_forward_free(forward);
r = wait_for_container(pid, &container_status);
pid = 0;
- if (r < 0) {
+ if (r < 0)
/* We failed to wait for the container, or the
* container exited abnormally */
- r = EXIT_FAILURE;
- break;
- } else if (r > 0 || container_status == CONTAINER_TERMINATED)
+ goto finish;
+ else if (r > 0 || container_status == CONTAINER_TERMINATED){
/* The container exited with a non-zero
* status, or with zero status and no reboot
* was requested. */
+ ret = r;
break;
+ }
/* CONTAINER_REBOOTED, loop again */
* restart. This is necessary since we might
* have cgroup parameters set we want to have
* flushed out. */
- r = 133;
+ ret = 133;
+ r = 0;
break;
}
}
if (pid > 0)
kill(pid, SIGKILL);
+ if (remove_subvol && arg_directory) {
+ int k;
+
+ k = btrfs_subvol_remove(arg_directory);
+ if (k < 0)
+ log_warning_errno(k, "Cannot remove subvolume '%s', ignoring: %m", arg_directory);
+ }
+
free(arg_directory);
+ free(arg_template);
+ free(arg_image);
free(arg_machine);
free(arg_user);
strv_free(arg_setenv);
strv_free(arg_bind_ro);
strv_free(arg_tmpfs);
- return r;
+ return r < 0 ? EXIT_FAILURE : ret;
}
~ianmdlvl / elogind.git / commitdiff