feature(sysman): implement getExtensionProperties in sysman driver component

Related-To: NEO-16529

Signed-off-by: Sarbojit Sarkar <sarbojit.sarkar@intel.com>

level_zero/include/level_zero/zes_intel_gpu_sysman.h

@@ -21,6 +21,12 @@ extern "C" {
 #define ZES_INTEL_GPU_SYSMAN_VERSION_MAJOR 0
 #define ZES_INTEL_GPU_SYSMAN_VERSION_MINOR 1
 
+///////////////////////////////////////////////////////////////////////////////
+#ifndef ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_NAME
+/// @brief PCI link speed downgrade state extension name
+#define ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_NAME "ZES_intel_experimental_pci_link_speed_downgrade_state"
+#endif // ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_NAME
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Query pcie downgrade status extension Version(s)
 typedef enum _zes_intel_pci_link_speed_downgrade_exp_state_version_t {
@@ -39,6 +45,12 @@ typedef struct _zes_intel_pci_link_speed_downgrade_exp_state_t {
     ze_bool_t pciLinkSpeedDowngradeStatus; ///< [out] Returns the current PCIe downgrade status .
 } zes_intel_pci_link_speed_downgrade_exp_state_t;
 
+///////////////////////////////////////////////////////////////////////////////
+#ifndef ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTY_NAME
+/// @brief PCI link speed downgrade property extension name
+#define ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTY_NAME "ZES_intel_experimental_pci_link_speed_downgrade_property"
+#endif // ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTY_NAME
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Query pcie downgrade capability extension Version(s)
 typedef enum _zes_intel_pci_link_speed_downgrade_exp_properties_version_t {
@@ -64,6 +76,12 @@ ze_result_t ZE_APICALL zesIntelDevicePciLinkSpeedUpdateExp(
     zes_device_action_t *pendingAction ///< [out] Pending action
 );
 
+///////////////////////////////////////////////////////////////////////////////
+#ifndef ZES_INTEL_DRIVER_NAME_EXP_PROPERTY_NAME
+/// @brief Driver name property extension name
+#define ZES_INTEL_DRIVER_NAME_EXP_PROPERTY_NAME "ZES_intel_experimental_driver_name_property"
+#endif // ZES_INTEL_DRIVER_NAME_EXP_PROPERTY_NAME
+
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Query driver name extension Version(s)
 typedef enum _zes_intel_driver_name_exp_properties_version_t {

level_zero/sysman/source/driver/CMakeLists.txt

@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2023 Intel Corporation
+# Copyright (C) 2023-2025 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -12,6 +12,7 @@ target_sources(${L0_STATIC_LIB_NAME}
                ${CMAKE_CURRENT_SOURCE_DIR}/sysman_driver.cpp
                ${CMAKE_CURRENT_SOURCE_DIR}/sysman_driver_handle.h
                ${CMAKE_CURRENT_SOURCE_DIR}/sysman_driver_handle_imp.h
+               ${CMAKE_CURRENT_SOURCE_DIR}/sysman_driver_handle_imp_helper.cpp
                ${CMAKE_CURRENT_SOURCE_DIR}/sysman_driver_handle_imp.cpp
                ${CMAKE_CURRENT_SOURCE_DIR}/os_sysman_driver.h
 )

level_zero/sysman/source/driver/sysman_driver_handle_imp.cpp

@@ -240,7 +240,17 @@ ze_result_t SysmanDriverHandleImp::getDeviceByUuid(zes_uuid_t uuid, zes_device_h
 }
 
 ze_result_t SysmanDriverHandleImp::getExtensionProperties(uint32_t *pCount, zes_driver_extension_properties_t *pExtensionProperties) {
-    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    if (*pCount == 0) {
+        *pCount = static_cast<uint32_t>(extensionsSupported.size());
+        return ZE_RESULT_SUCCESS;
+    }
+    uint32_t numExtensionsToCopy = std::min(*pCount, static_cast<uint32_t>(extensionsSupported.size()));
+    for (uint32_t i = 0; i < numExtensionsToCopy; i++) {
+        std::strncpy(pExtensionProperties[i].name, extensionsSupported[i].first.c_str(), ZE_MAX_EXTENSION_NAME);
+        pExtensionProperties[i].version = extensionsSupported[i].second;
+    }
+    *pCount = numExtensionsToCopy;
+    return ZE_RESULT_SUCCESS;
 }
 
 ze_result_t SysmanDriverHandleImp::sysmanEventsListen(uint32_t timeout, uint32_t count, zes_device_handle_t *phDevices, uint32_t *pNumDeviceEvents, zes_event_type_flags_t *pEvents) {

level_zero/sysman/source/driver/sysman_driver_handle_imp.h

@@ -11,6 +11,7 @@
 #include <mutex>
 #include <string>
 #include <unordered_map>
+#include <vector>
 
 namespace NEO {
 class ExecutionEnvironment;
@@ -40,6 +41,8 @@ struct SysmanDriverHandleImp : SysmanDriverHandle {
     const std::unordered_map<std::string, SysmanDevice *> &getUuidDeviceMap() const {
         return uuidDeviceMap;
     }
+    // list of supported extension apis
+    static const std::vector<std::pair<std::string, uint32_t>> extensionsSupported;
 
   private:
     void updateUuidMap(SysmanDevice *sysmanDevice);

level_zero/sysman/source/driver/sysman_driver_handle_imp_helper.cpp

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2025 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/source/driver/sysman_driver_handle_imp.h"
+#include "level_zero/zes_api.h"
+#include "level_zero/zes_intel_gpu_sysman.h"
+
+namespace L0 {
+namespace Sysman {
+const std::vector<std::pair<std::string, uint32_t>> SysmanDriverHandleImp::extensionsSupported = {
+    // zes_api extensions
+    {ZES_DEVICE_ECC_DEFAULT_PROPERTIES_EXT_NAME, ZES_DEVICE_ECC_DEFAULT_PROPERTIES_EXT_VERSION_CURRENT},
+    {ZES_POWER_LIMITS_EXT_NAME, ZES_POWER_LIMITS_EXT_VERSION_CURRENT},
+    {ZES_ENGINE_ACTIVITY_EXT_NAME, ZES_ENGINE_ACTIVITY_EXT_VERSION_CURRENT},
+    {ZES_RAS_GET_STATE_EXP_NAME, ZES_RAS_STATE_EXP_VERSION_CURRENT},
+    {ZES_MEM_PAGE_OFFLINE_STATE_EXP_NAME, ZES_MEM_PAGE_OFFLINE_STATE_EXP_VERSION_CURRENT},
+    {ZES_MEMORY_BANDWIDTH_COUNTER_BITS_EXP_PROPERTIES_NAME, ZES_MEM_BANDWIDTH_COUNTER_BITS_EXP_VERSION_CURRENT},
+    {ZES_SYSMAN_DEVICE_MAPPING_EXP_NAME, ZES_SYSMAN_DEVICE_MAPPING_EXP_VERSION_CURRENT},
+    {ZES_VIRTUAL_FUNCTION_MANAGEMENT_EXP_NAME, ZES_VF_MANAGEMENT_EXP_VERSION_CURRENT},
+
+    // zes_intel_gpu_sysman extensions
+    {ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_NAME, ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_VERSION_CURRENT},
+    {ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTY_NAME, ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTIES_VERSION_CURRENT},
+    {ZES_INTEL_DRIVER_NAME_EXP_PROPERTY_NAME, ZES_INTEL_DRIVER_NAME_EXP_PROPERTIES_VERSION_CURRENT}};
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/test/unit_tests/sources/linux/test_sysman_driver.cpp

@@ -15,6 +15,7 @@
 #include "level_zero/sysman/source/driver/sysman_driver_handle_imp.h"
 #include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_driver.h"
 #include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_drm.h"
+#include "level_zero/zes_intel_gpu_sysman.h"
 
 #include "gtest/gtest.h"
 
@@ -227,8 +228,32 @@ TEST_F(SysmanDriverHandleTest, whenQueryingForDevicesWithCountGreaterThanZeroAnd
     EXPECT_EQ(ZE_RESULT_ERROR_INVALID_NULL_HANDLE, result);
 }
 
+bool verifyExtensionDefinition(std::vector<zes_driver_extension_properties_t> &extensionsReturned, uint32_t count) {
+    const std::vector<std::pair<std::string, uint32_t>> supportedExtensions = {
+        {ZES_DEVICE_ECC_DEFAULT_PROPERTIES_EXT_NAME, ZES_DEVICE_ECC_DEFAULT_PROPERTIES_EXT_VERSION_CURRENT},
+        {ZES_POWER_LIMITS_EXT_NAME, ZES_POWER_LIMITS_EXT_VERSION_CURRENT},
+        {ZES_ENGINE_ACTIVITY_EXT_NAME, ZES_ENGINE_ACTIVITY_EXT_VERSION_CURRENT},
+        {ZES_RAS_GET_STATE_EXP_NAME, ZES_RAS_STATE_EXP_VERSION_CURRENT},
+        {ZES_MEM_PAGE_OFFLINE_STATE_EXP_NAME, ZES_MEM_PAGE_OFFLINE_STATE_EXP_VERSION_CURRENT},
+        {ZES_MEMORY_BANDWIDTH_COUNTER_BITS_EXP_PROPERTIES_NAME, ZES_MEM_BANDWIDTH_COUNTER_BITS_EXP_VERSION_CURRENT},
+        {ZES_SYSMAN_DEVICE_MAPPING_EXP_NAME, ZES_SYSMAN_DEVICE_MAPPING_EXP_VERSION_CURRENT},
+        {ZES_VIRTUAL_FUNCTION_MANAGEMENT_EXP_NAME, ZES_VF_MANAGEMENT_EXP_VERSION_CURRENT},
+        {ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_NAME, ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_VERSION_CURRENT},
+        {ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTY_NAME, ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTIES_VERSION_CURRENT},
+        {ZES_INTEL_DRIVER_NAME_EXP_PROPERTY_NAME, ZES_INTEL_DRIVER_NAME_EXP_PROPERTIES_VERSION_CURRENT}};
+    for (uint32_t i = 0; i < count; i++) {
+        if (extensionsReturned[i].name != supportedExtensions[i].first) {
+            return false;
+        }
+        if (extensionsReturned[i].version != supportedExtensions[i].second) {
+            return false;
+        }
+    }
+    return true;
+}
+
 TEST_F(SysmanDriverHandleTest,
-       givenInitializedDriverWhenzesDriverGetExtensionPropertiesIsCalledThenUnsupportedIsReturned) {
+       givenInitializedDriverWhenzesDriverGetExtensionPropertiesIsCalledThenAllSupportedExtensionsAreReturned) {
     uint32_t count = 0;
     ze_result_t result = zesDriverGet(&count, nullptr);
     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
@@ -239,7 +264,62 @@ TEST_F(SysmanDriverHandleTest,
     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
     EXPECT_NE(nullptr, driverHandle);
     uint32_t pCount = 0;
-    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesDriverGetExtensionProperties(driverHandle, &pCount, nullptr));
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle, &pCount, nullptr));
+    EXPECT_GE(pCount, 0u);
+    std::vector<zes_driver_extension_properties_t> extensionsSupported(pCount);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle, &pCount, extensionsSupported.data()));
+    EXPECT_TRUE(verifyExtensionDefinition(extensionsSupported, pCount));
+}
+
+TEST_F(SysmanDriverHandleTest,
+       givenInitializedDriverWhenzesDriverGetExtensionPropertiesIsCalledWithInvalidCountThenValidSupportedExtensionsCountIsReturned) {
+    uint32_t count = 0;
+    ze_result_t result = zesDriverGet(&count, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(1U, count);
+
+    ze_driver_handle_t driverHandle = {};
+    result = zesDriverGet(&count, &driverHandle);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_NE(nullptr, driverHandle);
+    uint32_t pCount = 0;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle, &pCount, nullptr));
+    EXPECT_GE(pCount, 0u);
+    std::vector<zes_driver_extension_properties_t> extensionsSupported(pCount);
+    auto actualCount = pCount; // Store the actual count
+    pCount += 5;               // Intentionally increase the count to check if function adjusts it correctly
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle, &pCount, extensionsSupported.data()));
+    EXPECT_EQ(actualCount, pCount);
+}
+
+TEST_F(SysmanDriverHandleTest,
+       givenInitializedDriverWhenzesDriverGetExtensionPropertiesIsCalledWithCountLessThanActualSizeThenSameNumberOfSupportedExtensionsReturned) {
+    uint32_t count = 0;
+    ze_result_t result = zesDriverGet(&count, nullptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(1U, count);
+
+    ze_driver_handle_t driverHandle = {};
+    result = zesDriverGet(&count, &driverHandle);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_NE(nullptr, driverHandle);
+    uint32_t pCount = 0;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle, &pCount, nullptr));
+    EXPECT_GE(pCount, 0u);
+    auto actualCount = pCount; // Store the actual count
+
+    std::vector<zes_driver_extension_properties_t> extensionsSupported(actualCount);
+    pCount -= 1; // Intentionally decrease the count to check if function adjusts it correctly
+    // Filled with invalid data to ensure only valid extensions are filled by driver function
+    strcpy_s(extensionsSupported[pCount].name, ZES_MAX_EXTENSION_NAME, "Invalid_Extension_Name");
+    extensionsSupported[pCount].version = 1234;
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle, &pCount, extensionsSupported.data()));
+    EXPECT_EQ(actualCount - 1, pCount);
+    EXPECT_TRUE(verifyExtensionDefinition(extensionsSupported, pCount));
+    // Verify that the last entry remains unchanged
+    EXPECT_EQ(strcmp(extensionsSupported[actualCount - 1].name, "Invalid_Extension_Name"), 0);
+    EXPECT_EQ(extensionsSupported[actualCount - 1].version, static_cast<uint32_t>(1234));
 }
 
 TEST_F(SysmanDriverHandleTest,

level_zero/sysman/test/unit_tests/sources/windows/test_sysman_driver.cpp

@@ -6,6 +6,7 @@
  */
 
 #include "level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_driver.h"
+#include "level_zero/zes_intel_gpu_sysman.h"
 
 #include "gtest/gtest.h"
 
@@ -51,10 +52,71 @@ TEST(zesInit, whenCallingZesInitWhenDriverInitFailsThenUninitializedIsReturned)
     EXPECT_EQ(1u, driver.initCalledCount);
 }
 
