pldm: Add Redfish PDR support patch
This change adds support in rded daemon to extract the Redfish
PDRs from miniBMC using the PLDM M&C Type and Redfish Resource PDR.
Additionally it removes the previously hardcoded list of resource IDs
Design Doc: go/redfish-pdr-support
Tested: Ran the complete minibmc weekly tests workflow
including the rde soak tests. All tests passed successfully.
Verified that the Action commands like Drive reset action also
work fine.
Fusion-Link: https://fusion2.corp.google.com/c0e4c574-b87b-3184-a2fa-1bec790cdf41
Platforms-Affected: platform6
Google-Bug-Id: 344927358
Google-Bug-Id: 341389695
Google-Bug-Id: 286465868
Change-Id: I224e84bcf97e8b18c9f64fc22bcbed57e69c8361
Signed-off-by: Nikhil Namjoshi <nikhilnamjoshi@google.com>
diff --git a/recipes-phosphor/pldm/pldm/0015-Add-Redfish-PDR-support.patch b/recipes-phosphor/pldm/pldm/0015-Add-Redfish-PDR-support.patch
new file mode 100644
index 0000000..2d7ed5a
--- /dev/null
+++ b/recipes-phosphor/pldm/pldm/0015-Add-Redfish-PDR-support.patch
@@ -0,0 +1,1032 @@
+From 964ce7458284b13f500cf7afda61f1fd3d004183 Mon Sep 17 00:00:00 2001
+From: Nikhil Namjoshi <nikhilnamjoshi@google.com>
+Date: Wed, 29 May 2024 04:54:22 +0000
+Subject: [PATCH] Add Redfish PDR support
+
+This change adds support in rded daemon to extract the Redfish
+PDRs from miniBMC using the PLDM M&C Type and Redfish Resource PDR.
+Additionally it removes the previously hardcoded list of resource IDs
+
+Tested: Ran the complete minibmc weekly tests workflow
+including the rde soak tests. All tests passed successfully.
+Verified that the Action commands like Drive reset action also
+work fine.
+
+Fusion-Link: https://fusion2.corp.google.com/c8be2eaa-dfd9-322e-965d-fb2fe908a678
+
+Patch Tracking Bug: b/344927358
+Upstream info / review: NA
+Upstream-Status: Pending
+Justification:
+There is dependency on upstreaming rded first, followed by other
+libpldm command support like OperationInit, Operation,Status,
+OperationComplete and OperationKill. It is possible that we can
+never upstream this support as the upstream did not reach consensus
+for the rded patches.
+
+Google-Bug-Id: 341389695
+Google-Bug-Id: 286465868
+Change-Id: I35dad7d187c0a946f19cd8e144afff9467c83cdd
+Signed-off-by: Nikhil Namjoshi <nikhilnamjoshi@google.com>
+---
+ rded/helper/discovery/platform_discovery.cpp | 354 +++++++++++++++++++
+ rded/helper/discovery/platform_discovery.hpp | 27 ++
+ rded/helper/discovery/rde_discovery.cpp | 72 +++-
+ rded/helper/discovery/rde_discovery.hpp | 13 +-
+ rded/helper/resource_id_mapper.hpp | 221 ------------
+ rded/meson.build | 1 +
+ rded/rded.cpp | 74 +++-
+ 7 files changed, 513 insertions(+), 249 deletions(-)
+ create mode 100644 rded/helper/discovery/platform_discovery.cpp
+ create mode 100644 rded/helper/discovery/platform_discovery.hpp
+ delete mode 100644 rded/helper/resource_id_mapper.hpp
+
+diff --git a/rded/helper/discovery/platform_discovery.cpp b/rded/helper/discovery/platform_discovery.cpp
+new file mode 100644
+index 0000000..9185025
+--- /dev/null
++++ b/rded/helper/discovery/platform_discovery.cpp
+@@ -0,0 +1,354 @@
++#include "helper/discovery/platform_discovery.hpp"
++
++#include "libpldm/base.h"
++#include "libpldm/platform.h"
++#include "libpldm/pldm.h"
++#include "libpldm/requester/pldm_platform_requester.h"
++#include "libpldm/utils.h"
++
++#include "helper/common.hpp"
++
++#include <cstdint>
++#include <cstring>
++#include <iostream>
++#include <iterator>
++#include <memory>
++#include <unordered_map>
++
++std::unordered_map<uint8_t, int> platformCommandRequestSize = {
++ {PLDM_GET_PDR, PLDM_GET_PDR_REQ_BYTES}};
++
++/**
++ * @brief Sends the current GetPDR request to rde device, decodes
++ * response and stores the response data in containers
++ *
++ * @param[in] fd - Socket Id.
++ * @param[in] eid - Destination EID.
++ * @param[in] instanceId - Instance ID of rde device.
++ * @param[in] netId - Net Id of the rde device.
++ * @param[in] ctx - Pointer to platform requester context
++ * @param[inout] requestMsg - Vector to store requestMsg bytes
++ * @param[inout] resourceIdToSubUriMap - Resource Id to Sub URI map
++ * @param[inout] resourceIdToContainingResourceIdMap - Resource Id to
++ * Containing resource Id map
++ * @param[inout] completePdrRecordBytes - Vector to store the complete Pdr
++ * Record Data bytes
++ */
++static int processGetPdrRequest(
++ int fd, uint8_t eid, int instanceId, int netId,
++ struct pldm_platform_requester_context* ctx,
++ const std::vector<uint8_t>& requestMsg,
++ std::unordered_map<uint32_t, std::string>& resourceIdToSubUriMap,
++ std::unordered_map<uint32_t, uint32_t>& resourceIdToContainingResourceIdMap,
++ std::vector<uint8_t>& completePdrRecordBytes)
++{
++ ctx->requester_status = PLDM_PLATFORM_REQUESTER_WAITING_FOR_RESPONSE;
++ int rc = pldm_send_at_network(eid, netId, fd, requestMsg.data(),
++ requestMsg.size());
++ if (rc)
++ {
++ ctx->requester_status = PLDM_PLATFORM_REQUESTER_REQUEST_FAILED;
++ return PLDM_PLATFORM_REQUESTER_SEND_FAIL;
++ }
++ std::vector<uint8_t> response(sizeof(pldm_msg_hdr) + PLDM_MAX_REQUEST_BYTES,
++ 0);
++ uint8_t* responseMsg = response.data();
++ size_t responseMsgSize = response.size();
++ auto responsePtr = reinterpret_cast<struct pldm_msg*>(responseMsg);
++ rc = pldm_recv_at_network(eid, fd, instanceId, &responseMsg,
++ &responseMsgSize, netId);
++ if (rc)
++ {
++ ctx->requester_status = PLDM_PLATFORM_REQUESTER_REQUEST_FAILED;
++ return PLDM_PLATFORM_REQUESTER_RECV_FAIL;
++ }
++
++ bool isRecordDataComplete = false;
++ size_t recordDataLength = PLDM_MAX_REQUEST_BYTES -
++ PLDM_GET_PDR_MIN_RESP_BYTES;
++
++ std::vector<uint8_t> recordData(recordDataLength);
++ rc = pldm_platform_push_get_pdr_response(
++ ctx, responsePtr, responseMsgSize, 1 /*expected_pdr_header_version*/,
++ recordData.data(), recordDataLength, &isRecordDataComplete);
++ if (rc)
++ {
++ ctx->requester_status = PLDM_PLATFORM_REQUESTER_REQUEST_FAILED;
++ std::cerr << "Saving Get PDR Response failed..." << std::endl;
++ return PLDM_PLATFORM_REQUESTER_NOT_RESP_MSG;
++ }
++
++ // Insert all the bytes excluding the command header bytes
++ completePdrRecordBytes.resize(completePdrRecordBytes.size() +
++ recordDataLength);
++ std::memcpy((void*)(completePdrRecordBytes.data() +
++ completePdrRecordBytes.size() - recordDataLength),
++ (void*)(recordData.data() + sizeof(pldm_pdr_hdr)),
++ recordDataLength);
++
++ if (isRecordDataComplete)
++ {
++ uint32_t resourceId = 0;
++ uint8_t resourceFlags = 0;
++ uint32_t containingResourceId = 0;
++ uint16_t proposedContainingResourceLength = 0;
++ char* proposedContainingResourceName = NULL;
++ uint16_t resourceUriLength = 0;
++ char* resourceUri = NULL;
++ uint16_t additionalResourceIdCount = 0;
++ rc = pldm_platform_decode_first_pdr_resource(
++ completePdrRecordBytes.data(), &resourceId, &resourceFlags,
++ &containingResourceId, &proposedContainingResourceLength,
++ &proposedContainingResourceName, &resourceUriLength, &resourceUri,
++ &additionalResourceIdCount);
++ if (rc)
++ {
++ ctx->requester_status = PLDM_PLATFORM_REQUESTER_REQUEST_FAILED;
++ std::cerr << "Decoding PDR's first resource failed with rc " << rc
++ << std::endl;
++ return PLDM_PLATFORM_REQUESTER_NOT_RESP_MSG;
++ }
++
++ if (containingResourceId == PLDM_EXTERNAL_RESOURCE_ID)
++ {
++ resourceIdToSubUriMap.emplace(resourceId,
++ proposedContainingResourceName);
++ }
++ else
++ {
++ resourceIdToSubUriMap.emplace(resourceId, resourceUri);
++ }
++ resourceIdToContainingResourceIdMap.emplace(resourceId,
++ containingResourceId);
++
++ for (uint16_t id = 0; id < additionalResourceIdCount; id++)
++ {
++ rc = pldm_platform_decode_additional_pdr_resource(
++ completePdrRecordBytes.data(), id, &resourceId,
++ &resourceUriLength, &resourceUri);
++ if (rc)
++ {
++ ctx->requester_status = PLDM_PLATFORM_REQUESTER_REQUEST_FAILED;
++ std::cerr << "Decoding PDR's additional resource failed..."
++ << std::endl;
++ return PLDM_PLATFORM_REQUESTER_NOT_RESP_MSG;
++ }
++
++ resourceIdToSubUriMap.emplace(resourceId, resourceUri);
++ resourceIdToContainingResourceIdMap.emplace(resourceId,
++ containingResourceId);
++ }
++
++ // Clear the container so it can be used for next set of PDR data
++ completePdrRecordBytes.clear();
++ }
++
++ return PLDM_PLATFORM_REQUESTER_SUCCESS;
++}
++
++/**
++ * @brief Initializes platform context for the plaform requests
++ *
++ * @param[inout] platformCtx - Pointer to platform requester context
++ * @param[inout] pdrOpCtx - Pointer to pdr operation context
++ * @param[in] rdeDeviceId - Rde device Id
++ * @param[in] netId - Net Id of the rde device.
++ * @param[in] negotiatedTransferSize - Negotiated PLDM message size
++ * @return 0 on success, -1 on failure
++ */
++static int initPlatformContextForRde(
++ struct pldm_platform_requester_context* platformCtx,
++ struct pldm_platform_get_pdr_operation* pdrOpCtx,
++ const std::string& rdeDeviceId, int netId, uint32_t negotiatedTransferSize)
++{
++ if (pldm_platform_init_context(platformCtx, rdeDeviceId.c_str(), netId,
++ negotiatedTransferSize) != 0)
++ {
++ std::cerr << "Unable to initialize platform context" << std::endl;
++ return -1;
++ }
++
++ if (pldm_platform_init_get_pdr_operation_context(platformCtx, pdrOpCtx) !=
++ 0)
++ {
++ std::cerr << "Unable to initialize GetPDR Operation context"
++ << std::endl;
++ return -1;
++ }
++
++ return 0;
++}
++
++/**
++ * @brief API to recursively construct complere Redfish resource URI
++ * using the sub URI fragments
++ * @param[in] resourceIdToSubUriMap - Resource ID to Sub Uri map
++ * @param[in] resourceIdToContainingResourceIdMap - Resource ID to
++ * Containing resource ID map
++ * @param[inout] resourcePartialUri - Partially constructed Redfish
++ * resource URI
++ * @param[in] containingResourceId - Containing Resource ID
++ * @return string representing the complete Redfish resource URI
++ */
++static std::string constructResourceUri(
++ const std::unordered_map<uint32_t, std::string>& resourceIdToSubUriMap,
++ const std::unordered_map<uint32_t, uint32_t>&
++ resourceIdToContainingResourceIdMap,
++ std::string& resourcePartialUri, uint32_t containingResourceId)
++{
++ // Break the recusion when the resource is root level resource
++ if (containingResourceId == 0x00000000)
++ {
++ return "/redfish/v1/" + resourcePartialUri;
++ }
++
++ auto resourceIdToSubUriMapItr =
++ resourceIdToSubUriMap.find(containingResourceId);
++ if (resourceIdToSubUriMapItr == resourceIdToSubUriMap.end())
++ {
++ std::cerr << "Cannot find containingResourceId : "
++ << containingResourceId << " in resourceIdToSubUriMap"
++ << std::endl;
++ return "";
++ }
++
++ std::string subUri = resourceIdToSubUriMapItr->second;
++
++ resourcePartialUri = subUri + "/" + resourcePartialUri;
++
++ auto resourceIdToContainingResourceIdMapItr =
++ resourceIdToContainingResourceIdMap.find(containingResourceId);
++ if (resourceIdToContainingResourceIdMapItr ==
++ resourceIdToContainingResourceIdMap.end())
++ {
++ std::cerr << "Cannot find containingResourceId : "
++ << containingResourceId
++ << " in resourceIdToContainingResourceIdMap" << std::endl;
++ return "";
++ }
++
++ uint32_t nextContainingResourceId =
++ resourceIdToContainingResourceIdMapItr->second;
++ return constructResourceUri(resourceIdToSubUriMap,
++ resourceIdToContainingResourceIdMap,
++ resourcePartialUri, nextContainingResourceId);
++}
++
++/**
++ * @brief API to recursively construct Redfish resource URI
++ * to Resource ID Map
++ * @param[inout] resourceIdMap - Redfish Resource URI to Resource ID map
++ * @param[in] resourceIdToSubUriMap - Resource ID to Sub Uri map
++ * @param[in] resourceIdToContainingResourceIdMap - Resource ID to
++ * Containing resource ID map
++ * @return string representing the complete Redfish resource URI
++ */
++static void constructResourceIdMap(
++ std::unordered_map<std::string, uint32_t>& resourceIdMap,
++ const std::unordered_map<uint32_t, std::string>& resourceIdToSubUriMap,
++ const std::unordered_map<uint32_t, uint32_t>&
++ resourceIdToContainingResourceIdMap)
++{
++ for (auto it = resourceIdToContainingResourceIdMap.begin();
++ it != resourceIdToContainingResourceIdMap.end(); ++it)
++ {
++ uint32_t resourceId = it->first;
++ uint32_t containingResourceId = it->second;
++
++ auto resourceIdToSubUriMapItr = resourceIdToSubUriMap.find(resourceId);
++ if (resourceIdToSubUriMapItr == resourceIdToSubUriMap.end())
++ {
++ std::cerr << "Cannot find resourceId : " << resourceId
++ << " in resourceIdToSubUriMap" << std::endl;
++ return;
++ }
++
++ std::string resourcePartialUri = resourceIdToSubUriMapItr->second;
++ std::string resourceFullUri = constructResourceUri(
++ resourceIdToSubUriMap, resourceIdToContainingResourceIdMap,
++ resourcePartialUri, containingResourceId);
++ std::cerr << "Adding resourceId " << std::showbase << std::hex
++ << resourceId << " with resource URI " << resourceFullUri
++ << std::endl;
++ resourceIdMap.emplace(resourceFullUri, resourceId);
++ }
++}
++
++int performPdrDiscovery(
++ const std::string& rdeDeviceId, int fd, int netId, uint8_t destEid,
++ uint8_t instanceId, uint32_t negotiatedTransferSize,
++ std::unordered_map<std::string, uint32_t>& resourceIdMap)
++{
++ struct pldm_platform_requester_context platformContext;
++ struct pldm_platform_get_pdr_operation pdrOpContext;
++
++ int rc = initPlatformContextForRde(&platformContext, &pdrOpContext,
++ rdeDeviceId, netId,
++ negotiatedTransferSize);
++ if (rc)
++ {
++ return -1;
++ }
++
++ rc = pldm_platform_start_pdr_discovery(&platformContext);
++ if (rc)
++ {
++ std::cerr << "PDR Discovery failed due to context busy with ec: " << rc
++ << std::endl;
++ return -1;
++ }
++
++ std::unordered_map<uint32_t, std::string> resourceIdToSubUriMap;
++ std::unordered_map<uint32_t, uint32_t> resourceIdToContainingResourceIdMap;
++ std::vector<uint8_t> completePdrRecordBytes;
++
++ std::cerr << "Sending Platform PDR Discovery requests." << std::endl;
++
++ while (true)
++ {
++ size_t requestBytes;
++ if (platformContext.requester_status ==
++ PLDM_PLATFORM_REQUESTER_NO_PENDING_ACTION)
++ {
++ break;
++ }
++ if (platformCommandRequestSize.find(platformContext.next_command) !=
++ platformCommandRequestSize.end())
++ {
++ requestBytes =
++ platformCommandRequestSize[platformContext.next_command];
++ }
++ else
++ {
++ requestBytes = PLDM_MAX_REQUEST_BYTES;
++ }
++
++ std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) + requestBytes);
++ auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
++
++ rc = pldm_platform_get_next_get_pdr_request(
++ &platformContext, instanceId, request, requestBytes);
++ if (rc)
++ {
++ std::cerr << "Not a valid request to process" << std::endl;
++ return rc;
++ }
++
++ rc = processGetPdrRequest(fd, destEid, 1, netId, &platformContext,
++ requestMsg, resourceIdToSubUriMap,
++ resourceIdToContainingResourceIdMap,
++ completePdrRecordBytes);
++
++ if (rc)
++ {
++ std::cerr << "Unable to process next platform request: "
++ << std::to_string(rc) << std::endl;
++ return rc;
++ }
++ }
++
++ std::cerr << "PDR Discovery complete." << std::endl;
++ constructResourceIdMap(resourceIdMap, resourceIdToSubUriMap,
++ resourceIdToContainingResourceIdMap);
++ return 0;
++}
+diff --git a/rded/helper/discovery/platform_discovery.hpp b/rded/helper/discovery/platform_discovery.hpp
+new file mode 100644
+index 0000000..864af62
+--- /dev/null
++++ b/rded/helper/discovery/platform_discovery.hpp
+@@ -0,0 +1,27 @@
++#include "libpldm/requester/pldm_platform_requester.h"
++
++#include <iostream>
++#include <optional>
++#include <string>
++#include <unordered_map>
++#include <vector>
++
++#pragma once
++
++/**
++ * @brief Collects all the PDRs from rde device
++ *
++ * @param[in] rdeDeviceId - Udev Id of the rde device.
++ * @param[in] fd - Socket Id.
++ * @param[in] netId - Net Id of the rde device.
++ * @param[in] destEid - Destination EID.
++ * @param[in] instanceId - Instance ID of rde device.
++ * @param[in] negotiatedTransferSize - Pldm msg transfer size negotiated with
++ * rde device.
++ * @param[inout] resourceIdMap - Map of resource URI against resource Id.
++ * @return 0 on success and negative errono on failure
++ */
++int performPdrDiscovery(
++ const std::string& rdeDeviceId, int fd, int netId, uint8_t destEid,
++ uint8_t instanceId, uint32_t negotiatedTransferSize,
++ std::unordered_map<std::string, uint32_t>& resourceIdMap);
+diff --git a/rded/helper/discovery/rde_discovery.cpp b/rded/helper/discovery/rde_discovery.cpp
+index 3ccae41..37e475e 100644
+--- a/rded/helper/discovery/rde_discovery.cpp
++++ b/rded/helper/discovery/rde_discovery.cpp
+@@ -1,5 +1,3 @@
+-#include "helper/discovery/rde_discovery.hpp"
+-
+ #include "libpldm/base.h"
+ #include "libpldm/pldm.h"
+ #include "libpldm/pldm_rde.h"
+@@ -7,7 +5,9 @@
+ #include "libpldm/utils.h"
+
+ #include "helper/common.hpp"
++#include "helper/discovery/rde_discovery.hpp"
+
++#include <algorithm>
+ #include <cstdint>
+ #include <iostream>
+ #include <map>
+@@ -139,11 +139,6 @@ int initManager(const std::string& rdeDeviceId, int netId)
+ std::unique_ptr<bitfield16_t> mcFeatures = std::make_unique<bitfield16_t>();
+ mcFeatures->value = 102; // Fixed for now
+ std::cout << "Initializing RDE Manager...\n";
+- std::vector<uint32_t> resourceIds = {
+- 0x00000000, 0x00010000, 0x00020000, 0x00030000, 0x00040000,
+- 0x00050000, 0x00060000, 0x00070000, 0x00080000, 0x00090000,
+- 0x000a0000, 0x000b0000, 0x000c0000, 0x000d0000, 0x000e0000,
+- 0x000f0000, 0x00100000, 0x00110000, 0xffffffff};
+
+ std::unique_ptr<struct pldm_rde_requester_manager> manager =
+ std::make_unique<struct pldm_rde_requester_manager>();
+@@ -151,8 +146,7 @@ int initManager(const std::string& rdeDeviceId, int netId)
+ managerCtxCounter.insert({rdeDeviceId, rdeContextCounter});
+ int rc = pldm_rde_init_context(
+ rdeDeviceId.c_str(), netId, manager.get(), mcConcurrency,
+- mcTransferSize, mcFeatures.get(), resourceIds.size(),
+- &resourceIds.front(), allocateMemoryToContexts, freeMemory);
++ mcTransferSize, mcFeatures.get(), allocateMemoryToContexts, freeMemory);
+
+ if (rc)
+ {
+@@ -168,6 +162,18 @@ int initManager(const std::string& rdeDeviceId, int netId)
+ return PLDM_RDE_REQUESTER_SUCCESS;
+ }
+
++/**
++ * @param[in] manager - Rde manager for the device
++ * @param[in] resourceIds - List of dictionary schema resource IDs
++ * @return 0 on success, non zero error code on failure.
++ */
++static int setResourcesIdsInManager(struct pldm_rde_requester_manager* manager,
++ std::vector<uint32_t>& resourceIds)
++{
++ return pldm_rde_set_resources_in_context(manager, resourceIds.size(),
++ resourceIds.data());
++}
++
+ int getRdeContextForRdeDevice(const std::string& rdeDevice)
+ {
+ auto it = managerCtxCounter.find(rdeDevice);
+@@ -542,7 +548,8 @@ int processNextRdeRequest(int fd, uint8_t eid, int instanceId,
+ }
+
+ int performRdeDiscovery(const std::string& rdeDeviceId, int fd, int netId,
+- uint8_t destEid, uint8_t instanceId)
++ uint8_t destEid, uint8_t instanceId,
++ uint32_t& negotiatedTransferSize)
+ {
+ int rc = initManager(rdeDeviceId, netId);
+
+@@ -625,6 +632,8 @@ int performRdeDiscovery(const std::string& rdeDeviceId, int fd, int netId,
+ }
+ }
+
++ negotiatedTransferSize = manager->negotiated_transfer_size;
++
+ if (DEBUG)
+ {
+ printRDENegotiateContext(manager);
+@@ -632,12 +641,35 @@ int performRdeDiscovery(const std::string& rdeDeviceId, int fd, int netId,
+ return rc;
+ }
+
+-int performDictionaryDiscoveryForDevice(const std::string& rdeDeviceId, int fd,
+- uint8_t destEid, uint8_t instanceId)
++int performDictionaryDiscoveryForDevice(
++ const std::string& rdeDeviceId, int fd, uint8_t destEid, uint8_t instanceId,
++ std::unordered_map<std::string, uint32_t>& resourceIdMap)
+ {
+ std::unordered_map<uint32_t, std::vector<uint8_t>> dictionaryRidMap;
+ std::unordered_map<uint32_t, std::tuple<uint8_t, uint8_t>>
+ dictionaryMetaRidMap;
++ std::vector<uint32_t> schemaResourceIds;
++
++ for (const auto& [key, value] : resourceIdMap)
++ {
++ // We need to extract just the schema resource IDs. There will be
++ // multiple resources which share the same schema, but we only need
++ // the resource ID of the first resource of that schema
++ // For e.g. We only need resource ID of /redfish/v1/Chassis/Tray i.e.
++ // 0x00020000 instead of resource ID of /redfish/v1/Chassis/SATA_0 i.e.
++ // 0x00020001. Here the MSB 0x0002 represents the resource type while
++ // the LSB 0x0001 represent the resource index. So we exclude the
++ // resource index
++ uint32_t schemaResourceId = value & 0xFFFF0000;
++ auto it = std::find(schemaResourceIds.begin(), schemaResourceIds.end(),
++ schemaResourceId);
++ if (it == schemaResourceIds.end())
++ {
++ schemaResourceIds.emplace_back(schemaResourceId);
++ }
++ }
++ // Add the annotation dictionary
++ schemaResourceIds.emplace_back(0xffffffff);
+
+ dictionaryDeviceMap.insert({rdeDeviceId, dictionaryRidMap});
+
+@@ -678,6 +710,15 @@ int performDictionaryDiscoveryForDevice(const std::string& rdeDeviceId, int fd,
+ }
+ struct pldm_rde_requester_manager* manager = managerOpt.value();
+
++ rc = setResourcesIdsInManager(manager, schemaResourceIds);
++ if (rc)
++ {
++ std::cerr
++ << "RDE Discovery failed due to failed to set resource IDs in context: "
++ << rc << "\n";
++ return -1;
++ }
++
+ std::cout << "Getting Dictionaries..." << std::endl;
+ int retryCounter = 0;
+ while (retryCounter < MAX_RETRIES_FOR_REQUEST)
+@@ -704,7 +745,7 @@ int performDictionaryDiscoveryForDevice(const std::string& rdeDeviceId, int fd,
+ {
+ std::cerr << "Getting dictionary for "
+ << manager->resource_ids[baseContext.current_pdr_resource
+- ->resource_id_index]
++ ->resource_id_index]
+ << "..." << std::endl;
+ }
+
+@@ -733,7 +774,8 @@ int performDictionaryDiscoveryForDevice(const std::string& rdeDeviceId, int fd,
+ }
+
+ int getRdeFreeContextForRdeDevice(
+- const std::string& rdeDevice, struct pldm_rde_requester_context* baseContext)
++ const std::string& rdeDevice,
++ struct pldm_rde_requester_context* baseContext)
+ {
+ auto it = managerCtxCounter.find(rdeDevice);
+ if (it != managerCtxCounter.end())
+@@ -756,7 +798,7 @@ int getDictionaryForRidDev(const std::string& rdeDeviceId, uint32_t resourceId,
+
+ std::optional<std::unordered_map<uint32_t, std::vector<uint8_t>>*>
+ dictionaryRidMapOpt = getDictionaryMap(rdeDeviceId);
+-
++
+ if (!dictionaryRidMapOpt.has_value())
+ {
+ std::cerr << "Unable to fetch dictionary from map while storing\n";
+diff --git a/rded/helper/discovery/rde_discovery.hpp b/rded/helper/discovery/rde_discovery.hpp
+index 1e5efa7..e40fc31 100644
+--- a/rded/helper/discovery/rde_discovery.hpp
++++ b/rded/helper/discovery/rde_discovery.hpp
+@@ -1,9 +1,10 @@
+ #include "libpldm/requester/pldm_rde_requester.h"
+
+ #include <iostream>
++#include <optional>
+ #include <string>
++#include <unordered_map>
+ #include <vector>
+-#include <optional>
+
+ #pragma once
+
+@@ -12,10 +13,12 @@
+ #define RDE_GET_DICT_SCHEMA_RESP_SIZE 6
+
+ int performRdeDiscovery(const std::string& rdeDeviceId, int fd, int netId,
+- uint8_t destEid, uint8_t instanceId);
++ uint8_t destEid, uint8_t instanceId,
++ uint32_t& negotiatedTransferSize);
+
+-int performDictionaryDiscoveryForDevice(const std::string& rdeDeviceId, int fd,
+- uint8_t destEid, uint8_t instanceId);
++int performDictionaryDiscoveryForDevice(
++ const std::string& rdeDeviceId, int fd, uint8_t destEid, uint8_t instanceId,
++ std::unordered_map<std::string, uint32_t>& resourceIdMap);
+
+ void cleanupDictionaries(const std::string& rdeDeviceId);
+
+@@ -33,4 +36,4 @@ std::optional<struct pldm_rde_requester_manager*>
+ void cleanupDictionaries(const std::string& rdeDeviceId);
+
+ // cleanup disc data at exit
+-void cleanupRdeDiscAtExit();
+\ No newline at end of file
++void cleanupRdeDiscAtExit();
+diff --git a/rded/helper/resource_id_mapper.hpp b/rded/helper/resource_id_mapper.hpp
+deleted file mode 100644
+index c605cb4..0000000
+--- a/rded/helper/resource_id_mapper.hpp
++++ /dev/null
+@@ -1,221 +0,0 @@
+-/**
+- *
+- * This file has a hardcoded resource id mapper for machines
+- * This would not be used once the PDR is implemented
+- *
+- */
+-#include <iostream>
+-#include <string>
+-#include <string_view>
+-#include <unordered_map>
+-
+-std::unordered_map<std::string_view, uint32_t> resourceIdMap = {
+- {"/redfish/v1/Chassis", 0x00000000},
+- {"/redfish/v1/Chassis/Tray", 0x00010000},
+- {"/redfish/v1/Chassis/SATA_0", 0x00010001},
+- {"/redfish/v1/Chassis/SATA_1", 0x00010002},
+- {"/redfish/v1/Chassis/SATA_2", 0x00010003},
+- {"/redfish/v1/Chassis/SATA_3", 0x00010004},
+- {"/redfish/v1/Chassis/SATA_4", 0x00010005},
+- {"/redfish/v1/Chassis/SATA_5", 0x00010006},
+- {"/redfish/v1/Chassis/SATA_6", 0x00010007},
+- {"/redfish/v1/Chassis/SATA_7", 0x00010008},
+- {"/redfish/v1/Chassis/SATA_8", 0x00010009},
+- {"/redfish/v1/Chassis/SATA_9", 0x0001000a},
+- {"/redfish/v1/Chassis/SATA_10", 0x0001000b},
+- {"/redfish/v1/Chassis/SATA_11", 0x0001000c},
+- {"/redfish/v1/Chassis/SATA_12", 0x0001000d},
+- {"/redfish/v1/Chassis/SATA_13", 0x0001000e},
+- {"/redfish/v1/Chassis/SATA_14", 0x0001000f},
+- {"/redfish/v1/Chassis/SATA_15", 0x00010010},
+- {"/redfish/v1/Chassis/SATA_16", 0x00010011},
+- {"/redfish/v1/Chassis/SATA_17", 0x00010012},
+- {"/redfish/v1/Chassis/SATA_18", 0x00010013},
+- {"/redfish/v1/Chassis/SATA_19", 0x00010014},
+- {"/redfish/v1/Chassis/SATA_20", 0x00010015},
+- {"/redfish/v1/Chassis/SATA_21", 0x00010016},
+- {"/redfish/v1/Chassis/SATA_22", 0x00010017},
+- {"/redfish/v1/Chassis/SATA_23", 0x00010018},
+- {"/redfish/v1/Chassis/Tray/Sensors", 0x00020000},
+- {"/redfish/v1/Chassis/SATA_0/Sensors", 0x00020001},
+- {"/redfish/v1/Chassis/SATA_1/Sensors", 0x00020002},
+- {"/redfish/v1/Chassis/SATA_2/Sensors", 0x00020003},
+- {"/redfish/v1/Chassis/SATA_3/Sensors", 0x00020004},
+- {"/redfish/v1/Chassis/SATA_4/Sensors", 0x00020005},
+- {"/redfish/v1/Chassis/SATA_5/Sensors", 0x00020006},
+- {"/redfish/v1/Chassis/SATA_6/Sensors", 0x00020007},
+- {"/redfish/v1/Chassis/SATA_7/Sensors", 0x00020008},
+- {"/redfish/v1/Chassis/SATA_8/Sensors", 0x00020009},
+- {"/redfish/v1/Chassis/SATA_9/Sensors", 0x0002000a},
+- {"/redfish/v1/Chassis/SATA_10/Sensors", 0x0002000b},
+- {"/redfish/v1/Chassis/SATA_11/Sensors", 0x0002000c},
+- {"/redfish/v1/Chassis/SATA_12/Sensors", 0x0002000d},
+- {"/redfish/v1/Chassis/SATA_13/Sensors", 0x0002000e},
+- {"/redfish/v1/Chassis/SATA_14/Sensors", 0x0002000f},
+- {"/redfish/v1/Chassis/SATA_15/Sensors", 0x00020010},
+- {"/redfish/v1/Chassis/SATA_16/Sensors", 0x00020011},
+- {"/redfish/v1/Chassis/SATA_17/Sensors", 0x00020012},
+- {"/redfish/v1/Chassis/SATA_18/Sensors", 0x00020013},
+- {"/redfish/v1/Chassis/SATA_19/Sensors", 0x00020014},
+- {"/redfish/v1/Chassis/SATA_20/Sensors", 0x00020015},
+- {"/redfish/v1/Chassis/SATA_21/Sensors", 0x00020016},
+- {"/redfish/v1/Chassis/SATA_22/Sensors", 0x00020017},
+- {"/redfish/v1/Chassis/SATA_23/Sensors", 0x00020018},
+- {"/redfish/v1/Chassis/Tray/Sensors/vol_p12v_scaled", 0x00030000},
+- {"/redfish/v1/Chassis/Tray/Sensors/vol_p5v1_scaled", 0x00030001},
+- {"/redfish/v1/Chassis/Tray/Sensors/vol_p5v2_scaled", 0x00030002},
+- {"/redfish/v1/Chassis/Tray/Sensors/vol_p3v3_aux_scaled", 0x00030003},
+- {"/redfish/v1/Chassis/Tray/Sensors/vol_p1v8_scaled", 0x00030004},
+- {"/redfish/v1/Chassis/Tray/Sensors/vol_p0v86_scaled", 0x00030005},
+- {"/redfish/v1/Chassis/Tray/Sensors/vol_p1v45_scaled", 0x00030006},
+- {"/redfish/v1/Chassis/Tray/Sensors/temp_i2tang", 0x00030007},
+- {"/redfish/v1/Chassis/Tray/Sensors/hsc_temp", 0x00030008},
+- {"/redfish/v1/Chassis/Tray/Sensors/hsc_vin", 0x00030009},
+- {"/redfish/v1/Chassis/Tray/Sensors/hsc_vout", 0x0003000a},
+- {"/redfish/v1/Chassis/Tray/Sensors/hsc_pin", 0x0003000b},
+- {"/redfish/v1/Chassis/Tray/Sensors/hsc_iout", 0x0003000c},
+- {"/redfish/v1/Chassis/Tray/Sensors/hsc_peak_iout", 0x0003000d},
+- {"/redfish/v1/Chassis/Tray/Sensors/hsc_peak_vin", 0x0003000e},
+- {"/redfish/v1/Chassis/Tray/Sensors/hsc_peak_temp", 0x0003000f},
+- {"/redfish/v1/Chassis/Tray/Sensors/hsc_peak_pin", 0x00030010},
+- {"/redfish/v1/Chassis/Tray/Sensors/brick_p12v_temp", 0x00030011},
+- {"/redfish/v1/Chassis/Tray/Sensors/brick_p12v_vin", 0x00030012},
+- {"/redfish/v1/Chassis/Tray/Sensors/brick_p12v_vout", 0x00030013},
+- {"/redfish/v1/Chassis/Tray/Sensors/brick_p12v_iout", 0x00030014},
+- {"/redfish/v1/Chassis/Tray/Sensors/brick_p12v_pout", 0x00030015},
+- {"/redfish/v1/Chassis/Tray/Sensors/p5v_1_vin", 0x00030016},
+- {"/redfish/v1/Chassis/Tray/Sensors/p5v_1_vout", 0x00030017},
+- {"/redfish/v1/Chassis/Tray/Sensors/p5v_1_iout", 0x00030018},
+- {"/redfish/v1/Chassis/Tray/Sensors/p5v_1_temp", 0x00030019},
+- {"/redfish/v1/Chassis/Tray/Sensors/p5v_2_vin", 0x0003001a},
+- {"/redfish/v1/Chassis/Tray/Sensors/p5v_2_vout", 0x0003001b},
+- {"/redfish/v1/Chassis/Tray/Sensors/p5v_2_iout", 0x0003001c},
+- {"/redfish/v1/Chassis/Tray/Sensors/p5v_2_temp", 0x0003001d},
+- {"/redfish/v1/Chassis/Tray/Sensors/p0v86_vin", 0x0003001e},
+- {"/redfish/v1/Chassis/Tray/Sensors/p0v86_vout", 0x0003001f},
+- {"/redfish/v1/Chassis/Tray/Sensors/p0v86_iout", 0x00030020},
+- {"/redfish/v1/Chassis/Tray/Sensors/p0v86_temp", 0x00030021},
+- {"/redfish/v1/Chassis/Tray/Sensors/fan0_tach", 0x00030022},
+- {"/redfish/v1/Chassis/Tray/Sensors/fan1_tach", 0x00030023},
+- {"/redfish/v1/Chassis/Tray/Sensors/fan0_duty", 0x00030024},
+- {"/redfish/v1/Chassis/Tray/Sensors/fan1_duty", 0x00030025},
+- {"/redfish/v1/Chassis/Tray/Sensors/ioc_temp", 0x00030026},
+- {"/redfish/v1/Chassis/SATA_0/Sensors/Drive_0t", 0x00030027},
+- {"/redfish/v1/Chassis/SATA_1/Sensors/Drive_0t", 0x00030028},
+- {"/redfish/v1/Chassis/SATA_2/Sensors/Drive_0t", 0x00030029},
+- {"/redfish/v1/Chassis/SATA_3/Sensors/Drive_0t", 0x0003002a},
+- {"/redfish/v1/Chassis/SATA_4/Sensors/Drive_0t", 0x0003002b},
+- {"/redfish/v1/Chassis/SATA_5/Sensors/Drive_0t", 0x0003002c},
+- {"/redfish/v1/Chassis/SATA_6/Sensors/Drive_0t", 0x0003002d},
+- {"/redfish/v1/Chassis/SATA_7/Sensors/Drive_0t", 0x0003002e},
+- {"/redfish/v1/Chassis/SATA_8/Sensors/Drive_0t", 0x0003002f},
+- {"/redfish/v1/Chassis/SATA_9/Sensors/Drive_0t", 0x00030030},
+- {"/redfish/v1/Chassis/SATA_10/Sensors/Drive_0t", 0x00030031},
+- {"/redfish/v1/Chassis/SATA_11/Sensors/Drive_0t", 0x00030032},
+- {"/redfish/v1/Chassis/SATA_12/Sensors/Drive_0t", 0x00030033},
+- {"/redfish/v1/Chassis/SATA_13/Sensors/Drive_0t", 0x00030034},
+- {"/redfish/v1/Chassis/SATA_14/Sensors/Drive_0t", 0x00030035},
+- {"/redfish/v1/Chassis/SATA_15/Sensors/Drive_0t", 0x00030036},
+- {"/redfish/v1/Chassis/SATA_16/Sensors/Drive_0t", 0x00030037},
+- {"/redfish/v1/Chassis/SATA_17/Sensors/Drive_0t", 0x00030038},
+- {"/redfish/v1/Chassis/SATA_18/Sensors/Drive_0t", 0x00030039},
+- {"/redfish/v1/Chassis/SATA_19/Sensors/Drive_0t", 0x0003003a},
+- {"/redfish/v1/Chassis/SATA_20/Sensors/Drive_0t", 0x0003003b},
+- {"/redfish/v1/Chassis/SATA_21/Sensors/Drive_0t", 0x0003003c},
+- {"/redfish/v1/Chassis/SATA_22/Sensors/Drive_0t", 0x0003003d},
+- {"/redfish/v1/Chassis/SATA_23/Sensors/Drive_0t", 0x0003003e},
+- {"/redfish/v1/Chassis/Tray/Sensors/host_fan0_pwm", 0x0003003f},
+- {"/redfish/v1/Chassis/Tray/Sensors/p12v_cem_imon", 0x00030040},
+- {"/redfish/v1/Chassis/Tray/Sensors/p12v_cem", 0x00030041},
+- {"/redfish/v1/Chassis/Tray/Sensors/mb_pwr_status", 0x00030042},
+- {"/redfish/v1/Chassis/Tray/Sensors/fan0_imon", 0x00030043},
+- {"/redfish/v1/Chassis/Tray/Sensors/fan1_imon", 0x00030044},
+- {"/redfish/v1/Managers", 0x00040000},
+- {"/redfish/v1/Managers/mbmc", 0x00050000},
+- {"/redfish/v1/Chassis/SATA_0/Drives", 0x00060001},
+- {"/redfish/v1/Chassis/SATA_1/Drives", 0x00060002},
+- {"/redfish/v1/Chassis/SATA_2/Drives", 0x00060003},
+- {"/redfish/v1/Chassis/SATA_3/Drives", 0x00060004},
+- {"/redfish/v1/Chassis/SATA_4/Drives", 0x00060005},
+- {"/redfish/v1/Chassis/SATA_5/Drives", 0x00060006},
+- {"/redfish/v1/Chassis/SATA_6/Drives", 0x00060007},
+- {"/redfish/v1/Chassis/SATA_7/Drives", 0x00060008},
+- {"/redfish/v1/Chassis/SATA_8/Drives", 0x00060009},
+- {"/redfish/v1/Chassis/SATA_9/Drives", 0x0006000a},
+- {"/redfish/v1/Chassis/SATA_10/Drives", 0x0006000b},
+- {"/redfish/v1/Chassis/SATA_11/Drives", 0x0006000c},
+- {"/redfish/v1/Chassis/SATA_12/Drives", 0x0006000d},
+- {"/redfish/v1/Chassis/SATA_13/Drives", 0x0006000e},
+- {"/redfish/v1/Chassis/SATA_14/Drives", 0x0006000f},
+- {"/redfish/v1/Chassis/SATA_15/Drives", 0x00060010},
+- {"/redfish/v1/Chassis/SATA_16/Drives", 0x00060011},
+- {"/redfish/v1/Chassis/SATA_17/Drives", 0x00060012},
+- {"/redfish/v1/Chassis/SATA_18/Drives", 0x00060013},
+- {"/redfish/v1/Chassis/SATA_19/Drives", 0x00060014},
+- {"/redfish/v1/Chassis/SATA_20/Drives", 0x00060015},
+- {"/redfish/v1/Chassis/SATA_21/Drives", 0x00060016},
+- {"/redfish/v1/Chassis/SATA_22/Drives", 0x00060017},
+- {"/redfish/v1/Chassis/SATA_23/Drives", 0x00060018},
+- {"/redfish/v1/Chassis/SATA_0/Drives/SATA_0", 0x00070000},
+- {"/redfish/v1/Chassis/SATA_1/Drives/SATA_1", 0x00070001},
+- {"/redfish/v1/Chassis/SATA_2/Drives/SATA_2", 0x00070002},
+- {"/redfish/v1/Chassis/SATA_3/Drives/SATA_3", 0x00070003},
+- {"/redfish/v1/Chassis/SATA_4/Drives/SATA_4", 0x00070004},
+- {"/redfish/v1/Chassis/SATA_5/Drives/SATA_5", 0x00070005},
+- {"/redfish/v1/Chassis/SATA_6/Drives/SATA_6", 0x00070006},
+- {"/redfish/v1/Chassis/SATA_7/Drives/SATA_7", 0x00070007},
+- {"/redfish/v1/Chassis/SATA_8/Drives/SATA_8", 0x00070008},
+- {"/redfish/v1/Chassis/SATA_9/Drives/SATA_9", 0x00070009},
+- {"/redfish/v1/Chassis/SATA_10/Drives/SATA_10", 0x0007000a},
+- {"/redfish/v1/Chassis/SATA_11/Drives/SATA_11", 0x0007000b},
+- {"/redfish/v1/Chassis/SATA_12/Drives/SATA_12", 0x0007000c},
+- {"/redfish/v1/Chassis/SATA_13/Drives/SATA_13", 0x0007000d},
+- {"/redfish/v1/Chassis/SATA_14/Drives/SATA_14", 0x0007000e},
+- {"/redfish/v1/Chassis/SATA_15/Drives/SATA_15", 0x0007000f},
+- {"/redfish/v1/Chassis/SATA_16/Drives/SATA_16", 0x00070010},
+- {"/redfish/v1/Chassis/SATA_17/Drives/SATA_17", 0x00070011},
+- {"/redfish/v1/Chassis/SATA_18/Drives/SATA_18", 0x00070012},
+- {"/redfish/v1/Chassis/SATA_19/Drives/SATA_19", 0x00070013},
+- {"/redfish/v1/Chassis/SATA_20/Drives/SATA_20", 0x00070014},
+- {"/redfish/v1/Chassis/SATA_21/Drives/SATA_21", 0x00070015},
+- {"/redfish/v1/Chassis/SATA_22/Drives/SATA_22", 0x00070016},
+- {"/redfish/v1/Chassis/SATA_23/Drives/SATA_23", 0x00070017},
+- {"/redfish/v1/UpdateService", 0x00080000},
+- {"/redfish/v1/UpdateService/FirmwareInventory", 0x000a0000},
+- {"/redfish/v1/UpdateService/FirmwareInventory/mbmc", 0x00090000},
+- {"/redfish/v1/Chassis/Tray/Controls", 0x000c0000},
+- {"/redfish/v1/Chassis/Tray/Controls/bmc_pid", 0x000b0000},
+- {"/redfish/v1/Chassis/Tray/Controls/lat_pid", 0x000b0001},
+- {"/redfish/v1/Chassis/Tray/Controls/ioc_pid", 0x000b0002},
+- {"/redfish/v1/Chassis/Tray/Controls/vr_pid", 0x000b0003},
+- {"/redfish/v1/Chassis/Tray/Controls/powerbrick_pid", 0x000b0004},
+- {"/redfish/v1/Chassis/Tray/Controls/hdd_max_pid", 0x000b0005},
+- {"/redfish/v1/Chassis/Tray/Controls/hdd_avg_pid", 0x000b0006},
+- {"/redfish/v1/Chassis/Tray/Controls/fans", 0x000b0007},
+- {"/redfish/v1/Storage", 0x000d0000},
+- {"/redfish/v1/Storage/SATA", 0x000e0000},
+- {"/redfish/v1/Storage/SATA/Controllers", 0x000f0000},
+- {"/redfish/v1/Storage/SATA/Controllers/ioc", 0x00100000},
+- {"/redfish/v1/Managers/mbmc/ManagerDiagnosticData", 0x00110000}
+-};
+-
+-int getResourceIdForUri(std::string_view uri, uint32_t& resourceId)
+-{
+- auto it = resourceIdMap.find(uri);
+- if (it != resourceIdMap.end())
+- {
+- resourceId = it->second;
+- if (DEBUG)
+- {
+- std::cout << "Resource id found: " << std::to_string(it->second)
+- << "\n";
+- }
+- return 0;
+- }
+- if ((uri.find("Cables") == std::string::npos) &&
+- (uri.find("Systems") == std::string::npos))
+- {
+- std::cerr << "Resource id not found for uri: " << uri << std::endl;
+- }
+- return 1;
+-}
+diff --git a/rded/meson.build b/rded/meson.build
+index ca2b087..ae622d5 100644
+--- a/rded/meson.build
++++ b/rded/meson.build
+@@ -2,6 +2,7 @@ sources = [
+ 'rded.cpp',
+ 'helper/discovery/base_discovery.cpp',
+ 'helper/discovery/rde_discovery.cpp',
++ 'helper/discovery/platform_discovery.cpp',
+ 'helper/rde_operation/rde_operation.cpp',
+ 'helper/rde_operation/rde_update_utils.cpp'
+ ]
+diff --git a/rded/rded.cpp b/rded/rded.cpp
+index ecd83d0..bc367dc 100644
+--- a/rded/rded.cpp
++++ b/rded/rded.cpp
+@@ -1,16 +1,16 @@
+ #include "common/utils.hpp"
+ #include "helper/common.hpp"
+ #include "helper/discovery/base_discovery.hpp"
++#include "helper/discovery/platform_discovery.hpp"
+ #include "helper/discovery/rde_discovery.hpp"
+ #include "helper/rde_operation/rde_operation.hpp"
+-#include "helper/resource_id_mapper.hpp"
+
+ // libbej
+ #include "libbej/bej_common.h"
+ #include "libbej/bej_encoder_core.h"
+
+ #include "libbej/bej_encoder_json.hpp"
+-#include <csignal>
++
+ #include <locale.h>
+ #include <signal.h>
+ #include <string.h>
+@@ -29,6 +29,7 @@
+ #include <sdbusplus/unpack_properties.hpp>
+ #include <sdeventplus/event.hpp>
+
++#include <csignal>
+ #include <cstddef>
+ #include <iostream>
+ #include <unordered_map>
+@@ -60,11 +61,41 @@ std::unordered_map<std::string,
+ dbusIntfMap;
+ std::unordered_map<std::string, std::string> objectPathDeviceId;
+
++std::unordered_map<std::string, std::unordered_map<std::string, uint32_t>>
++ rdeResourceIdMap;
++
++static int getResourceIdForUri(std::string& uri, std::string& udevId,
++ uint32_t& resourceId)
++{
++ if (rdeResourceIdMap.find(udevId) != rdeResourceIdMap.end())
++ {
++ std::unordered_map<std::string, uint32_t>::iterator it =
++ rdeResourceIdMap[udevId].find(uri);
++ if (it != rdeResourceIdMap[udevId].end())
++ {
++ resourceId = it->second;
++ if (DEBUG)
++ {
++ std::cout << "Resource id found: " << std::to_string(it->second)
++ << "\n";
++ }
++ return 0;
++ }
++ }
++
++ if ((uri.find("Cables") == std::string::npos) &&
++ (uri.find("Systems") == std::string::npos))
++ {
++ std::cerr << "Resource id not found for uri: " << uri << std::endl;
++ }
++ return 1;
++}
++
+ void cleanupAtExit()
+ {
+ // cleans up at daemon termination
+ fd = 0;
+- resourceIdMap.clear();
++ rdeResourceIdMap.clear();
+ deviceNetIdMap.clear();
+ dbusIntfMap.clear();
+ objectPathDeviceId.clear();
+@@ -74,7 +105,8 @@ void cleanupAtExit()
+ cleanupMctpAtExit();
+ }
+
+-void signalHandler(int signal) {
++void signalHandler(int signal)
++{
+ std::cerr << "Received signal " << signal << ". Cleaning up...\n";
+ cleanupAtExit();
+ std::exit(signal);
+@@ -96,7 +128,30 @@ int initiateDiscovery(int fd, std::string udevId, int netId, uint8_t destEid,
+ }
+
+ std::cerr << "Initializing RDE Discovery...\n";
+- rc = performRdeDiscovery(udevId, fd, netId, destEid, instanceId);
++ uint32_t negotiatedTransferSize = 0;
++ rc = performRdeDiscovery(udevId, fd, netId, destEid, instanceId,
++ negotiatedTransferSize);
++
++ if (rc)
++ {
++ std::cerr << "Failure in Base Discovery with error code: " << rc
++ << "\n";
++ return rc;
++ }
++
++ std::unordered_map<std::string, uint32_t> resourceIdMap;
++ rdeResourceIdMap.emplace(std::make_pair(udevId, std::move(resourceIdMap)));
++ auto it = rdeResourceIdMap.find(udevId);
++ if (it == rdeResourceIdMap.end())
++ {
++ std::cerr << "Failed to find Resource ID map for " << udevId
++ << " device" << std::endl;
++ return -1;
++ }
++
++ std::cerr << "Initializing PDR Discovery...\n";
++ rc = performPdrDiscovery(udevId, fd, netId, destEid, instanceId,
++ negotiatedTransferSize, it->second);
+
+ if (rc)
+ {
+@@ -105,7 +160,8 @@ int initiateDiscovery(int fd, std::string udevId, int netId, uint8_t destEid,
+ return rc;
+ }
+
+- rc = performDictionaryDiscoveryForDevice(udevId, fd, destEid, instanceId);
++ rc = performDictionaryDiscoveryForDevice(udevId, fd, destEid, instanceId,
++ it->second);
+
+ if (rc)
+ {
+@@ -310,7 +366,7 @@ std::string
+ }
+ truncateTrailingFwSlash(uri);
+
+- rc = getResourceIdForUri(uri, resourceId);
++ rc = getResourceIdForUri(uri, udevid, resourceId);
+ if (rc)
+ {
+ // TODO(@harshtya) - Define operation Types to be GET or POST
+@@ -336,7 +392,7 @@ std::string
+
+ if (isActionOperation(uri, resource_uri))
+ {
+- rc = getResourceIdForUri(resource_uri, resourceId);
++ rc = getResourceIdForUri(resource_uri, udevid, resourceId);
+ if (rc)
+ {
+ std::cerr
+@@ -654,6 +710,8 @@ int triggerRdeReactor(int fd)
+ {
+ cleanupDictionaries(deviceId);
+ cleanupMctpLink(deviceId);
++ // Remove the resource ID maps for the rde device
++ rdeResourceIdMap.erase(deviceId);
+ }
+ // TODO (@harshtya): clean up the manager for this object path
+ // TODO (@harshtya): clean up the dictionaries
+--
+2.47.0.277.g8800431eea-goog
+
diff --git a/recipes-phosphor/pldm/pldm_%.bbappend b/recipes-phosphor/pldm/pldm_%.bbappend
index af23030..9ae0cb4 100644
--- a/recipes-phosphor/pldm/pldm_%.bbappend
+++ b/recipes-phosphor/pldm/pldm_%.bbappend
@@ -22,6 +22,7 @@
file://0012-Update-rde-resource-map.patch \
file://0013-Use-Rde-Op-Enumerate-to-recover-BMC-RDE-device-commu.patch \
file://0014-rded-support-redfish-expand-feature-for-RDE-Devices.patch \
+ file://0015-Add-Redfish-PDR-support.patch \
"
