#include <bitset>

#include <sys/mount.h>

#include <sys/utsname.h>

#include <sys/socket.h>

#include <sys/sysmacros.h>

#include <pwd.h>

#include <future>

#include <signal.h>

#include <pty.h>

#include <lxbusapi.h>

#include "common.h"

#include "mountutilcpp.h"

#include "config.h"

#include "util.h"

#include "configfile.h"

#include "binfmt.h"

#include "wslpath.h"

#include "wslinfo.h"

#include "drvfs.h"

#include "timezone.h"

#include "message.h"

#include "WslDistributionConfig.h"

#include "lxfsshares.h"

#include "plan9.h"

#define AUTO_MOUNT_PARENT_MODE 0755

#define CGROUP_DEVICE "cgroup"

#define CGROUPS_FILE "/proc/cgroups"

#define CGROUPS_NO_V1 "cgroup_no_v1="

#define DEFAULT_CWD "/"

#define DRVFS_MOUNT_OPTIONS (MS_NOATIME)

#define DRVFS_SOURCE " :\\"

#define DRVFS_TARGET_MODE 0777

#define DRVFS_OPTIONS_BUFFER_LENGTH 38

#define ETC_DEFAULT_FOLDER ETC_FOLDER "default/"

#define HOSTNAME_FILE_PATH ETC_FOLDER "hostname"

#define HOSTNAME_FILE_MODE 0644

#define HOSTS_FILE_MODE 0644

#define HOSTS_FILE_PATH ETC_FOLDER "hosts"

#define LANG_ENV "LANG"

#define LOCALE_FILE_PATH ETC_DEFAULT_FOLDER "locale"

#define PATH_ENV "PATH"

#define RESOLV_CONF_DIRECTORY_MODE 0755

#define RESOLV_CONF_FILE_MODE 0644

#define RESOLV_CONF_FILE_NAME "resolv.conf"

#define RESOLV_CONF_FILE_PATH ETC_FOLDER RESOLV_CONF_FILE_NAME

#define RESOLV_CONF_FOLDER RUN_FOLDER "/resolvconf"

#define RESOLV_CONF_SYMLINK_TARGET ".." RESOLV_CONF_FOLDER "/" RESOLV_CONF_FILE_NAME

#define RESOLV_CONF_SYMLINK_WSL_MOUNT_SUFFIX SHARED_MOUNT_FOLDER "/" RESOLV_CONF_FILE_NAME

#define RUN_FOLDER "/run"

#define SHARED_MOUNT_FOLDER "wsl"

#define USER_MOUNT_FOLDER "user"

#define WINDOWS_LD_CONF_FILE "/etc/ld.so.conf.d/ld.wsl.conf"

#define WINDOWS_LD_CONF_FILE_MODE 0644

#define MOUNTS_FILE "/proc/self/mounts"

#define MOUNTS_FIELD_SEPARATOR ' '

#define MOUNTS_LINE_SEPARATOR '\n'

#define MOUNTS_DEVICE_FIELD 0

#define MOUNTS_FSTYPE_FIELD 2

static void ConfigApplyWindowsLibPath(const wsl::linux::WslDistributionConfig& Config);

class RemoveMountAndEnvironmentOnScopeExit

};

constexpr auto HostsFileFormatString = LX_INIT_AUTO_GENERATED_FILE_HEADER

"# [network]\n"

"# generateHosts = false\n"

"127.0.0.1\tlocalhost\n"

"127.0.1.1\t{}.{}\t{}\n"

"{}\n"

"# The following lines are desirable for IPv6 capable hosts\n"

"::1 ip6-localhost ip6-loopback\n"

"fe00::0 ip6-localnet\n"

"ff00::0 ip6-mcastprefix\n"

"ff02::1 ip6-allnodes\n"

"ff02::2 ip6-allrouters\n";

constexpr auto WindowsLibSearchFileHeaderString = LX_INIT_AUTO_GENERATED_FILE_HEADER

"# [automount]\n"

