f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen#ifdef HAVE_BLKID

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen#include <blkid/blkid.h>

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen#endif

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen#include <errno.h>

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen#include <getopt.h>

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen#include <linux/loop.h>

1346b1f0388f4100bb3c2a2bb23bc881769c020cTom Gundersen#include <sched.h>

f5be560181d092c5f52a2b819aedcd48220f36abTom Gundersen#ifdef HAVE_SECCOMP

dd43110f781a9245ec00531456fee68ed763a179Tom Gundersen#include <seccomp.h>

5c1d3fc93d91384bbac29adf01074fa4375317eaUmut Tezduyar Lindskog#endif

4138fb2c7936758da709eaed3f6b4f3df1d04effPatrik Flykt#ifdef HAVE_SELINUX

4138fb2c7936758da709eaed3f6b4f3df1d04effPatrik Flykt#include <selinux/selinux.h>

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen#endif

ce43e484465050c619ea9a1991d49b3d6215028bSusant Sahani#include <signal.h>

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen#include <stdio.h>

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen#include <stdlib.h>

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen#include <string.h>

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen#include <sys/file.h>

06f021a8048583d66202e3ac5cd0a12386d33ac2Tom Gundersen#include <sys/mount.h>

134e56dcc53970a20a858283650bb92cd5da1d17Lennart Poettering#include <sys/personality.h>

3b653205cf7bd3851befd0a9f6a3ded6e267c173Lennart Poettering#include <sys/prctl.h>

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen#include <sys/types.h>

aba496a58acf9d9c61314de71353550e579f85eeUmut Tezduyar Lindskog#include <unistd.h>

4faefc7ff884eae65a80e82313fd9f4bb859d6dbLennart Poettering

4faefc7ff884eae65a80e82313fd9f4bb859d6dbLennart Poettering#include "sd-daemon.h"

aba496a58acf9d9c61314de71353550e579f85eeUmut Tezduyar Lindskog#include "sd-id128.h"

1a436809498faf6486815baa0338fb6b8e5def07Tom Gundersen

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen#include "barrier.h"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen#include "base-filesystem.h"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen#include "blkid-util.h"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen#include "btrfs-util.h"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen#include "build.h"

11bf3cced13c885ca215c108cb0bdb7a148520d6Lennart Poettering#include "cap-list.h"

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta#include "capability.h"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen#include "cgroup-util.h"

cb9fc36a1211967e8c58b0502a26c42552ac8060Lennart Poettering#include "copy.h"

769d324c99aab129148bd25f5f663ef441287d86Lennart Poettering#include "dev-setup.h"

769d324c99aab129148bd25f5f663ef441287d86Lennart Poettering#include "env-util.h"

769d324c99aab129148bd25f5f663ef441287d86Lennart Poettering#include "event-util.h"

769d324c99aab129148bd25f5f663ef441287d86Lennart Poettering#include "fdset.h"

769d324c99aab129148bd25f5f663ef441287d86Lennart Poettering#include "fileio.h"

cb9fc36a1211967e8c58b0502a26c42552ac8060Lennart Poettering#include "formats-util.h"

cb9fc36a1211967e8c58b0502a26c42552ac8060Lennart Poettering#include "gpt.h"

cb9fc36a1211967e8c58b0502a26c42552ac8060Lennart Poettering#include "hostname-util.h"

ed942a9eb22d50f667909ad6184b45015d28d054Tom Gundersen#include "log.h"

bd8f65387673e29f46136a4ed172097035002c23Tom Gundersen#include "loopback-setup.h"

bd8f65387673e29f46136a4ed172097035002c23Tom Gundersen#include "machine-image.h"

bd8f65387673e29f46136a4ed172097035002c23Tom Gundersen#include "macro.h"

bd8f65387673e29f46136a4ed172097035002c23Tom Gundersen#include "missing.h"

bd8f65387673e29f46136a4ed172097035002c23Tom Gundersen#include "mkdir.h"

bd8f65387673e29f46136a4ed172097035002c23Tom Gundersen#include "netlink-util.h"

bd8f65387673e29f46136a4ed172097035002c23Tom Gundersen#include "path-util.h"

bd8f65387673e29f46136a4ed172097035002c23Tom Gundersen#include "process-util.h"

e331e24649213f2e093e16e4d3d64ee823dfc375Tom Gundersen#include "ptyfwd.h"

e331e24649213f2e093e16e4d3d64ee823dfc375Tom Gundersen#include "random-util.h"

e331e24649213f2e093e16e4d3d64ee823dfc375Tom Gundersen#include "rm-rf.h"

e331e24649213f2e093e16e4d3d64ee823dfc375Tom Gundersen#ifdef HAVE_SECCOMP

e331e24649213f2e093e16e4d3d64ee823dfc375Tom Gundersen#include "seccomp-util.h"

e331e24649213f2e093e16e4d3d64ee823dfc375Tom Gundersen#endif

e331e24649213f2e093e16e4d3d64ee823dfc375Tom Gundersen#include "signal-util.h"

e331e24649213f2e093e16e4d3d64ee823dfc375Tom Gundersen#include "strv.h"

e331e24649213f2e093e16e4d3d64ee823dfc375Tom Gundersen#include "terminal-util.h"

e331e24649213f2e093e16e4d3d64ee823dfc375Tom Gundersen#include "udev-util.h"

e331e24649213f2e093e16e4d3d64ee823dfc375Tom Gundersen#include "util.h"

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta#include "nspawn-settings.h"

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta#include "nspawn-mount.h"

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta#include "nspawn-network.h"

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta#include "nspawn-expose-ports.h"

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta#include "nspawn-cgroup.h"

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta#include "nspawn-register.h"

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta#include "nspawn-setuid.h"

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta

b98b483bac585af754e8a22ea890db8486905d8aAlin Rautatypedef enum ContainerStatus {

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen CONTAINER_TERMINATED,

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen CONTAINER_REBOOTED

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen} ContainerStatus;

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen

dbffab87f1504abc9f189dd253111693c99fbd9aTom Gundersentypedef enum LinkJournal {

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen LINK_NO,

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen LINK_AUTO,

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen LINK_HOST,

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen LINK_GUEST

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen} LinkJournal;

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen

edb85f0d8d0a84f27308a3728f3fde3c52b9dce2Susant Sahanistatic char *arg_directory = NULL;

edb85f0d8d0a84f27308a3728f3fde3c52b9dce2Susant Sahanistatic char *arg_template = NULL;

2cc412b59353576cece2d5b30c6a39c70552f0a0Tom Gundersenstatic char *arg_user = NULL;

2cc412b59353576cece2d5b30c6a39c70552f0a0Tom Gundersenstatic sd_id128_t arg_uuid = {};

2cc412b59353576cece2d5b30c6a39c70552f0a0Tom Gundersenstatic char *arg_machine = NULL;

edbb03e95a3c31bf719d5c6c46eec14d0bcb9c8fTom Gundersenstatic const char *arg_selinux_context = NULL;

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersenstatic const char *arg_selinux_apifs_context = NULL;

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersenstatic const char *arg_slice = NULL;

1a436809498faf6486815baa0338fb6b8e5def07Tom Gundersenstatic bool arg_private_network = false;

1a436809498faf6486815baa0338fb6b8e5def07Tom Gundersenstatic bool arg_read_only = false;

6a0a2f860f1ca4a10932da3b41dbc3c0139757ccTom Gundersenstatic bool arg_boot = false;

