blob: fad8c21063e0badb8b4e4cb2e5ef9eaf867556ca [file] [log] [blame]
Gunnar Millsb0ce9962018-09-07 13:39:10 -05001#include "config.h"
2
3#include "item_updater.hpp"
4
5#include "images.hpp"
6#include "serialize.hpp"
7#include "version.hpp"
Chanh Nguyen1fd6ddd2021-01-06 11:09:09 +07008#include "xyz/openbmc_project/Software/ExtendedVersion/server.hpp"
Gunnar Millsb0ce9962018-09-07 13:39:10 -05009#include "xyz/openbmc_project/Software/Version/server.hpp"
10
Adriana Kobylakd5b8f752019-05-01 11:52:35 -050011#include <phosphor-logging/elog-errors.hpp>
Gunnar Millsb0ce9962018-09-07 13:39:10 -050012#include <phosphor-logging/elog.hpp>
Patrick Williamsc9bb6422021-08-27 06:18:35 -050013#include <phosphor-logging/lg2.hpp>
Adriana Kobylak58aa7502020-06-08 11:12:11 -050014#include <xyz/openbmc_project/Common/error.hpp>
15#include <xyz/openbmc_project/Software/Image/error.hpp>
16
17#include <filesystem>
18#include <fstream>
Adriana Kobylak204e1e72018-01-24 16:00:05 -060019#include <queue>
Adriana Kobylakb77551c2017-10-27 12:46:23 -050020#include <set>
Gunnar Millsec1b41c2017-05-02 12:20:36 -050021#include <string>
George Liu44b9fef2023-02-07 14:31:32 +080022#include <system_error>
Gunnar Millsec1b41c2017-05-02 12:20:36 -050023
24namespace phosphor
25{
26namespace software
27{
28namespace updater
29{
30
Gunnar Mills2ce7da22017-05-04 15:37:56 -050031// When you see server:: you know we're referencing our base class
Patrick Williams1e9a5f12023-08-23 16:53:06 -050032namespace server = sdbusplus::server::xyz::openbmc_project::software;
33namespace control = sdbusplus::server::xyz::openbmc_project::control;
Gunnar Mills2ce7da22017-05-04 15:37:56 -050034
Patrick Williamsc9bb6422021-08-27 06:18:35 -050035PHOSPHOR_LOG2_USING;
Gunnar Mills2ce7da22017-05-04 15:37:56 -050036using namespace phosphor::logging;
Adriana Kobylakce82de52024-01-16 13:56:38 -060037using namespace sdbusplus::error::xyz::openbmc_project::software::image;
Jayanth Othayoth2ab9b102018-02-21 05:27:47 -060038using namespace phosphor::software::image;
Adriana Kobylakc98d9122020-05-05 10:36:01 -050039namespace fs = std::filesystem;
Adriana Kobylakce82de52024-01-16 13:56:38 -060040using NotAllowed = sdbusplus::error::xyz::openbmc_project::common::NotAllowed;
Saqib Khan35e83f32017-05-22 11:37:32 -050041
Patrick Williamsbf2bb2b2022-07-22 19:26:52 -050042void ItemUpdater::createActivation(sdbusplus::message_t& msg)
Gunnar Millsec1b41c2017-05-02 12:20:36 -050043{
Saqib Khan84a0e692017-06-28 17:27:01 -050044 using SVersion = server::Version;
45 using VersionPurpose = SVersion::VersionPurpose;
Gunnar Mills9a782242017-08-22 16:23:15 -050046 using VersionClass = phosphor::software::manager::Version;
Saqib Khan84a0e692017-06-28 17:27:01 -050047
Patrick Williamsbc1facd2020-06-03 05:58:27 -050048 sdbusplus::message::object_path objPath;
Saqib Khan84a0e692017-06-28 17:27:01 -050049 auto purpose = VersionPurpose::Unknown;
Chanh Nguyen1fd6ddd2021-01-06 11:09:09 +070050 std::string extendedVersion;
Saqib Khan705f1bf2017-06-09 23:58:38 -050051 std::string version;
Justin Ledford054bb0b2022-03-15 15:46:58 -070052 std::map<std::string,
53 std::map<std::string,
54 std::variant<std::string, std::vector<std::string>>>>
Adriana Kobylak2285fe02018-02-27 15:36:59 -060055 interfaces;
Patrick Williamse75d10f2017-05-30 16:56:32 -050056 msg.read(objPath, interfaces);
Gunnar Mills2ce7da22017-05-04 15:37:56 -050057 std::string path(std::move(objPath));
Saqib Khan19177d32017-06-20 08:11:49 -050058 std::string filePath;
Justin Ledford054bb0b2022-03-15 15:46:58 -070059 std::vector<std::string> compatibleNames;
Gunnar Mills2ce7da22017-05-04 15:37:56 -050060
61 for (const auto& intf : interfaces)
62 {
Saqib Khan705f1bf2017-06-09 23:58:38 -050063 if (intf.first == VERSION_IFACE)
Gunnar Mills2ce7da22017-05-04 15:37:56 -050064 {
Saqib Khan705f1bf2017-06-09 23:58:38 -050065 for (const auto& property : intf.second)
Gunnar Mills2ce7da22017-05-04 15:37:56 -050066 {
Saqib Khan705f1bf2017-06-09 23:58:38 -050067 if (property.first == "Purpose")
Gunnar Mills2ce7da22017-05-04 15:37:56 -050068 {
Saqib Khan84a0e692017-06-28 17:27:01 -050069 auto value = SVersion::convertVersionPurposeFromString(
Patrick Williamse883fb82020-05-13 11:38:55 -050070 std::get<std::string>(property.second));
Saqib Khan84a0e692017-06-28 17:27:01 -050071 if (value == VersionPurpose::BMC ||
Vijay Khemkae9f6c842020-01-14 14:32:39 -080072#ifdef HOST_BIOS_UPGRADE
73 value == VersionPurpose::Host ||
74#endif
Saqib Khan84a0e692017-06-28 17:27:01 -050075 value == VersionPurpose::System)
76 {
77 purpose = value;
78 }
Saqib Khan705f1bf2017-06-09 23:58:38 -050079 }
80 else if (property.first == "Version")
81 {
Patrick Williamse883fb82020-05-13 11:38:55 -050082 version = std::get<std::string>(property.second);
Gunnar Mills2ce7da22017-05-04 15:37:56 -050083 }
84 }
85 }
Saqib Khan19177d32017-06-20 08:11:49 -050086 else if (intf.first == FILEPATH_IFACE)
87 {
88 for (const auto& property : intf.second)
89 {
90 if (property.first == "Path")
91 {
Patrick Williamse883fb82020-05-13 11:38:55 -050092 filePath = std::get<std::string>(property.second);
Saqib Khan19177d32017-06-20 08:11:49 -050093 }
94 }
95 }
Chanh Nguyen1fd6ddd2021-01-06 11:09:09 +070096 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 Ledford054bb0b2022-03-15 15:46:58 -0700106 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 Mills2ce7da22017-05-04 15:37:56 -0500117 }
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600118 if (version.empty() || filePath.empty() ||
Saqib Khan84a0e692017-06-28 17:27:01 -0500119 purpose == VersionPurpose::Unknown)
Saqib Khan705f1bf2017-06-09 23:58:38 -0500120 {
121 return;
122 }
Gunnar Mills2ce7da22017-05-04 15:37:56 -0500123
124 // Version id is the last item in the path
Pavithra Barithaya27d49382024-06-24 01:52:42 -0500125 auto pos = path.rfind('/');
Gunnar Mills2ce7da22017-05-04 15:37:56 -0500126 if (pos == std::string::npos)
127 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500128 error("No version id found in object path: {PATH}", "PATH", path);
Patrick Williamse75d10f2017-05-30 16:56:32 -0500129 return;
Gunnar Mills2ce7da22017-05-04 15:37:56 -0500130 }
131
132 auto versionId = path.substr(pos + 1);
133
Patrick Williamse75d10f2017-05-30 16:56:32 -0500134 if (activations.find(versionId) == activations.end())
Gunnar Mills2ce7da22017-05-04 15:37:56 -0500135 {
Saqib Khan35e83f32017-05-22 11:37:32 -0500136 // Determine the Activation state by processing the given image dir.
137 auto activationState = server::Activation::Activations::Invalid;
Vijay Khemkae9f6c842020-01-14 14:32:39 -0800138 ItemUpdater::ActivationStatus result;
139 if (purpose == VersionPurpose::BMC || purpose == VersionPurpose::System)
Pavithra Barithayace9a5c92024-06-25 02:24:07 -0500140 {
Vijay Khemkae9f6c842020-01-14 14:32:39 -0800141 result = ItemUpdater::validateSquashFSImage(filePath);
Pavithra Barithayace9a5c92024-06-25 02:24:07 -0500142 }
Vijay Khemkae9f6c842020-01-14 14:32:39 -0800143 else
Pavithra Barithayace9a5c92024-06-25 02:24:07 -0500144 {
Vijay Khemkae9f6c842020-01-14 14:32:39 -0800145 result = ItemUpdater::ActivationStatus::ready;
Pavithra Barithayace9a5c92024-06-25 02:24:07 -0500146 }
Gunnar Mills43b25cd2017-09-07 13:19:34 -0500147 AssociationList associations = {};
148
Saqib Khan35e83f32017-05-22 11:37:32 -0500149 if (result == ItemUpdater::ActivationStatus::ready)
150 {
151 activationState = server::Activation::Activations::Ready;
Gunnar Mills43b25cd2017-09-07 13:19:34 -0500152 // Create an association to the BMC inventory item
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600153 associations.emplace_back(
154 std::make_tuple(ACTIVATION_FWD_ASSOCIATION,
155 ACTIVATION_REV_ASSOCIATION, bmcInventoryPath));
Saqib Khan35e83f32017-05-22 11:37:32 -0500156 }
Gunnar Millsb60add12017-08-24 16:41:42 -0500157
Saqib Khanee13e832017-10-23 12:53:11 -0500158 auto versionPtr = std::make_unique<VersionClass>(
Chanh Nguyen1fd6ddd2021-01-06 11:09:09 +0700159 bus, path, version, purpose, extendedVersion, filePath,
Justin Ledford054bb0b2022-03-15 15:46:58 -0700160 compatibleNames,
Adriana Kobylak59b640b2022-01-21 19:45:22 +0000161 std::bind(&ItemUpdater::erase, this, std::placeholders::_1),
162 versionId);
Saqib Khanee13e832017-10-23 12:53:11 -0500163 versionPtr->deleteObject =
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600164 std::make_unique<phosphor::software::manager::Delete>(bus, path,
165 *versionPtr);
Saqib Khanee13e832017-10-23 12:53:11 -0500166 versions.insert(std::make_pair(versionId, std::move(versionPtr)));
Adriana Kobylak88ba1f92022-03-09 21:14:15 +0000167
168 activations.insert(std::make_pair(
169 versionId,
170 std::make_unique<Activation>(bus, path, *this, versionId,
171 activationState, associations)));
Gunnar Mills2ce7da22017-05-04 15:37:56 -0500172 }
Patrick Williamse75d10f2017-05-30 16:56:32 -0500173 return;
Gunnar Millsec1b41c2017-05-02 12:20:36 -0500174}
175
Saqib Khanba239882017-05-26 08:41:54 -0500176void ItemUpdater::processBMCImage()
177{
Gunnar Mills88e8a322017-09-13 11:09:28 -0500178 using VersionClass = phosphor::software::manager::Version;
Lei YU269bff32018-08-21 15:21:40 +0800179
180 // Check MEDIA_DIR and create if it does not exist
181 try
182 {
183 if (!fs::is_directory(MEDIA_DIR))
184 {
185 fs::create_directory(MEDIA_DIR);
186 }
187 }
188 catch (const fs::filesystem_error& e)
189 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500190 error("Failed to prepare dir: {ERROR}", "ERROR", e);
Lei YU269bff32018-08-21 15:21:40 +0800191 return;
192 }
193
Adriana Kobylak1e81f232022-01-18 22:28:47 +0000194 // Functional images are mounted as rofs-<location>-functional
195 constexpr auto functionalSuffix = "-functional";
Lei YUd474d9c2021-12-10 16:21:21 +0800196 bool functionalFound = false;
Gunnar Mills88e8a322017-09-13 11:09:28 -0500197
Saqib Khan1eef62d2017-08-10 15:29:34 -0500198 // Read os-release from folders under /media/ to get
199 // BMC Software Versions.
George Liu44b9fef2023-02-07 14:31:32 +0800200 std::error_code ec;
201 for (const auto& iter : fs::directory_iterator(MEDIA_DIR, ec))
Saqib Khan1eef62d2017-08-10 15:29:34 -0500202 {
203 auto activationState = server::Activation::Activations::Active;
Saqib Khan6fab70d2017-09-07 00:13:50 -0500204 static const auto BMC_RO_PREFIX_LEN = strlen(BMC_ROFS_PREFIX);
Saqib Khan1eef62d2017-08-10 15:29:34 -0500205
206 // Check if the BMC_RO_PREFIXis the prefix of the iter.path
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600207 if (0 ==
208 iter.path().native().compare(0, BMC_RO_PREFIX_LEN, BMC_ROFS_PREFIX))
Saqib Khan1eef62d2017-08-10 15:29:34 -0500209 {
Adriana Kobylak716cd782020-06-08 13:27:43 -0500210 // Get the version to calculate the id
Adriana Kobylak24a8d832020-06-10 08:29:36 -0500211 fs::path releaseFile(OS_RELEASE_FILE);
212 auto osRelease = iter.path() / releaseFile.relative_path();
George Liu44b9fef2023-02-07 14:31:32 +0800213 if (!fs::is_regular_file(osRelease, ec))
Saqib Khan1eef62d2017-08-10 15:29:34 -0500214 {
Lei YUe56bf872022-02-22 18:40:37 +0800215#ifdef BMC_STATIC_DUAL_IMAGE
216 // For dual image, it is possible that the secondary image is
217 // empty or contains invalid data, ignore such case.
George Liu44b9fef2023-02-07 14:31:32 +0800218 info("Unable to find osRelease: {PATH}: {ERROR_MSG}", "PATH",
219 osRelease, "ERROR_MSG", ec.message());
Lei YUe56bf872022-02-22 18:40:37 +0800220#else
George Liu44b9fef2023-02-07 14:31:32 +0800221 error("Failed to read osRelease: {PATH}: {ERROR_MSG}", "PATH",
222 osRelease, "ERROR_MSG", ec.message());
Adriana Kobylak716cd782020-06-08 13:27:43 -0500223
224 // Try to get the version id from the mount directory name and
225 // call to delete it as this version may be corrupted. Dynamic
226 // volumes created by the UBI layout for example have the id in
227 // the mount directory name. The worst that can happen is that
228 // erase() is called with an non-existent id and returns.
229 auto id = iter.path().native().substr(BMC_RO_PREFIX_LEN);
Saqib Khan021c3652017-09-26 12:11:02 -0500230 ItemUpdater::erase(id);
Lei YUe56bf872022-02-22 18:40:37 +0800231#endif
Adriana Kobylak716cd782020-06-08 13:27:43 -0500232
Saqib Khan021c3652017-09-26 12:11:02 -0500233 continue;
Saqib Khan1eef62d2017-08-10 15:29:34 -0500234 }
Gunnar Mills88e8a322017-09-13 11:09:28 -0500235 auto version = VersionClass::getBMCVersion(osRelease);
Saqib Khan1eef62d2017-08-10 15:29:34 -0500236 if (version.empty())
237 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500238 error("Failed to read version from osRelease: {PATH}", "PATH",
239 osRelease);
Adriana Kobylak716cd782020-06-08 13:27:43 -0500240
241 // Try to delete the version, same as above if the
242 // OS_RELEASE_FILE does not exist.
243 auto id = iter.path().native().substr(BMC_RO_PREFIX_LEN);
244 ItemUpdater::erase(id);
245
246 continue;
Saqib Khan1eef62d2017-08-10 15:29:34 -0500247 }
Saqib Khan021c3652017-09-26 12:11:02 -0500248
Adriana Kobylak59b640b2022-01-21 19:45:22 +0000249 // The flash location is part of the mount name: rofs-<location>
250 auto flashId = iter.path().native().substr(BMC_RO_PREFIX_LEN);
251
252 auto id = VersionClass::getId(version + flashId);
Adriana Kobylak716cd782020-06-08 13:27:43 -0500253
Adriana Kobylakf383d272020-06-16 15:17:22 -0500254 // Check if the id has already been added. This can happen if the
255 // BMC partitions / devices were manually flashed with the same
256 // image.
257 if (versions.find(id) != versions.end())
258 {
259 continue;
260 }
261
Adriana Kobylak1e81f232022-01-18 22:28:47 +0000262 auto functional = false;
263 if (iter.path().native().find(functionalSuffix) !=
264 std::string::npos)
265 {
266 // Set functional to true and remove the functional suffix
267 functional = true;
268 flashId.erase(flashId.length() - strlen(functionalSuffix));
Lei YUd474d9c2021-12-10 16:21:21 +0800269 functionalFound = true;
Adriana Kobylak1e81f232022-01-18 22:28:47 +0000270 }
Adriana Kobylak780220f2022-01-18 20:01:53 +0000271
Saqib Khan1eef62d2017-08-10 15:29:34 -0500272 auto purpose = server::Version::VersionPurpose::BMC;
Adriana Kobylak780220f2022-01-18 20:01:53 +0000273 restorePurpose(flashId, purpose);
Adriana Kobylakec4eec32019-11-13 14:28:35 -0600274
Chanh Nguyen1fd6ddd2021-01-06 11:09:09 +0700275 // Read os-release from /etc/ to get the BMC extended version
276 std::string extendedVersion =
277 VersionClass::getBMCExtendedVersion(osRelease);
278
Saqib Khan1eef62d2017-08-10 15:29:34 -0500279 auto path = fs::path(SOFTWARE_OBJPATH) / id;
280
Adriana Kobylak7b11bba2024-06-24 10:14:49 -0500281 // Create functional association and minimum ship level instance if
282 // this is the functional version
Adriana Kobylak1e81f232022-01-18 22:28:47 +0000283 if (functional)
Gunnar Mills88e8a322017-09-13 11:09:28 -0500284 {
285 createFunctionalAssociation(path);
Adriana Kobylak7b11bba2024-06-24 10:14:49 -0500286
287 if (minimum_ship_level::enabled())
288 {
289 minimumVersionObject =
290 std::make_unique<MinimumVersion>(bus, path);
291 minimumVersionObject->minimumVersion(
292 minimum_ship_level::getMinimumVersion());
293 }
Gunnar Mills88e8a322017-09-13 11:09:28 -0500294 }
295
Gunnar Mills43b25cd2017-09-07 13:19:34 -0500296 AssociationList associations = {};
297
298 if (activationState == server::Activation::Activations::Active)
299 {
300 // Create an association to the BMC inventory item
301 associations.emplace_back(std::make_tuple(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600302 ACTIVATION_FWD_ASSOCIATION, ACTIVATION_REV_ASSOCIATION,
303 bmcInventoryPath));
Gunnar Mills43b25cd2017-09-07 13:19:34 -0500304
305 // Create an active association since this image is active
306 createActiveAssociation(path);
307 }
308
AppaRao Pulibbebec72020-01-28 23:57:41 +0530309 // All updateable firmware components must expose the updateable
310 // association.
311 createUpdateableAssociation(path);
312
Adriana Kobylakee590c72017-09-26 15:16:06 -0500313 // Create Version instance for this version.
314 auto versionPtr = std::make_unique<VersionClass>(
Adriana Kobylaka84f06d2022-01-18 15:41:57 +0000315 bus, path, version, purpose, extendedVersion, flashId,
Justin Ledford054bb0b2022-03-15 15:46:58 -0700316 std::vector<std::string>(),
Adriana Kobylak59b640b2022-01-21 19:45:22 +0000317 std::bind(&ItemUpdater::erase, this, std::placeholders::_1),
318 id);
Adriana Kobylak1e81f232022-01-18 22:28:47 +0000319 if (functional)
320 {
321 versionPtr->setFunctional(true);
322 }
323 else
Michael Tritz4254bec2017-10-03 17:18:22 -0500324 {
Saqib Khanee13e832017-10-23 12:53:11 -0500325 versionPtr->deleteObject =
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600326 std::make_unique<phosphor::software::manager::Delete>(
327 bus, path, *versionPtr);
Michael Tritz4254bec2017-10-03 17:18:22 -0500328 }
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600329 versions.insert(std::make_pair(id, std::move(versionPtr)));
Michael Tritz4254bec2017-10-03 17:18:22 -0500330
Saqib Khanee13e832017-10-23 12:53:11 -0500331 // Create Activation instance for this version.
332 activations.insert(std::make_pair(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600333 id, std::make_unique<Activation>(
334 bus, path, *this, id, activationState, associations)));
Saqib Khan1eef62d2017-08-10 15:29:34 -0500335
Lei YUbdf2d6c2021-12-15 14:05:01 +0800336#ifdef BMC_STATIC_DUAL_IMAGE
337 uint8_t priority;
338 if ((functional && (runningImageSlot == 0)) ||
339 (!functional && (runningImageSlot == 1)))
340 {
341 priority = 0;
342 }
343 else
344 {
345 priority = 1;
346 }
347 activations.find(id)->second->redundancyPriority =
348 std::make_unique<RedundancyPriority>(
349 bus, path, *(activations.find(id)->second), priority,
350 false);
351#else
Lei YU269bff32018-08-21 15:21:40 +0800352 // If Active, create RedundancyPriority instance for this
353 // version.
Saqib Khan1eef62d2017-08-10 15:29:34 -0500354 if (activationState == server::Activation::Activations::Active)
355 {
356 uint8_t priority = std::numeric_limits<uint8_t>::max();
Adriana Kobylak780220f2022-01-18 20:01:53 +0000357 if (!restorePriority(flashId, priority))
Saqib Khan1eef62d2017-08-10 15:29:34 -0500358 {
Adriana Kobylak1e81f232022-01-18 22:28:47 +0000359 if (functional)
Adriana Kobylakee590c72017-09-26 15:16:06 -0500360 {
361 priority = 0;
362 }
363 else
364 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500365 error(
366 "Unable to restore priority from file for {VERSIONID}",
367 "VERSIONID", id);
Adriana Kobylakee590c72017-09-26 15:16:06 -0500368 }
Saqib Khan1eef62d2017-08-10 15:29:34 -0500369 }
370 activations.find(id)->second->redundancyPriority =
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600371 std::make_unique<RedundancyPriority>(
372 bus, path, *(activations.find(id)->second), priority,
373 false);
Saqib Khan1eef62d2017-08-10 15:29:34 -0500374 }
Lei YUbdf2d6c2021-12-15 14:05:01 +0800375#endif
Saqib Khan1eef62d2017-08-10 15:29:34 -0500376 }
377 }
Saqib Khandcbfa042017-09-18 13:08:39 -0500378
Lei YUd474d9c2021-12-10 16:21:21 +0800379 if (!functionalFound)
Saqib Khandcbfa042017-09-18 13:08:39 -0500380 {
Lei YUd474d9c2021-12-10 16:21:21 +0800381 // If there is no functional version found, read the /etc/os-release and
382 // create rofs-<versionId>-functional under MEDIA_DIR, then call again
383 // processBMCImage() to create the D-Bus interface for it.
Gunnar Millsd16bcbd2017-10-08 16:50:42 -0500384 auto version = VersionClass::getBMCVersion(OS_RELEASE_FILE);
Adriana Kobylak59b640b2022-01-21 19:45:22 +0000385 auto id = phosphor::software::manager::Version::getId(version +
386 functionalSuffix);
Adriana Kobylak1e81f232022-01-18 22:28:47 +0000387 auto versionFileDir = BMC_ROFS_PREFIX + id + functionalSuffix + "/etc/";
Saqib Khandcbfa042017-09-18 13:08:39 -0500388 try
389 {
Gunnar Millsd16bcbd2017-10-08 16:50:42 -0500390 if (!fs::is_directory(versionFileDir))
Saqib Khandcbfa042017-09-18 13:08:39 -0500391 {
392 fs::create_directories(versionFileDir);
393 }
Patrick Williamsd5e8e732023-05-10 07:50:18 -0500394 auto versionFilePath = BMC_ROFS_PREFIX + id + functionalSuffix +
395 OS_RELEASE_FILE;
Saqib Khandcbfa042017-09-18 13:08:39 -0500396 fs::create_directory_symlink(OS_RELEASE_FILE, versionFilePath);
397 ItemUpdater::processBMCImage();
398 }
399 catch (const std::exception& e)
400 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500401 error("Exception during processing: {ERROR}", "ERROR", e);
Saqib Khandcbfa042017-09-18 13:08:39 -0500402 }
403 }
Eddie Jameseaa1ee02018-03-01 10:09:10 -0600404
405 mirrorUbootToAlt();
Saqib Khanba239882017-05-26 08:41:54 -0500406 return;
407}
408
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500409void ItemUpdater::erase(std::string entryId)
410{
Eddie James6d873712017-09-01 11:29:07 -0500411 // Find entry in versions map
412 auto it = versions.find(entryId);
413 if (it != versions.end())
414 {
Lei YU0f88b5a2018-08-21 15:28:53 +0800415 if (it->second->isFunctional() && ACTIVE_BMC_MAX_ALLOWED > 1)
Eddie James6d873712017-09-01 11:29:07 -0500416 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500417 error(
418 "Version ({VERSIONID}) is currently running on the BMC; unable to remove.",
419 "VERSIONID", entryId);
Gunnar Millsd16bcbd2017-10-08 16:50:42 -0500420 return;
Eddie James6d873712017-09-01 11:29:07 -0500421 }
Adriana Kobylakd1a55ad2020-06-11 14:01:28 -0500422 }
Eddie James6d873712017-09-01 11:29:07 -0500423
Adriana Kobylakd1a55ad2020-06-11 14:01:28 -0500424 // First call resetUbootEnvVars() so that the BMC points to a valid image to
425 // boot from. If resetUbootEnvVars() is called after the image is actually
426 // deleted from the BMC flash, there'd be a time window where the BMC would
427 // be pointing to a non-existent image to boot from.
428 // Need to remove the entries from the activations map before that call so
429 // that resetUbootEnvVars() doesn't use the version to be deleted.
430 auto iteratorActivations = activations.find(entryId);
431 if (iteratorActivations == activations.end())
432 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500433 error(
434 "Failed to find version ({VERSIONID}) in item updater activations map; unable to remove.",
435 "VERSIONID", entryId);
Adriana Kobylakd1a55ad2020-06-11 14:01:28 -0500436 }
437 else
438 {
439 removeAssociations(iteratorActivations->second->path);
Zami Seckae06d762021-08-13 20:11:15 -0500440 iteratorActivations->second->deleteImageManagerObject();
Adriana Kobylakd1a55ad2020-06-11 14:01:28 -0500441 this->activations.erase(entryId);
442 }
443 ItemUpdater::resetUbootEnvVars();
444
445 if (it != versions.end())
446 {
Adriana Kobylak780220f2022-01-18 20:01:53 +0000447 auto flashId = it->second->path();
448
Adriana Kobylak25773a72022-01-21 15:24:48 +0000449 // Delete version data if it has been installed on flash (path is not
450 // the upload directory)
451 if (flashId.find(IMG_UPLOAD_DIR) == std::string::npos)
452 {
453 removeReadOnlyPartition(entryId);
454 removePersistDataDirectory(flashId);
455 helper.clearEntry(flashId);
456 }
Saqib Khanee13e832017-10-23 12:53:11 -0500457
458 // Removing entry in versions map
459 this->versions.erase(entryId);
Eddie James6d873712017-09-01 11:29:07 -0500460 }
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500461
Saqib Khanee13e832017-10-23 12:53:11 -0500462 return;
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500463}
464
Michael Tritzbc1bf3a2017-09-18 16:38:23 -0500465void ItemUpdater::deleteAll()
466{
Adriana Kobylak83cd21f2018-02-28 15:48:48 -0600467 std::vector<std::string> deletableVersions;
468
Michael Tritzbc1bf3a2017-09-18 16:38:23 -0500469 for (const auto& versionIt : versions)
470 {
471 if (!versionIt.second->isFunctional())
472 {
Adriana Kobylak83cd21f2018-02-28 15:48:48 -0600473 deletableVersions.push_back(versionIt.first);
Michael Tritzbc1bf3a2017-09-18 16:38:23 -0500474 }
475 }
476
Adriana Kobylak83cd21f2018-02-28 15:48:48 -0600477 for (const auto& deletableIt : deletableVersions)
478 {
479 ItemUpdater::erase(deletableIt);
480 }
481
Lei YU56aaf452018-06-21 16:09:44 +0800482 helper.cleanup();
Michael Tritzbc1bf3a2017-09-18 16:38:23 -0500483}
484
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600485ItemUpdater::ActivationStatus
486 ItemUpdater::validateSquashFSImage(const std::string& filePath)
Saqib Khan35e83f32017-05-22 11:37:32 -0500487{
Bright Cheng8e9ccfe2019-11-18 16:18:44 +0800488 bool valid = true;
Saqib Khan35e83f32017-05-22 11:37:32 -0500489
Bright Cheng8e9ccfe2019-11-18 16:18:44 +0800490 // Record the images which are being updated
491 // First check for the fullimage, then check for images with partitions
492 imageUpdateList.push_back(bmcFullImages);
493 valid = checkImage(filePath, imageUpdateList);
494 if (!valid)
Saqib Khan35e83f32017-05-22 11:37:32 -0500495 {
Bright Cheng8e9ccfe2019-11-18 16:18:44 +0800496 imageUpdateList.clear();
497 imageUpdateList.assign(bmcImages.begin(), bmcImages.end());
498 valid = checkImage(filePath, imageUpdateList);
499 if (!valid)
Michael Tritzb1cfdf92017-08-14 14:33:30 -0500500 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500501 error("Failed to find the needed BMC images.");
Bright Cheng8e9ccfe2019-11-18 16:18:44 +0800502 return ItemUpdater::ActivationStatus::invalid;
Michael Tritzb1cfdf92017-08-14 14:33:30 -0500503 }
Saqib Khan35e83f32017-05-22 11:37:32 -0500504 }
Michael Tritzb1cfdf92017-08-14 14:33:30 -0500505
Michael Tritzb1cfdf92017-08-14 14:33:30 -0500506 return ItemUpdater::ActivationStatus::ready;
Saqib Khan35e83f32017-05-22 11:37:32 -0500507}
508
Adriana Kobylakbbcb7be2018-07-17 15:47:34 -0500509void ItemUpdater::savePriority(const std::string& versionId, uint8_t value)
510{
Adriana Kobylak780220f2022-01-18 20:01:53 +0000511 auto flashId = versions.find(versionId)->second->path();
512 storePriority(flashId, value);
Adriana Kobylak25773a72022-01-21 15:24:48 +0000513 helper.setEntry(flashId, value);
Adriana Kobylakbbcb7be2018-07-17 15:47:34 -0500514}
515
Saqib Khanb9da6632017-09-13 09:48:37 -0500516void ItemUpdater::freePriority(uint8_t value, const std::string& versionId)
Saqib Khan4c1aec02017-07-06 11:46:13 -0500517{
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500518 std::map<std::string, uint8_t> priorityMap;
519
520 // Insert the requested version and priority, it may not exist yet.
521 priorityMap.insert(std::make_pair(versionId, value));
522
Saqib Khan4c1aec02017-07-06 11:46:13 -0500523 for (const auto& intf : activations)
524 {
Gunnar Mills9a782242017-08-22 16:23:15 -0500525 if (intf.second->redundancyPriority)
Saqib Khan4c1aec02017-07-06 11:46:13 -0500526 {
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500527 priorityMap.insert(std::make_pair(
Pavithra Barithaya9d7b3312024-06-26 01:58:51 -0500528 intf.first, intf.second->redundancyPriority->priority()));
Saqib Khan4c1aec02017-07-06 11:46:13 -0500529 }
530 }
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500531
532 // Lambda function to compare 2 priority values, use <= to allow duplicates
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600533 typedef std::function<bool(std::pair<std::string, uint8_t>,
534 std::pair<std::string, uint8_t>)>
535 cmpPriority;
536 cmpPriority cmpPriorityFunc =
Pavithra Barithaya6d178522024-06-24 04:17:29 -0500537 [](const std::pair<std::string, uint8_t>& priority1,
538 const std::pair<std::string, uint8_t>& priority2) {
Patrick Williamsd5e8e732023-05-10 07:50:18 -0500539 return priority1.second <= priority2.second;
540 };
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500541
542 // Sort versions by ascending priority
543 std::set<std::pair<std::string, uint8_t>, cmpPriority> prioritySet(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600544 priorityMap.begin(), priorityMap.end(), cmpPriorityFunc);
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500545
546 auto freePriorityValue = value;
547 for (auto& element : prioritySet)
548 {
549 if (element.first == versionId)
550 {
551 continue;
552 }
553 if (element.second == freePriorityValue)
554 {
555 ++freePriorityValue;
556 auto it = activations.find(element.first);
Pavithra Barithaya9d7b3312024-06-26 01:58:51 -0500557 it->second->redundancyPriority->sdbusPriority(freePriorityValue);
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500558 }
559 }
560
561 auto lowestVersion = prioritySet.begin()->first;
562 if (value == prioritySet.begin()->second)
563 {
564 lowestVersion = versionId;
565 }
566 updateUbootEnvVars(lowestVersion);
Saqib Khan4c1aec02017-07-06 11:46:13 -0500567}
568
Michael Tritz37a59042017-07-12 13:44:53 -0500569void ItemUpdater::reset()
570{
Pavithra Barithayac5f6e7e2024-06-24 09:50:21 -0500571 phosphor::software::updater::Helper::factoryReset();
Michael Tritz37a59042017-07-12 13:44:53 -0500572
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500573 info("BMC factory reset will take effect upon reboot.");
Michael Tritz37a59042017-07-12 13:44:53 -0500574}
575
Pavithra Barithaya6d178522024-06-24 04:17:29 -0500576void ItemUpdater::removeReadOnlyPartition(const std::string& versionId)
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500577{
Adriana Kobylak25773a72022-01-21 15:24:48 +0000578 auto flashId = versions.find(versionId)->second->path();
579 helper.removeVersion(flashId);
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500580}
581
Michael Tritz0129d922017-08-10 19:33:46 -0500582bool ItemUpdater::fieldModeEnabled(bool value)
583{
584 // enabling field mode is intended to be one way: false -> true
585 if (value && !control::FieldMode::fieldModeEnabled())
586 {
587 control::FieldMode::fieldModeEnabled(value);
588
Adriana Kobylak22848ec2019-10-28 10:08:39 -0500589 auto method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
590 SYSTEMD_INTERFACE, "StartUnit");
591 method.append("obmc-flash-bmc-setenv@fieldmode\\x3dtrue.service",
592 "replace");
593 bus.call_noreply(method);
594
595 method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
596 SYSTEMD_INTERFACE, "StopUnit");
597 method.append("usr-local.mount", "replace");
598 bus.call_noreply(method);
599
600 std::vector<std::string> usrLocal = {"usr-local.mount"};
601
602 method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
603 SYSTEMD_INTERFACE, "MaskUnitFiles");
604 method.append(usrLocal, false, true);
605 bus.call_noreply(method);
Michael Tritz0129d922017-08-10 19:33:46 -0500606 }
Adriana Kobylakd5b8f752019-05-01 11:52:35 -0500607 else if (!value && control::FieldMode::fieldModeEnabled())
608 {
Adriana Kobylakce82de52024-01-16 13:56:38 -0600609 elog<NotAllowed>(xyz::openbmc_project::common::NotAllowed::REASON(
Adriana Kobylakd5b8f752019-05-01 11:52:35 -0500610 "FieldMode is not allowed to be cleared"));
611 }
Michael Tritz0129d922017-08-10 19:33:46 -0500612
613 return control::FieldMode::fieldModeEnabled();
614}
615
616void ItemUpdater::restoreFieldModeStatus()
617{
Isaac Kurthdeb86b42022-03-08 19:47:53 -0600618 // The fieldmode u-boot environment variable may not exist since it is not
619 // part of the default environment, run fw_printenv with 2>&1 to ignore the
620 // error message in the journal "Error: "fieldmode" not defined"
Patrick Williamsd5e8e732023-05-10 07:50:18 -0500621 std::pair<int, std::string> ret = utils::execute("/sbin/fw_printenv", "-n",
622 "fieldmode", "2>&1");
Michael Tritz0129d922017-08-10 19:33:46 -0500623
Isaac Kurthdeb86b42022-03-08 19:47:53 -0600624 if (ret.first != 0)
625 {
626 return;
627 }
628
629 // truncate any extra characters off the end to compare against a "true" str
630 std::string result = ret.second.substr(0, 4);
631 if (result == "true")
Michael Tritz0129d922017-08-10 19:33:46 -0500632 {
633 ItemUpdater::fieldModeEnabled(true);
634 }
635}
636
Gunnar Millsb60add12017-08-24 16:41:42 -0500637void ItemUpdater::setBMCInventoryPath()
638{
Gunnar Millsb60add12017-08-24 16:41:42 -0500639 auto depth = 0;
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600640 auto mapperCall = bus.new_method_call(MAPPER_BUSNAME, MAPPER_PATH,
641 MAPPER_INTERFACE, "GetSubTreePaths");
Gunnar Millsb60add12017-08-24 16:41:42 -0500642
Adriana Kobylak1254c622017-12-07 12:24:56 -0600643 mapperCall.append(INVENTORY_PATH);
Gunnar Millsb60add12017-08-24 16:41:42 -0500644 mapperCall.append(depth);
Adriana Kobylak1254c622017-12-07 12:24:56 -0600645 std::vector<std::string> filter = {BMC_INVENTORY_INTERFACE};
Gunnar Millsb60add12017-08-24 16:41:42 -0500646 mapperCall.append(filter);
647
Ed Tanous87c78172018-08-10 12:51:53 -0700648 try
649 {
650 auto response = bus.call(mapperCall);
651
652 using ObjectPaths = std::vector<std::string>;
653 ObjectPaths result;
654 response.read(result);
655
656 if (!result.empty())
657 {
658 bmcInventoryPath = result.front();
659 }
660 }
Patrick Williamsbf2bb2b2022-07-22 19:26:52 -0500661 catch (const sdbusplus::exception_t& e)
Gunnar Millsb60add12017-08-24 16:41:42 -0500662 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500663 error("Error in mapper GetSubTreePath: {ERROR}", "ERROR", e);
Gunnar Millsb60add12017-08-24 16:41:42 -0500664 return;
665 }
666
Adriana Kobylak1254c622017-12-07 12:24:56 -0600667 return;
Gunnar Millsb60add12017-08-24 16:41:42 -0500668}
669
Gunnar Millsf10b2322017-09-21 15:31:55 -0500670void ItemUpdater::createActiveAssociation(const std::string& path)
Gunnar Millsded875d2017-08-28 16:44:52 -0500671{
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600672 assocs.emplace_back(
673 std::make_tuple(ACTIVE_FWD_ASSOCIATION, ACTIVE_REV_ASSOCIATION, path));
Gunnar Millsded875d2017-08-28 16:44:52 -0500674 associations(assocs);
675}
676
Gunnar Mills88e8a322017-09-13 11:09:28 -0500677void ItemUpdater::createFunctionalAssociation(const std::string& path)
678{
679 assocs.emplace_back(std::make_tuple(FUNCTIONAL_FWD_ASSOCIATION,
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600680 FUNCTIONAL_REV_ASSOCIATION, path));
Gunnar Mills88e8a322017-09-13 11:09:28 -0500681 associations(assocs);
682}
683
AppaRao Pulibbebec72020-01-28 23:57:41 +0530684void ItemUpdater::createUpdateableAssociation(const std::string& path)
685{
686 assocs.emplace_back(std::make_tuple(UPDATEABLE_FWD_ASSOCIATION,
687 UPDATEABLE_REV_ASSOCIATION, path));
688 associations(assocs);
689}
690
Adriana Kobylak991af7e2018-12-10 13:08:38 -0600691void ItemUpdater::removeAssociations(const std::string& path)
Gunnar Millsded875d2017-08-28 16:44:52 -0500692{
693 for (auto iter = assocs.begin(); iter != assocs.end();)
694 {
Pavithra Barithaya9e307b72024-06-26 01:27:38 -0500695 if (std::get<2>(*iter) == path)
Gunnar Millsded875d2017-08-28 16:44:52 -0500696 {
697 iter = assocs.erase(iter);
698 associations(assocs);
699 }
700 else
701 {
702 ++iter;
703 }
704 }
705}
706
Saqib Khanb9da6632017-09-13 09:48:37 -0500707bool ItemUpdater::isLowestPriority(uint8_t value)
708{
709 for (const auto& intf : activations)
710 {
Gunnar Millsd16bcbd2017-10-08 16:50:42 -0500711 if (intf.second->redundancyPriority)
Saqib Khanb9da6632017-09-13 09:48:37 -0500712 {
Pavithra Barithaya9d7b3312024-06-26 01:58:51 -0500713 if (intf.second->redundancyPriority->priority() < value)
Saqib Khanb9da6632017-09-13 09:48:37 -0500714 {
715 return false;
716 }
717 }
718 }
719 return true;
720}
721
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500722void ItemUpdater::updateUbootEnvVars(const std::string& versionId)
723{
Lei YU9c76a0a2022-03-14 11:37:15 +0800724 auto it = versions.find(versionId);
725 if (it == versions.end())
726 {
727 return;
728 }
729 auto flashId = it->second->path();
Adriana Kobylak25773a72022-01-21 15:24:48 +0000730 helper.updateUbootVersionId(flashId);
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500731}
732
Saqib Khan49446ae2017-10-02 10:54:20 -0500733void ItemUpdater::resetUbootEnvVars()
734{
Pavithra Barithaya9d7b3312024-06-26 01:58:51 -0500735 decltype(activations.begin()->second->redundancyPriority->priority())
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600736 lowestPriority = std::numeric_limits<uint8_t>::max();
Saqib Khan49446ae2017-10-02 10:54:20 -0500737 decltype(activations.begin()->second->versionId) lowestPriorityVersion;
738 for (const auto& intf : activations)
739 {
Pavithra Barithaya9d7b3312024-06-26 01:58:51 -0500740 if (!intf.second->redundancyPriority)
Saqib Khan49446ae2017-10-02 10:54:20 -0500741 {
742 // Skip this version if the redundancyPriority is not initialized.
743 continue;
744 }
745
Pavithra Barithaya9d7b3312024-06-26 01:58:51 -0500746 if (intf.second->redundancyPriority->priority() <= lowestPriority)
Saqib Khan49446ae2017-10-02 10:54:20 -0500747 {
Pavithra Barithaya9d7b3312024-06-26 01:58:51 -0500748 lowestPriority = intf.second->redundancyPriority->priority();
Saqib Khan49446ae2017-10-02 10:54:20 -0500749 lowestPriorityVersion = intf.second->versionId;
750 }
751 }
752
Saqib Khanf0382c32017-10-24 13:36:22 -0500753 // Update the U-boot environment variable to point to the lowest priority
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500754 updateUbootEnvVars(lowestPriorityVersion);
Saqib Khan49446ae2017-10-02 10:54:20 -0500755}
756
Lei YUd8c9eea2021-12-16 16:08:30 +0800757void ItemUpdater::freeSpace([[maybe_unused]] const Activation& caller)
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600758{
Lei YUd8c9eea2021-12-16 16:08:30 +0800759#ifdef BMC_STATIC_DUAL_IMAGE
760 // For the golden image case, always remove the version on the primary side
761 std::string versionIDtoErase;
762 for (const auto& iter : activations)
763 {
764 if (iter.second->redundancyPriority &&
Pavithra Barithaya9d7b3312024-06-26 01:58:51 -0500765 iter.second->redundancyPriority->priority() == 0)
Lei YUd8c9eea2021-12-16 16:08:30 +0800766 {
767 versionIDtoErase = iter.second->versionId;
768 break;
769 }
770 }
771 if (!versionIDtoErase.empty())
772 {
773 erase(versionIDtoErase);
774 }
775 else
776 {
777 warning("Failed to find version to erase");
778 }
779#else
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600780 // Versions with the highest priority in front
781 std::priority_queue<std::pair<int, std::string>,
782 std::vector<std::pair<int, std::string>>,
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600783 std::less<std::pair<int, std::string>>>
784 versionsPQ;
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600785
786 std::size_t count = 0;
787 for (const auto& iter : activations)
788 {
789 if ((iter.second.get()->activation() ==
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600790 server::Activation::Activations::Active) ||
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600791 (iter.second.get()->activation() ==
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600792 server::Activation::Activations::Failed))
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600793 {
794 count++;
795 // Don't put the functional version on the queue since we can't
796 // remove the "running" BMC version.
Lei YU0f88b5a2018-08-21 15:28:53 +0800797 // If ACTIVE_BMC_MAX_ALLOWED <= 1, there is only one active BMC,
798 // so remove functional version as well.
Adriana Kobylaka6963592018-09-07 14:13:29 -0500799 // Don't delete the the Activation object that called this function.
800 if ((versions.find(iter.second->versionId)
801 ->second->isFunctional() &&
802 ACTIVE_BMC_MAX_ALLOWED > 1) ||
803 (iter.second->versionId == caller.versionId))
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600804 {
805 continue;
806 }
Adriana Kobylaka6963592018-09-07 14:13:29 -0500807
808 // Failed activations don't have priority, assign them a large value
809 // for sorting purposes.
810 auto priority = 999;
811 if (iter.second.get()->activation() ==
Lei YUcfb4b202021-05-06 17:47:28 +0800812 server::Activation::Activations::Active &&
813 iter.second->redundancyPriority)
Adriana Kobylaka6963592018-09-07 14:13:29 -0500814 {
815 priority = iter.second->redundancyPriority.get()->priority();
816 }
817
818 versionsPQ.push(std::make_pair(priority, iter.second->versionId));
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600819 }
820 }
821
822 // If the number of BMC versions is over ACTIVE_BMC_MAX_ALLOWED -1,
823 // remove the highest priority one(s).
824 while ((count >= ACTIVE_BMC_MAX_ALLOWED) && (!versionsPQ.empty()))
825 {
826 erase(versionsPQ.top().second);
827 versionsPQ.pop();
828 count--;
829 }
Lei YUd8c9eea2021-12-16 16:08:30 +0800830#endif
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600831}
832
Eddie Jameseaa1ee02018-03-01 10:09:10 -0600833void ItemUpdater::mirrorUbootToAlt()
834{
Lei YU56aaf452018-06-21 16:09:44 +0800835 helper.mirrorAlt();
Eddie Jameseaa1ee02018-03-01 10:09:10 -0600836}
837
Bright Cheng8e9ccfe2019-11-18 16:18:44 +0800838bool ItemUpdater::checkImage(const std::string& filePath,
839 const std::vector<std::string>& imageList)
840{
841 bool valid = true;
842
843 for (auto& bmcImage : imageList)
844 {
845 fs::path file(filePath);
846 file /= bmcImage;
847 std::ifstream efile(file.c_str());
848 if (efile.good() != 1)
849 {
850 valid = false;
851 break;
852 }
853 }
854
855 return valid;
856}
857
Lei YU6e9fb1d2021-02-19 18:01:40 +0800858#ifdef HOST_BIOS_UPGRADE
859void ItemUpdater::createBIOSObject()
860{
861 std::string path = BIOS_OBJPATH;
862 // Get version id from last item in the path
Pavithra Barithaya27d49382024-06-24 01:52:42 -0500863 auto pos = path.rfind('/');
Lei YU6e9fb1d2021-02-19 18:01:40 +0800864 if (pos == std::string::npos)
865 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500866 error("No version id found in object path {PATH}", "PATH", path);
Lei YU6e9fb1d2021-02-19 18:01:40 +0800867 return;
868 }
869
870 createActiveAssociation(path);
871 createFunctionalAssociation(path);
Daniel Hsu27d734f2024-05-21 15:20:23 +0800872 createUpdateableAssociation(path);
Lei YU6e9fb1d2021-02-19 18:01:40 +0800873
874 auto versionId = path.substr(pos + 1);
875 auto version = "null";
876 AssociationList assocs = {};
877 biosActivation = std::make_unique<Activation>(
878 bus, path, *this, versionId, server::Activation::Activations::Active,
879 assocs);
Pavithra Barithaya6d178522024-06-24 04:17:29 -0500880 auto dummyErase = [](const std::string& /*entryId*/) {
Lei YU6e9fb1d2021-02-19 18:01:40 +0800881 // Do nothing;
882 };
883 biosVersion = std::make_unique<VersionClass>(
884 bus, path, version, VersionPurpose::Host, "", "",
Justin Ledford054bb0b2022-03-15 15:46:58 -0700885 std::vector<std::string>(),
Adriana Kobylak59b640b2022-01-21 19:45:22 +0000886 std::bind(dummyErase, std::placeholders::_1), "");
Lei YU6e9fb1d2021-02-19 18:01:40 +0800887 biosVersion->deleteObject =
888 std::make_unique<phosphor::software::manager::Delete>(bus, path,
889 *biosVersion);
890}
891#endif
892
Lei YU531fbc22021-12-10 20:03:18 +0800893void ItemUpdater::getRunningSlot()
894{
895 // Check /run/media/slot to get the slot number
896 constexpr auto slotFile = "/run/media/slot";
897 std::fstream f(slotFile, std::ios_base::in);
898 f >> runningImageSlot;
899}
900
Gunnar Millsec1b41c2017-05-02 12:20:36 -0500901} // namespace updater
902} // namespace software
903} // namespace phosphor