Skip to content

Commit 5207c4c

Browse files
committed
Integrate HCS virtual machine backend
1 parent 4e1e1d8 commit 5207c4c

9 files changed

Lines changed: 458 additions & 543 deletions

‎guest-state.txt‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1 @@
1+
The debug shell is disabled by the computer policy.

‎src/windows/common/HcsVirtualMachineBackend.cpp‎

Lines changed: 156 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -31,6 +31,17 @@ constexpr UINT64 c_mib = 1024 * 1024;
3131
constexpr UINT32 c_maximumDisks = 254;
3232
constexpr HRESULT c_notSupported = HRESULT_FROM_WIN32(ERROR_NOT_SUPPORTED);
3333

34+
std::unique_ptr<ExecutionContext> CreateExecutionContext(Context Context)
35+
{
36+
const auto* current = ExecutionContext::Current();
37+
if (current != nullptr && current->CurrentContext() >= static_cast<ULONGLONG>(Context))
38+
{
39+
return {};
40+
}
41+
42+
return std::make_unique<ExecutionContext>(Context);
43+
}
44+
3445
template <typename... Visitors>
3546
struct Overloaded : Visitors...
3647
{
@@ -153,6 +164,47 @@ VmEffectiveMemory ConfigureMemory(const VmMemoryRequest& Request, const VmMmioRe
153164
return memory;
154165
}
155166

167+
// Maps console requests onto the HCS devices that serve them. A serial console is served by a COM
168+
// port and a virtio console by a port on the virtio-serial controller.
169+
//
170+
// N.B. The ordering of virtio ports is significant because it determines the order the guest
171+
// enumerates them as /dev/hvc devices, so ports are addressed by the caller-supplied index.
172+
void ConfigureConsoles(const std::vector<VmConsoleRequest>& Requests, schema::Devices& Settings)
173+
{
174+
for (const auto& request : Requests)
175+
{
176+
std::visit(
177+
Overloaded{
178+
[&](const VmSerialConsole& console) {
179+
THROW_HR_IF(E_INVALIDARG, console.NamedPipe.empty());
180+
const auto port = std::to_string(console.Port);
181+
THROW_HR_IF(HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), Settings.ComPorts.contains(port));
182+
Settings.ComPorts[port] = schema::ComPort{console.NamedPipe.native()};
183+
},
184+
[&](const VmVirtioConsole& console) {
185+
THROW_HR_IF(E_INVALIDARG, console.NamedPipe.empty() || console.GuestName.empty());
186+
if (!Settings.VirtioSerial.has_value())
187+
{
188+
Settings.VirtioSerial.emplace();
189+
}
190+
191+
const auto port = std::to_string(console.Port);
192+
auto& ports = Settings.VirtioSerial->Ports;
193+
THROW_HR_IF(HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), ports.contains(port));
194+
195+
// The guest addresses a virtio console by name, so names must be unique.
196+
THROW_HR_IF(
197+
HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS),
198+
std::any_of(ports.begin(), ports.end(), [&](const auto& entry) {
199+
return entry.second.Name == console.GuestName;
200+
}));
201+
202+
ports[port] = schema::VirtioSerialPort{console.GuestName, console.NamedPipe.native(), true};
203+
}},
204+
request.Device);
205+
}
206+
}
207+
156208
VmEffectiveBoot ConfigureBoot(const VmLinuxBootRequest& Request, schema::Chipset& Settings)
157209
{
158210
VmEffectiveBoot boot{};
@@ -215,13 +267,76 @@ HcsVirtualMachineBackend::VmConfiguration HcsVirtualMachineBackend::BuildConfigu
215267
configuration.Settings.ShouldTerminateOnLastHandleClosed = true;
216268
configuration.Settings.SchemaVersion.Major = 2;
217269
configuration.Settings.SchemaVersion.Minor = wsl::windows::common::helpers::IsWindows11OrAbove() ? 7 : 3;
270+
configuration.Settings.VirtualMachine.StopOnReset = true;
218271
auto& description = configuration.Description;
219272
description.Identity = Request.Identity;
220273
description.Backend = BackendKind::Hcs;
221274
description.Processor = ConfigureProcessor(Request.Processor, configuration.Settings.VirtualMachine.ComputeTopology.Processor);
222275
description.Memory = ConfigureMemory(Request.Memory, Request.Mmio, configuration.Settings.VirtualMachine.ComputeTopology.Memory);
223276
description.Boot = ConfigureBoot(Request.Boot, configuration.Settings.VirtualMachine.Chipset);
224-
configuration.Settings.VirtualMachine.Devices.Scsi["0"] = {};
277+
description.Boot.Consoles = Request.Consoles;
278+
ConfigureConsoles(Request.Consoles, configuration.Settings.VirtualMachine.Devices);
279+
auto& scsi = configuration.Settings.VirtualMachine.Devices.Scsi["0"];
280+
scsi = {};
281+
282+
// Attach the disks the VM boots from up front so that the guest can reach them without waiting
283+
// for a hot add. Their LUNs are reported so that the caller can name them in the guest.
284+
const auto vmIdString = wsl::shared::string::GuidToString<wchar_t>(Request.Identity.VmId, wsl::shared::string::GuidToStringFlags::None);
285+
std::uint32_t nextLun = 0;
286+
for (const auto& bootDisk : Request.BootDisks)
287+
{
288+
THROW_HR_IF(E_INVALIDARG, bootDisk.Key.empty());
289+
THROW_HR_IF(HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), description.BootDisks.contains(bootDisk.Key));
290+
THROW_HR_IF_MSG(
291+
c_notSupported, !std::holds_alternative<VmVirtualDiskSource>(bootDisk.Disk.Source), "HCS boot disks must be virtual disks");
292+
293+
const auto& path = validation::ValidateDiskSource(bootDisk.Disk);
294+
std::uint32_t lun = nextLun;
295+
if (bootDisk.Disk.Placement)
296+
{
297+
THROW_HR_IF(c_notSupported, bootDisk.Disk.Placement->Address.Controller != 0);
298+
lun = bootDisk.Disk.Placement->Address.Lun;
299+
}
300+
301+
THROW_HR_IF(E_BOUNDS, lun >= c_maximumDisks);
302+
THROW_HR_IF(HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), scsi.Attachments.contains(std::to_string(lun)));
303+
nextLun = lun + 1;
304+
305+
// Best effort: failures (for instance no WRITE_DAC on a SYSTEM-owned VHD) are swallowed
306+
// since the VM worker process may already have access via inherited ACLs; otherwise
307+
// starting the VM surfaces E_ACCESSDENIED.
308+
wsl::windows::common::disk::DiskStateFlags diskFlags{};
309+
if (bootDisk.GrantHostAccess)
310+
{
311+
try
312+
{
313+
auto runAsUser = wil::impersonate_token(Request.Identity.UserToken.get());
314+
schema::GrantVmAccess(vmIdString.c_str(), path.c_str());
315+
WI_SetFlag(diskFlags, wsl::windows::common::disk::DiskStateFlags::AccessGranted);
316+
}
317+
CATCH_LOG()
318+
}
319+
320+
auto backingFile = wsl::windows::common::disk::OpenVhdBackingFile(path.c_str());
321+
322+
schema::Attachment attachment{};
323+
attachment.Type = schema::AttachmentType::VirtualDisk;
324+
attachment.Path = path;
325+
attachment.ReadOnly = bootDisk.Disk.ReadOnly;
326+
attachment.SupportCompressedVolumes = true;
327+
attachment.AlwaysAllowSparseFiles = true;
328+
attachment.SupportEncryptedFiles = true;
329+
scsi.Attachments[std::to_string(lun)] = std::move(attachment);
330+
331+
const VmDiskAttachment diskAttachment{
332+
{Request.Identity, configuration.NextDiskId}, {0, lun}, bootDisk.Disk.ReadOnly, bootDisk.Disk.UserDisk};
333+
description.BootDisks.emplace(bootDisk.Key, diskAttachment);
334+
configuration.BootDisks.emplace(
335+
diskAttachment.Id.Value,
336+
AttachedDisk{diskAttachment, false, path, diskFlags, bootDisk.Disk.DeviceTimeout, std::move(backingFile)});
337+
338+
++configuration.NextDiskId;
339+
}
225340

