[SWDEV-504146] Fix Device Name

Changes: - Fixed Device Name (market name)
  - Added new API rsmi_dev_market_name_get()
  - Updated tests
  - Updated amdgpu_drm.h to match latest mainline kernel
  - Fixed subsystem ID to only show hex value (not subsystem name)
  - rocm_smi_lib now has a recommended requirement for libdrm
Change-Id: Ic438529e16c8c3dbbdd620da664918148c40c997

CMakeLists.txt

@@ -14,6 +14,8 @@ endif()
 ## Include common cmake modules
 include(utils)
 
+find_package(PkgConfig)
+
 # Default libdir to "lib", this skips GNUInstallDirs from trying to take a guess if it's unset:
 set(CMAKE_INSTALL_LIBDIR "lib" CACHE STRING "Library install directory")
 
@@ -36,6 +38,9 @@ set(SHARE_INSTALL_PREFIX
 # provide git to utilities
 find_program (GIT NAMES git)
 
+pkg_check_modules(DRM REQUIRED libdrm)
+pkg_check_modules(AMDGPU_DRM REQUIRED libdrm_amdgpu)
+
 ## Setup the package version based on git tags.
 set(PKG_VERSION_GIT_TAG_PREFIX "rsmi_pkg_ver")
 get_package_version_number("7.3.0" ${PKG_VERSION_GIT_TAG_PREFIX} GIT)
@@ -330,7 +335,7 @@ if(DEFINED ENV{CPACK_DEBIAN_PACKAGE_RELEASE})
 else()
    set(CPACK_DEBIAN_PACKAGE_RELEASE "local")
 endif()
-set(CPACK_DEBIAN_PACKAGE_SUGGESTS "sudo")
+set(CPACK_DEBIAN_PACKAGE_SUGGESTS "sudo, libdrm-dev")
 
 ## Process the Debian install/remove scripts to update the CPACK variables
 configure_file ( ${CMAKE_CURRENT_SOURCE_DIR}/DEBIAN/postinst.in DEBIAN/postinst @ONLY )

include/rocm_smi/rocm_smi.h

@@ -133,6 +133,7 @@ typedef enum {
                                          //!< for the current device
   RSMI_STATUS_AMDGPU_RESTART_ERR,        //!< Could not successfully restart
                                          //!< the amdgpu driver
+  RSMI_STATUS_DRM_ERROR,                 //!< Error when call libdrm
 
   RSMI_STATUS_UNKNOWN_ERROR = 0xFFFFFFFF,  //!< An unknown error occurred
 } rsmi_status_t;
@@ -1532,8 +1533,35 @@ rsmi_status_t rsmi_dev_brand_get(uint32_t dv_ind, char *brand, uint32_t len);
  *  be written.
  *
  */
-rsmi_status_t rsmi_dev_vendor_name_get(uint32_t dv_ind, char *name,
-                                                                  size_t len);
+rsmi_status_t rsmi_dev_vendor_name_get(uint32_t dv_ind, char *name, size_t len);
+
+
+/**
+ *  @brief Get the device's market name
+ *
+ *  @details Given a device index @p dv_ind, a pointer to a caller provided
+ *  char buffer @p market_name, and a length of this buffer @p len, this function will
+ *  write the name of the market name (up to @p len characters) buffer @p market_name.
+ *
+ *  @param[inout] market_name a pointer to a caller provided char buffer to which the
+ *  market name will be written
+ *  If this parameter is nullptr, this function will return
+ *  ::RSMI_STATUS_INVALID_ARGS if the function is supported with the provided,
+ *  arguments and ::RSMI_STATUS_DRM_ERROR if a DRM error occurs
+ *
+ *  @param[in] len the length of the caller provided buffer @p name.
+ *
+ *  @retval ::RSMI_STATUS_SUCCESS call was successful
+ *  @retval ::RSMI_STATUS_NOT_SUPPORTED installed software or hardware does not
+ *  support this function with the given arguments
+ *  @retval ::RSMI_STATUS_INVALID_ARGS the provided arguments are not valid
+ *  @retval ::RSMI_STATUS_DRM_ERROR if a DRM error occurs
+ *  @retval ::RSMI_STATUS_INSUFFICIENT_SIZE is returned if @p len bytes is not
+ *  large enough to hold the entire name. In this case, only @p len bytes will
+ *  be written.
+ *
+ */
+rsmi_status_t rsmi_dev_market_name_get(uint32_t dv_ind, char *market_name, uint32_t len);
 
 /**
  *  @brief Get the vram vendor string of a gpu device.

include/rocm_smi/rocm_smi_utils.h

@@ -142,6 +142,8 @@ std::string removeString(const std::string origStr,
                         const std::string &removeMe);
 void system_wait(int milli_seconds);
 int countDigit(uint64_t n);
+std::string find_file_in_folder(const std::string& folder,
+               const std::string& regex);
 template <typename T>
   std::string print_int_as_hex(T i, bool showHexNotation = true,
   int overloadBitSize = 0) {

oam/CMakeLists.txt

@@ -72,7 +72,7 @@ target_include_directories(${OAM_EXAMPLE_EXE} PRIVATE ${OAM_INC_LIST})
 target_link_libraries(${OAM_EXAMPLE_EXE} ${OAM_TARGET})
 add_library(${OAM_TARGET} ${CMN_SRC_LIST} ${OAM_SRC_LIST}
                                               ${CMN_INC_LIST} ${OAM_INC_LIST})
-target_link_libraries(${OAM_TARGET} pthread rt dl)
+target_link_libraries(${OAM_TARGET} pthread rt dl ${DRM_LIBRARIES} ${AMDGPU_DRM_LIBRARIES})
 target_include_directories(${OAM_TARGET} PRIVATE
    ${CMAKE_CURRENT_SOURCE_DIR}/include ${COMMON_PROJ_ROOT}/common/shared_mutex)
 

python_smi_tools/rocm_smi.py

@@ -346,13 +346,13 @@ def getSubsystemId(device, silent=False):
     :param silent: Turn on to silence error output
         (you plan to handle manually). Default is off.
     """
-    model = create_string_buffer(MAX_BUFF_SIZE)
-    ret = rocmsmi.rsmi_dev_subsystem_name_get(device, model, MAX_BUFF_SIZE)
+    model = c_short()
+    ret = rocmsmi.rsmi_dev_subsystem_id_get(device, byref(model))
     device_model = "N/A"
     if rsmi_ret_ok(ret, device, 'get_subsystem_name', silent=silent):
-        device_model = model.value.decode()
+        device_model = model.value
         # padHexValue is used for applications that expect 4-digit card models
-        device_model = padHexValue(device_model, 4)
+        device_model = padHexValue(hex(device_model), 4)
     return device_model
 
 def getVendor(device, silent=False):
@@ -418,8 +418,8 @@ def getNodeId(device, silent=False):
     return node_id_ret
 
 def getDeviceName(device, silent=False):
-    """ Return the uint64 value of device's target
-        graphics version as reported by KFD
+    """ Return the uint64 value of device's name
+        reported by KFD
 
     :param device: DRM device identifier
     :param silent: Turn on to silence error output
@@ -428,7 +428,7 @@ def getDeviceName(device, silent=False):
     # Retrieve the device series
     series = create_string_buffer(MAX_BUFF_SIZE)
     device_name_ret = "N/A"
-    ret = rocmsmi.rsmi_dev_name_get(device, series, MAX_BUFF_SIZE)
+    ret = rocmsmi.rsmi_dev_market_name_get(device, series, MAX_BUFF_SIZE)
     if rsmi_ret_ok(ret, device, 'get_name', silent=silent):
         device_name_ret = series.value.decode()
     return device_name_ret

python_smi_tools/rsmiBindings.py

@@ -54,6 +54,7 @@ class rsmi_status_t(c_int):
     RSMI_STATUS_REFCOUNT_OVERFLOW = 0x11
     RSMI_STATUS_SETTING_UNAVAILABLE = 0x12
     RSMI_STATUS_AMDGPU_RESTART_ERR = 0x13
+    RSMI_STATUS_DRM_ERROR = 0x14
     RSMI_STATUS_UNKNOWN_ERROR = 0xFFFFFFFF
 
 
@@ -79,6 +80,7 @@ rsmi_status_verbose_err_out = {
     rsmi_status_t.RSMI_STATUS_REFCOUNT_OVERFLOW: 'Data overflow - data exceeded INT32_MAX',
     rsmi_status_t.RSMI_STATUS_SETTING_UNAVAILABLE: 'Requested setting is unavailable for current device',
     rsmi_status_t.RSMI_STATUS_AMDGPU_RESTART_ERR: 'Could not successfully restart the amdgpu driver',
+    rsmi_status_t.RSMI_STATUS_DRM_ERROR: 'Error when calling libdrm',
     rsmi_status_t.RSMI_STATUS_UNKNOWN_ERROR: 'Unknown error occured'
 }
 

rocm_smi/CMakeLists.txt

@@ -81,7 +81,7 @@ add_executable(${SMI_EXAMPLE_EXE} "example/rocm_smi_example.cc")
 target_link_libraries(${SMI_EXAMPLE_EXE} ${ROCM_SMI_TARGET})
 add_library(${ROCM_SMI_TARGET}  ${CMN_SRC_LIST} ${SMI_SRC_LIST}
                                               ${CMN_INC_LIST} ${SMI_INC_LIST})
-target_link_libraries(${ROCM_SMI_TARGET} pthread rt dl)
+target_link_libraries(${ROCM_SMI_TARGET} pthread rt dl ${DRM_LIBRARIES} ${AMDGPU_DRM_LIBRARIES})
 target_include_directories(${ROCM_SMI_TARGET} PRIVATE
           ${CMAKE_CURRENT_SOURCE_DIR} ${COMMON_PROJ_ROOT}/common/shared_mutex)
 

src/rocm_smi.cc

@@ -41,15 +41,16 @@
  *
  */
 
-#include <fcntl.h>
-#include <poll.h>
-#include <pthread.h>
-#include <cstddef>
-#include <string>
 #include <sys/ioctl.h>
 #include <sys/utsname.h>
 #include <unistd.h>
+#include <libdrm/amdgpu.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <pthread.h>
 
+#include <cstddef>
+#include <string>
 #include <algorithm>
 #include <bitset>
 #include <cassert>
@@ -2338,6 +2339,60 @@ rsmi_dev_vendor_name_get(uint32_t dv_ind, char *name, size_t len) {
   CATCH
 }
 
+rsmi_status_t rsmi_dev_market_name_get(uint32_t dv_ind, char *market_name, uint32_t len) {
+  if (market_name == nullptr || len == 0) {
+    return RSMI_STATUS_INVALID_ARGS;
+  }
+
+  DEVICE_MUTEX
+  GET_DEV_FROM_INDX
+  dev->index();
+  std::string render_file_name;
+
+  const std::string regex("renderD([0-9]+)");
+  const std::string renderD_folder = "/sys/class/drm/card"
+              + std::to_string(dev->index()) + "/../";
+
+  // looking for /sys/class/drm/card0/../renderD*
+  std::string render_name = amd::smi::find_file_in_folder(renderD_folder, regex);
+  int gpu_fd = -1;
+  std::string drm_path = "/dev/dri/" + render_name;
+  if (render_name != "") {
+    gpu_fd = open(drm_path.c_str(), O_RDWR | O_CLOEXEC);
+  } else {
+    market_name[0] = '\0';
+    return RSMI_STATUS_NOT_SUPPORTED;
+  }
+
+  amdgpu_device_handle device_handle = nullptr;
+  uint32_t major_version, minor_version;
+  int ret = amdgpu_device_initialize(gpu_fd, &major_version, &minor_version, &device_handle);
+  if (ret != 0) {
+    market_name[0] = '\0';
+    close(gpu_fd);
+    return RSMI_STATUS_DRM_ERROR;
+  }
+
+  // Get the marketing name using libdrm's API
+  const char *name = amdgpu_get_marketing_name(device_handle);
+  if (name != nullptr) {
+    // copy name to market name
+    std::string temp_market_name(name);
+    memset(market_name, '\0', len);
+    uint32_t ln = static_cast<uint32_t>(temp_market_name.copy(market_name, len));
+    market_name[std::min(len - 1, ln)] = '\0';
+    amdgpu_device_deinitialize(device_handle);
+    close(gpu_fd);
+    if (len < (temp_market_name.size() + 1)) {
+      return RSMI_STATUS_INSUFFICIENT_SIZE;
+    }
+    return RSMI_STATUS_SUCCESS;
+  }
+  amdgpu_device_deinitialize(device_handle);
+  close(gpu_fd);
+  return RSMI_STATUS_DRM_ERROR;
+}
+
 
 rsmi_status_t
 rsmi_dev_pci_bandwidth_get(uint32_t dv_ind, rsmi_pcie_bandwidth_t *b) {

src/rocm_smi_utils.cc

@@ -1265,5 +1265,26 @@ int countDigit(uint64_t n) {
   return static_cast<int>(std::floor(log10(n) + 1));
 }
 
+std::string find_file_in_folder(const std::string& folder,
+               const std::string& regex) {
+  std::string file_name;
+  // TODO(amdsmi_dev): The closedir function has some non-standard attributes
+  // that are being ignored here which is causing a warning to be thrown
+  using dir_ptr = std::unique_ptr<DIR, decltype(&closedir)>;
+
+  struct dirent *dir = nullptr;
+  std::regex file_regex(regex);
+  auto drm_dir = dir_ptr(opendir(folder.c_str()), &closedir);
+  if (drm_dir == nullptr) return file_name;
+  std::cmatch m;
+  while ((dir = readdir(drm_dir.get())) != NULL) {
+    if (std::regex_search(dir->d_name, m, file_regex)) {
+        file_name = dir->d_name;
+        break;
+    }
+  }
+  return file_name;
+}
+
 }  // namespace smi
 }  // namespace amd

