src/mdrv2.cpp - openbmc/smbios-mdr - Gitiles

 /*
 // Copyright (c) 2018 Intel Corporation
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 */

 #include "mdrv2.hpp"

 #include "pcieslot.hpp"

 #include <sys/mman.h>

 #include <phosphor-logging/elog-errors.hpp>
 #include <sdbusplus/exception.hpp>
 #include <xyz/openbmc_project/Smbios/MDR_V2/error.hpp>

 #include <fstream>

 namespace phosphor
 {
 namespace smbios
 {

 std::vector<uint8_t> MDR_V2::getDirectoryInformation(uint8_t dirIndex)
 {
     std::vector<uint8_t> responseDir;

     std::ifstream smbiosFile(mdrType2File, std::ios_base::binary);
     if (!smbiosFile.good())
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "Read data from flash error - Open MDRV2 table file failure");
         throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
             InvalidParameter();
     }
     if (dirIndex > smbiosDir.dirEntries)
     {
         responseDir.push_back(0);
         throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
             InvalidParameter();
     }
     responseDir.push_back(mdr2Version);
     responseDir.push_back(smbiosDir.dirVersion);
     uint8_t returnedEntries = smbiosDir.dirEntries - dirIndex;
     responseDir.push_back(returnedEntries);
     if ((dirIndex + returnedEntries) >= smbiosDir.dirEntries)
     {
         responseDir.push_back(0);
     }
     else
     {
         responseDir.push_back(smbiosDir.dirEntries - dirIndex -
                               returnedEntries);
     }
     for (uint8_t index = dirIndex; index < smbiosDir.dirEntries; index++)
     {
         for (uint8_t indexId = 0; indexId < sizeof(DataIdStruct); indexId++)
         {
             responseDir.push_back(
                 smbiosDir.dir[index].common.id.dataInfo[indexId]);
         }
     }

     return responseDir;
 }

 bool MDR_V2::smbiosIsAvailForUpdate(uint8_t index)
 {
     bool ret = false;
     if (index >= maxDirEntries)
     {
         return ret;
     }

     switch (smbiosDir.dir[index].stage)
     {
         case MDR2SMBIOSStatusEnum::mdr2Updating:
             ret = false;
             break;

         case MDR2SMBIOSStatusEnum::mdr2Init:
             // This *looks* like there should be a break statement here,
             // as the effects of the previous statement are a noop given
             // the following code that this falls through to.
             // We've elected not to change it, though, since it's been
             // this way since the old generation, and it would affect
             // the way the code functions.
             // If it ain't broke, don't fix it.

         case MDR2SMBIOSStatusEnum::mdr2Loaded:
         case MDR2SMBIOSStatusEnum::mdr2Updated:
             if (smbiosDir.dir[index].lock == MDR2DirLockEnum::mdr2DirLock)
             {
                 ret = false;
             }
             else
             {
                 ret = true;
             }
             break;

         default:
             break;
     }

     return ret;
 }

 std::vector<uint8_t> MDR_V2::getDataOffer()
 {
     std::vector<uint8_t> offer(sizeof(DataIdStruct));
     if (smbiosIsAvailForUpdate(0))
     {
         std::copy(smbiosDir.dir[0].common.id.dataInfo,
                   &smbiosDir.dir[0].common.id.dataInfo[16], offer.data());
     }
     else
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "smbios is not ready for update");
         throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
             UpdateInProgress();
     }
     return offer;
 }

 inline uint8_t MDR_V2::smbiosValidFlag(uint8_t index)
 {
     FlagStatus ret = FlagStatus::flagIsInvalid;
     MDR2SMBIOSStatusEnum stage = smbiosDir.dir[index].stage;
     MDR2DirLockEnum lock = smbiosDir.dir[index].lock;

     switch (stage)
     {
         case MDR2SMBIOSStatusEnum::mdr2Loaded:
         case MDR2SMBIOSStatusEnum::mdr2Updated:
             if (lock == MDR2DirLockEnum::mdr2DirLock)
             {
                 ret = FlagStatus::flagIsLocked; // locked
             }
             else
             {
                 ret = FlagStatus::flagIsValid; // valid
             }
             break;

         case MDR2SMBIOSStatusEnum::mdr2Updating:
         case MDR2SMBIOSStatusEnum::mdr2Init:
             ret = FlagStatus::flagIsInvalid; // invalid
             break;

         default:
             break;
     }

     return static_cast<uint8_t>(ret);
 }

 // If source variable size is 4 bytes (uint32_t) and destination is Vector type
 // is 1 byte (uint8_t), then by using this API can copy data byte by byte. For
 // Example copying data from smbiosDir.dir[idIndex].common.size and
 // smbiosDir.dir[idIndex].common.timestamp to vector variable responseInfo
 template <typename T>
 void appendReversed(std::vector<uint8_t>& vector, const T& value)
 {
     auto data = reinterpret_cast<const uint8_t*>(&value);
     std::reverse_copy(data, data + sizeof(value), std::back_inserter(vector));
 }

 std::vector<uint8_t> MDR_V2::getDataInformation(uint8_t idIndex)
 {
     std::vector<uint8_t> responseInfo;
     responseInfo.push_back(mdr2Version);

     if (idIndex >= maxDirEntries)
     {
         throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
             InvalidParameter();
     }

     for (uint8_t index = 0; index < sizeof(DataIdStruct); index++)
     {
         responseInfo.push_back(
             smbiosDir.dir[idIndex].common.id.dataInfo[index]);
     }

     responseInfo.push_back(smbiosValidFlag(idIndex));
     appendReversed(responseInfo, smbiosDir.dir[idIndex].common.size);
     responseInfo.push_back(smbiosDir.dir[idIndex].common.dataVersion);
     appendReversed(responseInfo, smbiosDir.dir[idIndex].common.timestamp);

     return responseInfo;
 }

 bool MDR_V2::readDataFromFlash(MDRSMBIOSHeader* mdrHdr, uint8_t* data)
 {
     if (mdrHdr == nullptr)
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "Read data from flash error - Invalid mdr header");
         return false;
     }
     if (data == nullptr)
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "Read data from flash error - Invalid data point");
         return false;
     }
     std::ifstream smbiosFile(mdrType2File, std::ios_base::binary);
     if (!smbiosFile.good())
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "Read data from flash error - Open MDRV2 table file failure");
         return false;
     }
     smbiosFile.clear();
     smbiosFile.seekg(0, std::ios_base::end);
     int fileLength = smbiosFile.tellg();
     smbiosFile.seekg(0, std::ios_base::beg);
     if (fileLength < sizeof(MDRSMBIOSHeader))
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "MDR V2 file size is smaller than mdr header");
         return false;
     }
     smbiosFile.read(reinterpret_cast<char*>(mdrHdr), sizeof(MDRSMBIOSHeader));
     if (mdrHdr->dataSize > smbiosTableStorageSize)
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "Data size out of limitation");
         smbiosFile.close();
         return false;
     }
     fileLength -= sizeof(MDRSMBIOSHeader);
     if (fileLength < mdrHdr->dataSize)
     {
         smbiosFile.read(reinterpret_cast<char*>(data), fileLength);
     }
     else
     {
         smbiosFile.read(reinterpret_cast<char*>(data), mdrHdr->dataSize);
     }
     smbiosFile.close();
     return true;
 }

 bool MDR_V2::sendDirectoryInformation(uint8_t dirVersion, uint8_t dirIndex,
                                       uint8_t returnedEntries,
                                       uint8_t remainingEntries,
                                       std::vector<uint8_t> dirEntry)
 {
     bool teminate = false;
     if ((dirIndex >= maxDirEntries) || (returnedEntries < 1))
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "Send Dir info failed - input parameter invalid");
         throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
             InvalidParameter();
     }
     if ((static_cast<size_t>(returnedEntries) * sizeof(DataIdStruct)) !=
         dirEntry.size())
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "Directory size invalid");
         throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
             InvalidParameter();
     }
     if (dirVersion == smbiosDir.dirVersion)
     {
         teminate = true;
     }
     else
     {
         if (remainingEntries > 0)
         {
             teminate = false;
         }
         else
         {
             teminate = true;
             smbiosDir.dirVersion = dirVersion;
         }
         uint8_t idIndex = dirIndex;
         smbiosDir.dirEntries = returnedEntries;

         uint8_t* pData = dirEntry.data();
         if (pData == nullptr)
         {
             return false;
         }
         for (uint8_t index = 0; index < returnedEntries; index++)
         {
             auto data = reinterpret_cast<const DataIdStruct*>(pData);
             std::copy(data->dataInfo, data->dataInfo + sizeof(DataIdStruct),
                       smbiosDir.dir[idIndex + index].common.id.dataInfo);
             pData += sizeof(DataIdStruct);
         }
     }
     return teminate;
 }

 bool MDR_V2::sendDataInformation(uint8_t idIndex, uint8_t flag,
                                  uint32_t dataLen, uint32_t dataVer,
                                  uint32_t timeStamp)
 {
     if (idIndex >= maxDirEntries)
     {
         throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
             InvalidParameter();
     }
     int entryChanged = 0;
     if (smbiosDir.dir[idIndex].common.dataSetSize != dataLen)
     {
         entryChanged++;
         smbiosDir.dir[idIndex].common.dataSetSize = dataLen;
     }

     if (smbiosDir.dir[idIndex].common.dataVersion != dataVer)
     {
         entryChanged++;
         smbiosDir.dir[idIndex].common.dataVersion = dataVer;
     }

     if (smbiosDir.dir[idIndex].common.timestamp != timeStamp)
     {
         entryChanged++;
         smbiosDir.dir[idIndex].common.timestamp = timeStamp;
     }
     if (entryChanged == 0)
     {
         return false;
     }
     return true;
 }

 int MDR_V2::findIdIndex(std::vector<uint8_t> dataInfo)
 {
     if (dataInfo.size() != sizeof(DataIdStruct))
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "Length of dataInfo invalid");
         throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
             InvalidId();
     }
     std::array<uint8_t, 16> arrayDataInfo;

     std::copy(dataInfo.begin(), dataInfo.end(), arrayDataInfo.begin());

     for (int index = 0; index < smbiosDir.dirEntries; index++)
     {
         int info = 0;
         for (; info < arrayDataInfo.size(); info++)
         {
             if (arrayDataInfo[info] !=
                 smbiosDir.dir[index].common.id.dataInfo[info])
             {
                 break;
             }
         }
         if (info == arrayDataInfo.size())
         {
             return index;
         }
     }
     throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::InvalidId();
 }

 uint8_t MDR_V2::directoryEntries(uint8_t value)
 {
     std::ifstream smbiosFile(mdrType2File, std::ios_base::binary);
     if (!smbiosFile.good())
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "Read data from flash error - Open MDRV2 table file failure");
         value = 0;
     }
     else
     {
         value = smbiosDir.dirEntries;
     }
     return sdbusplus::xyz::openbmc_project::Smbios::server::MDR_V2::
         directoryEntries(value);
 }

 void MDR_V2::systemInfoUpdate()
 {
     std::string motherboardPath;
     auto method = bus.new_method_call(mapperBusName, mapperPath,
                                       mapperInterface, "GetSubTreePaths");
     method.append(systemInterfacePath);
     method.append(0);
     method.append(std::vector<std::string>({systemInterface}));
     try
     {
         std::vector<std::string> paths;
         sdbusplus::message_t reply = bus.call(method);
         reply.read(paths);
         if (paths.size() < 1)
         {
             phosphor::logging::log<phosphor::logging::level::ERR>(
                 "Failed to get system motherboard dbus path.");
         }
         else
         {
             motherboardPath = std::move(paths[0]);
         }
     }
     catch (const sdbusplus::exception_t& e)
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "Failed to query system motherboard",
             phosphor::logging::entry("ERROR=%s", e.what()));
     }

     cpus.clear();
     int num = getTotalCpuSlot();
     if (num == -1)
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "get cpu total slot failed");
         return;
     }

     for (int index = 0; index < num; index++)
     {
         std::string path = cpuPath + std::to_string(index);
         cpus.emplace_back(std::make_unique<phosphor::smbios::Cpu>(
             bus, path, index, smbiosDir.dir[smbiosDirIndex].dataStorage,
             motherboardPath));
     }

 #ifdef DIMM_DBUS

     dimms.clear();

     num = getTotalDimmSlot();
     if (num == -1)
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "get dimm total slot failed");
         return;
     }

     for (int index = 0; index < num; index++)
     {
         std::string path = dimmPath + std::to_string(index);
         dimms.emplace_back(std::make_unique<phosphor::smbios::Dimm>(
             bus, path, index, smbiosDir.dir[smbiosDirIndex].dataStorage,
             motherboardPath));
     }

 #endif

     pcies.clear();
     num = getTotalPcieSlot();
     if (num == -1)
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "get pcie total slot failed");
         return;
     }

     for (int index = 0; index < num; index++)
     {
         std::string path = pciePath + std::to_string(index);
         pcies.emplace_back(std::make_unique<phosphor::smbios::Pcie>(
             bus, path, index, smbiosDir.dir[smbiosDirIndex].dataStorage,
             motherboardPath));
     }

     system.reset();
     system = std::make_unique<System>(
         bus, systemPath, smbiosDir.dir[smbiosDirIndex].dataStorage);
 }

 int MDR_V2::getTotalCpuSlot()
 {
     uint8_t* dataIn = smbiosDir.dir[smbiosDirIndex].dataStorage;
     int num = 0;

     if (dataIn == nullptr)
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "get cpu total slot failed - no storage data");
         return -1;
     }

     while (1)
     {
         dataIn = getSMBIOSTypePtr(dataIn, processorsType);
         if (dataIn == nullptr)
         {
             break;
         }
         num++;
         dataIn = smbiosNextPtr(dataIn);
         if (dataIn == nullptr)
         {
             break;
         }
         if (num >= limitEntryLen)
         {
             break;
         }
     }

     return num;
 }

 int MDR_V2::getTotalDimmSlot()
 {
     uint8_t* dataIn = smbiosDir.dir[smbiosDirIndex].dataStorage;
     uint8_t num = 0;

     if (dataIn == nullptr)
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "Fail to get dimm total slot - no storage data");
         return -1;
     }

     while (1)
     {
         dataIn = getSMBIOSTypePtr(dataIn, memoryDeviceType);
         if (dataIn == nullptr)
         {
             break;
         }
         num++;
         dataIn = smbiosNextPtr(dataIn);
         if (dataIn == nullptr)
         {
             break;
         }
         if (num >= limitEntryLen)
         {
             break;
         }
     }

     return num;
 }

 int MDR_V2::getTotalPcieSlot()
 {
     uint8_t* dataIn = smbiosDir.dir[smbiosDirIndex].dataStorage;
     int num = 0;

     if (dataIn == nullptr)
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "Fail to get total system slot - no storage data");
         return -1;
     }

     while (1)
     {
         dataIn = getSMBIOSTypePtr(dataIn, systemSlots);
         if (dataIn == nullptr)
         {
             break;
         }

         /* System slot type offset. Check if the slot is a PCIE slots. All
          * PCIE slot type are hardcoded in a table.
          */
         if (pcieSmbiosType.find(*(dataIn + 5)) != pcieSmbiosType.end())
         {
             num++;
         }
         dataIn = smbiosNextPtr(dataIn);
         if (dataIn == nullptr)
         {
             break;
         }
         if (num >= limitEntryLen)
         {
             break;
         }
     }

     return num;
 }

 bool MDR_V2::checkSMBIOSVersion(uint8_t* dataIn)
 {
     const std::string anchorString21 = "_SM_";
     const std::string anchorString30 = "_SM3_";
     std::string buffer(dataIn, dataIn + smbiosTableStorageSize);

     auto it = std::search(std::begin(buffer), std::end(buffer),
                           std::begin(anchorString21), std::end(anchorString21));
     bool smbios21Found = it != std::end(buffer);
     if (!smbios21Found)
     {
         phosphor::logging::log<phosphor::logging::level::INFO>(
             "SMBIOS 2.1 Anchor String not found. Looking for SMBIOS 3.0");
         it = std::search(std::begin(buffer), std::end(buffer),
                          std::begin(anchorString30), std::end(anchorString30));
         if (it == std::end(buffer))
         {
             phosphor::logging::log<phosphor::logging::level::ERR>(
                 "SMBIOS 2.1 and 3.0 Anchor Strings not found");
             return false;
         }
     }

     auto pos = std::distance(std::begin(buffer), it);
     auto length = smbiosTableStorageSize - pos;
     uint8_t foundMajorVersion;
     uint8_t foundMinorVersion;

     if (smbios21Found)
     {
         if (length < sizeof(EntryPointStructure21))
         {
             phosphor::logging::log<phosphor::logging::level::ERR>(
                 "Invalid entry point structure for SMBIOS 2.1");
             return false;
         }

         auto epStructure =
             reinterpret_cast<const EntryPointStructure21*>(&dataIn[pos]);
         foundMajorVersion = epStructure->smbiosVersion.majorVersion;
         foundMinorVersion = epStructure->smbiosVersion.minorVersion;
     }
     else
     {
         if (length < sizeof(EntryPointStructure30))
         {
             phosphor::logging::log<phosphor::logging::level::ERR>(
                 "Invalid entry point structure for SMBIOS 3.0");
             return false;
         }

         auto epStructure =
             reinterpret_cast<const EntryPointStructure30*>(&dataIn[pos]);
         foundMajorVersion = epStructure->smbiosVersion.majorVersion;
         foundMinorVersion = epStructure->smbiosVersion.minorVersion;
     }
     lg2::info("SMBIOS VERSION - {MAJOR}.{MINOR}", "MAJOR", foundMajorVersion,
               "MINOR", foundMinorVersion);

     auto itr = std::find_if(
         std::begin(supportedSMBIOSVersions), std::end(supportedSMBIOSVersions),
         [&](SMBIOSVersion versionItr) {
             return versionItr.majorVersion == foundMajorVersion &&
                    versionItr.minorVersion == foundMinorVersion;
         });
     if (itr == std::end(supportedSMBIOSVersions))
     {
         return false;
     }
     return true;
 }

 bool MDR_V2::agentSynchronizeData()
 {
     struct MDRSMBIOSHeader mdr2SMBIOS;
     bool status = readDataFromFlash(&mdr2SMBIOS,
                                     smbiosDir.dir[smbiosDirIndex].dataStorage);
     if (!status)
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "agent data sync failed - read data from flash failed");
         return false;
     }

     if (!checkSMBIOSVersion(smbiosDir.dir[smbiosDirIndex].dataStorage))
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "Unsupported SMBIOS table version");
         return false;
     }

     systemInfoUpdate();
     smbiosDir.dir[smbiosDirIndex].common.dataVersion = mdr2SMBIOS.dirVer;
     smbiosDir.dir[smbiosDirIndex].common.timestamp = mdr2SMBIOS.timestamp;
     smbiosDir.dir[smbiosDirIndex].common.size = mdr2SMBIOS.dataSize;
     smbiosDir.dir[smbiosDirIndex].stage = MDR2SMBIOSStatusEnum::mdr2Loaded;
     smbiosDir.dir[smbiosDirIndex].lock = MDR2DirLockEnum::mdr2DirUnlock;

     return true;
 }

 std::vector<uint32_t> MDR_V2::synchronizeDirectoryCommonData(uint8_t idIndex,
                                                              uint32_t size)
 {
     std::chrono::microseconds usec(
         defaultTimeout); // default lock time out is 2s
     std::vector<uint32_t> result;
     smbiosDir.dir[idIndex].common.size = size;
     result.push_back(smbiosDir.dir[idIndex].common.dataSetSize);
     result.push_back(smbiosDir.dir[idIndex].common.dataVersion);
     result.push_back(smbiosDir.dir[idIndex].common.timestamp);

     timer.expires_after(usec);
     timer.async_wait([this](boost::system::error_code ec) {
         if (ec || this == nullptr)
         {
             phosphor::logging::log<phosphor::logging::level::ERR>(
                 "Timer Error!");
             return;
         }
         agentSynchronizeData();
     });
     return result;
 }

 std::vector<boost::container::flat_map<std::string, RecordVariant>>
     MDR_V2::getRecordType(size_t type)
 {

     std::vector<boost::container::flat_map<std::string, RecordVariant>> ret;
     if (type == memoryDeviceType)
     {

         uint8_t* dataIn = smbiosDir.dir[smbiosDirIndex].dataStorage;

         if (dataIn == nullptr)
         {
             throw std::runtime_error("Data not populated");
         }

         do
         {
             dataIn =
                 getSMBIOSTypePtr(dataIn, memoryDeviceType, sizeof(MemoryInfo));
             if (dataIn == nullptr)
             {
                 break;
             }
             boost::container::flat_map<std::string, RecordVariant>& record =
                 ret.emplace_back();

             auto memoryInfo = reinterpret_cast<MemoryInfo*>(dataIn);

             record["Type"] = memoryInfo->type;
             record["Length"] = memoryInfo->length;
             record["Handle"] = uint16_t(memoryInfo->handle);
             record["Physical Memory Array Handle"] =
                 uint16_t(memoryInfo->phyArrayHandle);
             record["Memory Error Information Handle"] =
                 uint16_t(memoryInfo->errInfoHandle);
             record["Total Width"] = uint16_t(memoryInfo->totalWidth);
             record["Data Width"] = uint16_t(memoryInfo->dataWidth);
             record["Size"] = uint16_t(memoryInfo->size);
             record["Form Factor"] = memoryInfo->formFactor;
             record["Device Set"] = memoryInfo->deviceSet;
             record["Device Locator"] = positionToString(
                 memoryInfo->deviceLocator, memoryInfo->length, dataIn);
             record["Bank Locator"] = positionToString(
                 memoryInfo->bankLocator, memoryInfo->length, dataIn);
             record["Memory Type"] = memoryInfo->memoryType;
             record["Type Detail"] = uint16_t(memoryInfo->typeDetail);
             record["Speed"] = uint16_t(memoryInfo->speed);
             record["Manufacturer"] = positionToString(
                 memoryInfo->manufacturer, memoryInfo->length, dataIn);
             record["Serial Number"] = positionToString(
                 memoryInfo->serialNum, memoryInfo->length, dataIn);
             record["Asset Tag"] = positionToString(memoryInfo->assetTag,
                                                    memoryInfo->length, dataIn);
             record["Part Number"] = positionToString(
                 memoryInfo->partNum, memoryInfo->length, dataIn);
             record["Attributes"] = memoryInfo->attributes;
             record["Extended Size"] = uint32_t(memoryInfo->extendedSize);
             record["Configured Memory Speed"] =
                 uint32_t(memoryInfo->confClockSpeed);
             record["Minimum voltage"] = uint16_t(memoryInfo->minimumVoltage);
             record["Maximum voltage"] = uint16_t(memoryInfo->maximumVoltage);
             record["Configured voltage"] =
                 uint16_t(memoryInfo->configuredVoltage);
             record["Memory Technology"] = memoryInfo->memoryTechnology;
             record["Memory Operating Mode Capabilty"] =
                 uint16_t(memoryInfo->memoryOperatingModeCap);
             record["Firmare Version"] = memoryInfo->firwareVersion;
             record["Module Manufacturer ID"] =
                 uint16_t(memoryInfo->modelManufId);
             record["Module Product ID"] = uint16_t(memoryInfo->modelProdId);
             record["Memory Subsystem Controller Manufacturer ID"] =
                 uint16_t(memoryInfo->memSubConManufId);
             record["Memory Subsystem Controller Product Id"] =
                 uint16_t(memoryInfo->memSubConProdId);
             record["Non-volatile Size"] = uint64_t(memoryInfo->nvSize);
             record["Volatile Size"] = uint64_t(memoryInfo->volatileSize);
             record["Cache Size"] = uint64_t(memoryInfo->cacheSize);
             record["Logical Size"] = uint64_t(memoryInfo->logicalSize);
         } while ((dataIn = smbiosNextPtr(dataIn)) != nullptr);

         return ret;
     }

     throw std::invalid_argument("Invalid record type");
     return ret;
 }

 } // namespace smbios
 } // namespace phosphor
	/*
	// Copyright (c) 2018 Intel Corporation
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.
	*/

	#include "mdrv2.hpp"

	#include "pcieslot.hpp"

	#include <sys/mman.h>

	#include <phosphor-logging/elog-errors.hpp>
	#include <sdbusplus/exception.hpp>
	#include <xyz/openbmc_project/Smbios/MDR_V2/error.hpp>

	#include <fstream>

	namespace phosphor
	{
	namespace smbios
	{

	std::vector<uint8_t> MDR_V2::getDirectoryInformation(uint8_t dirIndex)
	{
	std::vector<uint8_t> responseDir;

	std::ifstream smbiosFile(mdrType2File, std::ios_base::binary);
	if (!smbiosFile.good())
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"Read data from flash error - Open MDRV2 table file failure");
	throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
	InvalidParameter();
	}
	if (dirIndex > smbiosDir.dirEntries)
	{
	responseDir.push_back(0);
	throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
	InvalidParameter();
	}
	responseDir.push_back(mdr2Version);
	responseDir.push_back(smbiosDir.dirVersion);
	uint8_t returnedEntries = smbiosDir.dirEntries - dirIndex;
	responseDir.push_back(returnedEntries);
	if ((dirIndex + returnedEntries) >= smbiosDir.dirEntries)
	{
	responseDir.push_back(0);
	}
	else
	{
	responseDir.push_back(smbiosDir.dirEntries - dirIndex -
	returnedEntries);
	}
	for (uint8_t index = dirIndex; index < smbiosDir.dirEntries; index++)
	{
	for (uint8_t indexId = 0; indexId < sizeof(DataIdStruct); indexId++)
	{
	responseDir.push_back(
	smbiosDir.dir[index].common.id.dataInfo[indexId]);
	}
	}

	return responseDir;
	}

	bool MDR_V2::smbiosIsAvailForUpdate(uint8_t index)
	{
	bool ret = false;
	if (index >= maxDirEntries)
	{
	return ret;
	}

	switch (smbiosDir.dir[index].stage)
	{
	case MDR2SMBIOSStatusEnum::mdr2Updating:
	ret = false;
	break;

	case MDR2SMBIOSStatusEnum::mdr2Init:
	// This looks like there should be a break statement here,
	// as the effects of the previous statement are a noop given
	// the following code that this falls through to.
	// We've elected not to change it, though, since it's been
	// this way since the old generation, and it would affect
	// the way the code functions.
	// If it ain't broke, don't fix it.

	case MDR2SMBIOSStatusEnum::mdr2Loaded:
	case MDR2SMBIOSStatusEnum::mdr2Updated:
	if (smbiosDir.dir[index].lock == MDR2DirLockEnum::mdr2DirLock)
	{
	ret = false;
	}
	else
	{
	ret = true;
	}
	break;

	default:
	break;
	}

	return ret;
	}

	std::vector<uint8_t> MDR_V2::getDataOffer()
	{
	std::vector<uint8_t> offer(sizeof(DataIdStruct));
	if (smbiosIsAvailForUpdate(0))
	{
	std::copy(smbiosDir.dir[0].common.id.dataInfo,
	&smbiosDir.dir[0].common.id.dataInfo[16], offer.data());
	}
	else
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"smbios is not ready for update");
	throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
	UpdateInProgress();
	}
	return offer;
	}

	inline uint8_t MDR_V2::smbiosValidFlag(uint8_t index)
	{
	FlagStatus ret = FlagStatus::flagIsInvalid;
	MDR2SMBIOSStatusEnum stage = smbiosDir.dir[index].stage;
	MDR2DirLockEnum lock = smbiosDir.dir[index].lock;

	switch (stage)
	{
	case MDR2SMBIOSStatusEnum::mdr2Loaded:
	case MDR2SMBIOSStatusEnum::mdr2Updated:
	if (lock == MDR2DirLockEnum::mdr2DirLock)
	{
	ret = FlagStatus::flagIsLocked; // locked
	}
	else
	{
	ret = FlagStatus::flagIsValid; // valid
	}
	break;

	case MDR2SMBIOSStatusEnum::mdr2Updating:
	case MDR2SMBIOSStatusEnum::mdr2Init:
	ret = FlagStatus::flagIsInvalid; // invalid
	break;

	default:
	break;
	}

	return static_cast<uint8_t>(ret);
	}

	// If source variable size is 4 bytes (uint32_t) and destination is Vector type
	// is 1 byte (uint8_t), then by using this API can copy data byte by byte. For
	// Example copying data from smbiosDir.dir[idIndex].common.size and
	// smbiosDir.dir[idIndex].common.timestamp to vector variable responseInfo
	template <typename T>
	void appendReversed(std::vector<uint8_t>& vector, const T& value)
	{
	auto data = reinterpret_cast<const uint8_t*>(&value);
	std::reverse_copy(data, data + sizeof(value), std::back_inserter(vector));
	}

	std::vector<uint8_t> MDR_V2::getDataInformation(uint8_t idIndex)
	{
	std::vector<uint8_t> responseInfo;
	responseInfo.push_back(mdr2Version);

	if (idIndex >= maxDirEntries)
	{
	throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
	InvalidParameter();
	}

	for (uint8_t index = 0; index < sizeof(DataIdStruct); index++)
	{
	responseInfo.push_back(
	smbiosDir.dir[idIndex].common.id.dataInfo[index]);
	}

	responseInfo.push_back(smbiosValidFlag(idIndex));
	appendReversed(responseInfo, smbiosDir.dir[idIndex].common.size);
	responseInfo.push_back(smbiosDir.dir[idIndex].common.dataVersion);
	appendReversed(responseInfo, smbiosDir.dir[idIndex].common.timestamp);

	return responseInfo;
	}

	bool MDR_V2::readDataFromFlash(MDRSMBIOSHeader* mdrHdr, uint8_t* data)
	{
	if (mdrHdr == nullptr)
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"Read data from flash error - Invalid mdr header");
	return false;
	}
	if (data == nullptr)
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"Read data from flash error - Invalid data point");
	return false;
	}
	std::ifstream smbiosFile(mdrType2File, std::ios_base::binary);
	if (!smbiosFile.good())
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"Read data from flash error - Open MDRV2 table file failure");
	return false;
	}
	smbiosFile.clear();
	smbiosFile.seekg(0, std::ios_base::end);
	int fileLength = smbiosFile.tellg();
	smbiosFile.seekg(0, std::ios_base::beg);
	if (fileLength < sizeof(MDRSMBIOSHeader))
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"MDR V2 file size is smaller than mdr header");
	return false;
	}
	smbiosFile.read(reinterpret_cast<char*>(mdrHdr), sizeof(MDRSMBIOSHeader));
	if (mdrHdr->dataSize > smbiosTableStorageSize)
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"Data size out of limitation");
	smbiosFile.close();
	return false;
	}
	fileLength -= sizeof(MDRSMBIOSHeader);
	if (fileLength < mdrHdr->dataSize)
	{
	smbiosFile.read(reinterpret_cast<char*>(data), fileLength);
	}
	else
	{
	smbiosFile.read(reinterpret_cast<char*>(data), mdrHdr->dataSize);
	}
	smbiosFile.close();
	return true;
	}

	bool MDR_V2::sendDirectoryInformation(uint8_t dirVersion, uint8_t dirIndex,
	uint8_t returnedEntries,
	uint8_t remainingEntries,
	std::vector<uint8_t> dirEntry)
	{
	bool teminate = false;
	if ((dirIndex >= maxDirEntries) \|\| (returnedEntries < 1))
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"Send Dir info failed - input parameter invalid");
	throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
	InvalidParameter();
	}
	if ((static_cast<size_t>(returnedEntries) * sizeof(DataIdStruct)) !=
	dirEntry.size())
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"Directory size invalid");
	throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
	InvalidParameter();
	}
	if (dirVersion == smbiosDir.dirVersion)
	{
	teminate = true;
	}
	else
	{
	if (remainingEntries > 0)
	{
	teminate = false;
	}
	else
	{
	teminate = true;
	smbiosDir.dirVersion = dirVersion;
	}
	uint8_t idIndex = dirIndex;
	smbiosDir.dirEntries = returnedEntries;

	uint8_t* pData = dirEntry.data();
	if (pData == nullptr)
	{
	return false;
	}
	for (uint8_t index = 0; index < returnedEntries; index++)
	{
	auto data = reinterpret_cast<const DataIdStruct*>(pData);
	std::copy(data->dataInfo, data->dataInfo + sizeof(DataIdStruct),
	smbiosDir.dir[idIndex + index].common.id.dataInfo);
	pData += sizeof(DataIdStruct);
	}
	}
	return teminate;
	}

	bool MDR_V2::sendDataInformation(uint8_t idIndex, uint8_t flag,
	uint32_t dataLen, uint32_t dataVer,
	uint32_t timeStamp)
	{
	if (idIndex >= maxDirEntries)
	{
	throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
	InvalidParameter();
	}
	int entryChanged = 0;
	if (smbiosDir.dir[idIndex].common.dataSetSize != dataLen)
	{
	entryChanged++;
	smbiosDir.dir[idIndex].common.dataSetSize = dataLen;
	}

	if (smbiosDir.dir[idIndex].common.dataVersion != dataVer)
	{
	entryChanged++;
	smbiosDir.dir[idIndex].common.dataVersion = dataVer;
	}

	if (smbiosDir.dir[idIndex].common.timestamp != timeStamp)
	{
	entryChanged++;
	smbiosDir.dir[idIndex].common.timestamp = timeStamp;
	}
	if (entryChanged == 0)
	{
	return false;
	}
	return true;
	}

	int MDR_V2::findIdIndex(std::vector<uint8_t> dataInfo)
	{
	if (dataInfo.size() != sizeof(DataIdStruct))
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"Length of dataInfo invalid");
	throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
	InvalidId();
	}
	std::array<uint8_t, 16> arrayDataInfo;

	std::copy(dataInfo.begin(), dataInfo.end(), arrayDataInfo.begin());

	for (int index = 0; index < smbiosDir.dirEntries; index++)
	{
	int info = 0;
	for (; info < arrayDataInfo.size(); info++)
	{
	if (arrayDataInfo[info] !=
	smbiosDir.dir[index].common.id.dataInfo[info])
	{
	break;
	}
	}
	if (info == arrayDataInfo.size())
	{
	return index;
	}
	}
	throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::InvalidId();
	}

	uint8_t MDR_V2::directoryEntries(uint8_t value)
	{
	std::ifstream smbiosFile(mdrType2File, std::ios_base::binary);
	if (!smbiosFile.good())
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"Read data from flash error - Open MDRV2 table file failure");
	value = 0;
	}
	else
	{
	value = smbiosDir.dirEntries;
	}
	return sdbusplus::xyz::openbmc_project::Smbios::server::MDR_V2::
	directoryEntries(value);
	}

	void MDR_V2::systemInfoUpdate()
	{
	std::string motherboardPath;
	auto method = bus.new_method_call(mapperBusName, mapperPath,
	mapperInterface, "GetSubTreePaths");
	method.append(systemInterfacePath);
	method.append(0);
	method.append(std::vector<std::string>({systemInterface}));
	try
	{
	std::vector<std::string> paths;
	sdbusplus::message_t reply = bus.call(method);
	reply.read(paths);
	if (paths.size() < 1)
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"Failed to get system motherboard dbus path.");
	}
	else
	{
	motherboardPath = std::move(paths[0]);
	}
	}
	catch (const sdbusplus::exception_t& e)
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"Failed to query system motherboard",
	phosphor::logging::entry("ERROR=%s", e.what()));
	}

	cpus.clear();
	int num = getTotalCpuSlot();
	if (num == -1)
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"get cpu total slot failed");
	return;
	}

	for (int index = 0; index < num; index++)
	{
	std::string path = cpuPath + std::to_string(index);
	cpus.emplace_back(std::make_unique<phosphor::smbios::Cpu>(
	bus, path, index, smbiosDir.dir[smbiosDirIndex].dataStorage,
	motherboardPath));
	}

	#ifdef DIMM_DBUS

	dimms.clear();

	num = getTotalDimmSlot();
	if (num == -1)
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"get dimm total slot failed");
	return;
	}

	for (int index = 0; index < num; index++)
	{
	std::string path = dimmPath + std::to_string(index);
	dimms.emplace_back(std::make_unique<phosphor::smbios::Dimm>(
	bus, path, index, smbiosDir.dir[smbiosDirIndex].dataStorage,
	motherboardPath));
	}

	#endif

	pcies.clear();
	num = getTotalPcieSlot();
	if (num == -1)
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"get pcie total slot failed");
	return;
	}

	for (int index = 0; index < num; index++)
	{
	std::string path = pciePath + std::to_string(index);
	pcies.emplace_back(std::make_unique<phosphor::smbios::Pcie>(
	bus, path, index, smbiosDir.dir[smbiosDirIndex].dataStorage,
	motherboardPath));
	}

	system.reset();
	system = std::make_unique<System>(
	bus, systemPath, smbiosDir.dir[smbiosDirIndex].dataStorage);
	}

	int MDR_V2::getTotalCpuSlot()
	{
	uint8_t* dataIn = smbiosDir.dir[smbiosDirIndex].dataStorage;
	int num = 0;

	if (dataIn == nullptr)
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"get cpu total slot failed - no storage data");
	return -1;
	}

	while (1)
	{
	dataIn = getSMBIOSTypePtr(dataIn, processorsType);
	if (dataIn == nullptr)
	{
	break;
	}
	num++;
	dataIn = smbiosNextPtr(dataIn);
	if (dataIn == nullptr)
	{
	break;
	}
	if (num >= limitEntryLen)
	{
	break;
	}
	}

	return num;
	}

	int MDR_V2::getTotalDimmSlot()
	{
	uint8_t* dataIn = smbiosDir.dir[smbiosDirIndex].dataStorage;
	uint8_t num = 0;

	if (dataIn == nullptr)
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"Fail to get dimm total slot - no storage data");
	return -1;
	}

	while (1)
	{
	dataIn = getSMBIOSTypePtr(dataIn, memoryDeviceType);
	if (dataIn == nullptr)
	{
	break;
	}
	num++;
	dataIn = smbiosNextPtr(dataIn);
	if (dataIn == nullptr)
	{
	break;
	}
	if (num >= limitEntryLen)
	{
	break;
	}
	}

	return num;
	}

	int MDR_V2::getTotalPcieSlot()
	{
	uint8_t* dataIn = smbiosDir.dir[smbiosDirIndex].dataStorage;
	int num = 0;

	if (dataIn == nullptr)
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"Fail to get total system slot - no storage data");
	return -1;
	}

	while (1)
	{
	dataIn = getSMBIOSTypePtr(dataIn, systemSlots);
	if (dataIn == nullptr)
	{
	break;
	}

	/* System slot type offset. Check if the slot is a PCIE slots. All
	* PCIE slot type are hardcoded in a table.
	*/
	if (pcieSmbiosType.find(*(dataIn + 5)) != pcieSmbiosType.end())
	{
	num++;
	}
	dataIn = smbiosNextPtr(dataIn);
	if (dataIn == nullptr)
	{
	break;
	}
	if (num >= limitEntryLen)
	{
	break;
	}
	}

	return num;
	}

	bool MDR_V2::checkSMBIOSVersion(uint8_t* dataIn)
	{
	const std::string anchorString21 = "_SM_";
	const std::string anchorString30 = "_SM3_";
	std::string buffer(dataIn, dataIn + smbiosTableStorageSize);

	auto it = std::search(std::begin(buffer), std::end(buffer),
	std::begin(anchorString21), std::end(anchorString21));
	bool smbios21Found = it != std::end(buffer);
	if (!smbios21Found)
	{
	phosphor::logging::log<phosphor::logging::level::INFO>(
	"SMBIOS 2.1 Anchor String not found. Looking for SMBIOS 3.0");
	it = std::search(std::begin(buffer), std::end(buffer),
	std::begin(anchorString30), std::end(anchorString30));
	if (it == std::end(buffer))
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"SMBIOS 2.1 and 3.0 Anchor Strings not found");
	return false;
	}
	}

	auto pos = std::distance(std::begin(buffer), it);
	auto length = smbiosTableStorageSize - pos;
	uint8_t foundMajorVersion;
	uint8_t foundMinorVersion;

	if (smbios21Found)
	{
	if (length < sizeof(EntryPointStructure21))
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"Invalid entry point structure for SMBIOS 2.1");
	return false;
	}

	auto epStructure =
	reinterpret_cast<const EntryPointStructure21*>(&dataIn[pos]);
	foundMajorVersion = epStructure->smbiosVersion.majorVersion;
	foundMinorVersion = epStructure->smbiosVersion.minorVersion;
	}
	else
	{
	if (length < sizeof(EntryPointStructure30))
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"Invalid entry point structure for SMBIOS 3.0");
	return false;
	}

	auto epStructure =
	reinterpret_cast<const EntryPointStructure30*>(&dataIn[pos]);
	foundMajorVersion = epStructure->smbiosVersion.majorVersion;
	foundMinorVersion = epStructure->smbiosVersion.minorVersion;
	}
	lg2::info("SMBIOS VERSION - {MAJOR}.{MINOR}", "MAJOR", foundMajorVersion,
	"MINOR", foundMinorVersion);

	auto itr = std::find_if(
	std::begin(supportedSMBIOSVersions), std::end(supportedSMBIOSVersions),
	[&](SMBIOSVersion versionItr) {
	return versionItr.majorVersion == foundMajorVersion &&
	versionItr.minorVersion == foundMinorVersion;
	});
	if (itr == std::end(supportedSMBIOSVersions))
	{
	return false;
	}
	return true;
	}

	bool MDR_V2::agentSynchronizeData()
	{
	struct MDRSMBIOSHeader mdr2SMBIOS;
	bool status = readDataFromFlash(&mdr2SMBIOS,
	smbiosDir.dir[smbiosDirIndex].dataStorage);
	if (!status)
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"agent data sync failed - read data from flash failed");
	return false;
	}

	if (!checkSMBIOSVersion(smbiosDir.dir[smbiosDirIndex].dataStorage))
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"Unsupported SMBIOS table version");
	return false;
	}

	systemInfoUpdate();
	smbiosDir.dir[smbiosDirIndex].common.dataVersion = mdr2SMBIOS.dirVer;
	smbiosDir.dir[smbiosDirIndex].common.timestamp = mdr2SMBIOS.timestamp;
	smbiosDir.dir[smbiosDirIndex].common.size = mdr2SMBIOS.dataSize;
	smbiosDir.dir[smbiosDirIndex].stage = MDR2SMBIOSStatusEnum::mdr2Loaded;
	smbiosDir.dir[smbiosDirIndex].lock = MDR2DirLockEnum::mdr2DirUnlock;

	return true;
	}

	std::vector<uint32_t> MDR_V2::synchronizeDirectoryCommonData(uint8_t idIndex,
	uint32_t size)
	{
	std::chrono::microseconds usec(
	defaultTimeout); // default lock time out is 2s
	std::vector<uint32_t> result;
	smbiosDir.dir[idIndex].common.size = size;
	result.push_back(smbiosDir.dir[idIndex].common.dataSetSize);
	result.push_back(smbiosDir.dir[idIndex].common.dataVersion);
	result.push_back(smbiosDir.dir[idIndex].common.timestamp);

	timer.expires_after(usec);
	timer.async_wait([this](boost::system::error_code ec) {
	if (ec \|\| this == nullptr)
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(
	"Timer Error!");
	return;
	}
	agentSynchronizeData();
	});
	return result;
	}

	std::vector<boost::container::flat_map<std::string, RecordVariant>>
	MDR_V2::getRecordType(size_t type)
	{

	std::vector<boost::container::flat_map<std::string, RecordVariant>> ret;
	if (type == memoryDeviceType)
	{

	uint8_t* dataIn = smbiosDir.dir[smbiosDirIndex].dataStorage;

	if (dataIn == nullptr)
	{
	throw std::runtime_error("Data not populated");
	}

	do
	{
	dataIn =
	getSMBIOSTypePtr(dataIn, memoryDeviceType, sizeof(MemoryInfo));
	if (dataIn == nullptr)
	{
	break;
	}
	boost::container::flat_map<std::string, RecordVariant>& record =
	ret.emplace_back();

	auto memoryInfo = reinterpret_cast<MemoryInfo*>(dataIn);

	record["Type"] = memoryInfo->type;
	record["Length"] = memoryInfo->length;
	record["Handle"] = uint16_t(memoryInfo->handle);
	record["Physical Memory Array Handle"] =
	uint16_t(memoryInfo->phyArrayHandle);
	record["Memory Error Information Handle"] =
	uint16_t(memoryInfo->errInfoHandle);
	record["Total Width"] = uint16_t(memoryInfo->totalWidth);
	record["Data Width"] = uint16_t(memoryInfo->dataWidth);
	record["Size"] = uint16_t(memoryInfo->size);
	record["Form Factor"] = memoryInfo->formFactor;
	record["Device Set"] = memoryInfo->deviceSet;
	record["Device Locator"] = positionToString(
	memoryInfo->deviceLocator, memoryInfo->length, dataIn);
	record["Bank Locator"] = positionToString(
	memoryInfo->bankLocator, memoryInfo->length, dataIn);
	record["Memory Type"] = memoryInfo->memoryType;
	record["Type Detail"] = uint16_t(memoryInfo->typeDetail);
	record["Speed"] = uint16_t(memoryInfo->speed);
	record["Manufacturer"] = positionToString(
	memoryInfo->manufacturer, memoryInfo->length, dataIn);
	record["Serial Number"] = positionToString(
	memoryInfo->serialNum, memoryInfo->length, dataIn);
	record["Asset Tag"] = positionToString(memoryInfo->assetTag,
	memoryInfo->length, dataIn);
	record["Part Number"] = positionToString(
	memoryInfo->partNum, memoryInfo->length, dataIn);
	record["Attributes"] = memoryInfo->attributes;
	record["Extended Size"] = uint32_t(memoryInfo->extendedSize);
	record["Configured Memory Speed"] =
	uint32_t(memoryInfo->confClockSpeed);
	record["Minimum voltage"] = uint16_t(memoryInfo->minimumVoltage);
	record["Maximum voltage"] = uint16_t(memoryInfo->maximumVoltage);
	record["Configured voltage"] =
	uint16_t(memoryInfo->configuredVoltage);
	record["Memory Technology"] = memoryInfo->memoryTechnology;
	record["Memory Operating Mode Capabilty"] =
	uint16_t(memoryInfo->memoryOperatingModeCap);
	record["Firmare Version"] = memoryInfo->firwareVersion;
	record["Module Manufacturer ID"] =
	uint16_t(memoryInfo->modelManufId);
	record["Module Product ID"] = uint16_t(memoryInfo->modelProdId);
	record["Memory Subsystem Controller Manufacturer ID"] =
	uint16_t(memoryInfo->memSubConManufId);
	record["Memory Subsystem Controller Product Id"] =
	uint16_t(memoryInfo->memSubConProdId);
	record["Non-volatile Size"] = uint64_t(memoryInfo->nvSize);
	record["Volatile Size"] = uint64_t(memoryInfo->volatileSize);
	record["Cache Size"] = uint64_t(memoryInfo->cacheSize);
	record["Logical Size"] = uint64_t(memoryInfo->logicalSize);
	} while ((dataIn = smbiosNextPtr(dataIn)) != nullptr);

	return ret;
	}

	throw std::invalid_argument("Invalid record type");
	return ret;
	}

	} // namespace smbios
	} // namespace phosphor