blob: a2c49a630f6aad7c564785d18e942a8b83c6d707 [file] [log] [blame]
Gunnar Millsac6a4442020-10-14 14:55:29 -05001/*
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
Ed Tanous3ccb3ad2023-01-13 17:40:03 -080018#include "app.hpp"
Jonathan Doman1e1e5982021-06-11 09:36:17 -070019#include "dbus_singleton.hpp"
George Liu7a1dbc42022-12-07 16:03:22 +080020#include "dbus_utility.hpp"
Jonathan Doman1e1e5982021-06-11 09:36:17 -070021#include "error_messages.hpp"
Chris Caindfbf7de2023-04-13 16:01:04 -050022#include "generated/enums/processor.hpp"
Gunnar Millsac6a4442020-10-14 14:55:29 -050023#include "health.hpp"
Ed Tanous3ccb3ad2023-01-13 17:40:03 -080024#include "query.hpp"
25#include "registries/privilege_registry.hpp"
26#include "utils/collection.hpp"
27#include "utils/dbus_utils.hpp"
28#include "utils/json_utils.hpp"
Gunnar Millsac6a4442020-10-14 14:55:29 -050029
30#include <boost/container/flat_map.hpp>
George Liue99073f2022-12-09 11:06:16 +080031#include <boost/system/error_code.hpp>
Ed Tanousef4c65b2023-04-24 15:28:50 -070032#include <boost/url/format.hpp>
Jonathan Doman1e1e5982021-06-11 09:36:17 -070033#include <sdbusplus/asio/property.hpp>
Jonathan Domandba0c292020-12-02 15:34:13 -080034#include <sdbusplus/message/native_types.hpp>
Krzysztof Grobelny351053f2022-07-28 15:44:22 +020035#include <sdbusplus/unpack_properties.hpp>
Jonathan Domandba0c292020-12-02 15:34:13 -080036#include <sdbusplus/utility/dedup_variant.hpp>
Gunnar Millsac6a4442020-10-14 14:55:29 -050037
George Liu7a1dbc42022-12-07 16:03:22 +080038#include <array>
Michael Shenb9d679d2023-02-13 02:29:04 +000039#include <limits>
George Liu7a1dbc42022-12-07 16:03:22 +080040#include <string_view>
41
Gunnar Millsac6a4442020-10-14 14:55:29 -050042namespace redfish
43{
44
Jonathan Domanc9514482021-02-24 09:20:51 -080045// Interfaces which imply a D-Bus object represents a Processor
George Liu7a1dbc42022-12-07 16:03:22 +080046constexpr std::array<std::string_view, 2> processorInterfaces = {
Jonathan Domanc9514482021-02-24 09:20:51 -080047 "xyz.openbmc_project.Inventory.Item.Cpu",
48 "xyz.openbmc_project.Inventory.Item.Accelerator"};
Jonathan Doman2bab9832020-12-02 15:27:40 -080049
Sharad Yadav71b82f22021-05-10 15:11:39 +053050/**
51 * @brief Fill out uuid info of a processor by
52 * requesting data from the given D-Bus object.
53 *
Ed Tanousac106bf2023-06-07 09:24:59 -070054 * @param[in,out] asyncResp Async HTTP response.
Sharad Yadav71b82f22021-05-10 15:11:39 +053055 * @param[in] service D-Bus service to query.
56 * @param[in] objPath D-Bus object to query.
57 */
Ed Tanousac106bf2023-06-07 09:24:59 -070058inline void getProcessorUUID(std::shared_ptr<bmcweb::AsyncResp> asyncResp,
Sharad Yadav71b82f22021-05-10 15:11:39 +053059 const std::string& service,
60 const std::string& objPath)
61{
62 BMCWEB_LOG_DEBUG << "Get Processor UUID";
Jonathan Doman1e1e5982021-06-11 09:36:17 -070063 sdbusplus::asio::getProperty<std::string>(
64 *crow::connections::systemBus, service, objPath,
65 "xyz.openbmc_project.Common.UUID", "UUID",
Ed Tanousac106bf2023-06-07 09:24:59 -070066 [objPath, asyncResp{std::move(asyncResp)}](
67 const boost::system::error_code& ec, const std::string& property) {
Ed Tanous002d39b2022-05-31 08:59:27 -070068 if (ec)
69 {
70 BMCWEB_LOG_DEBUG << "DBUS response error";
Ed Tanousac106bf2023-06-07 09:24:59 -070071 messages::internalError(asyncResp->res);
Ed Tanous002d39b2022-05-31 08:59:27 -070072 return;
73 }
Ed Tanousac106bf2023-06-07 09:24:59 -070074 asyncResp->res.jsonValue["UUID"] = property;
Jonathan Doman1e1e5982021-06-11 09:36:17 -070075 });
Sharad Yadav71b82f22021-05-10 15:11:39 +053076}
77
Ed Tanous711ac7a2021-12-20 09:34:41 -080078inline void getCpuDataByInterface(
Ed Tanousac106bf2023-06-07 09:24:59 -070079 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous711ac7a2021-12-20 09:34:41 -080080 const dbus::utility::DBusInteracesMap& cpuInterfacesProperties)
Gunnar Millsac6a4442020-10-14 14:55:29 -050081{
82 BMCWEB_LOG_DEBUG << "Get CPU resources by interface.";
83
Chicago Duana1649ec2021-03-30 16:54:58 +080084 // Set the default value of state
Ed Tanousac106bf2023-06-07 09:24:59 -070085 asyncResp->res.jsonValue["Status"]["State"] = "Enabled";
86 asyncResp->res.jsonValue["Status"]["Health"] = "OK";
Gunnar Millsac6a4442020-10-14 14:55:29 -050087
88 for (const auto& interface : cpuInterfacesProperties)
89 {
90 for (const auto& property : interface.second)
91 {
Chicago Duana1649ec2021-03-30 16:54:58 +080092 if (property.first == "Present")
Gunnar Millsac6a4442020-10-14 14:55:29 -050093 {
Chicago Duana1649ec2021-03-30 16:54:58 +080094 const bool* cpuPresent = std::get_if<bool>(&property.second);
95 if (cpuPresent == nullptr)
Gunnar Millsac6a4442020-10-14 14:55:29 -050096 {
97 // Important property not in desired type
Ed Tanousac106bf2023-06-07 09:24:59 -070098 messages::internalError(asyncResp->res);
Gunnar Millsac6a4442020-10-14 14:55:29 -050099 return;
100 }
Ed Tanouse05aec52022-01-25 10:28:56 -0800101 if (!*cpuPresent)
Gunnar Millsac6a4442020-10-14 14:55:29 -0500102 {
Chicago Duana1649ec2021-03-30 16:54:58 +0800103 // Slot is not populated
Ed Tanousac106bf2023-06-07 09:24:59 -0700104 asyncResp->res.jsonValue["Status"]["State"] = "Absent";
Chicago Duana1649ec2021-03-30 16:54:58 +0800105 }
106 }
107 else if (property.first == "Functional")
108 {
109 const bool* cpuFunctional = std::get_if<bool>(&property.second);
110 if (cpuFunctional == nullptr)
111 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700112 messages::internalError(asyncResp->res);
Gunnar Millsac6a4442020-10-14 14:55:29 -0500113 return;
114 }
Ed Tanouse05aec52022-01-25 10:28:56 -0800115 if (!*cpuFunctional)
Chicago Duana1649ec2021-03-30 16:54:58 +0800116 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700117 asyncResp->res.jsonValue["Status"]["Health"] = "Critical";
Chicago Duana1649ec2021-03-30 16:54:58 +0800118 }
119 }
120 else if (property.first == "CoreCount")
121 {
122 const uint16_t* coresCount =
123 std::get_if<uint16_t>(&property.second);
124 if (coresCount == nullptr)
125 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700126 messages::internalError(asyncResp->res);
Chicago Duana1649ec2021-03-30 16:54:58 +0800127 return;
128 }
Ed Tanousac106bf2023-06-07 09:24:59 -0700129 asyncResp->res.jsonValue["TotalCores"] = *coresCount;
Gunnar Millsac6a4442020-10-14 14:55:29 -0500130 }
Jonathan Domandc3fa662020-10-26 23:10:24 -0700131 else if (property.first == "MaxSpeedInMhz")
132 {
133 const uint32_t* value = std::get_if<uint32_t>(&property.second);
134 if (value != nullptr)
135 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700136 asyncResp->res.jsonValue["MaxSpeedMHz"] = *value;
Jonathan Domandc3fa662020-10-26 23:10:24 -0700137 }
138 }
Gunnar Millsac6a4442020-10-14 14:55:29 -0500139 else if (property.first == "Socket")
140 {
141 const std::string* value =
142 std::get_if<std::string>(&property.second);
143 if (value != nullptr)
144 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700145 asyncResp->res.jsonValue["Socket"] = *value;
Gunnar Millsac6a4442020-10-14 14:55:29 -0500146 }
147 }
148 else if (property.first == "ThreadCount")
149 {
Jonathan Domandc3fa662020-10-26 23:10:24 -0700150 const uint16_t* value = std::get_if<uint16_t>(&property.second);
Gunnar Millsac6a4442020-10-14 14:55:29 -0500151 if (value != nullptr)
152 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700153 asyncResp->res.jsonValue["TotalThreads"] = *value;
Gunnar Millsac6a4442020-10-14 14:55:29 -0500154 }
155 }
Brandon Kim1930fbd2021-09-14 17:52:51 -0700156 else if (property.first == "EffectiveFamily")
Gunnar Millsac6a4442020-10-14 14:55:29 -0500157 {
Brandon Kim1930fbd2021-09-14 17:52:51 -0700158 const uint16_t* value = std::get_if<uint16_t>(&property.second);
Brad Bishop6169de22022-09-14 13:08:32 -0400159 if (value != nullptr && *value != 2)
Gunnar Millsac6a4442020-10-14 14:55:29 -0500160 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700161 asyncResp->res.jsonValue["ProcessorId"]["EffectiveFamily"] =
Ed Tanous866e4862022-02-17 11:40:25 -0800162 "0x" + intToHexString(*value, 4);
Gunnar Millsac6a4442020-10-14 14:55:29 -0500163 }
164 }
Brandon Kim1930fbd2021-09-14 17:52:51 -0700165 else if (property.first == "EffectiveModel")
166 {
167 const uint16_t* value = std::get_if<uint16_t>(&property.second);
168 if (value == nullptr)
169 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700170 messages::internalError(asyncResp->res);
Brandon Kim1930fbd2021-09-14 17:52:51 -0700171 return;
172 }
Brad Bishop6169de22022-09-14 13:08:32 -0400173 if (*value != 0)
174 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700175 asyncResp->res.jsonValue["ProcessorId"]["EffectiveModel"] =
Brad Bishop6169de22022-09-14 13:08:32 -0400176 "0x" + intToHexString(*value, 4);
177 }
Brandon Kim1930fbd2021-09-14 17:52:51 -0700178 }
Gunnar Millsac6a4442020-10-14 14:55:29 -0500179 else if (property.first == "Id")
180 {
181 const uint64_t* value = std::get_if<uint64_t>(&property.second);
182 if (value != nullptr && *value != 0)
183 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700184 asyncResp->res
Gunnar Millsac6a4442020-10-14 14:55:29 -0500185 .jsonValue["ProcessorId"]["IdentificationRegisters"] =
Ed Tanous866e4862022-02-17 11:40:25 -0800186 "0x" + intToHexString(*value, 16);
Gunnar Millsac6a4442020-10-14 14:55:29 -0500187 }
188 }
Brandon Kim1930fbd2021-09-14 17:52:51 -0700189 else if (property.first == "Microcode")
190 {
191 const uint32_t* value = std::get_if<uint32_t>(&property.second);
192 if (value == nullptr)
193 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700194 messages::internalError(asyncResp->res);
Brandon Kim1930fbd2021-09-14 17:52:51 -0700195 return;
196 }
Brad Bishop6169de22022-09-14 13:08:32 -0400197 if (*value != 0)
198 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700199 asyncResp->res.jsonValue["ProcessorId"]["MicrocodeInfo"] =
Brad Bishop6169de22022-09-14 13:08:32 -0400200 "0x" + intToHexString(*value, 8);
201 }
Brandon Kim1930fbd2021-09-14 17:52:51 -0700202 }
203 else if (property.first == "Step")
204 {
205 const uint16_t* value = std::get_if<uint16_t>(&property.second);
206 if (value == nullptr)
207 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700208 messages::internalError(asyncResp->res);
Brandon Kim1930fbd2021-09-14 17:52:51 -0700209 return;
210 }
Michael Shenb9d679d2023-02-13 02:29:04 +0000211 if (*value != std::numeric_limits<uint16_t>::max())
Brad Bishop6169de22022-09-14 13:08:32 -0400212 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700213 asyncResp->res.jsonValue["ProcessorId"]["Step"] =
Brad Bishop6169de22022-09-14 13:08:32 -0400214 "0x" + intToHexString(*value, 4);
215 }
Brandon Kim1930fbd2021-09-14 17:52:51 -0700216 }
Gunnar Millsac6a4442020-10-14 14:55:29 -0500217 }
218 }
Gunnar Millsac6a4442020-10-14 14:55:29 -0500219}
220
Ed Tanousac106bf2023-06-07 09:24:59 -0700221inline void getCpuDataByService(std::shared_ptr<bmcweb::AsyncResp> asyncResp,
Gunnar Millsac6a4442020-10-14 14:55:29 -0500222 const std::string& cpuId,
223 const std::string& service,
224 const std::string& objPath)
225{
226 BMCWEB_LOG_DEBUG << "Get available system cpu resources by service.";
227
228 crow::connections::systemBus->async_method_call(
Ed Tanousac106bf2023-06-07 09:24:59 -0700229 [cpuId, service, objPath, asyncResp{std::move(asyncResp)}](
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800230 const boost::system::error_code& ec,
Gunnar Millsac6a4442020-10-14 14:55:29 -0500231 const dbus::utility::ManagedObjectType& dbusData) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700232 if (ec)
233 {
234 BMCWEB_LOG_DEBUG << "DBUS response error";
Ed Tanousac106bf2023-06-07 09:24:59 -0700235 messages::internalError(asyncResp->res);
Ed Tanous002d39b2022-05-31 08:59:27 -0700236 return;
237 }
Ed Tanousac106bf2023-06-07 09:24:59 -0700238 asyncResp->res.jsonValue["Id"] = cpuId;
239 asyncResp->res.jsonValue["Name"] = "Processor";
240 asyncResp->res.jsonValue["ProcessorType"] = "CPU";
Gunnar Millsac6a4442020-10-14 14:55:29 -0500241
Ed Tanous002d39b2022-05-31 08:59:27 -0700242 bool slotPresent = false;
243 std::string corePath = objPath + "/core";
244 size_t totalCores = 0;
245 for (const auto& object : dbusData)
246 {
247 if (object.first.str == objPath)
Gunnar Millsac6a4442020-10-14 14:55:29 -0500248 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700249 getCpuDataByInterface(asyncResp, object.second);
Ed Tanous002d39b2022-05-31 08:59:27 -0700250 }
Ed Tanous11ba3972022-07-11 09:50:41 -0700251 else if (object.first.str.starts_with(corePath))
Ed Tanous002d39b2022-05-31 08:59:27 -0700252 {
253 for (const auto& interface : object.second)
Gunnar Millsac6a4442020-10-14 14:55:29 -0500254 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700255 if (interface.first == "xyz.openbmc_project.Inventory.Item")
Gunnar Millsac6a4442020-10-14 14:55:29 -0500256 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700257 for (const auto& property : interface.second)
Gunnar Millsac6a4442020-10-14 14:55:29 -0500258 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700259 if (property.first == "Present")
Gunnar Millsac6a4442020-10-14 14:55:29 -0500260 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700261 const bool* present =
262 std::get_if<bool>(&property.second);
263 if (present != nullptr)
Gunnar Millsac6a4442020-10-14 14:55:29 -0500264 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700265 if (*present)
Gunnar Millsac6a4442020-10-14 14:55:29 -0500266 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700267 slotPresent = true;
268 totalCores++;
Gunnar Millsac6a4442020-10-14 14:55:29 -0500269 }
270 }
271 }
272 }
273 }
274 }
275 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700276 }
277 // In getCpuDataByInterface(), state and health are set
278 // based on the present and functional status. If core
279 // count is zero, then it has a higher precedence.
280 if (slotPresent)
281 {
282 if (totalCores == 0)
Gunnar Millsac6a4442020-10-14 14:55:29 -0500283 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700284 // Slot is not populated, set status end return
Ed Tanousac106bf2023-06-07 09:24:59 -0700285 asyncResp->res.jsonValue["Status"]["State"] = "Absent";
286 asyncResp->res.jsonValue["Status"]["Health"] = "OK";
Gunnar Millsac6a4442020-10-14 14:55:29 -0500287 }
Ed Tanousac106bf2023-06-07 09:24:59 -0700288 asyncResp->res.jsonValue["TotalCores"] = totalCores;
Ed Tanous002d39b2022-05-31 08:59:27 -0700289 }
290 return;
Gunnar Millsac6a4442020-10-14 14:55:29 -0500291 },
292 service, "/xyz/openbmc_project/inventory",
293 "org.freedesktop.DBus.ObjectManager", "GetManagedObjects");
294}
295
Chris Caindfbf7de2023-04-13 16:01:04 -0500296/**
297 * @brief Translates throttle cause DBUS property to redfish.
298 *
299 * @param[in] dbusSource The throttle cause from DBUS
300 *
301 * @return Returns as a string, the throttle cause in Redfish terms. If
302 * translation cannot be done, returns "Unknown" throttle reason.
303 */
304inline processor::ThrottleCause
305 dbusToRfThrottleCause(const std::string& dbusSource)
306{
307 if (dbusSource ==
308 "xyz.openbmc_project.Control.Power.Throttle.ThrottleReasons.ClockLimit")
309 {
310 return processor::ThrottleCause::ClockLimit;
311 }
312 if (dbusSource ==
313 "xyz.openbmc_project.Control.Power.Throttle.ThrottleReasons.ManagementDetectedFault")
314 {
315 return processor::ThrottleCause::ManagementDetectedFault;
316 }
317 if (dbusSource ==
318 "xyz.openbmc_project.Control.Power.Throttle.ThrottleReasons.PowerLimit")
319 {
320 return processor::ThrottleCause::PowerLimit;
321 }
322 if (dbusSource ==
323 "xyz.openbmc_project.Control.Power.Throttle.ThrottleReasons.ThermalLimit")
324 {
325 return processor::ThrottleCause::ThermalLimit;
326 }
327 if (dbusSource ==
328 "xyz.openbmc_project.Control.Power.Throttle.ThrottleReasons.Unknown")
329 {
330 return processor::ThrottleCause::Unknown;
331 }
332 return processor::ThrottleCause::Invalid;
333}
334
335inline void
Ed Tanousac106bf2023-06-07 09:24:59 -0700336 readThrottleProperties(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Chris Caindfbf7de2023-04-13 16:01:04 -0500337 const boost::system::error_code& ec,
338 const dbus::utility::DBusPropertiesMap& properties)
339{
340 if (ec)
341 {
342 BMCWEB_LOG_ERROR << "Processor Throttle getAllProperties error " << ec;
Ed Tanousac106bf2023-06-07 09:24:59 -0700343 messages::internalError(asyncResp->res);
Chris Caindfbf7de2023-04-13 16:01:04 -0500344 return;
345 }
346
347 const bool* status = nullptr;
348 const std::vector<std::string>* causes = nullptr;
349
350 if (!sdbusplus::unpackPropertiesNoThrow(dbus_utils::UnpackErrorPrinter(),
351 properties, "Throttled", status,
352 "ThrottleCauses", causes))
353 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700354 messages::internalError(asyncResp->res);
Chris Caindfbf7de2023-04-13 16:01:04 -0500355 return;
356 }
357
Ed Tanousac106bf2023-06-07 09:24:59 -0700358 asyncResp->res.jsonValue["Throttled"] = *status;
Chris Caindfbf7de2023-04-13 16:01:04 -0500359 nlohmann::json::array_t rCauses;
360 for (const std::string& cause : *causes)
361 {
362 processor::ThrottleCause rfCause = dbusToRfThrottleCause(cause);
363 if (rfCause == processor::ThrottleCause::Invalid)
364 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700365 messages::internalError(asyncResp->res);
Chris Caindfbf7de2023-04-13 16:01:04 -0500366 return;
367 }
368
369 rCauses.emplace_back(rfCause);
370 }
Ed Tanousac106bf2023-06-07 09:24:59 -0700371 asyncResp->res.jsonValue["ThrottleCauses"] = std::move(rCauses);
Chris Caindfbf7de2023-04-13 16:01:04 -0500372}
373
374inline void
Ed Tanousac106bf2023-06-07 09:24:59 -0700375 getThrottleProperties(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Chris Caindfbf7de2023-04-13 16:01:04 -0500376 const std::string& service,
377 const std::string& objectPath)
378{
379 BMCWEB_LOG_DEBUG << "Get processor throttle resources";
380
381 sdbusplus::asio::getAllProperties(
382 *crow::connections::systemBus, service, objectPath,
383 "xyz.openbmc_project.Control.Power.Throttle",
Ed Tanousac106bf2023-06-07 09:24:59 -0700384 [asyncResp](const boost::system::error_code& ec,
385 const dbus::utility::DBusPropertiesMap& properties) {
386 readThrottleProperties(asyncResp, ec, properties);
Chris Caindfbf7de2023-04-13 16:01:04 -0500387 });
388}
389
Ed Tanousac106bf2023-06-07 09:24:59 -0700390inline void getCpuAssetData(std::shared_ptr<bmcweb::AsyncResp> asyncResp,
Gunnar Millsac6a4442020-10-14 14:55:29 -0500391 const std::string& service,
392 const std::string& objPath)
393{
394 BMCWEB_LOG_DEBUG << "Get Cpu Asset Data";
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200395 sdbusplus::asio::getAllProperties(
396 *crow::connections::systemBus, service, objPath,
397 "xyz.openbmc_project.Inventory.Decorator.Asset",
Ed Tanousac106bf2023-06-07 09:24:59 -0700398 [objPath, asyncResp{std::move(asyncResp)}](
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800399 const boost::system::error_code& ec,
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200400 const dbus::utility::DBusPropertiesMap& properties) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700401 if (ec)
402 {
403 BMCWEB_LOG_DEBUG << "DBUS response error";
Ed Tanousac106bf2023-06-07 09:24:59 -0700404 messages::internalError(asyncResp->res);
Ed Tanous002d39b2022-05-31 08:59:27 -0700405 return;
406 }
407
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200408 const std::string* serialNumber = nullptr;
409 const std::string* model = nullptr;
410 const std::string* manufacturer = nullptr;
411 const std::string* partNumber = nullptr;
412 const std::string* sparePartNumber = nullptr;
413
414 const bool success = sdbusplus::unpackPropertiesNoThrow(
415 dbus_utils::UnpackErrorPrinter(), properties, "SerialNumber",
416 serialNumber, "Model", model, "Manufacturer", manufacturer,
417 "PartNumber", partNumber, "SparePartNumber", sparePartNumber);
418
419 if (!success)
Ed Tanous002d39b2022-05-31 08:59:27 -0700420 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700421 messages::internalError(asyncResp->res);
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200422 return;
423 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700424
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200425 if (serialNumber != nullptr && !serialNumber->empty())
426 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700427 asyncResp->res.jsonValue["SerialNumber"] = *serialNumber;
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200428 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700429
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200430 if ((model != nullptr) && !model->empty())
431 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700432 asyncResp->res.jsonValue["Model"] = *model;
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200433 }
434
435 if (manufacturer != nullptr)
436 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700437 asyncResp->res.jsonValue["Manufacturer"] = *manufacturer;
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200438
439 // Otherwise would be unexpected.
440 if (manufacturer->find("Intel") != std::string::npos)
Ed Tanous002d39b2022-05-31 08:59:27 -0700441 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700442 asyncResp->res.jsonValue["ProcessorArchitecture"] = "x86";
443 asyncResp->res.jsonValue["InstructionSet"] = "x86-64";
Ed Tanous002d39b2022-05-31 08:59:27 -0700444 }
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200445 else if (manufacturer->find("IBM") != std::string::npos)
Ed Tanous002d39b2022-05-31 08:59:27 -0700446 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700447 asyncResp->res.jsonValue["ProcessorArchitecture"] = "Power";
448 asyncResp->res.jsonValue["InstructionSet"] = "PowerISA";
Ed Tanous002d39b2022-05-31 08:59:27 -0700449 }
450 }
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200451
452 if (partNumber != nullptr)
453 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700454 asyncResp->res.jsonValue["PartNumber"] = *partNumber;
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200455 }
456
Brad Bishop6169de22022-09-14 13:08:32 -0400457 if (sparePartNumber != nullptr && !sparePartNumber->empty())
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200458 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700459 asyncResp->res.jsonValue["SparePartNumber"] = *sparePartNumber;
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200460 }
461 });
Gunnar Millsac6a4442020-10-14 14:55:29 -0500462}
463
Ed Tanousac106bf2023-06-07 09:24:59 -0700464inline void getCpuRevisionData(std::shared_ptr<bmcweb::AsyncResp> asyncResp,
Gunnar Millsac6a4442020-10-14 14:55:29 -0500465 const std::string& service,
466 const std::string& objPath)
467{
468 BMCWEB_LOG_DEBUG << "Get Cpu Revision Data";
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200469 sdbusplus::asio::getAllProperties(
470 *crow::connections::systemBus, service, objPath,
471 "xyz.openbmc_project.Inventory.Decorator.Revision",
Ed Tanousac106bf2023-06-07 09:24:59 -0700472 [objPath, asyncResp{std::move(asyncResp)}](
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800473 const boost::system::error_code& ec,
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200474 const dbus::utility::DBusPropertiesMap& properties) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700475 if (ec)
476 {
477 BMCWEB_LOG_DEBUG << "DBUS response error";
Ed Tanousac106bf2023-06-07 09:24:59 -0700478 messages::internalError(asyncResp->res);
Ed Tanous002d39b2022-05-31 08:59:27 -0700479 return;
480 }
Gunnar Millsac6a4442020-10-14 14:55:29 -0500481
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200482 const std::string* version = nullptr;
483
484 const bool success = sdbusplus::unpackPropertiesNoThrow(
485 dbus_utils::UnpackErrorPrinter(), properties, "Version", version);
486
487 if (!success)
Ed Tanous002d39b2022-05-31 08:59:27 -0700488 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700489 messages::internalError(asyncResp->res);
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200490 return;
Ed Tanous002d39b2022-05-31 08:59:27 -0700491 }
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200492
493 if (version != nullptr)
494 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700495 asyncResp->res.jsonValue["Version"] = *version;
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200496 }
497 });
Gunnar Millsac6a4442020-10-14 14:55:29 -0500498}
499
zhanghch058d1b46d2021-04-01 11:18:24 +0800500inline void getAcceleratorDataByService(
Ed Tanousac106bf2023-06-07 09:24:59 -0700501 std::shared_ptr<bmcweb::AsyncResp> asyncResp, const std::string& acclrtrId,
zhanghch058d1b46d2021-04-01 11:18:24 +0800502 const std::string& service, const std::string& objPath)
Gunnar Millsac6a4442020-10-14 14:55:29 -0500503{
504 BMCWEB_LOG_DEBUG
505 << "Get available system Accelerator resources by service.";
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200506 sdbusplus::asio::getAllProperties(
507 *crow::connections::systemBus, service, objPath, "",
Ed Tanousac106bf2023-06-07 09:24:59 -0700508 [acclrtrId, asyncResp{std::move(asyncResp)}](
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800509 const boost::system::error_code& ec,
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200510 const dbus::utility::DBusPropertiesMap& properties) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700511 if (ec)
512 {
513 BMCWEB_LOG_DEBUG << "DBUS response error";
Ed Tanousac106bf2023-06-07 09:24:59 -0700514 messages::internalError(asyncResp->res);
Ed Tanous002d39b2022-05-31 08:59:27 -0700515 return;
516 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700517
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200518 const bool* functional = nullptr;
519 const bool* present = nullptr;
520
521 const bool success = sdbusplus::unpackPropertiesNoThrow(
522 dbus_utils::UnpackErrorPrinter(), properties, "Functional",
523 functional, "Present", present);
524
525 if (!success)
Ed Tanous002d39b2022-05-31 08:59:27 -0700526 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700527 messages::internalError(asyncResp->res);
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200528 return;
Ed Tanous002d39b2022-05-31 08:59:27 -0700529 }
Gunnar Millsac6a4442020-10-14 14:55:29 -0500530
Ed Tanous002d39b2022-05-31 08:59:27 -0700531 std::string state = "Enabled";
532 std::string health = "OK";
Gunnar Millsac6a4442020-10-14 14:55:29 -0500533
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200534 if (present != nullptr && !*present)
Ed Tanous002d39b2022-05-31 08:59:27 -0700535 {
536 state = "Absent";
537 }
538
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200539 if (functional != nullptr && !*functional)
Ed Tanous002d39b2022-05-31 08:59:27 -0700540 {
541 if (state == "Enabled")
Gunnar Millsac6a4442020-10-14 14:55:29 -0500542 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700543 health = "Critical";
Gunnar Millsac6a4442020-10-14 14:55:29 -0500544 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700545 }
Gunnar Millsac6a4442020-10-14 14:55:29 -0500546
Ed Tanousac106bf2023-06-07 09:24:59 -0700547 asyncResp->res.jsonValue["Id"] = acclrtrId;
548 asyncResp->res.jsonValue["Name"] = "Processor";
549 asyncResp->res.jsonValue["Status"]["State"] = state;
550 asyncResp->res.jsonValue["Status"]["Health"] = health;
551 asyncResp->res.jsonValue["ProcessorType"] = "Accelerator";
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200552 });
Gunnar Millsac6a4442020-10-14 14:55:29 -0500553}
554
Jonathan Domandba0c292020-12-02 15:34:13 -0800555// OperatingConfig D-Bus Types
556using TurboProfileProperty = std::vector<std::tuple<uint32_t, size_t>>;
557using BaseSpeedPrioritySettingsProperty =
558 std::vector<std::tuple<uint32_t, std::vector<uint32_t>>>;
559// uint32_t and size_t may or may not be the same type, requiring a dedup'd
560// variant
Jonathan Domandba0c292020-12-02 15:34:13 -0800561
562/**
563 * Fill out the HighSpeedCoreIDs in a Processor resource from the given
564 * OperatingConfig D-Bus property.
565 *
Ed Tanousac106bf2023-06-07 09:24:59 -0700566 * @param[in,out] asyncResp Async HTTP response.
Jonathan Domandba0c292020-12-02 15:34:13 -0800567 * @param[in] baseSpeedSettings Full list of base speed priority groups,
568 * to use to determine the list of high
569 * speed cores.
570 */
571inline void highSpeedCoreIdsHandler(
Ed Tanousac106bf2023-06-07 09:24:59 -0700572 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Jonathan Domandba0c292020-12-02 15:34:13 -0800573 const BaseSpeedPrioritySettingsProperty& baseSpeedSettings)
574{
575 // The D-Bus property does not indicate which bucket is the "high
576 // priority" group, so let's discern that by looking for the one with
577 // highest base frequency.
578 auto highPriorityGroup = baseSpeedSettings.cend();
579 uint32_t highestBaseSpeed = 0;
580 for (auto it = baseSpeedSettings.cbegin(); it != baseSpeedSettings.cend();
581 ++it)
582 {
583 const uint32_t baseFreq = std::get<uint32_t>(*it);
584 if (baseFreq > highestBaseSpeed)
585 {
586 highestBaseSpeed = baseFreq;
587 highPriorityGroup = it;
588 }
589 }
590
Ed Tanousac106bf2023-06-07 09:24:59 -0700591 nlohmann::json& jsonCoreIds = asyncResp->res.jsonValue["HighSpeedCoreIDs"];
Jonathan Domandba0c292020-12-02 15:34:13 -0800592 jsonCoreIds = nlohmann::json::array();
593
594 // There may not be any entries in the D-Bus property, so only populate
595 // if there was actually something there.
596 if (highPriorityGroup != baseSpeedSettings.cend())
597 {
598 jsonCoreIds = std::get<std::vector<uint32_t>>(*highPriorityGroup);
599 }
600}
601
602/**
603 * Fill out OperatingConfig related items in a Processor resource by requesting
604 * data from the given D-Bus object.
605 *
Ed Tanousac106bf2023-06-07 09:24:59 -0700606 * @param[in,out] asyncResp Async HTTP response.
Jonathan Domandba0c292020-12-02 15:34:13 -0800607 * @param[in] cpuId CPU D-Bus name.
608 * @param[in] service D-Bus service to query.
609 * @param[in] objPath D-Bus object to query.
610 */
Ed Tanousac106bf2023-06-07 09:24:59 -0700611inline void
612 getCpuConfigData(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
613 const std::string& cpuId, const std::string& service,
614 const std::string& objPath)
Jonathan Domandba0c292020-12-02 15:34:13 -0800615{
616 BMCWEB_LOG_INFO << "Getting CPU operating configs for " << cpuId;
617
618 // First, GetAll CurrentOperatingConfig properties on the object
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200619 sdbusplus::asio::getAllProperties(
620 *crow::connections::systemBus, service, objPath,
621 "xyz.openbmc_project.Control.Processor.CurrentOperatingConfig",
Ed Tanousac106bf2023-06-07 09:24:59 -0700622 [asyncResp, cpuId,
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800623 service](const boost::system::error_code& ec,
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200624 const dbus::utility::DBusPropertiesMap& properties) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700625 if (ec)
626 {
627 BMCWEB_LOG_WARNING << "D-Bus error: " << ec << ", " << ec.message();
Ed Tanousac106bf2023-06-07 09:24:59 -0700628 messages::internalError(asyncResp->res);
Ed Tanous002d39b2022-05-31 08:59:27 -0700629 return;
630 }
Jonathan Domandba0c292020-12-02 15:34:13 -0800631
Ed Tanousac106bf2023-06-07 09:24:59 -0700632 nlohmann::json& json = asyncResp->res.jsonValue;
Jonathan Domandba0c292020-12-02 15:34:13 -0800633
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200634 const sdbusplus::message::object_path* appliedConfig = nullptr;
635 const bool* baseSpeedPriorityEnabled = nullptr;
636
637 const bool success = sdbusplus::unpackPropertiesNoThrow(
638 dbus_utils::UnpackErrorPrinter(), properties, "AppliedConfig",
639 appliedConfig, "BaseSpeedPriorityEnabled",
640 baseSpeedPriorityEnabled);
641
642 if (!success)
Ed Tanous002d39b2022-05-31 08:59:27 -0700643 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700644 messages::internalError(asyncResp->res);
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200645 return;
Ed Tanous002d39b2022-05-31 08:59:27 -0700646 }
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200647
648 if (appliedConfig != nullptr)
649 {
650 const std::string& dbusPath = appliedConfig->str;
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200651 nlohmann::json::object_t operatingConfig;
Ed Tanousef4c65b2023-04-24 15:28:50 -0700652 operatingConfig["@odata.id"] = boost::urls::format(
653 "/redfish/v1/Systems/system/Processors/{}/OperatingConfigs",
654 cpuId);
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200655 json["OperatingConfigs"] = std::move(operatingConfig);
656
657 // Reuse the D-Bus config object name for the Redfish
658 // URI
659 size_t baseNamePos = dbusPath.rfind('/');
660 if (baseNamePos == std::string::npos ||
661 baseNamePos == (dbusPath.size() - 1))
662 {
663 // If the AppliedConfig was somehow not a valid path,
664 // skip adding any more properties, since everything
665 // else is tied to this applied config.
Ed Tanousac106bf2023-06-07 09:24:59 -0700666 messages::internalError(asyncResp->res);
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200667 return;
668 }
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200669 nlohmann::json::object_t appliedOperatingConfig;
Ed Tanousef4c65b2023-04-24 15:28:50 -0700670 appliedOperatingConfig["@odata.id"] = boost::urls::format(
671 "/redfish/v1/Systems/system/Processors/{}/OperatingConfigs/{}",
672 cpuId, dbusPath.substr(baseNamePos + 1));
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200673 json["AppliedOperatingConfig"] = std::move(appliedOperatingConfig);
674
675 // Once we found the current applied config, queue another
676 // request to read the base freq core ids out of that
677 // config.
678 sdbusplus::asio::getProperty<BaseSpeedPrioritySettingsProperty>(
679 *crow::connections::systemBus, service, dbusPath,
680 "xyz.openbmc_project.Inventory.Item.Cpu."
681 "OperatingConfig",
682 "BaseSpeedPrioritySettings",
Ed Tanousac106bf2023-06-07 09:24:59 -0700683 [asyncResp](
Ed Tanous5e7e2dc2023-02-16 10:37:01 -0800684 const boost::system::error_code& ec2,
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200685 const BaseSpeedPrioritySettingsProperty& baseSpeedList) {
686 if (ec2)
687 {
688 BMCWEB_LOG_WARNING << "D-Bus Property Get error: " << ec2;
Ed Tanousac106bf2023-06-07 09:24:59 -0700689 messages::internalError(asyncResp->res);
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200690 return;
691 }
692
Ed Tanousac106bf2023-06-07 09:24:59 -0700693 highSpeedCoreIdsHandler(asyncResp, baseSpeedList);
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200694 });
695 }
696
697 if (baseSpeedPriorityEnabled != nullptr)
698 {
699 json["BaseSpeedPriorityState"] =
700 *baseSpeedPriorityEnabled ? "Enabled" : "Disabled";
701 }
702 });
Jonathan Domandba0c292020-12-02 15:34:13 -0800703}
704
SunnySrivastava1984cba4f442021-01-07 12:48:16 -0600705/**
706 * @brief Fill out location info of a processor by
707 * requesting data from the given D-Bus object.
708 *
Ed Tanousac106bf2023-06-07 09:24:59 -0700709 * @param[in,out] asyncResp Async HTTP response.
SunnySrivastava1984cba4f442021-01-07 12:48:16 -0600710 * @param[in] service D-Bus service to query.
711 * @param[in] objPath D-Bus object to query.
712 */
Ed Tanousac106bf2023-06-07 09:24:59 -0700713inline void getCpuLocationCode(std::shared_ptr<bmcweb::AsyncResp> asyncResp,
SunnySrivastava1984cba4f442021-01-07 12:48:16 -0600714 const std::string& service,
715 const std::string& objPath)
716{
717 BMCWEB_LOG_DEBUG << "Get Cpu Location Data";
Jonathan Doman1e1e5982021-06-11 09:36:17 -0700718 sdbusplus::asio::getProperty<std::string>(
719 *crow::connections::systemBus, service, objPath,
720 "xyz.openbmc_project.Inventory.Decorator.LocationCode", "LocationCode",
Ed Tanousac106bf2023-06-07 09:24:59 -0700721 [objPath, asyncResp{std::move(asyncResp)}](
722 const boost::system::error_code& ec, const std::string& property) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700723 if (ec)
724 {
725 BMCWEB_LOG_DEBUG << "DBUS response error";
Ed Tanousac106bf2023-06-07 09:24:59 -0700726 messages::internalError(asyncResp->res);
Ed Tanous002d39b2022-05-31 08:59:27 -0700727 return;
728 }
SunnySrivastava1984cba4f442021-01-07 12:48:16 -0600729
Ed Tanousac106bf2023-06-07 09:24:59 -0700730 asyncResp->res.jsonValue["Location"]["PartLocation"]["ServiceLabel"] =
Ed Tanous002d39b2022-05-31 08:59:27 -0700731 property;
Jonathan Doman1e1e5982021-06-11 09:36:17 -0700732 });
SunnySrivastava1984cba4f442021-01-07 12:48:16 -0600733}
734
Jonathan Domanc9514482021-02-24 09:20:51 -0800735/**
Jonathan Doman49e429c2021-03-03 13:11:44 -0800736 * Populate the unique identifier in a Processor resource by requesting data
737 * from the given D-Bus object.
738 *
Ed Tanousac106bf2023-06-07 09:24:59 -0700739 * @param[in,out] asyncResp Async HTTP response.
Jonathan Doman49e429c2021-03-03 13:11:44 -0800740 * @param[in] service D-Bus service to query.
741 * @param[in] objPath D-Bus object to query.
742 */
Ed Tanousac106bf2023-06-07 09:24:59 -0700743inline void getCpuUniqueId(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Jonathan Doman49e429c2021-03-03 13:11:44 -0800744 const std::string& service,
745 const std::string& objectPath)
746{
747 BMCWEB_LOG_DEBUG << "Get CPU UniqueIdentifier";
Jonathan Doman1e1e5982021-06-11 09:36:17 -0700748 sdbusplus::asio::getProperty<std::string>(
749 *crow::connections::systemBus, service, objectPath,
750 "xyz.openbmc_project.Inventory.Decorator.UniqueIdentifier",
751 "UniqueIdentifier",
Ed Tanousac106bf2023-06-07 09:24:59 -0700752 [asyncResp](const boost::system::error_code& ec,
753 const std::string& id) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700754 if (ec)
755 {
756 BMCWEB_LOG_ERROR << "Failed to read cpu unique id: " << ec;
Ed Tanousac106bf2023-06-07 09:24:59 -0700757 messages::internalError(asyncResp->res);
Ed Tanous002d39b2022-05-31 08:59:27 -0700758 return;
759 }
Ed Tanousac106bf2023-06-07 09:24:59 -0700760 asyncResp->res
761 .jsonValue["ProcessorId"]["ProtectedIdentificationNumber"] = id;
Jonathan Doman1e1e5982021-06-11 09:36:17 -0700762 });
Jonathan Doman49e429c2021-03-03 13:11:44 -0800763}
764
765/**
Jonathan Domanc9514482021-02-24 09:20:51 -0800766 * Find the D-Bus object representing the requested Processor, and call the
767 * handler with the results. If matching object is not found, add 404 error to
768 * response and don't call the handler.
769 *
770 * @param[in,out] resp Async HTTP response.
771 * @param[in] processorId Redfish Processor Id.
772 * @param[in] handler Callback to continue processing request upon
773 * successfully finding object.
774 */
775template <typename Handler>
zhanghch058d1b46d2021-04-01 11:18:24 +0800776inline void getProcessorObject(const std::shared_ptr<bmcweb::AsyncResp>& resp,
Jonathan Domanc9514482021-02-24 09:20:51 -0800777 const std::string& processorId,
778 Handler&& handler)
Gunnar Millsac6a4442020-10-14 14:55:29 -0500779{
780 BMCWEB_LOG_DEBUG << "Get available system processor resources.";
781
Jonathan Domanc9514482021-02-24 09:20:51 -0800782 // GetSubTree on all interfaces which provide info about a Processor
Chris Caindfbf7de2023-04-13 16:01:04 -0500783 constexpr std::array<std::string_view, 9> interfaces = {
George Liue99073f2022-12-09 11:06:16 +0800784 "xyz.openbmc_project.Common.UUID",
785 "xyz.openbmc_project.Inventory.Decorator.Asset",
786 "xyz.openbmc_project.Inventory.Decorator.Revision",
787 "xyz.openbmc_project.Inventory.Item.Cpu",
788 "xyz.openbmc_project.Inventory.Decorator.LocationCode",
789 "xyz.openbmc_project.Inventory.Item.Accelerator",
790 "xyz.openbmc_project.Control.Processor.CurrentOperatingConfig",
Chris Caindfbf7de2023-04-13 16:01:04 -0500791 "xyz.openbmc_project.Inventory.Decorator.UniqueIdentifier",
792 "xyz.openbmc_project.Control.Power.Throttle"};
George Liue99073f2022-12-09 11:06:16 +0800793 dbus::utility::getSubTree(
794 "/xyz/openbmc_project/inventory", 0, interfaces,
Jonathan Domanc9514482021-02-24 09:20:51 -0800795 [resp, processorId, handler = std::forward<Handler>(handler)](
George Liue99073f2022-12-09 11:06:16 +0800796 const boost::system::error_code& ec,
797 const dbus::utility::MapperGetSubTreeResponse& subtree) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700798 if (ec)
799 {
800 BMCWEB_LOG_DEBUG << "DBUS response error: " << ec;
801 messages::internalError(resp->res);
802 return;
803 }
804 for (const auto& [objectPath, serviceMap] : subtree)
805 {
806 // Ignore any objects which don't end with our desired cpu name
Ed Tanous11ba3972022-07-11 09:50:41 -0700807 if (!objectPath.ends_with(processorId))
Gunnar Millsac6a4442020-10-14 14:55:29 -0500808 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700809 continue;
Gunnar Millsac6a4442020-10-14 14:55:29 -0500810 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700811
812 bool found = false;
813 // Filter out objects that don't have the CPU-specific
814 // interfaces to make sure we can return 404 on non-CPUs
815 // (e.g. /redfish/../Processors/dimm0)
816 for (const auto& [serviceName, interfaceList] : serviceMap)
Gunnar Millsac6a4442020-10-14 14:55:29 -0500817 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700818 if (std::find_first_of(
819 interfaceList.begin(), interfaceList.end(),
820 processorInterfaces.begin(),
821 processorInterfaces.end()) != interfaceList.end())
Gunnar Millsac6a4442020-10-14 14:55:29 -0500822 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700823 found = true;
824 break;
Jonathan Doman2bab9832020-12-02 15:27:40 -0800825 }
Gunnar Millsac6a4442020-10-14 14:55:29 -0500826 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700827
828 if (!found)
829 {
830 continue;
831 }
832
833 // Process the first object which does match our cpu name and
834 // required interfaces, and potentially ignore any other
835 // matching objects. Assume all interfaces we want to process
836 // must be on the same object path.
837
Ed Tanous8a592812022-06-04 09:06:59 -0700838 handler(objectPath, serviceMap);
Ed Tanous002d39b2022-05-31 08:59:27 -0700839 return;
840 }
841 messages::resourceNotFound(resp->res, "Processor", processorId);
George Liue99073f2022-12-09 11:06:16 +0800842 });
Gunnar Millsac6a4442020-10-14 14:55:29 -0500843}
844
Ed Tanousac106bf2023-06-07 09:24:59 -0700845inline void
846 getProcessorData(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
847 const std::string& processorId,
848 const std::string& objectPath,
849 const dbus::utility::MapperServiceMap& serviceMap)
Jonathan Domanc9514482021-02-24 09:20:51 -0800850{
851 for (const auto& [serviceName, interfaceList] : serviceMap)
852 {
853 for (const auto& interface : interfaceList)
854 {
855 if (interface == "xyz.openbmc_project.Inventory.Decorator.Asset")
856 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700857 getCpuAssetData(asyncResp, serviceName, objectPath);
Jonathan Domanc9514482021-02-24 09:20:51 -0800858 }
George Liu0fda0f12021-11-16 10:06:17 +0800859 else if (interface ==
860 "xyz.openbmc_project.Inventory.Decorator.Revision")
Jonathan Domanc9514482021-02-24 09:20:51 -0800861 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700862 getCpuRevisionData(asyncResp, serviceName, objectPath);
Jonathan Domanc9514482021-02-24 09:20:51 -0800863 }
864 else if (interface == "xyz.openbmc_project.Inventory.Item.Cpu")
865 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700866 getCpuDataByService(asyncResp, processorId, serviceName,
Jonathan Domanc9514482021-02-24 09:20:51 -0800867 objectPath);
868 }
George Liu0fda0f12021-11-16 10:06:17 +0800869 else if (interface ==
870 "xyz.openbmc_project.Inventory.Item.Accelerator")
Jonathan Domanc9514482021-02-24 09:20:51 -0800871 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700872 getAcceleratorDataByService(asyncResp, processorId, serviceName,
Jonathan Domanc9514482021-02-24 09:20:51 -0800873 objectPath);
874 }
George Liu0fda0f12021-11-16 10:06:17 +0800875 else if (
876 interface ==
877 "xyz.openbmc_project.Control.Processor.CurrentOperatingConfig")
Jonathan Domanc9514482021-02-24 09:20:51 -0800878 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700879 getCpuConfigData(asyncResp, processorId, serviceName,
880 objectPath);
Jonathan Domanc9514482021-02-24 09:20:51 -0800881 }
George Liu0fda0f12021-11-16 10:06:17 +0800882 else if (interface ==
883 "xyz.openbmc_project.Inventory.Decorator.LocationCode")
Jonathan Domanc9514482021-02-24 09:20:51 -0800884 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700885 getCpuLocationCode(asyncResp, serviceName, objectPath);
Jonathan Domanc9514482021-02-24 09:20:51 -0800886 }
Sharad Yadav71b82f22021-05-10 15:11:39 +0530887 else if (interface == "xyz.openbmc_project.Common.UUID")
888 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700889 getProcessorUUID(asyncResp, serviceName, objectPath);
Sharad Yadav71b82f22021-05-10 15:11:39 +0530890 }
George Liu0fda0f12021-11-16 10:06:17 +0800891 else if (interface ==
892 "xyz.openbmc_project.Inventory.Decorator.UniqueIdentifier")
Jonathan Doman49e429c2021-03-03 13:11:44 -0800893 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700894 getCpuUniqueId(asyncResp, serviceName, objectPath);
Jonathan Doman49e429c2021-03-03 13:11:44 -0800895 }
Chris Caindfbf7de2023-04-13 16:01:04 -0500896 else if (interface == "xyz.openbmc_project.Control.Power.Throttle")
897 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700898 getThrottleProperties(asyncResp, serviceName, objectPath);
Chris Caindfbf7de2023-04-13 16:01:04 -0500899 }
Jonathan Domanc9514482021-02-24 09:20:51 -0800900 }
901 }
902}
903
Jonathan Domandba0c292020-12-02 15:34:13 -0800904/**
905 * Request all the properties for the given D-Bus object and fill out the
906 * related entries in the Redfish OperatingConfig response.
907 *
Ed Tanousac106bf2023-06-07 09:24:59 -0700908 * @param[in,out] asyncResp Async HTTP response.
Jonathan Domandba0c292020-12-02 15:34:13 -0800909 * @param[in] service D-Bus service name to query.
910 * @param[in] objPath D-Bus object to query.
911 */
zhanghch058d1b46d2021-04-01 11:18:24 +0800912inline void
Ed Tanousac106bf2023-06-07 09:24:59 -0700913 getOperatingConfigData(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
zhanghch058d1b46d2021-04-01 11:18:24 +0800914 const std::string& service,
915 const std::string& objPath)
Jonathan Domandba0c292020-12-02 15:34:13 -0800916{
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200917 sdbusplus::asio::getAllProperties(
918 *crow::connections::systemBus, service, objPath,
919 "xyz.openbmc_project.Inventory.Item.Cpu.OperatingConfig",
Ed Tanousac106bf2023-06-07 09:24:59 -0700920 [asyncResp](const boost::system::error_code& ec,
921 const dbus::utility::DBusPropertiesMap& properties) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700922 if (ec)
923 {
924 BMCWEB_LOG_WARNING << "D-Bus error: " << ec << ", " << ec.message();
Ed Tanousac106bf2023-06-07 09:24:59 -0700925 messages::internalError(asyncResp->res);
Ed Tanous002d39b2022-05-31 08:59:27 -0700926 return;
927 }
928
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200929 const size_t* availableCoreCount = nullptr;
930 const uint32_t* baseSpeed = nullptr;
931 const uint32_t* maxJunctionTemperature = nullptr;
932 const uint32_t* maxSpeed = nullptr;
933 const uint32_t* powerLimit = nullptr;
934 const TurboProfileProperty* turboProfile = nullptr;
935 const BaseSpeedPrioritySettingsProperty* baseSpeedPrioritySettings =
936 nullptr;
937
938 const bool success = sdbusplus::unpackPropertiesNoThrow(
939 dbus_utils::UnpackErrorPrinter(), properties, "AvailableCoreCount",
940 availableCoreCount, "BaseSpeed", baseSpeed,
941 "MaxJunctionTemperature", maxJunctionTemperature, "MaxSpeed",
942 maxSpeed, "PowerLimit", powerLimit, "TurboProfile", turboProfile,
943 "BaseSpeedPrioritySettings", baseSpeedPrioritySettings);
944
945 if (!success)
Ed Tanous002d39b2022-05-31 08:59:27 -0700946 {
Ed Tanousac106bf2023-06-07 09:24:59 -0700947 messages::internalError(asyncResp->res);
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200948 return;
949 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700950
Ed Tanousac106bf2023-06-07 09:24:59 -0700951 nlohmann::json& json = asyncResp->res.jsonValue;
Ed Tanous002d39b2022-05-31 08:59:27 -0700952
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200953 if (availableCoreCount != nullptr)
954 {
955 json["TotalAvailableCoreCount"] = *availableCoreCount;
956 }
957
958 if (baseSpeed != nullptr)
959 {
960 json["BaseSpeedMHz"] = *baseSpeed;
961 }
962
963 if (maxJunctionTemperature != nullptr)
964 {
965 json["MaxJunctionTemperatureCelsius"] = *maxJunctionTemperature;
966 }
967
968 if (maxSpeed != nullptr)
969 {
970 json["MaxSpeedMHz"] = *maxSpeed;
971 }
972
973 if (powerLimit != nullptr)
974 {
975 json["TDPWatts"] = *powerLimit;
976 }
977
978 if (turboProfile != nullptr)
979 {
980 nlohmann::json& turboArray = json["TurboProfile"];
981 turboArray = nlohmann::json::array();
982 for (const auto& [turboSpeed, coreCount] : *turboProfile)
983 {
984 nlohmann::json::object_t turbo;
985 turbo["ActiveCoreCount"] = coreCount;
986 turbo["MaxSpeedMHz"] = turboSpeed;
Patrick Williamsb2ba3072023-05-12 10:27:39 -0500987 turboArray.emplace_back(std::move(turbo));
Ed Tanous002d39b2022-05-31 08:59:27 -0700988 }
989 }
Krzysztof Grobelny351053f2022-07-28 15:44:22 +0200990
991 if (baseSpeedPrioritySettings != nullptr)
992 {
993 nlohmann::json& baseSpeedArray = json["BaseSpeedPrioritySettings"];
994 baseSpeedArray = nlohmann::json::array();
995 for (const auto& [baseSpeedMhz, coreList] :
996 *baseSpeedPrioritySettings)
997 {
998 nlohmann::json::object_t speed;
999 speed["CoreCount"] = coreList.size();
1000 speed["CoreIDs"] = coreList;
1001 speed["BaseSpeedMHz"] = baseSpeedMhz;
Patrick Williamsb2ba3072023-05-12 10:27:39 -05001002 baseSpeedArray.emplace_back(std::move(speed));
Krzysztof Grobelny351053f2022-07-28 15:44:22 +02001003 }
1004 }
1005 });
Jonathan Domandba0c292020-12-02 15:34:13 -08001006}
1007
Jonathan Doman3cde86f2020-12-02 14:50:45 -08001008/**
1009 * Handle the D-Bus response from attempting to set the CPU's AppliedConfig
1010 * property. Main task is to translate error messages into Redfish errors.
1011 *
1012 * @param[in,out] resp HTTP response.
1013 * @param[in] setPropVal Value which we attempted to set.
1014 * @param[in] ec D-Bus response error code.
1015 * @param[in] msg D-Bus response message.
1016 */
1017inline void
1018 handleAppliedConfigResponse(const std::shared_ptr<bmcweb::AsyncResp>& resp,
1019 const std::string& setPropVal,
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001020 const boost::system::error_code& ec,
Patrick Williams59d494e2022-07-22 19:26:55 -05001021 const sdbusplus::message_t& msg)
Jonathan Doman3cde86f2020-12-02 14:50:45 -08001022{
1023 if (!ec)
1024 {
1025 BMCWEB_LOG_DEBUG << "Set Property succeeded";
1026 return;
1027 }
1028
1029 BMCWEB_LOG_DEBUG << "Set Property failed: " << ec;
1030
1031 const sd_bus_error* dbusError = msg.get_error();
1032 if (dbusError == nullptr)
1033 {
1034 messages::internalError(resp->res);
1035 return;
1036 }
1037
1038 // The asio error code doesn't know about our custom errors, so we have to
1039 // parse the error string. Some of these D-Bus -> Redfish translations are a
1040 // stretch, but it's good to try to communicate something vaguely useful.
1041 if (strcmp(dbusError->name,
1042 "xyz.openbmc_project.Common.Error.InvalidArgument") == 0)
1043 {
1044 // Service did not like the object_path we tried to set.
1045 messages::propertyValueIncorrect(
1046 resp->res, "AppliedOperatingConfig/@odata.id", setPropVal);
1047 }
1048 else if (strcmp(dbusError->name,
1049 "xyz.openbmc_project.Common.Error.NotAllowed") == 0)
1050 {
1051 // Service indicates we can never change the config for this processor.
1052 messages::propertyNotWritable(resp->res, "AppliedOperatingConfig");
1053 }
1054 else if (strcmp(dbusError->name,
1055 "xyz.openbmc_project.Common.Error.Unavailable") == 0)
1056 {
1057 // Service indicates the config cannot be changed right now, but maybe
1058 // in a different system state.
1059 messages::resourceInStandby(resp->res);
1060 }
Jonathan Doman3cde86f2020-12-02 14:50:45 -08001061 else
1062 {
1063 messages::internalError(resp->res);
1064 }
1065}
1066
1067/**
1068 * Handle the PATCH operation of the AppliedOperatingConfig property. Do basic
1069 * validation of the input data, and then set the D-Bus property.
1070 *
1071 * @param[in,out] resp Async HTTP response.
1072 * @param[in] processorId Processor's Id.
1073 * @param[in] appliedConfigUri New property value to apply.
1074 * @param[in] cpuObjectPath Path of CPU object to modify.
1075 * @param[in] serviceMap Service map for CPU object.
1076 */
1077inline void patchAppliedOperatingConfig(
1078 const std::shared_ptr<bmcweb::AsyncResp>& resp,
1079 const std::string& processorId, const std::string& appliedConfigUri,
Shantappa Teekappanavar5df6eda2022-01-18 12:29:28 -06001080 const std::string& cpuObjectPath,
1081 const dbus::utility::MapperServiceMap& serviceMap)
Jonathan Doman3cde86f2020-12-02 14:50:45 -08001082{
1083 // Check that the property even exists by checking for the interface
1084 const std::string* controlService = nullptr;
1085 for (const auto& [serviceName, interfaceList] : serviceMap)
1086 {
1087 if (std::find(interfaceList.begin(), interfaceList.end(),
1088 "xyz.openbmc_project.Control.Processor."
1089 "CurrentOperatingConfig") != interfaceList.end())
1090 {
1091 controlService = &serviceName;
1092 break;
1093 }
1094 }
1095
1096 if (controlService == nullptr)
1097 {
1098 messages::internalError(resp->res);
1099 return;
1100 }
1101
1102 // Check that the config URI is a child of the cpu URI being patched.
1103 std::string expectedPrefix("/redfish/v1/Systems/system/Processors/");
1104 expectedPrefix += processorId;
1105 expectedPrefix += "/OperatingConfigs/";
Ed Tanous11ba3972022-07-11 09:50:41 -07001106 if (!appliedConfigUri.starts_with(expectedPrefix) ||
Jonathan Doman3cde86f2020-12-02 14:50:45 -08001107 expectedPrefix.size() == appliedConfigUri.size())
1108 {
1109 messages::propertyValueIncorrect(
1110 resp->res, "AppliedOperatingConfig/@odata.id", appliedConfigUri);
1111 return;
1112 }
1113
1114 // Generate the D-Bus path of the OperatingConfig object, by assuming it's a
1115 // direct child of the CPU object.
1116 // Strip the expectedPrefix from the config URI to get the "filename", and
1117 // append to the CPU's path.
1118 std::string configBaseName = appliedConfigUri.substr(expectedPrefix.size());
1119 sdbusplus::message::object_path configPath(cpuObjectPath);
1120 configPath /= configBaseName;
1121
1122 BMCWEB_LOG_INFO << "Setting config to " << configPath.str;
1123
1124 // Set the property, with handler to check error responses
1125 crow::connections::systemBus->async_method_call(
Ed Tanous5e7e2dc2023-02-16 10:37:01 -08001126 [resp, appliedConfigUri](const boost::system::error_code& ec,
Patrick Williams59d494e2022-07-22 19:26:55 -05001127 const sdbusplus::message_t& msg) {
Ed Tanous002d39b2022-05-31 08:59:27 -07001128 handleAppliedConfigResponse(resp, appliedConfigUri, ec, msg);
Jonathan Doman3cde86f2020-12-02 14:50:45 -08001129 },
1130 *controlService, cpuObjectPath, "org.freedesktop.DBus.Properties",
1131 "Set", "xyz.openbmc_project.Control.Processor.CurrentOperatingConfig",
Ed Tanous168e20c2021-12-13 14:39:53 -08001132 "AppliedConfig", dbus::utility::DbusVariantType(std::move(configPath)));
Jonathan Doman3cde86f2020-12-02 14:50:45 -08001133}
1134
Ed Tanousac106bf2023-06-07 09:24:59 -07001135inline void
1136 handleProcessorHead(crow::App& app, const crow::Request& req,
1137 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1138 const std::string& /* systemName */,
1139 const std::string& /* processorId */)
Nikhil Namjoshi71a24ca2022-11-11 01:52:32 +00001140{
Ed Tanousac106bf2023-06-07 09:24:59 -07001141 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Nikhil Namjoshi71a24ca2022-11-11 01:52:32 +00001142 {
1143 return;
1144 }
Ed Tanousac106bf2023-06-07 09:24:59 -07001145 asyncResp->res.addHeader(
Nikhil Namjoshi71a24ca2022-11-11 01:52:32 +00001146 boost::beast::http::field::link,
1147 "</redfish/v1/JsonSchemas/Processor/Processor.json>; rel=describedby");
1148}
1149
1150inline void handleProcessorCollectionHead(
1151 crow::App& app, const crow::Request& req,
Ed Tanousac106bf2023-06-07 09:24:59 -07001152 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Nikhil Namjoshi71a24ca2022-11-11 01:52:32 +00001153 const std::string& /* systemName */)
1154{
Ed Tanousac106bf2023-06-07 09:24:59 -07001155 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Nikhil Namjoshi71a24ca2022-11-11 01:52:32 +00001156 {
1157 return;
1158 }
Ed Tanousac106bf2023-06-07 09:24:59 -07001159 asyncResp->res.addHeader(
Nikhil Namjoshi71a24ca2022-11-11 01:52:32 +00001160 boost::beast::http::field::link,
1161 "</redfish/v1/JsonSchemas/ProcessorCollection/ProcessorCollection.json>; rel=describedby");
1162}
1163
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001164inline void requestRoutesOperatingConfigCollection(App& app)
Jonathan Domandba0c292020-12-02 15:34:13 -08001165{
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001166 BMCWEB_ROUTE(
1167 app, "/redfish/v1/Systems/system/Processors/<str>/OperatingConfigs/")
Ed Tanoused398212021-06-09 17:05:54 -07001168 .privileges(redfish::privileges::getOperatingConfigCollection)
Ed Tanous002d39b2022-05-31 08:59:27 -07001169 .methods(boost::beast::http::verb::get)(
1170 [&app](const crow::Request& req,
1171 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1172 const std::string& cpuName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001173 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001174 {
1175 return;
1176 }
1177 asyncResp->res.jsonValue["@odata.type"] =
1178 "#OperatingConfigCollection.OperatingConfigCollection";
Ed Tanousef4c65b2023-04-24 15:28:50 -07001179 asyncResp->res.jsonValue["@odata.id"] = boost::urls::format(
1180 "/redfish/v1/Systems/system/Processors/{}/OperatingConfigs",
1181 cpuName);
Ed Tanous002d39b2022-05-31 08:59:27 -07001182 asyncResp->res.jsonValue["Name"] = "Operating Config Collection";
1183
1184 // First find the matching CPU object so we know how to
1185 // constrain our search for related Config objects.
George Liu7a1dbc42022-12-07 16:03:22 +08001186 const std::array<std::string_view, 1> interfaces = {
1187 "xyz.openbmc_project.Control.Processor.CurrentOperatingConfig"};
1188 dbus::utility::getSubTreePaths(
1189 "/xyz/openbmc_project/inventory", 0, interfaces,
Ed Tanous002d39b2022-05-31 08:59:27 -07001190 [asyncResp, cpuName](
George Liu7a1dbc42022-12-07 16:03:22 +08001191 const boost::system::error_code& ec,
Ed Tanous002d39b2022-05-31 08:59:27 -07001192 const dbus::utility::MapperGetSubTreePathsResponse& objects) {
1193 if (ec)
Ed Tanous45ca1b82022-03-25 13:07:27 -07001194 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001195 BMCWEB_LOG_WARNING << "D-Bus error: " << ec << ", "
1196 << ec.message();
1197 messages::internalError(asyncResp->res);
Ed Tanous45ca1b82022-03-25 13:07:27 -07001198 return;
1199 }
Jonathan Domandba0c292020-12-02 15:34:13 -08001200
Ed Tanous002d39b2022-05-31 08:59:27 -07001201 for (const std::string& object : objects)
1202 {
Ed Tanous11ba3972022-07-11 09:50:41 -07001203 if (!object.ends_with(cpuName))
Ed Tanous002d39b2022-05-31 08:59:27 -07001204 {
1205 continue;
1206 }
George Liu0fda0f12021-11-16 10:06:17 +08001207
Ed Tanous002d39b2022-05-31 08:59:27 -07001208 // Not expected that there will be multiple matching
1209 // CPU objects, but if there are just use the first
1210 // one.
Jonathan Domandba0c292020-12-02 15:34:13 -08001211
Ed Tanous002d39b2022-05-31 08:59:27 -07001212 // Use the common search routine to construct the
1213 // Collection of all Config objects under this CPU.
George Liu7a1dbc42022-12-07 16:03:22 +08001214 constexpr std::array<std::string_view, 1> interface {
1215 "xyz.openbmc_project.Inventory.Item.Cpu.OperatingConfig"
1216 };
Ed Tanous002d39b2022-05-31 08:59:27 -07001217 collection_util::getCollectionMembers(
1218 asyncResp,
Ed Tanousef4c65b2023-04-24 15:28:50 -07001219 boost::urls::format(
1220 "/redfish/v1/Systems/system/Processors/{}/OperatingConfigs",
1221 cpuName),
George Liu7a1dbc42022-12-07 16:03:22 +08001222 interface, object.c_str());
Ed Tanous002d39b2022-05-31 08:59:27 -07001223 return;
1224 }
George Liu7a1dbc42022-12-07 16:03:22 +08001225 });
George Liu0fda0f12021-11-16 10:06:17 +08001226 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001227}
1228
1229inline void requestRoutesOperatingConfig(App& app)
1230{
1231 BMCWEB_ROUTE(
1232 app,
1233 "/redfish/v1/Systems/system/Processors/<str>/OperatingConfigs/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001234 .privileges(redfish::privileges::getOperatingConfig)
Ed Tanous002d39b2022-05-31 08:59:27 -07001235 .methods(boost::beast::http::verb::get)(
1236 [&app](const crow::Request& req,
1237 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1238 const std::string& cpuName, const std::string& configName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001239 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001240 {
1241 return;
1242 }
1243 // Ask for all objects implementing OperatingConfig so we can search
1244 // for one with a matching name
George Liue99073f2022-12-09 11:06:16 +08001245 constexpr std::array<std::string_view, 1> interfaces = {
1246 "xyz.openbmc_project.Inventory.Item.Cpu.OperatingConfig"};
1247 dbus::utility::getSubTree(
1248 "/xyz/openbmc_project/inventory", 0, interfaces,
Ed Tanous39662a32023-02-06 15:09:46 -08001249 [asyncResp, cpuName, configName](
George Liue99073f2022-12-09 11:06:16 +08001250 const boost::system::error_code& ec,
Ed Tanous002d39b2022-05-31 08:59:27 -07001251 const dbus::utility::MapperGetSubTreeResponse& subtree) {
1252 if (ec)
Ed Tanous45ca1b82022-03-25 13:07:27 -07001253 {
Ed Tanous002d39b2022-05-31 08:59:27 -07001254 BMCWEB_LOG_WARNING << "D-Bus error: " << ec << ", "
1255 << ec.message();
1256 messages::internalError(asyncResp->res);
Ed Tanous45ca1b82022-03-25 13:07:27 -07001257 return;
1258 }
Ed Tanous002d39b2022-05-31 08:59:27 -07001259 const std::string expectedEnding = cpuName + '/' + configName;
1260 for (const auto& [objectPath, serviceMap] : subtree)
1261 {
1262 // Ignore any configs without matching cpuX/configY
Ed Tanous11ba3972022-07-11 09:50:41 -07001263 if (!objectPath.ends_with(expectedEnding) || serviceMap.empty())
Ed Tanous002d39b2022-05-31 08:59:27 -07001264 {
1265 continue;
1266 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001267
Ed Tanous002d39b2022-05-31 08:59:27 -07001268 nlohmann::json& json = asyncResp->res.jsonValue;
1269 json["@odata.type"] = "#OperatingConfig.v1_0_0.OperatingConfig";
Ed Tanousef4c65b2023-04-24 15:28:50 -07001270 json["@odata.id"] = boost::urls::format(
1271 "/redfish/v1/Systems/system/Processors/{}/OperatingConfigs/{}",
1272 cpuName, configName);
Ed Tanous002d39b2022-05-31 08:59:27 -07001273 json["Name"] = "Processor Profile";
1274 json["Id"] = configName;
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001275
Ed Tanous002d39b2022-05-31 08:59:27 -07001276 // Just use the first implementation of the object - not
1277 // expected that there would be multiple matching
1278 // services
1279 getOperatingConfigData(asyncResp, serviceMap.begin()->first,
1280 objectPath);
1281 return;
1282 }
1283 messages::resourceNotFound(asyncResp->res, "OperatingConfig",
1284 configName);
George Liue99073f2022-12-09 11:06:16 +08001285 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001286 });
1287}
Jonathan Domandba0c292020-12-02 15:34:13 -08001288
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001289inline void requestRoutesProcessorCollection(App& app)
Gunnar Millsac6a4442020-10-14 14:55:29 -05001290{
Gunnar Millsac6a4442020-10-14 14:55:29 -05001291 /**
1292 * Functions triggers appropriate requests on DBus
1293 */
Ed Tanous22d268c2022-05-19 09:39:07 -07001294 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/Processors/")
Nikhil Namjoshi71a24ca2022-11-11 01:52:32 +00001295 .privileges(redfish::privileges::headProcessorCollection)
1296 .methods(boost::beast::http::verb::head)(
1297 std::bind_front(handleProcessorCollectionHead, std::ref(app)));
1298
1299 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/Processors/")
Ed Tanoused398212021-06-09 17:05:54 -07001300 .privileges(redfish::privileges::getProcessorCollection)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001301 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001302 [&app](const crow::Request& req,
Ed Tanous22d268c2022-05-19 09:39:07 -07001303 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
1304 const std::string& systemName) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001305 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001306 {
1307 return;
1308 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001309 if (systemName != "system")
1310 {
1311 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1312 systemName);
1313 return;
1314 }
1315
Nikhil Namjoshi71a24ca2022-11-11 01:52:32 +00001316 asyncResp->res.addHeader(
1317 boost::beast::http::field::link,
1318 "</redfish/v1/JsonSchemas/ProcessorCollection/ProcessorCollection.json>; rel=describedby");
1319
Ed Tanous002d39b2022-05-31 08:59:27 -07001320 asyncResp->res.jsonValue["@odata.type"] =
1321 "#ProcessorCollection.ProcessorCollection";
1322 asyncResp->res.jsonValue["Name"] = "Processor Collection";
Gunnar Millsac6a4442020-10-14 14:55:29 -05001323
Ed Tanous002d39b2022-05-31 08:59:27 -07001324 asyncResp->res.jsonValue["@odata.id"] =
1325 "/redfish/v1/Systems/system/Processors";
Gunnar Millsac6a4442020-10-14 14:55:29 -05001326
Ed Tanous002d39b2022-05-31 08:59:27 -07001327 collection_util::getCollectionMembers(
Willy Tuae9031f2022-09-27 05:48:07 +00001328 asyncResp,
1329 boost::urls::url("/redfish/v1/Systems/system/Processors"),
George Liu7a1dbc42022-12-07 16:03:22 +08001330 processorInterfaces);
Ed Tanous002d39b2022-05-31 08:59:27 -07001331 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001332}
Gunnar Millsac6a4442020-10-14 14:55:29 -05001333
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001334inline void requestRoutesProcessor(App& app)
Gunnar Millsac6a4442020-10-14 14:55:29 -05001335{
Gunnar Millsac6a4442020-10-14 14:55:29 -05001336 /**
1337 * Functions triggers appropriate requests on DBus
1338 */
Gunnar Millsac6a4442020-10-14 14:55:29 -05001339
Ed Tanous22d268c2022-05-19 09:39:07 -07001340 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/Processors/<str>/")
Nikhil Namjoshi71a24ca2022-11-11 01:52:32 +00001341 .privileges(redfish::privileges::headProcessor)
1342 .methods(boost::beast::http::verb::head)(
1343 std::bind_front(handleProcessorHead, std::ref(app)));
1344
1345 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/Processors/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001346 .privileges(redfish::privileges::getProcessor)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001347 .methods(boost::beast::http::verb::get)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001348 [&app](const crow::Request& req,
1349 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07001350 const std::string& systemName,
Ed Tanous45ca1b82022-03-25 13:07:27 -07001351 const std::string& processorId) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001352 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001353 {
1354 return;
1355 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001356 if (systemName != "system")
1357 {
1358 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1359 systemName);
1360 return;
1361 }
1362
Nikhil Namjoshi71a24ca2022-11-11 01:52:32 +00001363 asyncResp->res.addHeader(
1364 boost::beast::http::field::link,
1365 "</redfish/v1/JsonSchemas/Processor/Processor.json>; rel=describedby");
Ed Tanous002d39b2022-05-31 08:59:27 -07001366 asyncResp->res.jsonValue["@odata.type"] =
Chris Caindfbf7de2023-04-13 16:01:04 -05001367 "#Processor.v1_18_0.Processor";
Ed Tanousef4c65b2023-04-24 15:28:50 -07001368 asyncResp->res.jsonValue["@odata.id"] = boost::urls::format(
1369 "/redfish/v1/Systems/system/Processors/{}", processorId);
Jonathan Doman3cde86f2020-12-02 14:50:45 -08001370
Ed Tanous8a592812022-06-04 09:06:59 -07001371 getProcessorObject(
1372 asyncResp, processorId,
1373 std::bind_front(getProcessorData, asyncResp, processorId));
Ed Tanous002d39b2022-05-31 08:59:27 -07001374 });
Jonathan Doman3cde86f2020-12-02 14:50:45 -08001375
Ed Tanous22d268c2022-05-19 09:39:07 -07001376 BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/Processors/<str>/")
Ed Tanoused398212021-06-09 17:05:54 -07001377 .privileges(redfish::privileges::patchProcessor)
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001378 .methods(boost::beast::http::verb::patch)(
Ed Tanous45ca1b82022-03-25 13:07:27 -07001379 [&app](const crow::Request& req,
1380 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous22d268c2022-05-19 09:39:07 -07001381 const std::string& systemName,
Ed Tanous45ca1b82022-03-25 13:07:27 -07001382 const std::string& processorId) {
Carson Labrado3ba00072022-06-06 19:40:56 +00001383 if (!redfish::setUpRedfishRoute(app, req, asyncResp))
Ed Tanous002d39b2022-05-31 08:59:27 -07001384 {
1385 return;
1386 }
Ed Tanous22d268c2022-05-19 09:39:07 -07001387 if (systemName != "system")
1388 {
1389 messages::resourceNotFound(asyncResp->res, "ComputerSystem",
1390 systemName);
1391 return;
1392 }
1393
Ed Tanous002d39b2022-05-31 08:59:27 -07001394 std::optional<nlohmann::json> appliedConfigJson;
1395 if (!json_util::readJsonPatch(req, asyncResp->res,
1396 "AppliedOperatingConfig",
1397 appliedConfigJson))
1398 {
1399 return;
1400 }
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001401
Ed Tanous002d39b2022-05-31 08:59:27 -07001402 if (appliedConfigJson)
1403 {
Ed Tanousf8fe53e2022-06-30 15:55:45 -07001404 std::string appliedConfigUri;
Ed Tanous002d39b2022-05-31 08:59:27 -07001405 if (!json_util::readJson(*appliedConfigJson, asyncResp->res,
1406 "@odata.id", appliedConfigUri))
1407 {
1408 return;
1409 }
1410 // Check for 404 and find matching D-Bus object, then run
1411 // property patch handlers if that all succeeds.
Ed Tanous8a592812022-06-04 09:06:59 -07001412 getProcessorObject(asyncResp, processorId,
1413 std::bind_front(patchAppliedOperatingConfig,
1414 asyncResp, processorId,
1415 appliedConfigUri));
Ed Tanous002d39b2022-05-31 08:59:27 -07001416 }
1417 });
John Edward Broadbent7e860f12021-04-08 15:57:16 -07001418}
Gunnar Millsac6a4442020-10-14 14:55:29 -05001419
1420} // namespace redfish