1 // SPDX-License-Identifier: Apache-2.0
2 // SPDX-FileCopyrightText: Copyright OpenBMC Authors
3 // SPDX-FileCopyrightText: Copyright 2018 Intel Corporation
4 #pragma once
5
6 #include "bmcweb_config.h"
7
8 #include "app.hpp"
9 #include "async_resp.hpp"
10 #include "dbus_singleton.hpp"
11 #include "dbus_utility.hpp"
12 #include "error_messages.hpp"
13 #include "generated/enums/action_info.hpp"
14 #include "generated/enums/manager.hpp"
15 #include "generated/enums/resource.hpp"
16 #include "http_request.hpp"
17 #include "led.hpp"
18 #include "logging.hpp"
19 #include "persistent_data.hpp"
20 #include "query.hpp"
21 #include "redfish.hpp"
22 #include "redfish_util.hpp"
23 #include "registries/privilege_registry.hpp"
24 #include "utils/dbus_utils.hpp"
25 #include "utils/json_utils.hpp"
26 #include "utils/manager_utils.hpp"
27 #include "utils/sw_utils.hpp"
28 #include "utils/systemd_utils.hpp"
29 #include "utils/time_utils.hpp"
30
31 #include <systemd/sd-bus.h>
32
33 #include <boost/beast/http/status.hpp>
34 #include <boost/beast/http/verb.hpp>
35 #include <boost/system/error_code.hpp>
36 #include <boost/url/format.hpp>
37 #include <boost/url/url.hpp>
38 #include <nlohmann/json.hpp>
39 #include <sdbusplus/asio/property.hpp>
40 #include <sdbusplus/message.hpp>
41 #include <sdbusplus/message/native_types.hpp>
42 #include <sdbusplus/unpack_properties.hpp>
43
44 #include <array>
45 #include <cstddef>
46 #include <cstdint>
47 #include <format>
48 #include <functional>
49 #include <map>
50 #include <memory>
51 #include <optional>
52 #include <ranges>
53 #include <string>
54 #include <string_view>
55 #include <utility>
56 #include <vector>
57
58 namespace redfish
59 {
60
handleSetLocationIndicatorActive(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,bool locationIndicatorActive,const std::string & managerId,const boost::system::error_code & ec,const dbus::utility::MapperGetSubTreePathsResponse & subtreePaths)61 inline void handleSetLocationIndicatorActive(
62 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
63 bool locationIndicatorActive, const std::string& managerId,
64 const boost::system::error_code& ec,
65 const dbus::utility::MapperGetSubTreePathsResponse& subtreePaths)
66 {
67 if (ec)
68 {
69 if (ec == boost::system::errc::io_error)
70 {
71 // Not found
72 BMCWEB_LOG_WARNING("Manager {} not found", managerId);
73 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
74 return;
75 }
76 BMCWEB_LOG_ERROR("D-Bus response error {}", ec.value());
77 messages::internalError(asyncResp->res);
78 return;
79 }
80 if (subtreePaths.empty())
81 {
82 BMCWEB_LOG_WARNING("Manager {} not found", managerId);
83 messages::resourceNotFound(asyncResp->res, "Manager", managerId);
84 return;
85 }
86 // Assume only 1 bmc D-Bus object
87 // Throw an error if there is more than 1
88 if (subtreePaths.size() != 1)
89 {
90 BMCWEB_LOG_ERROR("Found {} Bmc D-Bus paths", subtreePaths.size());
91 messages::internalError(asyncResp->res);
92 return;
93 }
94
95 setLocationIndicatorActive(asyncResp, subtreePaths[0],
96 locationIndicatorActive);
97 }
98
99 /**
100 * Set the locationIndicatorActive.
101 *
102 * @param[in,out] asyncResp Async HTTP response.
103 * @param[in] locationIndicatorActive Value of the property
104 */
setLocationIndicatorActiveState(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,bool locationIndicatorActive,const std::string & managerId)105 inline void setLocationIndicatorActiveState(
106 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
107 bool locationIndicatorActive, const std::string& managerId)
108 {
109 // GetSubTree on all interfaces which provide info about a Manager
110 constexpr std::array<std::string_view, 1> interfaces = {
111 "xyz.openbmc_project.Inventory.Item.Bmc"};
112 dbus::utility::getSubTreePaths(
113 "/xyz/openbmc_project/inventory", 0, interfaces,
114 std::bind_front(handleSetLocationIndicatorActive, asyncResp,
115 locationIndicatorActive, managerId));
116 }
117
getBMCUpdateServiceName()118 inline std::string getBMCUpdateServiceName()
119 {
120 if constexpr (BMCWEB_REDFISH_UPDATESERVICE_USE_DBUS)
121 {
122 return "xyz.openbmc_project.Software.Manager";
123 }
124 return "xyz.openbmc_project.Software.BMC.Updater";
125 }
126
getBMCUpdateServicePath()127 inline std::string getBMCUpdateServicePath()
128 {
129 if constexpr (BMCWEB_REDFISH_UPDATESERVICE_USE_DBUS)
130 {
131 return "/xyz/openbmc_project/software/bmc";
132 }
133 return "/xyz/openbmc_project/software";
134 }
135
136 /**
137 * Function reboots the BMC.
138 *
139 * @param[in] asyncResp - Shared pointer for completing asynchronous calls
140 */
doBMCGracefulRestart(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)141 inline void doBMCGracefulRestart(
142 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
143 {
144 const char* processName = "xyz.openbmc_project.State.BMC";
145 const char* objectPath = "/xyz/openbmc_project/state/bmc0";
146 const char* interfaceName = "xyz.openbmc_project.State.BMC";
147 const std::string& propertyValue =
148 "xyz.openbmc_project.State.BMC.Transition.Reboot";
149 const char* destProperty = "RequestedBMCTransition";
150
151 // Create the D-Bus variant for D-Bus call.
152 sdbusplus::asio::setProperty(
153 *crow::connections::systemBus, processName, objectPath, interfaceName,
154 destProperty, propertyValue,
155 [asyncResp](const boost::system::error_code& ec) {
156 // Use "Set" method to set the property value.
157 if (ec)
158 {
159 BMCWEB_LOG_DEBUG("[Set] Bad D-Bus request error: {}", ec);
160 messages::internalError(asyncResp->res);
161 return;
162 }
163
164 messages::success(asyncResp->res);
165 });
166 }
167
doBMCForceRestart(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)168 inline void doBMCForceRestart(
169 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
170 {
171 const char* processName = "xyz.openbmc_project.State.BMC";
172 const char* objectPath = "/xyz/openbmc_project/state/bmc0";
173 const char* interfaceName = "xyz.openbmc_project.State.BMC";
174 const std::string& propertyValue =
175 "xyz.openbmc_project.State.BMC.Transition.HardReboot";
176 const char* destProperty = "RequestedBMCTransition";
177
178 // Create the D-Bus variant for D-Bus call.
179 sdbusplus::asio::setProperty(
180 *crow::connections::systemBus, processName, objectPath, interfaceName,
181 destProperty, propertyValue,
182 [asyncResp](const boost::system::error_code& ec) {
183 // Use "Set" method to set the property value.
184 if (ec)
185 {
186 BMCWEB_LOG_DEBUG("[Set] Bad D-Bus request error: {}", ec);
187 messages::internalError(asyncResp->res);
188 return;
189 }
190
191 messages::success(asyncResp->res);
192 });
193 }
194
195 /**
196 * ManagerResetAction class supports the POST method for the Reset (reboot)
197 * action.
198 */
requestRoutesManagerResetAction(App & app)199 inline void requestRoutesManagerResetAction(App& app)
200 {
201 /**
202 * Function handles POST method request.
203 * Analyzes POST body before sending Reset (Reboot) request data to D-Bus.
204 * OpenBMC supports ResetType "GracefulRestart" and "ForceRestart".
205 */
206
207 BMCWEB_ROUTE(app, "/redfish/v1/Managers/<str>/Actions/Manager.Reset/")
208 .privileges(redfish::privileges::postManager)
209 .methods(boost::beast::http::verb::post)(
210 [&app](const crow::Request& req,
211 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
212 const std::string& managerId) {
213 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
214 {
215 return;
216 }
217 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
218 {
219 messages::resourceNotFound(asyncResp->res, "Manager",
220 managerId);
221 return;
222 }
223
224 BMCWEB_LOG_DEBUG("Post Manager Reset.");
225
226 std::string resetType;
227
228 if (!json_util::readJsonAction(req, asyncResp->res, "ResetType",
229 resetType))
230 {
231 return;
232 }
233
234 if (resetType == "GracefulRestart")
235 {
236 BMCWEB_LOG_DEBUG("Proceeding with {}", resetType);
237 doBMCGracefulRestart(asyncResp);
238 return;
239 }
240 if (resetType == "ForceRestart")
241 {
242 BMCWEB_LOG_DEBUG("Proceeding with {}", resetType);
243 doBMCForceRestart(asyncResp);
244 return;
245 }
246 BMCWEB_LOG_DEBUG("Invalid property value for ResetType: {}",
247 resetType);
248 messages::actionParameterNotSupported(asyncResp->res, resetType,
249 "ResetType");
250
251 return;
252 });
253 }
254
255 /**
256 * ManagerResetToDefaultsAction class supports POST method for factory reset
257 * action.
258 */
requestRoutesManagerResetToDefaultsAction(App & app)259 inline void requestRoutesManagerResetToDefaultsAction(App& app)
260 {
261 /**
262 * Function handles ResetToDefaults POST method request.
263 *
264 * Analyzes POST body message and factory resets BMC by calling
265 * BMC code updater factory reset followed by a BMC reboot.
266 *
267 * BMC code updater factory reset wipes the whole BMC read-write
268 * filesystem which includes things like the network settings.
269 *
270 * OpenBMC only supports ResetType "ResetAll".
271 */
272
273 BMCWEB_ROUTE(app,
274 "/redfish/v1/Managers/<str>/Actions/Manager.ResetToDefaults/")
275 .privileges(redfish::privileges::postManager)
276 .methods(boost::beast::http::verb::post)(
277 [&app](const crow::Request& req,
278 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
279 const std::string& managerId) {
280 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
281 {
282 return;
283 }
284
285 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
286 {
287 messages::resourceNotFound(asyncResp->res, "Manager",
288 managerId);
289 return;
290 }
291
292 BMCWEB_LOG_DEBUG("Post ResetToDefaults.");
293
294 std::optional<std::string> resetType;
295
296 if (!json_util::readJsonAction( //
297 req, asyncResp->res, //
298 "ResetType", resetType //
299 ))
300 {
301 BMCWEB_LOG_DEBUG("Missing property ResetType.");
302
303 messages::actionParameterMissing(
304 asyncResp->res, "ResetToDefaults", "ResetType");
305 return;
306 }
307
308 if (resetType != "ResetAll")
309 {
310 BMCWEB_LOG_DEBUG("Invalid property value for ResetType: {}",
311 *resetType);
312 messages::actionParameterNotSupported(
313 asyncResp->res, *resetType, "ResetType");
314 return;
315 }
316
317 crow::connections::systemBus->async_method_call(
318 [asyncResp](const boost::system::error_code& ec) {
319 if (ec)
320 {
321 BMCWEB_LOG_DEBUG("Failed to ResetToDefaults: {}",
322 ec);
323 messages::internalError(asyncResp->res);
324 return;
325 }
326 // Factory Reset doesn't actually happen until a reboot
327 // Can't erase what the BMC is running on
328 doBMCGracefulRestart(asyncResp);
329 },
330 getBMCUpdateServiceName(), getBMCUpdateServicePath(),
331 "xyz.openbmc_project.Common.FactoryReset", "Reset");
332 });
333 }
334
335 /**
336 * ManagerResetActionInfo derived class for delivering Manager
337 * ResetType AllowableValues using ResetInfo schema.
338 */
requestRoutesManagerResetActionInfo(App & app)339 inline void requestRoutesManagerResetActionInfo(App& app)
340 {
341 /**
342 * Functions triggers appropriate requests on DBus
343 */
344
345 BMCWEB_ROUTE(app, "/redfish/v1/Managers/<str>/ResetActionInfo/")
346 .privileges(redfish::privileges::getActionInfo)
347 .methods(boost::beast::http::verb::get)(
348 [&app](const crow::Request& req,
349 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
350 const std::string& managerId) {
351 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
352 {
353 return;
354 }
355
356 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
357 {
358 messages::resourceNotFound(asyncResp->res, "Manager",
359 managerId);
360 return;
361 }
362
363 asyncResp->res.jsonValue["@odata.type"] =
364 "#ActionInfo.v1_1_2.ActionInfo";
365 asyncResp->res.jsonValue["@odata.id"] = boost::urls::format(
366 "/redfish/v1/Managers/{}/ResetActionInfo",
367 BMCWEB_REDFISH_MANAGER_URI_NAME);
368 asyncResp->res.jsonValue["Name"] = "Reset Action Info";
369 asyncResp->res.jsonValue["Id"] = "ResetActionInfo";
370 nlohmann::json::object_t parameter;
371 parameter["Name"] = "ResetType";
372 parameter["Required"] = true;
373 parameter["DataType"] = action_info::ParameterTypes::String;
374
375 nlohmann::json::array_t allowableValues;
376 allowableValues.emplace_back("GracefulRestart");
377 allowableValues.emplace_back("ForceRestart");
378 parameter["AllowableValues"] = std::move(allowableValues);
379
380 nlohmann::json::array_t parameters;
381 parameters.emplace_back(std::move(parameter));
382
383 asyncResp->res.jsonValue["Parameters"] = std::move(parameters);
384 });
385 }
386
387 /**
388 * @brief Retrieves BMC manager location data over DBus
389 *
390 * @param[in] asyncResp Shared pointer for completing asynchronous calls
391 * @param[in] connectionName - service name
392 * @param[in] path - object path
393 * @return none
394 */
getLocation(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const std::string & connectionName,const std::string & path)395 inline void getLocation(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
396 const std::string& connectionName,
397 const std::string& path)
398 {
399 BMCWEB_LOG_DEBUG("Get BMC manager Location data.");
400
401 dbus::utility::getProperty<std::string>(
402 connectionName, path,
403 "xyz.openbmc_project.Inventory.Decorator.LocationCode", "LocationCode",
404 [asyncResp](const boost::system::error_code& ec,
405 const std::string& property) {
406 if (ec)
407 {
408 BMCWEB_LOG_DEBUG("DBUS response error for "
409 "Location");
410 messages::internalError(asyncResp->res);
411 return;
412 }
413
414 asyncResp->res
415 .jsonValue["Location"]["PartLocation"]["ServiceLabel"] =
416 property;
417 });
418 }
419 // avoid name collision systems.hpp
managerGetLastResetTime(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)420 inline void managerGetLastResetTime(
421 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
422 {
423 BMCWEB_LOG_DEBUG("Getting Manager Last Reset Time");
424
425 dbus::utility::getProperty<uint64_t>(
426 "xyz.openbmc_project.State.BMC", "/xyz/openbmc_project/state/bmc0",
427 "xyz.openbmc_project.State.BMC", "LastRebootTime",
428 [asyncResp](const boost::system::error_code& ec,
429 const uint64_t lastResetTime) {
430 if (ec)
431 {
432 BMCWEB_LOG_DEBUG("D-BUS response error {}", ec);
433 return;
434 }
435
436 // LastRebootTime is epoch time, in milliseconds
437 // https://github.com/openbmc/phosphor-dbus-interfaces/blob/7f9a128eb9296e926422ddc312c148b625890bb6/xyz/openbmc_project/State/BMC.interface.yaml#L19
438 uint64_t lastResetTimeStamp = lastResetTime / 1000;
439
440 // Convert to ISO 8601 standard
441 asyncResp->res.jsonValue["LastResetTime"] =
442 redfish::time_utils::getDateTimeUint(lastResetTimeStamp);
443 });
444 }
445
446 /**
447 * @brief Set the running firmware image
448 *
449 * @param[i,o] asyncResp - Async response object
450 * @param[i] runningFirmwareTarget - Image to make the running image
451 *
452 * @return void
453 */
setActiveFirmwareImage(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const std::string & runningFirmwareTarget)454 inline void setActiveFirmwareImage(
455 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
456 const std::string& runningFirmwareTarget)
457 {
458 // Get the Id from /redfish/v1/UpdateService/FirmwareInventory/<Id>
459 std::string::size_type idPos = runningFirmwareTarget.rfind('/');
460 if (idPos == std::string::npos)
461 {
462 messages::propertyValueNotInList(asyncResp->res, runningFirmwareTarget,
463 "@odata.id");
464 BMCWEB_LOG_DEBUG("Can't parse firmware ID!");
465 return;
466 }
467 idPos++;
468 if (idPos >= runningFirmwareTarget.size())
469 {
470 messages::propertyValueNotInList(asyncResp->res, runningFirmwareTarget,
471 "@odata.id");
472 BMCWEB_LOG_DEBUG("Invalid firmware ID.");
473 return;
474 }
475 std::string firmwareId = runningFirmwareTarget.substr(idPos);
476
477 // Make sure the image is valid before setting priority
478 sdbusplus::message::object_path objPath("/xyz/openbmc_project/software");
479 dbus::utility::getManagedObjects(
480 getBMCUpdateServiceName(), objPath,
481 [asyncResp, firmwareId, runningFirmwareTarget](
482 const boost::system::error_code& ec,
483 const dbus::utility::ManagedObjectType& subtree) {
484 if (ec)
485 {
486 BMCWEB_LOG_DEBUG("D-Bus response error getting objects.");
487 messages::internalError(asyncResp->res);
488 return;
489 }
490
491 if (subtree.empty())
492 {
493 BMCWEB_LOG_DEBUG("Can't find image!");
494 messages::internalError(asyncResp->res);
495 return;
496 }
497
498 bool foundImage = false;
499 for (const auto& object : subtree)
500 {
501 const std::string& path =
502 static_cast<const std::string&>(object.first);
503 std::size_t idPos2 = path.rfind('/');
504
505 if (idPos2 == std::string::npos)
506 {
507 continue;
508 }
509
510 idPos2++;
511 if (idPos2 >= path.size())
512 {
513 continue;
514 }
515
516 if (path.substr(idPos2) == firmwareId)
517 {
518 foundImage = true;
519 break;
520 }
521 }
522
523 if (!foundImage)
524 {
525 messages::propertyValueNotInList(
526 asyncResp->res, runningFirmwareTarget, "@odata.id");
527 BMCWEB_LOG_DEBUG("Invalid firmware ID.");
528 return;
529 }
530
531 BMCWEB_LOG_DEBUG("Setting firmware version {} to priority 0.",
532 firmwareId);
533
534 // Only support Immediate
535 // An addition could be a Redfish Setting like
536 // ActiveSoftwareImageApplyTime and support OnReset
537 sdbusplus::asio::setProperty(
538 *crow::connections::systemBus, getBMCUpdateServiceName(),
539 "/xyz/openbmc_project/software/" + firmwareId,
540 "xyz.openbmc_project.Software.RedundancyPriority", "Priority",
541 static_cast<uint8_t>(0),
542 [asyncResp](const boost::system::error_code& ec2) {
543 if (ec2)
544 {
545 BMCWEB_LOG_DEBUG("D-Bus response error setting.");
546 messages::internalError(asyncResp->res);
547 return;
548 }
549 doBMCGracefulRestart(asyncResp);
550 });
551 });
552 }
553
afterSetDateTime(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const boost::system::error_code & ec,const sdbusplus::message_t & msg)554 inline void afterSetDateTime(
555 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
556 const boost::system::error_code& ec, const sdbusplus::message_t& msg)
557 {
558 if (ec)
559 {
560 BMCWEB_LOG_DEBUG("Failed to set elapsed time. DBUS response error {}",
561 ec);
562 const sd_bus_error* dbusError = msg.get_error();
563 if (dbusError != nullptr)
564 {
565 std::string_view errorName(dbusError->name);
566 if (errorName ==
567 "org.freedesktop.timedate1.AutomaticTimeSyncEnabled")
568 {
569 BMCWEB_LOG_DEBUG("Setting conflict");
570 messages::propertyValueConflict(
571 asyncResp->res, "DateTime",
572 "Managers/NetworkProtocol/NTPProcotolEnabled");
573 return;
574 }
575 }
576 messages::internalError(asyncResp->res);
577 return;
578 }
579 asyncResp->res.result(boost::beast::http::status::no_content);
580 }
581
setDateTime(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const std::string & datetime)582 inline void setDateTime(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
583 const std::string& datetime)
584 {
585 BMCWEB_LOG_DEBUG("Set date time: {}", datetime);
586
587 std::optional<redfish::time_utils::usSinceEpoch> us =
588 redfish::time_utils::dateStringToEpoch(datetime);
589 if (!us)
590 {
591 messages::propertyValueFormatError(asyncResp->res, datetime,
592 "DateTime");
593 return;
594 }
595 // Set the absolute datetime
596 bool relative = false;
597 bool interactive = false;
598 crow::connections::systemBus->async_method_call(
599 [asyncResp](const boost::system::error_code& ec,
600 const sdbusplus::message_t& msg) {
601 afterSetDateTime(asyncResp, ec, msg);
602 },
603 "org.freedesktop.timedate1", "/org/freedesktop/timedate1",
604 "org.freedesktop.timedate1", "SetTime", us->count(), relative,
605 interactive);
606 }
607
checkForQuiesced(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp)608 inline void checkForQuiesced(
609 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
610 {
611 dbus::utility::getProperty<std::string>(
612 "org.freedesktop.systemd1",
613 "/org/freedesktop/systemd1/unit/obmc-bmc-service-quiesce@0.target",
614 "org.freedesktop.systemd1.Unit", "ActiveState",
615 [asyncResp](const boost::system::error_code& ec,
616 const std::string& val) {
617 if (!ec)
618 {
619 if (val == "active")
620 {
621 asyncResp->res.jsonValue["Status"]["Health"] =
622 resource::Health::Critical;
623 asyncResp->res.jsonValue["Status"]["State"] =
624 resource::State::Quiesced;
625 return;
626 }
627 }
628 asyncResp->res.jsonValue["Status"]["Health"] = resource::Health::OK;
629 asyncResp->res.jsonValue["Status"]["State"] =
630 resource::State::Enabled;
631 });
632 }
633
getPhysicalAssets(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const boost::system::error_code & ec,const dbus::utility::DBusPropertiesMap & propertiesList)634 inline void getPhysicalAssets(
635 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
636 const boost::system::error_code& ec,
637 const dbus::utility::DBusPropertiesMap& propertiesList)
638 {
639 if (ec)
640 {
641 BMCWEB_LOG_DEBUG("Can't get bmc asset!");
642 return;
643 }
644
645 const std::string* partNumber = nullptr;
646 const std::string* serialNumber = nullptr;
647 const std::string* manufacturer = nullptr;
648 const std::string* model = nullptr;
649 const std::string* sparePartNumber = nullptr;
650
651 const bool success = sdbusplus::unpackPropertiesNoThrow(
652 dbus_utils::UnpackErrorPrinter(), propertiesList, "PartNumber",
653 partNumber, "SerialNumber", serialNumber, "Manufacturer", manufacturer,
654 "Model", model, "SparePartNumber", sparePartNumber);
655
656 if (!success)
657 {
658 messages::internalError(asyncResp->res);
659 return;
660 }
661
662 if (partNumber != nullptr)
663 {
664 asyncResp->res.jsonValue["PartNumber"] = *partNumber;
665 }
666
667 if (serialNumber != nullptr)
668 {
669 asyncResp->res.jsonValue["SerialNumber"] = *serialNumber;
670 }
671
672 if (manufacturer != nullptr)
673 {
674 asyncResp->res.jsonValue["Manufacturer"] = *manufacturer;
675 }
676
677 if (model != nullptr)
678 {
679 asyncResp->res.jsonValue["Model"] = *model;
680 }
681
682 if (sparePartNumber != nullptr)
683 {
684 asyncResp->res.jsonValue["SparePartNumber"] = *sparePartNumber;
685 }
686 }
687
getManagerData(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const std::string & managerPath,const dbus::utility::MapperServiceMap & serviceMap)688 inline void getManagerData(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
689 const std::string& managerPath,
690 const dbus::utility::MapperServiceMap& serviceMap)
691 {
692 if (managerPath.empty() || serviceMap.size() != 1)
693 {
694 BMCWEB_LOG_DEBUG("Error getting bmc D-Bus object!");
695 messages::internalError(asyncResp->res);
696 return;
697 }
698
699 for (const auto& [connectionName, interfaces] : serviceMap)
700 {
701 for (const auto& interfaceName : interfaces)
702 {
703 if (interfaceName ==
704 "xyz.openbmc_project.Inventory.Decorator.Asset")
705 {
706 dbus::utility::getAllProperties(
707 *crow::connections::systemBus, connectionName, managerPath,
708 "xyz.openbmc_project.Inventory.Decorator.Asset",
709 std::bind_front(getPhysicalAssets, asyncResp));
710 }
711 else if (interfaceName ==
712 "xyz.openbmc_project.Inventory.Decorator.LocationCode")
713 {
714 getLocation(asyncResp, connectionName, managerPath);
715 }
716 else if (interfaceName ==
717 "xyz.openbmc_project.Association.Definitions")
718 {
719 getLocationIndicatorActive(asyncResp, managerPath);
720 }
721 }
722 }
723 }
724
afterGetManagerObject(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const boost::system::error_code & ec,const dbus::utility::MapperGetSubTreeResponse & subtree,const std::function<void (const std::string & managerPath,const dbus::utility::MapperServiceMap & serviceMap)> & callback)725 inline void afterGetManagerObject(
726 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
727 const boost::system::error_code& ec,
728 const dbus::utility::MapperGetSubTreeResponse& subtree,
729 const std::function<
730 void(const std::string& managerPath,
731 const dbus::utility::MapperServiceMap& serviceMap)>& callback)
732 {
733 if (ec)
734 {
735 BMCWEB_LOG_DEBUG("D-Bus response error on GetSubTree {}", ec);
736 return;
737 }
738 if (subtree.empty())
739 {
740 BMCWEB_LOG_DEBUG("Can't find bmc D-Bus object!");
741 return;
742 }
743 // Assume only 1 bmc D-Bus object
744 // Throw an error if there is more than 1
745 if (subtree.size() > 1)
746 {
747 BMCWEB_LOG_ERROR("Found more than 1 bmc D-Bus object!");
748 messages::internalError(asyncResp->res);
749 return;
750 }
751
752 callback(subtree[0].first, subtree[0].second);
753 }
754
getManagerObject(const std::shared_ptr<bmcweb::AsyncResp> & asyncResp,const std::string &,std::function<void (const std::string & managerPath,const dbus::utility::MapperServiceMap & serviceMap)> && callback)755 inline void getManagerObject(
756 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
757 const std::string& /* managerId */,
758 std::function<void(const std::string& managerPath,
759 const dbus::utility::MapperServiceMap& serviceMap)>&&
760 callback)
761 {
762 constexpr std::array<std::string_view, 1> interfaces = {
763 "xyz.openbmc_project.Inventory.Item.Bmc"};
764 dbus::utility::getSubTree(
765 "/xyz/openbmc_project/inventory", 0, interfaces,
766 [asyncResp, callback{std::move(callback)}](
767 const boost::system::error_code& ec,
768 const dbus::utility::MapperGetSubTreeResponse& subtree) {
769 afterGetManagerObject(asyncResp, ec, subtree, callback);
770 });
771 }
772
requestRoutesManager(App & app)773 inline void requestRoutesManager(App& app)
774 {
775 std::string uuid = persistent_data::getConfig().systemUuid;
776
777 BMCWEB_ROUTE(app, "/redfish/v1/Managers/<str>/")
778 .privileges(redfish::privileges::getManager)
779 .methods(
780 boost::beast::http::verb::
781 get)([&app,
782 uuid](const crow::Request& req,
783 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
784 const std::string& managerId) {
785 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
786 {
787 return;
788 }
789
790 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
791 {
792 messages::resourceNotFound(asyncResp->res, "Manager",
793 managerId);
794 return;
795 }
796
797 asyncResp->res.jsonValue["@odata.id"] = boost::urls::format(
798 "/redfish/v1/Managers/{}", BMCWEB_REDFISH_MANAGER_URI_NAME);
799 asyncResp->res.jsonValue["@odata.type"] =
800 "#Manager.v1_15_0.Manager";
801 asyncResp->res.jsonValue["Id"] = BMCWEB_REDFISH_MANAGER_URI_NAME;
802 asyncResp->res.jsonValue["Name"] = "OpenBmc Manager";
803 asyncResp->res.jsonValue["Description"] =
804 "Baseboard Management Controller";
805 asyncResp->res.jsonValue["PowerState"] = resource::PowerState::On;
806
807 asyncResp->res.jsonValue["ManagerType"] = manager::ManagerType::BMC;
808 asyncResp->res.jsonValue["UUID"] = systemd_utils::getUuid();
809 asyncResp->res.jsonValue["ServiceEntryPointUUID"] = uuid;
810 asyncResp->res.jsonValue["Model"] =
811 "OpenBmc"; // TODO(ed), get model
812
813 asyncResp->res.jsonValue["LogServices"]["@odata.id"] =
814 boost::urls::format("/redfish/v1/Managers/{}/LogServices",
815 BMCWEB_REDFISH_MANAGER_URI_NAME);
816 asyncResp->res.jsonValue["NetworkProtocol"]["@odata.id"] =
817 boost::urls::format("/redfish/v1/Managers/{}/NetworkProtocol",
818 BMCWEB_REDFISH_MANAGER_URI_NAME);
819 asyncResp->res.jsonValue["EthernetInterfaces"]["@odata.id"] =
820 boost::urls::format(
821 "/redfish/v1/Managers/{}/EthernetInterfaces",
822 BMCWEB_REDFISH_MANAGER_URI_NAME);
823
824 manager_utils::getServiceIdentification(asyncResp, false);
825
826 if constexpr (BMCWEB_VM_NBDPROXY)
827 {
828 asyncResp->res.jsonValue["VirtualMedia"]["@odata.id"] =
829 boost::urls::format("/redfish/v1/Managers/{}/VirtualMedia",
830 BMCWEB_REDFISH_MANAGER_URI_NAME);
831 }
832
833 // Manager.Reset (an action) can be many values, OpenBMC only
834 // supports BMC reboot.
835 nlohmann::json& managerReset =
836 asyncResp->res.jsonValue["Actions"]["#Manager.Reset"];
837 managerReset["target"] = boost::urls::format(
838 "/redfish/v1/Managers/{}/Actions/Manager.Reset",
839 BMCWEB_REDFISH_MANAGER_URI_NAME);
840 managerReset["@Redfish.ActionInfo"] =
841 boost::urls::format("/redfish/v1/Managers/{}/ResetActionInfo",
842 BMCWEB_REDFISH_MANAGER_URI_NAME);
843
844 // ResetToDefaults (Factory Reset) has values like
845 // PreserveNetworkAndUsers and PreserveNetwork that aren't supported
846 // on OpenBMC
847 nlohmann::json& resetToDefaults =
848 asyncResp->res.jsonValue["Actions"]["#Manager.ResetToDefaults"];
849 resetToDefaults["target"] = boost::urls::format(
850 "/redfish/v1/Managers/{}/Actions/Manager.ResetToDefaults",
851 BMCWEB_REDFISH_MANAGER_URI_NAME);
852 resetToDefaults["ResetType@Redfish.AllowableValues"] =
853 nlohmann::json::array_t({"ResetAll"});
854
855 std::pair<std::string, std::string> redfishDateTimeOffset =
856 redfish::time_utils::getDateTimeOffsetNow();
857
858 asyncResp->res.jsonValue["DateTime"] = redfishDateTimeOffset.first;
859 asyncResp->res.jsonValue["DateTimeLocalOffset"] =
860 redfishDateTimeOffset.second;
861
862 if constexpr (BMCWEB_KVM)
863 {
864 // Fill in GraphicalConsole info
865 asyncResp->res.jsonValue["GraphicalConsole"]["ServiceEnabled"] =
866 true;
867 asyncResp->res
868 .jsonValue["GraphicalConsole"]["MaxConcurrentSessions"] = 4;
869 asyncResp->res
870 .jsonValue["GraphicalConsole"]["ConnectTypesSupported"] =
871 nlohmann::json::array_t({"KVMIP"});
872 }
873 if constexpr (!BMCWEB_EXPERIMENTAL_REDFISH_MULTI_COMPUTER_SYSTEM)
874 {
875 asyncResp->res
876 .jsonValue["Links"]["ManagerForServers@odata.count"] = 1;
877
878 nlohmann::json::array_t managerForServers;
879 nlohmann::json::object_t manager;
880 manager["@odata.id"] = std::format(
881 "/redfish/v1/Systems/{}", BMCWEB_REDFISH_SYSTEM_URI_NAME);
882 managerForServers.emplace_back(std::move(manager));
883
884 asyncResp->res.jsonValue["Links"]["ManagerForServers"] =
885 std::move(managerForServers);
886 }
887
888 sw_util::populateSoftwareInformation(asyncResp, sw_util::bmcPurpose,
889 "FirmwareVersion", true);
890
891 managerGetLastResetTime(asyncResp);
892
893 // ManagerDiagnosticData is added for all BMCs.
894 nlohmann::json& managerDiagnosticData =
895 asyncResp->res.jsonValue["ManagerDiagnosticData"];
896 managerDiagnosticData["@odata.id"] = boost::urls::format(
897 "/redfish/v1/Managers/{}/ManagerDiagnosticData",
898 BMCWEB_REDFISH_MANAGER_URI_NAME);
899
900 getMainChassisId(asyncResp, [](const std::string& chassisId,
901 const std::shared_ptr<
902 bmcweb::AsyncResp>& aRsp) {
903 aRsp->res.jsonValue["Links"]["ManagerForChassis@odata.count"] =
904 1;
905 nlohmann::json::array_t managerForChassis;
906 nlohmann::json::object_t managerObj;
907 boost::urls::url chassiUrl =
908 boost::urls::format("/redfish/v1/Chassis/{}", chassisId);
909 managerObj["@odata.id"] = chassiUrl;
910 managerForChassis.emplace_back(std::move(managerObj));
911 aRsp->res.jsonValue["Links"]["ManagerForChassis"] =
912 std::move(managerForChassis);
913 aRsp->res.jsonValue["Links"]["ManagerInChassis"]["@odata.id"] =
914 chassiUrl;
915 });
916
917 dbus::utility::getProperty<double>(
918 "org.freedesktop.systemd1", "/org/freedesktop/systemd1",
919 "org.freedesktop.systemd1.Manager", "Progress",
920 [asyncResp](const boost::system::error_code& ec, double val) {
921 if (ec)
922 {
923 BMCWEB_LOG_ERROR("Error while getting progress");
924 messages::internalError(asyncResp->res);
925 return;
926 }
927 if (val < 1.0)
928 {
929 asyncResp->res.jsonValue["Status"]["Health"] =
930 resource::Health::OK;
931 asyncResp->res.jsonValue["Status"]["State"] =
932 resource::State::Starting;
933 return;
934 }
935 checkForQuiesced(asyncResp);
936 });
937
938 getManagerObject(asyncResp, managerId,
939 std::bind_front(getManagerData, asyncResp));
940
941 RedfishService::getInstance(app).handleSubRoute(req, asyncResp);
942 });
943
944 BMCWEB_ROUTE(app, "/redfish/v1/Managers/<str>/")
945 .privileges(redfish::privileges::patchManager)
946 .methods(boost::beast::http::verb::patch)(
947 [&app](const crow::Request& req,
948 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
949 const std::string& managerId) {
950 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
951 {
952 return;
953 }
954
955 if (managerId != BMCWEB_REDFISH_MANAGER_URI_NAME)
956 {
957 messages::resourceNotFound(asyncResp->res, "Manager",
958 managerId);
959 return;
960 }
961
962 std::optional<std::string> activeSoftwareImageOdataId;
963 std::optional<std::string> datetime;
964 std::optional<bool> locationIndicatorActive;
965 std::optional<nlohmann::json::object_t> pidControllers;
966 std::optional<nlohmann::json::object_t> fanControllers;
967 std::optional<nlohmann::json::object_t> fanZones;
968 std::optional<nlohmann::json::object_t> stepwiseControllers;
969 std::optional<std::string> profile;
970 std::optional<std::string> serviceIdentification;
971
972 if (!json_util::readJsonPatch( //
973 req, asyncResp->res, //
974 "DateTime", datetime, //
975 "Links/ActiveSoftwareImage/@odata.id",
976 activeSoftwareImageOdataId, //
977 "LocationIndicatorActive",
978 locationIndicatorActive, //
979 "Oem/OpenBmc/Fan/FanControllers", fanControllers, //
980 "Oem/OpenBmc/Fan/FanZones", fanZones, //
981 "Oem/OpenBmc/Fan/PidControllers", pidControllers, //
982 "Oem/OpenBmc/Fan/Profile", profile, //
983 "Oem/OpenBmc/Fan/StepwiseControllers",
984 stepwiseControllers, //
985 "ServiceIdentification", serviceIdentification //
986 ))
987 {
988 return;
989 }
990
991 if (activeSoftwareImageOdataId)
992 {
993 setActiveFirmwareImage(asyncResp,
994 *activeSoftwareImageOdataId);
995 }
996
997 if (datetime)
998 {
999 setDateTime(asyncResp, *datetime);
1000 }
1001
1002 if (locationIndicatorActive)
1003 {
1004 setLocationIndicatorActiveState(
1005 asyncResp, *locationIndicatorActive, managerId);
1006 }
1007
1008 if (serviceIdentification)
1009 {
1010 manager_utils::setServiceIdentification(
1011 asyncResp, serviceIdentification.value());
1012 }
1013
1014 RedfishService::getInstance(app).handleSubRoute(req, asyncResp);
1015 });
1016 }
1017
requestRoutesManagerCollection(App & app)1018 inline void requestRoutesManagerCollection(App& app)
1019 {
1020 BMCWEB_ROUTE(app, "/redfish/v1/Managers/")
1021 .privileges(redfish::privileges::getManagerCollection)
1022 .methods(boost::beast::http::verb::get)(
1023 [&app](const crow::Request& req,
1024 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) {
1025 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
1026 {
1027 return;
1028 }
1029 // Collections don't include the static data added by SubRoute
1030 // because it has a duplicate entry for members
1031 asyncResp->res.jsonValue["@odata.id"] = "/redfish/v1/Managers";
1032 asyncResp->res.jsonValue["@odata.type"] =
1033 "#ManagerCollection.ManagerCollection";
1034 asyncResp->res.jsonValue["Name"] = "Manager Collection";
1035 asyncResp->res.jsonValue["Members@odata.count"] = 1;
1036 nlohmann::json::array_t members;
1037 nlohmann::json& bmc = members.emplace_back();
1038 bmc["@odata.id"] = boost::urls::format(
1039 "/redfish/v1/Managers/{}", BMCWEB_REDFISH_MANAGER_URI_NAME);
1040 asyncResp->res.jsonValue["Members"] = std::move(members);
1041 });
1042 }
1043 } // namespace redfish
1044