cb9fc36a1211967e8c58b0502a26c42552ac8060Lennart Poetteringstatic bool arg_ephemeral = false;

5be4d38e31281727b6f45ae869136bb01a1f7790Tom Gundersenstatic LinkJournal arg_link_journal = LINK_AUTO;

bcb7a07e0a785bda1eed658e984ff6b4a11cba9aTom Gundersenstatic bool arg_link_journal_try = false;

4f882b2a5007e51032459e29d15a86df6b5ea9f4Tom Gundersenstatic uint64_t arg_retain =

1346b1f0388f4100bb3c2a2bb23bc881769c020cTom Gundersen (1ULL << CAP_CHOWN) |

ad0734e890b25751ef8229e47210ff11ae8fa3f3Tom Gundersen (1ULL << CAP_DAC_OVERRIDE) |

4cc7a82c9490a3c5ae03b1d6d168ce40ba499e23Eugene Yakubovich (1ULL << CAP_DAC_READ_SEARCH) |

f5de5b00204f041aaec828d336c8afd9e860a5c3Tom Gundersen (1ULL << CAP_FOWNER) |

eb27aeca247a4cf8816fffc4c0dbcab55ead3864Tom Gundersen (1ULL << CAP_FSETID) |

e1ea665edac17d75fce01b72dadfa3211b60df2cEugene Yakubovich (1ULL << CAP_IPC_OWNER) |

84b5b79a8f7b423c5b7cad4170eb68d57fe5e26cAngus Gibson (1ULL << CAP_KILL) |

5c1d3fc93d91384bbac29adf01074fa4375317eaUmut Tezduyar Lindskog (1ULL << CAP_LEASE) |

bfa695b5cc37aeb78737c57c84e9e69ea08152c0Tom Gundersen (1ULL << CAP_LINUX_IMMUTABLE) |

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen (1ULL << CAP_NET_BIND_SERVICE) |

dd43110f781a9245ec00531456fee68ed763a179Tom Gundersen (1ULL << CAP_NET_BROADCAST) |

dd43110f781a9245ec00531456fee68ed763a179Tom Gundersen (1ULL << CAP_NET_RAW) |

e1853b00ef7cb56cafd908327dd44b3ab48b402cSusant Sahani (1ULL << CAP_SETGID) |

e1853b00ef7cb56cafd908327dd44b3ab48b402cSusant Sahani (1ULL << CAP_SETFCAP) |

769d324c99aab129148bd25f5f663ef441287d86Lennart Poettering (1ULL << CAP_SETPCAP) |

5a8bcb674f71a20e95df55319b34c556638378ceLennart Poettering (1ULL << CAP_SETUID) |

5a8bcb674f71a20e95df55319b34c556638378ceLennart Poettering (1ULL << CAP_SYS_ADMIN) |

c106cc36b9b8e8998eb95299b02f1db9c1209122Tom Gundersen (1ULL << CAP_SYS_CHROOT) |

c106cc36b9b8e8998eb95299b02f1db9c1209122Tom Gundersen (1ULL << CAP_SYS_NICE) |

c106cc36b9b8e8998eb95299b02f1db9c1209122Tom Gundersen (1ULL << CAP_SYS_PTRACE) |

ce43e484465050c619ea9a1991d49b3d6215028bSusant Sahani (1ULL << CAP_SYS_TTY_CONFIG) |

ce43e484465050c619ea9a1991d49b3d6215028bSusant Sahani (1ULL << CAP_SYS_RESOURCE) |

f048a16b464295a4e0a4f4c1210f06343ad31231Tom Gundersen (1ULL << CAP_SYS_BOOT) |

f048a16b464295a4e0a4f4c1210f06343ad31231Tom Gundersen (1ULL << CAP_AUDIT_WRITE) |

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta (1ULL << CAP_AUDIT_CONTROL) |

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen (1ULL << CAP_MKNOD);

6ae115c1fe95611b39d2f20cfcea3d385429f59eTom Gundersenstatic CustomMount *arg_custom_mounts = NULL;

6ae115c1fe95611b39d2f20cfcea3d385429f59eTom Gundersenstatic unsigned arg_n_custom_mounts = 0;

b98b483bac585af754e8a22ea890db8486905d8aAlin Rautastatic char **arg_setenv = NULL;

6ae115c1fe95611b39d2f20cfcea3d385429f59eTom Gundersenstatic bool arg_quiet = false;

67272d157a35e5cda4e5c904eafdcc23d20541d1Tom Gundersenstatic bool arg_share_system = false;

6192b846ca0d15602e94ddb5da4420b7c60d64a5Tom Gundersenstatic bool arg_register = true;

06f021a8048583d66202e3ac5cd0a12386d33ac2Tom Gundersenstatic bool arg_keep_unit = false;

bd8f65387673e29f46136a4ed172097035002c23Tom Gundersenstatic char **arg_network_interfaces = NULL;

bd8f65387673e29f46136a4ed172097035002c23Tom Gundersenstatic char **arg_network_macvlan = NULL;

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersenstatic char **arg_network_ipvlan = NULL;

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersenstatic bool arg_network_veth = false;

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersenstatic char *arg_network_bridge = NULL;

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersenstatic unsigned long arg_personality = PERSONALITY_INVALID;

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersenstatic char *arg_image = NULL;

16aa63a00b5b1db23a9c0b8de350ebf482d90cd0Tom Gundersenstatic VolatileMode arg_volatile_mode = VOLATILE_NO;

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersenstatic ExposePort *arg_expose_ports = NULL;

0dd25fb9f005d8ab7ac4bc10a609d00569f8c56aLennart Poetteringstatic char **arg_property = NULL;

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersenstatic uid_t arg_uid_shift = UID_INVALID, arg_uid_range = 0x10000U;

5c1d3fc93d91384bbac29adf01074fa4375317eaUmut Tezduyar Lindskogstatic bool arg_userns = false;

81163121e649523b4071f67ddc03c2db649036c5Tom Gundersenstatic int arg_kill_signal = 0;

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersenstatic bool arg_unified_cgroup_hierarchy = false;

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersenstatic SettingsMask arg_settings_mask = 0;

eb0ea358b688a6f83ff305c6b825c61f12b6dcb8Tom Gundersenstatic int arg_settings_trusted = -1;

aba496a58acf9d9c61314de71353550e579f85eeUmut Tezduyar Lindskogstatic char **arg_parameters = NULL;

8cd11a0f0f4ca05199e1166f6a07472b296f7455Tom Gundersen

