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 Intializing"}, 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 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 101 void parseGetPDROptions() 102 { 103 optTIDSet = false; 104 if (getPDRGroupOption->count() > 0) 105 { 106 optTIDSet = true; 107 getPDRs(); 108 } 109 } 110 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 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 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 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 614 bool isLogicalBitSet(const uint16_t entity_type) 615 { 616 return entity_type & 0x8000; 617 } 618 619 uint16_t getEntityTypeForLogicalEntity(const uint16_t logical_entity_type) 620 { 621 return logical_entity_type & 0x7FFF; 622 } 623 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 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> 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 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 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 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 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 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 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 */ 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 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 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 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 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 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 */ 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 */ 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 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; 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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