"# ldconfig = false\n";

const INIT_STARTUP_ANY LxssStartupCommon[] = {

INIT_ANY_DIRECTORY("/sys", ROOT_UID, ROOT_GID, S_IFDIR | 0755),

INIT_ANY_MOUNT_DEVICE("/sys", "sysfs", "sysfs", (MS_NOSUID | MS_NODEV | MS_NOEXEC | MS_NOATIME | MS_SHARED)),

INIT_ANY_DIRECTORY("/proc", ROOT_UID, ROOT_GID, S_IFDIR | 0755),

INIT_ANY_MOUNT_DEVICE("/proc", "proc", "proc", (MS_NOSUID | MS_NODEV | MS_NOEXEC | MS_NOATIME | MS_SHARED)),

INIT_ANY_DIRECTORY("/dev/block", ROOT_UID, ROOT_GID, S_IFDIR | 0755),

INIT_ANY_SYMLINK("/dev/fd", "/proc/self/fd"),

INIT_ANY_SYMLINK("/dev/stdin", "/proc/self/fd/0"),

INIT_ANY_SYMLINK("/dev/stdout", "/proc/self/fd/1"),

INIT_ANY_SYMLINK("/dev/stderr", "/proc/self/fd/2"),

INIT_ANY_DIRECTORY("/dev/pts", ROOT_UID, ROOT_GID, S_IFDIR | 0755),

INIT_ANY_MOUNT_DEVICE_OPTION("/dev/pts", "devpts", "devpts", "gid=5,mode=620", MS_NOATIME | MS_NOSUID | MS_NOEXEC),

INIT_ANY_DIRECTORY("/run", ROOT_UID, ROOT_GID, S_IFDIR | 0755),

INIT_ANY_MOUNT_OPTION("/run", "tmpfs", "mode=755", (MS_NODEV | MS_STRICTATIME | MS_NOSUID | MS_SHARED)),

INIT_ANY_DIRECTORY("/run/lock", ROOT_UID, ROOT_GID, S_IFDIR | 0755),

INIT_ANY_MOUNT("/run/lock", "tmpfs", MS_NOATIME | MS_NOSUID | MS_NOEXEC | MS_NODEV | MS_SHARED),

INIT_ANY_DIRECTORY("/run/shm", ROOT_UID, ROOT_GID, S_IFDIR | 0755),

INIT_ANY_MOUNT("/run/shm", "tmpfs", MS_NOATIME | MS_NOSUID | MS_NODEV | MS_SHARED),

INIT_ANY_DIRECTORY("/dev/shm", ROOT_UID, ROOT_GID, S_IFDIR | 0755),

INIT_ANY_MOUNT_DEVICE("/dev/shm", nullptr, "/run/shm", MS_BIND),

INIT_ANY_DIRECTORY("/run/user", ROOT_UID, ROOT_GID, S_IFDIR | 0755),

INIT_ANY_MOUNT_OPTION("/run/user", "tmpfs", "mode=755", MS_NOATIME | MS_NOSUID | MS_NOEXEC | MS_NODEV),

INIT_ANY_DIRECTORY("/bin", ROOT_UID, ROOT_GID, S_IFDIR | 0755),

INIT_ANY_SYMLINK("/bin/" WSLINFO_NAME, "/init"),

INIT_ANY_SYMLINK("/bin/" WSLPATH_NAME, "/init"),

INIT_ANY_DIRECTORY("/sbin", ROOT_UID, ROOT_GID, S_IFDIR | 0755),

INIT_ANY_SYMLINK("/sbin/" MOUNT_DRVFS_NAME, "/init"),

INIT_ANY_MOUNT_DEVICE(BINFMT_MISC_MOUNT_TARGET, "binfmt_misc", "binfmt_misc", MS_RELATIME),

INIT_ANY_DIRECTORY("/tmp", ROOT_UID, ROOT_GID, S_IFDIR | S_ISVTX | 0777)};

