1 #include "common/types.hpp"
2 #include "pldm_cmd_helper.hpp"
3
4 #include <libpldm/entity.h>
5 #include <libpldm/platform.h>
6 #include <libpldm/state_set.h>
7
8 #include <algorithm>
9 #include <cstddef>
10 #include <map>
11 #include <ranges>
12
13 #ifdef OEM_IBM
14 #include "oem/ibm/oem_ibm_state_set.hpp"
15 #endif
16
17 using namespace pldm::utils;
18
19 namespace pldmtool
20 {
21 namespace platform
22 {
23 namespace
24 {
25 using namespace pldmtool::helper;
26
27 static const std::map<uint8_t, std::string> sensorPresState{
28 {PLDM_SENSOR_UNKNOWN, "Sensor Unknown"},
29 {PLDM_SENSOR_NORMAL, "Sensor Normal"},
30 {PLDM_SENSOR_WARNING, "Sensor Warning"},
31 {PLDM_SENSOR_CRITICAL, "Sensor Critical"},
32 {PLDM_SENSOR_FATAL, "Sensor Fatal"},
33 {PLDM_SENSOR_LOWERWARNING, "Sensor Lower Warning"},
34 {PLDM_SENSOR_LOWERCRITICAL, "Sensor Lower Critical"},
35 {PLDM_SENSOR_LOWERFATAL, "Sensor Lower Fatal"},
36 {PLDM_SENSOR_UPPERWARNING, "Sensor Upper Warning"},
37 {PLDM_SENSOR_UPPERCRITICAL, "Sensor Upper Critical"},
38 {PLDM_SENSOR_UPPERFATAL, "Sensor Upper Fatal"}};
39
40 static const std::map<uint8_t, std::string> sensorOpState{
41 {PLDM_SENSOR_ENABLED, "Sensor Enabled"},
42 {PLDM_SENSOR_DISABLED, "Sensor Disabled"},
43 {PLDM_SENSOR_UNAVAILABLE, "Sensor Unavailable"},
44 {PLDM_SENSOR_STATUSUNKOWN, "Sensor Status Unknown"},
45 {PLDM_SENSOR_FAILED, "Sensor Failed"},
46 {PLDM_SENSOR_INITIALIZING, "Sensor Sensor Initializing"},
47 {PLDM_SENSOR_SHUTTINGDOWN, "Sensor Shutting down"},
48 {PLDM_SENSOR_INTEST, "Sensor Intest"}};
49
50 std::vector<std::unique_ptr<CommandInterface>> commands;
51
52 } // namespace
53
54 using ordered_json = nlohmann::ordered_json;
55
56 class GetPDR : public CommandInterface
57 {
58 public:
59 ~GetPDR() = default;
60 GetPDR() = delete;
61 GetPDR(const GetPDR&) = delete;
62 GetPDR(GetPDR&&) = default;
63 GetPDR& operator=(const GetPDR&) = delete;
64 GetPDR& operator=(GetPDR&&) = delete;
65
66 using CommandInterface::CommandInterface;
67
GetPDR(const char * type,const char * name,CLI::App * app)68 explicit GetPDR(const char* type, const char* name, CLI::App* app) :
69 CommandInterface(type, name, app)
70 {
71 auto pdrOptionGroup = app->add_option_group(
72 "Required Option",
73 "Retrieve individual PDR, all PDRs, PDRs of a requested type or retrieve all PDRs of the requested terminusID");
74 pdrOptionGroup->add_option(
75 "-d,--data", recordHandle,
76 "retrieve individual PDRs from a PDR Repository\n"
77 "eg: The recordHandle value for the PDR to be retrieved and 0 "
78 "means get first PDR in the repository.");
79 pdrRecType = "";
80 pdrOptionGroup->add_option("-t, --type", pdrRecType,
81 "retrieve all PDRs of the requested type\n"
82 "supported types:\n"
83 "[terminusLocator, stateSensor, "
84 "numericEffecter, stateEffecter, "
85 "compactNumericSensor, sensorauxname, "
86 "efffecterAuxName, numericsensor, "
87 "EntityAssociation, fruRecord, ... ]");
88
89 getPDRGroupOption = pdrOptionGroup->add_option(
90 "-i, --terminusID", pdrTerminus,
91 "retrieve all PDRs of the requested terminusID\n"
92 "supported IDs:\n [1, 2, 208...]");
93
94 allPDRs = false;
95 pdrOptionGroup->add_flag("-a, --all", allPDRs,
96 "retrieve all PDRs from a PDR repository");
97
98 pdrOptionGroup->require_option(1);
99 }
100
parseGetPDROptions()101 void parseGetPDROptions()
102 {
103 optTIDSet = false;
104 if (getPDRGroupOption->count() > 0)
105 {
106 optTIDSet = true;
107 getPDRs();
108 }
109 }
110
getPDRs()111 void getPDRs()
112 {
113 // start the array
114 std::cout << "[";
115
116 recordHandle = 0;
117 do
118 {
119 CommandInterface::exec();
120 } while (recordHandle != 0);
121
122 // close the array
123 std::cout << "]\n";
124
125 if (handleFound)
126 {
127 recordHandle = 0;
128 uint32_t prevRecordHandle = 0;
129 do
130 {
131 CommandInterface::exec();
132 if (recordHandle == prevRecordHandle)
133 {
134 return;
135 }
136 prevRecordHandle = recordHandle;
137 } while (recordHandle != 0);
138 }
139 }
140
exec()141 void exec() override
142 {
143 if (allPDRs || !pdrRecType.empty())
144 {
145 if (!pdrRecType.empty())
146 {
147 std::transform(pdrRecType.begin(), pdrRecType.end(),
148 pdrRecType.begin(), tolower);
149 }
150
151 // start the array
152 std::cout << "[\n";
153
154 // Retrieve all PDR records starting from the first
155 recordHandle = 0;
156 uint32_t prevRecordHandle = 0;
157 std::map<uint32_t, uint32_t> recordsSeen;
158 do
159 {
160 CommandInterface::exec();
161 // recordHandle is updated to nextRecord when
162 // CommandInterface::exec() is successful.
163 // In case of any error, return.
164 if (recordHandle == prevRecordHandle)
165 {
166 return;
167 }
168
169 // check for circular references.
170 auto result = recordsSeen.emplace(recordHandle,
171 prevRecordHandle);
172 if (!result.second)
173 {
174 std::cerr
175 << "Record handle " << recordHandle
176 << " has multiple references: " << result.first->second
177 << ", " << prevRecordHandle << "\n";
178 return;
179 }
180 prevRecordHandle = recordHandle;
181
182 if (recordHandle != 0)
183 {
184 // close the array
185 std::cout << ",";
186 }
187 } while (recordHandle != 0);
188
189 // close the array
190 std::cout << "]\n";
191 }
192 else
193 {
194 CommandInterface::exec();
195 }
196 }
197
createRequestMsg()198 std::pair<int, std::vector<uint8_t>> createRequestMsg() override
199 {
200 std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
201 PLDM_GET_PDR_REQ_BYTES);
202 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
203
204 auto rc = encode_get_pdr_req(instanceId, recordHandle, 0,
205 PLDM_GET_FIRSTPART, UINT16_MAX, 0, request,
206 PLDM_GET_PDR_REQ_BYTES);
207 return {rc, requestMsg};
208 }
209
parseResponseMsg(pldm_msg * responsePtr,size_t payloadLength)210 void parseResponseMsg(pldm_msg* responsePtr, size_t payloadLength) override
211 {
212 uint8_t completionCode = 0;
213 uint8_t recordData[UINT16_MAX] = {0};
214 uint32_t nextRecordHndl = 0;
215 uint32_t nextDataTransferHndl = 0;
216 uint8_t transferFlag = 0;
217 uint16_t respCnt = 0;
218 uint8_t transferCRC = 0;
219
220 auto rc = decode_get_pdr_resp(
221 responsePtr, payloadLength, &completionCode, &nextRecordHndl,
222 &nextDataTransferHndl, &transferFlag, &respCnt, recordData,
223 sizeof(recordData), &transferCRC);
224
225 if (rc != PLDM_SUCCESS || completionCode != PLDM_SUCCESS)
226 {
227 std::cerr << "Response Message Error: "
228 << "rc=" << rc << ",cc=" << (int)completionCode
229 << std::endl;
230 return;
231 }
232
233 if (optTIDSet && !handleFound)
234 {
235 terminusHandle = getTerminusHandle(recordData, pdrTerminus);
236 if (terminusHandle.has_value())
237 {
238 recordHandle = 0;
239 return;
240 }
241 else
242 {
243 recordHandle = nextRecordHndl;
244 return;
245 }
246 }
247
248 else
249 {
250 printPDRMsg(nextRecordHndl, respCnt, recordData, terminusHandle);
251 recordHandle = nextRecordHndl;
252 }
253 }
254
255 private:
256 const std::map<pldm::pdr::EntityType, std::string> entityType = {
257 {PLDM_ENTITY_UNSPECIFIED, "Unspecified"},
258 {PLDM_ENTITY_OTHER, "Other"},
259 {PLDM_ENTITY_NETWORK, "Network"},
260 {PLDM_ENTITY_GROUP, "Group"},
261 {PLDM_ENTITY_REMOTE_MGMT_COMM_DEVICE,
262 "Remote Management Communication Device"},
263 {PLDM_ENTITY_EXTERNAL_ENVIRONMENT, "External Environment"},
264 {PLDM_ENTITY_COMM_CHANNEL, " Communication Channel"},
265 {PLDM_ENTITY_TERMINUS, "PLDM Terminus"},
266 {PLDM_ENTITY_PLATFORM_EVENT_LOG, " Platform Event Log"},
267 {PLDM_ENTITY_KEYPAD, "keypad"},
268 {PLDM_ENTITY_SWITCH, "Switch"},
269 {PLDM_ENTITY_PUSHBUTTON, "Pushbutton"},
270 {PLDM_ENTITY_DISPLAY, "Display"},
271 {PLDM_ENTITY_INDICATOR, "Indicator"},
272 {PLDM_ENTITY_SYS_MGMT_SW, "System Management Software"},
273 {PLDM_ENTITY_SYS_FIRMWARE, "System Firmware"},
274 {PLDM_ENTITY_OPERATING_SYS, "Operating System"},
275 {PLDM_ENTITY_VIRTUAL_MACHINE_MANAGER, "Virtual Machine Manager"},
276 {PLDM_ENTITY_OS_LOADER, "OS Loader"},
277 {PLDM_ENTITY_DEVICE_DRIVER, "Device Driver"},
278 {PLDM_ENTITY_MGMT_CONTROLLER_FW, "Management Controller Firmware"},
279 {PLDM_ENTITY_SYSTEM_CHASSIS, "System chassis (main enclosure)"},
280 {PLDM_ENTITY_SUB_CHASSIS, "Sub-chassis"},
281 {PLDM_ENTITY_DISK_DRIVE_BAY, "Disk Drive Bay"},
282 {PLDM_ENTITY_PERIPHERAL_BAY, "Peripheral Bay"},
283 {PLDM_ENTITY_DEVICE_BAY, "Device bay"},
284 {PLDM_ENTITY_DOOR, "Door"},
285 {PLDM_ENTITY_ACCESS_PANEL, "Access Panel"},
286 {PLDM_ENTITY_COVER, "Cover"},
287 {PLDM_ENTITY_BOARD, "Board"},
288 {PLDM_ENTITY_CARD, "Card"},
289 {PLDM_ENTITY_MODULE, "Module"},
290 {PLDM_ENTITY_SYS_MGMT_MODULE, "System management module"},
291 {PLDM_ENTITY_SYS_BOARD, "System Board"},
292 {PLDM_ENTITY_MEMORY_BOARD, "Memory Board"},
293 {PLDM_ENTITY_MEMORY_MODULE, "Memory Module"},
294 {PLDM_ENTITY_PROC_MODULE, "Processor Module"},
295 {PLDM_ENTITY_ADD_IN_CARD, "Add-in Card"},
296 {PLDM_ENTITY_CHASSIS_FRONT_PANEL_BOARD,
297 "Chassis front panel board(control panel)"},
298 {PLDM_ENTITY_BACK_PANEL_BOARD, "Back panel board"},
299 {PLDM_ENTITY_POWER_MGMT, "Power management board"},
300 {PLDM_ENTITY_POWER_SYS_BOARD, "Power system board"},
301 {PLDM_ENTITY_DRIVE_BACKPLANE, "Drive backplane"},
302 {PLDM_ENTITY_SYS_INTERNAL_EXPANSION_BOARD,
303 "System internal expansion board"},
304 {PLDM_ENTITY_OTHER_SYS_BOARD, "Other system board"},
305 {PLDM_ENTITY_CHASSIS_BACK_PANEL_BOARD, "Chassis back panel board"},
306 {PLDM_ENTITY_PROCESSING_BLADE, "Processing blade"},
307 {PLDM_ENTITY_CONNECTIVITY_SWITCH, "Connectivity switch"},
308 {PLDM_ENTITY_PROC_MEMORY_MODULE, "Processor/Memory Module"},
309 {PLDM_ENTITY_IO_MODULE, "I/O Module"},
310 {PLDM_ENTITY_PROC_IO_MODULE, "Processor I/O Module"},
311 {PLDM_ENTITY_COOLING_DEVICE, "Cooling device"},
312 {PLDM_ENTITY_COOLING_SUBSYSTEM, "Cooling subsystem"},
313 {PLDM_ENTITY_COOLING_UNIT, "Cooling Unit"},
314 {PLDM_ENTITY_FAN, "Fan"},
315 {PLDM_ENTITY_PELTIER_COOLING_DEVICE, "Peltier Cooling Device"},
316 {PLDM_ENTITY_LIQUID_COOLING_DEVICE, "Liquid Cooling Device"},
317 {PLDM_ENTITY_LIQUID_COOLING_SUBSYSTEM, "Liquid Colling Subsystem"},
318 {PLDM_ENTITY_OTHER_STORAGE_DEVICE, "Other Storage Device"},
319 {PLDM_ENTITY_FLOPPY_DRIVE, "Floppy Drive"},
320 {PLDM_ENTITY_FIXED_DISK_HARD_DRIVE, "Hard Drive"},
321 {PLDM_ENTITY_CD_DRIVE, "CD Drive"},
322 {PLDM_ENTITY_CD_DVD_DRIVE, "CD/DVD Drive"},
323 {PLDM_ENTITY_OTHER_SILICON_STORAGE_DEVICE,
324 "Other Silicon Storage Device"},
325 {PLDM_ENTITY_SOLID_STATE_SRIVE, "Solid State Drive"},
326 {PLDM_ENTITY_POWER_SUPPLY, "Power supply"},
327 {PLDM_ENTITY_BATTERY, "Battery"},
328 {PLDM_ENTITY_SUPER_CAPACITOR, "Super Capacitor"},
329 {PLDM_ENTITY_POWER_CONVERTER, "Power Converter"},
330 {PLDM_ENTITY_DC_DC_CONVERTER, "DC-DC Converter"},
331 {PLDM_ENTITY_AC_MAINS_POWER_SUPPLY, "AC mains power supply"},
332 {PLDM_ENTITY_DC_MAINS_POWER_SUPPLY, "DC mains power supply"},
333 {PLDM_ENTITY_PROC, "Processor"},
334 {PLDM_ENTITY_CHIPSET_COMPONENT, "Chipset Component"},
335 {PLDM_ENTITY_MGMT_CONTROLLER, "Management Controller"},
336 {PLDM_ENTITY_PERIPHERAL_CONTROLLER, "Peripheral Controller"},
337 {PLDM_ENTITY_SEEPROM, "SEEPROM"},
338 {PLDM_ENTITY_NVRAM_CHIP, "NVRAM Chip"},
339 {PLDM_ENTITY_FLASH_MEMORY_CHIP, "FLASH Memory chip"},
340 {PLDM_ENTITY_MEMORY_CHIP, "Memory Chip"},
341 {PLDM_ENTITY_MEMORY_CONTROLLER, "Memory Controller"},
342 {PLDM_ENTITY_NETWORK_CONTROLLER, "Network Controller"},
343 {PLDM_ENTITY_IO_CONTROLLER, "I/O Controller"},
344 {PLDM_ENTITY_SOUTH_BRIDGE, "South Bridge"},
345 {PLDM_ENTITY_REAL_TIME_CLOCK, "Real Time Clock (RTC)"},
346 {PLDM_ENTITY_FPGA_CPLD_DEVICE, "FPGA/CPLD Configurable Logic Device"},
347 {PLDM_ENTITY_OTHER_BUS, "Other Bus"},
348 {PLDM_ENTITY_SYS_BUS, "System Bus"},
349 {PLDM_ENTITY_I2C_BUS, "I2C Bus"},
350 {PLDM_ENTITY_SMBUS_BUS, "SMBus Bus"},
351 {PLDM_ENTITY_SPI_BUS, "SPI Bus"},
352 {PLDM_ENTITY_PCI_BUS, "PCI Bus"},
353 {PLDM_ENTITY_PCI_EXPRESS_BUS, "PCI Express Bus"},
354 {PLDM_ENTITY_PECI_BUS, "PECI Bus"},
355 {PLDM_ENTITY_LPC_BUS, "LPC Bus"},
356 {PLDM_ENTITY_USB_BUS, "USB Bus"},
357 {PLDM_ENTITY_FIREWIRE_BUS, "FireWire Bus"},
358 {PLDM_ENTITY_SCSI_BUS, "SCSI Bus"},
359 {PLDM_ENTITY_SATA_SAS_BUS, "SATA/SAS Bus"},
360 {PLDM_ENTITY_PROC_FRONT_SIDE_BUS, "Processor/Front-side Bus"},
361 {PLDM_ENTITY_INTER_PROC_BUS, "Inter-processor Bus"},
362 {PLDM_ENTITY_CONNECTOR, "Connector"},
363 {PLDM_ENTITY_SLOT, "Slot"},
364 {PLDM_ENTITY_CABLE, "Cable(electrical or optical)"},
365 {PLDM_ENTITY_INTERCONNECT, "Interconnect"},
366 {PLDM_ENTITY_PLUG, "Plug"},
367 {PLDM_ENTITY_SOCKET, "Socket"},
368 };
369
370 const std::map<uint16_t, std::string> stateSet = {
371 {PLDM_STATE_SET_HEALTH_STATE, "Health State"},
372 {PLDM_STATE_SET_AVAILABILITY, "Availability"},
373 {PLDM_STATE_SET_PREDICTIVE_CONDITION, "Predictive Condition"},
374 {PLDM_STATE_SET_REDUNDANCY_STATUS, "Redundancy Status"},
375 {PLDM_STATE_SET_HEALTH_REDUNDANCY_TREND, "Health/Redundancy Trend"},
376 {PLDM_STATE_SET_GROUP_RESOURCE_LEVEL, "Group Resource Level"},
377 {PLDM_STATE_SET_REDUNDANCY_ENTITY_ROLE, "Redundancy Entity Role"},
378 {PLDM_STATE_SET_OPERATIONAL_STATUS, "Operational Status"},
379 {PLDM_STATE_SET_OPERATIONAL_STRESS_STATUS, "Operational Stress Status"},
380 {PLDM_STATE_SET_OPERATIONAL_FAULT_STATUS, "Operational Fault Status"},
381 {PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS,
382 "Operational Running Status"},
383 {PLDM_STATE_SET_OPERATIONAL_CONNECTION_STATUS,
384 "Operational Connection Status"},
385 {PLDM_STATE_SET_PRESENCE, "Presence"},
386 {PLDM_STATE_SET_PERFORMANCE, "Performance"},
387 {PLDM_STATE_SET_CONFIGURATION_STATE, "Configuration State"},
388 {PLDM_STATE_SET_CHANGED_CONFIGURATION, "Changed Configuration"},
389 {PLDM_STATE_SET_IDENTIFY_STATE, "Identify State"},
390 {PLDM_STATE_SET_VERSION, "Version"},
391 {PLDM_STATE_SET_ALARM_STATE, "Alarm State"},
392 {PLDM_STATE_SET_DEVICE_INITIALIZATION, "Device Initialization"},
393 {PLDM_STATE_SET_THERMAL_TRIP, "Thermal Trip"},
394 {PLDM_STATE_SET_HEARTBEAT, "Heartbeat"},
395 {PLDM_STATE_SET_LINK_STATE, "Link State"},
396 {PLDM_STATE_SET_SMOKE_STATE, "Smoke State"},
397 {PLDM_STATE_SET_HUMIDITY_STATE, "Humidity State"},
398 {PLDM_STATE_SET_DOOR_STATE, "Door State"},
399 {PLDM_STATE_SET_SWITCH_STATE, "Switch State"},
400 {PLDM_STATE_SET_LOCK_STATE, "Lock State"},
401 {PLDM_STATE_SET_PHYSICAL_SECURITY, "Physical Security"},
402 {PLDM_STATE_SET_DOCK_AUTHORIZATION, "Dock Authorization"},
403 {PLDM_STATE_SET_HW_SECURITY, "Hardware Security"},
404 {PLDM_STATE_SET_PHYSICAL_COMM_CONNECTION,
405 "Physical Communication Connection"},
406 {PLDM_STATE_SET_COMM_LEASH_STATUS, "Communication Leash Status"},
407 {PLDM_STATE_SET_FOREIGN_NW_DETECTION_STATUS,
408 "Foreign Network Detection Status"},
409 {PLDM_STATE_SET_PASSWORD_PROTECTED_ACCESS_SECURITY,
410 "Password-Protected Access Security"},
411 {PLDM_STATE_SET_SECURITY_ACCESS_PRIVILEGE_LEVEL,
412 "Security Access –PrivilegeLevel"},
413 {PLDM_STATE_SET_SESSION_AUDIT, "PLDM Session Audit"},
414 {PLDM_STATE_SET_SW_TERMINATION_STATUS, "Software Termination Status"},
415 {PLDM_STATE_SET_STORAGE_MEDIA_ACTIVITY, "Storage Media Activity"},
416 {PLDM_STATE_SET_BOOT_RESTART_CAUSE, "Boot/Restart Cause"},
417 {PLDM_STATE_SET_BOOT_RESTART_REQUEST, "Boot/Restart Request"},
418 {PLDM_STATE_SET_ENTITY_BOOT_STATUS, "Entity Boot Status"},
419 {PLDM_STATE_SET_BOOT_ERROR_STATUS, "Boot ErrorStatus"},
420 {PLDM_STATE_SET_BOOT_PROGRESS, "Boot Progress"},
421 {PLDM_STATE_SET_SYS_FIRMWARE_HANG, "System Firmware Hang"},
422 {PLDM_STATE_SET_POST_ERRORS, "POST Errors"},
423 {PLDM_STATE_SET_LOG_FILL_STATUS, "Log Fill Status"},
424 {PLDM_STATE_SET_LOG_FILTER_STATUS, "Log Filter Status"},
425 {PLDM_STATE_SET_LOG_TIMESTAMP_CHANGE, "Log Timestamp Change"},
426 {PLDM_STATE_SET_INTERRUPT_REQUESTED, "Interrupt Requested"},
427 {PLDM_STATE_SET_INTERRUPT_RECEIVED, "Interrupt Received"},
428 {PLDM_STATE_SET_DIAGNOSTIC_INTERRUPT_REQUESTED,
429 "Diagnostic Interrupt Requested"},
430 {PLDM_STATE_SET_DIAGNOSTIC_INTERRUPT_RECEIVED,
431 "Diagnostic Interrupt Received"},
432 {PLDM_STATE_SET_IO_CHANNEL_CHECK_NMI_REQUESTED,
433 "I/O Channel Check NMI Requested"},
434 {PLDM_STATE_SET_IO_CHANNEL_CHECK_NMI_RECEIVED,
435 "I/O Channel Check NMI Received"},
436 {PLDM_STATE_SET_FATAL_NMI_REQUESTED, "Fatal NMI Requested"},
437 {PLDM_STATE_SET_FATAL_NMI_RECEIVED, "Fatal NMI Received"},
438 {PLDM_STATE_SET_SOFTWARE_NMI_REQUESTED, "Software NMI Requested"},
439 {PLDM_STATE_SET_SOFTWARE_NMI_RECEIVED, "Software NMI Received"},
440 {PLDM_STATE_SET_SMI_REQUESTED, "SMI Requested"},
441 {PLDM_STATE_SET_SMI_RECEIVED, "SMI Received"},
442 {PLDM_STATE_SET_PCI_PERR_REQUESTED, "PCI PERR Requested"},
443 {PLDM_STATE_SET_PCI_PERR_RECEIVED, "PCI PERR Received"},
444 {PLDM_STATE_SET_PCI_SERR_REQUESTED, "PCI SERR Requested "},
445 {PLDM_STATE_SET_PCI_SERR_RECEIVED, "PCI SERR Received"},
446 {PLDM_STATE_SET_BUS_ERROR_STATUS, "Bus Error Status"},
447 {PLDM_STATE_SET_WATCHDOG_STATUS, "Watchdog Status"},
448 {PLDM_STATE_SET_POWER_SUPPLY_STATE, "Power Supply State"},
449 {PLDM_STATE_SET_DEVICE_POWER_STATE, "Device Power State"},
450 {PLDM_STATE_SET_ACPI_POWER_STATE, "ACPI Power State"},
451 {PLDM_STATE_SET_BACKUP_POWER_SOURCE, "Backup Power Source"},
452 {PLDM_STATE_SET_SYSTEM_POWER_STATE, "System Power State "},
453 {PLDM_STATE_SET_BATTERY_ACTIVITY, "Battery Activity"},
454 {PLDM_STATE_SET_BATTERY_STATE, "Battery State"},
455 {PLDM_STATE_SET_PROC_POWER_STATE, "Processor Power State"},
456 {PLDM_STATE_SET_POWER_PERFORMANCE_STATE, "Power-Performance State"},
457 {PLDM_STATE_SET_PROC_ERROR_STATUS, "Processor Error Status"},
458 {PLDM_STATE_SET_BIST_FAILURE_STATUS, "BIST FailureStatus"},
459 {PLDM_STATE_SET_IBIST_FAILURE_STATUS, "IBIST FailureStatus"},
460 {PLDM_STATE_SET_PROC_HANG_IN_POST, "Processor Hang in POST"},
461 {PLDM_STATE_SET_PROC_STARTUP_FAILURE, "Processor Startup Failure"},
462 {PLDM_STATE_SET_UNCORRECTABLE_CPU_ERROR, "Uncorrectable CPU Error"},
463 {PLDM_STATE_SET_MACHINE_CHECK_ERROR, "Machine Check Error"},
464 {PLDM_STATE_SET_CORRECTED_MACHINE_CHECK, "Corrected Machine Check"},
465 {PLDM_STATE_SET_CACHE_STATUS, "Cache Status"},
466 {PLDM_STATE_SET_MEMORY_ERROR_STATUS, "Memory Error Status"},
467 {PLDM_STATE_SET_REDUNDANT_MEMORY_ACTIVITY_STATUS,
468 "Redundant Memory Activity Status"},
469 {PLDM_STATE_SET_ERROR_DETECTION_STATUS, "Error Detection Status"},
470 {PLDM_STATE_SET_STUCK_BIT_STATUS, "Stuck Bit Status"},
471 {PLDM_STATE_SET_SCRUB_STATUS, "Scrub Status"},
472 {PLDM_STATE_SET_SLOT_OCCUPANCY, "Slot Occupancy"},
473 {PLDM_STATE_SET_SLOT_STATE, "Slot State"},
474 };
475
476 const std::array<std::string_view, 4> sensorInit = {
477 "noInit", "useInitPDR", "enableSensor", "disableSensor"};
478
479 const std::array<std::string_view, 4> effecterInit = {
480 "noInit", "useInitPDR", "enableEffecter", "disableEffecter"};
481
482 const std::map<uint8_t, std::string> pdrType = {
483 {PLDM_TERMINUS_LOCATOR_PDR, "Terminus Locator PDR"},
484 {PLDM_NUMERIC_SENSOR_PDR, "Numeric Sensor PDR"},
485 {PLDM_NUMERIC_SENSOR_INITIALIZATION_PDR,
486 "Numeric Sensor Initialization PDR"},
487 {PLDM_STATE_SENSOR_PDR, "State Sensor PDR"},
488 {PLDM_STATE_SENSOR_INITIALIZATION_PDR,
489 "State Sensor Initialization PDR"},
490 {PLDM_SENSOR_AUXILIARY_NAMES_PDR, "Sensor Auxiliary Names PDR"},
491 {PLDM_OEM_UNIT_PDR, "OEM Unit PDR"},
492 {PLDM_OEM_STATE_SET_PDR, "OEM State Set PDR"},
493 {PLDM_NUMERIC_EFFECTER_PDR, "Numeric Effecter PDR"},
494 {PLDM_NUMERIC_EFFECTER_INITIALIZATION_PDR,
495 "Numeric Effecter Initialization PDR"},
496 {PLDM_COMPACT_NUMERIC_SENSOR_PDR, "Compact Numeric Sensor PDR"},
497 {PLDM_STATE_EFFECTER_PDR, "State Effecter PDR"},
498 {PLDM_STATE_EFFECTER_INITIALIZATION_PDR,
499 "State Effecter Initialization PDR"},
500 {PLDM_EFFECTER_AUXILIARY_NAMES_PDR, "Effecter Auxiliary Names PDR"},
501 {PLDM_EFFECTER_OEM_SEMANTIC_PDR, "Effecter OEM Semantic PDR"},
502 {PLDM_PDR_ENTITY_ASSOCIATION, "Entity Association PDR"},
503 {PLDM_ENTITY_AUXILIARY_NAMES_PDR, "Entity Auxiliary Names PDR"},
504 {PLDM_OEM_ENTITY_ID_PDR, "OEM Entity ID PDR"},
505 {PLDM_INTERRUPT_ASSOCIATION_PDR, "Interrupt Association PDR"},
506 {PLDM_EVENT_LOG_PDR, "PLDM Event Log PDR"},
507 {PLDM_PDR_FRU_RECORD_SET, "FRU Record Set PDR"},
508 {PLDM_OEM_DEVICE_PDR, "OEM Device PDR"},
509 {PLDM_OEM_PDR, "OEM PDR"},
510 };
511
512 static inline const std::map<uint8_t, std::string> setThermalTrip{
513 {PLDM_STATE_SET_THERMAL_TRIP_STATUS_NORMAL, "Normal"},
514 {PLDM_STATE_SET_THERMAL_TRIP_STATUS_THERMAL_TRIP, "Thermal Trip"}};
515
516 static inline const std::map<uint8_t, std::string> setIdentifyState{
517 {PLDM_STATE_SET_IDENTIFY_STATE_UNASSERTED, "Identify State Unasserted"},
518 {PLDM_STATE_SET_IDENTIFY_STATE_ASSERTED, "Identify State Asserted"}};
519
520 static inline const std::map<uint8_t, std::string> setBootProgressState{
521 {PLDM_STATE_SET_BOOT_PROG_STATE_NOT_ACTIVE, "Boot Not Active"},
522 {PLDM_STATE_SET_BOOT_PROG_STATE_COMPLETED, "Boot Completed"},
523 {PLDM_STATE_SET_BOOT_PROG_STATE_MEM_INITIALIZATION,
524 "Memory Initialization"},
525 {PLDM_STATE_SET_BOOT_PROG_STATE_SEC_PROC_INITIALIZATION,
526 "Secondary Processor(s) Initialization"},
527 {PLDM_STATE_SET_BOOT_PROG_STATE_PCI_RESORUCE_CONFIG,
528 "PCI Resource Configuration"},
529 {PLDM_STATE_SET_BOOT_PROG_STATE_STARTING_OP_SYS,
530 "Starting Operating System"},
531 {PLDM_STATE_SET_BOOT_PROG_STATE_BASE_BOARD_INITIALIZATION,
532 "Baseboard Initialization"},
533 {PLDM_STATE_SET_BOOT_PROG_STATE_PRIMARY_PROC_INITIALIZATION,
534 "Primary Processor Initialization"},
535 {PLDM_STATE_SET_BOOT_PROG_STATE_OSSTART, "OSStart"}};
536
537 static inline const std::map<uint8_t, std::string> setOpFaultStatus{
538 {PLDM_STATE_SET_OPERATIONAL_FAULT_STATUS_NORMAL, "Normal"},
539 {PLDM_STATE_SET_OPERATIONAL_FAULT_STATUS_ERROR, "Error"},
540 {PLDM_STATE_SET_OPERATIONAL_FAULT_STATUS_NON_RECOVERABLE_ERROR,
541 "Non Recoverable Error"}};
542
543 static inline const std::map<uint8_t, std::string> setSysPowerState{
544 {PLDM_STATE_SET_SYS_POWER_STATE_OFF_SOFT_GRACEFUL,
545 "Off-Soft Graceful"}};
546
547 static inline const std::map<uint8_t, std::string> setSWTerminationStatus{
548 {PLDM_SW_TERM_GRACEFUL_RESTART_REQUESTED,
549 "Graceful Restart Requested"}};
550
551 static inline const std::map<uint8_t, std::string> setAvailability{
552 {PLDM_STATE_SET_AVAILABILITY_REBOOTING, "Rebooting"}};
553
554 static inline const std::map<uint8_t, std::string> setHealthState{
555 {PLDM_STATE_SET_HEALTH_STATE_NORMAL, "Normal"},
556 {PLDM_STATE_SET_HEALTH_STATE_NON_CRITICAL, "Non-Critical"},
557 {PLDM_STATE_SET_HEALTH_STATE_CRITICAL, "Critical"},
558 {PLDM_STATE_SET_HEALTH_STATE_FATAL, "Fatal"},
559 {PLDM_STATE_SET_HEALTH_STATE_UPPER_NON_CRITICAL, "Upper Non-Critical"},
560 {PLDM_STATE_SET_HEALTH_STATE_LOWER_NON_CRITICAL, "Lower Non-Critical"},
561 {PLDM_STATE_SET_HEALTH_STATE_UPPER_CRITICAL, "Upper Critical"},
562 {PLDM_STATE_SET_HEALTH_STATE_LOWER_CRITICAL, "Lower Critical"},
563 {PLDM_STATE_SET_HEALTH_STATE_UPPER_FATAL, "Upper Fatal"},
564 {PLDM_STATE_SET_HEALTH_STATE_LOWER_FATAL, "Lower Fatal"}};
565
566 static inline const std::map<uint8_t, std::string>
567 setOperationalRunningState{
568 {PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS_STARTING, "Starting"},
569 {PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS_STOPPING, "Stopping"},
570 {PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS_STOPPED, "Stopped"},
571 {PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS_IN_SERVICE,
572 "In Service"},
573 {PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS_ABORTED, "Aborted"},
574 {PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS_DORMANT, "Dormant"}};
575
576 static inline const std::map<uint8_t, std::string> setPowerDeviceState{
577 {PLDM_STATE_SET_ACPI_DEVICE_POWER_STATE_UNKNOWN, "Unknown"},
578 {PLDM_STATE_SET_ACPI_DEVICE_POWER_STATE_FULLY_ON, "Fully-On"},
579 {PLDM_STATE_SET_ACPI_DEVICE_POWER_STATE_INTERMEDIATE_1,
580 "Intermediate State-1"},
581 {PLDM_STATE_SET_ACPI_DEVICE_POWER_STATE_INTERMEDIATE_2,
582 "Intermediate State-2"},
583 {PLDM_STATE_SET_ACPI_DEVICE_POWER_STATE_OFF, "Off"}};
584
585 static inline const std::map<uint16_t, const std::map<uint8_t, std::string>>
586 populatePStateMaps{
587 {PLDM_STATE_SET_THERMAL_TRIP, setThermalTrip},
588 {PLDM_STATE_SET_IDENTIFY_STATE, setIdentifyState},
589 {PLDM_STATE_SET_BOOT_PROGRESS, setBootProgressState},
590 {PLDM_STATE_SET_OPERATIONAL_FAULT_STATUS, setOpFaultStatus},
591 {PLDM_STATE_SET_SYSTEM_POWER_STATE, setSysPowerState},
592 {PLDM_STATE_SET_SW_TERMINATION_STATUS, setSWTerminationStatus},
593 {PLDM_STATE_SET_AVAILABILITY, setAvailability},
594 {PLDM_STATE_SET_HEALTH_STATE, setHealthState},
595 {PLDM_STATE_SET_OPERATIONAL_RUNNING_STATUS,
596 setOperationalRunningState},
597 {PLDM_STATE_SET_DEVICE_POWER_STATE, setPowerDeviceState},
598 };
599
600 const std::map<std::string, uint8_t> strToPdrType = {
601 {"terminuslocator", PLDM_TERMINUS_LOCATOR_PDR},
602 {"statesensor", PLDM_STATE_SENSOR_PDR},
603 {"sensorauxname", PLDM_SENSOR_AUXILIARY_NAMES_PDR},
604 {"numericeffecter", PLDM_NUMERIC_EFFECTER_PDR},
605 {"efffecterauxname", PLDM_EFFECTER_AUXILIARY_NAMES_PDR},
606 {"numericsensor", PLDM_NUMERIC_SENSOR_PDR},
607 {"compactnumericsensor", PLDM_COMPACT_NUMERIC_SENSOR_PDR},
608 {"stateeffecter", PLDM_STATE_EFFECTER_PDR},
609 {"entityassociation", PLDM_PDR_ENTITY_ASSOCIATION},
610 {"frurecord", PLDM_PDR_FRU_RECORD_SET},
611 // Add other types
612 };
613
isLogicalBitSet(const uint16_t entity_type)614 bool isLogicalBitSet(const uint16_t entity_type)
615 {
616 return entity_type & 0x8000;
617 }
618
getEntityTypeForLogicalEntity(const uint16_t logical_entity_type)619 uint16_t getEntityTypeForLogicalEntity(const uint16_t logical_entity_type)
620 {
621 return logical_entity_type & 0x7FFF;
622 }
623
getEntityName(pldm::pdr::EntityType type)624 std::string getEntityName(pldm::pdr::EntityType type)
625 {
626 uint16_t entityNumber = type;
627 std::string entityName = "[Physical] ";
628
629 if (isLogicalBitSet(type))
630 {
631 entityName = "[Logical] ";
632 entityNumber = getEntityTypeForLogicalEntity(type);
633 }
634
635 try
636 {
637 return entityName + entityType.at(entityNumber);
638 }
639 catch (const std::out_of_range& e)
640 {
641 auto OemString =
642 std::to_string(static_cast<unsigned>(entityNumber));
643 if (type >= PLDM_OEM_ENTITY_TYPE_START &&
644 type <= PLDM_OEM_ENTITY_TYPE_END)
645 {
646 #ifdef OEM_IBM
647 if (OemIBMEntityType.contains(entityNumber))
648 {
649 return entityName + OemIBMEntityType.at(entityNumber) +
650 "(OEM)";
651 }
652 #endif
653 return entityName + OemString + "(OEM)";
654 }
655 return OemString;
656 }
657 }
658
getStateSetName(uint16_t id)659 std::string getStateSetName(uint16_t id)
660 {
661 auto typeString = std::to_string(id);
662 try
663 {
664 return stateSet.at(id) + "(" + typeString + ")";
665 }
666 catch (const std::out_of_range& e)
667 {
668 return typeString;
669 }
670 }
671
672 std::vector<std::string>
getStateSetPossibleStateNames(uint16_t stateId,const std::vector<uint8_t> & value)673 getStateSetPossibleStateNames(uint16_t stateId,
674 const std::vector<uint8_t>& value)
675 {
676 std::vector<std::string> data{};
677
678 for (const auto& s : value)
679 {
680 std::map<uint8_t, std::string> stateNameMaps;
681 auto pstr = std::to_string(s);
682
683 #ifdef OEM_IBM
684 if (stateId >= PLDM_OEM_STATE_SET_ID_START &&
685 stateId < PLDM_OEM_STATE_SET_ID_END)
686 {
687 if (populateOemIBMStateMaps.contains(stateId))
688 {
689 const std::map<uint8_t, std::string> stateNames =
690 populateOemIBMStateMaps.at(stateId);
691 stateNameMaps.insert(stateNames.begin(), stateNames.end());
692 }
693 }
694 #endif
695 if (populatePStateMaps.contains(stateId))
696 {
697 const std::map<uint8_t, std::string> stateNames =
698 populatePStateMaps.at(stateId);
699 stateNameMaps.insert(stateNames.begin(), stateNames.end());
700 }
701 if (stateNameMaps.contains(s))
702 {
703 data.push_back(stateNameMaps.at(s) + "(" + pstr + ")");
704 }
705 else
706 {
707 data.push_back(pstr);
708 }
709 }
710 return data;
711 }
712
getPDRType(uint8_t type)713 std::string getPDRType(uint8_t type)
714 {
715 auto typeString = std::to_string(type);
716 try
717 {
718 return pdrType.at(type);
719 }
720 catch (const std::out_of_range& e)
721 {
722 return typeString;
723 }
724 }
725
printCommonPDRHeader(const pldm_pdr_hdr * hdr,ordered_json & output)726 void printCommonPDRHeader(const pldm_pdr_hdr* hdr, ordered_json& output)
727 {
728 output["recordHandle"] = hdr->record_handle;
729 output["PDRHeaderVersion"] = unsigned(hdr->version);
730 output["PDRType"] = getPDRType(hdr->type);
731 output["recordChangeNumber"] = hdr->record_change_num;
732 output["dataLength"] = hdr->length;
733 }
734
printPossibleStates(uint8_t possibleStatesSize,const bitfield8_t * states)735 std::vector<uint8_t> printPossibleStates(uint8_t possibleStatesSize,
736 const bitfield8_t* states)
737 {
738 uint8_t possibleStatesPos{};
739 std::vector<uint8_t> data{};
740 auto printStates = [&possibleStatesPos, &data](const bitfield8_t& val) {
741 std::stringstream pstates;
742 for (int i = 0; i < CHAR_BIT; i++)
743 {
744 if (val.byte & (1 << i))
745 {
746 pstates << (possibleStatesPos * CHAR_BIT + i);
747 data.push_back(
748 static_cast<uint8_t>(std::stoi(pstates.str())));
749 pstates.str("");
750 }
751 }
752 possibleStatesPos++;
753 };
754 std::for_each(states, states + possibleStatesSize, printStates);
755 return data;
756 }
757
printStateSensorPDR(const uint8_t * data,ordered_json & output)758 void printStateSensorPDR(const uint8_t* data, ordered_json& output)
759 {
760 auto pdr = reinterpret_cast<const pldm_state_sensor_pdr*>(data);
761 output["PLDMTerminusHandle"] = pdr->terminus_handle;
762 output["sensorID"] = pdr->sensor_id;
763 output["entityType"] = getEntityName(pdr->entity_type);
764 output["entityInstanceNumber"] = pdr->entity_instance;
765 output["containerID"] = pdr->container_id;
766 output["sensorInit"] = sensorInit[pdr->sensor_init];
767 output["sensorAuxiliaryNamesPDR"] =
768 (pdr->sensor_auxiliary_names_pdr ? true : false);
769 output["compositeSensorCount"] = unsigned(pdr->composite_sensor_count);
770
771 auto statesPtr = pdr->possible_states;
772 auto compCount = pdr->composite_sensor_count;
773
774 while (compCount--)
775 {
776 auto state = reinterpret_cast<const state_sensor_possible_states*>(
777 statesPtr);
778 output.emplace(("stateSetID[" + std::to_string(compCount) + "]"),
779 getStateSetName(state->state_set_id));
780 output.emplace(
781 ("possibleStatesSize[" + std::to_string(compCount) + "]"),
782 state->possible_states_size);
783 output.emplace(
784 ("possibleStates[" + std::to_string(compCount) + "]"),
785 getStateSetPossibleStateNames(
786 state->state_set_id,
787 printPossibleStates(state->possible_states_size,
788 state->states)));
789
790 if (compCount)
791 {
792 statesPtr += sizeof(state_sensor_possible_states) +
793 state->possible_states_size - 1;
794 }
795 }
796 }
797
printPDRFruRecordSet(uint8_t * data,ordered_json & output)798 void printPDRFruRecordSet(uint8_t* data, ordered_json& output)
799 {
800 if (data == NULL)
801 {
802 return;
803 }
804
805 data += sizeof(pldm_pdr_hdr);
806 pldm_pdr_fru_record_set* pdr =
807 reinterpret_cast<pldm_pdr_fru_record_set*>(data);
808 if (!pdr)
809 {
810 std::cerr << "Failed to get the FRU record set PDR" << std::endl;
811 return;
812 }
813
814 output["PLDMTerminusHandle"] = unsigned(pdr->terminus_handle);
815 output["FRURecordSetIdentifier"] = unsigned(pdr->fru_rsi);
816 output["entityType"] = getEntityName(pdr->entity_type);
817 output["entityInstanceNumber"] = unsigned(pdr->entity_instance);
818 output["containerID"] = unsigned(pdr->container_id);
819 }
820
printPDREntityAssociation(uint8_t * data,ordered_json & output)821 void printPDREntityAssociation(uint8_t* data, ordered_json& output)
822 {
823 const std::map<uint8_t, const char*> assocationType = {
824 {PLDM_ENTITY_ASSOCIAION_PHYSICAL, "Physical"},
825 {PLDM_ENTITY_ASSOCIAION_LOGICAL, "Logical"},
826 };
827
828 if (data == NULL)
829 {
830 return;
831 }
832
833 data += sizeof(pldm_pdr_hdr);
834 pldm_pdr_entity_association* pdr =
835 reinterpret_cast<pldm_pdr_entity_association*>(data);
836 if (!pdr)
837 {
838 std::cerr << "Failed to get the PDR eneity association"
839 << std::endl;
840 return;
841 }
842
843 output["containerID"] = int(pdr->container_id);
844 if (assocationType.contains(pdr->association_type))
845 {
846 output["associationType"] =
847 assocationType.at(pdr->association_type);
848 }
849 else
850 {
851 std::cout << "Get associationType failed.\n";
852 }
853 output["containerEntityType"] =
854 getEntityName(pdr->container.entity_type);
855 output["containerEntityInstanceNumber"] =
856 int(pdr->container.entity_instance_num);
857 output["containerEntityContainerID"] =
858 int(pdr->container.entity_container_id);
859 output["containedEntityCount"] =
860 static_cast<unsigned>(pdr->num_children);
861
862 auto child = reinterpret_cast<pldm_entity*>(&pdr->children[0]);
863 for (int i = 0; i < pdr->num_children; ++i)
864 {
865 output.emplace("containedEntityType[" + std::to_string(i + 1) + "]",
866 getEntityName(child->entity_type));
867 output.emplace("containedEntityInstanceNumber[" +
868 std::to_string(i + 1) + "]",
869 unsigned(child->entity_instance_num));
870 output.emplace("containedEntityContainerID[" +
871 std::to_string(i + 1) + "]",
872 unsigned(child->entity_container_id));
873
874 ++child;
875 }
876 }
877
878 /** @brief Format the Sensor/Effecter Aux Name PDR types to json output
879 *
880 * @param[in] data - reference to the Sensor/Effecter Aux Name PDR
881 * @param[out] output - PDRs data fields in Json format
882 */
printAuxNamePDR(uint8_t * data,ordered_json & output)883 void printAuxNamePDR(uint8_t* data, ordered_json& output)
884 {
885 constexpr uint8_t nullTerminator = 0;
886 struct pldm_effecter_aux_name_pdr* auxNamePdr =
887 (struct pldm_effecter_aux_name_pdr*)data;
888
889 if (!auxNamePdr)
890 {
891 std::cerr << "Failed to get Aux Name PDR" << std::endl;
892 return;
893 }
894
895 std::string sPrefix = "effecter";
896 if (auxNamePdr->hdr.type == PLDM_SENSOR_AUXILIARY_NAMES_PDR)
897 {
898 sPrefix = "sensor";
899 }
900 output["terminusHandle"] = int(auxNamePdr->terminus_handle);
901 output[sPrefix + "Id"] = int(auxNamePdr->effecter_id);
902 output[sPrefix + "Count"] = int(auxNamePdr->effecter_count);
903
904 const uint8_t* ptr = auxNamePdr->effecter_names;
905 for (auto i : std::views::iota(0, (int)auxNamePdr->effecter_count))
906 {
907 const uint8_t nameStringCount = static_cast<uint8_t>(*ptr);
908 ptr += sizeof(uint8_t);
909 for (auto j : std::views::iota(0, (int)nameStringCount))
910 {
911 std::string nameLanguageTagKey = sPrefix + std::to_string(j) +
912 "_nameLanguageTag" +
913 std::to_string(i);
914 std::string entityAuxNameKey = sPrefix + std::to_string(j) +
915 "_entityAuxName" +
916 std::to_string(i);
917 std::string nameLanguageTag(reinterpret_cast<const char*>(ptr),
918 0, PLDM_STR_UTF_8_MAX_LEN);
919 ptr += nameLanguageTag.size() + sizeof(nullTerminator);
920 std::u16string u16NameString(
921 reinterpret_cast<const char16_t*>(ptr), 0,
922 PLDM_STR_UTF_16_MAX_LEN);
923 ptr += (u16NameString.size() + sizeof(nullTerminator)) *
924 sizeof(uint16_t);
925 std::transform(u16NameString.cbegin(), u16NameString.cend(),
926 u16NameString.begin(),
927 [](uint16_t utf16) { return be16toh(utf16); });
928 std::string nameString =
929 std::wstring_convert<std::codecvt_utf8_utf16<char16_t>,
930 char16_t>{}
931 .to_bytes(u16NameString);
932 output[nameLanguageTagKey] = nameLanguageTag;
933 output[entityAuxNameKey] = nameString;
934 }
935 }
936 }
937
printNumericEffecterPDR(uint8_t * data,ordered_json & output)938 void printNumericEffecterPDR(uint8_t* data, ordered_json& output)
939 {
940 struct pldm_numeric_effecter_value_pdr* pdr =
941 (struct pldm_numeric_effecter_value_pdr*)data;
942 if (!pdr)
943 {
944 std::cerr << "Failed to get numeric effecter PDR" << std::endl;
945 return;
946 }
947
948 output["PLDMTerminusHandle"] = int(pdr->terminus_handle);
949 output["effecterID"] = int(pdr->effecter_id);
950 output["entityType"] = int(pdr->entity_type);
951 output["entityInstanceNumber"] = int(pdr->entity_instance);
952 output["containerID"] = int(pdr->container_id);
953 output["effecterSemanticID"] = int(pdr->effecter_semantic_id);
954 output["effecterInit"] = unsigned(pdr->effecter_init);
955 output["effecterAuxiliaryNames"] =
956 (unsigned(pdr->effecter_auxiliary_names) ? true : false);
957 output["baseUnit"] = unsigned(pdr->base_unit);
958 output["unitModifier"] = unsigned(pdr->unit_modifier);
959 output["rateUnit"] = unsigned(pdr->rate_unit);
960 output["baseOEMUnitHandle"] = unsigned(pdr->base_oem_unit_handle);
961 output["auxUnit"] = unsigned(pdr->aux_unit);
962 output["auxUnitModifier"] = unsigned(pdr->aux_unit_modifier);
963 output["auxrateUnit"] = unsigned(pdr->aux_rate_unit);
964 output["auxOEMUnitHandle"] = unsigned(pdr->aux_oem_unit_handle);
965 output["isLinear"] = (unsigned(pdr->is_linear) ? true : false);
966 output["effecterDataSize"] = unsigned(pdr->effecter_data_size);
967 output["resolution"] = unsigned(pdr->resolution);
968 output["offset"] = unsigned(pdr->offset);
969 output["accuracy"] = unsigned(pdr->accuracy);
970 output["plusTolerance"] = unsigned(pdr->plus_tolerance);
971 output["minusTolerance"] = unsigned(pdr->minus_tolerance);
972 output["stateTransitionInterval"] =
973 unsigned(pdr->state_transition_interval);
974 output["TransitionInterval"] = unsigned(pdr->transition_interval);
975
976 switch (pdr->effecter_data_size)
977 {
978 case PLDM_EFFECTER_DATA_SIZE_UINT8:
979 output["maxSettable"] = unsigned(pdr->max_settable.value_u8);
980 output["minSettable"] = unsigned(pdr->min_settable.value_u8);
981 break;
982 case PLDM_EFFECTER_DATA_SIZE_SINT8:
983 output["maxSettable"] = unsigned(pdr->max_settable.value_s8);
984 output["minSettable"] = unsigned(pdr->min_settable.value_s8);
985 break;
986 case PLDM_EFFECTER_DATA_SIZE_UINT16:
987 output["maxSettable"] = unsigned(pdr->max_settable.value_u16);
988 output["minSettable"] = unsigned(pdr->min_settable.value_u16);
989 break;
990 case PLDM_EFFECTER_DATA_SIZE_SINT16:
991 output["maxSettable"] = unsigned(pdr->max_settable.value_s16);
992 output["minSettable"] = unsigned(pdr->min_settable.value_s16);
993 break;
994 case PLDM_EFFECTER_DATA_SIZE_UINT32:
995 output["maxSettable"] = unsigned(pdr->max_settable.value_u32);
996 output["minSettable"] = unsigned(pdr->min_settable.value_u32);
997 break;
998 case PLDM_EFFECTER_DATA_SIZE_SINT32:
999 output["maxSettable"] = unsigned(pdr->max_settable.value_s32);
1000 output["minSettable"] = unsigned(pdr->min_settable.value_s32);
1001 break;
1002 default:
1003 break;
1004 }
1005
1006 output["rangeFieldFormat"] = unsigned(pdr->range_field_format);
1007 output["rangeFieldSupport"] = unsigned(pdr->range_field_support.byte);
1008
1009 switch (pdr->range_field_format)
1010 {
1011 case PLDM_RANGE_FIELD_FORMAT_UINT8:
1012 output["nominalValue"] = unsigned(pdr->nominal_value.value_u8);
1013 output["normalMax"] = unsigned(pdr->normal_max.value_u8);
1014 output["normalMin"] = unsigned(pdr->normal_min.value_u8);
1015 output["ratedMax"] = unsigned(pdr->rated_max.value_u8);
1016 output["ratedMin"] = unsigned(pdr->rated_min.value_u8);
1017 break;
1018 case PLDM_RANGE_FIELD_FORMAT_SINT8:
1019 output["nominalValue"] = unsigned(pdr->nominal_value.value_s8);
1020 output["normalMax"] = unsigned(pdr->normal_max.value_s8);
1021 output["normalMin"] = unsigned(pdr->normal_min.value_s8);
1022 output["ratedMax"] = unsigned(pdr->rated_max.value_s8);
1023 output["ratedMin"] = unsigned(pdr->rated_min.value_s8);
1024 break;
1025 case PLDM_RANGE_FIELD_FORMAT_UINT16:
1026 output["nominalValue"] = unsigned(pdr->nominal_value.value_u16);
1027 output["normalMax"] = unsigned(pdr->normal_max.value_u16);
1028 output["normalMin"] = unsigned(pdr->normal_min.value_u16);
1029 output["ratedMax"] = unsigned(pdr->rated_max.value_u16);
1030 output["ratedMin"] = unsigned(pdr->rated_min.value_u16);
1031 break;
1032 case PLDM_RANGE_FIELD_FORMAT_SINT16:
1033 output["nominalValue"] = unsigned(pdr->nominal_value.value_s16);
1034 output["normalMax"] = unsigned(pdr->normal_max.value_s16);
1035 output["normalMin"] = unsigned(pdr->normal_min.value_s16);
1036 output["ratedMax"] = unsigned(pdr->rated_max.value_s16);
1037 output["ratedMin"] = unsigned(pdr->rated_min.value_s16);
1038 break;
1039 case PLDM_RANGE_FIELD_FORMAT_UINT32:
1040 output["nominalValue"] = unsigned(pdr->nominal_value.value_u32);
1041 output["normalMax"] = unsigned(pdr->normal_max.value_u32);
1042 output["normalMin"] = unsigned(pdr->normal_min.value_u32);
1043 output["ratedMax"] = unsigned(pdr->rated_max.value_u32);
1044 output["ratedMin"] = unsigned(pdr->rated_min.value_u32);
1045 break;
1046 case PLDM_RANGE_FIELD_FORMAT_SINT32:
1047 output["nominalValue"] = unsigned(pdr->nominal_value.value_s32);
1048 output["normalMax"] = unsigned(pdr->normal_max.value_s32);
1049 output["normalMin"] = unsigned(pdr->normal_min.value_s32);
1050 output["ratedMax"] = unsigned(pdr->rated_max.value_s32);
1051 output["ratedMin"] = unsigned(pdr->rated_min.value_s32);
1052 break;
1053 case PLDM_RANGE_FIELD_FORMAT_REAL32:
1054 output["nominalValue"] = unsigned(pdr->nominal_value.value_f32);
1055 output["normalMax"] = unsigned(pdr->normal_max.value_f32);
1056 output["normalMin"] = unsigned(pdr->normal_min.value_f32);
1057 output["ratedMax"] = unsigned(pdr->rated_max.value_f32);
1058 output["ratedMin"] = unsigned(pdr->rated_min.value_f32);
1059 break;
1060 default:
1061 break;
1062 }
1063 }
1064
printStateEffecterPDR(const uint8_t * data,ordered_json & output)1065 void printStateEffecterPDR(const uint8_t* data, ordered_json& output)
1066 {
1067 auto pdr = reinterpret_cast<const pldm_state_effecter_pdr*>(data);
1068
1069 output["PLDMTerminusHandle"] = pdr->terminus_handle;
1070 output["effecterID"] = pdr->effecter_id;
1071 output["entityType"] = getEntityName(pdr->entity_type);
1072 output["entityInstanceNumber"] = pdr->entity_instance;
1073 output["containerID"] = pdr->container_id;
1074 output["effecterSemanticID"] = pdr->effecter_semantic_id;
1075 output["effecterInit"] = effecterInit[pdr->effecter_init];
1076 output["effecterDescriptionPDR"] = (pdr->has_description_pdr ? true
1077 : false);
1078 output["compositeEffecterCount"] =
1079 unsigned(pdr->composite_effecter_count);
1080
1081 auto statesPtr = pdr->possible_states;
1082 auto compEffCount = pdr->composite_effecter_count;
1083
1084 while (compEffCount--)
1085 {
1086 auto state =
1087 reinterpret_cast<const state_effecter_possible_states*>(
1088 statesPtr);
1089 output.emplace(("stateSetID[" + std::to_string(compEffCount) + "]"),
1090 getStateSetName(state->state_set_id));
1091 output.emplace(
1092 ("possibleStatesSize[" + std::to_string(compEffCount) + "]"),
1093 state->possible_states_size);
1094 output.emplace(
1095 ("possibleStates[" + std::to_string(compEffCount) + "]"),
1096 getStateSetPossibleStateNames(
1097 state->state_set_id,
1098 printPossibleStates(state->possible_states_size,
1099 state->states)));
1100
1101 if (compEffCount)
1102 {
1103 statesPtr += sizeof(state_effecter_possible_states) +
1104 state->possible_states_size - 1;
1105 }
1106 }
1107 }
1108
checkTerminusHandle(const uint8_t * data,std::optional<uint16_t> terminusHandle)1109 bool checkTerminusHandle(const uint8_t* data,
1110 std::optional<uint16_t> terminusHandle)
1111 {
1112 struct pldm_pdr_hdr* pdr = (struct pldm_pdr_hdr*)data;
1113
1114 if (pdr->type == PLDM_TERMINUS_LOCATOR_PDR)
1115 {
1116 auto tlpdr =
1117 reinterpret_cast<const pldm_terminus_locator_pdr*>(data);
1118
1119 if (tlpdr->terminus_handle != terminusHandle)
1120 {
1121 return true;
1122 }
1123 }
1124 else if (pdr->type == PLDM_STATE_SENSOR_PDR)
1125 {
1126 auto sensor = reinterpret_cast<const pldm_state_sensor_pdr*>(data);
1127
1128 if (sensor->terminus_handle != terminusHandle)
1129 {
1130 return true;
1131 }
1132 }
1133 else if (pdr->type == PLDM_NUMERIC_EFFECTER_PDR)
1134 {
1135 auto numericEffecter =
1136 reinterpret_cast<const pldm_numeric_effecter_value_pdr*>(data);
1137
1138 if (numericEffecter->terminus_handle != terminusHandle)
1139 {
1140 return true;
1141 }
1142 }
1143
1144 else if (pdr->type == PLDM_STATE_EFFECTER_PDR)
1145 {
1146 auto stateEffecter =
1147 reinterpret_cast<const pldm_state_effecter_pdr*>(data);
1148 if (stateEffecter->terminus_handle != terminusHandle)
1149 {
1150 return true;
1151 }
1152 }
1153 else if (pdr->type == PLDM_PDR_FRU_RECORD_SET)
1154 {
1155 data += sizeof(pldm_pdr_hdr);
1156 auto fru = reinterpret_cast<const pldm_pdr_fru_record_set*>(data);
1157
1158 if (fru->terminus_handle != terminusHandle)
1159 {
1160 return true;
1161 }
1162 }
1163 else
1164 {
1165 // Entity association PDRs does not have terminus handle
1166 return true;
1167 }
1168
1169 return false;
1170 }
1171
printTerminusLocatorPDR(const uint8_t * data,ordered_json & output)1172 void printTerminusLocatorPDR(const uint8_t* data, ordered_json& output)
1173 {
1174 const std::array<std::string_view, 4> terminusLocatorType = {
1175 "UID", "MCTP_EID", "SMBusRelative", "systemSoftware"};
1176
1177 auto pdr = reinterpret_cast<const pldm_terminus_locator_pdr*>(data);
1178
1179 output["PLDMTerminusHandle"] = pdr->terminus_handle;
1180 output["validity"] = (pdr->validity ? "valid" : "notValid");
1181 output["TID"] = unsigned(pdr->tid);
1182 output["containerID"] = pdr->container_id;
1183 output["terminusLocatorType"] =
1184 terminusLocatorType[pdr->terminus_locator_type];
1185 output["terminusLocatorValueSize"] =
1186 unsigned(pdr->terminus_locator_value_size);
1187
1188 if (pdr->terminus_locator_type == PLDM_TERMINUS_LOCATOR_TYPE_MCTP_EID)
1189 {
1190 auto locatorValue =
1191 reinterpret_cast<const pldm_terminus_locator_type_mctp_eid*>(
1192 pdr->terminus_locator_value);
1193 output["EID"] = unsigned(locatorValue->eid);
1194 }
1195 }
1196
getTerminusHandle(uint8_t * data,std::optional<uint8_t> tid)1197 std::optional<uint16_t> getTerminusHandle(uint8_t* data,
1198 std::optional<uint8_t> tid)
1199 {
1200 struct pldm_pdr_hdr* pdr = (struct pldm_pdr_hdr*)data;
1201 if (pdr->type == PLDM_TERMINUS_LOCATOR_PDR)
1202 {
1203 auto pdr = reinterpret_cast<const pldm_terminus_locator_pdr*>(data);
1204 if (pdr->tid == tid)
1205 {
1206 handleFound = true;
1207 return pdr->terminus_handle;
1208 }
1209 }
1210 return std::nullopt;
1211 }
1212
1213 /** @brief Format the Numeric Sensor PDR types to json output
1214 *
1215 * @param[in] data - reference to the Numeric Sensor PDR
1216 * @param[in] data_length - number of PDR data bytes
1217 * @param[out] output - PDRs data fields in Json format
1218 */
printNumericSensorPDR(const uint8_t * data,const uint16_t data_length,ordered_json & output)1219 void printNumericSensorPDR(const uint8_t* data, const uint16_t data_length,
1220 ordered_json& output)
1221 {
1222 struct pldm_numeric_sensor_value_pdr pdr;
1223 int rc = decode_numeric_sensor_pdr_data(data, (size_t)data_length,
1224 &pdr);
1225 if (rc != PLDM_SUCCESS)
1226 {
1227 std::cerr << "Failed to get numeric sensor PDR" << std::endl;
1228 return;
1229 }
1230 output["PLDMTerminusHandle"] = pdr.terminus_handle;
1231 output["sensorID"] = pdr.sensor_id;
1232 output["entityType"] = getEntityName(pdr.entity_type);
1233 output["entityInstanceNumber"] = pdr.entity_instance_num;
1234 output["containerID"] = pdr.container_id;
1235 output["sensorInit"] = pdr.sensor_init;
1236 output["sensorAuxiliaryNamesPDR"] =
1237 (pdr.sensor_auxiliary_names_pdr) ? true : false;
1238 output["baseUnit"] = pdr.base_unit;
1239 output["unitModifier"] = pdr.unit_modifier;
1240 output["rateUnit"] = pdr.rate_unit;
1241 output["baseOEMUnitHandle"] = pdr.base_oem_unit_handle;
1242 output["auxUnit"] = pdr.aux_unit;
1243 output["auxUnitModifier"] = pdr.aux_unit_modifier;
1244 output["auxrateUnit"] = pdr.aux_rate_unit;
1245 output["rel"] = pdr.rel;
1246 output["auxOEMUnitHandle"] = pdr.aux_oem_unit_handle;
1247 output["isLinear"] = (pdr.is_linear) ? true : false;
1248 output["sensorDataSize"] = pdr.sensor_data_size;
1249 output["resolution"] = pdr.resolution;
1250 output["offset"] = pdr.offset;
1251 output["accuracy"] = pdr.accuracy;
1252 output["plusTolerance"] = pdr.plus_tolerance;
1253 output["minusTolerance"] = pdr.minus_tolerance;
1254
1255 switch (pdr.sensor_data_size)
1256 {
1257 case PLDM_SENSOR_DATA_SIZE_UINT8:
1258 output["hysteresis"] = pdr.hysteresis.value_u8;
1259 output["maxReadable"] = pdr.max_readable.value_u8;
1260 output["minReadable"] = pdr.min_readable.value_u8;
1261 break;
1262 case PLDM_SENSOR_DATA_SIZE_SINT8:
1263 output["hysteresis"] = pdr.hysteresis.value_s8;
1264 output["maxReadable"] = pdr.max_readable.value_s8;
1265 output["minReadable"] = pdr.min_readable.value_s8;
1266 break;
1267 case PLDM_SENSOR_DATA_SIZE_UINT16:
1268 output["hysteresis"] = pdr.hysteresis.value_u16;
1269 output["maxReadable"] = pdr.max_readable.value_u16;
1270 output["minReadable"] = pdr.min_readable.value_u16;
1271 break;
1272 case PLDM_SENSOR_DATA_SIZE_SINT16:
1273 output["hysteresis"] = pdr.hysteresis.value_s16;
1274 output["maxReadable"] = pdr.max_readable.value_s16;
1275 output["minReadable"] = pdr.min_readable.value_s16;
1276 break;
1277 case PLDM_SENSOR_DATA_SIZE_UINT32:
1278 output["hysteresis"] = pdr.hysteresis.value_u32;
1279 output["maxReadable"] = pdr.max_readable.value_u32;
1280 output["minReadable"] = pdr.min_readable.value_u32;
1281 break;
1282 case PLDM_SENSOR_DATA_SIZE_SINT32:
1283 output["hysteresis"] = pdr.hysteresis.value_s32;
1284 output["maxReadable"] = pdr.max_readable.value_s32;
1285 output["minReadable"] = pdr.min_readable.value_s32;
1286 break;
1287 default:
1288 break;
1289 }
1290
1291 output["supportedThresholds"] = pdr.supported_thresholds.byte;
1292 output["thresholAndHysteresisVolatility"] =
1293 pdr.threshold_and_hysteresis_volatility.byte;
1294 output["stateTransitionInterval"] = pdr.state_transition_interval;
1295 output["updateInterval"] = pdr.update_interval;
1296 output["rangeFieldFormat"] = pdr.range_field_format;
1297 output["rangeFieldSupport"] = pdr.range_field_support.byte;
1298
1299 switch (pdr.range_field_format)
1300 {
1301 case PLDM_RANGE_FIELD_FORMAT_UINT8:
1302 output["nominalValue"] = pdr.nominal_value.value_u8;
1303 output["normalMax"] = pdr.normal_max.value_u8;
1304 output["normalMin"] = pdr.normal_min.value_u8;
1305 output["warningHigh"] = pdr.warning_high.value_u8;
1306 output["warningLow"] = pdr.warning_low.value_u8;
1307 output["criticalHigh"] = pdr.critical_high.value_u8;
1308 output["criticalLow"] = pdr.critical_low.value_u8;
1309 output["fatalHigh"] = pdr.fatal_high.value_u8;
1310 output["fatalLeow"] = pdr.fatal_low.value_u8;
1311 break;
1312 case PLDM_RANGE_FIELD_FORMAT_SINT8:
1313 output["nominalValue"] = pdr.nominal_value.value_s8;
1314 output["normalMax"] = pdr.normal_max.value_s8;
1315 output["normalMin"] = pdr.normal_min.value_s8;
1316 output["warningHigh"] = pdr.warning_high.value_s8;
1317 output["warningLow"] = pdr.warning_low.value_s8;
1318 output["criticalHigh"] = pdr.critical_high.value_s8;
1319 output["criticalLow"] = pdr.critical_low.value_s8;
1320 output["fatalHigh"] = pdr.fatal_high.value_s8;
1321 output["fatalLeow"] = pdr.fatal_low.value_s8;
1322 break;
1323 case PLDM_RANGE_FIELD_FORMAT_UINT16:
1324 output["nominalValue"] = pdr.nominal_value.value_u16;
1325 output["normalMax"] = pdr.normal_max.value_u16;
1326 output["normalMin"] = pdr.normal_min.value_u16;
1327 output["warningHigh"] = pdr.warning_high.value_u16;
1328 output["warningLow"] = pdr.warning_low.value_u16;
1329 output["criticalHigh"] = pdr.critical_high.value_u16;
1330 output["criticalLow"] = pdr.critical_low.value_u16;
1331 output["fatalHigh"] = pdr.fatal_high.value_u16;
1332 output["fatalLeow"] = pdr.fatal_low.value_u16;
1333 break;
1334 case PLDM_RANGE_FIELD_FORMAT_SINT16:
1335 output["nominalValue"] = pdr.nominal_value.value_s16;
1336 output["normalMax"] = pdr.normal_max.value_s16;
1337 output["normalMin"] = pdr.normal_min.value_s16;
1338 output["warningHigh"] = pdr.warning_high.value_s16;
1339 output["warningLow"] = pdr.warning_low.value_s16;
1340 output["criticalHigh"] = pdr.critical_high.value_s16;
1341 output["criticalLow"] = pdr.critical_low.value_s16;
1342 output["fatalHigh"] = pdr.fatal_high.value_s16;
1343 output["fatalLeow"] = pdr.fatal_low.value_s16;
1344 break;
1345 case PLDM_RANGE_FIELD_FORMAT_UINT32:
1346 output["nominalValue"] = pdr.nominal_value.value_u32;
1347 output["normalMax"] = pdr.normal_max.value_u32;
1348 output["normalMin"] = pdr.normal_min.value_u32;
1349 output["warningHigh"] = pdr.warning_high.value_u32;
1350 output["warningLow"] = pdr.warning_low.value_u32;
1351 output["criticalHigh"] = pdr.critical_high.value_u32;
1352 output["criticalLow"] = pdr.critical_low.value_u32;
1353 output["fatalHigh"] = pdr.fatal_high.value_u32;
1354 output["fatalLeow"] = pdr.fatal_low.value_u32;
1355 break;
1356 case PLDM_RANGE_FIELD_FORMAT_SINT32:
1357 output["nominalValue"] = pdr.nominal_value.value_s32;
1358 output["normalMax"] = pdr.normal_max.value_s32;
1359 output["normalMin"] = pdr.normal_min.value_s32;
1360 output["warningHigh"] = pdr.warning_high.value_s32;
1361 output["warningLow"] = pdr.warning_low.value_s32;
1362 output["criticalHigh"] = pdr.critical_high.value_s32;
1363 output["criticalLow"] = pdr.critical_low.value_s32;
1364 output["fatalHigh"] = pdr.fatal_high.value_s32;
1365 output["fatalLeow"] = pdr.fatal_low.value_s32;
1366 break;
1367 case PLDM_RANGE_FIELD_FORMAT_REAL32:
1368 output["nominalValue"] = pdr.nominal_value.value_f32;
1369 output["normalMax"] = pdr.normal_max.value_f32;
1370 output["normalMin"] = pdr.normal_min.value_f32;
1371 output["warningHigh"] = pdr.warning_high.value_f32;
1372 output["warningLow"] = pdr.warning_low.value_f32;
1373 output["criticalHigh"] = pdr.critical_high.value_f32;
1374 output["criticalLow"] = pdr.critical_low.value_f32;
1375 output["fatalHigh"] = pdr.fatal_high.value_f32;
1376 output["fatalLeow"] = pdr.fatal_low.value_f32;
1377 break;
1378 default:
1379 break;
1380 }
1381 }
1382
1383 /** @brief Format the Compact Numeric Sensor PDR types to json output
1384 *
1385 * @param[in] data - reference to the Compact Numeric Sensor PDR
1386 * @param[out] output - PDRs data fields in Json format
1387 */
printCompactNumericSensorPDR(const uint8_t * data,ordered_json & output)1388 void printCompactNumericSensorPDR(const uint8_t* data, ordered_json& output)
1389 {
1390 struct pldm_compact_numeric_sensor_pdr* pdr =
1391 (struct pldm_compact_numeric_sensor_pdr*)data;
1392 if (!pdr)
1393 {
1394 std::cerr << "Failed to get compact numeric sensor PDR"
1395 << std::endl;
1396 return;
1397 }
1398 output["PLDMTerminusHandle"] = int(pdr->terminus_handle);
1399 output["sensorID"] = int(pdr->sensor_id);
1400 output["entityType"] = getEntityName(pdr->entity_type);
1401 output["entityInstanceNumber"] = int(pdr->entity_instance);
1402 output["containerID"] = int(pdr->container_id);
1403 output["sensorNameStringByteLength"] = int(pdr->sensor_name_length);
1404 if (pdr->sensor_name_length == 0)
1405 {
1406 output["Name"] = std::format("PLDM_Device_TID{}_SensorId{}",
1407 unsigned(pdr->terminus_handle),
1408 unsigned(pdr->sensor_id));
1409 }
1410 else
1411 {
1412 std::string sTemp(reinterpret_cast<const char*>(pdr->sensor_name),
1413 pdr->sensor_name_length);
1414 output["Name"] = sTemp;
1415 }
1416 output["baseUnit"] = unsigned(pdr->base_unit);
1417 output["unitModifier"] = signed(pdr->unit_modifier);
1418 output["occurrenceRate"] = unsigned(pdr->occurrence_rate);
1419 output["rangeFieldSupport"] = unsigned(pdr->range_field_support.byte);
1420 if (pdr->range_field_support.bits.bit0)
1421 {
1422 output["warningHigh"] = int(pdr->warning_high);
1423 }
1424 if (pdr->range_field_support.bits.bit1)
1425 {
1426 output["warningLow"] = int(pdr->warning_low);
1427 }
1428 if (pdr->range_field_support.bits.bit2)
1429 {
1430 output["criticalHigh"] = int(pdr->critical_high);
1431 }
1432 if (pdr->range_field_support.bits.bit3)
1433 {
1434 output["criticalLow"] = int(pdr->critical_low);
1435 }
1436 if (pdr->range_field_support.bits.bit4)
1437 {
1438 output["fatalHigh"] = int(pdr->fatal_high);
1439 }
1440 if (pdr->range_field_support.bits.bit5)
1441 {
1442 output["fatalLow"] = int(pdr->fatal_low);
1443 }
1444 }
1445
printPDRMsg(uint32_t & nextRecordHndl,const uint16_t respCnt,uint8_t * data,std::optional<uint16_t> terminusHandle)1446 void printPDRMsg(uint32_t& nextRecordHndl, const uint16_t respCnt,
1447 uint8_t* data, std::optional<uint16_t> terminusHandle)
1448 {
1449 if (data == NULL)
1450 {
1451 std::cerr << "Failed to get PDR message" << std::endl;
1452 return;
1453 }
1454
1455 ordered_json output;
1456 output["nextRecordHandle"] = nextRecordHndl;
1457 output["responseCount"] = respCnt;
1458
1459 struct pldm_pdr_hdr* pdr = (struct pldm_pdr_hdr*)data;
1460 if (!pdr)
1461 {
1462 return;
1463 }
1464
1465 if (!pdrRecType.empty())
1466 {
1467 // Need to return if the requested PDR type
1468 // is not supported
1469 if (!strToPdrType.contains(pdrRecType))
1470 {
1471 std::cerr << "PDR type '" << pdrRecType
1472 << "' is not supported or invalid\n";
1473 // PDR type not supported, setting next record handle to
1474 // 0 to avoid looping through all PDR records
1475 nextRecordHndl = 0;
1476 return;
1477 }
1478
1479 // Do not print PDR record if the current record
1480 // PDR type does not match with requested type
1481 if (pdr->type != strToPdrType.at(pdrRecType))
1482 {
1483 return;
1484 }
1485 }
1486
1487 if (pdrTerminus.has_value())
1488 {
1489 if (checkTerminusHandle(data, terminusHandle))
1490 {
1491 std::cerr << "The Terminus handle doesn't match return"
1492 << std::endl;
1493 return;
1494 }
1495 }
1496
1497 printCommonPDRHeader(pdr, output);
1498
1499 switch (pdr->type)
1500 {
1501 case PLDM_TERMINUS_LOCATOR_PDR:
1502 printTerminusLocatorPDR(data, output);
1503 break;
1504 case PLDM_STATE_SENSOR_PDR:
1505 printStateSensorPDR(data, output);
1506 break;
1507 case PLDM_NUMERIC_EFFECTER_PDR:
1508 printNumericEffecterPDR(data, output);
1509 break;
1510 case PLDM_NUMERIC_SENSOR_PDR:
1511 printNumericSensorPDR(data, respCnt, output);
1512 break;
1513 case PLDM_SENSOR_AUXILIARY_NAMES_PDR:
1514 printAuxNamePDR(data, output);
1515 break;
1516 case PLDM_EFFECTER_AUXILIARY_NAMES_PDR:
1517 printAuxNamePDR(data, output);
1518 break;
1519 case PLDM_STATE_EFFECTER_PDR:
1520 printStateEffecterPDR(data, output);
1521 break;
1522 case PLDM_PDR_ENTITY_ASSOCIATION:
1523 printPDREntityAssociation(data, output);
1524 break;
1525 case PLDM_PDR_FRU_RECORD_SET:
1526 printPDRFruRecordSet(data, output);
1527 break;
1528 case PLDM_COMPACT_NUMERIC_SENSOR_PDR:
1529 printCompactNumericSensorPDR(data, output);
1530 break;
1531 default:
1532 break;
1533 }
1534 pldmtool::helper::DisplayInJson(output);
1535 }
1536
1537 private:
1538 bool optTIDSet = false;
1539 uint32_t recordHandle;
1540 bool allPDRs;
1541 std::string pdrRecType;
1542 std::optional<uint8_t> pdrTerminus;
1543 std::optional<uint16_t> terminusHandle;
1544 bool handleFound = false;
1545 CLI::Option* getPDRGroupOption = nullptr;
1546 };
1547
1548 class SetStateEffecter : public CommandInterface
1549 {
1550 public:
1551 ~SetStateEffecter() = default;
1552 SetStateEffecter() = delete;
1553 SetStateEffecter(const SetStateEffecter&) = delete;
1554 SetStateEffecter(SetStateEffecter&&) = default;
1555 SetStateEffecter& operator=(const SetStateEffecter&) = delete;
1556 SetStateEffecter& operator=(SetStateEffecter&&) = delete;
1557
1558 // compositeEffecterCount(value: 0x01 to 0x08) * stateField(2)
1559 static constexpr auto maxEffecterDataSize = 16;
1560
1561 // compositeEffecterCount(value: 0x01 to 0x08)
1562 static constexpr auto minEffecterCount = 1;
1563 static constexpr auto maxEffecterCount = 8;
SetStateEffecter(const char * type,const char * name,CLI::App * app)1564 explicit SetStateEffecter(const char* type, const char* name,
1565 CLI::App* app) :
1566 CommandInterface(type, name, app)
1567 {
1568 app->add_option(
1569 "-i, --id", effecterId,
1570 "A handle that is used to identify and access the effecter")
1571 ->required();
1572 app->add_option("-c, --count", effecterCount,
1573 "The number of individual sets of effecter information")
1574 ->required();
1575 app->add_option(
1576 "-d,--data", effecterData,
1577 "Set effecter state data\n"
1578 "eg: requestSet0 effecterState0 noChange1 dummyState1 ...")
1579 ->required();
1580 }
1581
createRequestMsg()1582 std::pair<int, std::vector<uint8_t>> createRequestMsg() override
1583 {
1584 std::vector<uint8_t> requestMsg(
1585 sizeof(pldm_msg_hdr) + PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES);
1586 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1587
1588 if (effecterCount > maxEffecterCount ||
1589 effecterCount < minEffecterCount)
1590 {
1591 std::cerr << "Request Message Error: effecterCount size "
1592 << effecterCount << "is invalid\n";
1593 auto rc = PLDM_ERROR_INVALID_DATA;
1594 return {rc, requestMsg};
1595 }
1596
1597 if (effecterData.size() > maxEffecterDataSize)
1598 {
1599 std::cerr << "Request Message Error: effecterData size "
1600 << effecterData.size() << "is invalid\n";
1601 auto rc = PLDM_ERROR_INVALID_DATA;
1602 return {rc, requestMsg};
1603 }
1604
1605 auto stateField = parseEffecterData(effecterData, effecterCount);
1606 if (!stateField)
1607 {
1608 std::cerr << "Failed to parse effecter data, effecterCount size "
1609 << effecterCount << "\n";
1610 auto rc = PLDM_ERROR_INVALID_DATA;
1611 return {rc, requestMsg};
1612 }
1613
1614 auto rc = encode_set_state_effecter_states_req(
1615 instanceId, effecterId, effecterCount, stateField->data(), request);
1616 return {rc, requestMsg};
1617 }
1618
parseResponseMsg(pldm_msg * responsePtr,size_t payloadLength)1619 void parseResponseMsg(pldm_msg* responsePtr, size_t payloadLength) override
1620 {
1621 uint8_t completionCode = 0;
1622 auto rc = decode_set_state_effecter_states_resp(
1623 responsePtr, payloadLength, &completionCode);
1624
1625 if (rc != PLDM_SUCCESS || completionCode != PLDM_SUCCESS)
1626 {
1627 std::cerr << "Response Message Error: "
1628 << "rc=" << rc << ",cc=" << (int)completionCode << "\n";
1629 return;
1630 }
1631
1632 ordered_json data;
1633 data["Response"] = "SUCCESS";
1634 pldmtool::helper::DisplayInJson(data);
1635 }
1636
1637 private:
1638 uint16_t effecterId;
1639 uint8_t effecterCount;
1640 std::vector<uint8_t> effecterData;
1641 };
1642
1643 class SetNumericEffecterValue : public CommandInterface
1644 {
1645 public:
1646 ~SetNumericEffecterValue() = default;
1647 SetNumericEffecterValue() = delete;
1648 SetNumericEffecterValue(const SetNumericEffecterValue&) = delete;
1649 SetNumericEffecterValue(SetNumericEffecterValue&&) = default;
1650 SetNumericEffecterValue& operator=(const SetNumericEffecterValue&) = delete;
1651 SetNumericEffecterValue& operator=(SetNumericEffecterValue&&) = delete;
1652
SetNumericEffecterValue(const char * type,const char * name,CLI::App * app)1653 explicit SetNumericEffecterValue(const char* type, const char* name,
1654 CLI::App* app) :
1655 CommandInterface(type, name, app)
1656 {
1657 app->add_option(
1658 "-i, --id", effecterId,
1659 "A handle that is used to identify and access the effecter")
1660 ->required();
1661 app->add_option("-s, --size", effecterDataSize,
1662 "The bit width and format of the setting value for the "
1663 "effecter. enum value: {uint8, sint8, uint16, sint16, "
1664 "uint32, sint32}\n")
1665 ->required();
1666 app->add_option("-d,--data", maxEffecterValue,
1667 "The setting value of numeric effecter being "
1668 "requested\n")
1669 ->required();
1670 }
1671
createRequestMsg()1672 std::pair<int, std::vector<uint8_t>> createRequestMsg() override
1673 {
1674 std::vector<uint8_t> requestMsg(
1675 sizeof(pldm_msg_hdr) +
1676 PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES + 3);
1677
1678 uint8_t* effecterValue = (uint8_t*)&maxEffecterValue;
1679
1680 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1681 size_t payload_length = PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES;
1682
1683 if (effecterDataSize == PLDM_EFFECTER_DATA_SIZE_UINT16 ||
1684 effecterDataSize == PLDM_EFFECTER_DATA_SIZE_SINT16)
1685 {
1686 payload_length = PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES + 1;
1687 }
1688 if (effecterDataSize == PLDM_EFFECTER_DATA_SIZE_UINT32 ||
1689 effecterDataSize == PLDM_EFFECTER_DATA_SIZE_SINT32)
1690 {
1691 payload_length = PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES + 3;
1692 }
1693 auto rc = encode_set_numeric_effecter_value_req(
1694 0, effecterId, effecterDataSize, effecterValue, request,
1695 payload_length);
1696
1697 return {rc, requestMsg};
1698 }
1699
parseResponseMsg(pldm_msg * responsePtr,size_t payloadLength)1700 void parseResponseMsg(pldm_msg* responsePtr, size_t payloadLength) override
1701 {
1702 uint8_t completionCode = 0;
1703 auto rc = decode_set_numeric_effecter_value_resp(
1704 responsePtr, payloadLength, &completionCode);
1705
1706 if (rc != PLDM_SUCCESS || completionCode != PLDM_SUCCESS)
1707 {
1708 std::cerr << "Response Message Error: "
1709 << "rc=" << rc << ",cc=" << (int)completionCode
1710 << std::endl;
1711 return;
1712 }
1713
1714 ordered_json data;
1715 data["Response"] = "SUCCESS";
1716 pldmtool::helper::DisplayInJson(data);
1717 }
1718
1719 private:
1720 uint16_t effecterId;
1721 uint8_t effecterDataSize;
1722 uint64_t maxEffecterValue;
1723 };
1724
1725 class GetStateSensorReadings : public CommandInterface
1726 {
1727 public:
1728 ~GetStateSensorReadings() = default;
1729 GetStateSensorReadings() = delete;
1730 GetStateSensorReadings(const GetStateSensorReadings&) = delete;
1731 GetStateSensorReadings(GetStateSensorReadings&&) = default;
1732 GetStateSensorReadings& operator=(const GetStateSensorReadings&) = delete;
1733 GetStateSensorReadings& operator=(GetStateSensorReadings&&) = delete;
1734
GetStateSensorReadings(const char * type,const char * name,CLI::App * app)1735 explicit GetStateSensorReadings(const char* type, const char* name,
1736 CLI::App* app) :
1737 CommandInterface(type, name, app)
1738 {
1739 app->add_option(
1740 "-i, --sensor_id", sensorId,
1741 "Sensor ID that is used to identify and access the sensor")
1742 ->required();
1743 app->add_option("-r, --rearm", sensorRearm,
1744 "Each bit location in this field corresponds to a "
1745 "particular sensor")
1746 ->required();
1747 }
1748
createRequestMsg()1749 std::pair<int, std::vector<uint8_t>> createRequestMsg() override
1750 {
1751 std::vector<uint8_t> requestMsg(
1752 sizeof(pldm_msg_hdr) + PLDM_GET_STATE_SENSOR_READINGS_REQ_BYTES);
1753 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1754
1755 uint8_t reserved = 0;
1756 bitfield8_t bf;
1757 bf.byte = sensorRearm;
1758 auto rc = encode_get_state_sensor_readings_req(instanceId, sensorId, bf,
1759 reserved, request);
1760
1761 return {rc, requestMsg};
1762 }
1763
parseResponseMsg(pldm_msg * responsePtr,size_t payloadLength)1764 void parseResponseMsg(pldm_msg* responsePtr, size_t payloadLength) override
1765 {
1766 uint8_t completionCode = 0;
1767 uint8_t compSensorCount = 0;
1768 std::array<get_sensor_state_field, 8> stateField{};
1769 auto rc = decode_get_state_sensor_readings_resp(
1770 responsePtr, payloadLength, &completionCode, &compSensorCount,
1771 stateField.data());
1772
1773 if (rc != PLDM_SUCCESS || completionCode != PLDM_SUCCESS)
1774 {
1775 std::cerr << "Response Message Error: "
1776 << "rc=" << rc << ",cc=" << (int)completionCode
1777 << std::endl;
1778 return;
1779 }
1780 ordered_json output;
1781 output["compositeSensorCount"] = (int)compSensorCount;
1782
1783 for (size_t i = 0; i < compSensorCount; i++)
1784 {
1785 if (sensorOpState.contains(stateField[i].sensor_op_state))
1786 {
1787 output.emplace(("sensorOpState[" + std::to_string(i) + "]"),
1788 sensorOpState.at(stateField[i].sensor_op_state));
1789 }
1790
1791 if (sensorPresState.contains(stateField[i].present_state))
1792 {
1793 output.emplace(("presentState[" + std::to_string(i) + "]"),
1794 sensorPresState.at(stateField[i].present_state));
1795 }
1796
1797 if (sensorPresState.contains(stateField[i].previous_state))
1798 {
1799 output.emplace(
1800 ("previousState[" + std::to_string(i) + "]"),
1801 sensorPresState.at(stateField[i].previous_state));
1802 }
1803
1804 if (sensorPresState.contains(stateField[i].event_state))
1805 {
1806 output.emplace(("eventState[" + std::to_string(i) + "]"),
1807 sensorPresState.at(stateField[i].event_state));
1808 }
1809 }
1810
1811 pldmtool::helper::DisplayInJson(output);
1812 }
1813
1814 private:
1815 uint16_t sensorId;
1816 uint8_t sensorRearm;
1817 };
1818
1819 class GetSensorReading : public CommandInterface
1820 {
1821 public:
1822 ~GetSensorReading() = default;
1823 GetSensorReading() = delete;
1824 GetSensorReading(const GetSensorReading&) = delete;
1825 GetSensorReading(GetSensorReading&&) = default;
1826 GetSensorReading& operator=(const GetSensorReading&) = delete;
1827 GetSensorReading& operator=(GetSensorReading&&) = delete;
1828
GetSensorReading(const char * type,const char * name,CLI::App * app)1829 explicit GetSensorReading(const char* type, const char* name,
1830 CLI::App* app) :
1831 CommandInterface(type, name, app)
1832 {
1833 app->add_option(
1834 "-i, --sensor_id", sensorId,
1835 "Sensor ID that is used to identify and access the sensor")
1836 ->required();
1837 app->add_option("-r, --rearm", rearm,
1838 "Manually re-arm EventState after "
1839 "responding to this request")
1840 ->required();
1841 }
1842
createRequestMsg()1843 std::pair<int, std::vector<uint8_t>> createRequestMsg() override
1844 {
1845 std::vector<uint8_t> requestMsg(sizeof(pldm_msg_hdr) +
1846 PLDM_GET_SENSOR_READING_REQ_BYTES);
1847 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1848
1849 auto rc = encode_get_sensor_reading_req(instanceId, sensorId, rearm,
1850 request);
1851
1852 return {rc, requestMsg};
1853 }
1854
parseResponseMsg(pldm_msg * responsePtr,size_t payloadLength)1855 void parseResponseMsg(pldm_msg* responsePtr, size_t payloadLength) override
1856 {
1857 uint8_t completionCode = 0;
1858 uint8_t sensorDataSize = 0;
1859 uint8_t sensorOperationalState = 0;
1860 uint8_t sensorEventMessageEnable = 0;
1861 uint8_t presentState = 0;
1862 uint8_t previousState = 0;
1863 uint8_t eventState = 0;
1864 std::array<uint8_t, sizeof(uint32_t)>
1865 presentReading{}; // maximum size for the present Value is uint32
1866 // according to spec DSP0248
1867
1868 auto rc = decode_get_sensor_reading_resp(
1869 responsePtr, payloadLength, &completionCode, &sensorDataSize,
1870 &sensorOperationalState, &sensorEventMessageEnable, &presentState,
1871 &previousState, &eventState, presentReading.data());
1872
1873 if (rc != PLDM_SUCCESS || completionCode != PLDM_SUCCESS)
1874 {
1875 std::cerr << "Response Message Error: "
1876 << "rc=" << rc << ",cc=" << (int)completionCode
1877 << std::endl;
1878 return;
1879 }
1880
1881 ordered_json output;
1882 output["sensorDataSize"] = getSensorState(sensorDataSize,
1883 &sensorDataSz);
1884 output["sensorOperationalState"] =
1885 getSensorState(sensorOperationalState, &sensorOpState);
1886 output["sensorEventMessageEnable"] =
1887 getSensorState(sensorEventMessageEnable, &sensorEventMsgEnable);
1888 output["presentState"] = getSensorState(presentState, &sensorPresState);
1889 output["previousState"] = getSensorState(previousState,
1890 &sensorPresState);
1891 output["eventState"] = getSensorState(eventState, &sensorPresState);
1892
1893 switch (sensorDataSize)
1894 {
1895 case PLDM_SENSOR_DATA_SIZE_UINT8:
1896 {
1897 output["presentReading"] =
1898 *(reinterpret_cast<uint8_t*>(presentReading.data()));
1899 break;
1900 }
1901 case PLDM_SENSOR_DATA_SIZE_SINT8:
1902 {
1903 output["presentReading"] =
1904 *(reinterpret_cast<int8_t*>(presentReading.data()));
1905 break;
1906 }
1907 case PLDM_SENSOR_DATA_SIZE_UINT16:
1908 {
1909 output["presentReading"] =
1910 *(reinterpret_cast<uint16_t*>(presentReading.data()));
1911 break;
1912 }
1913 case PLDM_SENSOR_DATA_SIZE_SINT16:
1914 {
1915 output["presentReading"] =
1916 *(reinterpret_cast<int16_t*>(presentReading.data()));
1917 break;
1918 }
1919 case PLDM_SENSOR_DATA_SIZE_UINT32:
1920 {
1921 output["presentReading"] =
1922 *(reinterpret_cast<uint32_t*>(presentReading.data()));
1923 break;
1924 }
1925 case PLDM_SENSOR_DATA_SIZE_SINT32:
1926 {
1927 output["presentReading"] =
1928 *(reinterpret_cast<int32_t*>(presentReading.data()));
1929 break;
1930 }
1931 default:
1932 {
1933 std::cerr << "Unknown Sensor Data Size : "
1934 << static_cast<int>(sensorDataSize) << std::endl;
1935 break;
1936 }
1937 }
1938
1939 pldmtool::helper::DisplayInJson(output);
1940 }
1941
1942 private:
1943 uint16_t sensorId;
1944 uint8_t rearm;
1945
1946 const std::map<uint8_t, std::string> sensorDataSz = {
1947 {PLDM_SENSOR_DATA_SIZE_UINT8, "uint8"},
1948 {PLDM_SENSOR_DATA_SIZE_SINT8, "uint8"},
1949 {PLDM_SENSOR_DATA_SIZE_UINT16, "uint16"},
1950 {PLDM_SENSOR_DATA_SIZE_SINT16, "uint16"},
1951 {PLDM_SENSOR_DATA_SIZE_UINT32, "uint32"},
1952 {PLDM_SENSOR_DATA_SIZE_SINT32, "uint32"}};
1953
1954 static inline const std::map<uint8_t, std::string> sensorEventMsgEnable{
1955 {PLDM_NO_EVENT_GENERATION, "Sensor No Event Generation"},
1956 {PLDM_EVENTS_DISABLED, "Sensor Events Disabled"},
1957 {PLDM_EVENTS_ENABLED, "Sensor Events Enabled"},
1958 {PLDM_OP_EVENTS_ONLY_ENABLED, "Sensor Op Events Only Enabled"},
1959 {PLDM_STATE_EVENTS_ONLY_ENABLED, "Sensor State Events Only Enabled"}};
1960
getSensorState(uint8_t state,const std::map<uint8_t,std::string> * cont)1961 std::string getSensorState(uint8_t state,
1962 const std::map<uint8_t, std::string>* cont)
1963 {
1964 auto typeString = std::to_string(state);
1965 try
1966 {
1967 return cont->at(state);
1968 }
1969 catch (const std::out_of_range& e)
1970 {
1971 return typeString;
1972 }
1973 }
1974 };
1975
1976 class GetNumericEffecterValue : public CommandInterface
1977 {
1978 public:
1979 ~GetNumericEffecterValue() = default;
1980 GetNumericEffecterValue() = delete;
1981 GetNumericEffecterValue(const GetNumericEffecterValue&) = delete;
1982 GetNumericEffecterValue(GetNumericEffecterValue&&) = default;
1983 GetNumericEffecterValue& operator=(const GetNumericEffecterValue&) = delete;
1984 GetNumericEffecterValue& operator=(GetNumericEffecterValue&&) = delete;
1985
GetNumericEffecterValue(const char * type,const char * name,CLI::App * app)1986 explicit GetNumericEffecterValue(const char* type, const char* name,
1987 CLI::App* app) :
1988 CommandInterface(type, name, app)
1989 {
1990 app->add_option(
1991 "-i, --effecter_id", effecterId,
1992 "A handle that is used to identify and access the effecter")
1993 ->required();
1994 }
1995
createRequestMsg()1996 std::pair<int, std::vector<uint8_t>> createRequestMsg() override
1997 {
1998 std::vector<uint8_t> requestMsg(
1999 sizeof(pldm_msg_hdr) + PLDM_GET_NUMERIC_EFFECTER_VALUE_REQ_BYTES);
2000 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
2001
2002 auto rc = encode_get_numeric_effecter_value_req(instanceId, effecterId,
2003 request);
2004
2005 return {rc, requestMsg};
2006 }
2007
parseResponseMsg(pldm_msg * responsePtr,size_t payloadLength)2008 void parseResponseMsg(pldm_msg* responsePtr, size_t payloadLength) override
2009 {
2010 uint8_t completionCode = 0;
2011 uint8_t effecterDataSize = 0;
2012 uint8_t effecterOperationalState = 0;
2013 std::array<uint8_t, sizeof(uint32_t)>
2014 pendingValue{}; // maximum size for the pending Value is uint32
2015 // according to spec DSP0248
2016 std::array<uint8_t, sizeof(uint32_t)>
2017 presentValue{}; // maximum size for the present Value is uint32
2018 // according to spec DSP0248
2019
2020 auto rc = decode_get_numeric_effecter_value_resp(
2021 responsePtr, payloadLength, &completionCode, &effecterDataSize,
2022 &effecterOperationalState, pendingValue.data(),
2023 presentValue.data());
2024
2025 if (rc != PLDM_SUCCESS || completionCode != PLDM_SUCCESS)
2026 {
2027 std::cerr << "Response Message Error: "
2028 << "rc=" << rc
2029 << ",cc=" << static_cast<int>(completionCode)
2030 << std::endl;
2031 return;
2032 }
2033
2034 ordered_json output;
2035 output["effecterDataSize"] = static_cast<int>(effecterDataSize);
2036 output["effecterOperationalState"] =
2037 getOpState(effecterOperationalState);
2038
2039 switch (effecterDataSize)
2040 {
2041 case PLDM_EFFECTER_DATA_SIZE_UINT8:
2042 {
2043 output["pendingValue"] =
2044 *(reinterpret_cast<uint8_t*>(pendingValue.data()));
2045 output["presentValue"] =
2046 *(reinterpret_cast<uint8_t*>(presentValue.data()));
2047 break;
2048 }
2049 case PLDM_EFFECTER_DATA_SIZE_SINT8:
2050 {
2051 output["pendingValue"] =
2052 *(reinterpret_cast<int8_t*>(pendingValue.data()));
2053 output["presentValue"] =
2054 *(reinterpret_cast<int8_t*>(presentValue.data()));
2055 break;
2056 }
2057 case PLDM_EFFECTER_DATA_SIZE_UINT16:
2058 {
2059 output["pendingValue"] =
2060 *(reinterpret_cast<uint16_t*>(pendingValue.data()));
2061 output["presentValue"] =
2062 *(reinterpret_cast<uint16_t*>(presentValue.data()));
2063 break;
2064 }
2065 case PLDM_EFFECTER_DATA_SIZE_SINT16:
2066 {
2067 output["pendingValue"] =
2068 *(reinterpret_cast<int16_t*>(pendingValue.data()));
2069 output["presentValue"] =
2070 *(reinterpret_cast<int16_t*>(presentValue.data()));
2071 break;
2072 }
2073 case PLDM_EFFECTER_DATA_SIZE_UINT32:
2074 {
2075 output["pendingValue"] =
2076 *(reinterpret_cast<uint32_t*>(pendingValue.data()));
2077 output["presentValue"] =
2078 *(reinterpret_cast<uint32_t*>(presentValue.data()));
2079 break;
2080 }
2081 case PLDM_EFFECTER_DATA_SIZE_SINT32:
2082 {
2083 output["pendingValue"] =
2084 *(reinterpret_cast<int32_t*>(pendingValue.data()));
2085 output["presentValue"] =
2086 *(reinterpret_cast<int32_t*>(presentValue.data()));
2087 break;
2088 }
2089 default:
2090 {
2091 std::cerr << "Unknown Effecter Data Size : "
2092 << static_cast<int>(effecterDataSize) << std::endl;
2093 break;
2094 }
2095 }
2096
2097 pldmtool::helper::DisplayInJson(output);
2098 }
2099
2100 private:
2101 uint16_t effecterId;
2102
2103 static inline const std::map<uint8_t, std::string> numericEffecterOpState{
2104 {EFFECTER_OPER_STATE_ENABLED_UPDATEPENDING,
2105 "Effecter Enabled Update Pending"},
2106 {EFFECTER_OPER_STATE_ENABLED_NOUPDATEPENDING,
2107 "Effecter Enabled No Update Pending"},
2108 {EFFECTER_OPER_STATE_DISABLED, "Effecter Disabled"},
2109 {EFFECTER_OPER_STATE_UNAVAILABLE, "Effecter Unavailable"},
2110 {EFFECTER_OPER_STATE_STATUSUNKNOWN, "Effecter Status Unknown"},
2111 {EFFECTER_OPER_STATE_FAILED, "Effecter Failed"},
2112 {EFFECTER_OPER_STATE_INITIALIZING, "Effecter Initializing"},
2113 {EFFECTER_OPER_STATE_SHUTTINGDOWN, "Effecter Shutting Down"},
2114 {EFFECTER_OPER_STATE_INTEST, "Effecter In Test"}};
2115
getOpState(uint8_t state)2116 std::string getOpState(uint8_t state)
2117 {
2118 auto typeString = std::to_string(state);
2119 try
2120 {
2121 return numericEffecterOpState.at(state);
2122 }
2123 catch (const std::out_of_range& e)
2124 {
2125 return typeString;
2126 }
2127 }
2128 };
2129
registerCommand(CLI::App & app)2130 void registerCommand(CLI::App& app)
2131 {
2132 auto platform = app.add_subcommand("platform", "platform type command");
2133 platform->require_subcommand(1);
2134
2135 auto getPDR = platform->add_subcommand("GetPDR",
2136 "get platform descriptor records");
2137 commands.push_back(std::make_unique<GetPDR>("platform", "getPDR", getPDR));
2138
2139 auto setStateEffecterStates = platform->add_subcommand(
2140 "SetStateEffecterStates", "set effecter states");
2141 commands.push_back(std::make_unique<SetStateEffecter>(
2142 "platform", "setStateEffecterStates", setStateEffecterStates));
2143
2144 auto setNumericEffecterValue = platform->add_subcommand(
2145 "SetNumericEffecterValue", "set the value for a PLDM Numeric Effecter");
2146 commands.push_back(std::make_unique<SetNumericEffecterValue>(
2147 "platform", "setNumericEffecterValue", setNumericEffecterValue));
2148
2149 auto getStateSensorReadings = platform->add_subcommand(
2150 "GetStateSensorReadings", "get the state sensor readings");
2151 commands.push_back(std::make_unique<GetStateSensorReadings>(
2152 "platform", "getStateSensorReadings", getStateSensorReadings));
2153
2154 auto getNumericEffecterValue = platform->add_subcommand(
2155 "GetNumericEffecterValue", "get the numeric effecter value");
2156 commands.push_back(std::make_unique<GetNumericEffecterValue>(
2157 "platform", "getNumericEffecterValue", getNumericEffecterValue));
2158
2159 auto getSensorReading = platform->add_subcommand(
2160 "GetSensorReading", "get the numeric sensor reading");
2161 commands.push_back(std::make_unique<GetSensorReading>(
2162 "platform", "getSensorReading", getSensorReading));
2163 }
2164
parseGetPDROption()2165 void parseGetPDROption()
2166 {
2167 for (const auto& command : commands)
2168 {
2169 if (command.get()->getPLDMType() == "platform" &&
2170 command.get()->getCommandName() == "getPDR")
2171 {
2172 auto getPDR = dynamic_cast<GetPDR*>(command.get());
2173 getPDR->parseGetPDROptions();
2174 }
2175 }
2176 }
2177
2178 } // namespace platform
2179 } // namespace pldmtool
2180