1 2 #include "estoraged.hpp" 3 #include "getConfig.hpp" 4 #include "util.hpp" 5 6 #include <boost/asio/deadline_timer.hpp> 7 #include <boost/asio/io_context.hpp> 8 #include <boost/asio/post.hpp> 9 #include <boost/container/flat_map.hpp> 10 #include <boost/container/throw_exception.hpp> 11 #include <phosphor-logging/lg2.hpp> 12 #include <sdbusplus/asio/connection.hpp> 13 #include <sdbusplus/asio/object_server.hpp> 14 #include <sdbusplus/bus.hpp> 15 #include <sdbusplus/bus/match.hpp> 16 #include <util.hpp> 17 18 #include <cstdlib> 19 #include <filesystem> 20 #include <iostream> 21 #include <memory> 22 #include <optional> 23 #include <string> 24 25 /* 26 * Get the configuration objects from Entity Manager and create new D-Bus 27 * objects for each one. This function can be called multiple times, in case 28 * new configuration objects show up later. 29 * 30 * Note: Currently, eStoraged can only support 1 eMMC device. 31 * Additional changes will be needed to support more than 1 eMMC, or to support 32 * more types of storage devices. 33 */ 34 void createStorageObjects( 35 sdbusplus::asio::object_server& objectServer, 36 boost::container::flat_map< 37 std::string, std::unique_ptr<estoraged::EStoraged>>& storageObjects, 38 std::shared_ptr<sdbusplus::asio::connection>& dbusConnection) 39 { 40 auto getter = std::make_shared<estoraged::GetStorageConfiguration>( 41 dbusConnection, 42 [&objectServer, &storageObjects]( 43 const estoraged::ManagedStorageType& storageConfigurations) { 44 size_t numConfigObj = storageConfigurations.size(); 45 if (numConfigObj > 1) 46 { 47 lg2::error("eStoraged can only manage 1 eMMC device; found {NUM}", 48 "NUM", numConfigObj, "REDFISH_MESSAGE_ID", 49 std::string("OpenBMC.0.1.CreateStorageObjectsFail")); 50 return; 51 } 52 53 for (const std::pair<sdbusplus::message::object_path, 54 estoraged::StorageData>& storage : 55 storageConfigurations) 56 { 57 const std::string& path = storage.first.str; 58 59 if (storageObjects.find(path) != storageObjects.end()) 60 { 61 /* 62 * We've already created this object, or at least 63 * attempted to. 64 */ 65 continue; 66 } 67 68 /* Get the properties from the config object. */ 69 const estoraged::StorageData& data = storage.second; 70 71 /* Look for the device file. */ 72 const std::filesystem::path blockDevDir{"/sys/block"}; 73 auto deviceInfo = estoraged::util::findDevice(data, blockDevDir); 74 if (!deviceInfo) 75 { 76 lg2::error("Device not found for path {PATH}", "PATH", path, 77 "REDFISH_MESSAGE_ID", 78 std::string("OpenBMC.0.1.CreateStorageObjectsFail")); 79 /* 80 * Set a NULL pointer as a placeholder, so that we don't 81 * try and fail again later. 82 */ 83 storageObjects[path] = nullptr; 84 continue; 85 } 86 87 std::filesystem::path deviceFile = 88 std::move(deviceInfo->deviceFile); 89 std::filesystem::path sysfsDir = std::move(deviceInfo->sysfsDir); 90 std::string luksName = std::move(deviceInfo->luksName); 91 std::string locationCode = std::move(deviceInfo->locationCode); 92 uint64_t eraseMaxGeometry = deviceInfo->eraseMaxGeometry; 93 uint64_t eraseMinGeometry = deviceInfo->eraseMinGeometry; 94 95 uint64_t size = estoraged::util::findSizeOfBlockDevice(deviceFile); 96 97 uint8_t lifeleft = 98 estoraged::util::findPredictedMediaLifeLeftPercent(sysfsDir); 99 std::string partNumber = estoraged::util::getPartNumber(sysfsDir); 100 std::string serialNumber = 101 estoraged::util::getSerialNumber(sysfsDir); 102 const std::string& driveType = deviceInfo->driveType; 103 const std::string& driveProtocol = deviceInfo->driveProtocol; 104 /* Create the storage object. */ 105 storageObjects[path] = std::make_unique<estoraged::EStoraged>( 106 objectServer, path, deviceFile, luksName, size, lifeleft, 107 partNumber, serialNumber, locationCode, eraseMaxGeometry, 108 eraseMinGeometry, driveType, driveProtocol); 109 lg2::info("Created eStoraged object for path {PATH}", "PATH", path, 110 "REDFISH_MESSAGE_ID", 111 std::string("OpenBMC.0.1.CreateStorageObjects")); 112 } 113 }); 114 getter->getConfiguration(); 115 } 116 117 int main(void) 118 { 119 try 120 { 121 // setup connection to dbus 122 boost::asio::io_context io; 123 auto conn = std::make_shared<sdbusplus::asio::connection>(io); 124 // request D-Bus server name. 125 conn->request_name("xyz.openbmc_project.eStoraged"); 126 sdbusplus::asio::object_server server(conn); 127 boost::container::flat_map<std::string, 128 std::unique_ptr<estoraged::EStoraged>> 129 storageObjects; 130 131 boost::asio::post( 132 io, [&]() { createStorageObjects(server, storageObjects, conn); }); 133 134 /* 135 * Set up an event handler to process any new configuration objects 136 * that show up later. 137 */ 138 boost::asio::deadline_timer filterTimer(io); 139 std::function<void(sdbusplus::message_t&)> eventHandler = 140 [&](sdbusplus::message_t& message) { 141 if (message.is_method_error()) 142 { 143 lg2::error("eventHandler callback method error"); 144 return; 145 } 146 /* 147 * This implicitly cancels the timer, if it's already pending. 148 * If there's a burst of events within a short period, we want 149 * to handle them all at once. So, we will wait this long for no 150 * more events to occur, before processing them. 151 */ 152 filterTimer.expires_from_now(boost::posix_time::seconds(1)); 153 154 filterTimer.async_wait([&](const boost::system::error_code& ec) { 155 if (ec == boost::asio::error::operation_aborted) 156 { 157 /* we were canceled */ 158 return; 159 } 160 if (ec) 161 { 162 lg2::error("timer error"); 163 return; 164 } 165 createStorageObjects(server, storageObjects, conn); 166 }); 167 }; 168 169 auto match = std::make_unique<sdbusplus::bus::match_t>( 170 static_cast<sdbusplus::bus_t&>(*conn), 171 "type='signal',member='PropertiesChanged',path_namespace='" + 172 std::string("/xyz/openbmc_project/inventory") + 173 "',arg0namespace='" + estoraged::emmcConfigInterface + "'", 174 eventHandler); 175 176 lg2::info("Storage management service is running", "REDFISH_MESSAGE_ID", 177 std::string("OpenBMC.1.0.ServiceStarted")); 178 179 io.run(); 180 return 0; 181 } 182 catch (const std::exception& e) 183 { 184 lg2::error(e.what(), "REDFISH_MESSAGE_ID", 185 std::string("OpenBMC.1.0.ServiceException")); 186 187 return 2; 188 } 189 return 1; 190 } 191