nvidia-gpu: fix crash caused by device instance ID collision

When multiple devices of the same device type return identical instance
IDs in response of the QueryDeviceIdentification MCTP VDM command, their
device names become similar due to the instance ID being appended. This
leads to multiple devices sharing the same dbus object path for their
sensors, resulting in a dbus object path collision and an exception.
This patch ensures that no dbus objects are created in the device class
constructor, and that the init method is only invoked when a new device
is instantiated. Additionally, it introduces checks for exceptions that
may occur during device creation.

Tested: Build an image for nvl32-obmc machine with the following patch
cherry picked.

https://gerrit.openbmc.org/c/openbmc/openbmc/+/85490

The patch cherry-picks the following patches that are currently under
review.

```
1. device tree
https://lore.kernel.org/all/aRbLqH8pLWCQryhu@molberding.nvidia.com/
2. mctpd patches
CodeConstruct/mctp#85
3. u-boot changes
https://lore.kernel.org/openbmc/20251121-msx4-v1-0-fc0118b666c1@nvidia.com/T/#t
4. kernel changes as specified in the openbmc patch (for espi)
5. entity-manager changes
https://gerrit.openbmc.org/c/openbmc/entity-manager/+/85455
6. platform-init changes
https://gerrit.openbmc.org/c/openbmc/platform-init/+/85456
7. spi changes
https://lore.kernel.org/all/20251121-w25q01jv_fixup-v1-1-3d175050db73@nvidia.com/
```

nvidiagpusensor application does not crash.

Change-Id: I44afe0233ad5dfe634b42f906c736ada82640b79
Signed-off-by: Harshit Aghera <haghera@nvidia.com>

Author: harshit-aghera

src/nvidia-gpu/NvidiaDeviceDiscovery.cpp

@@ -86,16 +86,26 @@ void processQueryDeviceIdResponse(
                 "EID", eid, "DEVTYPE", responseDeviceType, "IID",
                 responseInstanceId);
 
-            auto gpuName = configs.name + '_' +
-                           std::to_string(responseInstanceId);
-
-            auto gpu = gpuDevices
-                           .insert(std::make_pair(
-                               gpuName, std::make_shared<GpuDevice>(
-                                            configs, gpuName, path, conn, eid,
-                                            io, mctpRequester, objectServer)))
-                           .first;
-            gpu->second->init();
+            const std::string gpuName =
+                std::format("{}_{}", configs.name, responseInstanceId);
+
+            std::shared_ptr<GpuDevice>& gpu = gpuDevices[gpuName];
+
+            if (gpu == nullptr)
+            {
+                gpu = std::make_shared<GpuDevice>(configs, gpuName, path, conn,
+                                                  eid, io, mctpRequester,
+                                                  objectServer);
+
+                gpu->init();
+            }
+            else
+            {
+                lg2::info(
+                    "GPU Device with name {NAME} already exists. Skipping creating a new device.",
+                    "NAME", gpuName);
+            }
+
             break;
         }
 
@@ -106,16 +116,26 @@ void processQueryDeviceIdResponse(
                 "EID", eid, "DEVTYPE", responseDeviceType, "IID",
                 responseInstanceId);
 
-            auto smaName = configs.name + "_SMA_" +
-                           std::to_string(responseInstanceId);
+            const std::string smaName =
+                std::format("{}_SMA_{}", configs.name, responseInstanceId);
+
+            std::shared_ptr<SmaDevice>& sma = smaDevices[smaName];
+
+            if (sma == nullptr)
+            {
+                sma = std::make_shared<SmaDevice>(configs, smaName, path, conn,
+                                                  eid, io, mctpRequester,
+                                                  objectServer);
+
+                sma->init();
+            }
+            else
+            {
+                lg2::info(
+                    "SMA Device with name {NAME} already exists. Skipping creating a new device.",
+                    "NAME", smaName);
+            }
 
-            auto sma = smaDevices
-                           .insert(std::make_pair(
-                               smaName, std::make_shared<SmaDevice>(
-                                            configs, smaName, path, conn, eid,
-                                            io, mctpRequester, objectServer)))
-                           .first;
-            sma->second->init();
             break;
         }
 
@@ -126,17 +146,26 @@ void processQueryDeviceIdResponse(
                 "EID", eid, "DEVTYPE", responseDeviceType, "IID",
                 responseInstanceId);
 
-            std::string pcieName =
+            const std::string pcieName =
                 std::format("Nvidia_ConnectX_{}", responseInstanceId);
 
-            auto pcieDevice =
-                pcieDevices
-                    .insert(std::make_pair(
-                        pcieName, std::make_shared<PcieDevice>(
-                                      configs, pcieName, path, conn, eid, io,
-                                      mctpRequester, objectServer)))
-                    .first;
-            pcieDevice->second->init();
+            std::shared_ptr<PcieDevice>& pcie = pcieDevices[pcieName];
+
+            if (pcie == nullptr)
+            {
+                pcie = std::make_shared<PcieDevice>(
+                    configs, pcieName, path, conn, eid, io, mctpRequester,
+                    objectServer);
+
+                pcie->init();
+            }
+            else
+            {
+                lg2::info(
+                    "PCIe Device with name {NAME} already exists. Skipping creating a new device.",
+                    "NAME", pcieName);
+            }
+
             break;
         }
     }

src/nvidia-gpu/NvidiaGpuDevice.cpp

@@ -52,18 +52,19 @@ GpuDevice::GpuDevice(const SensorConfigs& configs, const std::string& name,
                      sdbusplus::asio::object_server& objectServer) :
     eid(eid), sensorPollMs(std::chrono::milliseconds{configs.pollRate}),
     waitTimer(io, std::chrono::steady_clock::duration(0)),
-    mctpRequester(mctpRequester), conn(conn), objectServer(objectServer),
-    configs(configs), name(escapeName(name)), path(path)
+    mctpRequester(mctpRequester), io(io), conn(conn),
+    objectServer(objectServer), configs(configs), name(escapeName(name)),
+    path(path)
+{}
+
+void GpuDevice::init()
 {
     inventory = std::make_shared<Inventory>(
         conn, objectServer, name, mctpRequester,
         gpu::DeviceIdentification::DEVICE_GPU, eid, io);
-}
+    inventory->init();
 
-void GpuDevice::init()
-{
     makeSensors();
-    inventory->init();
 }
 
 void GpuDevice::makeSensors()

src/nvidia-gpu/NvidiaGpuDevice.hpp

@@ -64,6 +64,8 @@ class GpuDevice : public std::enable_shared_from_this<GpuDevice>
 
     mctp::MctpRequester& mctpRequester;
 
+    boost::asio::io_context& io;
+
     std::shared_ptr<sdbusplus::asio::connection> conn;
 
     sdbusplus::asio::object_server& objectServer;