cleanup: add handling for product-specific virtio networking class IDs. (#13822)

benhillis · web-flow · commit 1390e644fbd3 · 2025-12-03T18:55:25.000-08:00
diff --git a/packages.config b/packages.config
@@ -18,7 +18,7 @@
   <package id="Microsoft.WSL.bsdtar" version="0.0.2-2" />
   <package id="Microsoft.WSL.Dependencies.amd64fre" version="10.0.27820.1000-250318-1700.rs-base2-hyp" targetFramework="native" />
   <package id="Microsoft.WSL.Dependencies.arm64fre" version="10.0.27820.1000-250318-1700.rs-base2-hyp" targetFramework="native" />
-  <package id="Microsoft.WSL.DeviceHost" version="1.0.0-20251201.1" />
+  <package id="Microsoft.WSL.DeviceHost" version="1.0.0-20251202.1" />
   <package id="Microsoft.WSL.Kernel" version="6.6.114.1-1" targetFramework="native" />
   <package id="Microsoft.WSL.LinuxSdk" version="1.20.0" targetFramework="native" />
   <package id="Microsoft.WSL.TestDistro" version="2.5.7-47" />
diff --git a/src/windows/common/GuestDeviceManager.cpp b/src/windows/common/GuestDeviceManager.cpp
@@ -70,7 +70,7 @@ void GuestDeviceManager::AddSharedMemoryDevice(_In_ const GUID& ImplementationCl
     static constexpr auto VIRTIO_FS_FLAGS_SHMEM_SIZE_SHIFT = 16;
     UINT32 flags = (SizeMb << VIRTIO_FS_FLAGS_SHMEM_SIZE_SHIFT);
     WI_SetFlag(flags, VIRTIO_FS_FLAGS_TYPE_SECTIONS);
-    (void)AddHdvShareWithOptions(VIRTIO_VIRTIOFS_DEVICE_ID, ImplementationClsid, Tag, {}, objectLifetime.Path.c_str(), flags, UserToken);
+    (void)AddHdvShareWithOptions(VIRTIO_FS_DEVICE_ID, ImplementationClsid, Tag, {}, objectLifetime.Path.c_str(), flags, UserToken);
     m_objectDirectories.emplace_back(std::move(objectLifetime));
 }
 
diff --git a/src/windows/common/GuestDeviceManager.h b/src/windows/common/GuestDeviceManager.h
@@ -8,14 +8,13 @@
 #define VIRTIO_FS_FLAGS_TYPE_FILES 0x8000
 #define VIRTIO_FS_FLAGS_TYPE_SECTIONS 0x4000
 
-// {872270E1-A899-4AF6-B454-7193634435AD}
-DEFINE_GUID(VIRTIO_VIRTIOFS_DEVICE_ID, 0x872270E1, 0xA899, 0x4AF6, 0xB4, 0x54, 0x71, 0x93, 0x63, 0x44, 0x35, 0xAD);
-
-// {ABB755FC-1B86-4255-83E2-E5787ABCF6C2}
-DEFINE_GUID(VIRTIO_PMEM_CLASS_ID, 0xABB755FC, 0x1B86, 0x4255, 0x83, 0xe2, 0xe5, 0x78, 0x7a, 0xbc, 0xf6, 0xc2);
-
 inline const std::wstring c_defaultDeviceTag = L"default";
 
+// These device types are implemented by the external wsldevicehost vdev.
+DEFINE_GUID(VIRTIO_FS_DEVICE_ID, 0x872270E1, 0xA899, 0x4AF6, 0xB4, 0x54, 0x71, 0x93, 0x63, 0x44, 0x35, 0xAD); // {872270E1-A899-4AF6-B454-7193634435AD}
+DEFINE_GUID(VIRTIO_NET_DEVICE_ID, 0xF07010D0, 0x0EA9, 0x447F, 0x88, 0xEF, 0xBD, 0x95, 0x2A, 0x4D, 0x2F, 0x14); // {F07010D0-0EA9-447F-88EF-BD952A4D2F14}
+DEFINE_GUID(VIRTIO_PMEM_DEVICE_ID, 0xEDBB24BB, 0x5E19, 0x40F4, 0x8A, 0x0F, 0x82, 0x24, 0x31, 0x30, 0x64, 0xFD); // {EDBB24BB-5E19-40F4-8A0F-8224313064FD}
+
 //
 // Provides synchronized access to guest device operations.
 //
diff --git a/src/windows/common/VirtioNetworking.cpp b/src/windows/common/VirtioNetworking.cpp
@@ -14,11 +14,12 @@ using wsl::core::VirtioNetworking;
 static constexpr auto c_loopbackDeviceName = TEXT(LX_INIT_LOOPBACK_DEVICE_NAME);
 
 VirtioNetworking::VirtioNetworking(
-    GnsChannel&& gnsChannel, bool enableLocalhostRelay, std::shared_ptr<GuestDeviceManager> guestDeviceManager, wil::shared_handle userToken) :
+    GnsChannel&& gnsChannel, bool enableLocalhostRelay, std::shared_ptr<GuestDeviceManager> guestDeviceManager, GUID classId, wil::shared_handle userToken) :
     m_guestDeviceManager(std::move(guestDeviceManager)),
     m_userToken(std::move(userToken)),
     m_gnsChannel(std::move(gnsChannel)),
