List and inspect named volumes

src/windows/inc/wslc_schema.h

@@ -101,4 +101,21 @@ struct InspectImage
         InspectImage, Id, RepoTags, RepoDigests, Parent, Comment, Created, Author, Architecture, Os, Size, Metadata, Config);
 };
 
-} // namespace wsl::windows::common::wslc_schema
+struct InspectVhdVolume
+{
+    std::string HostPath;
+    uint64_t SizeBytes{};
+
+    NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(InspectVhdVolume, HostPath, SizeBytes);
+};
+
+struct InspectVolume
+{
+    std::string Name;
+    std::string Type;
+    std::optional<InspectVhdVolume> VhdVolume;
+
+    NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(InspectVolume, Name, Type, VhdVolume);
+};
+
+} // namespace wsl::windows::common::wslc_schema

src/windows/service/inc/wslc.idl

@@ -22,10 +22,12 @@ cpp_quote("#endif")
 
 #define WSLC_MAX_CONTAINER_NAME_LENGTH 255
 #define WSLC_MAX_IMAGE_NAME_LENGTH 255
+#define WSLC_MAX_VOLUME_NAME_LENGTH 255
 #define WSLC_CONTAINER_ID_LENGTH 64
 
 cpp_quote("#define WSLC_MAX_CONTAINER_NAME_LENGTH 255")
 cpp_quote("#define WSLC_MAX_IMAGE_NAME_LENGTH 255")
+cpp_quote("#define WSLC_MAX_VOLUME_NAME_LENGTH 255")
 cpp_quote("#define WSLC_CONTAINER_ID_LENGTH 64")
 
 typedef
@@ -482,6 +484,12 @@ typedef struct _WSLCVolumeOptions
     [unique] LPCSTR Options;
 } WSLCVolumeOptions;
 
+typedef struct _WSLCVolumeInformation
+{
+    char Name[WSLC_MAX_VOLUME_NAME_LENGTH + 1];
+    char Type[64];
+} WSLCVolumeInformation;
+
 typedef struct _WSLCContainerPruneFilter
 {
     LPCSTR Key;
@@ -572,6 +580,8 @@ interface IWSLCSession : IUnknown
     // Volume management.
     HRESULT CreateVolume([in] const WSLCVolumeOptions* Options);
     HRESULT DeleteVolume([in] LPCSTR Name);
+    HRESULT ListVolumes([out, size_is(, *Count)] WSLCVolumeInformation** Volumes, [out] ULONG* Count);
+    HRESULT InspectVolume([in] LPCSTR Name, [out] LPSTR* Output);
 }
 
 //

src/windows/wslcsession/WSLCSession.cpp

@@ -1476,7 +1476,7 @@ try
 
     std::lock_guard volumesLock(m_volumesLock);
     THROW_HR_IF(HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS), m_volumes.contains(name));
-    THROW_HR_WITH_USER_ERROR_IF(E_INVALIDARG, Localization::MessageWslcInvalidVolumeType(type), type != "vhd");
+    THROW_HR_WITH_USER_ERROR_IF(E_INVALIDARG, Localization::MessageWslcInvalidVolumeType(type), type != WSLCVhdVolumeType);
 
     auto volume = WSLCVhdVolumeImpl::Create(*Options, m_storageVhdPath.parent_path(), m_virtualMachine.value(), m_dockerClient.value());
     auto [it, inserted] = m_volumes.insert({name, std::move(volume)});
@@ -1514,6 +1514,70 @@ try
 }
 CATCH_RETURN();
 
