monitor/tach_sensor.cpp - openbmc/phosphor-fan-presence - Gitiles

 /**
  * Copyright © 2017 IBM 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 "tach_sensor.hpp"

 #include "fan.hpp"
 #include "sdbusplus.hpp"
 #include "utility.hpp"

 #include <fmt/format.h>

 #include <phosphor-logging/elog.hpp>
 #include <phosphor-logging/log.hpp>

 #include <experimental/filesystem>
 #include <functional>
 #include <utility>

 namespace phosphor
 {
 namespace fan
 {
 namespace monitor
 {

 constexpr auto FAN_SENSOR_VALUE_INTF = "xyz.openbmc_project.Sensor.Value";
 constexpr auto FAN_TARGET_PROPERTY = "Target";
 constexpr auto FAN_VALUE_PROPERTY = "Value";

 using namespace std::experimental::filesystem;
 using InternalFailure =
     sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;

 /**
  * @brief Helper function to read a property
  *
  * @param[in] interface - the interface the property is on
  * @param[in] propertName - the name of the property
  * @param[in] path - the dbus path
  * @param[in] bus - the dbus object
  * @param[out] value - filled in with the property value
  */
 template <typename T>
 static void
     readProperty(const std::string& interface, const std::string& propertyName,
                  const std::string& path, sdbusplus::bus::bus& bus, T& value)
 {
     try
     {
         value =
             util::SDBusPlus::getProperty<T>(bus, path, interface, propertyName);
     }
     catch (std::exception& e)
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
     }
 }

 TachSensor::TachSensor(Mode mode, sdbusplus::bus::bus& bus, Fan& fan,
                        const std::string& id, bool hasTarget, size_t funcDelay,
                        const std::string& interface, double factor,
                        int64_t offset, size_t method, size_t threshold,
                        size_t timeout, const std::optional<size_t>& errorDelay,
                        const sdeventplus::Event& event) :
     _bus(bus),
     _fan(fan), _name(FAN_SENSOR_PATH + id), _invName(path(fan.getName()) / id),
     _hasTarget(hasTarget), _funcDelay(funcDelay), _interface(interface),
     _factor(factor), _offset(offset), _method(method), _threshold(threshold),
     _timeout(timeout), _timerMode(TimerMode::func),
     _timer(event, std::bind(&Fan::updateState, &fan, std::ref(*this))),
     _errorDelay(errorDelay)
 {
     // Start from a known state of functional
     setFunctional(true);

     // Load in current Target and Input values when entering monitor mode
 #ifndef MONITOR_USE_JSON
     if (mode != Mode::init)
     {
 #endif
         try
         {
             // Use getProperty directly to allow a missing sensor object
             // to abort construction.
             _tachInput = util::SDBusPlus::getProperty<decltype(_tachInput)>(
                 _bus, _name, FAN_SENSOR_VALUE_INTF, FAN_VALUE_PROPERTY);
         }
         catch (std::exception& e)
         {
             log<level::ERR>(
                 fmt::format("Failed to retrieve tach sensor {}", _name)
                     .c_str());
             // Mark tach sensor as nonfunctional
             setFunctional(false);
             throw InvalidSensorError();
         }

         if (_hasTarget)
         {
             readProperty(_interface, FAN_TARGET_PROPERTY, _name, _bus,
                          _tachTarget);
         }

         auto match = getMatchString(FAN_SENSOR_VALUE_INTF);

         tachSignal = std::make_unique<sdbusplus::server::match::match>(
             _bus, match.c_str(),
             [this](auto& msg) { this->handleTachChange(msg); });

         if (_hasTarget)
         {
             match = getMatchString(_interface);

             targetSignal = std::make_unique<sdbusplus::server::match::match>(
                 _bus, match.c_str(),
                 [this](auto& msg) { this->handleTargetChange(msg); });
         }

         if (_errorDelay)
         {
             _errorTimer = std::make_unique<
                 sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic>>(
                 event, std::bind(&Fan::sensorErrorTimerExpired, &fan,
                                  std::ref(*this)));
         }
 #ifndef MONITOR_USE_JSON
     }
 #endif
 }

 std::string TachSensor::getMatchString(const std::string& interface)
 {
     return sdbusplus::bus::match::rules::propertiesChanged(_name, interface);
 }

 uint64_t TachSensor::getTarget() const
 {
     if (!_hasTarget)
     {
         return _fan.findTargetSpeed();
     }
     return _tachTarget;
 }

 std::pair<uint64_t, uint64_t> TachSensor::getRange(const size_t deviation) const
 {
     // Determine min/max range applying the deviation
     uint64_t min = getTarget() * (100 - deviation) / 100;
     uint64_t max = getTarget() * (100 + deviation) / 100;

     // Adjust the min/max range by applying the factor & offset
     min = min * _factor + _offset;
     max = max * _factor + _offset;

     return std::make_pair(min, max);
 }

 void TachSensor::processState()
 {
     _fan.process(*this);
 }

 void TachSensor::resetMethod()
 {
     switch (_method)
     {
         case MethodMode::timebased:
             if (timerRunning())
             {
                 stopTimer();
             }
             break;
         case MethodMode::count:
             if (_functional)
             {
                 _counter = 0;
             }
             else
             {
                 _counter = _threshold;
             }
             break;
     }
 }

 void TachSensor::setFunctional(bool functional)
 {
     _functional = functional;
     updateInventory(_functional);

     if (!_errorTimer)
     {
         return;
     }

     if (!_functional)
     {
         if (_fan.present())
         {
             _errorTimer->restartOnce(std::chrono::seconds(*_errorDelay));
         }
     }
     else if (_errorTimer->isEnabled())
     {
         _errorTimer->setEnabled(false);
     }
 }

 void TachSensor::handleTargetChange(sdbusplus::message::message& msg)
 {
     readPropertyFromMessage(msg, _interface, FAN_TARGET_PROPERTY, _tachTarget);

     // Check all tach sensors on the fan against the target
     _fan.tachChanged();
 }

 void TachSensor::handleTachChange(sdbusplus::message::message& msg)
 {
     readPropertyFromMessage(msg, FAN_SENSOR_VALUE_INTF, FAN_VALUE_PROPERTY,
                             _tachInput);

     // Check just this sensor against the target
     _fan.tachChanged(*this);
 }

 void TachSensor::startTimer(TimerMode mode)
 {
     using namespace std::chrono;

     if (!timerRunning() || mode != _timerMode)
     {
         log<level::INFO>(
             fmt::format("Start timer({}) on tach sensor {}. [delay = {}s]",
                         mode, _name,
                         duration_cast<seconds>(getDelay(mode)).count())
                 .c_str());
         _timer.restartOnce(getDelay(mode));
         _timerMode = mode;
     }
 }

 std::chrono::microseconds TachSensor::getDelay(TimerMode mode)
 {
     using namespace std::chrono;

     switch (mode)
     {
         case TimerMode::nonfunc:
             return duration_cast<microseconds>(seconds(_timeout));
         case TimerMode::func:
             return duration_cast<microseconds>(seconds(_funcDelay));
         default:
             // Log an internal error for undefined timer mode
             log<level::ERR>("Undefined timer mode",
                             entry("TIMER_MODE=%u", mode));
             elog<InternalFailure>();
             return duration_cast<microseconds>(seconds(0));
     }
 }

 void TachSensor::setCounter(bool count)
 {
     if (count)
     {
         if (_counter < _threshold)
         {
             ++_counter;
         }
     }
     else
     {
         if (_counter > 0)
         {
             --_counter;
         }
     }
 }

 void TachSensor::updateInventory(bool functional)
 {
     auto objectMap =
         util::getObjMap<bool>(_invName, util::OPERATIONAL_STATUS_INTF,
                               util::FUNCTIONAL_PROPERTY, functional);
     auto response = util::SDBusPlus::lookupAndCallMethod(
         _bus, util::INVENTORY_PATH, util::INVENTORY_INTF, "Notify", objectMap);
     if (response.is_method_error())
     {
         log<level::ERR>("Error in notify update of tach sensor inventory");
     }
 }

 } // namespace monitor
 } // namespace fan
 } // namespace phosphor
	/**
	* Copyright © 2017 IBM 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 "tach_sensor.hpp"

	#include "fan.hpp"
	#include "sdbusplus.hpp"
	#include "utility.hpp"

	#include <fmt/format.h>

	#include <phosphor-logging/elog.hpp>
	#include <phosphor-logging/log.hpp>

	#include <experimental/filesystem>
	#include <functional>
	#include <utility>

	namespace phosphor
	{
	namespace fan
	{
	namespace monitor
	{

	constexpr auto FAN_SENSOR_VALUE_INTF = "xyz.openbmc_project.Sensor.Value";
	constexpr auto FAN_TARGET_PROPERTY = "Target";
	constexpr auto FAN_VALUE_PROPERTY = "Value";

	using namespace std::experimental::filesystem;
	using InternalFailure =
	sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;

	/**
	* @brief Helper function to read a property
	*
	* @param[in] interface - the interface the property is on
	* @param[in] propertName - the name of the property
	* @param[in] path - the dbus path
	* @param[in] bus - the dbus object
	* @param[out] value - filled in with the property value
	*/
	template <typename T>
	static void
	readProperty(const std::string& interface, const std::string& propertyName,
	const std::string& path, sdbusplus::bus::bus& bus, T& value)
	{
	try
	{
	value =
	util::SDBusPlus::getProperty<T>(bus, path, interface, propertyName);
	}
	catch (std::exception& e)
	{
	phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
	}
	}

	TachSensor::TachSensor(Mode mode, sdbusplus::bus::bus& bus, Fan& fan,
	const std::string& id, bool hasTarget, size_t funcDelay,
	const std::string& interface, double factor,
	int64_t offset, size_t method, size_t threshold,
	size_t timeout, const std::optional<size_t>& errorDelay,
	const sdeventplus::Event& event) :
	_bus(bus),
	_fan(fan), _name(FAN_SENSOR_PATH + id), _invName(path(fan.getName()) / id),
	_hasTarget(hasTarget), _funcDelay(funcDelay), _interface(interface),
	_factor(factor), _offset(offset), _method(method), _threshold(threshold),
	_timeout(timeout), _timerMode(TimerMode::func),
	_timer(event, std::bind(&Fan::updateState, &fan, std::ref(*this))),
	_errorDelay(errorDelay)
	{
	// Start from a known state of functional
	setFunctional(true);

	// Load in current Target and Input values when entering monitor mode
	#ifndef MONITOR_USE_JSON
	if (mode != Mode::init)
	{
	#endif
	try
	{
	// Use getProperty directly to allow a missing sensor object
	// to abort construction.
	_tachInput = util::SDBusPlus::getProperty<decltype(_tachInput)>(
	_bus, _name, FAN_SENSOR_VALUE_INTF, FAN_VALUE_PROPERTY);
	}
	catch (std::exception& e)
	{
	log<level::ERR>(
	fmt::format("Failed to retrieve tach sensor {}", _name)
	.c_str());
	// Mark tach sensor as nonfunctional
	setFunctional(false);
	throw InvalidSensorError();
	}

	if (_hasTarget)
	{
	readProperty(_interface, FAN_TARGET_PROPERTY, _name, _bus,
	_tachTarget);
	}

	auto match = getMatchString(FAN_SENSOR_VALUE_INTF);

	tachSignal = std::make_unique<sdbusplus::server::match::match>(
	_bus, match.c_str(),
	[this](auto& msg) { this->handleTachChange(msg); });

	if (_hasTarget)
	{
	match = getMatchString(_interface);

	targetSignal = std::make_unique<sdbusplus::server::match::match>(
	_bus, match.c_str(),
	[this](auto& msg) { this->handleTargetChange(msg); });
	}

	if (_errorDelay)
	{
	_errorTimer = std::make_unique<
	sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic>>(
	event, std::bind(&Fan::sensorErrorTimerExpired, &fan,
	std::ref(*this)));
	}
	#ifndef MONITOR_USE_JSON
	}
	#endif
	}

	std::string TachSensor::getMatchString(const std::string& interface)
	{
	return sdbusplus::bus::match::rules::propertiesChanged(_name, interface);
	}

	uint64_t TachSensor::getTarget() const
	{
	if (!_hasTarget)
	{
	return _fan.findTargetSpeed();
	}
	return _tachTarget;
	}

	std::pair<uint64_t, uint64_t> TachSensor::getRange(const size_t deviation) const
	{
	// Determine min/max range applying the deviation
	uint64_t min = getTarget() * (100 - deviation) / 100;
	uint64_t max = getTarget() * (100 + deviation) / 100;

	// Adjust the min/max range by applying the factor & offset
	min = min * _factor + _offset;
	max = max * _factor + _offset;

	return std::make_pair(min, max);
	}

	void TachSensor::processState()
	{
	_fan.process(*this);
	}

	void TachSensor::resetMethod()
	{
	switch (_method)
	{
	case MethodMode::timebased:
	if (timerRunning())
	{
	stopTimer();
	}
	break;
	case MethodMode::count:
	if (_functional)
	{
	_counter = 0;
	}
	else
	{
	_counter = _threshold;
	}
	break;
	}
	}

	void TachSensor::setFunctional(bool functional)
	{
	_functional = functional;
	updateInventory(_functional);

	if (!_errorTimer)
	{
	return;
	}

	if (!_functional)
	{
	if (_fan.present())
	{
	_errorTimer->restartOnce(std::chrono::seconds(*_errorDelay));
	}
	}
	else if (_errorTimer->isEnabled())
	{
	_errorTimer->setEnabled(false);
	}
	}

	void TachSensor::handleTargetChange(sdbusplus::message::message& msg)
	{
	readPropertyFromMessage(msg, _interface, FAN_TARGET_PROPERTY, _tachTarget);

	// Check all tach sensors on the fan against the target
	_fan.tachChanged();
	}

	void TachSensor::handleTachChange(sdbusplus::message::message& msg)
	{
	readPropertyFromMessage(msg, FAN_SENSOR_VALUE_INTF, FAN_VALUE_PROPERTY,
	_tachInput);

	// Check just this sensor against the target
	_fan.tachChanged(*this);
	}

	void TachSensor::startTimer(TimerMode mode)
	{
	using namespace std::chrono;

	if (!timerRunning() \|\| mode != _timerMode)
	{
	log<level::INFO>(
	fmt::format("Start timer({}) on tach sensor {}. [delay = {}s]",
	mode, _name,
	duration_cast<seconds>(getDelay(mode)).count())
	.c_str());
	_timer.restartOnce(getDelay(mode));
	_timerMode = mode;
	}
	}

	std::chrono::microseconds TachSensor::getDelay(TimerMode mode)
	{
	using namespace std::chrono;

	switch (mode)
	{
	case TimerMode::nonfunc:
	return duration_cast<microseconds>(seconds(_timeout));
	case TimerMode::func:
	return duration_cast<microseconds>(seconds(_funcDelay));
	default:
	// Log an internal error for undefined timer mode
	log<level::ERR>("Undefined timer mode",
	entry("TIMER_MODE=%u", mode));
	elog<InternalFailure>();
	return duration_cast<microseconds>(seconds(0));
	}
	}

	void TachSensor::setCounter(bool count)
	{
	if (count)
	{
	if (_counter < _threshold)
	{
	++_counter;
	}
	}
	else
	{
	if (_counter > 0)
	{
	--_counter;
	}
	}
	}

	void TachSensor::updateInventory(bool functional)
	{
	auto objectMap =
	util::getObjMap<bool>(_invName, util::OPERATIONAL_STATUS_INTF,
	util::FUNCTIONAL_PROPERTY, functional);
	auto response = util::SDBusPlus::lookupAndCallMethod(
	_bus, util::INVENTORY_PATH, util::INVENTORY_INTF, "Notify", objectMap);
	if (response.is_method_error())
	{
	log<level::ERR>("Error in notify update of tach sensor inventory");
	}
	}

	} // namespace monitor
	} // namespace fan
	} // namespace phosphor