Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 1 | #pragma once |
| 2 | |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 3 | #include "config.h" |
| 4 | |
George Liu | 6492f52 | 2020-06-16 10:34:05 +0800 | [diff] [blame] | 5 | #include "libpldm/platform.h" |
| 6 | #include "libpldm/states.h" |
George Liu | c4ea6a9 | 2020-07-14 15:48:44 +0800 | [diff] [blame^] | 7 | #include "pdr.h" |
George Liu | 6492f52 | 2020-06-16 10:34:05 +0800 | [diff] [blame] | 8 | |
Deepak Kodihalli | d130e1a | 2020-06-17 05:55:32 -0500 | [diff] [blame] | 9 | #include "common/utils.hpp" |
TOM JOSEPH | d4d97a5 | 2020-03-23 14:36:34 +0530 | [diff] [blame] | 10 | #include "event_parser.hpp" |
Tom Joseph | 33e9c7e | 2020-06-11 22:09:52 +0530 | [diff] [blame] | 11 | #include "fru.hpp" |
George Liu | cae1866 | 2020-05-15 09:32:57 +0800 | [diff] [blame] | 12 | #include "host-bmc/dbus_to_event_handler.hpp" |
Deepak Kodihalli | ac19bd6 | 2020-06-16 08:25:23 -0500 | [diff] [blame] | 13 | #include "host-bmc/host_pdr_handler.hpp" |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 14 | #include "libpldmresponder/pdr.hpp" |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 15 | #include "libpldmresponder/pdr_utils.hpp" |
Deepak Kodihalli | 1521f6d | 2020-06-16 08:51:02 -0500 | [diff] [blame] | 16 | #include "pldmd/handler.hpp" |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 17 | |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 18 | #include <stdint.h> |
| 19 | |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 20 | #include <map> |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 21 | |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 22 | namespace pldm |
| 23 | { |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 24 | namespace responder |
| 25 | { |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 26 | namespace platform |
| 27 | { |
| 28 | |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 29 | using namespace pldm::utils; |
| 30 | using namespace pldm::responder::pdr_utils; |
George Liu | cae1866 | 2020-05-15 09:32:57 +0800 | [diff] [blame] | 31 | using namespace pldm::state_sensor; |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 32 | |
George Liu | a287072 | 2020-02-11 11:09:30 +0800 | [diff] [blame] | 33 | using generatePDR = |
George Liu | 36e8135 | 2020-07-01 14:40:30 +0800 | [diff] [blame] | 34 | std::function<void(const pldm::utils::DBusHandler& dBusIntf, |
| 35 | const Json& json, pdr_utils::RepoInterface& repo)>; |
George Liu | a287072 | 2020-02-11 11:09:30 +0800 | [diff] [blame] | 36 | |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 37 | using EffecterId = uint16_t; |
George Liu | a287072 | 2020-02-11 11:09:30 +0800 | [diff] [blame] | 38 | using DbusObjMaps = |
| 39 | std::map<EffecterId, |
| 40 | std::tuple<pdr_utils::DbusMappings, pdr_utils::DbusValMaps>>; |
Tom Joseph | 56e45c5 | 2020-03-16 10:01:45 +0530 | [diff] [blame] | 41 | using DbusPath = std::string; |
| 42 | using EffecterObjs = std::vector<DbusPath>; |
| 43 | using EventType = uint8_t; |
| 44 | using EventHandler = std::function<int( |
| 45 | const pldm_msg* request, size_t payloadLength, uint8_t formatVersion, |
| 46 | uint8_t tid, size_t eventDataOffset)>; |
| 47 | using EventHandlers = std::vector<EventHandler>; |
| 48 | using EventMap = std::map<EventType, EventHandlers>; |
George Liu | c4ea6a9 | 2020-07-14 15:48:44 +0800 | [diff] [blame^] | 49 | using AssociatedEntityMap = std::map<DbusPath, pldm_entity>; |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 50 | |
Zahed Hossain | 75330f3 | 2020-03-24 02:15:03 -0500 | [diff] [blame] | 51 | // EventEntry = <uint8_t> - EventState <uint8_t> - SensorOffset <uint16_t> - |
| 52 | // SensorID |
| 53 | using EventEntry = uint32_t; |
| 54 | struct DBusInfo |
| 55 | { |
| 56 | pldm::utils::DBusMapping dBusValues; |
| 57 | pldm::utils::PropertyValue dBusPropertyValue; |
| 58 | }; |
| 59 | |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 60 | class Handler : public CmdHandler |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 61 | { |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 62 | public: |
Deepak Kodihalli | b5c227e | 2020-07-13 06:58:34 -0500 | [diff] [blame] | 63 | Handler(const pldm::utils::DBusHandler* dBusIntf, |
George Liu | 36e8135 | 2020-07-01 14:40:30 +0800 | [diff] [blame] | 64 | const std::string& pdrJsonsDir, const std::string& eventsJsonsDir, |
TOM JOSEPH | d4d97a5 | 2020-03-23 14:36:34 +0530 | [diff] [blame] | 65 | pldm_pdr* repo, HostPDRHandler* hostPDRHandler, |
George Liu | cae1866 | 2020-05-15 09:32:57 +0800 | [diff] [blame] | 66 | DbusToPLDMEvent* dbusToPLDMEventHandler, fru::Handler* fruHandler, |
| 67 | bool buildPDRLazily = false, |
Tom Joseph | 56e45c5 | 2020-03-16 10:01:45 +0530 | [diff] [blame] | 68 | const std::optional<EventMap>& addOnHandlersMap = std::nullopt) : |
Pavithra Barithaya | 51efaf8 | 2020-04-02 02:42:27 -0500 | [diff] [blame] | 69 | pdrRepo(repo), |
Tom Joseph | 33e9c7e | 2020-06-11 22:09:52 +0530 | [diff] [blame] | 70 | hostPDRHandler(hostPDRHandler), stateSensorHandler(eventsJsonsDir), |
George Liu | cae1866 | 2020-05-15 09:32:57 +0800 | [diff] [blame] | 71 | dbusToPLDMEventHandler(dbusToPLDMEventHandler), fruHandler(fruHandler), |
| 72 | dBusIntf(dBusIntf), pdrJsonsDir(pdrJsonsDir), pdrCreated(false) |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 73 | { |
Deepak Kodihalli | b5c227e | 2020-07-13 06:58:34 -0500 | [diff] [blame] | 74 | if (!buildPDRLazily) |
| 75 | { |
Sampa Misra | 12afe11 | 2020-05-25 11:40:44 -0500 | [diff] [blame] | 76 | generateTerminusLocatorPDR(pdrRepo); |
Deepak Kodihalli | b5c227e | 2020-07-13 06:58:34 -0500 | [diff] [blame] | 77 | generate(*dBusIntf, pdrJsonsDir, pdrRepo); |
| 78 | pdrCreated = true; |
| 79 | } |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 80 | |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 81 | handlers.emplace(PLDM_GET_PDR, |
| 82 | [this](const pldm_msg* request, size_t payloadLength) { |
| 83 | return this->getPDR(request, payloadLength); |
| 84 | }); |
George Liu | eccb0c5 | 2020-01-14 11:09:56 +0800 | [diff] [blame] | 85 | handlers.emplace(PLDM_SET_NUMERIC_EFFECTER_VALUE, |
| 86 | [this](const pldm_msg* request, size_t payloadLength) { |
| 87 | return this->setNumericEffecterValue( |
| 88 | request, payloadLength); |
| 89 | }); |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 90 | handlers.emplace(PLDM_SET_STATE_EFFECTER_STATES, |
| 91 | [this](const pldm_msg* request, size_t payloadLength) { |
| 92 | return this->setStateEffecterStates(request, |
| 93 | payloadLength); |
| 94 | }); |
Tom Joseph | 56e45c5 | 2020-03-16 10:01:45 +0530 | [diff] [blame] | 95 | handlers.emplace(PLDM_PLATFORM_EVENT_MESSAGE, |
| 96 | [this](const pldm_msg* request, size_t payloadLength) { |
| 97 | return this->platformEventMessage(request, |
| 98 | payloadLength); |
| 99 | }); |
George Liu | 362c18d | 2020-05-14 09:46:36 +0800 | [diff] [blame] | 100 | handlers.emplace(PLDM_GET_STATE_SENSOR_READINGS, |
| 101 | [this](const pldm_msg* request, size_t payloadLength) { |
| 102 | return this->getStateSensorReadings(request, |
| 103 | payloadLength); |
| 104 | }); |
Tom Joseph | 56e45c5 | 2020-03-16 10:01:45 +0530 | [diff] [blame] | 105 | |
| 106 | // Default handler for PLDM Events |
| 107 | eventHandlers[PLDM_SENSOR_EVENT].emplace_back( |
| 108 | [this](const pldm_msg* request, size_t payloadLength, |
| 109 | uint8_t formatVersion, uint8_t tid, size_t eventDataOffset) { |
| 110 | return this->sensorEvent(request, payloadLength, formatVersion, |
| 111 | tid, eventDataOffset); |
| 112 | }); |
Deepak Kodihalli | 8cb6f66 | 2020-04-10 02:55:43 -0500 | [diff] [blame] | 113 | eventHandlers[PLDM_PDR_REPOSITORY_CHG_EVENT].emplace_back( |
| 114 | [this](const pldm_msg* request, size_t payloadLength, |
| 115 | uint8_t formatVersion, uint8_t tid, size_t eventDataOffset) { |
| 116 | return this->pldmPDRRepositoryChgEvent(request, payloadLength, |
| 117 | formatVersion, tid, |
| 118 | eventDataOffset); |
| 119 | }); |
Tom Joseph | 56e45c5 | 2020-03-16 10:01:45 +0530 | [diff] [blame] | 120 | |
| 121 | // Additional OEM event handlers for PLDM events, append it to the |
| 122 | // standard handlers |
| 123 | if (addOnHandlersMap) |
| 124 | { |
| 125 | auto addOnHandlers = addOnHandlersMap.value(); |
| 126 | for (EventMap::iterator iter = addOnHandlers.begin(); |
| 127 | iter != addOnHandlers.end(); ++iter) |
| 128 | { |
| 129 | auto search = eventHandlers.find(iter->first); |
| 130 | if (search != eventHandlers.end()) |
| 131 | { |
| 132 | search->second.insert(std::end(search->second), |
| 133 | std::begin(iter->second), |
| 134 | std::end(iter->second)); |
| 135 | } |
| 136 | else |
| 137 | { |
| 138 | eventHandlers.emplace(iter->first, iter->second); |
| 139 | } |
| 140 | } |
| 141 | } |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 142 | } |
| 143 | |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 144 | pdr_utils::Repo& getRepo() |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 145 | { |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 146 | return this->pdrRepo; |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 147 | } |
| 148 | |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 149 | /** @brief Add D-Bus mapping and value mapping(stateId to D-Bus) for the |
George Liu | adbe172 | 2020-05-09 19:20:19 +0800 | [diff] [blame] | 150 | * Id. If the same id is added, the previous dbusObjs will |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 151 | * be "over-written". |
| 152 | * |
George Liu | adbe172 | 2020-05-09 19:20:19 +0800 | [diff] [blame] | 153 | * @param[in] Id - effecter/sensor id |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 154 | * @param[in] dbusObj - list of D-Bus object structure and list of D-Bus |
| 155 | * property value to attribute value |
George Liu | adbe172 | 2020-05-09 19:20:19 +0800 | [diff] [blame] | 156 | * @param[in] typeId - the type id of enum |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 157 | */ |
George Liu | a287072 | 2020-02-11 11:09:30 +0800 | [diff] [blame] | 158 | void addDbusObjMaps( |
George Liu | adbe172 | 2020-05-09 19:20:19 +0800 | [diff] [blame] | 159 | uint16_t id, |
| 160 | std::tuple<pdr_utils::DbusMappings, pdr_utils::DbusValMaps> dbusObj, |
| 161 | TypeId typeId = TypeId::PLDM_EFFECTER_ID); |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 162 | |
George Liu | adbe172 | 2020-05-09 19:20:19 +0800 | [diff] [blame] | 163 | /** @brief Retrieve an id -> D-Bus objects mapping |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 164 | * |
George Liu | adbe172 | 2020-05-09 19:20:19 +0800 | [diff] [blame] | 165 | * @param[in] Id - id |
| 166 | * @param[in] typeId - the type id of enum |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 167 | * |
George Liu | a287072 | 2020-02-11 11:09:30 +0800 | [diff] [blame] | 168 | * @return std::tuple<pdr_utils::DbusMappings, pdr_utils::DbusValMaps> - |
| 169 | * list of D-Bus object structure and list of D-Bus property value |
| 170 | * to attribute value |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 171 | */ |
George Liu | a287072 | 2020-02-11 11:09:30 +0800 | [diff] [blame] | 172 | const std::tuple<pdr_utils::DbusMappings, pdr_utils::DbusValMaps>& |
George Liu | adbe172 | 2020-05-09 19:20:19 +0800 | [diff] [blame] | 173 | getDbusObjMaps(uint16_t id, |
| 174 | TypeId typeId = TypeId::PLDM_EFFECTER_ID) const; |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 175 | |
| 176 | uint16_t getNextEffecterId() |
| 177 | { |
| 178 | return ++nextEffecterId; |
| 179 | } |
| 180 | |
George Liu | adbe172 | 2020-05-09 19:20:19 +0800 | [diff] [blame] | 181 | uint16_t getNextSensorId() |
| 182 | { |
| 183 | return ++nextSensorId; |
| 184 | } |
| 185 | |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 186 | /** @brief Parse PDR JSONs and build PDR repository |
| 187 | * |
George Liu | 36e8135 | 2020-07-01 14:40:30 +0800 | [diff] [blame] | 188 | * @param[in] dBusIntf - The interface object |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 189 | * @param[in] dir - directory housing platform specific PDR JSON files |
| 190 | * @param[in] repo - instance of concrete implementation of Repo |
| 191 | */ |
George Liu | 36e8135 | 2020-07-01 14:40:30 +0800 | [diff] [blame] | 192 | void generate(const pldm::utils::DBusHandler& dBusIntf, |
| 193 | const std::string& dir, Repo& repo); |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 194 | |
| 195 | /** @brief Parse PDR JSONs and build state effecter PDR repository |
| 196 | * |
| 197 | * @param[in] json - platform specific PDR JSON files |
| 198 | * @param[in] repo - instance of state effecter implementation of Repo |
| 199 | */ |
| 200 | void generateStateEffecterRepo(const Json& json, Repo& repo); |
| 201 | |
Tom Joseph | 56e45c5 | 2020-03-16 10:01:45 +0530 | [diff] [blame] | 202 | /** @brief map of PLDM event type to EventHandlers |
| 203 | * |
| 204 | */ |
| 205 | EventMap eventHandlers; |
| 206 | |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 207 | /** @brief Handler for GetPDR |
| 208 | * |
| 209 | * @param[in] request - Request message payload |
| 210 | * @param[in] payloadLength - Request payload length |
| 211 | * @param[out] Response - Response message written here |
| 212 | */ |
| 213 | Response getPDR(const pldm_msg* request, size_t payloadLength); |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 214 | |
George Liu | eccb0c5 | 2020-01-14 11:09:56 +0800 | [diff] [blame] | 215 | /** @brief Handler for setNumericEffecterValue |
| 216 | * |
| 217 | * @param[in] request - Request message |
| 218 | * @param[in] payloadLength - Request payload length |
| 219 | * @return Response - PLDM Response message |
| 220 | */ |
| 221 | Response setNumericEffecterValue(const pldm_msg* request, |
| 222 | size_t payloadLength); |
| 223 | |
George Liu | 362c18d | 2020-05-14 09:46:36 +0800 | [diff] [blame] | 224 | /** @brief Handler for getStateSensorReadings |
| 225 | * |
| 226 | * @param[in] request - Request message |
| 227 | * @param[in] payloadLength - Request payload length |
| 228 | * @return Response - PLDM Response message |
| 229 | */ |
| 230 | Response getStateSensorReadings(const pldm_msg* request, |
| 231 | size_t payloadLength); |
| 232 | |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 233 | /** @brief Handler for setStateEffecterStates |
| 234 | * |
| 235 | * @param[in] request - Request message |
| 236 | * @param[in] payloadLength - Request payload length |
| 237 | * @return Response - PLDM Response message |
| 238 | */ |
| 239 | Response setStateEffecterStates(const pldm_msg* request, |
| 240 | size_t payloadLength); |
| 241 | |
Tom Joseph | 56e45c5 | 2020-03-16 10:01:45 +0530 | [diff] [blame] | 242 | /** @brief Handler for PlatformEventMessage |
| 243 | * |
| 244 | * @param[in] request - Request message |
| 245 | * @param[in] payloadLength - Request payload length |
| 246 | * @return Response - PLDM Response message |
| 247 | */ |
| 248 | Response platformEventMessage(const pldm_msg* request, |
| 249 | size_t payloadLength); |
| 250 | |
| 251 | /** @brief Handler for event class Sensor event |
| 252 | * |
| 253 | * @param[in] request - Request message |
| 254 | * @param[in] payloadLength - Request payload length |
| 255 | * @param[in] formatVersion - Version of the event format |
| 256 | * @param[in] tid - Terminus ID of the event's originator |
| 257 | * @param[in] eventDataOffset - Offset of the event data in the request |
| 258 | * message |
| 259 | * @return PLDM completion code |
| 260 | */ |
| 261 | int sensorEvent(const pldm_msg* request, size_t payloadLength, |
| 262 | uint8_t formatVersion, uint8_t tid, size_t eventDataOffset); |
| 263 | |
Deepak Kodihalli | 8cb6f66 | 2020-04-10 02:55:43 -0500 | [diff] [blame] | 264 | /** @brief Handler for pldmPDRRepositoryChgEvent |
| 265 | * |
| 266 | * @param[in] request - Request message |
| 267 | * @param[in] payloadLength - Request payload length |
| 268 | * @param[in] formatVersion - Version of the event format |
| 269 | * @param[in] tid - Terminus ID of the event's originator |
| 270 | * @param[in] eventDataOffset - Offset of the event data in the request |
| 271 | * message |
| 272 | * @return PLDM completion code |
| 273 | */ |
| 274 | int pldmPDRRepositoryChgEvent(const pldm_msg* request, size_t payloadLength, |
| 275 | uint8_t formatVersion, uint8_t tid, |
| 276 | size_t eventDataOffset); |
| 277 | |
| 278 | /** @brief Handler for extracting the PDR handles from changeEntries |
| 279 | * |
| 280 | * @param[in] changeEntryData - ChangeEntry data from changeRecord |
| 281 | * @param[in] changeEntryDataSize - total size of changeEntryData |
| 282 | * @param[in] numberOfChangeEntries - total number of changeEntries to |
| 283 | * extract |
| 284 | * @param[out] pdrRecordHandles - std::vector where the extracted PDR |
| 285 | * handles are placed |
| 286 | * @return PLDM completion code |
| 287 | */ |
| 288 | int getPDRRecordHandles(const ChangeEntry* changeEntryData, |
| 289 | size_t changeEntryDataSize, |
| 290 | size_t numberOfChangeEntries, |
| 291 | PDRRecordHandles& pdrRecordHandles); |
| 292 | |
Zahed Hossain | 75330f3 | 2020-03-24 02:15:03 -0500 | [diff] [blame] | 293 | /** @brief Handler for setting Sensor event data |
| 294 | * |
| 295 | * @param[in] sensorId - sensorID value of the sensor |
| 296 | * @param[in] sensorOffset - Identifies which state sensor within a |
| 297 | * composite state sensor the event is being returned for |
| 298 | * @param[in] eventState - The event state value from the state change that |
| 299 | * triggered the event message |
| 300 | * @return PLDM completion code |
| 301 | */ |
| 302 | int setSensorEventData(uint16_t sensorId, uint8_t sensorOffset, |
| 303 | uint8_t eventState); |
| 304 | |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 305 | /** @brief Function to set the effecter requested by pldm requester |
| 306 | * @param[in] dBusIntf - The interface object |
| 307 | * @param[in] effecterId - Effecter ID sent by the requester to act on |
| 308 | * @param[in] stateField - The state field data for each of the states, |
| 309 | * equal to composite effecter count in number |
| 310 | * @return - Success or failure in setting the states. Returns failure in |
| 311 | * terms of PLDM completion codes if atleast one state fails to be set |
| 312 | */ |
| 313 | template <class DBusInterface> |
| 314 | int setStateEffecterStatesHandler( |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 315 | const DBusInterface& dBusIntf, uint16_t effecterId, |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 316 | const std::vector<set_effecter_state_field>& stateField) |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 317 | { |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 318 | using namespace pldm::responder::pdr; |
George Liu | 1e44c73 | 2020-02-28 20:20:06 +0800 | [diff] [blame] | 319 | using namespace pldm::utils; |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 320 | using StateSetNum = uint8_t; |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 321 | |
| 322 | state_effecter_possible_states* states = nullptr; |
| 323 | pldm_state_effecter_pdr* pdr = nullptr; |
| 324 | uint8_t compEffecterCnt = stateField.size(); |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 325 | |
| 326 | std::unique_ptr<pldm_pdr, decltype(&pldm_pdr_destroy)> |
| 327 | stateEffecterPdrRepo(pldm_pdr_init(), pldm_pdr_destroy); |
| 328 | Repo stateEffecterPDRs(stateEffecterPdrRepo.get()); |
| 329 | getRepoByType(pdrRepo, stateEffecterPDRs, PLDM_STATE_EFFECTER_PDR); |
| 330 | if (stateEffecterPDRs.empty()) |
| 331 | { |
| 332 | std::cerr << "Failed to get record by PDR type\n"; |
| 333 | return PLDM_PLATFORM_INVALID_EFFECTER_ID; |
| 334 | } |
| 335 | |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 336 | PdrEntry pdrEntry{}; |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 337 | auto pdrRecord = stateEffecterPDRs.getFirstRecord(pdrEntry); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 338 | while (pdrRecord) |
| 339 | { |
| 340 | pdr = reinterpret_cast<pldm_state_effecter_pdr*>(pdrEntry.data); |
| 341 | if (pdr->effecter_id != effecterId) |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 342 | { |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 343 | pdr = nullptr; |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 344 | pdrRecord = |
| 345 | stateEffecterPDRs.getNextRecord(pdrRecord, pdrEntry); |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 346 | continue; |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 347 | } |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 348 | |
| 349 | states = reinterpret_cast<state_effecter_possible_states*>( |
| 350 | pdr->possible_states); |
| 351 | if (compEffecterCnt > pdr->composite_effecter_count) |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 352 | { |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 353 | std::cerr << "The requester sent wrong composite effecter" |
| 354 | << " count for the effecter, EFFECTER_ID=" |
| 355 | << effecterId << "COMP_EFF_CNT=" << compEffecterCnt |
| 356 | << "\n"; |
| 357 | return PLDM_ERROR_INVALID_DATA; |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 358 | } |
George Liu | e53193f | 2020-02-24 09:23:26 +0800 | [diff] [blame] | 359 | break; |
| 360 | } |
| 361 | |
| 362 | if (!pdr) |
| 363 | { |
| 364 | return PLDM_PLATFORM_INVALID_EFFECTER_ID; |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 365 | } |
Sampa Misra | a2fa070 | 2019-05-31 01:28:55 -0500 | [diff] [blame] | 366 | |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 367 | int rc = PLDM_SUCCESS; |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 368 | try |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 369 | { |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 370 | const auto& [dbusMappings, dbusValMaps] = |
George Liu | adbe172 | 2020-05-09 19:20:19 +0800 | [diff] [blame] | 371 | effecterDbusObjMaps.at(effecterId); |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 372 | for (uint8_t currState = 0; currState < compEffecterCnt; |
| 373 | ++currState) |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 374 | { |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 375 | std::vector<StateSetNum> allowed{}; |
| 376 | // computation is based on table 79 from DSP0248 v1.1.1 |
| 377 | uint8_t bitfieldIndex = |
| 378 | stateField[currState].effecter_state / 8; |
| 379 | uint8_t bit = |
| 380 | stateField[currState].effecter_state - (8 * bitfieldIndex); |
| 381 | if (states->possible_states_size < bitfieldIndex || |
| 382 | !(states->states[bitfieldIndex].byte & (1 << bit))) |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 383 | { |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 384 | std::cerr |
| 385 | << "Invalid state set value, EFFECTER_ID=" << effecterId |
| 386 | << " VALUE=" << stateField[currState].effecter_state |
| 387 | << " COMPOSITE_EFFECTER_ID=" << currState |
| 388 | << " DBUS_PATH=" << dbusMappings[currState].objectPath |
| 389 | << "\n"; |
| 390 | rc = PLDM_PLATFORM_SET_EFFECTER_UNSUPPORTED_SENSORSTATE; |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 391 | break; |
| 392 | } |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 393 | const DBusMapping& dbusMapping = dbusMappings[currState]; |
| 394 | const StatestoDbusVal& dbusValToMap = dbusValMaps[currState]; |
| 395 | |
| 396 | if (stateField[currState].set_request == PLDM_REQUEST_SET) |
| 397 | { |
| 398 | try |
| 399 | { |
| 400 | dBusIntf.setDbusProperty( |
| 401 | dbusMapping, |
| 402 | dbusValToMap.at( |
| 403 | stateField[currState].effecter_state)); |
| 404 | } |
| 405 | catch (const std::exception& e) |
| 406 | { |
| 407 | std::cerr |
| 408 | << "Error setting property, ERROR=" << e.what() |
| 409 | << " PROPERTY=" << dbusMapping.propertyName |
| 410 | << " INTERFACE=" |
| 411 | << dbusMapping.interface << " PATH=" |
| 412 | << dbusMapping.objectPath << "\n"; |
| 413 | return PLDM_ERROR; |
| 414 | } |
| 415 | } |
| 416 | uint8_t* nextState = |
| 417 | reinterpret_cast<uint8_t*>(states) + |
| 418 | sizeof(state_effecter_possible_states) - |
| 419 | sizeof(states->states) + |
| 420 | (states->possible_states_size * sizeof(states->states)); |
| 421 | states = reinterpret_cast<state_effecter_possible_states*>( |
| 422 | nextState); |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 423 | } |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 424 | } |
George Liu | 1ec85d4 | 2020-02-12 16:05:32 +0800 | [diff] [blame] | 425 | catch (const std::out_of_range& e) |
| 426 | { |
| 427 | std::cerr << "the effecterId does not exist. effecter id: " |
| 428 | << effecterId << e.what() << '\n'; |
| 429 | } |
| 430 | |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 431 | return rc; |
| 432 | } |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 433 | |
Sampa Misra | 12afe11 | 2020-05-25 11:40:44 -0500 | [diff] [blame] | 434 | /** @brief Build BMC Terminus Locator PDR |
| 435 | * |
| 436 | * @param[in] repo - instance of concrete implementation of Repo |
| 437 | */ |
| 438 | void generateTerminusLocatorPDR(Repo& repo); |
| 439 | |
George Liu | c4ea6a9 | 2020-07-14 15:48:44 +0800 | [diff] [blame^] | 440 | /** @brief Get std::map associated with the entity |
| 441 | * key: object path |
| 442 | * value: pldm_entity |
| 443 | * |
| 444 | * @return std::map<ObjectPath, pldm_entity> |
| 445 | */ |
| 446 | inline const AssociatedEntityMap& getAssociateEntityMap() const |
| 447 | { |
| 448 | if (fruHandler == nullptr) |
| 449 | { |
| 450 | throw InternalFailure(); |
| 451 | } |
| 452 | return fruHandler->getAssociateEntityMap(); |
| 453 | } |
| 454 | |
Deepak Kodihalli | c682fe2 | 2020-03-04 00:42:54 -0600 | [diff] [blame] | 455 | private: |
| 456 | pdr_utils::Repo pdrRepo; |
| 457 | uint16_t nextEffecterId{}; |
George Liu | adbe172 | 2020-05-09 19:20:19 +0800 | [diff] [blame] | 458 | uint16_t nextSensorId{}; |
| 459 | DbusObjMaps effecterDbusObjMaps{}; |
| 460 | DbusObjMaps sensorDbusObjMaps{}; |
Pavithra Barithaya | 51efaf8 | 2020-04-02 02:42:27 -0500 | [diff] [blame] | 461 | HostPDRHandler* hostPDRHandler; |
TOM JOSEPH | d4d97a5 | 2020-03-23 14:36:34 +0530 | [diff] [blame] | 462 | events::StateSensorHandler stateSensorHandler; |
George Liu | cae1866 | 2020-05-15 09:32:57 +0800 | [diff] [blame] | 463 | DbusToPLDMEvent* dbusToPLDMEventHandler; |
Tom Joseph | 33e9c7e | 2020-06-11 22:09:52 +0530 | [diff] [blame] | 464 | fru::Handler* fruHandler; |
Deepak Kodihalli | b5c227e | 2020-07-13 06:58:34 -0500 | [diff] [blame] | 465 | const pldm::utils::DBusHandler* dBusIntf; |
| 466 | std::string pdrJsonsDir; |
| 467 | bool pdrCreated; |
Deepak Kodihalli | bc669f1 | 2019-11-28 08:52:07 -0600 | [diff] [blame] | 468 | }; |
| 469 | |
| 470 | } // namespace platform |
Deepak Kodihalli | 557dfb0 | 2019-05-12 13:11:17 +0530 | [diff] [blame] | 471 | } // namespace responder |
| 472 | } // namespace pldm |