blob: ad563fdc02ddb09d4ffb026f5e17a65ef9f8ac0b [file] [log] [blame]
#include "numeric_sensor.hpp"
#include "libpldm/platform.h"
#include "common/utils.hpp"
#include "requester/handler.hpp"
#include <limits>
#include <regex>
PHOSPHOR_LOG2_USING;
namespace pldm
{
namespace platform_mc
{
NumericSensor::NumericSensor(const pldm_tid_t tid, const bool sensorDisabled,
std::shared_ptr<pldm_numeric_sensor_value_pdr> pdr,
std::string& sensorName,
std::string& associationPath) :
tid(tid), sensorName(sensorName), isPriority(false)
{
if (!pdr)
{
throw sdbusplus::xyz::openbmc_project::Common::Error::InvalidArgument();
}
sensorId = pdr->sensor_id;
std::string path;
SensorUnit sensorUnit = SensorUnit::DegreesC;
switch (pdr->base_unit)
{
case PLDM_SENSOR_UNIT_DEGRESS_C:
sensorNameSpace = "/xyz/openbmc_project/sensors/temperature/";
sensorUnit = SensorUnit::DegreesC;
break;
case PLDM_SENSOR_UNIT_VOLTS:
sensorNameSpace = "/xyz/openbmc_project/sensors/voltage/";
sensorUnit = SensorUnit::Volts;
break;
case PLDM_SENSOR_UNIT_AMPS:
sensorNameSpace = "/xyz/openbmc_project/sensors/current/";
sensorUnit = SensorUnit::Amperes;
break;
case PLDM_SENSOR_UNIT_RPM:
sensorNameSpace = "/xyz/openbmc_project/sensors/fan_pwm/";
sensorUnit = SensorUnit::RPMS;
break;
case PLDM_SENSOR_UNIT_WATTS:
sensorNameSpace = "/xyz/openbmc_project/sensors/power/";
sensorUnit = SensorUnit::Watts;
break;
case PLDM_SENSOR_UNIT_JOULES:
sensorNameSpace = "/xyz/openbmc_project/sensors/energy/";
sensorUnit = SensorUnit::Joules;
break;
case PLDM_SENSOR_UNIT_PERCENTAGE:
sensorNameSpace = "/xyz/openbmc_project/sensors/utilization/";
sensorUnit = SensorUnit::Percent;
break;
default:
lg2::error("Sensor {NAME} has Invalid baseUnit {UNIT}.", "NAME",
sensorName, "UNIT", pdr->base_unit);
throw sdbusplus::xyz::openbmc_project::Common::Error::
InvalidArgument();
break;
}
path = sensorNameSpace + sensorName;
try
{
auto service = pldm::utils::DBusHandler().getService(
path.c_str(), "xyz.openbmc_project.Sensor.Value");
if (!service.empty())
{
throw sdbusplus::xyz::openbmc_project::Common::Error::
TooManyResources();
}
}
catch (const std::exception&)
{
/* The sensor object path is not created */
}
auto& bus = pldm::utils::DBusHandler::getBus();
try
{
associationDefinitionsIntf =
std::make_unique<AssociationDefinitionsInft>(bus, path.c_str());
}
catch (const sdbusplus::exception_t& e)
{
lg2::error(
"Failed to create association interface for numeric sensor {PATH} error - {ERROR}",
"PATH", path, "ERROR", e);
throw sdbusplus::xyz::openbmc_project::Common::Error::InvalidArgument();
}
associationDefinitionsIntf->associations(
{{"chassis", "all_sensors", associationPath}});
double maxValue = std::numeric_limits<double>::quiet_NaN();
double minValue = std::numeric_limits<double>::quiet_NaN();
switch (pdr->sensor_data_size)
{
case PLDM_SENSOR_DATA_SIZE_UINT8:
maxValue = pdr->max_readable.value_u8;
minValue = pdr->min_readable.value_u8;
hysteresis = pdr->hysteresis.value_u8;
break;
case PLDM_SENSOR_DATA_SIZE_SINT8:
maxValue = pdr->max_readable.value_s8;
minValue = pdr->min_readable.value_s8;
hysteresis = pdr->hysteresis.value_s8;
break;
case PLDM_SENSOR_DATA_SIZE_UINT16:
maxValue = pdr->max_readable.value_u16;
minValue = pdr->min_readable.value_u16;
hysteresis = pdr->hysteresis.value_u16;
break;
case PLDM_SENSOR_DATA_SIZE_SINT16:
maxValue = pdr->max_readable.value_s16;
minValue = pdr->min_readable.value_s16;
hysteresis = pdr->hysteresis.value_s16;
break;
case PLDM_SENSOR_DATA_SIZE_UINT32:
maxValue = pdr->max_readable.value_u32;
minValue = pdr->min_readable.value_u32;
hysteresis = pdr->hysteresis.value_u32;
break;
case PLDM_SENSOR_DATA_SIZE_SINT32:
maxValue = pdr->max_readable.value_s32;
minValue = pdr->min_readable.value_s32;
hysteresis = pdr->hysteresis.value_s32;
break;
}
bool hasCriticalThresholds = false;
bool hasWarningThresholds = false;
double criticalHigh = std::numeric_limits<double>::quiet_NaN();
double criticalLow = std::numeric_limits<double>::quiet_NaN();
double warningHigh = std::numeric_limits<double>::quiet_NaN();
double warningLow = std::numeric_limits<double>::quiet_NaN();
if (pdr->supported_thresholds.bits.bit0)
{
hasWarningThresholds = true;
switch (pdr->range_field_format)
{
case PLDM_RANGE_FIELD_FORMAT_UINT8:
warningHigh = pdr->warning_high.value_u8;
break;
case PLDM_RANGE_FIELD_FORMAT_SINT8:
warningHigh = pdr->warning_high.value_s8;
break;
case PLDM_RANGE_FIELD_FORMAT_UINT16:
warningHigh = pdr->warning_high.value_u16;
break;
case PLDM_RANGE_FIELD_FORMAT_SINT16:
warningHigh = pdr->warning_high.value_s16;
break;
case PLDM_RANGE_FIELD_FORMAT_UINT32:
warningHigh = pdr->warning_high.value_u32;
break;
case PLDM_RANGE_FIELD_FORMAT_SINT32:
warningHigh = pdr->warning_high.value_s32;
break;
case PLDM_RANGE_FIELD_FORMAT_REAL32:
warningHigh = pdr->warning_high.value_f32;
break;
}
}
if (pdr->supported_thresholds.bits.bit3)
{
hasWarningThresholds = true;
switch (pdr->range_field_format)
{
case PLDM_RANGE_FIELD_FORMAT_UINT8:
warningLow = pdr->warning_low.value_u8;
break;
case PLDM_RANGE_FIELD_FORMAT_SINT8:
warningLow = pdr->warning_low.value_s8;
break;
case PLDM_RANGE_FIELD_FORMAT_UINT16:
warningLow = pdr->warning_low.value_u16;
break;
case PLDM_RANGE_FIELD_FORMAT_SINT16:
warningLow = pdr->warning_low.value_s16;
break;
case PLDM_RANGE_FIELD_FORMAT_UINT32:
warningLow = pdr->warning_low.value_u32;
break;
case PLDM_RANGE_FIELD_FORMAT_SINT32:
warningLow = pdr->warning_low.value_s32;
break;
case PLDM_RANGE_FIELD_FORMAT_REAL32:
warningLow = pdr->warning_low.value_f32;
break;
}
}
if (pdr->supported_thresholds.bits.bit1)
{
hasCriticalThresholds = true;
switch (pdr->range_field_format)
{
case PLDM_RANGE_FIELD_FORMAT_UINT8:
criticalHigh = pdr->critical_high.value_u8;
break;
case PLDM_RANGE_FIELD_FORMAT_SINT8:
criticalHigh = pdr->critical_high.value_s8;
break;
case PLDM_RANGE_FIELD_FORMAT_UINT16:
criticalHigh = pdr->critical_high.value_u16;
break;
case PLDM_RANGE_FIELD_FORMAT_SINT16:
criticalHigh = pdr->critical_high.value_s16;
break;
case PLDM_RANGE_FIELD_FORMAT_UINT32:
criticalHigh = pdr->critical_high.value_u32;
break;
case PLDM_RANGE_FIELD_FORMAT_SINT32:
criticalHigh = pdr->critical_high.value_s32;
break;
case PLDM_RANGE_FIELD_FORMAT_REAL32:
criticalHigh = pdr->critical_high.value_f32;
break;
}
}
if (pdr->supported_thresholds.bits.bit4)
{
hasCriticalThresholds = true;
switch (pdr->range_field_format)
{
case PLDM_RANGE_FIELD_FORMAT_UINT8:
criticalLow = pdr->critical_low.value_u8;
break;
case PLDM_RANGE_FIELD_FORMAT_SINT8:
criticalLow = pdr->critical_low.value_s8;
break;
case PLDM_RANGE_FIELD_FORMAT_UINT16:
criticalLow = pdr->critical_low.value_u16;
break;
case PLDM_RANGE_FIELD_FORMAT_SINT16:
criticalLow = pdr->critical_low.value_s16;
break;
case PLDM_RANGE_FIELD_FORMAT_UINT32:
criticalLow = pdr->critical_low.value_u32;
break;
case PLDM_RANGE_FIELD_FORMAT_SINT32:
criticalLow = pdr->critical_low.value_s32;
break;
case PLDM_RANGE_FIELD_FORMAT_REAL32:
criticalLow = pdr->critical_low.value_f32;
break;
}
}
resolution = pdr->resolution;
offset = pdr->offset;
baseUnitModifier = pdr->unit_modifier;
/**
* DEFAULT_SENSOR_UPDATER_INTERVAL is in milliseconds
* updateTime is in microseconds
*/
updateTime = static_cast<uint64_t>(DEFAULT_SENSOR_UPDATER_INTERVAL * 1000);
if (!std::isnan(pdr->update_interval))
{
updateTime = pdr->update_interval * 1000000;
}
try
{
valueIntf = std::make_unique<ValueIntf>(bus, path.c_str());
}
catch (const sdbusplus::exception_t& e)
{
lg2::error(
"Failed to create Value interface for numeric sensor {PATH} error - {ERROR}",
"PATH", path, "ERROR", e);
throw sdbusplus::xyz::openbmc_project::Common::Error::InvalidArgument();
}
valueIntf->maxValue(unitModifier(conversionFormula(maxValue)));
valueIntf->minValue(unitModifier(conversionFormula(minValue)));
hysteresis = unitModifier(conversionFormula(hysteresis));
valueIntf->unit(sensorUnit);
try
{
availabilityIntf =
std::make_unique<AvailabilityIntf>(bus, path.c_str());
}
catch (const sdbusplus::exception_t& e)
{
lg2::error(
"Failed to create Availability interface for numeric sensor {PATH} error - {ERROR}",
"PATH", path, "ERROR", e);
throw sdbusplus::xyz::openbmc_project::Common::Error::InvalidArgument();
}
availabilityIntf->available(true);
try
{
operationalStatusIntf =
std::make_unique<OperationalStatusIntf>(bus, path.c_str());
}
catch (const sdbusplus::exception_t& e)
{
lg2::error(
"Failed to create Operation status interface for numeric sensor {PATH} error - {ERROR}",
"PATH", path, "ERROR", e);
throw sdbusplus::xyz::openbmc_project::Common::Error::InvalidArgument();
}
operationalStatusIntf->functional(!sensorDisabled);
if (hasWarningThresholds)
{
try
{
thresholdWarningIntf =
std::make_unique<ThresholdWarningIntf>(bus, path.c_str());
}
catch (const sdbusplus::exception_t& e)
{
lg2::error(
"Failed to create Threshold warning interface for numeric sensor {PATH} error - {ERROR}",
"PATH", path, "ERROR", e);
throw sdbusplus::xyz::openbmc_project::Common::Error::
InvalidArgument();
}
thresholdWarningIntf->warningHigh(unitModifier(warningHigh));
thresholdWarningIntf->warningLow(unitModifier(warningLow));
}
if (hasCriticalThresholds)
{
try
{
thresholdCriticalIntf =
std::make_unique<ThresholdCriticalIntf>(bus, path.c_str());
}
catch (const sdbusplus::exception_t& e)
{
lg2::error(
"Failed to create Threshold critical interface for numeric sensor {PATH} error - {ERROR}",
"PATH", path, "ERROR", e);
throw sdbusplus::xyz::openbmc_project::Common::Error::
InvalidArgument();
}
thresholdCriticalIntf->criticalHigh(unitModifier(criticalHigh));
thresholdCriticalIntf->criticalLow(unitModifier(criticalLow));
}
}
NumericSensor::NumericSensor(
const pldm_tid_t tid, const bool sensorDisabled,
std::shared_ptr<pldm_compact_numeric_sensor_pdr> pdr,
std::string& sensorName, std::string& associationPath) :
tid(tid), sensorName(sensorName), isPriority(false)
{
if (!pdr)
{
throw sdbusplus::xyz::openbmc_project::Common::Error::InvalidArgument();
}
sensorId = pdr->sensor_id;
std::string path;
SensorUnit sensorUnit = SensorUnit::DegreesC;
switch (pdr->base_unit)
{
case PLDM_SENSOR_UNIT_DEGRESS_C:
sensorNameSpace = "/xyz/openbmc_project/sensors/temperature/";
sensorUnit = SensorUnit::DegreesC;
break;
case PLDM_SENSOR_UNIT_VOLTS:
sensorNameSpace = "/xyz/openbmc_project/sensors/voltage/";
sensorUnit = SensorUnit::Volts;
break;
case PLDM_SENSOR_UNIT_AMPS:
sensorNameSpace = "/xyz/openbmc_project/sensors/current/";
sensorUnit = SensorUnit::Amperes;
break;
case PLDM_SENSOR_UNIT_RPM:
sensorNameSpace = "/xyz/openbmc_project/sensors/fan_pwm/";
sensorUnit = SensorUnit::RPMS;
break;
case PLDM_SENSOR_UNIT_WATTS:
sensorNameSpace = "/xyz/openbmc_project/sensors/power/";
sensorUnit = SensorUnit::Watts;
break;
case PLDM_SENSOR_UNIT_JOULES:
sensorNameSpace = "/xyz/openbmc_project/sensors/energy/";
sensorUnit = SensorUnit::Joules;
break;
case PLDM_SENSOR_UNIT_PERCENTAGE:
sensorNameSpace = "/xyz/openbmc_project/sensors/utilization/";
sensorUnit = SensorUnit::Percent;
break;
default:
lg2::error("Sensor {NAME} has Invalid baseUnit {UNIT}.", "NAME",
sensorName, "UNIT", pdr->base_unit);
throw sdbusplus::xyz::openbmc_project::Common::Error::
InvalidArgument();
break;
}
path = sensorNameSpace + sensorName;
try
{
auto service = pldm::utils::DBusHandler().getService(
path.c_str(), "xyz.openbmc_project.Sensor.Value");
if (!service.empty())
{
throw sdbusplus::xyz::openbmc_project::Common::Error::
TooManyResources();
}
}
catch (const std::exception&)
{
/* The sensor object path is not created */
}
auto& bus = pldm::utils::DBusHandler::getBus();
try
{
associationDefinitionsIntf =
std::make_unique<AssociationDefinitionsInft>(bus, path.c_str());
}
catch (const sdbusplus::exception_t& e)
{
lg2::error(
"Failed to create Association interface for compact numeric sensor {PATH} error - {ERROR}",
"PATH", path, "ERROR", e);
throw sdbusplus::xyz::openbmc_project::Common::Error::InvalidArgument();
}
associationDefinitionsIntf->associations(
{{"chassis", "all_sensors", associationPath.c_str()}});
double maxValue = std::numeric_limits<double>::quiet_NaN();
double minValue = std::numeric_limits<double>::quiet_NaN();
bool hasWarningThresholds = false;
bool hasCriticalThresholds = false;
double criticalHigh = std::numeric_limits<double>::quiet_NaN();
double criticalLow = std::numeric_limits<double>::quiet_NaN();
double warningHigh = std::numeric_limits<double>::quiet_NaN();
double warningLow = std::numeric_limits<double>::quiet_NaN();
if (pdr->range_field_support.bits.bit0)
{
hasWarningThresholds = true;
warningHigh = pdr->warning_high;
}
if (pdr->range_field_support.bits.bit1)
{
hasWarningThresholds = true;
warningLow = pdr->warning_low;
}
if (pdr->range_field_support.bits.bit2)
{
hasCriticalThresholds = true;
criticalHigh = pdr->critical_high;
}
if (pdr->range_field_support.bits.bit3)
{
hasCriticalThresholds = true;
criticalLow = pdr->critical_low;
}
resolution = std::numeric_limits<double>::quiet_NaN();
offset = std::numeric_limits<double>::quiet_NaN();
baseUnitModifier = pdr->unit_modifier;
/**
* DEFAULT_SENSOR_UPDATER_INTERVAL is in milliseconds
* updateTime is in microseconds
*/
updateTime = static_cast<uint64_t>(DEFAULT_SENSOR_UPDATER_INTERVAL * 1000);
try
{
valueIntf = std::make_unique<ValueIntf>(bus, path.c_str());
}
catch (const sdbusplus::exception_t& e)
{
lg2::error(
"Failed to create Value interface for compact numeric sensor {PATH} error - {ERROR}",
"PATH", path, "ERROR", e);
throw sdbusplus::xyz::openbmc_project::Common::Error::InvalidArgument();
}
valueIntf->maxValue(unitModifier(conversionFormula(maxValue)));
valueIntf->minValue(unitModifier(conversionFormula(minValue)));
hysteresis = unitModifier(conversionFormula(hysteresis));
valueIntf->unit(sensorUnit);
try
{
availabilityIntf =
std::make_unique<AvailabilityIntf>(bus, path.c_str());
}
catch (const sdbusplus::exception_t& e)
{
lg2::error(
"Failed to create Availability interface for compact numeric sensor {PATH} error - {ERROR}",
"PATH", path, "ERROR", e);
throw sdbusplus::xyz::openbmc_project::Common::Error::InvalidArgument();
}
availabilityIntf->available(true);
try
{
operationalStatusIntf =
std::make_unique<OperationalStatusIntf>(bus, path.c_str());
}
catch (const sdbusplus::exception_t& e)
{
lg2::error(
"Failed to create Operational status interface for compact numeric sensor {PATH} error - {ERROR}",
"PATH", path, "ERROR", e);
throw sdbusplus::xyz::openbmc_project::Common::Error::InvalidArgument();
}
operationalStatusIntf->functional(!sensorDisabled);
if (hasWarningThresholds)
{
try
{
thresholdWarningIntf =
std::make_unique<ThresholdWarningIntf>(bus, path.c_str());
}
catch (const sdbusplus::exception_t& e)
{
lg2::error(
"Failed to create Warning threshold interface for compact numeric sensor {PATH} error - {ERROR}",
"PATH", path, "ERROR", e);
throw sdbusplus::xyz::openbmc_project::Common::Error::
InvalidArgument();
}
thresholdWarningIntf->warningHigh(unitModifier(warningHigh));
thresholdWarningIntf->warningLow(unitModifier(warningLow));
}
if (hasCriticalThresholds)
{
try
{
thresholdCriticalIntf =
std::make_unique<ThresholdCriticalIntf>(bus, path.c_str());
}
catch (const sdbusplus::exception_t& e)
{
lg2::error(
"Failed to create Critical threshold interface for compact numeric sensor {PATH} error - {ERROR}",
"PATH", path, "ERROR", e);
throw sdbusplus::xyz::openbmc_project::Common::Error::
InvalidArgument();
}
thresholdCriticalIntf->criticalHigh(unitModifier(criticalHigh));
thresholdCriticalIntf->criticalLow(unitModifier(criticalLow));
}
}
double NumericSensor::conversionFormula(double value)
{
double convertedValue = value;
convertedValue *= std::isnan(resolution) ? 1 : resolution;
convertedValue += std::isnan(offset) ? 0 : offset;
return convertedValue;
}
double NumericSensor::unitModifier(double value)
{
return std::isnan(value) ? value : value * std::pow(10, baseUnitModifier);
}
} // namespace platform_mc
} // namespace pldm