blob: 8619c913923b9e78cddf9e239c64264fb759283f [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>
Gunnar Millsec1b41c2017-05-02 12:20:36 -050022
23namespace phosphor
24{
25namespace software
26{
27namespace updater
28{
29
Gunnar Mills2ce7da22017-05-04 15:37:56 -050030// When you see server:: you know we're referencing our base class
31namespace server = sdbusplus::xyz::openbmc_project::Software::server;
Michael Tritz0129d922017-08-10 19:33:46 -050032namespace control = sdbusplus::xyz::openbmc_project::Control::server;
Gunnar Mills2ce7da22017-05-04 15:37:56 -050033
Patrick Williamsc9bb6422021-08-27 06:18:35 -050034PHOSPHOR_LOG2_USING;
Gunnar Mills2ce7da22017-05-04 15:37:56 -050035using namespace phosphor::logging;
Adriana Kobylak43699ca2018-10-17 14:56:29 -050036using namespace sdbusplus::xyz::openbmc_project::Software::Image::Error;
Jayanth Othayoth2ab9b102018-02-21 05:27:47 -060037using namespace phosphor::software::image;
Adriana Kobylakc98d9122020-05-05 10:36:01 -050038namespace fs = std::filesystem;
Adriana Kobylakd5b8f752019-05-01 11:52:35 -050039using NotAllowed = sdbusplus::xyz::openbmc_project::Common::Error::NotAllowed;
Saqib Khan35e83f32017-05-22 11:37:32 -050040
Patrick Williamse75d10f2017-05-30 16:56:32 -050041void ItemUpdater::createActivation(sdbusplus::message::message& msg)
Gunnar Millsec1b41c2017-05-02 12:20:36 -050042{
Saqib Khan84a0e692017-06-28 17:27:01 -050043
44 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;
Patrick Williamsbc1facd2020-06-03 05:58:27 -050052 std::map<std::string, std::map<std::string, std::variant<std::string>>>
Adriana Kobylak2285fe02018-02-27 15:36:59 -060053 interfaces;
Patrick Williamse75d10f2017-05-30 16:56:32 -050054 msg.read(objPath, interfaces);
Gunnar Mills2ce7da22017-05-04 15:37:56 -050055 std::string path(std::move(objPath));
Saqib Khan19177d32017-06-20 08:11:49 -050056 std::string filePath;
Gunnar Mills2ce7da22017-05-04 15:37:56 -050057
58 for (const auto& intf : interfaces)
59 {
Saqib Khan705f1bf2017-06-09 23:58:38 -050060 if (intf.first == VERSION_IFACE)
Gunnar Mills2ce7da22017-05-04 15:37:56 -050061 {
Saqib Khan705f1bf2017-06-09 23:58:38 -050062 for (const auto& property : intf.second)
Gunnar Mills2ce7da22017-05-04 15:37:56 -050063 {
Saqib Khan705f1bf2017-06-09 23:58:38 -050064 if (property.first == "Purpose")
Gunnar Mills2ce7da22017-05-04 15:37:56 -050065 {
Saqib Khan84a0e692017-06-28 17:27:01 -050066 auto value = SVersion::convertVersionPurposeFromString(
Patrick Williamse883fb82020-05-13 11:38:55 -050067 std::get<std::string>(property.second));
Saqib Khan84a0e692017-06-28 17:27:01 -050068 if (value == VersionPurpose::BMC ||
Vijay Khemkae9f6c842020-01-14 14:32:39 -080069#ifdef HOST_BIOS_UPGRADE
70 value == VersionPurpose::Host ||
71#endif
Saqib Khan84a0e692017-06-28 17:27:01 -050072 value == VersionPurpose::System)
73 {
74 purpose = value;
75 }
Saqib Khan705f1bf2017-06-09 23:58:38 -050076 }
77 else if (property.first == "Version")
78 {
Patrick Williamse883fb82020-05-13 11:38:55 -050079 version = std::get<std::string>(property.second);
Gunnar Mills2ce7da22017-05-04 15:37:56 -050080 }
81 }
82 }
Saqib Khan19177d32017-06-20 08:11:49 -050083 else if (intf.first == FILEPATH_IFACE)
84 {
85 for (const auto& property : intf.second)
86 {
87 if (property.first == "Path")
88 {
Patrick Williamse883fb82020-05-13 11:38:55 -050089 filePath = std::get<std::string>(property.second);
Saqib Khan19177d32017-06-20 08:11:49 -050090 }
91 }
92 }
Chanh Nguyen1fd6ddd2021-01-06 11:09:09 +070093 else if (intf.first == EXTENDED_VERSION_IFACE)
94 {
95 for (const auto& property : intf.second)
96 {
97 if (property.first == "ExtendedVersion")
98 {
99 extendedVersion = std::get<std::string>(property.second);
100 }
101 }
102 }
Gunnar Mills2ce7da22017-05-04 15:37:56 -0500103 }
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600104 if (version.empty() || filePath.empty() ||
Saqib Khan84a0e692017-06-28 17:27:01 -0500105 purpose == VersionPurpose::Unknown)
Saqib Khan705f1bf2017-06-09 23:58:38 -0500106 {
107 return;
108 }
Gunnar Mills2ce7da22017-05-04 15:37:56 -0500109
110 // Version id is the last item in the path
111 auto pos = path.rfind("/");
112 if (pos == std::string::npos)
113 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500114 error("No version id found in object path: {PATH}", "PATH", path);
Patrick Williamse75d10f2017-05-30 16:56:32 -0500115 return;
Gunnar Mills2ce7da22017-05-04 15:37:56 -0500116 }
117
118 auto versionId = path.substr(pos + 1);
119
Patrick Williamse75d10f2017-05-30 16:56:32 -0500120 if (activations.find(versionId) == activations.end())
Gunnar Mills2ce7da22017-05-04 15:37:56 -0500121 {
Saqib Khan35e83f32017-05-22 11:37:32 -0500122 // Determine the Activation state by processing the given image dir.
123 auto activationState = server::Activation::Activations::Invalid;
Vijay Khemkae9f6c842020-01-14 14:32:39 -0800124 ItemUpdater::ActivationStatus result;
125 if (purpose == VersionPurpose::BMC || purpose == VersionPurpose::System)
126 result = ItemUpdater::validateSquashFSImage(filePath);
127 else
128 result = ItemUpdater::ActivationStatus::ready;
129
Gunnar Mills43b25cd2017-09-07 13:19:34 -0500130 AssociationList associations = {};
131
Saqib Khan35e83f32017-05-22 11:37:32 -0500132 if (result == ItemUpdater::ActivationStatus::ready)
133 {
134 activationState = server::Activation::Activations::Ready;
Gunnar Mills43b25cd2017-09-07 13:19:34 -0500135 // Create an association to the BMC inventory item
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600136 associations.emplace_back(
137 std::make_tuple(ACTIVATION_FWD_ASSOCIATION,
138 ACTIVATION_REV_ASSOCIATION, bmcInventoryPath));
Saqib Khan35e83f32017-05-22 11:37:32 -0500139 }
Gunnar Millsb60add12017-08-24 16:41:42 -0500140
Saqib Khanee13e832017-10-23 12:53:11 -0500141 activations.insert(std::make_pair(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600142 versionId,
143 std::make_unique<Activation>(bus, path, *this, versionId,
144 activationState, associations)));
Michael Tritz4254bec2017-10-03 17:18:22 -0500145
Saqib Khanee13e832017-10-23 12:53:11 -0500146 auto versionPtr = std::make_unique<VersionClass>(
Chanh Nguyen1fd6ddd2021-01-06 11:09:09 +0700147 bus, path, version, purpose, extendedVersion, filePath,
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600148 std::bind(&ItemUpdater::erase, this, std::placeholders::_1));
Saqib Khanee13e832017-10-23 12:53:11 -0500149 versionPtr->deleteObject =
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600150 std::make_unique<phosphor::software::manager::Delete>(bus, path,
151 *versionPtr);
Saqib Khanee13e832017-10-23 12:53:11 -0500152 versions.insert(std::make_pair(versionId, std::move(versionPtr)));
Gunnar Mills2ce7da22017-05-04 15:37:56 -0500153 }
Patrick Williamse75d10f2017-05-30 16:56:32 -0500154 return;
Gunnar Millsec1b41c2017-05-02 12:20:36 -0500155}
156
Saqib Khanba239882017-05-26 08:41:54 -0500157void ItemUpdater::processBMCImage()
158{
Gunnar Mills88e8a322017-09-13 11:09:28 -0500159 using VersionClass = phosphor::software::manager::Version;
Lei YU269bff32018-08-21 15:21:40 +0800160
161 // Check MEDIA_DIR and create if it does not exist
162 try
163 {
164 if (!fs::is_directory(MEDIA_DIR))
165 {
166 fs::create_directory(MEDIA_DIR);
167 }
168 }
169 catch (const fs::filesystem_error& e)
170 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500171 error("Failed to prepare dir: {ERROR}", "ERROR", e);
Lei YU269bff32018-08-21 15:21:40 +0800172 return;
173 }
174
Gunnar Mills88e8a322017-09-13 11:09:28 -0500175 // Read os-release from /etc/ to get the functional BMC version
176 auto functionalVersion = VersionClass::getBMCVersion(OS_RELEASE_FILE);
177
Saqib Khan1eef62d2017-08-10 15:29:34 -0500178 // Read os-release from folders under /media/ to get
179 // BMC Software Versions.
Gunnar Millsd16bcbd2017-10-08 16:50:42 -0500180 for (const auto& iter : fs::directory_iterator(MEDIA_DIR))
Saqib Khan1eef62d2017-08-10 15:29:34 -0500181 {
182 auto activationState = server::Activation::Activations::Active;
Saqib Khan6fab70d2017-09-07 00:13:50 -0500183 static const auto BMC_RO_PREFIX_LEN = strlen(BMC_ROFS_PREFIX);
Saqib Khan1eef62d2017-08-10 15:29:34 -0500184
185 // Check if the BMC_RO_PREFIXis the prefix of the iter.path
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600186 if (0 ==
187 iter.path().native().compare(0, BMC_RO_PREFIX_LEN, BMC_ROFS_PREFIX))
Saqib Khan1eef62d2017-08-10 15:29:34 -0500188 {
Adriana Kobylak716cd782020-06-08 13:27:43 -0500189 // Get the version to calculate the id
Adriana Kobylak24a8d832020-06-10 08:29:36 -0500190 fs::path releaseFile(OS_RELEASE_FILE);
191 auto osRelease = iter.path() / releaseFile.relative_path();
Saqib Khan1eef62d2017-08-10 15:29:34 -0500192 if (!fs::is_regular_file(osRelease))
193 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500194 error("Failed to read osRelease: {PATH}", "PATH", osRelease);
Adriana Kobylak716cd782020-06-08 13:27:43 -0500195
196 // Try to get the version id from the mount directory name and
197 // call to delete it as this version may be corrupted. Dynamic
198 // volumes created by the UBI layout for example have the id in
199 // the mount directory name. The worst that can happen is that
200 // erase() is called with an non-existent id and returns.
201 auto id = iter.path().native().substr(BMC_RO_PREFIX_LEN);
Saqib Khan021c3652017-09-26 12:11:02 -0500202 ItemUpdater::erase(id);
Adriana Kobylak716cd782020-06-08 13:27:43 -0500203
Saqib Khan021c3652017-09-26 12:11:02 -0500204 continue;
Saqib Khan1eef62d2017-08-10 15:29:34 -0500205 }
Gunnar Mills88e8a322017-09-13 11:09:28 -0500206 auto version = VersionClass::getBMCVersion(osRelease);
Saqib Khan1eef62d2017-08-10 15:29:34 -0500207 if (version.empty())
208 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500209 error("Failed to read version from osRelease: {PATH}", "PATH",
210 osRelease);
Adriana Kobylak716cd782020-06-08 13:27:43 -0500211
212 // Try to delete the version, same as above if the
213 // OS_RELEASE_FILE does not exist.
214 auto id = iter.path().native().substr(BMC_RO_PREFIX_LEN);
215 ItemUpdater::erase(id);
216
217 continue;
Saqib Khan1eef62d2017-08-10 15:29:34 -0500218 }
Saqib Khan021c3652017-09-26 12:11:02 -0500219
Adriana Kobylak716cd782020-06-08 13:27:43 -0500220 auto id = VersionClass::getId(version);
221
Adriana Kobylakf383d272020-06-16 15:17:22 -0500222 // Check if the id has already been added. This can happen if the
223 // BMC partitions / devices were manually flashed with the same
224 // image.
225 if (versions.find(id) != versions.end())
226 {
227 continue;
228 }
229
Saqib Khan1eef62d2017-08-10 15:29:34 -0500230 auto purpose = server::Version::VersionPurpose::BMC;
Adriana Kobylakec4eec32019-11-13 14:28:35 -0600231 restorePurpose(id, purpose);
232
Chanh Nguyen1fd6ddd2021-01-06 11:09:09 +0700233 // Read os-release from /etc/ to get the BMC extended version
234 std::string extendedVersion =
235 VersionClass::getBMCExtendedVersion(osRelease);
236
Saqib Khan1eef62d2017-08-10 15:29:34 -0500237 auto path = fs::path(SOFTWARE_OBJPATH) / id;
238
Lei YU269bff32018-08-21 15:21:40 +0800239 // Create functional association if this is the functional
240 // version
Gunnar Mills88e8a322017-09-13 11:09:28 -0500241 if (version.compare(functionalVersion) == 0)
242 {
243 createFunctionalAssociation(path);
244 }
245
Gunnar Mills43b25cd2017-09-07 13:19:34 -0500246 AssociationList associations = {};
247
248 if (activationState == server::Activation::Activations::Active)
249 {
250 // Create an association to the BMC inventory item
251 associations.emplace_back(std::make_tuple(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600252 ACTIVATION_FWD_ASSOCIATION, ACTIVATION_REV_ASSOCIATION,
253 bmcInventoryPath));
Gunnar Mills43b25cd2017-09-07 13:19:34 -0500254
255 // Create an active association since this image is active
256 createActiveAssociation(path);
257 }
258
AppaRao Pulibbebec72020-01-28 23:57:41 +0530259 // All updateable firmware components must expose the updateable
260 // association.
261 createUpdateableAssociation(path);
262
Adriana Kobylakee590c72017-09-26 15:16:06 -0500263 // Create Version instance for this version.
264 auto versionPtr = std::make_unique<VersionClass>(
Chanh Nguyen1fd6ddd2021-01-06 11:09:09 +0700265 bus, path, version, purpose, extendedVersion, "",
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600266 std::bind(&ItemUpdater::erase, this, std::placeholders::_1));
Adriana Kobylakee590c72017-09-26 15:16:06 -0500267 auto isVersionFunctional = versionPtr->isFunctional();
Michael Tritz4254bec2017-10-03 17:18:22 -0500268 if (!isVersionFunctional)
269 {
Saqib Khanee13e832017-10-23 12:53:11 -0500270 versionPtr->deleteObject =
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600271 std::make_unique<phosphor::software::manager::Delete>(
272 bus, path, *versionPtr);
Michael Tritz4254bec2017-10-03 17:18:22 -0500273 }
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600274 versions.insert(std::make_pair(id, std::move(versionPtr)));
Michael Tritz4254bec2017-10-03 17:18:22 -0500275
Saqib Khanee13e832017-10-23 12:53:11 -0500276 // Create Activation instance for this version.
277 activations.insert(std::make_pair(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600278 id, std::make_unique<Activation>(
279 bus, path, *this, id, activationState, associations)));
Saqib Khan1eef62d2017-08-10 15:29:34 -0500280
Lei YU269bff32018-08-21 15:21:40 +0800281 // If Active, create RedundancyPriority instance for this
282 // version.
Saqib Khan1eef62d2017-08-10 15:29:34 -0500283 if (activationState == server::Activation::Activations::Active)
284 {
285 uint8_t priority = std::numeric_limits<uint8_t>::max();
Adriana Kobylak687e75e2019-11-07 11:23:25 -0600286 if (!restorePriority(id, priority))
Saqib Khan1eef62d2017-08-10 15:29:34 -0500287 {
Adriana Kobylakee590c72017-09-26 15:16:06 -0500288 if (isVersionFunctional)
289 {
290 priority = 0;
291 }
292 else
293 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500294 error(
295 "Unable to restore priority from file for {VERSIONID}",
296 "VERSIONID", id);
Adriana Kobylakee590c72017-09-26 15:16:06 -0500297 }
Saqib Khan1eef62d2017-08-10 15:29:34 -0500298 }
299 activations.find(id)->second->redundancyPriority =
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600300 std::make_unique<RedundancyPriority>(
301 bus, path, *(activations.find(id)->second), priority,
302 false);
Saqib Khan1eef62d2017-08-10 15:29:34 -0500303 }
Saqib Khan1eef62d2017-08-10 15:29:34 -0500304 }
305 }
Saqib Khandcbfa042017-09-18 13:08:39 -0500306
Adriana Kobylak716cd782020-06-08 13:27:43 -0500307 // If there are no bmc versions mounted under MEDIA_DIR, then read the
308 // /etc/os-release and create rofs-<versionId> under MEDIA_DIR, then call
309 // again processBMCImage() to create the D-Bus interface for it.
Saqib Khandcbfa042017-09-18 13:08:39 -0500310 if (activations.size() == 0)
311 {
Gunnar Millsd16bcbd2017-10-08 16:50:42 -0500312 auto version = VersionClass::getBMCVersion(OS_RELEASE_FILE);
Saqib Khandcbfa042017-09-18 13:08:39 -0500313 auto id = phosphor::software::manager::Version::getId(version);
314 auto versionFileDir = BMC_ROFS_PREFIX + id + "/etc/";
315 try
316 {
Gunnar Millsd16bcbd2017-10-08 16:50:42 -0500317 if (!fs::is_directory(versionFileDir))
Saqib Khandcbfa042017-09-18 13:08:39 -0500318 {
319 fs::create_directories(versionFileDir);
320 }
321 auto versionFilePath = BMC_ROFS_PREFIX + id + OS_RELEASE_FILE;
322 fs::create_directory_symlink(OS_RELEASE_FILE, versionFilePath);
323 ItemUpdater::processBMCImage();
324 }
325 catch (const std::exception& e)
326 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500327 error("Exception during processing: {ERROR}", "ERROR", e);
Saqib Khandcbfa042017-09-18 13:08:39 -0500328 }
329 }
Eddie Jameseaa1ee02018-03-01 10:09:10 -0600330
331 mirrorUbootToAlt();
Saqib Khanba239882017-05-26 08:41:54 -0500332 return;
333}
334
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500335void ItemUpdater::erase(std::string entryId)
336{
Eddie James6d873712017-09-01 11:29:07 -0500337 // Find entry in versions map
338 auto it = versions.find(entryId);
339 if (it != versions.end())
340 {
Lei YU0f88b5a2018-08-21 15:28:53 +0800341 if (it->second->isFunctional() && ACTIVE_BMC_MAX_ALLOWED > 1)
Eddie James6d873712017-09-01 11:29:07 -0500342 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500343 error(
344 "Version ({VERSIONID}) is currently running on the BMC; unable to remove.",
345 "VERSIONID", entryId);
Gunnar Millsd16bcbd2017-10-08 16:50:42 -0500346 return;
Eddie James6d873712017-09-01 11:29:07 -0500347 }
Adriana Kobylakd1a55ad2020-06-11 14:01:28 -0500348 }
Eddie James6d873712017-09-01 11:29:07 -0500349
Adriana Kobylakd1a55ad2020-06-11 14:01:28 -0500350 // First call resetUbootEnvVars() so that the BMC points to a valid image to
351 // boot from. If resetUbootEnvVars() is called after the image is actually
352 // deleted from the BMC flash, there'd be a time window where the BMC would
353 // be pointing to a non-existent image to boot from.
354 // Need to remove the entries from the activations map before that call so
355 // that resetUbootEnvVars() doesn't use the version to be deleted.
356 auto iteratorActivations = activations.find(entryId);
357 if (iteratorActivations == activations.end())
358 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500359 error(
360 "Failed to find version ({VERSIONID}) in item updater activations map; unable to remove.",
361 "VERSIONID", entryId);
Adriana Kobylakd1a55ad2020-06-11 14:01:28 -0500362 }
363 else
364 {
365 removeAssociations(iteratorActivations->second->path);
Zami Seckae06d762021-08-13 20:11:15 -0500366 iteratorActivations->second->deleteImageManagerObject();
Adriana Kobylakd1a55ad2020-06-11 14:01:28 -0500367 this->activations.erase(entryId);
368 }
369 ItemUpdater::resetUbootEnvVars();
370
371 if (it != versions.end())
372 {
Eddie James6d873712017-09-01 11:29:07 -0500373 // Delete ReadOnly partitions if it's not active
374 removeReadOnlyPartition(entryId);
Adriana Kobylak687e75e2019-11-07 11:23:25 -0600375 removePersistDataDirectory(entryId);
Saqib Khanee13e832017-10-23 12:53:11 -0500376
377 // Removing entry in versions map
378 this->versions.erase(entryId);
Eddie James6d873712017-09-01 11:29:07 -0500379 }
380 else
381 {
382 // Delete ReadOnly partitions even if we can't find the version
383 removeReadOnlyPartition(entryId);
Adriana Kobylak687e75e2019-11-07 11:23:25 -0600384 removePersistDataDirectory(entryId);
Eddie James6d873712017-09-01 11:29:07 -0500385
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500386 error(
387 "Failed to find version ({VERSIONID}) in item updater versions map; unable to remove.",
388 "VERSIONID", entryId);
Eddie James6d873712017-09-01 11:29:07 -0500389 }
Saqib Khan1eef62d2017-08-10 15:29:34 -0500390
Lei YU56aaf452018-06-21 16:09:44 +0800391 helper.clearEntry(entryId);
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500392
Saqib Khanee13e832017-10-23 12:53:11 -0500393 return;
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500394}
395
Michael Tritzbc1bf3a2017-09-18 16:38:23 -0500396void ItemUpdater::deleteAll()
397{
Adriana Kobylak83cd21f2018-02-28 15:48:48 -0600398 std::vector<std::string> deletableVersions;
399
Michael Tritzbc1bf3a2017-09-18 16:38:23 -0500400 for (const auto& versionIt : versions)
401 {
402 if (!versionIt.second->isFunctional())
403 {
Adriana Kobylak83cd21f2018-02-28 15:48:48 -0600404 deletableVersions.push_back(versionIt.first);
Michael Tritzbc1bf3a2017-09-18 16:38:23 -0500405 }
406 }
407
Adriana Kobylak83cd21f2018-02-28 15:48:48 -0600408 for (const auto& deletableIt : deletableVersions)
409 {
410 ItemUpdater::erase(deletableIt);
411 }
412
Lei YU56aaf452018-06-21 16:09:44 +0800413 helper.cleanup();
Michael Tritzbc1bf3a2017-09-18 16:38:23 -0500414}
415
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600416ItemUpdater::ActivationStatus
417 ItemUpdater::validateSquashFSImage(const std::string& filePath)
Saqib Khan35e83f32017-05-22 11:37:32 -0500418{
Bright Cheng8e9ccfe2019-11-18 16:18:44 +0800419 bool valid = true;
Saqib Khan35e83f32017-05-22 11:37:32 -0500420
Bright Cheng8e9ccfe2019-11-18 16:18:44 +0800421 // Record the images which are being updated
422 // First check for the fullimage, then check for images with partitions
423 imageUpdateList.push_back(bmcFullImages);
424 valid = checkImage(filePath, imageUpdateList);
425 if (!valid)
Saqib Khan35e83f32017-05-22 11:37:32 -0500426 {
Bright Cheng8e9ccfe2019-11-18 16:18:44 +0800427 imageUpdateList.clear();
428 imageUpdateList.assign(bmcImages.begin(), bmcImages.end());
429 valid = checkImage(filePath, imageUpdateList);
430 if (!valid)
Michael Tritzb1cfdf92017-08-14 14:33:30 -0500431 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500432 error("Failed to find the needed BMC images.");
Bright Cheng8e9ccfe2019-11-18 16:18:44 +0800433 return ItemUpdater::ActivationStatus::invalid;
Michael Tritzb1cfdf92017-08-14 14:33:30 -0500434 }
Saqib Khan35e83f32017-05-22 11:37:32 -0500435 }
Michael Tritzb1cfdf92017-08-14 14:33:30 -0500436
Michael Tritzb1cfdf92017-08-14 14:33:30 -0500437 return ItemUpdater::ActivationStatus::ready;
Saqib Khan35e83f32017-05-22 11:37:32 -0500438}
439
Adriana Kobylakbbcb7be2018-07-17 15:47:34 -0500440void ItemUpdater::savePriority(const std::string& versionId, uint8_t value)
441{
Adriana Kobylak687e75e2019-11-07 11:23:25 -0600442 storePriority(versionId, value);
Adriana Kobylakbbcb7be2018-07-17 15:47:34 -0500443 helper.setEntry(versionId, value);
444}
445
Saqib Khanb9da6632017-09-13 09:48:37 -0500446void ItemUpdater::freePriority(uint8_t value, const std::string& versionId)
Saqib Khan4c1aec02017-07-06 11:46:13 -0500447{
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500448 std::map<std::string, uint8_t> priorityMap;
449
450 // Insert the requested version and priority, it may not exist yet.
451 priorityMap.insert(std::make_pair(versionId, value));
452
Saqib Khan4c1aec02017-07-06 11:46:13 -0500453 for (const auto& intf : activations)
454 {
Gunnar Mills9a782242017-08-22 16:23:15 -0500455 if (intf.second->redundancyPriority)
Saqib Khan4c1aec02017-07-06 11:46:13 -0500456 {
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500457 priorityMap.insert(std::make_pair(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600458 intf.first, intf.second->redundancyPriority.get()->priority()));
Saqib Khan4c1aec02017-07-06 11:46:13 -0500459 }
460 }
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500461
462 // Lambda function to compare 2 priority values, use <= to allow duplicates
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600463 typedef std::function<bool(std::pair<std::string, uint8_t>,
464 std::pair<std::string, uint8_t>)>
465 cmpPriority;
466 cmpPriority cmpPriorityFunc =
467 [](std::pair<std::string, uint8_t> priority1,
468 std::pair<std::string, uint8_t> priority2) {
469 return priority1.second <= priority2.second;
470 };
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500471
472 // Sort versions by ascending priority
473 std::set<std::pair<std::string, uint8_t>, cmpPriority> prioritySet(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600474 priorityMap.begin(), priorityMap.end(), cmpPriorityFunc);
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500475
476 auto freePriorityValue = value;
477 for (auto& element : prioritySet)
478 {
479 if (element.first == versionId)
480 {
481 continue;
482 }
483 if (element.second == freePriorityValue)
484 {
485 ++freePriorityValue;
486 auto it = activations.find(element.first);
487 it->second->redundancyPriority.get()->sdbusPriority(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600488 freePriorityValue);
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500489 }
490 }
491
492 auto lowestVersion = prioritySet.begin()->first;
493 if (value == prioritySet.begin()->second)
494 {
495 lowestVersion = versionId;
496 }
497 updateUbootEnvVars(lowestVersion);
Saqib Khan4c1aec02017-07-06 11:46:13 -0500498}
499
Michael Tritz37a59042017-07-12 13:44:53 -0500500void ItemUpdater::reset()
501{
Lei YU56aaf452018-06-21 16:09:44 +0800502 helper.factoryReset();
Michael Tritz37a59042017-07-12 13:44:53 -0500503
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500504 info("BMC factory reset will take effect upon reboot.");
Michael Tritz37a59042017-07-12 13:44:53 -0500505}
506
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500507void ItemUpdater::removeReadOnlyPartition(std::string versionId)
508{
Lei YU56aaf452018-06-21 16:09:44 +0800509 helper.removeVersion(versionId);
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500510}
511
Michael Tritz0129d922017-08-10 19:33:46 -0500512bool ItemUpdater::fieldModeEnabled(bool value)
513{
514 // enabling field mode is intended to be one way: false -> true
515 if (value && !control::FieldMode::fieldModeEnabled())
516 {
517 control::FieldMode::fieldModeEnabled(value);
518
Adriana Kobylak22848ec2019-10-28 10:08:39 -0500519 auto method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
520 SYSTEMD_INTERFACE, "StartUnit");
521 method.append("obmc-flash-bmc-setenv@fieldmode\\x3dtrue.service",
522 "replace");
523 bus.call_noreply(method);
524
525 method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
526 SYSTEMD_INTERFACE, "StopUnit");
527 method.append("usr-local.mount", "replace");
528 bus.call_noreply(method);
529
530 std::vector<std::string> usrLocal = {"usr-local.mount"};
531
532 method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
533 SYSTEMD_INTERFACE, "MaskUnitFiles");
534 method.append(usrLocal, false, true);
535 bus.call_noreply(method);
Michael Tritz0129d922017-08-10 19:33:46 -0500536 }
Adriana Kobylakd5b8f752019-05-01 11:52:35 -0500537 else if (!value && control::FieldMode::fieldModeEnabled())
538 {
539 elog<NotAllowed>(xyz::openbmc_project::Common::NotAllowed::REASON(
540 "FieldMode is not allowed to be cleared"));
541 }
Michael Tritz0129d922017-08-10 19:33:46 -0500542
543 return control::FieldMode::fieldModeEnabled();
544}
545
546void ItemUpdater::restoreFieldModeStatus()
547{
Michael Tritzff0b4212017-10-24 17:38:09 -0500548 std::ifstream input("/dev/mtd/u-boot-env");
Michael Tritz0129d922017-08-10 19:33:46 -0500549 std::string envVar;
550 std::getline(input, envVar);
551
Gunnar Mills9a782242017-08-22 16:23:15 -0500552 if (envVar.find("fieldmode=true") != std::string::npos)
Michael Tritz0129d922017-08-10 19:33:46 -0500553 {
554 ItemUpdater::fieldModeEnabled(true);
555 }
556}
557
Gunnar Millsb60add12017-08-24 16:41:42 -0500558void ItemUpdater::setBMCInventoryPath()
559{
Gunnar Millsb60add12017-08-24 16:41:42 -0500560 auto depth = 0;
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600561 auto mapperCall = bus.new_method_call(MAPPER_BUSNAME, MAPPER_PATH,
562 MAPPER_INTERFACE, "GetSubTreePaths");
Gunnar Millsb60add12017-08-24 16:41:42 -0500563
Adriana Kobylak1254c622017-12-07 12:24:56 -0600564 mapperCall.append(INVENTORY_PATH);
Gunnar Millsb60add12017-08-24 16:41:42 -0500565 mapperCall.append(depth);
Adriana Kobylak1254c622017-12-07 12:24:56 -0600566 std::vector<std::string> filter = {BMC_INVENTORY_INTERFACE};
Gunnar Millsb60add12017-08-24 16:41:42 -0500567 mapperCall.append(filter);
568
Ed Tanous87c78172018-08-10 12:51:53 -0700569 try
570 {
571 auto response = bus.call(mapperCall);
572
573 using ObjectPaths = std::vector<std::string>;
574 ObjectPaths result;
575 response.read(result);
576
577 if (!result.empty())
578 {
579 bmcInventoryPath = result.front();
580 }
581 }
Patrick Williams4ce901c2021-09-02 09:34:45 -0500582 catch (const sdbusplus::exception::exception& e)
Gunnar Millsb60add12017-08-24 16:41:42 -0500583 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500584 error("Error in mapper GetSubTreePath: {ERROR}", "ERROR", e);
Gunnar Millsb60add12017-08-24 16:41:42 -0500585 return;
586 }
587
Adriana Kobylak1254c622017-12-07 12:24:56 -0600588 return;
Gunnar Millsb60add12017-08-24 16:41:42 -0500589}
590
Gunnar Millsf10b2322017-09-21 15:31:55 -0500591void ItemUpdater::createActiveAssociation(const std::string& path)
Gunnar Millsded875d2017-08-28 16:44:52 -0500592{
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600593 assocs.emplace_back(
594 std::make_tuple(ACTIVE_FWD_ASSOCIATION, ACTIVE_REV_ASSOCIATION, path));
Gunnar Millsded875d2017-08-28 16:44:52 -0500595 associations(assocs);
596}
597
Gunnar Mills88e8a322017-09-13 11:09:28 -0500598void ItemUpdater::createFunctionalAssociation(const std::string& path)
599{
600 assocs.emplace_back(std::make_tuple(FUNCTIONAL_FWD_ASSOCIATION,
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600601 FUNCTIONAL_REV_ASSOCIATION, path));
Gunnar Mills88e8a322017-09-13 11:09:28 -0500602 associations(assocs);
603}
604
AppaRao Pulibbebec72020-01-28 23:57:41 +0530605void ItemUpdater::createUpdateableAssociation(const std::string& path)
606{
607 assocs.emplace_back(std::make_tuple(UPDATEABLE_FWD_ASSOCIATION,
608 UPDATEABLE_REV_ASSOCIATION, path));
609 associations(assocs);
610}
611
Adriana Kobylak991af7e2018-12-10 13:08:38 -0600612void ItemUpdater::removeAssociations(const std::string& path)
Gunnar Millsded875d2017-08-28 16:44:52 -0500613{
614 for (auto iter = assocs.begin(); iter != assocs.end();)
615 {
Adriana Kobylak991af7e2018-12-10 13:08:38 -0600616 if ((std::get<2>(*iter)).compare(path) == 0)
Gunnar Millsded875d2017-08-28 16:44:52 -0500617 {
618 iter = assocs.erase(iter);
619 associations(assocs);
620 }
621 else
622 {
623 ++iter;
624 }
625 }
626}
627
Saqib Khanb9da6632017-09-13 09:48:37 -0500628bool ItemUpdater::isLowestPriority(uint8_t value)
629{
630 for (const auto& intf : activations)
631 {
Gunnar Millsd16bcbd2017-10-08 16:50:42 -0500632 if (intf.second->redundancyPriority)
Saqib Khanb9da6632017-09-13 09:48:37 -0500633 {
634 if (intf.second->redundancyPriority.get()->priority() < value)
635 {
636 return false;
637 }
638 }
639 }
640 return true;
641}
642
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500643void ItemUpdater::updateUbootEnvVars(const std::string& versionId)
644{
Lei YU56aaf452018-06-21 16:09:44 +0800645 helper.updateUbootVersionId(versionId);
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500646}
647
Saqib Khan49446ae2017-10-02 10:54:20 -0500648void ItemUpdater::resetUbootEnvVars()
649{
650 decltype(activations.begin()->second->redundancyPriority.get()->priority())
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600651 lowestPriority = std::numeric_limits<uint8_t>::max();
Saqib Khan49446ae2017-10-02 10:54:20 -0500652 decltype(activations.begin()->second->versionId) lowestPriorityVersion;
653 for (const auto& intf : activations)
654 {
655 if (!intf.second->redundancyPriority.get())
656 {
657 // Skip this version if the redundancyPriority is not initialized.
658 continue;
659 }
660
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600661 if (intf.second->redundancyPriority.get()->priority() <= lowestPriority)
Saqib Khan49446ae2017-10-02 10:54:20 -0500662 {
663 lowestPriority = intf.second->redundancyPriority.get()->priority();
664 lowestPriorityVersion = intf.second->versionId;
665 }
666 }
667
Saqib Khanf0382c32017-10-24 13:36:22 -0500668 // Update the U-boot environment variable to point to the lowest priority
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500669 updateUbootEnvVars(lowestPriorityVersion);
Saqib Khan49446ae2017-10-02 10:54:20 -0500670}
671
Lei YU0cd6d842021-12-27 11:56:02 +0800672void ItemUpdater::freeSpace(const Activation& caller)
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600673{
674 // Versions with the highest priority in front
675 std::priority_queue<std::pair<int, std::string>,
676 std::vector<std::pair<int, std::string>>,
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600677 std::less<std::pair<int, std::string>>>
678 versionsPQ;
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600679
680 std::size_t count = 0;
681 for (const auto& iter : activations)
682 {
683 if ((iter.second.get()->activation() ==
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600684 server::Activation::Activations::Active) ||
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600685 (iter.second.get()->activation() ==
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600686 server::Activation::Activations::Failed))
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600687 {
688 count++;
689 // Don't put the functional version on the queue since we can't
690 // remove the "running" BMC version.
Lei YU0f88b5a2018-08-21 15:28:53 +0800691 // If ACTIVE_BMC_MAX_ALLOWED <= 1, there is only one active BMC,
692 // so remove functional version as well.
Adriana Kobylaka6963592018-09-07 14:13:29 -0500693 // Don't delete the the Activation object that called this function.
694 if ((versions.find(iter.second->versionId)
695 ->second->isFunctional() &&
696 ACTIVE_BMC_MAX_ALLOWED > 1) ||
697 (iter.second->versionId == caller.versionId))
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600698 {
699 continue;
700 }
Adriana Kobylaka6963592018-09-07 14:13:29 -0500701
702 // Failed activations don't have priority, assign them a large value
703 // for sorting purposes.
704 auto priority = 999;
705 if (iter.second.get()->activation() ==
Lei YUcfb4b202021-05-06 17:47:28 +0800706 server::Activation::Activations::Active &&
707 iter.second->redundancyPriority)
Adriana Kobylaka6963592018-09-07 14:13:29 -0500708 {
709 priority = iter.second->redundancyPriority.get()->priority();
710 }
711
712 versionsPQ.push(std::make_pair(priority, iter.second->versionId));
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600713 }
714 }
715
716 // If the number of BMC versions is over ACTIVE_BMC_MAX_ALLOWED -1,
717 // remove the highest priority one(s).
718 while ((count >= ACTIVE_BMC_MAX_ALLOWED) && (!versionsPQ.empty()))
719 {
720 erase(versionsPQ.top().second);
721 versionsPQ.pop();
722 count--;
723 }
724}
725
Eddie Jameseaa1ee02018-03-01 10:09:10 -0600726void ItemUpdater::mirrorUbootToAlt()
727{
Lei YU56aaf452018-06-21 16:09:44 +0800728 helper.mirrorAlt();
Eddie Jameseaa1ee02018-03-01 10:09:10 -0600729}
730
Bright Cheng8e9ccfe2019-11-18 16:18:44 +0800731bool ItemUpdater::checkImage(const std::string& filePath,
732 const std::vector<std::string>& imageList)
733{
734 bool valid = true;
735
736 for (auto& bmcImage : imageList)
737 {
738 fs::path file(filePath);
739 file /= bmcImage;
740 std::ifstream efile(file.c_str());
741 if (efile.good() != 1)
742 {
743 valid = false;
744 break;
745 }
746 }
747
748 return valid;
749}
750
Lei YU6e9fb1d2021-02-19 18:01:40 +0800751#ifdef HOST_BIOS_UPGRADE
752void ItemUpdater::createBIOSObject()
753{
754 std::string path = BIOS_OBJPATH;
755 // Get version id from last item in the path
756 auto pos = path.rfind("/");
757 if (pos == std::string::npos)
758 {
Patrick Williamsc9bb6422021-08-27 06:18:35 -0500759 error("No version id found in object path {PATH}", "PATH", path);
Lei YU6e9fb1d2021-02-19 18:01:40 +0800760 return;
761 }
762
763 createActiveAssociation(path);
764 createFunctionalAssociation(path);
765
766 auto versionId = path.substr(pos + 1);
767 auto version = "null";
768 AssociationList assocs = {};
769 biosActivation = std::make_unique<Activation>(
770 bus, path, *this, versionId, server::Activation::Activations::Active,
771 assocs);
772 auto dummyErase = [](std::string /*entryId*/) {
773 // Do nothing;
774 };
775 biosVersion = std::make_unique<VersionClass>(
776 bus, path, version, VersionPurpose::Host, "", "",
777 std::bind(dummyErase, std::placeholders::_1));
778 biosVersion->deleteObject =
779 std::make_unique<phosphor::software::manager::Delete>(bus, path,
780 *biosVersion);
781}
782#endif
783
Gunnar Millsec1b41c2017-05-02 12:20:36 -0500784} // namespace updater
785} // namespace software
786} // namespace phosphor