5d3de3fe9cc452f1bfe3c2dcafecbd7f904da4dcLennart Poetteringstatic void help(void) {

c081882f07617e56bcbce54105068137e4e0bb52Susant Sahani printf("%s [OPTIONS...] [PATH] [ARGUMENTS...]\n\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen "Spawn a minimal namespace container for debugging, testing and building.\n\n"

fd6d906cf46ecef45ebbb5a361e1dc436f031d7aLennart Poettering " -h --help Show this help\n"

5a8bcb674f71a20e95df55319b34c556638378ceLennart Poettering " --version Print version string\n"

3d3d425547a3f38473fcf8737b85dfebb630479dTom Gundersen " -q --quiet Do not show status information\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " -D --directory=PATH Root directory for the container\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " --template=PATH Initialize root directory from template directory,\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " if missing\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " -x --ephemeral Run container with snapshot of root directory, and\n"

16aa63a00b5b1db23a9c0b8de350ebf482d90cd0Tom Gundersen " remove it after exit\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " -i --image=PATH File system device or disk image for the container\n"

0dd25fb9f005d8ab7ac4bc10a609d00569f8c56aLennart Poettering " -b --boot Boot up full system (i.e. invoke init)\n"

6ae115c1fe95611b39d2f20cfcea3d385429f59eTom Gundersen " -u --user=USER Run the command under specified user or uid\n"

9e7e440835c43d81ffdbc299d2c07daaa641ed50Tom Gundersen " -M --machine=NAME Set the machine name for the container\n"

5c1d3fc93d91384bbac29adf01074fa4375317eaUmut Tezduyar Lindskog " --uuid=UUID Set a specific machine UUID for the container\n"

5c1d3fc93d91384bbac29adf01074fa4375317eaUmut Tezduyar Lindskog " -S --slice=SLICE Place the container in the specified slice\n"

28cc555d8504c9429776aedbbe1fee7101258578Dan Williams " --property=NAME=VALUE Set scope unit property\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " --private-users[=UIDBASE[:NUIDS]]\n"

5d3de3fe9cc452f1bfe3c2dcafecbd7f904da4dcLennart Poettering " Run within user namespace\n"

5d3de3fe9cc452f1bfe3c2dcafecbd7f904da4dcLennart Poettering " --private-network Disable network in container\n"

9e7e440835c43d81ffdbc299d2c07daaa641ed50Tom Gundersen " --network-interface=INTERFACE\n"

46b0c76e2c355c0d0cc4792abb98cde07b28bc53Emil Renner Berthing " Assign an existing network interface to the\n"

6ae115c1fe95611b39d2f20cfcea3d385429f59eTom Gundersen " container\n"

3d3d425547a3f38473fcf8737b85dfebb630479dTom Gundersen " --network-macvlan=INTERFACE\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " Create a macvlan network interface based on an\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " existing network interface to the container\n"

11bf3cced13c885ca215c108cb0bdb7a148520d6Lennart Poettering " --network-ipvlan=INTERFACE\n"

11bf3cced13c885ca215c108cb0bdb7a148520d6Lennart Poettering " Create a ipvlan network interface based on an\n"

11bf3cced13c885ca215c108cb0bdb7a148520d6Lennart Poettering " existing network interface to the container\n"

0dd25fb9f005d8ab7ac4bc10a609d00569f8c56aLennart Poettering " -n --network-veth Add a virtual ethernet connection between host\n"

11bf3cced13c885ca215c108cb0bdb7a148520d6Lennart Poettering " and container\n"

11bf3cced13c885ca215c108cb0bdb7a148520d6Lennart Poettering " --network-bridge=INTERFACE\n"

11bf3cced13c885ca215c108cb0bdb7a148520d6Lennart Poettering " Add a virtual ethernet connection between host\n"

11bf3cced13c885ca215c108cb0bdb7a148520d6Lennart Poettering " and container and add it to an existing bridge on\n"

11bf3cced13c885ca215c108cb0bdb7a148520d6Lennart Poettering " the host\n"

11bf3cced13c885ca215c108cb0bdb7a148520d6Lennart Poettering " -p --port=[PROTOCOL:]HOSTPORT[:CONTAINERPORT]\n"

11bf3cced13c885ca215c108cb0bdb7a148520d6Lennart Poettering " Expose a container IP port on the host\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " -Z --selinux-context=SECLABEL\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " Set the SELinux security context to be used by\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " processes in the container\n"

9c0a72f961e00b0447767973e7117e131bea5b5dTom Gundersen " -L --selinux-apifs-context=SECLABEL\n"

1346b1f0388f4100bb3c2a2bb23bc881769c020cTom Gundersen " Set the SELinux security context to be used by\n"

9c0a72f961e00b0447767973e7117e131bea5b5dTom Gundersen " API/tmpfs file systems in the container\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " --capability=CAP In addition to the default, retain specified\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " capability\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " --drop-capability=CAP Drop the specified capability from the default set\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " --kill-signal=SIGNAL Select signal to use for shutting down PID 1\n"

6a24f1484fcc1f59f89617afbe4282667a358eabTom Gundersen " --link-journal=MODE Link up guest journal, one of no, auto, guest, host,\n"

6a24f1484fcc1f59f89617afbe4282667a358eabTom Gundersen " try-guest, try-host\n"

bbf7c04821a71fec67eaf0e7a34d17afc5913c13Tom Gundersen " -j Equivalent to --link-journal=try-guest\n"

e331e24649213f2e093e16e4d3d64ee823dfc375Tom Gundersen " --read-only Mount the root directory read-only\n"

bbf7c04821a71fec67eaf0e7a34d17afc5913c13Tom Gundersen " --bind=PATH[:PATH[:OPTIONS]]\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " Bind mount a file or directory from the host into\n"

52433f6b65eccd1c54606dde999610640f3458acTom Gundersen " the container\n"

dbffab87f1504abc9f189dd253111693c99fbd9aTom Gundersen " --bind-ro=PATH[:PATH[:OPTIONS]\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " Similar, but creates a read-only bind mount\n"

11bf3cced13c885ca215c108cb0bdb7a148520d6Lennart Poettering " --tmpfs=PATH:[OPTIONS] Mount an empty tmpfs to the specified directory\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " --overlay=PATH[:PATH...]:PATH\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " Create an overlay mount from the host to \n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " the container\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " --overlay-ro=PATH[:PATH...]:PATH\n"

2ad8416dd057e7e3185169609ca3006e7649f576Zbigniew Jędrzejewski-Szmek " Similar, but creates a read-only overlay mount\n"

2ad8416dd057e7e3185169609ca3006e7649f576Zbigniew Jędrzejewski-Szmek " --setenv=NAME=VALUE Pass an environment variable to PID 1\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " --share-system Share system namespaces with host\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " --register=BOOLEAN Register container as machine\n"

e331e24649213f2e093e16e4d3d64ee823dfc375Tom Gundersen " --keep-unit Do not register a scope for the machine, reuse\n"

e331e24649213f2e093e16e4d3d64ee823dfc375Tom Gundersen " the service unit nspawn is running in\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " --volatile[=MODE] Run the system in volatile mode\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen " --settings=BOOLEAN Load additional settings from .nspawn file\n"

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen , program_invocation_short_name);

8f203c166ecb24f904a068f2d8f0c636c1511a8fTom Gundersen}

a97dcc12e486ecff531809802930a26c4da827f2Tom Gundersen

a97dcc12e486ecff531809802930a26c4da827f2Tom Gundersen

