blob: 03bc591555e7a15e6155c4b2d17da4be76814e82 [file] [log] [blame]
Saqib Khan35e83f32017-05-22 11:37:32 -05001#include <fstream>
Adriana Kobylak204e1e72018-01-24 16:00:05 -06002#include <queue>
Adriana Kobylakb77551c2017-10-27 12:46:23 -05003#include <set>
Gunnar Millsec1b41c2017-05-02 12:20:36 -05004#include <string>
Gunnar Mills2ce7da22017-05-04 15:37:56 -05005#include <phosphor-logging/log.hpp>
Saqib Khandcbfa042017-09-18 13:08:39 -05006#include <phosphor-logging/elog.hpp>
7#include <elog-errors.hpp>
8#include <xyz/openbmc_project/Software/Version/error.hpp>
Gunnar Millsec1b41c2017-05-02 12:20:36 -05009#include "config.h"
Gunnar Mills2ce7da22017-05-04 15:37:56 -050010#include "item_updater.hpp"
11#include "xyz/openbmc_project/Software/Version/server.hpp"
Saqib Khan35e83f32017-05-22 11:37:32 -050012#include <experimental/filesystem>
Saqib Khan705f1bf2017-06-09 23:58:38 -050013#include "version.hpp"
Saqib Khan5d532672017-08-09 10:44:50 -050014#include "serialize.hpp"
Jayanth Othayoth2ab9b102018-02-21 05:27:47 -060015#include "image_verify.hpp"
Gunnar Millsec1b41c2017-05-02 12:20:36 -050016
17namespace phosphor
18{
19namespace software
20{
21namespace updater
22{
23
Gunnar Mills2ce7da22017-05-04 15:37:56 -050024// When you see server:: you know we're referencing our base class
25namespace server = sdbusplus::xyz::openbmc_project::Software::server;
Michael Tritz0129d922017-08-10 19:33:46 -050026namespace control = sdbusplus::xyz::openbmc_project::Control::server;
Gunnar Mills2ce7da22017-05-04 15:37:56 -050027
28using namespace phosphor::logging;
Saqib Khandcbfa042017-09-18 13:08:39 -050029using namespace sdbusplus::xyz::openbmc_project::Software::Version::Error;
Jayanth Othayoth2ab9b102018-02-21 05:27:47 -060030using namespace phosphor::software::image;
Saqib Khan35e83f32017-05-22 11:37:32 -050031namespace fs = std::experimental::filesystem;
32
Patrick Williamse75d10f2017-05-30 16:56:32 -050033void ItemUpdater::createActivation(sdbusplus::message::message& msg)
Gunnar Millsec1b41c2017-05-02 12:20:36 -050034{
Saqib Khan84a0e692017-06-28 17:27:01 -050035
36 using SVersion = server::Version;
37 using VersionPurpose = SVersion::VersionPurpose;
Gunnar Mills9a782242017-08-22 16:23:15 -050038 using VersionClass = phosphor::software::manager::Version;
Saqib Khan84a0e692017-06-28 17:27:01 -050039 namespace mesg = sdbusplus::message;
40 namespace variant_ns = mesg::variant_ns;
41
42 mesg::object_path objPath;
43 auto purpose = VersionPurpose::Unknown;
Saqib Khan705f1bf2017-06-09 23:58:38 -050044 std::string version;
Adriana Kobylak2285fe02018-02-27 15:36:59 -060045 std::map<std::string, std::map<std::string, mesg::variant<std::string>>>
46 interfaces;
Patrick Williamse75d10f2017-05-30 16:56:32 -050047 msg.read(objPath, interfaces);
Gunnar Mills2ce7da22017-05-04 15:37:56 -050048 std::string path(std::move(objPath));
Saqib Khan19177d32017-06-20 08:11:49 -050049 std::string filePath;
Gunnar Mills2ce7da22017-05-04 15:37:56 -050050
51 for (const auto& intf : interfaces)
52 {
Saqib Khan705f1bf2017-06-09 23:58:38 -050053 if (intf.first == VERSION_IFACE)
Gunnar Mills2ce7da22017-05-04 15:37:56 -050054 {
Saqib Khan705f1bf2017-06-09 23:58:38 -050055 for (const auto& property : intf.second)
Gunnar Mills2ce7da22017-05-04 15:37:56 -050056 {
Saqib Khan705f1bf2017-06-09 23:58:38 -050057 if (property.first == "Purpose")
Gunnar Mills2ce7da22017-05-04 15:37:56 -050058 {
Saqib Khan84a0e692017-06-28 17:27:01 -050059 auto value = SVersion::convertVersionPurposeFromString(
Adriana Kobylak2285fe02018-02-27 15:36:59 -060060 variant_ns::get<std::string>(property.second));
Saqib Khan84a0e692017-06-28 17:27:01 -050061 if (value == VersionPurpose::BMC ||
62 value == VersionPurpose::System)
63 {
64 purpose = value;
65 }
Saqib Khan705f1bf2017-06-09 23:58:38 -050066 }
67 else if (property.first == "Version")
68 {
Saqib Khan84a0e692017-06-28 17:27:01 -050069 version = variant_ns::get<std::string>(property.second);
Gunnar Mills2ce7da22017-05-04 15:37:56 -050070 }
71 }
72 }
Saqib Khan19177d32017-06-20 08:11:49 -050073 else if (intf.first == FILEPATH_IFACE)
74 {
75 for (const auto& property : intf.second)
76 {
77 if (property.first == "Path")
78 {
Saqib Khan84a0e692017-06-28 17:27:01 -050079 filePath = variant_ns::get<std::string>(property.second);
Saqib Khan19177d32017-06-20 08:11:49 -050080 }
81 }
82 }
Gunnar Mills2ce7da22017-05-04 15:37:56 -050083 }
Adriana Kobylak2285fe02018-02-27 15:36:59 -060084 if (version.empty() || filePath.empty() ||
Saqib Khan84a0e692017-06-28 17:27:01 -050085 purpose == VersionPurpose::Unknown)
Saqib Khan705f1bf2017-06-09 23:58:38 -050086 {
87 return;
88 }
Gunnar Mills2ce7da22017-05-04 15:37:56 -050089
90 // Version id is the last item in the path
91 auto pos = path.rfind("/");
92 if (pos == std::string::npos)
93 {
94 log<level::ERR>("No version id found in object path",
Adriana Kobylak596466b2018-02-13 14:48:53 -060095 entry("OBJPATH=%s", path.c_str()));
Patrick Williamse75d10f2017-05-30 16:56:32 -050096 return;
Gunnar Mills2ce7da22017-05-04 15:37:56 -050097 }
98
99 auto versionId = path.substr(pos + 1);
100
Patrick Williamse75d10f2017-05-30 16:56:32 -0500101 if (activations.find(versionId) == activations.end())
Gunnar Mills2ce7da22017-05-04 15:37:56 -0500102 {
Saqib Khan35e83f32017-05-22 11:37:32 -0500103 // Determine the Activation state by processing the given image dir.
104 auto activationState = server::Activation::Activations::Invalid;
Gunnar Mills9a782242017-08-22 16:23:15 -0500105 ItemUpdater::ActivationStatus result =
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600106 ItemUpdater::validateSquashFSImage(filePath);
Gunnar Mills43b25cd2017-09-07 13:19:34 -0500107 AssociationList associations = {};
108
Saqib Khan35e83f32017-05-22 11:37:32 -0500109 if (result == ItemUpdater::ActivationStatus::ready)
110 {
111 activationState = server::Activation::Activations::Ready;
Gunnar Mills43b25cd2017-09-07 13:19:34 -0500112 // Create an association to the BMC inventory item
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600113 associations.emplace_back(
114 std::make_tuple(ACTIVATION_FWD_ASSOCIATION,
115 ACTIVATION_REV_ASSOCIATION, bmcInventoryPath));
Saqib Khan35e83f32017-05-22 11:37:32 -0500116 }
Gunnar Millsb60add12017-08-24 16:41:42 -0500117
Saqib Khanee13e832017-10-23 12:53:11 -0500118 activations.insert(std::make_pair(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600119 versionId,
120 std::make_unique<Activation>(bus, path, *this, versionId,
121 activationState, associations)));
Michael Tritz4254bec2017-10-03 17:18:22 -0500122
Saqib Khanee13e832017-10-23 12:53:11 -0500123 auto versionPtr = std::make_unique<VersionClass>(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600124 bus, path, version, purpose, filePath,
125 std::bind(&ItemUpdater::erase, this, std::placeholders::_1));
Saqib Khanee13e832017-10-23 12:53:11 -0500126 versionPtr->deleteObject =
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600127 std::make_unique<phosphor::software::manager::Delete>(bus, path,
128 *versionPtr);
Saqib Khanee13e832017-10-23 12:53:11 -0500129 versions.insert(std::make_pair(versionId, std::move(versionPtr)));
Gunnar Mills2ce7da22017-05-04 15:37:56 -0500130 }
Patrick Williamse75d10f2017-05-30 16:56:32 -0500131 return;
Gunnar Millsec1b41c2017-05-02 12:20:36 -0500132}
133
Saqib Khanba239882017-05-26 08:41:54 -0500134void ItemUpdater::processBMCImage()
135{
Gunnar Mills88e8a322017-09-13 11:09:28 -0500136 using VersionClass = phosphor::software::manager::Version;
137 // Read os-release from /etc/ to get the functional BMC version
138 auto functionalVersion = VersionClass::getBMCVersion(OS_RELEASE_FILE);
139
Saqib Khan1eef62d2017-08-10 15:29:34 -0500140 // Read os-release from folders under /media/ to get
141 // BMC Software Versions.
Gunnar Millsd16bcbd2017-10-08 16:50:42 -0500142 for (const auto& iter : fs::directory_iterator(MEDIA_DIR))
Saqib Khan1eef62d2017-08-10 15:29:34 -0500143 {
144 auto activationState = server::Activation::Activations::Active;
Saqib Khan6fab70d2017-09-07 00:13:50 -0500145 static const auto BMC_RO_PREFIX_LEN = strlen(BMC_ROFS_PREFIX);
Saqib Khan1eef62d2017-08-10 15:29:34 -0500146
147 // Check if the BMC_RO_PREFIXis the prefix of the iter.path
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600148 if (0 ==
149 iter.path().native().compare(0, BMC_RO_PREFIX_LEN, BMC_ROFS_PREFIX))
Saqib Khan1eef62d2017-08-10 15:29:34 -0500150 {
Saqib Khan021c3652017-09-26 12:11:02 -0500151 // The versionId is extracted from the path
152 // for example /media/ro-2a1022fe.
153 auto id = iter.path().native().substr(BMC_RO_PREFIX_LEN);
Saqib Khan1eef62d2017-08-10 15:29:34 -0500154 auto osRelease = iter.path() / OS_RELEASE_FILE;
155 if (!fs::is_regular_file(osRelease))
156 {
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600157 log<level::ERR>(
158 "Failed to read osRelease",
159 entry("FILENAME=%s", osRelease.string().c_str()));
Saqib Khan021c3652017-09-26 12:11:02 -0500160 ItemUpdater::erase(id);
161 continue;
Saqib Khan1eef62d2017-08-10 15:29:34 -0500162 }
Gunnar Mills88e8a322017-09-13 11:09:28 -0500163 auto version = VersionClass::getBMCVersion(osRelease);
Saqib Khan1eef62d2017-08-10 15:29:34 -0500164 if (version.empty())
165 {
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600166 log<level::ERR>(
167 "Failed to read version from osRelease",
168 entry("FILENAME=%s", osRelease.string().c_str()));
Saqib Khan1eef62d2017-08-10 15:29:34 -0500169 activationState = server::Activation::Activations::Invalid;
170 }
Saqib Khan021c3652017-09-26 12:11:02 -0500171
Saqib Khan1eef62d2017-08-10 15:29:34 -0500172 auto purpose = server::Version::VersionPurpose::BMC;
173 auto path = fs::path(SOFTWARE_OBJPATH) / id;
174
Gunnar Mills88e8a322017-09-13 11:09:28 -0500175 // Create functional association if this is the functional version
176 if (version.compare(functionalVersion) == 0)
177 {
178 createFunctionalAssociation(path);
179 }
180
Gunnar Mills43b25cd2017-09-07 13:19:34 -0500181 AssociationList associations = {};
182
183 if (activationState == server::Activation::Activations::Active)
184 {
185 // Create an association to the BMC inventory item
186 associations.emplace_back(std::make_tuple(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600187 ACTIVATION_FWD_ASSOCIATION, ACTIVATION_REV_ASSOCIATION,
188 bmcInventoryPath));
Gunnar Mills43b25cd2017-09-07 13:19:34 -0500189
190 // Create an active association since this image is active
191 createActiveAssociation(path);
192 }
193
Adriana Kobylakee590c72017-09-26 15:16:06 -0500194 // Create Version instance for this version.
195 auto versionPtr = std::make_unique<VersionClass>(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600196 bus, path, version, purpose, "",
197 std::bind(&ItemUpdater::erase, this, std::placeholders::_1));
Adriana Kobylakee590c72017-09-26 15:16:06 -0500198 auto isVersionFunctional = versionPtr->isFunctional();
Michael Tritz4254bec2017-10-03 17:18:22 -0500199 if (!isVersionFunctional)
200 {
Saqib Khanee13e832017-10-23 12:53:11 -0500201 versionPtr->deleteObject =
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600202 std::make_unique<phosphor::software::manager::Delete>(
203 bus, path, *versionPtr);
Michael Tritz4254bec2017-10-03 17:18:22 -0500204 }
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600205 versions.insert(std::make_pair(id, std::move(versionPtr)));
Michael Tritz4254bec2017-10-03 17:18:22 -0500206
Saqib Khanee13e832017-10-23 12:53:11 -0500207 // Create Activation instance for this version.
208 activations.insert(std::make_pair(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600209 id, std::make_unique<Activation>(
210 bus, path, *this, id, activationState, associations)));
Saqib Khan1eef62d2017-08-10 15:29:34 -0500211
212 // If Active, create RedundancyPriority instance for this version.
213 if (activationState == server::Activation::Activations::Active)
214 {
215 uint8_t priority = std::numeric_limits<uint8_t>::max();
216 if (!restoreFromFile(id, priority))
217 {
Adriana Kobylakee590c72017-09-26 15:16:06 -0500218 if (isVersionFunctional)
219 {
220 priority = 0;
221 }
222 else
223 {
224 log<level::ERR>("Unable to restore priority from file.",
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600225 entry("VERSIONID=%s", id.c_str()));
Adriana Kobylakee590c72017-09-26 15:16:06 -0500226 }
Saqib Khan1eef62d2017-08-10 15:29:34 -0500227 }
228 activations.find(id)->second->redundancyPriority =
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600229 std::make_unique<RedundancyPriority>(
230 bus, path, *(activations.find(id)->second), priority,
231 false);
Saqib Khan1eef62d2017-08-10 15:29:34 -0500232 }
Saqib Khan1eef62d2017-08-10 15:29:34 -0500233 }
234 }
Saqib Khandcbfa042017-09-18 13:08:39 -0500235
236 // If there is no ubi volume for bmc version then read the /etc/os-release
237 // and create rofs-<versionId> under /media
238 if (activations.size() == 0)
239 {
Gunnar Millsd16bcbd2017-10-08 16:50:42 -0500240 auto version = VersionClass::getBMCVersion(OS_RELEASE_FILE);
Saqib Khandcbfa042017-09-18 13:08:39 -0500241 auto id = phosphor::software::manager::Version::getId(version);
242 auto versionFileDir = BMC_ROFS_PREFIX + id + "/etc/";
243 try
244 {
Gunnar Millsd16bcbd2017-10-08 16:50:42 -0500245 if (!fs::is_directory(versionFileDir))
Saqib Khandcbfa042017-09-18 13:08:39 -0500246 {
247 fs::create_directories(versionFileDir);
248 }
249 auto versionFilePath = BMC_ROFS_PREFIX + id + OS_RELEASE_FILE;
250 fs::create_directory_symlink(OS_RELEASE_FILE, versionFilePath);
251 ItemUpdater::processBMCImage();
252 }
253 catch (const std::exception& e)
254 {
255 log<level::ERR>(e.what());
256 }
257 }
Eddie Jameseaa1ee02018-03-01 10:09:10 -0600258
259 mirrorUbootToAlt();
Saqib Khanba239882017-05-26 08:41:54 -0500260 return;
261}
262
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500263void ItemUpdater::erase(std::string entryId)
264{
Eddie James6d873712017-09-01 11:29:07 -0500265 // Find entry in versions map
266 auto it = versions.find(entryId);
267 if (it != versions.end())
268 {
269 if (it->second->isFunctional())
270 {
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600271 log<level::ERR>("Error: Version is currently running on the BMC. "
272 "Unable to remove.",
273 entry("VERSIONID=%s", entryId.c_str()));
Gunnar Millsd16bcbd2017-10-08 16:50:42 -0500274 return;
Eddie James6d873712017-09-01 11:29:07 -0500275 }
276
277 // Delete ReadOnly partitions if it's not active
278 removeReadOnlyPartition(entryId);
279 removeFile(entryId);
Saqib Khanee13e832017-10-23 12:53:11 -0500280
281 // Removing entry in versions map
282 this->versions.erase(entryId);
Eddie James6d873712017-09-01 11:29:07 -0500283 }
284 else
285 {
286 // Delete ReadOnly partitions even if we can't find the version
287 removeReadOnlyPartition(entryId);
288 removeFile(entryId);
289
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600290 log<level::ERR>("Error: Failed to find version in item updater "
291 "versions map. Unable to remove.",
292 entry("VERSIONID=%s", entryId.c_str()));
Eddie James6d873712017-09-01 11:29:07 -0500293 }
Saqib Khan1eef62d2017-08-10 15:29:34 -0500294
295 // Remove the priority environment variable.
296 auto serviceFile = "obmc-flash-bmc-setenv@" + entryId + ".service";
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600297 auto method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
298 SYSTEMD_INTERFACE, "StartUnit");
Saqib Khan1eef62d2017-08-10 15:29:34 -0500299 method.append(serviceFile, "replace");
300 bus.call_noreply(method);
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500301
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500302 // Removing entry in activations map
303 auto ita = activations.find(entryId);
304 if (ita == activations.end())
305 {
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600306 log<level::ERR>("Error: Failed to find version in item updater "
307 "activations map. Unable to remove.",
308 entry("VERSIONID=%s", entryId.c_str()));
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500309 }
Saqib Khanee13e832017-10-23 12:53:11 -0500310 else
311 {
312 this->activations.erase(entryId);
313 }
Saqib Khan49446ae2017-10-02 10:54:20 -0500314 ItemUpdater::resetUbootEnvVars();
Saqib Khanee13e832017-10-23 12:53:11 -0500315 return;
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500316}
317
Michael Tritzbc1bf3a2017-09-18 16:38:23 -0500318void ItemUpdater::deleteAll()
319{
Adriana Kobylak83cd21f2018-02-28 15:48:48 -0600320 std::vector<std::string> deletableVersions;
321
Michael Tritzbc1bf3a2017-09-18 16:38:23 -0500322 for (const auto& versionIt : versions)
323 {
324 if (!versionIt.second->isFunctional())
325 {
Adriana Kobylak83cd21f2018-02-28 15:48:48 -0600326 deletableVersions.push_back(versionIt.first);
Michael Tritzbc1bf3a2017-09-18 16:38:23 -0500327 }
328 }
329
Adriana Kobylak83cd21f2018-02-28 15:48:48 -0600330 for (const auto& deletableIt : deletableVersions)
331 {
332 ItemUpdater::erase(deletableIt);
333 }
334
Michael Tritzbc1bf3a2017-09-18 16:38:23 -0500335 // Remove any volumes that do not match current versions.
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600336 auto method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
337 SYSTEMD_INTERFACE, "StartUnit");
Michael Tritzbc1bf3a2017-09-18 16:38:23 -0500338 method.append("obmc-flash-bmc-cleanup.service", "replace");
339 bus.call_noreply(method);
340}
341
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600342ItemUpdater::ActivationStatus
343 ItemUpdater::validateSquashFSImage(const std::string& filePath)
Saqib Khan35e83f32017-05-22 11:37:32 -0500344{
Michael Tritzb1cfdf92017-08-14 14:33:30 -0500345 bool invalid = false;
Saqib Khan35e83f32017-05-22 11:37:32 -0500346
Michael Tritzb1cfdf92017-08-14 14:33:30 -0500347 for (auto& bmcImage : bmcImages)
Saqib Khan35e83f32017-05-22 11:37:32 -0500348 {
Michael Tritzb1cfdf92017-08-14 14:33:30 -0500349 fs::path file(filePath);
350 file /= bmcImage;
351 std::ifstream efile(file.c_str());
352 if (efile.good() != 1)
353 {
354 log<level::ERR>("Failed to find the BMC image.",
Gunnar Mills9a782242017-08-22 16:23:15 -0500355 entry("IMAGE=%s", bmcImage.c_str()));
Michael Tritzb1cfdf92017-08-14 14:33:30 -0500356 invalid = true;
357 }
Saqib Khan35e83f32017-05-22 11:37:32 -0500358 }
Michael Tritzb1cfdf92017-08-14 14:33:30 -0500359
360 if (invalid)
Saqib Khan35e83f32017-05-22 11:37:32 -0500361 {
Saqib Khan35e83f32017-05-22 11:37:32 -0500362 return ItemUpdater::ActivationStatus::invalid;
363 }
Michael Tritzb1cfdf92017-08-14 14:33:30 -0500364
365 return ItemUpdater::ActivationStatus::ready;
Saqib Khan35e83f32017-05-22 11:37:32 -0500366}
367
Saqib Khanb9da6632017-09-13 09:48:37 -0500368void ItemUpdater::freePriority(uint8_t value, const std::string& versionId)
Saqib Khan4c1aec02017-07-06 11:46:13 -0500369{
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500370 std::map<std::string, uint8_t> priorityMap;
371
372 // Insert the requested version and priority, it may not exist yet.
373 priorityMap.insert(std::make_pair(versionId, value));
374
Saqib Khan4c1aec02017-07-06 11:46:13 -0500375 for (const auto& intf : activations)
376 {
Gunnar Mills9a782242017-08-22 16:23:15 -0500377 if (intf.second->redundancyPriority)
Saqib Khan4c1aec02017-07-06 11:46:13 -0500378 {
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500379 priorityMap.insert(std::make_pair(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600380 intf.first, intf.second->redundancyPriority.get()->priority()));
Saqib Khan4c1aec02017-07-06 11:46:13 -0500381 }
382 }
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500383
384 // Lambda function to compare 2 priority values, use <= to allow duplicates
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600385 typedef std::function<bool(std::pair<std::string, uint8_t>,
386 std::pair<std::string, uint8_t>)>
387 cmpPriority;
388 cmpPriority cmpPriorityFunc =
389 [](std::pair<std::string, uint8_t> priority1,
390 std::pair<std::string, uint8_t> priority2) {
391 return priority1.second <= priority2.second;
392 };
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500393
394 // Sort versions by ascending priority
395 std::set<std::pair<std::string, uint8_t>, cmpPriority> prioritySet(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600396 priorityMap.begin(), priorityMap.end(), cmpPriorityFunc);
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500397
398 auto freePriorityValue = value;
399 for (auto& element : prioritySet)
400 {
401 if (element.first == versionId)
402 {
403 continue;
404 }
405 if (element.second == freePriorityValue)
406 {
407 ++freePriorityValue;
408 auto it = activations.find(element.first);
409 it->second->redundancyPriority.get()->sdbusPriority(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600410 freePriorityValue);
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500411 }
412 }
413
414 auto lowestVersion = prioritySet.begin()->first;
415 if (value == prioritySet.begin()->second)
416 {
417 lowestVersion = versionId;
418 }
419 updateUbootEnvVars(lowestVersion);
Saqib Khan4c1aec02017-07-06 11:46:13 -0500420}
421
Michael Tritz37a59042017-07-12 13:44:53 -0500422void ItemUpdater::reset()
423{
424 // Mark the read-write partition for recreation upon reboot.
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600425 auto method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
426 SYSTEMD_INTERFACE, "StartUnit");
Michael Tritz0129d922017-08-10 19:33:46 -0500427 method.append("obmc-flash-bmc-setenv@rwreset\\x3dtrue.service", "replace");
Michael Tritz37a59042017-07-12 13:44:53 -0500428 bus.call_noreply(method);
429
430 log<level::INFO>("BMC factory reset will take effect upon reboot.");
431
432 return;
433}
434
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500435void ItemUpdater::removeReadOnlyPartition(std::string versionId)
436{
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600437 auto serviceFile = "obmc-flash-bmc-ubiro-remove@" + versionId + ".service";
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500438
439 // Remove the read-only partitions.
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600440 auto method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
441 SYSTEMD_INTERFACE, "StartUnit");
Leonel Gonzalez3526ef72017-07-07 14:38:25 -0500442 method.append(serviceFile, "replace");
443 bus.call_noreply(method);
444}
445
Michael Tritz0129d922017-08-10 19:33:46 -0500446bool ItemUpdater::fieldModeEnabled(bool value)
447{
448 // enabling field mode is intended to be one way: false -> true
449 if (value && !control::FieldMode::fieldModeEnabled())
450 {
451 control::FieldMode::fieldModeEnabled(value);
452
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600453 auto method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
454 SYSTEMD_INTERFACE, "StartUnit");
Michael Tritz0129d922017-08-10 19:33:46 -0500455 method.append("obmc-flash-bmc-setenv@fieldmode\\x3dtrue.service",
Gunnar Mills9a782242017-08-22 16:23:15 -0500456 "replace");
Michael Tritz0129d922017-08-10 19:33:46 -0500457 bus.call_noreply(method);
458
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600459 method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
460 SYSTEMD_INTERFACE, "StopUnit");
Michael Tritz0129d922017-08-10 19:33:46 -0500461 method.append("usr-local.mount", "replace");
462 bus.call_noreply(method);
463
464 std::vector<std::string> usrLocal = {"usr-local.mount"};
465
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600466 method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
467 SYSTEMD_INTERFACE, "MaskUnitFiles");
Michael Tritz0129d922017-08-10 19:33:46 -0500468 method.append(usrLocal, false, true);
469 bus.call_noreply(method);
470 }
471
472 return control::FieldMode::fieldModeEnabled();
473}
474
475void ItemUpdater::restoreFieldModeStatus()
476{
Michael Tritzff0b4212017-10-24 17:38:09 -0500477 std::ifstream input("/dev/mtd/u-boot-env");
Michael Tritz0129d922017-08-10 19:33:46 -0500478 std::string envVar;
479 std::getline(input, envVar);
480
Gunnar Mills9a782242017-08-22 16:23:15 -0500481 if (envVar.find("fieldmode=true") != std::string::npos)
Michael Tritz0129d922017-08-10 19:33:46 -0500482 {
483 ItemUpdater::fieldModeEnabled(true);
484 }
485}
486
Gunnar Millsb60add12017-08-24 16:41:42 -0500487void ItemUpdater::setBMCInventoryPath()
488{
Gunnar Millsb60add12017-08-24 16:41:42 -0500489 auto depth = 0;
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600490 auto mapperCall = bus.new_method_call(MAPPER_BUSNAME, MAPPER_PATH,
491 MAPPER_INTERFACE, "GetSubTreePaths");
Gunnar Millsb60add12017-08-24 16:41:42 -0500492
Adriana Kobylak1254c622017-12-07 12:24:56 -0600493 mapperCall.append(INVENTORY_PATH);
Gunnar Millsb60add12017-08-24 16:41:42 -0500494 mapperCall.append(depth);
Adriana Kobylak1254c622017-12-07 12:24:56 -0600495 std::vector<std::string> filter = {BMC_INVENTORY_INTERFACE};
Gunnar Millsb60add12017-08-24 16:41:42 -0500496 mapperCall.append(filter);
497
498 auto response = bus.call(mapperCall);
499 if (response.is_method_error())
500 {
501 log<level::ERR>("Error in mapper GetSubTreePath");
502 return;
503 }
504
505 using ObjectPaths = std::vector<std::string>;
506 ObjectPaths result;
507 response.read(result);
508
Adriana Kobylak1254c622017-12-07 12:24:56 -0600509 if (!result.empty())
Gunnar Millsb60add12017-08-24 16:41:42 -0500510 {
Adriana Kobylak1254c622017-12-07 12:24:56 -0600511 bmcInventoryPath = result.front();
Gunnar Millsb60add12017-08-24 16:41:42 -0500512 }
513
Adriana Kobylak1254c622017-12-07 12:24:56 -0600514 return;
Gunnar Millsb60add12017-08-24 16:41:42 -0500515}
516
Gunnar Millsf10b2322017-09-21 15:31:55 -0500517void ItemUpdater::createActiveAssociation(const std::string& path)
Gunnar Millsded875d2017-08-28 16:44:52 -0500518{
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600519 assocs.emplace_back(
520 std::make_tuple(ACTIVE_FWD_ASSOCIATION, ACTIVE_REV_ASSOCIATION, path));
Gunnar Millsded875d2017-08-28 16:44:52 -0500521 associations(assocs);
522}
523
Gunnar Mills88e8a322017-09-13 11:09:28 -0500524void ItemUpdater::createFunctionalAssociation(const std::string& path)
525{
526 assocs.emplace_back(std::make_tuple(FUNCTIONAL_FWD_ASSOCIATION,
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600527 FUNCTIONAL_REV_ASSOCIATION, path));
Gunnar Mills88e8a322017-09-13 11:09:28 -0500528 associations(assocs);
529}
530
Gunnar Millsf10b2322017-09-21 15:31:55 -0500531void ItemUpdater::removeActiveAssociation(const std::string& path)
Gunnar Millsded875d2017-08-28 16:44:52 -0500532{
533 for (auto iter = assocs.begin(); iter != assocs.end();)
534 {
Gunnar Mills88e8a322017-09-13 11:09:28 -0500535 // Since there could be multiple associations to the same path,
536 // only remove ones that have an active forward association.
537 if ((std::get<0>(*iter)).compare(ACTIVE_FWD_ASSOCIATION) == 0 &&
538 (std::get<2>(*iter)).compare(path) == 0)
Gunnar Millsded875d2017-08-28 16:44:52 -0500539 {
540 iter = assocs.erase(iter);
541 associations(assocs);
542 }
543 else
544 {
545 ++iter;
546 }
547 }
548}
549
Saqib Khanb9da6632017-09-13 09:48:37 -0500550bool ItemUpdater::isLowestPriority(uint8_t value)
551{
552 for (const auto& intf : activations)
553 {
Gunnar Millsd16bcbd2017-10-08 16:50:42 -0500554 if (intf.second->redundancyPriority)
Saqib Khanb9da6632017-09-13 09:48:37 -0500555 {
556 if (intf.second->redundancyPriority.get()->priority() < value)
557 {
558 return false;
559 }
560 }
561 }
562 return true;
563}
564
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500565void ItemUpdater::updateUbootEnvVars(const std::string& versionId)
566{
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600567 auto method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
568 SYSTEMD_INTERFACE, "StartUnit");
569 auto updateEnvVarsFile =
570 "obmc-flash-bmc-updateubootvars@" + versionId + ".service";
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500571 method.append(updateEnvVarsFile, "replace");
572 auto result = bus.call(method);
573
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600574 // Check that the bus call didn't result in an error
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500575 if (result.is_method_error())
576 {
577 log<level::ERR>("Failed to update u-boot env variables",
Adriana Kobylak596466b2018-02-13 14:48:53 -0600578 entry("VERSIONID=%s", versionId.c_str()));
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500579 }
580}
581
Saqib Khan49446ae2017-10-02 10:54:20 -0500582void ItemUpdater::resetUbootEnvVars()
583{
584 decltype(activations.begin()->second->redundancyPriority.get()->priority())
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600585 lowestPriority = std::numeric_limits<uint8_t>::max();
Saqib Khan49446ae2017-10-02 10:54:20 -0500586 decltype(activations.begin()->second->versionId) lowestPriorityVersion;
587 for (const auto& intf : activations)
588 {
589 if (!intf.second->redundancyPriority.get())
590 {
591 // Skip this version if the redundancyPriority is not initialized.
592 continue;
593 }
594
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600595 if (intf.second->redundancyPriority.get()->priority() <= lowestPriority)
Saqib Khan49446ae2017-10-02 10:54:20 -0500596 {
597 lowestPriority = intf.second->redundancyPriority.get()->priority();
598 lowestPriorityVersion = intf.second->versionId;
599 }
600 }
601
Saqib Khanf0382c32017-10-24 13:36:22 -0500602 // Update the U-boot environment variable to point to the lowest priority
Adriana Kobylakb77551c2017-10-27 12:46:23 -0500603 updateUbootEnvVars(lowestPriorityVersion);
Saqib Khan49446ae2017-10-02 10:54:20 -0500604}
605
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600606void ItemUpdater::freeSpace()
607{
608 // Versions with the highest priority in front
609 std::priority_queue<std::pair<int, std::string>,
610 std::vector<std::pair<int, std::string>>,
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600611 std::less<std::pair<int, std::string>>>
612 versionsPQ;
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600613
614 std::size_t count = 0;
615 for (const auto& iter : activations)
616 {
617 if ((iter.second.get()->activation() ==
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600618 server::Activation::Activations::Active) ||
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600619 (iter.second.get()->activation() ==
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600620 server::Activation::Activations::Failed))
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600621 {
622 count++;
623 // Don't put the functional version on the queue since we can't
624 // remove the "running" BMC version.
625 if (versions.find(iter.second->versionId)->second->isFunctional())
626 {
627 continue;
628 }
629 versionsPQ.push(std::make_pair(
Adriana Kobylak2285fe02018-02-27 15:36:59 -0600630 iter.second->redundancyPriority.get()->priority(),
631 iter.second->versionId));
Adriana Kobylak204e1e72018-01-24 16:00:05 -0600632 }
633 }
634
635 // If the number of BMC versions is over ACTIVE_BMC_MAX_ALLOWED -1,
636 // remove the highest priority one(s).
637 while ((count >= ACTIVE_BMC_MAX_ALLOWED) && (!versionsPQ.empty()))
638 {
639 erase(versionsPQ.top().second);
640 versionsPQ.pop();
641 count--;
642 }
643}
644
Eddie Jameseaa1ee02018-03-01 10:09:10 -0600645void ItemUpdater::mirrorUbootToAlt()
646{
647 auto method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
648 SYSTEMD_INTERFACE, "StartUnit");
649 auto mirrorUbootFile = "obmc-flash-bmc-mirroruboot.service";
650 method.append(mirrorUbootFile, "replace");
651 auto result = bus.call(method);
652
653 // Check that the bus call didn't result in an error
654 if (result.is_method_error())
655 {
656 log<level::ERR>("Failed to copy U-Boot to alternate chip");
657 }
658}
659
Gunnar Millsec1b41c2017-05-02 12:20:36 -0500660} // namespace updater
661} // namespace software
662} // namespace phosphor