blob: 4e2ca458f4658266b9998f0121fb2691efd869af [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"
8#include "xyz/openbmc_project/Software/Version/server.hpp"
9
Gunnar Millsb0ce9962018-09-07 13:39:10 -050010#include <experimental/filesystem>
Saqib Khan35e83f32017-05-22 11:37:32 -050011#include <fstream>
Adriana Kobylakd5b8f752019-05-01 11:52:35 -050012#include <phosphor-logging/elog-errors.hpp>
Gunnar Millsb0ce9962018-09-07 13:39:10 -050013#include <phosphor-logging/elog.hpp>
14#include <phosphor-logging/log.hpp>
Adriana Kobylak204e1e72018-01-24 16:00:05 -060015#include <queue>
Adriana Kobylakb77551c2017-10-27 12:46:23 -050016#include <set>
Gunnar Millsec1b41c2017-05-02 12:20:36 -050017#include <string>
Adriana Kobylakd5b8f752019-05-01 11:52:35 -050018#include <xyz/openbmc_project/Common/error.hpp>
Adriana Kobylak43699ca2018-10-17 14:56:29 -050019#include <xyz/openbmc_project/Software/Image/error.hpp>
Gunnar Millsec1b41c2017-05-02 12:20:36 -050020
21namespace phosphor
22{
23namespace software
24{
25namespace updater
26{
27
Gunnar Mills2ce7da22017-05-04 15:37:56 -050028// When you see server:: you know we're referencing our base class
29namespace server = sdbusplus::xyz::openbmc_project::Software::server;
Michael Tritz0129d922017-08-10 19:33:46 -050030namespace control = sdbusplus::xyz::openbmc_project::Control::server;
Gunnar Mills2ce7da22017-05-04 15:37:56 -050031
32using namespace phosphor::logging;
Adriana Kobylak43699ca2018-10-17 14:56:29 -050033using namespace sdbusplus::xyz::openbmc_project::Software::Image::Error;
Jayanth Othayoth2ab9b102018-02-21 05:27:47 -060034using namespace phosphor::software::image;
Saqib Khan35e83f32017-05-22 11:37:32 -050035namespace fs = std::experimental::filesystem;
Adriana Kobylakd5b8f752019-05-01 11:52:35 -050036using NotAllowed = sdbusplus::xyz::openbmc_project::Common::Error::NotAllowed;
Saqib Khan35e83f32017-05-22 11:37:32 -050037
Patrick Williamse75d10f2017-05-30 16:56:32 -050038void ItemUpdater::createActivation(sdbusplus::message::message& msg)
Gunnar Millsec1b41c2017-05-02 12:20:36 -050039{
Saqib Khan84a0e692017-06-28 17:27:01 -050040
41 using SVersion = server::Version;
42 using VersionPurpose = SVersion::VersionPurpose;
Gunnar Mills9a782242017-08-22 16:23:15 -050043 using VersionClass = phosphor::software::manager::Version;
Saqib Khan84a0e692017-06-28 17:27:01 -050044 namespace mesg = sdbusplus::message;
Saqib Khan84a0e692017-06-28 17:27:01 -050045
46 mesg::object_path objPath;
47 auto purpose = VersionPurpose::Unknown;
Saqib Khan705f1bf2017-06-09 23:58:38 -050048 std::string version;
Adriana Kobylak2285fe02018-02-27 15:36:59 -060049 std::map<std::string, std::map<std::string, mesg::variant<std::string>>>
50 interfaces;
Patrick Williamse75d10f2017-05-30 16:56:32 -050051 msg.read(objPath, interfaces);
Gunnar Mills2ce7da22017-05-04 15:37:56 -050052 std::string path(std::move(objPath));
Saqib Khan19177d32017-06-20 08:11:49 -050053 std::string filePath;
Gunnar Mills2ce7da22017-05-04 15:37:56 -050054
55 for (const auto& intf : interfaces)
56 {
Saqib Khan705f1bf2017-06-09 23:58:38 -050057 if (intf.first == VERSION_IFACE)
Gunnar Mills2ce7da22017-05-04 15:37:56 -050058 {
Saqib Khan705f1bf2017-06-09 23:58:38 -050059 for (const auto& property : intf.second)
Gunnar Mills2ce7da22017-05-04 15:37:56 -050060 {
Saqib Khan705f1bf2017-06-09 23:58:38 -050061 if (property.first == "Purpose")
Gunnar Mills2ce7da22017-05-04 15:37:56 -050062 {
Saqib Khan84a0e692017-06-28 17:27:01 -050063 auto value = SVersion::convertVersionPurposeFromString(
Patrick Williamse883fb82020-05-13 11:38:55 -050064 std::get<std::string>(property.second));
Saqib Khan84a0e692017-06-28 17:27:01 -050065 if (value == VersionPurpose::BMC ||
Vijay Khemkae9f6c842020-01-14 14:32:39 -080066#ifdef HOST_BIOS_UPGRADE
67 value == VersionPurpose::Host ||
68#endif
Saqib Khan84a0e692017-06-28 17:27:01 -050069 value == VersionPurpose::System)
70 {
71 purpose = value;
72 }
Saqib Khan705f1bf2017-06-09 23:58:38 -050073 }
74 else if (property.first == "Version")
75 {
Patrick Williamse883fb82020-05-13 11:38:55 -050076 version = std::get<std::string>(property.second);
Gunnar Mills2ce7da22017-05-04 15:37:56 -050077 }
78 }
79 }
Saqib Khan19177d32017-06-20 08:11:49 -050080 else if (intf.first == FILEPATH_IFACE)
81 {
82 for (const auto& property : intf.second)
83 {
84 if (property.first == "Path")
85 {
Patrick Williamse883fb82020-05-13 11:38:55 -050086 filePath = std::get<std::string>(property.second);
Saqib Khan19177d32017-06-20 08:11:49 -050087 }
88 }
89 }
Gunnar Mills2ce7da22017-05-04 15:37:56 -050090 }
Adriana Kobylak2285fe02018-02-27 15:36:59 -060091 if (version.empty() || filePath.empty() ||
Saqib Khan84a0e692017-06-28 17:27:01 -050092 purpose == VersionPurpose::Unknown)
Saqib Khan705f1bf2017-06-09 23:58:38 -050093 {
94 return;
95 }
Gunnar Mills2ce7da22017-05-04 15:37:56 -050096
97 // Version id is the last item in the path
98 auto pos = path.rfind("/");
99 if (pos == std::string::npos)
100 {
101 log<level::ERR>("No version id found in object path",
Adriana Kobylak596466b2018-02-13 14:48:53 -0600102 entry("OBJPATH=%s", path.c_str()));
Patrick Williamse75d10f2017-05-30 16:56:32 -0500103 return;
Gunnar Mills2ce7da22017-05-04 15:37:56 -0500104 }
105
106 auto versionId = path.substr(pos + 1);
107
Patrick Williamse75d10f2017-05-30 16:56:32 -0500108 if (activations.find(versionId) == activations.end())
Gunnar Mills2ce7da22017-05-04 15:37:56 -0500109 {
Saqib Khan35e83f32017-05-22 11:37:32 -0500110 // Determine the Activation state by processing the given image dir.
111 auto activationState = server::Activation::Activations::Invalid;
Vijay Khemkae9f6c842020-01-14 14:32:39 -0800112 ItemUpdater::ActivationStatus result;
113 if (purpose == VersionPurpose::BMC || purpose == VersionPurpose::System)
114 result = ItemUpdater::validateSquashFSImage(filePath);
115 else
116 result = ItemUpdater::ActivationStatus::ready;
117
Gunnar Mills43b25cd2017-09-07 13:19:34 -0500118 AssociationList associations = {};
119
Saqib Khan35e83f32017-05-22 11:37:32 -0500120 if (result == ItemUpdater::ActivationStatus::ready)
121 {
122 activationState = server::Activation::Activations::Ready;
Gunnar Mills43b25cd2017-09-07 13:19:34 -0500123 // Create an association to the BMC inventory item
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600124 associations.emplace_back(
125 std::make_tuple(ACTIVATION_FWD_ASSOCIATION,
126 ACTIVATION_REV_ASSOCIATION, bmcInventoryPath));
Saqib Khan35e83f32017-05-22 11:37:32 -0500127 }
Gunnar Millsb60add12017-08-24 16:41:42 -0500128
Saqib Khanee13e832017-10-23 12:53:11 -0500129 activations.insert(std::make_pair(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600130 versionId,
131 std::make_unique<Activation>(bus, path, *this, versionId,
132 activationState, associations)));
Michael Tritz4254bec2017-10-03 17:18:22 -0500133
Saqib Khanee13e832017-10-23 12:53:11 -0500134 auto versionPtr = std::make_unique<VersionClass>(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600135 bus, path, version, purpose, filePath,
136 std::bind(&ItemUpdater::erase, this, std::placeholders::_1));
Saqib Khanee13e832017-10-23 12:53:11 -0500137 versionPtr->deleteObject =
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600138 std::make_unique<phosphor::software::manager::Delete>(bus, path,
139 *versionPtr);
Saqib Khanee13e832017-10-23 12:53:11 -0500140 versions.insert(std::make_pair(versionId, std::move(versionPtr)));
Gunnar Mills2ce7da22017-05-04 15:37:56 -0500141 }
Patrick Williamse75d10f2017-05-30 16:56:32 -0500142 return;
Gunnar Millsec1b41c2017-05-02 12:20:36 -0500143}
144
Saqib Khanba239882017-05-26 08:41:54 -0500145void ItemUpdater::processBMCImage()
146{
Gunnar Mills88e8a322017-09-13 11:09:28 -0500147 using VersionClass = phosphor::software::manager::Version;
Lei YU269bff32018-08-21 15:21:40 +0800148
149 // Check MEDIA_DIR and create if it does not exist
150 try
151 {
152 if (!fs::is_directory(MEDIA_DIR))
153 {
154 fs::create_directory(MEDIA_DIR);
155 }
156 }
157 catch (const fs::filesystem_error& e)
158 {
159 log<level::ERR>("Failed to prepare dir", entry("ERR=%s", e.what()));
160 return;
161 }
162
Gunnar Mills88e8a322017-09-13 11:09:28 -0500163 // Read os-release from /etc/ to get the functional BMC version
164 auto functionalVersion = VersionClass::getBMCVersion(OS_RELEASE_FILE);
165
Saqib Khan1eef62d2017-08-10 15:29:34 -0500166 // Read os-release from folders under /media/ to get
167 // BMC Software Versions.
Gunnar Millsd16bcbd2017-10-08 16:50:42 -0500168 for (const auto& iter : fs::directory_iterator(MEDIA_DIR))
Saqib Khan1eef62d2017-08-10 15:29:34 -0500169 {
170 auto activationState = server::Activation::Activations::Active;
Saqib Khan6fab70d2017-09-07 00:13:50 -0500171 static const auto BMC_RO_PREFIX_LEN = strlen(BMC_ROFS_PREFIX);
Saqib Khan1eef62d2017-08-10 15:29:34 -0500172
173 // Check if the BMC_RO_PREFIXis the prefix of the iter.path
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600174 if (0 ==
175 iter.path().native().compare(0, BMC_RO_PREFIX_LEN, BMC_ROFS_PREFIX))
Saqib Khan1eef62d2017-08-10 15:29:34 -0500176 {
Saqib Khan021c3652017-09-26 12:11:02 -0500177 // The versionId is extracted from the path
178 // for example /media/ro-2a1022fe.
179 auto id = iter.path().native().substr(BMC_RO_PREFIX_LEN);
Saqib Khan1eef62d2017-08-10 15:29:34 -0500180 auto osRelease = iter.path() / OS_RELEASE_FILE;
181 if (!fs::is_regular_file(osRelease))
182 {
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600183 log<level::ERR>(
184 "Failed to read osRelease",
185 entry("FILENAME=%s", osRelease.string().c_str()));
Saqib Khan021c3652017-09-26 12:11:02 -0500186 ItemUpdater::erase(id);
187 continue;
Saqib Khan1eef62d2017-08-10 15:29:34 -0500188 }
Gunnar Mills88e8a322017-09-13 11:09:28 -0500189 auto version = VersionClass::getBMCVersion(osRelease);
Saqib Khan1eef62d2017-08-10 15:29:34 -0500190 if (version.empty())
191 {
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600192 log<level::ERR>(
193 "Failed to read version from osRelease",
194 entry("FILENAME=%s", osRelease.string().c_str()));
Saqib Khan1eef62d2017-08-10 15:29:34 -0500195 activationState = server::Activation::Activations::Invalid;
196 }
Saqib Khan021c3652017-09-26 12:11:02 -0500197
Saqib Khan1eef62d2017-08-10 15:29:34 -0500198 auto purpose = server::Version::VersionPurpose::BMC;
Adriana Kobylakec4eec32019-11-13 14:28:35 -0600199 restorePurpose(id, purpose);
200
Saqib Khan1eef62d2017-08-10 15:29:34 -0500201 auto path = fs::path(SOFTWARE_OBJPATH) / id;
202
Lei YU269bff32018-08-21 15:21:40 +0800203 // Create functional association if this is the functional
204 // version
Gunnar Mills88e8a322017-09-13 11:09:28 -0500205 if (version.compare(functionalVersion) == 0)
206 {
207 createFunctionalAssociation(path);
208 }
209
Gunnar Mills43b25cd2017-09-07 13:19:34 -0500210 AssociationList associations = {};
211
212 if (activationState == server::Activation::Activations::Active)
213 {
214 // Create an association to the BMC inventory item
215 associations.emplace_back(std::make_tuple(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600216 ACTIVATION_FWD_ASSOCIATION, ACTIVATION_REV_ASSOCIATION,
217 bmcInventoryPath));
Gunnar Mills43b25cd2017-09-07 13:19:34 -0500218
219 // Create an active association since this image is active
220 createActiveAssociation(path);
221 }
222
AppaRao Pulibbebec72020-01-28 23:57:41 +0530223 // All updateable firmware components must expose the updateable
224 // association.
225 createUpdateableAssociation(path);
226
Adriana Kobylakee590c72017-09-26 15:16:06 -0500227 // Create Version instance for this version.
228 auto versionPtr = std::make_unique<VersionClass>(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600229 bus, path, version, purpose, "",
230 std::bind(&ItemUpdater::erase, this, std::placeholders::_1));
Adriana Kobylakee590c72017-09-26 15:16:06 -0500231 auto isVersionFunctional = versionPtr->isFunctional();
Michael Tritz4254bec2017-10-03 17:18:22 -0500232 if (!isVersionFunctional)
233 {
Saqib Khanee13e832017-10-23 12:53:11 -0500234 versionPtr->deleteObject =
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600235 std::make_unique<phosphor::software::manager::Delete>(
236 bus, path, *versionPtr);
Michael Tritz4254bec2017-10-03 17:18:22 -0500237 }
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600238 versions.insert(std::make_pair(id, std::move(versionPtr)));
Michael Tritz4254bec2017-10-03 17:18:22 -0500239
Saqib Khanee13e832017-10-23 12:53:11 -0500240 // Create Activation instance for this version.
241 activations.insert(std::make_pair(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600242 id, std::make_unique<Activation>(
243 bus, path, *this, id, activationState, associations)));
Saqib Khan1eef62d2017-08-10 15:29:34 -0500244
Lei YU269bff32018-08-21 15:21:40 +0800245 // If Active, create RedundancyPriority instance for this
246 // version.
Saqib Khan1eef62d2017-08-10 15:29:34 -0500247 if (activationState == server::Activation::Activations::Active)
248 {
249 uint8_t priority = std::numeric_limits<uint8_t>::max();
Adriana Kobylak687e75e2019-11-07 11:23:25 -0600250 if (!restorePriority(id, priority))
Saqib Khan1eef62d2017-08-10 15:29:34 -0500251 {
Adriana Kobylakee590c72017-09-26 15:16:06 -0500252 if (isVersionFunctional)
253 {
254 priority = 0;
255 }
256 else
257 {
258 log<level::ERR>("Unable to restore priority from file.",
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600259 entry("VERSIONID=%s", id.c_str()));
Adriana Kobylakee590c72017-09-26 15:16:06 -0500260 }
Saqib Khan1eef62d2017-08-10 15:29:34 -0500261 }
262 activations.find(id)->second->redundancyPriority =
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600263 std::make_unique<RedundancyPriority>(
264 bus, path, *(activations.find(id)->second), priority,
265 false);
Saqib Khan1eef62d2017-08-10 15:29:34 -0500266 }
Saqib Khan1eef62d2017-08-10 15:29:34 -0500267 }
268 }
Saqib Khandcbfa042017-09-18 13:08:39 -0500269
270 // If there is no ubi volume for bmc version then read the /etc/os-release
271 // and create rofs-<versionId> under /media
272 if (activations.size() == 0)
273 {
Gunnar Millsd16bcbd2017-10-08 16:50:42 -0500274 auto version = VersionClass::getBMCVersion(OS_RELEASE_FILE);
Saqib Khandcbfa042017-09-18 13:08:39 -0500275 auto id = phosphor::software::manager::Version::getId(version);
276 auto versionFileDir = BMC_ROFS_PREFIX + id + "/etc/";
277 try
278 {
Gunnar Millsd16bcbd2017-10-08 16:50:42 -0500279 if (!fs::is_directory(versionFileDir))
Saqib Khandcbfa042017-09-18 13:08:39 -0500280 {
281 fs::create_directories(versionFileDir);
282 }
283 auto versionFilePath = BMC_ROFS_PREFIX + id + OS_RELEASE_FILE;
284 fs::create_directory_symlink(OS_RELEASE_FILE, versionFilePath);
285 ItemUpdater::processBMCImage();
286 }
287 catch (const std::exception& e)
288 {
289 log<level::ERR>(e.what());
290 }
291 }
Eddie Jameseaa1ee02018-03-01 10:09:10 -0600292
293 mirrorUbootToAlt();
Saqib Khanba239882017-05-26 08:41:54 -0500294 return;
295}
296
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500297void ItemUpdater::erase(std::string entryId)
298{
Eddie James6d873712017-09-01 11:29:07 -0500299 // Find entry in versions map
300 auto it = versions.find(entryId);
301 if (it != versions.end())
302 {
Lei YU0f88b5a2018-08-21 15:28:53 +0800303 if (it->second->isFunctional() && ACTIVE_BMC_MAX_ALLOWED > 1)
Eddie James6d873712017-09-01 11:29:07 -0500304 {
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600305 log<level::ERR>("Error: Version is currently running on the BMC. "
306 "Unable to remove.",
307 entry("VERSIONID=%s", entryId.c_str()));
Gunnar Millsd16bcbd2017-10-08 16:50:42 -0500308 return;
Eddie James6d873712017-09-01 11:29:07 -0500309 }
310
311 // Delete ReadOnly partitions if it's not active
312 removeReadOnlyPartition(entryId);
Adriana Kobylak687e75e2019-11-07 11:23:25 -0600313 removePersistDataDirectory(entryId);
Saqib Khanee13e832017-10-23 12:53:11 -0500314
315 // Removing entry in versions map
316 this->versions.erase(entryId);
Eddie James6d873712017-09-01 11:29:07 -0500317 }
318 else
319 {
320 // Delete ReadOnly partitions even if we can't find the version
321 removeReadOnlyPartition(entryId);
Adriana Kobylak687e75e2019-11-07 11:23:25 -0600322 removePersistDataDirectory(entryId);
Eddie James6d873712017-09-01 11:29:07 -0500323
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600324 log<level::ERR>("Error: Failed to find version in item updater "
325 "versions map. Unable to remove.",
326 entry("VERSIONID=%s", entryId.c_str()));
Eddie James6d873712017-09-01 11:29:07 -0500327 }
Saqib Khan1eef62d2017-08-10 15:29:34 -0500328
Lei YU56aaf452018-06-21 16:09:44 +0800329 helper.clearEntry(entryId);
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500330
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500331 // Removing entry in activations map
332 auto ita = activations.find(entryId);
333 if (ita == activations.end())
334 {
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600335 log<level::ERR>("Error: Failed to find version in item updater "
336 "activations map. Unable to remove.",
337 entry("VERSIONID=%s", entryId.c_str()));
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500338 }
Saqib Khanee13e832017-10-23 12:53:11 -0500339 else
340 {
Adriana Kobylak991af7e2018-12-10 13:08:38 -0600341 removeAssociations(ita->second->path);
Saqib Khanee13e832017-10-23 12:53:11 -0500342 this->activations.erase(entryId);
343 }
Saqib Khan49446ae2017-10-02 10:54:20 -0500344 ItemUpdater::resetUbootEnvVars();
Saqib Khanee13e832017-10-23 12:53:11 -0500345 return;
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500346}
347
Michael Tritzbc1bf3a2017-09-18 16:38:23 -0500348void ItemUpdater::deleteAll()
349{
Adriana Kobylak83cd21f2018-02-28 15:48:48 -0600350 std::vector<std::string> deletableVersions;
351
Michael Tritzbc1bf3a2017-09-18 16:38:23 -0500352 for (const auto& versionIt : versions)
353 {
354 if (!versionIt.second->isFunctional())
355 {
Adriana Kobylak83cd21f2018-02-28 15:48:48 -0600356 deletableVersions.push_back(versionIt.first);
Michael Tritzbc1bf3a2017-09-18 16:38:23 -0500357 }
358 }
359
Adriana Kobylak83cd21f2018-02-28 15:48:48 -0600360 for (const auto& deletableIt : deletableVersions)
361 {
362 ItemUpdater::erase(deletableIt);
363 }
364
Lei YU56aaf452018-06-21 16:09:44 +0800365 helper.cleanup();
Michael Tritzbc1bf3a2017-09-18 16:38:23 -0500366}
367
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600368ItemUpdater::ActivationStatus
369 ItemUpdater::validateSquashFSImage(const std::string& filePath)
Saqib Khan35e83f32017-05-22 11:37:32 -0500370{
Michael Tritzb1cfdf92017-08-14 14:33:30 -0500371 bool invalid = false;
Saqib Khan35e83f32017-05-22 11:37:32 -0500372
Michael Tritzb1cfdf92017-08-14 14:33:30 -0500373 for (auto& bmcImage : bmcImages)
Saqib Khan35e83f32017-05-22 11:37:32 -0500374 {
Michael Tritzb1cfdf92017-08-14 14:33:30 -0500375 fs::path file(filePath);
376 file /= bmcImage;
377 std::ifstream efile(file.c_str());
378 if (efile.good() != 1)
379 {
380 log<level::ERR>("Failed to find the BMC image.",
Gunnar Mills9a782242017-08-22 16:23:15 -0500381 entry("IMAGE=%s", bmcImage.c_str()));
Michael Tritzb1cfdf92017-08-14 14:33:30 -0500382 invalid = true;
383 }
Saqib Khan35e83f32017-05-22 11:37:32 -0500384 }
Michael Tritzb1cfdf92017-08-14 14:33:30 -0500385
386 if (invalid)
Saqib Khan35e83f32017-05-22 11:37:32 -0500387 {
Saqib Khan35e83f32017-05-22 11:37:32 -0500388 return ItemUpdater::ActivationStatus::invalid;
389 }
Michael Tritzb1cfdf92017-08-14 14:33:30 -0500390
391 return ItemUpdater::ActivationStatus::ready;
Saqib Khan35e83f32017-05-22 11:37:32 -0500392}
393
Adriana Kobylakbbcb7be2018-07-17 15:47:34 -0500394void ItemUpdater::savePriority(const std::string& versionId, uint8_t value)
395{
Adriana Kobylak687e75e2019-11-07 11:23:25 -0600396 storePriority(versionId, value);
Adriana Kobylakbbcb7be2018-07-17 15:47:34 -0500397 helper.setEntry(versionId, value);
398}
399
Saqib Khanb9da6632017-09-13 09:48:37 -0500400void ItemUpdater::freePriority(uint8_t value, const std::string& versionId)
Saqib Khan4c1aec02017-07-06 11:46:13 -0500401{
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500402 std::map<std::string, uint8_t> priorityMap;
403
404 // Insert the requested version and priority, it may not exist yet.
405 priorityMap.insert(std::make_pair(versionId, value));
406
Saqib Khan4c1aec02017-07-06 11:46:13 -0500407 for (const auto& intf : activations)
408 {
Gunnar Mills9a782242017-08-22 16:23:15 -0500409 if (intf.second->redundancyPriority)
Saqib Khan4c1aec02017-07-06 11:46:13 -0500410 {
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500411 priorityMap.insert(std::make_pair(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600412 intf.first, intf.second->redundancyPriority.get()->priority()));
Saqib Khan4c1aec02017-07-06 11:46:13 -0500413 }
414 }
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500415
416 // Lambda function to compare 2 priority values, use <= to allow duplicates
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600417 typedef std::function<bool(std::pair<std::string, uint8_t>,
418 std::pair<std::string, uint8_t>)>
419 cmpPriority;
420 cmpPriority cmpPriorityFunc =
421 [](std::pair<std::string, uint8_t> priority1,
422 std::pair<std::string, uint8_t> priority2) {
423 return priority1.second <= priority2.second;
424 };
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500425
426 // Sort versions by ascending priority
427 std::set<std::pair<std::string, uint8_t>, cmpPriority> prioritySet(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600428 priorityMap.begin(), priorityMap.end(), cmpPriorityFunc);
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500429
430 auto freePriorityValue = value;
431 for (auto& element : prioritySet)
432 {
433 if (element.first == versionId)
434 {
435 continue;
436 }
437 if (element.second == freePriorityValue)
438 {
439 ++freePriorityValue;
440 auto it = activations.find(element.first);
441 it->second->redundancyPriority.get()->sdbusPriority(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600442 freePriorityValue);
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500443 }
444 }
445
446 auto lowestVersion = prioritySet.begin()->first;
447 if (value == prioritySet.begin()->second)
448 {
449 lowestVersion = versionId;
450 }
451 updateUbootEnvVars(lowestVersion);
Saqib Khan4c1aec02017-07-06 11:46:13 -0500452}
453
Michael Tritz37a59042017-07-12 13:44:53 -0500454void ItemUpdater::reset()
455{
Lei YU56aaf452018-06-21 16:09:44 +0800456 helper.factoryReset();
Michael Tritz37a59042017-07-12 13:44:53 -0500457
458 log<level::INFO>("BMC factory reset will take effect upon reboot.");
Michael Tritz37a59042017-07-12 13:44:53 -0500459}
460
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500461void ItemUpdater::removeReadOnlyPartition(std::string versionId)
462{
Lei YU56aaf452018-06-21 16:09:44 +0800463 helper.removeVersion(versionId);
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500464}
465
Michael Tritz0129d922017-08-10 19:33:46 -0500466bool ItemUpdater::fieldModeEnabled(bool value)
467{
468 // enabling field mode is intended to be one way: false -> true
469 if (value && !control::FieldMode::fieldModeEnabled())
470 {
471 control::FieldMode::fieldModeEnabled(value);
472
Adriana Kobylak22848ec2019-10-28 10:08:39 -0500473 auto method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
474 SYSTEMD_INTERFACE, "StartUnit");
475 method.append("obmc-flash-bmc-setenv@fieldmode\\x3dtrue.service",
476 "replace");
477 bus.call_noreply(method);
478
479 method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
480 SYSTEMD_INTERFACE, "StopUnit");
481 method.append("usr-local.mount", "replace");
482 bus.call_noreply(method);
483
484 std::vector<std::string> usrLocal = {"usr-local.mount"};
485
486 method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
487 SYSTEMD_INTERFACE, "MaskUnitFiles");
488 method.append(usrLocal, false, true);
489 bus.call_noreply(method);
Michael Tritz0129d922017-08-10 19:33:46 -0500490 }
Adriana Kobylakd5b8f752019-05-01 11:52:35 -0500491 else if (!value && control::FieldMode::fieldModeEnabled())
492 {
493 elog<NotAllowed>(xyz::openbmc_project::Common::NotAllowed::REASON(
494 "FieldMode is not allowed to be cleared"));
495 }
Michael Tritz0129d922017-08-10 19:33:46 -0500496
497 return control::FieldMode::fieldModeEnabled();
498}
499
500void ItemUpdater::restoreFieldModeStatus()
501{
Michael Tritzff0b4212017-10-24 17:38:09 -0500502 std::ifstream input("/dev/mtd/u-boot-env");
Michael Tritz0129d922017-08-10 19:33:46 -0500503 std::string envVar;
504 std::getline(input, envVar);
505
Gunnar Mills9a782242017-08-22 16:23:15 -0500506 if (envVar.find("fieldmode=true") != std::string::npos)
Michael Tritz0129d922017-08-10 19:33:46 -0500507 {
508 ItemUpdater::fieldModeEnabled(true);
509 }
510}
511
Gunnar Millsb60add12017-08-24 16:41:42 -0500512void ItemUpdater::setBMCInventoryPath()
513{
Gunnar Millsb60add12017-08-24 16:41:42 -0500514 auto depth = 0;
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600515 auto mapperCall = bus.new_method_call(MAPPER_BUSNAME, MAPPER_PATH,
516 MAPPER_INTERFACE, "GetSubTreePaths");
Gunnar Millsb60add12017-08-24 16:41:42 -0500517
Adriana Kobylak1254c622017-12-07 12:24:56 -0600518 mapperCall.append(INVENTORY_PATH);
Gunnar Millsb60add12017-08-24 16:41:42 -0500519 mapperCall.append(depth);
Adriana Kobylak1254c622017-12-07 12:24:56 -0600520 std::vector<std::string> filter = {BMC_INVENTORY_INTERFACE};
Gunnar Millsb60add12017-08-24 16:41:42 -0500521 mapperCall.append(filter);
522
Ed Tanous87c78172018-08-10 12:51:53 -0700523 try
524 {
525 auto response = bus.call(mapperCall);
526
527 using ObjectPaths = std::vector<std::string>;
528 ObjectPaths result;
529 response.read(result);
530
531 if (!result.empty())
532 {
533 bmcInventoryPath = result.front();
534 }
535 }
536 catch (const sdbusplus::exception::SdBusError& e)
Gunnar Millsb60add12017-08-24 16:41:42 -0500537 {
538 log<level::ERR>("Error in mapper GetSubTreePath");
539 return;
540 }
541
Adriana Kobylak1254c622017-12-07 12:24:56 -0600542 return;
Gunnar Millsb60add12017-08-24 16:41:42 -0500543}
544
Gunnar Millsf10b2322017-09-21 15:31:55 -0500545void ItemUpdater::createActiveAssociation(const std::string& path)
Gunnar Millsded875d2017-08-28 16:44:52 -0500546{
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600547 assocs.emplace_back(
548 std::make_tuple(ACTIVE_FWD_ASSOCIATION, ACTIVE_REV_ASSOCIATION, path));
Gunnar Millsded875d2017-08-28 16:44:52 -0500549 associations(assocs);
550}
551
Gunnar Mills88e8a322017-09-13 11:09:28 -0500552void ItemUpdater::createFunctionalAssociation(const std::string& path)
553{
554 assocs.emplace_back(std::make_tuple(FUNCTIONAL_FWD_ASSOCIATION,
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600555 FUNCTIONAL_REV_ASSOCIATION, path));
Gunnar Mills88e8a322017-09-13 11:09:28 -0500556 associations(assocs);
557}
558
AppaRao Pulibbebec72020-01-28 23:57:41 +0530559void ItemUpdater::createUpdateableAssociation(const std::string& path)
560{
561 assocs.emplace_back(std::make_tuple(UPDATEABLE_FWD_ASSOCIATION,
562 UPDATEABLE_REV_ASSOCIATION, path));
563 associations(assocs);
564}
565
Adriana Kobylak991af7e2018-12-10 13:08:38 -0600566void ItemUpdater::removeAssociations(const std::string& path)
Gunnar Millsded875d2017-08-28 16:44:52 -0500567{
568 for (auto iter = assocs.begin(); iter != assocs.end();)
569 {
Adriana Kobylak991af7e2018-12-10 13:08:38 -0600570 if ((std::get<2>(*iter)).compare(path) == 0)
Gunnar Millsded875d2017-08-28 16:44:52 -0500571 {
572 iter = assocs.erase(iter);
573 associations(assocs);
574 }
575 else
576 {
577 ++iter;
578 }
579 }
580}
581
Saqib Khanb9da6632017-09-13 09:48:37 -0500582bool ItemUpdater::isLowestPriority(uint8_t value)
583{
584 for (const auto& intf : activations)
585 {
Gunnar Millsd16bcbd2017-10-08 16:50:42 -0500586 if (intf.second->redundancyPriority)
Saqib Khanb9da6632017-09-13 09:48:37 -0500587 {
588 if (intf.second->redundancyPriority.get()->priority() < value)
589 {
590 return false;
591 }
592 }
593 }
594 return true;
595}
596
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500597void ItemUpdater::updateUbootEnvVars(const std::string& versionId)
598{
Lei YU56aaf452018-06-21 16:09:44 +0800599 helper.updateUbootVersionId(versionId);
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500600}
601
Saqib Khan49446ae2017-10-02 10:54:20 -0500602void ItemUpdater::resetUbootEnvVars()
603{
604 decltype(activations.begin()->second->redundancyPriority.get()->priority())
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600605 lowestPriority = std::numeric_limits<uint8_t>::max();
Saqib Khan49446ae2017-10-02 10:54:20 -0500606 decltype(activations.begin()->second->versionId) lowestPriorityVersion;
607 for (const auto& intf : activations)
608 {
609 if (!intf.second->redundancyPriority.get())
610 {
611 // Skip this version if the redundancyPriority is not initialized.
612 continue;
613 }
614
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600615 if (intf.second->redundancyPriority.get()->priority() <= lowestPriority)
Saqib Khan49446ae2017-10-02 10:54:20 -0500616 {
617 lowestPriority = intf.second->redundancyPriority.get()->priority();
618 lowestPriorityVersion = intf.second->versionId;
619 }
620 }
621
Saqib Khanf0382c32017-10-24 13:36:22 -0500622 // Update the U-boot environment variable to point to the lowest priority
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500623 updateUbootEnvVars(lowestPriorityVersion);
Saqib Khan49446ae2017-10-02 10:54:20 -0500624}
625
Adriana Kobylaka6963592018-09-07 14:13:29 -0500626void ItemUpdater::freeSpace(Activation& caller)
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600627{
628 // Versions with the highest priority in front
629 std::priority_queue<std::pair<int, std::string>,
630 std::vector<std::pair<int, std::string>>,
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600631 std::less<std::pair<int, std::string>>>
632 versionsPQ;
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600633
634 std::size_t count = 0;
635 for (const auto& iter : activations)
636 {
637 if ((iter.second.get()->activation() ==
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600638 server::Activation::Activations::Active) ||
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600639 (iter.second.get()->activation() ==
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600640 server::Activation::Activations::Failed))
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600641 {
642 count++;
643 // Don't put the functional version on the queue since we can't
644 // remove the "running" BMC version.
Lei YU0f88b5a2018-08-21 15:28:53 +0800645 // If ACTIVE_BMC_MAX_ALLOWED <= 1, there is only one active BMC,
646 // so remove functional version as well.
Adriana Kobylaka6963592018-09-07 14:13:29 -0500647 // Don't delete the the Activation object that called this function.
648 if ((versions.find(iter.second->versionId)
649 ->second->isFunctional() &&
650 ACTIVE_BMC_MAX_ALLOWED > 1) ||
651 (iter.second->versionId == caller.versionId))
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600652 {
653 continue;
654 }
Adriana Kobylaka6963592018-09-07 14:13:29 -0500655
656 // Failed activations don't have priority, assign them a large value
657 // for sorting purposes.
658 auto priority = 999;
659 if (iter.second.get()->activation() ==
660 server::Activation::Activations::Active)
661 {
662 priority = iter.second->redundancyPriority.get()->priority();
663 }
664
665 versionsPQ.push(std::make_pair(priority, iter.second->versionId));
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600666 }
667 }
668
669 // If the number of BMC versions is over ACTIVE_BMC_MAX_ALLOWED -1,
670 // remove the highest priority one(s).
671 while ((count >= ACTIVE_BMC_MAX_ALLOWED) && (!versionsPQ.empty()))
672 {
673 erase(versionsPQ.top().second);
674 versionsPQ.pop();
675 count--;
676 }
677}
678
Eddie Jameseaa1ee02018-03-01 10:09:10 -0600679void ItemUpdater::mirrorUbootToAlt()
680{
Lei YU56aaf452018-06-21 16:09:44 +0800681 helper.mirrorAlt();
Eddie Jameseaa1ee02018-03-01 10:09:10 -0600682}
683
Gunnar Millsec1b41c2017-05-02 12:20:36 -0500684} // namespace updater
685} // namespace software
686} // namespace phosphor