Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 1 | #pragma once |
| 2 | |
Ed Tanous | 3ccb3ad | 2023-01-13 17:40:03 -0800 | [diff] [blame] | 3 | #include "app.hpp" |
George Liu | e99073f | 2022-12-09 11:06:16 +0800 | [diff] [blame] | 4 | #include "dbus_utility.hpp" |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 5 | #include "error_messages.hpp" |
Ed Tanous | 4ce2c1b | 2023-02-10 11:57:54 -0800 | [diff] [blame] | 6 | #include "generated/enums/pcie_slots.hpp" |
Lakshmi Yadlapati | c49c329 | 2023-04-19 16:42:35 -0500 | [diff] [blame] | 7 | #include "query.hpp" |
Ed Tanous | 3ccb3ad | 2023-01-13 17:40:03 -0800 | [diff] [blame] | 8 | #include "registries/privilege_registry.hpp" |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 9 | #include "utility.hpp" |
Ed Tanous | 3ccb3ad | 2023-01-13 17:40:03 -0800 | [diff] [blame] | 10 | #include "utils/dbus_utils.hpp" |
| 11 | #include "utils/json_utils.hpp" |
Lakshmi Yadlapati | c49c329 | 2023-04-19 16:42:35 -0500 | [diff] [blame] | 12 | #include "utils/pcie_util.hpp" |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 13 | |
George Liu | e99073f | 2022-12-09 11:06:16 +0800 | [diff] [blame] | 14 | #include <boost/system/error_code.hpp> |
Ed Tanous | ef4c65b | 2023-04-24 15:28:50 -0700 | [diff] [blame] | 15 | #include <boost/url/format.hpp> |
Krzysztof Grobelny | d1bde9e | 2022-09-07 10:40:51 +0200 | [diff] [blame] | 16 | #include <sdbusplus/asio/property.hpp> |
| 17 | #include <sdbusplus/unpack_properties.hpp> |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 18 | |
George Liu | e99073f | 2022-12-09 11:06:16 +0800 | [diff] [blame] | 19 | #include <array> |
| 20 | #include <string_view> |
| 21 | |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 22 | namespace redfish |
| 23 | { |
| 24 | |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 25 | inline void |
| 26 | onPcieSlotGetAllDone(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
Ed Tanous | 5e7e2dc | 2023-02-16 10:37:01 -0800 | [diff] [blame] | 27 | const boost::system::error_code& ec, |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 28 | const dbus::utility::DBusPropertiesMap& propertiesList) |
| 29 | { |
| 30 | if (ec) |
| 31 | { |
| 32 | BMCWEB_LOG_ERROR << "Can't get PCIeSlot properties!"; |
| 33 | messages::internalError(asyncResp->res); |
| 34 | return; |
| 35 | } |
| 36 | |
| 37 | nlohmann::json& slots = asyncResp->res.jsonValue["Slots"]; |
| 38 | |
| 39 | nlohmann::json::array_t* slotsPtr = |
| 40 | slots.get_ptr<nlohmann::json::array_t*>(); |
| 41 | if (slotsPtr == nullptr) |
| 42 | { |
| 43 | BMCWEB_LOG_ERROR << "Slots key isn't an array???"; |
| 44 | messages::internalError(asyncResp->res); |
| 45 | return; |
| 46 | } |
| 47 | |
| 48 | nlohmann::json::object_t slot; |
| 49 | |
Krzysztof Grobelny | d1bde9e | 2022-09-07 10:40:51 +0200 | [diff] [blame] | 50 | const std::string* generation = nullptr; |
| 51 | const size_t* lanes = nullptr; |
| 52 | const std::string* slotType = nullptr; |
| 53 | const bool* hotPluggable = nullptr; |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 54 | |
Krzysztof Grobelny | d1bde9e | 2022-09-07 10:40:51 +0200 | [diff] [blame] | 55 | const bool success = sdbusplus::unpackPropertiesNoThrow( |
| 56 | dbus_utils::UnpackErrorPrinter(), propertiesList, "Generation", |
| 57 | generation, "Lanes", lanes, "SlotType", slotType, "HotPluggable", |
| 58 | hotPluggable); |
| 59 | |
| 60 | if (!success) |
| 61 | { |
| 62 | messages::internalError(asyncResp->res); |
| 63 | return; |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 64 | } |
Krzysztof Grobelny | d1bde9e | 2022-09-07 10:40:51 +0200 | [diff] [blame] | 65 | |
| 66 | if (generation != nullptr) |
| 67 | { |
Ed Tanous | 0ec8b83 | 2022-03-14 14:56:47 -0700 | [diff] [blame] | 68 | std::optional<pcie_device::PCIeTypes> pcieType = |
Lakshmi Yadlapati | c49c329 | 2023-04-19 16:42:35 -0500 | [diff] [blame] | 69 | pcie_util::redfishPcieGenerationFromDbus(*generation); |
Krzysztof Grobelny | d1bde9e | 2022-09-07 10:40:51 +0200 | [diff] [blame] | 70 | if (!pcieType) |
| 71 | { |
Lakshmi Yadlapati | cf3b484 | 2023-06-27 02:36:53 -0500 | [diff] [blame^] | 72 | BMCWEB_LOG_WARNING << "Unknown PCIe Slot Generation: " |
| 73 | << *generation; |
Krzysztof Grobelny | d1bde9e | 2022-09-07 10:40:51 +0200 | [diff] [blame] | 74 | } |
Lakshmi Yadlapati | cf3b484 | 2023-06-27 02:36:53 -0500 | [diff] [blame^] | 75 | else |
Lakshmi Yadlapati | bbf372a | 2023-05-02 15:09:08 -0500 | [diff] [blame] | 76 | { |
Lakshmi Yadlapati | cf3b484 | 2023-06-27 02:36:53 -0500 | [diff] [blame^] | 77 | if (*pcieType == pcie_device::PCIeTypes::Invalid) |
| 78 | { |
| 79 | messages::internalError(asyncResp->res); |
| 80 | return; |
| 81 | } |
Lakshmi Yadlapati | bbf372a | 2023-05-02 15:09:08 -0500 | [diff] [blame] | 82 | slot["PCIeType"] = *pcieType; |
| 83 | } |
Krzysztof Grobelny | d1bde9e | 2022-09-07 10:40:51 +0200 | [diff] [blame] | 84 | } |
| 85 | |
| 86 | if (lanes != nullptr) |
| 87 | { |
Krzysztof Grobelny | d1bde9e | 2022-09-07 10:40:51 +0200 | [diff] [blame] | 88 | slot["Lanes"] = *lanes; |
| 89 | } |
| 90 | |
| 91 | if (slotType != nullptr) |
| 92 | { |
Lakshmi Yadlapati | d87fdd9 | 2023-05-02 16:50:31 -0500 | [diff] [blame] | 93 | std::optional<pcie_slots::SlotTypes> redfishSlotType = |
Lakshmi Yadlapati | c49c329 | 2023-04-19 16:42:35 -0500 | [diff] [blame] | 94 | pcie_util::dbusSlotTypeToRf(*slotType); |
Lakshmi Yadlapati | d87fdd9 | 2023-05-02 16:50:31 -0500 | [diff] [blame] | 95 | if (!redfishSlotType) |
Krzysztof Grobelny | d1bde9e | 2022-09-07 10:40:51 +0200 | [diff] [blame] | 96 | { |
Lakshmi Yadlapati | cf3b484 | 2023-06-27 02:36:53 -0500 | [diff] [blame^] | 97 | BMCWEB_LOG_WARNING << "Unknown PCIe Slot Type: " << *slotType; |
Krzysztof Grobelny | d1bde9e | 2022-09-07 10:40:51 +0200 | [diff] [blame] | 98 | } |
Lakshmi Yadlapati | cf3b484 | 2023-06-27 02:36:53 -0500 | [diff] [blame^] | 99 | else |
Lakshmi Yadlapati | d87fdd9 | 2023-05-02 16:50:31 -0500 | [diff] [blame] | 100 | { |
Lakshmi Yadlapati | cf3b484 | 2023-06-27 02:36:53 -0500 | [diff] [blame^] | 101 | if (*redfishSlotType == pcie_slots::SlotTypes::Invalid) |
| 102 | { |
| 103 | BMCWEB_LOG_ERROR << "Unknown PCIe Slot Type: " << *slotType; |
| 104 | messages::internalError(asyncResp->res); |
| 105 | return; |
| 106 | } |
Lakshmi Yadlapati | d87fdd9 | 2023-05-02 16:50:31 -0500 | [diff] [blame] | 107 | slot["SlotType"] = *redfishSlotType; |
| 108 | } |
Krzysztof Grobelny | d1bde9e | 2022-09-07 10:40:51 +0200 | [diff] [blame] | 109 | } |
| 110 | |
| 111 | if (hotPluggable != nullptr) |
| 112 | { |
| 113 | slot["HotPluggable"] = *hotPluggable; |
| 114 | } |
| 115 | |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 116 | slots.emplace_back(std::move(slot)); |
| 117 | } |
| 118 | |
| 119 | inline void onMapperAssociationDone( |
| 120 | const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| 121 | const std::string& chassisID, const std::string& pcieSlotPath, |
Ed Tanous | 5e7e2dc | 2023-02-16 10:37:01 -0800 | [diff] [blame] | 122 | const std::string& connectionName, const boost::system::error_code& ec, |
George Liu | 6c3e945 | 2023-03-03 13:55:29 +0800 | [diff] [blame] | 123 | const dbus::utility::MapperEndPoints& pcieSlotChassis) |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 124 | { |
| 125 | if (ec) |
| 126 | { |
| 127 | if (ec.value() == EBADR) |
| 128 | { |
| 129 | // This PCIeSlot have no chassis association. |
| 130 | return; |
| 131 | } |
| 132 | BMCWEB_LOG_ERROR << "DBUS response error"; |
| 133 | messages::internalError(asyncResp->res); |
| 134 | return; |
| 135 | } |
| 136 | |
George Liu | 6c3e945 | 2023-03-03 13:55:29 +0800 | [diff] [blame] | 137 | if (pcieSlotChassis.size() != 1) |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 138 | { |
| 139 | BMCWEB_LOG_ERROR << "PCIe Slot association error! "; |
| 140 | messages::internalError(asyncResp->res); |
| 141 | return; |
| 142 | } |
| 143 | |
George Liu | 6c3e945 | 2023-03-03 13:55:29 +0800 | [diff] [blame] | 144 | sdbusplus::message::object_path path(pcieSlotChassis[0]); |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 145 | std::string chassisName = path.filename(); |
| 146 | if (chassisName != chassisID) |
| 147 | { |
| 148 | // The pcie slot doesn't belong to the chassisID |
| 149 | return; |
| 150 | } |
| 151 | |
Krzysztof Grobelny | d1bde9e | 2022-09-07 10:40:51 +0200 | [diff] [blame] | 152 | sdbusplus::asio::getAllProperties( |
| 153 | *crow::connections::systemBus, connectionName, pcieSlotPath, |
| 154 | "xyz.openbmc_project.Inventory.Item.PCIeSlot", |
Ed Tanous | 5e7e2dc | 2023-02-16 10:37:01 -0800 | [diff] [blame] | 155 | [asyncResp](const boost::system::error_code& ec2, |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 156 | const dbus::utility::DBusPropertiesMap& propertiesList) { |
Ed Tanous | 4ce2c1b | 2023-02-10 11:57:54 -0800 | [diff] [blame] | 157 | onPcieSlotGetAllDone(asyncResp, ec2, propertiesList); |
Krzysztof Grobelny | d1bde9e | 2022-09-07 10:40:51 +0200 | [diff] [blame] | 158 | }); |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 159 | } |
| 160 | |
| 161 | inline void |
| 162 | onMapperSubtreeDone(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| 163 | const std::string& chassisID, |
Ed Tanous | 5e7e2dc | 2023-02-16 10:37:01 -0800 | [diff] [blame] | 164 | const boost::system::error_code& ec, |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 165 | const dbus::utility::MapperGetSubTreeResponse& subtree) |
| 166 | { |
| 167 | if (ec) |
| 168 | { |
| 169 | BMCWEB_LOG_ERROR << "D-Bus response error on GetSubTree " << ec; |
| 170 | messages::internalError(asyncResp->res); |
| 171 | return; |
| 172 | } |
| 173 | if (subtree.empty()) |
| 174 | { |
Jiaqing Zhao | d8a5d5d | 2022-08-05 16:21:51 +0800 | [diff] [blame] | 175 | messages::resourceNotFound(asyncResp->res, "Chassis", chassisID); |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 176 | return; |
| 177 | } |
| 178 | |
| 179 | BMCWEB_LOG_DEBUG << "Get properties for PCIeSlots associated to chassis = " |
| 180 | << chassisID; |
| 181 | |
| 182 | asyncResp->res.jsonValue["@odata.type"] = "#PCIeSlots.v1_4_1.PCIeSlots"; |
| 183 | asyncResp->res.jsonValue["Name"] = "PCIe Slot Information"; |
Ed Tanous | ef4c65b | 2023-04-24 15:28:50 -0700 | [diff] [blame] | 184 | asyncResp->res.jsonValue["@odata.id"] = |
| 185 | boost::urls::format("/redfish/v1/Chassis/{}/PCIeSlots", chassisID); |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 186 | asyncResp->res.jsonValue["Id"] = "1"; |
| 187 | asyncResp->res.jsonValue["Slots"] = nlohmann::json::array(); |
| 188 | |
| 189 | for (const auto& pathServicePair : subtree) |
| 190 | { |
| 191 | const std::string& pcieSlotPath = pathServicePair.first; |
| 192 | for (const auto& connectionInterfacePair : pathServicePair.second) |
| 193 | { |
| 194 | const std::string& connectionName = connectionInterfacePair.first; |
| 195 | sdbusplus::message::object_path pcieSlotAssociationPath( |
| 196 | pcieSlotPath); |
| 197 | pcieSlotAssociationPath /= "chassis"; |
| 198 | |
| 199 | // The association of this PCIeSlot is used to determine whether |
| 200 | // it belongs to this ChassisID |
George Liu | 6c3e945 | 2023-03-03 13:55:29 +0800 | [diff] [blame] | 201 | dbus::utility::getAssociationEndPoints( |
| 202 | std::string{pcieSlotAssociationPath}, |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 203 | [asyncResp, chassisID, pcieSlotPath, connectionName]( |
Ed Tanous | 4ce2c1b | 2023-02-10 11:57:54 -0800 | [diff] [blame] | 204 | const boost::system::error_code& ec2, |
George Liu | 6c3e945 | 2023-03-03 13:55:29 +0800 | [diff] [blame] | 205 | const dbus::utility::MapperEndPoints& endpoints) { |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 206 | onMapperAssociationDone(asyncResp, chassisID, pcieSlotPath, |
Ed Tanous | 4ce2c1b | 2023-02-10 11:57:54 -0800 | [diff] [blame] | 207 | connectionName, ec2, endpoints); |
George Liu | 6c3e945 | 2023-03-03 13:55:29 +0800 | [diff] [blame] | 208 | }); |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 209 | } |
| 210 | } |
| 211 | } |
| 212 | |
| 213 | inline void handlePCIeSlotCollectionGet( |
| 214 | crow::App& app, const crow::Request& req, |
| 215 | const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| 216 | const std::string& chassisID) |
| 217 | { |
Ed Tanous | 2aacf85 | 2022-06-17 08:07:54 -0700 | [diff] [blame] | 218 | if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 219 | { |
| 220 | return; |
| 221 | } |
| 222 | |
George Liu | e99073f | 2022-12-09 11:06:16 +0800 | [diff] [blame] | 223 | constexpr std::array<std::string_view, 1> interfaces = { |
| 224 | "xyz.openbmc_project.Inventory.Item.PCIeSlot"}; |
| 225 | dbus::utility::getSubTree( |
| 226 | "/xyz/openbmc_project/inventory", 0, interfaces, |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 227 | [asyncResp, |
George Liu | e99073f | 2022-12-09 11:06:16 +0800 | [diff] [blame] | 228 | chassisID](const boost::system::error_code& ec, |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 229 | const dbus::utility::MapperGetSubTreeResponse& subtree) { |
| 230 | onMapperSubtreeDone(asyncResp, chassisID, ec, subtree); |
George Liu | e99073f | 2022-12-09 11:06:16 +0800 | [diff] [blame] | 231 | }); |
Chicago Duan | 7691cc2 | 2021-01-25 19:52:35 +0800 | [diff] [blame] | 232 | } |
| 233 | |
| 234 | inline void requestRoutesPCIeSlots(App& app) |
| 235 | { |
| 236 | BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/PCIeSlots/") |
| 237 | .privileges(redfish::privileges::getPCIeSlots) |
| 238 | .methods(boost::beast::http::verb::get)( |
| 239 | std::bind_front(handlePCIeSlotCollectionGet, std::ref(app))); |
| 240 | } |
| 241 | |
| 242 | } // namespace redfish |