+bool verifyExtensionDefinition(std::vector<zes_driver_extension_properties_t> &extensionsReturned, uint32_t count) {
+    const std::vector<std::pair<std::string, uint32_t>> supportedExtensions = {
+        {ZES_DEVICE_ECC_DEFAULT_PROPERTIES_EXT_NAME, ZES_DEVICE_ECC_DEFAULT_PROPERTIES_EXT_VERSION_CURRENT},
+        {ZES_POWER_LIMITS_EXT_NAME, ZES_POWER_LIMITS_EXT_VERSION_CURRENT},
+        {ZES_ENGINE_ACTIVITY_EXT_NAME, ZES_ENGINE_ACTIVITY_EXT_VERSION_CURRENT},
+        {ZES_RAS_GET_STATE_EXP_NAME, ZES_RAS_STATE_EXP_VERSION_CURRENT},
+        {ZES_MEM_PAGE_OFFLINE_STATE_EXP_NAME, ZES_MEM_PAGE_OFFLINE_STATE_EXP_VERSION_CURRENT},
+        {ZES_MEMORY_BANDWIDTH_COUNTER_BITS_EXP_PROPERTIES_NAME, ZES_MEM_BANDWIDTH_COUNTER_BITS_EXP_VERSION_CURRENT},
+        {ZES_SYSMAN_DEVICE_MAPPING_EXP_NAME, ZES_SYSMAN_DEVICE_MAPPING_EXP_VERSION_CURRENT},
+        {ZES_VIRTUAL_FUNCTION_MANAGEMENT_EXP_NAME, ZES_VF_MANAGEMENT_EXP_VERSION_CURRENT},
+        {ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_NAME, ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_VERSION_CURRENT},
+        {ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTY_NAME, ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTIES_VERSION_CURRENT},
+        {ZES_INTEL_DRIVER_NAME_EXP_PROPERTY_NAME, ZES_INTEL_DRIVER_NAME_EXP_PROPERTIES_VERSION_CURRENT}};
+    for (uint32_t i = 0; i < count; i++) {
+        if (extensionsReturned[i].name != supportedExtensions[i].first) {
+            return false;
+        }
+        if (extensionsReturned[i].version != supportedExtensions[i].second) {
+            return false;
+        }
+    }
+    return true;
+}
+
 TEST_F(SysmanDriverHandleTest,
-       givenInitializedDriverWhenZesDriverGetPropertiesIsCalledThenUnsupportedIsReturned) {
+       givenInitializedDriverWhenzesDriverGetExtensionPropertiesIsCalledThenAllSupportedExtensionsAreReturned) {
     uint32_t pCount = 0;
-    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesDriverGetExtensionProperties(driverHandle->toHandle(), &pCount, nullptr));
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle->toHandle(), &pCount, nullptr));
+    EXPECT_GE(pCount, 0u);
+    std::vector<zes_driver_extension_properties_t> extensionsSupported(pCount);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle->toHandle(), &pCount, extensionsSupported.data()));
+    EXPECT_TRUE(verifyExtensionDefinition(extensionsSupported, pCount));
+}
+
+TEST_F(SysmanDriverHandleTest,
+       givenInitializedDriverWhenzesDriverGetExtensionPropertiesIsCalledWithInvalidCountThenValidSupportedExtensionsCountIsReturned) {
+    uint32_t pCount = 0;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle->toHandle(), &pCount, nullptr));
+    EXPECT_GE(pCount, 0u);
+    std::vector<zes_driver_extension_properties_t> extensionsSupported(pCount);
+    auto actualCount = pCount; // Store the actual count
+    pCount += 5;               // Intentionally increase the count to check if function adjusts it correctly
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle->toHandle(), &pCount, extensionsSupported.data()));
+    EXPECT_EQ(actualCount, pCount);
+}
+
+TEST_F(SysmanDriverHandleTest,
+       givenInitializedDriverWhenzesDriverGetExtensionPropertiesIsCalledWithCountLessThanActualSizeThenSameNumberOfSupportedExtensionsReturned) {
+    uint32_t pCount = 0;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle->toHandle(), &pCount, nullptr));
+    EXPECT_GE(pCount, 0u);
+    auto actualCount = pCount; // Store the actual count
+
+    std::vector<zes_driver_extension_properties_t> extensionsSupported(actualCount);
+    pCount -= 1; // Intentionally decrease the count to check if function adjusts it correctly
+    // Filled with invalid data to ensure only valid extensions are filled by driver function
+    strcpy_s(extensionsSupported[pCount].name, ZES_MAX_EXTENSION_NAME, "Invalid_Extension_Name");
+    extensionsSupported[pCount].version = 1234;
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle->toHandle(), &pCount, extensionsSupported.data()));
+    EXPECT_EQ(actualCount - 1, pCount);
+    EXPECT_TRUE(verifyExtensionDefinition(extensionsSupported, pCount));
+    // Verify that the last entry remains unchanged
+    EXPECT_EQ(strcmp(extensionsSupported[actualCount - 1].name, "Invalid_Extension_Name"), 0);
+    EXPECT_EQ(extensionsSupported[actualCount - 1].version, static_cast<uint32_t>(1234));
 }
 
 TEST_F(SysmanDriverHandleTest,