Create and update Asset tag for the system

include/constants.hpp

@@ -100,6 +100,7 @@ static constexpr auto SHIFT_BITS_5 = 5;
 
 static constexpr auto ASCII_OF_SPACE = 32;
 
+constexpr auto systemInvPath = "/xyz/openbmc_project/inventory/system";
 constexpr auto pimPath = "/xyz/openbmc_project/inventory";
 constexpr auto pimIntf = "xyz.openbmc_project.Inventory.Manager";
 constexpr auto ipzVpdInf = "com.ibm.ipzvpd.";
@@ -134,6 +135,7 @@ constexpr auto biosConfigMgrInterface =
     "xyz.openbmc_project.BIOSConfig.Manager";
 constexpr auto systemVpdInvPath =
     "/xyz/openbmc_project/inventory/system/chassis/motherboard";
+constexpr auto assetTagInf = "xyz.openbmc_project.Inventory.Decorator.AssetTag";
 static constexpr auto BD_YEAR_END = 4;
 static constexpr auto BD_MONTH_END = 7;
 static constexpr auto BD_DAY_END = 10;

include/manager.hpp

@@ -219,6 +219,18 @@ class Manager
      * @throw std::runtime_error
      */
     void SetTimerToDetectVpdCollectionStatus();
+
+    /**
+     * @brief API to register callback for "AssetTag" property change.
+     */
+    void registerAssetChangeCallback();
+
+    /**
+     * @brief Callback API to be triggered on "AssetTag" property change.
+     *
+     * @param[in] i_msg - The callback message.
+     */
+    void processAssetTagChangeCallback(sdbusplus::message_t& i_msg);
 #endif
 
     /**

include/worker.hpp

@@ -445,6 +445,15 @@ class Worker
     void processEnabledProperty(const std::string& i_inventoryObjPath,
                                 types::InterfaceMap& io_interfaces);
 
+    /**
+     * @brief API to form asset tag string for the system.
+     *
+     * @param[in] i_parsedVpdMap - Parsed VPD map.
+     * @return - Formed asset tag string. Empty in case of any error.
+     */
+    std::string
+        createAssetTagString(const types::VPDMapVariant& i_parsedVpdMap);
+
     // Parsed JSON file.
     nlohmann::json m_parsedJson{};
 
@@ -462,6 +471,9 @@ class Worker
     // collection. It just states, if the VPD collection process is over or not.
     bool m_isAllFruCollected = false;
 
+    // To distinguish the factory reset path.
+    bool m_isFactoryResetDone = false;
+
     // Mutex to guard critical resource m_activeCollectionThreadCount.
     std::mutex m_mutex;
 };

src/manager.cpp

@@ -15,6 +15,7 @@
 #include "utility/vpd_specific_utility.hpp"
 
 #include <boost/asio/steady_timer.hpp>
+#include <sdbusplus/bus/match.hpp>
 #include <sdbusplus/message.hpp>
 
 namespace vpd
@@ -33,6 +34,9 @@ Manager::Manager(
         // Set up minimal things that is needed before bus name is claimed.
         m_worker->performInitialSetup();
 
+        // set callback to detect any asset tag change
+        registerAssetChangeCallback();
+
         // set async timer to detect if system VPD is published on D-Bus.
         SetTimerToDetectSVPDOnDbus();
 
@@ -116,6 +120,65 @@ Manager::Manager(
 }
 
 #ifdef IBM_SYSTEM
+void Manager::registerAssetTagChangeCallback()
+{
+    static std::shared_ptr<sdbusplus::bus::match_t> l_assetMatch =
+        std::make_shared<sdbusplus::bus::match_t>(
+            *m_asioConnection,
+            sdbusplus::bus::match::rules::propertiesChanged(
+                constants::systemInvPath, constants::assetTagInf),
+            [this](sdbusplus::message_t& l_msg) {
+        processAssetTagChangeCallback(l_msg)
+    });
+}
+
+void Manager::processAssetTagChangeCallback(sdbusplus::message_t& i_msg)
+{
+    try
+    {
+        if (i_msg.is_method_error())
+        {
+            throw std::runtime_error(
+                "Error reading callback msg for asset tag.");
+        }
+
+        std::string l_objectPath;
+        types::PropertyMap l_propMap;
+        i_msg.read(l_objectPath, l_propMap);
+
+        const auto& l_itrToAssetTag = l_propMap.find("AssetTag");
+        if (l_itrToAssetTag != l_propMap.end())
+        {
+            if (auto l_assetTag =
+                    std::get_if<std::string>(&(l_itrToAssetTag->second)))
+            {
+                // Call Notify to persist the AssetTag
+                types::ObjectMap l_objectMap = {
+                    {sdbusplus::message::object_path(constants::systemInvPath),
+                     {{constants::assetTagInf, {{"AssetTag", *l_assetTag}}}}}};
+
+                // Notify PIM
+                if (!dbusUtility::callPIM(move(l_objectMap)))
+                {
+                    throw std::runtime_error(
+                        "Call to PIM failed for asset tag update.");
+                }
+            }
+        }
+        else
+        {
+            throw std::runtime_error(
+                "Could not find asset tag in callback message.");
+        }
+    }
+    catch (const std::exception& l_ex)
+    {
+        // TODO: Log PEL with below description.
+        logging::logMessage("Asset tag callback update failed with error: " +
+                            std::string(l_ex.what()));
+    }
+}
+
 void Manager::SetTimerToDetectSVPDOnDbus()
 {
     static boost::asio::steady_timer timer(*m_ioContext);

src/worker.cpp

@@ -417,6 +417,8 @@ void Worker::setDeviceTreeAndJson()
                     ec.message());
             }
         }
