/** * 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 "fan.hpp" #include "logging.hpp" #include "sdbusplus.hpp" #include "system.hpp" #include "types.hpp" #include "utility.hpp" #include #include #include namespace phosphor { namespace fan { namespace monitor { using namespace phosphor::logging; using namespace sdbusplus::bus::match; Fan::Fan(Mode mode, sdbusplus::bus::bus& bus, const sdeventplus::Event& event, std::unique_ptr& trust, const FanDefinition& def, System& system) : _bus(bus), _name(std::get(def)), _deviation(std::get(def)), _numSensorFailsForNonFunc(std::get(def)), _trustManager(trust), #ifdef MONITOR_USE_JSON _monitorDelay(std::get(def)), _monitorTimer(event, std::bind(std::mem_fn(&Fan::startMonitor), this)), #endif _system(system), _presenceMatch(bus, rules::propertiesChanged(util::INVENTORY_PATH + _name, util::INV_ITEM_IFACE), std::bind(std::mem_fn(&Fan::presenceChanged), this, std::placeholders::_1)), _fanMissingErrorDelay(std::get(def)) { // Start from a known state of functional (even if // _numSensorFailsForNonFunc is 0) updateInventory(true); // Setup tach sensors for monitoring auto& sensors = std::get(def); for (auto& s : sensors) { try { _sensors.emplace_back(std::make_shared( mode, bus, *this, std::get(s), std::get(s), std::get(def), std::get(s), std::get(s), std::get(s), std::get(def), std::get(s), std::get(def), std::get(def), event)); _trustManager->registerSensor(_sensors.back()); } catch (InvalidSensorError& e) { // Count the number of failed tach sensors, though if // _numSensorFailsForNonFunc is zero that means the fan should not // be set to nonfunctional. if (_numSensorFailsForNonFunc && (++_numFailedSensor >= _numSensorFailsForNonFunc)) { // Mark associated fan as nonfunctional updateInventory(false); } } } #ifndef MONITOR_USE_JSON // Check current tach state when entering monitor mode if (mode != Mode::init) { _monitorReady = true; // The TachSensors will now have already read the input // and target values, so check them. tachChanged(); } #else // If it used the JSON config, then it also will do all the work // out of fan-monitor-init, after _monitorDelay. _monitorTimer.restartOnce(std::chrono::seconds(_monitorDelay)); #endif // Get the initial presence state bool available = true; try { _present = util::SDBusPlus::getProperty( util::INVENTORY_PATH + _name, util::INV_ITEM_IFACE, "Present"); } catch (const util::DBusServiceError& e) { // This could be the initial boot and phosphor-fan-presence hasn't // written to the inventory yet. available = false; } if (_fanMissingErrorDelay) { _fanMissingErrorTimer = std::make_unique< sdeventplus::utility::Timer>( event, std::bind(&System::fanMissingErrorTimerExpired, &system, std::ref(*this))); if (!_present && available) { getLogger().log( fmt::format("On startup, fan {} is missing", _name)); _fanMissingErrorTimer->restartOnce( std::chrono::seconds{*_fanMissingErrorDelay}); } } } void Fan::startMonitor() { _monitorReady = true; tachChanged(); } void Fan::tachChanged() { if (_monitorReady) { for (auto& s : _sensors) { tachChanged(*s); } } } void Fan::tachChanged(TachSensor& sensor) { if (_trustManager->active()) { if (!_trustManager->checkTrust(sensor)) { return; } } process(sensor); } void Fan::process(TachSensor& sensor) { // If this sensor is out of range at this moment, start // its timer, at the end of which the inventory // for the fan may get updated to not functional. // If this sensor is OK, put everything back into a good state. if (outOfRange(sensor)) { if (sensor.functional()) { switch (sensor.getMethod()) { case MethodMode::timebased: // Start nonfunctional timer if not already running sensor.startTimer(TimerMode::nonfunc); break; case MethodMode::count: sensor.setCounter(true); if (sensor.getCounter() >= sensor.getThreshold()) { updateState(sensor); } break; } } } else { switch (sensor.getMethod()) { case MethodMode::timebased: if (sensor.functional()) { if (sensor.timerRunning()) { sensor.stopTimer(); } } else { // Start functional timer if not already running sensor.startTimer(TimerMode::func); } break; case MethodMode::count: sensor.setCounter(false); if (!sensor.functional() && sensor.getCounter() == 0) { updateState(sensor); } break; } } } uint64_t Fan::findTargetSpeed() { uint64_t target = 0; // The sensor doesn't support a target, // so get it from another sensor. auto s = std::find_if(_sensors.begin(), _sensors.end(), [](const auto& s) { return s->hasTarget(); }); if (s != _sensors.end()) { target = (*s)->getTarget(); } return target; } size_t Fan::countNonFunctionalSensors() { return std::count_if(_sensors.begin(), _sensors.end(), [](const auto& s) { return !s->functional(); }); } bool Fan::outOfRange(const TachSensor& sensor) { auto actual = static_cast(sensor.getInput()); auto range = sensor.getRange(_deviation); if ((actual < range.first) || (actual > range.second)) { return true; } return false; } void Fan::updateState(TachSensor& sensor) { auto range = sensor.getRange(_deviation); sensor.setFunctional(!sensor.functional()); getLogger().log( fmt::format("Setting tach sensor {} functional state to {}. " "[target = {}, input = {}, allowed range = ({} - {})]", sensor.name(), sensor.functional(), sensor.getTarget(), sensor.getInput(), range.first, range.second)); // A zero value for _numSensorFailsForNonFunc means we aren't dealing // with fan FRU functional status, only sensor functional status. if (_numSensorFailsForNonFunc) { auto numNonFuncSensors = countNonFunctionalSensors(); // If the fan was nonfunctional and enough sensors are now OK, // the fan can be set to functional if (!_functional && !(numNonFuncSensors >= _numSensorFailsForNonFunc)) { getLogger().log(fmt::format("Setting fan {} to functional, number " "of nonfunctional sensors = {}", _name, numNonFuncSensors)); updateInventory(true); } // If the fan is currently functional, but too many // contained sensors are now nonfunctional, update // the fan to nonfunctional. if (_functional && (numNonFuncSensors >= _numSensorFailsForNonFunc)) { getLogger().log(fmt::format("Setting fan {} to nonfunctional, " "number of nonfunctional sensors = {}", _name, numNonFuncSensors)); updateInventory(false); } } _system.fanStatusChange(*this); } void Fan::updateInventory(bool functional) { auto objectMap = util::getObjMap(_name, 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("Error in Notify call to update inventory"); return; } // This will always track the current state of the inventory. _functional = functional; } void Fan::presenceChanged(sdbusplus::message::message& msg) { std::string interface; std::map> properties; msg.read(interface, properties); auto presentProp = properties.find("Present"); if (presentProp != properties.end()) { _present = std::get(presentProp->second); getLogger().log( fmt::format("Fan {} presence state change to {}", _name, _present)); _system.fanStatusChange(*this); if (_fanMissingErrorDelay) { if (!_present) { _fanMissingErrorTimer->restartOnce( std::chrono::seconds{*_fanMissingErrorDelay}); } else if (_fanMissingErrorTimer->isEnabled()) { _fanMissingErrorTimer->setEnabled(false); } } } } void Fan::sensorErrorTimerExpired(const TachSensor& sensor) { if (_present) { _system.sensorErrorTimerExpired(*this, sensor); } } } // namespace monitor } // namespace fan } // namespace phosphor