const INIT_STARTUP_ANY LxssStartupLoggingVmMode[] = {

INIT_ANY_DIRECTORY("/dev", ROOT_UID, ROOT_GID, S_IFDIR | 0755),

INIT_ANY_MOUNT_OPTION("/dev", "devtmpfs", "mode=755", (MS_NOSUID | MS_RELATIME | MS_SHARED))};

const INIT_STARTUP_ANY LxssStartupLoggingWsl[] = {

INIT_ANY_DIRECTORY("/dev", ROOT_UID, ROOT_GID, S_IFDIR | 0755),

INIT_ANY_MOUNT_OPTION("/dev", "tmpfs", "mode=755", MS_NOATIME | MS_SHARED),

INIT_ANY_NODE("/dev/kmsg", ROOT_UID, ROOT_GID, S_IFCHR | 0644, INIT_DEV_LOG_KMSG_MAJOR_NUMBER, INIT_DEV_LOG_KMSG_MINOR_NUMBER)};

const INIT_STARTUP_ANY LxssStartupWsl[] = {

INIT_ANY_NODE("/dev/ptmx", ROOT_UID, TTY_GID, S_IFCHR | 0666, INIT_DEV_PTM_MAJOR_NUMBER, INIT_DEV_PTM_MINOR_NUMBER),

INIT_ANY_NODE("/dev/random", ROOT_UID, ROOT_GID, S_IFCHR | 0666, INIT_DEV_RANDOM_MAJOR_NUMBER, INIT_DEV_RANDOM_MINOR_NUMBER),

INIT_ANY_NODE("/dev/urandom", ROOT_UID, ROOT_GID, S_IFCHR | 0666, INIT_DEV_URANDOM_MAJOR_NUMBER, INIT_DEV_URANDOM_MINOR_NUMBER),

INIT_ANY_NODE("/dev/null", ROOT_UID, ROOT_GID, S_IFCHR | 0666, INIT_DEV_NULL_MAJOR_NUMBER, INIT_DEV_NULL_MINOR_NUMBER),

INIT_ANY_NODE("/dev/tty", ROOT_UID, TTY_GID, S_IFCHR | 0666, INIT_DEV_TTYCT_MAJOR_NUMBER, INIT_DEV_TTYCT_MINOR_NUMBER),

INIT_ANY_NODE("/dev/tty0", ROOT_UID, TTY_GID, S_IFCHR | 0620, INIT_DEV_TTY_MAJOR_NUMBER, INIT_DEV_TTY0_MINOR_NUMBER),

INIT_ANY_NODE("/dev/zero", ROOT_UID, ROOT_GID, S_IFCHR | 0666, INIT_DEV_ZERO_MAJOR_NUMBER, INIT_DEV_ZERO_MINOR_NUMBER),

INIT_ANY_NODE(LXBUS_DEVICE_NAME, ROOT_UID, ROOT_GID, S_IFCHR | 0666, INIT_DEV_LXBUS_MAJOR_NUMBER, INIT_DEV_LXBUS_MINOR_NUMBER)};

int g_ElevatedMountNamespace = -1;

int g_NonElevatedMountNamespace = -1;

extern wsl::shared::SocketChannel g_plan9ControlChannel;

void ConfigAppendNtPath(EnvironmentBlock& Environment, char* NtPath)

try

{

auto TranslatedPath = UtilTranslatePathList(NtPath, true);

if (!TranslatedPath.has_value())

{

return;

}

ConfigAppendToPath(Environment, TranslatedPath.value());

return;

}

CATCH_LOG()

void ConfigAppendToPath(EnvironmentBlock& Environment, std::string_view PathElement)

try

{

//

// If no PATH variable is present, create a new variable. If a PATH is

// present, add the path element onto the end of the existing value.

//

auto Path = Environment.GetVariable(PATH_ENV);

if (Path.empty())

{

Environment.AddVariable(PATH_ENV, PathElement);

}

else

{

std::string NewPath{Path};

if (NewPath.back() != ':')

{

NewPath += ':';

}

NewPath += PathElement;

Environment.AddVariable(PATH_ENV, NewPath);

}

return;

}

