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