Gunnar Mills | b0ce996 | 2018-09-07 13:39:10 -0500 | [diff] [blame] | 1 | #include "config.h" |
| 2 | |
| 3 | #include "item_updater.hpp" |
| 4 | |
| 5 | #include "images.hpp" |
| 6 | #include "serialize.hpp" |
| 7 | #include "version.hpp" |
Chanh Nguyen | 1fd6ddd | 2021-01-06 11:09:09 +0700 | [diff] [blame] | 8 | #include "xyz/openbmc_project/Software/ExtendedVersion/server.hpp" |
Gunnar Mills | b0ce996 | 2018-09-07 13:39:10 -0500 | [diff] [blame] | 9 | #include "xyz/openbmc_project/Software/Version/server.hpp" |
| 10 | |
Adriana Kobylak | d5b8f75 | 2019-05-01 11:52:35 -0500 | [diff] [blame] | 11 | #include <phosphor-logging/elog-errors.hpp> |
Gunnar Mills | b0ce996 | 2018-09-07 13:39:10 -0500 | [diff] [blame] | 12 | #include <phosphor-logging/elog.hpp> |
Patrick Williams | c9bb642 | 2021-08-27 06:18:35 -0500 | [diff] [blame] | 13 | #include <phosphor-logging/lg2.hpp> |
Adriana Kobylak | 58aa750 | 2020-06-08 11:12:11 -0500 | [diff] [blame] | 14 | #include <xyz/openbmc_project/Common/error.hpp> |
| 15 | #include <xyz/openbmc_project/Software/Image/error.hpp> |
| 16 | |
| 17 | #include <filesystem> |
| 18 | #include <fstream> |
Adriana Kobylak | 204e1e7 | 2018-01-24 16:00:05 -0600 | [diff] [blame] | 19 | #include <queue> |
Adriana Kobylak | b77551c | 2017-10-27 12:46:23 -0500 | [diff] [blame] | 20 | #include <set> |
Gunnar Mills | ec1b41c | 2017-05-02 12:20:36 -0500 | [diff] [blame] | 21 | #include <string> |
George Liu | 44b9fef | 2023-02-07 14:31:32 +0800 | [diff] [blame] | 22 | #include <system_error> |
Gunnar Mills | ec1b41c | 2017-05-02 12:20:36 -0500 | [diff] [blame] | 23 | |
| 24 | namespace phosphor |
| 25 | { |
| 26 | namespace software |
| 27 | { |
| 28 | namespace updater |
| 29 | { |
| 30 | |
Gunnar Mills | 2ce7da2 | 2017-05-04 15:37:56 -0500 | [diff] [blame] | 31 | // When you see server:: you know we're referencing our base class |
Patrick Williams | 1e9a5f1 | 2023-08-23 16:53:06 -0500 | [diff] [blame] | 32 | namespace server = sdbusplus::server::xyz::openbmc_project::software; |
| 33 | namespace control = sdbusplus::server::xyz::openbmc_project::control; |
Gunnar Mills | 2ce7da2 | 2017-05-04 15:37:56 -0500 | [diff] [blame] | 34 | |
Patrick Williams | c9bb642 | 2021-08-27 06:18:35 -0500 | [diff] [blame] | 35 | PHOSPHOR_LOG2_USING; |
Gunnar Mills | 2ce7da2 | 2017-05-04 15:37:56 -0500 | [diff] [blame] | 36 | using namespace phosphor::logging; |
Adriana Kobylak | ce82de5 | 2024-01-16 13:56:38 -0600 | [diff] [blame] | 37 | using namespace sdbusplus::error::xyz::openbmc_project::software::image; |
Jayanth Othayoth | 2ab9b10 | 2018-02-21 05:27:47 -0600 | [diff] [blame] | 38 | using namespace phosphor::software::image; |
Adriana Kobylak | c98d912 | 2020-05-05 10:36:01 -0500 | [diff] [blame] | 39 | namespace fs = std::filesystem; |
Adriana Kobylak | ce82de5 | 2024-01-16 13:56:38 -0600 | [diff] [blame] | 40 | using NotAllowed = sdbusplus::error::xyz::openbmc_project::common::NotAllowed; |
Saqib Khan | 35e83f3 | 2017-05-22 11:37:32 -0500 | [diff] [blame] | 41 | |
Patrick Williams | bf2bb2b | 2022-07-22 19:26:52 -0500 | [diff] [blame] | 42 | void ItemUpdater::createActivation(sdbusplus::message_t& msg) |
Gunnar Mills | ec1b41c | 2017-05-02 12:20:36 -0500 | [diff] [blame] | 43 | { |
Saqib Khan | 84a0e69 | 2017-06-28 17:27:01 -0500 | [diff] [blame] | 44 | using SVersion = server::Version; |
| 45 | using VersionPurpose = SVersion::VersionPurpose; |
Gunnar Mills | 9a78224 | 2017-08-22 16:23:15 -0500 | [diff] [blame] | 46 | using VersionClass = phosphor::software::manager::Version; |
Saqib Khan | 84a0e69 | 2017-06-28 17:27:01 -0500 | [diff] [blame] | 47 | |
Patrick Williams | bc1facd | 2020-06-03 05:58:27 -0500 | [diff] [blame] | 48 | sdbusplus::message::object_path objPath; |
Saqib Khan | 84a0e69 | 2017-06-28 17:27:01 -0500 | [diff] [blame] | 49 | auto purpose = VersionPurpose::Unknown; |
Chanh Nguyen | 1fd6ddd | 2021-01-06 11:09:09 +0700 | [diff] [blame] | 50 | std::string extendedVersion; |
Saqib Khan | 705f1bf | 2017-06-09 23:58:38 -0500 | [diff] [blame] | 51 | std::string version; |
Justin Ledford | 054bb0b | 2022-03-15 15:46:58 -0700 | [diff] [blame] | 52 | std::map<std::string, |
| 53 | std::map<std::string, |
| 54 | std::variant<std::string, std::vector<std::string>>>> |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 55 | interfaces; |
Patrick Williams | e75d10f | 2017-05-30 16:56:32 -0500 | [diff] [blame] | 56 | msg.read(objPath, interfaces); |
Gunnar Mills | 2ce7da2 | 2017-05-04 15:37:56 -0500 | [diff] [blame] | 57 | std::string path(std::move(objPath)); |
Saqib Khan | 19177d3 | 2017-06-20 08:11:49 -0500 | [diff] [blame] | 58 | std::string filePath; |
Justin Ledford | 054bb0b | 2022-03-15 15:46:58 -0700 | [diff] [blame] | 59 | std::vector<std::string> compatibleNames; |
Gunnar Mills | 2ce7da2 | 2017-05-04 15:37:56 -0500 | [diff] [blame] | 60 | |
| 61 | for (const auto& intf : interfaces) |
| 62 | { |
Saqib Khan | 705f1bf | 2017-06-09 23:58:38 -0500 | [diff] [blame] | 63 | if (intf.first == VERSION_IFACE) |
Gunnar Mills | 2ce7da2 | 2017-05-04 15:37:56 -0500 | [diff] [blame] | 64 | { |
Saqib Khan | 705f1bf | 2017-06-09 23:58:38 -0500 | [diff] [blame] | 65 | for (const auto& property : intf.second) |
Gunnar Mills | 2ce7da2 | 2017-05-04 15:37:56 -0500 | [diff] [blame] | 66 | { |
Saqib Khan | 705f1bf | 2017-06-09 23:58:38 -0500 | [diff] [blame] | 67 | if (property.first == "Purpose") |
Gunnar Mills | 2ce7da2 | 2017-05-04 15:37:56 -0500 | [diff] [blame] | 68 | { |
Saqib Khan | 84a0e69 | 2017-06-28 17:27:01 -0500 | [diff] [blame] | 69 | auto value = SVersion::convertVersionPurposeFromString( |
Patrick Williams | e883fb8 | 2020-05-13 11:38:55 -0500 | [diff] [blame] | 70 | std::get<std::string>(property.second)); |
Saqib Khan | 84a0e69 | 2017-06-28 17:27:01 -0500 | [diff] [blame] | 71 | if (value == VersionPurpose::BMC || |
Vijay Khemka | e9f6c84 | 2020-01-14 14:32:39 -0800 | [diff] [blame] | 72 | #ifdef HOST_BIOS_UPGRADE |
| 73 | value == VersionPurpose::Host || |
| 74 | #endif |
Saqib Khan | 84a0e69 | 2017-06-28 17:27:01 -0500 | [diff] [blame] | 75 | value == VersionPurpose::System) |
| 76 | { |
| 77 | purpose = value; |
| 78 | } |
Saqib Khan | 705f1bf | 2017-06-09 23:58:38 -0500 | [diff] [blame] | 79 | } |
| 80 | else if (property.first == "Version") |
| 81 | { |
Patrick Williams | e883fb8 | 2020-05-13 11:38:55 -0500 | [diff] [blame] | 82 | version = std::get<std::string>(property.second); |
Gunnar Mills | 2ce7da2 | 2017-05-04 15:37:56 -0500 | [diff] [blame] | 83 | } |
| 84 | } |
| 85 | } |
Saqib Khan | 19177d3 | 2017-06-20 08:11:49 -0500 | [diff] [blame] | 86 | else if (intf.first == FILEPATH_IFACE) |
| 87 | { |
| 88 | for (const auto& property : intf.second) |
| 89 | { |
| 90 | if (property.first == "Path") |
| 91 | { |
Patrick Williams | e883fb8 | 2020-05-13 11:38:55 -0500 | [diff] [blame] | 92 | filePath = std::get<std::string>(property.second); |
Saqib Khan | 19177d3 | 2017-06-20 08:11:49 -0500 | [diff] [blame] | 93 | } |
| 94 | } |
| 95 | } |
Chanh Nguyen | 1fd6ddd | 2021-01-06 11:09:09 +0700 | [diff] [blame] | 96 | else if (intf.first == EXTENDED_VERSION_IFACE) |
| 97 | { |
| 98 | for (const auto& property : intf.second) |
| 99 | { |
| 100 | if (property.first == "ExtendedVersion") |
| 101 | { |
| 102 | extendedVersion = std::get<std::string>(property.second); |
| 103 | } |
| 104 | } |
| 105 | } |
Justin Ledford | 054bb0b | 2022-03-15 15:46:58 -0700 | [diff] [blame] | 106 | else if (intf.first == COMPATIBLE_IFACE) |
| 107 | { |
| 108 | for (const auto& property : intf.second) |
| 109 | { |
| 110 | if (property.first == "Names") |
| 111 | { |
| 112 | compatibleNames = |
| 113 | std::get<std::vector<std::string>>(property.second); |
| 114 | } |
| 115 | } |
| 116 | } |
Gunnar Mills | 2ce7da2 | 2017-05-04 15:37:56 -0500 | [diff] [blame] | 117 | } |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 118 | if (version.empty() || filePath.empty() || |
Saqib Khan | 84a0e69 | 2017-06-28 17:27:01 -0500 | [diff] [blame] | 119 | purpose == VersionPurpose::Unknown) |
Saqib Khan | 705f1bf | 2017-06-09 23:58:38 -0500 | [diff] [blame] | 120 | { |
| 121 | return; |
| 122 | } |
Gunnar Mills | 2ce7da2 | 2017-05-04 15:37:56 -0500 | [diff] [blame] | 123 | |
| 124 | // Version id is the last item in the path |
| 125 | auto pos = path.rfind("/"); |
| 126 | if (pos == std::string::npos) |
| 127 | { |
Patrick Williams | c9bb642 | 2021-08-27 06:18:35 -0500 | [diff] [blame] | 128 | error("No version id found in object path: {PATH}", "PATH", path); |
Patrick Williams | e75d10f | 2017-05-30 16:56:32 -0500 | [diff] [blame] | 129 | return; |
Gunnar Mills | 2ce7da2 | 2017-05-04 15:37:56 -0500 | [diff] [blame] | 130 | } |
| 131 | |
| 132 | auto versionId = path.substr(pos + 1); |
| 133 | |
Patrick Williams | e75d10f | 2017-05-30 16:56:32 -0500 | [diff] [blame] | 134 | if (activations.find(versionId) == activations.end()) |
Gunnar Mills | 2ce7da2 | 2017-05-04 15:37:56 -0500 | [diff] [blame] | 135 | { |
Saqib Khan | 35e83f3 | 2017-05-22 11:37:32 -0500 | [diff] [blame] | 136 | // Determine the Activation state by processing the given image dir. |
| 137 | auto activationState = server::Activation::Activations::Invalid; |
Vijay Khemka | e9f6c84 | 2020-01-14 14:32:39 -0800 | [diff] [blame] | 138 | ItemUpdater::ActivationStatus result; |
| 139 | if (purpose == VersionPurpose::BMC || purpose == VersionPurpose::System) |
| 140 | result = ItemUpdater::validateSquashFSImage(filePath); |
| 141 | else |
| 142 | result = ItemUpdater::ActivationStatus::ready; |
| 143 | |
Gunnar Mills | 43b25cd | 2017-09-07 13:19:34 -0500 | [diff] [blame] | 144 | AssociationList associations = {}; |
| 145 | |
Saqib Khan | 35e83f3 | 2017-05-22 11:37:32 -0500 | [diff] [blame] | 146 | if (result == ItemUpdater::ActivationStatus::ready) |
| 147 | { |
| 148 | activationState = server::Activation::Activations::Ready; |
Gunnar Mills | 43b25cd | 2017-09-07 13:19:34 -0500 | [diff] [blame] | 149 | // Create an association to the BMC inventory item |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 150 | associations.emplace_back( |
| 151 | std::make_tuple(ACTIVATION_FWD_ASSOCIATION, |
| 152 | ACTIVATION_REV_ASSOCIATION, bmcInventoryPath)); |
Saqib Khan | 35e83f3 | 2017-05-22 11:37:32 -0500 | [diff] [blame] | 153 | } |
Gunnar Mills | b60add1 | 2017-08-24 16:41:42 -0500 | [diff] [blame] | 154 | |
Saqib Khan | ee13e83 | 2017-10-23 12:53:11 -0500 | [diff] [blame] | 155 | auto versionPtr = std::make_unique<VersionClass>( |
Chanh Nguyen | 1fd6ddd | 2021-01-06 11:09:09 +0700 | [diff] [blame] | 156 | bus, path, version, purpose, extendedVersion, filePath, |
Justin Ledford | 054bb0b | 2022-03-15 15:46:58 -0700 | [diff] [blame] | 157 | compatibleNames, |
Adriana Kobylak | 59b640b | 2022-01-21 19:45:22 +0000 | [diff] [blame] | 158 | std::bind(&ItemUpdater::erase, this, std::placeholders::_1), |
| 159 | versionId); |
Saqib Khan | ee13e83 | 2017-10-23 12:53:11 -0500 | [diff] [blame] | 160 | versionPtr->deleteObject = |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 161 | std::make_unique<phosphor::software::manager::Delete>(bus, path, |
| 162 | *versionPtr); |
Saqib Khan | ee13e83 | 2017-10-23 12:53:11 -0500 | [diff] [blame] | 163 | versions.insert(std::make_pair(versionId, std::move(versionPtr))); |
Adriana Kobylak | 88ba1f9 | 2022-03-09 21:14:15 +0000 | [diff] [blame] | 164 | |
| 165 | activations.insert(std::make_pair( |
| 166 | versionId, |
| 167 | std::make_unique<Activation>(bus, path, *this, versionId, |
| 168 | activationState, associations))); |
Gunnar Mills | 2ce7da2 | 2017-05-04 15:37:56 -0500 | [diff] [blame] | 169 | } |
Patrick Williams | e75d10f | 2017-05-30 16:56:32 -0500 | [diff] [blame] | 170 | return; |
Gunnar Mills | ec1b41c | 2017-05-02 12:20:36 -0500 | [diff] [blame] | 171 | } |
| 172 | |
Saqib Khan | ba23988 | 2017-05-26 08:41:54 -0500 | [diff] [blame] | 173 | void ItemUpdater::processBMCImage() |
| 174 | { |
Gunnar Mills | 88e8a32 | 2017-09-13 11:09:28 -0500 | [diff] [blame] | 175 | using VersionClass = phosphor::software::manager::Version; |
Lei YU | 269bff3 | 2018-08-21 15:21:40 +0800 | [diff] [blame] | 176 | |
| 177 | // Check MEDIA_DIR and create if it does not exist |
| 178 | try |
| 179 | { |
| 180 | if (!fs::is_directory(MEDIA_DIR)) |
| 181 | { |
| 182 | fs::create_directory(MEDIA_DIR); |
| 183 | } |
| 184 | } |
| 185 | catch (const fs::filesystem_error& e) |
| 186 | { |
Patrick Williams | c9bb642 | 2021-08-27 06:18:35 -0500 | [diff] [blame] | 187 | error("Failed to prepare dir: {ERROR}", "ERROR", e); |
Lei YU | 269bff3 | 2018-08-21 15:21:40 +0800 | [diff] [blame] | 188 | return; |
| 189 | } |
| 190 | |
Adriana Kobylak | 1e81f23 | 2022-01-18 22:28:47 +0000 | [diff] [blame] | 191 | // Functional images are mounted as rofs-<location>-functional |
| 192 | constexpr auto functionalSuffix = "-functional"; |
Lei YU | d474d9c | 2021-12-10 16:21:21 +0800 | [diff] [blame] | 193 | bool functionalFound = false; |
Gunnar Mills | 88e8a32 | 2017-09-13 11:09:28 -0500 | [diff] [blame] | 194 | |
Saqib Khan | 1eef62d | 2017-08-10 15:29:34 -0500 | [diff] [blame] | 195 | // Read os-release from folders under /media/ to get |
| 196 | // BMC Software Versions. |
George Liu | 44b9fef | 2023-02-07 14:31:32 +0800 | [diff] [blame] | 197 | std::error_code ec; |
| 198 | for (const auto& iter : fs::directory_iterator(MEDIA_DIR, ec)) |
Saqib Khan | 1eef62d | 2017-08-10 15:29:34 -0500 | [diff] [blame] | 199 | { |
| 200 | auto activationState = server::Activation::Activations::Active; |
Saqib Khan | 6fab70d | 2017-09-07 00:13:50 -0500 | [diff] [blame] | 201 | static const auto BMC_RO_PREFIX_LEN = strlen(BMC_ROFS_PREFIX); |
Saqib Khan | 1eef62d | 2017-08-10 15:29:34 -0500 | [diff] [blame] | 202 | |
| 203 | // Check if the BMC_RO_PREFIXis the prefix of the iter.path |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 204 | if (0 == |
| 205 | iter.path().native().compare(0, BMC_RO_PREFIX_LEN, BMC_ROFS_PREFIX)) |
Saqib Khan | 1eef62d | 2017-08-10 15:29:34 -0500 | [diff] [blame] | 206 | { |
Adriana Kobylak | 716cd78 | 2020-06-08 13:27:43 -0500 | [diff] [blame] | 207 | // Get the version to calculate the id |
Adriana Kobylak | 24a8d83 | 2020-06-10 08:29:36 -0500 | [diff] [blame] | 208 | fs::path releaseFile(OS_RELEASE_FILE); |
| 209 | auto osRelease = iter.path() / releaseFile.relative_path(); |
George Liu | 44b9fef | 2023-02-07 14:31:32 +0800 | [diff] [blame] | 210 | if (!fs::is_regular_file(osRelease, ec)) |
Saqib Khan | 1eef62d | 2017-08-10 15:29:34 -0500 | [diff] [blame] | 211 | { |
Lei YU | e56bf87 | 2022-02-22 18:40:37 +0800 | [diff] [blame] | 212 | #ifdef BMC_STATIC_DUAL_IMAGE |
| 213 | // For dual image, it is possible that the secondary image is |
| 214 | // empty or contains invalid data, ignore such case. |
George Liu | 44b9fef | 2023-02-07 14:31:32 +0800 | [diff] [blame] | 215 | info("Unable to find osRelease: {PATH}: {ERROR_MSG}", "PATH", |
| 216 | osRelease, "ERROR_MSG", ec.message()); |
Lei YU | e56bf87 | 2022-02-22 18:40:37 +0800 | [diff] [blame] | 217 | #else |
George Liu | 44b9fef | 2023-02-07 14:31:32 +0800 | [diff] [blame] | 218 | error("Failed to read osRelease: {PATH}: {ERROR_MSG}", "PATH", |
| 219 | osRelease, "ERROR_MSG", ec.message()); |
Adriana Kobylak | 716cd78 | 2020-06-08 13:27:43 -0500 | [diff] [blame] | 220 | |
| 221 | // Try to get the version id from the mount directory name and |
| 222 | // call to delete it as this version may be corrupted. Dynamic |
| 223 | // volumes created by the UBI layout for example have the id in |
| 224 | // the mount directory name. The worst that can happen is that |
| 225 | // erase() is called with an non-existent id and returns. |
| 226 | auto id = iter.path().native().substr(BMC_RO_PREFIX_LEN); |
Saqib Khan | 021c365 | 2017-09-26 12:11:02 -0500 | [diff] [blame] | 227 | ItemUpdater::erase(id); |
Lei YU | e56bf87 | 2022-02-22 18:40:37 +0800 | [diff] [blame] | 228 | #endif |
Adriana Kobylak | 716cd78 | 2020-06-08 13:27:43 -0500 | [diff] [blame] | 229 | |
Saqib Khan | 021c365 | 2017-09-26 12:11:02 -0500 | [diff] [blame] | 230 | continue; |
Saqib Khan | 1eef62d | 2017-08-10 15:29:34 -0500 | [diff] [blame] | 231 | } |
Gunnar Mills | 88e8a32 | 2017-09-13 11:09:28 -0500 | [diff] [blame] | 232 | auto version = VersionClass::getBMCVersion(osRelease); |
Saqib Khan | 1eef62d | 2017-08-10 15:29:34 -0500 | [diff] [blame] | 233 | if (version.empty()) |
| 234 | { |
Patrick Williams | c9bb642 | 2021-08-27 06:18:35 -0500 | [diff] [blame] | 235 | error("Failed to read version from osRelease: {PATH}", "PATH", |
| 236 | osRelease); |
Adriana Kobylak | 716cd78 | 2020-06-08 13:27:43 -0500 | [diff] [blame] | 237 | |
| 238 | // Try to delete the version, same as above if the |
| 239 | // OS_RELEASE_FILE does not exist. |
| 240 | auto id = iter.path().native().substr(BMC_RO_PREFIX_LEN); |
| 241 | ItemUpdater::erase(id); |
| 242 | |
| 243 | continue; |
Saqib Khan | 1eef62d | 2017-08-10 15:29:34 -0500 | [diff] [blame] | 244 | } |
Saqib Khan | 021c365 | 2017-09-26 12:11:02 -0500 | [diff] [blame] | 245 | |
Adriana Kobylak | 59b640b | 2022-01-21 19:45:22 +0000 | [diff] [blame] | 246 | // The flash location is part of the mount name: rofs-<location> |
| 247 | auto flashId = iter.path().native().substr(BMC_RO_PREFIX_LEN); |
| 248 | |
| 249 | auto id = VersionClass::getId(version + flashId); |
Adriana Kobylak | 716cd78 | 2020-06-08 13:27:43 -0500 | [diff] [blame] | 250 | |
Adriana Kobylak | f383d27 | 2020-06-16 15:17:22 -0500 | [diff] [blame] | 251 | // Check if the id has already been added. This can happen if the |
| 252 | // BMC partitions / devices were manually flashed with the same |
| 253 | // image. |
| 254 | if (versions.find(id) != versions.end()) |
| 255 | { |
| 256 | continue; |
| 257 | } |
| 258 | |
Adriana Kobylak | 1e81f23 | 2022-01-18 22:28:47 +0000 | [diff] [blame] | 259 | auto functional = false; |
| 260 | if (iter.path().native().find(functionalSuffix) != |
| 261 | std::string::npos) |
| 262 | { |
| 263 | // Set functional to true and remove the functional suffix |
| 264 | functional = true; |
| 265 | flashId.erase(flashId.length() - strlen(functionalSuffix)); |
Lei YU | d474d9c | 2021-12-10 16:21:21 +0800 | [diff] [blame] | 266 | functionalFound = true; |
Adriana Kobylak | 1e81f23 | 2022-01-18 22:28:47 +0000 | [diff] [blame] | 267 | } |
Adriana Kobylak | 780220f | 2022-01-18 20:01:53 +0000 | [diff] [blame] | 268 | |
Saqib Khan | 1eef62d | 2017-08-10 15:29:34 -0500 | [diff] [blame] | 269 | auto purpose = server::Version::VersionPurpose::BMC; |
Adriana Kobylak | 780220f | 2022-01-18 20:01:53 +0000 | [diff] [blame] | 270 | restorePurpose(flashId, purpose); |
Adriana Kobylak | ec4eec3 | 2019-11-13 14:28:35 -0600 | [diff] [blame] | 271 | |
Chanh Nguyen | 1fd6ddd | 2021-01-06 11:09:09 +0700 | [diff] [blame] | 272 | // Read os-release from /etc/ to get the BMC extended version |
| 273 | std::string extendedVersion = |
| 274 | VersionClass::getBMCExtendedVersion(osRelease); |
| 275 | |
Saqib Khan | 1eef62d | 2017-08-10 15:29:34 -0500 | [diff] [blame] | 276 | auto path = fs::path(SOFTWARE_OBJPATH) / id; |
| 277 | |
Lei YU | 269bff3 | 2018-08-21 15:21:40 +0800 | [diff] [blame] | 278 | // Create functional association if this is the functional |
| 279 | // version |
Adriana Kobylak | 1e81f23 | 2022-01-18 22:28:47 +0000 | [diff] [blame] | 280 | if (functional) |
Gunnar Mills | 88e8a32 | 2017-09-13 11:09:28 -0500 | [diff] [blame] | 281 | { |
| 282 | createFunctionalAssociation(path); |
| 283 | } |
| 284 | |
Gunnar Mills | 43b25cd | 2017-09-07 13:19:34 -0500 | [diff] [blame] | 285 | AssociationList associations = {}; |
| 286 | |
| 287 | if (activationState == server::Activation::Activations::Active) |
| 288 | { |
| 289 | // Create an association to the BMC inventory item |
| 290 | associations.emplace_back(std::make_tuple( |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 291 | ACTIVATION_FWD_ASSOCIATION, ACTIVATION_REV_ASSOCIATION, |
| 292 | bmcInventoryPath)); |
Gunnar Mills | 43b25cd | 2017-09-07 13:19:34 -0500 | [diff] [blame] | 293 | |
| 294 | // Create an active association since this image is active |
| 295 | createActiveAssociation(path); |
| 296 | } |
| 297 | |
AppaRao Puli | bbebec7 | 2020-01-28 23:57:41 +0530 | [diff] [blame] | 298 | // All updateable firmware components must expose the updateable |
| 299 | // association. |
| 300 | createUpdateableAssociation(path); |
| 301 | |
Adriana Kobylak | ee590c7 | 2017-09-26 15:16:06 -0500 | [diff] [blame] | 302 | // Create Version instance for this version. |
| 303 | auto versionPtr = std::make_unique<VersionClass>( |
Adriana Kobylak | a84f06d | 2022-01-18 15:41:57 +0000 | [diff] [blame] | 304 | bus, path, version, purpose, extendedVersion, flashId, |
Justin Ledford | 054bb0b | 2022-03-15 15:46:58 -0700 | [diff] [blame] | 305 | std::vector<std::string>(), |
Adriana Kobylak | 59b640b | 2022-01-21 19:45:22 +0000 | [diff] [blame] | 306 | std::bind(&ItemUpdater::erase, this, std::placeholders::_1), |
| 307 | id); |
Adriana Kobylak | 1e81f23 | 2022-01-18 22:28:47 +0000 | [diff] [blame] | 308 | if (functional) |
| 309 | { |
| 310 | versionPtr->setFunctional(true); |
| 311 | } |
| 312 | else |
Michael Tritz | 4254bec | 2017-10-03 17:18:22 -0500 | [diff] [blame] | 313 | { |
Saqib Khan | ee13e83 | 2017-10-23 12:53:11 -0500 | [diff] [blame] | 314 | versionPtr->deleteObject = |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 315 | std::make_unique<phosphor::software::manager::Delete>( |
| 316 | bus, path, *versionPtr); |
Michael Tritz | 4254bec | 2017-10-03 17:18:22 -0500 | [diff] [blame] | 317 | } |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 318 | versions.insert(std::make_pair(id, std::move(versionPtr))); |
Michael Tritz | 4254bec | 2017-10-03 17:18:22 -0500 | [diff] [blame] | 319 | |
Saqib Khan | ee13e83 | 2017-10-23 12:53:11 -0500 | [diff] [blame] | 320 | // Create Activation instance for this version. |
| 321 | activations.insert(std::make_pair( |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 322 | id, std::make_unique<Activation>( |
| 323 | bus, path, *this, id, activationState, associations))); |
Saqib Khan | 1eef62d | 2017-08-10 15:29:34 -0500 | [diff] [blame] | 324 | |
Lei YU | bdf2d6c | 2021-12-15 14:05:01 +0800 | [diff] [blame] | 325 | #ifdef BMC_STATIC_DUAL_IMAGE |
| 326 | uint8_t priority; |
| 327 | if ((functional && (runningImageSlot == 0)) || |
| 328 | (!functional && (runningImageSlot == 1))) |
| 329 | { |
| 330 | priority = 0; |
| 331 | } |
| 332 | else |
| 333 | { |
| 334 | priority = 1; |
| 335 | } |
| 336 | activations.find(id)->second->redundancyPriority = |
| 337 | std::make_unique<RedundancyPriority>( |
| 338 | bus, path, *(activations.find(id)->second), priority, |
| 339 | false); |
| 340 | #else |
Lei YU | 269bff3 | 2018-08-21 15:21:40 +0800 | [diff] [blame] | 341 | // If Active, create RedundancyPriority instance for this |
| 342 | // version. |
Saqib Khan | 1eef62d | 2017-08-10 15:29:34 -0500 | [diff] [blame] | 343 | if (activationState == server::Activation::Activations::Active) |
| 344 | { |
| 345 | uint8_t priority = std::numeric_limits<uint8_t>::max(); |
Adriana Kobylak | 780220f | 2022-01-18 20:01:53 +0000 | [diff] [blame] | 346 | if (!restorePriority(flashId, priority)) |
Saqib Khan | 1eef62d | 2017-08-10 15:29:34 -0500 | [diff] [blame] | 347 | { |
Adriana Kobylak | 1e81f23 | 2022-01-18 22:28:47 +0000 | [diff] [blame] | 348 | if (functional) |
Adriana Kobylak | ee590c7 | 2017-09-26 15:16:06 -0500 | [diff] [blame] | 349 | { |
| 350 | priority = 0; |
| 351 | } |
| 352 | else |
| 353 | { |
Patrick Williams | c9bb642 | 2021-08-27 06:18:35 -0500 | [diff] [blame] | 354 | error( |
| 355 | "Unable to restore priority from file for {VERSIONID}", |
| 356 | "VERSIONID", id); |
Adriana Kobylak | ee590c7 | 2017-09-26 15:16:06 -0500 | [diff] [blame] | 357 | } |
Saqib Khan | 1eef62d | 2017-08-10 15:29:34 -0500 | [diff] [blame] | 358 | } |
| 359 | activations.find(id)->second->redundancyPriority = |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 360 | std::make_unique<RedundancyPriority>( |
| 361 | bus, path, *(activations.find(id)->second), priority, |
| 362 | false); |
Saqib Khan | 1eef62d | 2017-08-10 15:29:34 -0500 | [diff] [blame] | 363 | } |
Lei YU | bdf2d6c | 2021-12-15 14:05:01 +0800 | [diff] [blame] | 364 | #endif |
Saqib Khan | 1eef62d | 2017-08-10 15:29:34 -0500 | [diff] [blame] | 365 | } |
| 366 | } |
Saqib Khan | dcbfa04 | 2017-09-18 13:08:39 -0500 | [diff] [blame] | 367 | |
Lei YU | d474d9c | 2021-12-10 16:21:21 +0800 | [diff] [blame] | 368 | if (!functionalFound) |
Saqib Khan | dcbfa04 | 2017-09-18 13:08:39 -0500 | [diff] [blame] | 369 | { |
Lei YU | d474d9c | 2021-12-10 16:21:21 +0800 | [diff] [blame] | 370 | // If there is no functional version found, read the /etc/os-release and |
| 371 | // create rofs-<versionId>-functional under MEDIA_DIR, then call again |
| 372 | // processBMCImage() to create the D-Bus interface for it. |
Gunnar Mills | d16bcbd | 2017-10-08 16:50:42 -0500 | [diff] [blame] | 373 | auto version = VersionClass::getBMCVersion(OS_RELEASE_FILE); |
Adriana Kobylak | 59b640b | 2022-01-21 19:45:22 +0000 | [diff] [blame] | 374 | auto id = phosphor::software::manager::Version::getId(version + |
| 375 | functionalSuffix); |
Adriana Kobylak | 1e81f23 | 2022-01-18 22:28:47 +0000 | [diff] [blame] | 376 | auto versionFileDir = BMC_ROFS_PREFIX + id + functionalSuffix + "/etc/"; |
Saqib Khan | dcbfa04 | 2017-09-18 13:08:39 -0500 | [diff] [blame] | 377 | try |
| 378 | { |
Gunnar Mills | d16bcbd | 2017-10-08 16:50:42 -0500 | [diff] [blame] | 379 | if (!fs::is_directory(versionFileDir)) |
Saqib Khan | dcbfa04 | 2017-09-18 13:08:39 -0500 | [diff] [blame] | 380 | { |
| 381 | fs::create_directories(versionFileDir); |
| 382 | } |
Patrick Williams | d5e8e73 | 2023-05-10 07:50:18 -0500 | [diff] [blame] | 383 | auto versionFilePath = BMC_ROFS_PREFIX + id + functionalSuffix + |
| 384 | OS_RELEASE_FILE; |
Saqib Khan | dcbfa04 | 2017-09-18 13:08:39 -0500 | [diff] [blame] | 385 | fs::create_directory_symlink(OS_RELEASE_FILE, versionFilePath); |
| 386 | ItemUpdater::processBMCImage(); |
| 387 | } |
| 388 | catch (const std::exception& e) |
| 389 | { |
Patrick Williams | c9bb642 | 2021-08-27 06:18:35 -0500 | [diff] [blame] | 390 | error("Exception during processing: {ERROR}", "ERROR", e); |
Saqib Khan | dcbfa04 | 2017-09-18 13:08:39 -0500 | [diff] [blame] | 391 | } |
| 392 | } |
Eddie James | eaa1ee0 | 2018-03-01 10:09:10 -0600 | [diff] [blame] | 393 | |
| 394 | mirrorUbootToAlt(); |
Saqib Khan | ba23988 | 2017-05-26 08:41:54 -0500 | [diff] [blame] | 395 | return; |
| 396 | } |
| 397 | |
Leonel Gonzalez | 3526ef7 | 2017-07-07 14:38:25 -0500 | [diff] [blame] | 398 | void ItemUpdater::erase(std::string entryId) |
| 399 | { |
Eddie James | 6d87371 | 2017-09-01 11:29:07 -0500 | [diff] [blame] | 400 | // Find entry in versions map |
| 401 | auto it = versions.find(entryId); |
| 402 | if (it != versions.end()) |
| 403 | { |
Lei YU | 0f88b5a | 2018-08-21 15:28:53 +0800 | [diff] [blame] | 404 | if (it->second->isFunctional() && ACTIVE_BMC_MAX_ALLOWED > 1) |
Eddie James | 6d87371 | 2017-09-01 11:29:07 -0500 | [diff] [blame] | 405 | { |
Patrick Williams | c9bb642 | 2021-08-27 06:18:35 -0500 | [diff] [blame] | 406 | error( |
| 407 | "Version ({VERSIONID}) is currently running on the BMC; unable to remove.", |
| 408 | "VERSIONID", entryId); |
Gunnar Mills | d16bcbd | 2017-10-08 16:50:42 -0500 | [diff] [blame] | 409 | return; |
Eddie James | 6d87371 | 2017-09-01 11:29:07 -0500 | [diff] [blame] | 410 | } |
Adriana Kobylak | d1a55ad | 2020-06-11 14:01:28 -0500 | [diff] [blame] | 411 | } |
Eddie James | 6d87371 | 2017-09-01 11:29:07 -0500 | [diff] [blame] | 412 | |
Adriana Kobylak | d1a55ad | 2020-06-11 14:01:28 -0500 | [diff] [blame] | 413 | // First call resetUbootEnvVars() so that the BMC points to a valid image to |
| 414 | // boot from. If resetUbootEnvVars() is called after the image is actually |
| 415 | // deleted from the BMC flash, there'd be a time window where the BMC would |
| 416 | // be pointing to a non-existent image to boot from. |
| 417 | // Need to remove the entries from the activations map before that call so |
| 418 | // that resetUbootEnvVars() doesn't use the version to be deleted. |
| 419 | auto iteratorActivations = activations.find(entryId); |
| 420 | if (iteratorActivations == activations.end()) |
| 421 | { |
Patrick Williams | c9bb642 | 2021-08-27 06:18:35 -0500 | [diff] [blame] | 422 | error( |
| 423 | "Failed to find version ({VERSIONID}) in item updater activations map; unable to remove.", |
| 424 | "VERSIONID", entryId); |
Adriana Kobylak | d1a55ad | 2020-06-11 14:01:28 -0500 | [diff] [blame] | 425 | } |
| 426 | else |
| 427 | { |
| 428 | removeAssociations(iteratorActivations->second->path); |
Zami Seck | ae06d76 | 2021-08-13 20:11:15 -0500 | [diff] [blame] | 429 | iteratorActivations->second->deleteImageManagerObject(); |
Adriana Kobylak | d1a55ad | 2020-06-11 14:01:28 -0500 | [diff] [blame] | 430 | this->activations.erase(entryId); |
| 431 | } |
| 432 | ItemUpdater::resetUbootEnvVars(); |
| 433 | |
| 434 | if (it != versions.end()) |
| 435 | { |
Adriana Kobylak | 780220f | 2022-01-18 20:01:53 +0000 | [diff] [blame] | 436 | auto flashId = it->second->path(); |
| 437 | |
Adriana Kobylak | 25773a7 | 2022-01-21 15:24:48 +0000 | [diff] [blame] | 438 | // Delete version data if it has been installed on flash (path is not |
| 439 | // the upload directory) |
| 440 | if (flashId.find(IMG_UPLOAD_DIR) == std::string::npos) |
| 441 | { |
| 442 | removeReadOnlyPartition(entryId); |
| 443 | removePersistDataDirectory(flashId); |
| 444 | helper.clearEntry(flashId); |
| 445 | } |
Saqib Khan | ee13e83 | 2017-10-23 12:53:11 -0500 | [diff] [blame] | 446 | |
| 447 | // Removing entry in versions map |
| 448 | this->versions.erase(entryId); |
Eddie James | 6d87371 | 2017-09-01 11:29:07 -0500 | [diff] [blame] | 449 | } |
Leonel Gonzalez | 3526ef7 | 2017-07-07 14:38:25 -0500 | [diff] [blame] | 450 | |
Saqib Khan | ee13e83 | 2017-10-23 12:53:11 -0500 | [diff] [blame] | 451 | return; |
Leonel Gonzalez | 3526ef7 | 2017-07-07 14:38:25 -0500 | [diff] [blame] | 452 | } |
| 453 | |
Michael Tritz | bc1bf3a | 2017-09-18 16:38:23 -0500 | [diff] [blame] | 454 | void ItemUpdater::deleteAll() |
| 455 | { |
Adriana Kobylak | 83cd21f | 2018-02-28 15:48:48 -0600 | [diff] [blame] | 456 | std::vector<std::string> deletableVersions; |
| 457 | |
Michael Tritz | bc1bf3a | 2017-09-18 16:38:23 -0500 | [diff] [blame] | 458 | for (const auto& versionIt : versions) |
| 459 | { |
| 460 | if (!versionIt.second->isFunctional()) |
| 461 | { |
Adriana Kobylak | 83cd21f | 2018-02-28 15:48:48 -0600 | [diff] [blame] | 462 | deletableVersions.push_back(versionIt.first); |
Michael Tritz | bc1bf3a | 2017-09-18 16:38:23 -0500 | [diff] [blame] | 463 | } |
| 464 | } |
| 465 | |
Adriana Kobylak | 83cd21f | 2018-02-28 15:48:48 -0600 | [diff] [blame] | 466 | for (const auto& deletableIt : deletableVersions) |
| 467 | { |
| 468 | ItemUpdater::erase(deletableIt); |
| 469 | } |
| 470 | |
Lei YU | 56aaf45 | 2018-06-21 16:09:44 +0800 | [diff] [blame] | 471 | helper.cleanup(); |
Michael Tritz | bc1bf3a | 2017-09-18 16:38:23 -0500 | [diff] [blame] | 472 | } |
| 473 | |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 474 | ItemUpdater::ActivationStatus |
| 475 | ItemUpdater::validateSquashFSImage(const std::string& filePath) |
Saqib Khan | 35e83f3 | 2017-05-22 11:37:32 -0500 | [diff] [blame] | 476 | { |
Bright Cheng | 8e9ccfe | 2019-11-18 16:18:44 +0800 | [diff] [blame] | 477 | bool valid = true; |
Saqib Khan | 35e83f3 | 2017-05-22 11:37:32 -0500 | [diff] [blame] | 478 | |
Bright Cheng | 8e9ccfe | 2019-11-18 16:18:44 +0800 | [diff] [blame] | 479 | // Record the images which are being updated |
| 480 | // First check for the fullimage, then check for images with partitions |
| 481 | imageUpdateList.push_back(bmcFullImages); |
| 482 | valid = checkImage(filePath, imageUpdateList); |
| 483 | if (!valid) |
Saqib Khan | 35e83f3 | 2017-05-22 11:37:32 -0500 | [diff] [blame] | 484 | { |
Bright Cheng | 8e9ccfe | 2019-11-18 16:18:44 +0800 | [diff] [blame] | 485 | imageUpdateList.clear(); |
| 486 | imageUpdateList.assign(bmcImages.begin(), bmcImages.end()); |
| 487 | valid = checkImage(filePath, imageUpdateList); |
| 488 | if (!valid) |
Michael Tritz | b1cfdf9 | 2017-08-14 14:33:30 -0500 | [diff] [blame] | 489 | { |
Patrick Williams | c9bb642 | 2021-08-27 06:18:35 -0500 | [diff] [blame] | 490 | error("Failed to find the needed BMC images."); |
Bright Cheng | 8e9ccfe | 2019-11-18 16:18:44 +0800 | [diff] [blame] | 491 | return ItemUpdater::ActivationStatus::invalid; |
Michael Tritz | b1cfdf9 | 2017-08-14 14:33:30 -0500 | [diff] [blame] | 492 | } |
Saqib Khan | 35e83f3 | 2017-05-22 11:37:32 -0500 | [diff] [blame] | 493 | } |
Michael Tritz | b1cfdf9 | 2017-08-14 14:33:30 -0500 | [diff] [blame] | 494 | |
Michael Tritz | b1cfdf9 | 2017-08-14 14:33:30 -0500 | [diff] [blame] | 495 | return ItemUpdater::ActivationStatus::ready; |
Saqib Khan | 35e83f3 | 2017-05-22 11:37:32 -0500 | [diff] [blame] | 496 | } |
| 497 | |
Adriana Kobylak | bbcb7be | 2018-07-17 15:47:34 -0500 | [diff] [blame] | 498 | void ItemUpdater::savePriority(const std::string& versionId, uint8_t value) |
| 499 | { |
Adriana Kobylak | 780220f | 2022-01-18 20:01:53 +0000 | [diff] [blame] | 500 | auto flashId = versions.find(versionId)->second->path(); |
| 501 | storePriority(flashId, value); |
Adriana Kobylak | 25773a7 | 2022-01-21 15:24:48 +0000 | [diff] [blame] | 502 | helper.setEntry(flashId, value); |
Adriana Kobylak | bbcb7be | 2018-07-17 15:47:34 -0500 | [diff] [blame] | 503 | } |
| 504 | |
Saqib Khan | b9da663 | 2017-09-13 09:48:37 -0500 | [diff] [blame] | 505 | void ItemUpdater::freePriority(uint8_t value, const std::string& versionId) |
Saqib Khan | 4c1aec0 | 2017-07-06 11:46:13 -0500 | [diff] [blame] | 506 | { |
Adriana Kobylak | b77551c | 2017-10-27 12:46:23 -0500 | [diff] [blame] | 507 | std::map<std::string, uint8_t> priorityMap; |
| 508 | |
| 509 | // Insert the requested version and priority, it may not exist yet. |
| 510 | priorityMap.insert(std::make_pair(versionId, value)); |
| 511 | |
Saqib Khan | 4c1aec0 | 2017-07-06 11:46:13 -0500 | [diff] [blame] | 512 | for (const auto& intf : activations) |
| 513 | { |
Gunnar Mills | 9a78224 | 2017-08-22 16:23:15 -0500 | [diff] [blame] | 514 | if (intf.second->redundancyPriority) |
Saqib Khan | 4c1aec0 | 2017-07-06 11:46:13 -0500 | [diff] [blame] | 515 | { |
Adriana Kobylak | b77551c | 2017-10-27 12:46:23 -0500 | [diff] [blame] | 516 | priorityMap.insert(std::make_pair( |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 517 | intf.first, intf.second->redundancyPriority.get()->priority())); |
Saqib Khan | 4c1aec0 | 2017-07-06 11:46:13 -0500 | [diff] [blame] | 518 | } |
| 519 | } |
Adriana Kobylak | b77551c | 2017-10-27 12:46:23 -0500 | [diff] [blame] | 520 | |
| 521 | // Lambda function to compare 2 priority values, use <= to allow duplicates |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 522 | typedef std::function<bool(std::pair<std::string, uint8_t>, |
| 523 | std::pair<std::string, uint8_t>)> |
| 524 | cmpPriority; |
| 525 | cmpPriority cmpPriorityFunc = |
| 526 | [](std::pair<std::string, uint8_t> priority1, |
| 527 | std::pair<std::string, uint8_t> priority2) { |
Patrick Williams | d5e8e73 | 2023-05-10 07:50:18 -0500 | [diff] [blame] | 528 | return priority1.second <= priority2.second; |
| 529 | }; |
Adriana Kobylak | b77551c | 2017-10-27 12:46:23 -0500 | [diff] [blame] | 530 | |
| 531 | // Sort versions by ascending priority |
| 532 | std::set<std::pair<std::string, uint8_t>, cmpPriority> prioritySet( |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 533 | priorityMap.begin(), priorityMap.end(), cmpPriorityFunc); |
Adriana Kobylak | b77551c | 2017-10-27 12:46:23 -0500 | [diff] [blame] | 534 | |
| 535 | auto freePriorityValue = value; |
| 536 | for (auto& element : prioritySet) |
| 537 | { |
| 538 | if (element.first == versionId) |
| 539 | { |
| 540 | continue; |
| 541 | } |
| 542 | if (element.second == freePriorityValue) |
| 543 | { |
| 544 | ++freePriorityValue; |
| 545 | auto it = activations.find(element.first); |
| 546 | it->second->redundancyPriority.get()->sdbusPriority( |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 547 | freePriorityValue); |
Adriana Kobylak | b77551c | 2017-10-27 12:46:23 -0500 | [diff] [blame] | 548 | } |
| 549 | } |
| 550 | |
| 551 | auto lowestVersion = prioritySet.begin()->first; |
| 552 | if (value == prioritySet.begin()->second) |
| 553 | { |
| 554 | lowestVersion = versionId; |
| 555 | } |
| 556 | updateUbootEnvVars(lowestVersion); |
Saqib Khan | 4c1aec0 | 2017-07-06 11:46:13 -0500 | [diff] [blame] | 557 | } |
| 558 | |
Michael Tritz | 37a5904 | 2017-07-12 13:44:53 -0500 | [diff] [blame] | 559 | void ItemUpdater::reset() |
| 560 | { |
Lei YU | 56aaf45 | 2018-06-21 16:09:44 +0800 | [diff] [blame] | 561 | helper.factoryReset(); |
Michael Tritz | 37a5904 | 2017-07-12 13:44:53 -0500 | [diff] [blame] | 562 | |
Patrick Williams | c9bb642 | 2021-08-27 06:18:35 -0500 | [diff] [blame] | 563 | info("BMC factory reset will take effect upon reboot."); |
Michael Tritz | 37a5904 | 2017-07-12 13:44:53 -0500 | [diff] [blame] | 564 | } |
| 565 | |
Leonel Gonzalez | 3526ef7 | 2017-07-07 14:38:25 -0500 | [diff] [blame] | 566 | void ItemUpdater::removeReadOnlyPartition(std::string versionId) |
| 567 | { |
Adriana Kobylak | 25773a7 | 2022-01-21 15:24:48 +0000 | [diff] [blame] | 568 | auto flashId = versions.find(versionId)->second->path(); |
| 569 | helper.removeVersion(flashId); |
Leonel Gonzalez | 3526ef7 | 2017-07-07 14:38:25 -0500 | [diff] [blame] | 570 | } |
| 571 | |
Michael Tritz | 0129d92 | 2017-08-10 19:33:46 -0500 | [diff] [blame] | 572 | bool ItemUpdater::fieldModeEnabled(bool value) |
| 573 | { |
| 574 | // enabling field mode is intended to be one way: false -> true |
| 575 | if (value && !control::FieldMode::fieldModeEnabled()) |
| 576 | { |
| 577 | control::FieldMode::fieldModeEnabled(value); |
| 578 | |
Adriana Kobylak | 22848ec | 2019-10-28 10:08:39 -0500 | [diff] [blame] | 579 | auto method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH, |
| 580 | SYSTEMD_INTERFACE, "StartUnit"); |
| 581 | method.append("obmc-flash-bmc-setenv@fieldmode\\x3dtrue.service", |
| 582 | "replace"); |
| 583 | bus.call_noreply(method); |
| 584 | |
| 585 | method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH, |
| 586 | SYSTEMD_INTERFACE, "StopUnit"); |
| 587 | method.append("usr-local.mount", "replace"); |
| 588 | bus.call_noreply(method); |
| 589 | |
| 590 | std::vector<std::string> usrLocal = {"usr-local.mount"}; |
| 591 | |
| 592 | method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH, |
| 593 | SYSTEMD_INTERFACE, "MaskUnitFiles"); |
| 594 | method.append(usrLocal, false, true); |
| 595 | bus.call_noreply(method); |
Michael Tritz | 0129d92 | 2017-08-10 19:33:46 -0500 | [diff] [blame] | 596 | } |
Adriana Kobylak | d5b8f75 | 2019-05-01 11:52:35 -0500 | [diff] [blame] | 597 | else if (!value && control::FieldMode::fieldModeEnabled()) |
| 598 | { |
Adriana Kobylak | ce82de5 | 2024-01-16 13:56:38 -0600 | [diff] [blame] | 599 | elog<NotAllowed>(xyz::openbmc_project::common::NotAllowed::REASON( |
Adriana Kobylak | d5b8f75 | 2019-05-01 11:52:35 -0500 | [diff] [blame] | 600 | "FieldMode is not allowed to be cleared")); |
| 601 | } |
Michael Tritz | 0129d92 | 2017-08-10 19:33:46 -0500 | [diff] [blame] | 602 | |
| 603 | return control::FieldMode::fieldModeEnabled(); |
| 604 | } |
| 605 | |
| 606 | void ItemUpdater::restoreFieldModeStatus() |
| 607 | { |
Isaac Kurth | deb86b4 | 2022-03-08 19:47:53 -0600 | [diff] [blame] | 608 | // The fieldmode u-boot environment variable may not exist since it is not |
| 609 | // part of the default environment, run fw_printenv with 2>&1 to ignore the |
| 610 | // error message in the journal "Error: "fieldmode" not defined" |
Patrick Williams | d5e8e73 | 2023-05-10 07:50:18 -0500 | [diff] [blame] | 611 | std::pair<int, std::string> ret = utils::execute("/sbin/fw_printenv", "-n", |
| 612 | "fieldmode", "2>&1"); |
Michael Tritz | 0129d92 | 2017-08-10 19:33:46 -0500 | [diff] [blame] | 613 | |
Isaac Kurth | deb86b4 | 2022-03-08 19:47:53 -0600 | [diff] [blame] | 614 | if (ret.first != 0) |
| 615 | { |
| 616 | return; |
| 617 | } |
| 618 | |
| 619 | // truncate any extra characters off the end to compare against a "true" str |
| 620 | std::string result = ret.second.substr(0, 4); |
| 621 | if (result == "true") |
Michael Tritz | 0129d92 | 2017-08-10 19:33:46 -0500 | [diff] [blame] | 622 | { |
| 623 | ItemUpdater::fieldModeEnabled(true); |
| 624 | } |
| 625 | } |
| 626 | |
Gunnar Mills | b60add1 | 2017-08-24 16:41:42 -0500 | [diff] [blame] | 627 | void ItemUpdater::setBMCInventoryPath() |
| 628 | { |
Gunnar Mills | b60add1 | 2017-08-24 16:41:42 -0500 | [diff] [blame] | 629 | auto depth = 0; |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 630 | auto mapperCall = bus.new_method_call(MAPPER_BUSNAME, MAPPER_PATH, |
| 631 | MAPPER_INTERFACE, "GetSubTreePaths"); |
Gunnar Mills | b60add1 | 2017-08-24 16:41:42 -0500 | [diff] [blame] | 632 | |
Adriana Kobylak | 1254c62 | 2017-12-07 12:24:56 -0600 | [diff] [blame] | 633 | mapperCall.append(INVENTORY_PATH); |
Gunnar Mills | b60add1 | 2017-08-24 16:41:42 -0500 | [diff] [blame] | 634 | mapperCall.append(depth); |
Adriana Kobylak | 1254c62 | 2017-12-07 12:24:56 -0600 | [diff] [blame] | 635 | std::vector<std::string> filter = {BMC_INVENTORY_INTERFACE}; |
Gunnar Mills | b60add1 | 2017-08-24 16:41:42 -0500 | [diff] [blame] | 636 | mapperCall.append(filter); |
| 637 | |
Ed Tanous | 87c7817 | 2018-08-10 12:51:53 -0700 | [diff] [blame] | 638 | try |
| 639 | { |
| 640 | auto response = bus.call(mapperCall); |
| 641 | |
| 642 | using ObjectPaths = std::vector<std::string>; |
| 643 | ObjectPaths result; |
| 644 | response.read(result); |
| 645 | |
| 646 | if (!result.empty()) |
| 647 | { |
| 648 | bmcInventoryPath = result.front(); |
| 649 | } |
| 650 | } |
Patrick Williams | bf2bb2b | 2022-07-22 19:26:52 -0500 | [diff] [blame] | 651 | catch (const sdbusplus::exception_t& e) |
Gunnar Mills | b60add1 | 2017-08-24 16:41:42 -0500 | [diff] [blame] | 652 | { |
Patrick Williams | c9bb642 | 2021-08-27 06:18:35 -0500 | [diff] [blame] | 653 | error("Error in mapper GetSubTreePath: {ERROR}", "ERROR", e); |
Gunnar Mills | b60add1 | 2017-08-24 16:41:42 -0500 | [diff] [blame] | 654 | return; |
| 655 | } |
| 656 | |
Adriana Kobylak | 1254c62 | 2017-12-07 12:24:56 -0600 | [diff] [blame] | 657 | return; |
Gunnar Mills | b60add1 | 2017-08-24 16:41:42 -0500 | [diff] [blame] | 658 | } |
| 659 | |
Gunnar Mills | f10b232 | 2017-09-21 15:31:55 -0500 | [diff] [blame] | 660 | void ItemUpdater::createActiveAssociation(const std::string& path) |
Gunnar Mills | ded875d | 2017-08-28 16:44:52 -0500 | [diff] [blame] | 661 | { |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 662 | assocs.emplace_back( |
| 663 | std::make_tuple(ACTIVE_FWD_ASSOCIATION, ACTIVE_REV_ASSOCIATION, path)); |
Gunnar Mills | ded875d | 2017-08-28 16:44:52 -0500 | [diff] [blame] | 664 | associations(assocs); |
| 665 | } |
| 666 | |
Gunnar Mills | 88e8a32 | 2017-09-13 11:09:28 -0500 | [diff] [blame] | 667 | void ItemUpdater::createFunctionalAssociation(const std::string& path) |
| 668 | { |
| 669 | assocs.emplace_back(std::make_tuple(FUNCTIONAL_FWD_ASSOCIATION, |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 670 | FUNCTIONAL_REV_ASSOCIATION, path)); |
Gunnar Mills | 88e8a32 | 2017-09-13 11:09:28 -0500 | [diff] [blame] | 671 | associations(assocs); |
| 672 | } |
| 673 | |
AppaRao Puli | bbebec7 | 2020-01-28 23:57:41 +0530 | [diff] [blame] | 674 | void ItemUpdater::createUpdateableAssociation(const std::string& path) |
| 675 | { |
| 676 | assocs.emplace_back(std::make_tuple(UPDATEABLE_FWD_ASSOCIATION, |
| 677 | UPDATEABLE_REV_ASSOCIATION, path)); |
| 678 | associations(assocs); |
| 679 | } |
| 680 | |
Adriana Kobylak | 991af7e | 2018-12-10 13:08:38 -0600 | [diff] [blame] | 681 | void ItemUpdater::removeAssociations(const std::string& path) |
Gunnar Mills | ded875d | 2017-08-28 16:44:52 -0500 | [diff] [blame] | 682 | { |
| 683 | for (auto iter = assocs.begin(); iter != assocs.end();) |
| 684 | { |
Adriana Kobylak | 991af7e | 2018-12-10 13:08:38 -0600 | [diff] [blame] | 685 | if ((std::get<2>(*iter)).compare(path) == 0) |
Gunnar Mills | ded875d | 2017-08-28 16:44:52 -0500 | [diff] [blame] | 686 | { |
| 687 | iter = assocs.erase(iter); |
| 688 | associations(assocs); |
| 689 | } |
| 690 | else |
| 691 | { |
| 692 | ++iter; |
| 693 | } |
| 694 | } |
| 695 | } |
| 696 | |
Saqib Khan | b9da663 | 2017-09-13 09:48:37 -0500 | [diff] [blame] | 697 | bool ItemUpdater::isLowestPriority(uint8_t value) |
| 698 | { |
| 699 | for (const auto& intf : activations) |
| 700 | { |
Gunnar Mills | d16bcbd | 2017-10-08 16:50:42 -0500 | [diff] [blame] | 701 | if (intf.second->redundancyPriority) |
Saqib Khan | b9da663 | 2017-09-13 09:48:37 -0500 | [diff] [blame] | 702 | { |
| 703 | if (intf.second->redundancyPriority.get()->priority() < value) |
| 704 | { |
| 705 | return false; |
| 706 | } |
| 707 | } |
| 708 | } |
| 709 | return true; |
| 710 | } |
| 711 | |
Adriana Kobylak | b77551c | 2017-10-27 12:46:23 -0500 | [diff] [blame] | 712 | void ItemUpdater::updateUbootEnvVars(const std::string& versionId) |
| 713 | { |
Lei YU | 9c76a0a | 2022-03-14 11:37:15 +0800 | [diff] [blame] | 714 | auto it = versions.find(versionId); |
| 715 | if (it == versions.end()) |
| 716 | { |
| 717 | return; |
| 718 | } |
| 719 | auto flashId = it->second->path(); |
Adriana Kobylak | 25773a7 | 2022-01-21 15:24:48 +0000 | [diff] [blame] | 720 | helper.updateUbootVersionId(flashId); |
Adriana Kobylak | b77551c | 2017-10-27 12:46:23 -0500 | [diff] [blame] | 721 | } |
| 722 | |
Saqib Khan | 49446ae | 2017-10-02 10:54:20 -0500 | [diff] [blame] | 723 | void ItemUpdater::resetUbootEnvVars() |
| 724 | { |
| 725 | decltype(activations.begin()->second->redundancyPriority.get()->priority()) |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 726 | lowestPriority = std::numeric_limits<uint8_t>::max(); |
Saqib Khan | 49446ae | 2017-10-02 10:54:20 -0500 | [diff] [blame] | 727 | decltype(activations.begin()->second->versionId) lowestPriorityVersion; |
| 728 | for (const auto& intf : activations) |
| 729 | { |
| 730 | if (!intf.second->redundancyPriority.get()) |
| 731 | { |
| 732 | // Skip this version if the redundancyPriority is not initialized. |
| 733 | continue; |
| 734 | } |
| 735 | |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 736 | if (intf.second->redundancyPriority.get()->priority() <= lowestPriority) |
Saqib Khan | 49446ae | 2017-10-02 10:54:20 -0500 | [diff] [blame] | 737 | { |
| 738 | lowestPriority = intf.second->redundancyPriority.get()->priority(); |
| 739 | lowestPriorityVersion = intf.second->versionId; |
| 740 | } |
| 741 | } |
| 742 | |
Saqib Khan | f0382c3 | 2017-10-24 13:36:22 -0500 | [diff] [blame] | 743 | // Update the U-boot environment variable to point to the lowest priority |
Adriana Kobylak | b77551c | 2017-10-27 12:46:23 -0500 | [diff] [blame] | 744 | updateUbootEnvVars(lowestPriorityVersion); |
Saqib Khan | 49446ae | 2017-10-02 10:54:20 -0500 | [diff] [blame] | 745 | } |
| 746 | |
Lei YU | d8c9eea | 2021-12-16 16:08:30 +0800 | [diff] [blame] | 747 | void ItemUpdater::freeSpace([[maybe_unused]] const Activation& caller) |
Adriana Kobylak | 204e1e7 | 2018-01-24 16:00:05 -0600 | [diff] [blame] | 748 | { |
Lei YU | d8c9eea | 2021-12-16 16:08:30 +0800 | [diff] [blame] | 749 | #ifdef BMC_STATIC_DUAL_IMAGE |
| 750 | // For the golden image case, always remove the version on the primary side |
| 751 | std::string versionIDtoErase; |
| 752 | for (const auto& iter : activations) |
| 753 | { |
| 754 | if (iter.second->redundancyPriority && |
| 755 | iter.second->redundancyPriority.get()->priority() == 0) |
| 756 | { |
| 757 | versionIDtoErase = iter.second->versionId; |
| 758 | break; |
| 759 | } |
| 760 | } |
| 761 | if (!versionIDtoErase.empty()) |
| 762 | { |
| 763 | erase(versionIDtoErase); |
| 764 | } |
| 765 | else |
| 766 | { |
| 767 | warning("Failed to find version to erase"); |
| 768 | } |
| 769 | #else |
Adriana Kobylak | 204e1e7 | 2018-01-24 16:00:05 -0600 | [diff] [blame] | 770 | // Versions with the highest priority in front |
| 771 | std::priority_queue<std::pair<int, std::string>, |
| 772 | std::vector<std::pair<int, std::string>>, |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 773 | std::less<std::pair<int, std::string>>> |
| 774 | versionsPQ; |
Adriana Kobylak | 204e1e7 | 2018-01-24 16:00:05 -0600 | [diff] [blame] | 775 | |
| 776 | std::size_t count = 0; |
| 777 | for (const auto& iter : activations) |
| 778 | { |
| 779 | if ((iter.second.get()->activation() == |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 780 | server::Activation::Activations::Active) || |
Adriana Kobylak | 204e1e7 | 2018-01-24 16:00:05 -0600 | [diff] [blame] | 781 | (iter.second.get()->activation() == |
Adriana Kobylak | 2285fe0 | 2018-02-27 15:36:59 -0600 | [diff] [blame] | 782 | server::Activation::Activations::Failed)) |
Adriana Kobylak | 204e1e7 | 2018-01-24 16:00:05 -0600 | [diff] [blame] | 783 | { |
| 784 | count++; |
| 785 | // Don't put the functional version on the queue since we can't |
| 786 | // remove the "running" BMC version. |
Lei YU | 0f88b5a | 2018-08-21 15:28:53 +0800 | [diff] [blame] | 787 | // If ACTIVE_BMC_MAX_ALLOWED <= 1, there is only one active BMC, |
| 788 | // so remove functional version as well. |
Adriana Kobylak | a696359 | 2018-09-07 14:13:29 -0500 | [diff] [blame] | 789 | // Don't delete the the Activation object that called this function. |
| 790 | if ((versions.find(iter.second->versionId) |
| 791 | ->second->isFunctional() && |
| 792 | ACTIVE_BMC_MAX_ALLOWED > 1) || |
| 793 | (iter.second->versionId == caller.versionId)) |
Adriana Kobylak | 204e1e7 | 2018-01-24 16:00:05 -0600 | [diff] [blame] | 794 | { |
| 795 | continue; |
| 796 | } |
Adriana Kobylak | a696359 | 2018-09-07 14:13:29 -0500 | [diff] [blame] | 797 | |
| 798 | // Failed activations don't have priority, assign them a large value |
| 799 | // for sorting purposes. |
| 800 | auto priority = 999; |
| 801 | if (iter.second.get()->activation() == |
Lei YU | cfb4b20 | 2021-05-06 17:47:28 +0800 | [diff] [blame] | 802 | server::Activation::Activations::Active && |
| 803 | iter.second->redundancyPriority) |
Adriana Kobylak | a696359 | 2018-09-07 14:13:29 -0500 | [diff] [blame] | 804 | { |
| 805 | priority = iter.second->redundancyPriority.get()->priority(); |
| 806 | } |
| 807 | |
| 808 | versionsPQ.push(std::make_pair(priority, iter.second->versionId)); |
Adriana Kobylak | 204e1e7 | 2018-01-24 16:00:05 -0600 | [diff] [blame] | 809 | } |
| 810 | } |
| 811 | |
| 812 | // If the number of BMC versions is over ACTIVE_BMC_MAX_ALLOWED -1, |
| 813 | // remove the highest priority one(s). |
| 814 | while ((count >= ACTIVE_BMC_MAX_ALLOWED) && (!versionsPQ.empty())) |
| 815 | { |
| 816 | erase(versionsPQ.top().second); |
| 817 | versionsPQ.pop(); |
| 818 | count--; |
| 819 | } |
Lei YU | d8c9eea | 2021-12-16 16:08:30 +0800 | [diff] [blame] | 820 | #endif |
Adriana Kobylak | 204e1e7 | 2018-01-24 16:00:05 -0600 | [diff] [blame] | 821 | } |
| 822 | |
Eddie James | eaa1ee0 | 2018-03-01 10:09:10 -0600 | [diff] [blame] | 823 | void ItemUpdater::mirrorUbootToAlt() |
| 824 | { |
Lei YU | 56aaf45 | 2018-06-21 16:09:44 +0800 | [diff] [blame] | 825 | helper.mirrorAlt(); |
Eddie James | eaa1ee0 | 2018-03-01 10:09:10 -0600 | [diff] [blame] | 826 | } |
| 827 | |
Bright Cheng | 8e9ccfe | 2019-11-18 16:18:44 +0800 | [diff] [blame] | 828 | bool ItemUpdater::checkImage(const std::string& filePath, |
| 829 | const std::vector<std::string>& imageList) |
| 830 | { |
| 831 | bool valid = true; |
| 832 | |
| 833 | for (auto& bmcImage : imageList) |
| 834 | { |
| 835 | fs::path file(filePath); |
| 836 | file /= bmcImage; |
| 837 | std::ifstream efile(file.c_str()); |
| 838 | if (efile.good() != 1) |
| 839 | { |
| 840 | valid = false; |
| 841 | break; |
| 842 | } |
| 843 | } |
| 844 | |
| 845 | return valid; |
| 846 | } |
| 847 | |
Lei YU | 6e9fb1d | 2021-02-19 18:01:40 +0800 | [diff] [blame] | 848 | #ifdef HOST_BIOS_UPGRADE |
| 849 | void ItemUpdater::createBIOSObject() |
| 850 | { |
| 851 | std::string path = BIOS_OBJPATH; |
| 852 | // Get version id from last item in the path |
| 853 | auto pos = path.rfind("/"); |
| 854 | if (pos == std::string::npos) |
| 855 | { |
Patrick Williams | c9bb642 | 2021-08-27 06:18:35 -0500 | [diff] [blame] | 856 | error("No version id found in object path {PATH}", "PATH", path); |
Lei YU | 6e9fb1d | 2021-02-19 18:01:40 +0800 | [diff] [blame] | 857 | return; |
| 858 | } |
| 859 | |
| 860 | createActiveAssociation(path); |
| 861 | createFunctionalAssociation(path); |
Daniel Hsu | 27d734f | 2024-05-21 15:20:23 +0800 | [diff] [blame^] | 862 | createUpdateableAssociation(path); |
Lei YU | 6e9fb1d | 2021-02-19 18:01:40 +0800 | [diff] [blame] | 863 | |
| 864 | auto versionId = path.substr(pos + 1); |
| 865 | auto version = "null"; |
| 866 | AssociationList assocs = {}; |
| 867 | biosActivation = std::make_unique<Activation>( |
| 868 | bus, path, *this, versionId, server::Activation::Activations::Active, |
| 869 | assocs); |
| 870 | auto dummyErase = [](std::string /*entryId*/) { |
| 871 | // Do nothing; |
| 872 | }; |
| 873 | biosVersion = std::make_unique<VersionClass>( |
| 874 | bus, path, version, VersionPurpose::Host, "", "", |
Justin Ledford | 054bb0b | 2022-03-15 15:46:58 -0700 | [diff] [blame] | 875 | std::vector<std::string>(), |
Adriana Kobylak | 59b640b | 2022-01-21 19:45:22 +0000 | [diff] [blame] | 876 | std::bind(dummyErase, std::placeholders::_1), ""); |
Lei YU | 6e9fb1d | 2021-02-19 18:01:40 +0800 | [diff] [blame] | 877 | biosVersion->deleteObject = |
| 878 | std::make_unique<phosphor::software::manager::Delete>(bus, path, |
| 879 | *biosVersion); |
| 880 | } |
| 881 | #endif |
| 882 | |
Lei YU | 531fbc2 | 2021-12-10 20:03:18 +0800 | [diff] [blame] | 883 | void ItemUpdater::getRunningSlot() |
| 884 | { |
| 885 | // Check /run/media/slot to get the slot number |
| 886 | constexpr auto slotFile = "/run/media/slot"; |
| 887 | std::fstream f(slotFile, std::ios_base::in); |
| 888 | f >> runningImageSlot; |
| 889 | } |
| 890 | |
Gunnar Mills | ec1b41c | 2017-05-02 12:20:36 -0500 | [diff] [blame] | 891 | } // namespace updater |
| 892 | } // namespace software |
| 893 | } // namespace phosphor |