-    m_enableLocalhostRelay(enableLocalhostRelay)
+    m_enableLocalhostRelay(enableLocalhostRelay),
+    m_virtioNetworkClsid(classId)
 {
 }
 
@@ -31,7 +32,6 @@ VirtioNetworking::~VirtioNetworking()
 }
 
 void VirtioNetworking::Initialize()
-try
 {
     m_networkSettings = GetHostEndpointSettings();
 
@@ -80,7 +80,7 @@ try
 
     // Add virtio net adapter to guest
     m_adapterId = m_guestDeviceManager->AddGuestDevice(
-        c_virtioNetworkDeviceId, c_virtioNetworkClsid, L"eth0", nullptr, device_options.str().c_str(), 0, m_userToken.get());
+        VIRTIO_NET_DEVICE_ID, m_virtioNetworkClsid, L"eth0", nullptr, device_options.str().c_str(), 0, m_userToken.get());
 
     hns::HNSEndpoint endpointProperties;
     endpointProperties.ID = m_adapterId;
@@ -122,13 +122,12 @@ try
 
     THROW_IF_WIN32_ERROR(NotifyNetworkConnectivityHintChange(&VirtioNetworking::OnNetworkConnectivityChange, this, true, &m_networkNotifyHandle));
 }
-CATCH_LOG()
 
 void VirtioNetworking::SetupLoopbackDevice()
 {
     m_localhostAdapterId = m_guestDeviceManager->AddGuestDevice(
-        c_virtioNetworkDeviceId,
-        c_virtioNetworkClsid,
+        VIRTIO_NET_DEVICE_ID,
+        m_virtioNetworkClsid,
         c_loopbackDeviceName,
         nullptr,
         L"client_ip=127.0.0.1;client_mac=00:11:22:33:44:55",
@@ -196,13 +195,13 @@ HRESULT VirtioNetworking::HandlePortNotification(const SOCKADDR_INET& addr, int
                 localAddr.Ipv6.sin6_port = addr.Ipv6.sin6_port;
             }
         }
-        result = ModifyOpenPorts(c_virtioNetworkClsid, c_loopbackDeviceName, localAddr, protocol, allocate);
+        result = ModifyOpenPorts(c_loopbackDeviceName, localAddr, protocol, allocate);
         LOG_HR_IF_MSG(E_FAIL, result != S_OK, "Failure adding localhost relay port %d", localAddr.Ipv4.sin_port);
     }
 
     if (!loopback)
     {
-        const int localResult = ModifyOpenPorts(c_virtioNetworkClsid, L"eth0", addr, protocol, allocate);
+        const int localResult = ModifyOpenPorts(L"eth0", addr, protocol, allocate);
         LOG_HR_IF_MSG(E_FAIL, localResult != S_OK, "Failure adding relay port %d", addr.Ipv4.sin_port);
         if (result == 0)
         {
@@ -213,7 +212,7 @@ HRESULT VirtioNetworking::HandlePortNotification(const SOCKADDR_INET& addr, int
     return result;
 }
 
-int VirtioNetworking::ModifyOpenPorts(_In_ const GUID& clsid, _In_ PCWSTR tag, _In_ const SOCKADDR_INET& addr, _In_ int protocol, _In_ bool isOpen) const
+int VirtioNetworking::ModifyOpenPorts(_In_ PCWSTR tag, _In_ const SOCKADDR_INET& addr, _In_ int protocol, _In_ bool isOpen) const
 {
     if (protocol != IPPROTO_TCP && protocol != IPPROTO_UDP)
     {
@@ -229,7 +228,7 @@ int VirtioNetworking::ModifyOpenPorts(_In_ const GUID& clsid, _In_ PCWSTR tag, _
     }
 
     auto lock = m_lock.lock_exclusive();
-    const auto server = m_guestDeviceManager->GetRemoteFileSystem(clsid, c_defaultDeviceTag);
+    const auto server = m_guestDeviceManager->GetRemoteFileSystem(m_virtioNetworkClsid, c_defaultDeviceTag);
     if (server)
     {
         std::wstring portString = std::format(L"tag={};port_number={}", tag, addr.Ipv4.sin_port);
diff --git a/src/windows/common/VirtioNetworking.h b/src/windows/common/VirtioNetworking.h
@@ -13,7 +13,7 @@ namespace wsl::core {
 class VirtioNetworking : public INetworkingEngine
 {
 public:
-    VirtioNetworking(GnsChannel&& gnsChannel, bool enableLocalhostRelay, std::shared_ptr<GuestDeviceManager> guestDeviceManager, wil::shared_handle userToken);
+    VirtioNetworking(GnsChannel&& gnsChannel, bool enableLocalhostRelay, std::shared_ptr<GuestDeviceManager> guestDeviceManager, GUID classId, wil::shared_handle userToken);
     ~VirtioNetworking();
 
     // Note: This class cannot be moved because m_networkNotifyHandle captures a 'this' pointer.
@@ -35,7 +35,7 @@ class VirtioNetworking : public INetworkingEngine
     static std::optional<ULONGLONG> FindVirtioInterfaceLuid(const SOCKADDR_INET& virtioAddress, const NL_NETWORK_CONNECTIVITY_HINT& currentConnectivityHint);
 
     HRESULT HandlePortNotification(const SOCKADDR_INET& addr, int protocol, bool allocate) const noexcept;
-    int ModifyOpenPorts(_In_ const GUID& clsid, _In_ PCWSTR tag, _In_ const SOCKADDR_INET& addr, _In_ int protocol, _In_ bool isOpen) const;
+    int ModifyOpenPorts(_In_ PCWSTR tag, _In_ const SOCKADDR_INET& addr, _In_ int protocol, _In_ bool isOpen) const;
     void RefreshGuestConnection(NL_NETWORK_CONNECTIVITY_HINT hint) noexcept;
     void SetupLoopbackDevice();
     void UpdateDns(wsl::shared::hns::DNS&& dnsSettings);
@@ -51,18 +51,14 @@ class VirtioNetworking : public INetworkingEngine
     bool m_enableLocalhostRelay;
     GUID m_localhostAdapterId;
     GUID m_adapterId;
+    GUID m_virtioNetworkClsid;
 
     std::optional<ULONGLONG> m_interfaceLuid;
     ULONG m_networkMtu = 0;
     std::optional<wsl::core::networking::HostDnsInfo> m_dnsInfo;
 
     // Note: this field must be destroyed first to stop the callbacks before any other field is destroyed.
     networking::unique_notify_handle m_networkNotifyHandle;
-
-    // 16479D2E-F0C3-4DBA-BF7A-04FFF0892B07
-    static constexpr GUID c_virtioNetworkClsid = {0x16479D2E, 0xF0C3, 0x4DBA, {0xBF, 0x7A, 0x04, 0xFF, 0xF0, 0x89, 0x2B, 0x07}};
-    // F07010D0-0EA9-447F-88EF-BD952A4D2F14
-    static constexpr GUID c_virtioNetworkDeviceId = {0xF07010D0, 0x0EA9, 0x447F, {0x88, 0xEF, 0xBD, 0x95, 0x2A, 0x4D, 0x2F, 0x14}};
 };
 
 } // namespace wsl::core
diff --git a/src/windows/service/exe/WslCoreVm.cpp b/src/windows/service/exe/WslCoreVm.cpp
@@ -39,10 +39,6 @@ using namespace std::string_literals;
 // Start of unaddressable memory if guest only supports the minimum 36-bit addressing.
 #define MAX_36_BIT_PAGE_IN_MB (0x1000000000 / _1MB)
 
-// This device type is implemented by the external virtio-pmem vdev.
-// {EDBB24BB-5E19-40F4-8A0F-8224313064FD}
-DEFINE_GUID(VIRTIO_PMEM_DEVICE_ID, 0xEDBB24BB, 0x5E19, 0x40F4, 0x8A, 0x0F, 0x82, 0x24, 0x31, 0x30, 0x64, 0xFD);
-
 // Version numbers for various functionality that was backported.
 #define NICKEL_BUILD_FLOOR 22350
 #define VIRTIO_SERIAL_CONSOLE_COBALT_RELEASE_UBR 40
@@ -53,6 +49,12 @@ DEFINE_GUID(VIRTIO_PMEM_DEVICE_ID, 0xEDBB24BB, 0x5E19, 0x40F4, 0x8A, 0x0F, 0x82,
 #define WSLG_SHARED_MEMORY_SIZE_MB 8192
 #define PAGE_SIZE 0x1000
 
+// WSL-specific virtio device class IDs.
+DEFINE_GUID(VIRTIO_FS_ADMIN_CLASS_ID, 0x7E6AD219, 0xD1B3, 0x42D5, 0xB8, 0xEE, 0xD9, 0x63, 0x24, 0xE6, 0x4F, 0xF6); // {7E6AD219-D1B3-42D5-B8EE-D96324E64FF6}
+DEFINE_GUID(VIRTIO_FS_CLASS_ID, 0x60285AE6, 0xAAF3, 0x4456, 0xB4, 0x44, 0xA6, 0xC2, 0xD0, 0xDE, 0xDA, 0x38); // {60285AE6-AAF3-4456-B444-A6C2D0DEDA38}
+DEFINE_GUID(VIRTIO_NET_CLASS_ID, 0x16479D2E, 0xF0C3, 0x4DBA, 0xBF, 0x7A, 0x04, 0xFF, 0xF0, 0x89, 0x2B, 0x07); // {16479D2E-F0C3-4DBA-BF7A-04FFF0892B07}
+DEFINE_GUID(VIRTIO_PMEM_CLASS_ID, 0xABB755FC, 0x1B86, 0x4255, 0x83, 0xE2, 0xE5, 0x78, 0x7A, 0xBC, 0xF6, 0xC2); // {ABB755FC-1B86-4255-83E2-E5787ABCF6C2}
+
 static constexpr size_t c_bootEntropy = 0x1000;
 static constexpr auto c_localDevicesKey = L"SOFTWARE\\Microsoft\\Terminal Server Client\\LocalDevices";
 static constexpr std::pair<uint32_t, uint32_t> c_schemaVersionNickel{2, 7};
@@ -596,7 +598,7 @@ void WslCoreVm::Initialize(const GUID& VmId, const wil::shared_handle& UserToken
             else if (m_vmConfig.NetworkingMode == NetworkingMode::VirtioProxy)
             {
                 m_networkingEngine = std::make_unique<wsl::core::VirtioNetworking>(
-                    std::move(gnsChannel), m_vmConfig.EnableLocalhostRelay, m_guestDeviceManager, m_userToken);
+                    std::move(gnsChannel), m_vmConfig.EnableLocalhostRelay, m_guestDeviceManager, VIRTIO_NET_CLASS_ID, m_userToken);
             }
             else if (m_vmConfig.NetworkingMode == NetworkingMode::Bridged)
             {
@@ -1792,7 +1794,7 @@ void WslCoreVm::InitializeGuest()
             try
             {
                 m_guestDeviceManager->AddSharedMemoryDevice(
-                    c_virtiofsClassId, L"wslg", L"wslg", WSLG_SHARED_MEMORY_SIZE_MB, m_userToken.get());
+                    VIRTIO_FS_CLASS_ID, L"wslg", L"wslg", WSLG_SHARED_MEMORY_SIZE_MB, m_userToken.get());
                 m_sharedMemoryRoot = std::format(L"WSL\\{}\\wslg", m_machineId);
             }
             CATCH_LOG()
@@ -2145,8 +2147,8 @@ std::wstring WslCoreVm::AddVirtioFsShare(_In_ bool Admin, _In_ PCWSTR Path, _In_
         WI_ASSERT(!FindVirtioFsShare(tag.c_str(), Admin));
 
         (void)m_guestDeviceManager->AddGuestDevice(
-            VIRTIO_VIRTIOFS_DEVICE_ID,
-            Admin ? c_virtiofsAdminClassId : c_virtiofsClassId,
+            VIRTIO_FS_DEVICE_ID,
+            Admin ? VIRTIO_FS_ADMIN_CLASS_ID : VIRTIO_FS_CLASS_ID,
             tag.c_str(),
             key.OptionsString().c_str(),
             sharePath.c_str(),
diff --git a/src/windows/service/exe/WslCoreVm.h b/src/windows/service/exe/WslCoreVm.h
@@ -40,11 +40,6 @@ inline constexpr auto c_optionsValueName = L"Options";
 inline constexpr auto c_typeValueName = L"Type";
 inline constexpr auto c_mountNameValueName = L"Name";
 
-static constexpr GUID c_virtiofsAdminClassId = {0x7e6ad219, 0xd1b3, 0x42d5, {0xb8, 0xee, 0xd9, 0x63, 0x24, 0xe6, 0x4f, 0xf6}};
-
-// {60285AE6-AAF3-4456-B444-A6C2D0DEDA38}
-static constexpr GUID c_virtiofsClassId = {0x60285ae6, 0xaaf3, 0x4456, {0xb4, 0x44, 0xa6, 0xc2, 0xd0, 0xde, 0xda, 0x38}};
-
 namespace wrl = Microsoft::WRL;
 
 /// <summary>

Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ void GuestDeviceManager::AddSharedMemoryDevice(_In_ const GUID& ImplementationCl`
`70`	`70`	`static constexpr auto VIRTIO_FS_FLAGS_SHMEM_SIZE_SHIFT = 16;`
`71`	`71`	`UINT32 flags = (SizeMb << VIRTIO_FS_FLAGS_SHMEM_SIZE_SHIFT);`
`72`	`72`	`WI_SetFlag(flags, VIRTIO_FS_FLAGS_TYPE_SECTIONS);`
`73`		`- (void)AddHdvShareWithOptions(VIRTIO_VIRTIOFS_DEVICE_ID, ImplementationClsid, Tag, {}, objectLifetime.Path.c_str(), flags, UserToken);`
	`73`	`+ (void)AddHdvShareWithOptions(VIRTIO_FS_DEVICE_ID, ImplementationClsid, Tag, {}, objectLifetime.Path.c_str(), flags, UserToken);`
`74`	`74`	`m_objectDirectories.emplace_back(std::move(objectLifetime));`
`75`	`75`	`}`
`76`	`76`
Original file line number	Diff line number	Diff line change
`@@ -14,11 +14,12 @@ using wsl::core::VirtioNetworking;`
`14`	`14`	`static constexpr auto c_loopbackDeviceName = TEXT(LX_INIT_LOOPBACK_DEVICE_NAME);`
`15`	`15`
`16`	`16`	`VirtioNetworking::VirtioNetworking(`
`17`		`- GnsChannel&& gnsChannel, bool enableLocalhostRelay, std::shared_ptr<GuestDeviceManager> guestDeviceManager, wil::shared_handle userToken) :`
	`17`	`+ GnsChannel&& gnsChannel, bool enableLocalhostRelay, std::shared_ptr<GuestDeviceManager> guestDeviceManager, GUID classId, wil::shared_handle userToken) :`
`18`	`18`	`m_guestDeviceManager(std::move(guestDeviceManager)),`
`19`	`19`	`m_userToken(std::move(userToken)),`
`20`	`20`	`m_gnsChannel(std::move(gnsChannel)),`
`21`		`- m_enableLocalhostRelay(enableLocalhostRelay)`
	`21`	`+ m_enableLocalhostRelay(enableLocalhostRelay),`
	`22`	`+ m_virtioNetworkClsid(classId)`
`22`	`23`	`{`
`23`	`24`	`}`
`24`	`25`
`@@ -31,7 +32,6 @@ VirtioNetworking::~VirtioNetworking()`
`31`	`32`	`}`
`32`	`33`
`33`	`34`	`void VirtioNetworking::Initialize()`
`34`		`-try`
`35`	`35`	`{`
`36`	`36`	`m_networkSettings = GetHostEndpointSettings();`
`37`	`37`
`@@ -80,7 +80,7 @@ try`
`80`	`80`
`81`	`81`	`// Add virtio net adapter to guest`
`82`	`82`	`m_adapterId = m_guestDeviceManager->AddGuestDevice(`
`83`		`- c_virtioNetworkDeviceId, c_virtioNetworkClsid, L"eth0", nullptr, device_options.str().c_str(), 0, m_userToken.get());`
	`83`	`+ VIRTIO_NET_DEVICE_ID, m_virtioNetworkClsid, L"eth0", nullptr, device_options.str().c_str(), 0, m_userToken.get());`
`84`	`84`
`85`	`85`	`hns::HNSEndpoint endpointProperties;`
`86`	`86`	`endpointProperties.ID = m_adapterId;`
`@@ -122,13 +122,12 @@ try`
`122`	`122`
`123`	`123`	`THROW_IF_WIN32_ERROR(NotifyNetworkConnectivityHintChange(&VirtioNetworking::OnNetworkConnectivityChange, this, true, &m_networkNotifyHandle));`
`124`	`124`	`}`
`125`		`-CATCH_LOG()`
`126`	`125`
`127`	`126`	`void VirtioNetworking::SetupLoopbackDevice()`
`128`	`127`	`{`
`129`	`128`	`m_localhostAdapterId = m_guestDeviceManager->AddGuestDevice(`
`130`		`- c_virtioNetworkDeviceId,`
`131`		`- c_virtioNetworkClsid,`
	`129`	`+ VIRTIO_NET_DEVICE_ID,`
	`130`	`+ m_virtioNetworkClsid,`
`132`	`131`	`c_loopbackDeviceName,`
`133`	`132`	`nullptr,`
`134`	`133`	`L"client_ip=127.0.0.1;client_mac=00:11:22:33:44:55",`
`@@ -196,13 +195,13 @@ HRESULT VirtioNetworking::HandlePortNotification(const SOCKADDR_INET& addr, int`
`196`	`195`	`localAddr.Ipv6.sin6_port = addr.Ipv6.sin6_port;`
`197`	`196`	`}`
`198`	`197`	`}`
`199`		`- result = ModifyOpenPorts(c_virtioNetworkClsid, c_loopbackDeviceName, localAddr, protocol, allocate);`
	`198`	`+ result = ModifyOpenPorts(c_loopbackDeviceName, localAddr, protocol, allocate);`
`200`	`199`	`LOG_HR_IF_MSG(E_FAIL, result != S_OK, "Failure adding localhost relay port %d", localAddr.Ipv4.sin_port);`
`201`	`200`	`}`
`202`	`201`
`203`	`202`	`if (!loopback)`
`204`	`203`	`{`
`205`		`- const int localResult = ModifyOpenPorts(c_virtioNetworkClsid, L"eth0", addr, protocol, allocate);`
	`204`	`+ const int localResult = ModifyOpenPorts(L"eth0", addr, protocol, allocate);`
`206`	`205`	`LOG_HR_IF_MSG(E_FAIL, localResult != S_OK, "Failure adding relay port %d", addr.Ipv4.sin_port);`
`207`	`206`	`if (result == 0)`
`208`	`207`	`{`
`@@ -213,7 +212,7 @@ HRESULT VirtioNetworking::HandlePortNotification(const SOCKADDR_INET& addr, int`
`213`	`212`	`return result;`
`214`	`213`	`}`
`215`	`214`
`216`		`-int VirtioNetworking::ModifyOpenPorts(_In_ const GUID& clsid, _In_ PCWSTR tag, _In_ const SOCKADDR_INET& addr, _In_ int protocol, _In_ bool isOpen) const`
	`215`	`+int VirtioNetworking::ModifyOpenPorts(_In_ PCWSTR tag, _In_ const SOCKADDR_INET& addr, _In_ int protocol, _In_ bool isOpen) const`
`217`	`216`	`{`
`218`	`217`	`if (protocol != IPPROTO_TCP && protocol != IPPROTO_UDP)`
`219`	`218`	`{`
`@@ -229,7 +228,7 @@ int VirtioNetworking::ModifyOpenPorts(_In_ const GUID& clsid, _In_ PCWSTR tag, _`
`229`	`228`	`}`
`230`	`229`
`231`	`230`	`auto lock = m_lock.lock_exclusive();`
`232`		`- const auto server = m_guestDeviceManager->GetRemoteFileSystem(clsid, c_defaultDeviceTag);`
	`231`	`+ const auto server = m_guestDeviceManager->GetRemoteFileSystem(m_virtioNetworkClsid, c_defaultDeviceTag);`
`233`	`232`	`if (server)`
`234`	`233`	`{`
`235`	`234`	`std::wstring portString = std::format(L"tag={};port_number={}", tag, addr.Ipv4.sin_port);`