02b59d57e0c08231645120077f651151f5bb2babTom Gundersenstatic int custom_mounts_prepare(void) {

02b59d57e0c08231645120077f651151f5bb2babTom Gundersen unsigned i;

02b59d57e0c08231645120077f651151f5bb2babTom Gundersen int r;

505f8da7325591defe5f751f328bd26915267602Tom Gundersen

45af44d47da6933b260c734ad9ff721f63f80a4dTom Gundersen /* Ensure the mounts are applied prefix first. */

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen qsort_safe(arg_custom_mounts, arg_n_custom_mounts, sizeof(CustomMount), custom_mount_compare);

e331e24649213f2e093e16e4d3d64ee823dfc375Tom Gundersen

bbf7c04821a71fec67eaf0e7a34d17afc5913c13Tom Gundersen /* Allocate working directories for the overlay file systems that need it */

3bef724f7e7f7eaca69881548b06e221b77d7031Tom Gundersen for (i = 0; i < arg_n_custom_mounts; i++) {

0dd25fb9f005d8ab7ac4bc10a609d00569f8c56aLennart Poettering CustomMount *m = &arg_custom_mounts[i];

11bf3cced13c885ca215c108cb0bdb7a148520d6Lennart Poettering

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen if (arg_userns && arg_uid_shift == UID_INVALID && path_equal(m->destination, "/")) {

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen log_error("--private-users with automatic UID shift may not be combined with custom root mounts.");

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen return -EINVAL;

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen }

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen if (m->type != CUSTOM_MOUNT_OVERLAY)

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen continue;

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen if (m->work_dir)

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen continue;

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen if (m->read_only)

dbffab87f1504abc9f189dd253111693c99fbd9aTom Gundersen continue;

505f8da7325591defe5f751f328bd26915267602Tom Gundersen

505f8da7325591defe5f751f328bd26915267602Tom Gundersen r = tempfn_random(m->source, NULL, &m->work_dir);

505f8da7325591defe5f751f328bd26915267602Tom Gundersen if (r < 0)

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen return log_error_errno(r, "Failed to generate work directory from %s: %m", m->source);

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen }

69a93e7db47addc4495a6ec9dc0fc74092a6ebeeTom Gundersen

02b59d57e0c08231645120077f651151f5bb2babTom Gundersen return 0;

02b59d57e0c08231645120077f651151f5bb2babTom Gundersen}

02b59d57e0c08231645120077f651151f5bb2babTom Gundersen

6192b846ca0d15602e94ddb5da4420b7c60d64a5Tom Gundersenstatic int set_sanitized_path(char **b, const char *path) {

6192b846ca0d15602e94ddb5da4420b7c60d64a5Tom Gundersen char *p;

6192b846ca0d15602e94ddb5da4420b7c60d64a5Tom Gundersen

6192b846ca0d15602e94ddb5da4420b7c60d64a5Tom Gundersen assert(b);

6192b846ca0d15602e94ddb5da4420b7c60d64a5Tom Gundersen assert(path);

6192b846ca0d15602e94ddb5da4420b7c60d64a5Tom Gundersen

6192b846ca0d15602e94ddb5da4420b7c60d64a5Tom Gundersen p = canonicalize_file_name(path);

6192b846ca0d15602e94ddb5da4420b7c60d64a5Tom Gundersen if (!p) {

6192b846ca0d15602e94ddb5da4420b7c60d64a5Tom Gundersen if (errno != ENOENT)

6192b846ca0d15602e94ddb5da4420b7c60d64a5Tom Gundersen return -errno;

6192b846ca0d15602e94ddb5da4420b7c60d64a5Tom Gundersen

7951dea20911969287878e6897b3eca348721adeSusant Sahani p = path_make_absolute_cwd(path);

7951dea20911969287878e6897b3eca348721adeSusant Sahani if (!p)

7951dea20911969287878e6897b3eca348721adeSusant Sahani return -ENOMEM;

7951dea20911969287878e6897b3eca348721adeSusant Sahani }

7951dea20911969287878e6897b3eca348721adeSusant Sahani

7951dea20911969287878e6897b3eca348721adeSusant Sahani free(*b);

7951dea20911969287878e6897b3eca348721adeSusant Sahani *b = path_kill_slashes(p);

7951dea20911969287878e6897b3eca348721adeSusant Sahani return 0;

7951dea20911969287878e6897b3eca348721adeSusant Sahani}

7951dea20911969287878e6897b3eca348721adeSusant Sahani

7951dea20911969287878e6897b3eca348721adeSusant Sahanistatic int detect_unified_cgroup_hierarchy(void) {

7951dea20911969287878e6897b3eca348721adeSusant Sahani const char *e;

7951dea20911969287878e6897b3eca348721adeSusant Sahani int r;

7951dea20911969287878e6897b3eca348721adeSusant Sahani

7951dea20911969287878e6897b3eca348721adeSusant Sahani /* Allow the user to control whether the unified hierarchy is used */

7951dea20911969287878e6897b3eca348721adeSusant Sahani e = getenv("UNIFIED_CGROUP_HIERARCHY");

7951dea20911969287878e6897b3eca348721adeSusant Sahani if (e) {

7951dea20911969287878e6897b3eca348721adeSusant Sahani r = parse_boolean(e);

7951dea20911969287878e6897b3eca348721adeSusant Sahani if (r < 0)

7951dea20911969287878e6897b3eca348721adeSusant Sahani return log_error_errno(r, "Failed to parse $UNIFIED_CGROUP_HIERARCHY.");

7951dea20911969287878e6897b3eca348721adeSusant Sahani

7951dea20911969287878e6897b3eca348721adeSusant Sahani arg_unified_cgroup_hierarchy = r;

85a8eeee36b57c1ab382b0225fa9a87525bbeee9Susant Sahani return 0;

85a8eeee36b57c1ab382b0225fa9a87525bbeee9Susant Sahani }

85a8eeee36b57c1ab382b0225fa9a87525bbeee9Susant Sahani

85a8eeee36b57c1ab382b0225fa9a87525bbeee9Susant Sahani /* Otherwise inherit the default from the host system */

85a8eeee36b57c1ab382b0225fa9a87525bbeee9Susant Sahani r = cg_unified();

85a8eeee36b57c1ab382b0225fa9a87525bbeee9Susant Sahani if (r < 0)

85a8eeee36b57c1ab382b0225fa9a87525bbeee9Susant Sahani return log_error_errno(r, "Failed to determine whether the unified cgroups hierarchy is used: %m");

85a8eeee36b57c1ab382b0225fa9a87525bbeee9Susant Sahani

85a8eeee36b57c1ab382b0225fa9a87525bbeee9Susant Sahani arg_unified_cgroup_hierarchy = r;

85a8eeee36b57c1ab382b0225fa9a87525bbeee9Susant Sahani return 0;

85a8eeee36b57c1ab382b0225fa9a87525bbeee9Susant Sahani}

02b59d57e0c08231645120077f651151f5bb2babTom Gundersen

