blob: 37610c0707409b780764dda0a96d3f7df35c5c01 [file] [log] [blame]
Lei YU12c9f4c2019-09-11 15:08:15 +08001#include "config.h"
2
Lei YU01539e72019-07-31 10:57:38 +08003#include "activation.hpp"
4
Lei YU12c9f4c2019-09-11 15:08:15 +08005#include "utils.hpp"
6
7#include <cassert>
8#include <filesystem>
Lei YUd0bbfa92019-09-11 16:10:54 +08009#include <phosphor-logging/elog-errors.hpp>
10#include <phosphor-logging/log.hpp>
Lei YU12c9f4c2019-09-11 15:08:15 +080011
Lei YU01539e72019-07-31 10:57:38 +080012namespace phosphor
13{
14namespace software
15{
16namespace updater
17{
18
Lei YU12c9f4c2019-09-11 15:08:15 +080019constexpr auto SYSTEMD_BUSNAME = "org.freedesktop.systemd1";
20constexpr auto SYSTEMD_PATH = "/org/freedesktop/systemd1";
21constexpr auto SYSTEMD_INTERFACE = "org.freedesktop.systemd1.Manager";
22
23namespace fs = std::filesystem;
Lei YU01539e72019-07-31 10:57:38 +080024namespace softwareServer = sdbusplus::xyz::openbmc_project::Software::server;
25
Lei YUd0bbfa92019-09-11 16:10:54 +080026using namespace phosphor::logging;
27using sdbusplus::exception::SdBusError;
Lei YU12c9f4c2019-09-11 15:08:15 +080028using SoftwareActivation = softwareServer::Activation;
29
Lei YU01539e72019-07-31 10:57:38 +080030auto Activation::activation(Activations value) -> Activations
31{
Lei YU12c9f4c2019-09-11 15:08:15 +080032 if (value == Status::Activating)
33 {
Lei YUff83c2a2019-09-12 13:55:18 +080034 value = startActivation();
Lei YU12c9f4c2019-09-11 15:08:15 +080035 }
36 else
37 {
Lei YU81c67722019-09-11 16:47:29 +080038 activationBlocksTransition.reset();
Lei YU90c8a8b2019-09-11 17:20:03 +080039 activationProgress.reset();
Lei YU12c9f4c2019-09-11 15:08:15 +080040 }
41
42 return SoftwareActivation::activation(value);
Lei YU01539e72019-07-31 10:57:38 +080043}
44
45auto Activation::requestedActivation(RequestedActivations value)
46 -> RequestedActivations
47{
Lei YU12c9f4c2019-09-11 15:08:15 +080048 if ((value == SoftwareActivation::RequestedActivations::Active) &&
49 (SoftwareActivation::requestedActivation() !=
50 SoftwareActivation::RequestedActivations::Active))
51 {
Lei YU63f9e712019-10-12 15:16:55 +080052 // PSU image could be activated even when it's in active,
53 // e.g. in case a PSU is replaced and has a older image, it will be
54 // updated with the running PSU image that is stored in BMC.
55 if ((activation() == Status::Ready) ||
56 (activation() == Status::Failed) || activation() == Status::Active)
Lei YU12c9f4c2019-09-11 15:08:15 +080057 {
58 activation(Status::Activating);
59 }
60 }
61 return SoftwareActivation::requestedActivation(value);
62}
63
64void Activation::unitStateChange(sdbusplus::message::message& msg)
65{
66 uint32_t newStateID{};
67 sdbusplus::message::object_path newStateObjPath;
68 std::string newStateUnit{};
69 std::string newStateResult{};
70
71 // Read the msg and populate each variable
72 msg.read(newStateID, newStateObjPath, newStateUnit, newStateResult);
73
74 if (newStateUnit == psuUpdateUnit)
75 {
76 if (newStateResult == "done")
77 {
Lei YUff83c2a2019-09-12 13:55:18 +080078 onUpdateDone();
Lei YU12c9f4c2019-09-11 15:08:15 +080079 }
80 if (newStateResult == "failed" || newStateResult == "dependency")
81 {
Lei YUff83c2a2019-09-12 13:55:18 +080082 onUpdateFailed();
Lei YU12c9f4c2019-09-11 15:08:15 +080083 }
84 }
85}
86
Lei YUff83c2a2019-09-12 13:55:18 +080087bool Activation::doUpdate(const std::string& psuInventoryPath)
88{
Lei YU7f2a2152019-09-16 16:50:18 +080089 currentUpdatingPsu = psuInventoryPath;
Lei YUe8945ea2019-09-29 17:25:31 +080090 psuUpdateUnit = getUpdateService(currentUpdatingPsu);
Lei YUff83c2a2019-09-12 13:55:18 +080091 try
92 {
93 auto method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
94 SYSTEMD_INTERFACE, "StartUnit");
95 method.append(psuUpdateUnit, "replace");
96 bus.call_noreply(method);
97 return true;
98 }
99 catch (const SdBusError& e)
100 {
101 log<level::ERR>("Error staring service", entry("ERROR=%s", e.what()));
102 onUpdateFailed();
103 return false;
104 }
105}
106
107bool Activation::doUpdate()
108{
109 // When the queue is empty, all updates are done
110 if (psuQueue.empty())
111 {
112 finishActivation();
113 return true;
114 }
115
116 // Do the update on a PSU
117 const auto& psu = psuQueue.front();
118 return doUpdate(psu);
119}
120
121void Activation::onUpdateDone()
122{
123 auto progress = activationProgress->progress() + progressStep;
124 activationProgress->progress(progress);
125
Lei YU7f2a2152019-09-16 16:50:18 +0800126 // Update the activation association
127 auto assocs = associations();
128 assocs.emplace_back(ACTIVATION_FWD_ASSOCIATION, ACTIVATION_REV_ASSOCIATION,
129 currentUpdatingPsu);
Lei YU7f2a2152019-09-16 16:50:18 +0800130 associations(assocs);
131
Lei YUffb36532019-10-15 13:55:24 +0800132 activationListener->onUpdateDone(versionId, currentUpdatingPsu);
133 currentUpdatingPsu.clear();
134
Lei YUff83c2a2019-09-12 13:55:18 +0800135 psuQueue.pop();
136 doUpdate(); // Update the next psu
137}
138
139void Activation::onUpdateFailed()
140{
141 // TODO: report an event
142 log<level::ERR>("Failed to udpate PSU",
143 entry("PSU=%s", psuQueue.front().c_str()));
144 std::queue<std::string>().swap(psuQueue); // Clear the queue
145 activation(Status::Failed);
146}
147
148Activation::Status Activation::startActivation()
Lei YU12c9f4c2019-09-11 15:08:15 +0800149{
Lei YU63f9e712019-10-12 15:16:55 +0800150 // Check if the activation has file path
151 if (path().empty())
152 {
153 log<level::WARNING>("No image for the activation, skipped",
154 entry("VERSION_ID=%s", versionId.c_str()));
155 return activation(); // Return the previous activation status
156 }
Lei YU81c67722019-09-11 16:47:29 +0800157
Lei YU12c9f4c2019-09-11 15:08:15 +0800158 auto psuPaths = utils::getPSUInventoryPath(bus);
159 if (psuPaths.empty())
160 {
Lei YUff83c2a2019-09-12 13:55:18 +0800161 log<level::WARNING>("No PSU inventory found");
162 return Status::Failed;
Lei YU12c9f4c2019-09-11 15:08:15 +0800163 }
164
Lei YUff83c2a2019-09-12 13:55:18 +0800165 for (const auto& p : psuPaths)
166 {
Lei YU9edb7332019-09-19 14:46:19 +0800167 if (isCompatible(p))
168 {
Lei YU63f9e712019-10-12 15:16:55 +0800169 if (utils::isAssociated(p, associations()))
170 {
171 log<level::NOTICE>("PSU already running the image, skipping",
172 entry("PSU=%s", p.c_str()));
173 continue;
174 }
Lei YU9edb7332019-09-19 14:46:19 +0800175 psuQueue.push(p);
176 }
177 else
178 {
179 log<level::NOTICE>("PSU not compatible",
180 entry("PSU=%s", p.c_str()));
181 }
182 }
183
184 if (psuQueue.empty())
185 {
Lei YU63f9e712019-10-12 15:16:55 +0800186 log<level::WARNING>("No PSU compatible with the software");
187 return activation(); // Return the previous activation status
Lei YUff83c2a2019-09-12 13:55:18 +0800188 }
Lei YU12c9f4c2019-09-11 15:08:15 +0800189
Lei YU8afeee52019-10-21 15:25:35 +0800190 if (!activationProgress)
191 {
192 activationProgress = std::make_unique<ActivationProgress>(bus, objPath);
193 }
194 if (!activationBlocksTransition)
195 {
196 activationBlocksTransition =
197 std::make_unique<ActivationBlocksTransition>(bus, objPath);
198 }
199
Lei YUff83c2a2019-09-12 13:55:18 +0800200 // The progress to be increased for each successful update of PSU
201 // E.g. in case we have 4 PSUs:
202 // 1. Initial progrss is 10
203 // 2. Add 20 after each update is done, so we will see progress to be 30,
204 // 50, 70, 90
205 // 3. When all PSUs are updated, it will be 100 and the interface is
206 // removed.
207 progressStep = 80 / psuQueue.size();
208 if (doUpdate())
209 {
210 activationProgress->progress(10);
211 return Status::Activating;
212 }
213 else
214 {
215 return Status::Failed;
216 }
Lei YU12c9f4c2019-09-11 15:08:15 +0800217}
218
219void Activation::finishActivation()
220{
Lei YU2e0e2de2019-09-26 16:42:23 +0800221 storeImage();
Lei YU90c8a8b2019-09-11 17:20:03 +0800222 activationProgress->progress(100);
Lei YU81c67722019-09-11 16:47:29 +0800223
Lei YUd0bbfa92019-09-11 16:10:54 +0800224 deleteImageManagerObject();
Lei YU7f2a2152019-09-16 16:50:18 +0800225
Lei YU99301372019-09-29 16:27:12 +0800226 associationInterface->createActiveAssociation(objPath);
227 associationInterface->addFunctionalAssociation(objPath);
Lei YU7f2a2152019-09-16 16:50:18 +0800228
Lei YU1517f5f2019-10-14 16:44:42 +0800229 // Reset RequestedActivations to none so that it could be activated in
230 // future
231 requestedActivation(SoftwareActivation::RequestedActivations::None);
Lei YU12c9f4c2019-09-11 15:08:15 +0800232 activation(Status::Active);
Lei YU01539e72019-07-31 10:57:38 +0800233}
234
Lei YUd0bbfa92019-09-11 16:10:54 +0800235void Activation::deleteImageManagerObject()
236{
237 // Get the Delete object for <versionID> inside image_manager
238 constexpr auto versionServiceStr = "xyz.openbmc_project.Software.Version";
239 constexpr auto deleteInterface = "xyz.openbmc_project.Object.Delete";
240 std::string versionService;
Lei YU99301372019-09-29 16:27:12 +0800241 auto services = utils::getServices(bus, objPath.c_str(), deleteInterface);
Lei YUd0bbfa92019-09-11 16:10:54 +0800242
243 // We need to find the phosphor-version-software-manager's version service
244 // to invoke the delete interface
245 for (const auto& service : services)
246 {
247 if (service.find(versionServiceStr) != std::string::npos)
248 {
249 versionService = service;
250 break;
251 }
252 }
253 if (versionService.empty())
254 {
Lei YUe8945ea2019-09-29 17:25:31 +0800255 // When updating a stored image, there is no version object created by
256 // "xyz.openbmc_project.Software.Version" service, so skip it.
Lei YUd0bbfa92019-09-11 16:10:54 +0800257 return;
258 }
259
260 // Call the Delete object for <versionID> inside image_manager
Lei YU99301372019-09-29 16:27:12 +0800261 auto method = bus.new_method_call(versionService.c_str(), objPath.c_str(),
Lei YUd0bbfa92019-09-11 16:10:54 +0800262 deleteInterface, "Delete");
263 try
264 {
265 bus.call(method);
266 }
267 catch (const SdBusError& e)
268 {
269 log<level::ERR>("Error performing call to Delete object path",
270 entry("ERROR=%s", e.what()),
Lei YU99301372019-09-29 16:27:12 +0800271 entry("PATH=%s", objPath.c_str()));
Lei YUd0bbfa92019-09-11 16:10:54 +0800272 }
273}
274
Lei YU9edb7332019-09-19 14:46:19 +0800275bool Activation::isCompatible(const std::string& psuInventoryPath)
276{
277 auto service =
278 utils::getService(bus, psuInventoryPath.c_str(), ASSET_IFACE);
279 auto psuManufacturer = utils::getProperty<std::string>(
280 bus, service.c_str(), psuInventoryPath.c_str(), ASSET_IFACE,
281 MANUFACTURER);
282 auto psuModel = utils::getProperty<std::string>(
283 bus, service.c_str(), psuInventoryPath.c_str(), ASSET_IFACE, MODEL);
284 if (psuModel != model)
285 {
286 // The model shall match
287 return false;
288 }
289 if (!psuManufacturer.empty())
290 {
291 // If PSU inventory has manufacturer property, it shall match
292 return psuManufacturer == manufacturer;
293 }
294 return true;
295}
296
Lei YU2e0e2de2019-09-26 16:42:23 +0800297void Activation::storeImage()
298{
299 // Store image in persistent dir separated by model
300 // and only store the latest one by removing old ones
Lei YUe8945ea2019-09-29 17:25:31 +0800301 auto src = path();
Lei YU2e0e2de2019-09-26 16:42:23 +0800302 auto dst = fs::path(IMG_DIR_PERSIST) / model;
Lei YUe8945ea2019-09-29 17:25:31 +0800303 if (src == dst)
304 {
305 // This happens when updating an stored image, no need to store it again
306 return;
307 }
Lei YU2e0e2de2019-09-26 16:42:23 +0800308 try
309 {
310 fs::remove_all(dst);
311 fs::create_directories(dst);
312 fs::copy(src, dst);
313 path(dst.string()); // Update the FilePath interface
314 }
315 catch (const fs::filesystem_error& e)
316 {
317 log<level::ERR>("Error storing PSU image", entry("ERROR=%s", e.what()),
318 entry("SRC=%s", src.c_str()),
319 entry("DST=%s", dst.c_str()));
320 }
321}
322
Lei YUe8945ea2019-09-29 17:25:31 +0800323std::string Activation::getUpdateService(const std::string& psuInventoryPath)
324{
325 fs::path imagePath(path());
326
327 // The systemd unit shall be escaped
328 std::string args = psuInventoryPath;
329 args += "\\x20";
330 args += imagePath;
331 std::replace(args.begin(), args.end(), '/', '-');
332
333 std::string service = PSU_UPDATE_SERVICE;
334 auto p = service.find('@');
335 assert(p != std::string::npos);
336 service.insert(p + 1, args);
337 return service;
338}
339
Lei YU8afeee52019-10-21 15:25:35 +0800340void ActivationBlocksTransition::enableRebootGuard()
341{
342 log<level::INFO>("PSU image activating - BMC reboots are disabled.");
343
344 auto method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
345 SYSTEMD_INTERFACE, "StartUnit");
346 method.append("reboot-guard-enable.service", "replace");
347 bus.call_noreply_noerror(method);
348}
349
350void ActivationBlocksTransition::disableRebootGuard()
351{
352 log<level::INFO>("PSU activation has ended - BMC reboots are re-enabled.");
353
354 auto method = bus.new_method_call(SYSTEMD_BUSNAME, SYSTEMD_PATH,
355 SYSTEMD_INTERFACE, "StartUnit");
356 method.append("reboot-guard-disable.service", "replace");
357 bus.call_noreply_noerror(method);
358}
359
Lei YU01539e72019-07-31 10:57:38 +0800360} // namespace updater
361} // namespace software
362} // namespace phosphor