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