CATCH_LOG()

void ConfigHandleInteropMessage(

wsl::shared::SocketChannel& ResponseChannel,

wsl::shared::SocketChannel& InteropChannel,

bool Elevated,

gsl::span<gsl::byte> Message,

const MESSAGE_HEADER* Header,

const wsl::linux::WslDistributionConfig& Config)

try

{

switch (Header->MessageType)

{

case LxInitMessageCreateProcessUtilityVm:

if (InteropChannel.Socket() > 0)

{

InteropChannel.SendMessage<LX_INIT_CREATE_NT_PROCESS_UTILITY_VM>(Message);

}

break;

case LxInitMessageQueryDrvfsElevated:

{

ResponseChannel.SendResultMessage<bool>(Elevated);

break;

}

case LxInitMessageQueryEnvironmentVariable:

{

auto* Query = gslhelpers::try_get_struct<LX_INIT_QUERY_ENVIRONMENT_VARIABLE>(Message);

if (!Query)

{

LOG_ERROR("Unexpected MessageSize {}", Message.size());

return;

}

auto Value = UtilGetEnvironmentVariable(Query->Buffer);

wsl::shared::MessageWriter<LX_INIT_QUERY_ENVIRONMENT_VARIABLE> Response(LxInitMessageQueryEnvironmentVariable);

Response.WriteString(Value);

ResponseChannel.SendMessage<LX_INIT_QUERY_ENVIRONMENT_VARIABLE>(Response.Span());

}

break;

case LxInitMessageQueryFeatureFlags:

{

assert(Config.FeatureFlags.has_value());

ResponseChannel.SendResultMessage<int32_t>(Config.FeatureFlags.value());

break;

}

case LxInitMessageCreateLoginSession:

{

auto* CreateSession = gslhelpers::try_get_struct<LX_INIT_CREATE_LOGIN_SESSION>(Message);

if (!CreateSession)

{

LOG_ERROR("Unexpected MessageSize {}", Message.size());

return;

}

if (!Config.BootInit || Config.InitPid.value_or(0) != getpid())

{

LOG_ERROR("Unexpected LxInitMessageCreateLoginSession message");

return;

}

static std::mutex LoginSessionsLock;

static std::map<uid_t, int> LoginSessions;

// Keep track of login sessions that have been created.

LoginSessionsLock.lock();

auto Unlock = wil::scope_exit([&]() { LoginSessionsLock.unlock(); });

if (LoginSessions.contains(CreateSession->Uid))

{

return;

}

// Symlink the content of the WSLG XDG runtime dir onto the user's runtime path and

// create a login session to initialize PAM for the user.

if (Config.GuiAppsEnabled)

{

auto* RuntimeDir = getenv(XDG_RUNTIME_DIR_ENV);

if (RuntimeDir)

{

// Create a tmpfs mount point for the user directory.

auto userFolder = std::format("/run/user/{}", CreateSession->Uid);

UtilMount("tmpfs", userFolder.c_str(), "tmpfs", (MS_NOSUID | MS_NODEV | MS_NOEXEC), "mode=755");

// Create the directory structure for wslg's symlinks.

for (const auto* e : {"/", "/dbus-1", "/dbus-1/service", "/pulse"})

{

auto target = userFolder + e;

UtilMkdir(target.c_str(), 0777);

if (chown(target.c_str(), CreateSession->Uid, CreateSession->Gid) < 0)

{

LOG_ERROR("chown({}, {}, {}) failed {}", target, CreateSession->Uid, CreateSession->Gid, errno);

}

}

// Create the actual symlinks.

for (const auto* e : {"wayland-0", "wayland-0.lock", "pulse/native", "pulse/pid"})

{

auto link = std::format("{}/{}", userFolder, e);

if (unlink(link.c_str()) < 0 && errno != ENOENT)

{

LOG_ERROR("unlink({}) failed {}", link, errno);

}

auto target = RuntimeDir + std::string("/") + e;

if (symlink(target.c_str(), link.c_str()) < 0)

{

LOG_ERROR("symlink({}, {}) failed {}", target, link, errno);

}

}

}

else

{

LOG_ERROR("getenv({}) failed {}", XDG_RUNTIME_DIR_ENV, errno);

}

}

int LoginLeader;

const int Result = forkpty(&LoginLeader, nullptr, nullptr, nullptr);

if (Result < 0)

{

LOG_ERROR("forkpty failed {}", errno);

return;

}

else if (Result == 0)

{

Unlock.reset();

_exit(execl("/bin/login", "/bin/login", "-f", CreateSession->Buffer, nullptr));

}

LoginSessions.emplace(CreateSession->Uid, LoginLeader);

break;

}

case LxInitMessageQueryNetworkingMode:

assert(Config.NetworkingMode.has_value());

ResponseChannel.SendResultMessage<uint8_t>(static_cast<uint8_t>(Config.NetworkingMode.value()));

break;

default:

LOG_ERROR("unexpected message {}", Header->MessageType);

break;

}

}