tests/rocm_smi_test/functional/id_info_read.cc

@@ -83,6 +83,7 @@ void TestIdInfoRead::Close() {
 }
 
 static const uint32_t kBufferLen = 80;
+static const uint32_t kSize5 = 5;
 
 void TestIdInfoRead::Run(void) {
   rsmi_status_t err;
@@ -91,6 +92,8 @@ void TestIdInfoRead::Run(void) {
   uint32_t drm_render_minor;
 
   char buffer[kBufferLen];
+  char fix_market_name[kBufferLen];
+  char small_buffer[kSize5];
 
   TestBase::Run();
   if (setup_failed_) {
@@ -99,6 +102,11 @@ void TestIdInfoRead::Run(void) {
   }
 
   for (uint32_t i = 0; i < num_monitor_devs(); ++i) {
+    std::string temp_val = "Hello World111111111111111111111111111111";
+    memset(fix_market_name, '\0', kBufferLen);
+    temp_val.copy(fix_market_name, kBufferLen-1);
+    fix_market_name[kBufferLen-1] = '\0';
+
     IF_VERB(STANDARD) {
       std::cout << "\t*************************" << std::endl;
       std::cout << "\t**Device index: " << i << std::endl;
@@ -139,6 +147,62 @@ void TestIdInfoRead::Run(void) {
       ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
     }
 
+    // Verify api support checking functionality is working
+    err = rsmi_dev_market_name_get(i, small_buffer, kSize5);
+    if (err == RSMI_STATUS_NOT_SUPPORTED) {
+      std::cout << "\t**Device Marketing name (libdrm) not found on this system." <<
+                                                                    std::endl;
+    } else {
+      IF_VERB(STANDARD) {
+        std::cout << "\t**[Test small_buffer] Device Marketing name"
+                  << " (libdrm): " << small_buffer << std::endl;
+      }
+      ASSERT_EQ(err, RSMI_STATUS_INSUFFICIENT_SIZE);
+    }
+
+    err = rsmi_dev_market_name_get(i, nullptr, kBufferLen);
+    ASSERT_EQ(err, RSMI_STATUS_INVALID_ARGS);
+    bool shouldCompareMarketValue = false;
+
+    err = rsmi_dev_market_name_get(i, fix_market_name, kBufferLen);
+    if (err == RSMI_STATUS_NOT_SUPPORTED) {
+      std::cout << "\t**Device Marketing name (libdrm) not found on this system." <<
+                                                                    std::endl;
+    } else {
+      CHK_ERR_ASRT(err)
+      IF_VERB(STANDARD) {
+        std::cout << "\t**[Test fix_market_name] Device Marketing name"
+                  << " (libdrm): " << fix_market_name << std::endl;
+      }
+      if (err == RSMI_STATUS_SUCCESS) {
+        shouldCompareMarketValue = true;
+      }
+    }
+
+    err = rsmi_dev_market_name_get(i, buffer, kBufferLen);
+    if (err == RSMI_STATUS_NOT_SUPPORTED) {
+      std::cout << "\t**Device Marketing name (libdrm) not found on this system." <<
+                                                                    std::endl;
+    } else {
+      CHK_ERR_ASRT(err)
+      IF_VERB(STANDARD) {
+        std::cout << "\t**[buffer] Device Marketing name (libdrm): " << buffer << std::endl;
+      }
+      (shouldCompareMarketValue && err == RSMI_STATUS_SUCCESS) ? shouldCompareMarketValue = true :
+        shouldCompareMarketValue = false;
+    }
+
+    if (shouldCompareMarketValue) {
+      IF_VERB(STANDARD) {
+        std::cout << "\t**fix_market_name: |" << fix_market_name << "|" << std::endl;
+        std::cout << "\t**buffer: |" << buffer << "|" << std::endl;
+        (strcmp(fix_market_name, buffer) == 0) ?
+          (std::cout << "\t**Both fix_market_name & buffer are equal" << std::endl) :
+          (std::cout << "\t**Both fix_market_name & buffer not equal" << std::endl);
+      }
+      ASSERT_STREQ(fix_market_name, buffer);
+    }
+
     err = rsmi_dev_name_get(i, buffer, kBufferLen);
     if (err == RSMI_STATUS_NOT_SUPPORTED) {
       std::cout << "\t**Device Marketing name not found on this system." <<