/
niceSOFT
/
systemd
Обзор
Документация
Войти
/
niceSOFT
/
systemd
Код
Задачи
Вики
Пакеты
0
Релизы
0
Аналитика
Безопасность
v260
src/nspawn/nspawn.c
6 721 строка
286 KB
Luca Boccassi
nspawn: apply BindUser/Ephemeral from settings file only if trusted
12 мар 2026, 03:24
12 мар 2026, 03:24
61bceb1
Код
Авторство
О чём код?
/* SPDX-License-Identifier: LGPL-2.1-or-later */ #include <getopt.h> #include <linux/loop.h> #include <net/if.h> #include <stdlib.h> #include <sys/file.h> #include <sys/ioctl.h> #include <sys/keyctl.h> #include <sys/mount.h> #include <sys/personality.h> #include <sys/prctl.h> #include <sys/wait.h> #include <unistd.h> #include "sd-bus.h" #include "sd-daemon.h" #include "sd-event.h" #include "sd-id128.h" #include "sd-netlink.h" #include "sd-path.h" #include "sd-varlink.h" #include "alloc-util.h" #include "barrier.h" #include "base-filesystem.h" #include "btrfs-util.h" #include "build.h" #include "bus-error.h" #include "bus-locator.h" #include "bus-util.h" #include "capability-list.h" #include "capability-util.h" #include "cgroup-setup.h" #include "chase.h" #include "common-signal.h" #include "constants.h" #include "copy.h" #include "cpu-set-util.h" #include "daemon-util.h" #include "dev-setup.h" #include "devnum-util.h" #include "discover-image.h" #include "dissect-image.h" #include "dlfcn-util.h" #include "env-util.h" #include "escape.h" #include "ether-addr-util.h" #include "extract-word.h" #include "fd-util.h" #include "fdset.h" #include "fileio.h" #include "format-util.h" #include "fs-util.h" #include "gpt.h" #include "hexdecoct.h" #include "hostname-setup.h" #include "hostname-util.h" #include "id128-util.h" #include "image-policy.h" #include "in-addr-util.h" #include "io-util.h" #include "libmount-util.h" #include "log.h" #include "loop-util.h" #include "loopback-setup.h" #include "machine-bind-user.h" #include "machine-credential.h" #include "main-func.h" #include "mkdir.h" #include "mount-util.h" #include "mountpoint-util.h" #include "mstack.h" #include "namespace-util.h" #include "netlink-internal.h" #include "notify-recv.h" #include "nspawn-bind-user.h" #include "nspawn-cgroup.h" #include "nspawn-expose-ports.h" #include "nspawn-mount.h" #include "nspawn-network.h" #include "nspawn-oci.h" #include "nspawn-register.h" #include "nspawn-seccomp.h" #include "nspawn-settings.h" #include "nspawn-setuid.h" #include "nspawn-stub-pid1.h" #include "nspawn.h" #include "nsresource.h" #include "os-util.h" #include "osc-context.h" #include "pager.h" #include "parse-argument.h" #include "parse-util.h" #include "path-util.h" #include "pidref.h" #include "polkit-agent.h" #include "pretty-print.h" #include "process-util.h" #include "ptyfwd.h" #include "random-util.h" #include "raw-clone.h" #include "resolve-util.h" #include "rlimit-util.h" #include "rm-rf.h" #include "runtime-scope.h" #include "seccomp-util.h" #include "selinux-util.h" #include "shift-uid.h" #include "signal-util.h" #include "siphash24.h" #include "snapshot-util.h" #include "socket-util.h" #include "stat-util.h" #include "stdio-util.h" #include "string-table.h" #include "string-util.h" #include "strv.h" #include "sysctl-util.h" #include "terminal-util.h" #include "tmpfile-util.h" #include "uid-classification.h" #include "umask-util.h" #include "unit-name.h" #include "user-record.h" #include "user-util.h" #include "vpick.h" /* The notify socket inside the container it can use to talk to nspawn using the sd_notify(3) protocol */ #define NSPAWN_NOTIFY_SOCKET_PATH "/run/host/notify" #define NSPAWN_MOUNT_TUNNEL "/run/host/incoming" #define EXIT_FORCE_RESTART 133 typedef enum ContainerStatus { CONTAINER_TERMINATED, CONTAINER_REBOOTED, } ContainerStatus; static char *arg_directory = NULL; static char *arg_template = NULL; static char *arg_chdir = NULL; static char *arg_pivot_root_new = NULL; static char *arg_pivot_root_old = NULL; static char *arg_user = NULL; static uid_t arg_uid = UID_INVALID; static gid_t arg_gid = GID_INVALID; static gid_t* arg_supplementary_gids = NULL; static size_t arg_n_supplementary_gids = 0; static sd_id128_t arg_uuid = {}; static char *arg_machine = NULL; /* The name used by the host to refer to this */ static char *arg_hostname = NULL; /* The name the payload sees by default */ static const char *arg_selinux_context = NULL; static const char *arg_selinux_apifs_context = NULL; static char *arg_slice = NULL; static bool arg_private_network; /* initialized depending on arg_privileged in run() */ static bool arg_read_only = false; static StartMode arg_start_mode = START_PID1; static bool arg_ephemeral = false; static LinkJournal arg_link_journal = LINK_AUTO; static bool arg_link_journal_try = false; static uint64_t arg_caps_retain = (1ULL << CAP_AUDIT_CONTROL) | (1ULL << CAP_AUDIT_WRITE) | (1ULL << CAP_CHOWN) | (1ULL << CAP_DAC_OVERRIDE) | (1ULL << CAP_DAC_READ_SEARCH) | (1ULL << CAP_FOWNER) | (1ULL << CAP_FSETID) | (1ULL << CAP_IPC_OWNER) | (1ULL << CAP_KILL) | (1ULL << CAP_LEASE) | (1ULL << CAP_LINUX_IMMUTABLE) | (1ULL << CAP_MKNOD) | (1ULL << CAP_NET_BIND_SERVICE) | (1ULL << CAP_NET_BROADCAST) | (1ULL << CAP_NET_RAW) | (1ULL << CAP_SETFCAP) | (1ULL << CAP_SETGID) | (1ULL << CAP_SETPCAP) | (1ULL << CAP_SETUID) | (1ULL << CAP_SYS_ADMIN) | (1ULL << CAP_SYS_BOOT) | (1ULL << CAP_SYS_CHROOT) | (1ULL << CAP_SYS_NICE) | (1ULL << CAP_SYS_PTRACE) | (1ULL << CAP_SYS_RESOURCE) | (1ULL << CAP_SYS_TTY_CONFIG); static uint64_t arg_caps_ambient = 0; static CapabilityQuintet arg_full_capabilities = CAPABILITY_QUINTET_NULL; static CustomMount *arg_custom_mounts = NULL; static size_t arg_n_custom_mounts = 0; static char **arg_setenv = NULL; static bool arg_quiet = false; static bool arg_register = true; static bool arg_keep_unit = false; static char **arg_network_interfaces = NULL; static char **arg_network_macvlan = NULL; static char **arg_network_ipvlan = NULL; static bool arg_network_veth = false; static char **arg_network_veth_extra = NULL; static char *arg_network_bridge = NULL; static char *arg_network_zone = NULL; static char *arg_network_namespace_path = NULL; static struct ether_addr arg_network_provided_mac = {}; static PagerFlags arg_pager_flags = 0; static unsigned long arg_personality = PERSONALITY_INVALID; static char *arg_image = NULL; static char *arg_mstack = NULL; static char *arg_oci_bundle = NULL; static VolatileMode arg_volatile_mode = VOLATILE_NO; static ExposePort *arg_expose_ports = NULL; static char **arg_property = NULL; static sd_bus_message *arg_property_message = NULL; static UserNamespaceMode arg_userns_mode; /* initialized depending on arg_privileged in run() */ static uid_t arg_uid_shift = UID_INVALID, arg_uid_range = 0x10000U; static unsigned arg_delegate_container_ranges = 0; static UserNamespaceOwnership arg_userns_ownership = _USER_NAMESPACE_OWNERSHIP_INVALID; static int arg_kill_signal = 0; static SettingsMask arg_settings_mask = 0; static int arg_settings_trusted = -1; static char **arg_parameters = NULL; static const char *arg_container_service_name = "systemd-nspawn"; static bool arg_notify_ready = false; static bool arg_use_cgns = true; static unsigned long arg_clone_ns_flags = CLONE_NEWIPC|CLONE_NEWPID|CLONE_NEWUTS; static MountSettingsMask arg_mount_settings = MOUNT_APPLY_APIVFS_RO|MOUNT_APPLY_TMPFS_TMP; static VeritySettings arg_verity_settings = VERITY_SETTINGS_DEFAULT; static char **arg_syscall_allow_list = NULL; static char **arg_syscall_deny_list = NULL; #if HAVE_SECCOMP static scmp_filter_ctx arg_seccomp = NULL; #endif static struct rlimit *arg_rlimit[_RLIMIT_MAX] = {}; static bool arg_no_new_privileges = false; static int arg_oom_score_adjust = 0; static bool arg_oom_score_adjust_set = false; static CPUSet arg_cpu_set = {}; static ResolvConfMode arg_resolv_conf = RESOLV_CONF_AUTO; static TimezoneMode arg_timezone = TIMEZONE_AUTO; static unsigned arg_console_width = UINT_MAX, arg_console_height = UINT_MAX; static DeviceNode* arg_extra_nodes = NULL; static size_t arg_n_extra_nodes = 0; static char **arg_sysctl = NULL; static ConsoleMode arg_console_mode = _CONSOLE_MODE_INVALID; static MachineCredentialContext arg_credentials = {}; static char **arg_bind_user = NULL; static char *arg_bind_user_shell = NULL; static bool arg_bind_user_shell_copy = false; static char **arg_bind_user_groups = NULL; static bool arg_suppress_sync = false; static char *arg_settings_filename = NULL; static Architecture arg_architecture = _ARCHITECTURE_INVALID; static ImagePolicy *arg_image_policy = NULL; static char *arg_background = NULL; static bool arg_privileged = false; static bool arg_cleanup = false; static bool arg_ask_password = true; STATIC_DESTRUCTOR_REGISTER(arg_directory, freep); STATIC_DESTRUCTOR_REGISTER(arg_template, freep); STATIC_DESTRUCTOR_REGISTER(arg_chdir, freep); STATIC_DESTRUCTOR_REGISTER(arg_pivot_root_new, freep); STATIC_DESTRUCTOR_REGISTER(arg_pivot_root_old, freep); STATIC_DESTRUCTOR_REGISTER(arg_user, freep); STATIC_DESTRUCTOR_REGISTER(arg_supplementary_gids, freep); STATIC_DESTRUCTOR_REGISTER(arg_machine, freep); STATIC_DESTRUCTOR_REGISTER(arg_hostname, freep); STATIC_DESTRUCTOR_REGISTER(arg_slice, freep); STATIC_DESTRUCTOR_REGISTER(arg_setenv, strv_freep); STATIC_DESTRUCTOR_REGISTER(arg_network_interfaces, strv_freep); STATIC_DESTRUCTOR_REGISTER(arg_network_macvlan, strv_freep); STATIC_DESTRUCTOR_REGISTER(arg_network_ipvlan, strv_freep); STATIC_DESTRUCTOR_REGISTER(arg_network_veth_extra, strv_freep); STATIC_DESTRUCTOR_REGISTER(arg_network_bridge, freep); STATIC_DESTRUCTOR_REGISTER(arg_network_zone, freep); STATIC_DESTRUCTOR_REGISTER(arg_network_namespace_path, freep); STATIC_DESTRUCTOR_REGISTER(arg_image, freep); STATIC_DESTRUCTOR_REGISTER(arg_mstack, freep); STATIC_DESTRUCTOR_REGISTER(arg_oci_bundle, freep); STATIC_DESTRUCTOR_REGISTER(arg_property, strv_freep); STATIC_DESTRUCTOR_REGISTER(arg_property_message, sd_bus_message_unrefp); STATIC_DESTRUCTOR_REGISTER(arg_parameters, strv_freep); STATIC_DESTRUCTOR_REGISTER(arg_verity_settings, verity_settings_done); STATIC_DESTRUCTOR_REGISTER(arg_syscall_allow_list, strv_freep); STATIC_DESTRUCTOR_REGISTER(arg_syscall_deny_list, strv_freep); #if HAVE_SECCOMP STATIC_DESTRUCTOR_REGISTER(arg_seccomp, seccomp_releasep); #endif STATIC_DESTRUCTOR_REGISTER(arg_credentials, machine_credential_context_done); STATIC_DESTRUCTOR_REGISTER(arg_cpu_set, cpu_set_done); STATIC_DESTRUCTOR_REGISTER(arg_sysctl, strv_freep); STATIC_DESTRUCTOR_REGISTER(arg_bind_user, strv_freep); STATIC_DESTRUCTOR_REGISTER(arg_bind_user_shell, freep); STATIC_DESTRUCTOR_REGISTER(arg_bind_user_groups, strv_freep); STATIC_DESTRUCTOR_REGISTER(arg_settings_filename, freep); STATIC_DESTRUCTOR_REGISTER(arg_image_policy, image_policy_freep); STATIC_DESTRUCTOR_REGISTER(arg_background, freep); static int parse_private_users( const char *s, UserNamespaceMode *ret_userns_mode, uid_t *ret_uid_shift, uid_t *ret_uid_range) { int boolean, r; assert(ret_userns_mode); assert(ret_uid_shift); assert(ret_uid_range); if (!s) boolean = true; else if (!in_charset(s, DIGITS)) /* do *not* parse numbers as booleans */ boolean = parse_boolean(s); else boolean = -1; if (boolean == 0) { /* no: User namespacing off */ *ret_userns_mode = USER_NAMESPACE_NO; *ret_uid_shift = UID_INVALID; *ret_uid_range = UINT32_C(0x10000); } else if (boolean > 0) { /* yes: User namespacing on, UID range is read from root dir */ *ret_userns_mode = USER_NAMESPACE_FIXED; *ret_uid_shift = UID_INVALID; *ret_uid_range = UINT32_C(0x10000); } else if (streq(s, "pick")) { /* pick: User namespacing on, UID range is picked randomly */ *ret_userns_mode = USER_NAMESPACE_PICK; /* Note that arg_userns_ownership is * implied by USER_NAMESPACE_PICK * further down. */ *ret_uid_shift = UID_INVALID; *ret_uid_range = UINT32_C(0x10000); } else if (streq(s, "identity")) { /* identity: User namespaces on, UID range is map of the 0…0xFFFF range to * itself, i.e. we don't actually map anything, but do take benefit of * isolation of capability sets. */ *ret_userns_mode = USER_NAMESPACE_FIXED; *ret_uid_shift = 0; *ret_uid_range = UINT32_C(0x10000); } else if (streq(optarg, "managed")) { /* managed: User namespace on, and acquire it from systemd-nsresourced */ *ret_userns_mode = USER_NAMESPACE_MANAGED; *ret_uid_shift = UID_INVALID; *ret_uid_range = UINT32_C(0x10000); } else { /* anything else: User namespacing on, UID range is explicitly configured */ r = parse_userns_uid_range(optarg, ret_uid_shift, ret_uid_range); if (r < 0) return r; *ret_userns_mode = USER_NAMESPACE_FIXED; } return 0; } static int help(void) { _cleanup_free_ char *link = NULL; int r; pager_open(arg_pager_flags); r = terminal_urlify_man("systemd-nspawn", "1", &link); if (r < 0) return log_oom(); printf("%1$s [OPTIONS...] [PATH] [ARGUMENTS...]\n\n" "%5$sSpawn a command or OS in a lightweight container.%6$s\n\n" " -h --help Show this help\n" " --version Print version string\n" " -q --quiet Do not show status information\n" " --no-pager Do not pipe output into a pager\n" " --settings=BOOLEAN Load additional settings from .nspawn file\n" " --cleanup Clean up left-over mounts and underlying mount\n" " points used by the container\n" " --no-ask-password Do not prompt for password\n" "\n%3$sImage:%4$s\n" " -D --directory=PATH Root directory 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 Root file system disk image (or device node) for\n" " the container\n" " --image-policy=POLICY Specify disk image dissection policy\n" " --oci-bundle=PATH OCI bundle directory\n" " --read-only Mount the root directory read-only\n" " --volatile[=MODE] Run the system in volatile mode\n" " --root-hash=HASH Specify verity root hash for root disk image\n" " --root-hash-sig=SIG Specify pkcs7 signature of root hash for verity\n" " as a DER encoded PKCS7, either as a path to a file\n" " or as an ASCII base64 encoded string prefixed by\n" " 'base64:'\n" " --verity-data=PATH Specify hash device for verity\n" " --pivot-root=PATH[:PATH]\n" " Pivot root to given directory in the container\n" "\n%3$sExecution:%4$s\n" " -a --as-pid2 Maintain a stub init as PID1, invoke binary as PID2\n" " -b --boot Boot up full system (i.e. invoke init)\n" " --chdir=PATH Set working directory in the container\n" " -E --setenv=NAME[=VALUE] Pass an environment variable to PID 1\n" " -u --user=USER Run the command under specified user or UID\n" " --kill-signal=SIGNAL Select signal to use for shutting down PID 1\n" " --notify-ready=BOOLEAN Receive notifications from the child init process\n" " --suppress-sync=BOOLEAN\n" " Suppress any form of disk data synchronization\n" "\n%3$sSystem Identity:%4$s\n" " -M --machine=NAME Set the machine name for the container\n" " --hostname=NAME Override the hostname for the container\n" " --uuid=UUID Set a specific machine UUID for the container\n" "\n%3$sProperties:%4$s\n" " -S --slice=SLICE Place the container in the specified slice\n" " --property=NAME=VALUE Set scope unit property\n" " --register=BOOLEAN Register container as machine\n" " --keep-unit Do not register a scope for the machine, reuse\n" " the service unit nspawn is running in\n" "\n%3$sUser Namespacing:%4$s\n" " --private-users=no Run without user namespacing\n" " --private-users=yes|pick|identity|managed\n" " Run within user namespace, autoselect UID/GID range\n" " --private-users=UIDBASE[:NUIDS]\n" " Similar, but with user configured UID/GID range\n" " --private-users-ownership=MODE\n" " Adjust ('chown') or map ('map') OS tree ownership\n" " to private UID/GID range\n" " --private-users-delegate=N\n" " Delegate N additional 64K UID/GID ranges for use\n" " by nested containers (requires managed user\n" " namespaces)\n" " -U Equivalent to --private-users=pick and\n" " --private-users-ownership=auto\n" "\n%3$sNetworking:%4$s\n" " --private-network Disable network in container\n" " --network-interface=HOSTIF[:CONTAINERIF]\n" " Assign an existing network interface to the\n" " container\n" " --network-macvlan=HOSTIF[:CONTAINERIF]\n" " Create a macvlan network interface based on an\n" " existing network interface to the container\n" " --network-ipvlan=HOSTIF[:CONTAINERIF]\n" " Create an ipvlan network interface based on an\n" " existing network interface to the container\n" " -n --network-veth Add a virtual Ethernet connection between host\n" " and container\n" " --network-veth-extra=HOSTIF[:CONTAINERIF]\n" " Add an additional virtual Ethernet link between\n" " host and container\n" " --network-bridge=INTERFACE\n" " Add a virtual Ethernet connection to the container\n" " and attach it to an existing bridge on the host\n" " --network-zone=NAME Similar, but attach the new interface to an\n" " automatically managed bridge interface\n" " --network-namespace-path=PATH\n" " Set network namespace to the one represented by\n" " the specified kernel namespace file node\n" " -p --port=[PROTOCOL:]HOSTPORT[:CONTAINERPORT]\n" " Expose a container IP port on the host\n" "\n%3$sSecurity:%4$s\n" " --capability=CAP In addition to the default, retain specified\n" " capability\n" " --drop-capability=CAP Drop the specified capability from the default set\n" " --ambient-capability=CAP\n" " Sets the specified capability for the started\n" " process. Not useful if booting a machine.\n" " --no-new-privileges Set PR_SET_NO_NEW_PRIVS flag for container payload\n" " --system-call-filter=LIST|~LIST\n" " Permit/prohibit specific system calls\n" " -Z --selinux-context=SECLABEL\n" " Set the SELinux security context to be used by\n" " processes in the container\n" " -L --selinux-apifs-context=SECLABEL\n" " Set the SELinux security context to be used by\n" " API/tmpfs file systems in the container\n" "\n%3$sResources:%4$s\n" " --rlimit=NAME=LIMIT Set a resource limit for the payload\n" " --oom-score-adjust=VALUE\n" " Adjust the OOM score value for the payload\n" " --cpu-affinity=CPUS Adjust the CPU affinity of the container\n" " --personality=ARCH Pick personality for this container\n" "\n%3$sIntegration:%4$s\n" " --resolv-conf=MODE Select mode of /etc/resolv.conf initialization\n" " --timezone=MODE Select mode of /etc/localtime initialization\n" " --link-journal=MODE Link up guest journal, one of no, auto, guest, \n" " host, try-guest, try-host\n" " -j Equivalent to --link-journal=try-guest\n" "\n%3$sMounts:%4$s\n" " --bind=PATH[:PATH[:OPTIONS]]\n" " Bind mount a file or directory from the host into\n" " the container\n" " --bind-ro=PATH[:PATH[:OPTIONS]\n" " Similar, but creates a read-only bind mount\n" " --inaccessible=PATH Over-mount file node with inaccessible node to mask\n" " it\n" " --tmpfs=PATH:[OPTIONS] Mount an empty tmpfs to the specified directory\n" " --overlay=PATH[:PATH...]:PATH\n" " Create an overlay mount from the host to \n" " the container\n" " --overlay-ro=PATH[:PATH...]:PATH\n" " Similar, but creates a read-only overlay mount\n" " --bind-user=NAME Bind user from host to container\n" " --bind-user-shell=BOOL|PATH\n" " Configure the shell to use for --bind-user= users\n" " --bind-user-group=GROUP\n" " Add an auxiliary group to --bind-user= users\n" "\n%3$sInput/Output:%4$s\n" " --console=MODE Select how stdin/stdout/stderr and /dev/console are\n" " set up for the container.\n" " -P --pipe Equivalent to --console=pipe\n" " --background=COLOR Set ANSI color for background\n" "\n%3$sCredentials:%4$s\n" " --set-credential=ID:VALUE\n" " Pass a credential with literal value to container.\n" " --load-credential=ID:PATH\n" " Load credential to pass to container from file or\n" " AF_UNIX stream socket.\n" "\nSee the %2$s for details.\n", program_invocation_short_name, link, ansi_underline(), ansi_normal(), ansi_highlight(), ansi_normal()); return 0; } static int custom_mount_check_all(void) { FOREACH_ARRAY(m, arg_custom_mounts, arg_n_custom_mounts) if (path_equal(m->destination, "/") && arg_userns_mode != USER_NAMESPACE_NO) { if (arg_userns_ownership != USER_NAMESPACE_OWNERSHIP_OFF) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--private-users-ownership=%s may not be combined with custom root mounts.", user_namespace_ownership_to_string(arg_userns_ownership)); if (arg_uid_shift == UID_INVALID) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--private-users with automatic UID shift may not be combined with custom root mounts."); } return 0; } static int parse_capability_spec(const char *spec, uint64_t *ret_mask) { uint64_t mask = 0; int r; for (;;) { _cleanup_free_ char *t = NULL; r = extract_first_word(&spec, &t, ",", 0); if (r < 0) return log_error_errno(r, "Failed to parse capability %s.", t); if (r == 0) break; if (streq(t, "help")) { for (unsigned i = 0; i < capability_list_length(); i++) { const char *name; name = capability_to_name(i); if (name) puts(name); } return 0; /* quit */ } if (streq(t, "all")) mask = UINT64_MAX; else { r = capability_from_name(t); if (r < 0) return log_error_errno(r, "Failed to parse capability %s.", t); mask |= 1ULL << r; } } *ret_mask = mask; return 1; /* continue */ } static int parse_share_ns_env(const char *name, unsigned long ns_flag) { int r; r = getenv_bool(name); if (r == -ENXIO) return 0; if (r < 0) return log_error_errno(r, "Failed to parse $%s: %m", name); arg_clone_ns_flags = (arg_clone_ns_flags & ~ns_flag) | (r > 0 ? 0 : ns_flag); arg_settings_mask |= SETTING_CLONE_NS_FLAGS; return 0; } static int parse_mount_settings_env(void) { const char *e; int r; r = getenv_bool("SYSTEMD_NSPAWN_TMPFS_TMP"); if (r < 0 && r != -ENXIO) return log_error_errno(r, "Failed to parse $SYSTEMD_NSPAWN_TMPFS_TMP: %m"); if (r >= 0) SET_FLAG(arg_mount_settings, MOUNT_APPLY_TMPFS_TMP, r > 0); e = getenv("SYSTEMD_NSPAWN_API_VFS_WRITABLE"); if (streq_ptr(e, "network")) arg_mount_settings |= MOUNT_APPLY_APIVFS_RO|MOUNT_APPLY_APIVFS_NETNS; else if (e) { r = parse_boolean(e); if (r < 0) return log_error_errno(r, "Failed to parse $SYSTEMD_NSPAWN_API_VFS_WRITABLE: %m"); SET_FLAG(arg_mount_settings, MOUNT_APPLY_APIVFS_RO, r == 0); SET_FLAG(arg_mount_settings, MOUNT_APPLY_APIVFS_NETNS, false); } return 0; } static int parse_environment(void) { const char *e; int r; r = parse_share_ns_env("SYSTEMD_NSPAWN_SHARE_NS_IPC", CLONE_NEWIPC); if (r < 0) return r; r = parse_share_ns_env("SYSTEMD_NSPAWN_SHARE_NS_PID", CLONE_NEWPID); if (r < 0) return r; r = parse_share_ns_env("SYSTEMD_NSPAWN_SHARE_NS_UTS", CLONE_NEWUTS); if (r < 0) return r; r = parse_share_ns_env("SYSTEMD_NSPAWN_SHARE_SYSTEM", CLONE_NEWIPC|CLONE_NEWPID|CLONE_NEWUTS); if (r < 0) return r; r = parse_mount_settings_env(); if (r < 0) return r; /* SYSTEMD_NSPAWN_USE_CGNS=0 can be used to disable CLONE_NEWCGROUP use, * even if it is supported. If not supported, it has no effect. */ if (!namespace_type_supported(NAMESPACE_CGROUP)) arg_use_cgns = false; else { r = getenv_bool("SYSTEMD_NSPAWN_USE_CGNS"); if (r < 0) { if (r != -ENXIO) return log_error_errno(r, "Failed to parse $SYSTEMD_NSPAWN_USE_CGNS: %m"); arg_use_cgns = true; } else { arg_use_cgns = r > 0; arg_settings_mask |= SETTING_USE_CGNS; } } e = getenv("SYSTEMD_NSPAWN_CONTAINER_SERVICE"); if (e) arg_container_service_name = e; e = getenv("SYSTEMD_NSPAWN_NETWORK_MAC"); if (e) { r = parse_ether_addr(e, &arg_network_provided_mac); if (r < 0) return log_error_errno(r, "Failed to parse provided MAC address via environment variable"); } r = getenv_bool("SYSTEMD_SUPPRESS_SYNC"); if (r >= 0) arg_suppress_sync = r; else if (r != -ENXIO) log_debug_errno(r, "Failed to parse $SYSTEMD_SUPPRESS_SYNC, ignoring: %m"); return 0; } static int parse_argv(int argc, char *argv[]) { enum { ARG_VERSION = 0x100, ARG_PRIVATE_NETWORK, ARG_UUID, ARG_READ_ONLY, ARG_CAPABILITY, ARG_AMBIENT_CAPABILITY, ARG_DROP_CAPABILITY, ARG_LINK_JOURNAL, ARG_BIND, ARG_BIND_RO, ARG_TMPFS, ARG_OVERLAY, ARG_OVERLAY_RO, ARG_INACCESSIBLE, ARG_SHARE_SYSTEM, ARG_REGISTER, ARG_KEEP_UNIT, ARG_NETWORK_INTERFACE, ARG_NETWORK_MACVLAN, ARG_NETWORK_IPVLAN, ARG_NETWORK_BRIDGE, ARG_NETWORK_ZONE, ARG_NETWORK_VETH_EXTRA, ARG_NETWORK_NAMESPACE_PATH, ARG_PERSONALITY, ARG_VOLATILE, ARG_TEMPLATE, ARG_PROPERTY, ARG_PRIVATE_USERS, ARG_PRIVATE_USERS_DELEGATE, ARG_KILL_SIGNAL, ARG_SETTINGS, ARG_CHDIR, ARG_PIVOT_ROOT, ARG_PRIVATE_USERS_CHOWN, ARG_PRIVATE_USERS_OWNERSHIP, ARG_NOTIFY_READY, ARG_ROOT_HASH, ARG_ROOT_HASH_SIG, ARG_VERITY_DATA, ARG_SYSTEM_CALL_FILTER, ARG_RLIMIT, ARG_HOSTNAME, ARG_NO_NEW_PRIVILEGES, ARG_OOM_SCORE_ADJUST, ARG_CPU_AFFINITY, ARG_RESOLV_CONF, ARG_TIMEZONE, ARG_CONSOLE, ARG_PIPE, ARG_OCI_BUNDLE, ARG_NO_PAGER, ARG_SET_CREDENTIAL, ARG_LOAD_CREDENTIAL, ARG_BIND_USER, ARG_BIND_USER_SHELL, ARG_BIND_USER_GROUP, ARG_SUPPRESS_SYNC, ARG_IMAGE_POLICY, ARG_BACKGROUND, ARG_CLEANUP, ARG_NO_ASK_PASSWORD, ARG_MSTACK, }; 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 }, { "as-pid2", no_argument, NULL, 'a' }, { "boot", no_argument, NULL, 'b' }, { "uuid", required_argument, NULL, ARG_UUID }, { "read-only", no_argument, NULL, ARG_READ_ONLY }, { "capability", required_argument, NULL, ARG_CAPABILITY }, { "ambient-capability", required_argument, NULL, ARG_AMBIENT_CAPABILITY }, { "drop-capability", required_argument, NULL, ARG_DROP_CAPABILITY }, { "no-new-privileges", required_argument, NULL, ARG_NO_NEW_PRIVILEGES }, { "link-journal", required_argument, NULL, ARG_LINK_JOURNAL }, { "bind", required_argument, NULL, ARG_BIND }, { "bind-ro", required_argument, NULL, ARG_BIND_RO }, { "tmpfs", required_argument, NULL, ARG_TMPFS }, { "overlay", required_argument, NULL, ARG_OVERLAY }, { "overlay-ro", required_argument, NULL, ARG_OVERLAY_RO }, { "inaccessible", required_argument, NULL, ARG_INACCESSIBLE }, { "machine", required_argument, NULL, 'M' }, { "hostname", required_argument, NULL, ARG_HOSTNAME }, { "slice", required_argument, NULL, 'S' }, { "setenv", required_argument, NULL, 'E' }, { "selinux-context", required_argument, NULL, 'Z' }, { "selinux-apifs-context", required_argument, NULL, 'L' }, { "quiet", no_argument, NULL, 'q' }, { "share-system", no_argument, NULL, ARG_SHARE_SYSTEM }, /* not documented */ { "register", required_argument, NULL, ARG_REGISTER }, { "keep-unit", no_argument, NULL, ARG_KEEP_UNIT }, { "network-interface", required_argument, NULL, ARG_NETWORK_INTERFACE }, { "network-macvlan", required_argument, NULL, ARG_NETWORK_MACVLAN }, { "network-ipvlan", required_argument, NULL, ARG_NETWORK_IPVLAN }, { "network-veth", no_argument, NULL, 'n' }, { "network-veth-extra", required_argument, NULL, ARG_NETWORK_VETH_EXTRA }, { "network-bridge", required_argument, NULL, ARG_NETWORK_BRIDGE }, { "network-zone", required_argument, NULL, ARG_NETWORK_ZONE }, { "network-namespace-path", required_argument, NULL, ARG_NETWORK_NAMESPACE_PATH }, { "personality", required_argument, NULL, ARG_PERSONALITY }, { "image", required_argument, NULL, 'i' }, { "volatile", optional_argument, NULL, ARG_VOLATILE }, { "port", required_argument, NULL, 'p' }, { "property", required_argument, NULL, ARG_PROPERTY }, { "private-users", optional_argument, NULL, ARG_PRIVATE_USERS }, { "private-users-chown", optional_argument, NULL, ARG_PRIVATE_USERS_CHOWN }, /* obsolete */ { "private-users-ownership",required_argument, NULL, ARG_PRIVATE_USERS_OWNERSHIP}, { "private-users-delegate", required_argument, NULL, ARG_PRIVATE_USERS_DELEGATE }, { "kill-signal", required_argument, NULL, ARG_KILL_SIGNAL }, { "settings", required_argument, NULL, ARG_SETTINGS }, { "chdir", required_argument, NULL, ARG_CHDIR }, { "pivot-root", required_argument, NULL, ARG_PIVOT_ROOT }, { "notify-ready", required_argument, NULL, ARG_NOTIFY_READY }, { "root-hash", required_argument, NULL, ARG_ROOT_HASH }, { "root-hash-sig", required_argument, NULL, ARG_ROOT_HASH_SIG }, { "verity-data", required_argument, NULL, ARG_VERITY_DATA }, { "system-call-filter", required_argument, NULL, ARG_SYSTEM_CALL_FILTER }, { "rlimit", required_argument, NULL, ARG_RLIMIT }, { "oom-score-adjust", required_argument, NULL, ARG_OOM_SCORE_ADJUST }, { "cpu-affinity", required_argument, NULL, ARG_CPU_AFFINITY }, { "resolv-conf", required_argument, NULL, ARG_RESOLV_CONF }, { "timezone", required_argument, NULL, ARG_TIMEZONE }, { "console", required_argument, NULL, ARG_CONSOLE }, { "pipe", no_argument, NULL, ARG_PIPE }, { "oci-bundle", required_argument, NULL, ARG_OCI_BUNDLE }, { "no-pager", no_argument, NULL, ARG_NO_PAGER }, { "set-credential", required_argument, NULL, ARG_SET_CREDENTIAL }, { "load-credential", required_argument, NULL, ARG_LOAD_CREDENTIAL }, { "bind-user", required_argument, NULL, ARG_BIND_USER }, { "bind-user-shell", required_argument, NULL, ARG_BIND_USER_SHELL }, { "bind-user-group", required_argument, NULL, ARG_BIND_USER_GROUP }, { "suppress-sync", required_argument, NULL, ARG_SUPPRESS_SYNC }, { "image-policy", required_argument, NULL, ARG_IMAGE_POLICY }, { "background", required_argument, NULL, ARG_BACKGROUND }, { "cleanup", no_argument, NULL, ARG_CLEANUP }, { "no-ask-password", no_argument, NULL, ARG_NO_ASK_PASSWORD }, { "mstack", required_argument, NULL, ARG_MSTACK }, {} }; int c, r; uint64_t plus = 0, minus = 0; bool mask_all_settings = false, mask_no_settings = false; assert(argc >= 0); assert(argv); /* Resetting to 0 forces the invocation of an internal initialization routine of getopt_long() * that checks for GNU extensions in optstring ('-' or '+' at the beginning). */ optind = 0; while ((c = getopt_long(argc, argv, "+hD:u:abL:M:jS:Z:qi:xp:nUE:P", options, NULL)) >= 0) switch (c) { case 'h': return help(); case ARG_VERSION: return version(); case 'D': r = parse_path_argument(optarg, false, &arg_directory); if (r < 0) return r; arg_settings_mask |= SETTING_DIRECTORY; break; case ARG_TEMPLATE: r = parse_path_argument(optarg, false, &arg_template); if (r < 0) return r; arg_settings_mask |= SETTING_DIRECTORY; break; case 'i': r = parse_path_argument(optarg, false, &arg_image); if (r < 0) return r; arg_settings_mask |= SETTING_DIRECTORY; break; case ARG_MSTACK: r = parse_path_argument(optarg, false, &arg_mstack); if (r < 0) return r; arg_settings_mask |= SETTING_DIRECTORY; break; case ARG_OCI_BUNDLE: r = parse_path_argument(optarg, false, &arg_oci_bundle); if (r < 0) return r; break; case 'x': arg_ephemeral = true; arg_settings_mask |= SETTING_EPHEMERAL; break; case 'u': r = free_and_strdup(&arg_user, optarg); if (r < 0) return log_oom(); arg_settings_mask |= SETTING_USER; break; case ARG_NETWORK_ZONE: { _cleanup_free_ char *j = NULL; j = strjoin("vz-", optarg); if (!j) return log_oom(); if (!ifname_valid(j)) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Network zone name not valid: %s", j); free_and_replace(arg_network_zone, j); arg_network_veth = true; arg_private_network = true; arg_settings_mask |= SETTING_NETWORK; break; } case ARG_NETWORK_BRIDGE: if (!ifname_valid(optarg)) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Bridge interface name not valid: %s", optarg); r = free_and_strdup(&arg_network_bridge, optarg); if (r < 0) return log_oom(); _fallthrough_; case 'n': arg_network_veth = true; arg_private_network = true; arg_settings_mask |= SETTING_NETWORK; break; case ARG_NETWORK_VETH_EXTRA: r = veth_extra_parse(&arg_network_veth_extra, optarg); if (r < 0) return log_error_errno(r, "Failed to parse --network-veth-extra= parameter: %s", optarg); arg_private_network = true; arg_settings_mask |= SETTING_NETWORK; break; case ARG_NETWORK_INTERFACE: r = interface_pair_parse(&arg_network_interfaces, optarg); if (r < 0) return r; arg_private_network = true; arg_settings_mask |= SETTING_NETWORK; break; case ARG_NETWORK_MACVLAN: r = macvlan_pair_parse(&arg_network_macvlan, optarg); if (r < 0) return r; arg_private_network = true; arg_settings_mask |= SETTING_NETWORK; break; case ARG_NETWORK_IPVLAN: r = ipvlan_pair_parse(&arg_network_ipvlan, optarg); if (r < 0) return r; _fallthrough_; case ARG_PRIVATE_NETWORK: arg_private_network = true; arg_settings_mask |= SETTING_NETWORK; break; case ARG_NETWORK_NAMESPACE_PATH: r = parse_path_argument(optarg, false, &arg_network_namespace_path); if (r < 0) return r; arg_settings_mask |= SETTING_NETWORK; break; case 'b': if (arg_start_mode == START_PID2) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--boot and --as-pid2 may not be combined."); arg_start_mode = START_BOOT; arg_settings_mask |= SETTING_START_MODE; break; case 'a': if (arg_start_mode == START_BOOT) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--boot and --as-pid2 may not be combined."); arg_start_mode = START_PID2; arg_settings_mask |= SETTING_START_MODE; break; case ARG_UUID: r = id128_from_string_nonzero(optarg, &arg_uuid); if (r == -ENXIO) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Machine UUID may not be all zeroes."); if (r < 0) return log_error_errno(r, "Invalid UUID: %s", optarg); arg_settings_mask |= SETTING_MACHINE_ID; break; case 'S': { _cleanup_free_ char *mangled = NULL; r = unit_name_mangle_with_suffix(optarg, NULL, UNIT_NAME_MANGLE_WARN, ".slice", &mangled); if (r < 0) return log_oom(); free_and_replace(arg_slice, mangled); arg_settings_mask |= SETTING_SLICE; break; } case 'M': if (!isempty(optarg) && !hostname_is_valid(optarg, /* flags= */ 0)) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid machine name: %s", optarg); r = free_and_strdup_warn(&arg_machine, optarg); if (r < 0) return r; break; case ARG_HOSTNAME: if (!isempty(optarg) && !hostname_is_valid(optarg, /* flags= */ 0)) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid hostname: %s", optarg); r = free_and_strdup_warn(&arg_hostname, optarg); if (r < 0) return r; arg_settings_mask |= SETTING_HOSTNAME; break; case 'Z': arg_selinux_context = optarg; break; case 'L': arg_selinux_apifs_context = optarg; break; case ARG_READ_ONLY: arg_read_only = true; arg_settings_mask |= SETTING_READ_ONLY; break; case ARG_AMBIENT_CAPABILITY: { uint64_t m; r = parse_capability_spec(optarg, &m); if (r <= 0) return r; arg_caps_ambient |= m; arg_settings_mask |= SETTING_CAPABILITY; break; } case ARG_CAPABILITY: case ARG_DROP_CAPABILITY: { uint64_t m; r = parse_capability_spec(optarg, &m); if (r <= 0) return r; if (c == ARG_CAPABILITY) plus |= m; else minus |= m; arg_settings_mask |= SETTING_CAPABILITY; break; } case ARG_NO_NEW_PRIVILEGES: r = parse_boolean_argument("--no-new-privileges=", optarg, &arg_no_new_privileges); if (r < 0) return r; arg_settings_mask |= SETTING_NO_NEW_PRIVILEGES; break; case 'j': arg_link_journal = LINK_GUEST; arg_link_journal_try = true; arg_settings_mask |= SETTING_LINK_JOURNAL; break; case ARG_LINK_JOURNAL: r = parse_link_journal(optarg, &arg_link_journal, &arg_link_journal_try); if (r < 0) return log_error_errno(r, "Failed to parse link journal mode %s", optarg); arg_settings_mask |= SETTING_LINK_JOURNAL; break; case ARG_BIND: case ARG_BIND_RO: r = bind_mount_parse(&arg_custom_mounts, &arg_n_custom_mounts, optarg, c == ARG_BIND_RO); if (r < 0) return log_error_errno(r, "Failed to parse --bind(-ro)= argument %s: %m", optarg); arg_settings_mask |= SETTING_CUSTOM_MOUNTS; break; case ARG_TMPFS: r = tmpfs_mount_parse(&arg_custom_mounts, &arg_n_custom_mounts, optarg); if (r < 0) return log_error_errno(r, "Failed to parse --tmpfs= argument %s: %m", optarg); arg_settings_mask |= SETTING_CUSTOM_MOUNTS; break; case ARG_OVERLAY: case ARG_OVERLAY_RO: r = overlay_mount_parse(&arg_custom_mounts, &arg_n_custom_mounts, optarg, c == ARG_OVERLAY_RO); if (r == -EADDRNOTAVAIL) return log_error_errno(r, "--overlay(-ro)= needs at least two colon-separated directories specified."); if (r < 0) return log_error_errno(r, "Failed to parse --overlay(-ro)= argument %s: %m", optarg); arg_settings_mask |= SETTING_CUSTOM_MOUNTS; break; case ARG_INACCESSIBLE: r = inaccessible_mount_parse(&arg_custom_mounts, &arg_n_custom_mounts, optarg); if (r < 0) return log_error_errno(r, "Failed to parse --inaccessible= argument %s: %m", optarg); arg_settings_mask |= SETTING_CUSTOM_MOUNTS; break; case 'E': r = strv_env_replace_strdup_passthrough(&arg_setenv, optarg); if (r < 0) return log_error_errno(r, "Cannot assign environment variable %s: %m", optarg); arg_settings_mask |= SETTING_ENVIRONMENT; break; case 'q': arg_quiet = true; break; case ARG_SHARE_SYSTEM: /* We don't officially support this anymore, except for compat reasons. People should use the * $SYSTEMD_NSPAWN_SHARE_* environment variables instead. */ log_warning("Please do not use --share-system anymore, use $SYSTEMD_NSPAWN_SHARE_* instead."); arg_clone_ns_flags = 0; break; case ARG_REGISTER: r = parse_boolean_argument("--register=", optarg, &arg_register); if (r < 0) return r; break; case ARG_KEEP_UNIT: arg_keep_unit = true; break; case ARG_PERSONALITY: arg_personality = personality_from_string(optarg); if (arg_personality == PERSONALITY_INVALID) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Unknown or unsupported personality '%s'.", optarg); arg_settings_mask |= SETTING_PERSONALITY; break; case ARG_VOLATILE: if (!optarg) arg_volatile_mode = VOLATILE_YES; else if (streq(optarg, "help")) return DUMP_STRING_TABLE(volatile_mode, VolatileMode, _VOLATILE_MODE_MAX); else { VolatileMode m; m = volatile_mode_from_string(optarg); if (m < 0) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to parse --volatile= argument: %s", optarg); else arg_volatile_mode = m; } arg_settings_mask |= SETTING_VOLATILE_MODE; break; case 'p': r = expose_port_parse(&arg_expose_ports, optarg); if (r == -EEXIST) return log_error_errno(r, "Duplicate port specification: %s", optarg); if (r < 0) return log_error_errno(r, "Failed to parse host port %s: %m", optarg); arg_settings_mask |= SETTING_EXPOSE_PORTS; break; case ARG_PROPERTY: if (strv_extend(&arg_property, optarg) < 0) return log_oom(); break; case ARG_PRIVATE_USERS: r = parse_private_users(optarg, &arg_userns_mode, &arg_uid_shift, &arg_uid_range); if (r < 0) return r; arg_settings_mask |= SETTING_USERNS; break; case 'U': if (userns_supported()) { /* Note that arg_userns_ownership is implied by USER_NAMESPACE_PICK further down. */ arg_userns_mode = arg_privileged ? USER_NAMESPACE_PICK : USER_NAMESPACE_MANAGED; arg_uid_shift = UID_INVALID; arg_uid_range = UINT32_C(0x10000); arg_settings_mask |= SETTING_USERNS; } break; case ARG_PRIVATE_USERS_CHOWN: arg_userns_ownership = USER_NAMESPACE_OWNERSHIP_CHOWN; arg_settings_mask |= SETTING_USERNS; break; case ARG_PRIVATE_USERS_OWNERSHIP: if (streq(optarg, "help")) return DUMP_STRING_TABLE(user_namespace_ownership, UserNamespaceOwnership, _USER_NAMESPACE_OWNERSHIP_MAX); arg_userns_ownership = user_namespace_ownership_from_string(optarg); if (arg_userns_ownership < 0) return log_error_errno(arg_userns_ownership, "Cannot parse --private-users-ownership= value: %s", optarg); arg_settings_mask |= SETTING_USERNS; break; case ARG_PRIVATE_USERS_DELEGATE: r = safe_atou(optarg, &arg_delegate_container_ranges); if (r < 0) return log_error_errno(r, "Failed to parse --private-users-delegate= parameter: %s", optarg); arg_settings_mask |= SETTING_USERNS; break; case ARG_KILL_SIGNAL: if (streq(optarg, "help")) return DUMP_STRING_TABLE(signal, int, _NSIG); arg_kill_signal = signal_from_string(optarg); if (arg_kill_signal < 0) return log_error_errno(arg_kill_signal, "Cannot parse signal: %s", optarg); arg_settings_mask |= SETTING_KILL_SIGNAL; break; case ARG_SETTINGS: /* no → do not read files * yes → read files, do not override cmdline, trust only subset * override → read files, override cmdline, trust only subset * trusted → read files, do not override cmdline, trust all */ r = parse_boolean(optarg); if (r < 0) { if (streq(optarg, "trusted")) { mask_all_settings = false; mask_no_settings = false; arg_settings_trusted = true; } else if (streq(optarg, "override")) { mask_all_settings = false; mask_no_settings = true; arg_settings_trusted = -1; } else return log_error_errno(r, "Failed to parse --settings= argument: %s", optarg); } else if (r > 0) { /* yes */ mask_all_settings = false; mask_no_settings = false; arg_settings_trusted = -1; } else { /* no */ mask_all_settings = true; mask_no_settings = false; arg_settings_trusted = false; } break; case ARG_CHDIR: { _cleanup_free_ char *wd = NULL; if (!path_is_absolute(optarg)) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Working directory %s is not an absolute path.", optarg); r = path_simplify_alloc(optarg, &wd); if (r < 0) return log_error_errno(r, "Failed to simplify path %s: %m", optarg); if (!path_is_normalized(wd)) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Working directory path is not normalized: %s", wd); if (path_below_api_vfs(wd)) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Working directory is below API VFS, refusing: %s", wd); free_and_replace(arg_chdir, wd); arg_settings_mask |= SETTING_WORKING_DIRECTORY; break; } case ARG_PIVOT_ROOT: r = pivot_root_parse(&arg_pivot_root_new, &arg_pivot_root_old, optarg); if (r < 0) return log_error_errno(r, "Failed to parse --pivot-root= argument %s: %m", optarg); arg_settings_mask |= SETTING_PIVOT_ROOT; break; case ARG_NOTIFY_READY: r = parse_boolean_argument("--notify-ready=", optarg, &arg_notify_ready); if (r < 0) return r; arg_settings_mask |= SETTING_NOTIFY_READY; break; case ARG_ROOT_HASH: { _cleanup_(iovec_done) struct iovec k = {}; r = unhexmem(optarg, &k.iov_base, &k.iov_len); if (r < 0) return log_error_errno(r, "Failed to parse root hash: %s", optarg); if (k.iov_len < sizeof(sd_id128_t)) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Root hash must be at least 128-bit long: %s", optarg); iovec_done(&arg_verity_settings.root_hash); arg_verity_settings.root_hash = TAKE_STRUCT(k); break; } case ARG_ROOT_HASH_SIG: { _cleanup_(iovec_done) struct iovec p = {}; char *value; if ((value = startswith(optarg, "base64:"))) { r = unbase64mem(value, &p.iov_base, &p.iov_len); if (r < 0) return log_error_errno(r, "Failed to parse root hash signature '%s': %m", optarg); } else { r = read_full_file(optarg, (char**) &p.iov_base, &p.iov_len); if (r < 0) return log_error_errno(r, "Failed to parse root hash signature file '%s': %m", optarg); } iovec_done(&arg_verity_settings.root_hash_sig); arg_verity_settings.root_hash_sig = TAKE_STRUCT(p); break; } case ARG_VERITY_DATA: r = parse_path_argument(optarg, false, &arg_verity_settings.data_path); if (r < 0) return r; break; case ARG_SYSTEM_CALL_FILTER: { bool negative; const char *items; negative = optarg[0] == '~'; items = negative ? optarg + 1 : optarg; for (;;) { _cleanup_free_ char *word = NULL; r = extract_first_word(&items, &word, NULL, 0); if (r == 0) break; if (r == -ENOMEM) return log_oom(); if (r < 0) return log_error_errno(r, "Failed to parse system call filter: %m"); if (negative) r = strv_extend(&arg_syscall_deny_list, word); else r = strv_extend(&arg_syscall_allow_list, word); if (r < 0) return log_oom(); } arg_settings_mask |= SETTING_SYSCALL_FILTER; break; } case ARG_RLIMIT: { const char *eq; _cleanup_free_ char *name = NULL; int rl; if (streq(optarg, "help")) return DUMP_STRING_TABLE(rlimit, int, _RLIMIT_MAX); eq = strchr(optarg, '='); if (!eq) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--rlimit= expects an '=' assignment."); name = strndup(optarg, eq - optarg); if (!name) return log_oom(); rl = rlimit_from_string_harder(name); if (rl < 0) return log_error_errno(rl, "Unknown resource limit: %s", name); if (!arg_rlimit[rl]) { arg_rlimit[rl] = new0(struct rlimit, 1); if (!arg_rlimit[rl]) return log_oom(); } r = rlimit_parse(rl, eq + 1, arg_rlimit[rl]); if (r < 0) return log_error_errno(r, "Failed to parse resource limit: %s", eq + 1); arg_settings_mask |= SETTING_RLIMIT_FIRST << rl; break; } case ARG_OOM_SCORE_ADJUST: r = parse_oom_score_adjust(optarg, &arg_oom_score_adjust); if (r < 0) return log_error_errno(r, "Failed to parse --oom-score-adjust= parameter: %s", optarg); arg_oom_score_adjust_set = true; arg_settings_mask |= SETTING_OOM_SCORE_ADJUST; break; case ARG_CPU_AFFINITY: { CPUSet cpuset; r = parse_cpu_set(optarg, &cpuset); if (r < 0) return log_error_errno(r, "Failed to parse CPU affinity mask %s: %m", optarg); cpu_set_done_and_replace(arg_cpu_set, cpuset); arg_settings_mask |= SETTING_CPU_AFFINITY; break; } case ARG_RESOLV_CONF: if (streq(optarg, "help")) return DUMP_STRING_TABLE(resolv_conf_mode, ResolvConfMode, _RESOLV_CONF_MODE_MAX); arg_resolv_conf = resolv_conf_mode_from_string(optarg); if (arg_resolv_conf < 0) return log_error_errno(arg_resolv_conf, "Failed to parse /etc/resolv.conf mode: %s", optarg); arg_settings_mask |= SETTING_RESOLV_CONF; break; case ARG_TIMEZONE: if (streq(optarg, "help")) return DUMP_STRING_TABLE(timezone_mode, TimezoneMode, _TIMEZONE_MODE_MAX); arg_timezone = timezone_mode_from_string(optarg); if (arg_timezone < 0) return log_error_errno(arg_timezone, "Failed to parse /etc/localtime mode: %s", optarg); arg_settings_mask |= SETTING_TIMEZONE; break; case ARG_CONSOLE: if (streq(optarg, "help")) return DUMP_STRING_TABLE(console_mode, ConsoleMode, _CONSOLE_MODE_MAX); arg_console_mode = console_mode_from_string(optarg); if (arg_console_mode < 0) return log_error_errno(arg_console_mode, "Unknown console mode: %s", optarg); arg_settings_mask |= SETTING_CONSOLE_MODE; break; case 'P': case ARG_PIPE: arg_console_mode = CONSOLE_PIPE; arg_settings_mask |= SETTING_CONSOLE_MODE; break; case ARG_NO_PAGER: arg_pager_flags |= PAGER_DISABLE; break; case ARG_SET_CREDENTIAL: r = machine_credential_set(&arg_credentials, optarg); if (r < 0) return r; arg_settings_mask |= SETTING_CREDENTIALS; break; case ARG_LOAD_CREDENTIAL: r = machine_credential_load(&arg_credentials, optarg); if (r < 0) return r; arg_settings_mask |= SETTING_CREDENTIALS; break; case ARG_BIND_USER: if (!valid_user_group_name(optarg, 0)) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid user name to bind: %s", optarg); if (strv_extend(&arg_bind_user, optarg) < 0) return log_oom(); arg_settings_mask |= SETTING_BIND_USER; break; case ARG_BIND_USER_SHELL: { bool copy = false; char *sh = NULL; r = parse_user_shell(optarg, &sh, ©); if (r == -ENOMEM) return log_oom(); if (r < 0) return log_error_errno(r, "Invalid user shell to bind: %s", optarg); free_and_replace(arg_bind_user_shell, sh); arg_bind_user_shell_copy = copy; arg_settings_mask |= SETTING_BIND_USER_SHELL; break; } case ARG_BIND_USER_GROUP: if (!valid_user_group_name(optarg, /* flags= */ 0)) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid bind user auxiliary group name: %s", optarg); if (strv_extend(&arg_bind_user_groups, optarg) < 0) return log_oom(); break; case ARG_SUPPRESS_SYNC: r = parse_boolean_argument("--suppress-sync=", optarg, &arg_suppress_sync); if (r < 0) return r; arg_settings_mask |= SETTING_SUPPRESS_SYNC; break; case ARG_IMAGE_POLICY: r = parse_image_policy_argument(optarg, &arg_image_policy); if (r < 0) return r; break; case ARG_BACKGROUND: r = parse_background_argument(optarg, &arg_background); if (r < 0) return r; break; case ARG_CLEANUP: arg_cleanup = true; break; case ARG_NO_ASK_PASSWORD: arg_ask_password = false; break; case '?': return -EINVAL; default: assert_not_reached(); } if (argc > optind) { strv_free(arg_parameters); arg_parameters = strv_copy(argv + optind); if (!arg_parameters) return log_oom(); arg_settings_mask |= SETTING_START_MODE; } if (arg_ephemeral && arg_template && !arg_directory) /* User asked for ephemeral execution but specified --template= instead of --directory=. Semantically * such an invocation makes some sense, see https://github.com/systemd/systemd/issues/3667. Let's * accept this here, and silently make "--ephemeral --template=" equivalent to "--ephemeral * --directory=". */ arg_directory = TAKE_PTR(arg_template); arg_caps_retain |= plus; arg_caps_retain |= arg_private_network ? UINT64_C(1) << CAP_NET_ADMIN : 0; arg_caps_retain &= ~minus; /* Make sure to parse environment before we reset the settings mask below */ r = parse_environment(); if (r < 0) return r; /* Load all settings from .nspawn files */ if (mask_no_settings) arg_settings_mask = 0; /* Don't load any settings from .nspawn files */ if (mask_all_settings) arg_settings_mask = _SETTINGS_MASK_ALL; return 1; } static int verify_arguments(void) { int r; SET_FLAG(arg_mount_settings, MOUNT_UNMANAGED, arg_userns_mode != USER_NAMESPACE_MANAGED); /* We can mount selinuxfs only if we are privileged and can do so before userns. In managed mode we * have to enter the userns earlier, hence cannot do that. */ /* SET_FLAG(arg_mount_settings, MOUNT_PRIVILEGED, arg_privileged); */ SET_FLAG(arg_mount_settings, MOUNT_PRIVILEGED, arg_userns_mode != USER_NAMESPACE_MANAGED); SET_FLAG(arg_mount_settings, MOUNT_USE_USERNS, arg_userns_mode != USER_NAMESPACE_NO); if (arg_private_network) SET_FLAG(arg_mount_settings, MOUNT_APPLY_APIVFS_NETNS, arg_private_network); if (!arg_privileged && arg_userns_mode != USER_NAMESPACE_MANAGED) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Unprivileged operation requires managed user namespaces, as otherwise no UID range can be acquired."); if (arg_userns_mode == USER_NAMESPACE_MANAGED && !arg_private_network) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Managed user namespace operation requires private networking, as otherwise /sys/ may not be mounted."); if (arg_delegate_container_ranges > 0 && arg_userns_mode != USER_NAMESPACE_MANAGED) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--private-users-delegate= requires --private-users=managed."); if (!(arg_clone_ns_flags & CLONE_NEWPID) || !(arg_clone_ns_flags & CLONE_NEWUTS)) { arg_register = false; if (arg_start_mode != START_PID1) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--boot cannot be used without namespacing."); } if (arg_userns_ownership < 0) arg_userns_ownership = IN_SET(arg_userns_mode, USER_NAMESPACE_PICK, USER_NAMESPACE_MANAGED) ? USER_NAMESPACE_OWNERSHIP_AUTO : USER_NAMESPACE_OWNERSHIP_OFF; if (arg_start_mode == START_BOOT && arg_kill_signal <= 0) arg_kill_signal = SIGRTMIN+3; if (arg_volatile_mode != VOLATILE_NO) /* Make sure all file systems contained in the image are mounted read-only if we are in volatile mode */ arg_read_only = true; if (has_custom_root_mount(arg_custom_mounts, arg_n_custom_mounts)) arg_read_only = true; if (!!arg_directory + !!arg_image + !!arg_mstack > 1) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--directory=, --image= --mstack= may not be combined."); if (arg_template && (arg_image || arg_mstack)) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--template= and --image=/--mstack= may not be combined."); if (arg_template && !(arg_directory || arg_machine)) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--template= needs --directory= or --machine=."); if (arg_ephemeral && arg_template) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--ephemeral and --template= may not be combined."); if (arg_ephemeral && arg_mstack) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--ephemeral and --mstack= may not be combined."); /* Permit --ephemeral with --link-journal=try-* to satisfy principle of the least astonishment * (by common sense, "try" means "do not fail if not possible") */ if (arg_ephemeral && !IN_SET(arg_link_journal, LINK_NO, LINK_AUTO) && !arg_link_journal_try) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--ephemeral and --link-journal={host,guest} may not be combined."); if (arg_userns_mode != USER_NAMESPACE_NO && !userns_supported()) return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "--private-users= is not supported, kernel compiled without user namespace support."); if (arg_userns_ownership == USER_NAMESPACE_OWNERSHIP_CHOWN && arg_read_only) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--read-only and --private-users-ownership=chown may not be combined."); /* We don't support --private-users-ownership=chown together with any of the volatile modes since we * couldn't change the read-only part of the tree (i.e. /usr) anyway, or because it would trigger a * massive copy-up (in case of overlay) making the entire exercise pointless. */ if (arg_userns_ownership == USER_NAMESPACE_OWNERSHIP_CHOWN && arg_volatile_mode != VOLATILE_NO) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--volatile= and --private-users-ownership=chown may not be combined."); /* If --network-namespace-path is given with any other network-related option (except --private-network), * we need to error out, to avoid conflicts between different network options. */ if (arg_network_namespace_path && (arg_network_interfaces || arg_network_macvlan || arg_network_ipvlan || arg_network_veth_extra || arg_network_bridge || arg_network_zone || arg_network_veth)) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--network-namespace-path= cannot be combined with other network options."); if (arg_network_bridge && arg_network_zone) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--network-bridge= and --network-zone= may not be combined."); if (arg_userns_mode != USER_NAMESPACE_NO && (arg_mount_settings & MOUNT_APPLY_APIVFS_NETNS) && !arg_private_network) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid namespacing settings. Mounting sysfs with --private-users requires --private-network."); if (arg_userns_mode != USER_NAMESPACE_NO && !(arg_mount_settings & MOUNT_APPLY_APIVFS_RO)) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Cannot combine --private-users with read-write API VFS mounts."); if (arg_expose_ports && !arg_private_network) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Cannot use --port= without private networking."); if (arg_caps_ambient) { if (arg_caps_ambient == CAP_MASK_UNSET) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "AmbientCapability= does not support the value all."); if ((arg_caps_ambient & arg_caps_retain) != arg_caps_ambient) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "AmbientCapability= setting is not fully covered by Capability= setting."); if (arg_start_mode == START_BOOT) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "AmbientCapability= setting is not useful for boot mode."); } /* Drop duplicate --bind-user= and --bind-user-group= entries */ strv_uniq(arg_bind_user); strv_uniq(arg_bind_user_groups); if (arg_bind_user_shell && strv_isempty(arg_bind_user)) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Cannot use --bind-user-shell= without --bind-user="); if (!strv_isempty(arg_bind_user_groups) && strv_isempty(arg_bind_user)) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Cannot use --bind-user-group= without --bind-user="); r = custom_mount_check_all(); if (r < 0) return r; if (arg_console_mode == CONSOLE_PIPE && isatty_safe(STDIN_FILENO) && isatty_safe(STDOUT_FILENO)) log_full(arg_quiet ? LOG_DEBUG : LOG_NOTICE, "Console mode 'pipe' selected, but standard input/output are connected to an interactive TTY. " "Most likely you want to use 'interactive' console mode for proper interactivity and shell job control. " "Proceeding anyway."); return 0; } static int verify_network_interfaces_initialized(void) { int r; r = test_network_interfaces_initialized(arg_network_interfaces); if (r < 0) return r; r = test_network_interfaces_initialized(arg_network_macvlan); if (r < 0) return r; r = test_network_interfaces_initialized(arg_network_ipvlan); if (r < 0) return r; return 0; } static int in_child_chown(void) { /* Returns true when chown()ing inodes we create inside the outer child is required. Basically, we * need the chowning when we implement userns ourselves. If userns is off we don#t need to chown(), * obviously. And if we are in managed mode we already entered the userns, and hence don#t need to * manually chown either. */ return IN_SET(arg_userns_mode, USER_NAMESPACE_PICK, USER_NAMESPACE_FIXED); } int userns_chown_at(int fd, const char *fname, uid_t uid, gid_t gid, int flags) { assert(fd >= 0 || fd == AT_FDCWD); if (!in_child_chown()) return 0; if (uid == UID_INVALID && gid == GID_INVALID) return 0; if (uid != UID_INVALID) { uid += arg_uid_shift; if (uid < arg_uid_shift || uid >= arg_uid_shift + arg_uid_range) return -EOVERFLOW; } if (gid != GID_INVALID) { gid += (gid_t) arg_uid_shift; if (gid < (gid_t) arg_uid_shift || gid >= (gid_t) (arg_uid_shift + arg_uid_range)) return -EOVERFLOW; } if (isempty(fname)) flags |= AT_EMPTY_PATH; return RET_NERRNO(fchownat(fd, strempty(fname), uid, gid, flags)); } int userns_lchown(const char *path, uid_t uid, gid_t gid) { return userns_chown_at(AT_FDCWD, path, uid, gid, AT_SYMLINK_NOFOLLOW); } int userns_mkdir(const char *root, const char *path, mode_t mode, uid_t uid, gid_t gid) { int r; assert(path); _cleanup_close_ int parent_fd = -EBADF; _cleanup_free_ char *dname = NULL; r = chase(path, root, CHASE_PARENT|CHASE_PREFIX_ROOT|CHASE_EXTRACT_FILENAME, &dname, &parent_fd); if (r < 0) return r; _cleanup_close_ int dir_fd = open_mkdir_at(parent_fd, dname, O_EXCL|O_CLOEXEC, mode); if (dir_fd == -EEXIST) return 0; if (dir_fd < 0) return dir_fd; return userns_chown_at(dir_fd, /* fname= */ NULL, uid, gid, AT_SYMLINK_NOFOLLOW|AT_EMPTY_PATH); } static const char *timezone_from_path(const char *path) { return PATH_STARTSWITH_SET( path, "../usr/share/zoneinfo/", "/usr/share/zoneinfo/"); } static bool etc_writable(void) { return !arg_read_only || IN_SET(arg_volatile_mode, VOLATILE_YES, VOLATILE_OVERLAY); } static int setup_timezone(const char *dest) { _cleanup_free_ char *p = NULL, *etc = NULL; const char *where, *check; TimezoneMode m; int r; assert(dest); if (IN_SET(arg_timezone, TIMEZONE_AUTO, TIMEZONE_SYMLINK)) { r = readlink_malloc("/etc/localtime", &p); if (r == -ENOENT && arg_timezone == TIMEZONE_AUTO) m = etc_writable() ? TIMEZONE_DELETE : TIMEZONE_OFF; else if (r == -EINVAL && arg_timezone == TIMEZONE_AUTO) /* regular file? */ m = etc_writable() ? TIMEZONE_COPY : TIMEZONE_BIND; else if (r < 0) { log_warning_errno(r, "Failed to read host's /etc/localtime symlink, not updating container timezone: %m"); /* To handle warning, delete /etc/localtime and replace it with a symbolic link to a time zone data * file. * * Example: * ln -s /usr/share/zoneinfo/UTC /etc/localtime */ return 0; } else if (arg_timezone == TIMEZONE_AUTO) m = etc_writable() ? TIMEZONE_SYMLINK : TIMEZONE_BIND; else m = arg_timezone; } else m = arg_timezone; if (m == TIMEZONE_OFF) return 0; r = chase("/etc", dest, CHASE_PREFIX_ROOT, &etc, NULL); if (r < 0) { log_warning_errno(r, "Failed to resolve /etc path in container, ignoring: %m"); return 0; } where = strjoina(etc, "/localtime"); switch (m) { case TIMEZONE_DELETE: if (unlink(where) < 0) log_full_errno(errno == ENOENT ? LOG_DEBUG : LOG_WARNING, errno, "Failed to remove '%s', ignoring: %m", where); return 0; case TIMEZONE_SYMLINK: { _cleanup_free_ char *q = NULL; const char *z, *what; z = timezone_from_path(p); if (!z) { log_warning("/etc/localtime does not point into /usr/share/zoneinfo/, not updating container timezone."); return 0; } r = readlink_malloc(where, &q); if (r >= 0 && streq_ptr(timezone_from_path(q), z)) return 0; /* Already pointing to the right place? Then do nothing .. */ check = strjoina(dest, "/usr/share/zoneinfo/", z); r = chase(check, dest, 0, NULL, NULL); if (r < 0) log_debug_errno(r, "Timezone %s does not exist (or is not accessible) in container, not creating symlink: %m", z); else { if (unlink(where) < 0 && errno != ENOENT) { log_full_errno(ERRNO_IS_FS_WRITE_REFUSED(errno) ? LOG_DEBUG : LOG_WARNING, /* Don't complain on read-only images */ errno, "Failed to remove existing timezone info %s in container, ignoring: %m", where); return 0; } what = strjoina("../usr/share/zoneinfo/", z); if (symlink(what, where) < 0) { log_full_errno(ERRNO_IS_FS_WRITE_REFUSED(errno) ? LOG_DEBUG : LOG_WARNING, errno, "Failed to correct timezone of container, ignoring: %m"); return 0; } break; } _fallthrough_; } case TIMEZONE_BIND: { _cleanup_free_ char *resolved = NULL; int found; found = chase(where, dest, CHASE_NONEXISTENT, &resolved, NULL); if (found < 0) { log_warning_errno(found, "Failed to resolve /etc/localtime path in container, ignoring: %m"); return 0; } if (found == 0) /* missing? */ (void) touch(resolved); r = mount_nofollow_verbose(LOG_WARNING, "/etc/localtime", resolved, NULL, MS_BIND, NULL); if (r >= 0) return mount_nofollow_verbose(LOG_ERR, NULL, resolved, NULL, MS_BIND|MS_REMOUNT|MS_RDONLY|MS_NOSUID|MS_NODEV, NULL); _fallthrough_; } case TIMEZONE_COPY: /* If mounting failed, try to copy */ r = copy_file_atomic("/etc/localtime", where, 0644, COPY_REFLINK|COPY_REPLACE); if (r < 0) { log_full_errno(ERRNO_IS_NEG_FS_WRITE_REFUSED(r) ? LOG_DEBUG : LOG_WARNING, r, "Failed to copy /etc/localtime to %s, ignoring: %m", where); return 0; } break; default: assert_not_reached(); } /* Fix permissions of the symlink or file copy we just created */ r = userns_lchown(where, 0, 0); if (r < 0) log_warning_errno(r, "Failed to chown /etc/localtime, ignoring: %m"); return 0; } static int have_resolv_conf(const char *path) { assert(path); if (access(path, F_OK) < 0) { if (errno == ENOENT) return 0; return log_debug_errno(errno, "Failed to determine whether '%s' is available: %m", path); } return 1; } static int resolved_listening(void) { _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL; _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL; _cleanup_free_ char *dns_stub_listener_mode = NULL; int r; /* Check if resolved is listening */ r = sd_bus_open_system(&bus); if (r < 0) return log_debug_errno(r, "Failed to open system bus: %m"); r = bus_name_has_owner(bus, "org.freedesktop.resolve1", NULL); if (r < 0) return log_debug_errno(r, "Failed to check whether the 'org.freedesktop.resolve1' bus name is taken: %m"); if (r == 0) return 0; r = bus_get_property_string(bus, bus_resolve_mgr, "DNSStubListener", &error, &dns_stub_listener_mode); if (r < 0) return log_debug_errno(r, "Failed to query DNSStubListener property: %s", bus_error_message(&error, r)); return STR_IN_SET(dns_stub_listener_mode, "udp", "yes"); } static int setup_resolv_conf(const char *dest) { _cleanup_free_ char *etc = NULL; const char *where, *what; ResolvConfMode m; int r; assert(dest); if (arg_resolv_conf == RESOLV_CONF_AUTO) { if (arg_private_network) m = RESOLV_CONF_OFF; else if (have_resolv_conf(PRIVATE_STUB_RESOLV_CONF) > 0 && resolved_listening() > 0) m = etc_writable() ? RESOLV_CONF_COPY_STUB : RESOLV_CONF_BIND_STUB; else if (have_resolv_conf("/etc/resolv.conf") > 0) m = etc_writable() ? RESOLV_CONF_COPY_HOST : RESOLV_CONF_BIND_HOST; else m = etc_writable() ? RESOLV_CONF_DELETE : RESOLV_CONF_OFF; } else m = arg_resolv_conf; if (m == RESOLV_CONF_OFF) return 0; r = chase("/etc", dest, CHASE_PREFIX_ROOT, &etc, NULL); if (r < 0) { log_warning_errno(r, "Failed to resolve /etc path in container, ignoring: %m"); return 0; } where = strjoina(etc, "/resolv.conf"); if (m == RESOLV_CONF_DELETE) { if (unlink(where) < 0) log_full_errno(errno == ENOENT ? LOG_DEBUG : LOG_WARNING, errno, "Failed to remove '%s', ignoring: %m", where); return 0; } if (IN_SET(m, RESOLV_CONF_BIND_STATIC, RESOLV_CONF_REPLACE_STATIC, RESOLV_CONF_COPY_STATIC)) what = PRIVATE_STATIC_RESOLV_CONF; else if (IN_SET(m, RESOLV_CONF_BIND_UPLINK, RESOLV_CONF_REPLACE_UPLINK, RESOLV_CONF_COPY_UPLINK)) what = PRIVATE_UPLINK_RESOLV_CONF; else if (IN_SET(m, RESOLV_CONF_BIND_STUB, RESOLV_CONF_REPLACE_STUB, RESOLV_CONF_COPY_STUB)) what = PRIVATE_STUB_RESOLV_CONF; else what = "/etc/resolv.conf"; if (IN_SET(m, RESOLV_CONF_BIND_HOST, RESOLV_CONF_BIND_STATIC, RESOLV_CONF_BIND_UPLINK, RESOLV_CONF_BIND_STUB)) { _cleanup_free_ char *resolved = NULL; int found; found = chase(where, dest, CHASE_NONEXISTENT|CHASE_NOFOLLOW, &resolved, NULL); if (found < 0) { log_warning_errno(found, "Failed to resolve /etc/resolv.conf path in container, ignoring: %m"); return 0; } if (found == 0) /* missing? */ (void) touch(resolved); r = mount_nofollow_verbose(LOG_WARNING, what, resolved, NULL, MS_BIND, NULL); if (r >= 0) return mount_nofollow_verbose(LOG_ERR, NULL, resolved, NULL, MS_BIND|MS_REMOUNT|MS_RDONLY|MS_NOSUID|MS_NODEV, NULL); /* If that didn't work, let's copy the file */ } if (IN_SET(m, RESOLV_CONF_REPLACE_HOST, RESOLV_CONF_REPLACE_STATIC, RESOLV_CONF_REPLACE_UPLINK, RESOLV_CONF_REPLACE_STUB)) r = copy_file_atomic(what, where, 0644, COPY_REFLINK|COPY_REPLACE); else r = copy_file(what, where, O_TRUNC|O_NOFOLLOW, 0644, COPY_REFLINK); if (r < 0) { /* If the file already exists as symlink, let's suppress the warning, under the assumption that * resolved or something similar runs inside and the symlink points there. * * If the disk image is read-only, there's also no point in complaining. */ log_full_errno(!IN_SET(RESOLV_CONF_COPY_HOST, RESOLV_CONF_COPY_STATIC, RESOLV_CONF_COPY_UPLINK, RESOLV_CONF_COPY_STUB) && (r == -ELOOP || ERRNO_IS_NEG_FS_WRITE_REFUSED(r)) ? LOG_DEBUG : LOG_WARNING, r, "Failed to copy /etc/resolv.conf to %s, ignoring: %m", where); return 0; } r = userns_lchown(where, 0, 0); if (r < 0) log_warning_errno(r, "Failed to chown /etc/resolv.conf, ignoring: %m"); return 0; } static int setup_boot_id(void) { _cleanup_(unlink_and_freep) char *from = NULL; _cleanup_free_ char *path = NULL; sd_id128_t rnd = SD_ID128_NULL; const char *to; int r; /* Generate a new randomized boot ID, so that each boot-up of the container gets a new one */ r = tempfn_random_child("/run", "proc-sys-kernel-random-boot-id", &path); if (r < 0) return log_error_errno(r, "Failed to generate random boot ID path: %m"); r = sd_id128_randomize(&rnd); if (r < 0) return log_error_errno(r, "Failed to generate random boot id: %m"); r = id128_write(path, ID128_FORMAT_UUID, rnd); if (r < 0) return log_error_errno(r, "Failed to write boot id: %m"); from = TAKE_PTR(path); to = "/proc/sys/kernel/random/boot_id"; r = mount_nofollow_verbose(LOG_ERR, from, to, NULL, MS_BIND, NULL); if (r < 0) return r; return mount_nofollow_verbose(LOG_ERR, NULL, to, NULL, MS_BIND|MS_REMOUNT|MS_RDONLY|MS_NOSUID|MS_NOEXEC|MS_NODEV, NULL); } static int bind_mount_devnode(const char *from, const char *to) { int r; assert(from); assert(to); r = touch(to); if (r < 0) return log_debug_errno(r, "Failed to touch %s: %m", to); r = mount_nofollow_verbose(LOG_DEBUG, from, to, NULL, MS_BIND, NULL); if (r < 0) { (void) unlink(to); return log_error_errno(r, "Failed to bind mount %s to %s: %m", from, to); } return 0; } static int copy_devnode_one(const char *dest, const char *node, bool check) { int r; assert(dest); assert(!isempty(node)); BLOCK_WITH_UMASK(0000); _cleanup_free_ char *from = path_join("/dev/", node); if (!from) return log_oom(); if (check) { /* If 'check' is true, create /dev/fuse only when it is accessible. The check is necessary, * as some custom service units that invoke systemd-nspawn may enable DevicePolicy= without * DeviceAllow= for the device node. */ _cleanup_close_ int fd = open(from, O_CLOEXEC|O_RDWR); if (fd < 0) { log_debug_errno(errno, "Failed to open %s, skipping creation of the device node in the container, ignoring: %m", from); return 0; } } _cleanup_free_ char *to = path_join(dest, from); if (!to) return log_oom(); struct stat st; if (stat(from, &st) < 0) { if (errno != ENOENT) return log_error_errno(errno, "Failed to stat %s: %m", from); log_debug_errno(errno, "Device node %s does not exist, ignoring.", from); return 0; } if (!S_ISCHR(st.st_mode) && !S_ISBLK(st.st_mode)) return log_error_errno(SYNTHETIC_ERRNO(ESTALE), "%s is not a device node.", from); /* Create the parent directory of the device node. Here, we assume that the path has at most one * subdirectory under /dev/, e.g. /dev/net/tun. */ _cleanup_free_ char *parent = NULL; r = path_extract_directory(from, &parent); if (r < 0) return log_error_errno(r, "Failed to extract directory from %s: %m", from); r = userns_mkdir(dest, parent, 0755, 0, 0); if (r < 0) return log_error_errno(r, "Failed to create directory %s: %m", parent); r = RET_NERRNO(mknod(to, st.st_mode, st.st_rdev)); if (r < 0) { /* Explicitly warn the user when /dev/ is already populated. */ if (r == -EEXIST) log_notice("%s/dev/ is pre-mounted and pre-populated. If a pre-mounted /dev/ is provided it needs to be an unpopulated file system.", dest); /* If arg_uid_shift != 0, then we cannot fall back to use bind mount. */ if (!(arg_userns_mode == USER_NAMESPACE_NO || (arg_userns_mode == USER_NAMESPACE_FIXED && arg_uid_shift == 0))) { if (arg_userns_mode != USER_NAMESPACE_MANAGED || !ERRNO_IS_NEG_PRIVILEGE(r)) return log_error_errno(r, "Failed to mknod(%s): %m", to); log_debug_errno(r, "Failed to create device node '%s' and running in managed mode, resorting to bind mount: %m", to); } /* Some systems abusively restrict mknod but allow bind mounts. */ if (bind_mount_devnode(from, to) < 0) /* use the original error code. */ return log_error_errno(r, "Both mknod() and bind mount %s failed: %m", to); } else { /* mknod() succeeds, chown() it if necessary. */ r = userns_lchown(to, 0, 0); if (r < 0) return log_error_errno(r, "chown() of device node %s failed: %m", to); } _cleanup_free_ char *dn = path_join("/dev", S_ISCHR(st.st_mode) ? "char" : "block"); if (!dn) return log_oom(); r = userns_mkdir(dest, dn, 0755, 0, 0); if (r < 0) return log_error_errno(r, "Failed to create '%s': %m", dn); _cleanup_free_ char *sl = NULL; if (asprintf(&sl, "%s/" DEVNUM_FORMAT_STR, dn, DEVNUM_FORMAT_VAL(st.st_rdev)) < 0) return log_oom(); _cleanup_free_ char *prefixed = path_join(dest, sl); if (!prefixed) return log_oom(); _cleanup_free_ char *t = path_join("..", node); if (!t) return log_oom(); if (symlink(t, prefixed) < 0) log_debug_errno(errno, "Failed to symlink '%s' to '%s', ignoring: %m", t, prefixed); return 0; } static int copy_devnodes(const char *dest) { int r = 0; assert(dest); /* Required basic device nodes. */ FOREACH_STRING(node, "null", "zero", "full", "random", "urandom", "tty") { r = copy_devnode_one(dest, node, /* check= */ false); if (r < 0) return r; } /* Optional device nodes. */ FOREACH_STRING(node, "fuse", "net/tun") { r = copy_devnode_one(dest, node, /* check= */ true); if (r < 0) return r; } return 0; } static int make_extra_nodes(const char *dest) { int r; BLOCK_WITH_UMASK(0000); FOREACH_ARRAY(node, arg_extra_nodes, arg_n_extra_nodes) { _cleanup_free_ char *path = NULL; path = path_join(dest, node->path); if (!path) return log_oom(); dev_t dev = S_ISCHR(node->mode) || S_ISBLK(node->mode) ? makedev(node->major, node->minor) : 0; if (mknod(path, node->mode, dev) < 0) return log_error_errno(errno, "Failed to create device node '%s': %m", path); r = chmod_and_chown(path, node->mode, node->uid, node->gid); if (r < 0) return log_error_errno(r, "Failed to adjust device node ownership of '%s': %m", path); } return 0; } static int setup_pts(const char *dest, uid_t chown_uid) { _cleanup_free_ char *options = NULL; int r; #if HAVE_SELINUX if (arg_selinux_apifs_context) (void) asprintf(&options, "newinstance,ptmxmode=0666,mode=" STRINGIFY(TTY_MODE) ",gid=" GID_FMT ",context=\"%s\"", chown_uid + TTY_GID, arg_selinux_apifs_context); else #endif (void) asprintf(&options, "newinstance,ptmxmode=0666,mode=" STRINGIFY(TTY_MODE) ",gid=" GID_FMT, chown_uid + TTY_GID); if (!options) return log_oom(); /* Mount /dev/pts itself */ _cleanup_free_ char *p = path_join(dest, "/dev/pts"); if (!p) return log_oom(); r = RET_NERRNO(mkdir(p, 0755)); if (r < 0) return log_error_errno(r, "Failed to create /dev/pts: %m"); r = mount_nofollow_verbose(LOG_ERR, "devpts", p, "devpts", MS_NOSUID|MS_NOEXEC, options); if (r < 0) return r; r = userns_lchown(p, 0, 0); if (r < 0) return log_error_errno(r, "Failed to chown /dev/pts: %m"); /* Create /dev/ptmx symlink */ free(p); p = path_join(dest, "/dev/ptmx"); if (!p) return log_oom(); if (symlink("pts/ptmx", p) < 0) return log_error_errno(errno, "Failed to create /dev/ptmx symlink: %m"); r = userns_lchown(p, 0, 0); if (r < 0) return log_error_errno(r, "Failed to chown /dev/ptmx: %m"); /* And fix /dev/pts/ptmx ownership */ free(p); p = path_join(dest, "/dev/pts/ptmx"); if (!p) return log_oom(); r = userns_lchown(p, 0, 0); if (r < 0) return log_error_errno(r, "Failed to chown /dev/pts/ptmx: %m"); return 0; } static int setup_stdio_as_dev_console(void) { _cleanup_close_ int terminal = -EBADF; int r; /* We open the TTY in O_NOCTTY mode, so that we do not become controller yet. We'll do that later * explicitly, if we are configured to. */ terminal = open_terminal("/dev/console", O_RDWR|O_NOCTTY); if (terminal < 0) return log_error_errno(terminal, "Failed to open console: %m"); /* Make sure we can continue logging to the original stderr, even if * stderr points elsewhere now */ r = log_dup_console(); if (r < 0) return log_error_errno(r, "Failed to duplicate stderr: %m"); /* invalidates 'terminal' on success and failure */ r = rearrange_stdio(terminal, terminal, terminal); TAKE_FD(terminal); if (r < 0) return log_error_errno(r, "Failed to move console to stdin/stdout/stderr: %m"); return 0; } static int setup_dev_console(const char *console) { _cleanup_free_ char *p = NULL; int r; /* Create /dev/console symlink */ r = path_make_relative("/dev", console, &p); if (r < 0) return log_error_errno(r, "Failed to create relative path: %m"); if (symlink(p, "/dev/console") < 0) return log_error_errno(errno, "Failed to create /dev/console symlink: %m"); return 0; } static int setup_keyring(void) { key_serial_t keyring; /* Allocate a new session keyring for the container. This makes sure the keyring of the session * systemd-nspawn was invoked from doesn't leak into the container. Note that by default we block * keyctl() and request_key() anyway via seccomp so doing this operation isn't strictly necessary, * but in case people explicitly allow-list these system calls let's make sure we don't leak anything * into the container. */ keyring = keyctl(KEYCTL_JOIN_SESSION_KEYRING, 0, 0, 0, 0); if (keyring == -1) { if (errno == ENOSYS) log_debug_errno(errno, "Kernel keyring not supported, ignoring."); else if (ERRNO_IS_PRIVILEGE(errno)) log_debug_errno(errno, "Kernel keyring access prohibited, ignoring."); else return log_error_errno(errno, "Setting up kernel keyring failed: %m"); } return 0; } int make_run_host(const char *root) { int r; assert(root); r = userns_mkdir(root, "/run/host", 0755, 0, 0); if (r < 0) return log_error_errno(r, "Failed to create /run/host/: %m"); return 0; } static int setup_credentials(const char *root) { bool world_readable = false; int r; if (arg_credentials.n_credentials == 0) return 0; /* If starting a single-process container as a non-root user, the uid will only be resolved after we * are inside the inner child, when credential directories and files are already read-only, so they * are unusable as the single process won't have access to them. We also don't have access to the * uid that will actually be used from here, as we are setting credentials up from the outer child. * In order to make them usable as requested by the configuration, make them world readable in that * case, as by definition there are no other processes in that case besides the one being started, * which is being configured to be able to access credentials, and any of its children which will * inherit its privileges anyway. To ensure this, also enforce (and document) that * --no-new-privileges is necessary for this combination to work. */ if (arg_no_new_privileges && !isempty(arg_user) && !STR_IN_SET(arg_user, "root", "0") && arg_start_mode == START_PID1) world_readable = true; r = make_run_host(root); if (r < 0) return r; r = userns_mkdir(root, "/run/host/credentials", world_readable ? 0777 : 0700, 0, 0); if (r < 0) return log_error_errno(r, "Failed to create /run/host/credentials: %m"); _cleanup_free_ char *q = path_join(root, "/run/host/credentials"); if (!q) return log_oom(); r = mount_nofollow_verbose(LOG_ERR, NULL, q, "ramfs", MS_NOSUID|MS_NOEXEC|MS_NODEV, "mode=0700"); if (r < 0) return r; FOREACH_ARRAY(cred, arg_credentials.credentials, arg_credentials.n_credentials) { _cleanup_free_ char *j = NULL; _cleanup_close_ int fd = -EBADF; j = path_join(q, cred->id); if (!j) return log_oom(); fd = open(j, O_CREAT|O_EXCL|O_WRONLY|O_CLOEXEC|O_NOFOLLOW, world_readable ? 0666 : 0600); if (fd < 0) return log_error_errno(errno, "Failed to create credential file %s: %m", j); r = loop_write(fd, cred->data, cred->size); if (r < 0) return log_error_errno(r, "Failed to write credential to file %s: %m", j); if (fchmod(fd, world_readable ? 0444 : 0400) < 0) return log_error_errno(errno, "Failed to adjust access mode of %s: %m", j); if (in_child_chown()) if (fchown(fd, arg_uid_shift, arg_uid_shift) < 0) return log_error_errno(errno, "Failed to adjust ownership of %s: %m", j); } if (chmod(q, world_readable ? 0555 : 0500) < 0) return log_error_errno(errno, "Failed to adjust access mode of %s: %m", q); r = userns_lchown(q, 0, 0); if (r < 0) return r; /* Make both mount and superblock read-only now */ r = mount_nofollow_verbose(LOG_ERR, NULL, q, NULL, MS_REMOUNT|MS_BIND|MS_RDONLY|MS_NOSUID|MS_NOEXEC|MS_NODEV, NULL); if (r < 0) return r; return mount_nofollow_verbose(LOG_ERR, NULL, q, NULL, MS_REMOUNT|MS_RDONLY|MS_NOSUID|MS_NOEXEC|MS_NODEV, "mode=0500"); } static int setup_kmsg(int fd_inner_socket) { _cleanup_(unlink_and_freep) char *from = NULL; _cleanup_free_ char *fifo = NULL; _cleanup_close_ int fd = -EBADF; int r; assert(fd_inner_socket >= 0); BLOCK_WITH_UMASK(0000); /* We create the kmsg FIFO as a temporary file in /run, but immediately delete it after bind mounting it to * /proc/kmsg. While FIFOs on the reading side behave very similar to /proc/kmsg, their writing side behaves * differently from /dev/kmsg in that writing blocks when nothing is reading. In order to avoid any problems * with containers deadlocking due to this we simply make /dev/kmsg unavailable to the container. */ r = tempfn_random_child("/run", "proc-kmsg", &fifo); if (r < 0) return log_error_errno(r, "Failed to generate kmsg path: %m"); if (mkfifo(fifo, 0600) < 0) return log_error_errno(errno, "mkfifo() for /run/kmsg failed: %m"); from = TAKE_PTR(fifo); r = mount_nofollow_verbose(LOG_ERR, from, "/proc/kmsg", NULL, MS_BIND, NULL); if (r < 0) return r; fd = open(from, O_RDWR|O_NONBLOCK|O_CLOEXEC); if (fd < 0) return log_error_errno(errno, "Failed to open fifo: %m"); /* Store away the fd in the socket, so that it stays open as long as we run the child */ r = send_one_fd(fd_inner_socket, fd, 0); if (r < 0) return log_error_errno(r, "Failed to send FIFO fd: %m"); return 0; } struct ExposeArgs { union in_addr_union address4; union in_addr_union address6; sd_netlink *nfnl; }; static int on_address_change(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) { struct ExposeArgs *args = ASSERT_PTR(userdata); assert(rtnl); assert(m); (void) expose_port_execute(rtnl, args->nfnl, arg_expose_ports, AF_INET, &args->address4); (void) expose_port_execute(rtnl, args->nfnl, arg_expose_ports, AF_INET6, &args->address6); return 0; } static int setup_hostname(void) { int r; if ((arg_clone_ns_flags & CLONE_NEWUTS) == 0) return 0; r = sethostname_idempotent(arg_hostname ?: arg_machine); if (r < 0) return log_error_errno(r, "Failed to set hostname: %m"); return 0; } static int setup_journal(const char *directory, uid_t uid_shift, uid_t uid_range) { _cleanup_free_ char *d = NULL; sd_id128_t this_id; bool try; int r; /* Don't link journals in ephemeral mode */ if (arg_ephemeral) return 0; if (arg_link_journal == LINK_NO) return 0; try = arg_link_journal_try || arg_link_journal == LINK_AUTO; r = sd_id128_get_machine(&this_id); if (r < 0) return log_error_errno(r, "Failed to retrieve machine ID: %m"); if (sd_id128_equal(arg_uuid, this_id)) { log_full(try ? LOG_WARNING : LOG_ERR, "Host and machine ids are equal (%s): refusing to link journals", SD_ID128_TO_STRING(arg_uuid)); if (try) return 0; return -EEXIST; } FOREACH_STRING(dirname, "/var", "/var/log", "/var/log/journal") { r = userns_mkdir(directory, dirname, 0755, 0, 0); if (r < 0) { bool ignore = r == -EROFS && try; log_full_errno(ignore ? LOG_DEBUG : LOG_ERR, r, "Failed to create %s%s: %m", dirname, ignore ? ", ignoring" : ""); return ignore ? 0 : r; } } _cleanup_free_ char *p = path_join("/var/log/journal/", SD_ID128_TO_STRING(arg_uuid)); if (!p) return log_oom(); _cleanup_free_ char *q = path_join(directory, p); if (!q) return log_oom(); if (path_is_mount_point(p) > 0) { if (try) return 0; return log_error_errno(SYNTHETIC_ERRNO(EEXIST), "%s: already a mount point, refusing to use for journal", p); } if (path_is_mount_point(q) > 0) { if (try) return 0; return log_error_errno(SYNTHETIC_ERRNO(EEXIST), "%s: already a mount point, refusing to use for journal", q); } r = readlink_and_make_absolute(p, &d); if (r >= 0) { if (IN_SET(arg_link_journal, LINK_GUEST, LINK_AUTO) && path_equal(d, q)) { r = userns_mkdir(directory, p, 0755, 0, 0); if (r < 0) log_warning_errno(r, "Failed to create directory %s: %m", q); return 0; } if (unlink(p) < 0) return log_error_errno(errno, "Failed to remove symlink %s: %m", p); } else if (r == -EINVAL) { if (arg_link_journal == LINK_GUEST && rmdir(p) < 0) { if (errno == ENOTDIR) { log_error("%s already exists and is neither a symlink nor a directory", p); return r; } else return log_error_errno(errno, "Failed to remove %s: %m", p); } } else if (r != -ENOENT) return log_error_errno(r, "readlink(%s) failed: %m", p); if (arg_link_journal == LINK_GUEST) { if (symlink(q, p) < 0) { if (try) { log_debug_errno(errno, "Failed to symlink %s to %s, skipping journal setup: %m", q, p); return 0; } else return log_error_errno(errno, "Failed to symlink %s to %s: %m", q, p); } r = userns_mkdir(directory, p, 0755, 0, 0); if (r < 0) log_warning_errno(r, "Failed to create directory %s: %m", q); return 0; } if (arg_link_journal == LINK_HOST) { /* don't create parents here — if the host doesn't have * permanent journal set up, don't force it here */ r = RET_NERRNO(mkdir(p, 0755)); if (r < 0 && r != -EEXIST) { if (try) { log_debug_errno(r, "Failed to create %s, skipping journal setup: %m", p); return 0; } else return log_error_errno(r, "Failed to create %s: %m", p); } } else if (access(p, F_OK) < 0) return 0; if (dir_is_empty(q, /* ignore_hidden_or_backup= */ false) == 0) log_warning("%s is not empty, proceeding anyway.", q); r = userns_mkdir(directory, p, 0755, 0, 0); if (r < 0) return log_error_errno(r, "Failed to create %s: %m", q); return mount_custom( directory, &(CustomMount) { .type = CUSTOM_MOUNT_BIND, .options = (char*) (uid_is_valid(uid_shift) ? "rootidmap" : NULL), .source = p, .destination = p, .destination_uid = UID_INVALID, }, /* n= */ 1, uid_shift, uid_range, arg_selinux_apifs_context, MOUNT_NON_ROOT_ONLY); } static int drop_capabilities(uid_t uid) { CapabilityQuintet q; /* Let's initialize all five capability sets to something valid. If the quintet was configured via * OCI use that, but fill in missing bits. If it wasn't then derive the quintet in full from * arg_caps_retain. */ if (capability_quintet_is_set(&arg_full_capabilities)) { q = arg_full_capabilities; if (q.bounding == UINT64_MAX) q.bounding = uid == 0 ? arg_caps_retain : 0; if (q.effective == UINT64_MAX) q.effective = uid == 0 ? q.bounding : 0; if (q.inheritable == UINT64_MAX) q.inheritable = uid == 0 ? q.bounding : arg_caps_ambient; if (q.permitted == UINT64_MAX) q.permitted = uid == 0 ? q.bounding : arg_caps_ambient; if (q.ambient == UINT64_MAX) q.ambient = arg_caps_ambient; if (capability_quintet_mangle(&q)) return log_error_errno(SYNTHETIC_ERRNO(EPERM), "Cannot set capabilities that are not in the current bounding set."); } else { q = (CapabilityQuintet) { .bounding = arg_caps_retain, .effective = uid == 0 ? arg_caps_retain : 0, .inheritable = uid == 0 ? arg_caps_retain : arg_caps_ambient, .permitted = uid == 0 ? arg_caps_retain : arg_caps_ambient, .ambient = arg_caps_ambient, }; /* If we're not using OCI, proceed with mangled capabilities (so we don't error out) * in order to maintain the same behavior as systemd < 242. */ if (capability_quintet_mangle(&q)) log_full(arg_quiet ? LOG_DEBUG : LOG_WARNING, "Some capabilities will not be set because they are not in the current bounding set."); } return capability_quintet_enforce(&q); } static int reset_audit_loginuid(void) { _cleanup_free_ char *p = NULL; int r; if ((arg_clone_ns_flags & CLONE_NEWPID) == 0) return 0; /* if we are in managed userns mode, then we are already in our userns, hence we cannot reset the * loginuid anyway, hence don't bother */ if (arg_userns_mode == USER_NAMESPACE_MANAGED) return 0; r = read_virtual_file("/proc/self/loginuid", SIZE_MAX, &p, /* ret_size= */ NULL); if (r == -ENOENT) return 0; if (r < 0) return log_error_errno(r, "Failed to read /proc/self/loginuid: %m"); /* Already reset? */ if (streq(p, "4294967295")) return 0; r = write_string_file("/proc/self/loginuid", "4294967295", WRITE_STRING_FILE_DISABLE_BUFFER); if (r < 0) return log_error_errno(r, "Failed to reset audit login UID: %m"); return 0; } static int mount_tunnel_dig(const char *root) { int r; if (arg_userns_mode == USER_NAMESPACE_MANAGED) { log_debug("Not digging mount tunnel, because running in managed user namespace mode."); return 0; } (void) mkdir_p("/run/systemd/nspawn/", 0755); (void) mkdir_p("/run/systemd/nspawn/propagate", 0600); _cleanup_free_ char *p = path_join("/run/systemd/nspawn/propagate/", arg_machine); if (!p) return log_oom(); (void) mkdir_p(p, 0600); r = make_run_host(root); if (r < 0) return r; r = userns_mkdir(root, NSPAWN_MOUNT_TUNNEL, 0600, 0, 0); if (r < 0) return log_error_errno(r, "Failed to create "NSPAWN_MOUNT_TUNNEL": %m"); _cleanup_free_ char *q = path_join(root, NSPAWN_MOUNT_TUNNEL); if (!q) return log_oom(); r = mount_nofollow_verbose(LOG_ERR, p, q, NULL, MS_BIND, NULL); if (r < 0) return r; r = mount_nofollow_verbose(LOG_ERR, NULL, q, NULL, MS_BIND|MS_REMOUNT|MS_RDONLY, NULL); if (r < 0) return r; return 0; } static int mount_tunnel_open(void) { int r; if (arg_userns_mode == USER_NAMESPACE_MANAGED) { log_debug("Not opening up mount tunnel, because running in managed user namespace mode."); return 0; } r = mount_follow_verbose(LOG_ERR, NULL, NSPAWN_MOUNT_TUNNEL, NULL, MS_SLAVE, NULL); if (r < 0) return r; return 0; } static int setup_machine_id(const char *directory) { int r; /* If the UUID in the container is already set, then that's what counts, and we use. If it isn't set, and the * caller passed --uuid=, then we'll pass it in the $container_uuid env var to PID 1 of the container. The * assumption is that PID 1 will then write it to /etc/machine-id to make it persistent. If --uuid= is not * passed we generate a random UUID, and pass it via $container_uuid. In effect this means that /etc/machine-id * in the container and our idea of the container UUID will always be in sync (at least if PID 1 in the * container behaves nicely). */ r = id128_get_machine(directory, &arg_uuid); if (ERRNO_IS_NEG_MACHINE_ID_UNSET(r)) { /* If the file is missing, empty, or uninitialized, we don't mind */ if (sd_id128_is_null(arg_uuid)) { r = sd_id128_randomize(&arg_uuid); if (r < 0) return log_error_errno(r, "Failed to acquire randomized machine UUID: %m"); } } else if (r < 0) return log_error_errno(r, "Failed to read machine ID from container image: %m"); return 0; } static int setup_varlink_socket(const char *directory, const char *name) { int r; assert(directory); if (arg_delegate_container_ranges == 0) return 0; r = make_run_host(directory); if (r < 0) return r; _cleanup_free_ char *src = path_join("/run/systemd", name); if (!src) return log_oom(); _cleanup_free_ char *dest = path_join(directory, "/run/host", name); if (!dest) return log_oom(); r = touch(dest); if (r < 0) return log_error_errno(r, "Failed to create %s: %m", dest); r = userns_lchown(dest, 0, 0); if (r < 0) return log_error_errno(r, "Failed to chown %s: %m", dest); return mount_nofollow_verbose( LOG_ERR, src, dest, /* fstype= */ NULL, MS_BIND|MS_RDONLY, /* options= */ NULL); } static int recursive_chown(const char *directory, uid_t shift, uid_t range) { int r; assert(directory); if (arg_userns_mode == USER_NAMESPACE_NO || arg_userns_ownership != USER_NAMESPACE_OWNERSHIP_CHOWN) return 0; r = path_patch_uid(directory, arg_uid_shift, arg_uid_range); if (r == -EOPNOTSUPP) return log_error_errno(r, "Automatic UID/GID adjusting is only supported for UID/GID ranges starting at multiples of 2^16 with a range of 2^16."); if (r == -EBADE) return log_error_errno(r, "Upper 16 bits of root directory UID and GID do not match."); if (r < 0) return log_error_errno(r, "Failed to adjust UID/GID shift of OS tree: %m"); if (r == 0) log_debug("Root directory of image is already owned by the right UID/GID range, skipping recursive chown operation."); else log_debug("Patched directory tree to match UID/GID range."); return r; } /* * Return values: * < 0 : pidref_wait_for_terminate() failed to get the state of the * container, the container was terminated by a signal, or * failed for an unknown reason. No change is made to the * container argument. * > 0 : The program executed in the container terminated with an * error. The exit code of the program executed in the * container is returned. The container argument has been set * to CONTAINER_TERMINATED. * 0 : The container is being rebooted, has been shut down or exited * successfully. The container argument has been set to either * CONTAINER_TERMINATED or CONTAINER_REBOOTED. * * That is, success is indicated by a return value of zero, and an * error is indicated by a non-zero value. */ static int wait_for_container(PidRef *pid, ContainerStatus *container) { siginfo_t status; int r; assert(pidref_is_set(pid)); r = pidref_wait_for_terminate(pid, &status); if (r < 0) return log_warning_errno(r, "Failed to wait for container: %m"); pidref_done(pid); switch (status.si_code) { case CLD_EXITED: if (status.si_status == 0) log_full(arg_quiet ? LOG_DEBUG : LOG_INFO, "Container %s exited successfully.", arg_machine); else log_full(arg_quiet ? LOG_DEBUG : LOG_INFO, "Container %s failed with error code %i.", arg_machine, status.si_status); *container = CONTAINER_TERMINATED; return status.si_status; case CLD_KILLED: if (status.si_status == SIGINT) { log_full(arg_quiet ? LOG_DEBUG : LOG_INFO, "Container %s has been shut down.", arg_machine); *container = CONTAINER_TERMINATED; return 0; } else if (status.si_status == SIGHUP) { log_full(arg_quiet ? LOG_DEBUG : LOG_INFO, "Container %s is being rebooted.", arg_machine); *container = CONTAINER_REBOOTED; return 0; } _fallthrough_; case CLD_DUMPED: return log_error_errno(SYNTHETIC_ERRNO(EIO), "Container %s terminated by signal %s.", arg_machine, signal_to_string(status.si_status)); default: return log_error_errno(SYNTHETIC_ERRNO(EIO), "Container %s failed due to unknown reason.", arg_machine); } } static int on_orderly_shutdown(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) { PidRef *pid = userdata; assert(si); if (pidref_is_set(pid)) if (pidref_kill(pid, arg_kill_signal) >= 0) { log_info("Trying to halt container by sending %s to container PID 1. Send SIGTERM again to trigger immediate termination.", signal_to_string(si->ssi_signo)); sd_event_source_set_userdata(s, NULL); sd_notify(/* unset_environment= */ false, NOTIFY_STOPPING_MESSAGE); return 0; } log_debug("Got %s, exiting.", signal_to_string(si->ssi_signo)); sd_event_exit(sd_event_source_get_event(s), 0); return 0; } static int on_sigchld(sd_event_source *s, const struct signalfd_siginfo *ssi, void *userdata) { assert(s); assert(ssi); PidRef *pid = ASSERT_PTR(userdata); for (;;) { siginfo_t si = {}; if (waitid(P_ALL, 0, &si, WNOHANG|WNOWAIT|WEXITED) < 0) return log_error_errno(errno, "Failed to waitid(): %m"); if (si.si_pid == 0) /* No pending children. */ break; if (si.si_pid == pid->pid) { /* The main process we care for has exited. Return from * signal handler but leave the zombie. */ sd_event_exit(sd_event_source_get_event(s), 0); break; } /* Reap all other children. */ (void) waitid(P_PID, si.si_pid, &si, WNOHANG|WEXITED); } return 0; } static int on_request_stop(sd_bus_message *m, void *userdata, sd_bus_error *error) { PidRef *pid = ASSERT_PTR(userdata); assert(m); if (arg_kill_signal > 0) { log_info("Container termination requested. Attempting to halt container."); (void) pidref_kill(pid, arg_kill_signal); } else { log_info("Container termination requested. Exiting."); sd_event_exit(sd_bus_get_event(sd_bus_message_get_bus(m)), 0); } return 0; } static int pick_paths(void) { int r; if (arg_directory) { _cleanup_(pick_result_done) PickResult result = PICK_RESULT_NULL; PickFilter filter = *pick_filter_image_dir; filter.architecture = arg_architecture; r = path_pick_update_warn( &arg_directory, &filter, /* n_filters= */ 1, PICK_ARCHITECTURE|PICK_TRIES, &result); if (r < 0) { /* Accept ENOENT here so that the --template= logic can work */ if (r != -ENOENT) return r; } else arg_architecture = result.architecture; } if (arg_image) { _cleanup_(pick_result_done) PickResult result = PICK_RESULT_NULL; PickFilter filter = *pick_filter_image_raw; filter.architecture = arg_architecture; r = path_pick_update_warn( &arg_image, &filter, /* n_filters= */ 1, PICK_ARCHITECTURE|PICK_TRIES, &result); if (r < 0) return r; arg_architecture = result.architecture; } if (arg_mstack) { _cleanup_(pick_result_done) PickResult result = PICK_RESULT_NULL; PickFilter filter = *pick_filter_image_mstack; filter.architecture = arg_architecture; r = path_pick_update_warn( &arg_mstack, &filter, /* n_filters= */ 1, PICK_ARCHITECTURE|PICK_TRIES, &result); if (r < 0) return r; arg_architecture = result.architecture; } if (arg_template) { _cleanup_(pick_result_done) PickResult result = PICK_RESULT_NULL; PickFilter filter = *pick_filter_image_dir; filter.architecture = arg_architecture; r = path_pick_update_warn( &arg_template, &filter, /* n_filters= */ 1, PICK_ARCHITECTURE, &result); if (r < 0) return r; arg_architecture = result.architecture; } return 0; } static int determine_names(void) { int r; if (arg_template && !arg_directory && arg_machine) { /* If --template= was specified then we should not search for a machine, but instead create a * new one in /var/lib/machine. */ arg_directory = path_join("/var/lib/machines", arg_machine); if (!arg_directory) return log_oom(); } if (!arg_image && !arg_directory && !arg_mstack) { if (arg_machine) { _cleanup_(image_unrefp) Image *i = NULL; r = image_find(arg_privileged ? RUNTIME_SCOPE_SYSTEM : RUNTIME_SCOPE_USER, IMAGE_MACHINE, arg_machine, NULL, &i); if (r == -ENOENT) return log_error_errno(r, "No image for machine '%s'.", arg_machine); if (r < 0) return log_error_errno(r, "Failed to find image for machine '%s': %m", arg_machine); switch (i->type) { case IMAGE_RAW: case IMAGE_BLOCK: r = free_and_strdup(&arg_image, i->path); break; case IMAGE_DIRECTORY: case IMAGE_SUBVOLUME: r = free_and_strdup(&arg_directory, i->path); break; case IMAGE_MSTACK: r = free_and_strdup(&arg_mstack, i->path); break; default: assert_not_reached(); } if (r < 0) return log_oom(); if (!arg_ephemeral) arg_read_only = arg_read_only || image_is_read_only(i); } else { r = safe_getcwd(&arg_directory); if (r < 0) return log_error_errno(r, "Failed to determine current directory: %m"); } if (!arg_directory && !arg_image && !arg_mstack) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to determine path, please use --directory=, --image= or --mstack=."); } if (!arg_machine) { if (arg_directory) { if (path_equal(arg_directory, "/")) { arg_machine = gethostname_malloc(); if (!arg_machine) return log_oom(); } else { r = path_extract_filename(arg_directory, &arg_machine); if (r < 0) return log_error_errno(r, "Failed to extract file name from '%s': %m", arg_directory); } } else if (arg_image) { r = path_extract_filename(arg_image, &arg_machine); if (r < 0) return log_error_errno(r, "Failed to extract file name from '%s': %m", arg_image); /* Truncate suffix if there is one */ char *e = endswith(arg_machine, ".raw"); if (e) *e = 0; } else if (arg_mstack) { r = path_extract_filename(arg_mstack, &arg_machine); if (r < 0) return log_error_errno(r, "Failed to extract file name from '%s': %m", arg_mstack); char *e = endswith(arg_machine, ".mstack"); if (e) *e = 0; } else assert_not_reached(); hostname_cleanup(arg_machine); if (!hostname_is_valid(arg_machine, 0)) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to determine machine name automatically, please use -M."); /* Copy the machine name before the random suffix is added below, otherwise we won't be able * to match fixed config file names. */ arg_settings_filename = strjoin(arg_machine, ".nspawn"); if (!arg_settings_filename) return log_oom(); /* Add a random suffix when this is an ephemeral machine, so that we can run many * instances at once without manually having to specify -M each time. */ if (arg_ephemeral) if (strextendf(&arg_machine, "-%016" PRIx64, random_u64()) < 0) return log_oom(); } else { arg_settings_filename = strjoin(arg_machine, ".nspawn"); if (!arg_settings_filename) return log_oom(); } return 0; } static int chase_and_update(char **p, ChaseFlags flags) { char *chased; int r; assert(p); if (!*p) return 0; r = chase(*p, /* root= */ NULL, flags, &chased, /* ret_fd= */ NULL); if (r < 0) return log_error_errno(r, "Failed to resolve path %s: %m", *p); return free_and_replace(*p, chased); } static int determine_uid_shift(const char *directory) { assert(directory); if (arg_userns_mode == USER_NAMESPACE_MANAGED) { /* In managed mode we should already know the UID shift */ assert(uid_is_valid(arg_uid_shift)); return 0; } if (arg_userns_mode == USER_NAMESPACE_NO) { arg_uid_shift = 0; return 0; } if (arg_uid_shift == UID_INVALID) { struct stat st; /* Read the UID shift off the image. Maybe we can reuse this to avoid chowning. */ if (stat(directory, &st) < 0) return log_error_errno(errno, "Failed to determine UID base of %s: %m", directory); arg_uid_shift = st.st_uid & UINT32_C(0xffff0000); if (arg_uid_shift != (st.st_gid & UINT32_C(0xffff0000))) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "UID and GID base of %s don't match.", directory); arg_uid_range = UINT32_C(0x10000); if (arg_uid_shift != 0) { /* If the image is shifted already, then we'll fall back to classic chowning, for * compatibility (and simplicity), or refuse if mapping is explicitly requested. */ if (arg_userns_ownership == USER_NAMESPACE_OWNERSHIP_AUTO) { log_debug("UID base of %s is non-zero, not using UID mapping.", directory); arg_userns_ownership = USER_NAMESPACE_OWNERSHIP_CHOWN; } else if (arg_userns_ownership == USER_NAMESPACE_OWNERSHIP_MAP) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "UID base of %s is not zero, UID mapping not supported.", directory); } } if (!userns_shift_range_valid(arg_uid_shift, arg_uid_range)) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "UID base too high for UID range."); return 0; } static unsigned long effective_clone_ns_flags(void) { unsigned long flags = arg_clone_ns_flags; if (arg_private_network) flags |= CLONE_NEWNET; if (arg_use_cgns) flags |= CLONE_NEWCGROUP; if (arg_userns_mode != USER_NAMESPACE_NO) flags |= CLONE_NEWUSER; return flags; } static int patch_sysctl(void) { /* This table is inspired by runc's sysctl() function */ static const struct { const char *key; bool prefix; unsigned long clone_flags; } safe_sysctl[] = { { "kernel.hostname", false, CLONE_NEWUTS }, { "kernel.domainname", false, CLONE_NEWUTS }, { "kernel.msgmax", false, CLONE_NEWIPC }, { "kernel.msgmnb", false, CLONE_NEWIPC }, { "kernel.msgmni", false, CLONE_NEWIPC }, { "kernel.sem", false, CLONE_NEWIPC }, { "kernel.shmall", false, CLONE_NEWIPC }, { "kernel.shmmax", false, CLONE_NEWIPC }, { "kernel.shmmni", false, CLONE_NEWIPC }, { "fs.mqueue.", true, CLONE_NEWIPC }, { "net.", true, CLONE_NEWNET }, }; unsigned long flags; int r; flags = effective_clone_ns_flags(); STRV_FOREACH_PAIR(k, v, arg_sysctl) { bool good = false; FOREACH_ELEMENT(i, safe_sysctl) { if (!FLAGS_SET(flags, i->clone_flags)) continue; if (i->prefix) good = startswith(*k, i->key); else good = streq(*k, i->key); if (good) break; } if (!good) return log_error_errno(SYNTHETIC_ERRNO(EPERM), "Refusing to write to sysctl '%s', as it is not safe in the selected namespaces.", *k); r = sysctl_write(*k, *v); if (r < 0) return log_error_errno(r, "Failed to write sysctl '%s': %m", *k); } return 0; } static int inner_child( Barrier *barrier, int fd_inner_socket, FDSet *fds, char **os_release_pairs) { _cleanup_free_ char *home = NULL; size_t n_env = 1; char *envp[] = { (char*) "PATH=" DEFAULT_PATH_COMPAT, NULL, /* container */ NULL, /* TERM */ NULL, /* COLORTERM */ NULL, /* NO_COLOR */ NULL, /* HOME */ NULL, /* USER */ NULL, /* LOGNAME */ NULL, /* container_uuid */ NULL, /* LISTEN_FDS */ NULL, /* LISTEN_PID */ NULL, /* NOTIFY_SOCKET */ NULL, /* CREDENTIALS_DIRECTORY */ NULL, /* LANG */ NULL }; const char *exec_target; _cleanup_strv_free_ char **env_use = NULL; int r, which_failed; /* This is the "inner" child process, i.e. the one forked off by the "outer" child process, which is the one * the container manager itself forked off. At the time of clone() it gained its own CLONE_NEWNS, CLONE_NEWPID, * CLONE_NEWUTS, CLONE_NEWIPC, CLONE_NEWUSER namespaces. Note that it has its own CLONE_NEWNS namespace, * separate from the CLONE_NEWNS created for the "outer" child, and also separate from the host's CLONE_NEWNS * namespace. The reason for having two levels of CLONE_NEWNS namespaces is that the "inner" one is owned by * the CLONE_NEWUSER namespace of the container, while the "outer" one is owned by the host's CLONE_NEWUSER * namespace. * * Note at this point we have no CLONE_NEWNET namespace yet. We'll acquire that one later through * unshare(). See below. */ assert(barrier); assert(fd_inner_socket >= 0); log_debug("Inner child is initializing."); if (arg_userns_mode != USER_NAMESPACE_NO) { /* Tell the parent, that it now can write the UID map. */ (void) barrier_place(barrier); /* #1 */ /* Wait until the parent wrote the UID map */ if (!barrier_place_and_sync(barrier)) /* #2 */ return log_error_errno(SYNTHETIC_ERRNO(ESRCH), "Parent died too early"); /* Become the new root user inside our namespace */ r = reset_uid_gid(); if (r < 0) return log_error_errno(r, "Couldn't become new root: %m"); /* Creating a new user namespace means all MS_SHARED mounts become MS_SLAVE. Let's put them * back to MS_SHARED here, since that's what we want as defaults. (This will not reconnect * propagation, but simply create new peer groups for all our mounts). */ r = mount_follow_verbose(LOG_ERR, NULL, "/", NULL, MS_SHARED|MS_REC, NULL); if (r < 0) return r; } r = mount_all(/* dest= */ NULL, arg_mount_settings | MOUNT_IN_USERNS, arg_uid_shift, arg_selinux_apifs_context); if (r < 0) return r; if (!arg_network_namespace_path && arg_private_network) { _cleanup_close_ int netns_fd = -EBADF; if (arg_userns_mode != USER_NAMESPACE_MANAGED) if (unshare(CLONE_NEWNET) < 0) return log_error_errno(errno, "Failed to unshare network namespace: %m"); netns_fd = namespace_open_by_type(NAMESPACE_NET); if (netns_fd < 0) return log_error_errno(netns_fd, "Failed to open newly allocate network namespace: %m"); r = send_one_fd(fd_inner_socket, netns_fd, 0); if (r < 0) return log_error_errno(r, "Failed to send network namespace to supervisor: %m"); /* Tell the parent that it can setup network interfaces. */ (void) barrier_place(barrier); /* #3 */ } if (arg_userns_mode != USER_NAMESPACE_MANAGED) { r = mount_sysfs(NULL, arg_mount_settings | MOUNT_IN_USERNS); if (r < 0) return r; } /* Wait until we are cgroup-ified, so that we can mount the right cgroup path writable */ if (!barrier_place_and_sync(barrier)) /* #4 */ return log_error_errno(SYNTHETIC_ERRNO(ESRCH), "Parent died too early"); if (arg_use_cgns) { r = unshare(CLONE_NEWCGROUP); if (r < 0) return log_error_errno(errno, "Failed to unshare cgroup namespace: %m"); r = mount_cgroups(/* dest= */ NULL, /* accept_existing= */ false); } else r = bind_mount_cgroup_hierarchy(); if (r < 0) return r; r = setup_boot_id(); if (r < 0) return r; r = setup_kmsg(fd_inner_socket); if (r < 0) return r; r = mount_custom( "/", arg_custom_mounts, arg_n_custom_mounts, 0, 0, arg_selinux_apifs_context, MOUNT_NON_ROOT_ONLY | MOUNT_IN_USERNS); if (r < 0) return r; if (setsid() < 0) return log_error_errno(errno, "setsid() failed: %m"); if (arg_private_network) (void) loopback_setup(); if (arg_expose_ports) { r = expose_port_send_rtnl(fd_inner_socket); if (r < 0) return r; } if (arg_console_mode != CONSOLE_PIPE) { _cleanup_close_ int master = -EBADF; _cleanup_free_ char *console = NULL; /* Allocate a pty and make it available as /dev/console. */ master = openpt_allocate(O_RDWR|O_NONBLOCK, &console); if (master < 0) return log_error_errno(master, "Failed to allocate a pty: %m"); r = setup_dev_console(console); if (r < 0) return log_error_errno(r, "Failed to set up /dev/console: %m"); r = send_one_fd(fd_inner_socket, master, 0); if (r < 0) return log_error_errno(r, "Failed to send master fd: %m"); r = setup_stdio_as_dev_console(); if (r < 0) return r; } r = patch_sysctl(); if (r < 0) return r; if (arg_oom_score_adjust_set) { r = set_oom_score_adjust(arg_oom_score_adjust); if (r < 0) return log_error_errno(r, "Failed to adjust OOM score: %m"); } if (arg_cpu_set.set) if (sched_setaffinity(0, arg_cpu_set.allocated, arg_cpu_set.set) < 0) return log_error_errno(errno, "Failed to set CPU affinity: %m"); (void) setup_hostname(); if (arg_personality != PERSONALITY_INVALID) { r = safe_personality(arg_personality); if (r < 0) return log_error_errno(r, "personality() failed: %m"); #ifdef ARCHITECTURE_SECONDARY } else if (arg_architecture == ARCHITECTURE_SECONDARY) { r = safe_personality(PER_LINUX32); if (r < 0) return log_error_errno(r, "personality() failed: %m"); #endif } else if (!arg_quiet && arg_architecture >= 0 && arg_architecture != native_architecture()) log_notice("Selected architecture '%s' not supported natively on the local CPU, assuming " "invocation with qemu userspace emulator (or equivalent) in effect.", architecture_to_string(arg_architecture)); r = setrlimit_closest_all((const struct rlimit *const*) arg_rlimit, &which_failed); if (r < 0) return log_error_errno(r, "Failed to apply resource limit RLIMIT_%s: %m", rlimit_to_string(which_failed)); #if HAVE_SECCOMP if (arg_seccomp) { if (is_seccomp_available()) { r = sym_seccomp_load(arg_seccomp); if (ERRNO_IS_NEG_SECCOMP_FATAL(r)) return log_error_errno(r, "Failed to install seccomp filter: %m"); if (r < 0) log_debug_errno(r, "Failed to install seccomp filter: %m"); } } else #endif { r = setup_seccomp(arg_caps_retain, arg_syscall_allow_list, arg_syscall_deny_list); if (r < 0) return r; } if (arg_suppress_sync) { #if HAVE_SECCOMP r = seccomp_suppress_sync(); if (r < 0) log_debug_errno(r, "Failed to install sync() suppression seccomp filter, ignoring: %m"); #else log_debug("systemd is built without SECCOMP support. Ignoring --suppress-sync= command line option and SuppressSync= setting."); #endif } #if HAVE_SELINUX if (arg_selinux_context && mac_selinux_use()) if (sym_setexeccon_raw(arg_selinux_context) < 0) return log_error_errno(errno, "setexeccon(\"%s\") failed: %m", arg_selinux_context); #endif /* Make sure we keep the caps across the uid/gid dropping, so that we can retain some selected caps * if we need to later on. */ if (prctl(PR_SET_KEEPCAPS, 1) < 0) return log_error_errno(errno, "Failed to set PR_SET_KEEPCAPS: %m"); if (uid_is_valid(arg_uid) || gid_is_valid(arg_gid)) r = change_uid_gid_raw(arg_uid, arg_gid, arg_supplementary_gids, arg_n_supplementary_gids, arg_console_mode != CONSOLE_PIPE); else r = change_uid_gid(arg_user, arg_console_mode != CONSOLE_PIPE, &home); if (r < 0) return r; r = drop_capabilities(getuid()); if (r < 0) return log_error_errno(r, "Dropping capabilities failed: %m"); if (arg_no_new_privileges) if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) < 0) return log_error_errno(errno, "Failed to disable new privileges: %m"); /* LXC sets container=lxc, so follow the scheme here */ envp[n_env++] = strjoina("container=", arg_container_service_name); /* Propagate $TERM & Co. unless we are invoked in pipe mode and stdin/stdout/stderr don't refer to a TTY */ if (arg_console_mode != CONSOLE_PIPE && !terminal_is_dumb()) FOREACH_STRING(v, "TERM=", "COLORTERM=", "NO_COLOR=") { char *t = strv_find_prefix(environ, v); if (!t) continue; envp[n_env++] = t; } else envp[n_env++] = (char*) "TERM=dumb"; if (home || !uid_is_valid(arg_uid) || arg_uid == 0) if (asprintf(envp + n_env++, "HOME=%s", home ?: "/root") < 0) return log_oom(); if (arg_user || !uid_is_valid(arg_uid) || arg_uid == 0) if (asprintf(envp + n_env++, "USER=%s", arg_user ?: "root") < 0 || asprintf(envp + n_env++, "LOGNAME=%s", arg_user ?: "root") < 0) return log_oom(); assert(!sd_id128_is_null(arg_uuid)); if (asprintf(envp + n_env++, "container_uuid=%s", SD_ID128_TO_UUID_STRING(arg_uuid)) < 0) return log_oom(); if (!fdset_isempty(fds)) { r = fdset_cloexec(fds, false); if (r < 0) return log_error_errno(r, "Failed to unset O_CLOEXEC for file descriptors."); if ((asprintf(envp + n_env++, "LISTEN_FDS=%u", fdset_size(fds)) < 0) || (asprintf(envp + n_env++, "LISTEN_PID=1") < 0)) return log_oom(); } if (asprintf(envp + n_env++, "NOTIFY_SOCKET=%s", NSPAWN_NOTIFY_SOCKET_PATH) < 0) return log_oom(); if (arg_credentials.n_credentials > 0) { envp[n_env] = strdup("CREDENTIALS_DIRECTORY=/run/host/credentials"); if (!envp[n_env]) return log_oom(); n_env++; } if (arg_start_mode != START_BOOT) { envp[n_env] = strdup("LANG=" SYSTEMD_NSPAWN_LOCALE); if (!envp[n_env]) return log_oom(); n_env++; } env_use = strv_env_merge(envp, os_release_pairs, arg_setenv); if (!env_use) return log_oom(); /* Let the parent know that we are ready and wait until the parent is ready with the setup, too... */ if (!barrier_place_and_sync(barrier)) /* #5 */ return log_error_errno(SYNTHETIC_ERRNO(ESRCH), "Parent died too early"); /* Note, this should be done this late (💣 and not moved earlier! 💣), so that all namespacing * changes are already in effect by now, so that any resolved paths here definitely reference * resources inside the container, and not outside of them. */ if (arg_chdir) if (chdir(arg_chdir) < 0) return log_error_errno(errno, "Failed to change to specified working directory %s: %m", arg_chdir); if (arg_start_mode == START_PID2) { r = stub_pid1(arg_uuid); if (r < 0) return r; } if (arg_console_mode != CONSOLE_PIPE) { /* So far our pty wasn't controlled by any process. Finally, it's time to change that, if we * are configured for that. Acquire it as controlling tty. */ if (ioctl(STDIN_FILENO, TIOCSCTTY) < 0) return log_error_errno(errno, "Failed to acquire controlling TTY: %m"); } log_debug("Inner child finished, invoking payload."); /* Now, explicitly close the log, so that we then can close all remaining fds. Closing the log explicitly first * has the benefit that the logging subsystem knows about it, and is thus ready to be reopened should we need * it again. Note that the other fds closed here are at least the locking and barrier fds. */ log_close(); log_set_open_when_needed(true); log_settle_target(); (void) fdset_close_others(fds); if (arg_start_mode == START_BOOT) { char **a; size_t m; /* Automatically search for the init system */ m = strv_length(arg_parameters); a = newa(char*, m + 2); memcpy_safe(a + 1, arg_parameters, m * sizeof(char*)); a[1 + m] = NULL; FOREACH_STRING(init, "/usr/lib/systemd/systemd", "/lib/systemd/systemd", "/sbin/init") { a[0] = (char*) init; execve(a[0], a, env_use); } exec_target = "/usr/lib/systemd/systemd, /lib/systemd/systemd, /sbin/init"; } else if (!strv_isempty(arg_parameters)) { const char *dollar_path; exec_target = arg_parameters[0]; /* Use the user supplied search $PATH if there is one, or DEFAULT_PATH_COMPAT if not to search the * binary. */ dollar_path = strv_env_get(env_use, "PATH"); if (dollar_path) { if (setenv("PATH", dollar_path, 1) < 0) return log_error_errno(errno, "Failed to update $PATH: %m"); } execvpe(arg_parameters[0], arg_parameters, env_use); } else { if (!arg_chdir) /* If we cannot change the directory, we'll end up in /, that is expected. */ (void) chdir(home ?: "/root"); execle(DEFAULT_USER_SHELL, "-" DEFAULT_USER_SHELL_NAME, NULL, env_use); if (!streq(DEFAULT_USER_SHELL, "/bin/bash")) execle("/bin/bash", "-bash", NULL, env_use); if (!streq(DEFAULT_USER_SHELL, "/bin/sh")) execle("/bin/sh", "-sh", NULL, env_use); exec_target = DEFAULT_USER_SHELL ", /bin/bash, /bin/sh"; } return log_error_errno(errno, "execv(%s) failed: %m", exec_target); } static int setup_notify_child(const void *directory) { _cleanup_close_ int fd = -EBADF; _cleanup_free_ char *j = NULL; union sockaddr_union sa = { .un.sun_family = AF_UNIX, }; int r; fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0); if (fd < 0) return log_error_errno(errno, "Failed to allocate notification socket: %m"); if (directory) { j = path_join(directory, NSPAWN_NOTIFY_SOCKET_PATH); if (!j) return log_oom(); } r = sockaddr_un_set_path(&sa.un, j ?: NSPAWN_NOTIFY_SOCKET_PATH); if (r < 0) return log_error_errno(r, "Failed to set AF_UNIX path to %s: %m", j ?: NSPAWN_NOTIFY_SOCKET_PATH); (void) mkdir_parents(sa.un.sun_path, 0755); (void) sockaddr_un_unlink(&sa.un); WITH_UMASK(0577) { /* only set "w" bit, which is all that's necessary for connecting from the container */ r = bind(fd, &sa.sa, sockaddr_un_len(&sa.un)); if (r < 0) return log_error_errno(errno, "bind(" NSPAWN_NOTIFY_SOCKET_PATH ") failed: %m"); } r = userns_lchown(sa.un.sun_path, 0, 0); if (r < 0) return log_error_errno(r, "Failed to chown " NSPAWN_NOTIFY_SOCKET_PATH ": %m"); r = setsockopt_int(fd, SOL_SOCKET, SO_PASSCRED, true); if (r < 0) return log_error_errno(r, "Failed to enable SO_PASSCRED: %m"); r = setsockopt_int(fd, SOL_SOCKET, SO_PASSPIDFD, true); if (r < 0) log_debug_errno(r, "Failed to enable SO_PASSPIDFD, ignoring: %m"); r = setsockopt_int(fd, SOL_SOCKET, SO_PASSRIGHTS, false); if (r < 0) log_debug_errno(r, "Failed to turn off SO_PASSRIGHTS, ignoring: %m"); return TAKE_FD(fd); } static int setup_unix_export_dir_outside(char **ret) { int r; assert(ret); if (arg_userns_mode == USER_NAMESPACE_MANAGED) { log_debug("Not digging socket tunnel, because running in managed user namespace mode."); return 0; } _cleanup_free_ char *p = NULL; p = path_join("/run/systemd/nspawn/unix-export", arg_machine); if (!p) return log_oom(); r = path_is_mount_point(p); if (r > 0) return log_error_errno(SYNTHETIC_ERRNO(EEXIST), "Mount point '%s' exists already, refusing.", p); if (r < 0 && r != -ENOENT) return log_error_errno(r, "Failed to detect if '%s' is a mount point: %m", p); r = mkdir_p(p, 0755); if (r < 0) return log_error_errno(r, "Failed to create '%s': %m", p); _cleanup_(rmdir_and_freep) char *q = TAKE_PTR(p); /* Mount the "unix export" directory really tiny, just 64 inodes. We mark the superblock writable * (since the container shall bind sockets into it). */ r = mount_nofollow_verbose( LOG_ERR, "tmpfs", q, "tmpfs", MS_NODEV|MS_NOEXEC|MS_NOSUID|MS_NOSYMFOLLOW, "size=4M,nr_inodes=64,mode=0755"); if (r < 0) return r; _cleanup_(umount_and_rmdir_and_freep) char *w = TAKE_PTR(q); /* After creating the superblock we change the bind mount to be read-only. This means that the fs * itself is writable, but not through the mount accessible from the host. */ r = mount_nofollow_verbose( LOG_ERR, /* what= */ NULL, w, /* fstype= */ NULL, MS_BIND|MS_REMOUNT|MS_RDONLY|MS_NODEV|MS_NOEXEC|MS_NOSUID|MS_NOSYMFOLLOW, /* options= */ NULL); if (r < 0) return r; *ret = TAKE_PTR(w); return 0; } static int setup_unix_export_host_inside(const char *directory, const char *unix_export_path) { int r; assert(directory); if (arg_userns_mode == USER_NAMESPACE_MANAGED) return 0; assert(unix_export_path); r = make_run_host(directory); if (r < 0) return r; _cleanup_free_ char *p = path_join(directory, "run/host/unix-export"); if (!p) return log_oom(); if (mkdir(p, 0755) < 0) return log_error_errno(errno, "Failed to create '%s': %m", p); r = mount_nofollow_verbose( LOG_ERR, unix_export_path, p, /* fstype= */ NULL, MS_BIND, /* options= */ NULL); if (r < 0) return r; r = mount_nofollow_verbose( LOG_ERR, /* what= */ NULL, p, /* fstype= */ NULL, MS_BIND|MS_REMOUNT|MS_NODEV|MS_NOEXEC|MS_NOSUID|MS_NOSYMFOLLOW, /* options= */ NULL); if (r < 0) return r; r = userns_lchown(p, 0, 0); if (r < 0) return log_error_errno(r, "Failed to chown '%s': %m", p); return 0; } static DissectImageFlags determine_dissect_image_flags(void) { return DISSECT_IMAGE_GENERIC_ROOT | DISSECT_IMAGE_REQUIRE_ROOT | DISSECT_IMAGE_RELAX_VAR_CHECK | DISSECT_IMAGE_USR_NO_ROOT | DISSECT_IMAGE_DISCARD_ON_LOOP | DISSECT_IMAGE_ADD_PARTITION_DEVICES | DISSECT_IMAGE_PIN_PARTITION_DEVICES | (arg_read_only ? DISSECT_IMAGE_READ_ONLY : DISSECT_IMAGE_FSCK|DISSECT_IMAGE_GROWFS) | DISSECT_IMAGE_ALLOW_USERSPACE_VERITY | DISSECT_IMAGE_VERITY_SHARE | (arg_console_mode == CONSOLE_INTERACTIVE && arg_ask_password ? DISSECT_IMAGE_ALLOW_INTERACTIVE_AUTH : 0) | ((arg_userns_ownership == USER_NAMESPACE_OWNERSHIP_FOREIGN) ? DISSECT_IMAGE_FOREIGN_UID : (arg_userns_ownership != USER_NAMESPACE_OWNERSHIP_AUTO) ? DISSECT_IMAGE_IDENTITY_UID : 0); } static int outer_child( Barrier *barrier, const char *directory, int mount_fd, DissectedImage *dissected_image, MStack *mstack, int fd_outer_socket, int fd_inner_socket, FDSet *fds, int netns_fd, const char *unix_export_path) { _cleanup_strv_free_ char **os_release_pairs = NULL; bool idmap = false; ssize_t l; int r; /* This is the "outer" child process, i.e the one forked off by the container manager itself. Its * namespace situation is: * * - CLONE_NEWUSER : if not in USER_NAMESPACE_MANAGED mode: still in the host's * if USER_NAMESPACE_MANAGED mode: already has its own (created by nsresource_allocate_userns()->setns(userns_fd)) * - CLONE_NEWNS : already has its own (created by clone() if not USER_NAMESPACE_MANAGED, or unshare() otherwise) * - CLONE_NEWPID : still in the host's * - CLONE_NEWUTS : still in the host's * - CLONE_NEWIPC : still in the host's * - CLONE_NEWNET : still in the host's * * After it completed a number of initializations a second child (the "inner" one) is forked off it, * and it exits. */ assert(barrier); assert(directory); assert(fd_outer_socket >= 0); assert(fd_inner_socket >= 0); log_debug("Outer child is initializing."); r = load_os_release_pairs_with_prefix("/", "container_host_", &os_release_pairs); if (r < 0) log_debug_errno(r, "Failed to read os-release from host for container, ignoring: %m"); if (prctl(PR_SET_PDEATHSIG, SIGKILL) < 0) return log_error_errno(errno, "PR_SET_PDEATHSIG failed: %m"); r = reset_audit_loginuid(); if (r < 0) return r; /* Mark everything as slave, so that we still receive mounts from the real root, but don't propagate * mounts to the real root. */ r = mount_follow_verbose(LOG_ERR, NULL, "/", NULL, MS_SLAVE|MS_REC, NULL); if (r < 0) return r; /* Put the root dir into the target directory now. One of three mechanisms is provided: either we * have a single mount fd (typically unprivileged --directory= mode) or we have a fully dissected * image (--image= mode), or we have a regular path. */ if (mount_fd >= 0) { assert(arg_directory); assert(!arg_image); assert(!arg_mstack); if (move_mount(mount_fd, "", AT_FDCWD, directory, MOVE_MOUNT_F_EMPTY_PATH) < 0) return log_error_errno(errno, "Failed to attach root directory: %m"); mount_fd = safe_close(mount_fd); log_debug("Successfully attached root directory to '%s'.", directory); } else if (dissected_image) { assert(!arg_directory); assert(arg_image); assert(!arg_mstack); /* If we are operating on a disk image, then mount its root directory now, but leave out the * rest. We can read the UID shift from it if we need to. Further down we'll mount the rest, * but then with the uid shift known. That way we can mount VFAT file systems shifted to the * right place right away. This makes sure ESP partitions and userns are compatible. */ r = dissected_image_mount_and_warn( dissected_image, directory, arg_uid_shift, arg_uid_range, /* userns_fd= */ -EBADF, determine_dissect_image_flags()| DISSECT_IMAGE_MOUNT_ROOT_ONLY| (arg_start_mode == START_BOOT ? DISSECT_IMAGE_VALIDATE_OS : 0)); if (r < 0) return r; } else if (arg_mstack) { assert(!arg_directory); assert(!arg_image); assert(arg_mstack); MStackFlags mstack_flags = arg_read_only ? MSTACK_RDONLY : 0; /* This creates the needed overlayfs or tmpfs, owned by our target userns. Note that we pass * the target mount dir as temporary mount dir here. We after all just need some dir here * that definitely exists, and the temporary mounts on it are not going to be visible * outside. */ r = mstack_make_mounts( mstack, /* temp_mount_dir= */ directory, /* !! */ mstack_flags); if (r < 0) return log_error_errno(r, "Failed to make .mstack/ mounts: %m"); /* And then attaches all mounts to the directory */ r = mstack_bind_mounts( mstack, directory, /* where_fd= */ -EBADF, mstack_flags, /* ret_root_fd= */ NULL); if (r < 0) return log_error_errno(r, "Failed bind mount .mstack/ mounts: %m"); } else { assert(arg_directory); assert(!arg_image); assert(!arg_mstack); r = mount_nofollow_verbose(LOG_ERR, arg_directory, directory, /* fstype= */ NULL, MS_BIND|MS_REC, /* options= */ NULL); if (r < 0) return r; } r = determine_uid_shift(directory); if (r < 0) return r; /* If we do userns on our own, we need to chown() all files ourselves before. Otherwise, if userns is * off or we are in managed mode we already have the userns applied, hence don't need to chown * anything */ uid_t chown_uid, chown_range; if (in_child_chown()) { chown_uid = arg_uid_shift; chown_range = arg_uid_range; } else { chown_uid = 0; chown_range = UINT32_C(0x10000); } if (arg_userns_mode != USER_NAMESPACE_NO) { _cleanup_close_ int mntns_fd = -EBADF; mntns_fd = namespace_open_by_type(NAMESPACE_MOUNT); if (mntns_fd < 0) return log_error_errno(mntns_fd, "Failed to pin outer mount namespace: %m"); l = send_one_fd(fd_outer_socket, mntns_fd, 0); if (l < 0) return log_error_errno(l, "Failed to send outer mount namespace fd: %m"); mntns_fd = safe_close(mntns_fd); /* Let the parent know which UID shift we read from the image */ l = send(fd_outer_socket, &arg_uid_shift, sizeof(arg_uid_shift), MSG_NOSIGNAL); if (l < 0) return log_error_errno(errno, "Failed to send UID shift: %m"); if (l != sizeof(arg_uid_shift)) return log_error_errno(SYNTHETIC_ERRNO(EIO), "Short write while sending UID shift."); if (arg_userns_mode == USER_NAMESPACE_PICK) { /* When we are supposed to pick the UID shift, the parent will check now whether the * UID shift we just read from the image is available. If yes, it will send the UID * shift back to us, if not it will pick a different one, and send it back to us. */ l = recv(fd_outer_socket, &arg_uid_shift, sizeof(arg_uid_shift), 0); if (l < 0) return log_error_errno(errno, "Failed to recv UID shift: %m"); if (l != sizeof(arg_uid_shift)) return log_error_errno(SYNTHETIC_ERRNO(EIO), "Short read while receiving UID shift."); if (in_child_chown()) chown_uid = arg_uid_shift; } log_full(arg_quiet ? LOG_DEBUG : LOG_INFO, "Selected user namespace base " UID_FMT " and range " UID_FMT ".", arg_uid_shift, arg_uid_range); } /* So the whole tree is now MS_SLAVE, i.e. we'll still receive mount/umount events from the host * mount namespace. For the directory we are going to run our container let's turn this off, so that * we'll live in our own little world from now on, and propagation from the host may only happen via * the mount tunnel dir, or not at all. */ r = mount_follow_verbose(LOG_ERR, NULL, directory, NULL, MS_PRIVATE|MS_REC, NULL); if (r < 0) return r; r = setup_pivot_root( directory, arg_pivot_root_new, arg_pivot_root_old); if (r < 0) return r; r = setup_volatile_mode( directory, arg_volatile_mode, chown_uid, arg_selinux_apifs_context); if (r < 0) return r; _cleanup_(machine_bind_user_context_freep) MachineBindUserContext *bind_user_context = NULL; r = machine_bind_user_prepare( directory, arg_bind_user, arg_bind_user_shell, arg_bind_user_shell_copy, "/run/host/home", arg_bind_user_groups, &bind_user_context); if (r < 0) return r; if (bind_user_context) FOREACH_ARRAY(bind_user, bind_user_context->data, bind_user_context->n_data) { _cleanup_free_ char *sm = strdup(user_record_home_directory(bind_user->host_user)); if (!sm) return log_oom(); _cleanup_free_ char *sd = strdup(user_record_home_directory(bind_user->payload_user)); if (!sd) return log_oom(); if (!GREEDY_REALLOC(arg_custom_mounts, arg_n_custom_mounts + 1)) return log_oom(); char *options = strdup("owneridmap"); if (!options) return log_oom(); arg_custom_mounts[arg_n_custom_mounts++] = (CustomMount) { .type = CUSTOM_MOUNT_BIND, .source = TAKE_PTR(sm), .destination = TAKE_PTR(sd), .options = TAKE_PTR(options), .destination_uid = bind_user->payload_user->uid, }; } r = mount_custom( directory, arg_custom_mounts, arg_n_custom_mounts, chown_uid, chown_range, arg_selinux_apifs_context, MOUNT_ROOT_ONLY); if (r < 0) return r; if (!IN_SET(arg_userns_mode, USER_NAMESPACE_NO, USER_NAMESPACE_MANAGED) && IN_SET(arg_userns_ownership, USER_NAMESPACE_OWNERSHIP_MAP, USER_NAMESPACE_OWNERSHIP_FOREIGN, USER_NAMESPACE_OWNERSHIP_AUTO) && chown_uid != 0) { _cleanup_strv_free_ char **dirs = NULL; RemountIdmapping mapping; switch (arg_userns_ownership) { case USER_NAMESPACE_OWNERSHIP_MAP: mapping = REMOUNT_IDMAPPING_HOST_ROOT; break; case USER_NAMESPACE_OWNERSHIP_FOREIGN: mapping = REMOUNT_IDMAPPING_FOREIGN_WITH_HOST_ROOT; break; case USER_NAMESPACE_OWNERSHIP_AUTO: { struct stat st; if (lstat(directory, &st) < 0) return log_error_errno(errno, "Failed to stat() container root directory '%s': %m", directory); r = stat_verify_directory(&st); if (r < 0) return log_error_errno(r, "Container root directory '%s' is not a directory: %m", directory); mapping = uid_is_foreign(st.st_uid) ? REMOUNT_IDMAPPING_FOREIGN_WITH_HOST_ROOT : REMOUNT_IDMAPPING_HOST_ROOT; break; } default: assert_not_reached(); } if (arg_volatile_mode != VOLATILE_YES) { r = strv_extend(&dirs, directory); if (r < 0) return log_oom(); } if ((dissected_image && dissected_image->partitions[PARTITION_USR].found) || arg_volatile_mode == VOLATILE_YES) { char *s = path_join(directory, "/usr"); if (!s) return log_oom(); r = strv_consume(&dirs, s); if (r < 0) return log_oom(); } r = remount_idmap( dirs, chown_uid, chown_range, /* source_owner= */ UID_INVALID, /* dest_owner= */ UID_INVALID, mapping); if (r == -EINVAL || ERRNO_IS_NEG_NOT_SUPPORTED(r)) { /* This might fail because the kernel or file system doesn't support idmapping. We * can't really distinguish this nicely, nor do we have any guarantees about the * error codes we see, could be EOPNOTSUPP or EINVAL. */ if (arg_userns_ownership != USER_NAMESPACE_OWNERSHIP_AUTO) return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "ID mapped mounts are apparently not available, sorry."); log_debug("ID mapped mounts are apparently not available on this kernel or for the selected file system, reverting to recursive chown()ing."); arg_userns_ownership = USER_NAMESPACE_OWNERSHIP_CHOWN; } else if (r < 0) return log_error_errno(r, "Failed to set up ID mapped mounts: %m"); else { log_debug("ID mapped mounts available, making use of them."); idmap = true; } } r = setup_volatile_mode_after_remount_idmap( directory, arg_volatile_mode, chown_uid, arg_selinux_apifs_context); if (r < 0) return r; if (dissected_image) { /* Now we know the uid shift, let's now mount everything else that might be in the image. */ r = dissected_image_mount_and_warn( dissected_image, directory, chown_uid, chown_range, /* userns_fd= */ -EBADF, determine_dissect_image_flags()| DISSECT_IMAGE_MOUNT_NON_ROOT_ONLY| (idmap ? DISSECT_IMAGE_MOUNT_IDMAPPED : 0)); if (r < 0) return r; } r = recursive_chown(directory, chown_uid, chown_range); if (r < 0) return r; r = base_filesystem_create(directory, chown_uid, (gid_t) chown_uid); if (r < 0) return r; if (arg_read_only && arg_volatile_mode == VOLATILE_NO && !has_custom_root_mount(arg_custom_mounts, arg_n_custom_mounts)) { r = bind_remount_recursive(directory, MS_RDONLY, MS_RDONLY, NULL); if (r < 0) return log_error_errno(r, "Failed to make tree read-only: %m"); } r = mount_all(directory, arg_mount_settings, chown_uid, arg_selinux_apifs_context); if (r < 0) return r; r = copy_devnodes(directory); if (r < 0) return r; r = make_extra_nodes(directory); if (r < 0) return r; (void) dev_setup(directory, chown_uid, chown_uid); _cleanup_free_ char *p = path_join(directory, "/run/host"); if (!p) return log_oom(); (void) make_inaccessible_nodes(p, chown_uid, chown_uid); r = setup_unix_export_host_inside(directory, unix_export_path); if (r < 0) return r; r = setup_pts(directory, chown_uid); if (r < 0) return r; r = mount_tunnel_dig(directory); if (r < 0) return r; r = setup_keyring(); if (r < 0) return r; r = setup_credentials(directory); if (r < 0) return r; r = bind_user_setup(bind_user_context, directory); if (r < 0) return r; r = mount_custom( directory, arg_custom_mounts, arg_n_custom_mounts, chown_uid, chown_range, arg_selinux_apifs_context, MOUNT_NON_ROOT_ONLY); if (r < 0) return r; r = setup_timezone(directory); if (r < 0) return r; r = setup_resolv_conf(directory); if (r < 0) return r; r = setup_machine_id(directory); if (r < 0) return r; r = setup_journal(directory, chown_uid, chown_range); if (r < 0) return r; r = setup_varlink_socket(directory, "io.systemd.NamespaceResource"); if (r < 0) return r; r = setup_varlink_socket(directory, "io.systemd.MountFileSystem"); if (r < 0) return r; /* The same stuff as the $container env var, but nicely readable for the entire payload */ free(p); p = path_join(directory, "/run/host/container-manager"); if (!p) return log_oom(); (void) write_string_file(p, arg_container_service_name, WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_MODE_0444); /* The same stuff as the $container_uuid env var */ free(p); p = path_join(directory, "/run/host/container-uuid"); if (!p) return log_oom(); (void) write_string_filef(p, WRITE_STRING_FILE_CREATE|WRITE_STRING_FILE_MODE_0444, SD_ID128_UUID_FORMAT_STR, SD_ID128_FORMAT_VAL(arg_uuid)); if (!arg_use_cgns) { r = mount_cgroups(directory, /* accept_existing= */ true); if (r < 0) return r; } /* We have different codepaths here for privileged and non-privileged mode. In privileged mode we'll * now switch into the target directory, and then do the final setup from there. If a user namespace * is then allocated for the container, the root mount and everything else will be out of reach for * it. For unprivileged containers we cannot do that however, since we couldn't mount a sysfs and * procfs then anymore, since that only works if there's an unobstructed instance currently * visible. Hence there we do it the other way round: we first allocate a new set of namespaces * (and fork for it) for which we then mount sysfs/procfs, and only then switch root. */ _cleanup_close_ int notify_fd = -EBADF; if (arg_userns_mode != USER_NAMESPACE_MANAGED) { /* Mark everything as shared so our mounts get propagated down. This is required to make new * bind mounts available in systemd services inside the container that create a new mount * namespace. See https://github.com/systemd/systemd/issues/3860 Further submounts (such as * /dev/) done after this will inherit the shared propagation mode. * * IMPORTANT: Do not overmount the root directory anymore from now on to enable moving the root * directory mount to root later on. * https://github.com/systemd/systemd/issues/3847#issuecomment-562735251 */ r = mount_switch_root(directory, MS_SHARED); if (r < 0) return log_error_errno(r, "Failed to move root directory: %m"); /* We finished setting up the rootfs which is a shared mount. The mount tunnel needs to be a * dependent mount otherwise we can't MS_MOVE mounts that were propagated from the host into * the container. */ r = mount_tunnel_open(); if (r < 0) return r; if (arg_userns_mode != USER_NAMESPACE_NO) { /* In order to mount procfs and sysfs in an unprivileged container the kernel * requires that a fully visible instance is already present in the target mount * namespace. Mount one here so the inner child can mount its own instances. Later * we umount the temporary instances created here before we actually exec the * payload. Since the rootfs is shared the umount will propagate into the container. * Note, the inner child wouldn't be able to unmount the instances on its own since * it doesn't own the originating mount namespace. IOW, the outer child needs to do * this. */ r = pin_fully_visible_api_fs(); if (r < 0) return r; } notify_fd = setup_notify_child(NULL); } else notify_fd = setup_notify_child(directory); if (notify_fd < 0) return notify_fd; pid_t pid = raw_clone(SIGCHLD|CLONE_NEWNS| arg_clone_ns_flags | (IN_SET(arg_userns_mode, USER_NAMESPACE_FIXED, USER_NAMESPACE_PICK) ? CLONE_NEWUSER : 0) | ((arg_private_network && arg_userns_mode == USER_NAMESPACE_MANAGED) ? CLONE_NEWNET : 0)); if (pid < 0) return log_error_errno(errno, "Failed to fork inner child: %m"); if (pid == 0) { fd_outer_socket = safe_close(fd_outer_socket); /* In the child refuse dlopen(), so that we never mix shared libraries from payload and parent */ block_dlopen(); /* The inner child has all namespaces that are requested, so that we all are owned by the * user if user namespaces are turned on. */ if (arg_network_namespace_path && setns(netns_fd, CLONE_NEWNET) < 0) return log_error_errno(errno, "Failed to join network namespace: %m"); if (arg_userns_mode == USER_NAMESPACE_MANAGED) { /* In managed usernamespace operation, sysfs + procfs are special, we'll have to * mount them inside the inner namespaces, but before we switch root. Hence do so * here. */ _cleanup_free_ char *j = path_join(directory, "/proc"); if (!j) return log_oom(); r = mount_follow_verbose(LOG_ERR, "proc", j, "proc", MS_NOSUID|MS_NOEXEC|MS_NODEV, NULL); if (r < 0) return r; r = mount_sysfs(directory, arg_mount_settings); if (r < 0) return r; r = mount_switch_root(directory, MS_SHARED); if (r < 0) return log_error_errno(r, "Failed to move root directory: %m"); } r = inner_child(barrier, fd_inner_socket, fds, os_release_pairs); if (r < 0) _exit(EXIT_FAILURE); _exit(EXIT_SUCCESS); } l = send(fd_outer_socket, &pid, sizeof(pid), MSG_NOSIGNAL); if (l < 0) return log_error_errno(errno, "Failed to send PID: %m"); if (l != sizeof(pid)) return log_error_errno(SYNTHETIC_ERRNO(EIO), "Short write while sending PID."); l = send(fd_outer_socket, &arg_uuid, sizeof(arg_uuid), MSG_NOSIGNAL); if (l < 0) return log_error_errno(errno, "Failed to send machine ID: %m"); if (l != sizeof(arg_uuid)) return log_error_errno(SYNTHETIC_ERRNO(EIO), "Short write while sending machine ID."); l = send_one_fd(fd_outer_socket, notify_fd, 0); if (l < 0) return log_error_errno(l, "Failed to send notify fd: %m"); fd_outer_socket = safe_close(fd_outer_socket); fd_inner_socket = safe_close(fd_inner_socket); netns_fd = safe_close(netns_fd); return 0; } static int uid_shift_pick(uid_t *shift, LockFile *ret_lock_file) { bool tried_hashed = false; unsigned n_tries = 100; uid_t candidate; int r; assert(shift); assert(ret_lock_file); assert(arg_userns_mode == USER_NAMESPACE_PICK); assert(arg_uid_range == 0x10000U); candidate = *shift; (void) mkdir("/run/systemd/nspawn-uid", 0755); for (;;) { char lock_path[STRLEN("/run/systemd/nspawn-uid/") + DECIMAL_STR_MAX(uid_t) + 1]; _cleanup_(release_lock_file) LockFile lf = LOCK_FILE_INIT; if (--n_tries <= 0) return -EBUSY; if (candidate < CONTAINER_UID_BASE_MIN || candidate > CONTAINER_UID_BASE_MAX) goto next; if ((candidate & UINT32_C(0xFFFF)) != 0) goto next; xsprintf(lock_path, "/run/systemd/nspawn-uid/" UID_FMT, candidate); r = make_lock_file(lock_path, LOCK_EX|LOCK_NB, &lf); if (r == -EBUSY) /* Range already taken by another nspawn instance */ goto next; if (r < 0) return r; /* Make some superficial checks whether the range is currently known in the user database */ if (getpwuid_malloc(candidate, /* ret= */ NULL) >= 0) goto next; if (getpwuid_malloc(candidate + UINT32_C(0xFFFE), /* ret= */ NULL) >= 0) goto next; if (getgrgid_malloc(candidate, /* ret= */ NULL) >= 0) goto next; if (getgrgid_malloc(candidate + UINT32_C(0xFFFE), /* ret= */ NULL) >= 0) goto next; *ret_lock_file = lf; lf = (struct LockFile) LOCK_FILE_INIT; *shift = candidate; return 0; next: if (arg_machine && !tried_hashed) { /* Try to hash the base from the container name */ static const uint8_t hash_key[] = { 0xe1, 0x56, 0xe0, 0xf0, 0x4a, 0xf0, 0x41, 0xaf, 0x96, 0x41, 0xcf, 0x41, 0x33, 0x94, 0xff, 0x72 }; candidate = (uid_t) siphash24(arg_machine, strlen(arg_machine), hash_key); tried_hashed = true; } else random_bytes(&candidate, sizeof(candidate)); candidate = (candidate % (CONTAINER_UID_BASE_MAX - CONTAINER_UID_BASE_MIN)) + CONTAINER_UID_BASE_MIN; candidate &= (uid_t) UINT32_C(0xFFFF0000); } } static int setup_uid_map( const PidRef *pid, const uid_t bind_user_uid[], size_t n_bind_user_uid) { char uid_map[STRLEN("/proc//uid_map") + DECIMAL_STR_MAX(uid_t) + 1]; _cleanup_free_ char *s = NULL; int r; assert(pidref_is_set(pid)); assert(pid->pid > 1); if (asprintf(&s, "0 " UID_FMT " " UID_FMT "\n", arg_uid_shift, arg_uid_range) < 0) return log_oom(); xsprintf(uid_map, "/proc/" PID_FMT "/uid_map", pid->pid); r = write_string_file(uid_map, s, WRITE_STRING_FILE_DISABLE_BUFFER); if (r < 0) return log_error_errno(r, "Failed to write UID map: %m"); xsprintf(uid_map, "/proc/" PID_FMT "/gid_map", pid->pid); r = write_string_file(uid_map, s, WRITE_STRING_FILE_DISABLE_BUFFER); if (r < 0) return log_error_errno(r, "Failed to write GID map: %m"); return 0; } static int nspawn_dispatch_notify_fd(sd_event_source *source, int fd, uint32_t revents, void *userdata) { PidRef *inner_child_pid = ASSERT_PTR(userdata); int r; assert(userdata); _cleanup_(pidref_done) PidRef sender_pid = PIDREF_NULL; _cleanup_strv_free_ char **tags = NULL; r = notify_recv_strv(fd, &tags, /* ret_ucred= */ NULL, &sender_pid); if (r == -EAGAIN) return 0; if (r < 0) return r; if (!pidref_equal(&sender_pid, inner_child_pid)) { log_debug("Received notify message from process that is not the payload's PID 1. Ignoring."); return 0; } if (DEBUG_LOGGING) { _cleanup_free_ char *joined = strv_join(tags, " "); if (joined) { _cleanup_free_ char *j = cescape(joined); free_and_replace(joined, j); } log_debug("Got sd_notify() message: %s", strnull(joined)); } char *status = strv_find_startswith(tags, "STATUS="); if (status) (void) sd_notifyf(/* unset_environment= */ false, "STATUS=Container running: %s", status); if (strv_contains(tags, "READY=1")) { r = sd_notify(/* unset_environment= */ false, "READY=1\n"); if (r < 0) log_warning_errno(r, "Failed to send readiness notification, ignoring: %m"); if (!status) (void) sd_notifyf(/* unset_environment= */ false, "STATUS=Container running."); } return 0; } static int setup_notify_parent(sd_event *event, int fd, PidRef *inner_child_pid, sd_event_source **notify_event_source) { int r; if (fd < 0) return 0; r = sd_event_add_io(event, notify_event_source, fd, EPOLLIN, nspawn_dispatch_notify_fd, inner_child_pid); if (r < 0) return log_error_errno(r, "Failed to allocate notify event source: %m"); (void) sd_event_source_set_description(*notify_event_source, "nspawn-notify"); return 0; } static int ptyfwd_hotkey(PTYForward *f, char c, void *userdata) { PidRef *pid = ASSERT_PTR(userdata); const char *word; int sig = 0, r; assert(f); switch (c) { case 'p': sig = SIGRTMIN+4; word = "power off"; break; case 'r': sig = SIGRTMIN+5; word = "reboot"; break; default: log_info("Unknown hotkey sequence ^]^]%c, ignoring.", c); return 0; } r = pidref_kill(pid, sig); if (r < 0) log_error_errno(r, "Failed to send %s (%s request) to PID 1 of container: %m", signal_to_string(sig), word); else log_info("Sent %s (%s request) to PID 1 of container.", signal_to_string(sig), word); return 0; } static int merge_settings(Settings *settings, const char *path) { int rl; assert(settings); assert(path); /* Copy over bits from the settings, unless they have been explicitly masked by command line switches. Note * that this steals the fields of the Settings* structure, and hence modifies it. */ if ((arg_settings_mask & SETTING_START_MODE) == 0 && settings->start_mode >= 0) { arg_start_mode = settings->start_mode; strv_free_and_replace(arg_parameters, settings->parameters); } if ((arg_settings_mask & SETTING_EPHEMERAL) == 0 && settings->ephemeral >= 0) { if (!arg_settings_trusted) log_warning("Ignoring ephemeral setting, file %s is not trusted.", path); else arg_ephemeral = settings->ephemeral; } if ((arg_settings_mask & SETTING_DIRECTORY) == 0 && settings->root) { if (!arg_settings_trusted) log_warning("Ignoring root directory setting, file %s is not trusted.", path); else free_and_replace(arg_directory, settings->root); } if ((arg_settings_mask & SETTING_PIVOT_ROOT) == 0 && settings->pivot_root_new) { free_and_replace(arg_pivot_root_new, settings->pivot_root_new); free_and_replace(arg_pivot_root_old, settings->pivot_root_old); } if ((arg_settings_mask & SETTING_WORKING_DIRECTORY) == 0 && settings->working_directory) free_and_replace(arg_chdir, settings->working_directory); if ((arg_settings_mask & SETTING_ENVIRONMENT) == 0 && settings->environment) strv_free_and_replace(arg_setenv, settings->environment); if ((arg_settings_mask & SETTING_USER) == 0) { if (settings->user) free_and_replace(arg_user, settings->user); if (uid_is_valid(settings->uid)) arg_uid = settings->uid; if (gid_is_valid(settings->gid)) arg_gid = settings->gid; if (settings->n_supplementary_gids > 0) { free_and_replace(arg_supplementary_gids, settings->supplementary_gids); arg_n_supplementary_gids = settings->n_supplementary_gids; } } if ((arg_settings_mask & SETTING_CAPABILITY) == 0) { uint64_t plus, minus; uint64_t network_minus = 0; uint64_t ambient; /* Note that we copy both the simple plus/minus caps here, and the full quintet from the * Settings structure */ plus = settings->capability; minus = settings->drop_capability; if ((arg_settings_mask & SETTING_NETWORK) == 0 && settings_network_configured(settings)) { if (settings_private_network(settings)) plus |= UINT64_C(1) << CAP_NET_ADMIN; else network_minus |= UINT64_C(1) << CAP_NET_ADMIN; } if (!arg_settings_trusted && plus != 0) { if (settings->capability != 0) log_warning("Ignoring Capability= setting, file %s is not trusted.", path); } else { arg_caps_retain &= ~network_minus; arg_caps_retain |= plus; } arg_caps_retain &= ~minus; /* Copy the full capabilities over too */ if (capability_quintet_is_set(&settings->full_capabilities)) { if (!arg_settings_trusted) log_warning("Ignoring capability settings, file %s is not trusted.", path); else arg_full_capabilities = settings->full_capabilities; } ambient = settings->ambient_capability; if (!arg_settings_trusted && ambient != 0) log_warning("Ignoring AmbientCapability= setting, file %s is not trusted.", path); else arg_caps_ambient |= ambient; } if ((arg_settings_mask & SETTING_KILL_SIGNAL) == 0 && settings->kill_signal > 0) arg_kill_signal = settings->kill_signal; if ((arg_settings_mask & SETTING_PERSONALITY) == 0 && settings->personality != PERSONALITY_INVALID) arg_personality = settings->personality; if ((arg_settings_mask & SETTING_MACHINE_ID) == 0 && !sd_id128_is_null(settings->machine_id)) { if (!arg_settings_trusted) log_warning("Ignoring MachineID= setting, file %s is not trusted.", path); else arg_uuid = settings->machine_id; } if ((arg_settings_mask & SETTING_READ_ONLY) == 0 && settings->read_only >= 0) arg_read_only = settings->read_only; if ((arg_settings_mask & SETTING_VOLATILE_MODE) == 0 && settings->volatile_mode != _VOLATILE_MODE_INVALID) arg_volatile_mode = settings->volatile_mode; if ((arg_settings_mask & SETTING_CUSTOM_MOUNTS) == 0 && settings->n_custom_mounts > 0) { if (!arg_settings_trusted) log_warning("Ignoring TemporaryFileSystem=, Bind= and BindReadOnly= settings, file %s is not trusted.", path); else { custom_mount_free_all(arg_custom_mounts, arg_n_custom_mounts); arg_custom_mounts = TAKE_PTR(settings->custom_mounts); arg_n_custom_mounts = settings->n_custom_mounts; settings->n_custom_mounts = 0; } } if ((arg_settings_mask & SETTING_NETWORK) == 0 && settings_network_configured(settings)) { if (!arg_settings_trusted) log_warning("Ignoring network settings, file %s is not trusted.", path); else { arg_network_veth = settings_network_veth(settings); arg_private_network = settings_private_network(settings); strv_free_and_replace(arg_network_interfaces, settings->network_interfaces); strv_free_and_replace(arg_network_macvlan, settings->network_macvlan); strv_free_and_replace(arg_network_ipvlan, settings->network_ipvlan); strv_free_and_replace(arg_network_veth_extra, settings->network_veth_extra); free_and_replace(arg_network_bridge, settings->network_bridge); free_and_replace(arg_network_zone, settings->network_zone); free_and_replace(arg_network_namespace_path, settings->network_namespace_path); } } if ((arg_settings_mask & SETTING_EXPOSE_PORTS) == 0 && settings->expose_ports) { if (!arg_settings_trusted) log_warning("Ignoring Port= setting, file %s is not trusted.", path); else { expose_port_free_all(arg_expose_ports); arg_expose_ports = TAKE_PTR(settings->expose_ports); } } if ((arg_settings_mask & SETTING_USERNS) == 0 && settings->userns_mode != _USER_NAMESPACE_MODE_INVALID) { if (!arg_settings_trusted) log_warning("Ignoring PrivateUsers= and PrivateUsersChown= settings, file %s is not trusted.", path); else { arg_userns_mode = settings->userns_mode; arg_uid_shift = settings->uid_shift; arg_uid_range = settings->uid_range; arg_userns_ownership = settings->userns_ownership; arg_delegate_container_ranges = settings->delegate_container_ranges; } } if ((arg_settings_mask & SETTING_BIND_USER) == 0 && !strv_isempty(settings->bind_user)) { if (!arg_settings_trusted) log_warning("Ignoring bind user setting, file %s is not trusted.", path); else strv_free_and_replace(arg_bind_user, settings->bind_user); } if (!FLAGS_SET(arg_settings_mask, SETTING_BIND_USER_SHELL) && settings->bind_user_shell_set) { free_and_replace(arg_bind_user_shell, settings->bind_user_shell); arg_bind_user_shell_copy = settings->bind_user_shell_copy; } if ((arg_settings_mask & SETTING_NOTIFY_READY) == 0 && settings->notify_ready >= 0) arg_notify_ready = settings->notify_ready; if ((arg_settings_mask & SETTING_SYSCALL_FILTER) == 0) { if (!strv_isempty(settings->syscall_allow_list) || !strv_isempty(settings->syscall_deny_list)) { if (!arg_settings_trusted && !strv_isempty(settings->syscall_allow_list)) log_warning("Ignoring SystemCallFilter= settings, file %s is not trusted.", path); else { strv_free_and_replace(arg_syscall_allow_list, settings->syscall_allow_list); strv_free_and_replace(arg_syscall_deny_list, settings->syscall_deny_list); } } #if HAVE_SECCOMP if (settings->seccomp) { if (!arg_settings_trusted) log_warning("Ignoring SECCOMP filter, file %s is not trusted.", path); else { sym_seccomp_release(arg_seccomp); arg_seccomp = TAKE_PTR(settings->seccomp); } } #endif } for (rl = 0; rl < _RLIMIT_MAX; rl++) { if ((arg_settings_mask & (SETTING_RLIMIT_FIRST << rl))) continue; if (!settings->rlimit[rl]) continue; if (!arg_settings_trusted) { log_warning("Ignoring Limit%s= setting, file '%s' is not trusted.", rlimit_to_string(rl), path); continue; } free_and_replace(arg_rlimit[rl], settings->rlimit[rl]); } if ((arg_settings_mask & SETTING_HOSTNAME) == 0 && settings->hostname) free_and_replace(arg_hostname, settings->hostname); if ((arg_settings_mask & SETTING_NO_NEW_PRIVILEGES) == 0 && settings->no_new_privileges >= 0) arg_no_new_privileges = settings->no_new_privileges; if ((arg_settings_mask & SETTING_OOM_SCORE_ADJUST) == 0 && settings->oom_score_adjust_set) { if (!arg_settings_trusted) log_warning("Ignoring OOMScoreAdjust= setting, file '%s' is not trusted.", path); else { arg_oom_score_adjust = settings->oom_score_adjust; arg_oom_score_adjust_set = true; } } if ((arg_settings_mask & SETTING_CPU_AFFINITY) == 0 && settings->cpu_set.set) { if (!arg_settings_trusted) log_warning("Ignoring CPUAffinity= setting, file '%s' is not trusted.", path); else cpu_set_done_and_replace(arg_cpu_set, settings->cpu_set); } if ((arg_settings_mask & SETTING_RESOLV_CONF) == 0 && settings->resolv_conf != _RESOLV_CONF_MODE_INVALID) arg_resolv_conf = settings->resolv_conf; if ((arg_settings_mask & SETTING_LINK_JOURNAL) == 0 && settings->link_journal != _LINK_JOURNAL_INVALID) { if (!arg_settings_trusted) log_warning("Ignoring journal link setting, file '%s' is not trusted.", path); else { arg_link_journal = settings->link_journal; arg_link_journal_try = settings->link_journal_try; } } if ((arg_settings_mask & SETTING_TIMEZONE) == 0 && settings->timezone != _TIMEZONE_MODE_INVALID) arg_timezone = settings->timezone; if ((arg_settings_mask & SETTING_SLICE) == 0 && settings->slice) { if (!arg_settings_trusted) log_warning("Ignoring slice setting, file '%s' is not trusted.", path); else free_and_replace(arg_slice, settings->slice); } if ((arg_settings_mask & SETTING_USE_CGNS) == 0 && settings->use_cgns >= 0) { if (!arg_settings_trusted) log_warning("Ignoring cgroup namespace setting, file '%s' is not trusted.", path); else arg_use_cgns = settings->use_cgns; } if ((arg_settings_mask & SETTING_CLONE_NS_FLAGS) == 0 && settings->clone_ns_flags != ULONG_MAX) { if (!arg_settings_trusted) log_warning("Ignoring namespace setting, file '%s' is not trusted.", path); else arg_clone_ns_flags = settings->clone_ns_flags; } if ((arg_settings_mask & SETTING_CONSOLE_MODE) == 0 && settings->console_mode >= 0) { if (!arg_settings_trusted) log_warning("Ignoring console mode setting, file '%s' is not trusted.", path); else arg_console_mode = settings->console_mode; } if ((arg_settings_mask & SETTING_SUPPRESS_SYNC) == 0 && settings->suppress_sync >= 0) arg_suppress_sync = settings->suppress_sync; /* The following properties can only be set through the OCI settings logic, not from the command line, hence we * don't consult arg_settings_mask for them. */ sd_bus_message_unref(arg_property_message); arg_property_message = TAKE_PTR(settings->properties); arg_console_width = settings->console_width; arg_console_height = settings->console_height; device_node_array_free(arg_extra_nodes, arg_n_extra_nodes); arg_extra_nodes = TAKE_PTR(settings->extra_nodes); arg_n_extra_nodes = settings->n_extra_nodes; settings->n_extra_nodes = 0; return 0; } static int load_settings(void) { _cleanup_(settings_freep) Settings *settings = NULL; _cleanup_fclose_ FILE *f = NULL; _cleanup_free_ char *p = NULL; int r; if (arg_oci_bundle) return 0; /* If all settings are masked, there's no point in looking for * the settings file */ if (FLAGS_SET(arg_settings_mask, _SETTINGS_MASK_ALL)) return 0; /* We first look in the admin's directories in /etc/ and /run/ */ static const uint64_t lookup_dir_system[] = { SD_PATH_SYSTEM_CONFIGURATION, SD_PATH_SYSTEM_RUNTIME, _SD_PATH_INVALID, }; static const uint64_t lookup_dir_user[] = { SD_PATH_USER_CONFIGURATION, SD_PATH_USER_RUNTIME, _SD_PATH_INVALID, }; const uint64_t *q = arg_privileged ? lookup_dir_system : lookup_dir_user; for (; *q != _SD_PATH_INVALID; q++) { _cleanup_free_ char *cd = NULL; r = sd_path_lookup(*q, "systemd/nspawn", &cd); if (r < 0) { log_warning_errno(r, "Failed to determine settings directory, ignoring: %m"); continue; } _cleanup_free_ char *j = NULL; j = path_join(cd, arg_settings_filename); if (!j) return log_oom(); f = fopen(j, "re"); if (f) { p = TAKE_PTR(j); log_debug("Found settings file: %s", p); /* By default, we trust configuration from /etc and /run */ if (arg_settings_trusted < 0) arg_settings_trusted = true; break; } if (errno != ENOENT) return log_error_errno(errno, "Failed to open %s: %m", j); } if (!f) { /* After that, let's look for a file next to the * actual image we shall boot. */ if (arg_image) { r = file_in_same_dir(arg_image, arg_settings_filename, &p); if (r < 0) return log_error_errno(r, "Failed to generate settings path from image path: %m"); } else if (arg_directory) { r = file_in_same_dir(arg_directory, arg_settings_filename, &p); if (r < 0 && r != -EADDRNOTAVAIL) /* if directory is root fs, don't complain */ return log_error_errno(r, "Failed to generate settings path from directory path: %m"); } else if (arg_mstack) { r = file_in_same_dir(arg_mstack, arg_settings_filename, &p); if (r < 0) return log_error_errno(r, "Failed to generate settings path from mstack path: %m"); } if (p) { f = fopen(p, "re"); if (!f && errno != ENOENT) return log_error_errno(errno, "Failed to open %s: %m", p); if (f) log_debug("Found settings file: %s", p); /* By default, we do not trust configuration from /var/lib/machines */ if (arg_settings_trusted < 0) arg_settings_trusted = false; } } if (!f) return 0; log_debug("Settings are trusted: %s", yes_no(arg_settings_trusted)); r = settings_load(f, p, &settings); if (r < 0) return r; return merge_settings(settings, p); } static int load_oci_bundle(void) { _cleanup_(settings_freep) Settings *settings = NULL; int r; if (!arg_oci_bundle) return 0; /* By default let's trust OCI bundles */ if (arg_settings_trusted < 0) arg_settings_trusted = true; r = oci_load(NULL, arg_oci_bundle, &settings); if (r < 0) return r; return merge_settings(settings, arg_oci_bundle); } static int run_container( const char *directory, int mount_fd, DissectedImage *dissected_image, MStack *mstack, int userns_fd, FDSet *fds, char veth_name[IFNAMSIZ], bool *veth_created, struct ExposeArgs *expose_args, int *master, PidRef *pid, int *ret) { _cleanup_(release_lock_file) LockFile uid_shift_lock = LOCK_FILE_INIT; _cleanup_close_ int etc_passwd_lock = -EBADF; _cleanup_close_pair_ int fd_inner_socket_pair[2] = EBADF_PAIR, fd_outer_socket_pair[2] = EBADF_PAIR; _cleanup_close_ int notify_socket = -EBADF, mntns_fd = -EBADF, fd_kmsg_fifo = -EBADF; _cleanup_(barrier_destroy) Barrier barrier = BARRIER_NULL; _cleanup_(sd_event_source_unrefp) sd_event_source *notify_event_source = NULL; _cleanup_(umount_and_rmdir_and_freep) char *unix_export_host_dir = NULL; _cleanup_(sd_event_unrefp) sd_event *event = NULL; _cleanup_(pty_forward_freep) PTYForward *forward = NULL; _cleanup_(sd_netlink_unrefp) sd_netlink *rtnl = NULL; _cleanup_free_ uid_t *bind_user_uid = NULL; size_t n_bind_user_uid = 0; ContainerStatus container_status = 0; int ifi = 0, r; ssize_t l; sigset_t mask_chld; _cleanup_close_ int child_netns_fd = -EBADF; assert_se(sigemptyset(&mask_chld) == 0); assert_se(sigaddset(&mask_chld, SIGCHLD) == 0); /* Set up the unix export host directory on the host first */ r = setup_unix_export_dir_outside(&unix_export_host_dir); if (r < 0) return r; if (arg_userns_mode == USER_NAMESPACE_PICK) { /* When we shall pick the UID/GID range, let's first lock /etc/passwd, so that we can safely * check with getpwuid() if the specific user already exists. Note that /etc might be * read-only, in which case this will fail with EROFS. But that's really OK, as in that case we * can be reasonably sure that no users are going to be added. Note that getpwuid() checks are * really just an extra safety net. We kinda assume that the UID range we allocate from is * really ours. */ etc_passwd_lock = take_etc_passwd_lock(NULL); if (etc_passwd_lock < 0 && etc_passwd_lock != -EROFS) return log_error_errno(etc_passwd_lock, "Failed to take /etc/passwd lock: %m"); } r = barrier_create(&barrier); if (r < 0) return log_error_errno(r, "Cannot initialize IPC barrier: %m"); if (socketpair(AF_UNIX, SOCK_SEQPACKET|SOCK_CLOEXEC, 0, fd_inner_socket_pair) < 0) return log_error_errno(errno, "Failed to create inner socket pair: %m"); if (socketpair(AF_UNIX, SOCK_SEQPACKET|SOCK_CLOEXEC, 0, fd_outer_socket_pair) < 0) return log_error_errno(errno, "Failed to create outer socket pair: %m"); /* Child can be killed before execv(), so handle SIGCHLD in order to interrupt * parent's blocking calls and give it a chance to call wait() and terminate. */ r = sigprocmask(SIG_UNBLOCK, &mask_chld, NULL); if (r < 0) return log_error_errno(errno, "Failed to change the signal mask: %m"); r = sigaction(SIGCHLD, &sigaction_nop_nocldstop, NULL); if (r < 0) return log_error_errno(errno, "Failed to install SIGCHLD handler: %m"); if (arg_network_namespace_path) { child_netns_fd = open(arg_network_namespace_path, O_RDONLY|O_NOCTTY|O_CLOEXEC); if (child_netns_fd < 0) return log_error_errno(errno, "Cannot open file %s: %m", arg_network_namespace_path); r = fd_is_namespace(child_netns_fd, NAMESPACE_NET); if (r < 0) return log_error_errno(r, "Failed to check %s fs type: %m", arg_network_namespace_path); if (r == 0) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Path %s doesn't refer to a network namespace, refusing.", arg_network_namespace_path); } bool in_child; if (arg_userns_mode != USER_NAMESPACE_MANAGED) { assert(userns_fd < 0); /* If we have no user namespace then we'll clone and create a new mount namespace right-away. */ pid_t _pid = raw_clone(SIGCHLD|CLONE_NEWNS); if (_pid < 0) return log_error_errno(errno, "clone() failed%s: %m", errno == EINVAL ? ", do you have namespace support enabled in your kernel? (You need UTS, IPC, PID and NET namespacing built in)" : ""); if (_pid != 0) { r = pidref_set_pid(pid, _pid); if (r < 0) return log_error_errno(r, "Failed to allocate pidfd: %m"); } in_child = _pid == 0; } else { assert(userns_fd >= 0); /* If we have a user namespace then we'll clone() first, and then join the user namespace, * and then open the mount namespace, so that it is owned by the user namespace */ pid_t _pid = raw_clone(SIGCHLD); if (_pid < 0) return log_error_errno(errno, "clone() failed: %m"); if (_pid != 0) { r = pidref_set_pid(pid, _pid); if (r < 0) return log_error_errno(r, "Failed to allocate pidfd: %m"); } in_child = _pid == 0; if (in_child) { if (setns(userns_fd, CLONE_NEWUSER) < 0) { log_error_errno(errno, "Failed to join allocate user namespace: %m"); _exit(EXIT_FAILURE); } r = reset_uid_gid(); if (r < 0) { log_error_errno(r, "Failed to reset UID/GID to root: %m"); _exit(EXIT_FAILURE); } if (unshare(CLONE_NEWNS) < 0) { log_error_errno(errno, "Failed to unshare file system namespace: %m"); _exit(EXIT_FAILURE); } } } if (in_child) { /* The outer child only has a file system namespace. */ barrier_set_role(&barrier, BARRIER_CHILD); fd_inner_socket_pair[0] = safe_close(fd_inner_socket_pair[0]); fd_outer_socket_pair[0] = safe_close(fd_outer_socket_pair[0]); (void) reset_all_signal_handlers(); (void) reset_signal_mask(); r = outer_child(&barrier, directory, mount_fd, dissected_image, mstack, fd_outer_socket_pair[1], fd_inner_socket_pair[1], fds, child_netns_fd, unix_export_host_dir); if (r < 0) _exit(EXIT_FAILURE); _exit(EXIT_SUCCESS); } barrier_set_role(&barrier, BARRIER_PARENT); fdset_close(fds, /* async= */ false); fd_inner_socket_pair[1] = safe_close(fd_inner_socket_pair[1]); fd_outer_socket_pair[1] = safe_close(fd_outer_socket_pair[1]); if (arg_userns_mode != USER_NAMESPACE_NO) { mntns_fd = receive_one_fd(fd_outer_socket_pair[0], 0); if (mntns_fd < 0) return log_error_errno(mntns_fd, "Failed to receive mount namespace fd from outer child: %m"); /* The child just let us know the UID shift it might have read from the image. */ l = recv(fd_outer_socket_pair[0], &arg_uid_shift, sizeof arg_uid_shift, 0); if (l < 0) return log_error_errno(errno, "Failed to read UID shift: %m"); if (l != sizeof arg_uid_shift) return log_error_errno(SYNTHETIC_ERRNO(EIO), "Short read while reading UID shift."); if (arg_userns_mode == USER_NAMESPACE_PICK) { /* If we are supposed to pick the UID shift, let's try to use the shift read from the * image, but if that's already in use, pick a new one, and report back to the child, * which one we now picked. */ r = uid_shift_pick(&arg_uid_shift, &uid_shift_lock); if (r < 0) return log_error_errno(r, "Failed to pick suitable UID/GID range: %m"); l = send(fd_outer_socket_pair[0], &arg_uid_shift, sizeof arg_uid_shift, MSG_NOSIGNAL); if (l < 0) return log_error_errno(errno, "Failed to send UID shift: %m"); if (l != sizeof arg_uid_shift) return log_error_errno(SYNTHETIC_ERRNO(EIO), "Short write while writing UID shift."); } } /* Wait for the outer child. */ r = pidref_wait_for_terminate_and_check("(sd-namespace)", pid, WAIT_LOG_ABNORMAL); if (r < 0) return r; pidref_done(pid); if (r != EXIT_SUCCESS) return -EIO; /* And now retrieve the PID of the inner child. */ pid_t _pid; l = recv(fd_outer_socket_pair[0], &_pid, sizeof _pid, 0); if (l < 0) return log_error_errno(errno, "Failed to read inner child PID: %m"); if (l != sizeof _pid) return log_error_errno(SYNTHETIC_ERRNO(EIO), "Short read while reading inner child PID."); r = pidref_set_pid(pid, _pid); if (r < 0) return log_error_errno(r, "Failed to allocate pidfd: %m"); /* We also retrieve container UUID in case it was generated by outer child */ l = recv(fd_outer_socket_pair[0], &arg_uuid, sizeof arg_uuid, 0); if (l < 0) return log_error_errno(errno, "Failed to read container machine ID: %m"); if (l != sizeof(arg_uuid)) return log_error_errno(SYNTHETIC_ERRNO(EIO), "Short read while reading container machined ID."); /* We also retrieve the socket used for notifications generated by outer child */ notify_socket = receive_one_fd(fd_outer_socket_pair[0], 0); if (notify_socket < 0) return log_error_errno(notify_socket, "Failed to receive notification socket from the outer child: %m"); log_debug("Init process invoked as PID "PID_FMT, pid->pid); if (arg_userns_mode != USER_NAMESPACE_NO) { if (!barrier_place_and_sync(&barrier)) /* #1 */ return log_error_errno(SYNTHETIC_ERRNO(ESRCH), "Child died too early."); if (arg_userns_mode != USER_NAMESPACE_MANAGED) { r = setup_uid_map(pid, bind_user_uid, n_bind_user_uid); if (r < 0) return r; } (void) barrier_place(&barrier); /* #2 */ } if (arg_private_network) { if (!arg_network_namespace_path) { /* Wait until the child has unshared its network namespace. */ if (!barrier_place_and_sync(&barrier)) /* #3 */ return log_error_errno(SYNTHETIC_ERRNO(ESRCH), "Child died too early"); /* Make sure we have an open file descriptor to the child's network namespace so it * stays alive even if the child exits. */ assert(child_netns_fd < 0); child_netns_fd = receive_one_fd(fd_inner_socket_pair[0], 0); if (child_netns_fd < 0) return log_error_errno(r, "Failed to receive child network namespace: %m"); } r = move_network_interfaces(child_netns_fd, arg_network_interfaces); if (r < 0) return r; if (arg_network_veth) { if (arg_userns_mode != USER_NAMESPACE_MANAGED) { r = setup_veth(arg_machine, pid, veth_name, arg_network_bridge || arg_network_zone, &arg_network_provided_mac); if (r < 0) return r; else if (r > 0) ifi = r; } else { _cleanup_free_ char *host_ifname = NULL; r = nsresource_add_netif_veth( /* vl= */ NULL, userns_fd, child_netns_fd, /* namespace_ifname= */ NULL, &host_ifname, /* ret_namespace_ifname= */ NULL); if (r < 0) return log_error_errno(r, "Failed to add network interface to container: %m"); ifi = if_nametoindex(host_ifname); if (ifi == 0) return log_error_errno(errno, "Failed to resolve interface '%s': %m", host_ifname); if (strlen(host_ifname) >= IFNAMSIZ) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Host interface name too long?"); strcpy(veth_name, host_ifname); } if (arg_network_bridge) { /* Add the interface to a bridge */ r = setup_bridge(veth_name, arg_network_bridge, false); if (r < 0) return r; if (r > 0) ifi = r; } else if (arg_network_zone) { /* Add the interface to a bridge, possibly creating it */ r = setup_bridge(veth_name, arg_network_zone, true); if (r < 0) return r; if (r > 0) ifi = r; } } r = setup_veth_extra(arg_machine, pid, arg_network_veth_extra); if (r < 0) return r; /* We created the primary and extra veth links now; let's remember this, so that we know to remove them later on. Note that we don't bother with removing veth links that were created here when their setup failed half-way, because in that case the kernel should be able to remove them on its own, since they cannot be referenced by anything yet. */ *veth_created = true; r = setup_macvlan(arg_machine, pid, arg_network_macvlan); if (r < 0) return r; r = setup_ipvlan(arg_machine, pid, arg_network_ipvlan); if (r < 0) return r; } /* Registration always happens on the system bus */ _cleanup_(sd_bus_flush_close_unrefp) sd_bus *system_bus = NULL; if (arg_register || (arg_privileged && !arg_keep_unit)) { r = sd_bus_default_system(&system_bus); if (r < 0) return log_error_errno(r, "Failed to open system bus: %m"); r = sd_bus_set_close_on_exit(system_bus, false); if (r < 0) return log_error_errno(r, "Failed to disable close-on-exit behaviour: %m"); (void) sd_bus_set_allow_interactive_authorization(system_bus, arg_ask_password); } _cleanup_(sd_bus_flush_close_unrefp) sd_bus *user_bus = NULL; _cleanup_(sd_bus_unrefp) sd_bus *runtime_bus = NULL; if (arg_register || !arg_keep_unit) { if (arg_privileged) runtime_bus = sd_bus_ref(system_bus); else { r = sd_bus_default_user(&user_bus); if (r < 0) return log_error_errno(r, "Failed to open user bus: %m"); r = sd_bus_set_close_on_exit(user_bus, false); if (r < 0) return log_error_errno(r, "Failed to disable close-on-exit behaviour: %m"); runtime_bus = sd_bus_ref(user_bus); } } /* Scope allocation happens on the user bus if we are unpriv, otherwise system bus. */ if (arg_keep_unit) { /* If we are not supposed to allocate a unit, then let's move the process now, so that we can * register things while being in the right cgroup location already. Otherwise, let's move * the process later, once we have unit and hence cgroup. */ r = create_subcgroup( pid, arg_keep_unit, arg_uid_shift, userns_fd, arg_userns_mode); if (r < 0) return r; } else { /* When a new scope is created for this container, then we'll be registered as its controller, in which * case PID 1 will send us a friendly RequestStop signal, when it is asked to terminate the * scope. Let's hook into that, and cleanly shut down the container, and print a friendly message. */ r = sd_bus_match_signal_async( runtime_bus, /* ret= */ NULL, "org.freedesktop.systemd1", /* path= */ NULL, "org.freedesktop.systemd1.Scope", "RequestStop", on_request_stop, /* install_callback= */ NULL, pid); if (r < 0) return log_error_errno(r, "Failed to request RequestStop match: %m"); } bool scope_allocated = false; if (!arg_keep_unit) { AllocateScopeFlags flags = ALLOCATE_SCOPE_ALLOW_PIDFD; r = allocate_scope( runtime_bus, arg_machine, pid, arg_slice, arg_custom_mounts, arg_n_custom_mounts, arg_kill_signal, arg_property, arg_property_message, arg_start_mode, flags); if (r < 0) return r; scope_allocated = true; } bool registered_system = false, registered_runtime = false; if (arg_register) { r = register_machine( system_bus, arg_machine, pid, arg_directory, arg_uuid, ifi, arg_container_service_name); if (r < 0) { if (arg_privileged) /* if privileged the request to register definitely failed */ return r; log_notice_errno(r, "Failed to register machine in system context, will try in user context."); } else registered_system = true; if (!arg_privileged) { r = register_machine( runtime_bus, arg_machine, pid, arg_directory, arg_uuid, ifi, arg_container_service_name); if (r < 0) { if (!registered_system) /* neither registration worked: fail */ return r; log_notice_errno(r, "Failed to register machine in user context, but succeeded in system context, will proceed."); } else registered_runtime = true; } } if (arg_keep_unit && (arg_slice || arg_property)) log_notice("Machine and scope registration turned off, --slice= and --property= settings will have no effect."); if (!arg_keep_unit) { r = create_subcgroup( pid, arg_keep_unit, arg_uid_shift, userns_fd, arg_userns_mode); if (r < 0) return r; } /* Notify the child that the parent is ready with all its setup (including cgroup-ification), and * that the child can now hand over control to the code to run inside the container. */ (void) barrier_place(&barrier); /* #4 */ /* Block SIGCHLD here, before notifying child. * process_pty() will handle it with the other signals. */ assert_se(sigprocmask(SIG_BLOCK, &mask_chld, NULL) >= 0); /* Reset signal to default */ r = default_signals(SIGCHLD); if (r < 0) return log_error_errno(r, "Failed to reset SIGCHLD: %m"); r = sd_event_new(&event); if (r < 0) return log_error_errno(r, "Failed to get default event source: %m"); (void) sd_event_set_watchdog(event, true); if (system_bus) { r = sd_bus_attach_event(system_bus, event, 0); if (r < 0) return log_error_errno(r, "Failed to attach system bus to event loop: %m"); } if (user_bus) { r = sd_bus_attach_event(user_bus, event, 0); if (r < 0) return log_error_errno(r, "Failed to attach user bus to event loop: %m"); } r = setup_notify_parent(event, notify_socket, pid, ¬ify_event_source); if (r < 0) return r; /* Wait that the child is completely ready now, and has mounted their own copies of procfs and so on, * before we take the fully visible instances away. */ if (!barrier_sync(&barrier)) /* #5.1 */ return log_error_errno(SYNTHETIC_ERRNO(ESRCH), "Child died too early."); if (!IN_SET(arg_userns_mode, USER_NAMESPACE_NO, USER_NAMESPACE_MANAGED)) { r = wipe_fully_visible_api_fs(mntns_fd); if (r < 0) return r; mntns_fd = safe_close(mntns_fd); } /* And now let the child know that we completed removing the procfs instances, and it can start the * payload. */ if (!barrier_place(&barrier)) /* #5.2 */ return log_error_errno(SYNTHETIC_ERRNO(ESRCH), "Child died too early."); /* At this point we have made use of the UID we picked, and thus nss-systemd/systemd-machined.service * will make them appear in getpwuid(), thus we can release the /etc/passwd lock. */ etc_passwd_lock = safe_close(etc_passwd_lock); (void) sd_notifyf(/* unset_environment= */ false, "STATUS=Container started.\n" "X_NSPAWN_LEADER_PID=" PID_FMT, pid->pid); if (!arg_notify_ready) { r = sd_notify(/* unset_environment= */ false, "READY=1\n"); if (r < 0) log_warning_errno(r, "Failed to send readiness notification, ignoring: %m"); } /* All operations that might need Polkit authorizations (i.e. userns registration, mounts, and * machine registration are complete now, get rid of the agent again, so that we retain exclusive * control of the TTY from now on. */ polkit_agent_close(); /* Note: we do not use SD_EVENT_SIGNAL_PROCMASK or sd_event_set_signal_exit(), since we want the * signals to be block continuously, even if we destroy the event loop and allocate a new one on * container reboot. */ if (arg_kill_signal > 0) { /* Try to kill the init system on SIGINT or SIGTERM */ (void) sd_event_add_signal(event, NULL, SIGINT, on_orderly_shutdown, pid); (void) sd_event_add_signal(event, NULL, SIGTERM, on_orderly_shutdown, pid); } else { /* Immediately exit */ (void) sd_event_add_signal(event, NULL, SIGINT, NULL, NULL); (void) sd_event_add_signal(event, NULL, SIGTERM, NULL, NULL); } (void) sd_event_add_signal(event, NULL, SIGRTMIN+18, sigrtmin18_handler, NULL); r = sd_event_add_memory_pressure(event, NULL, NULL, NULL); if (r < 0) log_debug_errno(r, "Failed to allocate memory pressure event source, ignoring: %m"); /* Exit when the child exits */ (void) sd_event_add_signal(event, NULL, SIGCHLD, on_sigchld, pid); /* Retrieve the kmsg fifo allocated by inner child */ fd_kmsg_fifo = receive_one_fd(fd_inner_socket_pair[0], 0); if (fd_kmsg_fifo < 0) return log_error_errno(fd_kmsg_fifo, "Failed to receive kmsg fifo from inner child: %m"); if (arg_expose_ports) { r = expose_port_watch_rtnl(event, fd_inner_socket_pair[0], on_address_change, expose_args, &rtnl); if (r < 0) return r; (void) expose_port_execute(rtnl, expose_args->nfnl, arg_expose_ports, AF_INET, &expose_args->address4); (void) expose_port_execute(rtnl, expose_args->nfnl, arg_expose_ports, AF_INET6, &expose_args->address6); } _cleanup_(osc_context_closep) sd_id128_t osc_context_id = SD_ID128_NULL; if (IN_SET(arg_console_mode, CONSOLE_INTERACTIVE, CONSOLE_READ_ONLY) && !terminal_is_dumb()) { r = osc_context_open_container(arg_machine, /* ret_seq= */ NULL, &osc_context_id); if (r < 0) return r; } if (arg_console_mode != CONSOLE_PIPE) { _cleanup_close_ int fd = -EBADF; PTYForwardFlags flags = 0; /* Retrieve the master pty allocated by inner child */ fd = receive_one_fd(fd_inner_socket_pair[0], 0); if (fd < 0) return log_error_errno(fd, "Failed to receive master pty from the inner child: %m"); switch (arg_console_mode) { case CONSOLE_READ_ONLY: flags |= PTY_FORWARD_READ_ONLY; _fallthrough_; case CONSOLE_INTERACTIVE: flags |= PTY_FORWARD_IGNORE_VHANGUP; r = pty_forward_new(event, fd, flags, &forward); if (r < 0) return log_error_errno(r, "Failed to create PTY forwarder: %m"); if (arg_console_width != UINT_MAX || arg_console_height != UINT_MAX) (void) pty_forward_set_width_height( forward, arg_console_width, arg_console_height); if (!arg_background) { _cleanup_free_ char *bg = NULL; r = terminal_tint_color(220 /* blue */, &bg); if (r < 0) log_debug_errno(r, "Failed to determine terminal background color, not tinting."); else (void) pty_forward_set_background_color(forward, bg); } else if (!isempty(arg_background)) (void) pty_forward_set_background_color(forward, arg_background); (void) pty_forward_set_window_title(forward, GLYPH_BLUE_CIRCLE, /* hostname= */ NULL, STRV_MAKE("Container", arg_machine)); pty_forward_set_hotkey_handler(forward, ptyfwd_hotkey, pid); break; default: assert(arg_console_mode == CONSOLE_PASSIVE); } *master = TAKE_FD(fd); } fd_inner_socket_pair[0] = safe_close(fd_inner_socket_pair[0]); r = sd_event_loop(event); if (r < 0) return log_error_errno(r, "Failed to run event loop: %m"); /* Kill if it is not dead yet anyway */ if (scope_allocated) terminate_scope(runtime_bus, arg_machine); /* Normally redundant, but better safe than sorry */ (void) pidref_kill(pid, SIGKILL); fd_kmsg_fifo = safe_close(fd_kmsg_fifo); if (arg_private_network && arg_userns_mode != USER_NAMESPACE_MANAGED) { r = move_back_network_interfaces(child_netns_fd, arg_network_interfaces); if (r < 0) return r; r = remove_macvlan(child_netns_fd, arg_network_macvlan); if (r < 0) return r; } r = wait_for_container(pid, &container_status); /* Tell machined that we are gone. */ if (registered_system) (void) unregister_machine(system_bus, arg_machine); if (registered_runtime) (void) unregister_machine(runtime_bus, arg_machine); if (r < 0) /* We failed to wait for the container, or the container exited abnormally. */ return r; if (r > 0 || container_status == CONTAINER_TERMINATED) { /* r > 0 → The container exited with a non-zero status. * As a special case, we need to replace 133 with a different value, * because 133 is special-cased in the service file to reboot the container. * otherwise → The container exited with zero status and a reboot was not requested. */ if (r == EXIT_FORCE_RESTART) r = EXIT_FAILURE; /* replace 133 with the general failure code */ *ret = r; return 0; /* finito */ } /* CONTAINER_REBOOTED, loop again */ if (arg_keep_unit) { /* Special handling if we are running as a service: instead of simply * restarting the machine we want to restart the entire service, so let's * inform systemd about this with the special exit code 133. The service * file uses RestartForceExitStatus=133 so that this results in a full * nspawn restart. This is necessary since we might have cgroup parameters * set we want to have flushed out. */ *ret = EXIT_FORCE_RESTART; return 0; /* finito */ } expose_port_flush(expose_args->nfnl, arg_expose_ports, AF_INET, &expose_args->address4); expose_port_flush(expose_args->nfnl, arg_expose_ports, AF_INET6, &expose_args->address6); (void) remove_veth_links(veth_name, arg_network_veth_extra); *veth_created = false; return 1; /* loop again */ } static int initialize_rlimits(void) { /* The default resource limits the kernel passes to PID 1, as per kernel 5.16. Let's pass our container payload * the same values as the kernel originally passed to PID 1, in order to minimize differences between host and * container execution environments. */ static const struct rlimit kernel_defaults[_RLIMIT_MAX] = { [RLIMIT_AS] = { RLIM_INFINITY, RLIM_INFINITY }, [RLIMIT_CORE] = { 0, RLIM_INFINITY }, [RLIMIT_CPU] = { RLIM_INFINITY, RLIM_INFINITY }, [RLIMIT_DATA] = { RLIM_INFINITY, RLIM_INFINITY }, [RLIMIT_FSIZE] = { RLIM_INFINITY, RLIM_INFINITY }, [RLIMIT_LOCKS] = { RLIM_INFINITY, RLIM_INFINITY }, [RLIMIT_MEMLOCK] = { DEFAULT_RLIMIT_MEMLOCK, DEFAULT_RLIMIT_MEMLOCK }, [RLIMIT_MSGQUEUE] = { 819200, 819200 }, [RLIMIT_NICE] = { 0, 0 }, [RLIMIT_NOFILE] = { 1024, 4096 }, [RLIMIT_RSS] = { RLIM_INFINITY, RLIM_INFINITY }, [RLIMIT_RTPRIO] = { 0, 0 }, [RLIMIT_RTTIME] = { RLIM_INFINITY, RLIM_INFINITY }, [RLIMIT_STACK] = { 8388608, RLIM_INFINITY }, /* The kernel scales the default for RLIMIT_NPROC and RLIMIT_SIGPENDING based on the system's amount of * RAM. To provide best compatibility we'll read these limits off PID 1 instead of hardcoding them * here. This is safe as we know that PID 1 doesn't change these two limits and thus the original * kernel's initialization should still be valid during runtime — at least if PID 1 is systemd. Note * that PID 1 changes a number of other resource limits during early initialization which is why we * don't read the other limits from PID 1 but prefer the static table above. */ }; int rl, r; for (rl = 0; rl < _RLIMIT_MAX; rl++) { /* Let's only fill in what the user hasn't explicitly configured anyway */ if ((arg_settings_mask & (SETTING_RLIMIT_FIRST << rl)) == 0) { const struct rlimit *v; struct rlimit buffer; if (IN_SET(rl, RLIMIT_NPROC, RLIMIT_SIGPENDING)) { /* For these two let's read the limits off PID 1. See above for an explanation. */ r = pid_getrlimit(1, rl, &buffer); if (r < 0) return log_error_errno(r, "Failed to read resource limit RLIMIT_%s of PID 1: %m", rlimit_to_string(rl)); v = &buffer; } else if (rl == RLIMIT_NOFILE) { /* We nowadays bump RLIMIT_NOFILE's hard limit early in PID 1 for all * userspace. Given that nspawn containers are often run without our PID 1, * let's grant the containers a raised RLIMIT_NOFILE hard limit by default, * so that container userspace gets similar resources as host userspace * gets. */ buffer = kernel_defaults[rl]; buffer.rlim_max = MIN((rlim_t) read_nr_open(), (rlim_t) HIGH_RLIMIT_NOFILE); v = &buffer; } else v = kernel_defaults + rl; arg_rlimit[rl] = newdup(struct rlimit, v, 1); if (!arg_rlimit[rl]) return log_oom(); } if (DEBUG_LOGGING) { _cleanup_free_ char *k = NULL; (void) rlimit_format(arg_rlimit[rl], &k); log_debug("Setting RLIMIT_%s to %s.", rlimit_to_string(rl), k); } } return 0; } static int cant_be_in_netns(void) { _cleanup_close_ int fd = -EBADF; struct ucred ucred; int r; /* Check if we are in the same netns as udev. If we aren't, then device monitoring (and thus waiting * for loopback block devices) won't work, and we will hang. Detect this case and exit early with a * nice message. */ if (!arg_image) /* only matters if --image= us used, i.e. we actually need to use loopback devices */ return 0; fd = socket(AF_UNIX, SOCK_SEQPACKET|SOCK_NONBLOCK|SOCK_CLOEXEC, 0); if (fd < 0) return log_error_errno(errno, "Failed to allocate udev control socket: %m"); r = connect_unix_path(fd, AT_FDCWD, "/run/udev/control"); if (r == -ENOENT || ERRNO_IS_NEG_DISCONNECT(r)) return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Sorry, but --image= requires access to the host's /run/ hierarchy, since we need access to udev."); if (ERRNO_IS_NEG_PRIVILEGE(r)) { log_debug_errno(r, "Can't connect to udev control socket, assuming we are in same netns."); return 0; } if (r < 0) return log_error_errno(r, "Failed to connect socket to udev control socket: %m"); r = getpeercred(fd, &ucred); if (r < 0) return log_error_errno(r, "Failed to determine peer of udev control socket: %m"); r = in_same_namespace(ucred.pid, 0, NAMESPACE_NET); if (r < 0) return log_error_errno(r, "Failed to determine network namespace of udev: %m"); if (r == 0) return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Sorry, but --image= is only supported in the main network namespace, since we need access to udev/AF_NETLINK."); return 0; } static void initialize_defaults(void) { arg_privileged = getuid() == 0; /* If running unprivileged default to systemd-nsresourced operation */ arg_userns_mode = arg_privileged ? USER_NAMESPACE_NO : USER_NAMESPACE_MANAGED; /* Imply private networking for unprivileged operation, since kernel otherwise refuses mounting sysfs */ arg_private_network = !arg_privileged; } static void cleanup_propagation_and_export_directories(void) { const char *p; if (!arg_machine || !arg_privileged) return; p = strjoina("/run/systemd/nspawn/propagate/", arg_machine); (void) rm_rf(p, REMOVE_ROOT); p = strjoina("/run/systemd/nspawn/unix-export/", arg_machine); (void) umount2(p, MNT_DETACH|UMOUNT_NOFOLLOW); (void) rmdir(p); } static int do_cleanup(void) { int r; if (arg_ephemeral) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Cannot specify --ephemeral with --cleanup."); r = determine_names(); if (r < 0) return r; cleanup_propagation_and_export_directories(); return 0; } static int run(int argc, char *argv[]) { bool remove_image = false, veth_created = false; _cleanup_close_ int master = -EBADF, userns_fd = -EBADF, mount_fd = -EBADF; _cleanup_fdset_free_ FDSet *fds = NULL; int r, ret = EXIT_SUCCESS; char veth_name[IFNAMSIZ] = ""; struct ExposeArgs expose_args = {}; _cleanup_(release_lock_file) LockFile tree_global_lock = LOCK_FILE_INIT, tree_local_lock = LOCK_FILE_INIT; _cleanup_(rmdir_and_freep) char *rootdir = NULL; _cleanup_(rm_rf_subvolume_and_freep) char *snapshot_dir = NULL; _cleanup_(loop_device_unrefp) LoopDevice *loop = NULL; _cleanup_(dissected_image_unrefp) DissectedImage *dissected_image = NULL; _cleanup_(mstack_freep) MStack *mstack = NULL; _cleanup_(sd_netlink_unrefp) sd_netlink *nfnl = NULL; _cleanup_(pidref_done) PidRef pid = PIDREF_NULL; _cleanup_(sd_varlink_unrefp) sd_varlink *nsresource_link = NULL, *mountfsd_link = NULL; log_setup(); initialize_defaults(); r = parse_argv(argc, argv); if (r <= 0) goto finish; if (arg_cleanup) return do_cleanup(); (void) dlopen_libmount(); (void) dlopen_libseccomp(); (void) dlopen_libselinux(); r = cg_has_legacy(); if (r < 0) goto finish; if (r > 0) { r = log_error_errno(SYNTHETIC_ERRNO(EPROTO), "Detected host uses legacy cgroup v1 hierarchy, refusing."); goto finish; } r = cant_be_in_netns(); if (r < 0) goto finish; r = initialize_rlimits(); if (r < 0) goto finish; r = load_oci_bundle(); if (r < 0) goto finish; r = pick_paths(); if (r < 0) goto finish; r = determine_names(); if (r < 0) goto finish; r = load_settings(); if (r < 0) goto finish; /* If we're not unsharing the network namespace and are unsharing the user namespace, we won't have * permissions to bind ports in the container, so let's drop the CAP_NET_BIND_SERVICE capability to * indicate that. */ if (!arg_private_network && arg_userns_mode != USER_NAMESPACE_NO) arg_caps_retain &= ~(UINT64_C(1) << CAP_NET_BIND_SERVICE); r = verify_arguments(); if (r < 0) goto finish; r = resolve_network_interface_names(arg_network_interfaces); if (r < 0) goto finish; r = verify_network_interfaces_initialized(); if (r < 0) goto finish; /* Ignore SIGPIPE here, because we use splice() on the ptyfwd stuff and that will generate SIGPIPE if * the result is closed. Note that the container payload child will reset signal mask+handler anyway, * so just turning this off here means we only turn it off in nspawn itself, not any children. */ (void) ignore_signals(SIGPIPE); r = fdset_new_listen_fds(&fds, /* unset= */ false); if (r < 0) { log_error_errno(r, "Failed to collect file descriptors: %m"); goto finish; } /* The "default" umask. This is appropriate for most file and directory * operations performed by nspawn, and is the umask that will be used for * the child. Functions like copy_devnodes() change the umask temporarily. */ umask(0022); if (arg_console_mode < 0) arg_console_mode = isatty_safe(STDIN_FILENO) && isatty_safe(STDOUT_FILENO) ? CONSOLE_INTERACTIVE : CONSOLE_READ_ONLY; if (arg_console_mode == CONSOLE_AUTOPIPE) { if (isatty_safe(STDIN_FILENO) && isatty_safe(STDOUT_FILENO)) arg_console_mode = CONSOLE_INTERACTIVE; else arg_console_mode = CONSOLE_PIPE; } if (arg_console_mode == CONSOLE_PIPE) /* if we pass STDERR on to the container, don't add our own logs into it too */ arg_quiet = true; polkit_agent_open(); if (arg_userns_mode == USER_NAMESPACE_MANAGED) { /* Let's allocate a 64K userns first, if managed mode is chosen */ r = nsresource_connect(&nsresource_link); if (r < 0) { log_error_errno(r, "Failed to connect to nsresourced: %m"); goto finish; } r = mountfsd_connect(&mountfsd_link); if (r < 0) { log_error_errno(r, "Failed to connect to mountfsd: %m"); goto finish; } _cleanup_free_ char *userns_name = NULL; if (asprintf(&userns_name, "nspawn-" PID_FMT "-%s", getpid_cached(), arg_machine) < 0) { r = log_oom(); goto finish; } userns_fd = nsresource_allocate_userns_full( nsresource_link, userns_name, NSRESOURCE_UIDS_64K, arg_delegate_container_ranges); if (userns_fd < 0) { r = log_error_errno(userns_fd, "Failed to allocate user namespace with 64K users: %m"); goto finish; } r = userns_get_base_uid(userns_fd, &arg_uid_shift, /* ret_gid= */ NULL); if (r < 0) { log_error_errno(r, "Failed to determine UID shift from userns: %m"); goto finish; } arg_uid_range = NSRESOURCE_UIDS_64K; } if (arg_directory) { assert(!arg_image); /* Safety precaution: let's not allow running images from the live host OS image, as long as * /var from the host will propagate into container dynamically (because bad things happen if * two systems write to the same /var). Let's allow it for the special cases where /var is * either copied (i.e. --ephemeral) or replaced (i.e. --volatile=yes|state). */ if (path_equal(arg_directory, "/") && !(arg_ephemeral || IN_SET(arg_volatile_mode, VOLATILE_YES, VOLATILE_STATE))) { r = log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Spawning container on root directory is not supported. Consider using --ephemeral, --volatile=yes or --volatile=state."); goto finish; } if (arg_ephemeral) { r = chase_and_update(&arg_directory, 0); if (r < 0) goto finish; r = create_ephemeral_snapshot( arg_directory, arg_privileged ? RUNTIME_SCOPE_SYSTEM : RUNTIME_SCOPE_USER, arg_read_only, &tree_global_lock, &tree_local_lock, &snapshot_dir); if (r < 0) { log_error_errno(r, "Failed to create ephemeral snapshot: %m"); goto finish; } r = free_and_strdup(&arg_directory, snapshot_dir); if (r < 0) { log_oom(); goto finish; } } else { r = chase_and_update(&arg_directory, arg_template ? CHASE_NONEXISTENT : 0); if (r < 0) goto finish; r = image_path_lock( arg_privileged ? RUNTIME_SCOPE_SYSTEM : RUNTIME_SCOPE_USER, arg_directory, (arg_read_only ? LOCK_SH : LOCK_EX) | LOCK_NB, arg_privileged ? &tree_global_lock : NULL, &tree_local_lock); if (r == -EBUSY) { log_error_errno(r, "Directory tree %s is currently busy.", arg_directory); goto finish; } if (r < 0) { log_error_errno(r, "Failed to lock %s: %m", arg_directory); goto finish; } if (arg_template) { r = chase_and_update(&arg_template, 0); if (r < 0) goto finish; { BLOCK_SIGNALS(SIGINT); r = btrfs_subvol_snapshot_at(AT_FDCWD, arg_template, AT_FDCWD, arg_directory, (arg_read_only ? BTRFS_SNAPSHOT_READ_ONLY : 0) | BTRFS_SNAPSHOT_FALLBACK_COPY | BTRFS_SNAPSHOT_FALLBACK_DIRECTORY | BTRFS_SNAPSHOT_FALLBACK_IMMUTABLE | BTRFS_SNAPSHOT_RECURSIVE | BTRFS_SNAPSHOT_QUOTA | BTRFS_SNAPSHOT_SIGINT); } if (r == -EEXIST) log_full(arg_quiet ? LOG_DEBUG : LOG_INFO, "Directory %s already exists, not populating from template %s.", arg_directory, arg_template); else if (r == -EINTR) { log_error_errno(r, "Interrupted while copying file system tree to %s, removed again.", arg_directory); goto finish; } else if (r < 0) { log_error_errno(r, "Couldn't create snapshot %s from %s: %m", arg_directory, arg_template); goto finish; } else log_full(arg_quiet ? LOG_DEBUG : LOG_INFO, "Populated %s from template %s.", arg_directory, arg_template); } } if (arg_start_mode == START_BOOT) { _cleanup_free_ char *b = NULL; const char *p; int check_os_release, is_os_tree; if (arg_pivot_root_new) { b = path_join(arg_directory, arg_pivot_root_new); if (!b) { r = log_oom(); goto finish; } p = b; } else p = arg_directory; check_os_release = getenv_bool("SYSTEMD_NSPAWN_CHECK_OS_RELEASE"); if (check_os_release < 0 && check_os_release != -ENXIO) { r = log_error_errno(check_os_release, "Failed to parse $SYSTEMD_NSPAWN_CHECK_OS_RELEASE: %m"); goto finish; } is_os_tree = path_is_os_tree(p); if (is_os_tree == 0 && check_os_release == 0) log_debug("Directory %s is missing an os-release file, continuing anyway.", p); else if (is_os_tree <= 0) { r = log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Directory %s doesn't look like an OS root directory (os-release file is missing). Refusing.", p); goto finish; } } else { _cleanup_free_ char *p = NULL; if (arg_pivot_root_new) p = path_join(arg_directory, arg_pivot_root_new, "/usr/"); else p = path_join(arg_directory, "/usr/"); if (!p) { r = log_oom(); goto finish; } r = access_nofollow(p, F_OK); if (r == -ENOENT) { log_error_errno(r, "Directory %s doesn't look like it has an OS tree (/usr/ directory is missing). Refusing.", arg_directory); goto finish; } else if (r < 0) { log_error_errno(r, "Unable to determine if %s looks like it has an OS tree (i.e. whether /usr/ exists): %m", arg_directory); goto finish; } } if (userns_fd >= 0) { r = mountfsd_mount_directory( mountfsd_link, arg_directory, userns_fd, determine_dissect_image_flags(), &mount_fd); if (r < 0) { log_error_errno(r, "Failed to mount directory via mountfsd: %m"); goto finish; } } } else if (arg_image) { DissectImageFlags dissect_image_flags = determine_dissect_image_flags(); assert(!arg_template); r = chase_and_update(&arg_image, 0); if (r < 0) goto finish; if (arg_ephemeral) { _cleanup_free_ char *np = NULL; r = tempfn_random(arg_image, "machine.", &np); if (r < 0) { log_error_errno(r, "Failed to generate name for image snapshot: %m"); goto finish; } /* Always take an exclusive lock on our own ephemeral copy. */ r = image_path_lock( arg_privileged ? RUNTIME_SCOPE_SYSTEM : RUNTIME_SCOPE_USER, np, LOCK_EX|LOCK_NB, arg_privileged ? &tree_global_lock : NULL, &tree_local_lock); if (r < 0) { log_error_errno(r, "Failed to create image lock: %m"); goto finish; } { BLOCK_SIGNALS(SIGINT); r = copy_file(arg_image, np, O_EXCL, arg_read_only ? 0400 : 0600, COPY_REFLINK|COPY_CRTIME|COPY_SIGINT|COPY_NOCOW_AFTER); } if (r == -EINTR) { log_error_errno(r, "Interrupted while copying image file to %s, removed again.", np); goto finish; } if (r < 0) { r = log_error_errno(r, "Failed to copy image file: %m"); goto finish; } free_and_replace(arg_image, np); remove_image = true; } else { r = image_path_lock( arg_privileged ? RUNTIME_SCOPE_SYSTEM : RUNTIME_SCOPE_USER, arg_image, (arg_read_only ? LOCK_SH : LOCK_EX) | LOCK_NB, arg_privileged ? &tree_global_lock : NULL, &tree_local_lock); if (r == -EBUSY) { log_error_errno(r, "Disk image %s is currently busy.", arg_image); goto finish; } if (r < 0) { log_error_errno(r, "Failed to create image lock: %m"); goto finish; } r = verity_settings_load( &arg_verity_settings, arg_image, NULL, NULL); if (r < 0) { log_error_errno(r, "Failed to read verity artefacts for %s: %m", arg_image); goto finish; } if (arg_verity_settings.data_path) dissect_image_flags |= DISSECT_IMAGE_NO_PARTITION_TABLE; } if (arg_userns_mode != USER_NAMESPACE_MANAGED) { r = loop_device_make_by_path( arg_image, arg_read_only ? O_RDONLY : O_RDWR, /* sector_size= */ UINT32_MAX, FLAGS_SET(dissect_image_flags, DISSECT_IMAGE_NO_PARTITION_TABLE) ? 0 : LO_FLAGS_PARTSCAN, LOCK_SH, &loop); if (r < 0) { log_error_errno(r, "Failed to set up loopback block device: %m"); goto finish; } r = dissect_loop_device_and_warn( loop, &arg_verity_settings, /* mount_options= */ NULL, arg_image_policy ?: &image_policy_container, /* image_filter= */ NULL, dissect_image_flags, &dissected_image); if (r == -ENOPKG) { /* dissected_image_and_warn() already printed a brief error message. Extend on that with more details */ log_notice("Note that the disk image needs to\n" " a) either contain only a single MBR partition of type 0x83 that is marked bootable\n" " b) or contain a single GPT partition of type 0FC63DAF-8483-4772-8E79-3D69D8477DE4\n" " c) or follow https://uapi-group.org/specifications/specs/discoverable_partitions_specification\n" " d) or contain a file system without a partition table\n" "in order to be bootable with systemd-nspawn."); goto finish; } if (r < 0) goto finish; r = dissected_image_load_verity_sig_partition( dissected_image, loop->fd, &arg_verity_settings); if (r < 0) { log_error_errno(r, "Failed to load Verity signature partition: %m"); goto finish; } r = dissected_image_guess_verity_roothash( dissected_image, &arg_verity_settings); if (r < 0) { log_error_errno(r, "Failed to guess Verity root hash: %m"); goto finish; } if (dissected_image->has_verity && !iovec_is_set(&arg_verity_settings.root_hash)) log_notice("Note: image %s contains verity information, but no root hash specified and no embedded " "root hash signature found! Proceeding without integrity checking.", arg_image); r = dissected_image_decrypt_interactively( dissected_image, NULL, &arg_verity_settings, arg_image_policy ?: &image_policy_container, dissect_image_flags); if (r < 0) goto finish; } else { r = mountfsd_mount_image( mountfsd_link, arg_image, userns_fd, /* options= */ NULL, arg_image_policy, &arg_verity_settings, dissect_image_flags, &dissected_image); if (r < 0) { log_error_errno(r, "Failed to mount image via mountfsd: %m"); goto finish; } } /* Now that we mounted the image, let's try to remove it again, if it is ephemeral */ if (remove_image && unlink(arg_image) >= 0) remove_image = false; if (arg_architecture < 0) arg_architecture = dissected_image_architecture(dissected_image); } else if (arg_mstack) { assert(!arg_template); assert(!arg_ephemeral); r = chase_and_update(&arg_mstack, CHASE_MUST_BE_DIRECTORY); if (r < 0) goto finish; if (!IN_SET(arg_userns_mode, USER_NAMESPACE_NO, USER_NAMESPACE_MANAGED)) return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "--mstack= requires managed user namespacing, or user namespace turned off."); MStackFlags mstack_flags = arg_read_only ? MSTACK_RDONLY : 0; r = mstack_load(arg_mstack, /* dir_fd= */ -EBADF, &mstack); if (r < 0) { log_error_errno(r, "Failed to load .mstack/ directory '%s': %m", arg_mstack); goto finish; } r = mstack_open_images( mstack, mountfsd_link, userns_fd, arg_image_policy, /* image_filter= */ NULL, mstack_flags); if (r < 0) { log_error_errno(r, "Failed to open .mstack/ layer images '%s': %m", arg_mstack); goto finish; } } else assert_not_reached(); /* Create a temporary place to mount stuff. */ r = mkdtemp_malloc("/tmp/nspawn-root-XXXXXX", &rootdir); if (r < 0) { log_error_errno(r, "Failed to create temporary directory: %m"); goto finish; } r = custom_mount_prepare_all(rootdir, arg_custom_mounts, arg_n_custom_mounts); if (r < 0) goto finish; mountfsd_link = sd_varlink_unref(mountfsd_link); nsresource_link = sd_varlink_unref(nsresource_link); if (!arg_quiet) { const char *t = arg_mstack ?: arg_image ?: arg_directory; _cleanup_free_ char *u = NULL; (void) terminal_urlify_path(t, t, &u); log_info("%s %sSpawning container %s on %s.%s", glyph(GLYPH_LIGHT_SHADE), ansi_grey(), arg_machine, u ?: t, ansi_normal()); if (arg_console_mode == CONSOLE_INTERACTIVE) log_info("%s %sPress %sCtrl-]%s three times within 1s to kill container; two times followed by %sr%s\n" "%s %sto reboot container; two times followed by %sp%s to poweroff container.%s", glyph(GLYPH_LIGHT_SHADE), ansi_grey(), ansi_highlight(), ansi_grey(), ansi_highlight(), ansi_normal(), glyph(GLYPH_LIGHT_SHADE), ansi_grey(), ansi_highlight(), ansi_grey(), ansi_normal()); } assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGCHLD, SIGWINCH, SIGTERM, SIGINT, SIGRTMIN+18) >= 0); r = make_reaper_process(true); if (r < 0) { log_error_errno(r, "Failed to become subreaper: %m"); goto finish; } if (arg_expose_ports) { r = sd_nfnl_socket_open(&nfnl); if (r < 0) { log_error_errno(r, "Cannot expose configured ports, failed to initialize nftables: %m"); goto finish; } expose_args.nfnl = nfnl; } for (;;) { r = run_container( rootdir, mount_fd, dissected_image, mstack, userns_fd, fds, veth_name, &veth_created, &expose_args, &master, &pid, &ret); if (r <= 0) break; } finish: (void) sd_notify(false, r == 0 && ret == EXIT_FORCE_RESTART ? "STOPPING=1\nSTATUS=Restarting..." : "STOPPING=1\nSTATUS=Terminating..."); if (pidref_is_set(&pid)) (void) pidref_kill(&pid, SIGKILL); /* Try to flush whatever is still queued in the pty */ if (master >= 0) { (void) copy_bytes(master, STDOUT_FILENO, UINT64_MAX, 0); master = safe_close(master); } if (pidref_is_set(&pid)) { (void) pidref_wait_for_terminate(&pid, NULL); pidref_done(&pid); } pager_close(); if (remove_image && arg_image) { if (unlink(arg_image) < 0) log_warning_errno(errno, "Can't remove image file '%s', ignoring: %m", arg_image); } if (arg_machine && arg_userns_mode != USER_NAMESPACE_MANAGED) { const char *p; p = strjoina("/run/systemd/nspawn/propagate/", arg_machine); (void) rm_rf(p, REMOVE_ROOT); p = strjoina("/run/systemd/nspawn/unix-export/", arg_machine); (void) umount2(p, MNT_DETACH|UMOUNT_NOFOLLOW); (void) rmdir(p); } cleanup_propagation_and_export_directories(); expose_port_flush(nfnl, arg_expose_ports, AF_INET, &expose_args.address4); expose_port_flush(nfnl, arg_expose_ports, AF_INET6, &expose_args.address6); if (arg_userns_mode != USER_NAMESPACE_MANAGED) { if (veth_created) (void) remove_veth_links(veth_name, arg_network_veth_extra); (void) remove_bridge(arg_network_zone); } custom_mount_free_all(arg_custom_mounts, arg_n_custom_mounts); expose_port_free_all(arg_expose_ports); rlimit_free_all(arg_rlimit); device_node_array_free(arg_extra_nodes, arg_n_extra_nodes); if (r < 0) return r; return ret; } DEFINE_MAIN_FUNCTION_WITH_POSITIVE_FAILURE(run);