blob: 7b73a819f80ebdd72f609ba83447fb14da4e0f78 [file] [log] [blame]
#include "fru.hpp"
#include "utils.hpp"
#include <systemd/sd-journal.h>
#include <boost/crc.hpp>
#include <iostream>
#include <sdbusplus/bus.hpp>
#include <set>
namespace pldm
{
namespace responder
{
FruImpl::FruImpl(const std::string& configPath)
{
fru_parser::FruParser handle(configPath);
fru_parser::DBusLookupInfo dbusInfo;
// Read the all the inventory D-Bus objects
auto& bus = pldm::utils::DBusHandler::getBus();
dbus::ObjectValueTree objects;
try
{
dbusInfo = handle.inventoryLookup();
auto method = bus.new_method_call(
std::get<0>(dbusInfo).c_str(), std::get<1>(dbusInfo).c_str(),
"org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
auto reply = bus.call(method);
reply.read(objects);
}
catch (const std::exception& e)
{
std::cerr << "Look up of inventory objects failed and PLDM FRU table "
"creation failed";
return;
}
// Populate all the interested Item types to a map for easy lookup
std::set<dbus::Interface> itemIntfsLookup;
auto itemIntfs = std::get<2>(dbusInfo);
std::transform(std::begin(itemIntfs), std::end(itemIntfs),
std::inserter(itemIntfsLookup, itemIntfsLookup.end()),
[](dbus::Interface intf) { return intf; });
for (const auto& object : objects)
{
const auto& interfaces = object.second;
for (const auto& interface : interfaces)
{
if (itemIntfsLookup.find(interface.first) != itemIntfsLookup.end())
{
// An exception will be thrown by getRecordInfo, if the item
// D-Bus interface name specified in FRU_Master.json does
// not have corresponding config jsons
try
{
auto recordInfos = handle.getRecordInfo(interface.first);
populateRecords(interfaces, recordInfos);
}
catch (const std::exception& e)
{
std::cout << "Config JSONs missing for the item "
"interface type, interface = "
<< interface.first << "\n";
break;
}
}
}
}
if (table.size())
{
padBytes = utils::getNumPadBytes(table.size());
table.resize(table.size() + padBytes, 0);
// Calculate the checksum
boost::crc_32_type result;
result.process_bytes(table.data(), table.size());
checksum = result.checksum();
}
}
void FruImpl::populateRecords(
const pldm::responder::dbus::InterfaceMap& interfaces,
const fru_parser::FruRecordInfos& recordInfos)
{
// recordSetIdentifier for the FRU will be set when the first record gets
// added for the FRU
uint16_t recordSetIdentifier = 0;
auto numRecsCount = numRecs;
for (auto const& [recType, encType, fieldInfos] : recordInfos)
{
std::vector<uint8_t> tlvs;
uint8_t numFRUFields = 0;
for (auto const& [intf, prop, propType, fieldTypeNum] : fieldInfos)
{
try
{
auto propValue = interfaces.at(intf).at(prop);
if (propType == "bytearray")
{
auto byteArray = std::get<std::vector<uint8_t>>(propValue);
if (!byteArray.size())
{
continue;
}
numFRUFields++;
tlvs.emplace_back(fieldTypeNum);
tlvs.emplace_back(byteArray.size());
std::move(std::begin(byteArray), std::end(byteArray),
std::back_inserter(tlvs));
}
else if (propType == "string")
{
auto str = std::get<std::string>(propValue);
if (!str.size())
{
continue;
}
numFRUFields++;
tlvs.emplace_back(fieldTypeNum);
tlvs.emplace_back(str.size());
std::move(std::begin(str), std::end(str),
std::back_inserter(tlvs));
}
}
catch (const std::out_of_range& e)
{
continue;
}
}
if (tlvs.size())
{
if (numRecs == numRecsCount)
{
recordSetIdentifier = nextRSI();
}
auto curSize = table.size();
table.resize(curSize + recHeaderSize + tlvs.size());
encode_fru_record(table.data(), table.size(), &curSize,
recordSetIdentifier, recType, numFRUFields,
encType, tlvs.data(), tlvs.size());
numRecs++;
}
}
}
void FruImpl::getFRUTable(Response& response)
{
auto hdrSize = response.size();
response.resize(hdrSize + table.size() + sizeof(checksum), 0);
std::copy(table.begin(), table.end(), response.begin() + hdrSize);
// Copy the checksum to response data
auto iter = response.begin() + hdrSize + table.size();
std::copy_n(reinterpret_cast<const uint8_t*>(&checksum), sizeof(checksum),
iter);
}
namespace fru
{
Response Handler::getFRURecordTableMetadata(const pldm_msg* request,
size_t /*payloadLength*/)
{
constexpr uint8_t major = 0x01;
constexpr uint8_t minor = 0x00;
constexpr uint32_t maxSize = 0xFFFFFFFF;
Response response(sizeof(pldm_msg_hdr) +
PLDM_GET_FRU_RECORD_TABLE_METADATA_RESP_BYTES,
0);
auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
auto rc = encode_get_fru_record_table_metadata_resp(
request->hdr.instance_id, PLDM_SUCCESS, major, minor, maxSize,
impl.size(), impl.numRSI(), impl.numRecords(), impl.checkSum(),
responsePtr);
if (rc != PLDM_SUCCESS)
{
return ccOnlyResponse(request, rc);
}
return response;
}
Response Handler::getFRURecordTable(const pldm_msg* request,
size_t payloadLength)
{
if (payloadLength != PLDM_GET_FRU_RECORD_TABLE_REQ_BYTES)
{
return ccOnlyResponse(request, PLDM_ERROR_INVALID_LENGTH);
}
Response response(
sizeof(pldm_msg_hdr) + PLDM_GET_FRU_RECORD_TABLE_MIN_RESP_BYTES, 0);
auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
auto rc =
encode_get_fru_record_table_resp(request->hdr.instance_id, PLDM_SUCCESS,
0, PLDM_START_AND_END, responsePtr);
if (rc != PLDM_SUCCESS)
{
return ccOnlyResponse(request, rc);
}
impl.getFRUTable(response);
return response;
}
} // namespace fru
} // namespace responder
} // namespace pldm