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