CATCH_LOG()

wsl::linux::WslDistributionConfig ConfigInitializeCommon(struct sigaction* SavedSignalActions)

{

wil::unique_fd DevNullFd;

unsigned int Index;

//

// Set the umask to 0 to ensure that devices and files that init creates

// have the correct mode.

//

umask(0);

//

// Perform initialization required for logging to kmsg.

//

if (!UtilIsUtilityVm())

{

for (Index = 0; Index < COUNT_OF(LxssStartupLoggingWsl); Index += 1)

{

THROW_LAST_ERROR_IF(ConfigInitializeEntry(&LxssStartupLoggingWsl[Index]) < 0);

}

}

else

{

for (Index = 0; Index < COUNT_OF(LxssStartupLoggingVmMode); Index += 1)

{

THROW_LAST_ERROR_IF(ConfigInitializeEntry(&LxssStartupLoggingVmMode[Index]) < 0);

}

}

//

// Open /dev/kmsg for logging.

//

THROW_LAST_ERROR_IF(InitializeLogging(true) < 0);

//

// Ignore all signals except SIGHUP and signals that cannot be ignored.

//

// N.B. Ignoring SIGCHLD automatically reaps zombie processes.

//

// N.B. Child processes reset signals to default before calling execv.

//

THROW_LAST_ERROR_IF(UtilSaveSignalHandlers(SavedSignalActions) < 0);

THROW_LAST_ERROR_IF(UtilSetSignalHandlers(SavedSignalActions, true) < 0);

//

// Load the configuration file.

//

wsl::linux::WslDistributionConfig Config{CONFIG_FILE};

//

// Initialize the static entries.

//

for (Index = 0; Index < COUNT_OF(LxssStartupCommon); Index += 1)

{

THROW_LAST_ERROR_IF(ConfigInitializeEntry(&LxssStartupCommon[Index]) < 0);

}

//

// Initialize WSL1 and WSL2 specific environment.

//

if (!UtilIsUtilityVm())

{

THROW_LAST_ERROR_IF(ConfigInitializeWsl() < 0);

}

//

// Open /dev/null for the stdin and stdout in case libraries try to use

// them (but keep stderr open for kmsg logging).

//

DevNullFd = TEMP_FAILURE_RETRY(open("/dev/null", O_RDWR));

THROW_LAST_ERROR_IF(!DevNullFd);

for (const auto& Fd : {STDIN_FILENO, STDOUT_FILENO})

{

THROW_LAST_ERROR_IF(dup2(DevNullFd.get(), Fd) < 0);

}

//

// Initialize cgroups based on what the kernel supports.

//

ConfigInitializeCgroups();

//

// Attempt to register the NT interop binfmt extension.

//

// N.B. Registration for VM mode is done by mini_init.

//

if ((!UtilIsUtilityVm()) && (Config.InteropEnabled))

{

ConfigRegisterBinfmtInterpreter();

}

//

// Ensure the target for automounts exists.

//

if ((Config.AutoMount) || ((UtilIsUtilityVm())))

{

UtilMkdirPath(Config.DrvFsPrefix.c_str(), AUTO_MOUNT_PARENT_MODE, false);

}

//

// Initialization successful.

//

return Config;

}