+
+        m_isFactoryResetDone = true;
     }
 
     // JSON is madatory for processing of this API.
@@ -1101,13 +1103,91 @@ void Worker::populateDbus(const types::VPDMapVariant& parsedVpdMap,
     }
 }
 
+std::string
+    Worker::createAssetTagString(const types::VPDMapVariant& i_parsedVpdMap)
+{
+    std::string l_assetTag;
+
+    try
+    {
+        // system VPD will be in IPZ format.
+        if (auto l_parsedVpdMap =
+                std::get_if<types::IPZVpdMap>(&i_parsedVpdMap))
+        {
+            auto l_itrToVsys = (*l_parsedVpdMap).find(constants::recVSYS);
+            if (l_itrToVsys != (*l_parsedVpdMap).end())
+            {
+                std::string l_tmKwdValue;
+                vpdSpecificUtility::getKwVal(l_itrToVsys->second,
+                                             constants::kwdTM, l_tmKwdValue);
+
+                std::string l_seKwdValue;
+                vpdSpecificUtility::getKwVal(l_itrToVsys->second,
+                                             constants::kwdSE, l_seKwdValue);
+
+                l_assetTag = std::string{"Server-"} + l_tmKwdValue +
+                             std::string{"-"} + l_seKwdValue;
+            }
+            else
+            {
+                throw std::runtime_error(
+                    "VSYS record not found in parsed VPD map to create Asset tag.");
+            }
+        }
+        else
+        {
+            throw std::runtime_error(
+                "Invalid VPD type recieved to create Asset tag.");
+        }
+    }
+    catch (const std::exception& l_ex)
+    {
+        // TODO:Log PEL with below description.
+        logging::logMessage("Asset tag can't be formed. Error = " +
+                            std::string(l_ex.what()));
+    }
+
+    return l_assetTag;
+}
+
 void Worker::publishSystemVPD(const types::VPDMapVariant& parsedVpdMap)
 {
     types::ObjectMap objectInterfaceMap;
 
     if (std::get_if<types::IPZVpdMap>(&parsedVpdMap))
     {
         populateDbus(parsedVpdMap, objectInterfaceMap, SYSTEM_VPD_FILE_PATH);
+
+        try
+        {
+            if (m_isFactoryResetDone)
+            {
+                const auto& l_assetTag = createAssetTagString(parsedVpdMap);
+
+                auto l_itrToSystemPath = objectInterfaceMap.find(
+                    sdbusplus::message::object_path(constants::systemInvPath));
+                if (l_itrToSystemPath == objectInterfaceMap.end())
+                {
+                    throw std::runtime_error(
+                        "System Path not found in object map.");
+                }
+
+                types::PropertyMap l_assetTagProperty;
+                l_assetTagProperty.emplace("AssetTag", l_assetTag);
+
+                (l_itrToSystemPath->second)
+                    .emplace(constants::assetTagInf,
+                             std::move(l_assetTagProperty));
+            }
+        }
+        catch (const std::exception& l_ex)
+        {
+            // TODO Log PEL with below description
+            logging::logMessage(
+                "Asset tag update failed with following error: " +
+                std::string(l_ex.what()));
+        }
+
         // Notify PIM
         if (!dbusUtility::callPIM(move(objectInterfaceMap)))
         {