include/threshold_event_monitor.hpp - openbmc/phosphor-sel-logger - Gitiles

 /*
 // Copyright (c) 2018 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.
 */

 #pragma once
 #include <sel_logger.hpp>
 #include <sensorutils.hpp>

 #include <string_view>
 #include <variant>

 enum class thresholdEventOffsets : uint8_t
 {
     lowerNonCritGoingLow = 0x00,
     lowerCritGoingLow = 0x02,
     upperNonCritGoingHigh = 0x07,
     upperCritGoingHigh = 0x09,
 };

 static constexpr const uint8_t thresholdEventDataTriggerReadingByte2 = (1 << 6);
 static constexpr const uint8_t thresholdEventDataTriggerReadingByte3 = (1 << 4);

 static const std::string openBMCMessageRegistryVersion("0.1");

 inline static sdbusplus::bus::match_t startThresholdAssertMonitor(
     std::shared_ptr<sdbusplus::asio::connection> conn)
 {
     auto thresholdAssertMatcherCallback = [conn](sdbusplus::message_t& msg) {
         // This static set of std::pair<path, event> tracks asserted events to
         // avoid duplicate logs or deasserts logged without an assert
         static boost::container::flat_set<std::pair<std::string, std::string>>
             assertedEvents;
         std::vector<uint8_t> eventData(selEvtDataMaxSize,
                                        selEvtDataUnspecified);

         // Get the event type and assertion details from the message
         std::string sensorName;
         std::string thresholdInterface;
         std::string event;
         bool assert;
         double assertValue;
         try
         {
             msg.read(sensorName, thresholdInterface, event, assert,
                      assertValue);
         }
         catch (const sdbusplus::exception_t&)
         {
             std::cerr << "error getting assert signal data from "
                       << msg.get_path() << "\n";
             return;
         }

         // Check the asserted events to determine if we should log this event
         std::pair<std::string, std::string> pathAndEvent(
             std::string(msg.get_path()), event);
         if (assert)
         {
             // For asserts, add the event to the set and only log it if it's new
             if (assertedEvents.insert(pathAndEvent).second == false)
             {
                 // event is already in the set
                 return;
             }
         }
         else
         {
             // For deasserts, remove the event and only log the deassert if it
             // was asserted
             if (assertedEvents.erase(pathAndEvent) == 0)
             {
                 // asserted event was not in the set
                 return;
             }
         }

         // Set the IPMI threshold event type based on the event details from the
         // message
         if (event == "CriticalAlarmLow")
         {
             eventData[0] =
                 static_cast<uint8_t>(thresholdEventOffsets::lowerCritGoingLow);
         }
         else if (event == "WarningAlarmLow")
         {
             eventData[0] = static_cast<uint8_t>(
                 thresholdEventOffsets::lowerNonCritGoingLow);
         }
         else if (event == "WarningAlarmHigh")
         {
             eventData[0] = static_cast<uint8_t>(
                 thresholdEventOffsets::upperNonCritGoingHigh);
         }
         else if (event == "CriticalAlarmHigh")
         {
             eventData[0] =
                 static_cast<uint8_t>(thresholdEventOffsets::upperCritGoingHigh);
         }
         // Indicate that bytes 2 and 3 are threshold sensor trigger values
         eventData[0] |= thresholdEventDataTriggerReadingByte2 |
                         thresholdEventDataTriggerReadingByte3;

         // Get the sensor reading to put in the event data
         sdbusplus::message_t getSensorValue =
             conn->new_method_call(msg.get_sender(), msg.get_path(),
                                   "org.freedesktop.DBus.Properties", "GetAll");
         getSensorValue.append("xyz.openbmc_project.Sensor.Value");
         boost::container::flat_map<std::string, std::variant<double, int64_t>>
             sensorValue;
         try
         {
             sdbusplus::message_t getSensorValueResp =
                 conn->call(getSensorValue);
             getSensorValueResp.read(sensorValue);
         }
         catch (const sdbusplus::exception_t&)
         {
             std::cerr << "error getting sensor value from " << msg.get_path()
                       << "\n";
             return;
         }
         double max = 0;
         auto findMax = sensorValue.find("MaxValue");
         if (findMax != sensorValue.end())
         {
             max = std::visit(ipmi::VariantToDoubleVisitor(), findMax->second);
         }
         double min = 0;
         auto findMin = sensorValue.find("MinValue");
         if (findMin != sensorValue.end())
         {
             min = std::visit(ipmi::VariantToDoubleVisitor(), findMin->second);
         }

         try
         {
             eventData[1] = ipmi::getScaledIPMIValue(assertValue, max, min);
         }
         catch (const std::exception& e)
         {
             std::cerr << e.what();
             eventData[1] = selEvtDataUnspecified;
         }

         // Get the threshold value to put in the event data
         // Get the threshold parameter by removing the "Alarm" text from the
         // event string
         std::string alarm("Alarm");
         if (std::string::size_type pos = event.find(alarm);
             pos != std::string::npos)
         {
             event.erase(pos, alarm.length());
         }
         sdbusplus::message_t getThreshold =
             conn->new_method_call(msg.get_sender(), msg.get_path(),
                                   "org.freedesktop.DBus.Properties", "Get");
         getThreshold.append(thresholdInterface, event);
         std::variant<double, int64_t> thresholdValue;
         try
         {
             sdbusplus::message_t getThresholdResp = conn->call(getThreshold);
             getThresholdResp.read(thresholdValue);
         }
         catch (const sdbusplus::exception_t&)
         {
             std::cerr << "error getting sensor threshold from "
                       << msg.get_path() << "\n";
             return;
         }
         double thresholdVal =
             std::visit(ipmi::VariantToDoubleVisitor(), thresholdValue);

         double scale = 0;
         auto findScale = sensorValue.find("Scale");
         if (findScale != sensorValue.end())
         {
             scale =
                 std::visit(ipmi::VariantToDoubleVisitor(), findScale->second);
             thresholdVal *= std::pow(10, scale);
         }
         try
         {
             eventData[2] = ipmi::getScaledIPMIValue(thresholdVal, max, min);
         }
         catch (const std::exception& e)
         {
             std::cerr << e.what();
             eventData[2] = selEvtDataUnspecified;
         }

         std::string threshold;
         std::string direction;
         std::string redfishMessageID =
             "OpenBMC." + openBMCMessageRegistryVersion;
         enum EventType
         {
             eventNone,
             eventInfo,
             eventWarn,
             eventErr
         };
         [[maybe_unused]] EventType eventType = eventNone;
         if (event == "CriticalLow")
         {
             threshold = "critical low";
             if (assert)
             {
                 eventType = eventErr;
                 direction = "low";
                 redfishMessageID += ".SensorThresholdCriticalLowGoingLow";
             }
             else
             {
                 eventType = eventInfo;
                 direction = "high";
                 redfishMessageID += ".SensorThresholdCriticalLowGoingHigh";
             }
         }
         else if (event == "WarningLow")
         {
             threshold = "warning low";
             if (assert)
             {
                 eventType = eventWarn;
                 direction = "low";
                 redfishMessageID += ".SensorThresholdWarningLowGoingLow";
             }
             else
             {
                 eventType = eventInfo;
                 direction = "high";
                 redfishMessageID += ".SensorThresholdWarningLowGoingHigh";
             }
         }
         else if (event == "WarningHigh")
         {
             threshold = "warning high";
             if (assert)
             {
                 eventType = eventWarn;
                 direction = "high";
                 redfishMessageID += ".SensorThresholdWarningHighGoingHigh";
             }
             else
             {
                 eventType = eventInfo;
                 direction = "low";
                 redfishMessageID += ".SensorThresholdWarningHighGoingLow";
             }
         }
         else if (event == "CriticalHigh")
         {
             threshold = "critical high";
             if (assert)
             {
                 eventType = eventErr;
                 direction = "high";
                 redfishMessageID += ".SensorThresholdCriticalHighGoingHigh";
             }
             else
             {
                 eventType = eventInfo;
                 direction = "low";
                 redfishMessageID += ".SensorThresholdCriticalHighGoingLow";
             }
         }

         std::string journalMsg(
             std::string(sensorName) + " " + threshold + " threshold " +
             (assert ? "assert" : "deassert") +
             ". Reading=" + std::to_string(assertValue) +
             " Threshold=" + std::to_string(thresholdVal) + ".");

 #ifdef SEL_LOGGER_SEND_TO_LOGGING_SERVICE
         std::string LogLevel = "";
         switch (eventType)
         {
             case eventInfo:
             {
                 LogLevel =
                     "xyz.openbmc_project.Logging.Entry.Level.Informational";
                 break;
             }
             case eventWarn:
             {
                 LogLevel = "xyz.openbmc_project.Logging.Entry.Level.Warning";
                 break;
             }
             case eventErr:
             {
                 LogLevel = "xyz.openbmc_project.Logging.Entry.Level.Critical";
                 break;
             }
             default:
             {
                 LogLevel = "xyz.openbmc_project.Logging.Entry.Level.Debug";
                 break;
             }
         }
         if (eventType != eventNone)
         {
             sdbusplus::message_t AddToLog = conn->new_method_call(
                 "xyz.openbmc_project.Logging", "/xyz/openbmc_project/logging",
                 "xyz.openbmc_project.Logging.Create", "Create");
             AddToLog.append(journalMsg, LogLevel,
                             std::map<std::string, std::string>(
                                 {{"SENSOR_PATH", std::string(msg.get_path())},
                                  {"EVENT", threshold},
                                  {"DIRECTION", direction},
                                  {"THRESHOLD", std::to_string(thresholdVal)},
                                  {"READING", std::to_string(assertValue)}}));
             conn->call(AddToLog);
         }
 #else
         selAddSystemRecord(
             conn, journalMsg, std::string(msg.get_path()), eventData, assert,
             selBMCGenID, "REDFISH_MESSAGE_ID=%s", redfishMessageID.c_str(),
             "REDFISH_MESSAGE_ARGS=%.*s,%f,%f", sensorName.length(),
             sensorName.data(), assertValue, thresholdVal);
 #endif
     };
     sdbusplus::bus::match_t thresholdAssertMatcher(
         static_cast<sdbusplus::bus_t&>(*conn),
         "type='signal', member='ThresholdAsserted'",
         std::move(thresholdAssertMatcherCallback));
     return thresholdAssertMatcher;
 }
	/*
	// Copyright (c) 2018 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.
	*/

	#pragma once
	#include <sel_logger.hpp>
	#include <sensorutils.hpp>

	#include <string_view>
	#include <variant>

	enum class thresholdEventOffsets : uint8_t
	{
	lowerNonCritGoingLow = 0x00,
	lowerCritGoingLow = 0x02,
	upperNonCritGoingHigh = 0x07,
	upperCritGoingHigh = 0x09,
	};

	static constexpr const uint8_t thresholdEventDataTriggerReadingByte2 = (1 << 6);
	static constexpr const uint8_t thresholdEventDataTriggerReadingByte3 = (1 << 4);

	static const std::string openBMCMessageRegistryVersion("0.1");

	inline static sdbusplus::bus::match_t startThresholdAssertMonitor(
	std::shared_ptr<sdbusplus::asio::connection> conn)
	{
	auto thresholdAssertMatcherCallback = [conn](sdbusplus::message_t& msg) {
	// This static set of std::pair<path, event> tracks asserted events to
	// avoid duplicate logs or deasserts logged without an assert
	static boost::container::flat_set<std::pair<std::string, std::string>>
	assertedEvents;
	std::vector<uint8_t> eventData(selEvtDataMaxSize,
	selEvtDataUnspecified);

	// Get the event type and assertion details from the message
	std::string sensorName;
	std::string thresholdInterface;
	std::string event;
	bool assert;
	double assertValue;
	try
	{
	msg.read(sensorName, thresholdInterface, event, assert,
	assertValue);
	}
	catch (const sdbusplus::exception_t&)
	{
	std::cerr << "error getting assert signal data from "
	<< msg.get_path() << "\n";
	return;
	}

	// Check the asserted events to determine if we should log this event
	std::pair<std::string, std::string> pathAndEvent(
	std::string(msg.get_path()), event);
	if (assert)
	{
	// For asserts, add the event to the set and only log it if it's new
	if (assertedEvents.insert(pathAndEvent).second == false)
	{
	// event is already in the set
	return;
	}
	}
	else
	{
	// For deasserts, remove the event and only log the deassert if it
	// was asserted
	if (assertedEvents.erase(pathAndEvent) == 0)
	{
	// asserted event was not in the set
	return;
	}
	}

	// Set the IPMI threshold event type based on the event details from the
	// message
	if (event == "CriticalAlarmLow")
	{
	eventData[0] =
	static_cast<uint8_t>(thresholdEventOffsets::lowerCritGoingLow);
	}
	else if (event == "WarningAlarmLow")
	{
	eventData[0] = static_cast<uint8_t>(
	thresholdEventOffsets::lowerNonCritGoingLow);
	}
	else if (event == "WarningAlarmHigh")
	{
	eventData[0] = static_cast<uint8_t>(
	thresholdEventOffsets::upperNonCritGoingHigh);
	}
	else if (event == "CriticalAlarmHigh")
	{
	eventData[0] =
	static_cast<uint8_t>(thresholdEventOffsets::upperCritGoingHigh);
	}
	// Indicate that bytes 2 and 3 are threshold sensor trigger values
	eventData[0] \|= thresholdEventDataTriggerReadingByte2 \|
	thresholdEventDataTriggerReadingByte3;

	// Get the sensor reading to put in the event data
	sdbusplus::message_t getSensorValue =
	conn->new_method_call(msg.get_sender(), msg.get_path(),
	"org.freedesktop.DBus.Properties", "GetAll");
	getSensorValue.append("xyz.openbmc_project.Sensor.Value");
	boost::container::flat_map<std::string, std::variant<double, int64_t>>
	sensorValue;
	try
	{
	sdbusplus::message_t getSensorValueResp =
	conn->call(getSensorValue);
	getSensorValueResp.read(sensorValue);
	}
	catch (const sdbusplus::exception_t&)
	{
	std::cerr << "error getting sensor value from " << msg.get_path()
	<< "\n";
	return;
	}
	double max = 0;
	auto findMax = sensorValue.find("MaxValue");
	if (findMax != sensorValue.end())
	{
	max = std::visit(ipmi::VariantToDoubleVisitor(), findMax->second);
	}
	double min = 0;
	auto findMin = sensorValue.find("MinValue");
	if (findMin != sensorValue.end())
	{
	min = std::visit(ipmi::VariantToDoubleVisitor(), findMin->second);
	}

	try
	{
	eventData[1] = ipmi::getScaledIPMIValue(assertValue, max, min);
	}
	catch (const std::exception& e)
	{
	std::cerr << e.what();
	eventData[1] = selEvtDataUnspecified;
	}

	// Get the threshold value to put in the event data
	// Get the threshold parameter by removing the "Alarm" text from the
	// event string
	std::string alarm("Alarm");
	if (std::string::size_type pos = event.find(alarm);
	pos != std::string::npos)
	{
	event.erase(pos, alarm.length());
	}
	sdbusplus::message_t getThreshold =
	conn->new_method_call(msg.get_sender(), msg.get_path(),
	"org.freedesktop.DBus.Properties", "Get");
	getThreshold.append(thresholdInterface, event);
	std::variant<double, int64_t> thresholdValue;
	try
	{
	sdbusplus::message_t getThresholdResp = conn->call(getThreshold);
	getThresholdResp.read(thresholdValue);
	}
	catch (const sdbusplus::exception_t&)
	{
	std::cerr << "error getting sensor threshold from "
	<< msg.get_path() << "\n";
	return;
	}
	double thresholdVal =
	std::visit(ipmi::VariantToDoubleVisitor(), thresholdValue);

	double scale = 0;
	auto findScale = sensorValue.find("Scale");
	if (findScale != sensorValue.end())
	{
	scale =
	std::visit(ipmi::VariantToDoubleVisitor(), findScale->second);
	thresholdVal *= std::pow(10, scale);
	}
	try
	{
	eventData[2] = ipmi::getScaledIPMIValue(thresholdVal, max, min);
	}
	catch (const std::exception& e)
	{
	std::cerr << e.what();
	eventData[2] = selEvtDataUnspecified;
	}

	std::string threshold;
	std::string direction;
	std::string redfishMessageID =
	"OpenBMC." + openBMCMessageRegistryVersion;
	enum EventType
	{
	eventNone,
	eventInfo,
	eventWarn,
	eventErr
	};
	[[maybe_unused]] EventType eventType = eventNone;
	if (event == "CriticalLow")
	{
	threshold = "critical low";
	if (assert)
	{
	eventType = eventErr;
	direction = "low";
	redfishMessageID += ".SensorThresholdCriticalLowGoingLow";
	}
	else
	{
	eventType = eventInfo;
	direction = "high";
	redfishMessageID += ".SensorThresholdCriticalLowGoingHigh";
	}
	}
	else if (event == "WarningLow")
	{
	threshold = "warning low";
	if (assert)
	{
	eventType = eventWarn;
	direction = "low";
	redfishMessageID += ".SensorThresholdWarningLowGoingLow";
	}
	else
	{
	eventType = eventInfo;
	direction = "high";
	redfishMessageID += ".SensorThresholdWarningLowGoingHigh";
	}
	}
	else if (event == "WarningHigh")
	{
	threshold = "warning high";
	if (assert)
	{
	eventType = eventWarn;
	direction = "high";
	redfishMessageID += ".SensorThresholdWarningHighGoingHigh";
	}
	else
	{
	eventType = eventInfo;
	direction = "low";
	redfishMessageID += ".SensorThresholdWarningHighGoingLow";
	}
	}
	else if (event == "CriticalHigh")
	{
	threshold = "critical high";
	if (assert)
	{
	eventType = eventErr;
	direction = "high";
	redfishMessageID += ".SensorThresholdCriticalHighGoingHigh";
	}
	else
	{
	eventType = eventInfo;
	direction = "low";
	redfishMessageID += ".SensorThresholdCriticalHighGoingLow";
	}
	}

	std::string journalMsg(
	std::string(sensorName) + " " + threshold + " threshold " +
	(assert ? "assert" : "deassert") +
	". Reading=" + std::to_string(assertValue) +
	" Threshold=" + std::to_string(thresholdVal) + ".");

	#ifdef SEL_LOGGER_SEND_TO_LOGGING_SERVICE
	std::string LogLevel = "";
	switch (eventType)
	{
	case eventInfo:
	{
	LogLevel =
	"xyz.openbmc_project.Logging.Entry.Level.Informational";
	break;
	}
	case eventWarn:
	{
	LogLevel = "xyz.openbmc_project.Logging.Entry.Level.Warning";
	break;
	}
	case eventErr:
	{
	LogLevel = "xyz.openbmc_project.Logging.Entry.Level.Critical";
	break;
	}
	default:
	{
	LogLevel = "xyz.openbmc_project.Logging.Entry.Level.Debug";
	break;
	}
	}
	if (eventType != eventNone)
	{
	sdbusplus::message_t AddToLog = conn->new_method_call(
	"xyz.openbmc_project.Logging", "/xyz/openbmc_project/logging",
	"xyz.openbmc_project.Logging.Create", "Create");
	AddToLog.append(journalMsg, LogLevel,
	std::map<std::string, std::string>(
	{{"SENSOR_PATH", std::string(msg.get_path())},
	{"EVENT", threshold},
	{"DIRECTION", direction},
	{"THRESHOLD", std::to_string(thresholdVal)},
	{"READING", std::to_string(assertValue)}}));
	conn->call(AddToLog);
	}
	#else
	selAddSystemRecord(
	conn, journalMsg, std::string(msg.get_path()), eventData, assert,
	selBMCGenID, "REDFISH_MESSAGE_ID=%s", redfishMessageID.c_str(),
	"REDFISH_MESSAGE_ARGS=%.*s,%f,%f", sensorName.length(),
	sensorName.data(), assertValue, thresholdVal);
	#endif
	};
	sdbusplus::bus::match_t thresholdAssertMatcher(
	static_cast<sdbusplus::bus_t&>(*conn),
	"type='signal', member='ThresholdAsserted'",
	std::move(thresholdAssertMatcherCallback));
	return thresholdAssertMatcher;
	}