+HRESULT WSLCSession::ListVolumes(WSLCVolumeInformation** Volumes, ULONG* Count)
+try
+{
+    COMServiceExecutionContext context;
+
+    RETURN_HR_IF_NULL(E_POINTER, Volumes);
+    RETURN_HR_IF_NULL(E_POINTER, Count);
+
+    *Volumes = nullptr;
+    *Count = 0;
+
+    auto lock = m_lock.lock_shared();
+    std::lock_guard volumesLock(m_volumesLock);
+
+    if (m_volumes.empty())
+    {
+        return S_OK;
+    }
+
+    auto output = wil::make_unique_cotaskmem<WSLCVolumeInformation[]>(m_volumes.size());
+
+    ULONG index = 0;
+    for (const auto& [name, volume] : m_volumes)
+    {
+        THROW_HR_IF(E_UNEXPECTED, strcpy_s(output[index].Name, name.c_str()) != 0);
+        THROW_HR_IF(E_UNEXPECTED, strcpy_s(output[index].Type, WSLCVhdVolumeType) != 0);
+        index++;
+    }
+
+    *Volumes = output.release();
+    *Count = index;
+
+    return S_OK;
+}
+CATCH_RETURN();
+
+HRESULT WSLCSession::InspectVolume(LPCSTR Name, LPSTR* Output)
+try
+{
+    COMServiceExecutionContext context;
+
+    RETURN_HR_IF_NULL(E_POINTER, Name);
+    RETURN_HR_IF_NULL(E_POINTER, Output);
+
+    *Output = nullptr;
+
+    std::string name = Name;
+    ValidateName(name.c_str());
+
+    auto lock = m_lock.lock_shared();
+    std::lock_guard volumesLock(m_volumesLock);
+
+    auto it = m_volumes.find(name);
+    THROW_HR_WITH_USER_ERROR_IF(WSLC_E_VOLUME_NOT_FOUND, Localization::MessageWslcVolumeNotFound(name), it == m_volumes.end());
+
+    const auto& volume = it->second;
+
+    std::string json = volume->Inspect();
+    *Output = wil::make_unique_ansistring<wil::unique_cotaskmem_ansistring>(json.c_str()).release();
+
+    return S_OK;
+}
+CATCH_RETURN();
+
 HRESULT WSLCSession::Terminate()
 try
 {

src/windows/wslcsession/WSLCSession.h

@@ -99,6 +99,8 @@ class DECLSPEC_UUID("4877FEFC-4977-4929-A958-9F36AA1892A4") WSLCSession
     // Volume management.
     IFACEMETHOD(CreateVolume)(_In_ const WSLCVolumeOptions* Options) override;
     IFACEMETHOD(DeleteVolume)(_In_ LPCSTR Name) override;
+    IFACEMETHOD(ListVolumes)(_Out_ WSLCVolumeInformation** Volumes, _Out_ ULONG* Count) override;
+    IFACEMETHOD(InspectVolume)(_In_ LPCSTR Name, _Out_ LPSTR* Output) override;
 
     IFACEMETHOD(Terminate()) override;
 

src/windows/wslcsession/WSLCVhdVolume.cpp

@@ -18,6 +18,7 @@ Module Name:
 #include "WSLCVirtualMachine.h"
 #include "WSLCVolumeMetadata.h"
 #include "WslCoreFilesystem.h"
+#include "wslc_schema.h"
 
 using namespace wsl::windows::common;
 using wsl::shared::Localization;
@@ -28,7 +29,7 @@ namespace {
     std::string SerializeVhdVolumeMetadata(const std::filesystem::path& HostPath, ULONGLONG SizeBytes)
     {
         WSLCVolumeMetadata metadata{};
-        metadata.Type = "vhd";
+        metadata.Type = WSLCVhdVolumeType;
 
         WSLCVhdVolumeMetadata vhdMetadata{};
         vhdMetadata.V1 = WSLCVhdVolumeMetadataV1{HostPath.wstring(), SizeBytes};
@@ -132,7 +133,7 @@ std::unique_ptr<WSLCVhdVolumeImpl> WSLCVhdVolumeImpl::Open(
     THROW_HR_IF(E_INVALIDARG, metadataIt == Volume.Labels.end());
 
     auto metadata = wsl::shared::FromJson<WSLCVolumeMetadata>(metadataIt->second.c_str());
-    THROW_HR_IF(E_INVALIDARG, metadata.Type != "vhd");
+    THROW_HR_IF(E_INVALIDARG, metadata.Type != WSLCVhdVolumeType);
     THROW_HR_IF(E_INVALIDARG, !metadata.VhdVolumeMetadata.has_value() || !metadata.VhdVolumeMetadata->V1.has_value());
 
     const auto& vhdMetadata = metadata.VhdVolumeMetadata->V1.value();
@@ -179,6 +180,19 @@ void WSLCVhdVolumeImpl::Delete()
     LOG_IF_WIN32_BOOL_FALSE(DeleteFileW(m_hostPath.c_str()));
 }
 
+std::string WSLCVhdVolumeImpl::Inspect() const
+{
+    wslc_schema::InspectVolume inspect{};
+    inspect.Name = m_name;
+    inspect.Type = WSLCVhdVolumeType;
+    inspect.VhdVolume = wslc_schema::InspectVhdVolume{
+        m_hostPath.string(),
+        m_sizeBytes,
+    };
+
+    return wsl::shared::ToJson(inspect);
+}
+
 void WSLCVhdVolumeImpl::Detach()
 try
 {

src/windows/wslcsession/WSLCVhdVolume.h

@@ -56,6 +56,7 @@ class WSLCVhdVolumeImpl
         _In_ const wsl::windows::common::docker_schema::Volume& Volume, _In_ WSLCVirtualMachine& VirtualMachine, _In_ DockerHTTPClient& DockerClient);
 
     void Delete();
+    std::string Inspect() const;
 
     const std::string& Name() const noexcept
     {

src/windows/wslcsession/WSLCVolumeMetadata.h

@@ -21,6 +21,9 @@ namespace wsl::windows::service::wslc {
 // Label key used to store WSLC volume metadata in Docker volume labels.
 constexpr auto WSLCVolumeMetadataLabel = "com.microsoft.wsl.volume.metadata";
 
+// Volume type identifier for VHD-backed volumes.
+constexpr auto WSLCVhdVolumeType = "vhd";
+
 struct WSLCVhdVolumeMetadataV1
 {
     std::wstring HostPath;

test/windows/WSLCTests.cpp

@@ -2993,6 +2993,75 @@ class WSLCTests
         validateInvalidOptionsFailure("", WSL_E_INVALID_JSON);
     }
 
+    TEST_METHOD(ListAndInspectNamedVolumesTest)
+    {
+        WSL2_TEST_ONLY();
+
+        const std::string volumeName1 = "wsla-test-vol1";
+        const std::string volumeName2 = "wsla-test-vol2";
+
+        auto cleanup = wil::scope_exit([&]() {
+            LOG_IF_FAILED(m_defaultSession->DeleteVolume(volumeName1.c_str()));
+            LOG_IF_FAILED(m_defaultSession->DeleteVolume(volumeName2.c_str()));
+        });
+
+        // Verify empty list is returned when no volumes exist.
+        wil::unique_cotaskmem_array_ptr<WSLCVolumeInformation> volumes;
+        VERIFY_SUCCEEDED(m_defaultSession->ListVolumes(volumes.addressof(), volumes.size_address<ULONG>()));
+        VERIFY_ARE_EQUAL(0u, volumes.size());
+
+        // Create first volume and verify list returns one entry.
+        WSLCVolumeOptions volumeOptions{};
+        volumeOptions.Name = volumeName1.c_str();
+        volumeOptions.Type = "vhd";
+        volumeOptions.Options = R"({"SizeBytes":"1073741824"})";
+        VERIFY_SUCCEEDED(m_defaultSession->CreateVolume(&volumeOptions));
+
+        VERIFY_SUCCEEDED(m_defaultSession->ListVolumes(volumes.addressof(), volumes.size_address<ULONG>()));
+        VERIFY_ARE_EQUAL(1u, volumes.size());
+        VERIFY_ARE_EQUAL(std::string(volumes[0].Name), volumeName1);
+        VERIFY_ARE_EQUAL(std::string(volumes[0].Type), std::string("vhd"));
+
+        // Create second volume and verify list returns two entries.
+        volumeOptions.Name = volumeName2.c_str();
+        VERIFY_SUCCEEDED(m_defaultSession->CreateVolume(&volumeOptions));
+
+        VERIFY_SUCCEEDED(m_defaultSession->ListVolumes(volumes.addressof(), volumes.size_address<ULONG>()));
+        VERIFY_ARE_EQUAL(2u, volumes.size());
+
+        std::set<std::string> names;
+        for (const auto& v : volumes)
+        {
+            names.insert(v.Name);
+            VERIFY_ARE_EQUAL(std::string(v.Type), std::string("vhd"));
+        }
+
+        VERIFY_IS_TRUE(names.contains(volumeName1));
+        VERIFY_IS_TRUE(names.contains(volumeName2));
+
+        // Verify InspectVolume returns correct details.
+        wil::unique_cotaskmem_ansistring output;
+        VERIFY_SUCCEEDED(m_defaultSession->InspectVolume(volumeName1.c_str(), &output));
+        VERIFY_IS_NOT_NULL(output.get());
+
+        auto inspect = wsl::shared::FromJson<wsl::windows::common::wslc_schema::InspectVolume>(output.get());
+        VERIFY_ARE_EQUAL(inspect.Name, volumeName1);
+        VERIFY_ARE_EQUAL(inspect.Type, std::string("vhd"));
+        VERIFY_IS_TRUE(inspect.VhdVolume.has_value());
+        VERIFY_ARE_EQUAL(inspect.VhdVolume->SizeBytes, 1073741824ull);
+        VERIFY_IS_FALSE(inspect.VhdVolume->HostPath.empty());
+
+        // Verify InspectVolume fails for a non-existent volume.
+        output.reset();
+        VERIFY_ARE_EQUAL(m_defaultSession->InspectVolume("does-not-exist", &output), WSLC_E_VOLUME_NOT_FOUND);
+
+        // Delete first volume and verify list returns one entry.
+        VERIFY_SUCCEEDED(m_defaultSession->DeleteVolume(volumeName1.c_str()));
+        VERIFY_SUCCEEDED(m_defaultSession->ListVolumes(volumes.addressof(), volumes.size_address<ULONG>()));
+        VERIFY_ARE_EQUAL(1u, volumes.size());
+        VERIFY_ARE_EQUAL(std::string(volumes[0].Name), volumeName2);
+    }
+
     TEST_METHOD(CreateContainer)
     {
         WSL2_TEST_ONLY();