blob: 3f74ca52b81863d06aa60a0e0c9fd519fc50fe23 [file] [log] [blame]
Lewanczyk, Dawidc5b2abe2018-05-30 16:59:42 +02001/*
2// Copyright (c) 2018 Intel Corporation
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8// http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15*/
16#pragma once
17
James Feistb49ac872019-05-21 15:12:01 -070018#include "health.hpp"
James Feist1c8fba92019-12-20 15:12:07 -080019#include "led.hpp"
Jason M. Billsf5c9f8b2018-12-18 16:51:18 -080020#include "pcie.hpp"
Jennifer Leec5d03ff2019-03-08 15:42:58 -080021#include "redfish_util.hpp"
22
Ed Tanous9712f8a2018-09-21 13:38:49 -070023#include <boost/container/flat_map.hpp>
24#include <node.hpp>
Andrew Geisslercb7e1e72019-02-19 13:05:38 -060025#include <utils/fw_utils.hpp>
Lewanczyk, Dawidc5b2abe2018-05-30 16:59:42 +020026#include <utils/json_utils.hpp>
Gunnar Mills1214b7e2020-06-04 10:11:30 -050027
Ed Tanousabf2add2019-01-22 16:40:12 -080028#include <variant>
Lewanczyk, Dawidc5b2abe2018-05-30 16:59:42 +020029
Ed Tanous1abe55e2018-09-05 08:30:59 -070030namespace redfish
31{
Lewanczyk, Dawidc5b2abe2018-05-30 16:59:42 +020032
Alpana Kumari9d3ae102019-04-12 06:49:32 -050033/**
34 * @brief Updates the Functional State of DIMMs
35 *
36 * @param[in] aResp Shared pointer for completing asynchronous calls
37 * @param[in] dimmState Dimm's Functional state, true/false
38 *
39 * @return None.
40 */
Ed Tanous23a21a12020-07-25 04:45:05 +000041inline void updateDimmProperties(std::shared_ptr<AsyncResp> aResp,
42 const std::variant<bool>& dimmState)
Alpana Kumari9d3ae102019-04-12 06:49:32 -050043{
Gunnar Mills1214b7e2020-06-04 10:11:30 -050044 const bool* isDimmFunctional = std::get_if<bool>(&dimmState);
Alpana Kumari9d3ae102019-04-12 06:49:32 -050045 if (isDimmFunctional == nullptr)
46 {
47 messages::internalError(aResp->res);
48 return;
49 }
Gunnar Mills698654b2019-10-16 13:17:37 -050050 BMCWEB_LOG_DEBUG << "Dimm Functional: " << *isDimmFunctional;
Alpana Kumari9d3ae102019-04-12 06:49:32 -050051
Gunnar Mills4e0453b2020-07-08 14:00:30 -050052 // Set it as Enabled if at least one DIMM is functional
Alpana Kumari9d3ae102019-04-12 06:49:32 -050053 // Update STATE only if previous State was DISABLED and current Dimm is
54 // ENABLED.
Gunnar Mills1214b7e2020-06-04 10:11:30 -050055 nlohmann::json& prevMemSummary =
Alpana Kumari9d3ae102019-04-12 06:49:32 -050056 aResp->res.jsonValue["MemorySummary"]["Status"]["State"];
57 if (prevMemSummary == "Disabled")
58 {
59 if (*isDimmFunctional == true)
60 {
61 aResp->res.jsonValue["MemorySummary"]["Status"]["State"] =
62 "Enabled";
63 }
64 }
65}
66
Alpana Kumari57e8c9b2019-04-15 01:09:36 -050067/*
68 * @brief Update "ProcessorSummary" "Count" based on Cpu PresenceState
69 *
70 * @param[in] aResp Shared pointer for completing asynchronous calls
71 * @param[in] cpuPresenceState CPU present or not
72 *
73 * @return None.
74 */
Ed Tanous23a21a12020-07-25 04:45:05 +000075inline void modifyCpuPresenceState(std::shared_ptr<AsyncResp> aResp,
76 const std::variant<bool>& cpuPresenceState)
Alpana Kumari57e8c9b2019-04-15 01:09:36 -050077{
Gunnar Mills1214b7e2020-06-04 10:11:30 -050078 const bool* isCpuPresent = std::get_if<bool>(&cpuPresenceState);
Alpana Kumari57e8c9b2019-04-15 01:09:36 -050079
80 if (isCpuPresent == nullptr)
81 {
82 messages::internalError(aResp->res);
83 return;
84 }
Gunnar Mills698654b2019-10-16 13:17:37 -050085 BMCWEB_LOG_DEBUG << "Cpu Present: " << *isCpuPresent;
Alpana Kumari57e8c9b2019-04-15 01:09:36 -050086
Alpana Kumari57e8c9b2019-04-15 01:09:36 -050087 if (*isCpuPresent == true)
88 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -050089 nlohmann::json& procCount =
James Feistb4b95952019-12-05 15:01:55 -080090 aResp->res.jsonValue["ProcessorSummary"]["Count"];
91 auto procCountPtr =
Gunnar Mills1214b7e2020-06-04 10:11:30 -050092 procCount.get_ptr<nlohmann::json::number_integer_t*>();
James Feistb4b95952019-12-05 15:01:55 -080093 if (procCountPtr != nullptr)
94 {
95 // shouldn't be possible to be nullptr
96 *procCountPtr += 1;
97 }
Alpana Kumari57e8c9b2019-04-15 01:09:36 -050098 }
Alpana Kumari57e8c9b2019-04-15 01:09:36 -050099}
100
101/*
102 * @brief Update "ProcessorSummary" "Status" "State" based on
103 * CPU Functional State
104 *
105 * @param[in] aResp Shared pointer for completing asynchronous calls
106 * @param[in] cpuFunctionalState is CPU functional true/false
107 *
108 * @return None.
109 */
Ed Tanous23a21a12020-07-25 04:45:05 +0000110inline void
111 modifyCpuFunctionalState(std::shared_ptr<AsyncResp> aResp,
112 const std::variant<bool>& cpuFunctionalState)
Alpana Kumari57e8c9b2019-04-15 01:09:36 -0500113{
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500114 const bool* isCpuFunctional = std::get_if<bool>(&cpuFunctionalState);
Alpana Kumari57e8c9b2019-04-15 01:09:36 -0500115
116 if (isCpuFunctional == nullptr)
117 {
118 messages::internalError(aResp->res);
119 return;
120 }
Gunnar Mills698654b2019-10-16 13:17:37 -0500121 BMCWEB_LOG_DEBUG << "Cpu Functional: " << *isCpuFunctional;
Alpana Kumari57e8c9b2019-04-15 01:09:36 -0500122
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500123 nlohmann::json& prevProcState =
Alpana Kumari57e8c9b2019-04-15 01:09:36 -0500124 aResp->res.jsonValue["ProcessorSummary"]["Status"]["State"];
125
Gunnar Mills4e0453b2020-07-08 14:00:30 -0500126 // Set it as Enabled if at least one CPU is functional
Alpana Kumari57e8c9b2019-04-15 01:09:36 -0500127 // Update STATE only if previous State was Non_Functional and current CPU is
128 // Functional.
129 if (prevProcState == "Disabled")
130 {
131 if (*isCpuFunctional == true)
132 {
133 aResp->res.jsonValue["ProcessorSummary"]["Status"]["State"] =
134 "Enabled";
135 }
136 }
137}
138
139/*
Ed Tanous6c34de42018-08-29 13:37:36 -0700140 * @brief Retrieves computer system properties over dbus
141 *
142 * @param[in] aResp Shared pointer for completing asynchronous calls
143 * @param[in] name Computer system name from request
144 *
145 * @return None.
146 */
Ed Tanous23a21a12020-07-25 04:45:05 +0000147inline void getComputerSystem(std::shared_ptr<AsyncResp> aResp,
148 std::shared_ptr<HealthPopulate> systemHealth)
Ed Tanous6c34de42018-08-29 13:37:36 -0700149{
Ed Tanous6c34de42018-08-29 13:37:36 -0700150 BMCWEB_LOG_DEBUG << "Get available system components.";
Alpana Kumari9d3ae102019-04-12 06:49:32 -0500151
Ed Tanous6c34de42018-08-29 13:37:36 -0700152 crow::connections::systemBus->async_method_call(
James Feist5bc2dc82019-10-22 14:33:16 -0700153 [aResp, systemHealth](
Ed Tanous6c34de42018-08-29 13:37:36 -0700154 const boost::system::error_code ec,
155 const std::vector<std::pair<
156 std::string,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500157 std::vector<std::pair<std::string, std::vector<std::string>>>>>&
158 subtree) {
Ed Tanous6c34de42018-08-29 13:37:36 -0700159 if (ec)
160 {
161 BMCWEB_LOG_DEBUG << "DBUS response error";
Jason M. Billsf12894f2018-10-09 12:45:45 -0700162 messages::internalError(aResp->res);
Ed Tanous6c34de42018-08-29 13:37:36 -0700163 return;
164 }
Ed Tanous6c34de42018-08-29 13:37:36 -0700165 // Iterate over all retrieved ObjectPaths.
166 for (const std::pair<std::string,
167 std::vector<std::pair<
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500168 std::string, std::vector<std::string>>>>&
169 object : subtree)
Ed Tanous6c34de42018-08-29 13:37:36 -0700170 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500171 const std::string& path = object.first;
Ed Tanous6c34de42018-08-29 13:37:36 -0700172 BMCWEB_LOG_DEBUG << "Got path: " << path;
173 const std::vector<
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500174 std::pair<std::string, std::vector<std::string>>>&
175 connectionNames = object.second;
Ed Tanous6c34de42018-08-29 13:37:36 -0700176 if (connectionNames.size() < 1)
177 {
178 continue;
179 }
Ed Tanous029573d2019-02-01 10:57:49 -0800180
James Feist5bc2dc82019-10-22 14:33:16 -0700181 auto memoryHealth = std::make_shared<HealthPopulate>(
182 aResp, aResp->res.jsonValue["MemorySummary"]["Status"]);
183
184 auto cpuHealth = std::make_shared<HealthPopulate>(
185 aResp, aResp->res.jsonValue["ProcessorSummary"]["Status"]);
186
187 systemHealth->children.emplace_back(memoryHealth);
188 systemHealth->children.emplace_back(cpuHealth);
189
Ed Tanous029573d2019-02-01 10:57:49 -0800190 // This is not system, so check if it's cpu, dimm, UUID or
191 // BiosVer
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500192 for (const auto& connection : connectionNames)
Ed Tanous6c34de42018-08-29 13:37:36 -0700193 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500194 for (const auto& interfaceName : connection.second)
Ed Tanous6c34de42018-08-29 13:37:36 -0700195 {
Ed Tanous029573d2019-02-01 10:57:49 -0800196 if (interfaceName ==
197 "xyz.openbmc_project.Inventory.Item.Dimm")
Ed Tanous6c34de42018-08-29 13:37:36 -0700198 {
Ed Tanous029573d2019-02-01 10:57:49 -0800199 BMCWEB_LOG_DEBUG
200 << "Found Dimm, now get its properties.";
Alpana Kumari9d3ae102019-04-12 06:49:32 -0500201
Ed Tanous029573d2019-02-01 10:57:49 -0800202 crow::connections::systemBus->async_method_call(
Alpana Kumari9d3ae102019-04-12 06:49:32 -0500203 [aResp, service{connection.first},
204 path(std::move(path))](
Ed Tanouscb13a392020-07-25 19:02:03 +0000205 const boost::system::error_code ec2,
Alpana Kumari9d3ae102019-04-12 06:49:32 -0500206 const std::vector<
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500207 std::pair<std::string, VariantType>>&
208 properties) {
Ed Tanouscb13a392020-07-25 19:02:03 +0000209 if (ec2)
Ed Tanous029573d2019-02-01 10:57:49 -0800210 {
211 BMCWEB_LOG_ERROR
Ed Tanouscb13a392020-07-25 19:02:03 +0000212 << "DBUS response error " << ec2;
Ed Tanous029573d2019-02-01 10:57:49 -0800213 messages::internalError(aResp->res);
214 return;
215 }
216 BMCWEB_LOG_DEBUG << "Got "
217 << properties.size()
Gunnar Mills698654b2019-10-16 13:17:37 -0500218 << " Dimm properties.";
Alpana Kumari9d3ae102019-04-12 06:49:32 -0500219
220 if (properties.size() > 0)
Ed Tanous029573d2019-02-01 10:57:49 -0800221 {
Alpana Kumari9d3ae102019-04-12 06:49:32 -0500222 for (const std::pair<std::string,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500223 VariantType>&
224 property : properties)
Ed Tanous6c34de42018-08-29 13:37:36 -0700225 {
Cheng C Yang5fd7ba62019-11-28 15:58:08 +0800226 if (property.first !=
227 "MemorySizeInKB")
Ed Tanous6c34de42018-08-29 13:37:36 -0700228 {
Cheng C Yang5fd7ba62019-11-28 15:58:08 +0800229 continue;
Ed Tanous6c34de42018-08-29 13:37:36 -0700230 }
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500231 const uint32_t* value =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500232 std::get_if<uint32_t>(
233 &property.second);
Cheng C Yang5fd7ba62019-11-28 15:58:08 +0800234 if (value == nullptr)
235 {
236 BMCWEB_LOG_DEBUG
237 << "Find incorrect type of "
238 "MemorySize";
239 continue;
240 }
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500241 nlohmann::json& totalMemory =
Cheng C Yang5fd7ba62019-11-28 15:58:08 +0800242 aResp->res
243 .jsonValue["MemorySummar"
244 "y"]
245 ["TotalSystemMe"
246 "moryGiB"];
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500247 uint64_t* preValue =
Cheng C Yang5fd7ba62019-11-28 15:58:08 +0800248 totalMemory
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500249 .get_ptr<uint64_t*>();
Cheng C Yang5fd7ba62019-11-28 15:58:08 +0800250 if (preValue == nullptr)
251 {
252 continue;
253 }
254 aResp->res
255 .jsonValue["MemorySummary"]
256 ["TotalSystemMemoryGi"
257 "B"] =
258 *value / (1024 * 1024) +
259 *preValue;
260 aResp->res
261 .jsonValue["MemorySummary"]
262 ["Status"]["State"] =
263 "Enabled";
Ed Tanous6c34de42018-08-29 13:37:36 -0700264 }
Ed Tanous029573d2019-02-01 10:57:49 -0800265 }
Alpana Kumari9d3ae102019-04-12 06:49:32 -0500266 else
267 {
268 auto getDimmProperties =
269 [aResp](
270 const boost::system::error_code
Ed Tanouscb13a392020-07-25 19:02:03 +0000271 ec3,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500272 const std::variant<bool>&
273 dimmState) {
Ed Tanouscb13a392020-07-25 19:02:03 +0000274 if (ec3)
Alpana Kumari9d3ae102019-04-12 06:49:32 -0500275 {
276 BMCWEB_LOG_ERROR
277 << "DBUS response "
278 "error "
Ed Tanouscb13a392020-07-25 19:02:03 +0000279 << ec3;
Alpana Kumari9d3ae102019-04-12 06:49:32 -0500280 return;
281 }
282 updateDimmProperties(aResp,
283 dimmState);
284 };
285 crow::connections::systemBus
286 ->async_method_call(
287 std::move(getDimmProperties),
288 service, path,
289 "org.freedesktop.DBus."
290 "Properties",
291 "Get",
292 "xyz.openbmc_project.State."
293 "Decorator.OperationalStatus",
294 "Functional");
295 }
Ed Tanous029573d2019-02-01 10:57:49 -0800296 },
297 connection.first, path,
298 "org.freedesktop.DBus.Properties", "GetAll",
299 "xyz.openbmc_project.Inventory.Item.Dimm");
James Feist5bc2dc82019-10-22 14:33:16 -0700300
301 memoryHealth->inventory.emplace_back(path);
Ed Tanous029573d2019-02-01 10:57:49 -0800302 }
303 else if (interfaceName ==
304 "xyz.openbmc_project.Inventory.Item.Cpu")
305 {
306 BMCWEB_LOG_DEBUG
307 << "Found Cpu, now get its properties.";
Alpana Kumari57e8c9b2019-04-15 01:09:36 -0500308
Ed Tanous029573d2019-02-01 10:57:49 -0800309 crow::connections::systemBus->async_method_call(
Alpana Kumari57e8c9b2019-04-15 01:09:36 -0500310 [aResp, service{connection.first},
311 path(std::move(path))](
Ed Tanouscb13a392020-07-25 19:02:03 +0000312 const boost::system::error_code ec2,
Alpana Kumari57e8c9b2019-04-15 01:09:36 -0500313 const std::vector<
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500314 std::pair<std::string, VariantType>>&
315 properties) {
Ed Tanouscb13a392020-07-25 19:02:03 +0000316 if (ec2)
Ed Tanous029573d2019-02-01 10:57:49 -0800317 {
318 BMCWEB_LOG_ERROR
Ed Tanouscb13a392020-07-25 19:02:03 +0000319 << "DBUS response error " << ec2;
Ed Tanous029573d2019-02-01 10:57:49 -0800320 messages::internalError(aResp->res);
321 return;
322 }
323 BMCWEB_LOG_DEBUG << "Got "
324 << properties.size()
Gunnar Mills698654b2019-10-16 13:17:37 -0500325 << " Cpu properties.";
Ed Tanous04a258f2018-10-15 08:00:41 -0700326
Alpana Kumari57e8c9b2019-04-15 01:09:36 -0500327 if (properties.size() > 0)
328 {
Zhikui Ren9cf21522020-09-10 11:13:14 -0700329 const uint64_t* processorId = nullptr;
Zhikui Ren029cc1f2020-08-25 15:21:41 -0700330 const std::string* procFamily = nullptr;
331 nlohmann::json& procSummary =
332 aResp->res.jsonValue["ProcessorSumm"
333 "ary"];
334 nlohmann::json& procCount =
335 procSummary["Count"];
336
337 auto procCountPtr = procCount.get_ptr<
338 nlohmann::json::
339 number_integer_t*>();
340 if (procCountPtr == nullptr)
341 {
342 messages::internalError(aResp->res);
343 return;
344 }
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500345 for (const auto& property : properties)
Alpana Kumari57e8c9b2019-04-15 01:09:36 -0500346 {
Zhikui Ren029cc1f2020-08-25 15:21:41 -0700347
Zhikui Ren9cf21522020-09-10 11:13:14 -0700348 if (property.first == "Id")
Zhikui Ren029cc1f2020-08-25 15:21:41 -0700349 {
350 processorId =
Zhikui Ren9cf21522020-09-10 11:13:14 -0700351 std::get_if<uint64_t>(
Zhikui Ren029cc1f2020-08-25 15:21:41 -0700352 &property.second);
353 if (nullptr != procFamily)
Ed Tanous3174e4d2020-10-07 11:41:22 -0700354 {
Zhikui Ren029cc1f2020-08-25 15:21:41 -0700355 break;
Ed Tanous3174e4d2020-10-07 11:41:22 -0700356 }
Zhikui Ren029cc1f2020-08-25 15:21:41 -0700357 continue;
358 }
359
Zhikui Ren9cf21522020-09-10 11:13:14 -0700360 if (property.first == "Family")
Alpana Kumari57e8c9b2019-04-15 01:09:36 -0500361 {
Zhikui Ren029cc1f2020-08-25 15:21:41 -0700362 procFamily =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500363 std::get_if<std::string>(
364 &property.second);
Zhikui Ren029cc1f2020-08-25 15:21:41 -0700365 if (nullptr != processorId)
Ed Tanous3174e4d2020-10-07 11:41:22 -0700366 {
Zhikui Ren029cc1f2020-08-25 15:21:41 -0700367 break;
Ed Tanous3174e4d2020-10-07 11:41:22 -0700368 }
Zhikui Ren029cc1f2020-08-25 15:21:41 -0700369 continue;
370 }
371 }
James Feistb4b95952019-12-05 15:01:55 -0800372
Zhikui Ren029cc1f2020-08-25 15:21:41 -0700373 if (procFamily != nullptr &&
374 processorId != nullptr)
375 {
376 if (procCountPtr != nullptr &&
377 *processorId != 0)
378 {
379 *procCountPtr += 1;
380 procSummary["Status"]["State"] =
381 "Enabled";
382
383 procSummary["Model"] =
384 *procFamily;
Ed Tanous6c34de42018-08-29 13:37:36 -0700385 }
386 }
Ed Tanous029573d2019-02-01 10:57:49 -0800387 }
Alpana Kumari57e8c9b2019-04-15 01:09:36 -0500388 else
389 {
390 auto getCpuPresenceState =
391 [aResp](
392 const boost::system::error_code
Ed Tanouscb13a392020-07-25 19:02:03 +0000393 ec3,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500394 const std::variant<bool>&
395 cpuPresenceCheck) {
Ed Tanouscb13a392020-07-25 19:02:03 +0000396 if (ec3)
Alpana Kumari57e8c9b2019-04-15 01:09:36 -0500397 {
398 BMCWEB_LOG_ERROR
399 << "DBUS response "
400 "error "
Ed Tanouscb13a392020-07-25 19:02:03 +0000401 << ec3;
Alpana Kumari57e8c9b2019-04-15 01:09:36 -0500402 return;
403 }
404 modifyCpuPresenceState(
405 aResp, cpuPresenceCheck);
406 };
407
408 auto getCpuFunctionalState =
409 [aResp](
410 const boost::system::error_code
Ed Tanouscb13a392020-07-25 19:02:03 +0000411 ec3,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500412 const std::variant<bool>&
413 cpuFunctionalCheck) {
Ed Tanouscb13a392020-07-25 19:02:03 +0000414 if (ec3)
Alpana Kumari57e8c9b2019-04-15 01:09:36 -0500415 {
416 BMCWEB_LOG_ERROR
417 << "DBUS response "
418 "error "
Ed Tanouscb13a392020-07-25 19:02:03 +0000419 << ec3;
Alpana Kumari57e8c9b2019-04-15 01:09:36 -0500420 return;
421 }
422 modifyCpuFunctionalState(
423 aResp, cpuFunctionalCheck);
424 };
425 // Get the Presence of CPU
426 crow::connections::systemBus
427 ->async_method_call(
428 std::move(getCpuPresenceState),
429 service, path,
430 "org.freedesktop.DBus."
431 "Properties",
432 "Get",
433 "xyz.openbmc_project.Inventory."
434 "Item",
435 "Present");
436
437 // Get the Functional State
438 crow::connections::systemBus
439 ->async_method_call(
440 std::move(
441 getCpuFunctionalState),
442 service, path,
443 "org.freedesktop.DBus."
444 "Properties",
445 "Get",
446 "xyz.openbmc_project.State."
447 "Decorator."
448 "OperationalStatus",
449 "Functional");
450
451 // Get the MODEL from
452 // xyz.openbmc_project.Inventory.Decorator.Asset
453 // support it later as Model is Empty
454 // currently.
455 }
Ed Tanous029573d2019-02-01 10:57:49 -0800456 },
457 connection.first, path,
458 "org.freedesktop.DBus.Properties", "GetAll",
459 "xyz.openbmc_project.Inventory.Item.Cpu");
James Feist5bc2dc82019-10-22 14:33:16 -0700460
461 cpuHealth->inventory.emplace_back(path);
Ed Tanous029573d2019-02-01 10:57:49 -0800462 }
463 else if (interfaceName ==
464 "xyz.openbmc_project.Common.UUID")
465 {
466 BMCWEB_LOG_DEBUG
467 << "Found UUID, now get its properties.";
468 crow::connections::systemBus->async_method_call(
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500469 [aResp](
Ed Tanouscb13a392020-07-25 19:02:03 +0000470 const boost::system::error_code ec3,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500471 const std::vector<
472 std::pair<std::string, VariantType>>&
473 properties) {
Ed Tanouscb13a392020-07-25 19:02:03 +0000474 if (ec3)
Ed Tanous029573d2019-02-01 10:57:49 -0800475 {
476 BMCWEB_LOG_DEBUG
Ed Tanouscb13a392020-07-25 19:02:03 +0000477 << "DBUS response error " << ec3;
Ed Tanous029573d2019-02-01 10:57:49 -0800478 messages::internalError(aResp->res);
479 return;
480 }
481 BMCWEB_LOG_DEBUG << "Got "
482 << properties.size()
Gunnar Mills698654b2019-10-16 13:17:37 -0500483 << " UUID properties.";
Ed Tanous029573d2019-02-01 10:57:49 -0800484 for (const std::pair<std::string,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500485 VariantType>&
486 property : properties)
Ed Tanous029573d2019-02-01 10:57:49 -0800487 {
Ed Tanous029573d2019-02-01 10:57:49 -0800488 if (property.first == "UUID")
489 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500490 const std::string* value =
Patrick Williams8d78b7a2020-05-13 11:24:20 -0500491 std::get_if<std::string>(
492 &property.second);
Ed Tanous04a258f2018-10-15 08:00:41 -0700493
Ed Tanous029573d2019-02-01 10:57:49 -0800494 if (value != nullptr)
495 {
496 std::string valueStr = *value;
497 if (valueStr.size() == 32)
Ed Tanous6c34de42018-08-29 13:37:36 -0700498 {
Ed Tanous029573d2019-02-01 10:57:49 -0800499 valueStr.insert(8, 1, '-');
500 valueStr.insert(13, 1, '-');
501 valueStr.insert(18, 1, '-');
502 valueStr.insert(23, 1, '-');
Ed Tanous6c34de42018-08-29 13:37:36 -0700503 }
Ed Tanous029573d2019-02-01 10:57:49 -0800504 BMCWEB_LOG_DEBUG << "UUID = "
505 << valueStr;
506 aResp->res.jsonValue["UUID"] =
507 valueStr;
Ed Tanous6c34de42018-08-29 13:37:36 -0700508 }
509 }
Ed Tanous029573d2019-02-01 10:57:49 -0800510 }
511 },
512 connection.first, path,
513 "org.freedesktop.DBus.Properties", "GetAll",
514 "xyz.openbmc_project.Common.UUID");
515 }
516 else if (interfaceName ==
517 "xyz.openbmc_project.Inventory.Item.System")
518 {
519 crow::connections::systemBus->async_method_call(
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500520 [aResp](
Ed Tanouscb13a392020-07-25 19:02:03 +0000521 const boost::system::error_code ec2,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500522 const std::vector<
523 std::pair<std::string, VariantType>>&
524 propertiesList) {
Ed Tanouscb13a392020-07-25 19:02:03 +0000525 if (ec2)
Ed Tanous029573d2019-02-01 10:57:49 -0800526 {
James Feiste4a4b9a2019-06-20 14:08:07 -0700527 // doesn't have to include this
528 // interface
Ed Tanous029573d2019-02-01 10:57:49 -0800529 return;
530 }
Gunnar Mills698654b2019-10-16 13:17:37 -0500531 BMCWEB_LOG_DEBUG
532 << "Got " << propertiesList.size()
533 << " properties for system";
Ed Tanous029573d2019-02-01 10:57:49 -0800534 for (const std::pair<std::string,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500535 VariantType>&
536 property : propertiesList)
Ed Tanous029573d2019-02-01 10:57:49 -0800537 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500538 const std::string& propertyName =
beccabroekfc5afcf2019-03-05 14:35:15 -0600539 property.first;
540 if ((propertyName == "PartNumber") ||
541 (propertyName == "SerialNumber") ||
542 (propertyName == "Manufacturer") ||
543 (propertyName == "Model"))
Ed Tanous029573d2019-02-01 10:57:49 -0800544 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500545 const std::string* value =
beccabroekfc5afcf2019-03-05 14:35:15 -0600546 std::get_if<std::string>(
547 &property.second);
548 if (value != nullptr)
549 {
550 aResp->res
551 .jsonValue[propertyName] =
552 *value;
553 }
Ed Tanous029573d2019-02-01 10:57:49 -0800554 }
555 }
Gunnar Millsc1e236a2020-04-14 21:36:33 -0500556
Andrew Geisslercb7e1e72019-02-19 13:05:38 -0600557 // Grab the bios version
Gunnar Millsf97ddba2020-08-20 15:57:40 -0500558 fw_util::populateFirmwareInformation(
Andrew Geisslercb7e1e72019-02-19 13:05:38 -0600559 aResp, fw_util::biosPurpose,
Gunnar Mills72d566d2020-07-21 12:44:00 -0500560 "BiosVersion", false);
Ed Tanous029573d2019-02-01 10:57:49 -0800561 },
562 connection.first, path,
563 "org.freedesktop.DBus.Properties", "GetAll",
564 "xyz.openbmc_project.Inventory.Decorator."
565 "Asset");
James Feiste4a4b9a2019-06-20 14:08:07 -0700566
567 crow::connections::systemBus->async_method_call(
568 [aResp](
Ed Tanouscb13a392020-07-25 19:02:03 +0000569 const boost::system::error_code ec2,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500570 const std::variant<std::string>& property) {
Ed Tanouscb13a392020-07-25 19:02:03 +0000571 if (ec2)
James Feiste4a4b9a2019-06-20 14:08:07 -0700572 {
573 // doesn't have to include this
574 // interface
575 return;
576 }
577
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500578 const std::string* value =
James Feiste4a4b9a2019-06-20 14:08:07 -0700579 std::get_if<std::string>(&property);
580 if (value != nullptr)
581 {
582 aResp->res.jsonValue["AssetTag"] =
583 *value;
584 }
585 },
586 connection.first, path,
587 "org.freedesktop.DBus.Properties", "Get",
588 "xyz.openbmc_project.Inventory.Decorator."
589 "AssetTag",
590 "AssetTag");
Ed Tanous6c34de42018-08-29 13:37:36 -0700591 }
592 }
593 }
594 }
Ed Tanous6c34de42018-08-29 13:37:36 -0700595 },
596 "xyz.openbmc_project.ObjectMapper",
597 "/xyz/openbmc_project/object_mapper",
598 "xyz.openbmc_project.ObjectMapper", "GetSubTree",
Ed Tanous66173382018-08-15 18:20:59 -0700599 "/xyz/openbmc_project/inventory", int32_t(0),
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500600 std::array<const char*, 5>{
Ed Tanous66173382018-08-15 18:20:59 -0700601 "xyz.openbmc_project.Inventory.Decorator.Asset",
602 "xyz.openbmc_project.Inventory.Item.Cpu",
603 "xyz.openbmc_project.Inventory.Item.Dimm",
604 "xyz.openbmc_project.Inventory.Item.System",
605 "xyz.openbmc_project.Common.UUID",
606 });
Ed Tanous6c34de42018-08-29 13:37:36 -0700607}
608
609/**
Ed Tanous6c34de42018-08-29 13:37:36 -0700610 * @brief Retrieves host state properties over dbus
611 *
612 * @param[in] aResp Shared pointer for completing asynchronous calls.
613 *
614 * @return None.
615 */
Ed Tanous23a21a12020-07-25 04:45:05 +0000616inline void getHostState(std::shared_ptr<AsyncResp> aResp)
Ed Tanous6c34de42018-08-29 13:37:36 -0700617{
618 BMCWEB_LOG_DEBUG << "Get host information.";
619 crow::connections::systemBus->async_method_call(
Jennifer Leec5d03ff2019-03-08 15:42:58 -0800620 [aResp](const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500621 const std::variant<std::string>& hostState) {
Ed Tanous6c34de42018-08-29 13:37:36 -0700622 if (ec)
623 {
624 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
Jason M. Billsf12894f2018-10-09 12:45:45 -0700625 messages::internalError(aResp->res);
Ed Tanous6c34de42018-08-29 13:37:36 -0700626 return;
627 }
Ed Tanous66173382018-08-15 18:20:59 -0700628
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500629 const std::string* s = std::get_if<std::string>(&hostState);
Ed Tanous66173382018-08-15 18:20:59 -0700630 BMCWEB_LOG_DEBUG << "Host state: " << *s;
631 if (s != nullptr)
Ed Tanous6c34de42018-08-29 13:37:36 -0700632 {
Ed Tanous66173382018-08-15 18:20:59 -0700633 // Verify Host State
Andrew Geissler94732662019-01-08 19:32:16 -0800634 if (*s == "xyz.openbmc_project.State.Host.HostState.Running")
Ed Tanous6c34de42018-08-29 13:37:36 -0700635 {
Ed Tanous66173382018-08-15 18:20:59 -0700636 aResp->res.jsonValue["PowerState"] = "On";
637 aResp->res.jsonValue["Status"]["State"] = "Enabled";
638 }
Andrew Geissler83935af2020-02-13 10:24:53 -0600639 else if (*s == "xyz.openbmc_project.State.Host.HostState."
Gunnar Mills8c888602020-05-01 14:25:09 -0500640 "Quiesced")
641 {
642 aResp->res.jsonValue["PowerState"] = "On";
643 aResp->res.jsonValue["Status"]["State"] = "Quiesced";
644 }
645 else if (*s == "xyz.openbmc_project.State.Host.HostState."
Andrew Geissler83935af2020-02-13 10:24:53 -0600646 "DiagnosticMode")
647 {
648 aResp->res.jsonValue["PowerState"] = "On";
649 aResp->res.jsonValue["Status"]["State"] = "InTest";
650 }
Ed Tanous66173382018-08-15 18:20:59 -0700651 else
652 {
653 aResp->res.jsonValue["PowerState"] = "Off";
654 aResp->res.jsonValue["Status"]["State"] = "Disabled";
Ed Tanous6c34de42018-08-29 13:37:36 -0700655 }
656 }
657 },
658 "xyz.openbmc_project.State.Host", "/xyz/openbmc_project/state/host0",
Ed Tanous66173382018-08-15 18:20:59 -0700659 "org.freedesktop.DBus.Properties", "Get",
660 "xyz.openbmc_project.State.Host", "CurrentHostState");
Ed Tanous6c34de42018-08-29 13:37:36 -0700661}
662
663/**
Gunnar Mills786d0f62020-07-08 13:43:15 -0500664 * @brief Translates boot source DBUS property value to redfish.
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530665 *
666 * @param[in] dbusSource The boot source in DBUS speak.
667 *
668 * @return Returns as a string, the boot source in Redfish terms. If translation
669 * cannot be done, returns an empty string.
670 */
Ed Tanous23a21a12020-07-25 04:45:05 +0000671inline std::string dbusToRfBootSource(const std::string& dbusSource)
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530672{
673 if (dbusSource == "xyz.openbmc_project.Control.Boot.Source.Sources.Default")
674 {
675 return "None";
676 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700677 if (dbusSource == "xyz.openbmc_project.Control.Boot.Source.Sources.Disk")
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530678 {
679 return "Hdd";
680 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700681 if (dbusSource ==
682 "xyz.openbmc_project.Control.Boot.Source.Sources.ExternalMedia")
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530683 {
684 return "Cd";
685 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700686 if (dbusSource == "xyz.openbmc_project.Control.Boot.Source.Sources.Network")
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530687 {
688 return "Pxe";
689 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700690 if (dbusSource ==
691 "xyz.openbmc_project.Control.Boot.Source.Sources.RemovableMedia")
Jennifer Lee9f16b2c2019-04-19 15:33:48 -0700692 {
693 return "Usb";
694 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700695 return "";
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530696}
697
698/**
Gunnar Mills786d0f62020-07-08 13:43:15 -0500699 * @brief Translates boot mode DBUS property value to redfish.
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530700 *
701 * @param[in] dbusMode The boot mode in DBUS speak.
702 *
703 * @return Returns as a string, the boot mode in Redfish terms. If translation
704 * cannot be done, returns an empty string.
705 */
Ed Tanous23a21a12020-07-25 04:45:05 +0000706inline std::string dbusToRfBootMode(const std::string& dbusMode)
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530707{
708 if (dbusMode == "xyz.openbmc_project.Control.Boot.Mode.Modes.Regular")
709 {
710 return "None";
711 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700712 if (dbusMode == "xyz.openbmc_project.Control.Boot.Mode.Modes.Safe")
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530713 {
714 return "Diags";
715 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700716 if (dbusMode == "xyz.openbmc_project.Control.Boot.Mode.Modes.Setup")
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530717 {
718 return "BiosSetup";
719 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700720 return "";
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530721}
722
723/**
Gunnar Mills786d0f62020-07-08 13:43:15 -0500724 * @brief Translates boot source from Redfish to the DBus boot paths.
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530725 *
726 * @param[in] rfSource The boot source in Redfish.
Johnathan Mantey944ffaf2019-08-12 16:16:14 -0700727 * @param[out] bootSource The DBus source
728 * @param[out] bootMode the DBus boot mode
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530729 *
Johnathan Mantey944ffaf2019-08-12 16:16:14 -0700730 * @return Integer error code.
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530731 */
Ed Tanous23a21a12020-07-25 04:45:05 +0000732inline int assignBootParameters(std::shared_ptr<AsyncResp> aResp,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500733 const std::string& rfSource,
734 std::string& bootSource, std::string& bootMode)
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530735{
Johnathan Mantey944ffaf2019-08-12 16:16:14 -0700736 // The caller has initialized the bootSource and bootMode to:
737 // bootMode = "xyz.openbmc_project.Control.Boot.Mode.Modes.Regular";
738 // bootSource = "xyz.openbmc_project.Control.Boot.Source.Sources.Default";
739 // Only modify the bootSource/bootMode variable needed to achieve the
740 // desired boot action.
741
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530742 if (rfSource == "None")
743 {
Johnathan Mantey944ffaf2019-08-12 16:16:14 -0700744 return 0;
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530745 }
Ed Tanous3174e4d2020-10-07 11:41:22 -0700746 if (rfSource == "Pxe")
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530747 {
Johnathan Mantey944ffaf2019-08-12 16:16:14 -0700748 bootSource = "xyz.openbmc_project.Control.Boot.Source.Sources.Network";
749 }
750 else if (rfSource == "Hdd")
751 {
752 bootSource = "xyz.openbmc_project.Control.Boot.Source.Sources.Disk";
753 }
754 else if (rfSource == "Diags")
755 {
756 bootMode = "xyz.openbmc_project.Control.Boot.Mode.Modes.Safe";
757 }
758 else if (rfSource == "Cd")
759 {
760 bootSource =
761 "xyz.openbmc_project.Control.Boot.Source.Sources.ExternalMedia";
762 }
763 else if (rfSource == "BiosSetup")
764 {
765 bootMode = "xyz.openbmc_project.Control.Boot.Mode.Modes.Setup";
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530766 }
Jennifer Lee9f16b2c2019-04-19 15:33:48 -0700767 else if (rfSource == "Usb")
768 {
Johnathan Mantey944ffaf2019-08-12 16:16:14 -0700769 bootSource =
770 "xyz.openbmc_project.Control.Boot.Source.Sources.RemovableMedia";
Jennifer Lee9f16b2c2019-04-19 15:33:48 -0700771 }
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530772 else
773 {
Johnathan Mantey944ffaf2019-08-12 16:16:14 -0700774 BMCWEB_LOG_DEBUG << "Invalid property value for "
775 "BootSourceOverrideTarget: "
776 << bootSource;
777 messages::propertyValueNotInList(aResp->res, rfSource,
778 "BootSourceTargetOverride");
779 return -1;
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530780 }
Johnathan Mantey944ffaf2019-08-12 16:16:14 -0700781 return 0;
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530782}
783
784/**
785 * @brief Retrieves boot mode over DBUS and fills out the response
786 *
787 * @param[in] aResp Shared pointer for generating response message.
788 * @param[in] bootDbusObj The dbus object to query for boot properties.
789 *
790 * @return None.
791 */
Ed Tanous23a21a12020-07-25 04:45:05 +0000792inline void getBootMode(std::shared_ptr<AsyncResp> aResp,
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530793 std::string bootDbusObj)
794{
795 crow::connections::systemBus->async_method_call(
796 [aResp](const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500797 const std::variant<std::string>& bootMode) {
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530798 if (ec)
799 {
800 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
801 messages::internalError(aResp->res);
802 return;
803 }
804
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500805 const std::string* bootModeStr =
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530806 std::get_if<std::string>(&bootMode);
807
808 if (!bootModeStr)
809 {
810 messages::internalError(aResp->res);
811 return;
812 }
813
814 BMCWEB_LOG_DEBUG << "Boot mode: " << *bootModeStr;
815
816 // TODO (Santosh): Do we need to support override mode?
817 aResp->res.jsonValue["Boot"]["BootSourceOverrideMode"] = "Legacy";
818 aResp->res.jsonValue["Boot"]["BootSourceOverrideTarget@Redfish."
819 "AllowableValues"] = {
Johnathan Mantey944ffaf2019-08-12 16:16:14 -0700820 "None", "Pxe", "Hdd", "Cd", "Diags", "BiosSetup", "Usb"};
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530821
822 if (*bootModeStr !=
823 "xyz.openbmc_project.Control.Boot.Mode.Modes.Regular")
824 {
825 auto rfMode = dbusToRfBootMode(*bootModeStr);
826 if (!rfMode.empty())
827 {
828 aResp->res.jsonValue["Boot"]["BootSourceOverrideTarget"] =
829 rfMode;
830 }
831 }
832
833 // If the BootSourceOverrideTarget is still "None" at the end,
834 // reset the BootSourceOverrideEnabled to indicate that
835 // overrides are disabled
836 if (aResp->res.jsonValue["Boot"]["BootSourceOverrideTarget"] ==
837 "None")
838 {
839 aResp->res.jsonValue["Boot"]["BootSourceOverrideEnabled"] =
840 "Disabled";
841 }
842 },
843 "xyz.openbmc_project.Settings", bootDbusObj,
844 "org.freedesktop.DBus.Properties", "Get",
845 "xyz.openbmc_project.Control.Boot.Mode", "BootMode");
846}
847
848/**
849 * @brief Retrieves boot source over DBUS
850 *
851 * @param[in] aResp Shared pointer for generating response message.
852 * @param[in] oneTimeEnable Boolean to indicate boot properties are one-time.
853 *
854 * @return None.
855 */
Ed Tanous23a21a12020-07-25 04:45:05 +0000856inline void getBootSource(std::shared_ptr<AsyncResp> aResp, bool oneTimeEnabled)
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530857{
858 std::string bootDbusObj =
859 oneTimeEnabled ? "/xyz/openbmc_project/control/host0/boot/one_time"
860 : "/xyz/openbmc_project/control/host0/boot";
861
862 BMCWEB_LOG_DEBUG << "Is one time: " << oneTimeEnabled;
863 aResp->res.jsonValue["Boot"]["BootSourceOverrideEnabled"] =
864 (oneTimeEnabled) ? "Once" : "Continuous";
865
866 crow::connections::systemBus->async_method_call(
867 [aResp, bootDbusObj](const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500868 const std::variant<std::string>& bootSource) {
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530869 if (ec)
870 {
871 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
872 messages::internalError(aResp->res);
873 return;
874 }
875
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500876 const std::string* bootSourceStr =
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530877 std::get_if<std::string>(&bootSource);
878
879 if (!bootSourceStr)
880 {
881 messages::internalError(aResp->res);
882 return;
883 }
884 BMCWEB_LOG_DEBUG << "Boot source: " << *bootSourceStr;
885
886 auto rfSource = dbusToRfBootSource(*bootSourceStr);
887 if (!rfSource.empty())
888 {
889 aResp->res.jsonValue["Boot"]["BootSourceOverrideTarget"] =
890 rfSource;
891 }
892 },
893 "xyz.openbmc_project.Settings", bootDbusObj,
894 "org.freedesktop.DBus.Properties", "Get",
895 "xyz.openbmc_project.Control.Boot.Source", "BootSource");
896 getBootMode(std::move(aResp), std::move(bootDbusObj));
897}
898
899/**
900 * @brief Retrieves "One time" enabled setting over DBUS and calls function to
901 * get boot source and boot mode.
902 *
903 * @param[in] aResp Shared pointer for generating response message.
904 *
905 * @return None.
906 */
Ed Tanous23a21a12020-07-25 04:45:05 +0000907inline void getBootProperties(std::shared_ptr<AsyncResp> aResp)
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530908{
909 BMCWEB_LOG_DEBUG << "Get boot information.";
910
911 crow::connections::systemBus->async_method_call(
Jennifer Leec5d03ff2019-03-08 15:42:58 -0800912 [aResp](const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500913 const std::variant<bool>& oneTime) {
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530914 if (ec)
915 {
916 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
James Feist2a833c72019-07-19 10:17:13 -0700917 // not an error, don't have to have the interface
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530918 return;
919 }
920
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500921 const bool* oneTimePtr = std::get_if<bool>(&oneTime);
Santosh Puranik491d8ee2019-02-06 19:46:56 +0530922
923 if (!oneTimePtr)
924 {
925 messages::internalError(aResp->res);
926 return;
927 }
928 getBootSource(aResp, *oneTimePtr);
929 },
930 "xyz.openbmc_project.Settings",
931 "/xyz/openbmc_project/control/host0/boot/one_time",
932 "org.freedesktop.DBus.Properties", "Get",
933 "xyz.openbmc_project.Object.Enable", "Enabled");
934}
935
936/**
Gunnar Millsc0557e12020-06-30 11:26:20 -0500937 * @brief Retrieves the Last Reset Time
938 *
939 * "Reset" is an overloaded term in Redfish, "Reset" includes power on
940 * and power off. Even though this is the "system" Redfish object look at the
941 * chassis D-Bus interface for the LastStateChangeTime since this has the
942 * last power operation time.
943 *
944 * @param[in] aResp Shared pointer for generating response message.
945 *
946 * @return None.
947 */
Ed Tanous23a21a12020-07-25 04:45:05 +0000948inline void getLastResetTime(std::shared_ptr<AsyncResp> aResp)
Gunnar Millsc0557e12020-06-30 11:26:20 -0500949{
950 BMCWEB_LOG_DEBUG << "Getting System Last Reset Time";
951
952 crow::connections::systemBus->async_method_call(
953 [aResp](const boost::system::error_code ec,
954 std::variant<uint64_t>& lastResetTime) {
955 if (ec)
956 {
957 BMCWEB_LOG_DEBUG << "D-BUS response error " << ec;
958 return;
959 }
960
961 const uint64_t* lastResetTimePtr =
962 std::get_if<uint64_t>(&lastResetTime);
963
964 if (!lastResetTimePtr)
965 {
966 messages::internalError(aResp->res);
967 return;
968 }
969 // LastStateChangeTime is epoch time, in milliseconds
970 // https://github.com/openbmc/phosphor-dbus-interfaces/blob/33e8e1dd64da53a66e888d33dc82001305cd0bf9/xyz/openbmc_project/State/Chassis.interface.yaml#L19
971 time_t lastResetTimeStamp =
972 static_cast<time_t>(*lastResetTimePtr / 1000);
973
974 // Convert to ISO 8601 standard
975 aResp->res.jsonValue["LastResetTime"] =
976 crow::utility::getDateTime(lastResetTimeStamp);
977 },
978 "xyz.openbmc_project.State.Chassis",
979 "/xyz/openbmc_project/state/chassis0",
980 "org.freedesktop.DBus.Properties", "Get",
981 "xyz.openbmc_project.State.Chassis", "LastStateChangeTime");
982}
983
984/**
Gunnar Mills6bd5a8d2020-05-16 18:49:33 -0500985 * @brief Retrieves Automatic Retry properties. Known on D-Bus as AutoReboot.
986 *
987 * @param[in] aResp Shared pointer for generating response message.
988 *
989 * @return None.
990 */
Ed Tanous23a21a12020-07-25 04:45:05 +0000991inline void getAutomaticRetry(std::shared_ptr<AsyncResp> aResp)
Gunnar Mills6bd5a8d2020-05-16 18:49:33 -0500992{
993 BMCWEB_LOG_DEBUG << "Get Automatic Retry policy";
994
995 crow::connections::systemBus->async_method_call(
996 [aResp](const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500997 std::variant<bool>& autoRebootEnabled) {
Gunnar Mills6bd5a8d2020-05-16 18:49:33 -0500998 if (ec)
999 {
1000 BMCWEB_LOG_DEBUG << "D-BUS response error " << ec;
1001 return;
1002 }
1003
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001004 const bool* autoRebootEnabledPtr =
Gunnar Mills6bd5a8d2020-05-16 18:49:33 -05001005 std::get_if<bool>(&autoRebootEnabled);
1006
1007 if (!autoRebootEnabledPtr)
1008 {
1009 messages::internalError(aResp->res);
1010 return;
1011 }
1012
1013 BMCWEB_LOG_DEBUG << "Auto Reboot: " << *autoRebootEnabledPtr;
1014 if (*autoRebootEnabledPtr == true)
1015 {
1016 aResp->res.jsonValue["Boot"]["AutomaticRetryConfig"] =
1017 "RetryAttempts";
1018 // If AutomaticRetry (AutoReboot) is enabled see how many
1019 // attempts are left
1020 crow::connections::systemBus->async_method_call(
Ed Tanouscb13a392020-07-25 19:02:03 +00001021 [aResp](const boost::system::error_code ec2,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001022 std::variant<uint32_t>& autoRebootAttemptsLeft) {
Ed Tanouscb13a392020-07-25 19:02:03 +00001023 if (ec2)
Gunnar Mills6bd5a8d2020-05-16 18:49:33 -05001024 {
Ed Tanouscb13a392020-07-25 19:02:03 +00001025 BMCWEB_LOG_DEBUG << "D-BUS response error " << ec2;
Gunnar Mills6bd5a8d2020-05-16 18:49:33 -05001026 return;
1027 }
1028
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001029 const uint32_t* autoRebootAttemptsLeftPtr =
Gunnar Mills6bd5a8d2020-05-16 18:49:33 -05001030 std::get_if<uint32_t>(&autoRebootAttemptsLeft);
1031
1032 if (!autoRebootAttemptsLeftPtr)
1033 {
1034 messages::internalError(aResp->res);
1035 return;
1036 }
1037
1038 BMCWEB_LOG_DEBUG << "Auto Reboot Attempts Left: "
1039 << *autoRebootAttemptsLeftPtr;
1040
1041 aResp->res
1042 .jsonValue["Boot"]
1043 ["RemainingAutomaticRetryAttempts"] =
1044 *autoRebootAttemptsLeftPtr;
1045 },
1046 "xyz.openbmc_project.State.Host",
1047 "/xyz/openbmc_project/state/host0",
1048 "org.freedesktop.DBus.Properties", "Get",
1049 "xyz.openbmc_project.Control.Boot.RebootAttempts",
1050 "AttemptsLeft");
1051 }
1052 else
1053 {
1054 aResp->res.jsonValue["Boot"]["AutomaticRetryConfig"] =
1055 "Disabled";
1056 }
1057
1058 // Not on D-Bus. Hardcoded here:
1059 // https://github.com/openbmc/phosphor-state-manager/blob/1dbbef42675e94fb1f78edb87d6b11380260535a/meson_options.txt#L71
1060 aResp->res.jsonValue["Boot"]["AutomaticRetryAttempts"] = 3;
Gunnar Mills69f35302020-05-17 16:06:31 -05001061
1062 // "AutomaticRetryConfig" can be 3 values, Disabled, RetryAlways,
1063 // and RetryAttempts. OpenBMC only supports Disabled and
1064 // RetryAttempts.
1065 aResp->res.jsonValue["Boot"]["AutomaticRetryConfig@Redfish."
1066 "AllowableValues"] = {"Disabled",
1067 "RetryAttempts"};
Gunnar Mills6bd5a8d2020-05-16 18:49:33 -05001068 },
1069 "xyz.openbmc_project.Settings",
1070 "/xyz/openbmc_project/control/host0/auto_reboot",
1071 "org.freedesktop.DBus.Properties", "Get",
1072 "xyz.openbmc_project.Control.Boot.RebootPolicy", "AutoReboot");
1073}
1074
1075/**
George Liuc6a620f2020-04-10 17:18:11 +08001076 * @brief Retrieves power restore policy over DBUS.
1077 *
1078 * @param[in] aResp Shared pointer for generating response message.
1079 *
1080 * @return None.
1081 */
Ed Tanous23a21a12020-07-25 04:45:05 +00001082inline void getPowerRestorePolicy(std::shared_ptr<AsyncResp> aResp)
George Liuc6a620f2020-04-10 17:18:11 +08001083{
1084 BMCWEB_LOG_DEBUG << "Get power restore policy";
1085
1086 crow::connections::systemBus->async_method_call(
1087 [aResp](const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001088 std::variant<std::string>& policy) {
George Liuc6a620f2020-04-10 17:18:11 +08001089 if (ec)
1090 {
1091 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
1092 return;
1093 }
1094
1095 const boost::container::flat_map<std::string, std::string>
1096 policyMaps = {
1097 {"xyz.openbmc_project.Control.Power.RestorePolicy.Policy."
1098 "AlwaysOn",
1099 "AlwaysOn"},
1100 {"xyz.openbmc_project.Control.Power.RestorePolicy.Policy."
1101 "AlwaysOff",
1102 "AlwaysOff"},
1103 {"xyz.openbmc_project.Control.Power.RestorePolicy.Policy."
1104 "LastState",
1105 "LastState"}};
1106
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001107 const std::string* policyPtr = std::get_if<std::string>(&policy);
George Liuc6a620f2020-04-10 17:18:11 +08001108
1109 if (!policyPtr)
1110 {
1111 messages::internalError(aResp->res);
1112 return;
1113 }
1114
1115 auto policyMapsIt = policyMaps.find(*policyPtr);
1116 if (policyMapsIt == policyMaps.end())
1117 {
1118 messages::internalError(aResp->res);
1119 return;
1120 }
1121
1122 aResp->res.jsonValue["PowerRestorePolicy"] = policyMapsIt->second;
1123 },
1124 "xyz.openbmc_project.Settings",
1125 "/xyz/openbmc_project/control/host0/power_restore_policy",
1126 "org.freedesktop.DBus.Properties", "Get",
1127 "xyz.openbmc_project.Control.Power.RestorePolicy",
1128 "PowerRestorePolicy");
1129}
1130
1131/**
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301132 * @brief Sets boot properties into DBUS object(s).
1133 *
1134 * @param[in] aResp Shared pointer for generating response message.
1135 * @param[in] oneTimeEnabled Is "one-time" setting already enabled.
1136 * @param[in] bootSource The boot source to set.
1137 * @param[in] bootEnable The source override "enable" to set.
1138 *
Johnathan Mantey265c1602019-08-08 11:02:51 -07001139 * @return Integer error code.
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301140 */
Ed Tanous23a21a12020-07-25 04:45:05 +00001141inline void setBootModeOrSource(std::shared_ptr<AsyncResp> aResp,
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301142 bool oneTimeEnabled,
1143 std::optional<std::string> bootSource,
1144 std::optional<std::string> bootEnable)
1145{
Johnathan Mantey944ffaf2019-08-12 16:16:14 -07001146 std::string bootSourceStr =
1147 "xyz.openbmc_project.Control.Boot.Source.Sources.Default";
1148 std::string bootModeStr =
1149 "xyz.openbmc_project.Control.Boot.Mode.Modes.Regular";
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301150 bool oneTimeSetting = oneTimeEnabled;
Johnathan Mantey944ffaf2019-08-12 16:16:14 -07001151 bool useBootSource = true;
1152
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301153 // Validate incoming parameters
1154 if (bootEnable)
1155 {
1156 if (*bootEnable == "Once")
1157 {
1158 oneTimeSetting = true;
1159 }
1160 else if (*bootEnable == "Continuous")
1161 {
1162 oneTimeSetting = false;
1163 }
1164 else if (*bootEnable == "Disabled")
1165 {
Johnathan Mantey944ffaf2019-08-12 16:16:14 -07001166 BMCWEB_LOG_DEBUG << "Boot source override will be disabled";
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301167 oneTimeSetting = false;
Johnathan Mantey944ffaf2019-08-12 16:16:14 -07001168 useBootSource = false;
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301169 }
1170 else
1171 {
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301172 BMCWEB_LOG_DEBUG << "Unsupported value for "
1173 "BootSourceOverrideEnabled: "
1174 << *bootEnable;
1175 messages::propertyValueNotInList(aResp->res, *bootEnable,
1176 "BootSourceOverrideEnabled");
1177 return;
1178 }
1179 }
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301180
Johnathan Mantey944ffaf2019-08-12 16:16:14 -07001181 if (bootSource && useBootSource)
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301182 {
1183 // Source target specified
1184 BMCWEB_LOG_DEBUG << "Boot source: " << *bootSource;
1185 // Figure out which DBUS interface and property to use
Johnathan Mantey944ffaf2019-08-12 16:16:14 -07001186 if (assignBootParameters(aResp, *bootSource, bootSourceStr,
1187 bootModeStr))
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301188 {
Johnathan Mantey944ffaf2019-08-12 16:16:14 -07001189 BMCWEB_LOG_DEBUG
1190 << "Invalid property value for BootSourceOverrideTarget: "
1191 << *bootSource;
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301192 messages::propertyValueNotInList(aResp->res, *bootSource,
1193 "BootSourceTargetOverride");
1194 return;
1195 }
Johnathan Mantey944ffaf2019-08-12 16:16:14 -07001196 }
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301197
Johnathan Mantey944ffaf2019-08-12 16:16:14 -07001198 // Act on validated parameters
1199 BMCWEB_LOG_DEBUG << "DBUS boot source: " << bootSourceStr;
1200 BMCWEB_LOG_DEBUG << "DBUS boot mode: " << bootModeStr;
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001201 const char* bootObj =
Johnathan Mantey944ffaf2019-08-12 16:16:14 -07001202 oneTimeSetting ? "/xyz/openbmc_project/control/host0/boot/one_time"
1203 : "/xyz/openbmc_project/control/host0/boot";
1204
1205 crow::connections::systemBus->async_method_call(
1206 [aResp](const boost::system::error_code ec) {
1207 if (ec)
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301208 {
Johnathan Mantey944ffaf2019-08-12 16:16:14 -07001209 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
1210 messages::internalError(aResp->res);
1211 return;
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301212 }
Johnathan Mantey944ffaf2019-08-12 16:16:14 -07001213 BMCWEB_LOG_DEBUG << "Boot source update done.";
1214 },
1215 "xyz.openbmc_project.Settings", bootObj,
1216 "org.freedesktop.DBus.Properties", "Set",
1217 "xyz.openbmc_project.Control.Boot.Source", "BootSource",
1218 std::variant<std::string>(bootSourceStr));
1219
1220 crow::connections::systemBus->async_method_call(
1221 [aResp](const boost::system::error_code ec) {
1222 if (ec)
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301223 {
Johnathan Mantey944ffaf2019-08-12 16:16:14 -07001224 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
1225 messages::internalError(aResp->res);
1226 return;
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301227 }
Johnathan Mantey944ffaf2019-08-12 16:16:14 -07001228 BMCWEB_LOG_DEBUG << "Boot mode update done.";
1229 },
1230 "xyz.openbmc_project.Settings", bootObj,
1231 "org.freedesktop.DBus.Properties", "Set",
1232 "xyz.openbmc_project.Control.Boot.Mode", "BootMode",
1233 std::variant<std::string>(bootModeStr));
1234
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301235 crow::connections::systemBus->async_method_call(
1236 [aResp{std::move(aResp)}](const boost::system::error_code ec) {
1237 if (ec)
1238 {
1239 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
1240 messages::internalError(aResp->res);
1241 return;
1242 }
1243 BMCWEB_LOG_DEBUG << "Boot enable update done.";
1244 },
1245 "xyz.openbmc_project.Settings",
1246 "/xyz/openbmc_project/control/host0/boot/one_time",
1247 "org.freedesktop.DBus.Properties", "Set",
1248 "xyz.openbmc_project.Object.Enable", "Enabled",
1249 std::variant<bool>(oneTimeSetting));
1250}
1251
1252/**
1253 * @brief Retrieves "One time" enabled setting over DBUS and calls function to
1254 * set boot source/boot mode properties.
1255 *
1256 * @param[in] aResp Shared pointer for generating response message.
1257 * @param[in] bootSource The boot source from incoming RF request.
1258 * @param[in] bootEnable The boot override enable from incoming RF request.
1259 *
Johnathan Mantey265c1602019-08-08 11:02:51 -07001260 * @return Integer error code.
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301261 */
Ed Tanous23a21a12020-07-25 04:45:05 +00001262inline void setBootSourceProperties(std::shared_ptr<AsyncResp> aResp,
Gunnar Mills69f35302020-05-17 16:06:31 -05001263 std::optional<std::string> bootSource,
1264 std::optional<std::string> bootEnable)
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301265{
1266 BMCWEB_LOG_DEBUG << "Set boot information.";
1267
1268 crow::connections::systemBus->async_method_call(
Johnathan Mantey265c1602019-08-08 11:02:51 -07001269 [aResp, bootSource{std::move(bootSource)},
Patrick Williams19bd78d2020-05-13 17:38:24 -05001270 bootEnable{std::move(bootEnable)}](const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001271 const std::variant<bool>& oneTime) {
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301272 if (ec)
1273 {
1274 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
1275 messages::internalError(aResp->res);
1276 return;
1277 }
1278
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001279 const bool* oneTimePtr = std::get_if<bool>(&oneTime);
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301280
1281 if (!oneTimePtr)
1282 {
1283 messages::internalError(aResp->res);
1284 return;
1285 }
1286
1287 BMCWEB_LOG_DEBUG << "Got one time: " << *oneTimePtr;
1288
1289 setBootModeOrSource(aResp, *oneTimePtr, std::move(bootSource),
1290 std::move(bootEnable));
1291 },
1292 "xyz.openbmc_project.Settings",
1293 "/xyz/openbmc_project/control/host0/boot/one_time",
1294 "org.freedesktop.DBus.Properties", "Get",
1295 "xyz.openbmc_project.Object.Enable", "Enabled");
1296}
1297
George Liuc6a620f2020-04-10 17:18:11 +08001298/**
Gunnar Mills69f35302020-05-17 16:06:31 -05001299 * @brief Sets automaticRetry (Auto Reboot)
1300 *
1301 * @param[in] aResp Shared pointer for generating response message.
1302 * @param[in] automaticRetryConfig "AutomaticRetryConfig" from request.
1303 *
1304 * @return None.
1305 */
Ed Tanous23a21a12020-07-25 04:45:05 +00001306inline void setAutomaticRetry(std::shared_ptr<AsyncResp> aResp,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001307 const std::string&& automaticRetryConfig)
Gunnar Mills69f35302020-05-17 16:06:31 -05001308{
1309 BMCWEB_LOG_DEBUG << "Set Automatic Retry.";
1310
1311 // OpenBMC only supports "Disabled" and "RetryAttempts".
1312 bool autoRebootEnabled;
1313
1314 if (automaticRetryConfig == "Disabled")
1315 {
1316 autoRebootEnabled = false;
1317 }
1318 else if (automaticRetryConfig == "RetryAttempts")
1319 {
1320 autoRebootEnabled = true;
1321 }
1322 else
1323 {
1324 BMCWEB_LOG_DEBUG << "Invalid property value for "
1325 "AutomaticRetryConfig: "
1326 << automaticRetryConfig;
1327 messages::propertyValueNotInList(aResp->res, automaticRetryConfig,
1328 "AutomaticRetryConfig");
1329 return;
1330 }
1331
1332 crow::connections::systemBus->async_method_call(
1333 [aResp](const boost::system::error_code ec) {
1334 if (ec)
1335 {
1336 messages::internalError(aResp->res);
1337 return;
1338 }
1339 },
1340 "xyz.openbmc_project.Settings",
1341 "/xyz/openbmc_project/control/host0/auto_reboot",
1342 "org.freedesktop.DBus.Properties", "Set",
1343 "xyz.openbmc_project.Control.Boot.RebootPolicy", "AutoReboot",
1344 std::variant<bool>(autoRebootEnabled));
1345}
1346
1347/**
George Liuc6a620f2020-04-10 17:18:11 +08001348 * @brief Sets power restore policy properties.
1349 *
1350 * @param[in] aResp Shared pointer for generating response message.
1351 * @param[in] policy power restore policy properties from request.
1352 *
1353 * @return None.
1354 */
Ed Tanous23a21a12020-07-25 04:45:05 +00001355inline void setPowerRestorePolicy(std::shared_ptr<AsyncResp> aResp,
George Liuc6a620f2020-04-10 17:18:11 +08001356 std::optional<std::string> policy)
1357{
1358 BMCWEB_LOG_DEBUG << "Set power restore policy.";
1359
1360 const boost::container::flat_map<std::string, std::string> policyMaps = {
1361 {"AlwaysOn", "xyz.openbmc_project.Control.Power.RestorePolicy.Policy."
1362 "AlwaysOn"},
1363 {"AlwaysOff", "xyz.openbmc_project.Control.Power.RestorePolicy.Policy."
1364 "AlwaysOff"},
1365 {"LastState", "xyz.openbmc_project.Control.Power.RestorePolicy.Policy."
1366 "LastState"}};
1367
1368 std::string powerRestorPolicy;
1369
1370 auto policyMapsIt = policyMaps.find(*policy);
1371 if (policyMapsIt == policyMaps.end())
1372 {
1373 messages::internalError(aResp->res);
1374 return;
1375 }
1376
1377 powerRestorPolicy = policyMapsIt->second;
1378
1379 crow::connections::systemBus->async_method_call(
1380 [aResp](const boost::system::error_code ec) {
1381 if (ec)
1382 {
1383 messages::internalError(aResp->res);
1384 return;
1385 }
1386 },
1387 "xyz.openbmc_project.Settings",
1388 "/xyz/openbmc_project/control/host0/power_restore_policy",
1389 "org.freedesktop.DBus.Properties", "Set",
1390 "xyz.openbmc_project.Control.Power.RestorePolicy", "PowerRestorePolicy",
1391 std::variant<std::string>(powerRestorPolicy));
1392}
1393
AppaRao Pulia6349912019-10-18 17:16:08 +05301394#ifdef BMCWEB_ENABLE_REDFISH_PROVISIONING_FEATURE
1395/**
1396 * @brief Retrieves provisioning status
1397 *
1398 * @param[in] aResp Shared pointer for completing asynchronous calls.
1399 *
1400 * @return None.
1401 */
Ed Tanous23a21a12020-07-25 04:45:05 +00001402inline void getProvisioningStatus(std::shared_ptr<AsyncResp> aResp)
AppaRao Pulia6349912019-10-18 17:16:08 +05301403{
1404 BMCWEB_LOG_DEBUG << "Get OEM information.";
1405 crow::connections::systemBus->async_method_call(
1406 [aResp](const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001407 const std::vector<std::pair<std::string, VariantType>>&
1408 propertiesList) {
AppaRao Pulib99fb1a2020-07-08 16:42:48 +05301409 nlohmann::json& oemPFR =
1410 aResp->res.jsonValue["Oem"]["OpenBmc"]["FirmwareProvisioning"];
James Feist50626f42020-09-23 14:40:47 -07001411 aResp->res.jsonValue["Oem"]["OpenBmc"]["@odata.type"] =
1412 "#OemComputerSystem.OpenBmc";
1413 oemPFR["@odata.type"] = "#OemComputerSystem.FirmwareProvisioning";
1414
AppaRao Pulia6349912019-10-18 17:16:08 +05301415 if (ec)
1416 {
1417 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
AppaRao Pulib99fb1a2020-07-08 16:42:48 +05301418 // not an error, don't have to have the interface
1419 oemPFR["ProvisioningStatus"] = "NotProvisioned";
AppaRao Pulia6349912019-10-18 17:16:08 +05301420 return;
1421 }
1422
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001423 const bool* provState = nullptr;
1424 const bool* lockState = nullptr;
1425 for (const std::pair<std::string, VariantType>& property :
AppaRao Pulia6349912019-10-18 17:16:08 +05301426 propertiesList)
1427 {
1428 if (property.first == "UfmProvisioned")
1429 {
1430 provState = std::get_if<bool>(&property.second);
1431 }
1432 else if (property.first == "UfmLocked")
1433 {
1434 lockState = std::get_if<bool>(&property.second);
1435 }
1436 }
1437
1438 if ((provState == nullptr) || (lockState == nullptr))
1439 {
1440 BMCWEB_LOG_DEBUG << "Unable to get PFR attributes.";
1441 messages::internalError(aResp->res);
1442 return;
1443 }
1444
AppaRao Pulia6349912019-10-18 17:16:08 +05301445 if (*provState == true)
1446 {
1447 if (*lockState == true)
1448 {
1449 oemPFR["ProvisioningStatus"] = "ProvisionedAndLocked";
1450 }
1451 else
1452 {
1453 oemPFR["ProvisioningStatus"] = "ProvisionedButNotLocked";
1454 }
1455 }
1456 else
1457 {
1458 oemPFR["ProvisioningStatus"] = "NotProvisioned";
1459 }
1460 },
1461 "xyz.openbmc_project.PFR.Manager", "/xyz/openbmc_project/pfr",
1462 "org.freedesktop.DBus.Properties", "GetAll",
1463 "xyz.openbmc_project.PFR.Attributes");
1464}
1465#endif
1466
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301467/**
Yong Li51709ff2019-09-30 14:13:04 +08001468 * @brief Translates watchdog timeout action DBUS property value to redfish.
1469 *
1470 * @param[in] dbusAction The watchdog timeout action in D-BUS.
1471 *
1472 * @return Returns as a string, the timeout action in Redfish terms. If
1473 * translation cannot be done, returns an empty string.
1474 */
Ed Tanous23a21a12020-07-25 04:45:05 +00001475inline std::string dbusToRfWatchdogAction(const std::string& dbusAction)
Yong Li51709ff2019-09-30 14:13:04 +08001476{
1477 if (dbusAction == "xyz.openbmc_project.State.Watchdog.Action.None")
1478 {
1479 return "None";
1480 }
Ed Tanous3174e4d2020-10-07 11:41:22 -07001481 if (dbusAction == "xyz.openbmc_project.State.Watchdog.Action.HardReset")
Yong Li51709ff2019-09-30 14:13:04 +08001482 {
1483 return "ResetSystem";
1484 }
Ed Tanous3174e4d2020-10-07 11:41:22 -07001485 if (dbusAction == "xyz.openbmc_project.State.Watchdog.Action.PowerOff")
Yong Li51709ff2019-09-30 14:13:04 +08001486 {
1487 return "PowerDown";
1488 }
Ed Tanous3174e4d2020-10-07 11:41:22 -07001489 if (dbusAction == "xyz.openbmc_project.State.Watchdog.Action.PowerCycle")
Yong Li51709ff2019-09-30 14:13:04 +08001490 {
1491 return "PowerCycle";
1492 }
1493
1494 return "";
1495}
1496
1497/**
Yong Lic45f0082019-10-10 14:19:01 +08001498 *@brief Translates timeout action from Redfish to DBUS property value.
1499 *
1500 *@param[in] rfAction The timeout action in Redfish.
1501 *
1502 *@return Returns as a string, the time_out action as expected by DBUS.
1503 *If translation cannot be done, returns an empty string.
1504 */
1505
Ed Tanous23a21a12020-07-25 04:45:05 +00001506inline std::string rfToDbusWDTTimeOutAct(const std::string& rfAction)
Yong Lic45f0082019-10-10 14:19:01 +08001507{
1508 if (rfAction == "None")
1509 {
1510 return "xyz.openbmc_project.State.Watchdog.Action.None";
1511 }
Ed Tanous3174e4d2020-10-07 11:41:22 -07001512 if (rfAction == "PowerCycle")
Yong Lic45f0082019-10-10 14:19:01 +08001513 {
1514 return "xyz.openbmc_project.State.Watchdog.Action.PowerCycle";
1515 }
Ed Tanous3174e4d2020-10-07 11:41:22 -07001516 if (rfAction == "PowerDown")
Yong Lic45f0082019-10-10 14:19:01 +08001517 {
1518 return "xyz.openbmc_project.State.Watchdog.Action.PowerOff";
1519 }
Ed Tanous3174e4d2020-10-07 11:41:22 -07001520 if (rfAction == "ResetSystem")
Yong Lic45f0082019-10-10 14:19:01 +08001521 {
1522 return "xyz.openbmc_project.State.Watchdog.Action.HardReset";
1523 }
1524
1525 return "";
1526}
1527
1528/**
Yong Li51709ff2019-09-30 14:13:04 +08001529 * @brief Retrieves host watchdog timer properties over DBUS
1530 *
1531 * @param[in] aResp Shared pointer for completing asynchronous calls.
1532 *
1533 * @return None.
1534 */
Ed Tanous23a21a12020-07-25 04:45:05 +00001535inline void getHostWatchdogTimer(std::shared_ptr<AsyncResp> aResp)
Yong Li51709ff2019-09-30 14:13:04 +08001536{
1537 BMCWEB_LOG_DEBUG << "Get host watchodg";
1538 crow::connections::systemBus->async_method_call(
1539 [aResp](const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001540 PropertiesType& properties) {
Yong Li51709ff2019-09-30 14:13:04 +08001541 if (ec)
1542 {
1543 // watchdog service is stopped
1544 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
1545 return;
1546 }
1547
1548 BMCWEB_LOG_DEBUG << "Got " << properties.size() << " wdt prop.";
1549
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001550 nlohmann::json& hostWatchdogTimer =
Yong Li51709ff2019-09-30 14:13:04 +08001551 aResp->res.jsonValue["HostWatchdogTimer"];
1552
1553 // watchdog service is running/enabled
1554 hostWatchdogTimer["Status"]["State"] = "Enabled";
1555
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001556 for (const auto& property : properties)
Yong Li51709ff2019-09-30 14:13:04 +08001557 {
1558 BMCWEB_LOG_DEBUG << "prop=" << property.first;
1559 if (property.first == "Enabled")
1560 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001561 const bool* state = std::get_if<bool>(&property.second);
Yong Li51709ff2019-09-30 14:13:04 +08001562
1563 if (!state)
1564 {
1565 messages::internalError(aResp->res);
1566 continue;
1567 }
1568
1569 hostWatchdogTimer["FunctionEnabled"] = *state;
1570 }
1571 else if (property.first == "ExpireAction")
1572 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001573 const std::string* s =
Yong Li51709ff2019-09-30 14:13:04 +08001574 std::get_if<std::string>(&property.second);
1575 if (!s)
1576 {
1577 messages::internalError(aResp->res);
1578 continue;
1579 }
1580
1581 std::string action = dbusToRfWatchdogAction(*s);
1582 if (action.empty())
1583 {
1584 messages::internalError(aResp->res);
1585 continue;
1586 }
1587 hostWatchdogTimer["TimeoutAction"] = action;
1588 }
1589 }
1590 },
1591 "xyz.openbmc_project.Watchdog", "/xyz/openbmc_project/watchdog/host0",
1592 "org.freedesktop.DBus.Properties", "GetAll",
1593 "xyz.openbmc_project.State.Watchdog");
1594}
1595
1596/**
Yong Lic45f0082019-10-10 14:19:01 +08001597 * @brief Sets Host WatchDog Timer properties.
1598 *
1599 * @param[in] aResp Shared pointer for generating response message.
1600 * @param[in] wdtEnable The WDTimer Enable value (true/false) from incoming
1601 * RF request.
1602 * @param[in] wdtTimeOutAction The WDT Timeout action, from incoming RF request.
1603 *
1604 * @return None.
1605 */
Ed Tanous23a21a12020-07-25 04:45:05 +00001606inline void setWDTProperties(std::shared_ptr<AsyncResp> aResp,
Yong Lic45f0082019-10-10 14:19:01 +08001607 const std::optional<bool> wdtEnable,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001608 const std::optional<std::string>& wdtTimeOutAction)
Yong Lic45f0082019-10-10 14:19:01 +08001609{
1610 BMCWEB_LOG_DEBUG << "Set host watchdog";
1611
1612 if (wdtTimeOutAction)
1613 {
1614 std::string wdtTimeOutActStr = rfToDbusWDTTimeOutAct(*wdtTimeOutAction);
1615 // check if TimeOut Action is Valid
1616 if (wdtTimeOutActStr.empty())
1617 {
1618 BMCWEB_LOG_DEBUG << "Unsupported value for TimeoutAction: "
1619 << *wdtTimeOutAction;
1620 messages::propertyValueNotInList(aResp->res, *wdtTimeOutAction,
1621 "TimeoutAction");
1622 return;
1623 }
1624
1625 crow::connections::systemBus->async_method_call(
1626 [aResp](const boost::system::error_code ec) {
1627 if (ec)
1628 {
1629 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
1630 messages::internalError(aResp->res);
1631 return;
1632 }
1633 },
1634 "xyz.openbmc_project.Watchdog",
1635 "/xyz/openbmc_project/watchdog/host0",
1636 "org.freedesktop.DBus.Properties", "Set",
1637 "xyz.openbmc_project.State.Watchdog", "ExpireAction",
1638 std::variant<std::string>(wdtTimeOutActStr));
1639 }
1640
1641 if (wdtEnable)
1642 {
1643 crow::connections::systemBus->async_method_call(
1644 [aResp](const boost::system::error_code ec) {
1645 if (ec)
1646 {
1647 BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
1648 messages::internalError(aResp->res);
1649 return;
1650 }
1651 },
1652 "xyz.openbmc_project.Watchdog",
1653 "/xyz/openbmc_project/watchdog/host0",
1654 "org.freedesktop.DBus.Properties", "Set",
1655 "xyz.openbmc_project.State.Watchdog", "Enabled",
1656 std::variant<bool>(*wdtEnable));
1657 }
1658}
1659
1660/**
Lewanczyk, Dawidc5b2abe2018-05-30 16:59:42 +02001661 * SystemsCollection derived class for delivering ComputerSystems Collection
1662 * Schema
1663 */
Ed Tanous1abe55e2018-09-05 08:30:59 -07001664class SystemsCollection : public Node
1665{
1666 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07001667 SystemsCollection(App& app) : Node(app, "/redfish/v1/Systems/")
Ed Tanous1abe55e2018-09-05 08:30:59 -07001668 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07001669 entityPrivileges = {
1670 {boost::beast::http::verb::get, {{"Login"}}},
1671 {boost::beast::http::verb::head, {{"Login"}}},
1672 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}},
1673 {boost::beast::http::verb::put, {{"ConfigureComponents"}}},
1674 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}},
1675 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
1676 }
Lewanczyk, Dawidc5b2abe2018-05-30 16:59:42 +02001677
Ed Tanous1abe55e2018-09-05 08:30:59 -07001678 private:
Ed Tanouscb13a392020-07-25 19:02:03 +00001679 void doGet(crow::Response& res, const crow::Request&,
1680 const std::vector<std::string>&) override
Ed Tanous1abe55e2018-09-05 08:30:59 -07001681 {
Sunitha Harish462023a2020-02-19 08:34:59 -06001682 std::shared_ptr<AsyncResp> asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous0f74e642018-11-12 15:17:05 -08001683 res.jsonValue["@odata.type"] =
1684 "#ComputerSystemCollection.ComputerSystemCollection";
1685 res.jsonValue["@odata.id"] = "/redfish/v1/Systems";
Ed Tanous0f74e642018-11-12 15:17:05 -08001686 res.jsonValue["Name"] = "Computer System Collection";
Sunitha Harish462023a2020-02-19 08:34:59 -06001687
1688 crow::connections::systemBus->async_method_call(
1689 [asyncResp](const boost::system::error_code ec,
Ed Tanouscb13a392020-07-25 19:02:03 +00001690 const std::variant<std::string>& /*hostName*/) {
Ed Tanous2c70f802020-09-28 14:29:23 -07001691 nlohmann::json& ifaceArray =
Sunitha Harish462023a2020-02-19 08:34:59 -06001692 asyncResp->res.jsonValue["Members"];
Ed Tanous2c70f802020-09-28 14:29:23 -07001693 ifaceArray = nlohmann::json::array();
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001694 auto& count = asyncResp->res.jsonValue["Members@odata.count"];
Sunitha Harish462023a2020-02-19 08:34:59 -06001695 count = 0;
Ed Tanous2c70f802020-09-28 14:29:23 -07001696 ifaceArray.push_back(
Ed Tanouscb13a392020-07-25 19:02:03 +00001697 {{"@odata.id", "/redfish/v1/Systems/system"}});
1698 if (!ec)
Sunitha Harish462023a2020-02-19 08:34:59 -06001699 {
Ed Tanouscb13a392020-07-25 19:02:03 +00001700 BMCWEB_LOG_DEBUG << "Hypervisor is available";
Ed Tanous2c70f802020-09-28 14:29:23 -07001701 ifaceArray.push_back(
Ed Tanouscb13a392020-07-25 19:02:03 +00001702 {{"@odata.id", "/redfish/v1/Systems/hypervisor"}});
Ed Tanous2c70f802020-09-28 14:29:23 -07001703 count = ifaceArray.size();
Sunitha Harish462023a2020-02-19 08:34:59 -06001704 return;
1705 }
Sunitha Harish462023a2020-02-19 08:34:59 -06001706 },
Sunitha Harish8e651fb2020-06-17 06:06:25 -05001707 "xyz.openbmc_project.Settings",
1708 "/xyz/openbmc_project/network/hypervisor",
Sunitha Harish462023a2020-02-19 08:34:59 -06001709 "org.freedesktop.DBus.Properties", "Get",
1710 "xyz.openbmc_project.Network.SystemConfiguration", "HostName");
Ed Tanous1abe55e2018-09-05 08:30:59 -07001711 }
Lewanczyk, Dawidc5b2abe2018-05-30 16:59:42 +02001712};
1713
1714/**
Ed Tanouscc340dd2018-08-29 13:43:38 -07001715 * SystemActionsReset class supports handle POST method for Reset action.
1716 * The class retrieves and sends data directly to D-Bus.
1717 */
1718class SystemActionsReset : public Node
1719{
1720 public:
Ed Tanous52cc1122020-07-18 13:51:21 -07001721 SystemActionsReset(App& app) :
Ed Tanous029573d2019-02-01 10:57:49 -08001722 Node(app, "/redfish/v1/Systems/system/Actions/ComputerSystem.Reset/")
Ed Tanouscc340dd2018-08-29 13:43:38 -07001723 {
1724 entityPrivileges = {
1725 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
1726 }
1727
1728 private:
1729 /**
1730 * Function handles POST method request.
1731 * Analyzes POST body message before sends Reset request data to D-Bus.
1732 */
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001733 void doPost(crow::Response& res, const crow::Request& req,
Ed Tanouscb13a392020-07-25 19:02:03 +00001734 const std::vector<std::string>&) override
Ed Tanouscc340dd2018-08-29 13:43:38 -07001735 {
Ed Tanous9712f8a2018-09-21 13:38:49 -07001736 auto asyncResp = std::make_shared<AsyncResp>(res);
1737
1738 std::string resetType;
1739 if (!json_util::readJson(req, res, "ResetType", resetType))
Ed Tanouscc340dd2018-08-29 13:43:38 -07001740 {
1741 return;
1742 }
1743
Jason M. Billsd22c8392019-06-03 13:59:03 -07001744 // Get the command and host vs. chassis
Ed Tanous9712f8a2018-09-21 13:38:49 -07001745 std::string command;
Jason M. Billsd22c8392019-06-03 13:59:03 -07001746 bool hostCommand;
Ed Tanousd4d25792020-09-29 15:15:03 -07001747 if ((resetType == "On") || (resetType == "ForceOn"))
Ed Tanous9712f8a2018-09-21 13:38:49 -07001748 {
1749 command = "xyz.openbmc_project.State.Host.Transition.On";
Jason M. Billsd22c8392019-06-03 13:59:03 -07001750 hostCommand = true;
1751 }
1752 else if (resetType == "ForceOff")
1753 {
1754 command = "xyz.openbmc_project.State.Chassis.Transition.Off";
1755 hostCommand = false;
1756 }
Jason M. Billsd22c8392019-06-03 13:59:03 -07001757 else if (resetType == "ForceRestart")
1758 {
Jason M. Bills86a08512020-02-04 13:15:49 -08001759 command =
1760 "xyz.openbmc_project.State.Host.Transition.ForceWarmReboot";
1761 hostCommand = true;
Ed Tanous9712f8a2018-09-21 13:38:49 -07001762 }
1763 else if (resetType == "GracefulShutdown")
1764 {
1765 command = "xyz.openbmc_project.State.Host.Transition.Off";
Jason M. Billsd22c8392019-06-03 13:59:03 -07001766 hostCommand = true;
Ed Tanous9712f8a2018-09-21 13:38:49 -07001767 }
1768 else if (resetType == "GracefulRestart")
1769 {
Jason M. Bills86a08512020-02-04 13:15:49 -08001770 command =
1771 "xyz.openbmc_project.State.Host.Transition.GracefulWarmReboot";
Jason M. Billsd22c8392019-06-03 13:59:03 -07001772 hostCommand = true;
1773 }
1774 else if (resetType == "PowerCycle")
1775 {
Jason M. Bills86a08512020-02-04 13:15:49 -08001776 command = "xyz.openbmc_project.State.Host.Transition.Reboot";
1777 hostCommand = true;
Ed Tanous9712f8a2018-09-21 13:38:49 -07001778 }
Lakshminarayana R. Kammathbfd5b822019-06-17 12:11:01 -05001779 else if (resetType == "Nmi")
1780 {
1781 doNMI(asyncResp);
1782 return;
1783 }
Ed Tanous9712f8a2018-09-21 13:38:49 -07001784 else
1785 {
Jason M. Billsf12894f2018-10-09 12:45:45 -07001786 messages::actionParameterUnknown(res, "Reset", resetType);
Ed Tanous9712f8a2018-09-21 13:38:49 -07001787 return;
1788 }
1789
Jason M. Billsd22c8392019-06-03 13:59:03 -07001790 if (hostCommand)
1791 {
1792 crow::connections::systemBus->async_method_call(
1793 [asyncResp, resetType](const boost::system::error_code ec) {
1794 if (ec)
1795 {
1796 BMCWEB_LOG_ERROR << "D-Bus responses error: " << ec;
1797 if (ec.value() == boost::asio::error::invalid_argument)
1798 {
1799 messages::actionParameterNotSupported(
1800 asyncResp->res, resetType, "Reset");
1801 }
1802 else
1803 {
1804 messages::internalError(asyncResp->res);
1805 }
1806 return;
1807 }
1808 messages::success(asyncResp->res);
1809 },
1810 "xyz.openbmc_project.State.Host",
1811 "/xyz/openbmc_project/state/host0",
1812 "org.freedesktop.DBus.Properties", "Set",
1813 "xyz.openbmc_project.State.Host", "RequestedHostTransition",
1814 std::variant<std::string>{command});
1815 }
1816 else
1817 {
1818 crow::connections::systemBus->async_method_call(
1819 [asyncResp, resetType](const boost::system::error_code ec) {
1820 if (ec)
1821 {
1822 BMCWEB_LOG_ERROR << "D-Bus responses error: " << ec;
1823 if (ec.value() == boost::asio::error::invalid_argument)
1824 {
1825 messages::actionParameterNotSupported(
1826 asyncResp->res, resetType, "Reset");
1827 }
1828 else
1829 {
1830 messages::internalError(asyncResp->res);
1831 }
1832 return;
1833 }
1834 messages::success(asyncResp->res);
1835 },
1836 "xyz.openbmc_project.State.Chassis",
1837 "/xyz/openbmc_project/state/chassis0",
1838 "org.freedesktop.DBus.Properties", "Set",
1839 "xyz.openbmc_project.State.Chassis", "RequestedPowerTransition",
1840 std::variant<std::string>{command});
1841 }
Ed Tanouscc340dd2018-08-29 13:43:38 -07001842 }
Lakshminarayana R. Kammathbfd5b822019-06-17 12:11:01 -05001843 /**
1844 * Function transceives data with dbus directly.
1845 */
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001846 void doNMI(const std::shared_ptr<AsyncResp>& asyncResp)
Lakshminarayana R. Kammathbfd5b822019-06-17 12:11:01 -05001847 {
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001848 constexpr char const* serviceName =
Lakshminarayana R. Kammathbfd5b822019-06-17 12:11:01 -05001849 "xyz.openbmc_project.Control.Host.NMI";
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001850 constexpr char const* objectPath =
Lakshminarayana R. Kammathbfd5b822019-06-17 12:11:01 -05001851 "/xyz/openbmc_project/control/host0/nmi";
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001852 constexpr char const* interfaceName =
Lakshminarayana R. Kammathbfd5b822019-06-17 12:11:01 -05001853 "xyz.openbmc_project.Control.Host.NMI";
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001854 constexpr char const* method = "NMI";
Lakshminarayana R. Kammathbfd5b822019-06-17 12:11:01 -05001855
1856 crow::connections::systemBus->async_method_call(
1857 [asyncResp](const boost::system::error_code ec) {
1858 if (ec)
1859 {
1860 BMCWEB_LOG_ERROR << " Bad D-Bus request error: " << ec;
1861 messages::internalError(asyncResp->res);
1862 return;
1863 }
1864 messages::success(asyncResp->res);
1865 },
1866 serviceName, objectPath, interfaceName, method);
1867 }
Ed Tanouscc340dd2018-08-29 13:43:38 -07001868};
1869
1870/**
Ed Tanous66173382018-08-15 18:20:59 -07001871 * Systems derived class for delivering Computer Systems Schema.
Lewanczyk, Dawidc5b2abe2018-05-30 16:59:42 +02001872 */
Ed Tanous1abe55e2018-09-05 08:30:59 -07001873class Systems : public Node
1874{
1875 public:
1876 /*
1877 * Default Constructor
1878 */
Ed Tanous52cc1122020-07-18 13:51:21 -07001879 Systems(App& app) : Node(app, "/redfish/v1/Systems/system/")
Ed Tanous1abe55e2018-09-05 08:30:59 -07001880 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07001881 entityPrivileges = {
1882 {boost::beast::http::verb::get, {{"Login"}}},
1883 {boost::beast::http::verb::head, {{"Login"}}},
1884 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}},
1885 {boost::beast::http::verb::put, {{"ConfigureComponents"}}},
1886 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}},
1887 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
Lewanczyk, Dawidc5b2abe2018-05-30 16:59:42 +02001888 }
1889
Ed Tanous1abe55e2018-09-05 08:30:59 -07001890 private:
Ed Tanous1abe55e2018-09-05 08:30:59 -07001891 /**
1892 * Functions triggers appropriate requests on DBus
1893 */
Ed Tanouscb13a392020-07-25 19:02:03 +00001894 void doGet(crow::Response& res, const crow::Request&,
1895 const std::vector<std::string>&) override
Ed Tanous1abe55e2018-09-05 08:30:59 -07001896 {
Gunnar Millsc0557e12020-06-30 11:26:20 -05001897 res.jsonValue["@odata.type"] = "#ComputerSystem.v1_12_0.ComputerSystem";
Gunnar Mills450a25c2020-04-14 21:34:07 -05001898 res.jsonValue["Name"] = "system";
Ed Tanous029573d2019-02-01 10:57:49 -08001899 res.jsonValue["Id"] = "system";
Ed Tanous0f74e642018-11-12 15:17:05 -08001900 res.jsonValue["SystemType"] = "Physical";
1901 res.jsonValue["Description"] = "Computer System";
Ed Tanous0f74e642018-11-12 15:17:05 -08001902 res.jsonValue["ProcessorSummary"]["Count"] = 0;
1903 res.jsonValue["ProcessorSummary"]["Status"]["State"] = "Disabled";
Cheng C Yang5fd7ba62019-11-28 15:58:08 +08001904 res.jsonValue["MemorySummary"]["TotalSystemMemoryGiB"] = uint64_t(0);
Ed Tanous0f74e642018-11-12 15:17:05 -08001905 res.jsonValue["MemorySummary"]["Status"]["State"] = "Disabled";
Ed Tanous029573d2019-02-01 10:57:49 -08001906 res.jsonValue["@odata.id"] = "/redfish/v1/Systems/system";
Ed Tanous04a258f2018-10-15 08:00:41 -07001907
Rapkiewicz, Pawel443c2932018-10-22 15:08:49 +02001908 res.jsonValue["Processors"] = {
Ed Tanous029573d2019-02-01 10:57:49 -08001909 {"@odata.id", "/redfish/v1/Systems/system/Processors"}};
Rapkiewicz, Pawel443c2932018-10-22 15:08:49 +02001910 res.jsonValue["Memory"] = {
Ed Tanous029573d2019-02-01 10:57:49 -08001911 {"@odata.id", "/redfish/v1/Systems/system/Memory"}};
Nikhil Potadea25aecc2019-08-23 16:35:26 -07001912 res.jsonValue["Storage"] = {
1913 {"@odata.id", "/redfish/v1/Systems/system/Storage"}};
Ed Tanous029573d2019-02-01 10:57:49 -08001914
Ed Tanouscc340dd2018-08-29 13:43:38 -07001915 res.jsonValue["Actions"]["#ComputerSystem.Reset"] = {
1916 {"target",
Ed Tanous029573d2019-02-01 10:57:49 -08001917 "/redfish/v1/Systems/system/Actions/ComputerSystem.Reset"},
AppaRao Puli1cb1a9e2020-07-17 23:38:57 +05301918 {"@Redfish.ActionInfo",
1919 "/redfish/v1/Systems/system/ResetActionInfo"}};
Lewanczyk, Dawidc5b2abe2018-05-30 16:59:42 +02001920
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001921 res.jsonValue["LogServices"] = {
Ed Tanous029573d2019-02-01 10:57:49 -08001922 {"@odata.id", "/redfish/v1/Systems/system/LogServices"}};
Jason M. Billsc4bf6372018-11-05 13:48:27 -08001923
Carol Wangd82a3ac2019-11-21 13:56:38 +08001924 res.jsonValue["Bios"] = {
1925 {"@odata.id", "/redfish/v1/Systems/system/Bios"}};
1926
Jennifer Leec5d03ff2019-03-08 15:42:58 -08001927 res.jsonValue["Links"]["ManagedBy"] = {
1928 {{"@odata.id", "/redfish/v1/Managers/bmc"}}};
1929
1930 res.jsonValue["Status"] = {
1931 {"Health", "OK"},
1932 {"State", "Enabled"},
1933 };
Ed Tanousa0803ef2018-08-29 13:29:23 -07001934 auto asyncResp = std::make_shared<AsyncResp>(res);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001935
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001936 constexpr const std::array<const char*, 4> inventoryForSystems = {
James Feistb49ac872019-05-21 15:12:01 -07001937 "xyz.openbmc_project.Inventory.Item.Dimm",
James Feist2ad9c2f2019-10-29 16:26:48 -07001938 "xyz.openbmc_project.Inventory.Item.Cpu",
James Feiste284a7c2019-11-20 16:20:23 -08001939 "xyz.openbmc_project.Inventory.Item.Drive",
1940 "xyz.openbmc_project.Inventory.Item.StorageController"};
James Feistb49ac872019-05-21 15:12:01 -07001941
1942 auto health = std::make_shared<HealthPopulate>(asyncResp);
1943 crow::connections::systemBus->async_method_call(
1944 [health](const boost::system::error_code ec,
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001945 std::vector<std::string>& resp) {
James Feistb49ac872019-05-21 15:12:01 -07001946 if (ec)
1947 {
1948 // no inventory
1949 return;
1950 }
1951
1952 health->inventory = std::move(resp);
1953 },
1954 "xyz.openbmc_project.ObjectMapper",
1955 "/xyz/openbmc_project/object_mapper",
1956 "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths", "/",
1957 int32_t(0), inventoryForSystems);
1958
1959 health->populate();
1960
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001961 getMainChassisId(asyncResp, [](const std::string& chassisId,
Jennifer Leec5d03ff2019-03-08 15:42:58 -08001962 std::shared_ptr<AsyncResp> aRsp) {
1963 aRsp->res.jsonValue["Links"]["Chassis"] = {
1964 {{"@odata.id", "/redfish/v1/Chassis/" + chassisId}}};
1965 });
AppaRao Pulia3002222019-11-12 21:32:59 +05301966
1967 getIndicatorLedState(asyncResp);
James Feist5bc2dc82019-10-22 14:33:16 -07001968 getComputerSystem(asyncResp, health);
Ed Tanous6c34de42018-08-29 13:37:36 -07001969 getHostState(asyncResp);
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301970 getBootProperties(asyncResp);
Jason M. Billsadbe1922019-10-14 15:44:35 -07001971 getPCIeDeviceList(asyncResp, "PCIeDevices");
Yong Li51709ff2019-09-30 14:13:04 +08001972 getHostWatchdogTimer(asyncResp);
George Liuc6a620f2020-04-10 17:18:11 +08001973 getPowerRestorePolicy(asyncResp);
Gunnar Mills6bd5a8d2020-05-16 18:49:33 -05001974 getAutomaticRetry(asyncResp);
Gunnar Millsc0557e12020-06-30 11:26:20 -05001975 getLastResetTime(asyncResp);
AppaRao Pulia6349912019-10-18 17:16:08 +05301976#ifdef BMCWEB_ENABLE_REDFISH_PROVISIONING_FEATURE
1977 getProvisioningStatus(asyncResp);
1978#endif
Lewanczyk, Dawidc5b2abe2018-05-30 16:59:42 +02001979 }
1980
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001981 void doPatch(crow::Response& res, const crow::Request& req,
Ed Tanouscb13a392020-07-25 19:02:03 +00001982 const std::vector<std::string>&) override
Ed Tanous1abe55e2018-09-05 08:30:59 -07001983 {
Santosh Puranikcde19e52019-02-20 00:10:56 +05301984 std::optional<std::string> indicatorLed;
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301985 std::optional<nlohmann::json> bootProps;
Yong Lic45f0082019-10-10 14:19:01 +08001986 std::optional<nlohmann::json> wdtTimerProps;
George Liuc6a620f2020-04-10 17:18:11 +08001987 std::optional<std::string> powerRestorePolicy;
Santosh Puranik41352c22019-07-03 05:35:49 -05001988 auto asyncResp = std::make_shared<AsyncResp>(res);
1989
Johnathan Mantey944ffaf2019-08-12 16:16:14 -07001990 if (!json_util::readJson(req, res, "IndicatorLED", indicatorLed, "Boot",
George Liuc6a620f2020-04-10 17:18:11 +08001991 bootProps, "WatchdogTimer", wdtTimerProps,
1992 "PowerRestorePolicy", powerRestorePolicy))
Ed Tanous66173382018-08-15 18:20:59 -07001993 {
Ed Tanous9712f8a2018-09-21 13:38:49 -07001994 return;
1995 }
Santosh Puranik491d8ee2019-02-06 19:46:56 +05301996
Johnathan Mantey944ffaf2019-08-12 16:16:14 -07001997 res.result(boost::beast::http::status::no_content);
Yong Lic45f0082019-10-10 14:19:01 +08001998
1999 if (wdtTimerProps)
2000 {
2001 std::optional<bool> wdtEnable;
2002 std::optional<std::string> wdtTimeOutAction;
2003
2004 if (!json_util::readJson(*wdtTimerProps, asyncResp->res,
2005 "FunctionEnabled", wdtEnable,
2006 "TimeoutAction", wdtTimeOutAction))
2007 {
2008 return;
2009 }
2010 setWDTProperties(asyncResp, std::move(wdtEnable),
2011 std::move(wdtTimeOutAction));
2012 }
2013
Santosh Puranik491d8ee2019-02-06 19:46:56 +05302014 if (bootProps)
2015 {
2016 std::optional<std::string> bootSource;
2017 std::optional<std::string> bootEnable;
Gunnar Mills69f35302020-05-17 16:06:31 -05002018 std::optional<std::string> automaticRetryConfig;
Santosh Puranik491d8ee2019-02-06 19:46:56 +05302019
Gunnar Mills69f35302020-05-17 16:06:31 -05002020 if (!json_util::readJson(
2021 *bootProps, asyncResp->res, "BootSourceOverrideTarget",
2022 bootSource, "BootSourceOverrideEnabled", bootEnable,
2023 "AutomaticRetryConfig", automaticRetryConfig))
Santosh Puranik491d8ee2019-02-06 19:46:56 +05302024 {
2025 return;
2026 }
Gunnar Mills69f35302020-05-17 16:06:31 -05002027 if (bootSource || bootEnable)
2028 {
2029 setBootSourceProperties(asyncResp, std::move(bootSource),
2030 std::move(bootEnable));
2031 }
2032 if (automaticRetryConfig)
2033 {
2034 setAutomaticRetry(asyncResp, std::move(*automaticRetryConfig));
2035 }
Santosh Puranik491d8ee2019-02-06 19:46:56 +05302036 }
Johnathan Mantey265c1602019-08-08 11:02:51 -07002037
Ed Tanous9712f8a2018-09-21 13:38:49 -07002038 if (indicatorLed)
2039 {
AppaRao Pulia3002222019-11-12 21:32:59 +05302040 setIndicatorLedState(asyncResp, std::move(*indicatorLed));
Ed Tanous1abe55e2018-09-05 08:30:59 -07002041 }
George Liuc6a620f2020-04-10 17:18:11 +08002042
2043 if (powerRestorePolicy)
2044 {
2045 setPowerRestorePolicy(asyncResp, std::move(*powerRestorePolicy));
2046 }
Lewanczyk, Dawidc5b2abe2018-05-30 16:59:42 +02002047 }
Lewanczyk, Dawidc5b2abe2018-05-30 16:59:42 +02002048};
AppaRao Puli1cb1a9e2020-07-17 23:38:57 +05302049
2050/**
2051 * SystemResetActionInfo derived class for delivering Computer Systems
2052 * ResetType AllowableValues using ResetInfo schema.
2053 */
2054class SystemResetActionInfo : public Node
2055{
2056 public:
2057 /*
2058 * Default Constructor
2059 */
Ed Tanous52cc1122020-07-18 13:51:21 -07002060 SystemResetActionInfo(App& app) :
AppaRao Puli1cb1a9e2020-07-17 23:38:57 +05302061 Node(app, "/redfish/v1/Systems/system/ResetActionInfo/")
2062 {
2063 entityPrivileges = {
2064 {boost::beast::http::verb::get, {{"Login"}}},
2065 {boost::beast::http::verb::head, {{"Login"}}},
2066 {boost::beast::http::verb::patch, {{"ConfigureComponents"}}},
2067 {boost::beast::http::verb::put, {{"ConfigureComponents"}}},
2068 {boost::beast::http::verb::delete_, {{"ConfigureComponents"}}},
2069 {boost::beast::http::verb::post, {{"ConfigureComponents"}}}};
2070 }
2071
2072 private:
2073 /**
2074 * Functions triggers appropriate requests on DBus
2075 */
Ed Tanouscb13a392020-07-25 19:02:03 +00002076 void doGet(crow::Response& res, const crow::Request&,
2077 const std::vector<std::string>&) override
AppaRao Puli1cb1a9e2020-07-17 23:38:57 +05302078 {
2079 res.jsonValue = {
2080 {"@odata.type", "#ActionInfo.v1_1_2.ActionInfo"},
2081 {"@odata.id", "/redfish/v1/Systems/system/ResetActionInfo"},
2082 {"Name", "Reset Action Info"},
2083 {"Id", "ResetActionInfo"},
2084 {"Parameters",
2085 {{{"Name", "ResetType"},
2086 {"Required", true},
2087 {"DataType", "String"},
2088 {"AllowableValues",
2089 {"On", "ForceOff", "ForceOn", "ForceRestart", "GracefulRestart",
2090 "GracefulShutdown", "PowerCycle", "Nmi"}}}}}};
2091 res.end();
2092 }
2093};
Ed Tanous1abe55e2018-09-05 08:30:59 -07002094} // namespace redfish