void ConfigInitializeX11(const wsl::linux::WslDistributionConfig& Config)

try

{

auto socketPath = "/tmp/" X11_SOCKET_NAME;

THROW_LAST_ERROR_IF(UtilMkdir(socketPath, 0775) < 0);

std::string source{Config.DrvFsPrefix};

source += WSLG_SHARED_FOLDER;

source += "/" X11_SOCKET_NAME;

THROW_LAST_ERROR_IF(mount(source.c_str(), socketPath, NULL, (MS_BIND | MS_REC), NULL) < 0);

// The .X11-unix folder is mounted read-only so the socket file can't be removed.

// It's left writable in the system distro since wslg is supposed to write to that folder to create it.

if (WI_IsFlagClear(Config.FeatureFlags.value(), LxInitFeatureSystemDistro))

{

THROW_LAST_ERROR_IF(mount("none", socketPath, NULL, (MS_RDONLY | MS_REMOUNT | MS_BIND), NULL) < 0);

}

}

CATCH_LOG()

int ConfigInitializeInstance(wsl::shared::SocketChannel& Channel, gsl::span<gsl::byte> Buffer, wsl::linux::WslDistributionConfig& Config)

try

{

//

// Validate input parameters.

//

const auto* Message = gslhelpers::try_get_struct<const LX_INIT_CONFIGURATION_INFORMATION>(Buffer);

if (!Message)

{

FATAL_ERROR("Unexpected configuration size {}", Buffer.size());

}

//

// Set the host name and domain name buffers.

//

std::string Hostname = wsl::shared::string::FromSpan(Buffer, Message->HostnameOffset);

auto* Domainname = wsl::shared::string::FromSpan(Buffer, Message->DomainnameOffset);

auto* WindowsHosts = wsl::shared::string::FromSpan(Buffer, Message->WindowsHostsOffset);

auto* DistributionName = wsl::shared::string::FromSpan(Buffer, Message->DistributionNameOffset);

auto* Plan9SocketPath = wsl::shared::string::FromSpan(Buffer, Message->Plan9SocketOffset);

auto* Timezone = wsl::shared::string::FromSpan(Buffer, Message->TimezoneOffset);

bool Elevated = Message->DrvfsMount == LxInitDrvfsMountElevated;

const std::string ThreadName = std::format("{}({})", (Config.BootInit ? "init-systemd" : "init"), DistributionName);

UtilSetThreadName(ThreadName.c_str());

//

// Store feature flags for future use.

//

// N.B. This is also stored in an environment variable so that mount.drvfs, when launched

// through fstab mounting below, can use that. This is needed because mount.drvfs won't

// be able to connect to init during this call. This environment variable is not present

// for user-launched processes.

//

Config.FeatureFlags = Message->FeatureFlags;

char FeatureFlagsString[10];

snprintf(FeatureFlagsString, sizeof(FeatureFlagsString), "%x", Config.FeatureFlags.value());

if (setenv(WSL_FEATURE_FLAGS_ENV, FeatureFlagsString, 1) < 0)

{

LOG_ERROR("setenv failed {}", errno);

}

//

// Determine the default UID which can be specified in /etc/wsl.conf.

//

uid_t DefaultUid = Message->DrvFsDefaultOwner;

if (Config.DefaultUser.has_value())

{

passwd* PasswordEntry = getpwnam(Config.DefaultUser->c_str());

if (PasswordEntry == nullptr)

{

LOG_ERROR("getpwnam({}) failed {}", Config.DefaultUser->c_str(), errno);

}

else

{

DefaultUid = PasswordEntry->pw_uid;

}

}

//

// Process the /etc/fstab file.

//

// N.B. This must happen before mounting DrvFs volumes because the user may

// have specified DrvFs mounts in /etc/fstab and they should overwrite defaults.

//

if (Config.MountFsTab)

{

ConfigMountFsTab(Elevated);

}

//

// Perform additional WSL2-specific mounts.

//

if (UtilIsUtilityVm())

{

if (ConfigInitializeVmMode(Elevated, Config) < 0)

{

FATAL_ERROR("ConfigInitializeVmMode");

}

}

if (Config.AutoMount && (Message->DrvfsMount != LxInitDrvfsMountNone))

{

ConfigMountDrvFsVolumes(Message->DrvFsVolumesBitmap, DefaultUid, Elevated, Config);

}

//

// If a hostname was specified in /etc/wsl.conf, use it.

//

if (Config.HostName.has_value())

{

Hostname = Config.HostName.value();

LOG_WARNING("hostname set to {} in {}", Hostname.c_str(), CONFIG_FILE);

}

//

// Sanitize the hostname.

//

// N.B. If systemd is enabled, systemd-hostnamed will cleanup the

// hostname, which can lead to a disconnect if that doesn't match

// what we write in /etc/hostname & /etc/hosts, so to hostname needs

// to be cleaned up before being passed to systemd.

//

// N.B. While the Windows UI doesn't let the user set an invalid hostname

// (from systemd-hostnamed's perspective), it's possible to override that

// via Rename-Computer.

Hostname = wsl::shared::string::CleanHostname(Hostname);

//

// Update the host and domain name.

//

if (sethostname(Hostname.c_str(), Hostname.size()) < 0)

{

LOG_ERROR("sethostname({}) failed {}", Hostname.c_str(), errno);

Hostname = wsl::shared::string::c_defaultHostName;

if (sethostname(Hostname.c_str(), Hostname.size()) < 0)

{

LOG_ERROR("sethostname({}) failed {}", Hostname.c_str(), errno);

}

}

if (setenv(NAME_ENV, Hostname.c_str(), 1) < 0)

{

LOG_ERROR("setenv({}, {}) failed {}", NAME_ENV, Hostname.c_str(), errno);

}

//

// Update the domain name.

//

if (setdomainname(Domainname, strlen(Domainname)) < 0)

{

LOG_ERROR("setdomainname({}) failed {}", Domainname, errno);

}

//

// Generate and write /etc/hostname.

//

wil::unique_fd HostnameFd{TEMP_FAILURE_RETRY(creat(HOSTNAME_FILE_PATH, HOSTNAME_FILE_MODE))};

if (!HostnameFd)

{

LOG_ERROR("creat {} failed: {}", HOSTNAME_FILE_PATH, errno);

}

else

{

try

{

auto FileContents = std::format("{}\n", Hostname);

if (UtilWriteStringView(HostnameFd.get(), FileContents) < 0)

{

LOG_ERROR("write failed {}", errno);

}

}

CATCH_LOG()

}

HostnameFd.reset();

//

// Generate and write /etc/hosts.

//

if (Config.GenerateHosts)

{

wil::unique_fd HostsFd{TEMP_FAILURE_RETRY(creat(HOSTS_FILE_PATH, HOSTS_FILE_MODE))};

if (!HostsFd)

{

LOG_ERROR("creat {} failed {}", HOSTS_FILE_PATH, errno);

}

else

{

try

{

auto FileContents = std::format(HostsFileFormatString, Hostname.c_str(), Domainname, Hostname.c_str(), WindowsHosts);

if (UtilWriteStringView(HostsFd.get(), FileContents) < 0)

{

LOG_ERROR("write failed {}", errno);

}

}

CATCH_LOG()

}

}

else

{

LOG_WARNING("{} updating disabled in {}", HOSTS_FILE_PATH, CONFIG_FILE);

}

//

// Store the distribution name.

//

if (setenv(WSL_DISTRO_NAME_ENV, DistributionName, 1) < 0)

{

LOG_ERROR("setenv({}, {}, 1) failed {}", WSL_DISTRO_NAME_ENV, DistributionName, errno);

}

//

// Run the Plan 9 server. This requires a DrvFs mount for the socket file,

// so either fstab or automount must be enabled to have a chance the mount

// exists.

//

// N.B. Failure to start the server is non-fatal.

//

unsigned int Plan9Port = LX_INIT_UTILITY_VM_INVALID_PORT;

if ((WI_IsFlagClear(Config.FeatureFlags.value(), LxInitFeatureDisable9pServer)) && (Config.Plan9Enabled) &&

(Config.AutoMount || Config.MountFsTab))

{

std::tie(Plan9Port, Config.Plan9ControlChannel) = StartPlan9Server(Plan9SocketPath, Config);

}

//

// If the root filesystem is compressed, log a warning.

//

if (WI_IsFlagSet(Config.FeatureFlags.value(), LxInitFeatureRootfsCompressed))

{

LOG_WARNING("{} root file system is compressed, performance may be severly impacted.", DistributionName);

}

//

// Update the timezone.

//

UpdateTimezone(Timezone, Config);

if (Config.BootInit)

{

try

{

// Create the /run/user bind mount.

// This mount is required because systemd will mount a tmpfs on each /run/user/<uid> folder

// so /run/user need to be in the global mount namespace so both elevated and non elevated processes see it.

const auto UserMountTarget = Config.DrvFsPrefix + WSLG_SHARED_FOLDER "/run/user";

THROW_LAST_ERROR_IF(UtilMkdirPath(UserMountTarget.c_str(), 0755) < 0);

THROW_LAST_ERROR_IF(UtilMount(UserMountTarget.c_str(), RUN_FOLDER "/" USER_MOUNT_FOLDER, nullptr, MS_BIND, nullptr) < 0)

}

CATCH_LOG();

}

//

// Create a listening hvsocket for interop if the feature is enabled.

//

wil::unique_fd ListenSocket{};

sockaddr_vm SocketAddress{};

if (UtilIsUtilityVm() && Config.InteropEnabled)

{

ListenSocket = UtilListenVsockAnyPort(&SocketAddress, 1);

}

//

// Send the config response to the service.

//

wsl::shared::MessageWriter<LX_INIT_CONFIGURATION_INFORMATION_RESPONSE> Response(LxInitMessageInitializeResponse);

Response->Plan9Port = Plan9Port;

Response->DefaultUid = DefaultUid;

Response->InteropPort = ListenSocket ? SocketAddress.svm_port : LX_INIT_UTILITY_VM_INVALID_PORT;

Response->SystemdEnabled = Config.BootInit;

struct stat PidNamespaceInfo = {};

THROW_LAST_ERROR_IF(stat("/proc/self/ns/pid", &PidNamespaceInfo));

Response->PidNamespace = PidNamespaceInfo.st_ino;

static_assert(sizeof(Response->PidNamespace) == sizeof(PidNamespaceInfo.st_ino));

auto [Flavor, Version] = UtilReadFlavorAndVersion("/etc/os-release");

if (Flavor.has_value())

{

Response.WriteString(Response->FlavorIndex, Flavor->c_str());

}

if (Version.has_value())

{

Response.WriteString(Response->VersionIndex, Version->c_str());

}

Channel.SendMessage<LX_INIT_CONFIGURATION_INFORMATION_RESPONSE>(Response.Span());

//

// Accept the interop connection.

//

wsl::shared::SocketChannel InteropChannel;

if (ListenSocket)

{

InteropChannel = {UtilAcceptVsock(ListenSocket.get(), SocketAddress, INTEROP_TIMEOUT_MS), "Interop"};

}

//

// Create a thread to handle interop requests.

//

InteropServer InteropServer;

if (InteropServer.Create() < 0)

{

FATAL_ERROR("Could not create init interop server");

}

//

// If init is not running as pid 1, create a symlink to the interop server that was created.

//

if (Config.InitPid.has_value())

try