blob: ca71dfa7d2e66fa667f5173503cb6bba46ec3cef [file] [log] [blame]
/*
// Copyright (c) 2019 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
*/
#include <boost/algorithm/string/join.hpp>
#include <boost/beast/core/span.hpp>
#include <iomanip>
#include <ipmi_to_redfish_hooks.hpp>
#include <phosphor-logging/log.hpp>
#include <sstream>
#include <storagecommands.hpp>
#include <string_view>
namespace intel_oem::ipmi::sel
{
namespace redfish_hooks
{
static void toHexStr(const boost::beast::span<uint8_t> bytes,
std::string& hexStr)
{
std::stringstream stream;
stream << std::hex << std::uppercase << std::setfill('0');
for (const uint8_t& byte : bytes)
{
stream << std::setw(2) << static_cast<int>(byte);
}
hexStr = stream.str();
}
static bool defaultMessageHook(const std::string& ipmiRaw)
{
// Log the record as a default Redfish message instead of a SEL record
static const std::string openBMCMessageRegistryVersion("0.1");
std::string messageID =
"OpenBMC." + openBMCMessageRegistryVersion + ".SELEntryAdded";
std::vector<std::string> messageArgs;
messageArgs.push_back(ipmiRaw);
// Log the Redfish message to the journal with the appropriate metadata
std::string journalMsg = "SEL Entry Added: " + ipmiRaw;
std::string messageArgsString = boost::algorithm::join(messageArgs, ",");
phosphor::logging::log<phosphor::logging::level::INFO>(
journalMsg.c_str(),
phosphor::logging::entry("REDFISH_MESSAGE_ID=%s", messageID.c_str()),
phosphor::logging::entry("REDFISH_MESSAGE_ARGS=%s",
messageArgsString.c_str()));
return true;
}
// Record a BIOS message as a Redfish message instead of a SEL record
static bool biosMessageHook(const SELData& selData, const std::string& ipmiRaw)
{
// This is a BIOS message, so record it as a Redfish message instead
// of a SEL record
// Walk through the SEL request record to build the appropriate Redfish
// message
static constexpr std::string_view openBMCMessageRegistryVersion = "0.1";
std::string messageID =
"OpenBMC." + std::string(openBMCMessageRegistryVersion);
std::vector<std::string> messageArgs;
BIOSSensors sensor = static_cast<BIOSSensors>(selData.sensorNum);
BIOSEventTypes eventType = static_cast<BIOSEventTypes>(selData.eventType);
switch (sensor)
{
case BIOSSensors::memoryRASConfigStatus:
switch (eventType)
{
case BIOSEventTypes::digitalDiscrete:
{
switch (selData.offset)
{
case 0x00:
messageID += ".MemoryRASConfigurationDisabled";
break;
case 0x01:
messageID += ".MemoryRASConfigurationEnabled";
break;
default:
return defaultMessageHook(ipmiRaw);
break;
}
// Get the message data from eventData2 and eventData3
// error = eventData2 bits [3:0]
int error = selData.eventData2 & 0x0F;
// mode = eventData3 bits [3:0]
int mode = selData.eventData3 & 0x0F;
// Save the messageArgs
switch (error)
{
case 0x00:
messageArgs.push_back("None");
break;
case 0x03:
messageArgs.push_back("Invalid DIMM Config");
break;
default:
messageArgs.push_back(std::to_string(error));
break;
}
switch (mode)
{
case 0x00:
messageArgs.push_back("None");
break;
case 0x01:
messageArgs.push_back("Mirroring");
break;
case 0x02:
messageArgs.push_back("Lockstep");
break;
case 0x04:
messageArgs.push_back("Rank Sparing");
break;
default:
messageArgs.push_back(std::to_string(mode));
break;
}
break;
}
default:
return defaultMessageHook(ipmiRaw);
break;
}
break;
case BIOSSensors::biosPOSTError:
switch (eventType)
{
case BIOSEventTypes::sensorSpecificOffset:
{
switch (selData.offset)
{
case 0x00:
messageID += ".BIOSPOSTError";
break;
default:
return defaultMessageHook(ipmiRaw);
break;
}
// Get the message data from eventData2 and eventData3
std::array<uint8_t, 2> post;
// post LSB = eventData2 bits [7:0]
post[1] = selData.eventData2;
// post MSB = eventData3 bits [7:0]
post[0] = selData.eventData3;
// Save the messageArgs
messageArgs.emplace_back();
std::string& postStr = messageArgs.back();
toHexStr(boost::beast::span<uint8_t>(post), postStr);
break;
}
default:
return defaultMessageHook(ipmiRaw);
break;
}
break;
case BIOSSensors::intelUPILinkWidthReduced:
switch (eventType)
{
case BIOSEventTypes::oemDiscrete7:
{
switch (selData.offset)
{
case 0x01:
messageID += ".IntelUPILinkWidthReducedToHalf";
break;
case 0x02:
messageID += ".IntelUPILinkWidthReducedToQuarter";
break;
default:
return defaultMessageHook(ipmiRaw);
break;
}
// Get the message data from eventData2
// Node ID = eventData2 bits [7:0]
int node = selData.eventData2;
// Save the messageArgs
messageArgs.push_back(std::to_string(node + 1));
break;
}
default:
return defaultMessageHook(ipmiRaw);
break;
}
break;
case BIOSSensors::memoryRASModeSelect:
switch (eventType)
{
case BIOSEventTypes::digitalDiscrete:
{
switch (selData.offset)
{
case 0x00:
messageID += ".MemoryRASModeDisabled";
break;
case 0x01:
messageID += ".MemoryRASModeEnabled";
break;
default:
return defaultMessageHook(ipmiRaw);
break;
}
// Get the message data from eventData2 and eventData3
// prior mode = eventData2 bits [3:0]
int priorMode = selData.eventData2 & 0x0F;
// selected mode = eventData3 bits [3:0]
int selectedMode = selData.eventData3 & 0x0F;
// Save the messageArgs
switch (priorMode)
{
case 0x00:
messageArgs.push_back("None");
break;
case 0x01:
messageArgs.push_back("Mirroring");
break;
case 0x02:
messageArgs.push_back("Lockstep");
break;
case 0x04:
messageArgs.push_back("Rank Sparing");
break;
default:
messageArgs.push_back(std::to_string(priorMode));
break;
}
switch (selectedMode)
{
case 0x00:
messageArgs.push_back("None");
break;
case 0x01:
messageArgs.push_back("Mirroring");
break;
case 0x02:
messageArgs.push_back("Lockstep");
break;
case 0x04:
messageArgs.push_back("Rank Sparing");
break;
default:
messageArgs.push_back(std::to_string(selectedMode));
break;
}
break;
}
default:
return defaultMessageHook(ipmiRaw);
break;
}
break;
case BIOSSensors::bootEvent:
switch (eventType)
{
case BIOSEventTypes::sensorSpecificOffset:
{
switch (selData.offset)
{
case 0x01:
messageID += ".BIOSBoot";
break;
default:
return defaultMessageHook(ipmiRaw);
break;
}
break;
}
default:
return defaultMessageHook(ipmiRaw);
break;
}
break;
default:
return defaultMessageHook(ipmiRaw);
break;
}
// Log the Redfish message to the journal with the appropriate metadata
std::string journalMsg = "BIOS POST IPMI event: " + ipmiRaw;
if (messageArgs.empty())
{
phosphor::logging::log<phosphor::logging::level::INFO>(
journalMsg.c_str(),
phosphor::logging::entry("REDFISH_MESSAGE_ID=%s",
messageID.c_str()));
}
else
{
std::string messageArgsString =
boost::algorithm::join(messageArgs, ",");
phosphor::logging::log<phosphor::logging::level::INFO>(
journalMsg.c_str(),
phosphor::logging::entry("REDFISH_MESSAGE_ID=%s",
messageID.c_str()),
phosphor::logging::entry("REDFISH_MESSAGE_ARGS=%s",
messageArgsString.c_str()));
}
return true;
}
// Record a BIOS SMI message as a Redfish message instead of a SEL record
static bool biosSMIMessageHook(const SELData& selData,
const std::string& ipmiRaw)
{
// This is a BIOS SMI message, so record it as a Redfish message instead
// of a SEL record
// Walk through the SEL request record to build the appropriate Redfish
// message
static constexpr std::string_view openBMCMessageRegistryVersion = "0.1";
std::string messageID =
"OpenBMC." + std::string(openBMCMessageRegistryVersion);
std::vector<std::string> messageArgs;
BIOSSMISensors sensor = static_cast<BIOSSMISensors>(selData.sensorNum);
BIOSEventTypes eventType = static_cast<BIOSEventTypes>(selData.eventType);
switch (sensor)
{
case BIOSSMISensors::mirroringRedundancyState:
switch (eventType)
{
case BIOSEventTypes::discreteRedundancyStates:
{
switch (selData.offset)
{
case 0x00:
messageID += ".MirroringRedundancyFull";
break;
case 0x02:
messageID += ".MirroringRedundancyDegraded";
break;
default:
return defaultMessageHook(ipmiRaw);
break;
}
// Get the message data from eventData2 and eventData3
// pair = eventData2 bits [7:4]
int pair = selData.eventData2 >> 4 & 0x0F;
// rank = eventData2 bits [1:0]
int rank = selData.eventData2 & 0x03;
// Socket ID = eventData3 bits [7:5]
int socket = selData.eventData3 >> 5 & 0x07;
// Channel = eventData3 bits [4:2]
int channel = selData.eventData3 >> 2 & 0x07;
char channelLetter[4] = {'A'};
channelLetter[0] += channel;
// DIMM = eventData3 bits [1:0]
int dimm = selData.eventData3 & 0x03;
// Save the messageArgs
messageArgs.push_back(std::to_string(socket + 1));
messageArgs.push_back(std::string(channelLetter));
messageArgs.push_back(std::to_string(dimm + 1));
messageArgs.push_back(std::to_string(pair));
messageArgs.push_back(std::to_string(rank));
break;
}
default:
return defaultMessageHook(ipmiRaw);
break;
}
break;
case BIOSSMISensors::memoryECCError:
switch (eventType)
{
case BIOSEventTypes::sensorSpecificOffset:
{
switch (selData.offset)
{
case 0x00:
messageID += ".MemoryECCCorrectable";
break;
case 0x01:
messageID += ".MemoryECCUncorrectable";
break;
default:
return defaultMessageHook(ipmiRaw);
break;
}
// Get the message data from eventData2 and eventData3
// dimm = eventData2 bits [7:4]
int dimm = selData.eventData2 >> 4 & 0x0F;
// rank = eventData2 bits [3:0]
int rank = selData.eventData2 & 0x0F;
// Socket ID = eventData3 bits [7:4]
int socket = selData.eventData3 >> 4 & 0x0F;
// Channel = eventData3 bits [3:0]
int channel = selData.eventData3 & 0x0F;
char channelLetter[4] = {'A'};
channelLetter[0] += channel;
// Save the messageArgs
messageArgs.push_back(std::to_string(socket + 1));
messageArgs.push_back(std::string(channelLetter));
messageArgs.push_back(std::to_string(dimm));
messageArgs.push_back(std::to_string(rank));
break;
}
default:
return defaultMessageHook(ipmiRaw);
break;
}
break;
case BIOSSMISensors::legacyPCIError:
switch (eventType)
{
case BIOSEventTypes::sensorSpecificOffset:
{
switch (selData.offset)
{
case 0x04:
messageID += ".LegacyPCIPERR";
break;
case 0x05:
messageID += ".LegacyPCISERR";
break;
default:
return defaultMessageHook(ipmiRaw);
break;
}
// Get the message data from eventData2 and eventData3
// Bus = eventData2 bits [7:0]
int bus = selData.eventData2;
// Device = eventData3 bits [7:3]
int device = selData.eventData3 >> 3 & 0x1F;
// Function = eventData3 bits [2:0]
int function = selData.eventData3 >> 0x07;
// Save the messageArgs
messageArgs.push_back(std::to_string(bus));
messageArgs.push_back(std::to_string(device));
messageArgs.push_back(std::to_string(function));
break;
}
default:
return defaultMessageHook(ipmiRaw);
break;
}
break;
case BIOSSMISensors::pcieFatalError:
switch (eventType)
{
case BIOSEventTypes::oemDiscrete0:
{
switch (selData.offset)
{
case 0x00:
messageID += ".PCIeFatalDataLinkLayerProtocol";
break;
case 0x01:
messageID += ".PCIeFatalSurpriseLinkDown";
break;
case 0x02:
messageID += ".PCIeFatalCompleterAbort";
break;
case 0x03:
messageID += ".PCIeFatalUnsupportedRequest";
break;
case 0x04:
messageID += ".PCIeFatalPoisonedTLP";
break;
case 0x05:
messageID += ".PCIeFatalFlowControlProtocol";
break;
case 0x06:
messageID += ".PCIeFatalCompletionTimeout";
break;
case 0x07:
messageID += ".PCIeFatalReceiverBufferOverflow";
break;
case 0x08:
messageID += ".PCIeFatalACSViolation";
break;
case 0x09:
messageID += ".PCIeFatalMalformedTLP";
break;
case 0x0a:
messageID += ".PCIeFatalECRCError";
break;
case 0x0b:
messageID +=
".PCIeFatalReceivedFatalMessageFromDownstream";
break;
case 0x0c:
messageID += ".PCIeFatalUnexpectedCompletion";
break;
case 0x0d:
messageID += ".PCIeFatalReceivedErrNonFatalMessage";
break;
case 0x0e:
messageID += ".PCIeFatalUncorrectableInternal";
break;
case 0x0f:
messageID += ".PCIeFatalMCBlockedTLP";
break;
default:
return defaultMessageHook(ipmiRaw);
break;
}
// Get the message data from eventData2 and eventData3
// Bus = eventData2 bits [7:0]
int bus = selData.eventData2;
// Device = eventData3 bits [7:3]
int device = selData.eventData3 >> 3 & 0x1F;
// Function = eventData3 bits [2:0]
int function = selData.eventData3 >> 0x07;
// Save the messageArgs
messageArgs.push_back(std::to_string(bus));
messageArgs.push_back(std::to_string(device));
messageArgs.push_back(std::to_string(function));
break;
}
default:
return defaultMessageHook(ipmiRaw);
break;
}
break;
case BIOSSMISensors::pcieCorrectableError:
switch (eventType)
{
case BIOSEventTypes::oemDiscrete1:
{
switch (selData.offset)
{
case 0x00:
messageID += ".PCIeCorrectableReceiverError";
break;
case 0x01:
messageID += ".PCIeCorrectableBadDLLP";
break;
case 0x02:
messageID += ".PCIeCorrectableBadTLP";
break;
case 0x03:
messageID += ".PCIeCorrectableReplayNumRollover";
break;
case 0x04:
messageID += ".PCIeCorrectableReplayTimerTimeout";
break;
case 0x05:
messageID += ".PCIeCorrectableAdvisoryNonFatal";
break;
case 0x06:
messageID += ".PCIeCorrectableLinkBWChanged";
break;
case 0x07:
messageID += ".PCIeCorrectableInternal";
break;
case 0x08:
messageID += ".PCIeCorrectableHeaderLogOverflow";
break;
case 0x0f:
messageID += ".PCIeCorrectableUnspecifiedAERError";
break;
default:
return defaultMessageHook(ipmiRaw);
break;
}
// Get the message data from eventData2 and eventData3
// Bus = eventData2 bits [7:0]
int bus = selData.eventData2;
// Device = eventData3 bits [7:3]
int device = selData.eventData3 >> 3 & 0x1F;
// Function = eventData3 bits [2:0]
int function = selData.eventData3 >> 0x07;
// Save the messageArgs
messageArgs.push_back(std::to_string(bus));
messageArgs.push_back(std::to_string(device));
messageArgs.push_back(std::to_string(function));
break;
}
default:
return defaultMessageHook(ipmiRaw);
break;
}
break;
case BIOSSMISensors::sparingRedundancyState:
switch (eventType)
{
case BIOSEventTypes::discreteRedundancyStates:
{
switch (selData.offset)
{
case 0x00:
messageID += ".SparingRedundancyFull";
break;
case 0x02:
messageID += ".SparingRedundancyDegraded";
break;
default:
return defaultMessageHook(ipmiRaw);
break;
}
// Get the message data from eventData2 and eventData3
// domain = eventData2 bits [7:4]
int domain = selData.eventData2 >> 4 & 0x0F;
char domainLetter[4] = {'A'};
domainLetter[0] += domain;
// rank = eventData2 bits [1:0]
int rank = selData.eventData2 & 0x03;
// Socket ID = eventData3 bits [7:5]
int socket = selData.eventData3 >> 5 & 0x07;
// Channel = eventData3 bits [4:2]
int channel = selData.eventData3 >> 2 & 0x07;
char channelLetter[4] = {'A'};
channelLetter[0] += channel;
// DIMM = eventData3 bits [1:0]
int dimm = selData.eventData3 & 0x03;
// Save the messageArgs
messageArgs.push_back(std::to_string(socket + 1));
messageArgs.push_back(std::string(channelLetter));
messageArgs.push_back(std::to_string(dimm + 1));
messageArgs.push_back(std::string(domainLetter));
messageArgs.push_back(std::to_string(rank));
break;
}
default:
return defaultMessageHook(ipmiRaw);
break;
}
break;
case BIOSSMISensors::memoryParityError:
switch (eventType)
{
case BIOSEventTypes::sensorSpecificOffset:
{
switch (selData.offset)
{
case 0x03:
{
// type = eventData2 bits [2:0]
int type = selData.eventData2 & 0x07;
switch (type)
{
case 0x00:
messageID += ".MemoryParityNotKnown";
break;
case 0x03:
messageID +=
".MemoryParityCommandAndAddress";
break;
default:
return defaultMessageHook(ipmiRaw);
break;
}
break;
}
default:
return defaultMessageHook(ipmiRaw);
break;
}
// Get the message data from eventData2 and eventData3
// channelValid = eventData2 bit [4]
int channelValid = selData.eventData2 >> 4 & 0x01;
// dimmValid = eventData2 bit [3]
int dimmValid = selData.eventData2 >> 3 & 0x01;
// Socket ID = eventData3 bits [7:5]
int socket = selData.eventData3 >> 5 & 0x07;
// Channel = eventData3 bits [4:2]
int channel = selData.eventData3 >> 2 & 0x07;
char channelLetter[4] = {'A'};
channelLetter[0] += channel;
// DIMM = eventData3 bits [1:0]
int dimm = selData.eventData3 & 0x03;
// Save the messageArgs
messageArgs.push_back(std::to_string(socket + 1));
messageArgs.push_back(std::string(channelLetter));
messageArgs.push_back(std::to_string(dimm + 1));
messageArgs.push_back(std::to_string(channelValid));
messageArgs.push_back(std::to_string(dimmValid));
break;
}
default:
return defaultMessageHook(ipmiRaw);
break;
}
break;
case BIOSSMISensors::pcieFatalError2:
switch (eventType)
{
case BIOSEventTypes::oemDiscrete6:
{
switch (selData.offset)
{
case 0x00:
messageID += ".PCIeFatalAtomicEgressBlocked";
break;
case 0x01:
messageID += ".PCIeFatalTLPPrefixBlocked";
break;
case 0x0f:
messageID +=
".PCIeFatalUnspecifiedNonAERFatalError";
break;
default:
return defaultMessageHook(ipmiRaw);
break;
}
// Get the message data from eventData2 and eventData3
// Bus = eventData2 bits [7:0]
int bus = selData.eventData2;
// Device = eventData3 bits [7:3]
int device = selData.eventData3 >> 3 & 0x1F;
// Function = eventData3 bits [2:0]
int function = selData.eventData3 >> 0x07;
// Save the messageArgs
messageArgs.push_back(std::to_string(bus));
messageArgs.push_back(std::to_string(device));
messageArgs.push_back(std::to_string(function));
break;
}
default:
return defaultMessageHook(ipmiRaw);
break;
}
break;
case BIOSSMISensors::biosRecovery:
switch (eventType)
{
case BIOSEventTypes::oemDiscrete0:
{
switch (selData.offset)
{
case 0x01:
messageID += ".BIOSRecoveryStart";
break;
default:
return defaultMessageHook(ipmiRaw);
break;
}
break;
}
case BIOSEventTypes::reservedF0:
{
switch (selData.offset)
{
case 0x01:
messageID += ".BIOSRecoveryComplete";
break;
default:
return defaultMessageHook(ipmiRaw);
break;
}
break;
}
default:
return defaultMessageHook(ipmiRaw);
break;
}
break;
case BIOSSMISensors::adddcError:
switch (eventType)
{
case BIOSEventTypes::reservedA0:
{
messageID += ".ADDDCCorrectable";
// Get the message data from eventData2 and eventData3
// dimm = eventData2 bits [7:4]
int dimm = selData.eventData2 >> 4 & 0x0F;
// rank = eventData2 bits [3:0]
int rank = selData.eventData2 & 0x0F;
// Socket ID = eventData3 bits [7:4]
int socket = selData.eventData3 >> 4 & 0x0F;
// Channel = eventData3 bits [3:0]
int channel = selData.eventData3 & 0x0F;
char channelLetter[4] = {'A'};
channelLetter[0] += channel;
// Save the messageArgs
messageArgs.push_back(std::to_string(socket + 1));
messageArgs.push_back(std::string(channelLetter));
messageArgs.push_back(std::to_string(dimm));
messageArgs.push_back(std::to_string(rank));
break;
}
default:
return defaultMessageHook(ipmiRaw);
break;
}
break;
default:
return defaultMessageHook(ipmiRaw);
break;
}
// Log the Redfish message to the journal with the appropriate metadata
std::string journalMsg = "BIOS SMI IPMI event: " + ipmiRaw;
std::string messageArgsString = boost::algorithm::join(messageArgs, ",");
phosphor::logging::log<phosphor::logging::level::INFO>(
journalMsg.c_str(),
phosphor::logging::entry("REDFISH_MESSAGE_ID=%s", messageID.c_str()),
phosphor::logging::entry("REDFISH_MESSAGE_ARGS=%s",
messageArgsString.c_str()));
return true;
}
static bool startRedfishHook(const SELData& selData, const std::string& ipmiRaw)
{
switch (selData.generatorID)
{
case 0x01: // Check if this message is from the BIOS Generator ID
// Let the BIOS hook handle this request
return biosMessageHook(selData, ipmiRaw);
break;
case 0x33: // Check if this message is from the BIOS SMI Generator ID
// Let the BIOS SMI hook handle this request
return biosSMIMessageHook(selData, ipmiRaw);
break;
}
// No hooks handled the request, so let it go to default
return defaultMessageHook(ipmiRaw);
}
} // namespace redfish_hooks
bool checkRedfishHooks(uint16_t recordID, uint8_t recordType,
uint32_t timestamp, uint16_t generatorID, uint8_t evmRev,
uint8_t sensorType, uint8_t sensorNum, uint8_t eventType,
uint8_t eventData1, uint8_t eventData2,
uint8_t eventData3)
{
// Save the raw IPMI string of the request
std::string ipmiRaw;
std::array selBytes = {static_cast<uint8_t>(recordID),
static_cast<uint8_t>(recordID >> 8),
recordType,
static_cast<uint8_t>(timestamp),
static_cast<uint8_t>(timestamp >> 8),
static_cast<uint8_t>(timestamp >> 16),
static_cast<uint8_t>(timestamp >> 24),
static_cast<uint8_t>(generatorID),
static_cast<uint8_t>(generatorID >> 8),
evmRev,
sensorType,
sensorNum,
eventType,
eventData1,
eventData2,
eventData3};
redfish_hooks::toHexStr(boost::beast::span<uint8_t>(selBytes), ipmiRaw);
// First check that this is a system event record type since that
// determines the definition of the rest of the data
if (recordType != ipmi::sel::systemEvent)
{
// OEM record type, so let it go to the SEL
return redfish_hooks::defaultMessageHook(ipmiRaw);
}
// Extract the SEL data for the hook
redfish_hooks::SELData selData = {.generatorID = generatorID,
.sensorNum = sensorNum,
.eventType = eventType,
.offset = eventData1 & 0x0F,
.eventData2 = eventData2,
.eventData3 = eventData3};
return redfish_hooks::startRedfishHook(selData, ipmiRaw);
}
bool checkRedfishHooks(uint8_t generatorID, uint8_t evmRev, uint8_t sensorType,
uint8_t sensorNum, uint8_t eventType, uint8_t eventData1,
uint8_t eventData2, uint8_t eventData3)
{
// Save the raw IPMI string of the selData
std::string ipmiRaw;
std::array selBytes = {generatorID, evmRev, sensorType, sensorNum,
eventType, eventData1, eventData2, eventData3};
redfish_hooks::toHexStr(boost::beast::span<uint8_t>(selBytes), ipmiRaw);
// Extract the SEL data for the hook
redfish_hooks::SELData selData = {.generatorID = generatorID,
.sensorNum = sensorNum,
.eventType = eventType,
.offset = eventData1 & 0x0F,
.eventData2 = eventData2,
.eventData3 = eventData3};
return redfish_hooks::startRedfishHook(selData, ipmiRaw);
}
} // namespace intel_oem::ipmi::sel