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 /// \file fru_device.cpp 17 18 #include "fru_utils.hpp" 19 #include "utils.hpp" 20 21 #include <fcntl.h> 22 #include <sys/inotify.h> 23 #include <sys/ioctl.h> 24 25 #include <boost/algorithm/string/predicate.hpp> 26 #include <boost/asio/io_context.hpp> 27 #include <boost/asio/steady_timer.hpp> 28 #include <boost/container/flat_map.hpp> 29 #include <nlohmann/json.hpp> 30 #include <phosphor-logging/lg2.hpp> 31 #include <sdbusplus/asio/connection.hpp> 32 #include <sdbusplus/asio/object_server.hpp> 33 34 #include <array> 35 #include <cerrno> 36 #include <charconv> 37 #include <chrono> 38 #include <ctime> 39 #include <filesystem> 40 #include <fstream> 41 #include <functional> 42 #include <future> 43 #include <iomanip> 44 #include <iostream> 45 #include <limits> 46 #include <map> 47 #include <optional> 48 #include <regex> 49 #include <set> 50 #include <sstream> 51 #include <string> 52 #include <thread> 53 #include <utility> 54 #include <variant> 55 #include <vector> 56 57 extern "C" 58 { 59 #include <i2c/smbus.h> 60 #include <linux/i2c-dev.h> 61 } 62 63 namespace fs = std::filesystem; 64 constexpr size_t maxFruSize = 512; 65 constexpr size_t maxEepromPageIndex = 255; 66 constexpr size_t busTimeoutSeconds = 10; 67 68 constexpr const char* blocklistPath = PACKAGE_DIR "blacklist.json"; 69 70 const static constexpr char* baseboardFruLocation = 71 "/etc/fru/baseboard.fru.bin"; 72 73 const static constexpr char* i2CDevLocation = "/dev"; 74 75 constexpr const char* fruDevice16BitDetectMode = FRU_DEVICE_16BITDETECTMODE; 76 77 // TODO Refactor these to not be globals 78 // NOLINTBEGIN(cppcoreguidelines-avoid-non-const-global-variables) 79 static boost::container::flat_map<size_t, std::optional<std::set<size_t>>> 80 busBlocklist; 81 struct FindDevicesWithCallback; 82 83 static boost::container::flat_map< 84 std::pair<size_t, size_t>, std::shared_ptr<sdbusplus::asio::dbus_interface>> 85 foundDevices; 86 87 static boost::container::flat_map<size_t, std::set<size_t>> failedAddresses; 88 static boost::container::flat_map<size_t, std::set<size_t>> fruAddresses; 89 90 boost::asio::io_context io; 91 // NOLINTEND(cppcoreguidelines-avoid-non-const-global-variables) 92 93 bool updateFRUProperty( 94 const std::string& updatePropertyReq, uint32_t bus, uint32_t address, 95 const std::string& propertyName, 96 boost::container::flat_map< 97 std::pair<size_t, size_t>, 98 std::shared_ptr<sdbusplus::asio::dbus_interface>>& dbusInterfaceMap, 99 size_t& unknownBusObjectCount, const bool& powerIsOn, 100 sdbusplus::asio::object_server& objServer, 101 std::shared_ptr<sdbusplus::asio::connection>& systemBus); 102 103 // Given a bus/address, produce the path in sysfs for an eeprom. 104 static std::string getEepromPath(size_t bus, size_t address) 105 { 106 std::stringstream output; 107 output << "/sys/bus/i2c/devices/" << bus << "-" << std::right 108 << std::setfill('0') << std::setw(4) << std::hex << address 109 << "/eeprom"; 110 return output.str(); 111 } 112 113 static bool hasEepromFile(size_t bus, size_t address) 114 { 115 auto path = getEepromPath(bus, address); 116 try 117 { 118 return fs::exists(path); 119 } 120 catch (...) 121 { 122 return false; 123 } 124 } 125 126 static int64_t readFromEeprom(int fd, off_t offset, size_t len, uint8_t* buf) 127 { 128 auto result = lseek(fd, offset, SEEK_SET); 129 if (result < 0) 130 { 131 std::cerr << "failed to seek\n"; 132 return -1; 133 } 134 135 return read(fd, buf, len); 136 } 137 138 static int busStrToInt(const std::string_view busName) 139 { 140 auto findBus = busName.rfind('-'); 141 if (findBus == std::string::npos) 142 { 143 return -1; 144 } 145 std::string_view num = busName.substr(findBus + 1); 146 int val = 0; 147 std::from_chars(num.data(), num.data() + num.size(), val); 148 return val; 149 } 150 151 static int getRootBus(size_t bus) 152 { 153 auto ec = std::error_code(); 154 auto path = std::filesystem::read_symlink( 155 std::filesystem::path( 156 "/sys/bus/i2c/devices/i2c-" + std::to_string(bus) + "/mux_device"), 157 ec); 158 if (ec) 159 { 160 return -1; 161 } 162 163 std::string filename = path.filename(); 164 auto findBus = filename.find('-'); 165 if (findBus == std::string::npos) 166 { 167 return -1; 168 } 169 return std::stoi(filename.substr(0, findBus)); 170 } 171 172 static bool isMuxBus(size_t bus) 173 { 174 auto ec = std::error_code(); 175 auto isSymlink = 176 is_symlink(std::filesystem::path("/sys/bus/i2c/devices/i2c-" + 177 std::to_string(bus) + "/mux_device"), 178 ec); 179 return (!ec && isSymlink); 180 } 181 182 static void makeProbeInterface(size_t bus, size_t address, 183 sdbusplus::asio::object_server& objServer) 184 { 185 if (isMuxBus(bus)) 186 { 187 return; // the mux buses are random, no need to publish 188 } 189 auto [it, success] = foundDevices.emplace( 190 std::make_pair(bus, address), 191 objServer.add_interface( 192 "/xyz/openbmc_project/FruDevice/" + std::to_string(bus) + "_" + 193 std::to_string(address), 194 "xyz.openbmc_project.Inventory.Item.I2CDevice")); 195 if (!success) 196 { 197 return; // already added 198 } 199 it->second->register_property("Bus", bus); 200 it->second->register_property("Address", address); 201 it->second->initialize(); 202 } 203 204 // Issue an I2C transaction to first write to_target_buf_len bytes,then read 205 // from_target_buf_len bytes. 206 static int i2cSmbusWriteThenRead( 207 int file, uint16_t address, uint8_t* toTargetBuf, uint8_t toTargetBufLen, 208 uint8_t* fromTargetBuf, uint8_t fromTargetBufLen) 209 { 210 if (toTargetBuf == nullptr || toTargetBufLen == 0 || 211 fromTargetBuf == nullptr || fromTargetBufLen == 0) 212 { 213 return -1; 214 } 215 216 constexpr size_t smbusWriteThenReadMsgCount = 2; 217 std::array<struct i2c_msg, smbusWriteThenReadMsgCount> msgs{}; 218 struct i2c_rdwr_ioctl_data rdwr{}; 219 220 msgs[0].addr = address; 221 msgs[0].flags = 0; 222 msgs[0].len = toTargetBufLen; 223 msgs[0].buf = toTargetBuf; 224 msgs[1].addr = address; 225 msgs[1].flags = I2C_M_RD; 226 msgs[1].len = fromTargetBufLen; 227 msgs[1].buf = fromTargetBuf; 228 229 rdwr.msgs = msgs.data(); 230 rdwr.nmsgs = msgs.size(); 231 232 int ret = ioctl(file, I2C_RDWR, &rdwr); 233 234 return (ret == static_cast<int>(msgs.size())) ? msgs[1].len : -1; 235 } 236 237 static int64_t readData(bool is16bit, bool isBytewise, int file, 238 uint16_t address, off_t offset, size_t len, 239 uint8_t* buf) 240 { 241 if (!is16bit) 242 { 243 if (!isBytewise) 244 { 245 return i2c_smbus_read_i2c_block_data( 246 file, static_cast<uint8_t>(offset), len, buf); 247 } 248 249 std::span<uint8_t> bufspan{buf, len}; 250 for (size_t i = 0; i < len; i++) 251 { 252 int byte = i2c_smbus_read_byte_data( 253 file, static_cast<uint8_t>(offset + i)); 254 if (byte < 0) 255 { 256 return static_cast<int64_t>(byte); 257 } 258 bufspan[i] = static_cast<uint8_t>(byte); 259 } 260 return static_cast<int64_t>(len); 261 } 262 263 offset = htobe16(offset); 264 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 265 uint8_t* u8Offset = reinterpret_cast<uint8_t*>(&offset); 266 return i2cSmbusWriteThenRead(file, address, u8Offset, 2, buf, len); 267 } 268 269 // Mode_1: 270 // -------- 271 // Please refer to document docs/address_size_detection_modes.md for 272 // more details and explanations. 273 static std::optional<bool> isDevice16BitMode1(int file) 274 { 275 // Set the higher data word address bits to 0. It's safe on 8-bit 276 // addressing EEPROMs because it doesn't write any actual data. 277 int ret = i2c_smbus_write_byte(file, 0); 278 if (ret < 0) 279 { 280 return std::nullopt; 281 } 282 283 /* Get first byte */ 284 int byte1 = i2c_smbus_read_byte_data(file, 0); 285 if (byte1 < 0) 286 { 287 return std::nullopt; 288 } 289 /* Read 7 more bytes, it will read same first byte in case of 290 * 8 bit but it will read next byte in case of 16 bit 291 */ 292 for (int i = 0; i < 7; i++) 293 { 294 int byte2 = i2c_smbus_read_byte_data(file, 0); 295 if (byte2 < 0) 296 { 297 return std::nullopt; 298 } 299 if (byte2 != byte1) 300 { 301 return true; 302 } 303 } 304 return false; 305 } 306 307 // Mode_2: 308 // -------- 309 // Please refer to document docs/address_size_detection_modes.md for 310 // more details and explanations. 311 static std::optional<bool> isDevice16BitMode2(int file, uint16_t address) 312 { 313 uint8_t first = 0; 314 uint8_t cur = 0; 315 uint16_t v = 0; 316 int ret = 0; 317 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 318 uint8_t* p = reinterpret_cast<uint8_t*>(&v); 319 320 /* 321 * Write 2 bytes byte0 = 0, byte1 = {0..7} and then subsequent read byte 322 * It will read same first byte in case of 8 bit but 323 * it will read next byte in case of 16 bit 324 */ 325 for (int i = 0; i < 8; i++) 326 { 327 v = htobe16(i); 328 329 ret = i2cSmbusWriteThenRead(file, address, p, 2, &cur, 1); 330 if (ret < 0) 331 { 332 return std::nullopt; 333 } 334 335 if (i == 0) 336 { 337 first = cur; 338 } 339 340 if (first != cur) 341 { 342 return true; 343 } 344 } 345 return false; 346 } 347 348 static std::optional<bool> isDevice16Bit(int file, uint16_t address) 349 { 350 std::string mode(fruDevice16BitDetectMode); 351 352 if (mode == "MODE_2") 353 { 354 return isDevice16BitMode2(file, address); 355 } 356 357 return isDevice16BitMode1(file); 358 } 359 360 // TODO: This code is very similar to the non-eeprom version and can be merged 361 // with some tweaks. 362 static std::vector<uint8_t> processEeprom(int bus, int address) 363 { 364 auto path = getEepromPath(bus, address); 365 366 int file = open(path.c_str(), O_RDONLY); 367 if (file < 0) 368 { 369 std::cerr << "Unable to open eeprom file: " << path << "\n"; 370 return {}; 371 } 372 373 std::string errorMessage = "eeprom at " + std::to_string(bus) + 374 " address " + std::to_string(address); 375 auto readFunc = [file](off_t offset, size_t length, uint8_t* outbuf) { 376 return readFromEeprom(file, offset, length, outbuf); 377 }; 378 FRUReader reader(std::move(readFunc)); 379 std::pair<std::vector<uint8_t>, bool> pair = 380 readFRUContents(reader, errorMessage); 381 382 close(file); 383 return pair.first; 384 } 385 386 std::set<size_t> findI2CEeproms(int i2cBus, 387 const std::shared_ptr<DeviceMap>& devices) 388 { 389 std::set<size_t> foundList; 390 391 std::string path = "/sys/bus/i2c/devices/i2c-" + std::to_string(i2cBus); 392 393 // For each file listed under the i2c device 394 // NOTE: This should be faster than just checking for each possible address 395 // path. 396 auto ec = std::error_code(); 397 for (const auto& p : fs::directory_iterator(path, ec)) 398 { 399 if (ec) 400 { 401 std::cerr << "directory_iterator err " << ec.message() << "\n"; 402 break; 403 } 404 const std::string node = p.path().string(); 405 std::smatch m; 406 bool found = 407 std::regex_match(node, m, std::regex(".+\\d+-([0-9abcdef]+$)")); 408 409 if (!found) 410 { 411 continue; 412 } 413 if (m.size() != 2) 414 { 415 std::cerr << "regex didn't capture\n"; 416 continue; 417 } 418 419 std::ssub_match subMatch = m[1]; 420 std::string addressString = subMatch.str(); 421 std::string_view addressStringView(addressString); 422 423 size_t address = 0; 424 std::from_chars(addressStringView.begin(), addressStringView.end(), 425 address, 16); 426 427 const std::string eeprom = node + "/eeprom"; 428 429 try 430 { 431 if (!fs::exists(eeprom)) 432 { 433 continue; 434 } 435 } 436 catch (...) 437 { 438 continue; 439 } 440 441 // There is an eeprom file at this address, it may have invalid 442 // contents, but we found it. 443 foundList.insert(address); 444 445 std::vector<uint8_t> device = processEeprom(i2cBus, address); 446 if (!device.empty()) 447 { 448 devices->emplace(address, device); 449 } 450 } 451 452 return foundList; 453 } 454 455 int getBusFRUs(int file, int first, int last, int bus, 456 std::shared_ptr<DeviceMap> devices, const bool& powerIsOn, 457 sdbusplus::asio::object_server& objServer) 458 { 459 std::future<int> future = std::async(std::launch::async, [&]() { 460 // NOTE: When reading the devices raw on the bus, it can interfere with 461 // the driver's ability to operate, therefore read eeproms first before 462 // scanning for devices without drivers. Several experiments were run 463 // and it was determined that if there were any devices on the bus 464 // before the eeprom was hit and read, the eeprom driver wouldn't open 465 // while the bus device was open. An experiment was not performed to see 466 // if this issue was resolved if the i2c bus device was closed, but 467 // hexdumps of the eeprom later were successful. 468 469 // Scan for i2c eeproms loaded on this bus. 470 std::set<size_t> skipList = findI2CEeproms(bus, devices); 471 std::set<size_t>& failedItems = failedAddresses[bus]; 472 std::set<size_t>& foundItems = fruAddresses[bus]; 473 foundItems.clear(); 474 475 auto busFind = busBlocklist.find(bus); 476 if (busFind != busBlocklist.end()) 477 { 478 if (busFind->second != std::nullopt) 479 { 480 for (const auto& address : *(busFind->second)) 481 { 482 skipList.insert(address); 483 } 484 } 485 } 486 487 std::set<size_t>* rootFailures = nullptr; 488 int rootBus = getRootBus(bus); 489 490 if (rootBus >= 0) 491 { 492 auto rootBusFind = busBlocklist.find(rootBus); 493 if (rootBusFind != busBlocklist.end()) 494 { 495 if (rootBusFind->second != std::nullopt) 496 { 497 for (const auto& rootAddress : *(rootBusFind->second)) 498 { 499 skipList.insert(rootAddress); 500 } 501 } 502 } 503 rootFailures = &(failedAddresses[rootBus]); 504 foundItems = fruAddresses[rootBus]; 505 } 506 507 constexpr int startSkipTargetAddr = 0; 508 constexpr int endSkipTargetAddr = 12; 509 510 for (int ii = first; ii <= last; ii++) 511 { 512 if (foundItems.find(ii) != foundItems.end()) 513 { 514 continue; 515 } 516 if (skipList.find(ii) != skipList.end()) 517 { 518 continue; 519 } 520 // skipping since no device is present in this range 521 if (ii >= startSkipTargetAddr && ii <= endSkipTargetAddr) 522 { 523 continue; 524 } 525 // Set target address 526 if (ioctl(file, I2C_SLAVE, ii) < 0) 527 { 528 std::cerr << "device at bus " << bus << " address " << ii 529 << " busy\n"; 530 continue; 531 } 532 // probe 533 if (i2c_smbus_read_byte(file) < 0) 534 { 535 continue; 536 } 537 538 lg2::debug("something at bus {BUS}, addr {ADDR}", "BUS", bus, 539 "ADDR", ii); 540 541 makeProbeInterface(bus, ii, objServer); 542 543 if (failedItems.find(ii) != failedItems.end()) 544 { 545 // if we failed to read it once, unlikely we can read it later 546 continue; 547 } 548 549 if (rootFailures != nullptr) 550 { 551 if (rootFailures->find(ii) != rootFailures->end()) 552 { 553 continue; 554 } 555 } 556 557 /* Check for Device type if it is 8 bit or 16 bit */ 558 std::optional<bool> is16Bit = isDevice16Bit(file, ii); 559 if (!is16Bit.has_value()) 560 { 561 std::cerr << "failed to read bus " << bus << " address " << ii 562 << "\n"; 563 if (powerIsOn) 564 { 565 failedItems.insert(ii); 566 } 567 continue; 568 } 569 bool is16BitBool{*is16Bit}; 570 571 auto readFunc = [is16BitBool, file, 572 ii](off_t offset, size_t length, uint8_t* outbuf) { 573 return readData(is16BitBool, false, file, ii, offset, length, 574 outbuf); 575 }; 576 FRUReader reader(std::move(readFunc)); 577 std::string errorMessage = 578 "bus " + std::to_string(bus) + " address " + std::to_string(ii); 579 std::pair<std::vector<uint8_t>, bool> pair = 580 readFRUContents(reader, errorMessage); 581 const bool foundHeader = pair.second; 582 583 if (!foundHeader && !is16BitBool) 584 { 585 // certain FRU eeproms require bytewise reading. 586 // otherwise garbage is read. e.g. SuperMicro PWS 920P-SQ 587 588 auto readFunc = 589 [is16BitBool, file, 590 ii](off_t offset, size_t length, uint8_t* outbuf) { 591 return readData(is16BitBool, true, file, ii, offset, 592 length, outbuf); 593 }; 594 FRUReader readerBytewise(std::move(readFunc)); 595 pair = readFRUContents(readerBytewise, errorMessage); 596 } 597 598 if (pair.first.empty()) 599 { 600 continue; 601 } 602 603 devices->emplace(ii, pair.first); 604 fruAddresses[bus].insert(ii); 605 } 606 return 1; 607 }); 608 std::future_status status = 609 future.wait_for(std::chrono::seconds(busTimeoutSeconds)); 610 if (status == std::future_status::timeout) 611 { 612 std::cerr << "Error reading bus " << bus << "\n"; 613 if (powerIsOn) 614 { 615 busBlocklist[bus] = std::nullopt; 616 } 617 close(file); 618 return -1; 619 } 620 621 close(file); 622 return future.get(); 623 } 624 625 void loadBlocklist(const char* path) 626 { 627 std::ifstream blocklistStream(path); 628 if (!blocklistStream.good()) 629 { 630 // File is optional. 631 std::cerr << "Cannot open blocklist file.\n\n"; 632 return; 633 } 634 635 nlohmann::json data = 636 nlohmann::json::parse(blocklistStream, nullptr, false); 637 if (data.is_discarded()) 638 { 639 std::cerr << "Illegal blocklist file detected, cannot validate JSON, " 640 "exiting\n"; 641 std::exit(EXIT_FAILURE); 642 } 643 644 // It's expected to have at least one field, "buses" that is an array of the 645 // buses by integer. Allow for future options to exclude further aspects, 646 // such as specific addresses or ranges. 647 if (data.type() != nlohmann::json::value_t::object) 648 { 649 std::cerr << "Illegal blocklist, expected to read dictionary\n"; 650 std::exit(EXIT_FAILURE); 651 } 652 653 // If buses field is missing, that's fine. 654 if (data.count("buses") == 1) 655 { 656 // Parse the buses array after a little validation. 657 auto buses = data.at("buses"); 658 if (buses.type() != nlohmann::json::value_t::array) 659 { 660 // Buses field present but invalid, therefore this is an error. 661 std::cerr << "Invalid contents for blocklist buses field\n"; 662 std::exit(EXIT_FAILURE); 663 } 664 665 // Catch exception here for type mis-match. 666 try 667 { 668 for (const auto& busIterator : buses) 669 { 670 // If bus and addresses field are missing, that's fine. 671 if (busIterator.contains("bus") && 672 busIterator.contains("addresses")) 673 { 674 auto busData = busIterator.at("bus"); 675 auto bus = busData.get<size_t>(); 676 677 auto addressData = busIterator.at("addresses"); 678 auto addresses = 679 addressData.get<std::set<std::string_view>>(); 680 681 auto& block = busBlocklist[bus].emplace(); 682 for (const auto& address : addresses) 683 { 684 size_t addressInt = 0; 685 std::from_chars(address.begin() + 2, address.end(), 686 addressInt, 16); 687 block.insert(addressInt); 688 } 689 } 690 else 691 { 692 busBlocklist[busIterator.get<size_t>()] = std::nullopt; 693 } 694 } 695 } 696 catch (const nlohmann::detail::type_error& e) 697 { 698 // Type mis-match is a critical error. 699 std::cerr << "Invalid bus type: " << e.what() << "\n"; 700 std::exit(EXIT_FAILURE); 701 } 702 } 703 } 704 705 static void findI2CDevices(const std::vector<fs::path>& i2cBuses, 706 BusMap& busmap, const bool& powerIsOn, 707 sdbusplus::asio::object_server& objServer) 708 { 709 for (const auto& i2cBus : i2cBuses) 710 { 711 int bus = busStrToInt(i2cBus.string()); 712 713 if (bus < 0) 714 { 715 std::cerr << "Cannot translate " << i2cBus << " to int\n"; 716 continue; 717 } 718 auto busFind = busBlocklist.find(bus); 719 if (busFind != busBlocklist.end()) 720 { 721 if (busFind->second == std::nullopt) 722 { 723 continue; // Skip blocked busses. 724 } 725 } 726 int rootBus = getRootBus(bus); 727 auto rootBusFind = busBlocklist.find(rootBus); 728 if (rootBusFind != busBlocklist.end()) 729 { 730 if (rootBusFind->second == std::nullopt) 731 { 732 continue; 733 } 734 } 735 736 auto file = open(i2cBus.c_str(), O_RDWR); 737 if (file < 0) 738 { 739 std::cerr << "unable to open i2c device " << i2cBus.string() 740 << "\n"; 741 continue; 742 } 743 unsigned long funcs = 0; 744 745 if (ioctl(file, I2C_FUNCS, &funcs) < 0) 746 { 747 std::cerr 748 << "Error: Could not get the adapter functionality matrix bus " 749 << bus << "\n"; 750 close(file); 751 continue; 752 } 753 if (((funcs & I2C_FUNC_SMBUS_READ_BYTE) == 0U) || 754 ((I2C_FUNC_SMBUS_READ_I2C_BLOCK) == 0)) 755 { 756 std::cerr << "Error: Can't use SMBus Receive Byte command bus " 757 << bus << "\n"; 758 close(file); 759 continue; 760 } 761 auto& device = busmap[bus]; 762 device = std::make_shared<DeviceMap>(); 763 764 // i2cdetect by default uses the range 0x03 to 0x77, as 765 // this is what we have tested with, use this range. Could be 766 // changed in future. 767 lg2::debug("Scanning bus {BUS}", "BUS", bus); 768 769 // fd is closed in this function in case the bus locks up 770 getBusFRUs(file, 0x03, 0x77, bus, device, powerIsOn, objServer); 771 772 lg2::debug("Done scanning bus {BUS}", "BUS", bus); 773 } 774 } 775 776 // this class allows an async response after all i2c devices are discovered 777 struct FindDevicesWithCallback : 778 std::enable_shared_from_this<FindDevicesWithCallback> 779 { 780 FindDevicesWithCallback(const std::vector<fs::path>& i2cBuses, 781 BusMap& busmap, const bool& powerIsOn, 782 sdbusplus::asio::object_server& objServer, 783 std::function<void()>&& callback) : 784 _i2cBuses(i2cBuses), _busMap(busmap), _powerIsOn(powerIsOn), 785 _objServer(objServer), _callback(std::move(callback)) 786 {} 787 ~FindDevicesWithCallback() 788 { 789 _callback(); 790 } 791 void run() 792 { 793 findI2CDevices(_i2cBuses, _busMap, _powerIsOn, _objServer); 794 } 795 796 const std::vector<fs::path>& _i2cBuses; 797 BusMap& _busMap; 798 const bool& _powerIsOn; 799 sdbusplus::asio::object_server& _objServer; 800 std::function<void()> _callback; 801 }; 802 803 void addFruObjectToDbus( 804 std::vector<uint8_t>& device, 805 boost::container::flat_map< 806 std::pair<size_t, size_t>, 807 std::shared_ptr<sdbusplus::asio::dbus_interface>>& dbusInterfaceMap, 808 uint32_t bus, uint32_t address, size_t& unknownBusObjectCount, 809 const bool& powerIsOn, sdbusplus::asio::object_server& objServer, 810 std::shared_ptr<sdbusplus::asio::connection>& systemBus) 811 { 812 boost::container::flat_map<std::string, std::string> formattedFRU; 813 814 std::optional<std::string> optionalProductName = getProductName( 815 device, formattedFRU, bus, address, unknownBusObjectCount); 816 if (!optionalProductName) 817 { 818 std::cerr << "getProductName failed. product name is empty.\n"; 819 return; 820 } 821 822 std::string productName = 823 "/xyz/openbmc_project/FruDevice/" + optionalProductName.value(); 824 825 std::optional<int> index = findIndexForFRU(dbusInterfaceMap, productName); 826 if (index.has_value()) 827 { 828 productName += "_"; 829 productName += std::to_string(++(*index)); 830 } 831 832 std::shared_ptr<sdbusplus::asio::dbus_interface> iface = 833 objServer.add_interface(productName, "xyz.openbmc_project.FruDevice"); 834 dbusInterfaceMap[std::pair<size_t, size_t>(bus, address)] = iface; 835 836 for (auto& property : formattedFRU) 837 { 838 std::regex_replace(property.second.begin(), property.second.begin(), 839 property.second.end(), nonAsciiRegex, "_"); 840 if (property.second.empty() && property.first != "PRODUCT_ASSET_TAG") 841 { 842 continue; 843 } 844 std::string key = 845 std::regex_replace(property.first, nonAsciiRegex, "_"); 846 847 if (property.first == "PRODUCT_ASSET_TAG") 848 { 849 std::string propertyName = property.first; 850 iface->register_property( 851 key, property.second + '\0', 852 [bus, address, propertyName, &dbusInterfaceMap, 853 &unknownBusObjectCount, &powerIsOn, &objServer, 854 &systemBus](const std::string& req, std::string& resp) { 855 if (strcmp(req.c_str(), resp.c_str()) != 0) 856 { 857 // call the method which will update 858 if (updateFRUProperty(req, bus, address, propertyName, 859 dbusInterfaceMap, 860 unknownBusObjectCount, powerIsOn, 861 objServer, systemBus)) 862 { 863 resp = req; 864 } 865 else 866 { 867 throw std::invalid_argument( 868 "FRU property update failed."); 869 } 870 } 871 return 1; 872 }); 873 } 874 else if (!iface->register_property(key, property.second + '\0')) 875 { 876 std::cerr << "illegal key: " << key << "\n"; 877 } 878 lg2::debug("parsed FRU property: {FIRST}: {SECOND}", "FIRST", 879 property.first, "SECOND", property.second); 880 } 881 882 // baseboard will be 0, 0 883 iface->register_property("BUS", bus); 884 iface->register_property("ADDRESS", address); 885 886 iface->initialize(); 887 } 888 889 static bool readBaseboardFRU(std::vector<uint8_t>& baseboardFRU) 890 { 891 // try to read baseboard fru from file 892 std::ifstream baseboardFRUFile(baseboardFruLocation, std::ios::binary); 893 if (baseboardFRUFile.good()) 894 { 895 baseboardFRUFile.seekg(0, std::ios_base::end); 896 size_t fileSize = static_cast<size_t>(baseboardFRUFile.tellg()); 897 baseboardFRU.resize(fileSize); 898 baseboardFRUFile.seekg(0, std::ios_base::beg); 899 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 900 char* charOffset = reinterpret_cast<char*>(baseboardFRU.data()); 901 baseboardFRUFile.read(charOffset, fileSize); 902 } 903 else 904 { 905 return false; 906 } 907 return true; 908 } 909 910 bool writeFRU(uint8_t bus, uint8_t address, const std::vector<uint8_t>& fru) 911 { 912 boost::container::flat_map<std::string, std::string> tmp; 913 if (fru.size() > maxFruSize) 914 { 915 std::cerr << "Invalid fru.size() during writeFRU\n"; 916 return false; 917 } 918 // verify legal fru by running it through fru parsing logic 919 if (formatIPMIFRU(fru, tmp) != resCodes::resOK) 920 { 921 std::cerr << "Invalid fru format during writeFRU\n"; 922 return false; 923 } 924 // baseboard fru 925 if (bus == 0 && address == 0) 926 { 927 std::ofstream file(baseboardFruLocation, std::ios_base::binary); 928 if (!file.good()) 929 { 930 std::cerr << "Error opening file " << baseboardFruLocation << "\n"; 931 throw DBusInternalError(); 932 return false; 933 } 934 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 935 const char* charOffset = reinterpret_cast<const char*>(fru.data()); 936 file.write(charOffset, fru.size()); 937 return file.good(); 938 } 939 940 if (hasEepromFile(bus, address)) 941 { 942 auto path = getEepromPath(bus, address); 943 off_t offset = 0; 944 945 int eeprom = open(path.c_str(), O_RDWR | O_CLOEXEC); 946 if (eeprom < 0) 947 { 948 std::cerr << "unable to open i2c device " << path << "\n"; 949 throw DBusInternalError(); 950 return false; 951 } 952 953 std::array<uint8_t, I2C_SMBUS_BLOCK_MAX> blockData{}; 954 std::string errorMessage = "eeprom at " + std::to_string(bus) + 955 " address " + std::to_string(address); 956 auto readFunc = [eeprom](off_t offset, size_t length, uint8_t* outbuf) { 957 return readFromEeprom(eeprom, offset, length, outbuf); 958 }; 959 FRUReader reader(std::move(readFunc)); 960 961 if (!findFRUHeader(reader, errorMessage, blockData, offset)) 962 { 963 offset = 0; 964 } 965 966 if (lseek(eeprom, offset, SEEK_SET) < 0) 967 { 968 std::cerr << "Unable to seek to offset " << offset 969 << " in device: " << path << "\n"; 970 close(eeprom); 971 throw DBusInternalError(); 972 } 973 974 ssize_t writtenBytes = write(eeprom, fru.data(), fru.size()); 975 if (writtenBytes < 0) 976 { 977 std::cerr << "unable to write to i2c device " << path << "\n"; 978 close(eeprom); 979 throw DBusInternalError(); 980 return false; 981 } 982 983 close(eeprom); 984 return true; 985 } 986 987 std::string i2cBus = "/dev/i2c-" + std::to_string(bus); 988 989 int file = open(i2cBus.c_str(), O_RDWR | O_CLOEXEC); 990 if (file < 0) 991 { 992 std::cerr << "unable to open i2c device " << i2cBus << "\n"; 993 throw DBusInternalError(); 994 return false; 995 } 996 if (ioctl(file, I2C_SLAVE_FORCE, address) < 0) 997 { 998 std::cerr << "unable to set device address\n"; 999 close(file); 1000 throw DBusInternalError(); 1001 return false; 1002 } 1003 1004 constexpr const size_t retryMax = 2; 1005 uint16_t index = 0; 1006 size_t retries = retryMax; 1007 while (index < fru.size()) 1008 { 1009 if (((index != 0U) && ((index % (maxEepromPageIndex + 1)) == 0)) && 1010 (retries == retryMax)) 1011 { 1012 // The 4K EEPROM only uses the A2 and A1 device address bits 1013 // with the third bit being a memory page address bit. 1014 if (ioctl(file, I2C_SLAVE_FORCE, ++address) < 0) 1015 { 1016 std::cerr << "unable to set device address\n"; 1017 close(file); 1018 throw DBusInternalError(); 1019 return false; 1020 } 1021 } 1022 1023 if (i2c_smbus_write_byte_data(file, static_cast<uint8_t>(index), 1024 fru[index]) < 0) 1025 { 1026 if ((retries--) == 0U) 1027 { 1028 std::cerr << "error writing fru: " << strerror(errno) << "\n"; 1029 close(file); 1030 throw DBusInternalError(); 1031 return false; 1032 } 1033 } 1034 else 1035 { 1036 retries = retryMax; 1037 index++; 1038 } 1039 // most eeproms require 5-10ms between writes 1040 std::this_thread::sleep_for(std::chrono::milliseconds(10)); 1041 } 1042 close(file); 1043 return true; 1044 } 1045 1046 void rescanOneBus( 1047 BusMap& busmap, uint16_t busNum, 1048 boost::container::flat_map< 1049 std::pair<size_t, size_t>, 1050 std::shared_ptr<sdbusplus::asio::dbus_interface>>& dbusInterfaceMap, 1051 bool dbusCall, size_t& unknownBusObjectCount, const bool& powerIsOn, 1052 sdbusplus::asio::object_server& objServer, 1053 std::shared_ptr<sdbusplus::asio::connection>& systemBus) 1054 { 1055 for (auto device = foundDevices.begin(); device != foundDevices.end();) 1056 { 1057 if (device->first.first == static_cast<size_t>(busNum)) 1058 { 1059 objServer.remove_interface(device->second); 1060 device = foundDevices.erase(device); 1061 } 1062 else 1063 { 1064 device++; 1065 } 1066 } 1067 1068 fs::path busPath = fs::path("/dev/i2c-" + std::to_string(busNum)); 1069 if (!fs::exists(busPath)) 1070 { 1071 if (dbusCall) 1072 { 1073 std::cerr << "Unable to access i2c bus " << static_cast<int>(busNum) 1074 << "\n"; 1075 throw std::invalid_argument("Invalid Bus."); 1076 } 1077 return; 1078 } 1079 1080 std::vector<fs::path> i2cBuses; 1081 i2cBuses.emplace_back(busPath); 1082 1083 auto scan = std::make_shared<FindDevicesWithCallback>( 1084 i2cBuses, busmap, powerIsOn, objServer, 1085 [busNum, &busmap, &dbusInterfaceMap, &unknownBusObjectCount, &powerIsOn, 1086 &objServer, &systemBus]() { 1087 for (auto busIface = dbusInterfaceMap.begin(); 1088 busIface != dbusInterfaceMap.end();) 1089 { 1090 if (busIface->first.first == static_cast<size_t>(busNum)) 1091 { 1092 objServer.remove_interface(busIface->second); 1093 busIface = dbusInterfaceMap.erase(busIface); 1094 } 1095 else 1096 { 1097 busIface++; 1098 } 1099 } 1100 auto found = busmap.find(busNum); 1101 if (found == busmap.end() || found->second == nullptr) 1102 { 1103 return; 1104 } 1105 for (auto& device : *(found->second)) 1106 { 1107 addFruObjectToDbus(device.second, dbusInterfaceMap, 1108 static_cast<uint32_t>(busNum), device.first, 1109 unknownBusObjectCount, powerIsOn, objServer, 1110 systemBus); 1111 } 1112 }); 1113 scan->run(); 1114 } 1115 1116 void rescanBusses( 1117 BusMap& busmap, 1118 boost::container::flat_map< 1119 std::pair<size_t, size_t>, 1120 std::shared_ptr<sdbusplus::asio::dbus_interface>>& dbusInterfaceMap, 1121 size_t& unknownBusObjectCount, const bool& powerIsOn, 1122 sdbusplus::asio::object_server& objServer, 1123 std::shared_ptr<sdbusplus::asio::connection>& systemBus) 1124 { 1125 static boost::asio::steady_timer timer(io); 1126 timer.expires_from_now(std::chrono::seconds(1)); 1127 1128 // setup an async wait in case we get flooded with requests 1129 timer.async_wait([&](const boost::system::error_code& ec) { 1130 if (ec == boost::asio::error::operation_aborted) 1131 { 1132 return; 1133 } 1134 1135 if (ec) 1136 { 1137 std::cerr << "Error in timer: " << ec.message() << "\n"; 1138 return; 1139 } 1140 1141 auto devDir = fs::path("/dev/"); 1142 std::vector<fs::path> i2cBuses; 1143 1144 boost::container::flat_map<size_t, fs::path> busPaths; 1145 if (!getI2cDevicePaths(devDir, busPaths)) 1146 { 1147 std::cerr << "unable to find i2c devices\n"; 1148 return; 1149 } 1150 1151 for (const auto& busPath : busPaths) 1152 { 1153 i2cBuses.emplace_back(busPath.second); 1154 } 1155 1156 busmap.clear(); 1157 for (auto& [pair, interface] : foundDevices) 1158 { 1159 objServer.remove_interface(interface); 1160 } 1161 foundDevices.clear(); 1162 1163 auto scan = std::make_shared<FindDevicesWithCallback>( 1164 i2cBuses, busmap, powerIsOn, objServer, [&]() { 1165 for (auto& busIface : dbusInterfaceMap) 1166 { 1167 objServer.remove_interface(busIface.second); 1168 } 1169 1170 dbusInterfaceMap.clear(); 1171 unknownBusObjectCount = 0; 1172 1173 // todo, get this from a more sensable place 1174 std::vector<uint8_t> baseboardFRU; 1175 if (readBaseboardFRU(baseboardFRU)) 1176 { 1177 // If no device on i2c bus 0, the insertion will happen. 1178 auto bus0 = 1179 busmap.try_emplace(0, std::make_shared<DeviceMap>()); 1180 bus0.first->second->emplace(0, baseboardFRU); 1181 } 1182 for (auto& devicemap : busmap) 1183 { 1184 for (auto& device : *devicemap.second) 1185 { 1186 addFruObjectToDbus(device.second, dbusInterfaceMap, 1187 devicemap.first, device.first, 1188 unknownBusObjectCount, powerIsOn, 1189 objServer, systemBus); 1190 } 1191 } 1192 }); 1193 scan->run(); 1194 }); 1195 } 1196 1197 // Details with example of Asset Tag Update 1198 // To find location of Product Info Area asset tag as per FRU specification 1199 // 1. Find product Info area starting offset (*8 - as header will be in 1200 // multiple of 8 bytes). 1201 // 2. Skip 3 bytes of product info area (like format version, area length, 1202 // and language code). 1203 // 3. Traverse manufacturer name, product name, product version, & product 1204 // serial number, by reading type/length code to reach the Asset Tag. 1205 // 4. Update the Asset Tag, reposition the product Info area in multiple of 1206 // 8 bytes. Update the Product area length and checksum. 1207 1208 bool updateFRUProperty( 1209 const std::string& updatePropertyReq, uint32_t bus, uint32_t address, 1210 const std::string& propertyName, 1211 boost::container::flat_map< 1212 std::pair<size_t, size_t>, 1213 std::shared_ptr<sdbusplus::asio::dbus_interface>>& dbusInterfaceMap, 1214 size_t& unknownBusObjectCount, const bool& powerIsOn, 1215 sdbusplus::asio::object_server& objServer, 1216 std::shared_ptr<sdbusplus::asio::connection>& systemBus) 1217 { 1218 size_t updatePropertyReqLen = updatePropertyReq.length(); 1219 if (updatePropertyReqLen == 1 || updatePropertyReqLen > 63) 1220 { 1221 std::cerr 1222 << "FRU field data cannot be of 1 char or more than 63 chars. " 1223 "Invalid Length " 1224 << updatePropertyReqLen << "\n"; 1225 return false; 1226 } 1227 1228 std::vector<uint8_t> fruData; 1229 1230 if (!getFruData(fruData, bus, address)) 1231 { 1232 std::cerr << "Failure getting FRU Data \n"; 1233 return false; 1234 } 1235 1236 struct FruArea fruAreaParams{}; 1237 1238 if (!findFruAreaLocationAndField(fruData, propertyName, fruAreaParams)) 1239 { 1240 std::cerr << "findFruAreaLocationAndField failed \n"; 1241 return false; 1242 } 1243 1244 std::vector<uint8_t> restFRUAreaFieldsData; 1245 if (!copyRestFRUArea(fruData, propertyName, fruAreaParams, 1246 restFRUAreaFieldsData)) 1247 { 1248 std::cerr << "copyRestFRUArea failed \n"; 1249 return false; 1250 } 1251 1252 // Push post update fru areas if any 1253 unsigned int nextFRUAreaLoc = 0; 1254 for (fruAreas nextFRUArea = fruAreas::fruAreaInternal; 1255 nextFRUArea <= fruAreas::fruAreaMultirecord; ++nextFRUArea) 1256 { 1257 unsigned int fruAreaLoc = 1258 fruData[getHeaderAreaFieldOffset(nextFRUArea)] * fruBlockSize; 1259 if ((fruAreaLoc > fruAreaParams.restFieldsEnd) && 1260 ((nextFRUAreaLoc == 0) || (fruAreaLoc < nextFRUAreaLoc))) 1261 { 1262 nextFRUAreaLoc = fruAreaLoc; 1263 } 1264 } 1265 std::vector<uint8_t> restFRUAreasData; 1266 if (nextFRUAreaLoc != 0U) 1267 { 1268 std::copy_n(fruData.begin() + nextFRUAreaLoc, 1269 fruData.size() - nextFRUAreaLoc, 1270 std::back_inserter(restFRUAreasData)); 1271 } 1272 1273 // check FRU area size 1274 size_t fruAreaDataSize = 1275 ((fruAreaParams.updateFieldLoc - fruAreaParams.start + 1) + 1276 restFRUAreaFieldsData.size()); 1277 size_t fruAreaAvailableSize = fruAreaParams.size - fruAreaDataSize; 1278 if ((updatePropertyReqLen + 1) > fruAreaAvailableSize) 1279 { 1280 #ifdef ENABLE_FRU_AREA_RESIZE 1281 size_t newFRUAreaSize = fruAreaDataSize + updatePropertyReqLen + 1; 1282 // round size to 8-byte blocks 1283 newFRUAreaSize = 1284 ((newFRUAreaSize - 1) / fruBlockSize + 1) * fruBlockSize; 1285 size_t newFRUDataSize = 1286 fruData.size() + newFRUAreaSize - fruAreaParams.size; 1287 fruData.resize(newFRUDataSize); 1288 fruAreaParams.size = newFRUAreaSize; 1289 fruAreaParams.end = fruAreaParams.start + fruAreaParams.size; 1290 #else 1291 std::cerr << "FRU field length: " << updatePropertyReqLen + 1 1292 << " should not be greater than available FRU area size: " 1293 << fruAreaAvailableSize << "\n"; 1294 return false; 1295 #endif // ENABLE_FRU_AREA_RESIZE 1296 } 1297 1298 // write new requested property field length and data 1299 constexpr uint8_t newTypeLenMask = 0xC0; 1300 fruData[fruAreaParams.updateFieldLoc] = 1301 static_cast<uint8_t>(updatePropertyReqLen | newTypeLenMask); 1302 fruAreaParams.updateFieldLoc++; 1303 std::copy(updatePropertyReq.begin(), updatePropertyReq.end(), 1304 fruData.begin() + fruAreaParams.updateFieldLoc); 1305 1306 // Copy remaining data to main fru area - post updated fru field vector 1307 fruAreaParams.restFieldsLoc = 1308 fruAreaParams.updateFieldLoc + updatePropertyReqLen; 1309 size_t fruAreaDataEnd = 1310 fruAreaParams.restFieldsLoc + restFRUAreaFieldsData.size(); 1311 1312 std::copy(restFRUAreaFieldsData.begin(), restFRUAreaFieldsData.end(), 1313 fruData.begin() + fruAreaParams.restFieldsLoc); 1314 1315 // Update final fru with new fru area length and checksum 1316 unsigned int nextFRUAreaNewLoc = updateFRUAreaLenAndChecksum( 1317 fruData, fruAreaParams.start, fruAreaDataEnd, fruAreaParams.end); 1318 1319 #ifdef ENABLE_FRU_AREA_RESIZE 1320 ++nextFRUAreaNewLoc; 1321 ssize_t nextFRUAreaOffsetDiff = 1322 (nextFRUAreaNewLoc - nextFRUAreaLoc) / fruBlockSize; 1323 // Append rest FRU Areas if size changed and there were other sections after 1324 // updated one 1325 if (nextFRUAreaOffsetDiff && nextFRUAreaLoc) 1326 { 1327 std::copy(restFRUAreasData.begin(), restFRUAreasData.end(), 1328 fruData.begin() + nextFRUAreaNewLoc); 1329 // Update Common Header 1330 for (fruAreas nextFRUArea = fruAreas::fruAreaInternal; 1331 nextFRUArea <= fruAreas::fruAreaMultirecord; ++nextFRUArea) 1332 { 1333 unsigned int fruAreaOffsetField = 1334 getHeaderAreaFieldOffset(nextFRUArea); 1335 size_t curFRUAreaOffset = fruData[fruAreaOffsetField]; 1336 if (curFRUAreaOffset > fruAreaParams.end) 1337 { 1338 fruData[fruAreaOffsetField] = static_cast<int8_t>( 1339 curFRUAreaOffset + nextFRUAreaOffsetDiff); 1340 } 1341 } 1342 // Calculate new checksum 1343 std::vector<uint8_t> headerFRUData; 1344 std::copy_n(fruData.begin(), 7, std::back_inserter(headerFRUData)); 1345 size_t checksumVal = calculateChecksum(headerFRUData); 1346 fruData[7] = static_cast<uint8_t>(checksumVal); 1347 // fill zeros if FRU Area size decreased 1348 if (nextFRUAreaOffsetDiff < 0) 1349 { 1350 std::fill(fruData.begin() + nextFRUAreaNewLoc + 1351 restFRUAreasData.size(), 1352 fruData.end(), 0); 1353 } 1354 } 1355 #else 1356 // this is to avoid "unused variable" warning 1357 (void)nextFRUAreaNewLoc; 1358 #endif // ENABLE_FRU_AREA_RESIZE 1359 if (fruData.empty()) 1360 { 1361 return false; 1362 } 1363 1364 if (!writeFRU(static_cast<uint8_t>(bus), static_cast<uint8_t>(address), 1365 fruData)) 1366 { 1367 return false; 1368 } 1369 1370 // Rescan the bus so that GetRawFru dbus-call fetches updated values 1371 rescanBusses(busMap, dbusInterfaceMap, unknownBusObjectCount, powerIsOn, 1372 objServer, systemBus); 1373 return true; 1374 } 1375 1376 int main() 1377 { 1378 auto systemBus = std::make_shared<sdbusplus::asio::connection>(io); 1379 sdbusplus::asio::object_server objServer(systemBus); 1380 1381 static size_t unknownBusObjectCount = 0; 1382 static bool powerIsOn = false; 1383 auto devDir = fs::path("/dev/"); 1384 auto matchString = std::string(R"(i2c-\d+$)"); 1385 std::vector<fs::path> i2cBuses; 1386 1387 if (!findFiles(devDir, matchString, i2cBuses)) 1388 { 1389 std::cerr << "unable to find i2c devices\n"; 1390 return 1; 1391 } 1392 1393 // check for and load blocklist with initial buses. 1394 loadBlocklist(blocklistPath); 1395 1396 systemBus->request_name("xyz.openbmc_project.FruDevice"); 1397 1398 // this is a map with keys of pair(bus number, address) and values of 1399 // the object on dbus 1400 boost::container::flat_map<std::pair<size_t, size_t>, 1401 std::shared_ptr<sdbusplus::asio::dbus_interface>> 1402 dbusInterfaceMap; 1403 1404 std::shared_ptr<sdbusplus::asio::dbus_interface> iface = 1405 objServer.add_interface("/xyz/openbmc_project/FruDevice", 1406 "xyz.openbmc_project.FruDeviceManager"); 1407 1408 iface->register_method("ReScan", [&]() { 1409 rescanBusses(busMap, dbusInterfaceMap, unknownBusObjectCount, powerIsOn, 1410 objServer, systemBus); 1411 }); 1412 1413 iface->register_method("ReScanBus", [&](uint16_t bus) { 1414 rescanOneBus(busMap, bus, dbusInterfaceMap, true, unknownBusObjectCount, 1415 powerIsOn, objServer, systemBus); 1416 }); 1417 1418 iface->register_method("GetRawFru", getFRUInfo); 1419 1420 iface->register_method( 1421 "WriteFru", [&](const uint16_t bus, const uint8_t address, 1422 const std::vector<uint8_t>& data) { 1423 if (!writeFRU(bus, address, data)) 1424 { 1425 throw std::invalid_argument("Invalid Arguments."); 1426 return; 1427 } 1428 // schedule rescan on success 1429 rescanBusses(busMap, dbusInterfaceMap, unknownBusObjectCount, 1430 powerIsOn, objServer, systemBus); 1431 }); 1432 iface->initialize(); 1433 1434 std::function<void(sdbusplus::message_t & message)> eventHandler = 1435 [&](sdbusplus::message_t& message) { 1436 std::string objectName; 1437 boost::container::flat_map< 1438 std::string, 1439 std::variant<std::string, bool, int64_t, uint64_t, double>> 1440 values; 1441 message.read(objectName, values); 1442 auto findState = values.find("CurrentHostState"); 1443 if (findState != values.end()) 1444 { 1445 if (std::get<std::string>(findState->second) == 1446 "xyz.openbmc_project.State.Host.HostState.Running") 1447 { 1448 powerIsOn = true; 1449 } 1450 } 1451 1452 if (powerIsOn) 1453 { 1454 rescanBusses(busMap, dbusInterfaceMap, unknownBusObjectCount, 1455 powerIsOn, objServer, systemBus); 1456 } 1457 }; 1458 1459 sdbusplus::bus::match_t powerMatch = sdbusplus::bus::match_t( 1460 static_cast<sdbusplus::bus_t&>(*systemBus), 1461 "type='signal',interface='org.freedesktop.DBus.Properties',path='/xyz/" 1462 "openbmc_project/state/" 1463 "host0',arg0='xyz.openbmc_project.State.Host'", 1464 eventHandler); 1465 1466 int fd = inotify_init(); 1467 inotify_add_watch(fd, i2CDevLocation, IN_CREATE | IN_MOVED_TO | IN_DELETE); 1468 std::array<char, 4096> readBuffer{}; 1469 // monitor for new i2c devices 1470 boost::asio::posix::stream_descriptor dirWatch(io, fd); 1471 std::function<void(const boost::system::error_code, std::size_t)> 1472 watchI2cBusses = [&](const boost::system::error_code& ec, 1473 std::size_t bytesTransferred) { 1474 if (ec) 1475 { 1476 std::cout << "Callback Error " << ec << "\n"; 1477 return; 1478 } 1479 size_t index = 0; 1480 while ((index + sizeof(inotify_event)) <= bytesTransferred) 1481 { 1482 const char* p = &readBuffer[index]; 1483 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1484 const auto* iEvent = reinterpret_cast<const inotify_event*>(p); 1485 switch (iEvent->mask) 1486 { 1487 case IN_CREATE: 1488 case IN_MOVED_TO: 1489 case IN_DELETE: 1490 { 1491 std::string_view name(&iEvent->name[0], iEvent->len); 1492 if (boost::starts_with(name, "i2c")) 1493 { 1494 int bus = busStrToInt(name); 1495 if (bus < 0) 1496 { 1497 std::cerr 1498 << "Could not parse bus " << name << "\n"; 1499 continue; 1500 } 1501 int rootBus = getRootBus(bus); 1502 if (rootBus >= 0) 1503 { 1504 rescanOneBus(busMap, 1505 static_cast<uint16_t>(rootBus), 1506 dbusInterfaceMap, false, 1507 unknownBusObjectCount, powerIsOn, 1508 objServer, systemBus); 1509 } 1510 rescanOneBus(busMap, static_cast<uint16_t>(bus), 1511 dbusInterfaceMap, false, 1512 unknownBusObjectCount, powerIsOn, 1513 objServer, systemBus); 1514 } 1515 } 1516 break; 1517 default: 1518 break; 1519 } 1520 index += sizeof(inotify_event) + iEvent->len; 1521 } 1522 1523 dirWatch.async_read_some(boost::asio::buffer(readBuffer), 1524 watchI2cBusses); 1525 }; 1526 1527 dirWatch.async_read_some(boost::asio::buffer(readBuffer), watchI2cBusses); 1528 // run the initial scan 1529 rescanBusses(busMap, dbusInterfaceMap, unknownBusObjectCount, powerIsOn, 1530 objServer, systemBus); 1531 1532 io.run(); 1533 return 0; 1534 } 1535