226341
if (Request.CrashCapture && Request.CrashCapture->SavedStateFolder)
227342
{
@@ -286,7 +401,7 @@ HcsVirtualMachineBackend::~HcsVirtualMachineBackend() noexcept
286401

287402
std::unique_ptr<HcsVirtualMachineBackend> HcsVirtualMachineBackend::Create(const VmCreateRequest& Request)
288403
{
289-
ExecutionContext context(Context::CreateVm);
404+
const auto context = CreateExecutionContext(Context::CreateVm);
290405
auto newInstance = std::unique_ptr<HcsVirtualMachineBackend>{new HcsVirtualMachineBackend{}};
291406
try
292407
{
@@ -347,13 +462,20 @@ void HcsVirtualMachineBackend::Initialize(const VmCreateRequest& Request)
347462
auto configuration = BuildConfiguration(Request);
348463
const auto id = wsl::shared::string::GuidToString<wchar_t>(Request.Identity.VmId, wsl::shared::string::GuidToStringFlags::None);
349464
const auto settings = wsl::shared::ToJsonW(configuration.Settings);
465+
auto bootDisks = std::move(configuration.BootDisks);
466+
const auto nextDiskId = configuration.NextDiskId;
350467
m_configuration = std::move(configuration);
351468
m_vmIdString = id;
352469
auto lock = m_lock.lock_exclusive();
470+
471+
// Track the boot disks before the compute system is created so that the host state changes made
472+
// to attach them are undone even if creation fails.
473+
m_attachedDisks = std::move(bootDisks);
474+
m_nextDiskId = nextDiskId;
353475
m_system = schema::CreateComputeSystem(id.c_str(), settings.c_str());
354476
m_state = VmState::Created;
355477
m_runtimeId = wsl::windows::common::hcs::GetRuntimeId(m_system.get());
356-
m_guestDeviceManager = std::make_shared<GuestDeviceManager>(id, m_runtimeId, true);
478+
m_guestDeviceManager = std::make_shared<GuestDeviceManager>(id, m_runtimeId, Request.EnableTelemetry);
357479
m_pendingNetworkAdapters = Request.NetworkAdapters;
358480
schema::RegisterCallback(m_system.get(), OnSystemEvent, this);
359481
}
@@ -363,6 +485,20 @@ VmPlatformCapabilities HcsVirtualMachineBackend::GetCapabilities() const
363485
return QueryCapabilities();
364486
}
365487

488+
HCS_SYSTEM HcsVirtualMachineBackend::GetComputeSystemHandle() const
489+
{
490+
auto lock = m_lock.lock_shared();
491+
THROW_HR_IF(HRESULT_FROM_WIN32(ERROR_INVALID_STATE), !m_system);
492+
return m_system.get();
493+
}
494+
495+
std::shared_ptr<GuestDeviceManager> HcsVirtualMachineBackend::GetGuestDeviceManager() const
496+
{
497+
auto lock = m_lock.lock_shared();
498+
THROW_HR_IF(HRESULT_FROM_WIN32(ERROR_INVALID_STATE), !m_system || !m_guestDeviceManager);
499+
return m_guestDeviceManager;
500+
}
501+
366502
VmPlatformCapabilities HcsVirtualMachineBackend::QueryCapabilities()
367503
{
368504
VmPlatformCapabilities capabilities{};
@@ -638,11 +774,13 @@ void HcsVirtualMachineBackend::CleanupAttachedDisks(std::map<std::uint64_t, Atta
638774

639775
VmDiskAttachment HcsVirtualMachineBackend::AttachDisk(const VmDiskRequest& Request)
640776
{
641-
ExecutionContext context(Context::MountDisk);
777+
const auto context = CreateExecutionContext(Context::MountDisk);
642778

643779
const auto& path = validation::ValidateDiskSource(Request);
644780
const bool passThrough = std::holds_alternative<VmPhysicalDiskSource>(Request.Source);
645781
const auto timeoutMs = static_cast<size_t>(Request.DeviceTimeout.count());
782+
HANDLE userToken = Request.UserToken ? Request.UserToken.get() : m_configuration.Description.Identity.UserToken.get();
783+
THROW_HR_IF_MSG(E_UNEXPECTED, !userToken, "UserToken not set for the disk request");
646784

647785
auto lock = m_lock.lock_exclusive();
648786
THROW_HR_IF(HRESULT_FROM_WIN32(ERROR_INVALID_STATE), !m_system);
@@ -728,7 +866,7 @@ VmDiskAttachment HcsVirtualMachineBackend::AttachDisk(const VmDiskRequest& Reque
728866
{
729867
// Grant the VM access to the disk.
730868
schema::GrantVmWorkerProcessAccessToDisk(
731-
m_vmIdString.c_str(), path.c_str(), m_configuration.Description.Identity.UserToken.get());
869+
m_vmIdString.c_str(), path.c_str(), userToken);
732870
WI_SetFlag(diskFlags, wsl::windows::common::disk::DiskStateFlags::AccessGranted);
733871

734872
// Set the disk offline if needed.
@@ -752,7 +890,7 @@ VmDiskAttachment HcsVirtualMachineBackend::AttachDisk(const VmDiskRequest& Reque
752890
path.c_str(),
753891
lun,
754892
Request.ReadOnly,
755-
m_configuration.Description.Identity.UserToken.get(),
893+
userToken,
756894
diskFlags);
757895
}
758896
});
@@ -777,7 +915,7 @@ VmDiskAttachment HcsVirtualMachineBackend::AttachDisk(const VmDiskRequest& Reque
777915

778916
void HcsVirtualMachineBackend::DetachDisk(VmDiskId Disk)
779917
{
780-
ExecutionContext context(Context::DetachDisk);
918+
const auto context = CreateExecutionContext(Context::DetachDisk);
781919

782920
WSL_LOG(
783921
"HcsDetachDiskBegin",
@@ -904,7 +1042,7 @@ VmPersistentMemoryDevice HcsVirtualMachineBackend::AddPersistentMemory(const VmP
9041042

9051043
VmGpuAttachment HcsVirtualMachineBackend::AddGpu(const VmGpuRequest& Request)
9061044
{
907-
ExecutionContext context(Context::ConfigureGpu);
1045+
const auto context = CreateExecutionContext(Context::ConfigureGpu);
9081046
THROW_HR_IF(c_notSupported, Request.AssignmentMode != VmGpuAssignmentMode::Mirror);
9091047

9101048
const auto disableVgpuSettingsSupported = schema::IsDisableVgpuSettingsSupported();
@@ -1489,7 +1627,7 @@ void HcsVirtualMachineBackend::ModifyHostEndpointLocked(
14891627

14901628
VmNetworkAttachment HcsVirtualMachineBackend::AddNetworkAdapter(const VmNetworkAdapterRequest& Request)
14911629
{
1492-
ExecutionContext context(Context::ConfigureNetworking);
1630+
const auto context = CreateExecutionContext(Context::ConfigureNetworking);
14931631

14941632
WSL_LOG(
14951633
"HcsAddNetworkAdapterBegin",
@@ -1564,7 +1702,7 @@ VmNetworkAttachment HcsVirtualMachineBackend::AddNetworkAdapter(const VmNetworkA
15641702

15651703
void HcsVirtualMachineBackend::UpdateNetworkAdapter(VmDeviceId Device, const VmNetworkConfiguration& Configuration)
15661704
{
1567-
ExecutionContext context(Context::ConfigureNetworking);
1705+
const auto context = CreateExecutionContext(Context::ConfigureNetworking);
15681706

15691707
WSL_LOG(
15701708
"HcsUpdateNetworkAdapterBegin",
@@ -1627,7 +1765,7 @@ void HcsVirtualMachineBackend::RemoveNetworkAdapterLocked(std::map<std::uint64_t
16271765

16281766
void HcsVirtualMachineBackend::RemoveNetworkAdapter(VmDeviceId Device)
16291767
{
1630-
ExecutionContext context(Context::ConfigureNetworking);
1768+
const auto context = CreateExecutionContext(Context::ConfigureNetworking);
16311769

16321770
WSL_LOG(
16331771
"HcsRemoveNetworkAdapterBegin",
@@ -1674,7 +1812,7 @@ void HcsVirtualMachineBackend::CloseNetworkAdaptersLocked() noexcept
16741812

16751813
VmPortBinding HcsVirtualMachineBackend::BindPort(VmDeviceId Device, const VmPortBindingRequest& Request)
16761814
{
1677-
ExecutionContext context(Context::ConfigureNetworking);
1815+
const auto context = CreateExecutionContext(Context::ConfigureNetworking);
16781816

16791817
THROW_HR_IF(E_INVALIDARG, Request.GuestPort == 0);
16801818
THROW_HR_IF(E_INVALIDARG, Request.Protocol != TransportProtocol_Tcp && Request.Protocol != TransportProtocol_Udp);
@@ -1726,7 +1864,7 @@ VmPortBinding HcsVirtualMachineBackend::BindPort(VmDeviceId Device, const VmPort
17261864

17271865
void HcsVirtualMachineBackend::UnbindPort(VmPortBindingId Binding)
17281866
{
1729-
ExecutionContext context(Context::ConfigureNetworking);
1867+
const auto context = CreateExecutionContext(Context::ConfigureNetworking);
17301868

17311869
WSL_LOG(
17321870
"HcsUnbindPortBegin",
@@ -1754,7 +1892,7 @@ void HcsVirtualMachineBackend::UnbindPort(VmPortBindingId Binding)
17541892

17551893
IpAddress HcsVirtualMachineBackend::CreateVirtualAddress(VmDeviceId Device, const IpAddress& Destination)
17561894
{
1757-
ExecutionContext context(Context::ConfigureNetworking);
1895+
const auto context = CreateExecutionContext(Context::ConfigureNetworking);
17581896

17591897
WSL_LOG(
17601898
"HcsCreateVirtualAddressBegin",
@@ -1780,7 +1918,7 @@ IpAddress HcsVirtualMachineBackend::CreateVirtualAddress(VmDeviceId Device, cons
17801918

17811919
void HcsVirtualMachineBackend::CreateDnsRecord(VmDeviceId Device, const VmDnsRecord& Record)
17821920
{
1783-
ExecutionContext context(Context::ConfigureNetworking);
1921+
const auto context = CreateExecutionContext(Context::ConfigureNetworking);
17841922

17851923
THROW_HR_IF_MSG(E_INVALIDARG, Record.Name.empty(), "A DNS record requires a name");
17861924
THROW_HR_IF_MSG(c_notSupported, Record.Type != DnsRecordType_A, "Only A records are supported");
@@ -1876,6 +2014,9 @@ void HcsVirtualMachineBackend::OnExit(PCWSTR ExitDetails)
18762014

18772015
m_exitEvent.SetEvent();
18782016

2017+
// Callers blocked on the guest must not wait forever when the VM exits on its own.
2018+
CancelGuestListeners();
2019+
18792020
if (!m_terminatingEvent.is_signaled())
18802021
{
18812022
WSL_LOG("AbnormalVmExit", TraceLoggingValue(ExitDetails, "Details"));

‎src/windows/common/HcsVirtualMachineBackend.h‎

Lines changed: 17 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -26,6 +26,13 @@ class HcsVirtualMachineBackend : public IVirtualMachineBackend
2626
static std::unique_ptr<HcsVirtualMachineBackend> Create(const VmCreateRequest& Request);
2727
static VmPlatformCapabilities QueryCapabilities();
2828

29+
// N.B. Transitional escape hatches for WSL networking implementations that still operate
30+
// directly on HCS and GuestDeviceManager. The returned HCS handle is valid only while this
31+
// backend remains alive and has not been terminated. New backend-independent code must use
32+
// IVirtualMachineBackend instead.
33+
HCS_SYSTEM GetComputeSystemHandle() const;
34+
std::shared_ptr<GuestDeviceManager> GetGuestDeviceManager() const;
35+
2936
VmPlatformCapabilities GetCapabilities() const override;
3037
VmDescription GetDescription() const override;
3138
VmState GetState() const override;
@@ -63,12 +70,6 @@ class HcsVirtualMachineBackend : public IVirtualMachineBackend
6370
void CreateDnsRecord(VmDeviceId Device, const VmDnsRecord& Record) override;
6471

6572
private:
66-
struct VmConfiguration
67-
{
68-
VmDescription Description;
69-
wsl::windows::common::hcs::ComputeSystem Settings;
70-
};
71-
7273
struct AttachedDisk
7374
{
7475
VmDiskAttachment Attachment;
@@ -81,6 +82,16 @@ class HcsVirtualMachineBackend : public IVirtualMachineBackend
8182
wil::unique_hfile BackingFile;
8283
};
8384

85+
struct VmConfiguration
86+
{
87+
VmDescription Description;
88+
wsl::windows::common::hcs::ComputeSystem Settings;
89+
// Disks attached as part of the compute system settings, tracked so that the host state
90+
// changes made to attach them are undone when the VM goes away.
91+
std::map<std::uint64_t, AttachedDisk> BootDisks;
92+
std::uint64_t NextDiskId = 1;
93+
};
94+
8495
struct FileSystemDevice
8596
{
8697
VmFileSystemDevice Device;

0 commit comments

Comments
 (0)