xref: /openbmc/smbios-mdr/src/mdrv2.cpp (revision c6d87a5cccbb13b9c7b01e90be6e61c5397c5917)
1 /*
2 // Copyright (c) 2018 Intel Corporation
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 //      http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 */
16 
17 #include "mdrv2.hpp"
18 
19 #include "pcieslot.hpp"
20 
21 #include <sys/mman.h>
22 
23 #include <phosphor-logging/elog-errors.hpp>
24 #include <sdbusplus/exception.hpp>
25 #include <xyz/openbmc_project/Smbios/MDR_V2/error.hpp>
26 
27 #include <fstream>
28 
29 namespace phosphor
30 {
31 namespace smbios
32 {
33 
34 std::vector<uint8_t> MDRV2::getDirectoryInformation(uint8_t dirIndex)
35 {
36     std::vector<uint8_t> responseDir;
37 
38     std::ifstream smbiosFile(smbiosFilePath, std::ios_base::binary);
39     if (!smbiosFile.good())
40     {
41         phosphor::logging::log<phosphor::logging::level::ERR>(
42             "Read data from flash error - Open MDRV2 table file failure");
43         throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
44             InvalidParameter();
45     }
46     if (dirIndex > smbiosDir.dirEntries)
47     {
48         responseDir.push_back(0);
49         throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
50             InvalidParameter();
51     }
52     responseDir.push_back(mdr2Version);
53     responseDir.push_back(smbiosDir.dirVersion);
54     uint8_t returnedEntries = smbiosDir.dirEntries - dirIndex;
55     responseDir.push_back(returnedEntries);
56     if ((dirIndex + returnedEntries) >= smbiosDir.dirEntries)
57     {
58         responseDir.push_back(0);
59     }
60     else
61     {
62         responseDir.push_back(smbiosDir.dirEntries - dirIndex -
63                               returnedEntries);
64     }
65     for (uint8_t index = dirIndex; index < smbiosDir.dirEntries; index++)
66     {
67         for (uint8_t indexId = 0; indexId < sizeof(DataIdStruct); indexId++)
68         {
69             responseDir.push_back(
70                 smbiosDir.dir[index].common.id.dataInfo[indexId]);
71         }
72     }
73 
74     return responseDir;
75 }
76 
77 bool MDRV2::smbiosIsAvailForUpdate(uint8_t index)
78 {
79     bool ret = false;
80     if (index >= maxDirEntries)
81     {
82         return ret;
83     }
84 
85     switch (smbiosDir.dir[index].stage)
86     {
87         case MDR2SMBIOSStatusEnum::mdr2Updating:
88             ret = false;
89             break;
90 
91         case MDR2SMBIOSStatusEnum::mdr2Init:
92             // This *looks* like there should be a break statement here,
93             // as the effects of the previous statement are a noop given
94             // the following code that this falls through to.
95             // We've elected not to change it, though, since it's been
96             // this way since the old generation, and it would affect
97             // the way the code functions.
98             // If it ain't broke, don't fix it.
99 
100         case MDR2SMBIOSStatusEnum::mdr2Loaded:
101         case MDR2SMBIOSStatusEnum::mdr2Updated:
102             if (smbiosDir.dir[index].lock == MDR2DirLockEnum::mdr2DirLock)
103             {
104                 ret = false;
105             }
106             else
107             {
108                 ret = true;
109             }
110             break;
111 
112         default:
113             break;
114     }
115 
116     return ret;
117 }
118 
119 std::vector<uint8_t> MDRV2::getDataOffer()
120 {
121     std::vector<uint8_t> offer(sizeof(DataIdStruct));
122     if (smbiosIsAvailForUpdate(0))
123     {
124         std::copy(smbiosDir.dir[0].common.id.dataInfo,
125                   &smbiosDir.dir[0].common.id.dataInfo[16], offer.data());
126     }
127     else
128     {
129         phosphor::logging::log<phosphor::logging::level::ERR>(
130             "smbios is not ready for update");
131         throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
132             UpdateInProgress();
133     }
134     return offer;
135 }
136 
137 inline uint8_t MDRV2::smbiosValidFlag(uint8_t index)
138 {
139     FlagStatus ret = FlagStatus::flagIsInvalid;
140     MDR2SMBIOSStatusEnum stage = smbiosDir.dir[index].stage;
141     MDR2DirLockEnum lock = smbiosDir.dir[index].lock;
142 
143     switch (stage)
144     {
145         case MDR2SMBIOSStatusEnum::mdr2Loaded:
146         case MDR2SMBIOSStatusEnum::mdr2Updated:
147             if (lock == MDR2DirLockEnum::mdr2DirLock)
148             {
149                 ret = FlagStatus::flagIsLocked; // locked
150             }
151             else
152             {
153                 ret = FlagStatus::flagIsValid; // valid
154             }
155             break;
156 
157         case MDR2SMBIOSStatusEnum::mdr2Updating:
158         case MDR2SMBIOSStatusEnum::mdr2Init:
159             ret = FlagStatus::flagIsInvalid; // invalid
160             break;
161 
162         default:
163             break;
164     }
165 
166     return static_cast<uint8_t>(ret);
167 }
168 
169 // If source variable size is 4 bytes (uint32_t) and destination is Vector type
170 // is 1 byte (uint8_t), then by using this API can copy data byte by byte. For
171 // Example copying data from smbiosDir.dir[idIndex].common.size and
172 // smbiosDir.dir[idIndex].common.timestamp to vector variable responseInfo
173 template <typename T>
174 void appendReversed(std::vector<uint8_t>& vector, const T& value)
175 {
176     auto data = reinterpret_cast<const uint8_t*>(&value);
177     std::reverse_copy(data, data + sizeof(value), std::back_inserter(vector));
178 }
179 
180 std::vector<uint8_t> MDRV2::getDataInformation(uint8_t idIndex)
181 {
182     std::vector<uint8_t> responseInfo;
183     responseInfo.push_back(mdr2Version);
184 
185     if (idIndex >= maxDirEntries)
186     {
187         throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
188             InvalidParameter();
189     }
190 
191     for (uint8_t index = 0; index < sizeof(DataIdStruct); index++)
192     {
193         responseInfo.push_back(
194             smbiosDir.dir[idIndex].common.id.dataInfo[index]);
195     }
196 
197     responseInfo.push_back(smbiosValidFlag(idIndex));
198     appendReversed(responseInfo, smbiosDir.dir[idIndex].common.size);
199     responseInfo.push_back(smbiosDir.dir[idIndex].common.dataVersion);
200     appendReversed(responseInfo, smbiosDir.dir[idIndex].common.timestamp);
201 
202     return responseInfo;
203 }
204 
205 bool MDRV2::readDataFromFlash(MDRSMBIOSHeader* mdrHdr, uint8_t* data)
206 {
207     if (mdrHdr == nullptr)
208     {
209         phosphor::logging::log<phosphor::logging::level::ERR>(
210             "Read data from flash error - Invalid mdr header");
211         return false;
212     }
213     if (data == nullptr)
214     {
215         phosphor::logging::log<phosphor::logging::level::ERR>(
216             "Read data from flash error - Invalid data point");
217         return false;
218     }
219     std::ifstream smbiosFile(smbiosFilePath, std::ios_base::binary);
220     if (!smbiosFile.good())
221     {
222         phosphor::logging::log<phosphor::logging::level::ERR>(
223             "Read data from flash error - Open MDRV2 table file failure");
224         return false;
225     }
226     smbiosFile.clear();
227     smbiosFile.seekg(0, std::ios_base::end);
228     size_t fileLength = smbiosFile.tellg();
229     smbiosFile.seekg(0, std::ios_base::beg);
230     if (fileLength < sizeof(MDRSMBIOSHeader))
231     {
232         phosphor::logging::log<phosphor::logging::level::ERR>(
233             "MDR V2 file size is smaller than mdr header");
234         return false;
235     }
236     smbiosFile.read(reinterpret_cast<char*>(mdrHdr), sizeof(MDRSMBIOSHeader));
237     if (mdrHdr->dataSize > smbiosTableStorageSize)
238     {
239         phosphor::logging::log<phosphor::logging::level::ERR>(
240             "Data size out of limitation");
241         smbiosFile.close();
242         return false;
243     }
244     fileLength -= sizeof(MDRSMBIOSHeader);
245     if (fileLength < mdrHdr->dataSize)
246     {
247         smbiosFile.read(reinterpret_cast<char*>(data), fileLength);
248     }
249     else
250     {
251         smbiosFile.read(reinterpret_cast<char*>(data), mdrHdr->dataSize);
252     }
253     smbiosFile.close();
254     return true;
255 }
256 
257 bool MDRV2::sendDirectoryInformation(uint8_t dirVersion, uint8_t dirIndex,
258                                      uint8_t returnedEntries,
259                                      uint8_t remainingEntries,
260                                      std::vector<uint8_t> dirEntry)
261 {
262     bool teminate = false;
263     if ((dirIndex >= maxDirEntries) || (returnedEntries < 1))
264     {
265         phosphor::logging::log<phosphor::logging::level::ERR>(
266             "Send Dir info failed - input parameter invalid");
267         throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
268             InvalidParameter();
269     }
270     if ((static_cast<size_t>(returnedEntries) * sizeof(DataIdStruct)) !=
271         dirEntry.size())
272     {
273         phosphor::logging::log<phosphor::logging::level::ERR>(
274             "Directory size invalid");
275         throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
276             InvalidParameter();
277     }
278     if (dirVersion == smbiosDir.dirVersion)
279     {
280         teminate = true;
281     }
282     else
283     {
284         if (remainingEntries > 0)
285         {
286             teminate = false;
287         }
288         else
289         {
290             teminate = true;
291             smbiosDir.dirVersion = dirVersion;
292         }
293         uint8_t idIndex = dirIndex;
294         smbiosDir.dirEntries = returnedEntries;
295 
296         uint8_t* pData = dirEntry.data();
297         if (pData == nullptr)
298         {
299             return false;
300         }
301         for (uint8_t index = 0; index < returnedEntries; index++)
302         {
303             auto data = reinterpret_cast<const DataIdStruct*>(pData);
304             std::copy(data->dataInfo, data->dataInfo + sizeof(DataIdStruct),
305                       smbiosDir.dir[idIndex + index].common.id.dataInfo);
306             pData += sizeof(DataIdStruct);
307         }
308     }
309     return teminate;
310 }
311 
312 bool MDRV2::sendDataInformation(uint8_t idIndex, uint8_t /* flag */,
313                                 uint32_t dataLen, uint32_t dataVer,
314                                 uint32_t timeStamp)
315 {
316     if (idIndex >= maxDirEntries)
317     {
318         throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
319             InvalidParameter();
320     }
321     int entryChanged = 0;
322     if (smbiosDir.dir[idIndex].common.dataSetSize != dataLen)
323     {
324         entryChanged++;
325         smbiosDir.dir[idIndex].common.dataSetSize = dataLen;
326     }
327 
328     if (smbiosDir.dir[idIndex].common.dataVersion != dataVer)
329     {
330         entryChanged++;
331         smbiosDir.dir[idIndex].common.dataVersion = dataVer;
332     }
333 
334     if (smbiosDir.dir[idIndex].common.timestamp != timeStamp)
335     {
336         entryChanged++;
337         smbiosDir.dir[idIndex].common.timestamp = timeStamp;
338     }
339     if (entryChanged == 0)
340     {
341         return false;
342     }
343     return true;
344 }
345 
346 int MDRV2::findIdIndex(std::vector<uint8_t> dataInfo)
347 {
348     if (dataInfo.size() != sizeof(DataIdStruct))
349     {
350         phosphor::logging::log<phosphor::logging::level::ERR>(
351             "Length of dataInfo invalid");
352         throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::
353             InvalidId();
354     }
355     std::array<uint8_t, 16> arrayDataInfo;
356 
357     std::copy(dataInfo.begin(), dataInfo.end(), arrayDataInfo.begin());
358 
359     for (int index = 0; index < smbiosDir.dirEntries; index++)
360     {
361         size_t info = 0;
362         for (; info < arrayDataInfo.size(); info++)
363         {
364             if (arrayDataInfo[info] !=
365                 smbiosDir.dir[index].common.id.dataInfo[info])
366             {
367                 break;
368             }
369         }
370         if (info == arrayDataInfo.size())
371         {
372             return index;
373         }
374     }
375     throw sdbusplus::xyz::openbmc_project::Smbios::MDR_V2::Error::InvalidId();
376 }
377 
378 uint8_t MDRV2::directoryEntries(uint8_t value)
379 {
380     std::ifstream smbiosFile(smbiosFilePath, std::ios_base::binary);
381     if (!smbiosFile.good())
382     {
383         phosphor::logging::log<phosphor::logging::level::ERR>(
384             "Read data from flash error - Open MDRV2 table file failure");
385         value = 0;
386     }
387     else
388     {
389         value = smbiosDir.dirEntries;
390     }
391     return sdbusplus::server::xyz::openbmc_project::smbios::MDRV2::
392         directoryEntries(value);
393 }
394 
395 void MDRV2::systemInfoUpdate()
396 {
397     // By default, look for System interface on any system/board/* object
398     std::string mapperAncestorPath = smbiosInventoryPath;
399     std::string matchParentPath = smbiosInventoryPath + "/board/";
400     bool requireExactMatch = false;
401 
402     // If customized, look for System on only that custom object
403     if (smbiosInventoryPath != defaultInventoryPath)
404     {
405         std::filesystem::path path(smbiosInventoryPath);
406 
407         // Search under parent to find exact match for self
408         mapperAncestorPath = path.parent_path().string();
409         matchParentPath = mapperAncestorPath;
410         requireExactMatch = true;
411     }
412 
413     std::string motherboardPath;
414     auto method = bus->new_method_call(mapperBusName, mapperPath,
415                                        mapperInterface, "GetSubTreePaths");
416     method.append(mapperAncestorPath);
417     method.append(0);
418     method.append(std::vector<std::string>({systemInterface}));
419 
420     try
421     {
422         std::vector<std::string> paths;
423         sdbusplus::message_t reply = bus->call(method);
424         reply.read(paths);
425 
426         size_t pathsCount = paths.size();
427         for (size_t i = 0; i < pathsCount; ++i)
428         {
429             if (requireExactMatch && (paths[i] != smbiosInventoryPath))
430             {
431                 continue;
432             }
433 
434             motherboardPath = std::move(paths[i]);
435             break;
436         }
437 
438         if (motherboardPath.empty())
439         {
440             phosphor::logging::log<phosphor::logging::level::ERR>(
441                 "Failed to get system motherboard dbus path. Setting up a "
442                 "match rule");
443 
444             if (!motherboardConfigMatch)
445             {
446                 motherboardConfigMatch =
447                     std::make_unique<sdbusplus::bus::match_t>(
448                         *bus,
449                         sdbusplus::bus::match::rules::interfacesAdded() +
450                             sdbusplus::bus::match::rules::argNpath(
451                                 0, matchParentPath),
452                         [this](sdbusplus::message_t& msg) {
453                     sdbusplus::message::object_path objectName;
454                     boost::container::flat_map<
455                         std::string,
456                         boost::container::flat_map<
457                             std::string, std::variant<std::string, uint64_t>>>
458                         msgData;
459                     msg.read(objectName, msgData);
460                     if (msgData.contains(systemInterface))
461                     {
462                         systemInfoUpdate();
463                     }
464                 });
465             }
466         }
467         else
468         {
469             lg2::info(
470                 "Found Inventory anchor object for SMBIOS content {I}: {M}",
471                 "I", smbiosInventoryPath, "M", motherboardPath);
472         }
473     }
474     catch (const sdbusplus::exception_t& e)
475     {
476         lg2::error(
477             "Exception while trying to find Inventory anchor object for SMBIOS content {I}: {E}",
478             "I", smbiosInventoryPath, "E", e.what());
479         phosphor::logging::log<phosphor::logging::level::ERR>(
480             "Failed to query system motherboard",
481             phosphor::logging::entry("ERROR=%s", e.what()));
482     }
483 
484     std::optional<size_t> num = getTotalCpuSlot();
485     if (!num)
486     {
487         phosphor::logging::log<phosphor::logging::level::ERR>(
488             "get cpu total slot failed");
489         return;
490     }
491 
492     // In case the new size is smaller than old, trim the vector
493     if (*num < cpus.size())
494     {
495         cpus.resize(*num);
496     }
497 
498     for (unsigned int index = 0; index < *num; index++)
499     {
500         std::string path = smbiosInventoryPath + cpuSuffix +
501                            std::to_string(index);
502         if (index + 1 > cpus.size())
503         {
504             cpus.emplace_back(std::make_unique<phosphor::smbios::Cpu>(
505                 *bus, path, index, smbiosDir.dir[smbiosDirIndex].dataStorage,
506                 motherboardPath));
507         }
508         else
509         {
510             cpus[index]->infoUpdate(smbiosDir.dir[smbiosDirIndex].dataStorage,
511                                     motherboardPath);
512         }
513     }
514 
515 #ifdef DIMM_DBUS
516 
517     num = getTotalDimmSlot();
518     if (!num)
519     {
520         phosphor::logging::log<phosphor::logging::level::ERR>(
521             "get dimm total slot failed");
522         return;
523     }
524 
525     // In case the new size is smaller than old, trim the vector
526     if (*num < dimms.size())
527     {
528         dimms.resize(*num);
529     }
530 
531     for (unsigned int index = 0; index < *num; index++)
532     {
533         std::string path = smbiosInventoryPath + dimmSuffix +
534                            std::to_string(index);
535         if (index + 1 > dimms.size())
536         {
537             dimms.emplace_back(std::make_unique<phosphor::smbios::Dimm>(
538                 *bus, path, index, smbiosDir.dir[smbiosDirIndex].dataStorage,
539                 motherboardPath));
540         }
541         else
542         {
543             dimms[index]->memoryInfoUpdate(
544                 smbiosDir.dir[smbiosDirIndex].dataStorage, motherboardPath);
545         }
546     }
547 
548 #endif
549 
550     num = getTotalPcieSlot();
551     if (!num)
552     {
553         phosphor::logging::log<phosphor::logging::level::ERR>(
554             "get pcie total slot failed");
555         return;
556     }
557 
558     // In case the new size is smaller than old, trim the vector
559     if (*num < pcies.size())
560     {
561         pcies.resize(*num);
562     }
563 
564     for (unsigned int index = 0; index < *num; index++)
565     {
566         std::string path = smbiosInventoryPath + pcieSuffix +
567                            std::to_string(index);
568         if (index + 1 > pcies.size())
569         {
570             pcies.emplace_back(std::make_unique<phosphor::smbios::Pcie>(
571                 *bus, path, index, smbiosDir.dir[smbiosDirIndex].dataStorage,
572                 motherboardPath));
573         }
574         else
575         {
576             pcies[index]->pcieInfoUpdate(
577                 smbiosDir.dir[smbiosDirIndex].dataStorage, motherboardPath);
578         }
579     }
580 
581     system.reset();
582     system = std::make_unique<System>(bus, smbiosInventoryPath + systemSuffix,
583                                       smbiosDir.dir[smbiosDirIndex].dataStorage,
584                                       smbiosFilePath);
585 }
586 
587 std::optional<size_t> MDRV2::getTotalCpuSlot()
588 {
589     uint8_t* dataIn = smbiosDir.dir[smbiosDirIndex].dataStorage;
590     size_t num = 0;
591 
592     if (dataIn == nullptr)
593     {
594         phosphor::logging::log<phosphor::logging::level::ERR>(
595             "get cpu total slot failed - no storage data");
596         return std::nullopt;
597     }
598 
599     while (1)
600     {
601         dataIn = getSMBIOSTypePtr(dataIn, processorsType);
602         if (dataIn == nullptr)
603         {
604             break;
605         }
606         num++;
607         dataIn = smbiosNextPtr(dataIn);
608         if (dataIn == nullptr)
609         {
610             break;
611         }
612         if (num >= limitEntryLen)
613         {
614             break;
615         }
616     }
617 
618     return num;
619 }
620 
621 std::optional<size_t> MDRV2::getTotalDimmSlot()
622 {
623     uint8_t* dataIn = smbiosDir.dir[smbiosDirIndex].dataStorage;
624     size_t num = 0;
625 
626     if (dataIn == nullptr)
627     {
628         phosphor::logging::log<phosphor::logging::level::ERR>(
629             "Fail to get dimm total slot - no storage data");
630         return std::nullopt;
631     }
632 
633     while (1)
634     {
635         dataIn = getSMBIOSTypePtr(dataIn, memoryDeviceType);
636         if (dataIn == nullptr)
637         {
638             break;
639         }
640         num++;
641         dataIn = smbiosNextPtr(dataIn);
642         if (dataIn == nullptr)
643         {
644             break;
645         }
646         if (num >= limitEntryLen)
647         {
648             break;
649         }
650     }
651 
652     return num;
653 }
654 
655 std::optional<size_t> MDRV2::getTotalPcieSlot()
656 {
657     uint8_t* dataIn = smbiosDir.dir[smbiosDirIndex].dataStorage;
658     size_t num = 0;
659 
660     if (dataIn == nullptr)
661     {
662         phosphor::logging::log<phosphor::logging::level::ERR>(
663             "Fail to get total system slot - no storage data");
664         return std::nullopt;
665     }
666 
667     while (1)
668     {
669         dataIn = getSMBIOSTypePtr(dataIn, systemSlots);
670         if (dataIn == nullptr)
671         {
672             break;
673         }
674 
675         /* System slot type offset. Check if the slot is a PCIE slots. All
676          * PCIE slot type are hardcoded in a table.
677          */
678         if (pcieSmbiosType.find(*(dataIn + 5)) != pcieSmbiosType.end())
679         {
680             num++;
681         }
682         dataIn = smbiosNextPtr(dataIn);
683         if (dataIn == nullptr)
684         {
685             break;
686         }
687         if (num >= limitEntryLen)
688         {
689             break;
690         }
691     }
692 
693     return num;
694 }
695 
696 bool MDRV2::checkSMBIOSVersion(uint8_t* dataIn)
697 {
698     const std::string anchorString21 = "_SM_";
699     const std::string anchorString30 = "_SM3_";
700     std::string buffer(reinterpret_cast<const char*>(dataIn),
701                        smbiosTableStorageSize);
702 
703     auto it = std::search(std::begin(buffer), std::end(buffer),
704                           std::begin(anchorString21), std::end(anchorString21));
705     bool smbios21Found = it != std::end(buffer);
706     if (!smbios21Found)
707     {
708         phosphor::logging::log<phosphor::logging::level::INFO>(
709             "SMBIOS 2.1 Anchor String not found. Looking for SMBIOS 3.0");
710         it = std::search(std::begin(buffer), std::end(buffer),
711                          std::begin(anchorString30), std::end(anchorString30));
712         if (it == std::end(buffer))
713         {
714             phosphor::logging::log<phosphor::logging::level::ERR>(
715                 "SMBIOS 2.1 and 3.0 Anchor Strings not found");
716             return false;
717         }
718     }
719 
720     auto pos = std::distance(std::begin(buffer), it);
721     size_t length = smbiosTableStorageSize - pos;
722     uint8_t foundMajorVersion;
723     uint8_t foundMinorVersion;
724 
725     if (smbios21Found)
726     {
727         if (length < sizeof(EntryPointStructure21))
728         {
729             phosphor::logging::log<phosphor::logging::level::ERR>(
730                 "Invalid entry point structure for SMBIOS 2.1");
731             return false;
732         }
733 
734         auto epStructure =
735             reinterpret_cast<const EntryPointStructure21*>(&dataIn[pos]);
736         foundMajorVersion = epStructure->smbiosVersion.majorVersion;
737         foundMinorVersion = epStructure->smbiosVersion.minorVersion;
738     }
739     else
740     {
741         if (length < sizeof(EntryPointStructure30))
742         {
743             phosphor::logging::log<phosphor::logging::level::ERR>(
744                 "Invalid entry point structure for SMBIOS 3.0");
745             return false;
746         }
747 
748         auto epStructure =
749             reinterpret_cast<const EntryPointStructure30*>(&dataIn[pos]);
750         foundMajorVersion = epStructure->smbiosVersion.majorVersion;
751         foundMinorVersion = epStructure->smbiosVersion.minorVersion;
752     }
753     lg2::info("SMBIOS VERSION - {MAJOR}.{MINOR}", "MAJOR", foundMajorVersion,
754               "MINOR", foundMinorVersion);
755 
756     auto itr = std::find_if(std::begin(supportedSMBIOSVersions),
757                             std::end(supportedSMBIOSVersions),
758                             [&](SMBIOSVersion versionItr) {
759         return versionItr.majorVersion == foundMajorVersion &&
760                versionItr.minorVersion == foundMinorVersion;
761     });
762     if (itr == std::end(supportedSMBIOSVersions))
763     {
764         return false;
765     }
766     return true;
767 }
768 
769 bool MDRV2::agentSynchronizeData()
770 {
771     struct MDRSMBIOSHeader mdr2SMBIOS;
772     bool status = readDataFromFlash(&mdr2SMBIOS,
773                                     smbiosDir.dir[smbiosDirIndex].dataStorage);
774     if (!status)
775     {
776         phosphor::logging::log<phosphor::logging::level::ERR>(
777             "agent data sync failed - read data from flash failed");
778         return false;
779     }
780 
781     if (!checkSMBIOSVersion(smbiosDir.dir[smbiosDirIndex].dataStorage))
782     {
783         phosphor::logging::log<phosphor::logging::level::ERR>(
784             "Unsupported SMBIOS table version");
785         return false;
786     }
787 
788     systemInfoUpdate();
789     smbiosDir.dir[smbiosDirIndex].common.dataVersion = mdr2SMBIOS.dirVer;
790     smbiosDir.dir[smbiosDirIndex].common.timestamp = mdr2SMBIOS.timestamp;
791     smbiosDir.dir[smbiosDirIndex].common.size = mdr2SMBIOS.dataSize;
792     smbiosDir.dir[smbiosDirIndex].stage = MDR2SMBIOSStatusEnum::mdr2Loaded;
793     smbiosDir.dir[smbiosDirIndex].lock = MDR2DirLockEnum::mdr2DirUnlock;
794 
795     return true;
796 }
797 
798 std::vector<uint32_t> MDRV2::synchronizeDirectoryCommonData(uint8_t idIndex,
799                                                             uint32_t size)
800 {
801     std::chrono::microseconds usec(
802         defaultTimeout); // default lock time out is 2s
803     std::vector<uint32_t> result;
804     smbiosDir.dir[idIndex].common.size = size;
805     result.push_back(smbiosDir.dir[idIndex].common.dataSetSize);
806     result.push_back(smbiosDir.dir[idIndex].common.dataVersion);
807     result.push_back(smbiosDir.dir[idIndex].common.timestamp);
808 
809     timer.expires_after(usec);
810     timer.async_wait([this](boost::system::error_code ec) {
811         if (ec)
812         {
813             phosphor::logging::log<phosphor::logging::level::ERR>(
814                 "Timer Error!");
815             return;
816         }
817         agentSynchronizeData();
818     });
819     return result;
820 }
821 
822 std::vector<boost::container::flat_map<std::string, RecordVariant>>
823     MDRV2::getRecordType(size_t type)
824 {
825     std::vector<boost::container::flat_map<std::string, RecordVariant>> ret;
826     if (type == memoryDeviceType)
827     {
828         uint8_t* dataIn = smbiosDir.dir[smbiosDirIndex].dataStorage;
829 
830         if (dataIn == nullptr)
831         {
832             throw std::runtime_error("Data not populated");
833         }
834 
835         do
836         {
837             dataIn = getSMBIOSTypePtr(dataIn, memoryDeviceType,
838                                       sizeof(MemoryInfo));
839             if (dataIn == nullptr)
840             {
841                 break;
842             }
843             boost::container::flat_map<std::string, RecordVariant>& record =
844                 ret.emplace_back();
845 
846             auto memoryInfo = reinterpret_cast<MemoryInfo*>(dataIn);
847 
848             record["Type"] = memoryInfo->type;
849             record["Length"] = memoryInfo->length;
850             record["Handle"] = uint16_t(memoryInfo->handle);
851             record["Physical Memory Array Handle"] =
852                 uint16_t(memoryInfo->phyArrayHandle);
853             record["Memory Error Information Handle"] =
854                 uint16_t(memoryInfo->errInfoHandle);
855             record["Total Width"] = uint16_t(memoryInfo->totalWidth);
856             record["Data Width"] = uint16_t(memoryInfo->dataWidth);
857             record["Size"] = uint16_t(memoryInfo->size);
858             record["Form Factor"] = memoryInfo->formFactor;
859             record["Device Set"] = memoryInfo->deviceSet;
860             record["Device Locator"] = positionToString(
861                 memoryInfo->deviceLocator, memoryInfo->length, dataIn);
862             record["Bank Locator"] = positionToString(
863                 memoryInfo->bankLocator, memoryInfo->length, dataIn);
864             record["Memory Type"] = memoryInfo->memoryType;
865             record["Type Detail"] = uint16_t(memoryInfo->typeDetail);
866             record["Speed"] = uint16_t(memoryInfo->speed);
867             record["Manufacturer"] = positionToString(
868                 memoryInfo->manufacturer, memoryInfo->length, dataIn);
869             record["Serial Number"] = positionToString(
870                 memoryInfo->serialNum, memoryInfo->length, dataIn);
871             record["Asset Tag"] = positionToString(memoryInfo->assetTag,
872                                                    memoryInfo->length, dataIn);
873             record["Part Number"] = positionToString(
874                 memoryInfo->partNum, memoryInfo->length, dataIn);
875             record["Attributes"] = uint32_t(memoryInfo->attributes);
876             record["Extended Size"] = uint32_t(memoryInfo->extendedSize);
877             record["Configured Memory Speed"] =
878                 uint32_t(memoryInfo->confClockSpeed);
879             record["Minimum voltage"] = uint16_t(memoryInfo->minimumVoltage);
880             record["Maximum voltage"] = uint16_t(memoryInfo->maximumVoltage);
881             record["Configured voltage"] =
882                 uint16_t(memoryInfo->configuredVoltage);
883             record["Memory Technology"] = memoryInfo->memoryTechnology;
884             record["Memory Operating Mode Capabilty"] =
885                 uint16_t(memoryInfo->memoryOperatingModeCap);
886             record["Firmare Version"] = memoryInfo->firwareVersion;
887             record["Module Manufacturer ID"] =
888                 uint16_t(memoryInfo->modelManufId);
889             record["Module Product ID"] = uint16_t(memoryInfo->modelProdId);
890             record["Memory Subsystem Controller Manufacturer ID"] =
891                 uint16_t(memoryInfo->memSubConManufId);
892             record["Memory Subsystem Controller Product Id"] =
893                 uint16_t(memoryInfo->memSubConProdId);
894             record["Non-volatile Size"] = uint64_t(memoryInfo->nvSize);
895             record["Volatile Size"] = uint64_t(memoryInfo->volatileSize);
896             record["Cache Size"] = uint64_t(memoryInfo->cacheSize);
897             record["Logical Size"] = uint64_t(memoryInfo->logicalSize);
898         } while ((dataIn = smbiosNextPtr(dataIn)) != nullptr);
899 
900         return ret;
901     }
902 
903     throw std::invalid_argument("Invalid record type");
904     return ret;
905 }
906 
907 } // namespace smbios
908 } // namespace phosphor
909