feature(sysman): Retrieve uuid for Sysman device properties

- Abstracts product helpers logic for uuid
- Add UUID retrieval for Linux for Sysman via zesInit path

Related-To: LOCI-4137

Signed-off-by: Aravind Gopalakrishnan <aravind.gopalakrishnan@intel.com>

level_zero/sysman/source/global_operations/linux/sysman_os_global_operations_imp.cpp

@@ -180,6 +180,78 @@ void LinuxGlobalOperationsImp::getDriverVersion(char (&driverVersion)[ZES_STRING
     return;
 }
 
+bool LinuxGlobalOperationsImp::generateUuidFromPciBusInfo(const NEO::PhysicalDevicePciBusInfo &pciBusInfo, std::array<uint8_t, NEO::ProductHelper::uuidSize> &uuid) {
+    if (pciBusInfo.pciDomain != NEO::PhysicalDevicePciBusInfo::invalidValue) {
+        uuid.fill(0);
+
+        /* Device UUID uniquely identifies a device within a system.
+         * We generate it based on device information along with PCI information
+         * This guarantees uniqueness of UUIDs on a system even when multiple
+         * identical Intel GPUs are present.
+         */
+
+        /* We want to have UUID matching between different GPU APIs (including outside
+         * of compute_runtime project - i.e. other than L0 or OCL). This structure definition
+         * has been agreed upon by various Intel driver teams.
+         *
+         * Consult other driver teams before changing this.
+         */
+
+        struct DeviceUUID {
+            uint16_t vendorID;
+            uint16_t deviceID;
+            uint16_t revisionID;
+            uint16_t pciDomain;
+            uint8_t pciBus;
+            uint8_t pciDev;
+            uint8_t pciFunc;
+            uint8_t reserved[4];
+            uint8_t subDeviceID;
+        };
+
+        auto &hwInfo = pLinuxSysmanImp->getParentSysmanDeviceImp()->getHardwareInfo();
+        DeviceUUID deviceUUID = {};
+        deviceUUID.vendorID = 0x8086; // Intel
+        deviceUUID.deviceID = hwInfo.platform.usDeviceID;
+        deviceUUID.revisionID = hwInfo.platform.usRevId;
+        deviceUUID.pciDomain = static_cast<uint16_t>(pciBusInfo.pciDomain);
+        deviceUUID.pciBus = static_cast<uint8_t>(pciBusInfo.pciBus);
+        deviceUUID.pciDev = static_cast<uint8_t>(pciBusInfo.pciDevice);
+        deviceUUID.pciFunc = static_cast<uint8_t>(pciBusInfo.pciFunction);
+        deviceUUID.subDeviceID = 0;
+
+        static_assert(sizeof(DeviceUUID) == NEO::ProductHelper::uuidSize);
+
+        memcpy_s(uuid.data(), NEO::ProductHelper::uuidSize, &deviceUUID, sizeof(DeviceUUID));
+
+        return true;
+    }
+    return false;
+}
+
+bool LinuxGlobalOperationsImp::getUuid(std::array<uint8_t, NEO::ProductHelper::uuidSize> &uuid) {
+    auto driverModel = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironment().osInterface->getDriverModel();
+    auto &gfxCoreHelper = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironment().getHelper<NEO::GfxCoreHelper>();
+    auto &productHelper = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironment().getHelper<NEO::ProductHelper>();
+    auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
+    if (NEO::DebugManager.flags.EnableChipsetUniqueUUID.get() != 0) {
+        if (gfxCoreHelper.isChipsetUniqueUUIDSupported()) {
+            this->uuid.isValid = productHelper.getUuid(driverModel, subDeviceCount, 0u, this->uuid.id);
+        }
+    }
+
+    if (!this->uuid.isValid && pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironment().osInterface != nullptr) {
+        NEO::PhysicalDevicePciBusInfo pciBusInfo = driverModel->getPciBusInfo();
+        this->uuid.isValid = generateUuidFromPciBusInfo(pciBusInfo, this->uuid.id);
+    }
+
+    if (this->uuid.isValid) {
+        uuid = this->uuid.id;
+    }
+
+    return this->uuid.isValid;
+}
+
 ze_result_t LinuxGlobalOperationsImp::reset(ze_bool_t force) {
     if (!pSysfsAccess->isRootUser()) {
         return ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;
@@ -480,6 +552,7 @@ LinuxGlobalOperationsImp::LinuxGlobalOperationsImp(OsSysman *pOsSysman) {
     pFsAccess = &pLinuxSysmanImp->getFsAccess();
     devicePciBdf = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceEnvironment().osInterface->getDriverModel()->as<NEO::Drm>()->getPciPath();
     rootDeviceIndex = pLinuxSysmanImp->getParentSysmanDeviceImp()->getRootDeviceIndex();
+    uuid.isValid = false;
 }
 
 OsGlobalOperations *OsGlobalOperations::create(OsSysman *pOsSysman) {

level_zero/sysman/source/global_operations/linux/sysman_os_global_operations_imp.h

@@ -6,7 +6,11 @@
  */
 
 #pragma once
+#include "shared/source/debug_settings/debug_settings_manager.h"
+#include "shared/source/helpers/gfx_core_helper.h"
+#include "shared/source/os_interface/driver_info.h"
 #include "shared/source/os_interface/linux/pmt_util.h"
+#include "shared/source/os_interface/product_helper.h"
 
 #include "level_zero/sysman/source/global_operations/sysman_os_global_operations.h"
 #include "level_zero/sysman/source/linux/zes_os_sysman_imp.h"
@@ -28,10 +32,17 @@ class LinuxGlobalOperationsImp : public OsGlobalOperations, NEO::NonCopyableOrMo
     ze_result_t reset(ze_bool_t force) override;
     ze_result_t scanProcessesState(std::vector<zes_process_state_t> &pProcessList) override;
     ze_result_t deviceGetState(zes_device_state_t *pState) override;
+    bool getUuid(std::array<uint8_t, NEO::ProductHelper::uuidSize> &uuid) override;
+    bool generateUuidFromPciBusInfo(const NEO::PhysicalDevicePciBusInfo &pciBusInfo, std::array<uint8_t, NEO::ProductHelper::uuidSize> &uuid) override;
     LinuxGlobalOperationsImp() = default;
     LinuxGlobalOperationsImp(OsSysman *pOsSysman);
     ~LinuxGlobalOperationsImp() override = default;
 
+    struct {
+        bool isValid = false;
+        std::array<uint8_t, NEO::ProductHelper::uuidSize> id;
+    } uuid;
+
   protected:
     FsAccess *pFsAccess = nullptr;
     ProcfsAccess *pProcfsAccess = nullptr;

level_zero/sysman/source/global_operations/sysman_global_operations_imp.cpp

@@ -45,6 +45,12 @@ ze_result_t GlobalOperationsImp::processesGetState(uint32_t *pCount, zes_process
 ze_result_t GlobalOperationsImp::deviceGetProperties(zes_device_properties_t *pProperties) {
     initGlobalOperations();
     sysmanProperties.numSubdevices = pOsSysman->getSubDeviceCount();
+
+    std::array<uint8_t, NEO::ProductHelper::uuidSize> deviceUuid;
+    bool uuidValid = pOsGlobalOperations->getUuid(deviceUuid);
+    if (uuidValid) {
+        std::copy_n(std::begin(deviceUuid), ZE_MAX_DEVICE_UUID_SIZE, std::begin(sysmanProperties.core.uuid.id));
+    }
     *pProperties = sysmanProperties;
     return ZE_RESULT_SUCCESS;
 }

level_zero/sysman/source/global_operations/sysman_os_global_operations.h

@@ -7,9 +7,14 @@
 
 #pragma once
 
+#include "shared/source/debug_settings/debug_settings_manager.h"
+#include "shared/source/os_interface/driver_info.h"
+#include "shared/source/os_interface/product_helper.h"
+
 #include "level_zero/sysman/source/os_sysman.h"
 #include <level_zero/zes_api.h>
 
+#include <array>
 #include <vector>
 
 namespace L0 {
@@ -25,6 +30,8 @@ class OsGlobalOperations {
     virtual void getDriverVersion(char (&driverVersion)[ZES_STRING_PROPERTY_SIZE]) = 0;
     virtual void getWedgedStatus(zes_device_state_t *pState) = 0;
     virtual void getRepairStatus(zes_device_state_t *pState) = 0;
+    virtual bool getUuid(std::array<uint8_t, NEO::ProductHelper::uuidSize> &uuid) = 0;
+    virtual bool generateUuidFromPciBusInfo(const NEO::PhysicalDevicePciBusInfo &pciBusInfo, std::array<uint8_t, NEO::ProductHelper::uuidSize> &uuid) = 0;
     virtual ze_result_t reset(ze_bool_t force) = 0;
     virtual ze_result_t scanProcessesState(std::vector<zes_process_state_t> &pProcessList) = 0;
     virtual ze_result_t deviceGetState(zes_device_state_t *pState) = 0;

level_zero/sysman/source/global_operations/windows/sysman_os_global_operations_imp.cpp

@@ -34,6 +34,12 @@ void WddmGlobalOperationsImp::getWedgedStatus(zes_device_state_t *pState) {
 }
 void WddmGlobalOperationsImp::getRepairStatus(zes_device_state_t *pState) {
 }
+bool WddmGlobalOperationsImp::getUuid(std::array<uint8_t, NEO::ProductHelper::uuidSize> &uuid) {
+    return false;
+}
+bool WddmGlobalOperationsImp::generateUuidFromPciBusInfo(const NEO::PhysicalDevicePciBusInfo &pciBusInfo, std::array<uint8_t, NEO::ProductHelper::uuidSize> &uuid) {
+    return false;
+}
 ze_result_t WddmGlobalOperationsImp::reset(ze_bool_t force) {
     uint32_t value = 0;
     KmdSysman::RequestProperty request;

level_zero/sysman/source/global_operations/windows/sysman_os_global_operations_imp.h

@@ -7,6 +7,7 @@
 
 #pragma once
 #include "shared/source/helpers/non_copyable_or_moveable.h"
+#include "shared/source/os_interface/product_helper.h"
 
 #include "level_zero/sysman/source/global_operations/sysman_os_global_operations.h"
 #include "level_zero/sysman/source/windows/zes_os_sysman_imp.h"
@@ -27,6 +28,8 @@ class WddmGlobalOperationsImp : public OsGlobalOperations, NEO::NonCopyableOrMov
     ze_result_t reset(ze_bool_t force) override;
     ze_result_t scanProcessesState(std::vector<zes_process_state_t> &pProcessList) override;
     ze_result_t deviceGetState(zes_device_state_t *pState) override;
+    bool getUuid(std::array<uint8_t, NEO::ProductHelper::uuidSize> &uuid) override;
+    bool generateUuidFromPciBusInfo(const NEO::PhysicalDevicePciBusInfo &pciBusInfo, std::array<uint8_t, NEO::ProductHelper::uuidSize> &uuid) override;
 
     WddmGlobalOperationsImp(OsSysman *pOsSysman);
     WddmGlobalOperationsImp() = default;