c0dda18697e0994272c0c9616d36f6777b60e2c7Tom Gundersenstatic int parse_argv(int argc, char *argv[]) {

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen enum {

f048a16b464295a4e0a4f4c1210f06343ad31231Tom Gundersen ARG_VERSION = 0x100,

28cc555d8504c9429776aedbbe1fee7101258578Dan Williams ARG_PRIVATE_NETWORK,

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen ARG_UUID,

f882c247ad59776c3a7753bb963c1f8e2386cb79Tom Gundersen ARG_READ_ONLY,

5c1d3fc93d91384bbac29adf01074fa4375317eaUmut Tezduyar Lindskog ARG_CAPABILITY,

5c1d3fc93d91384bbac29adf01074fa4375317eaUmut Tezduyar Lindskog ARG_DROP_CAPABILITY,

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen ARG_LINK_JOURNAL,

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen ARG_BIND,

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen ARG_BIND_RO,

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen ARG_TMPFS,

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen ARG_OVERLAY,

71a6151083d842b2f5bf04e50239f0bf85d34d2eTom Gundersen ARG_OVERLAY_RO,

71a6151083d842b2f5bf04e50239f0bf85d34d2eTom Gundersen ARG_SETENV,

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen ARG_SHARE_SYSTEM,

6ae115c1fe95611b39d2f20cfcea3d385429f59eTom Gundersen ARG_REGISTER,

6ae115c1fe95611b39d2f20cfcea3d385429f59eTom Gundersen ARG_KEEP_UNIT,

6ae115c1fe95611b39d2f20cfcea3d385429f59eTom Gundersen ARG_NETWORK_INTERFACE,

6ae115c1fe95611b39d2f20cfcea3d385429f59eTom Gundersen ARG_NETWORK_MACVLAN,

5d8e593dce074bff966fc0a46579c61b4f3bc33aSusant Sahani ARG_NETWORK_IPVLAN,

5d8e593dce074bff966fc0a46579c61b4f3bc33aSusant Sahani ARG_NETWORK_BRIDGE,

5d8e593dce074bff966fc0a46579c61b4f3bc33aSusant Sahani ARG_PERSONALITY,

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen ARG_VOLATILE,

f048a16b464295a4e0a4f4c1210f06343ad31231Tom Gundersen ARG_TEMPLATE,

f048a16b464295a4e0a4f4c1210f06343ad31231Tom Gundersen ARG_PROPERTY,

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen ARG_PRIVATE_USERS,

f882c247ad59776c3a7753bb963c1f8e2386cb79Tom Gundersen ARG_KILL_SIGNAL,

aba496a58acf9d9c61314de71353550e579f85eeUmut Tezduyar Lindskog ARG_SETTINGS,

407fe036a24834203aca6c1eec7d74d9ad3e9ee0Tom Gundersen };

5a8bcb674f71a20e95df55319b34c556638378ceLennart Poettering

5a8bcb674f71a20e95df55319b34c556638378ceLennart Poettering static const struct option options[] = {

9505d3c6deda0452c22ab2ed47bca74b98d87a17Tom Gundersen { "help", no_argument, NULL, 'h' },

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen { "version", no_argument, NULL, ARG_VERSION },

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen { "directory", required_argument, NULL, 'D' },

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen { "template", required_argument, NULL, ARG_TEMPLATE },

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen { "ephemeral", no_argument, NULL, 'x' },

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen { "user", required_argument, NULL, 'u' },

71a6151083d842b2f5bf04e50239f0bf85d34d2eTom Gundersen { "private-network", no_argument, NULL, ARG_PRIVATE_NETWORK },

71a6151083d842b2f5bf04e50239f0bf85d34d2eTom Gundersen { "boot", no_argument, NULL, 'b' },

f579559b3a14c1f1ef96c372e7626c4733e6ef7dTom Gundersen { "uuid", required_argument, NULL, ARG_UUID },

eb0ea358b688a6f83ff305c6b825c61f12b6dcb8Tom Gundersen { "read-only", no_argument, NULL, ARG_READ_ONLY },

eb0ea358b688a6f83ff305c6b825c61f12b6dcb8Tom Gundersen { "capability", required_argument, NULL, ARG_CAPABILITY },

eb0ea358b688a6f83ff305c6b825c61f12b6dcb8Tom Gundersen { "drop-capability", required_argument, NULL, ARG_DROP_CAPABILITY },

eb0ea358b688a6f83ff305c6b825c61f12b6dcb8Tom Gundersen { "link-journal", required_argument, NULL, ARG_LINK_JOURNAL },

6ae115c1fe95611b39d2f20cfcea3d385429f59eTom Gundersen { "bind", required_argument, NULL, ARG_BIND },

6ae115c1fe95611b39d2f20cfcea3d385429f59eTom Gundersen { "bind-ro", required_argument, NULL, ARG_BIND_RO },

6ae115c1fe95611b39d2f20cfcea3d385429f59eTom Gundersen { "tmpfs", required_argument, NULL, ARG_TMPFS },

6ae115c1fe95611b39d2f20cfcea3d385429f59eTom Gundersen { "overlay", required_argument, NULL, ARG_OVERLAY },

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta { "overlay-ro", required_argument, NULL, ARG_OVERLAY_RO },

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta { "machine", required_argument, NULL, 'M' },

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta { "slice", required_argument, NULL, 'S' },

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta { "setenv", required_argument, NULL, ARG_SETENV },

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta { "selinux-context", required_argument, NULL, 'Z' },

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta { "selinux-apifs-context", required_argument, NULL, 'L' },

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta { "quiet", no_argument, NULL, 'q' },

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta { "share-system", no_argument, NULL, ARG_SHARE_SYSTEM },

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta { "register", required_argument, NULL, ARG_REGISTER },

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta { "keep-unit", no_argument, NULL, ARG_KEEP_UNIT },

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta { "network-interface", required_argument, NULL, ARG_NETWORK_INTERFACE },

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta { "network-macvlan", required_argument, NULL, ARG_NETWORK_MACVLAN },

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta { "network-ipvlan", required_argument, NULL, ARG_NETWORK_IPVLAN },

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta { "network-veth", no_argument, NULL, 'n' },

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta { "network-bridge", required_argument, NULL, ARG_NETWORK_BRIDGE },

b98b483bac585af754e8a22ea890db8486905d8aAlin Rauta { "personality", required_argument, NULL, ARG_PERSONALITY },

ed942a9eb22d50f667909ad6184b45015d28d054Tom Gundersen { "image", required_argument, NULL, 'i' },

ed942a9eb22d50f667909ad6184b45015d28d054Tom Gundersen { "volatile", optional_argument, NULL, ARG_VOLATILE },

ed942a9eb22d50f667909ad6184b45015d28d054Tom Gundersen { "port", required_argument, NULL, 'p' },

ed942a9eb22d50f667909ad6184b45015d28d054Tom Gundersen { "property", required_argument, NULL, ARG_PROPERTY },

ed942a9eb22d50f667909ad6184b45015d28d054Tom Gundersen { "private-users", optional_argument, NULL, ARG_PRIVATE_USERS },

ed942a9eb22d50f667909ad6184b45015d28d054Tom Gundersen { "kill-signal", required_argument, NULL, ARG_KILL_SIGNAL },

bd8f65387673e29f46136a4ed172097035002c23Tom Gundersen { "settings", required_argument, NULL, ARG_SETTINGS },

bd8f65387673e29f46136a4ed172097035002c23Tom Gundersen {}

bd8f65387673e29f46136a4ed172097035002c23Tom Gundersen };

bd8f65387673e29f46136a4ed172097035002c23Tom Gundersen

bd8f65387673e29f46136a4ed172097035002c23Tom Gundersen int c, r;

bd8f65387673e29f46136a4ed172097035002c23Tom Gundersen uint64_t plus = 0, minus = 0;

bd8f65387673e29f46136a4ed172097035002c23Tom Gundersen bool mask_all_settings = false, mask_no_settings = false;

bd8f65387673e29f46136a4ed172097035002c23Tom Gundersen

bd8f65387673e29f46136a4ed172097035002c23Tom Gundersen assert(argc >= 0);

11bf3cced13c885ca215c108cb0bdb7a148520d6Lennart Poettering assert(argv);

11bf3cced13c885ca215c108cb0bdb7a148520d6Lennart Poettering

0dd25fb9f005d8ab7ac4bc10a609d00569f8c56aLennart Poettering while ((c = getopt_long(argc, argv, "+hD:u:bL:M:jS:Z:qi:xp:n", options, NULL)) >= 0)

0dd25fb9f005d8ab7ac4bc10a609d00569f8c56aLennart Poettering

11bf3cced13c885ca215c108cb0bdb7a148520d6Lennart Poettering switch (c) {

11bf3cced13c885ca215c108cb0bdb7a148520d6Lennart Poettering

11bf3cced13c885ca215c108cb0bdb7a148520d6Lennart Poettering case 'h':

cb9fc36a1211967e8c58b0502a26c42552ac8060Lennart Poettering help();

cb9fc36a1211967e8c58b0502a26c42552ac8060Lennart Poettering return 0;

cb9fc36a1211967e8c58b0502a26c42552ac8060Lennart Poettering

769d324c99aab129148bd25f5f663ef441287d86Lennart Poettering case ARG_VERSION:

769d324c99aab129148bd25f5f663ef441287d86Lennart Poettering puts(PACKAGE_STRING);

e331e24649213f2e093e16e4d3d64ee823dfc375Tom Gundersen puts(SYSTEMD_FEATURES);

e331e24649213f2e093e16e4d3d64ee823dfc375Tom Gundersen return 0;

e331e24649213f2e093e16e4d3d64ee823dfc375Tom Gundersen

e331e24649213f2e093e16e4d3d64ee823dfc375Tom Gundersen case 'D':

e331e24649213f2e093e16e4d3d64ee823dfc375Tom Gundersen r = set_sanitized_path(&arg_directory, optarg);

if (r < 0)

return log_error_errno(r, "Invalid root directory: %m");

break;

case ARG_TEMPLATE:

r = set_sanitized_path(&arg_template, optarg);

if (r < 0)

return log_error_errno(r, "Invalid template directory: %m");

break;

case 'i':

r = set_sanitized_path(&arg_image, optarg);

if (r < 0)

return log_error_errno(r, "Invalid image path: %m");

break;

case 'x':

arg_ephemeral = true;

break;

case 'u':

r = free_and_strdup(&arg_user, optarg);

if (r < 0)

return log_oom();

arg_settings_mask |= SETTING_USER;

break;

case ARG_NETWORK_BRIDGE:

r = free_and_strdup(&arg_network_bridge, optarg);

if (r < 0)

return log_oom();

/* fall through */

case 'n':

arg_network_veth = true;

arg_private_network = true;

arg_settings_mask |= SETTING_NETWORK;

break;

case ARG_NETWORK_INTERFACE:

if (strv_extend(&arg_network_interfaces, optarg) < 0)

return log_oom();

arg_private_network = true;

arg_settings_mask |= SETTING_NETWORK;

break;

case ARG_NETWORK_MACVLAN:

if (strv_extend(&arg_network_macvlan, optarg) < 0)

return log_oom();

arg_private_network = true;

arg_settings_mask |= SETTING_NETWORK;

break;

case ARG_NETWORK_IPVLAN:

if (strv_extend(&arg_network_ipvlan, optarg) < 0)

return log_oom();

/* fall through */

case ARG_PRIVATE_NETWORK:

arg_private_network = true;

arg_settings_mask |= SETTING_NETWORK;

break;

case 'b':

arg_boot = true;

arg_settings_mask |= SETTING_BOOT;

break;

case ARG_UUID:

r = sd_id128_from_string(optarg, &arg_uuid);

if (r < 0) {

log_error("Invalid UUID: %s", optarg);

return r;

}

arg_settings_mask |= SETTING_MACHINE_ID;

break;

case 'S':

arg_slice = optarg;

break;

case 'M':

if (isempty(optarg))

arg_machine = mfree(arg_machine);

else {

if (!machine_name_is_valid(optarg)) {

log_error("Invalid machine name: %s", optarg);

return -EINVAL;

}

r = free_and_strdup(&arg_machine, optarg);

if (r < 0)

return log_oom();

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_CAPABILITY:

case ARG_DROP_CAPABILITY: {

const char *state, *word;

size_t length;

FOREACH_WORD_SEPARATOR(word, length, optarg, ",", state) {

_cleanup_free_ char *t;

t = strndup(word, length);

if (!t)

return log_oom();

if (streq(t, "all")) {

if (c == ARG_CAPABILITY)

plus = (uint64_t) -1;

else

minus = (uint64_t) -1;

} else {

int cap;

cap = capability_from_name(t);

if (cap < 0) {

log_error("Failed to parse capability %s.", t);

return -EINVAL;

}

if (c == ARG_CAPABILITY)

plus |= 1ULL << (uint64_t) cap;

else

minus |= 1ULL << (uint64_t) cap;

}

}

arg_settings_mask |= SETTING_CAPABILITY;

break;

}

case 'j':

arg_link_journal = LINK_GUEST;

arg_link_journal_try = true;

break;

case ARG_LINK_JOURNAL:

if (streq(optarg, "auto")) {

arg_link_journal = LINK_AUTO;

arg_link_journal_try = false;

} else if (streq(optarg, "no")) {

arg_link_journal = LINK_NO;

arg_link_journal_try = false;

} else if (streq(optarg, "guest")) {

arg_link_journal = LINK_GUEST;

arg_link_journal_try = false;

} else if (streq(optarg, "host")) {

arg_link_journal = LINK_HOST;

arg_link_journal_try = false;

} else if (streq(optarg, "try-guest")) {

arg_link_journal = LINK_GUEST;

arg_link_journal_try = true;

} else if (streq(optarg, "try-host")) {

arg_link_journal = LINK_HOST;

arg_link_journal_try = true;

} else {

log_error("Failed to parse link journal mode %s", optarg);

return -EINVAL;

}

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: {

_cleanup_free_ char *upper = NULL, *destination = NULL;

_cleanup_strv_free_ char **lower = NULL;

CustomMount *m;

unsigned n = 0;

char **i;

r = strv_split_extract(&lower, optarg, ":", EXTRACT_DONT_COALESCE_SEPARATORS);

if (r == -ENOMEM)

return log_oom();

else if (r < 0) {

log_error("Invalid overlay specification: %s", optarg);

return r;

}

STRV_FOREACH(i, lower) {

if (!path_is_absolute(*i)) {

log_error("Overlay path %s is not absolute.", *i);

return -EINVAL;

}

n++;

}

if (n < 2) {

log_error("--overlay= needs at least two colon-separated directories specified.");

return -EINVAL;

}

if (n == 2) {

/* If two parameters are specified,

upper = lower[1];

lower[1] = NULL;

destination = strdup(upper);

if (!destination)

return log_oom();

} else {

upper = lower[n - 2];

destination = lower[n - 1];

lower[n - 2] = NULL;

}

m = custom_mount_add(&arg_custom_mounts, &arg_n_custom_mounts, CUSTOM_MOUNT_OVERLAY);

if (!m)

return log_oom();

m->destination = destination;

m->source = upper;

m->lower = lower;

m->read_only = c == ARG_OVERLAY_RO;

upper = destination = NULL;

lower = NULL;

arg_settings_mask |= SETTING_CUSTOM_MOUNTS;

break;

}

case ARG_SETENV: {

char **n;

if (!env_assignment_is_valid(optarg)) {

log_error("Environment variable assignment '%s' is not valid.", optarg);

return -EINVAL;

}

n = strv_env_set(arg_setenv, optarg);

if (!n)

return log_oom();

strv_free(arg_setenv);

arg_setenv = n;

arg_settings_mask |= SETTING_ENVIRONMENT;

break;

}

case 'q':

arg_quiet = true;

break;

case ARG_SHARE_SYSTEM:

arg_share_system = true;

break;

case ARG_REGISTER:

r = parse_boolean(optarg);

if (r < 0) {

log_error("Failed to parse --register= argument: %s", optarg);

return r;

}

arg_register = 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) {

log_error("Unknown or unsupported personality '%s'.", optarg);

return -EINVAL;

}

arg_settings_mask |= SETTING_PERSONALITY;

break;

case ARG_VOLATILE:

if (!optarg)

arg_volatile_mode = VOLATILE_YES;

else {

VolatileMode m;

m = volatile_mode_from_string(optarg);

if (m < 0) {

log_error("Failed to parse --volatile= argument: %s", optarg);

return -EINVAL;

} 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:

if (optarg) {

_cleanup_free_ char *buffer = NULL;

const char *range, *shift;

range = strchr(optarg, ':');

if (range) {

buffer = strndup(optarg, range - optarg);

if (!buffer)

return log_oom();

shift = buffer;

range++;

if (safe_atou32(range, &arg_uid_range) < 0 || arg_uid_range <= 0) {

log_error("Failed to parse UID range: %s", range);

return -EINVAL;

}

} else

shift = optarg;

if (parse_uid(shift, &arg_uid_shift) < 0) {

log_error("Failed to parse UID: %s", optarg);

return -EINVAL;

}

}

arg_userns = true;

break;

case ARG_KILL_SIGNAL:

arg_kill_signal = signal_from_string_try_harder(optarg);

if (arg_kill_signal < 0) {

log_error("Cannot parse signal: %s", optarg);

return -EINVAL;

}

arg_settings_mask |= SETTING_KILL_SIGNAL;

break;

case ARG_SETTINGS:

/* no → do not read files

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 '?':

return -EINVAL;

default:

assert_not_reached("Unhandled option");

}

if (arg_share_system)

arg_register = false;

if (arg_boot && arg_share_system) {

log_error("--boot and --share-system may not be combined.");

return -EINVAL;

}

if (arg_keep_unit && cg_pid_get_owner_uid(0, NULL) >= 0) {

log_error("--keep-unit may not be used when invoked from a user session.");

return -EINVAL;

}

if (arg_directory && arg_image) {

log_error("--directory= and --image= may not be combined.");

return -EINVAL;

}

if (arg_template && arg_image) {

log_error("--template= and --image= may not be combined.");

return -EINVAL;

}

if (arg_template && !(arg_directory || arg_machine)) {

log_error("--template= needs --directory= or --machine=.");

return -EINVAL;

}

if (arg_ephemeral && arg_template) {

log_error("--ephemeral and --template= may not be combined.");

return -EINVAL;

}

if (arg_ephemeral && arg_image) {

log_error("--ephemeral and --image= may not be combined.");

return -EINVAL;

}

if (arg_ephemeral && !IN_SET(arg_link_journal, LINK_NO, LINK_AUTO)) {

log_error("--ephemeral and --link-journal= may not be combined.");

return -EINVAL;

}

if (arg_userns && access("/proc/self/uid_map", F_OK) < 0)

return log_error_errno(EOPNOTSUPP, "--private-users= is not supported, kernel compiled without user namespace support.");

if (argc > optind) {

arg_parameters = strv_copy(argv + optind);

if (!arg_parameters)

return log_oom();

arg_settings_mask |= SETTING_BOOT;

}

/* 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;

arg_retain = (arg_retain | plus | (arg_private_network ? 1ULL << CAP_NET_ADMIN : 0)) & ~minus;

r = detect_unified_cgroup_hierarchy();

if (r < 0)

return r;

return 1;

}

static int verify_arguments(void) {

if (arg_volatile_mode != VOLATILE_NO && arg_read_only) {

log_error("Cannot combine --read-only with --volatile. Note that --volatile already implies a read-only base hierarchy.");

return -EINVAL;

}

if (arg_expose_ports && !arg_private_network) {

log_error("Cannot use --port= without private networking.");

return -EINVAL;

}

if (arg_boot && arg_kill_signal <= 0)

arg_kill_signal = SIGRTMIN+3;

return 0;

}

static int userns_lchown(const char *p, uid_t uid, gid_t gid) {

assert(p);

if (!arg_userns)

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 (lchown(p, uid, gid) < 0)

return -errno;

return 0;

}

static int userns_mkdir(const char *root, const char *path, mode_t mode, uid_t uid, gid_t gid) {

const char *q;

q = prefix_roota(root, path);

if (mkdir(q, mode) < 0) {

if (errno == EEXIST)

return 0;

return -errno;

}

return userns_lchown(q, uid, gid);

}

static int setup_timezone(const char *dest) {

_cleanup_free_ char *p = NULL, *q = NULL;

const char *where, *check, *what;

char *z, *y;

int r;

assert(dest);

/* Fix the timezone, if possible */

r = readlink_malloc("/etc/localtime", &p);

if (r < 0) {

log_warning("/etc/localtime is not a symlink, not updating container timezone.");

return 0;

}

z = path_startswith(p, "../usr/share/zoneinfo/");

if (!z)

z = path_startswith(p, "/usr/share/zoneinfo/");

if (!z) {

log_warning("/etc/localtime does not point into /usr/share/zoneinfo/, not updating container timezone.");

return 0;

}

where = prefix_roota(dest, "/etc/localtime");

r = readlink_malloc(where, &q);

if (r >= 0) {

y = path_startswith(q, "../usr/share/zoneinfo/");

if (!y)

y = path_startswith(q, "/usr/share/zoneinfo/");

/* Already pointing to the right place? Then do nothing .. */

if (y && streq(y, z))

return 0;

}

check = strjoina("/usr/share/zoneinfo/", z);

check = prefix_root(dest, check);

if (laccess(check, F_OK) < 0) {

log_warning("Timezone %s does not exist in container, not updating container timezone.", z);

return 0;

}

r = unlink(where);

if (r < 0 && errno != ENOENT) {

log_error_errno(errno, "Failed to remove existing timezone info %s in container: %m", where);

return 0;

}

what = strjoina("../usr/share/zoneinfo/", z);

if (symlink(what, where) < 0) {

log_error_errno(errno, "Failed to correct timezone of container: %m");

return 0;

}

r = userns_lchown(where, 0, 0);

if (r < 0)

return log_warning_errno(r, "Failed to chown /etc/localtime: %m");

return 0;

}

static int setup_resolv_conf(const char *dest) {

const char *where = NULL;

int r;

assert(dest);

if (arg_private_network)

return 0;

/* Fix resolv.conf, if possible */

where = prefix_roota(dest, "/etc/resolv.conf");

r = copy_file("/etc/resolv.conf", where, O_TRUNC|O_NOFOLLOW, 0644, 0);

if (r < 0) {

/* If the file already exists as symlink, let's

log_full_errno(IN_SET(r, -ELOOP, -EROFS) ? LOG_DEBUG : LOG_WARNING, r,

"Failed to copy /etc/resolv.conf to %s: %m", where);

return 0;

}

r = userns_lchown(where, 0, 0);

if (r < 0)

log_warning_errno(r, "Failed to chown /etc/resolv.conf: %m");

return 0;

}

static char* id128_format_as_uuid(sd_id128_t id, char s[37]) {

assert(s);

snprintf(s, 37,

"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",

SD_ID128_FORMAT_VAL(id));

return s;

}

static int setup_boot_id(const char *dest) {

const char *from, *to;

sd_id128_t rnd = {};

char as_uuid[37];

int r;

if (arg_share_system)

return 0;

/* Generate a new randomized boot ID, so that each boot-up of

from = prefix_roota(dest, "/run/proc-sys-kernel-random-boot-id");

to = prefix_roota(dest, "/proc/sys/kernel/random/boot_id");

r = sd_id128_randomize(&rnd);

if (r < 0)

return log_error_errno(r, "Failed to generate random boot id: %m");

id128_format_as_uuid(rnd, as_uuid);

r = write_string_file(from, as_uuid, WRITE_STRING_FILE_CREATE);

if (r < 0)

return log_error_errno(r, "Failed to write boot id: %m");

if (mount(from, to, NULL, MS_BIND, NULL) < 0)

r = log_error_errno(errno, "Failed to bind mount boot id: %m");

else if (mount(NULL, to, NULL, MS_BIND|MS_REMOUNT|MS_RDONLY|MS_NOSUID|MS_NODEV, NULL) < 0)

log_warning_errno(errno, "Failed to make boot id read-only: %m");

unlink(from);

return r;

}

static int copy_devnodes(const char *dest) {

static const char devnodes[] =

"null\0"

"zero\0"

"full\0"

"random\0"

"urandom\0"

"tty\0"

"net/tun\0";

const char *d;

int r = 0;

_cleanup_umask_ mode_t u;

assert(dest);

u = umask(0000);

/* Create /dev/net, so that we can create /dev/net/tun in it */

if (userns_mkdir(dest, "/dev/net", 0755, 0, 0) < 0)

return log_error_errno(r, "Failed to create /dev/net directory: %m");

NULSTR_FOREACH(d, devnodes) {

_cleanup_free_ char *from = NULL, *to = NULL;

struct stat st;

from = strappend("/dev/", d);

to = prefix_root(dest, from);

if (stat(from, &st) < 0) {

if (errno != ENOENT)

return log_error_errno(errno, "Failed to stat %s: %m", from);

} else if (!S_ISCHR(st.st_mode) && !S_ISBLK(st.st_mode)) {

log_error("%s is not a char or block device, cannot copy.", from);

return -EIO;

} else {

if (mknod(to, st.st_mode, st.st_rdev) < 0) {

if (errno != EPERM)

return log_error_errno(errno, "mknod(%s) failed: %m", to);

/* Some systems abusively restrict mknod but

r = touch(to);

if (r < 0)

return log_error_errno(r, "touch (%s) failed: %m", to);

if (mount(from, to, NULL, MS_BIND, NULL) < 0)

return log_error_errno(errno, "Both mknod and bind mount (%s) failed: %m", to);

}

r = userns_lchown(to, 0, 0);

if (r < 0)

return log_error_errno(r, "chown() of device node %s failed: %m", to);

}

}

return r;

}

static int setup_pts(const char *dest) {

_cleanup_free_ char *options = NULL;

const char *p;

#ifdef HAVE_SELINUX

if (arg_selinux_apifs_context)

(void) asprintf(&options,

"newinstance,ptmxmode=0666,mode=620,gid=" GID_FMT ",context=\"%s\"",

arg_uid_shift + TTY_GID,

arg_selinux_apifs_context);

else

#endif

(void) asprintf(&options,

"newinstance,ptmxmode=0666,mode=620,gid=" GID_FMT,

arg_uid_shift + TTY_GID);

if (!options)

return log_oom();

/* Mount /dev/pts itself */

p = prefix_roota(dest, "/dev/pts");

if (mkdir(p, 0755) < 0)

return log_error_errno(errno, "Failed to create /dev/pts: %m");

if (mount("devpts", p, "devpts", MS_NOSUID|MS_NOEXEC, options) < 0)

return log_error_errno(errno, "Failed to mount /dev/pts: %m");

if (userns_lchown(p, 0, 0) < 0)

return log_error_errno(errno, "Failed to chown /dev/pts: %m");

/* Create /dev/ptmx symlink */

p = prefix_roota(dest, "/dev/ptmx");

if (symlink("pts/ptmx", p) < 0)

return log_error_errno(errno, "Failed to create /dev/ptmx symlink: %m");

if (userns_lchown(p, 0, 0) < 0)

return log_error_errno(errno, "Failed to chown /dev/ptmx: %m");

/* And fix /dev/pts/ptmx ownership */

p = prefix_roota(dest, "/dev/pts/ptmx");

if (userns_lchown(p, 0, 0) < 0)

return log_error_errno(errno, "Failed to chown /dev/pts/ptmx: %m");

return 0;

}

static int setup_dev_console(const char *dest, const char *console) {

_cleanup_umask_ mode_t u;

const char *to;

int r;

assert(dest);

assert(console);

u = umask(0000);

r = chmod_and_chown(console, 0600, arg_uid_shift, arg_uid_shift);

if (r < 0)

return log_error_errno(r, "Failed to correct access mode for TTY: %m");

/* We need to bind mount the right tty to /dev/console since

to = prefix_roota(dest, "/dev/console");

r = touch(to);

if (r < 0)

return log_error_errno(r, "touch() for /dev/console failed: %m");

if (mount(console, to, NULL, MS_BIND, NULL) < 0)

return log_error_errno(errno, "Bind mount for /dev/console failed: %m");

return 0;

}

static int setup_kmsg(const char *dest, int kmsg_socket) {

const char *from, *to;

_cleanup_umask_ mode_t u;

int fd, r;

assert(kmsg_socket >= 0);

u = umask(0000);

/* We create the kmsg FIFO as /run/kmsg, but immediately

from = prefix_roota(dest, "/run/kmsg");

to = prefix_roota(dest, "/proc/kmsg");

if (mkfifo(from, 0600) < 0)

return log_error_errno(errno, "mkfifo() for /run/kmsg failed: %m");

if (mount(from, to, NULL, MS_BIND, NULL) < 0)

return log_error_errno(errno, "Bind mount for /proc/kmsg failed: %m");

fd = open(from, O_RDWR|O_NDELAY|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

r = send_one_fd(kmsg_socket, fd, 0);

safe_close(fd);

if (r < 0)

return log_error_errno(r, "Failed to send FIFO fd: %m");

/* And now make the FIFO unavailable as /run/kmsg... */

(void) unlink(from);

return 0;

}

static int on_address_change(sd_netlink *rtnl, sd_netlink_message *m, void *userdata) {

union in_addr_union *exposed = userdata;

assert(rtnl);

assert(m);

assert(exposed);

expose_port_execute(rtnl, arg_expose_ports, exposed);

return 0;

}

static int setup_hostname(void) {

if (arg_share_system)

return 0;

if (sethostname_idempotent(arg_machine) < 0)

return -errno;

return 0;

}

static int setup_journal(const char *directory) {

sd_id128_t machine_id, this_id;

_cleanup_free_ char *b = NULL, *d = NULL;

const char *etc_machine_id, *p, *q;

char *id;

int r;

/* Don't link journals in ephemeral mode */

if (arg_ephemeral)

return 0;

etc_machine_id = prefix_roota(directory, "/etc/machine-id");

r = read_one_line_file(etc_machine_id, &b);

if (r == -ENOENT && arg_link_journal == LINK_AUTO)

return 0;

else if (r < 0)

return log_error_errno(r, "Failed to read machine ID from %s: %m", etc_machine_id);

id = strstrip(b);

if (isempty(id) && arg_link_journal == LINK_AUTO)

return 0;

/* Verify validity */

r = sd_id128_from_string(id, &machine_id);

if (r < 0)

return log_error_errno(r, "Failed to parse machine ID from %s: %m", etc_machine_id);